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