FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
fstr_ctrl_util.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#define fstr_ctrl_util_MAIN
7
8#include "fstr_ctrl_util.h"
9#include "hecmw_malloc.h"
10
11#ifndef TRUE
12#define TRUE 1
13#define FALSE 0
14#endif
15
16#define buffsize 256
17#define STR_SIZE buffsize
18#define FILE_NAME_SIZE 512
19
21
22void c_fstr_ctrl_get_err_msg(char *buff) { strcpy(buff, err_msg); }
23
24static void set_param_err_msg(fstr_ctrl_data *ctrl, const char *param_name,
25 const char *msg);
26static void set_data_err_msg(fstr_ctrl_data *ctrl, int line, int data_no,
27 const char *msg);
28static void set_record_data_line_err_msg(fstr_ctrl_data *ctrl, int r);
29static char *gettoken(const char *line);
30static void strcpy_f2c(char *dest, const char *src, int len);
31static void strcpy_c2f(char *dest, int len, const char *src);
32static char *remove_header_space(char *token);
33static int Strncmpi(const char *s1, const char *s2, int len);
34static int Strcmpi(const char *s1, const char *s2);
35/* static void Strupr( char* s ); */
36static void remove_cr(char *s);
37static void format_conv(const char *format, char *fmt, int *array_size);
38
39/* JP-0 */
40/* JP-1 */
41
43
44/* =================================================================================
45 */
46/* STATIC FUNCTIONS */
47/* =================================================================================
48 */
49
50static void fstr_ctrl_data_init(fstr_ctrl_data *ctrl) {
51 ctrl->rec = NULL;
52 ctrl->rec_n = 0;
53 ctrl->header_pos = NULL;
54 ctrl->header_n = 0;
55 ctrl->data_line_n = NULL;
56 ctrl->current_header_index = 0;
57 err_msg[0] = 0;
58}
59
60static void fstr_ctrl_data_finalize(fstr_ctrl_data *ctrl) {
61 int i;
62
63 for (i = 0; i < ctrl->rec_n; i++) {
64 HECMW_free(ctrl->rec[i].line);
65 }
66
67 HECMW_free(ctrl->rec);
70}
71
73 ctrl->current_header_index = 0;
74 return 0;
75}
76
77int fstr_ctrl_rewind__(int *ctrl) {
78 return fstr_ctrl_tmp_rewind(ctrl_list[*ctrl]);
79}
80
81int fstr_ctrl_rewind(int *ctrl) { return fstr_ctrl_rewind__(ctrl); }
82
83int fstr_ctrl_rewind_(int *ctrl) { return fstr_ctrl_rewind__(ctrl); }
84
85int FSTR_CTRL_REWIND(int *ctrl) { return fstr_ctrl_rewind__(ctrl); }
86
87int FSTR_CTRL_REWIND_(int *ctrl) { return fstr_ctrl_rewind__(ctrl); }
88
89int FSTR_CTRL_REWIND__(int *ctrl) { return fstr_ctrl_rewind__(ctrl); }
90
91/*-----------------------------------------------------------------------------------*/
92
94
95static int is_comment_or_blank_line(char *buff) {
96 char *p = buff;
97
98 if (buff[0] == '\n' || buff[0] == 0 || buff[0] == '#' ||
99 (buff[0] == '!' && buff[1] == '!')) {
100 return TRUE;
101 }
102
103 while (*p) {
104 if (*p != ' ' && *p != '\n') {
105 return FALSE;
106 }
107
108 p++;
109 }
110
111 return TRUE;
112}
113
114/*-----------------------------------------------------------------------------------*/
115
116static int count_line_and_header_number(const char *fname, int *line_n,
117 int *header_n) {
118 FILE *fp;
119 char buff[buffsize];
120 int line_no, L, N;
121 fp = fopen(fname, "r");
122
123 if (!fp) {
124 return -1;
125 }
126
127 line_no = 0;
128 L = N = 0;
129
130 while (!feof(fp)) {
131 line_no++;
132
133 if (fgets(buff, buffsize - 1, fp) == NULL) {
134 break;
135 }
136
137 if (is_comment_or_blank_line(buff)) {
138 continue;
139 }
140
141 if (buff[0] == '!') {
142 N++;
143 }
144
145 L++;
146 }
147
148 fclose(fp);
149 *line_n = L;
150 *header_n = N;
151 return 0;
152}
153
154/*-----------------------------------------------------------------------------------*/
155
156static int set_fstr_ctrl_data(const char *fname, fstr_ctrl_data *ctrl) {
157 FILE *fp;
158 char buff[buffsize];
159 int line_no;
160 int header_count;
161 int rec_count;
162 fp = fopen(fname, "r");
163
164 if (!fp) {
165 return -1;
166 }
167
168 line_no = 0;
169 rec_count = 0;
170 header_count = -1;
171
172 while (fgets(buff, buffsize - 1, fp)) {
173 line_no++;
174
175 if (is_comment_or_blank_line(buff)) {
176 continue;
177 }
178
179 if (buff[0] == '!') {
180 header_count++;
181 ctrl->header_pos[header_count] = rec_count;
182 ctrl->data_line_n[header_count] = 0;
183
184 } else {
185 if (header_count >= 0) {
186 ctrl->data_line_n[header_count]++;
187 }
188 }
189
190 ctrl->rec[rec_count].line_no = line_no;
191 ctrl->rec[rec_count].line = HECMW_malloc(sizeof(char) * (strlen(buff) + 1));
192
193 if (ctrl->rec[rec_count].line == NULL) {
194 printf("Not enough memory\n");
195 exit(-1);
196 }
197
198 /* Strupr( buff ); */
199 remove_cr(buff);
200 strcpy(ctrl->rec[rec_count].line, buff);
201 rec_count++;
202 }
203
204 fclose(fp);
205 return 0;
206}
207
208/*-----------------------------------------------------------------------------------*/
209
210static int create_fstr_ctrl_data(const char *fname, fstr_ctrl_data *ctrl) {
211 int i;
212 int line_n, header_n;
213 fstr_ctrl_data_init(ctrl);
214
215 if (count_line_and_header_number(fname, &line_n, &header_n)) {
216 return -1;
217 }
218
219 ctrl->rec_n = line_n;
220 ctrl->rec = (ctrl_rec *)HECMW_malloc(sizeof(ctrl_rec) * line_n);
221
222 for (i = 0; i < line_n; i++) {
223 ctrl->rec[i].line = NULL;
224 ctrl->rec[i].line_no = 0;
225 }
226
227 ctrl->header_n = header_n;
228 ctrl->header_pos = (int *)HECMW_malloc(sizeof(int) * header_n);
229 ctrl->data_line_n = (int *)HECMW_malloc(sizeof(int) * header_n);
230
231 for (i = 0; i < header_n; i++) {
232 ctrl->header_pos[i] = 0;
233 ctrl->data_line_n[i] = 0;
234 }
235
236 if (set_fstr_ctrl_data(fname, ctrl)) {
237 fstr_ctrl_data_finalize(ctrl);
238 return -1;
239 }
240
241 return 0;
242}
243
244/*===================================================================================*/
245/* PUBLIC FUNCTIONS */
246/*===================================================================================*/
247
248/* return fstr_ctrl_data* --- NULL: error */
249
250fstr_ctrl_data *c_fstr_ctrl_open(const char *filename) {
251 fstr_ctrl_data *ctrl;
252 ctrl = (fstr_ctrl_data *)HECMW_malloc(sizeof(fstr_ctrl_data));
253
254 if (!ctrl) {
255 return NULL;
256 }
257
258#if 0 /* all PE reading fstr contorl */
259 /* #ifndef HECMW_SERIAL */
260 {
261 int i;
262 int myrank = HECMW_comm_get_rank();
264 /* file ----------------------------------------------------------- */
265 int err;
266
267 if (myrank == 0) {
268 err = create_fstr_ctrl_data(filename, ctrl);
269 }
270
271 HECMW_Bcast(&err, 1, HECMW_INT, 0, comm);
272
273 if (err) {
274 HECMW_free(ctrl);
275 return NULL;
276 }
277
278 /* rec ------------------------------------------------------------ */
279 HECMW_Bcast(&ctrl->rec_n, 1, HECMW_INT, 0, comm);
280
281 if (myrank != 0) {
282 ctrl->rec = HECMW_malloc(sizeof(ctrl_rec) * ctrl->rec_n);
283 }
284
285 for (i = 0; i < ctrl->rec_n; i++) {
286 int line_size;
287
288 if (myrank == 0) {
289 line_size = strlen(ctrl->rec[i].line) + 1;
290 }
291
292 HECMW_Bcast(&line_size, 1, HECMW_INT, 0, comm);
293
294 if (myrank != 0) {
295 ctrl->rec[i].line = HECMW_malloc(sizeof(char) * line_size);
296 }
297
298 HECMW_Bcast(ctrl->rec[i].line, line_size, HECMW_CHAR, 0, comm);
299 HECMW_Bcast(&ctrl->rec[i].line_no, 1, HECMW_INT, 0, comm);
300 }
301
302 /* header --------------------------------------------------------- */
303 HECMW_Bcast(&ctrl->header_n, 1, HECMW_INT, 0, comm);
304
305 if (myrank != 0) {
306 ctrl->header_pos = HECMW_malloc(sizeof(int) * ctrl->header_n);
307 }
308
309 HECMW_Bcast(ctrl->header_pos, ctrl->header_n, HECMW_INT, 0, comm);
310
311 /* data line ----------------------------------------------------- */
312
313 if (myrank != 0) {
314 ctrl->data_line_n = HECMW_malloc(sizeof(int) * ctrl->header_n);
315 }
316
317 HECMW_Bcast(ctrl->data_line_n, ctrl->header_n, HECMW_INT, 0, comm);
318 }
319#else
320
321 if (create_fstr_ctrl_data(filename, ctrl)) {
322 HECMW_free(ctrl);
323 return NULL;
324 }
325
326#endif
327 return ctrl;
328}
329
330/*-----------------------------------------------------------------------------------*/
331/* JP-2 */
332
334 if (!ctrl) {
335 return -1;
336 }
337
338 return ctrl->rec_n;
339}
340
341/*-----------------------------------------------------------------------------------*/
342/* JP-3 */
343
344int c_fstr_ctrl_get_line(fstr_ctrl_data *ctrl, int rec_no, char *buff) {
345 if (!ctrl) {
346 return -1;
347 }
348
349 if (rec_no < 0 || rec_no >= ctrl->rec_n) {
350 return -1;
351 }
352
353 strcpy(buff, ctrl->rec[rec_no].line);
354 return 0;
355}
356
357/*-----------------------------------------------------------------------------------*/
358/* JP-4 */
359
360int c_fstr_ctrl_seek_header(fstr_ctrl_data *ctrl, const char *header_name) {
361 int i;
362 static char *h_name = NULL;
363 int header_name_len;
364 int start_index;
365
366 if (!ctrl) {
367 return FALSE;
368 }
369
370 if (header_name == NULL || header_name[0] == 0) {
371 start_index = ctrl->current_header_index + 1;
372
373 } else {
374 start_index = 0;
375 h_name = (char *)header_name;
376 }
377
378 if (h_name == NULL) {
379 return FALSE;
380 }
381
382 header_name_len = strlen(h_name);
383
384 for (i = start_index; i < ctrl->header_n; i++) {
385 int hp = ctrl->header_pos[i];
386 char *header = ctrl->rec[hp].line;
387
388 if (Strncmpi(header, h_name, header_name_len) == 0) {
389 ctrl->current_header_index = i;
390 return TRUE;
391 }
392 }
393
394 return FALSE;
395}
396
397/*-----------------------------------------------------------------------------------*/
398/* JP-5 */
399
401 if (!ctrl) {
402 return FALSE;
403 }
404
405 ctrl->current_header_index++;
406
407 if (ctrl->header_n <= ctrl->current_header_index) {
408 return FALSE;
409
410 } else {
411 return TRUE;
412 }
413}
414
415/*-----------------------------------------------------------------------------------*/
416/* JP-6 */
417
419 char *header_name) {
420 int hp;
421 char *line_p;
422 char *header_p;
423
424 if (!ctrl) {
425 return -1;
426 }
427
428 hp = ctrl->header_pos[ctrl->current_header_index];
429 line_p = ctrl->rec[hp].line;
430 header_p = header_name;
431
432 while (*line_p && (*line_p != ',') && (*line_p != ' ') && (*line_p != '\n') &&
433 (*line_p != '\r')) {
434 *header_p = (char)toupper(*line_p);
435 line_p++;
436 header_p++;
437 }
438
439 *header_p = 0;
440 return 0;
441}
442
443/*-----------------------------------------------------------------------------------*/
444/* JP-7 */
445
447 int index, hp;
448
449 if (!ctrl) {
450 return -1;
451 }
452
453 index = ctrl->current_header_index;
454 hp = ctrl->header_pos[index];
455 return ctrl->rec[hp].line_no;
456}
457
458/*-----------------------------------------------------------------------------------*/
459/* JP-8 */
460
462 int index, hp;
463
464 if (!ctrl) {
465 return -1;
466 }
467
468 index = ctrl->current_header_index;
469 hp = ctrl->header_pos[index];
470 return hp;
471}
472
473/*-----------------------------------------------------------------------------------*/
474/* JP-9 */
475
476static int param_value_check(const char *value_list, char *val, int *index) {
477 char vlist[buffsize];
478 char *token;
479 int fg, i, n;
480
481 if (value_list == NULL || value_list[0] == 0 || value_list[0] == '#') {
482 if (index) {
483 *index = 0;
484 }
485
486 return 0;
487 }
488
489 /* JP-10 */
490 fg = 0;
491 n = strlen(value_list);
492
493 for (i = 0; i < n; i++) {
494 if (value_list[i] != ' ') {
495 fg = 1;
496 break;
497 }
498 }
499
500 if (!fg) {
501 if (index) {
502 *index = 0;
503 }
504
505 return 0;
506 }
507
508 strcpy(vlist, value_list);
509 i = 1;
510 token = strtok(vlist, " ,");
511
512 while (token) {
513 if (Strcmpi(token, val) == 0) {
514 if (index) {
515 *index = i;
516 }
517
518 return 0;
519 }
520
521 token = strtok(NULL, ", ");
522 i++;
523 }
524
525 return -1;
526}
527
528static int param_value_convert(int type, char *token, void *val) {
529 char fmt[5];
530 int fmt_i;
531 int r;
532 fmt_i = 0;
533 fmt[fmt_i] = '%';
534 fmt_i++;
535 type = toupper(type);
536
537 switch ((char)type) {
538 case 'I':
539 fmt[fmt_i] = 'd';
540 fmt_i++;
541 break;
542
543 case 'C':
544 case 'S':
545 case (int)'P':
546 fmt[fmt_i] = 's';
547 fmt_i++;
548 break;
549
550 case 'R':
551 fmt[fmt_i] = 'l';
552 fmt_i++;
553 fmt[fmt_i] = 'f';
554 fmt_i++;
555 break;
556
557 default:
559 }
560
561 fmt[fmt_i] = 0;
562 r = sscanf(token, fmt, val);
563
564 if (r != 1) {
566 }
567
569}
570
571static int param_length_count(const char *param) {
572 const char *p = param;
573 int len = 0;
574 while (*p != '\0' && *p != '=' && *p != ' ') {
575 p++;
576 len++;
577 }
578 return len;
579}
580
581int c_fstr_ctrl_get_param(fstr_ctrl_data *ctrl, const char *param_name,
582 const char *value_list, char type, void *val) {
583 int h_index;
584 int h_pos;
585 char header[buffsize];
586 type = type & 0xff; /* bug fix for compiler=pgi */
587
588 if (!ctrl) {
589 return -1;
590 }
591
592 h_index = ctrl->current_header_index;
593
594 if (h_index < 0) {
595 return -1;
596 }
597
598 h_pos = ctrl->header_pos[h_index];
599 strcpy(header, ctrl->rec[h_pos].line);
600 {
601 char *token;
602 char *param_pos;
603 char *eq_pos;
604 char *val_pos;
605 char *p;
606 int param_name_len;
607 int param_len;
608 int r;
609 int index;
610 param_name_len = strlen(param_name);
611 strtok(header, ",\n"); /* remove !header name */
612 token = strtok(NULL, ",\n");
613
614 while (token) {
615 param_pos = remove_header_space(token);
616 param_len = param_length_count(param_pos);
617
618 if (param_len == param_name_len && Strncmpi(param_pos, param_name, param_name_len) == 0) {
619 if (type == 'E' || type == 'e') {
620 *((int *)val) = 1;
622 }
623
624 eq_pos = strstr(param_pos, "=");
625
626 if (eq_pos) {
627 val_pos = eq_pos + 1;
628 val_pos = remove_header_space(val_pos);
629 p = val_pos;
630
631 while (*p) {
632 if (*p == ',') {
633 *p = 0;
634 break;
635 }
636
637 p++;
638 }
639
640 if (param_value_check(value_list, val_pos, &index)) {
642 }
643
644 if (type == 'P' || type == 'p') {
645 *((int *)val) = index;
647
648 } else {
649 r = param_value_convert(type, val_pos, val);
650 return r;
651 }
652
653 } else {
655 }
656 }
657
658 token = strtok(NULL, ",\n");
659 }
660 }
661
662 if (type == 'E' || type == 'e') {
663 *((int *)val) = 0;
664 }
665
667}
668
669/*-----------------------------------------------------------------------------------*/
670/* JP-11 */
671
672static int rcode_of_get_param = 0;
673
674int c_fstr_ctrl_get_param_ex(fstr_ctrl_data *ctrl, const char *param_name,
675 const char *value_list, int necessity, char type,
676 void *val) {
677 char s[buffsize];
678 int rcode = c_fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
679 rcode_of_get_param = rcode;
680
681 switch (rcode) {
684
685 case FSTR_CTRL_RCODE_PARAM_NOTHING: /* nothing parameter */
686 if (necessity) {
687 set_param_err_msg(ctrl, param_name, " is required");
688
689 } else {
691 }
692
693 break;
694
695 case FSTR_CTRL_RCODE_PARAM_VALUE_NOTHING: /* nothing value of parameter */
696 if (necessity) {
697 set_param_err_msg(ctrl, param_name, ": value is required");
698
699 } else {
701 }
702
703 break;
704
705 case FSTR_CTRL_RCODE_PARAM_TYPE_ERROR: /* type change error */
706 set_param_err_msg(ctrl, param_name, ": type conversion fail");
707 break;
708
709 case FSTR_CTRL_RCODE_PARAM_RANGE_ERROR: /* range error */
710 sprintf(s, ": type range fail(%s)", value_list);
711 set_param_err_msg(ctrl, param_name, s);
712 break;
713
714 default:
715 assert(0);
716 }
717
718 return rcode;
719}
720
721/*-----------------------------------------------------------------------------------*/
722/* JP-12 */
723
725 int h_index;
726
727 if (!ctrl) {
728 return -1;
729 }
730
731 h_index = ctrl->current_header_index;
732
733 if (h_index < 0) {
734 return -1;
735 }
736
737 return ctrl->data_line_n[h_index];
738}
739
740/*-----------------------------------------------------------------------------------*/
741
742/* JP-13 */
743
745 char *data_line) {
746 int data_line_n;
747 int h_index;
748 int data_pos;
749 data_line_n = c_fstr_ctrl_get_data_line_n(ctrl);
750
751 if (data_line_n <= 0 || data_line_n < line_no) {
752 return -1;
753 }
754
755 h_index = ctrl->current_header_index;
756 data_pos = ctrl->header_pos[h_index] + line_no;
757 strcpy(data_line, ctrl->rec[data_pos].line);
758 return 0;
759}
760
761/*-----------------------------------------------------------------------------------*/
762
763/* JP-14 */
764
766 const char *delim) {
767 char data_line[buffsize];
768 char *token;
769 int err;
770 int counter;
771 err = c_fstr_ctrl_copy_data_line(ctrl, line_no, data_line);
772
773 if (err) {
774 return -1;
775 }
776
777 counter = 0;
778 token = strtok(data_line, delim);
779
780 while (token) {
781 counter++;
782 token = strtok(NULL, delim);
783 }
784
785 return counter;
786}
787
788/*-----------------------------------------------------------------------------------*/
789
790/* JP-15 */
791
792int error_pos = -1;
793
795
796int error_line = -1;
797
799
800/* JP-16 */
801
802int c_fstr_ctrl_get_data(fstr_ctrl_data *ctrl, int line_no, const char *format,
803 ...) {
804 va_list va;
805 int r;
806 va_start(va, format);
807 r = c_fstr_ctrl_get_data_v(ctrl, line_no, format, va);
808 va_end(va);
809 return r;
810}
811
813 const char *format, ...) {
814 va_list va;
815 int r;
816 va_start(va, format);
817 r = c_fstr_ctrl_get_data_v(ctrl, line_no, format, va);
818 va_end(va);
819
820 if (r != 0) {
821 set_record_data_line_err_msg(ctrl, r);
822 return -1;
823 }
824
825 return 0;
826}
827
829 const char *format, va_list va) {
830 char data_line[buffsize];
831 int necessary;
832 int type;
833 void *val_p;
834 char *token;
835 int err;
836 int counter;
837 int len;
838 char *fmt;
839 char fmt_integer[] = "%d";
840 char fmt_double[] = "%lf";
841 char fmt_string[] = "%s";
842 char fmt_char[] = "%c";
843 char format_c[buffsize] = { '\0' };
844 int array_size[buffsize] = { '\0' };
845 char buff[buffsize * 2] = { '\0' };
846 format_conv(format, format_c, array_size);
847 error_pos = -1;
848 err = c_fstr_ctrl_copy_data_line(ctrl, line_no, data_line);
849
850 if (err) {
851 int i = 0;
852
853 while (format_c[i] != 0) {
854 if (isupper(format_c[i])) {
856 }
857
858 i++;
859 }
860
861 return 0;
862 }
863
864 len = strlen(format_c);
865 counter = 0;
866
867 if (data_line[0] == '!') {
868 for (; counter < len; counter++) {
869 if (isupper(format_c[counter])) {
870 return counter + 1;
871 }
872 }
873
874 return 0;
875 }
876
877 token = gettoken(data_line);
878
879 while (token && counter < len) {
880 error_pos = counter + 1;
881 necessary = isupper(format_c[counter]);
882 type = toupper(format_c[counter]) & 0xff;
883
884 switch ((char)type) {
885 case 'I':
886 fmt = fmt_integer;
887 break;
888
889 case 'R':
890 fmt = fmt_double;
891 break;
892
893 case 'S':
894 fmt = fmt_string;
895 break;
896
897 case 'C':
898 fmt = fmt_char;
899 break;
900
901 default:
903 }
904
905 val_p = va_arg(va, void *);
906
907 if (token[0] != 0) {
908 err = sscanf(token, fmt, val_p);
909
910 if (err != 1 && necessary) {
912 }
913
914 if ((char)type == 'S') {
915 strcpy(buff, (char *)val_p);
916 strcpy_c2f((char *)val_p, array_size[counter], buff);
917 }
918
919 } else if (necessary) {
921 }
922
923 token = gettoken(NULL);
924 counter++;
925 }
926
927 for (; counter < len; counter++) {
928 if (isupper(format[counter])) {
930 }
931 }
932
934}
935
936int c_fstr_ctrl_get_data_array_v(fstr_ctrl_data *ctrl, const char *format,
937 va_list va) {
938#define MAX_DATA_ARRAY_NUMBER 256
939 int line_n;
940 int i, j;
941 char fmt[buffsize];
942 int array_size[buffsize];
943 char *param[MAX_DATA_ARRAY_NUMBER];
944 size_t param_size[MAX_DATA_ARRAY_NUMBER];
945 char *p;
946 int column_n;
947 int type;
948 int r;
949 char buff[buffsize * 2] = { '\0' };
950 line_n = c_fstr_ctrl_get_data_line_n(ctrl);
951
952 if (line_n < 0) {
954 }
955
956 format_conv(format, fmt, array_size);
957 p = fmt;
958 i = 0;
959
960 while (*p) {
961 if (i >= MAX_DATA_ARRAY_NUMBER) {
962 assert(0);
963 }
964
965 param[i] = va_arg(va, void *);
966 type = toupper(*p) & 0xff;
967
968 switch ((char)type) {
969 case 'I':
970 param_size[i] = sizeof(int);
971 break;
972
973 case 'R':
974 param_size[i] = sizeof(double);
975 break;
976
977 case 'S':
978 param_size[i] = sizeof(char) * array_size[i];
979 break;
980
981 case 'C':
982 param_size[i] = sizeof(char);
983 break;
984
985 default:
986 assert(0);
987 }
988
989 p++;
990 i++;
991 }
992
993 column_n = i;
994
995 for (i = 1; i <= line_n; i++) {
996 r = c_fstr_ctrl_get_data(ctrl, i, fmt, param[0], param[1], param[2],
997 param[3], param[4], param[5], param[6], param[7],
998 param[8], param[9], param[10], param[11],
999 param[12], param[13], param[14], param[15],
1000 param[16], param[17], param[18], param[19]);
1001
1002 if (r != 0) {
1003 error_line = i;
1004 return r;
1005 }
1006
1007 for (j = 0; j < column_n; j++) {
1008 if (fg_fortran_get_data_array_v && toupper(fmt[j]) == 'S') {
1009 strcpy(buff, (char *)param[j]);
1010 strcpy_c2f((char *)param[j], array_size[j], buff);
1011 }
1012
1013 param[j] += param_size[j];
1014 }
1015 }
1016
1018#undef MAX_DATA_ARRAY_NUMBER
1019}
1020
1021int c_fstr_ctrl_get_data_array(fstr_ctrl_data *ctrl, const char *format, ...) {
1022 va_list va;
1023 int rcode;
1024 va_start(va, format);
1025 rcode = c_fstr_ctrl_get_data_array_v(ctrl, format, va);
1026 va_end(va);
1027 return rcode;
1028}
1029
1030int c_fstr_ctrl_get_data_array_ex(fstr_ctrl_data *ctrl, const char *format,
1031 ...) {
1032 va_list va;
1033 int r;
1034 va_start(va, format);
1035 r = c_fstr_ctrl_get_data_array_v(ctrl, format, va);
1036 va_end(va);
1037
1038 if (r != 0) {
1039 set_record_data_line_err_msg(ctrl, r);
1040 return -1;
1041 }
1042
1043 return 0;
1044}
1045
1046/*-----------------------------------------------------------------------------------*/
1047
1048/* JP-17 */
1049
1051 fstr_ctrl_data_finalize(ctrl);
1052 return 0;
1053}
1054
1055/*-----------------------------------------------------------------------------------*/
1056
1058 int i;
1059 printf("header pos: ");
1060
1061 for (i = 0; i < ctrl->header_n; i++) {
1062 printf("%d,", ctrl->header_pos[i]);
1063 }
1064
1065 printf("\n");
1066
1067 for (i = 0; i < ctrl->rec_n; i++) {
1068 printf("%3d: %s", ctrl->rec[i].line_no, ctrl->rec[i].line);
1069 }
1070}
1071
1072/* ==================================================================================*/
1073/* FORTRAN INTERFACE */
1074/* ==================================================================================*/
1075
1076void fstr_ctrl_get_err_msg(char *f_buff, int *len) {
1077 strcpy_c2f(f_buff, *len, err_msg);
1078}
1079
1080void fstr_ctrl_get_err_msg_(char *f_buff, int *len) {
1081 strcpy_c2f(f_buff, *len, err_msg);
1082}
1083
1084void fstr_ctrl_get_err_msg__(char *f_buff, int *len) {
1085 strcpy_c2f(f_buff, *len, err_msg);
1086}
1087
1088void FSTR_CTRL_GET_ERR_MSG(char *f_buff, int *len) {
1089 strcpy_c2f(f_buff, *len, err_msg);
1090}
1091
1092void FSTR_CTRL_GET_ERR_MSG_(char *f_buff, int *len) {
1093 strcpy_c2f(f_buff, *len, err_msg);
1094}
1095
1096void FSTR_CTRL_GET_ERR_MSG__(char *f_buff, int *len) {
1097 strcpy_c2f(f_buff, *len, err_msg);
1098}
1099
1100/*-----------------------------------------------------------------------------------*/
1101
1102/* JP-18 */
1103
1104int is_first = 1; /* JP-19 */
1105
1106int fstr_ctrl_open(char *filename) {
1107 int i;
1108 int index;
1109 char fname[FILE_NAME_SIZE];
1110 strcpy_f2c(fname, filename, FILE_NAME_SIZE);
1111
1112 if (is_first) {
1113 for (i = 0; i < ctrl_list_size; i++) {
1114 ctrl_list[i] = NULL;
1115 }
1116
1117 index = 0;
1118 is_first = 0;
1119
1120 } else {
1121 index = -1;
1122
1123 for (i = 0; i < ctrl_list_size; i++) {
1124 if (ctrl_list[i] == NULL) {
1125 index = i;
1126 break;
1127 }
1128 }
1129
1130 if (index < 0) {
1131 return -1;
1132 }
1133 }
1134
1135 ctrl_list[index] = c_fstr_ctrl_open(fname);
1136
1137 if (ctrl_list[index] == NULL) {
1138 return -1;
1139
1140 } else {
1141 return index;
1142 }
1143}
1144
1145int fstr_ctrl_open_(char *filename) { return fstr_ctrl_open(filename); }
1146int fstr_ctrl_open__(char *filename) { return fstr_ctrl_open(filename); }
1147int FSTR_CTRL_OPEN(char *filename) { return fstr_ctrl_open(filename); }
1148int FSTR_CTRL_OPEN_(char *filename) { return fstr_ctrl_open(filename); }
1149int FSTR_CTRL_OPEN__(char *filename) { return fstr_ctrl_open(filename); }
1150
1151/*-----------------------------------------------------------------------------------*/
1152
1155}
1156
1159}
1160
1163}
1164
1167}
1168
1171}
1172
1175}
1176
1177/*-----------------------------------------------------------------------------------*/
1178
1179int fstr_ctrl_get_line(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1180 char c_buff[STR_SIZE] = { '\0' };
1181
1182 if (c_fstr_ctrl_get_line(ctrl_list[*ctrl], *rec_no, c_buff)) {
1183 return -1;
1184 }
1185
1186 strcpy_c2f(buff, *buff_size, c_buff);
1187 return 0;
1188}
1189
1190int fstr_ctrl_get_line_(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1191 return fstr_ctrl_get_line(ctrl, rec_no, buff, buff_size);
1192}
1193
1194int fstr_ctrl_get_line__(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1195 return fstr_ctrl_get_line(ctrl, rec_no, buff, buff_size);
1196}
1197
1198int FSTR_CTRL_GET_LINE(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1199 return fstr_ctrl_get_line(ctrl, rec_no, buff, buff_size);
1200}
1201
1202int FSTR_CTRL_GET_LINE_(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1203 return fstr_ctrl_get_line(ctrl, rec_no, buff, buff_size);
1204}
1205
1206int FSTR_CTRL_GET_LINE__(int *ctrl, int *rec_no, char *buff, int *buff_size) {
1207 return fstr_ctrl_get_line(ctrl, rec_no, buff, buff_size);
1208}
1209
1210/*-----------------------------------------------------------------------------------*/
1211
1212int fstr_ctrl_seek_header(int *ctrl, const char *header_name) {
1213 char name[STR_SIZE];
1214 strcpy_f2c(name, header_name, STR_SIZE);
1215
1216 if (name[0] == 0) {
1217 return c_fstr_ctrl_seek_header(ctrl_list[*ctrl], NULL);
1218
1219 } else {
1220 return c_fstr_ctrl_seek_header(ctrl_list[*ctrl], name);
1221 }
1222}
1223
1224int fstr_ctrl_seek_header_(int *ctrl, const char *header_name) {
1225 return fstr_ctrl_seek_header(ctrl, header_name);
1226}
1227
1228int fstr_ctrl_seek_header__(int *ctrl, const char *header_name) {
1229 return fstr_ctrl_seek_header(ctrl, header_name);
1230}
1231
1232int FSTR_CTRL_SEEK_HEADER(int *ctrl, const char *header_name) {
1233 return fstr_ctrl_seek_header(ctrl, header_name);
1234}
1235
1236int FSTR_CTRL_SEEK_HEADER_(int *ctrl, const char *header_name) {
1237 return fstr_ctrl_seek_header(ctrl, header_name);
1238}
1239
1240int FSTR_CTRL_SEEK_HEADER__(int *ctrl, const char *header_name) {
1241 return fstr_ctrl_seek_header(ctrl, header_name);
1242}
1243
1244/*-----------------------------------------------------------------------------------*/
1245
1248}
1249
1252}
1253
1256}
1257
1260}
1261
1264}
1265
1268}
1269
1270/*-----------------------------------------------------------------------------------*/
1271
1272int fstr_ctrl_get_c_h_name(int *ctrl, char *header_name, int *buff_size) {
1273 char c_buff[STR_SIZE] = { '\0' };
1274
1275 if (c_fstr_ctrl_get_current_header_name(ctrl_list[*ctrl], c_buff)) {
1276 return -1;
1277 }
1278
1279 strcpy_c2f(header_name, *buff_size, c_buff);
1280 return 0;
1281}
1282
1283int fstr_ctrl_get_c_h_name_(int *ctrl, char *header_name, int *buff_size) {
1284 return fstr_ctrl_get_c_h_name(ctrl, header_name, buff_size);
1285}
1286
1287int fstr_ctrl_get_c_h_name__(int *ctrl, char *header_name, int *buff_size) {
1288 return fstr_ctrl_get_c_h_name(ctrl, header_name, buff_size);
1289}
1290
1291int FSTR_CTRL_GET_C_H_NAME(int *ctrl, char *header_name, int *buff_size) {
1292 return fstr_ctrl_get_c_h_name(ctrl, header_name, buff_size);
1293}
1294
1295int FSTR_CTRL_GET_C_H_NAME_(int *ctrl, char *header_name, int *buff_size) {
1296 return fstr_ctrl_get_c_h_name(ctrl, header_name, buff_size);
1297}
1298
1299int FSTR_CTRL_GET_C_H_NAME__(int *ctrl, char *header_name, int *buff_size) {
1300 return fstr_ctrl_get_c_h_name(ctrl, header_name, buff_size);
1301}
1302
1303/*-----------------------------------------------------------------------------------*/
1304
1307}
1308
1311}
1312
1315}
1316
1319}
1320
1323}
1324
1327}
1328
1329/*-----------------------------------------------------------------------------------*/
1330
1333}
1334
1337}
1338
1341}
1342
1345}
1346
1349}
1350
1353}
1354
1355/*-----------------------------------------------------------------------------------*/
1356
1357int fstr_ctrl_get_param(int *ctrl, const char *param_name,
1358 const char *value_list, char *type, void *val) {
1359 int rcode;
1360 char p_name[STR_SIZE];
1361 char v_list[STR_SIZE];
1362 memset(p_name, '\0', sizeof(p_name));
1363 memset(v_list, '\0', sizeof(v_list));
1364 strcpy_f2c(p_name, param_name, STR_SIZE);
1365 strcpy_f2c(v_list, value_list, STR_SIZE);
1366 rcode = c_fstr_ctrl_get_param(ctrl_list[*ctrl], p_name, v_list, *type, val);
1367
1368 if (rcode == 0 && (*type == 'S' || *type == 's')) {
1369 char buff[HECMW_NAME_LEN + 1];
1370 strcpy(buff, (char *)val);
1371 strcpy_c2f((char *)val, HECMW_NAME_LEN, buff);
1372 }
1373
1374 return rcode;
1375}
1376
1377int fstr_ctrl_get_param_(int *ctrl, const char *param_name,
1378 const char *value_list, char *type, void *val) {
1379 return fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
1380}
1381
1382int fstr_ctrl_get_param__(int *ctrl, const char *param_name,
1383 const char *value_list, char *type, void *val) {
1384 return fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
1385}
1386
1387int FSTR_CTRL_GET_PARAM(int *ctrl, const char *param_name,
1388 const char *value_list, char *type, void *val) {
1389 return fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
1390}
1391
1392int FSTR_CTRL_GET_PARAM_(int *ctrl, const char *param_name,
1393 const char *value_list, char *type, void *val) {
1394 return fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
1395}
1396
1397int FSTR_CTRL_GET_PARAM__(int *ctrl, const char *param_name,
1398 const char *value_list, char *type, void *val) {
1399 return fstr_ctrl_get_param(ctrl, param_name, value_list, type, val);
1400}
1401
1402/*-----------------------------------------------------------------------------------*/
1403
1404int fstr_ctrl_get_param_ex(int *ctrl, const char *param_name,
1405 const char *value_list, int *necessity, char *type,
1406 void *val) {
1407 int rcode;
1408 char p_name[STR_SIZE];
1409 char v_list[STR_SIZE];
1410 strcpy_f2c(p_name, param_name, STR_SIZE);
1411 strcpy_f2c(v_list, value_list, STR_SIZE);
1412 rcode = c_fstr_ctrl_get_param_ex(ctrl_list[*ctrl], p_name, v_list, *necessity,
1413 *type, val);
1414
1415 if (rcode_of_get_param == FSTR_CTRL_RCODE_PARAM_SUCCESS &&
1416 (*type == 'S' || *type == 's')) {
1417 char buff[HECMW_NAME_LEN + 1] = { '\0' };
1418 strcpy(buff, (char *)val);
1419 strcpy_c2f((char *)val, HECMW_NAME_LEN, buff);
1420 }
1421
1422 return rcode;
1423}
1424
1425int fstr_ctrl_get_param_ex_(int *ctrl, const char *param_name,
1426 const char *value_list, int *necessity, char *type,
1427 void *val) {
1428 return fstr_ctrl_get_param_ex(ctrl, param_name, value_list, necessity, type,
1429 val);
1430}
1431
1432int fstr_ctrl_get_param_ex__(int *ctrl, const char *param_name,
1433 const char *value_list, int *necessity, char *type,
1434 void *val) {
1435 return fstr_ctrl_get_param_ex(ctrl, param_name, value_list, necessity, type,
1436 val);
1437}
1438
1439int FSTR_CTRL_GET_PARAM_EX(int *ctrl, const char *param_name,
1440 const char *value_list, int *necessity, char *type,
1441 void *val) {
1442 return fstr_ctrl_get_param_ex(ctrl, param_name, value_list, necessity, type,
1443 val);
1444}
1445
1446int FSTR_CTRL_GET_PARAM_EX_(int *ctrl, const char *param_name,
1447 const char *value_list, int *necessity, char *type,
1448 void *val) {
1449 return fstr_ctrl_get_param_ex(ctrl, param_name, value_list, necessity, type,
1450 val);
1451}
1452
1453int FSTR_CTRL_GET_PARAM_EX__(int *ctrl, const char *param_name,
1454 const char *value_list, int *necessity, char *type,
1455 void *val) {
1456 return fstr_ctrl_get_param_ex(ctrl, param_name, value_list, necessity, type,
1457 val);
1458}
1459
1460/*-----------------------------------------------------------------------------------*/
1461
1464}
1465
1467 return fstr_ctrl_get_data_line_n(ctrl);
1468}
1469
1471 return fstr_ctrl_get_data_line_n(ctrl);
1472}
1473
1475 return fstr_ctrl_get_data_line_n(ctrl);
1476}
1477
1479 return fstr_ctrl_get_data_line_n(ctrl);
1480}
1481
1483 return fstr_ctrl_get_data_line_n(ctrl);
1484}
1485
1486/*-----------------------------------------------------------------------------------*/
1487
1488int fstr_ctrl_get_data_n_in_line(int *ctrl, int *line_no, const char *delim) {
1489 char delim_c[STR_SIZE];
1490 strcpy_f2c(delim_c, delim, STR_SIZE);
1491 return c_fstr_ctrl_get_data_n_in_line(ctrl_list[*ctrl], *line_no, delim_c);
1492}
1493
1494int fstr_ctrl_get_data_n_in_line_(int *ctrl, int *line_no, const char *delim) {
1495 return fstr_ctrl_get_data_n_in_line(ctrl, line_no, delim);
1496}
1497
1498int fstr_ctrl_get_data_n_in_line__(int *ctrl, int *line_no, const char *delim) {
1499 return fstr_ctrl_get_data_n_in_line(ctrl, line_no, delim);
1500}
1501
1502int FSTR_CTRL_GET_DATA_N_IN_LINE(int *ctrl, int *line_no, const char *delim) {
1503 return fstr_ctrl_get_data_n_in_line(ctrl, line_no, delim);
1504}
1505
1506int FSTR_CTRL_GET_DATA_N_IN_LINE_(int *ctrl, int *line_no, const char *delim) {
1507 return fstr_ctrl_get_data_n_in_line(ctrl, line_no, delim);
1508}
1509
1510int FSTR_CTRL_GET_DATA_N_IN_LINE__(int *ctrl, int *line_no, const char *delim) {
1511 return fstr_ctrl_get_data_n_in_line(ctrl, line_no, delim);
1512}
1513
1514/*-----------------------------------------------------------------------------------*/
1515
1518}
1521}
1524}
1528}
1529
1532}
1535}
1538}
1541}
1544}
1547}
1548
1549/*-----------------------------------------------------------------------------------*/
1550
1552 const char *format, va_list va) {
1553 char fmt_c[STR_SIZE];
1554 strcpy_f2c(fmt_c, format, STR_SIZE);
1555 return c_fstr_ctrl_get_data_v(ctrl, line_no, format, va);
1556}
1557
1558int fstr_ctrl_get_data(int *ctrl, int *line_no, const char *format, ...) {
1559 va_list va;
1560 int r;
1561 va_start(va, format);
1562 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1563 va_end(va);
1564 return r;
1565}
1566
1567int fstr_ctrl_get_data_(int *ctrl, int *line_no, const char *format, ...) {
1568 va_list va;
1569 int r;
1570 va_start(va, format);
1571 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1572 va_end(va);
1573 return r;
1574}
1575
1576int fstr_ctrl_get_data__(int *ctrl, int *line_no, const char *format, ...) {
1577 va_list va;
1578 int r;
1579 va_start(va, format);
1580 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1581 va_end(va);
1582 return r;
1583}
1584
1585int FSTR_CTRL_GET_DATA(int *ctrl, int *line_no, const char *format, ...) {
1586 va_list va;
1587 int r;
1588 va_start(va, format);
1589 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1590 va_end(va);
1591 return r;
1592}
1593
1594int FSTR_CTRL_GET_DATA_(int *ctrl, int *line_no, const char *format, ...) {
1595 va_list va;
1596 int r;
1597 va_start(va, format);
1598 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1599 va_end(va);
1600 return r;
1601}
1602
1603int FSTR_CTRL_GET_DATA__(int *ctrl, int *line_no, const char *format, ...) {
1604 va_list va;
1605 int r;
1606 va_start(va, format);
1607 r = fstr_ctrl_get_data_v_f(ctrl_list[*ctrl], *line_no, format, va);
1608 va_end(va);
1609 return r;
1610}
1611/*-----------------------------------------------------------------------------------*/
1612
1614 const char *format, va_list va) {
1615 int r;
1616 char fmt_c[STR_SIZE] = { '\0' };
1617 strcpy_f2c(fmt_c, format, STR_SIZE);
1618 r = c_fstr_ctrl_get_data_v(ctrl, line_no, fmt_c, va);
1619
1620 if (r != 0) {
1621 set_record_data_line_err_msg(ctrl, r);
1622 return -1;
1623 }
1624
1625 return 0;
1626}
1627
1628int fstr_ctrl_get_data_ex(int *ctrl, int *line_no, const char *format, ...) {
1629 va_list va;
1630 int r;
1631 va_start(va, format);
1632 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1633 va_end(va);
1634 return r;
1635}
1636
1637int fstr_ctrl_get_data_ex_(int *ctrl, int *line_no, const char *format, ...) {
1638 va_list va;
1639 int r;
1640 va_start(va, format);
1641 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1642 va_end(va);
1643 return r;
1644}
1645
1646int fstr_ctrl_get_data_ex__(int *ctrl, int *line_no, const char *format, ...) {
1647 va_list va;
1648 int r;
1649 va_start(va, format);
1650 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1651 va_end(va);
1652 return r;
1653}
1654
1655int FSTR_CTRL_GET_DATA_EX(int *ctrl, int *line_no, const char *format, ...) {
1656 va_list va;
1657 int r;
1658 va_start(va, format);
1659 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1660 va_end(va);
1661 return r;
1662}
1663
1664int FSTR_CTRL_GET_DATA_EX_(int *ctrl, int *line_no, const char *format, ...) {
1665 va_list va;
1666 int r;
1667 va_start(va, format);
1668 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1669 va_end(va);
1670 return r;
1671}
1672
1673int FSTR_CTRL_GET_DATA_EX__(int *ctrl, int *line_no, const char *format, ...) {
1674 va_list va;
1675 int r;
1676 va_start(va, format);
1677 r = fstr_ctrl_get_data_ex_v_f(ctrl_list[*ctrl], *line_no, format, va);
1678 va_end(va);
1679 return r;
1680}
1681
1682/*-----------------------------------------------------------------------------------*/
1683
1685 va_list va) {
1686 int r;
1687 char fmt_c[STR_SIZE];
1688 strcpy_f2c(fmt_c, format, STR_SIZE);
1690 r = c_fstr_ctrl_get_data_array_v(ctrl, fmt_c, va);
1692
1693 if (r != 0) {
1694 set_record_data_line_err_msg(ctrl, r);
1695 return -1;
1696 }
1697
1698 return 0;
1699}
1700
1701int fstr_ctrl_get_data_array_ex(int *ctrl, const char *format, ...) {
1702 va_list va;
1703 int r;
1704 va_start(va, format);
1705 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1706 va_end(va);
1707 return r;
1708}
1709
1710int fstr_ctrl_get_data_array_ex_(int *ctrl, const char *format, ...) {
1711 va_list va;
1712 int r;
1713 va_start(va, format);
1714 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1715 va_end(va);
1716 return r;
1717}
1718
1719int fstr_ctrl_get_data_array_ex__(int *ctrl, const char *format, ...) {
1720 va_list va;
1721 int r;
1722 va_start(va, format);
1723 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1724 va_end(va);
1725 return r;
1726}
1727
1728int FSTR_CTRL_GET_DATA_ARRAY_EX(int *ctrl, const char *format, ...) {
1729 va_list va;
1730 int r;
1731 va_start(va, format);
1732 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1733 va_end(va);
1734 return r;
1735}
1736
1737int FSTR_CTRL_GET_DATA_ARRAY_EX_(int *ctrl, const char *format, ...) {
1738 va_list va;
1739 int r;
1740 va_start(va, format);
1741 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1742 va_end(va);
1743 return r;
1744}
1745
1746int FSTR_CTRL_GET_DATA_ARRAY_EX__(int *ctrl, const char *format, ...) {
1747 va_list va;
1748 int r;
1749 va_start(va, format);
1750 r = fstr_ctrl_get_data_array_ex_v_f(ctrl_list[*ctrl], format, va);
1751 va_end(va);
1752 return r;
1753}
1754
1755/*-----------------------------------------------------------------------------------*/
1756
1757int fstr_ctrl_close(int *ctrl) {
1758 int fg = c_fstr_ctrl_close(ctrl_list[*ctrl]);
1759 HECMW_free(ctrl_list[*ctrl]);
1760 ctrl_list[*ctrl] = NULL;
1761 return fg;
1762}
1763
1764int fstr_ctrl_close_(int *ctrl) { return fstr_ctrl_close(ctrl); }
1765int fstr_ctrl_close__(int *ctrl) { return fstr_ctrl_close(ctrl); }
1766int FSTR_CTRL_CLOSE(int *ctrl) { return fstr_ctrl_close(ctrl); }
1767int FSTR_CTRL_CLOSE_(int *ctrl) { return fstr_ctrl_close(ctrl); }
1768int FSTR_CTRL_CLOSE__(int *ctrl) { return fstr_ctrl_close(ctrl); }
1769
1770/*-----------------------------------------------------------------------------------*/
1771
1772void fstr_ctrl_dump(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1773
1774void fstr_ctrl_dump_(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1775
1776void fstr_ctrl_dump__(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1777
1778void FSTR_CTRL_DUMP(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1779
1780void FSTR_CTRL_DUMP_(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1781
1782void FSTR_CTRL_DUMP__(int *ctrl) { c_fstr_ctrl_dump(ctrl_list[*ctrl]); }
1783
1784/* ==================================================================================*/
1785/* LOCAL UTIRITY FUNCTION */
1786/* ==================================================================================*/
1787
1788/* JP-20 */
1789
1790static void set_param_err_msg(fstr_ctrl_data *ctrl, const char *param_name,
1791 const char *msg) {
1792 sprintf(err_msg, "fstr control file error(param): line:%d, %s, %s\n",
1793 c_fstr_ctrl_get_current_header_line_no(ctrl), param_name, msg);
1794}
1795
1796/* JP-21 */
1797
1798static void set_data_err_msg(fstr_ctrl_data *ctrl, int line, int data_no,
1799 const char *msg) {
1801 sprintf(err_msg, "fstr control file error(data): line:%d, column:%d : %s\n",
1802 line, data_no, msg);
1803}
1804
1805static void set_record_data_line_err_msg(fstr_ctrl_data *ctrl, int r) {
1806 char msg[buffsize];
1808 int pos = fstr_ctrl_get_data_error_pos();
1809
1810 switch (r) {
1811 case 0:
1812 strcpy(msg, "no error");
1813 break;
1814
1816 strcpy(msg, "data type converting error");
1817 break;
1818
1820 strcpy(msg, "data range error");
1821 break;
1822
1824 strcpy(msg, "data must exist");
1825 break;
1826
1828 strcpy(msg, "data line does not exist");
1829 break;
1830
1831 default:
1832 sprintf(msg, "data line unknown error (r:%d)", r);
1833 }
1834
1835 set_data_err_msg(ctrl, line_no, pos, msg);
1836}
1837
1838/* JP-22 */
1839
1840static char *gettoken(const char *line) {
1841 static char buff[buffsize];
1842 static char *p;
1843 static char *h;
1844 char *token;
1845 char *t;
1846 int is_null = 0;
1847
1848 if (line) {
1849 strcpy(buff, line);
1850 h = p = buff;
1851
1852 } else {
1853 if (*p == 0 || *p == '\n' || *p == '\r') {
1854 return NULL;
1855 }
1856 }
1857
1858 for (;;) {
1859 if (*p == 0 || *p == '\n' || *p == '\r' || *p == ',') {
1860 if (*p == 0) {
1861 is_null = 1;
1862 }
1863
1864 *p = 0;
1865
1866 /* remove space in head */
1867 while (*h == ' ') {
1868 h++;
1869 }
1870
1871 /* remove space in tail */
1872 t = p;
1873
1874 if (t != buff) {
1875 t--;
1876
1877 while (*t == ' ' && t != h) {
1878 *t = 0;
1879 t--;
1880 }
1881 }
1882
1883 token = h;
1884 h = p;
1885 h++;
1886 break;
1887 }
1888
1889 p++;
1890 }
1891
1892 if (!is_null) {
1893 p++;
1894 }
1895
1896 return token;
1897}
1898
1899/* JP-23 */
1900/* JP-24 */
1901/* JP-25 */
1902/* JP-26 */
1903
1904static void strcpy_f2c(char *dest, const char *src, int len) {
1905 int i;
1906 int fg = 0;
1907
1908 for (i = 0; i < len - 1; i++) {
1909 if (src[i] != ' ') {
1910 fg = 1;
1911
1912 } else if (fg) {
1913 break;
1914 }
1915
1916 dest[i] = src[i];
1917 }
1918
1919 dest[i] = 0;
1920}
1921
1922/* JP-27 */
1923
1924static void strcpy_c2f(char *dest, int len, const char *src) {
1925 int i;
1926 int fg = 0;
1927
1928 for (i = 0; i < len; i++) {
1929 if (fg == 0 && src[i] == 0) {
1930 fg = 1;
1931 }
1932
1933 if (fg) {
1934 dest[i] = ' ';
1935
1936 } else {
1937 dest[i] = src[i];
1938 }
1939 }
1940}
1941
1942/* JP-28 */
1943
1944static char *remove_header_space(char *token) {
1945 char *p = token;
1946
1947 while (*p) {
1948 if (*p != ' ') {
1949 break;
1950 }
1951
1952 p++;
1953 }
1954
1955 return p;
1956}
1957
1958/* JP-29 */
1959
1960static int Strncmpi(const char *s1, const char *s2, int len) {
1961 char *p1, *p2;
1962 int i;
1963 p1 = (char *)s1;
1964 p2 = (char *)s2;
1965 i = 0;
1966
1967 while (*p1 && *p2 && i < len) {
1968 if (toupper(*p1) != toupper(*p2)) {
1969 return -1;
1970 }
1971
1972 p1++;
1973 p2++;
1974 i++;
1975 }
1976
1977 return 0;
1978}
1979
1980static int Strcmpi(const char *s1, const char *s2) {
1981 char *p1, *p2;
1982 p1 = (char *)s1;
1983 p2 = (char *)s2;
1984
1985 while (*p1 && *p2) {
1986 if (toupper(*p1) != toupper(*p2)) {
1987 return -1;
1988 }
1989
1990 p1++;
1991 p2++;
1992 }
1993
1994 if (*p1 || *p2) {
1995 return -1;
1996
1997 } else {
1998 return 0;
1999 }
2000}
2001
2002/* JP-30 */
2003#if 0
2004static
2005void Strupr(char *s) {
2006 while (*s) {
2007 *s = toupper(*s);
2008 s++;
2009 }
2010}
2011#endif
2012
2013/* JP-31 */
2014
2015static void remove_cr(char *s) {
2016 while (*s) {
2017 if (*s == '\n' || *s == '\r') {
2018 *s = 0;
2019 return;
2020 }
2021
2022 s++;
2023 }
2024}
2025
2026/* JP-32 */
2027
2028static void format_conv(const char *format, char *fmt, int *array_size) {
2029 char *p = (char *)format;
2030 int i = 0;
2031 int num_fg = 0;
2032 char num_str[buffsize] = { '\0' } ;
2033 int num_index = 0;
2034 int n;
2035
2036 while (*p) {
2037 if ('0' <= *p && *p <= '9') {
2038 num_fg = 1;
2039 num_str[num_index] = *p;
2040 num_index++;
2041
2042 } else {
2043 if (num_fg) {
2044 if (i == 0) {
2045 assert(0);
2046 }
2047
2048 num_str[num_index] = 0;
2049 sscanf(num_str, "%d", &n);
2050 array_size[i - 1] = n;
2051 num_fg = 0;
2052 num_index = 0;
2053 }
2054
2055 fmt[i] = *p;
2056 array_size[i] = 1;
2057 i++;
2058 }
2059
2060 p++;
2061 }
2062
2063 fmt[i] = 0;
2064
2065 if (num_fg) {
2066 if (i == 0) {
2067 assert(0);
2068 }
2069
2070 num_str[num_index] = 0;
2071 sscanf(num_str, "%d", &n);
2072 array_size[i - 1] = n;
2073 }
2074}
void FSTR_CTRL_DUMP_(int *ctrl)
int fstr_ctrl_open__(char *filename)
int fstr_ctrl_get_data_n_in_line_(int *ctrl, int *line_no, const char *delim)
int FSTR_CTRL_GET_C_H_LINE_NO_(int *ctrl)
int fg_fortran_get_data_array_v
int fstr_ctrl_get_param_ex(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
int fstr_ctrl_get_c_h_line_no(int *ctrl)
int FSTR_CTRL_GET_C_H_LINE_NO__(int *ctrl)
int fstr_ctrl_get_line_(int *ctrl, int *rec_no, char *buff, int *buff_size)
int fstr_ctrl_close(int *ctrl)
int fstr_ctrl_get_rec_number(int *ctrl)
int FSTR_CTRL_REWIND__(int *ctrl)
int fstr_ctrl_get_c_h_name_(int *ctrl, char *header_name, int *buff_size)
int fstr_ctrl_get_data_(int *ctrl, int *line_no, const char *format,...)
int c_fstr_ctrl_seek_next_header(fstr_ctrl_data *ctrl)
int FSTR_CTRL_OPEN__(char *filename)
int FSTR_CTRL_OPEN(char *filename)
int FSTR_CTRL_GET_DATA_EX(int *ctrl, int *line_no, const char *format,...)
int fstr_ctrl_get_line__(int *ctrl, int *rec_no, char *buff, int *buff_size)
void c_fstr_ctrl_get_err_msg(char *buff)
int is_first
int fstr_ctrl_get_data_line_n_(int *ctrl)
int FSTR_CTRL_GET_DATA(int *ctrl, int *line_no, const char *format,...)
int fstr_ctrl_get_data_line_n__(int *ctrl)
void FSTR_CTRL_GET_ERR_MSG(char *f_buff, int *len)
int fstr_ctrl_get_data_n_in_line__(int *ctrl, int *line_no, const char *delim)
int FSTR_CTRL_GET_PARAM__(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
int fstr_ctrl_get_c_h_pos_(int *ctrl)
void FSTR_CTRL_GET_ERR_MSG__(char *f_buff, int *len)
int FSTR_CTRL_SEEK_NEXT_HEADER__(int *ctrl)
int fstr_ctrl_get_data_n_in_line(int *ctrl, int *line_no, const char *delim)
int fstr_ctrl_rewind__(int *ctrl)
int c_fstr_ctrl_get_rec_number(fstr_ctrl_data *ctrl)
#define STR_SIZE
int c_fstr_ctrl_get_current_header_name(fstr_ctrl_data *ctrl, char *header_name)
int fstr_ctrl_seek_header_(int *ctrl, const char *header_name)
int fstr_ctrl_get_data_line_n(int *ctrl)
int FSTR_CTRL_GET_DATA_LINE_N_(int *ctrl)
int fstr_ctrl_tmp_rewind(fstr_ctrl_data *ctrl)
int FSTR_CTRL_GET_PARAM_EX(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
int fstr_ctrl_seek_next_header(int *ctrl)
int FSTR_CTRL_GET_C_H_NAME(int *ctrl, char *header_name, int *buff_size)
int FSTR_CTRL_GET_DATA_ERROR_LINE__(void)
int FSTR_CTRL_GET_C_H_NAME__(int *ctrl, char *header_name, int *buff_size)
int FSTR_CTRL_GET_PARAM_(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
int FSTR_CTRL_GET_DATA_N_IN_LINE(int *ctrl, int *line_no, const char *delim)
int fstr_ctrl_get_c_h_line_no_(int *ctrl)
void fstr_ctrl_get_err_msg__(char *f_buff, int *len)
int fstr_ctrl_get_param_(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
#define buffsize
int fstr_ctrl_get_data_v_f(fstr_ctrl_data *ctrl, int line_no, const char *format, va_list va)
int FSTR_CTRL_GET_LINE(int *ctrl, int *rec_no, char *buff, int *buff_size)
void fstr_ctrl_get_err_msg(char *f_buff, int *len)
int error_line
int FSTR_CTRL_GET_C_H_POS(int *ctrl)
int FSTR_CTRL_CLOSE_(int *ctrl)
int fstr_ctrl_get_data_error_pos(void)
int fstr_ctrl_get_data_error_line_(void)
int fstr_ctrl_get_line(int *ctrl, int *rec_no, char *buff, int *buff_size)
int c_fstr_ctrl_get_data_array_v(fstr_ctrl_data *ctrl, const char *format, va_list va)
int fstr_ctrl_get_data_ex_v_f(fstr_ctrl_data *ctrl, int line_no, const char *format, va_list va)
int FSTR_CTRL_GET_C_H_NAME_(int *ctrl, char *header_name, int *buff_size)
int fstr_ctrl_get_data_error_line(void)
int c_fstr_ctrl_close(fstr_ctrl_data *ctrl)
int FSTR_CTRL_REWIND_(int *ctrl)
int fstr_ctrl_get_c_h_line_no__(int *ctrl)
int error_pos
int FSTR_CTRL_GET_LINE_(int *ctrl, int *rec_no, char *buff, int *buff_size)
int fstr_ctrl_get_data_array_ex(int *ctrl, const char *format,...)
int fstr_ctrl_get_param_ex_(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
int c_fstr_ctrl_get_data_array(fstr_ctrl_data *ctrl, const char *format,...)
int fstr_ctrl_get_data_ex__(int *ctrl, int *line_no, const char *format,...)
int FSTR_CTRL_SEEK_HEADER__(int *ctrl, const char *header_name)
int FSTR_CTRL_GET_C_H_POS_(int *ctrl)
void fstr_ctrl_dump_(int *ctrl)
int fstr_ctrl_open_(char *filename)
int fstr_ctrl_seek_header(int *ctrl, const char *header_name)
int c_fstr_ctrl_get_param_ex(fstr_ctrl_data *ctrl, const char *param_name, const char *value_list, int necessity, char type, void *val)
int fstr_ctrl_open(char *filename)
void fstr_ctrl_dump(int *ctrl)
int c_fstr_ctrl_seek_header(fstr_ctrl_data *ctrl, const char *header_name)
int FSTR_CTRL_SEEK_HEADER(int *ctrl, const char *header_name)
int c_fstr_ctrl_get_data_array_ex(fstr_ctrl_data *ctrl, const char *format,...)
int fstr_ctrl_get_data_error_pos_(void)
int FSTR_CTRL_GET_DATA_(int *ctrl, int *line_no, const char *format,...)
int c_fstr_ctrl_get_data_line_n(fstr_ctrl_data *ctrl)
int c_fstr_ctrl_get_data_error_pos(void)
int c_fstr_ctrl_get_current_header_pos(fstr_ctrl_data *ctrl)
int fstr_ctrl_get_param__(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
int line_no
int c_fstr_ctrl_get_data_ex(fstr_ctrl_data *ctrl, int line_no, const char *format,...)
int fstr_ctrl_get_data_error_line__(void)
int FSTR_CTRL_SEEK_NEXT_HEADER(int *ctrl)
int FSTR_CTRL_GET_LINE__(int *ctrl, int *rec_no, char *buff, int *buff_size)
int FSTR_CTRL_GET_C_H_POS__(int *ctrl)
void fstr_ctrl_dump__(int *ctrl)
int FSTR_CTRL_SEEK_NEXT_HEADER_(int *ctrl)
int FSTR_CTRL_GET_DATA_ARRAY_EX_(int *ctrl, const char *format,...)
int c_fstr_ctrl_get_data_n_in_line(fstr_ctrl_data *ctrl, int line_no, const char *delim)
int FSTR_CTRL_CLOSE(int *ctrl)
int fstr_ctrl_seek_next_header__(int *ctrl)
int fstr_ctrl_seek_header__(int *ctrl, const char *header_name)
int FSTR_CTRL_GET_PARAM_EX_(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
#define FILE_NAME_SIZE
void FSTR_CTRL_DUMP__(int *ctrl)
#define TRUE
int FSTR_CTRL_GET_DATA__(int *ctrl, int *line_no, const char *format,...)
#define FALSE
int fstr_ctrl_get_data_array_ex__(int *ctrl, const char *format,...)
int FSTR_CTRL_GET_REC_NUMBER(int *ctrl)
int fstr_ctrl_get_data(int *ctrl, int *line_no, const char *format,...)
int c_fstr_ctrl_get_current_header_line_no(fstr_ctrl_data *ctrl)
int FSTR_CTRL_GET_DATA_ERROR_(void)
int fstr_ctrl_get_c_h_name(int *ctrl, char *header_name, int *buff_size)
int fstr_ctrl_get_data_ex(int *ctrl, int *line_no, const char *format,...)
int FSTR_CTRL_GET_PARAM(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
int FSTR_CTRL_OPEN_(char *filename)
int c_fstr_ctrl_copy_data_line(fstr_ctrl_data *ctrl, int line_no, char *data_line)
int FSTR_CTRL_GET_DATA_ERROR_LINE(void)
int fstr_ctrl_get_c_h_pos__(int *ctrl)
int FSTR_CTRL_GET_DATA_EX_(int *ctrl, int *line_no, const char *format,...)
void FSTR_CTRL_GET_ERR_MSG_(char *f_buff, int *len)
int fstr_ctrl_get_c_h_pos(int *ctrl)
int fstr_ctrl_get_data_array_ex_v_f(fstr_ctrl_data *ctrl, const char *format, va_list va)
int FSTR_CTRL_CLOSE__(int *ctrl)
int fstr_ctrl_get_c_h_name__(int *ctrl, char *header_name, int *buff_size)
int FSTR_CTRL_GET_DATA_N_IN_LINE__(int *ctrl, int *line_no, const char *delim)
#define MAX_DATA_ARRAY_NUMBER
int FSTR_CTRL_GET_REC_NUMBER__(int *ctrl)
int fstr_ctrl_get_data__(int *ctrl, int *line_no, const char *format,...)
int fstr_ctrl_rewind_(int *ctrl)
int FSTR_CTRL_GET_DATA_ARRAY_EX(int *ctrl, const char *format,...)
char err_msg[buffsize]
int FSTR_CTRL_GET_DATA_LINE_N(int *ctrl)
int fstr_ctrl_get_data_array_ex_(int *ctrl, const char *format,...)
int FSTR_CTRL_REWIND(int *ctrl)
int c_fstr_ctrl_get_data(fstr_ctrl_data *ctrl, int line_no, const char *format,...)
int fstr_ctrl_close__(int *ctrl)
void FSTR_CTRL_DUMP(int *ctrl)
int FSTR_CTRL_GET_PARAM_EX__(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
int FSTR_CTRL_GET_DATA_N_IN_LINE_(int *ctrl, int *line_no, const char *delim)
int fstr_ctrl_rewind(int *ctrl)
int FSTR_CTRL_GET_C_H_LINE_NO(int *ctrl)
int c_fstr_ctrl_get_line(fstr_ctrl_data *ctrl, int rec_no, char *buff)
int fstr_ctrl_get_rec_number__(int *ctrl)
int FSTR_CTRL_GET_DATA_ERROR__(void)
void c_fstr_ctrl_dump(fstr_ctrl_data *ctrl)
int c_fstr_ctrl_get_param(fstr_ctrl_data *ctrl, const char *param_name, const char *value_list, char type, void *val)
int c_fstr_ctrl_get_data_v(fstr_ctrl_data *ctrl, int line_no, const char *format, va_list va)
int FSTR_CTRL_GET_DATA_ERROR_LINE_(void)
int fstr_ctrl_get_rec_number_(int *ctrl)
int fstr_ctrl_close_(int *ctrl)
int FSTR_CTRL_SEEK_HEADER_(int *ctrl, const char *header_name)
int fstr_ctrl_get_param(int *ctrl, const char *param_name, const char *value_list, char *type, void *val)
int fstr_ctrl_seek_next_header_(int *ctrl)
int FSTR_CTRL_GET_REC_NUMBER_(int *ctrl)
fstr_ctrl_data * c_fstr_ctrl_open(const char *filename)
void fstr_ctrl_get_err_msg_(char *f_buff, int *len)
int FSTR_CTRL_GET_DATA_ARRAY_EX__(int *ctrl, const char *format,...)
int FSTR_CTRL_GET_DATA_LINE_N__(int *ctrl)
int fstr_ctrl_get_param_ex__(int *ctrl, const char *param_name, const char *value_list, int *necessity, char *type, void *val)
int fstr_ctrl_get_data_error_pos__(void)
int FSTR_CTRL_GET_DATA_EX__(int *ctrl, int *line_no, const char *format,...)
int c_fstr_ctrl_get_data_error_line(void)
int fstr_ctrl_get_data_ex_(int *ctrl, int *line_no, const char *format,...)
#define FSTR_CTRL_RCODE_PARAM_TYPE_ERROR
#define FSTR_CTRL_RCODE_DATA_TYPE_ERROR
#define FSTR_CTRL_RCODE_DATA_RANGE_ERROR
#define FSTR_CTRL_RCODE_PARAM_NOTHING
fstr_ctrl_data * ctrl_list[ctrl_list_size]
#define FSTR_CTRL_RCODE_DATA_ERROR
#define FSTR_CTRL_RCODE_DATA_SUCCESS
#define FSTR_CTRL_RCODE_PARAM_RANGE_ERROR
#define ctrl_list_size
#define FSTR_CTRL_RCODE_DATA_LINE_NOTHING
#define FSTR_CTRL_RCODE_PARAM_VALUE_NOTHING
#define FSTR_CTRL_RCODE_DATA_NOTHING
#define FSTR_CTRL_RCODE_PARAM_SUCCESS
HECMW_Comm HECMW_comm_get_comm(void)
Definition: hecmw_comm.c:699
int HECMW_comm_get_rank(void)
Definition: hecmw_comm.c:707
int HECMW_Bcast(void *buffer, int count, HECMW_Datatype datatype, int root, HECMW_Comm comm)
Definition: hecmw_comm.c:151
#define HECMW_INT
Definition: hecmw_config.h:48
MPI_Comm HECMW_Comm
Definition: hecmw_config.h:30
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
#define HECMW_CHAR
Definition: hecmw_config.h:52
#define NULL
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
subroutine assert(cond, mesg)
Assertion routine for debugging.
void toupper(char *s)
Definition: hecd_util.cpp:37