FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
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
56typedef struct ST_IFF_NODE {
58 int line_no; /* JP-17 */
61
62/* JP-18 */
63
64typedef struct ST_IFF_BULK {
67 int file_no; /* JP-20 */
70
71/* JP-21 */
72
73typedef struct ST_IFF_BULK_LIST {
77
78/* JP-22 */
79
80typedef enum ENUM_FIELD_FORMAT {
81 fft_none, /* JP-23 */
82 fft_comment, /* JP-24 */
85 fft_large_field_format /* JP-27 */
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
96typedef struct ST_FILE_STACK {
97 FILE* fp;
99 int lineno;
101
102static file_stack_t file_stack[FILE_STACK_SIZE];
103static int file_stack_pos;
104
105static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
106
107static FILE* c_fp = NULL;
108static char c_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
109static int c_lineno = 0;
110
111/* JP-29 */
112
113/* utils.c */
114
115/* JP-30 */
116static char* str_upr(char* s);
117
118/* JP-31 */
119static 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 */
125static 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 */
130static void remove_cr(char* line);
131
132/* JP-34 */
133static void skip_to_begin_bulk(FILE* fp, int* line_no);
134
135/* JP-35 */
136static char* ngrp_name_by_GID(int gid, char* name);
137
138/* JP-36 */
139static char* egrp_name_by_PID(int pid, char* name);
140
141/* JP-37 */
142static char* egrp_name_by_SID(int sid, char* name);
143
144/* JP-38 */
145static char* ngrp_name_by_SID_GID(int sid, int gid, char* name);
146
147/* JP-39 */
148static char* ngrp_name_by_SID(int sid, int sub_id, char* name);
149
150/* JP-40 */
151static char* matrial_name_by_MID(int mid, char* name);
152
153/* JP-41 */
154static char* egrp_CTRIAX6_name_by_MID(int mid, char* name);
155
156/* JP-42 */
157static int is_CTRIAX6_egrp_name(char* name, int* mid);
158
159/* ------------------------------------------------------------------------------------------------
160 */
161/* field_format_judge.c */
162
163/* JP-43 */
164static field_format_t field_format_judge(char* line);
165
166/* ------------------------------------------------------------------------------------------------
167 */
168/* iff.c */
169
170static void iff_init(char* iff); /* JP-44 */
171static void iff_clear(char* iff); /* JP-45 */
172static int iff_field_empty(char* field); /* JP-46 */
173static int iff_is_blank_field(char* iff, int no); /* JP-47 */
174static char* iff_get_field(char* iff, int no); /* JP-48 */
175static void iff_set_field(char* iff, int no, char* field); /* JP-49 */
176static void iff_regulize(char* iff); /* JP-50 */
177static void iff_copy(char* dest, char* src); /* JP-51 */
178static char* iff_get_continuous_line_pointer(char* iff); /* JP-52 */
179static char* iff_get_pointing_line_pointer(char* iff); /* JP-53 */
180
181static int iff_is_parent(char* iff); /* JP-54 */
182static int iff_is_last(char* iff); /* JP-55 */
183static int iff_is_continuous_line(char* iff); /* JP-56 */
184static int iff_is_pointing_line(char* iff); /* JP-57 */
185
186static int iff_add_auto_pointer(char* iff1, char* iff2,
187 int* counter); /* JP-58 */
188
189/* JP-59 */
190/* JP-60 */
191
192static int iff_field_to_int(char* field, int default_val, int* val); /* JP-61 */
193static int iff_field_to_uint(char* field, unsigned int default_val,
194 unsigned int* val); /* JP-62 */
195static int iff_field_to_double(char* field, double default_val,
196 double* val); /* JP-63 */
197static int iff_field_to_param(char* field, char type, void* param,
198 void** next_param_pos); /* JP-64 */
199
200/* JP-65 */
201
202static void iff_dump(char* iff);
203static void iff_dump_csv(char* iff);
204
205/* ------------------------------------------------------------------------------------------------
206 */
207/* iff_conv.c */
208
209static void free_to_iff_format(char* line, char* iff); /* JP-66 */
210static void small_to_iff_format(char* line, char* iff); /* JP-67 */
211static void large_to_iff_format(char* line1, char* line2,
212 char* iff); /* JP-68 */
213
214static char* get_fixed_token(char* src, char* token,
215 int field_size); /* JP-69 */
216
217/* ------------------------------------------------------------------------------------------------
218 */
219/* iff_node.c */
220
221static iff_node_t* iff_node_create(void); /* JP-70 */
222static void iff_node_free(iff_node_t* node); /* JP-71 */
223static void iff_node_init(iff_node_t* node); /* JP-72 */
224static 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 */
231static int read_iff(FILE* fp, char* iff, int* line_no);
232
233/* ------------------------------------------------------------------------------------------------
234 */
235/* bulk.c */
236
237static void iff_bulk_init(iff_bulk_t* bulk); /* JP-75 */
238
239/* JP-76 */
240
241static iff_bulk_t* iff_bulk_create(void); /* JP-77 */
242static void iff_bulk_free(iff_bulk_t* bulk); /* JP-78 */
243static void iff_bulk_regist(iff_bulk_t* bulk, char* iff,
244 int line_no); /* JP-79 */
245static void iff_bulk_move_append(iff_bulk_t* dest, iff_bulk_t* src); /* JP-80 */
246static int iff_bulk_is_completed(iff_bulk_t* bulk); /* JP-81 */
247static int iff_bulk_parse(iff_bulk_t* bulk); /* JP-82 */
248
249/* JP-83 */
250
251static char* iff_bulk_get_name(iff_bulk_t* bulk); /* JP-84 */
252static char* iff_bulk_get_field(iff_bulk_t* bulk, int field_no); /* JP-85 */
253static char* iif_bulk_get_param(iff_bulk_t* bulk, int param_no); /* JP-86 */
254static 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 */
258static int iff_bulk_get_param_list(iff_bulk_t* bulk, const char* format,
259 int* result, ...);
260
261/* JP-89 */
262static int iff_bulk_get_param_list_pattern(iff_bulk_t* bulk, const char* format,
263 int start_param_no, int* size, ...);
264
265static int iff_bulk_get_line_number(iff_bulk_t* bulk); /* JP-90 */
266static int iff_bulk_get_line_no(iff_bulk_t* bulk, int iff_pos); /* JP-91 */
267
268/* JP-92 */
269
270static iff_node_t* iff_bulk_search_pointing_line(
271 iff_bulk_t* bulk, char* line_pointer); /* JP-93 */
272static iff_node_t* iff_bulk_search_continuous_line(
273 iff_bulk_t* bulk, char* line_pointer); /* JP-94 */
274
275/* JP-95 */
276
277static void iff_bulk_dump(iff_bulk_t* bulk); /* JP-96 */
278
279/* ------------------------------------------------------------------------------------------------
280 */
281/* bulk_parse_head.c */
282
283static char* iff_bulk_get_name(iff_bulk_t* bulk); /* JP-97 */
284static char* iff_bulk_get_param(iff_bulk_t* bulk, int field_no); /* JP-98 */
285static int iff_bulk_type(const char* bulkname); /* JP-99 */
286
287/* JP-100 */
288static int iff_bulk_parse(iff_bulk_t* bulk);
289
290/* ------------------------------------------------------------------------------------------------
291 */
292/* bulk_parse.c */
293
294/* JP-101 */
295static struct hecmw_io_material* create_mat_struct(const char* name, int item_n,
296 int sub_n[], double data[]);
297
298/* JP-102 */
299static 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 */
304static 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
312static void iff_bulk_list_init(iff_bulk_list_t* list); /* JP-104 */
313static void iff_bulk_list_clear(iff_bulk_list_t* list); /* JP-105 */
314
315static int iff_bulk_list_is_empty(iff_bulk_list_t* list); /* JP-106 */
316
317/* JP-107 */
318static void iff_bulk_list_regist(iff_bulk_list_t* bulk_list,
319 iff_bulk_t* bulk); /* JP-108 */
320static iff_bulk_t* iff_bulk_list_search_pointing_bulk(
321 iff_bulk_list_t* bulk_list, char* line_pointer); /* JP-109 */
322static iff_bulk_t* iff_bulk_list_search_continuous_bulk(
323 iff_bulk_list_t* bulk_list, char* line_pointer); /* JP-110 */
324static int iff_bulk_list_remove(iff_bulk_list_t* bulk_list,
325 iff_bulk_t* bulk); /* JP-111 */
326
327/* JP-112 */
328static int iff_bulk_list_after_operation(iff_bulk_list_t* list);
329
330/* JP-113 */
331static void iff_bulk_list_dump(iff_bulk_list_t* bulk_list); /* JP-114 */
332
333/* ------------------------------------------------------------------------------------------------
334 */
335/* iff_operation.c */
336
337/* JP-115 */
338static 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 */
345static void file_stack_init(void); /* JP-117 */
346static int file_stack_push(char* fname, FILE* fp, int lineno); /* JP-118 */
347static int file_stack_pop(char* fname, FILE** fp, int* lineno); /* JP-119 */
348static int file_stack_clear(void); /* JP-120 */
349static int file_stack_check(const char* fname); /* JP-121 */
350
351/* JP-122 */
352static void nastran_file_init(void); /* JP-123 */
353static int nastran_file_open(const char* filename); /* JP-124 */
354static int nastran_file_close(void); /* JP-125 */
355
356/* ------------------------------------------------------------------------------------------------
357 */
358/* read_nastran.c */
359
360/* JP-126 */
361static 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
465static 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
478static 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
530static 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
549static 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
568static 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
581static 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
590static 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
599static 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
610static 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
620static 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
630static 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
640static 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
651static 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
660static 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
685static 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
711
712 while (p != line) {
713 p--;
714 if (*p != ' ') {
715 if (*p == '*')
717 else
719 }
720 }
721
723}
724
725/* iff.c */
726
727/* JP-153 */
728
729/* JP-154 */
730
731static void iff_init(char* iff) { iff_clear(iff); }
732
733/* ------------------------------------------------------------------------------------------------
734 */
735/* JP-155 */
736
737static void iff_clear(char* iff) { memset(iff, 0, IFF_SIZE); }
738
739/* ------------------------------------------------------------------------------------------------
740 */
741/* JP-156 */
742
743static int iff_field_empty(char* field) { return (field[0] == 0); }
744
745/* ------------------------------------------------------------------------------------------------
746 */
747/* JP-157 */
748
749static 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
758static 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
772static void iff_set_field(char* iff, int no, char* field) {
773 int i, fg;
774 char *start_p, *p, *s;
775
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
814static 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
868static void iff_copy(char* dest, char* src) { memcpy(dest, src, IFF_SIZE); }
869
870/* JP-170 */
871
872/* ------------------------------------------------------------------------------------------------
873 */
874/* JP-171 */
875
876static 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
886static 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
895static 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
913static 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
926static 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
935static 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
944static 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
962static 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
985static 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
1007static 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
1052static 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
1106static 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
1131static 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
1149static 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
1191static 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
1222static 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
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
1280static 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
1305static 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
1315static void iff_node_free(iff_node_t* node) { HECMW_free(node); }
1316
1317/* ------------------------------------------------------------------------------------------------
1318 */
1319/* JP-210 */
1320
1321static 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
1331static 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
1346static 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
1387static 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
1397static 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
1408static void iff_bulk_free(iff_bulk_t* bulk) {
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
1426static 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
1447static 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
1465static 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
1480static 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
1490static 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
1513static 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
1536static 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
1566static 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
1587static 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
1699static 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 }
1803END:
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
1816static 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
1832static 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
1848static 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
1872static 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
1894static 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
1918GENERATE_CODE(GRID)
1919GENERATE_CODE(MAT1)
1920GENERATE_CODE(MAT4)
1921GENERATE_CODE(PROD)
1922GENERATE_CODE(PSHELL)
1923GENERATE_CODE(PSOLID)
1924GENERATE_CODE(CROD)
1925GENERATE_CODE(CBAR)
1926GENERATE_CODE(CBEAM)
1927GENERATE_CODE(CTRIA3)
1928GENERATE_CODE(CTRIA6)
1929GENERATE_CODE(CQUAD4)
1930GENERATE_CODE(CQUAD8)
1931GENERATE_CODE(CTETRA)
1932GENERATE_CODE(CPENTA)
1933GENERATE_CODE(CHEXA)
1934GENERATE_CODE(CTRIAX6)
1936
1937#undef GENERATE_CODE
1938
1939#define GENERATE_CODE(name) BULK_TYPE_##name,
1940
1941enum {
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)
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
1957static char* bulk_type_name[] = {
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
1968static 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
1978static 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)
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
2024typedef struct ST_PSHELL_MID2 {
2025 int PID;
2026 int MID2;
2027 struct ST_PSHELL_MID2* next;
2028} pshell_mid2_t;
2029
2030typedef struct ST_PSHELLMID2_LIST { pshell_mid2_t* root; } pshell_mid2_list_t;
2031
2032static pshell_mid2_list_t pshell_mid2_list;
2033static int pshell_mid2_list_init_fg = 0;
2034
2035static void pshell_mid2_list_init(void);
2036static void pshell_mid2_list_clear(void);
2037static void pshell_mid2_list_regist(int pid, int mid2);
2038static int pshell_mid2_list_get_mid2_by_pid(int pid, int* mid2);
2039
2040/* JP-271 */
2041
2042static void pshell_mid2_list_init(void) {
2043 pshell_mid2_list.root = NULL;
2044 pshell_mid2_list_init_fg = 1;
2045}
2046
2047static 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
2059static 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
2080static 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
2097static 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
2125static 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
2179static 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
2239static 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
2300typedef struct hecmw_io_section section_rec;
2301
2302static void init_section_rec(section_rec* a) {
2303 memset(a, 0, sizeof(section_rec));
2304}
2305
2306CREATE_LIST_CODE(section_rec)
2307
2308static int is_eq_section_rec(section_rec a, section_rec b) {
2309 return (strcmp(a.egrp, b.egrp) == 0);
2310}
2311
2312static void copy_section_rec(section_rec* dest, section_rec src) {
2313 memcpy(dest, &src, sizeof(section_rec));
2314}
2315
2316static void delete_section_rec(section_rec a) { /* JP-306 */ }
2317
2318static t_list_section_rec section_list;
2319
2320/*---------------------------------------------*/
2321
2322/* JP-307 */
2323
2324static void section_list_init(void) { list_init_section_rec(&section_list); }
2325
2326/* JP-308 */
2327
2328static 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
2334static 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
2353static 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
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
2392static 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)
2433 else if (MID2 == -1)
2435
2436 if (MID2 == 0 || MID2 == -1)
2438 else
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
2465static 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
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
2519static 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
2553static int iff_bulk_parse_CBAR(iff_bulk_t* bulk) { return -1; }
2554
2555/* ------------------------------------------------------------------------------------------------
2556 */
2557/* JP-349 */
2558
2559static 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
2570static 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
2614static 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
2659static 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
2702static 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
2753static 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
2802static 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
2854static 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
2913static 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
2923static 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
2933static 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
2947static 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 */
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
3012static 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
3052static 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
3096NEXT:
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
3114static 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
3121static void iff_bulk_list_clear(iff_bulk_list_t* bulk_list) {
3122 iff_bulk_t* node = bulk_list->bulk_root;
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
3138static 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
3146static 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
3160static 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
3176static 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
3193static 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
3222static 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
3261static 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
3282static 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
3333static void file_stack_init() { file_stack_pos = 0; }
3334
3335/* ------------------------------------------------------------------------------------------------
3336 */
3337/* JP-447 */
3338
3339static 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
3357static 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
3376static 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
3394static 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
3409static 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
3421static 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
3461static 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
3495static 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
3570int 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
3608struct 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}
int line_no
#define INCLUDE
Definition: hecmw_ablex.c:1126
#define HECMW_ETYPE_PRI1
#define HECMW_ETYPE_PRI2
#define HECMW_ETYPE_QUA2
#define HECMW_ETYPE_SHQ1
#define HECMW_ETYPE_SHT1
#define HECMW_ETYPE_TET2
#define HECMW_ETYPE_SHT2
#define HECMW_ETYPE_TRI1
#define HECMW_ETYPE_HEX1
#define HECMW_ETYPE_ROD1
#define HECMW_ETYPE_QUA1
#define HECMW_ETYPE_TET1
#define HECMW_ETYPE_HEX2
#define HECMW_ETYPE_TRI2
#define HECMW_ETYPE_SHQ2
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:72
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
struct hecmw_io_egrp * HECMW_io_get_egrp(const char *name)
int HECMW_io_add_ngrp(const char *name, int nnode, int *node)
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
int HECMW_io_add_egrp(const char *name, int nelem, int *elem)
struct hecmwST_local_mesh * HECMW_io_make_local_mesh(void)
struct hecmw_io_node * HECMW_io_add_node(int id, double x, double y, double z)
struct hecmw_io_section * HECMW_io_add_sect(struct hecmw_io_section *sect)
int HECMW_io_init(void)
int HECMW_io_pre_process(void)
struct hecmw_io_element * HECMW_io_get_elem(int id)
int HECMW_io_post_process(void)
struct hecmw_io_id_array * HECMW_io_get_elem_in_egrp(const char *name)
int HECMW_io_set_gridfile(char *gridfile)
int HECMW_io_finalize(void)
struct hecmw_io_material * HECMW_io_add_mat(const char *name, struct hecmw_io_material *mat)
#define FILE_STACK_SIZE
#define LARGE_FIELD_COLUMN
struct ST_IFF_BULK iff_bulk_t
#define NULL
#define read_iff_success
#define read_iff_comment
#define T_NUMBER
#define BULK_PARAM_NUMBER
#define LARGE_FIELD_LINE_FIELD_NUMBER
struct ST_FILE_STACK file_stack_t
struct ST_IFF_NODE iff_node_t
#define G_NUMBER
#define cms_malloc(p, size)
#define GPLP_PARAM_LIST_SIZE
#define CTRIAX6_EGRP_NAME_HEADER
#define read_iff_error
#define IFF_FIELD_BUFFER_SIZE
#define SMALL_FIELD_COLUMN
#define IFF_SIZE
#define BULK_PARAM_LIST_SIZE
#define FIELD_NUMBER
#define read_iff_eof
#define IFF_FIELD_SIZE
ENUM_FIELD_FORMAT
@ fft_small_field_format
@ fft_free_field_format
@ fft_comment
@ fft_large_field_format
@ fft_none
#define IFF_LAST_FIELD
#define GENERATE_CODE(name)
#define TRYAL_NUMBER
#define IFF_FIELD_NUMBER
#define BULK_TYPE_NUMBER
#define G_LIST_SIZE
#define REMOVE_CR_MAX_LINE
#define item_n
#define FIRST_FIELD_COLUMN
enum ENUM_FIELD_FORMAT field_format_t
#define LAST_FIELD_COLUMN
#define CREATE_LIST_CODE(type)
struct ST_IFF_BULK_LIST iff_bulk_list_t
struct hecmwST_local_mesh * HECMW_get_nastran_mesh(const char *filename)
int HECMW_read_nastran_mesh(const char *filename)
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
#define HECMW_IO_HEC_E0001
Definition: hecmw_msgno.h:194
#define HECMW_SECT_TYPE_SOLID
Definition: hecmw_struct.h:15
#define HECMW_SECT_OPT_PSTRAIN
Definition: hecmw_struct.h:22
#define HECMW_SECT_TYPE_SHELL
Definition: hecmw_struct.h:16
#define HECMW_SECT_OPT_PSTRESS
Definition: hecmw_struct.h:21
#define HECMW_SECT_OPT_ASYMMETRY
Definition: hecmw_struct.h:23
#define HECMW_assert(cond)
Definition: hecmw_util.h:40
void toupper(char *s)
Definition: hecd_util.cpp:37
void remove_cr(char *s)
Definition: hecd_util.cpp:75
CNFData data
char filename[HECMW_FILENAME_LEN+1]
iff_bulk_t * bulk_root
iff_node_t * iff_node_last
iff_node_t * iff_node_root
struct ST_IFF_BULK * next_bulk
char iff[IFF_SIZE]
struct ST_IFF_NODE * next
struct hecmw_io_material * next
struct hecmw_io_material::hecmw_io_matitem * item
char name[HECMW_NAME_LEN+1]
struct hecmw_io_section * next
union hecmw_io_section::hecmw_io_section_item sect
struct hecmw_io_section::hecmw_io_section_item::hecmw_io_section_solid solid
struct hecmw_io_section::hecmw_io_section_item::hecmw_io_section_shell shell