FrontISTR  5.9.0
Large-scale structural analysis program with finit element method
hecmw_io_nastran.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 /* JP-0 */
7 
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <stdarg.h>
11 #include <errno.h>
12 #include "hecmw_util.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 #include "hecmw_io_nastran.h"
24 
25 /* def.h */
26 
27 /* JP-1 */
28 
29 #ifndef NULL
30 #define NULL ((void*)0)
31 #endif
32 
33 /* JP-2 */
34 
35 #define FIELD_BUFFER_SIZE 16 + 1 /* JP-3 */
36 #define FIELD_NUMBER 10 /* JP-4 */
37 #define LINE_BUFFER_SIZE (FIELD_BUFFER_SIZE * FIELD_NUMBER) /* JP-5 */
38 
39 #define FIRST_FIELD_COLUMN 8 /* JP-6 */
40 #define LAST_FIELD_COLUMN 8 /* JP-7 */
41 #define SMALL_FIELD_COLUMN 8 /* JP-8 */
42 #define LARGE_FIELD_COLUMN 16 /* JP-9 */
43 #define LARGE_FIELD_LINE_FIELD_NUMBER 6 /* JP-10 */
44 
45 /* JP-11 */
46 
47 #define IFF_FIELD_NUMBER FIELD_NUMBER
48 #define IFF_FIELD_SIZE 16 /* JP-12 */
49 #define IFF_FIELD_BUFFER_SIZE (IFF_FIELD_SIZE + 1) /* JP-13 */
50 #define IFF_SIZE (IFF_FIELD_BUFFER_SIZE * IFF_FIELD_NUMBER) /* JP-14 */
51 
52 #define IFF_LAST_FIELD 9 /* JP-15 */
53 
54 /* JP-16 */
55 
56 typedef struct ST_IFF_NODE {
57  char iff[IFF_SIZE];
58  int line_no; /* JP-17 */
59  struct ST_IFF_NODE* next;
60 } iff_node_t;
61 
62 /* JP-18 */
63 
64 typedef struct ST_IFF_BULK {
65  iff_node_t* iff_node_root; /* JP-19 */
66  iff_node_t* iff_node_last;
67  int file_no; /* JP-20 */
68  struct ST_IFF_BULK* next_bulk;
69 } iff_bulk_t;
70 
71 /* JP-21 */
72 
73 typedef struct ST_IFF_BULK_LIST {
74  iff_bulk_t* bulk_root;
75  int bulk_number;
76 } iff_bulk_list_t;
77 
78 /* JP-22 */
79 
80 typedef enum ENUM_FIELD_FORMAT {
81  fft_none, /* JP-23 */
82  fft_comment, /* JP-24 */
83  fft_free_field_format, /* JP-25 */
84  fft_small_field_format, /* JP-26 */
85  fft_large_field_format /* JP-27 */
86 } field_format_t;
87 
88 /* JP-28 */
89 
90 #ifndef HECMW_FILENAME_LEN
91 #define HECMW_FILENAME_LEN 1023
92 #endif
93 
94 #define FILE_STACK_SIZE 10
95 
96 typedef struct ST_FILE_STACK {
97  FILE* fp;
98  char filename[HECMW_FILENAME_LEN + 1];
99  int lineno;
100 } file_stack_t;
101 
102 static file_stack_t file_stack[FILE_STACK_SIZE];
103 static int file_stack_pos;
104 
105 static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
106 
107 static FILE* c_fp = NULL;
108 static char c_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
109 static int c_lineno = 0;
110 
111 /* JP-29 */
112 
113 /* utils.c */
114 
115 /* JP-30 */
116 static char* str_upr(char* s);
117 
118 /* JP-31 */
119 static void set_error_of_field_convert(const char* file_name, int line_no,
120  int field_no, const char* bulk_name,
121  const char* param_name,
122  const char* param_val, int type);
123 
124 /* JP-32 */
125 static void set_error_of_blank_field(const char* file_name, int line_no,
126  int field_no, const char* bulk_name,
127  const char* param_name);
128 
129 /* JP-33 */
130 static void remove_cr(char* line);
131 
132 /* JP-34 */
133 static void skip_to_begin_bulk(FILE* fp, int* line_no);
134 
135 /* JP-35 */
136 static char* ngrp_name_by_GID(int gid, char* name, size_t size);
137 
138 /* JP-36 */
139 static char* egrp_name_by_PID(int pid, char* name, size_t size);
140 
141 /* JP-37 */
142 static char* egrp_name_by_SID(int sid, char* name, size_t size);
143 
144 /* JP-38 */
145 static char* ngrp_name_by_SID_GID(int sid, int gid, char* name, size_t size);
146 
147 /* JP-39 */
148 static char* ngrp_name_by_SID(int sid, int sub_id, char* name, size_t size);
149 
150 /* JP-40 */
151 static char* matrial_name_by_MID(int mid, char* name, size_t size);
152 
153 /* JP-41 */
154 static char* egrp_CTRIAX6_name_by_MID(int mid, char* name, size_t size);
155 
156 /* JP-42 */
157 static int is_CTRIAX6_egrp_name(char* name, int* mid);
158 
159 /* ------------------------------------------------------------------------------------------------
160  */
161 /* field_format_judge.c */
162 
163 /* JP-43 */
164 static field_format_t field_format_judge(char* line);
165 
166 /* ------------------------------------------------------------------------------------------------
167  */
168 /* iff.c */
169 
170 static void iff_init(char* iff); /* JP-44 */
171 static void iff_clear(char* iff); /* JP-45 */
172 static int iff_field_empty(char* field); /* JP-46 */
173 static int iff_is_blank_field(char* iff, int no); /* JP-47 */
174 static char* iff_get_field(char* iff, int no); /* JP-48 */
175 static void iff_set_field(char* iff, int no, char* field); /* JP-49 */
176 static void iff_regulize(char* iff); /* JP-50 */
177 static void iff_copy(char* dest, char* src); /* JP-51 */
178 static char* iff_get_continuous_line_pointer(char* iff); /* JP-52 */
179 static char* iff_get_pointing_line_pointer(char* iff); /* JP-53 */
180 
181 static int iff_is_parent(char* iff); /* JP-54 */
182 static int iff_is_last(char* iff); /* JP-55 */
183 static int iff_is_continuous_line(char* iff); /* JP-56 */
184 static int iff_is_pointing_line(char* iff); /* JP-57 */
185 
186 static int iff_add_auto_pointer(char* iff1, char* iff2,
187  int* counter); /* JP-58 */
188 
189 /* JP-59 */
190 /* JP-60 */
191 
192 static int iff_field_to_int(char* field, int default_val, int* val); /* JP-61 */
193 static int iff_field_to_uint(char* field, unsigned int default_val,
194  unsigned int* val); /* JP-62 */
195 static int iff_field_to_double(char* field, double default_val,
196  double* val); /* JP-63 */
197 static int iff_field_to_param(char* field, char type, void* param,
198  void** next_param_pos); /* JP-64 */
199 
200 /* JP-65 */
201 
202 static void iff_dump(char* iff);
203 static void iff_dump_csv(char* iff);
204 
205 /* ------------------------------------------------------------------------------------------------
206  */
207 /* iff_conv.c */
208 
209 static void free_to_iff_format(char* line, char* iff); /* JP-66 */
210 static void small_to_iff_format(char* line, char* iff); /* JP-67 */
211 static void large_to_iff_format(char* line1, char* line2,
212  char* iff); /* JP-68 */
213 
214 static char* get_fixed_token(char* src, char* token,
215  int field_size); /* JP-69 */
216 
217 /* ------------------------------------------------------------------------------------------------
218  */
219 /* iff_node.c */
220 
221 static iff_node_t* iff_node_create(void); /* JP-70 */
222 static void iff_node_free(iff_node_t* node); /* JP-71 */
223 static void iff_node_init(iff_node_t* node); /* JP-72 */
224 static void iff_node_set(iff_node_t* node, char* iff, int line_no); /* JP-73 */
225 
226 /* ------------------------------------------------------------------------------------------------
227  */
228 /* read_iff.c */
229 
230 /* JP-74 */
231 static int read_iff(FILE* fp, char* iff, int* line_no);
232 
233 /* ------------------------------------------------------------------------------------------------
234  */
235 /* bulk.c */
236 
237 static void iff_bulk_init(iff_bulk_t* bulk); /* JP-75 */
238 
239 /* JP-76 */
240 
241 static iff_bulk_t* iff_bulk_create(void); /* JP-77 */
242 static void iff_bulk_free(iff_bulk_t* bulk); /* JP-78 */
243 static void iff_bulk_regist(iff_bulk_t* bulk, char* iff,
244  int line_no); /* JP-79 */
245 static void iff_bulk_move_append(iff_bulk_t* dest, iff_bulk_t* src); /* JP-80 */
246 static int iff_bulk_is_completed(iff_bulk_t* bulk); /* JP-81 */
247 static int iff_bulk_parse(iff_bulk_t* bulk); /* JP-82 */
248 
249 /* JP-83 */
250 
251 static char* iff_bulk_get_name(iff_bulk_t* bulk); /* JP-84 */
252 static char* iff_bulk_get_field(iff_bulk_t* bulk, int field_no); /* JP-85 */
253 static char* iif_bulk_get_param(iff_bulk_t* bulk, int param_no); /* JP-86 */
254 static char* iff_bulk_get_param_data(iff_bulk_t* bulk, int param_no,
255  int* line_no, int* field_no); /* JP-87 */
256 
257 /* JP-88 */
258 static int iff_bulk_get_param_list(iff_bulk_t* bulk, const char* format,
259  int* result, ...);
260 
261 /* JP-89 */
262 static int iff_bulk_get_param_list_pattern(iff_bulk_t* bulk, const char* format,
263  int start_param_no, int* size, ...);
264 
265 static int iff_bulk_get_line_number(iff_bulk_t* bulk); /* JP-90 */
266 static int iff_bulk_get_line_no(iff_bulk_t* bulk, int iff_pos); /* JP-91 */
267 
268 /* JP-92 */
269 
270 static iff_node_t* iff_bulk_search_pointing_line(
271  iff_bulk_t* bulk, char* line_pointer); /* JP-93 */
272 static iff_node_t* iff_bulk_search_continuous_line(
273  iff_bulk_t* bulk, char* line_pointer); /* JP-94 */
274 
275 /* JP-95 */
276 
277 static void iff_bulk_dump(iff_bulk_t* bulk); /* JP-96 */
278 
279 /* ------------------------------------------------------------------------------------------------
280  */
281 /* bulk_parse_head.c */
282 
283 static char* iff_bulk_get_name(iff_bulk_t* bulk); /* JP-97 */
284 static char* iff_bulk_get_param(iff_bulk_t* bulk, int field_no); /* JP-98 */
285 static int iff_bulk_type(const char* bulkname); /* JP-99 */
286 
287 /* JP-100 */
288 static int iff_bulk_parse(iff_bulk_t* bulk);
289 
290 /* ------------------------------------------------------------------------------------------------
291  */
292 /* bulk_parse.c */
293 
294 /* JP-101 */
295 static struct hecmw_io_material* create_mat_struct(const char* name, int item_n,
296  int sub_n[], double data[]);
297 
298 /* JP-102 */
299 static int surface_elem_store(int bulk_type, unsigned int EID, unsigned int PID,
300  unsigned int G[], int G_number, double THETA_MCID,
301  double ZOFFS, double T[], int T_number);
302 
303 /* JP-103 */
304 static int iff_bulk_parse_solid_elem(iff_bulk_t* bulk, int first_etype,
305  int second_etype, int conv_table[],
306  int g_number, int g_ness_number);
307 
308 /* ------------------------------------------------------------------------------------------------
309  */
310 /* bulk_list.c */
311 
312 static void iff_bulk_list_init(iff_bulk_list_t* list); /* JP-104 */
313 static void iff_bulk_list_clear(iff_bulk_list_t* list); /* JP-105 */
314 
315 static int iff_bulk_list_is_empty(iff_bulk_list_t* list); /* JP-106 */
316 
317 /* JP-107 */
318 static void iff_bulk_list_regist(iff_bulk_list_t* bulk_list,
319  iff_bulk_t* bulk); /* JP-108 */
320 static iff_bulk_t* iff_bulk_list_search_pointing_bulk(
321  iff_bulk_list_t* bulk_list, char* line_pointer); /* JP-109 */
322 static iff_bulk_t* iff_bulk_list_search_continuous_bulk(
323  iff_bulk_list_t* bulk_list, char* line_pointer); /* JP-110 */
324 static int iff_bulk_list_remove(iff_bulk_list_t* bulk_list,
325  iff_bulk_t* bulk); /* JP-111 */
326 
327 /* JP-112 */
328 static int iff_bulk_list_after_operation(iff_bulk_list_t* list);
329 
330 /* JP-113 */
331 static void iff_bulk_list_dump(iff_bulk_list_t* bulk_list); /* JP-114 */
332 
333 /* ------------------------------------------------------------------------------------------------
334  */
335 /* iff_operation.c */
336 
337 /* JP-115 */
338 static int iff_operation(iff_bulk_list_t* bulk_list, char* iff, int line_no);
339 
340 /* ------------------------------------------------------------------------------------------------
341  */
342 /* f_open_close.c */
343 
344 /* JP-116 */
345 static void file_stack_init(void); /* JP-117 */
346 static int file_stack_push(char* fname, FILE* fp, int lineno); /* JP-118 */
347 static int file_stack_pop(char* fname, size_t fname_len, FILE** fp, int* lineno); /* JP-119 */
348 static int file_stack_clear(void); /* JP-120 */
349 static int file_stack_check(const char* fname); /* JP-121 */
350 
351 /* JP-122 */
352 static void nastran_file_init(void); /* JP-123 */
353 static int nastran_file_open(const char* filename); /* JP-124 */
354 static int nastran_file_close(void); /* JP-125 */
355 
356 /* ------------------------------------------------------------------------------------------------
357  */
358 /* read_nastran.c */
359 
360 /* JP-126 */
361 static int read_nastran(const char* filename);
362 
363 /* list_creator.c */
364 
365 /* JP-127 */
366 
367 /* JP-128 */
368 
369 #define CREATE_LIST_CODE(type) \
370  \
371  static int is_eq_##type(type a, type b); \
372  static void copy_##type(type* dest, type src); \
373  static void delete_##type(type a); \
374  \
375  typedef struct struct_list_node_##type { \
376  type data; \
377  struct struct_list_node_##type* next; \
378  } t_list_node_##type; \
379  \
380  typedef struct struct_list_##type { \
381  t_list_node_##type* root; \
382  t_list_node_##type *current, *next; \
383  } t_list_##type; \
384  \
385  static void list_init_##type(t_list_##type* list) { list->root = NULL; } \
386  \
387  static void list_clear_##type(t_list_##type* list) { \
388  t_list_node_##type* t; \
389  t_list_node_##type* node = list->root; \
390  while (node) { \
391  t = node->next; \
392  delete_##type(node->data); \
393  node = t; \
394  } \
395  list->root = NULL; \
396  } \
397  \
398  static t_list_node_##type* list_add_##type(t_list_##type* list, type d) { \
399  t_list_node_##type* node; \
400  node = HECMW_malloc(sizeof(t_list_node_##type)); \
401  copy_##type(&node->data, d); \
402  node->next = NULL; \
403  if (list->root) { \
404  node->next = list->root; \
405  list->root = node; \
406  } else { \
407  list->root = node; \
408  } \
409  return node; \
410  } \
411  \
412  static t_list_node_##type* list_search_##type(t_list_##type* list, \
413  type data) { \
414  static t_list_##type* list_s; \
415  if (list != NULL) { \
416  list->current = list->root; \
417  list_s = list; \
418  } \
419  while (list_s->current) { \
420  if (is_eq_##type(list_s->current->data, data)) return list_s->current; \
421  list_s->current = list_s->current->next; \
422  } \
423  return NULL; \
424  } \
425  \
426  static void list_scan_start_##type(t_list_##type* list) { \
427  list->next = list->current = list->root; \
428  } \
429  \
430  static int list_scan_next_##type(t_list_##type* list) { \
431  t_list_node_##type* t; \
432  if (list->next == NULL) return 0; \
433  \
434  t = list->next; \
435  list->next = list->next->next; \
436  list->current = t; \
437  \
438  return 1; \
439  } \
440  \
441  static void list_get_current_data_##type(t_list_##type* list, type* data) { \
442  *data = list->current->data; \
443  } \
444  \
445  static t_list_node_##type* list_get_current_node_##type( \
446  t_list_##type* list) { \
447  return list->current; \
448  } \
449  \
450  static int list_operation_##type(t_list_##type* list, int (*foo)(type)) { \
451  list_scan_start_##type((list)); \
452  while (list_scan_next_##type((list))) { \
453  int err = (*(foo))(list->current->data); \
454  if (err) return err; \
455  } \
456  return 0; \
457  }
458 
459 /* utils.c */
460 
461 /* JP-129 */
462 
463 /* JP-130 */
464 
465 static char* str_upr(char* s) {
466  char* p = s;
467  while (*p) {
468  if ('a' <= *p && *p < 'A') *p += ('A' - 'a');
469  p++;
470  }
471  return s;
472 }
473 
474 /* JP-131 */
475 
476 /* JP-132 */
477 
478 static void set_error_of_field_convert(const char* file_name, int line_no,
479  int field_no, const char* bulk_name,
480  const char* param_name,
481  const char* param_val, int type) {
482  char line[256];
483  char msg[256];
484  char type_s[10];
485  char val_str[256];
486 
487  switch (type) {
488  case 's':
489  case 'S':
490  snprintf(type_s, sizeof(type_s), "string");
491  break;
492  case 'i':
493  case 'I':
494  case 'u':
495  case 'U':
496  snprintf(type_s, sizeof(type_s), "integer");
497  break;
498  case 'd':
499  case 'D':
500  snprintf(type_s, sizeof(type_s), "real");
501  break;
502  case '_':
503  snprintf(type_s, sizeof(type_s), "blank");
504  break;
505  default:
506  HECMW_assert(0);
507  }
508 
509  if (param_val) {
510  int i;
511  char s[20];
512  size_t len = snprintf(val_str, sizeof(val_str), "H");
513  for (i = 0; i < IFF_FIELD_SIZE && param_val[i]; i++) {
514  len += snprintf(val_str + len, sizeof(val_str) - len, "%x", param_val[i]);
515  }
516  } else
517  snprintf(val_str, sizeof(val_str), "NULL");
518 
519  snprintf(line, sizeof(line), "%s:%d:", file_name, line_no);
520  snprintf(msg, sizeof(msg),
521  "Cannot convert '%s'(%s) to '%s' value ('%s' (field.%d) in '%s')",
522  param_val, val_str, type_s, param_name, field_no, bulk_name);
523 
524  HECMW_set_error(HECMW_IO_HEC_E0001, "%s%s", line, msg); /* JP-133 */
525 }
526 
527 /* JP-134 */
528 
529 static void set_error_of_blank_field(const char* file_name, int line_no,
530  int field_no, const char* bulk_name,
531  const char* param_name) {
532  char line[256];
533  char msg[256];
534 
535  snprintf(line, sizeof(line), "%s:%d:", file_name, line_no);
536  snprintf(msg, sizeof(msg), "Cannot be blank field ('%s' (no.%d) in '%s')", param_name,
537  field_no, bulk_name);
538 
539  HECMW_set_error(HECMW_IO_HEC_E0001, "%s%s", line, msg); /* JP-135 */
540 }
541 
542 /* ------------------------------------------------------------------------------------------------
543  */
544 /* JP-136 */
545 
546 #define REMOVE_CR_MAX_LINE 256
547 
548 static void remove_cr(char* line) {
549  int i = 0;
550  char* p = line;
551  while (*p && i < REMOVE_CR_MAX_LINE) {
552  if (*p == '\n' || *p == 0xd) {
553  *p = 0;
554  return;
555  }
556  i++;
557  p++;
558  }
559 }
560 
561 /* ------------------------------------------------------------------------------------------------
562  */
563 /* ------------------------------------------------------------------------------------------------
564  */
565 /* JP-137 */
566 
567 static void skip_to_begin_bulk(FILE* fp, int* line_no) {
568  char line[IFF_SIZE];
569 
570  while (fgets(line, IFF_SIZE, fp)) {
571  (*line_no)++;
572  if (strncmp(line, "BEGIN BULK", sizeof("BEGIN BULK") - 1) == 0) return;
573  }
574 }
575 
576 /* JP-138 */
577 
578 /* JP-139 */
579 
580 static char* ngrp_name_by_GID(int gid, char* name, size_t size) {
581  snprintf(name, size, "G%d", gid);
582  return name;
583 }
584 
585 /* ------------------------------------------------------------------------------------------------
586  */
587 /* JP-140 */
588 
589 static char* egrp_name_by_PID(int pid, char* name, size_t size) {
590  snprintf(name, size, "P%d", pid);
591  return name;
592 }
593 
594 /* ------------------------------------------------------------------------------------------------
595  */
596 /* JP-141 */
597 
598 static char* create_SID_grp_name(char* name, size_t size) {
599  static int SID_counter = 1;
600  snprintf(name, size, "SID%d", SID_counter);
601  SID_counter++;
602  return name;
603 }
604 
605 /* ------------------------------------------------------------------------------------------------
606  */
607 /* JP-142 */
608 
609 static char* egrp_name_by_SID(int sid, char* name, size_t size) {
610  /* snprintf( name, size, "S%d", sid); */
611  create_SID_grp_name(name, size);
612  return name;
613 }
614 
615 /* ------------------------------------------------------------------------------------------------
616  */
617 /* JP-143 */
618 
619 static char* ngrp_name_by_SID_GID(int sid, int gid, char* name, size_t size) {
620  /* snprintf( name, size, "S%dG%d", sid, gid); */
621  create_SID_grp_name(name, size);
622  return name;
623 }
624 
625 /* ------------------------------------------------------------------------------------------------
626  */
627 /* JP-144 */
628 
629 static char* ngrp_name_by_SID(int sid, int sub_id, char* name, size_t size) {
630  /* snprintf( name, size, "SID%d-%d", sid, sub_id); */
631  create_SID_grp_name(name, size);
632  return name;
633 }
634 
635 /* ------------------------------------------------------------------------------------------------
636  */
637 /* JP-145 */
638 
639 static char* matrial_name_by_MID(int mid, char* name, size_t size) {
640  snprintf(name, size, "M%d", mid);
641  return name;
642 }
643 
644 /* ------------------------------------------------------------------------------------------------
645  */
646 /* JP-146 */
647 
648 #define CTRIAX6_EGRP_NAME_HEADER "CTRIAX6-"
649 
650 static char* egrp_CTRIAX6_name_by_MID(int mid, char* name, size_t size) {
651  snprintf(name, size, "%s%d", CTRIAX6_EGRP_NAME_HEADER, mid);
652  return name;
653 }
654 
655 /* ------------------------------------------------------------------------------------------------
656  */
657 /* JP-147 */
658 
659 static int is_CTRIAX6_egrp_name(char* name, int* mid) {
660  char* p = CTRIAX6_EGRP_NAME_HEADER;
661  char* s = name;
662  while (*s && *p) {
663  if (*s != *p) return 0;
664  s++;
665  p++;
666  }
667  *mid = atoi(s);
668  return 1;
669 }
670 
671 /* field_format_judge.c */
672 
673 /* JP-148 */
674 
675 /* JP-149 */
676 
677 /* JP-150 */
678 
679 /* ------------------------------------------------------------------------------------------------
680  */
681 /* JP-151 */
682 /* JP-152 */
683 
684 static field_format_t field_format_judge(char* line) {
685  int i;
686  int fg;
687  int n;
688  char* p;
689 
690  p = line;
691 
692  if (*p == '$' || *p == 0) return fft_comment;
693 
694  fg = 1;
695  while (*p != 0) {
696  if (*p == ',') return fft_free_field_format;
697  if (*p != ' ') fg = 0;
698  p++;
699  }
700 
701  if (fg) return fft_comment;
702 
703  n = strlen(line);
704  p = line;
705 
706  if (n < FIRST_FIELD_COLUMN)
707  p += n;
708  else
709  p += FIRST_FIELD_COLUMN;
710 
711  while (p != line) {
712  p--;
713  if (*p != ' ') {
714  if (*p == '*')
715  return fft_large_field_format;
716  else
717  return fft_small_field_format;
718  }
719  }
720 
721  return fft_small_field_format;
722 }
723 
724 /* iff.c */
725 
726 /* JP-153 */
727 
728 /* JP-154 */
729 
730 static void iff_init(char* iff) { iff_clear(iff); }
731 
732 /* ------------------------------------------------------------------------------------------------
733  */
734 /* JP-155 */
735 
736 static void iff_clear(char* iff) { memset(iff, 0, IFF_SIZE); }
737 
738 /* ------------------------------------------------------------------------------------------------
739  */
740 /* JP-156 */
741 
742 static int iff_field_empty(char* field) { return (field[0] == 0); }
743 
744 /* ------------------------------------------------------------------------------------------------
745  */
746 /* JP-157 */
747 
748 static int iff_is_blank_field(char* iff, int no) {
749  char* field = iff_get_field(iff, no);
750  return field[0] == 0;
751 }
752 
753 /* ------------------------------------------------------------------------------------------------
754  */
755 /* JP-158 */
756 
757 static char* iff_get_field(char* iff, int no) {
758  char* p = iff;
759 
760  if (no < 0 || no >= IFF_FIELD_NUMBER) return NULL;
761 
762  p += IFF_FIELD_BUFFER_SIZE * no;
763  return p;
764 }
765 
766 /* ------------------------------------------------------------------------------------------------
767  */
768 /* JP-159 */
769 /* JP-160 */
770 
771 static void iff_set_field(char* iff, int no, char* field) {
772  int i, fg;
773  char *start_p, *p, *s;
774 
775  HECMW_assert(no < FIELD_NUMBER);
776 
777  s = field;
778 
779  start_p = iff;
780  start_p += IFF_FIELD_BUFFER_SIZE * no;
781 
782  /* JP-161 */
783 
784  fg = 0;
785  p = start_p;
786  for (i = 0; *s && i < IFF_FIELD_SIZE; i++, s++) {
787  if (*s != ' ') fg = 1;
788 
789  if (fg) {
790  *p = *s;
791  p++;
792  }
793  }
794  *p = 0;
795 
796  /* JP-162 */
797 
798  if (p == start_p) return;
799 
800  do {
801  p--;
802  if (*p == ' ')
803  *p = 0;
804  else
805  break;
806  } while (p != start_p);
807 }
808 
809 /* ------------------------------------------------------------------------------------------------
810  */
811 /* JP-163 */
812 
813 static void iff_regulize(char* iff) {
814  char* last_field;
815 
816  /* JP-164 */
817 
818  int i;
819  char* p = iff;
820  p += IFF_FIELD_SIZE;
821 
822  do {
823  p--;
824  if (*p == '*') {
825  *p = 0;
826  break;
827  }
828  } while (p != iff);
829 
830  /* JP-165 */
831 
832  if (p == iff) return;
833 
834  do {
835  p--;
836  if (*p == ' ')
837  *p = 0;
838  else
839  break;
840  } while (p != iff);
841 
842  /* JP-166 */
843 
844  /* JP-167 */
845  /* JP-168 */
846 
847  if (iff[0] == '*') {
848  if (iff[1] == 0)
849  iff[0] = 0;
850  else
851  iff[0] = '+';
852  }
853 
854  last_field = iff_get_field(iff, IFF_LAST_FIELD);
855  if (last_field[0] == '*') {
856  if (last_field[1] == 0)
857  last_field[0] = 0;
858  else
859  last_field[0] = '+';
860  }
861 }
862 
863 /* ------------------------------------------------------------------------------------------------
864  */
865 /* JP-169 */
866 
867 static void iff_copy(char* dest, char* src) { memcpy(dest, src, IFF_SIZE); }
868 
869 /* JP-170 */
870 
871 /* ------------------------------------------------------------------------------------------------
872  */
873 /* JP-171 */
874 
875 static int iff_is_continuous_line(char* iff) {
876  char* f = iff_get_field(iff, 0);
877 
878  return (f[0] == '+');
879 }
880 
881 /* ------------------------------------------------------------------------------------------------
882  */
883 /* JP-172 */
884 
885 static int iff_is_pointing_line(char* iff) {
886  char* f = iff_get_field(iff, IFF_LAST_FIELD);
887  return !iff_field_empty(f);
888 }
889 
890 /* ------------------------------------------------------------------------------------------------
891  */
892 /* JP-173 */
893 
894 static char* iff_get_continuous_line_pointer(char* iff) {
895  char* f = iff_get_field(iff, 0);
896 
897  if (iff_field_empty(f)) return NULL;
898 
899  if (f[0] == '+') {
900  if (f[1] == '+') /* JP-174 */
901  f++;
902  return f;
903  } else
904  return NULL;
905 }
906 
907 /* ------------------------------------------------------------------------------------------------
908  */
909 /* JP-175 */
910 /* JP-176 */
911 
912 static char* iff_get_pointing_line_pointer(char* iff) {
913  char* f = iff_get_field(iff, IFF_LAST_FIELD);
914  if (iff_field_empty(f))
915  return NULL;
916  else {
917  return f;
918  }
919 }
920 
921 /* ------------------------------------------------------------------------------------------------
922  */
923 /* JP-177 */
924 
925 static int iff_is_parent(char* iff) {
926  char* field = iff_get_field(iff, 0);
927  return (field[0] != '+');
928 }
929 
930 /* ------------------------------------------------------------------------------------------------
931  */
932 /* JP-178 */
933 
934 static int iff_is_last(char* iff) {
935  return (iff_get_pointing_line_pointer(iff) == NULL);
936 }
937 
938 /* ------------------------------------------------------------------------------------------------
939  */
940 /* JP-179 */
941 /* JP-180 */
942 
943 static int iff_add_auto_pointer(char* iff1, char* iff2, int* counter) {
944  if (iff_is_blank_field(iff2, 0)) {
945  if (iff_is_blank_field(iff1, IFF_LAST_FIELD)) {
946  char pointer[IFF_FIELD_SIZE];
947  snprintf(pointer, sizeof(pointer), "+%d", *counter);
948  (*counter)++;
949  iff_set_field(iff1, IFF_LAST_FIELD, pointer);
950  iff_set_field(iff2, 0, pointer);
951  } else
952  return -1;
953  }
954  return 0;
955 }
956 
957 /* ------------------------------------------------------------------------------------------------
958  */
959 /* JP-181 */
960 
961 static int iff_field_to_uint(char* field, unsigned int default_val,
962  unsigned int* val) {
963  char* endptr;
964 
965  if (field == NULL || (field && *field == 0)) {
966  *val = default_val;
967  return 2;
968  }
969 
970  *val = strtoul(field, &endptr, 10);
971 
972  if (*endptr != 0) {
973  /* JP-182 */
974  return 0;
975  }
976 
977  return 1;
978 }
979 
980 /* ------------------------------------------------------------------------------------------------
981  */
982 /* JP-183 */
983 
984 static int iff_field_to_int(char* field, int default_val, int* val) {
985  char* endptr;
986 
987  if (field == NULL || (field && *field == 0)) {
988  *val = default_val;
989  return 2;
990  }
991 
992  *val = strtol(field, &endptr, 10);
993 
994  if (*endptr != 0) {
995  /* JP-184 */
996  return 0;
997  }
998 
999  return 1;
1000 }
1001 
1002 /* ------------------------------------------------------------------------------------------------
1003  */
1004 /* JP-185 */
1005 
1006 static int iff_field_to_double(char* field, double default_val, double* val) {
1007  char* endptr;
1008  char buf[IFF_FIELD_SIZE];
1009  char *p, *bp;
1010 
1011  if (field == NULL || (field && *field == 0)) {
1012  *val = default_val;
1013  return 2;
1014  }
1015 
1016  *val = strtod(field, &endptr);
1017 
1018  if (*endptr != 0) {
1019  /* JP-186 */
1020 
1021  p = field;
1022  bp = buf;
1023  while (*p) {
1024  if (p == endptr) {
1025  if (*p == '+' || *p == '-') {
1026  *bp = 'E';
1027  bp++;
1028  } else
1029  return 0;
1030  }
1031  *bp = *p;
1032  p++;
1033  bp++;
1034  }
1035  *bp = 0;
1036  *val = strtod(buf, &endptr);
1037 
1038  if (*endptr != 0) {
1039  /* JP-187 */
1040  return 0;
1041  }
1042  }
1043 
1044  return 1;
1045 }
1046 
1047 /* ------------------------------------------------------------------------------------------------
1048  */
1049 /* JP-188 */
1050 
1051 static int iff_field_to_param(char* field, char type, void* param,
1052  void** next_param_pos) {
1053  int R;
1054  int* p_int;
1055  double* p_double;
1056 
1057  type = toupper(type);
1058 
1059  switch (type) {
1060  case 'I':
1061  R = iff_field_to_int(field, *((int*)param), (int*)param);
1062  p_int = (int*)param;
1063  p_int++;
1064  param = p_int;
1065  break;
1066  case 'U':
1067  R = iff_field_to_uint(field, *((unsigned int*)param),
1068  (unsigned int*)param);
1069  p_int = (int*)param;
1070  p_int++;
1071  param = p_int;
1072  break;
1073  case 'D':
1074  R = iff_field_to_double(field, *((double*)param), (double*)param);
1075  p_double = (double*)param;
1076  p_double++;
1077  param = p_double;
1078  break;
1079  case 'S':
1080  if (field == NULL || field[0] == 0)
1081  R = 2;
1082  else {
1083  size_t param_len = IFF_FIELD_BUFFER_SIZE;
1084  snprintf((char*)param, param_len, "%s", field);
1085  R = 1;
1086  }
1087  break;
1088  case '_':
1089  /* JP-189 */
1090  R = 1; /* JP-190 */
1091  break;
1092  default:
1093  HECMW_assert(0);
1094  }
1095 
1096  if (next_param_pos) {
1097  *next_param_pos = param;
1098  }
1099 
1100  return R;
1101 }
1102 
1103 /* ------------------------------------------------------------------------------------------------
1104  */
1105 /* JP-191 */
1106 
1107 static void iff_dump(char* iff) {
1108  int i, j;
1109  char* p;
1110 
1111  putc('|', stdout);
1112 
1113  p = iff;
1114  for (i = 0; i < FIELD_NUMBER; i++) {
1115  for (j = 0; j < IFF_FIELD_SIZE; j++) {
1116  if (*p == 0)
1117  putc('_', stdout);
1118  else
1119  putc(*p, stdout);
1120  p++;
1121  }
1122  putc('|', stdout);
1123  p++;
1124  }
1125  putc('\n', stdout);
1126 }
1127 
1128 /* ------------------------------------------------------------------------------------------------
1129  */
1130 /* JP-192 */
1131 
1132 static void iff_dump_csv(char* iff) {
1133  int i;
1134  char* f;
1135  for (i = 0; i < FIELD_NUMBER; i++) {
1136  f = iff_get_field(iff, i);
1137  printf("%s,", f);
1138  }
1139  printf("\n");
1140 }
1141 
1142 /* iff_conv.c */
1143 
1144 /* JP-193 */
1145 
1146 /* JP-194 */
1147 
1148 /* JP-195 */
1149 
1150 static void free_to_iff_format(char* line, char* iff) {
1151  /* JP-196 */
1152 
1153  char token[IFF_FIELD_BUFFER_SIZE];
1154  char *line_p, *token_p;
1155  int i;
1156 
1157  iff_clear(iff);
1158 
1159  i = 0;
1160  token_p = token;
1161  line_p = line;
1162 
1163  while (*line_p) {
1164  if (*line_p == ',') {
1165  *token_p = 0;
1166  if (i >= FIELD_NUMBER) {
1167  printf("?Õ¥???????¿??????);
1168  break;
1169  }
1170  iff_set_field(iff, i, token);
1171  token_p = token;
1172  i++;
1173  } else {
1174  *token_p = *line_p;
1175  token_p++;
1176  }
1177  line_p++;
1178  }
1179 
1180  if (i > 0 && i < FIELD_NUMBER) {
1181  *token_p = 0;
1182  iff_set_field(iff, i, token);
1183  }
1184 
1185  iff_regulize(iff);
1186 }
1187 
1188 /* ------------------------------------------------------------------------------------------------
1189  */
1190 /* JP-197 */
1191 
1192 static void small_to_iff_format(char* line, char* iff) {
1193  int i, j;
1194  char token[SMALL_FIELD_COLUMN + 1];
1195 
1196  iff_clear(iff);
1197 
1198  i = 0;
1199 
1200  if (get_fixed_token(line, token, FIRST_FIELD_COLUMN)) {
1201  iff_set_field(iff, i, token);
1202  } else {
1203  /* JP-198 */
1204  printf("?Õ¥???????¿??????);
1205  }
1206 
1207  i++;
1208 
1209  for (; i < FIELD_NUMBER; i++) {
1210  if (get_fixed_token(NULL, token, SMALL_FIELD_COLUMN))
1211  iff_set_field(iff, i, token);
1212  else
1213  break;
1214  }
1215 
1216  iff_regulize(iff);
1217 }
1218 
1219 /* ------------------------------------------------------------------------------------------------
1220  */
1221 /* JP-199 */
1222 
1223 static void large_to_iff_format(char* line1, char* line2, char* iff) {
1224  char token[LARGE_FIELD_COLUMN + 1];
1225 
1226  int i = 0;
1227  int j;
1228  char buff[LARGE_FIELD_COLUMN + 1];
1229 
1230  iff_clear(iff);
1231 
1232  /* line1 -------------- */
1233 
1234  /* JP-200 */
1235 
1236  if (get_fixed_token(line1, token, FIRST_FIELD_COLUMN)) {
1237  iff_set_field(iff, i, token);
1238  } else {
1239  /* JP-201 */
1240  }
1241 
1242  i++;
1243 
1244  for (; i < LARGE_FIELD_LINE_FIELD_NUMBER - 1; i++) {
1245  if (get_fixed_token(NULL, token, LARGE_FIELD_COLUMN))
1246  iff_set_field(iff, i, token);
1247  else
1248  break;
1249  }
1250 
1251  /* JP-202 */
1252 
1253  /* line2 -------------- */
1254 
1255  /* JP-203 */
1256  get_fixed_token(line2, token, FIRST_FIELD_COLUMN);
1257 
1258  i = LARGE_FIELD_LINE_FIELD_NUMBER - 1;
1259 
1260  for (; i < FIELD_NUMBER; i++, j++) {
1261  if (get_fixed_token(NULL, token, LARGE_FIELD_COLUMN))
1262  iff_set_field(iff, i, token);
1263  else
1264  break;
1265  }
1266 
1267  /* JP-204 */
1268 
1269  if (i == FIELD_NUMBER - 1) {
1270  if (get_fixed_token(NULL, token, LAST_FIELD_COLUMN))
1271  iff_set_field(iff, i, token);
1272  }
1273 
1274  iff_regulize(iff); /* JP-205 */
1275 }
1276 
1277 /* ------------------------------------------------------------------------------------------------
1278  */
1279 /* JP-206 */
1280 
1281 static char* get_fixed_token(char* src, char* token, int field_size) {
1282  int j;
1283  char* token_p;
1284  static char* src_p = NULL;
1285 
1286  if (src) src_p = src;
1287 
1288  if (src_p == NULL || *src_p == 0 || *src_p == '\n') return NULL;
1289 
1290  token_p = token;
1291 
1292  for (j = 0; j < field_size && *src_p != 0; j++, src_p++, token_p++) {
1293  *token_p = *src_p;
1294  }
1295  *token_p = 0;
1296 
1297  return token;
1298 }
1299 
1300 /* iff_node.c */
1301 
1302 /* JP-207 */
1303 
1304 /* JP-208 */
1305 
1306 static iff_node_t* iff_node_create(void) {
1307  iff_node_t* node = HECMW_malloc(sizeof(iff_node_t));
1308  iff_node_init(node);
1309  return node;
1310 }
1311 
1312 /* ------------------------------------------------------------------------------------------------
1313  */
1314 /* JP-209 */
1315 
1316 static void iff_node_free(iff_node_t* node) { HECMW_free(node); }
1317 
1318 /* ------------------------------------------------------------------------------------------------
1319  */
1320 /* JP-210 */
1321 
1322 static void iff_node_init(iff_node_t* node) {
1323  iff_init(node->iff);
1324  node->line_no = -1;
1325  node->next = NULL;
1326 }
1327 
1328 /* ------------------------------------------------------------------------------------------------
1329  */
1330 /* JP-211 */
1331 
1332 static void iff_node_set(iff_node_t* node, char* iff, int line_no) {
1333  iff_copy(node->iff, iff);
1334  node->line_no = line_no;
1335 }
1336 
1337 /* read_iff.c */
1338 
1339 /* JP-212 */
1340 /* JP-213 */
1341 
1342 #define read_iff_error -1
1343 #define read_iff_comment 0
1344 #define read_iff_success 1
1345 #define read_iff_eof 2
1346 
1347 static int read_iff(FILE* fp, char* iff, int* line_no) {
1348  char line1[IFF_SIZE];
1349  char line2[IFF_SIZE];
1350 
1351  char* fg = fgets(line1, IFF_SIZE - 1, fp);
1352  if (!fg) return read_iff_eof;
1353 
1354  (*line_no)++;
1355  remove_cr(line1);
1356 
1357  switch (field_format_judge(line1)) {
1358  case fft_free_field_format: /* JP-214 */
1359  free_to_iff_format(line1, iff);
1360  break;
1361  case fft_small_field_format: /* JP-215 */
1362  small_to_iff_format(line1, iff);
1363  break;
1364  case fft_large_field_format: /* JP-216 */
1365  /* JP-217 */
1366  if (!fgets(line2, IFF_SIZE - 1, fp)) {
1367  return read_iff_error; /* JP-218 */
1368  }
1369  (*line_no)++;
1370  remove_cr(line2);
1371  large_to_iff_format(line1, line2, iff);
1372  break;
1373  case fft_comment:
1374  return read_iff_comment; /* JP-219 */
1375  default:
1376  return read_iff_error; /* JP-220 */
1377  }
1378 
1379  return read_iff_success;
1380 }
1381 
1382 /* bulk.c */
1383 
1384 /* JP-221 */
1385 
1386 /* JP-222 */
1387 
1388 static void iff_bulk_init(iff_bulk_t* bulk) {
1389  bulk->iff_node_root = NULL;
1390  bulk->iff_node_last = NULL;
1391  bulk->next_bulk = NULL;
1392 }
1393 
1394 /* ------------------------------------------------------------------------------------------------
1395  */
1396 /* JP-223 */
1397 
1398 static iff_bulk_t* iff_bulk_create(void) {
1399  iff_bulk_t* bulk = (iff_bulk_t*)HECMW_malloc(sizeof(iff_bulk_t));
1400  iff_bulk_init(bulk);
1401 
1402  return bulk;
1403 }
1404 
1405 /* ------------------------------------------------------------------------------------------------
1406  */
1407 /* JP-224 */
1408 
1409 static void iff_bulk_free(iff_bulk_t* bulk) {
1410  iff_node_t* next;
1411  iff_node_t* node = bulk->iff_node_root;
1412 
1413  while (node) {
1414  next = node->next;
1415  iff_node_free(node);
1416  node = next;
1417  }
1418 
1419  HECMW_free(bulk);
1420 }
1421 
1422 /* ------------------------------------------------------------------------------------------------
1423  */
1424 /* JP-225 */
1425 /* JP-226 */
1426 
1427 static void iff_bulk_regist(iff_bulk_t* bulk, char* iff, int line_no) {
1428  iff_node_t *node, *last;
1429  iff_node_t* new_node;
1430 
1431  new_node = iff_node_create();
1432  iff_node_set(new_node, iff, line_no);
1433 
1434  /* JP-227 */
1435 
1436  if (bulk->iff_node_last) {
1437  bulk->iff_node_last->next = new_node;
1438  bulk->iff_node_last = new_node;
1439  } else {
1440  bulk->iff_node_last = bulk->iff_node_root = new_node;
1441  }
1442 }
1443 
1444 /* ------------------------------------------------------------------------------------------------
1445  */
1446 /* JP-228 */
1447 
1448 static void iff_bulk_move_append(iff_bulk_t* dest, iff_bulk_t* src) {
1449  if (src->iff_node_root == NULL) return;
1450 
1451  if (dest->iff_node_last)
1452  dest->iff_node_last->next = src->iff_node_root;
1453  else
1454  dest->iff_node_root = src->iff_node_root;
1455 
1456  dest->iff_node_last = src->iff_node_last;
1457 
1458  src->iff_node_root = NULL;
1459  src->iff_node_last = NULL;
1460 }
1461 
1462 /* ------------------------------------------------------------------------------------------------
1463  */
1464 /* JP-229 */
1465 
1466 static int iff_bulk_is_completed(iff_bulk_t* bulk) {
1467  int fg;
1468 
1469  if (bulk->iff_node_root == NULL) return 0; /* JP-230 */
1470 
1471  fg = iff_is_parent(bulk->iff_node_root->iff) &&
1472  iff_is_last(bulk->iff_node_last->iff);
1473 
1474  return fg;
1475 }
1476 
1477 /* ------------------------------------------------------------------------------------------------
1478  */
1479 /* JP-231 */
1480 
1481 static char* iff_bulk_get_name(iff_bulk_t* bulk) {
1482  if (!bulk->iff_node_root) return NULL;
1483 
1484  return iff_get_field(bulk->iff_node_root->iff, 0);
1485 }
1486 
1487 /* ------------------------------------------------------------------------------------------------
1488  */
1489 /* JP-232 */
1490 
1491 static char* iff_bulk_get_field(iff_bulk_t* bulk, int field_no) {
1492  int i, line, n;
1493  iff_node_t* node;
1494 
1495  line = field_no / FIELD_NUMBER;
1496  n = field_no % FIELD_NUMBER;
1497 
1498  i = 0;
1499  node = bulk->iff_node_root;
1500  while (node && i < line) {
1501  node = node->next;
1502  i++;
1503  }
1504  if (i < line) return NULL;
1505 
1506  return iff_get_field(node->iff, n);
1507 }
1508 
1509 /* ------------------------------------------------------------------------------------------------
1510  */
1511 /* JP-233 */
1512 /* JP-234 */
1513 
1514 static char* iff_bulk_get_param(iff_bulk_t* bulk, int param_no) {
1515  int i;
1516  iff_node_t* node;
1517  int N = FIELD_NUMBER - 2;
1518  int line = param_no / N;
1519  int n = param_no % N + 1;
1520 
1521  i = 0;
1522  node = bulk->iff_node_root;
1523  while (node && i < line) {
1524  node = node->next;
1525  i++;
1526  }
1527  if (node == NULL) return NULL;
1528 
1529  return iff_get_field(node->iff, n);
1530 }
1531 
1532 /* ------------------------------------------------------------------------------------------------
1533  */
1534 /* JP-235 */
1535 /* JP-236 */
1536 
1537 static char* iff_bulk_get_param_data(iff_bulk_t* bulk, int param_no,
1538  int* line_no, int* field_no) {
1539  int i;
1540  iff_node_t* node;
1541  int N = FIELD_NUMBER - 2;
1542  int line = param_no / N;
1543  int n = param_no % N + 1;
1544 
1545  i = 0;
1546  node = bulk->iff_node_root;
1547  while (node && i < line) {
1548  node = node->next;
1549  i++;
1550  }
1551  if (node == NULL) return 0;
1552 
1553  *line_no = node->line_no;
1554 
1555  *field_no = n + 1;
1556 
1557  return iff_get_field(node->iff, n);
1558 }
1559 
1560 /* ------------------------------------------------------------------------------------------------
1561  */
1562 /* JP-237 */
1563 /* JP-238 */
1564 
1565 /* JP-239 */
1566 
1567 static int get_number_in_str(char** pp) {
1568  char* p = *pp;
1569  char s[40];
1570  char* sp = s;
1571  int n;
1572 
1573  while (*p >= '0' && *p <= '9') {
1574  *sp = *p;
1575  sp++;
1576  p++;
1577  }
1578  *sp = 0;
1579  if (s[0] != 0)
1580  n = atoi(s);
1581  else
1582  n = 0;
1583 
1584  *pp = p;
1585  return n;
1586 }
1587 
1588 static int iff_bulk_get_param_list(iff_bulk_t* bulk, const char* format,
1589  int* result, ...) {
1590  va_list ap;
1591 
1592  char* nf;
1593  int i;
1594  int arr_n; /* JP-240 */
1595  int ness_n; /* JP-241 */
1596  int arr_fg; /* JP-242 */
1597  int R;
1598  int* r;
1599  char* f;
1600  char* field;
1601  char type;
1602  int ness; /* JP-243 */
1603 
1604  int line_no; /* JP-244 */
1605  int field_no; /* JP-245 */
1606 
1607  int param_pos;
1608  void* param;
1609  char* param_name_p;
1610  char param_name[IFF_FIELD_SIZE];
1611  int read_param_count;
1612 
1613  va_start(ap, result);
1614 
1615  f = (char*)format;
1616  r = result;
1617  param_pos = 0;
1618  read_param_count = 0;
1619 
1620  while (*f) {
1621  type = toupper(*f);
1622  if (type != '_')
1623  ness = isupper(*f);
1624  else
1625  ness = 0;
1626 
1627  /* JP-246 */
1628 
1629  if (ness)
1630  ness_n = 1;
1631  else
1632  ness_n = 0;
1633 
1634  nf = f;
1635  nf++;
1636  arr_n = get_number_in_str(&nf);
1637  arr_fg = 1;
1638  if (arr_n == 0) {
1639  arr_n = 1;
1640  arr_fg = 0;
1641  } else if (*nf == '/') {
1642  nf++;
1643  ness_n = get_number_in_str(&nf);
1644  if (!ness) ness_n = 0;
1645  } else if (ness) {
1646  ness_n = arr_n;
1647  }
1648 
1649  HECMW_assert(!((type == 'S') && (arr_n > 1)));
1650 
1651  /* JP-247 */
1652 
1653  if (type != '_') {
1654  param = va_arg(ap, void*);
1655  param_name_p = va_arg(ap, char*);
1656  }
1657 
1658  for (i = 0; i < arr_n; i++) {
1659  field = iff_bulk_get_param_data(bulk, param_pos, &line_no, &field_no);
1660  param_pos++;
1661  R = iff_field_to_param(field, type, param, &param);
1662 
1663  if (R == 0) { /* JP-248 */
1664  if (arr_fg)
1665  snprintf(param_name, sizeof(param_name), "%s%d", param_name_p, i + 1);
1666  else
1667  snprintf(param_name, sizeof(param_name), "%s", param_name_p);
1668  set_error_of_field_convert(grid_filename, line_no, field_no,
1669  iff_bulk_get_name(bulk), param_name, field,
1670  type);
1671  return -1;
1672  } else if (i < ness_n && R == 2) { /* JP-249 */
1673  if (arr_fg)
1674  snprintf(param_name, sizeof(param_name), "%s%d", param_name_p, i + 1);
1675  else
1676  snprintf(param_name, sizeof(param_name), "%s", param_name_p);
1677  set_error_of_blank_field(grid_filename, line_no, field_no,
1678  iff_bulk_get_name(bulk), param_name);
1679  return -1;
1680  }
1681 
1682  if (type != '_') {
1683  *r = R;
1684  r++;
1685  }
1686  }
1687 
1688  f = nf;
1689  }
1690 
1691  va_end(ap);
1692  return 0;
1693 }
1694 
1695 /* ------------------------------------------------------------------------------------------------
1696  */
1697 /* JP-250 */
1698 /* JP-251 */
1699 
1700 static int iff_bulk_get_param_list_pattern(iff_bulk_t* bulk, const char* format,
1701  int start_param_pos, int* size,
1702  ...) {
1703 #define GPLP_PARAM_LIST_SIZE 50
1704 
1705  va_list ap;
1706 
1707  int i;
1708  char* field;
1709  char type;
1710 
1711  int param_pos;
1712  void* param;
1713  char param_name[IFF_FIELD_SIZE];
1714 
1715  void* param_list_p[GPLP_PARAM_LIST_SIZE];
1716  void** param_list[GPLP_PARAM_LIST_SIZE];
1717  char* param_name_head[GPLP_PARAM_LIST_SIZE];
1718 
1719  int R[GPLP_PARAM_LIST_SIZE];
1720 
1721  int param_list_size; /* JP-252 */
1722  int data_number; /* JP-253 */
1723  int data_size; /* JP-254 */
1724 
1725  int index;
1726  int loop_fg;
1727 
1728  int type_size;
1729  int r;
1730  int line_no;
1731  int field_no;
1732  int state; /* JP-255 */
1733 
1734  /* ------------------------------------------- */
1735 
1736  va_start(ap, size);
1737 
1738  str_upr((char*)format);
1739  param_list_size = strlen((char*)format);
1740 
1741  /* JP-256 */
1742 
1743  for (i = 0; i < param_list_size; i++) {
1744  param_list[i] = va_arg(ap, void**);
1745  param_name_head[i] = va_arg(ap, char*);
1746  }
1747 
1748  /* JP-257 */
1749 
1750  data_size = iff_bulk_get_line_number(bulk) / param_list_size;
1751  for (i = 0; i < param_list_size; i++) {
1752  switch (format[i]) {
1753  case 'I':
1754  type_size = sizeof(int);
1755  break;
1756  case 'U':
1757  type_size = sizeof(unsigned int);
1758  break;
1759  case 'D':
1760  type_size = sizeof(double);
1761  break;
1762  default:
1763  HECMW_assert(0);
1764  }
1765  *param_list[i] = HECMW_malloc(type_size * data_size);
1766  param_list_p[i] = *param_list[i];
1767  }
1768 
1769  param_pos = start_param_pos;
1770  index = 0;
1771  loop_fg = 1;
1772  while (loop_fg) {
1773  state = 0;
1774  for (i = 0; i < param_list_size; i++) {
1775  field = iff_bulk_get_param_data(bulk, param_pos, &line_no, &field_no);
1776  if (field == NULL || field[0] == 0) {
1777  goto END;
1778  break;
1779  }
1780  param_pos++;
1781  type = format[i];
1782  param = param_list_p[i];
1783  r = iff_field_to_param(field, type, param, &param);
1784  if (r == 1) {
1785  param_list_p[i] = param; /* JP-258 */
1786  } else if (r == 0) { /* error */
1787  snprintf(param_name, sizeof(param_name), "%s%d", param_name_head[i], index + 1);
1788  set_error_of_field_convert(grid_filename, line_no, field_no,
1789  iff_bulk_get_name(bulk), param_name, field,
1790  type);
1791  return -1;
1792  }
1793  if (state != 0 && state != r) {
1794  snprintf(param_name, sizeof(param_name), "%s%d", param_name_head[i], index + 1);
1795  set_error_of_field_convert(grid_filename, line_no, field_no,
1796  iff_bulk_get_name(bulk), param_name, field,
1797  type);
1798  return -1;
1799  }
1800  state = r;
1801  }
1802  index++;
1803  }
1804 END:
1805  *size = index;
1806 
1807  va_end(ap);
1808  return 0;
1809 
1810 #undef GPLP_PARAM_LIST_SIZE
1811 }
1812 
1813 /* ------------------------------------------------------------------------------------------------
1814  */
1815 /* JP-259 */
1816 
1817 static int iff_bulk_get_line_number(iff_bulk_t* bulk) {
1818  int i = 0;
1819  iff_node_t* node = bulk->iff_node_root;
1820 
1821  while (node) {
1822  i++;
1823  node = node->next;
1824  }
1825 
1826  return i;
1827 }
1828 
1829 /* ------------------------------------------------------------------------------------------------
1830  */
1831 /* JP-260 */
1832 
1833 static int iff_bulk_get_line_no(iff_bulk_t* bulk, int iff_pos) {
1834  int i = 0;
1835  iff_node_t* node = bulk->iff_node_root;
1836 
1837  while (node) {
1838  if (i == iff_pos) return node->line_no;
1839  i++;
1840  node = node->next;
1841  }
1842  return 0;
1843 }
1844 
1845 /* ------------------------------------------------------------------------------------------------
1846  */
1847 /* JP-261 */
1848 
1849 static iff_node_t* iff_bulk_search_pointing_line(iff_bulk_t* bulk,
1850  char* line_pointer) {
1851  /* JP-262 */
1852 
1853  char* p;
1854 
1855  iff_node_t* node;
1856 
1857  node = bulk->iff_node_last;
1858 
1859  if (node && iff_is_pointing_line(node->iff)) {
1860  p = iff_get_pointing_line_pointer(node->iff);
1861  if (strcmp(p, line_pointer) == 0) {
1862  return node;
1863  }
1864  }
1865 
1866  return NULL;
1867 }
1868 
1869 /* ------------------------------------------------------------------------------------------------
1870  */
1871 /* JP-263 */
1872 
1873 static iff_node_t* iff_bulk_search_continuous_line(iff_bulk_t* bulk,
1874  char* line_pointer) {
1875  /* JP-264 */
1876 
1877  char* p;
1878 
1879  iff_node_t* node = bulk->iff_node_root;
1880 
1881  if (node && iff_is_continuous_line(node->iff)) {
1882  p = iff_get_continuous_line_pointer(node->iff);
1883  if (strcmp(p, line_pointer) == 0) {
1884  return node;
1885  }
1886  }
1887 
1888  return NULL;
1889 }
1890 
1891 /* ------------------------------------------------------------------------------------------------
1892  */
1893 /* JP-265 */
1894 
1895 static void iff_bulk_dump(iff_bulk_t* bulk) {
1896  iff_node_t* node = bulk->iff_node_root;
1897 
1898  while (node) {
1899  printf("%3d", node->line_no);
1900  iff_dump(node->iff);
1901  node = node->next;
1902  }
1903 }
1904 
1905 /* bulk_parse_head.c */
1906 
1907 /* JP-266 */
1908 
1909 /* JP-267 */
1910 
1911 /* ------------------------------------------------------------------------------------------------
1912  */
1913 
1914 #include <stdarg.h>
1915 #include <stdlib.h>
1916 
1917 #define GENERATE_CODE(name) static int iff_bulk_parse_##name(iff_bulk_t* bulk);
1918 
1919 GENERATE_CODE(GRID)
1920 GENERATE_CODE(MAT1)
1921 GENERATE_CODE(MAT4)
1922 GENERATE_CODE(PROD)
1923 GENERATE_CODE(PSHELL)
1924 GENERATE_CODE(PSOLID)
1925 GENERATE_CODE(CROD)
1926 GENERATE_CODE(CBAR)
1927 GENERATE_CODE(CBEAM)
1928 GENERATE_CODE(CTRIA3)
1929 GENERATE_CODE(CTRIA6)
1930 GENERATE_CODE(CQUAD4)
1931 GENERATE_CODE(CQUAD8)
1932 GENERATE_CODE(CTETRA)
1933 GENERATE_CODE(CPENTA)
1934 GENERATE_CODE(CHEXA)
1935 GENERATE_CODE(CTRIAX6)
1936 GENERATE_CODE(INCLUDE)
1937 
1938 #undef GENERATE_CODE
1939 
1940 #define GENERATE_CODE(name) BULK_TYPE_##name,
1941 
1942 enum {
1943  GENERATE_CODE(GRID) GENERATE_CODE(MAT1) GENERATE_CODE(MAT4)
1944  GENERATE_CODE(PROD) GENERATE_CODE(PSHELL) GENERATE_CODE(PSOLID)
1945  GENERATE_CODE(CROD) GENERATE_CODE(CBAR) GENERATE_CODE(CBEAM)
1946  GENERATE_CODE(CTRIA3) GENERATE_CODE(CTRIA6) GENERATE_CODE(CQUAD4)
1947  GENERATE_CODE(CQUAD8) GENERATE_CODE(CTETRA)
1948  GENERATE_CODE(CPENTA) GENERATE_CODE(CHEXA)
1949  GENERATE_CODE(CTRIAX6) GENERATE_CODE(INCLUDE)
1950  BULK_TYPE_UNKNOWN
1951 };
1952 #undef GENERATE_CODE
1953 
1954 #define BULK_TYPE_NUMBER BULK_TYPE_UNKNOWN
1955 
1956 #define GENERATE_CODE(name) #name,
1957 
1958 static char* bulk_type_name[] = {
1959  GENERATE_CODE(GRID) GENERATE_CODE(MAT1) GENERATE_CODE(MAT4) GENERATE_CODE(
1960  PROD) GENERATE_CODE(PSHELL) GENERATE_CODE(PSOLID) GENERATE_CODE(CROD)
1961  GENERATE_CODE(CBAR) GENERATE_CODE(CBEAM) GENERATE_CODE(CTRIA3)
1962  GENERATE_CODE(CTRIA6) GENERATE_CODE(CQUAD4) GENERATE_CODE(CQUAD8)
1963  GENERATE_CODE(CTETRA) GENERATE_CODE(CPENTA) GENERATE_CODE(CHEXA)
1964  GENERATE_CODE(CTRIAX6) GENERATE_CODE(INCLUDE) "UNKNOWN"};
1965 #undef GENERATE_CODE
1966 
1967 /*-------------------------------------------------------*/
1968 
1969 static int iff_bulk_type(const char* bulkname) {
1970  int i;
1971 
1972  for (i = 0; i < BULK_TYPE_NUMBER; i++) {
1973  if (0 == strcmp(bulkname, bulk_type_name[i])) return i;
1974  }
1975 
1976  return BULK_TYPE_UNKNOWN;
1977 }
1978 
1979 static int iff_bulk_parse(iff_bulk_t* bulk) {
1980  char* bulkname;
1981  int no;
1982 
1983  bulkname = iff_bulk_get_name(bulk);
1984 
1985  HECMW_assert(bulkname);
1986 
1987  no = iff_bulk_type(bulkname);
1988 
1989 #define GENERATE_CODE(name) \
1990  case BULK_TYPE_##name: \
1991  return iff_bulk_parse_##name(bulk);
1992 
1993  switch (no) {
1994  GENERATE_CODE(GRID)
1995  GENERATE_CODE(MAT1)
1996  GENERATE_CODE(MAT4)
1997  GENERATE_CODE(PROD)
1998  GENERATE_CODE(PSHELL)
1999  GENERATE_CODE(PSOLID)
2000  GENERATE_CODE(CROD)
2001  GENERATE_CODE(CBAR)
2002  GENERATE_CODE(CBEAM)
2003  GENERATE_CODE(CTRIA3)
2004  GENERATE_CODE(CTRIA6)
2005  GENERATE_CODE(CQUAD4)
2006  GENERATE_CODE(CQUAD8)
2007  GENERATE_CODE(CTETRA)
2008  GENERATE_CODE(CPENTA)
2009  GENERATE_CODE(CHEXA)
2010  GENERATE_CODE(CTRIAX6)
2011  GENERATE_CODE(INCLUDE)
2012  default:
2013  /* JP-268 */
2014  /* JP-269 */
2015  return 0;
2016  /* return iff_bulk_parse_debug( bulk ); */
2017  }
2018 }
2019 
2020 /* bulk_parse.c */
2021 
2022 /*---------------------------------------------------------------*/
2023 /* JP-270 */
2024 
2025 typedef struct ST_PSHELL_MID2 {
2026  int PID;
2027  int MID2;
2028  struct ST_PSHELL_MID2* next;
2029 } pshell_mid2_t;
2030 
2031 typedef struct ST_PSHELLMID2_LIST { pshell_mid2_t* root; } pshell_mid2_list_t;
2032 
2033 static pshell_mid2_list_t pshell_mid2_list;
2034 static int pshell_mid2_list_init_fg = 0;
2035 
2036 static void pshell_mid2_list_init(void);
2037 static void pshell_mid2_list_clear(void);
2038 static void pshell_mid2_list_regist(int pid, int mid2);
2039 static int pshell_mid2_list_get_mid2_by_pid(int pid, int* mid2);
2040 
2041 /* JP-271 */
2042 
2043 static void pshell_mid2_list_init(void) {
2044  pshell_mid2_list.root = NULL;
2045  pshell_mid2_list_init_fg = 1;
2046 }
2047 
2048 static void pshell_mid2_list_clear(void) {
2049  pshell_mid2_t* node = pshell_mid2_list.root;
2050  pshell_mid2_t* next;
2051 
2052  while (node) {
2053  next = node->next;
2054  HECMW_free(node);
2055  node = next;
2056  }
2057  pshell_mid2_list.root = NULL;
2058 }
2059 
2060 static void pshell_mid2_list_regist(int pid, int mid2) {
2061  pshell_mid2_t* node;
2062 
2063  node = HECMW_malloc(sizeof(pshell_mid2_t));
2064  HECMW_assert(node);
2065 
2066  node->PID = pid;
2067  node->MID2 = mid2;
2068 
2069  if (!pshell_mid2_list_init_fg) {
2070  pshell_mid2_list_init();
2071  }
2072 
2073  if (pshell_mid2_list.root) {
2074  node->next = pshell_mid2_list.root;
2075  } else {
2076  node->next = NULL;
2077  }
2078  pshell_mid2_list.root = node;
2079 }
2080 
2081 static int pshell_mid2_list_get_mid2_by_pid(int pid, int* mid2) {
2082  pshell_mid2_t* node = pshell_mid2_list.root;
2083 
2084  while (node) {
2085  if (node->PID == pid) {
2086  *mid2 = node->MID2;
2087  return 1;
2088  }
2089  node = node->next;
2090  }
2091 
2092  return 0;
2093 }
2094 
2095 /* JP-272 */
2096 /* JP-273 */
2097 
2098 static int check_order_of_elem(int result[], int G_start_pos, int G_number,
2099  int G_ness) {
2100  int i;
2101  int first_order = 0;
2102  int* r = &(result[G_start_pos]);
2103 
2104  for (i = 0; i < G_ness; i++, r++) {
2105  if (*r != 1) {
2106  return 0; /* JP-274 */
2107  }
2108  }
2109 
2110  for (; i < G_number; i++, r++) {
2111  if (*r != 1) {
2112  return 1; /* JP-275 */
2113  }
2114  }
2115 
2116  return 2;
2117 }
2118 
2119 /* JP-276 */
2120 /* JP-277 */
2121 
2122 /* ------------------------------------------------------------------------------------------------
2123  */
2124 /* JP-278 */
2125 
2126 static struct hecmw_io_material* create_mat_struct(const char* name, int item_n,
2127  int sub_n[], double data[]) {
2128 #define cms_malloc(p, size) \
2129  { \
2130  (p) = HECMW_malloc((size)); \
2131  if ((p) == NULL) { \
2132  HECMW_set_error(errno, ""); \
2133  return NULL; \
2134  } \
2135  }
2136 
2137  struct hecmw_io_material* mat;
2138  struct hecmw_io_matitem* matitem;
2139  struct hecmw_io_matsubitem* matsubitem;
2140  int i, j, d_count;
2141  int val_n;
2142 
2143  cms_malloc(mat, sizeof(*mat));
2144  cms_malloc(matitem, sizeof(*matitem) * item_n);
2145 
2146  d_count = 0;
2147 
2148  for (i = 0; i < item_n; i++) {
2149  matitem[i].item = i + 1;
2150  matitem[i].nval = sub_n[i];
2151 
2152  cms_malloc(matsubitem, sizeof(*matsubitem));
2153  cms_malloc(matsubitem->val, sizeof(*(matsubitem->val)) * sub_n[i]);
2154 
2155  for (j = 0; j < sub_n[i]; j++) {
2156  matsubitem->val[j] = data[d_count];
2157  d_count++;
2158  }
2159  matsubitem->temp = data[d_count];
2160  d_count++;
2161 
2162  matsubitem->next = NULL;
2163  matitem[i].subitem = matsubitem;
2164  }
2165 
2166  snprintf(mat->name, sizeof(mat->name), "%s", name);
2167  mat->nitem = item_n;
2168  mat->item = matitem;
2169  mat->next = NULL;
2170 
2171  return mat;
2172 
2173 #undef cms_malloc
2174 }
2175 
2176 /* ------------------------------------------------------------------------------------------------
2177  */
2178 /* JP-279 */
2179 
2180 static int iff_bulk_parse_MAT1(iff_bulk_t* bulk) {
2181 #define BULK_PARAM_NUMBER 12
2182 
2183  unsigned int MID; /* JP-280 */
2184  double E; /* JP-281 */
2185  double G; /* JP-282 */
2186  double NU; /* JP-283 */
2187  double RHO; /* JP-284 */
2188  double A; /* JP-285 */
2189  double TREF; /* JP-286 */
2190  double GE; /* JP-287 */
2191  double ST, SC, SS; /* JP-288 */
2192  unsigned int MCSID; /* JP-289 */
2193 
2194  char format[] = "UDdDDDdddddu";
2195 
2196  int result[BULK_PARAM_NUMBER];
2197 
2198  MID = 0;
2199  E = G = NU = RHO = A = TREF = GE = ST = SC = SS = 0.0;
2200  MCSID = 0;
2201 
2202  iff_bulk_get_param_list(bulk, format, result, &MID, "MID", &E, "E", &G, "G",
2203  &NU, "NU", &RHO, "RHO", &A, "A", &TREF, "TREF", &GE,
2204  "GE", &ST, "ST", &SC, "SC", &SS, "SS", &MCSID,
2205  "MCSID");
2206 
2207  {
2208  int i;
2209  struct hecmw_io_material* mat;
2210  char name[HECMW_NAME_LEN + 1];
2211 #define item_n 3
2212  int sub_n[item_n] = {2, 1, 1};
2213  double data[4 + item_n];
2214 
2215  matrial_name_by_MID(MID, name, sizeof(name));
2216 
2217  i = 0;
2218  data[i++] = E;
2219  data[i++] = NU;
2220  data[i++] = 0; /* temp */
2221  data[i++] = RHO;
2222  data[i++] = 0; /* temp */
2223  data[i++] = A;
2224  data[i++] = 0; /* temp */
2225 
2226  mat = create_mat_struct(name, item_n, sub_n, data);
2227  if (HECMW_io_add_mat(name, mat) == NULL) return -1;
2228 
2229 #undef item_n
2230  }
2231 
2232  return 0;
2233 #undef BULK_PARAM_NUMBER
2234 }
2235 
2236 /* ------------------------------------------------------------------------------------------------
2237  */
2238 /* JP-290 */
2239 
2240 static int iff_bulk_parse_MAT4(iff_bulk_t* bulk) {
2241 #define BULK_PARAM_NUMBER 11
2242 
2243  unsigned int MID; /* JP-291 */
2244  double K = 0; /* JP-292 */
2245  double CP = 0; /* JP-293 */
2246  double r = 1.0; /* JP-294 */
2247  double H; /* JP-295 */
2248  double m; /* JP-296 */
2249  double HGEN; /* JP-297 */
2250  double REFENTH; /* JP-298 */
2251  double TCH; /* JP-299 */
2252  double TDELTA; /* JP-300 */
2253  double QLAT; /* JP-301 */
2254 
2255  char format[] = "Udddddddddd";
2256 
2257  int result[BULK_PARAM_NUMBER];
2258 
2259  iff_bulk_get_param_list(bulk, format, result, &MID, "MID", &K, "K", &CP, "CP",
2260  &r, "rho", &H, "H", &m, "m", &HGEN, "HGEN", &REFENTH,
2261  "REFENTH", &TCH, "TCH", &TDELTA, "TDELTA", &QLAT,
2262  "QLAT");
2263 
2264  {
2265  int i;
2266  struct hecmw_io_material* mat;
2267  char name[HECMW_NAME_LEN + 1];
2268 #define item_n 3
2269  int sub_n[item_n] = {1, 1, 1};
2270  double data[3 + item_n];
2271 
2272  matrial_name_by_MID(MID, name, sizeof(name));
2273 
2274  i = 0;
2275  data[i++] = K;
2276  data[i++] = 0; /* temp */
2277  data[i++] = CP;
2278  data[i++] = 0; /* temp */
2279  data[i++] = r;
2280  data[i++] = 0; /* temp */
2281 
2282  mat = create_mat_struct(name, item_n, sub_n, data);
2283  if (HECMW_io_add_mat(name, mat) == NULL) return -1;
2284 
2285 #undef item_n
2286  }
2287 
2288  return 0;
2289 #undef BULK_PARAM_NUMBER
2290 }
2291 
2292 /* JP-302 */
2293 /* JP-303 */
2294 
2295 /* ------------------------------------------------------------------------------------------------
2296  */
2297 /* JP-304 */
2298 
2299 /* JP-305 */
2300 
2301 typedef struct hecmw_io_section section_rec;
2302 
2303 static void init_section_rec(section_rec* a) {
2304  memset(a, 0, sizeof(section_rec));
2305 }
2306 
2307 CREATE_LIST_CODE(section_rec)
2308 
2309 static int is_eq_section_rec(section_rec a, section_rec b) {
2310  return (strcmp(a.egrp, b.egrp) == 0);
2311 }
2312 
2313 static void copy_section_rec(section_rec* dest, section_rec src) {
2314  memcpy(dest, &src, sizeof(section_rec));
2315 }
2316 
2317 static void delete_section_rec(section_rec a) { /* JP-306 */ }
2318 
2319 static t_list_section_rec section_list;
2320 
2321 /*---------------------------------------------*/
2322 
2323 /* JP-307 */
2324 
2325 static void section_list_init(void) { list_init_section_rec(&section_list); }
2326 
2327 /* JP-308 */
2328 
2329 static int section_list_regist(struct hecmw_io_section* sect) {
2330  return (list_add_section_rec(&section_list, *sect) == NULL);
2331 }
2332 
2333 /* JP-309 */
2334 
2335 static int section_list_finalize(void) {
2336  list_scan_start_section_rec(&section_list);
2337  while (list_scan_next_section_rec(&section_list)) {
2338  section_rec* rec = &section_list.current->data;
2339  struct hecmw_io_egrp* egrp = HECMW_io_get_egrp(rec->egrp);
2340  if (egrp) {
2341  if (HECMW_io_add_sect(rec) == NULL) return -1;
2342  }
2343  }
2344 
2345  list_clear_section_rec(&section_list);
2346 
2347  return 0;
2348 }
2349 
2350 /* ------------------------------------------------------------------------------------------------
2351  */
2352 /* JP-310 */
2353 
2354 static int iff_bulk_parse_PROD(iff_bulk_t* bulk) {
2355 #define BULK_PARAM_NUMBER 6
2356 
2357  unsigned int PID; /* JP-311 */
2358  unsigned int MID; /* JP-312 */
2359  double A; /* JP-313 */
2360  double J; /* JP-314 */
2361  double C = 0; /* JP-315 */
2362  double NSM; /* JP-316 */
2363 
2364  char format[] = "UUdddd";
2365  int result[BULK_PARAM_NUMBER];
2366  char grp_name[HECMW_NAME_LEN + 1];
2367  struct hecmw_io_section sect;
2368 
2369  iff_bulk_get_param_list(bulk, format, result, &PID, "PID", &MID, "MID", &A,
2370  "A", &J, "J", &C, "C", &NSM, "NSM");
2371 
2372  snprintf(sect.egrp, sizeof(sect.egrp), "%s", egrp_name_by_PID(PID, grp_name, sizeof(grp_name)));
2373  snprintf(sect.material, sizeof(sect.material), "%s", matrial_name_by_MID(MID, grp_name, sizeof(grp_name)));
2374  sect.composite = 1;
2375  sect.secopt = 0;
2376 
2377  sect.type = HECMW_SECT_TYPE_SOLID;
2378  sect.sect.solid.thickness = A;
2379 
2380  sect.next = NULL;
2381 
2382  if (section_list_regist(&sect)) return -1;
2383 
2384  return 0;
2385 
2386 #undef BULK_PARAM_NUMBER
2387 }
2388 
2389 /* ------------------------------------------------------------------------------------------------
2390  */
2391 /* JP-317 */
2392 
2393 static int iff_bulk_parse_PSHELL(iff_bulk_t* bulk) {
2394 #define BULK_PARAM_NUMBER 11
2395 
2396  unsigned int PID; /* JP-318 */
2397  unsigned int MID1; /* JP-319 */
2398  double T; /* JP-320 */
2399  int MID2; /* JP-321 */
2400  double _12I_T_3; /* JP-322 */
2401  unsigned int MID3; /* JP-323 */
2402  double TS_S; /* JP-324 */
2403  double NSM; /* JP-325 */
2404  double Z1, Z2; /* JP-326 */
2405  unsigned int MID4; /* JP-327 */
2406 
2407  char format[] = "Uudiduddddi";
2408 
2409  int result[BULK_PARAM_NUMBER];
2410 
2411  char grp_name[HECMW_NAME_LEN + 1];
2412 
2413  struct hecmw_io_section sect;
2414 
2415  /* JP-328 */
2416 
2417  MID1 = 0;
2418  MID2 = 0;
2419  _12I_T_3 = 1.0;
2420  TS_S = 0.833333;
2421 
2422  iff_bulk_get_param_list(bulk, format, result, &PID, "PID", &MID1, "MID1", &T,
2423  "T", &MID2, "MID2", &_12I_T_3, "12I/T^3", &MID3,
2424  "MID3", &TS_S, "TS/S", &NSM, "NSM", &Z1, "Z1", &Z2,
2425  "Z2", &MID4, "MID4");
2426 
2427  snprintf(sect.egrp, sizeof(sect.egrp), "%s", egrp_name_by_PID(PID, grp_name, sizeof(grp_name)));
2428  snprintf(sect.material, sizeof(sect.material), "%s", matrial_name_by_MID(MID1, grp_name, sizeof(grp_name)));
2429  sect.composite = 1;
2430  sect.secopt = 0;
2431 
2432  if (MID2 == 0)
2433  sect.secopt = HECMW_SECT_OPT_PSTRESS;
2434  else if (MID2 == -1)
2435  sect.secopt = HECMW_SECT_OPT_PSTRAIN;
2436 
2437  if (MID2 == 0 || MID2 == -1)
2438  sect.type = HECMW_SECT_TYPE_SOLID;
2439  else
2440  sect.type = HECMW_SECT_TYPE_SHELL;
2441 
2442  if (sect.type == HECMW_SECT_TYPE_SOLID) {
2443  sect.sect.solid.thickness = T;
2444  } else {
2445  sect.sect.shell.thickness = T;
2446  sect.sect.shell.integpoints = 1; /* JP-329 */
2447  }
2448 
2449  sect.next = NULL;
2450 
2451  if (section_list_regist(&sect)) return -1;
2452 
2453  /* JP-330 */
2454 
2455  pshell_mid2_list_regist(PID, MID2);
2456 
2457  return 0;
2458 
2459 #undef BULK_PARAM_NUMBER
2460 }
2461 
2462 /* ------------------------------------------------------------------------------------------------
2463  */
2464 /* JP-331 */
2465 
2466 static int iff_bulk_parse_PSOLID(iff_bulk_t* bulk) {
2467 #define BULK_PARAM_NUMBER 7
2468 
2469  unsigned int PID; /* JP-332 */
2470  unsigned int MID; /* JP-333 */
2471  int CORDM; /* JP-334 */
2472  char IN[IFF_FIELD_SIZE]; /* JP-335 */
2473  char STRESS[IFF_FIELD_SIZE]; /* JP-336 */
2474  char ISOP[IFF_FIELD_SIZE]; /* JP-337 */
2475  char FCTN[IFF_FIELD_SIZE]; /* JP-338 */
2476 
2477  char format[] = "UUissss";
2478  int result[BULK_PARAM_NUMBER];
2479  struct hecmw_io_section sect;
2480  char grp_name[HECMW_NAME_LEN + 1];
2481 
2482  /* JP-339 */
2483 
2484  CORDM = 0;
2485  IN[0] = 0;
2486  STRESS[0] = 0;
2487  ISOP[0] = 0;
2488  snprintf(FCTN, sizeof(FCTN), "%s", "SMECH");
2489 
2490  iff_bulk_get_param_list(bulk, format, result, &PID, "PID", &MID, "MID",
2491  &CORDM, "CORDM", IN, "IN", STRESS, "STRESS", ISOP,
2492  "ISOP", FCTN, "FCTN");
2493 
2494  sect.type = HECMW_SECT_TYPE_SOLID;
2495 
2496  snprintf(sect.egrp, sizeof(sect.egrp), "%s", egrp_name_by_PID(PID, grp_name, sizeof(grp_name)));
2497  snprintf(sect.material, sizeof(sect.material), "%s", matrial_name_by_MID(MID, grp_name, sizeof(grp_name)));
2498  sect.composite = 1; /* JP-340 */
2499 
2500  sect.secopt = 0; /* JP-341 */
2501 
2502  sect.sect.solid.thickness = 1; /* JP-342 */
2503 
2504  sect.next = NULL;
2505 
2506  if (section_list_regist(&sect)) return -1;
2507 
2508  return 0;
2509 
2510 #undef BULK_PARAM_NUMBER
2511 }
2512 
2513 /* JP-343 */
2514 /* JP-344 */
2515 
2516 /* ------------------------------------------------------------------------------------------------
2517  */
2518 /* JP-345 */
2519 
2520 static int iff_bulk_parse_CROD(iff_bulk_t* bulk) {
2521 #define G_NUMBER 2
2522 #define BULK_PARAM_NUMBER (2 + G_NUMBER)
2523 
2524  unsigned int EID; /* JP-346 */
2525  unsigned int PID; /* JP-347 */
2526  unsigned int G[G_NUMBER];
2527 
2528  char format[20] = "UUU2";
2529  int result[BULK_PARAM_NUMBER];
2530  char grp_name[HECMW_NAME_LEN + 1];
2531  int EID_List[1];
2532 
2533  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", G, "G");
2534 
2535  if (HECMW_io_add_elem(EID, HECMW_ETYPE_ROD1, (int*)G, 0, NULL) == NULL)
2536  return -1;
2537 
2538  EID_List[0] = EID;
2539  if (HECMW_io_add_egrp(egrp_name_by_PID(PID, grp_name, sizeof(grp_name)), 1, EID_List) == -1)
2540  return -1;
2541 
2542  if (HECMW_io_add_egrp("ALL", 1, EID_List) == -1) return -1;
2543 
2544  return 0;
2545 
2546 #undef G_NUMBER
2547 #undef BULK_PARAM_NUMBER
2548 }
2549 
2550 /* ------------------------------------------------------------------------------------------------
2551  */
2552 /* JP-348 */
2553 
2554 static int iff_bulk_parse_CBAR(iff_bulk_t* bulk) { return -1; }
2555 
2556 /* ------------------------------------------------------------------------------------------------
2557  */
2558 /* JP-349 */
2559 
2560 static int iff_bulk_parse_CBEAM(iff_bulk_t* bulk) { return -1; }
2561 
2562 /* JP-350 */
2563 /* JP-351 */
2564 
2565 /* ------------------------------------------------------------------------------------------------
2566  */
2567 /* JP-352 */
2568 
2569 /* JP-353 */
2570 
2571 static int surface_elem_store(int bulk_type, unsigned int EID, unsigned int PID,
2572  unsigned int G[], int G_number, double THETA_MCID,
2573  double ZOFFS, double T[], int T_number) {
2574  int elem_type;
2575  struct hecmw_io_egrp* egrp;
2576  char grp_name[HECMW_NAME_LEN + 1];
2577  int EID_List[1];
2578 
2579  /* JP-354 */
2580 
2581  switch (bulk_type) {
2582  case BULK_TYPE_CTRIA3:
2583  elem_type = HECMW_ETYPE_TRI1;
2584  break;
2585  case BULK_TYPE_CTRIA6:
2586  elem_type = HECMW_ETYPE_TRI2;
2587  break;
2588  case BULK_TYPE_CQUAD4:
2589  elem_type = HECMW_ETYPE_QUA1;
2590  break;
2591  case BULK_TYPE_CQUAD8:
2592  elem_type = HECMW_ETYPE_QUA2;
2593  break;
2594  default:
2595  HECMW_assert(0);
2596  }
2597 
2598  if (HECMW_io_add_elem(EID, elem_type, (int*)G, T_number, T) == NULL)
2599  return -1;
2600 
2601  EID_List[0] = EID;
2602 
2603  if (HECMW_io_add_egrp("ALL", 1, EID_List) == -1) return -1;
2604 
2605  if (HECMW_io_add_egrp(egrp_name_by_PID(PID, grp_name, sizeof(grp_name)), 1, EID_List) == -1)
2606  return -1;
2607 
2608  return 0;
2609 }
2610 
2611 /* JP-355 */
2612 /* JP-356 */
2613 /* JP-357 */
2614 
2615 static int surface_elem_type_decide(void) {
2616  int i;
2617  struct hecmw_io_id_array* id_array;
2618  char grp_name[HECMW_NAME_LEN + 1];
2619  pshell_mid2_t* node;
2620  struct hecmw_io_element* elem;
2621 
2622  node = pshell_mid2_list.root;
2623  while (node) {
2624  egrp_name_by_PID(node->PID, grp_name, sizeof(grp_name));
2625  id_array = HECMW_io_get_elem_in_egrp(grp_name);
2626  if (id_array) {
2627  for (i = 0; i < id_array->n; i++) {
2628  elem = HECMW_io_get_elem(id_array->id[i]);
2629  if (!elem) HECMW_assert(0);
2630  if (node->MID2 >= 1) {
2631  switch (elem->type) {
2632  case HECMW_ETYPE_TRI1:
2633  elem->type = HECMW_ETYPE_SHT1;
2634  break;
2635  case HECMW_ETYPE_TRI2:
2636  elem->type = HECMW_ETYPE_SHT2;
2637  break;
2638  case HECMW_ETYPE_QUA1:
2639  elem->type = HECMW_ETYPE_SHQ1;
2640  break;
2641  case HECMW_ETYPE_QUA2:
2642  elem->type = HECMW_ETYPE_SHQ2;
2643  break;
2644  }
2645  }
2646  }
2647  HECMW_free(id_array);
2648  }
2649  node = node->next;
2650  }
2651 
2652  pshell_mid2_list_clear();
2653  return 0;
2654 }
2655 
2656 /* ------------------------------------------------------------------------------------------------
2657  */
2658 /* JP-358 */
2659 
2660 static int iff_bulk_parse_CTRIA3(iff_bulk_t* bulk) {
2661  int i;
2662 
2663 #define BULK_PARAM_NUMBER (2 + 3 + 2 + 3)
2664 
2665  unsigned int EID; /* JP-359 */
2666  unsigned int PID; /* JP-360 */
2667  unsigned int G[3]; /* JP-361 */
2668  double THETA_MCID; /* JP-362 */
2669  double ZOFFS; /* JP-363 */
2670  double T[3]; /* JP-364 */
2671  int Tnumber;
2672 
2673  char format[] = "UUU3dd_3d3";
2674  int result[BULK_PARAM_NUMBER];
2675 
2676  T[0] = T[1] = T[2] = 0.0;
2677 
2678  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &PID, "PID", G,
2679  "G", &THETA_MCID, "THETA/MCID", &ZOFFS, "ZOFFS", T,
2680  "T");
2681 
2682  /* JP-365 */
2683 
2684  if (result[BULK_PARAM_NUMBER - 3] == 1 &&
2685  result[BULK_PARAM_NUMBER - 2] == 1 && result[BULK_PARAM_NUMBER - 1] == 1)
2686  Tnumber = 3;
2687  else
2688  Tnumber = 0;
2689 
2690  if (surface_elem_store(BULK_TYPE_CTRIA3, EID, PID, G, 3, THETA_MCID, ZOFFS, T,
2691  Tnumber))
2692  return -1;
2693 
2694  return 0;
2695 
2696 #undef BULK_PARAM_NUMBER
2697 }
2698 
2699 /* ------------------------------------------------------------------------------------------------
2700  */
2701 /* JP-366 */
2702 
2703 static int iff_bulk_parse_CTRIA6(iff_bulk_t* bulk) {
2704  int i;
2705 
2706 #define G_NUMBER 6
2707 #define BULK_PARAM_NUMBER (2 + G_NUMBER + 2 + 3)
2708 
2709  unsigned int EID; /* JP-367 */
2710  unsigned int PID; /* JP-368 */
2711  unsigned int G[G_NUMBER]; /* JP-369 */
2712  double THETA_MCID; /* JP-370 */
2713  double ZOFFS; /* JP-371 */
2714  double T[3]; /* JP-372 */
2715  int Tnumber;
2716  int order;
2717  int conv_table[] = {1, 2, 3, 5, 6, 4};
2718  unsigned int node[G_NUMBER];
2719 
2720  char format[] = "UUU6dd_3d3";
2721  int result[BULK_PARAM_NUMBER];
2722 
2723  T[0] = T[1] = T[2] = 0.0;
2724 
2725  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &PID, "PID", G,
2726  "G", &THETA_MCID, "THETA/MCID", &ZOFFS, "ZOFFS", T,
2727  "T");
2728 
2729  /* JP-373 */
2730 
2731  if (result[BULK_PARAM_NUMBER - 3] == 1 &&
2732  result[BULK_PARAM_NUMBER - 2] == 1 && result[BULK_PARAM_NUMBER - 1] == 1)
2733  Tnumber = 3;
2734  else
2735  Tnumber = 0;
2736 
2737  for (i = 0; i < G_NUMBER; i++) node[i] = G[conv_table[i] - 1];
2738 
2739  if (surface_elem_store(BULK_TYPE_CTRIA6, EID, PID, node, G_NUMBER, THETA_MCID,
2740  ZOFFS, T, Tnumber))
2741  return -1;
2742 
2743  return 0;
2744 
2745 #undef BULK_PARAM_NUMBER
2746 #undef G_NUMBER
2747 }
2748 
2749 /* ------------------------------------------------------------------------------------------------
2750  */
2751 
2752 /* JP-374 */
2753 
2754 static int iff_bulk_parse_CQUAD4(iff_bulk_t* bulk) {
2755  int i;
2756 
2757 #define G_NUMBER 4
2758 #define T_NUMBER 4
2759 #define BULK_PARAM_NUMBER (2 + G_NUMBER + 2 + T_NUMBER)
2760 
2761  unsigned int EID; /* JP-375 */
2762  unsigned int PID; /* JP-376 */
2763  unsigned int G[G_NUMBER]; /* JP-377 */
2764  double THETA_MCID; /* JP-378 */
2765  double ZOFFS; /* JP-379 */
2766  double T[T_NUMBER]; /* JP-380 */
2767  int Tnumber;
2768  int order;
2769 
2770  char format[] = "UUU4dd_2d4";
2771  int result[BULK_PARAM_NUMBER];
2772 
2773  T[0] = T[1] = T[2] = T[3] = 0.0;
2774 
2775  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &PID, "PID", G,
2776  "G", &THETA_MCID, "THETA/MCID", &ZOFFS, "ZOFFS", T,
2777  "T");
2778 
2779  /* JP-381 */
2780 
2781  if (result[BULK_PARAM_NUMBER - 4] == 1 &&
2782  result[BULK_PARAM_NUMBER - 3] == 1 &&
2783  result[BULK_PARAM_NUMBER - 2] == 1 && result[BULK_PARAM_NUMBER - 1] == 1)
2784  Tnumber = T_NUMBER;
2785  else
2786  Tnumber = 0;
2787 
2788  if (surface_elem_store(BULK_TYPE_CQUAD4, EID, PID, G, G_NUMBER, THETA_MCID,
2789  ZOFFS, T, Tnumber))
2790  return -1;
2791 
2792  return 0;
2793 
2794 #undef BULK_PARAM_NUMBER
2795 #undef G_NUMBER
2796 #undef T_NUMBER
2797 }
2798 
2799 /* ------------------------------------------------------------------------------------------------
2800  */
2801 /* JP-382 */
2802 
2803 static int iff_bulk_parse_CQUAD8(iff_bulk_t* bulk) {
2804  int i;
2805 
2806 #define G_NUMBER 8
2807 #define T_NUMBER 4
2808 #define BULK_PARAM_NUMBER (2 + G_NUMBER + T_NUMBER + 2)
2809 
2810  unsigned int EID; /* JP-383 */
2811  unsigned int PID; /* JP-384 */
2812  unsigned int G[G_NUMBER]; /* JP-385 */
2813  double T[T_NUMBER]; /* JP-386 */
2814  double THETA_MCID; /* JP-387 */
2815  double ZOFFS; /* JP-388 */
2816  int Tnumber;
2817  int order;
2818 
2819  char format[] = "UUU8d4dd";
2820  int result[BULK_PARAM_NUMBER];
2821 
2822  T[0] = T[1] = T[2] = T[3] = 0.0;
2823 
2824  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &PID, "PID", G,
2825  "G", T, "T", &THETA_MCID, "THETA/MCID", &ZOFFS,
2826  "ZOFFS");
2827 
2828  /* JP-389 */
2829 
2830  if (result[BULK_PARAM_NUMBER - 4] == 1 &&
2831  result[BULK_PARAM_NUMBER - 3] == 1 &&
2832  result[BULK_PARAM_NUMBER - 2] == 1 && result[BULK_PARAM_NUMBER - 1] == 1)
2833  Tnumber = T_NUMBER;
2834  else
2835  Tnumber = 0;
2836 
2837  if (surface_elem_store(BULK_TYPE_CQUAD8, EID, PID, G, G_NUMBER, THETA_MCID,
2838  ZOFFS, T, Tnumber))
2839  return -1;
2840 
2841  return 0;
2842 
2843 #undef BULK_PARAM_NUMBER
2844 #undef G_NUMBER
2845 #undef T_NUMBER
2846 }
2847 
2848 /* JP-390 */
2849 /*
2850 */
2851 /* ------------------------------------------------------------------------------------------------
2852  */
2853 /* JP-391 */
2854 
2855 static int iff_bulk_parse_solid_elem(iff_bulk_t* bulk, int first_etype,
2856  int second_etype, int conv_table[],
2857  int g_number, int g_ness_number) {
2858 #define G_LIST_SIZE 100
2859 #define BULK_PARAM_LIST_SIZE (2 + G_LIST_SIZE)
2860 
2861  unsigned int EID; /* JP-392 */
2862  unsigned int PID; /* JP-393 */
2863 
2864  unsigned int G[G_LIST_SIZE];
2865  unsigned int node[G_LIST_SIZE];
2866 
2867  int order; /* JP-394 */
2868  int i;
2869 
2870  char format[20];
2871  int result[BULK_PARAM_LIST_SIZE];
2872 
2873  char grp_name[HECMW_NAME_LEN + 1];
2874  int EID_List[1];
2875 
2876  snprintf(format, sizeof(format), "UUU%d/%d", g_number, g_ness_number);
2877 
2878  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &PID, "PID", G,
2879  "G");
2880 
2881  order = check_order_of_elem(result, 2, g_number, g_ness_number);
2882 
2883  /* JP-395 */
2884 
2885  for (i = 0; i < g_number; i++) node[i] = G[conv_table[i] - 1];
2886 
2887  if (order == 1) {
2888  if (HECMW_io_add_elem(EID, first_etype, (int*)node, 0, NULL) == NULL)
2889  return -1;
2890  } else if (order == 2) {
2891  if (HECMW_io_add_elem(EID, second_etype, (int*)node, 0, NULL) == NULL)
2892  return -1;
2893  } else
2894  return -1;
2895 
2896  /* JP-396 */
2897 
2898  EID_List[0] = EID;
2899  if (HECMW_io_add_egrp(egrp_name_by_PID(PID, grp_name, sizeof(grp_name)), 1, EID_List) == -1)
2900  return -1;
2901 
2902  if (HECMW_io_add_egrp("ALL", 1, EID_List) == -1) return -1;
2903 
2904  return 0;
2905 
2906 #undef G_LIST_SIZE
2907 #undef BULK_PARAM_LIST_SIZE
2908 }
2909 
2910 /* ------------------------------------------------------------------------------------------------
2911  */
2912 /* JP-397 */
2913 
2914 static int iff_bulk_parse_CTETRA(iff_bulk_t* bulk) {
2915  int conv_table[] = {1, 2, 3, 4, 6, 7, 5, 8, 9, 10};
2916  return iff_bulk_parse_solid_elem(bulk, HECMW_ETYPE_TET1, HECMW_ETYPE_TET2,
2917  conv_table, 10, 4);
2918 }
2919 
2920 /* ------------------------------------------------------------------------------------------------
2921  */
2922 /* JP-398 */
2923 
2924 static int iff_bulk_parse_CPENTA(iff_bulk_t* bulk) {
2925  int conv_table[] = {1, 2, 3, 4, 5, 6, 8, 9, 7, 14, 15, 13, 10, 11, 12};
2926  return iff_bulk_parse_solid_elem(bulk, HECMW_ETYPE_PRI1, HECMW_ETYPE_PRI2,
2927  conv_table, 15, 6);
2928 }
2929 
2930 /* ------------------------------------------------------------------------------------------------
2931  */
2932 /* JP-399 */
2933 
2934 static int iff_bulk_parse_CHEXA(iff_bulk_t* bulk) {
2935  int conv_table[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
2936  11, 12, 17, 18, 19, 20, 13, 14, 15, 16};
2937  return iff_bulk_parse_solid_elem(bulk, HECMW_ETYPE_HEX1, HECMW_ETYPE_HEX2,
2938  conv_table, 20, 8);
2939 }
2940 
2941 /* JP-400 */
2942 /*
2943 */
2944 /* ------------------------------------------------------------------------------------------------
2945  */
2946 /* JP-401 */
2947 
2948 static int iff_bulk_parse_CTRIAX6(iff_bulk_t* bulk) {
2949 #define G_NUMBER 6
2950 #define BULK_PARAM_NUMBER (2 + G_NUMBER + 1)
2951 
2952  int i;
2953  int conv_table[] = {1, 3, 5, 4, 6, 2};
2954 
2955  unsigned int EID; /* JP-402 */
2956  unsigned int MID; /* JP-403 */
2957  unsigned int G[G_NUMBER];
2958  double TH = 0.0; /* JP-404 */
2959 
2960  unsigned int node[G_NUMBER];
2961 
2962  char format[20] = "UUU6d";
2963  int result[BULK_PARAM_NUMBER];
2964 
2965  iff_bulk_get_param_list(bulk, format, result, &EID, "EID", &MID, "MID", G,
2966  "G", &TH, "TH");
2967 
2968  /* JP-405 */
2969 
2970  for (i = 0; i < G_NUMBER; i++) node[i] = G[conv_table[i] - 1];
2971 
2972  if (HECMW_io_add_elem(EID, HECMW_ETYPE_TRI2, (int*)node, 0, NULL) == NULL)
2973  return -1;
2974 
2975  /* JP-406 */
2976 
2977  {
2978  struct hecmw_io_egrp* egrp;
2979  char grp_name[HECMW_NAME_LEN + 1];
2980  int EID_List[1];
2981 
2982  egrp_CTRIAX6_name_by_MID(MID, grp_name, sizeof(grp_name));
2983  egrp = HECMW_io_get_egrp(grp_name);
2984 
2985  if (!egrp) { /* JP-407 */
2986  char mat_name[HECMW_NAME_LEN + 1];
2987  struct hecmw_io_section sect;
2988  snprintf(sect.egrp, sizeof(sect.egrp), "%s", grp_name);
2989  snprintf(sect.material, sizeof(sect.material), "%s", matrial_name_by_MID(MID, mat_name, sizeof(mat_name)));
2990  sect.composite = 1; /* JP-408 */
2991  sect.secopt = HECMW_SECT_OPT_ASYMMETRY; /* JP-409 */
2992  sect.type = HECMW_SECT_TYPE_SOLID;
2993  sect.sect.solid.thickness = 1; /* JP-410 */
2994  sect.next = NULL;
2995  if (HECMW_io_add_sect(&sect) == NULL) return -1;
2996  }
2997 
2998  /* JP-411 */
2999 
3000  EID_List[0] = EID;
3001  if (HECMW_io_add_egrp(grp_name, 1, EID_List) == -1) return -1;
3002 
3003  if (HECMW_io_add_egrp("ALL", 1, EID_List) == -1) return -1;
3004  }
3005  return 0;
3006 
3007 #undef G_NUMBER
3008 #undef BULK_PARAM_NUMBER
3009 }
3010 
3011 /* JP-412 */
3012 
3013 static int iff_bulk_parse_GRID(iff_bulk_t* bulk) {
3014 #define BULK_PARAM_NUMBER 8
3015 
3016  unsigned int ID = 0; /* JP-413 */
3017  unsigned int CP = 0; /* JP-414 */
3018  double X[3]; /* JP-415 */
3019  unsigned int CDI = 0; /* JP-416 */
3020  unsigned int PS = 0; /* JP-417 */
3021  unsigned int SEID; /* JP-418 */
3022 
3023  char format[] = "UUD3uuu";
3024  int result[BULK_PARAM_NUMBER];
3025 
3026  int ID_List[1];
3027 
3028  X[0] = X[1] = X[2] = 0.0;
3029 
3030  iff_bulk_get_param_list(bulk, format, result, &ID, "ID", &CP, "CP", X, "X",
3031  &CDI, "CDI", &PS, "PS", &SEID, "SEID");
3032 
3033  /* JP-419 */
3034 
3035  if (HECMW_io_add_node(ID, X[0], X[1], X[2]) == NULL) /* JP-420 */
3036  return -1;
3037 
3038  ID_List[0] = ID;
3039  if (HECMW_io_add_ngrp("ALL", 1, ID_List) == -1) return -1;
3040 
3041 #undef BULK_PARAM_NUMBER
3042  return 0;
3043 }
3044 
3045 /* JP-421 */
3046 
3047 /* ------------------------------------------------------------------------------------------------
3048  */
3049 /*
3050  Nastran Quick Reference P.703
3051 */
3052 
3053 static int iff_bulk_parse_INCLUDE(iff_bulk_t* bulk) {
3054  int i;
3055  char buff[IFF_SIZE];
3056  char* iff;
3057  iff_node_t* node;
3058  char filename[HECMW_FILENAME_LEN + 1];
3059  char *p, *bp;
3060  int fg;
3061  int errcode;
3062 
3063  /* JP-422 */
3064 
3065  node = bulk->iff_node_root;
3066  HECMW_assert(node);
3067 
3068  iff = node->iff;
3069 
3070  buff[0] = 0;
3071  for (i = 0; i < FIELD_NUMBER; i++) {
3072  strncat(buff, iff_get_field(iff, i), sizeof(buff) - strlen(buff) - 1);
3073  }
3074 
3075  /* JP-423 */
3076 
3077  bp = buff;
3078  p = filename;
3079  fg = 0;
3080  while (*bp) {
3081  if (fg) {
3082  if (*bp == '\'') {
3083  *p = 0;
3084  goto NEXT;
3085  }
3086  *p = *bp;
3087  p++;
3088  } else if (*bp == '\'') {
3089  fg = 1;
3090  }
3091  bp++;
3092  }
3093 
3094  /* JP-424 */
3095  return -1;
3096 
3097 NEXT:
3098 
3099  /* JP-425 */
3100 
3101  printf("Include %s ==================================\n", filename);
3102 
3103  errcode = nastran_file_open(filename);
3104  return errcode;
3105 }
3106 
3107 /* bulk_list.c */
3108 
3109 /* JP-426 */
3110 
3111 /* ------------------------------------------------------------------------------------------------
3112  */
3113 /* JP-427 */
3114 
3115 static void iff_bulk_list_init(iff_bulk_list_t* bulk_list) {
3116  bulk_list->bulk_root = NULL;
3117  bulk_list->bulk_number = 0;
3118 }
3119 
3120 /* JP-428 */
3121 
3122 static void iff_bulk_list_clear(iff_bulk_list_t* bulk_list) {
3123  iff_bulk_t* node = bulk_list->bulk_root;
3124  iff_bulk_t* next;
3125 
3126  while (node) {
3127  next = node->next_bulk;
3128  iff_bulk_free(node);
3129  node = next;
3130  }
3131  bulk_list->bulk_root = NULL;
3132  bulk_list->bulk_number = 0;
3133 }
3134 
3135 /* ------------------------------------------------------------------------------------------------
3136  */
3137 /* JP-429 */
3138 
3139 static int iff_bulk_list_is_empty(iff_bulk_list_t* list) {
3140  return (list->bulk_root == NULL);
3141 }
3142 
3143 /* ------------------------------------------------------------------------------------------------
3144  */
3145 /* JP-430 */
3146 
3147 static void iff_bulk_list_regist(iff_bulk_list_t* bulk_list, iff_bulk_t* bulk) {
3148  if (bulk_list->bulk_root == NULL) {
3149  bulk_list->bulk_root = bulk;
3150  } else {
3151  bulk->next_bulk = bulk_list->bulk_root;
3152  bulk_list->bulk_root = bulk;
3153  }
3154  bulk_list->bulk_number++;
3155 }
3156 
3157 /* ------------------------------------------------------------------------------------------------
3158  */
3159 /* JP-431 */
3160 
3161 static iff_bulk_t* iff_bulk_list_search_pointing_bulk(
3162  iff_bulk_list_t* bulk_list, char* line_pointer) {
3163  iff_bulk_t* node = bulk_list->bulk_root;
3164 
3165  while (node) {
3166  if (iff_bulk_search_pointing_line(node, line_pointer)) return node;
3167  node = node->next_bulk;
3168  }
3169 
3170  return NULL;
3171 }
3172 
3173 /* ------------------------------------------------------------------------------------------------
3174  */
3175 /* JP-432 */
3176 
3177 static iff_bulk_t* iff_bulk_list_search_continuous_bulk(
3178  iff_bulk_list_t* bulk_list, char* line_pointer) {
3179  iff_bulk_t* node = bulk_list->bulk_root;
3180 
3181  while (node) {
3182  if (iff_bulk_search_continuous_line(node, line_pointer)) return node;
3183  node = node->next_bulk;
3184  }
3185 
3186  return NULL;
3187 }
3188 
3189 /* ------------------------------------------------------------------------------------------------
3190  */
3191 /* JP-433 */
3192 /* JP-434 */
3193 
3194 static int iff_bulk_list_remove(iff_bulk_list_t* bulk_list, iff_bulk_t* bulk) {
3195  iff_bulk_t *prev, *node;
3196  node = bulk_list->bulk_root;
3197  prev = NULL;
3198 
3199  while (node) {
3200  if (node == bulk) {
3201  if (prev)
3202  prev->next_bulk = node->next_bulk;
3203  else {
3204  bulk_list->bulk_root = node->next_bulk;
3205  }
3206  node->next_bulk = NULL;
3207  bulk_list->bulk_number--;
3208  return 1;
3209  }
3210  prev = node;
3211  node = node->next_bulk;
3212  }
3213 
3214  return 0;
3215 }
3216 
3217 /* ------------------------------------------------------------------------------------------------
3218  */
3219 /* JP-435 */
3220 
3221 #define TRYAL_NUMBER 20
3222 
3223 static int iff_bulk_list_after_operation(iff_bulk_list_t* bulk_list) {
3224  int bulk_number = bulk_list->bulk_number;
3225  iff_bulk_t* bulk;
3226  int counter = 0;
3227 
3228  while (!iff_bulk_list_is_empty(bulk_list)) {
3229  bulk = bulk_list->bulk_root;
3230  while (bulk) {
3231  iff_bulk_t* next_bulk = bulk->next_bulk;
3232  if (iff_bulk_is_completed(bulk)) {
3233  if (iff_bulk_parse(bulk)) {
3234  iff_bulk_list_remove(bulk_list, bulk);
3235  iff_bulk_free(bulk);
3236  }
3237  } else {
3238  /* JP-436 */ /* JP-437 */
3239  return -1;
3240  }
3241  bulk = next_bulk;
3242  }
3243  if (bulk_number == bulk_list->bulk_number) { /* JP-438 */
3244  /* JP-439 */
3245  return -1;
3246  }
3247  bulk_number = bulk_list->bulk_number;
3248  counter++;
3249  if (counter == TRYAL_NUMBER) {
3250  /* JP-440 */
3251  return -1;
3252  }
3253  }
3254 
3255  return 0;
3256 }
3257 
3258 /* ------------------------------------------------------------------------------------------------
3259  */
3260 /* JP-441 */
3261 
3262 static void iff_bulk_list_dump(iff_bulk_list_t* bulk_list) {
3263  iff_bulk_t* node = bulk_list->bulk_root;
3264 
3265  printf(" Bulk List Dump ==============\n");
3266 
3267  while (node) {
3268  iff_bulk_dump(node);
3269  node = node->next_bulk;
3270  printf("==============\n");
3271  }
3272 }
3273 
3274 /* iff_operation.c */
3275 
3276 /* JP-442 */
3277 
3278 /* JP-443 */
3279 
3280 /* =================================================================================================================
3281  */
3282 
3283 static int iff_operation(iff_bulk_list_t* bulk_list, char* iff, int line_no) {
3284  iff_bulk_t* bulk1 = NULL;
3285  iff_bulk_t* bulk2 = NULL;
3286  char* pointer;
3287 
3288  if (iff_is_parent(iff)) {
3289  bulk1 = iff_bulk_create();
3290  iff_bulk_regist(bulk1, iff, line_no);
3291  iff_bulk_list_regist(bulk_list, bulk1);
3292  } else if (iff_is_continuous_line(iff)) {
3293  bulk1 = iff_bulk_list_search_pointing_bulk(
3294  bulk_list, iff_get_continuous_line_pointer(iff));
3295  if (bulk1) {
3296  iff_bulk_regist(bulk1, iff, line_no);
3297  } else {
3298  bulk1 = iff_bulk_create();
3299  iff_bulk_regist(bulk1, iff, line_no);
3300  iff_bulk_list_regist(bulk_list, bulk1);
3301  }
3302  } else {
3303  HECMW_assert(0);
3304  }
3305 
3306  if (iff_is_pointing_line(iff)) {
3307  pointer = iff_get_pointing_line_pointer(iff);
3308  bulk2 = iff_bulk_list_search_continuous_bulk(bulk_list, pointer);
3309  if (bulk2) {
3310  iff_bulk_move_append(bulk1, bulk2);
3311  iff_bulk_list_remove(bulk_list, bulk2);
3312  iff_bulk_free(bulk2);
3313  }
3314  }
3315 
3316  if (iff_bulk_is_completed(bulk1)) {
3317  int rcode = iff_bulk_parse(bulk1);
3318  iff_bulk_list_remove(bulk_list, bulk1);
3319  iff_bulk_free(bulk1);
3320  return rcode;
3321  }
3322 
3323  return 0;
3324 }
3325 
3326 /* f_open_close.c */
3327 
3328 /* JP-444 */
3329 
3330 /* JP-445 */
3331 
3332 /* JP-446 */
3333 
3334 static void file_stack_init() { file_stack_pos = 0; }
3335 
3336 /* ------------------------------------------------------------------------------------------------
3337  */
3338 /* JP-447 */
3339 
3340 static int file_stack_push(char* fname, FILE* fp, int lineno) {
3341  if (file_stack_pos >= FILE_STACK_SIZE) {
3342  /* JP-448 */
3343  return -1;
3344  }
3345 
3346  file_stack[file_stack_pos].fp = fp;
3347  snprintf(file_stack[file_stack_pos].filename, sizeof(file_stack[file_stack_pos].filename), "%s", fname);
3348  file_stack[file_stack_pos].lineno = lineno;
3349 
3350  file_stack_pos++;
3351  return 0;
3352 }
3353 
3354 /* ------------------------------------------------------------------------------------------------
3355  */
3356 /* JP-449 */
3357 
3358 static int file_stack_pop(char* fname, size_t fname_len, FILE** fp, int* lineno) {
3359  if (file_stack_pos <= 0) {
3360  /* JP-450 */
3361  return -1;
3362  }
3363 
3364  file_stack_pos--;
3365 
3366  *fp = file_stack[file_stack_pos].fp;
3367  snprintf(fname, fname_len, "%s", file_stack[file_stack_pos].filename);
3368  *lineno = file_stack[file_stack_pos].lineno;
3369 
3370  return 0;
3371 }
3372 
3373 /* ------------------------------------------------------------------------------------------------
3374  */
3375 /* JP-451 */
3376 
3377 static int file_stack_clear() {
3378  int i;
3379  int fg;
3380 
3381  for (i = 0; i < file_stack_pos; i++) {
3382  fclose(file_stack[i].fp);
3383  }
3384 
3385  fg = (file_stack_pos != 0);
3386  file_stack_pos = 0;
3387 
3388  return fg;
3389 }
3390 
3391 /* ------------------------------------------------------------------------------------------------
3392  */
3393 /* JP-452 */
3394 
3395 static int file_stack_check(const char* fname) {
3396  int i;
3397  for (i = 0; i < file_stack_pos; i++) {
3398  if (strcmp(fname, file_stack[i].filename) == 0) return -1;
3399  }
3400  return 0;
3401 }
3402 
3403 /* JP-453 */
3404 /* JP-454 */
3405 
3406 /* ------------------------------------------------------------------------------------------------
3407  */
3408 /* JP-455 */
3409 
3410 static void nastran_file_init() {
3411  c_fp = 0;
3412  c_filename[0] = 0;
3413  c_lineno = 0;
3414 
3415  file_stack_init();
3416 }
3417 
3418 /* ------------------------------------------------------------------------------------------------
3419  */
3420 /* JP-456 */
3421 
3422 static int nastran_file_open(const char* filename) {
3423  FILE* fp;
3424 
3425  if (file_stack_check(filename)) {
3426  /* JP-457 */
3427  printf("???顼??¿?Å¥????×¥????褦?Ȥ???\n");
3428  return -1;
3429  }
3430 
3431  fp = fopen(filename, "r");
3432 
3433  if (!fp) {
3434  /* JP-458 */
3435  /* HECMW_set_error(HECMW_IO_NASTRAN_XXXX, "File: %s, %s", filename,
3436  * strerror(errno)); */
3437  return -1;
3438  }
3439 
3440  if (c_fp) {
3441  if (file_stack_push(c_filename, c_fp, c_lineno)) { /* JP-459 */
3442  /* JP-460 */
3443  /* HECMW_set_error(HECMW_IO_NASTRAN_XXXX, "File: %s, %s", filename,
3444  * strerror(errno)); */
3445  return -1;
3446  }
3447  }
3448 
3449  c_fp = fp;
3450  snprintf(c_filename, sizeof(c_filename), "%s", filename);
3451  c_lineno = 0;
3452 
3453  HECMW_io_set_gridfile((char*)filename);
3454 
3455  return 0;
3456 }
3457 
3458 /* ------------------------------------------------------------------------------------------------
3459  */
3460 /* JP-461 */
3461 
3462 static int nastran_file_close() {
3463  if (!c_fp) {
3464  /* JP-462 */
3465  return -1;
3466  }
3467 
3468  if (fclose(c_fp)) {
3469  /* JP-463 */
3470  /* HECMW_set_error(HECMW_IO_HEC_E0002, "File: %s, %s", filename,
3471  * strerror(errno)); */
3472  return -1;
3473  }
3474 
3475  if (file_stack_pop(c_filename, sizeof(c_filename), &c_fp, &c_lineno)) {
3476  HECMW_io_set_gridfile("Unknown");
3477  c_fp = NULL;
3478  snprintf(c_filename, sizeof(c_filename), "%s", "Unknown");
3479  return 1;
3480  } else {
3481  return 0;
3482  }
3483 }
3484 
3485 /* read_nastran.c */
3486 
3487 /* JP-464 */
3488 /* JP-465 */
3489 
3490 /* ------------------------------------------------------------------------------------------------
3491  */
3492 /* JP-466 */
3493 
3494 /* JP-467 */
3495 
3496 static int read_nastran(const char* filename) {
3497  /* JP-468 */
3498 
3499  int end_fg;
3500  int read_fg;
3501  int next_read_fg;
3502 
3503  char iff_buff1[IFF_SIZE];
3504  char iff_buff2[IFF_SIZE];
3505 
3506  char* iff1;
3507  char* iff2;
3508  char* temp;
3509 
3510  int iff1_lineno;
3511 
3512  iff_bulk_list_t bulk_list;
3513  int bulk_number;
3514 
3515  int auto_pointer_counter = 1;
3516 
3517  iff_bulk_list_init(&bulk_list);
3518 
3519  if (nastran_file_open(filename)) return -1;
3520 
3521  skip_to_begin_bulk(c_fp, &c_lineno); /* JP-469 */
3522 
3523  iff1 = iff_buff1;
3524  iff2 = iff_buff2;
3525 
3526  read_fg = read_iff(c_fp, iff1, &c_lineno);
3527 
3528  iff1_lineno = c_lineno;
3529 
3530  end_fg = 1;
3531 
3532  while (end_fg) {
3533  next_read_fg = read_iff(c_fp, iff2, &c_lineno);
3534  switch (next_read_fg) {
3535  case read_iff_success:
3536  if (iff_add_auto_pointer(iff1, iff2, &auto_pointer_counter)) return -1;
3537  break;
3538  case read_iff_comment:
3539  continue;
3540  }
3541  switch (read_fg) {
3542  case read_iff_success:
3543  iff_operation(&bulk_list, iff1, iff1_lineno); /* JP-470 */
3544  break;
3545  case read_iff_error:
3546  return -1;
3547  break;
3548  case read_iff_comment:
3549  break;
3550  case read_iff_eof:
3551  if (nastran_file_close() != 0) end_fg = 0;
3552  }
3553 
3554  temp = iff1;
3555  iff1 = iff2;
3556  iff2 = temp;
3557  iff1_lineno = c_lineno;
3558  read_fg = next_read_fg;
3559  }
3560 
3561  iff_bulk_list_after_operation(&bulk_list);
3562 
3563  iff_bulk_list_clear(&bulk_list);
3564 
3565  return 0;
3566 }
3567 /* read_file.c */
3568 
3569 /* JP-471 */
3570 
3571 int HECMW_read_nastran_mesh(const char* filename) {
3572  /* -----------------------------------
3573 
3574  HECMW_log(HECMW_LOG_DEBUG, "Start to read NASTRAN mesh");
3575 
3576  if(filename == NULL) {
3577  HECMW_set_error(HECMW_IO_E0001, "Not specified filename for NASTRAN
3578  mesh input routine");
3579  return -1;
3580  }
3581  HECMW_log(HECMW_LOG_DEBUG, "NASTRAN mesh file is '%s'", filename);
3582 
3583  if(strlen(filename) > HECMW_FILENAME_LEN) {
3584  HECMW_set_error(HECMW_IO_E0002, "");
3585  return -1;
3586  }
3587 
3588  snprintf(grid_filename, sizeof(grid_filename), "%s", filename);
3589  HECMW_io_set_gridfile(grid_filename);
3590 
3591  ---------------------------------------- */
3592 
3593  nastran_file_init();
3594  section_list_init();
3595 
3596  if (read_nastran(filename)) return -1;
3597 
3598  if (surface_elem_type_decide()) return -1;
3599  if (section_list_finalize()) return -1;
3600 
3601  HECMW_io_set_gridfile((char*)filename);
3602 
3603  return 0;
3604 }
3605 
3606 /* ------------------------------------------------------------------------------------------------
3607  */
3608 
3609 struct hecmwST_local_mesh* HECMW_get_nastran_mesh(const char* filename) {
3610  struct hecmwST_local_mesh* local_mesh;
3611 
3612  if (HECMW_io_init()) return NULL;
3613  if (HECMW_io_pre_process()) return NULL;
3614  if (HECMW_read_nastran_mesh(filename)) return NULL;
3615  if (HECMW_io_post_process()) return NULL;
3616  local_mesh = HECMW_io_make_local_mesh();
3617  if (local_mesh == NULL) return NULL;
3618  if (HECMW_io_finalize()) return NULL;
3619 
3620  snprintf(grid_filename, sizeof(grid_filename), "%s", "Unknown");
3621 
3622  return local_mesh;
3623 }
line_no
int line_no
Definition: fstr_ctrl_util.c:86
hecmw_common.h
HECMW_ETYPE_PRI1
#define HECMW_ETYPE_PRI1
Definition: hecmw_common_define.h:29
HECMW_ETYPE_PRI2
#define HECMW_ETYPE_PRI2
Definition: hecmw_common_define.h:30
HECMW_ETYPE_QUA2
#define HECMW_ETYPE_QUA2
Definition: hecmw_common_define.h:23
HECMW_ETYPE_SHQ1
#define HECMW_ETYPE_SHQ1
Definition: hecmw_common_define.h:51
HECMW_ETYPE_SHT1
#define HECMW_ETYPE_SHT1
Definition: hecmw_common_define.h:49
HECMW_ETYPE_TET2
#define HECMW_ETYPE_TET2
Definition: hecmw_common_define.h:27
HECMW_ETYPE_SHT2
#define HECMW_ETYPE_SHT2
Definition: hecmw_common_define.h:50
HECMW_ETYPE_TRI1
#define HECMW_ETYPE_TRI1
Definition: hecmw_common_define.h:19
HECMW_ETYPE_HEX1
#define HECMW_ETYPE_HEX1
Definition: hecmw_common_define.h:31
HECMW_ETYPE_ROD1
#define HECMW_ETYPE_ROD1
Definition: hecmw_common_define.h:17
HECMW_ETYPE_QUA1
#define HECMW_ETYPE_QUA1
Definition: hecmw_common_define.h:22
HECMW_ETYPE_TET1
#define HECMW_ETYPE_TET1
Definition: hecmw_common_define.h:25
HECMW_ETYPE_HEX2
#define HECMW_ETYPE_HEX2
Definition: hecmw_common_define.h:33
HECMW_ETYPE_TRI2
#define HECMW_ETYPE_TRI2
Definition: hecmw_common_define.h:20
HECMW_ETYPE_SHQ2
#define HECMW_ETYPE_SHQ2
Definition: hecmw_common_define.h:52
hecmw_config.h
HECMW_FILENAME_LEN
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:74
HECMW_NAME_LEN
#define HECMW_NAME_LEN
Definition: hecmw_config.h:72
hecmw_conn_conv.h
hecmw_dist.h
hecmw_dist_print.h
HECMW_set_error
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:33
INCLUDE
#define INCLUDE
Definition: hecmw_heclex.c:1203
HECMW_io_get_egrp
struct hecmw_io_egrp * HECMW_io_get_egrp(const char *name)
Definition: hecmw_io_mesh.c:843
HECMW_io_add_ngrp
int HECMW_io_add_ngrp(const char *name, int nnode, int *node)
Definition: hecmw_io_mesh.c:1109
HECMW_io_add_sect
struct hecmw_io_section * HECMW_io_add_sect(struct hecmw_io_section *sect)
Definition: hecmw_io_mesh.c:1372
HECMW_io_get_elem_in_egrp
struct hecmw_io_id_array * HECMW_io_get_elem_in_egrp(const char *name)
Definition: hecmw_io_mesh.c:849
HECMW_io_add_egrp
int HECMW_io_add_egrp(const char *name, int nelem, int *elem)
Definition: hecmw_io_mesh.c:891
HECMW_io_get_elem
struct hecmw_io_element * HECMW_io_get_elem(int id)
Definition: hecmw_io_mesh.c:733
HECMW_io_add_mat
struct hecmw_io_material * HECMW_io_add_mat(const char *name, struct hecmw_io_material *mat)
Definition: hecmw_io_mesh.c:1418
HECMW_io_make_local_mesh
struct hecmwST_local_mesh * HECMW_io_make_local_mesh(void)
Definition: hecmw_io_mesh.c:4068
HECMW_io_init
int HECMW_io_init(void)
Definition: hecmw_io_mesh.c:4010
HECMW_io_add_elem
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
Definition: hecmw_io_mesh.c:768
HECMW_io_pre_process
int HECMW_io_pre_process(void)
Definition: hecmw_io_mesh.c:4038
HECMW_io_add_node
struct hecmw_io_node * HECMW_io_add_node(int id, double x, double y, double z)
Definition: hecmw_io_mesh.c:993
HECMW_io_post_process
int HECMW_io_post_process(void)
Definition: hecmw_io_mesh.c:4040
HECMW_io_set_gridfile
int HECMW_io_set_gridfile(char *gridfile)
Definition: hecmw_io_mesh.c:624
HECMW_io_finalize
int HECMW_io_finalize(void)
Definition: hecmw_io_mesh.c:4024
hecmw_io_mesh.h
FILE_STACK_SIZE
#define FILE_STACK_SIZE
Definition: hecmw_io_nastran.c:94
LARGE_FIELD_COLUMN
#define LARGE_FIELD_COLUMN
Definition: hecmw_io_nastran.c:42
iff_bulk_t
struct ST_IFF_BULK iff_bulk_t
NULL
#define NULL
Definition: hecmw_io_nastran.c:30
read_iff_success
#define read_iff_success
read_iff_comment
#define read_iff_comment
T_NUMBER
#define T_NUMBER
BULK_PARAM_NUMBER
#define BULK_PARAM_NUMBER
LARGE_FIELD_LINE_FIELD_NUMBER
#define LARGE_FIELD_LINE_FIELD_NUMBER
Definition: hecmw_io_nastran.c:43
file_stack_t
struct ST_FILE_STACK file_stack_t
iff_node_t
struct ST_IFF_NODE iff_node_t
G_NUMBER
#define G_NUMBER
cms_malloc
#define cms_malloc(p, size)
GPLP_PARAM_LIST_SIZE
#define GPLP_PARAM_LIST_SIZE
CTRIAX6_EGRP_NAME_HEADER
#define CTRIAX6_EGRP_NAME_HEADER
Definition: hecmw_io_nastran.c:648
read_iff_error
#define read_iff_error
IFF_FIELD_BUFFER_SIZE
#define IFF_FIELD_BUFFER_SIZE
Definition: hecmw_io_nastran.c:49
SMALL_FIELD_COLUMN
#define SMALL_FIELD_COLUMN
Definition: hecmw_io_nastran.c:41
IFF_SIZE
#define IFF_SIZE
Definition: hecmw_io_nastran.c:50
BULK_PARAM_LIST_SIZE
#define BULK_PARAM_LIST_SIZE
FIELD_NUMBER
#define FIELD_NUMBER
Definition: hecmw_io_nastran.c:36
read_iff_eof
#define read_iff_eof
IFF_FIELD_SIZE
#define IFF_FIELD_SIZE
Definition: hecmw_io_nastran.c:48
ENUM_FIELD_FORMAT
ENUM_FIELD_FORMAT
Definition: hecmw_io_nastran.c:80
fft_small_field_format
@ fft_small_field_format
Definition: hecmw_io_nastran.c:84
fft_free_field_format
@ fft_free_field_format
Definition: hecmw_io_nastran.c:83
fft_comment
@ fft_comment
Definition: hecmw_io_nastran.c:82
fft_large_field_format
@ fft_large_field_format
Definition: hecmw_io_nastran.c:85
fft_none
@ fft_none
Definition: hecmw_io_nastran.c:81
IFF_LAST_FIELD
#define IFF_LAST_FIELD
Definition: hecmw_io_nastran.c:52
GENERATE_CODE
#define GENERATE_CODE(name)
TRYAL_NUMBER
#define TRYAL_NUMBER
IFF_FIELD_NUMBER
#define IFF_FIELD_NUMBER
Definition: hecmw_io_nastran.c:47
BULK_TYPE_NUMBER
#define BULK_TYPE_NUMBER
G_LIST_SIZE
#define G_LIST_SIZE
REMOVE_CR_MAX_LINE
#define REMOVE_CR_MAX_LINE
Definition: hecmw_io_nastran.c:546
item_n
#define item_n
FIRST_FIELD_COLUMN
#define FIRST_FIELD_COLUMN
Definition: hecmw_io_nastran.c:39
field_format_t
enum ENUM_FIELD_FORMAT field_format_t
LAST_FIELD_COLUMN
#define LAST_FIELD_COLUMN
Definition: hecmw_io_nastran.c:40
CREATE_LIST_CODE
#define CREATE_LIST_CODE(type)
Definition: hecmw_io_nastran.c:369
iff_bulk_list_t
struct ST_IFF_BULK_LIST iff_bulk_list_t
hecmw_io_nastran.h
HECMW_get_nastran_mesh
struct hecmwST_local_mesh * HECMW_get_nastran_mesh(const char *filename)
Definition: hecmw_io_nastran_dummy.c:34
HECMW_read_nastran_mesh
int HECMW_read_nastran_mesh(const char *filename)
Definition: hecmw_io_nastran_dummy.c:26
hecmw_io_struct.h
HECMW_free
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
HECMW_malloc
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
HECMW_IO_HEC_E0001
#define HECMW_IO_HEC_E0001
Definition: hecmw_msgno.h:190
hecmw_path.h
hecmw_struct.h
HECMW_SECT_TYPE_SOLID
#define HECMW_SECT_TYPE_SOLID
Definition: hecmw_struct.h:15
HECMW_SECT_OPT_PSTRAIN
#define HECMW_SECT_OPT_PSTRAIN
Definition: hecmw_struct.h:22
HECMW_SECT_TYPE_SHELL
#define HECMW_SECT_TYPE_SHELL
Definition: hecmw_struct.h:16
HECMW_SECT_OPT_PSTRESS
#define HECMW_SECT_OPT_PSTRESS
Definition: hecmw_struct.h:21
HECMW_SECT_OPT_ASYMMETRY
#define HECMW_SECT_OPT_ASYMMETRY
Definition: hecmw_struct.h:23
hecmw_system.h
hecmw_util.h
HECMW_assert
#define HECMW_assert(cond)
Definition: hecmw_util.h:40
hecd_util::toupper
void toupper(char *s)
Definition: hecd_util.cpp:38
hecd_util::remove_cr
void remove_cr(char *s)
Definition: hecd_util.cpp:76
data
CNFData data
Definition: neu_reporter.cpp:18
ST_FILE_STACK
Definition: hecmw_io_nastran.c:96
ST_FILE_STACK::lineno
int lineno
Definition: hecmw_io_nastran.c:99
ST_FILE_STACK::filename
char filename[HECMW_FILENAME_LEN+1]
Definition: hecmw_io_nastran.c:98
ST_FILE_STACK::fp
FILE * fp
Definition: hecmw_io_nastran.c:97
ST_IFF_BULK_LIST
Definition: hecmw_io_nastran.c:73
ST_IFF_BULK_LIST::bulk_number
int bulk_number
Definition: hecmw_io_nastran.c:75
ST_IFF_BULK_LIST::bulk_root
iff_bulk_t * bulk_root
Definition: hecmw_io_nastran.c:74
ST_IFF_BULK
Definition: hecmw_io_nastran.c:64
ST_IFF_BULK::iff_node_last
iff_node_t * iff_node_last
Definition: hecmw_io_nastran.c:66
ST_IFF_BULK::file_no
int file_no
Definition: hecmw_io_nastran.c:67
ST_IFF_BULK::iff_node_root
iff_node_t * iff_node_root
Definition: hecmw_io_nastran.c:65
ST_IFF_BULK::next_bulk
struct ST_IFF_BULK * next_bulk
Definition: hecmw_io_nastran.c:68
ST_IFF_NODE
Definition: hecmw_io_nastran.c:56
ST_IFF_NODE::iff
char iff[IFF_SIZE]
Definition: hecmw_io_nastran.c:57
ST_IFF_NODE::line_no
int line_no
Definition: hecmw_io_nastran.c:58
ST_IFF_NODE::next
struct ST_IFF_NODE * next
Definition: hecmw_io_nastran.c:59
hecmw_io_egrp
Definition: hecmw_io_struct.h:52
hecmw_io_element
Definition: hecmw_io_struct.h:36
hecmw_io_element::type
int type
Definition: hecmw_io_struct.h:37
hecmw_io_element::node
int * node
Definition: hecmw_io_struct.h:38
hecmw_io_id_array
Definition: hecmw_io_struct.h:12
hecmw_io_id_array::id
int * id
Definition: hecmw_io_struct.h:14
hecmw_io_id_array::n
int n
Definition: hecmw_io_struct.h:13
hecmw_io_material
Definition: hecmw_io_struct.h:101
hecmw_io_material::next
struct hecmw_io_material * next
Definition: hecmw_io_struct.h:115
hecmw_io_material::item
struct hecmw_io_material::hecmw_io_matitem * item
hecmw_io_material::name
char name[HECMW_NAME_LEN+1]
Definition: hecmw_io_struct.h:102
hecmw_io_material::nitem
int nitem
Definition: hecmw_io_struct.h:103
hecmw_io_section::hecmw_io_section_item::hecmw_io_section_shell::thickness
double thickness
Definition: hecmw_io_struct.h:131
hecmw_io_section::hecmw_io_section_item::hecmw_io_section_shell::integpoints
int integpoints
Definition: hecmw_io_struct.h:132
hecmw_io_section::hecmw_io_section_item::hecmw_io_section_solid::thickness
double thickness
Definition: hecmw_io_struct.h:127
hecmw_io_section
Definition: hecmw_io_struct.h:118
hecmw_io_section::next
struct hecmw_io_section * next
Definition: hecmw_io_struct.h:150
hecmw_io_section::sect
union hecmw_io_section::hecmw_io_section_item sect
hecmwST_local_mesh
Definition: hecmw_struct.h:139
hecmw_io_section::hecmw_io_section_item::solid
struct hecmw_io_section::hecmw_io_section_item::hecmw_io_section_solid solid
hecmw_io_section::hecmw_io_section_item::shell
struct hecmw_io_section::hecmw_io_section_item::hecmw_io_section_shell shell