1 /*
2 * (C) Copyright 2005- ECMWF.
3 *
4 * This software is licensed under the terms of the Apache Licence Version 2.0
5 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6 *
7 * In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
8 * virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
9 */
10
11 #include "grib_api_internal.h"
12 #include "grib_fortran_prototypes.h"
13
14 #if HAVE_SYS_TYPES_H
15 # include <sys/types.h>
16 #endif
17
18 /*
19 #if HAVE_SYS_STAT_H
20 # include <sys/stat.h>
21 #endif
22 */
23
24 #ifdef HAVE_FCNTL_H
25 # include <fcntl.h>
26 #endif
27
28 #include <ctype.h>
29
30 /* Have file ids distinct from grib ids, in order to be
31 * protected against user errors where a file id is given
32 * instead of a grib id or viceversa
33 */
34 #define MIN_FILE_ID 50000
35
36 #if GRIB_PTHREADS
37 static pthread_once_t once = PTHREAD_ONCE_INIT;
38 static pthread_mutex_t handle_mutex = PTHREAD_MUTEX_INITIALIZER;
39 static pthread_mutex_t index_mutex = PTHREAD_MUTEX_INITIALIZER;
40 static pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;
41 static pthread_mutex_t multi_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
42 static pthread_mutex_t iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
43 static pthread_mutex_t keys_iterator_mutex = PTHREAD_MUTEX_INITIALIZER;
44
init()45 static void init() {
46 pthread_mutexattr_t attr;
47
48 pthread_mutexattr_init(&attr);
49 pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
50 pthread_mutex_init(&handle_mutex,&attr);
51 pthread_mutex_init(&index_mutex,&attr);
52 pthread_mutex_init(&read_mutex,&attr);
53 pthread_mutex_init(&multi_handle_mutex,&attr);
54 pthread_mutex_init(&iterator_mutex,&attr);
55 pthread_mutex_init(&keys_iterator_mutex,&attr);
56 pthread_mutexattr_destroy(&attr);
57 }
58 #elif GRIB_OMP_THREADS
59 static int once = 0;
60 static omp_nest_lock_t handle_mutex;
61 static omp_nest_lock_t index_mutex;
62 static omp_nest_lock_t read_mutex;
63 static omp_nest_lock_t multi_handle_mutex;
64 static omp_nest_lock_t iterator_mutex;
65 static omp_nest_lock_t keys_iterator_mutex;
66
init()67 static void init()
68 {
69 GRIB_OMP_CRITICAL(lock_fortran)
70 {
71 if (once == 0)
72 {
73 omp_init_nest_lock(&handle_mutex);
74 omp_init_nest_lock(&index_mutex);
75 omp_init_nest_lock(&read_mutex);
76 omp_init_nest_lock(&multi_handle_mutex);
77 omp_init_nest_lock(&iterator_mutex);
78 omp_init_nest_lock(&keys_iterator_mutex);
79 once = 1;
80 }
81 }
82 }
83 #endif
84
85 int GRIB_NULL=-1;
86 int GRIB_NULL_NEAREST=-1;
87 /*extern int errno;*/
88
89 typedef struct l_grib_file l_grib_file;
90
91 struct l_grib_file {
92 FILE* f;
93 char* buffer;
94 int id;
95 l_grib_file* next;
96 };
97
98 typedef struct l_grib_handle l_grib_handle;
99
100 struct l_grib_handle {
101 int id;
102 grib_handle* h;
103 l_grib_handle* next;
104 };
105
106 typedef struct l_grib_index l_grib_index;
107
108 struct l_grib_index {
109 int id;
110 grib_index* h;
111 l_grib_index* next;
112 };
113
114 typedef struct l_grib_multi_handle l_grib_multi_handle;
115
116 struct l_grib_multi_handle {
117 int id;
118 grib_multi_handle* h;
119 l_grib_multi_handle* next;
120 };
121
122 typedef struct l_grib_iterator l_grib_iterator;
123
124 struct l_grib_iterator {
125 int id;
126 grib_iterator* i;
127 l_grib_iterator* next;
128 };
129
130 typedef struct l_grib_keys_iterator l_grib_keys_iterator;
131 struct l_grib_keys_iterator {
132 int id;
133 grib_keys_iterator* i;
134 l_grib_keys_iterator* next;
135 };
136
137 typedef struct l_bufr_keys_iterator l_bufr_keys_iterator;
138 struct l_bufr_keys_iterator {
139 int id;
140 bufr_keys_iterator* i;
141 l_bufr_keys_iterator* next;
142 };
143
144 typedef struct l_binary_message l_binary_message;
145 struct l_binary_message {
146 size_t size;
147 void* data;
148 };
149
150 typedef struct l_message_info l_message_info;
151 struct l_message_info {
152 off_t offset;
153 size_t size;
154 };
155
156 static l_grib_handle* handle_set = NULL;
157 static l_grib_index* index_set = NULL;
158 static l_grib_multi_handle* multi_handle_set = NULL;
159 static l_grib_file* file_set = NULL;
160 static l_grib_iterator* iterator_set = NULL;
161 static l_grib_keys_iterator* keys_iterator_set = NULL;
162 static l_bufr_keys_iterator* bufr_keys_iterator_set = NULL;
163 static grib_oarray* binary_messages = NULL;
164 static grib_oarray* info_messages = NULL;
165
cast_char(char * buf,char * fortstr,int len)166 static char* cast_char(char* buf, char* fortstr,int len)
167 {
168 char *p,*end;
169 if (len == 0 || fortstr == NULL) return NULL;
170 memcpy(buf,fortstr,len);
171 p=buf;
172 end=buf+len-1;
173 while (isgraph(*p) && p != end) {
174 p++;
175 }
176 if (*p==' ') *p='\0';
177 if (p==end) *(p+1)='\0';
178 else *p='\0';
179
180 return buf;
181 }
182
cast_char_no_cut(char * buf,char * fortstr,int len)183 static char* cast_char_no_cut(char* buf, char* fortstr,int len)
184 {
185 if (len == 0 || fortstr == NULL) return NULL;
186 memcpy(buf,fortstr,len);
187 buf[len]='\0';
188
189 return buf;
190 }
191
czstr_to_fortran(char * str,int len)192 static void czstr_to_fortran(char* str,int len)
193 {
194 char *p,*end;
195 p=str; end=str+len-1;
196 while (*p != '\0' && p != end) p++;
197 while (p !=end) *(p++)=' ';
198 *p=' ';
199 }
200
201 /*static void czstr_to_fortran_replace0(char* str,int len)
202 {
203 char *p,*end;
204 p=str; end=str+len-1;
205 while (p != end) {
206 if (*p=='\0') *p=' ';
207 p++;
208 }
209 }*/
210
fort_char_clean(char * str,int len)211 static void fort_char_clean(char* str,int len)
212 {
213 char *p,*end;
214 p=str; end=str+len-1;
215 while (p != end) *(p++)=' ';
216 *p=' ';
217 }
218
push_file(FILE * f,char * buffer)219 static int push_file(FILE* f,char* buffer)
220 {
221 l_grib_file* current = file_set;
222 l_grib_file* previous = file_set;
223 l_grib_file* the_new = NULL;
224 int myindex = MIN_FILE_ID;
225
226 if(!file_set){
227 file_set = (l_grib_file*)malloc(sizeof(l_grib_file));
228 Assert(file_set);
229 file_set->id = myindex;
230 file_set->f = f;
231 file_set->buffer =buffer;
232 file_set->next = NULL;
233 return myindex;
234 }
235
236 while(current){
237 if(current->id < 0){
238 current->id = -(current->id);
239 current->f = f;
240 current->buffer = buffer;
241 return current->id ;
242 } else{
243 myindex++;
244 previous = current;
245 current = current->next;
246 }
247 }
248
249 the_new = (l_grib_file*)malloc(sizeof(l_grib_file));
250 Assert(the_new);
251 the_new->id = myindex;
252 the_new->f = f;
253 the_new->buffer = buffer;
254 the_new->next = current;
255 previous->next = the_new;
256 return myindex;
257 }
258
_push_handle(grib_handle * h,int * gid)259 static void _push_handle(grib_handle *h,int *gid)
260 {
261 l_grib_handle* current= NULL;
262 l_grib_handle* previous= handle_set;
263 l_grib_handle* the_new= NULL;
264 int myindex= 1;
265
266 /*
267 if (*gid > 0 ) {
268 while(current) {
269 if(current->id == *gid) break;
270 current = current->next;
271 }
272 if (current) {
273 grib_handle_delete(current->h);
274 current->h=h;
275 return;
276 }
277 }
278 */
279
280 if(!handle_set){
281 handle_set = (l_grib_handle*)malloc(sizeof(l_grib_handle));
282 Assert(handle_set);
283 handle_set->id = myindex;
284 handle_set->h = h;
285 handle_set->next = NULL;
286 *gid=myindex;
287 return;
288 }
289
290 current= handle_set;
291
292 while(current){
293 if(current->id < 0){
294 current->id = -(current->id);
295 current->h = h;
296 *gid=current->id;
297 return;
298 }
299 else{
300 myindex++;
301 previous = current;
302 current = current->next;
303 }
304 }
305
306 the_new = (l_grib_handle*)malloc(sizeof(l_grib_handle));
307 Assert(the_new);
308 the_new->id = myindex;
309 the_new->h = h;
310 the_new->next = current;
311 previous->next = the_new;
312
313 *gid=myindex;
314 return;
315 }
316
_push_index(grib_index * h,int * gid)317 static void _push_index(grib_index *h,int *gid)
318 {
319 l_grib_index* current= NULL;
320 l_grib_index* previous= index_set;
321 l_grib_index* the_new= NULL;
322 int myindex= 1;
323
324 /*
325 if (*gid > 0 ) {
326 while(current) {
327 if(current->id == *gid) break;
328 current = current->next;
329 }
330 if (current) {
331 grib_index_delete(current->h);
332 current->h=h;
333 return;
334 }
335 }
336 */
337
338 if(!index_set){
339 index_set = (l_grib_index*)malloc(sizeof(l_grib_index));
340 Assert(index_set);
341 index_set->id = myindex;
342 index_set->h = h;
343 index_set->next = NULL;
344 *gid=myindex;
345 return;
346 }
347
348 current= index_set;
349
350 while(current){
351 if(current->id < 0){
352 current->id = -(current->id);
353 current->h = h;
354 *gid=current->id;
355 return;
356 }
357 else{
358 myindex++;
359 previous = current;
360 current = current->next;
361 }
362 }
363
364 the_new = (l_grib_index*)malloc(sizeof(l_grib_index));
365 Assert(the_new);
366 the_new->id = myindex;
367 the_new->h = h;
368 the_new->next = current;
369 previous->next = the_new;
370
371 *gid=myindex;
372 return;
373 }
374
_push_multi_handle(grib_multi_handle * h,int * gid)375 static void _push_multi_handle(grib_multi_handle *h,int *gid)
376 {
377 l_grib_multi_handle* current= NULL;
378 l_grib_multi_handle* previous= multi_handle_set;
379 l_grib_multi_handle* the_new= NULL;
380 int myindex= 1;
381
382 /*
383 if (*gid > 0 ) {
384 while(current) {
385 if(current->id == *gid) break;
386 current = current->next;
387 }
388 if (current) {
389 grib_multi_handle_delete(current->h);
390 current->h=h;
391 return;
392 }
393 }
394 */
395
396 if(!multi_handle_set){
397 multi_handle_set = (l_grib_multi_handle*)malloc(sizeof(l_grib_multi_handle));
398 Assert(multi_handle_set);
399 multi_handle_set->id = myindex;
400 multi_handle_set->h = h;
401 multi_handle_set->next = NULL;
402 *gid=myindex;
403 return;
404 }
405
406 current= multi_handle_set;
407
408 while(current){
409 if(current->id < 0){
410 current->id = -(current->id);
411 current->h = h;
412 *gid=current->id;
413 return;
414 }
415 else{
416 myindex++;
417 previous = current;
418 current = current->next;
419 }
420 }
421
422 the_new = (l_grib_multi_handle*)malloc(sizeof(l_grib_multi_handle));
423 Assert(the_new);
424 the_new->id = myindex;
425 the_new->h = h;
426 the_new->next = current;
427 previous->next = the_new;
428
429 *gid=myindex;
430 return;
431 }
432
push_handle(grib_handle * h,int * gid)433 static void push_handle(grib_handle *h,int *gid)
434 {
435 GRIB_MUTEX_INIT_ONCE(&once,&init);
436 GRIB_MUTEX_LOCK(&handle_mutex);
437 _push_handle(h,gid);
438 GRIB_MUTEX_UNLOCK(&handle_mutex);
439 return;
440 }
441
push_index(grib_index * h,int * gid)442 static void push_index(grib_index *h,int *gid)
443 {
444 GRIB_MUTEX_INIT_ONCE(&once,&init);
445 GRIB_MUTEX_LOCK(&index_mutex);
446 _push_index(h,gid);
447 GRIB_MUTEX_UNLOCK(&index_mutex);
448 return;
449 }
450
push_multi_handle(grib_multi_handle * h,int * gid)451 static void push_multi_handle(grib_multi_handle *h,int *gid)
452 {
453 GRIB_MUTEX_INIT_ONCE(&once,&init);
454 GRIB_MUTEX_LOCK(&multi_handle_mutex);
455 _push_multi_handle(h,gid);
456 GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
457 return;
458 }
459
_push_iterator(grib_iterator * i)460 static int _push_iterator(grib_iterator *i)
461 {
462 l_grib_iterator* current = iterator_set;
463 l_grib_iterator* previous = iterator_set;
464 l_grib_iterator* the_new = NULL;
465 int myindex = 1;
466
467 if(!iterator_set){
468 iterator_set = (l_grib_iterator*)malloc(sizeof(l_grib_iterator));
469 Assert(iterator_set);
470 iterator_set->id = myindex;
471 iterator_set->i = i;
472 iterator_set->next = NULL;
473 return myindex;
474 }
475
476 while(current){
477 if(current->id < 0){
478 current->id = -(current->id);
479 current->i = i;
480 return current->id;
481 }
482 else{
483 myindex++;
484 previous = current;
485 current = current->next;
486 }
487 }
488
489 the_new = (l_grib_iterator*)malloc(sizeof(l_grib_iterator));
490 Assert(the_new);
491 the_new->id = myindex;
492 the_new->i = i;
493 the_new->next = current;
494 previous->next = the_new;
495
496 return myindex;
497 }
498
push_iterator(grib_iterator * i)499 static int push_iterator(grib_iterator *i)
500 {
501 int ret=0;
502 GRIB_MUTEX_INIT_ONCE(&once,&init);
503 GRIB_MUTEX_LOCK(&iterator_mutex);
504 ret=_push_iterator(i);
505 GRIB_MUTEX_UNLOCK(&iterator_mutex);
506 return ret;
507 }
508
_push_keys_iterator(grib_keys_iterator * i)509 static int _push_keys_iterator(grib_keys_iterator *i)
510 {
511 l_grib_keys_iterator* current = keys_iterator_set;
512 l_grib_keys_iterator* previous = keys_iterator_set;
513 l_grib_keys_iterator* the_new = NULL;
514 int myindex = 1;
515
516 if(!keys_iterator_set){
517 keys_iterator_set = (l_grib_keys_iterator*)malloc(sizeof(l_grib_keys_iterator));
518 Assert(keys_iterator_set);
519 keys_iterator_set->id = myindex;
520 keys_iterator_set->i = i;
521 keys_iterator_set->next = NULL;
522 return myindex;
523 }
524
525 while(current){
526 if(current->id < 0){
527 current->id = -(current->id);
528 current->i = i;
529 return current->id;
530 }
531 else{
532 myindex++;
533 previous = current;
534 current = current->next;
535 }
536 }
537 if(!previous) return -1;
538
539 the_new = (l_grib_keys_iterator*)malloc(sizeof(l_grib_keys_iterator));
540 Assert(the_new);
541 the_new->id = myindex;
542 the_new->i = i;
543 the_new->next = current;
544 previous->next = the_new;
545
546 return myindex;
547 }
548
push_keys_iterator(grib_keys_iterator * i)549 static int push_keys_iterator(grib_keys_iterator *i)
550 {
551 int ret=0;
552 GRIB_MUTEX_INIT_ONCE(&once,&init);
553 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
554 ret=_push_keys_iterator(i);
555 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
556 return ret;
557 }
558
559 /* BUFR Keys iterator */
_push_bufr_keys_iterator(bufr_keys_iterator * i)560 static int _push_bufr_keys_iterator(bufr_keys_iterator *i)
561 {
562 l_bufr_keys_iterator* current = bufr_keys_iterator_set;
563 l_bufr_keys_iterator* previous = bufr_keys_iterator_set;
564 l_bufr_keys_iterator* the_new = NULL;
565 int myindex = 1;
566
567 if(!bufr_keys_iterator_set){
568 bufr_keys_iterator_set = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
569 Assert(bufr_keys_iterator_set);
570 bufr_keys_iterator_set->id = myindex;
571 bufr_keys_iterator_set->i = i;
572 bufr_keys_iterator_set->next = NULL;
573 return myindex;
574 }
575
576 while(current){
577 if(current->id < 0){
578 current->id = -(current->id);
579 current->i = i;
580 return current->id;
581 }
582 else{
583 myindex++;
584 previous = current;
585 current = current->next;
586 }
587 }
588 if(!previous) return -1;
589
590 the_new = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
591 Assert(the_new);
592 the_new->id = myindex;
593 the_new->i = i;
594 the_new->next = current;
595 previous->next = the_new;
596
597 return myindex;
598 }
push_bufr_keys_iterator(bufr_keys_iterator * i)599 static int push_bufr_keys_iterator(bufr_keys_iterator *i)
600 {
601 int ret=0;
602 GRIB_MUTEX_INIT_ONCE(&once,&init);
603 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
604 ret=_push_bufr_keys_iterator(i);
605 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
606 return ret;
607 }
608
609
_get_handle(int handle_id)610 static grib_handle* _get_handle(int handle_id)
611 {
612 l_grib_handle* current= handle_set;
613
614 while(current){
615 if(current->id == handle_id) return current->h;
616 current = current->next;
617 }
618 return NULL;
619 }
620
_get_index(int index_id)621 static grib_index* _get_index(int index_id)
622 {
623 l_grib_index* current= index_set;
624
625 while(current){
626 if(current->id == index_id) return current->h;
627 current = current->next;
628 }
629 return NULL;
630 }
631
_get_multi_handle(int multi_handle_id)632 static grib_multi_handle* _get_multi_handle(int multi_handle_id)
633 {
634 l_grib_multi_handle* current= multi_handle_set;
635
636 while(current){
637 if(current->id == multi_handle_id) return current->h;
638 current = current->next;
639 }
640 return NULL;
641 }
642
get_handle(int handle_id)643 static grib_handle* get_handle(int handle_id)
644 {
645 grib_handle* h=NULL;
646 GRIB_MUTEX_INIT_ONCE(&once,&init);
647 GRIB_MUTEX_LOCK(&handle_mutex);
648 h=_get_handle(handle_id);
649 GRIB_MUTEX_UNLOCK(&handle_mutex);
650 return h;
651 }
652
get_index(int index_id)653 static grib_index* get_index(int index_id)
654 {
655 grib_index* h=NULL;
656 GRIB_MUTEX_INIT_ONCE(&once,&init);
657 GRIB_MUTEX_LOCK(&index_mutex);
658 h=_get_index(index_id);
659 GRIB_MUTEX_UNLOCK(&index_mutex);
660 return h;
661 }
662
get_multi_handle(int multi_handle_id)663 static grib_multi_handle* get_multi_handle(int multi_handle_id)
664 {
665 grib_multi_handle* h=NULL;
666 GRIB_MUTEX_INIT_ONCE(&once,&init);
667 GRIB_MUTEX_LOCK(&multi_handle_mutex);
668 h=_get_multi_handle(multi_handle_id);
669 GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
670 return h;
671 }
672
get_file(int file_id)673 static FILE* get_file(int file_id)
674 {
675 l_grib_file* current = file_set;
676
677 if ( file_id < MIN_FILE_ID ) return NULL;
678
679 while(current){
680 if(current->id == file_id) return current->f;
681 current = current->next;
682 }
683 return NULL;
684 }
685
_get_iterator(int iterator_id)686 static grib_iterator* _get_iterator(int iterator_id)
687 {
688 l_grib_iterator* current = iterator_set;
689
690 while(current){
691 if(current->id == iterator_id) return current->i;
692 current = current->next;
693 }
694 return NULL;
695 }
696
get_iterator(int iterator_id)697 static grib_iterator* get_iterator(int iterator_id)
698 {
699 grib_iterator* i=NULL;
700 GRIB_MUTEX_INIT_ONCE(&once,&init);
701 GRIB_MUTEX_LOCK(&iterator_mutex);
702 i=_get_iterator(iterator_id);
703 GRIB_MUTEX_UNLOCK(&iterator_mutex);
704 return i;
705 }
706
_get_keys_iterator(int keys_iterator_id)707 static grib_keys_iterator* _get_keys_iterator(int keys_iterator_id)
708 {
709 l_grib_keys_iterator* current = keys_iterator_set;
710
711 while(current){
712 if(current->id == keys_iterator_id) return current->i;
713 current = current->next;
714 }
715 return NULL;
716 }
get_keys_iterator(int keys_iterator_id)717 static grib_keys_iterator* get_keys_iterator(int keys_iterator_id)
718 {
719 grib_keys_iterator* i=NULL;
720 GRIB_MUTEX_INIT_ONCE(&once,&init);
721 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
722 i=_get_keys_iterator(keys_iterator_id);
723 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
724 return i;
725 }
726
727 /* BUFR */
_get_bufr_keys_iterator(int keys_iterator_id)728 static bufr_keys_iterator* _get_bufr_keys_iterator(int keys_iterator_id)
729 {
730 l_bufr_keys_iterator* current = bufr_keys_iterator_set;
731
732 while(current){
733 if(current->id == keys_iterator_id) return current->i;
734 current = current->next;
735 }
736 return NULL;
737 }
get_bufr_keys_iterator(int keys_iterator_id)738 static bufr_keys_iterator* get_bufr_keys_iterator(int keys_iterator_id)
739 {
740 bufr_keys_iterator* i=NULL;
741 GRIB_MUTEX_INIT_ONCE(&once,&init);
742 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
743 i=_get_bufr_keys_iterator(keys_iterator_id);
744 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
745 return i;
746 }
747
748
clear_file(int file_id)749 static int clear_file(int file_id)
750 {
751 l_grib_file* current = file_set;
752 while(current){
753 if(current->id == file_id){
754 current->id = -(current->id);
755 if (current->f) fclose(current->f);
756 if (current->buffer) free(current->buffer);
757 return GRIB_SUCCESS;
758 }
759 current = current->next;
760 }
761 return GRIB_INVALID_FILE;
762 }
763
_clear_handle(int handle_id)764 static int _clear_handle(int handle_id)
765 {
766 l_grib_handle* current = handle_set;
767 if (handle_id<0) return 0;
768 while(current){
769 if(current->id == handle_id){
770 current->id = -(current->id);
771 if(current->h) return grib_handle_delete(current->h);
772 }
773 current = current->next;
774 }
775 return GRIB_SUCCESS;
776 }
777
_clear_index(int index_id)778 static int _clear_index(int index_id)
779 {
780 l_grib_index* current = index_set;
781
782 while(current){
783 if(current->id == index_id){
784 current->id = -(current->id);
785 if (current->h) {
786 grib_index_delete(current->h);
787 return GRIB_SUCCESS;
788 }
789 }
790 current = current->next;
791 }
792 return GRIB_SUCCESS;
793 }
794
_clear_multi_handle(int multi_handle_id)795 static int _clear_multi_handle(int multi_handle_id)
796 {
797 l_grib_multi_handle* current = multi_handle_set;
798
799 while(current){
800 if(current->id == multi_handle_id){
801 current->id = -(current->id);
802 if(current->h) return grib_multi_handle_delete(current->h);
803 }
804 current = current->next;
805 }
806 return GRIB_SUCCESS;
807 }
808
clear_handle(int handle_id)809 static int clear_handle(int handle_id)
810 {
811 int ret=0;
812 GRIB_MUTEX_INIT_ONCE(&once,&init);
813 GRIB_MUTEX_LOCK(&handle_mutex);
814 ret=_clear_handle(handle_id);
815 GRIB_MUTEX_UNLOCK(&handle_mutex);
816 return ret;
817 }
818
clear_index(int index_id)819 static int clear_index(int index_id)
820 {
821 int ret=0;
822 GRIB_MUTEX_INIT_ONCE(&once,&init);
823 GRIB_MUTEX_LOCK(&index_mutex);
824 ret=_clear_index(index_id);
825 GRIB_MUTEX_UNLOCK(&index_mutex);
826 return ret;
827 }
828
clear_multi_handle(int multi_handle_id)829 static int clear_multi_handle(int multi_handle_id)
830 {
831 int ret=0;
832 GRIB_MUTEX_INIT_ONCE(&once,&init);
833 GRIB_MUTEX_LOCK(&multi_handle_mutex);
834 ret=_clear_multi_handle(multi_handle_id);
835 GRIB_MUTEX_UNLOCK(&multi_handle_mutex);
836 return ret;
837 }
838
_clear_iterator(int iterator_id)839 static int _clear_iterator(int iterator_id)
840 {
841 l_grib_iterator* current = iterator_set;
842
843 while(current){
844 if(current->id == iterator_id){
845 current->id = -(current->id);
846 return grib_iterator_delete(current->i);
847 }
848 current = current->next;
849 }
850 return GRIB_INVALID_ITERATOR;
851 }
852
clear_iterator(int iterator_id)853 static int clear_iterator(int iterator_id)
854 {
855 int ret=0;
856 GRIB_MUTEX_INIT_ONCE(&once,&init);
857 GRIB_MUTEX_LOCK(&iterator_mutex);
858 ret=_clear_iterator(iterator_id);
859 GRIB_MUTEX_UNLOCK(&iterator_mutex);
860 return ret;
861 }
862
_clear_keys_iterator(int keys_iterator_id)863 static int _clear_keys_iterator(int keys_iterator_id)
864 {
865 l_grib_keys_iterator* current = keys_iterator_set;
866
867 while(current){
868 if(current->id == keys_iterator_id){
869 current->id = -(current->id);
870 return grib_keys_iterator_delete(current->i);
871 }
872 current = current->next;
873 }
874 return GRIB_INVALID_KEYS_ITERATOR;
875 }
clear_keys_iterator(int keys_iterator_id)876 static int clear_keys_iterator(int keys_iterator_id)
877 {
878 int ret=0;
879 GRIB_MUTEX_INIT_ONCE(&once,&init);
880 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
881 ret=_clear_keys_iterator(keys_iterator_id);
882 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
883 return ret;
884 }
885
886 /* BUFR */
_clear_bufr_keys_iterator(int keys_iterator_id)887 static int _clear_bufr_keys_iterator(int keys_iterator_id)
888 {
889 l_bufr_keys_iterator* current = bufr_keys_iterator_set;
890
891 while(current){
892 if(current->id == keys_iterator_id){
893 current->id = -(current->id);
894 return codes_bufr_keys_iterator_delete(current->i);
895 }
896 current = current->next;
897 }
898 return GRIB_INVALID_KEYS_ITERATOR;
899 }
clear_bufr_keys_iterator(int keys_iterator_id)900 static int clear_bufr_keys_iterator(int keys_iterator_id)
901 {
902 int ret=0;
903 GRIB_MUTEX_INIT_ONCE(&once,&init);
904 GRIB_MUTEX_LOCK(&keys_iterator_mutex);
905 ret=_clear_bufr_keys_iterator(keys_iterator_id);
906 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
907 return ret;
908 }
909
910 /*****************************************************************************/
grib_f_read_any_headers_only_from_file_(int * fid,char * buffer,size_t * nbytes)911 int grib_f_read_any_headers_only_from_file_(int* fid, char* buffer, size_t* nbytes) {
912 grib_context* c;
913 int err=0;
914 FILE* f=get_file(*fid);
915
916 if (f) {
917 c=grib_context_get_default( );
918 err=grib_read_any_headers_only_from_file(c,f,buffer,nbytes);
919 return err;
920 } else {
921 return GRIB_INVALID_FILE;
922 }
923 }
grib_f_read_any_headers_only_from_file__(int * fid,char * buffer,size_t * nbytes)924 int grib_f_read_any_headers_only_from_file__(int* fid, char* buffer, size_t* nbytes) {
925 return grib_f_read_any_headers_only_from_file_(fid,buffer,nbytes);
926 }
grib_f_read_any_headers_only_from_file(int * fid,char * buffer,size_t * nbytes)927 int grib_f_read_any_headers_only_from_file(int* fid, char* buffer, size_t* nbytes) {
928 return grib_f_read_any_headers_only_from_file_(fid,buffer,nbytes);
929 }
930
931 /*****************************************************************************/
grib_f_read_any_from_file_(int * fid,char * buffer,size_t * nbytes)932 int grib_f_read_any_from_file_(int* fid, char* buffer, size_t* nbytes) {
933 grib_context* c;
934 int err=0;
935 FILE* f=get_file(*fid);
936
937 if (f) {
938 c=grib_context_get_default( );
939 err=grib_read_any_from_file(c,f,buffer,nbytes);
940 return err;
941 } else {
942 return GRIB_INVALID_FILE;
943 }
944 }
grib_f_read_any_from_file__(int * fid,char * buffer,size_t * nbytes)945 int grib_f_read_any_from_file__(int* fid, char* buffer, size_t* nbytes) {
946 return grib_f_read_any_from_file_(fid,buffer,nbytes);
947 }
grib_f_read_any_from_file(int * fid,char * buffer,size_t * nbytes)948 int grib_f_read_any_from_file(int* fid, char* buffer, size_t* nbytes) {
949 return grib_f_read_any_from_file_(fid,buffer,nbytes);
950 }
951
952 /*****************************************************************************/
grib_f_write_file_(int * fid,char * buffer,size_t * nbytes)953 int grib_f_write_file_(int* fid, char* buffer, size_t* nbytes) {
954 grib_context* c;
955 FILE* f=get_file(*fid);
956
957 if (f) {
958 int ioerr;
959 c=grib_context_get_default( );
960 if( fwrite(buffer, 1, *nbytes, f) != *nbytes) {
961 ioerr=errno;
962 grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
963 return GRIB_IO_PROBLEM;
964 }
965 return GRIB_SUCCESS;
966 } else {
967 return GRIB_INVALID_FILE;
968 }
969 }
grib_f_write_file__(int * fid,char * buffer,size_t * nbytes)970 int grib_f_write_file__(int* fid, char* buffer, size_t* nbytes) {
971 return grib_f_write_file_(fid,buffer,nbytes);
972 }
grib_f_write_file(int * fid,char * buffer,size_t * nbytes)973 int grib_f_write_file(int* fid, char* buffer, size_t* nbytes) {
974 return grib_f_write_file_(fid,buffer,nbytes);
975 }
976
977 /*****************************************************************************/
grib_f_read_file_(int * fid,char * buffer,size_t * nbytes)978 int grib_f_read_file_(int* fid, char* buffer, size_t* nbytes) {
979 grib_context* c;
980 FILE* f=get_file(*fid);
981
982 if (f) {
983 int ioerr;
984 c=grib_context_get_default( );
985 if( fread(buffer, 1, *nbytes, f) != *nbytes) {
986 ioerr=errno;
987 grib_context_log(c,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s",strerror(ioerr));
988 return GRIB_IO_PROBLEM;
989 }
990 return GRIB_SUCCESS;
991 } else {
992 return GRIB_INVALID_FILE;
993 }
994 }
grib_f_read_file__(int * fid,char * buffer,size_t * nbytes)995 int grib_f_read_file__(int* fid, char* buffer, size_t* nbytes) {
996 return grib_f_read_file_(fid,buffer,nbytes);
997 }
grib_f_read_file(int * fid,char * buffer,size_t * nbytes)998 int grib_f_read_file(int* fid, char* buffer, size_t* nbytes) {
999 return grib_f_read_file_(fid,buffer,nbytes);
1000 }
1001
1002 /*****************************************************************************/
grib_f_open_file_(int * fid,char * name,char * op,int lname,int lop)1003 int grib_f_open_file_(int* fid, char* name , char* op, int lname, int lop) {
1004 FILE* f = NULL;
1005 int ioerr=0;
1006 char oper[1024]; /* GRIB-576: open mode */
1007 char *p;
1008 char fname[1024];
1009 int ret=GRIB_SUCCESS;
1010 char* iobuf=NULL;
1011 /*TODO Proper context passed as external parameter */
1012 grib_context* context=grib_context_get_default();
1013
1014 cast_char(oper,op,lop);
1015
1016 p=oper;
1017
1018 while (*p != '\0') { *p=tolower(*p);p++;}
1019
1020 f = fopen(cast_char(fname,name,lname),oper);
1021 if(!f) {
1022 ioerr=errno;
1023 grib_context_log(context,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR),"IO ERROR: %s: %s",strerror(ioerr),cast_char(fname,name,lname));
1024 *fid = -1;
1025 ret=GRIB_IO_PROBLEM;
1026 } else {
1027 if (context->io_buffer_size) {
1028 /* printf("setting vbuf = %d\n",context->io_buffer_size); */
1029 #ifdef POSIX_MEMALIGN
1030 if (posix_memalign((void **)&iobuf,sysconf(_SC_PAGESIZE),context->io_buffer_size) ) {
1031 grib_context_log(context,GRIB_LOG_FATAL,"grib_f_open_file_: posix_memalign unable to allocate io_buffer\n");
1032 }
1033 #else
1034 iobuf = (void*)malloc(context->io_buffer_size);
1035 if (!iobuf) {
1036 grib_context_log(context,GRIB_LOG_FATAL,"grib_f_open_file_: Unable to allocate io_buffer\n");
1037 }
1038 #endif
1039 setvbuf(f,iobuf,_IOFBF,context->io_buffer_size);
1040 }
1041 *fid = push_file(f,iobuf);
1042 ret=GRIB_SUCCESS;
1043 }
1044 return ret;
1045 }
grib_f_open_file__(int * fid,char * name,char * op,int lname,int lop)1046 int grib_f_open_file__(int* fid, char* name , char* op, int lname, int lop){
1047 return grib_f_open_file_( fid, name , op, lname, lop);
1048 }
grib_f_open_file(int * fid,char * name,char * op,int lname,int lop)1049 int grib_f_open_file(int* fid, char* name , char* op, int lname, int lop){
1050 return grib_f_open_file_( fid, name , op, lname, lop);
1051 }
1052
1053 /*****************************************************************************/
grib_f_close_file_(int * fid)1054 int grib_f_close_file_(int* fid){
1055 return clear_file(*fid);
1056 }
grib_f_close_file__(int * fid)1057 int grib_f_close_file__(int* fid){
1058 return grib_f_close_file_(fid);
1059 }
grib_f_close_file(int * fid)1060 int grib_f_close_file(int* fid){
1061 return grib_f_close_file_(fid);
1062 }
1063
1064 /*****************************************************************************/
1065 static int file_count=0;
1066
grib_f_write_on_fail(int * gid)1067 void grib_f_write_on_fail(int* gid) {
1068 grib_context* c=grib_context_get_default();
1069 if (c->write_on_fail) {
1070 char filename[100]={0,};
1071 grib_handle* h=NULL;
1072 pid_t pid=getpid();
1073
1074 GRIB_MUTEX_INIT_ONCE(&once,&init)
1075 GRIB_MUTEX_LOCK(&handle_mutex)
1076 file_count++;
1077 GRIB_MUTEX_UNLOCK(&handle_mutex)
1078
1079 sprintf(filename,"%ld_%d_error.grib",(long)pid,file_count);
1080
1081 h=get_handle(*gid);
1082 if (h) grib_write_message(h,filename,"w");
1083 }
1084 }
grib_f_write_on_fail_(int * gid)1085 void grib_f_write_on_fail_(int* gid) {
1086 grib_f_write_on_fail(gid);
1087 }
grib_f_write_on_fail__(int * gid)1088 void grib_f_write_on_fail__(int* gid) {
1089 grib_f_write_on_fail(gid);
1090 }
1091
1092 /*****************************************************************************/
grib_f_multi_support_on_()1093 int grib_f_multi_support_on_(){
1094 grib_multi_support_on(0);
1095 return GRIB_SUCCESS;
1096 }
grib_f_multi_support_on__()1097 int grib_f_multi_support_on__(){
1098 return grib_f_multi_support_on_();
1099 }
grib_f_multi_support_on()1100 int grib_f_multi_support_on(){
1101 return grib_f_multi_support_on_();
1102 }
1103
grib_f_multi_support_off_()1104 int grib_f_multi_support_off_(){
1105 grib_multi_support_off(0);
1106 return GRIB_SUCCESS;
1107 }
grib_f_multi_support_off__()1108 int grib_f_multi_support_off__(){
1109 return grib_f_multi_support_off_();
1110 }
grib_f_multi_support_off()1111 int grib_f_multi_support_off(){
1112 return grib_f_multi_support_off_();
1113 }
1114
1115
1116 /*****************************************************************************/
_grib_f_iterator_new_(int * gid,int * iterid,int * mode)1117 static int _grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
1118 int err=0;
1119 grib_handle* h;
1120 grib_iterator* iter;
1121
1122 h=get_handle(*gid);
1123 if (!h) {
1124 *iterid=-1;
1125 return GRIB_NULL_HANDLE;
1126 }
1127 iter=grib_iterator_new(h,*mode,&err);
1128 if (iter)
1129 *iterid=push_iterator(iter);
1130 else
1131 *iterid=-1;
1132 return err;
1133 }
grib_f_iterator_new_(int * gid,int * iterid,int * mode)1134 int grib_f_iterator_new_(int* gid,int* iterid,int* mode) {
1135 int ret=0;
1136 GRIB_MUTEX_INIT_ONCE(&once,&init)
1137 GRIB_MUTEX_LOCK(&iterator_mutex)
1138 ret=_grib_f_iterator_new_(gid,iterid,mode);
1139 GRIB_MUTEX_UNLOCK(&iterator_mutex)
1140 return ret;
1141 }
grib_f_iterator_new__(int * gid,int * iterid,int * mode)1142 int grib_f_iterator_new__(int* gid,int* iterid,int* mode) {
1143 return grib_f_iterator_new_(gid,iterid,mode);
1144 }
grib_f_iterator_new(int * gid,int * iterid,int * mode)1145 int grib_f_iterator_new(int* gid,int* iterid,int* mode) {
1146 return grib_f_iterator_new_(gid,iterid,mode);
1147 }
1148
1149 /*****************************************************************************/
grib_f_iterator_next_(int * iterid,double * lat,double * lon,double * value)1150 int grib_f_iterator_next_(int* iterid,double* lat,double* lon,double* value) {
1151 grib_iterator* iter=get_iterator(*iterid);
1152 if (!iter) return GRIB_INVALID_ITERATOR;
1153 return grib_iterator_next(iter,lat,lon,value);
1154 }
1155
grib_f_iterator_next__(int * iterid,double * lat,double * lon,double * value)1156 int grib_f_iterator_next__(int* iterid,double* lat,double* lon,double* value) {
1157 return grib_f_iterator_next_(iterid,lat,lon,value);
1158 }
grib_f_iterator_next(int * iterid,double * lat,double * lon,double * value)1159 int grib_f_iterator_next(int* iterid,double* lat,double* lon,double* value) {
1160 return grib_f_iterator_next_(iterid,lat,lon,value);
1161 }
1162
1163 /*****************************************************************************/
grib_f_iterator_delete_(int * iterid)1164 int grib_f_iterator_delete_(int* iterid) {
1165 return clear_iterator(*iterid);
1166 }
1167
grib_f_iterator_delete__(int * iterid)1168 int grib_f_iterator_delete__(int* iterid) {
1169 return grib_f_iterator_delete_(iterid);
1170 }
grib_f_iterator_delete(int * iterid)1171 int grib_f_iterator_delete(int* iterid) {
1172 return grib_f_iterator_delete_(iterid);
1173 }
1174
1175 /*****************************************************************************/
_grib_f_keys_iterator_new_(int * gid,int * iterid,char * name_space,int len)1176 static int _grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int len) {
1177 int err=0;
1178 char buf[1024];
1179 grib_handle* h;
1180 grib_keys_iterator* iter;
1181
1182 h=get_handle(*gid);
1183 if (!h) {
1184 *iterid=-1;
1185 return GRIB_NULL_HANDLE;
1186 }
1187 iter=grib_keys_iterator_new(h,0,cast_char(buf,name_space,len));
1188 if (iter)
1189 *iterid=push_keys_iterator(iter);
1190 else
1191 *iterid=-1;
1192 return err;
1193 }
grib_f_keys_iterator_new_(int * gid,int * iterid,char * name_space,int len)1194 int grib_f_keys_iterator_new_(int* gid,int* iterid,char* name_space,int len) {
1195 int ret=0;
1196 GRIB_MUTEX_INIT_ONCE(&once,&init)
1197 GRIB_MUTEX_LOCK(&keys_iterator_mutex)
1198 ret=_grib_f_keys_iterator_new_(gid,iterid,name_space,len);
1199 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
1200 return ret;
1201 }
1202
grib_f_keys_iterator_new__(int * gid,int * iterid,char * name_space,int len)1203 int grib_f_keys_iterator_new__(int* gid,int* iterid,char* name_space,int len) {
1204 return grib_f_keys_iterator_new_(gid,iterid,name_space,len);
1205 }
grib_f_keys_iterator_new(int * gid,int * iterid,char * name_space,int len)1206 int grib_f_keys_iterator_new(int* gid,int* iterid,char* name_space,int len) {
1207 return grib_f_keys_iterator_new_(gid,iterid,name_space,len);
1208 }
1209
1210 /*****************************************************************************/
grib_f_keys_iterator_next_(int * iterid)1211 int grib_f_keys_iterator_next_(int* iterid) {
1212 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1213 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1214
1215 return grib_keys_iterator_next(iter);
1216 }
grib_f_keys_iterator_next__(int * iterid)1217 int grib_f_keys_iterator_next__(int* iterid) {
1218 return grib_f_keys_iterator_next_(iterid);
1219 }
grib_f_keys_iterator_next(int * iterid)1220 int grib_f_keys_iterator_next(int* iterid) {
1221 return grib_f_keys_iterator_next_(iterid);
1222 }
1223
1224 /*****************************************************************************/
grib_f_keys_iterator_delete_(int * iterid)1225 int grib_f_keys_iterator_delete_(int* iterid) {
1226 return clear_keys_iterator(*iterid);
1227 }
grib_f_keys_iterator_delete__(int * iterid)1228 int grib_f_keys_iterator_delete__(int* iterid) {
1229 return grib_f_keys_iterator_delete_(iterid);
1230 }
grib_f_keys_iterator_delete(int * iterid)1231 int grib_f_keys_iterator_delete(int* iterid) {
1232 return grib_f_keys_iterator_delete_(iterid);
1233 }
1234
1235 /*****************************************************************************/
grib_f_gribex_mode_on_()1236 int grib_f_gribex_mode_on_() {
1237 grib_gribex_mode_on(0);
1238 return GRIB_SUCCESS;
1239 }
grib_f_gribex_mode_on__()1240 int grib_f_gribex_mode_on__() {
1241 grib_gribex_mode_on(0);
1242 return GRIB_SUCCESS;
1243 }
grib_f_gribex_mode_on()1244 int grib_f_gribex_mode_on() {
1245 grib_gribex_mode_on(0);
1246 return GRIB_SUCCESS;
1247 }
1248
grib_f_gribex_mode_off_()1249 int grib_f_gribex_mode_off_() {
1250 grib_gribex_mode_off(0);
1251 return GRIB_SUCCESS;
1252 }
grib_f_gribex_mode_off__()1253 int grib_f_gribex_mode_off__() {
1254 grib_gribex_mode_off(0);
1255 return GRIB_SUCCESS;
1256 }
grib_f_gribex_mode_off()1257 int grib_f_gribex_mode_off() {
1258 grib_gribex_mode_off(0);
1259 return GRIB_SUCCESS;
1260 }
1261
1262 /*****************************************************************************/
grib_f_skip_computed_(int * iterid)1263 int grib_f_skip_computed_(int* iterid) {
1264 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1265 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1266 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_COMPUTED);
1267 }
grib_f_skip_computed__(int * iterid)1268 int grib_f_skip_computed__(int* iterid) {
1269 return grib_f_skip_computed_(iterid);
1270 }
grib_f_skip_computed(int * iterid)1271 int grib_f_skip_computed(int* iterid) {
1272 return grib_f_skip_computed_(iterid);
1273 }
1274
grib_f_skip_coded_(int * iterid)1275 int grib_f_skip_coded_(int* iterid) {
1276 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1277 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1278 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_CODED);
1279 }
grib_f_skip_coded__(int * iterid)1280 int grib_f_skip_coded__(int* iterid) {
1281 return grib_f_skip_coded_(iterid);
1282 }
grib_f_skip_coded(int * iterid)1283 int grib_f_skip_coded(int* iterid) {
1284 return grib_f_skip_coded_(iterid);
1285 }
1286
grib_f_skip_edition_specific_(int * iterid)1287 int grib_f_skip_edition_specific_(int* iterid) {
1288 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1289 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1290 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC);
1291 }
grib_f_skip_edition_specific__(int * iterid)1292 int grib_f_skip_edition_specific__(int* iterid) {
1293 return grib_f_skip_edition_specific_(iterid);
1294 }
grib_f_skip_edition_specific(int * iterid)1295 int grib_f_skip_edition_specific(int* iterid) {
1296 return grib_f_skip_edition_specific_(iterid);
1297 }
1298
grib_f_skip_duplicates_(int * iterid)1299 int grib_f_skip_duplicates_(int* iterid) {
1300 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1301 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1302 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_DUPLICATES);
1303 }
grib_f_skip_duplicates__(int * iterid)1304 int grib_f_skip_duplicates__(int* iterid) {
1305 return grib_f_skip_duplicates_(iterid);
1306 }
grib_f_skip_duplicates(int * iterid)1307 int grib_f_skip_duplicates(int* iterid) {
1308 return grib_f_skip_duplicates_(iterid);
1309 }
1310
grib_f_skip_read_only_(int * iterid)1311 int grib_f_skip_read_only_(int* iterid) {
1312 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1313 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1314 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_READ_ONLY);
1315 }
grib_f_skip_read_only__(int * iterid)1316 int grib_f_skip_read_only__(int* iterid) {
1317 return grib_f_skip_read_only_(iterid);
1318 }
grib_f_skip_read_only(int * iterid)1319 int grib_f_skip_read_only(int* iterid) {
1320 return grib_f_skip_read_only_(iterid);
1321 }
1322
grib_f_skip_function_(int * iterid)1323 int grib_f_skip_function_(int* iterid) {
1324 grib_keys_iterator* iter=get_keys_iterator(*iterid);
1325 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1326 return grib_keys_iterator_set_flags(iter,GRIB_KEYS_ITERATOR_SKIP_FUNCTION);
1327 }
grib_f_skip_function__(int * iterid)1328 int grib_f_skip_function__(int* iterid) {
1329 return grib_f_skip_function_(iterid);
1330 }
grib_f_skip_function(int * iterid)1331 int grib_f_skip_function(int* iterid) {
1332 return grib_f_skip_function_(iterid);
1333 }
1334
1335 /*****************************************************************************/
grib_f_keys_iterator_get_name_(int * iterid,char * name,int len)1336 int grib_f_keys_iterator_get_name_(int* iterid,char* name,int len) {
1337 size_t lsize=len;
1338 char buf[1024]={0,};
1339
1340 grib_keys_iterator* kiter=get_keys_iterator(*iterid);
1341
1342 if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
1343
1344 fort_char_clean(name,len);
1345
1346 sprintf(buf,"%s",grib_keys_iterator_get_name(kiter));
1347 lsize=strlen(buf);
1348 if (len < lsize) return GRIB_ARRAY_TOO_SMALL;
1349
1350 memcpy(name,buf,lsize);
1351
1352 czstr_to_fortran(name,len);
1353
1354 return 0;
1355 }
grib_f_keys_iterator_get_name__(int * kiter,char * name,int len)1356 int grib_f_keys_iterator_get_name__(int* kiter,char* name,int len) {
1357 return grib_f_keys_iterator_get_name_(kiter,name,len);
1358 }
grib_f_keys_iterator_get_name(int * kiter,char * name,int len)1359 int grib_f_keys_iterator_get_name(int* kiter,char* name,int len) {
1360 return grib_f_keys_iterator_get_name_(kiter,name,len);
1361 }
1362
1363 /*****************************************************************************/
grib_f_keys_iterator_rewind_(int * kiter)1364 int grib_f_keys_iterator_rewind_(int* kiter) {
1365 grib_keys_iterator* i=get_keys_iterator(*kiter);
1366
1367 if (!i) return GRIB_INVALID_KEYS_ITERATOR;
1368 return grib_keys_iterator_rewind(i);
1369 }
grib_f_keys_iterator_rewind__(int * kiter)1370 int grib_f_keys_iterator_rewind__(int* kiter) {
1371 return grib_f_keys_iterator_rewind_(kiter);
1372 }
grib_f_keys_iterator_rewind(int * kiter)1373 int grib_f_keys_iterator_rewind(int* kiter) {
1374 return grib_f_keys_iterator_rewind_(kiter);
1375 }
1376
1377 /*BUFR keys iterator*/
1378 /*****************************************************************************/
_codes_f_bufr_keys_iterator_new_(int * gid,int * iterid)1379 static int _codes_f_bufr_keys_iterator_new_(int* gid,int* iterid) {
1380 int err=0;
1381 grib_handle* h;
1382 bufr_keys_iterator* iter;
1383
1384 h=get_handle(*gid);
1385 if (!h) {
1386 *iterid=-1;
1387 return GRIB_NULL_HANDLE;
1388 }
1389 Assert(h->product_kind==PRODUCT_BUFR);
1390 iter=codes_bufr_keys_iterator_new(h,0);
1391 if (iter)
1392 *iterid=push_bufr_keys_iterator(iter);
1393 else
1394 *iterid=-1;
1395 return err;
1396 }
codes_f_bufr_keys_iterator_new_(int * gid,int * iterid)1397 int codes_f_bufr_keys_iterator_new_(int* gid,int* iterid) {
1398 int ret=0;
1399 GRIB_MUTEX_INIT_ONCE(&once,&init)
1400 GRIB_MUTEX_LOCK(&keys_iterator_mutex)
1401 ret=_codes_f_bufr_keys_iterator_new_(gid,iterid);
1402 GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
1403 return ret;
1404 }
codes_f_bufr_keys_iterator_new__(int * gid,int * iterid)1405 int codes_f_bufr_keys_iterator_new__(int* gid,int* iterid) {
1406 return codes_f_bufr_keys_iterator_new_(gid,iterid);
1407 }
codes_f_bufr_keys_iterator_new(int * gid,int * iterid)1408 int codes_f_bufr_keys_iterator_new(int* gid,int* iterid) {
1409 return codes_f_bufr_keys_iterator_new_(gid,iterid);
1410 }
1411 /*****************************************************************************/
codes_f_bufr_keys_iterator_next_(int * iterid)1412 int codes_f_bufr_keys_iterator_next_(int* iterid) {
1413 bufr_keys_iterator* iter=get_bufr_keys_iterator(*iterid);
1414 if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
1415
1416 return codes_bufr_keys_iterator_next(iter);
1417 }
codes_f_bufr_keys_iterator_next__(int * iterid)1418 int codes_f_bufr_keys_iterator_next__(int* iterid) {
1419 return codes_f_bufr_keys_iterator_next_(iterid);
1420 }
codes_f_bufr_keys_iterator_next(int * iterid)1421 int codes_f_bufr_keys_iterator_next(int* iterid) {
1422 return codes_f_bufr_keys_iterator_next_(iterid);
1423 }
1424 /*****************************************************************************/
codes_f_bufr_keys_iterator_get_name_(int * iterid,char * name,int len)1425 int codes_f_bufr_keys_iterator_get_name_(int* iterid,char* name,int len) {
1426 size_t lsize=len;
1427 char buf[1024]={0,};
1428
1429 bufr_keys_iterator* kiter=get_bufr_keys_iterator(*iterid);
1430
1431 if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
1432
1433 fort_char_clean(name,len);
1434
1435 sprintf(buf,"%s",codes_bufr_keys_iterator_get_name(kiter));
1436 lsize=strlen(buf);
1437 if (len < lsize) return GRIB_ARRAY_TOO_SMALL;
1438
1439 memcpy(name,buf,lsize);
1440
1441 czstr_to_fortran(name,len);
1442
1443 return 0;
1444 }
codes_f_bufr_keys_iterator_get_name__(int * kiter,char * name,int len)1445 int codes_f_bufr_keys_iterator_get_name__(int* kiter,char* name,int len) {
1446 return codes_f_bufr_keys_iterator_get_name_(kiter,name,len);
1447 }
codes_f_bufr_keys_iterator_get_name(int * kiter,char * name,int len)1448 int codes_f_bufr_keys_iterator_get_name(int* kiter,char* name,int len) {
1449 return codes_f_bufr_keys_iterator_get_name_(kiter,name,len);
1450 }
1451 /*****************************************************************************/
codes_f_bufr_keys_iterator_rewind_(int * kiter)1452 int codes_f_bufr_keys_iterator_rewind_(int* kiter) {
1453 bufr_keys_iterator* i=get_bufr_keys_iterator(*kiter);
1454
1455 if (!i) return GRIB_INVALID_KEYS_ITERATOR;
1456 return codes_bufr_keys_iterator_rewind(i);
1457 }
codes_f_bufr_keys_iterator_rewind__(int * kiter)1458 int codes_f_bufr_keys_iterator_rewind__(int* kiter) {
1459 return codes_f_bufr_keys_iterator_rewind_(kiter);
1460 }
codes_f_bufr_keys_iterator_rewind(int * kiter)1461 int codes_f_bufr_keys_iterator_rewind(int* kiter) {
1462 return codes_f_bufr_keys_iterator_rewind_(kiter);
1463 }
1464 /*****************************************************************************/
codes_f_bufr_keys_iterator_delete_(int * iterid)1465 int codes_f_bufr_keys_iterator_delete_(int* iterid) {
1466 return clear_bufr_keys_iterator(*iterid);
1467 }
codes_f_bufr_keys_iterator_delete__(int * iterid)1468 int codes_f_bufr_keys_iterator_delete__(int* iterid) {
1469 return codes_f_bufr_keys_iterator_delete_(iterid);
1470 }
codes_f_bufr_keys_iterator_delete(int * iterid)1471 int codes_f_bufr_keys_iterator_delete(int* iterid) {
1472 return codes_f_bufr_keys_iterator_delete_(iterid);
1473 }
1474
1475
1476 /*****************************************************************************/
grib_f_new_from_message_(int * gid,void * buffer,size_t * bufsize)1477 int grib_f_new_from_message_(int* gid, void* buffer , size_t* bufsize){
1478 grib_handle *h = NULL;
1479 h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
1480 if(h){
1481 push_handle(h,gid);
1482 return GRIB_SUCCESS;
1483 }
1484
1485 *gid = -1;
1486 return GRIB_INTERNAL_ERROR;
1487 }
grib_f_new_from_message__(int * gid,void * buffer,size_t * bufsize)1488 int grib_f_new_from_message__(int* gid, void* buffer , size_t* bufsize){
1489 return grib_f_new_from_message_(gid, buffer , bufsize);
1490 }
grib_f_new_from_message(int * gid,void * buffer,size_t * bufsize)1491 int grib_f_new_from_message(int* gid, void* buffer , size_t* bufsize){
1492 return grib_f_new_from_message_(gid, buffer , bufsize);
1493 }
1494
1495 /*****************************************************************************/
grib_f_new_from_message_copy_(int * gid,void * buffer,size_t * bufsize)1496 int grib_f_new_from_message_copy_(int* gid, void* buffer , size_t* bufsize){
1497 grib_handle *h = NULL;
1498 h = grib_handle_new_from_message_copy(0, buffer, *bufsize);
1499 if(h){
1500 push_handle(h,gid);
1501 return GRIB_SUCCESS;
1502 }
1503
1504 *gid = -1;
1505 return GRIB_INTERNAL_ERROR;
1506 }
grib_f_new_from_message_copy__(int * gid,void * buffer,size_t * bufsize)1507 int grib_f_new_from_message_copy__(int* gid, void* buffer , size_t* bufsize){
1508 return grib_f_new_from_message_copy_(gid, buffer , bufsize);
1509 }
grib_f_new_from_message_copy(int * gid,void * buffer,size_t * bufsize)1510 int grib_f_new_from_message_copy(int* gid, void* buffer , size_t* bufsize){
1511 return grib_f_new_from_message_copy_(gid, buffer , bufsize);
1512 }
1513
1514 /*****************************************************************************/
grib_f_new_from_samples_(int * gid,char * name,int lname)1515 int grib_f_new_from_samples_(int* gid, char* name , int lname){
1516 char fname[1024];
1517 grib_handle *h = NULL;
1518
1519 h = grib_handle_new_from_samples(NULL,cast_char(fname,name,lname));
1520 /* grib_context_set_debug(h->context,1);*/
1521
1522 if(h){
1523 push_handle(h,gid);
1524 return GRIB_SUCCESS;
1525 }
1526
1527 *gid = -1;
1528 return GRIB_FILE_NOT_FOUND;
1529 }
grib_f_new_from_samples__(int * gid,char * name,int lname)1530 int grib_f_new_from_samples__(int* gid, char* name , int lname){
1531 return grib_f_new_from_samples_( gid, name , lname);
1532 }
grib_f_new_from_samples(int * gid,char * name,int lname)1533 int grib_f_new_from_samples(int* gid, char* name , int lname){
1534 return grib_f_new_from_samples_( gid, name , lname);
1535 }
1536
1537 /*****************************************************************************/
codes_bufr_f_new_from_samples_(int * gid,char * name,int lname)1538 int codes_bufr_f_new_from_samples_(int* gid, char* name, int lname){
1539 char fname[1024];
1540 grib_handle *h = NULL;
1541
1542 h = codes_bufr_handle_new_from_samples(NULL,cast_char(fname,name,lname));
1543 /* grib_context_set_debug(h->context,1);*/
1544
1545 if(h){
1546 push_handle(h,gid);
1547 return GRIB_SUCCESS;
1548 }
1549
1550 *gid = -1;
1551 return GRIB_FILE_NOT_FOUND;
1552 }
codes_bufr_f_new_from_samples__(int * gid,char * name,int lname)1553 int codes_bufr_f_new_from_samples__(int* gid, char* name, int lname){
1554 return codes_bufr_f_new_from_samples_( gid, name, lname);
1555 }
codes_bufr_f_new_from_samples(int * gid,char * name,int lname)1556 int codes_bufr_f_new_from_samples(int* gid, char* name, int lname){
1557 return codes_bufr_f_new_from_samples_( gid, name, lname);
1558 }
1559
1560 /*****************************************************************************/
grib_f_clone_(int * gidsrc,int * giddest)1561 int grib_f_clone_(int* gidsrc,int* giddest){
1562 grib_handle *src = get_handle(*gidsrc);
1563 grib_handle *dest = NULL;
1564
1565 if(src){
1566 dest = grib_handle_clone(src);
1567 if(dest){
1568 push_handle(dest,giddest);
1569 return GRIB_SUCCESS;
1570 }
1571 }
1572
1573 *giddest = -1;
1574 return GRIB_INVALID_GRIB;
1575 }
grib_f_clone__(int * gidsrc,int * giddest)1576 int grib_f_clone__(int* gidsrc,int* giddest){
1577 return grib_f_clone_(gidsrc, giddest);
1578 }
grib_f_clone(int * gidsrc,int * giddest)1579 int grib_f_clone(int* gidsrc,int* giddest){
1580 return grib_f_clone_(gidsrc, giddest);
1581 }
1582
1583 /*****************************************************************************/
grib_f_copy_key_(int * gidsrc,char * key,int * giddest,int len)1584 int grib_f_copy_key_(int* gidsrc, char* key, int* giddest, int len)
1585 {
1586 grib_handle *src = get_handle(*gidsrc);
1587 grib_handle *dest = get_handle(*giddest);
1588
1589 if(src && dest) {
1590 char buf[1024]={0,};
1591 char* ckey = (char*)key;
1592 const int type = GRIB_TYPE_UNDEFINED; /* will be computed */
1593 return codes_copy_key(src, dest, cast_char(buf,ckey,len), type);
1594 }
1595
1596 return GRIB_INVALID_GRIB;
1597 }
grib_f_copy_key__(int * gidsrc,char * name,int * giddest,int len)1598 int grib_f_copy_key__(int* gidsrc, char* name, int* giddest, int len){
1599 return grib_f_copy_key_(gidsrc, name, giddest, len);
1600 }
grib_f_copy_key(int * gidsrc,char * name,int * giddest,int len)1601 int grib_f_copy_key(int* gidsrc, char* name, int* giddest, int len){
1602 return grib_f_copy_key_(gidsrc, name, giddest, len);
1603 }
1604 /*****************************************************************************/
grib_f_util_sections_copy_(int * gidfrom,int * gidto,int * what,int * gidout)1605 int grib_f_util_sections_copy_(int* gidfrom,int* gidto,int* what,int *gidout){
1606 int err=0;
1607 grib_handle *hfrom = get_handle(*gidfrom);
1608 grib_handle *hto = get_handle(*gidto);
1609 grib_handle *out =0;
1610
1611 if(hfrom && hto) out=grib_util_sections_copy(hfrom,hto,*what,&err);
1612 if(out){
1613 push_handle(out,gidout);
1614 return GRIB_SUCCESS;
1615 }
1616
1617 return err;
1618 }
grib_f_util_sections_copy__(int * gidfrom,int * gidto,int * what,int * gidout)1619 int grib_f_util_sections_copy__(int* gidfrom,int* gidto,int* what,int *gidout){
1620 return grib_f_util_sections_copy_(gidfrom,gidto,what,gidout);
1621 }
grib_f_util_sections_copy(int * gidfrom,int * gidto,int * what,int * gidout)1622 int grib_f_util_sections_copy(int* gidfrom,int* gidto,int* what,int *gidout){
1623 return grib_f_util_sections_copy_(gidfrom,gidto,what,gidout);
1624 }
1625
1626 /*****************************************************************************/
grib_f_copy_namespace_(int * gidsrc,char * name,int * giddest,int len)1627 int grib_f_copy_namespace_(int* gidsrc,char* name,int* giddest,int len){
1628 char buf[1024]={0,};
1629 grib_handle *src = get_handle(*gidsrc);
1630 grib_handle *dest = get_handle(*giddest);
1631
1632 if(src && dest)
1633 return grib_copy_namespace(dest,cast_char(buf,name,len),src);
1634
1635 return GRIB_INVALID_GRIB;
1636 }
grib_f_copy_namespace__(int * gidsrc,char * name,int * giddest,int len)1637 int grib_f_copy_namespace__(int* gidsrc,char* name,int* giddest,int len){
1638 return grib_f_copy_namespace_(gidsrc,name,giddest,len);
1639 }
grib_f_copy_namespace(int * gidsrc,char * name,int * giddest,int len)1640 int grib_f_copy_namespace(int* gidsrc,char* name,int* giddest,int len){
1641 return grib_f_copy_namespace_(gidsrc,name,giddest,len);
1642 }
1643
1644 /*****************************************************************************/
any_f_scan_file(int * fid,int * n)1645 int any_f_scan_file(int* fid,int* n) {
1646 int err = 0;
1647 off_t offset=0;
1648 void *data = NULL;
1649 size_t olen = 0;
1650 l_message_info* msg=0;
1651 FILE* f = get_file(*fid);
1652 grib_context* c=grib_context_get_default();
1653
1654 /* this needs a callback to a destructor*/
1655 /* grib_oarray_delete_content(c,binary_messages); */
1656
1657 grib_oarray_delete(c,info_messages);
1658 info_messages=grib_oarray_new(c,1000,1000);
1659
1660 if (f) {
1661 while (err!=GRIB_END_OF_FILE) {
1662 data = wmo_read_any_from_file_malloc ( f, 0,&olen,&offset,&err );
1663 msg=(l_message_info*)grib_context_malloc_clear(c,sizeof(l_message_info));
1664 msg->offset=offset;
1665 msg->size=olen;
1666
1667 if (err==0 && data) grib_oarray_push(c,info_messages,msg);
1668 grib_context_free(c,data);
1669 }
1670 if (err==GRIB_END_OF_FILE) err=0;
1671 }
1672 *n=info_messages->n;
1673 return err;
1674 }
any_f_scan_file_(int * fid,int * n)1675 int any_f_scan_file_(int* fid,int* n) {
1676 return any_f_scan_file(fid,n);
1677 }
any_f_scan_file__(int * fid,int * n)1678 int any_f_scan_file__(int* fid,int* n) {
1679 return any_f_scan_file(fid,n);
1680 }
1681
any_f_new_from_scanned_file(int * fid,int * msgid,int * gid)1682 int any_f_new_from_scanned_file(int* fid,int* msgid,int* gid)
1683 {
1684 grib_handle *h = NULL;
1685 grib_context* c=grib_context_get_default();
1686 int err=0;
1687 FILE* f = get_file(*fid);
1688
1689 /* fortran convention of 1 based index*/
1690 const int n=*msgid-1;
1691
1692 l_message_info* msg=(l_message_info*)grib_oarray_get(info_messages,n);
1693
1694 if (msg && f) {
1695 GRIB_MUTEX_INIT_ONCE(&once,&init);
1696 GRIB_MUTEX_LOCK(&read_mutex);
1697 fseeko(f,msg->offset,SEEK_SET);
1698 h=any_new_from_file (c,f,&err);
1699 GRIB_MUTEX_UNLOCK(&read_mutex);
1700 }
1701 if (err) return err;
1702
1703 if(h){
1704 push_handle(h,gid);
1705 return GRIB_SUCCESS;
1706 } else {
1707 *gid=-1;
1708 return GRIB_END_OF_FILE;
1709 }
1710 }
1711
any_f_new_from_scanned_file_(int * fid,int * msgid,int * gid)1712 int any_f_new_from_scanned_file_(int* fid,int* msgid,int* gid){
1713 return any_f_new_from_scanned_file(fid,msgid,gid);
1714 }
any_f_new_from_scanned_file__(int * fid,int * msgid,int * gid)1715 int any_f_new_from_scanned_file__(int* fid,int* msgid,int* gid){
1716 return any_f_new_from_scanned_file(fid,msgid,gid);
1717 }
1718
1719 /*****************************************************************************/
any_f_load_all_from_file(int * fid,int * n)1720 int any_f_load_all_from_file(int* fid,int* n) {
1721 int err = 0;
1722 off_t offset=0;
1723 void *data = NULL;
1724 size_t olen = 0;
1725 l_binary_message* msg=0;
1726 FILE* f = get_file(*fid);
1727 grib_context* c=grib_context_get_default();
1728
1729 /* this needs a callback to a destructor*/
1730 /* grib_oarray_delete_content(c,binary_messages); */
1731
1732 grib_oarray_delete(c,binary_messages);
1733 binary_messages=grib_oarray_new(c,1000,1000);
1734
1735 if (f) {
1736 while (err!=GRIB_END_OF_FILE) {
1737 data = wmo_read_any_from_file_malloc ( f, 0,&olen,&offset,&err );
1738 msg=(l_binary_message*)grib_context_malloc_clear(c,sizeof(l_binary_message));
1739 msg->data=data;
1740 msg->size=olen;
1741
1742 if (err==0 && data) grib_oarray_push(c,binary_messages,msg);
1743 }
1744 if (err==GRIB_END_OF_FILE) err=0;
1745 }
1746 *n=binary_messages->n;
1747 return err;
1748 }
any_f_load_all_from_file_(int * fid,int * n)1749 int any_f_load_all_from_file_(int* fid,int* n) {
1750 return any_f_load_all_from_file(fid,n);
1751 }
any_f_load_all_from_file__(int * fid,int * n)1752 int any_f_load_all_from_file__(int* fid,int* n) {
1753 return any_f_load_all_from_file(fid,n);
1754 }
1755
any_f_new_from_loaded(int * msgid,int * gid)1756 int any_f_new_from_loaded(int* msgid,int* gid)
1757 {
1758 grib_handle *h = NULL;
1759 grib_context* c=grib_context_get_default();
1760
1761 /* fortran convention of 1 based index*/
1762 const int n=*msgid-1;
1763
1764 l_binary_message* msg=(l_binary_message*)grib_oarray_get(binary_messages,n);
1765
1766 if (msg && msg->data)
1767 h=grib_handle_new_from_message_copy (c,msg->data,msg->size);
1768
1769 if(h){
1770 push_handle(h,gid);
1771 return GRIB_SUCCESS;
1772 } else {
1773 *gid=-1;
1774 return GRIB_END_OF_FILE;
1775 }
1776 }
1777
any_f_new_from_loaded_(int * msgid,int * gid)1778 int any_f_new_from_loaded_(int* msgid,int* gid){
1779 return any_f_new_from_loaded(msgid,gid);
1780 }
any_f_new_from_loaded__(int * msgid,int * gid)1781 int any_f_new_from_loaded__(int* msgid,int* gid){
1782 return any_f_new_from_loaded(msgid,gid);
1783 }
1784
codes_f_clear_loaded_from_file(void)1785 int codes_f_clear_loaded_from_file(void) {
1786 grib_context* c=grib_context_get_default();
1787 /* grib_oarray_delete_content(c,binary_messages); */
1788 grib_oarray_delete(c,binary_messages);
1789 return GRIB_SUCCESS;
1790 }
codes_f_clear_loaded_from_file_(void)1791 int codes_f_clear_loaded_from_file_(void) {
1792 return codes_f_clear_loaded_from_file();
1793 }
codes_f_clear_loaded_from_file__(void)1794 int codes_f_clear_loaded_from_file__(void) {
1795 return codes_f_clear_loaded_from_file();
1796 }
1797 /*****************************************************************************/
grib_f_count_in_file(int * fid,int * n)1798 int grib_f_count_in_file(int* fid,int* n) {
1799 int err = 0;
1800 FILE* f = get_file(*fid);
1801 if (f) err=grib_count_in_file(0, f,n);
1802 return err;
1803 }
grib_f_count_in_file_(int * fid,int * n)1804 int grib_f_count_in_file_(int* fid,int* n) {
1805 return grib_f_count_in_file(fid,n);
1806 }
grib_f_count_in_file__(int * fid,int * n)1807 int grib_f_count_in_file__(int* fid,int* n) {
1808 return grib_f_count_in_file(fid,n);
1809 }
1810
1811 /*****************************************************************************/
any_f_new_from_file_(int * fid,int * gid)1812 int any_f_new_from_file_(int* fid, int* gid){
1813 int err = 0;
1814 FILE* f = get_file(*fid);
1815 grib_handle *h = NULL;
1816
1817 if(f){
1818 h = codes_handle_new_from_file(0,f,PRODUCT_ANY,&err);
1819 if(h){
1820 push_handle(h,gid);
1821 return GRIB_SUCCESS;
1822 } else {
1823 *gid=-1;
1824 return GRIB_END_OF_FILE;
1825 }
1826 }
1827 *gid=-1;
1828 return GRIB_INVALID_FILE;
1829 }
any_f_new_from_file__(int * fid,int * gid)1830 int any_f_new_from_file__(int* fid, int* gid){
1831 return any_f_new_from_file_( fid, gid);
1832 }
any_f_new_from_file(int * fid,int * gid)1833 int any_f_new_from_file(int* fid, int* gid){
1834 return any_f_new_from_file_( fid, gid);
1835 }
1836
1837 /*****************************************************************************/
bufr_f_new_from_file_(int * fid,int * gid)1838 int bufr_f_new_from_file_(int* fid, int* gid){
1839 int err = 0;
1840 FILE* f = get_file(*fid);
1841
1842 grib_handle *h = NULL;
1843
1844 if(f){
1845 h = codes_handle_new_from_file(0,f,PRODUCT_BUFR,&err);
1846 if(h){
1847 push_handle(h,gid);
1848 return GRIB_SUCCESS;
1849 } else {
1850 *gid=-1;
1851 return GRIB_END_OF_FILE;
1852 }
1853 }
1854
1855 *gid=-1;
1856 return GRIB_INVALID_FILE;
1857 }
1858
bufr_f_new_from_file__(int * fid,int * gid)1859 int bufr_f_new_from_file__(int* fid, int* gid){
1860 return bufr_f_new_from_file_( fid, gid);
1861 }
bufr_f_new_from_file(int * fid,int * gid)1862 int bufr_f_new_from_file(int* fid, int* gid){
1863 return bufr_f_new_from_file_( fid, gid);
1864 }
1865
1866 /*****************************************************************************/
grib_f_new_from_file_(int * fid,int * gid)1867 int grib_f_new_from_file_(int* fid, int* gid){
1868 int err = 0;
1869 FILE* f = get_file(*fid);
1870
1871 grib_handle *h = NULL;
1872
1873 if(f){
1874 h = grib_handle_new_from_file(0,f,&err);
1875 if(h){
1876 push_handle(h,gid);
1877 return GRIB_SUCCESS;
1878 } else {
1879 *gid=-1;
1880 return GRIB_END_OF_FILE;
1881 }
1882 }
1883
1884 *gid=-1;
1885 return GRIB_INVALID_FILE;
1886 }
grib_f_new_from_file__(int * fid,int * gid)1887 int grib_f_new_from_file__(int* fid, int* gid){
1888 return grib_f_new_from_file_( fid, gid);
1889 }
grib_f_new_from_file(int * fid,int * gid)1890 int grib_f_new_from_file(int* fid, int* gid){
1891 return grib_f_new_from_file_( fid, gid);
1892 }
1893
1894 /*****************************************************************************/
grib_f_headers_only_new_from_file_(int * fid,int * gid)1895 int grib_f_headers_only_new_from_file_(int* fid, int* gid){
1896 int err = 0;
1897 FILE* f = get_file(*fid);
1898
1899 grib_handle *h = NULL;
1900
1901 if(f){
1902 h=grib_new_from_file ( 0, f,1,&err);
1903 if(h){
1904 push_handle(h,gid);
1905 return GRIB_SUCCESS;
1906 } else {
1907 *gid=-1;
1908 return GRIB_END_OF_FILE;
1909 }
1910 }
1911
1912 *gid=-1;
1913 return GRIB_INVALID_FILE;
1914 }
grib_f_headers_only_new_from_file__(int * fid,int * gid)1915 int grib_f_headers_only_new_from_file__(int* fid, int* gid){
1916 return grib_f_headers_only_new_from_file_( fid, gid);
1917 }
grib_f_headers_only_new_from_file(int * fid,int * gid)1918 int grib_f_headers_only_new_from_file(int* fid, int* gid){
1919 return grib_f_headers_only_new_from_file_( fid, gid);
1920 }
1921
1922 /*****************************************************************************/
grib_f_new_from_index_(int * iid,int * gid)1923 int grib_f_new_from_index_(int* iid, int* gid){
1924 int err = 0;
1925 grib_index* i = get_index(*iid);
1926
1927 grib_handle *h = NULL;
1928
1929 if(i){
1930 h = grib_handle_new_from_index(i,&err);
1931 if(h){
1932 push_handle(h,gid);
1933 return GRIB_SUCCESS;
1934 } else {
1935 *gid=-1;
1936 return GRIB_END_OF_INDEX;
1937 }
1938 }
1939
1940 *gid=-1;
1941 return GRIB_INVALID_INDEX;
1942 }
1943
grib_f_new_from_index__(int * iid,int * gid)1944 int grib_f_new_from_index__(int* iid, int* gid){
1945 return grib_f_new_from_index_(iid,gid);
1946 }
grib_f_new_from_index(int * iid,int * gid)1947 int grib_f_new_from_index(int* iid, int* gid){
1948 return grib_f_new_from_index_(iid,gid);
1949 }
1950
1951 /*****************************************************************************/
grib_f_index_new_from_file_(char * file,char * keys,int * gid,int lfile,int lkeys)1952 int grib_f_index_new_from_file_(char* file ,char* keys ,int* gid, int lfile, int lkeys){
1953 int err = 0;
1954 char fname[1024]={0,};
1955 char knames[1024]={0,};
1956
1957 grib_index *i = NULL;
1958
1959 if(*file){
1960 i = grib_index_new_from_file(0,cast_char(fname,file,lfile),
1961 cast_char(knames,keys,lkeys),&err);
1962 if(i){
1963 push_index(i,gid);
1964 return GRIB_SUCCESS;
1965 } else {
1966 *gid=-1;
1967 return GRIB_END_OF_FILE;
1968 }
1969 }
1970
1971 *gid=-1;
1972 return GRIB_INVALID_FILE;
1973 }
grib_f_index_new_from_file__(char * file,char * keys,int * gid,int lfile,int lkeys)1974 int grib_f_index_new_from_file__(char* file, char* keys, int* gid, int lfile, int lkeys){
1975 return grib_f_index_new_from_file_(file ,keys ,gid, lfile, lkeys);
1976 }
grib_f_index_new_from_file(char * file,char * keys,int * gid,int lfile,int lkeys)1977 int grib_f_index_new_from_file(char* file, char* keys, int* gid, int lfile, int lkeys){
1978 return grib_f_index_new_from_file_(file ,keys ,gid, lfile, lkeys);
1979 }
1980
1981 /*****************************************************************************/
grib_f_index_add_file_(int * iid,char * file,int lfile)1982 int grib_f_index_add_file_(int* iid, char* file, int lfile) {
1983 grib_index *i = get_index(*iid);
1984 int err = GRIB_SUCCESS;
1985 char buf[1024];
1986
1987 if (!i) {
1988 return GRIB_INVALID_INDEX;
1989 } else {
1990 err = grib_index_add_file(i,cast_char(buf,file,lfile));
1991 return err;
1992 }
1993 }
1994
grib_f_index_add_file__(int * iid,char * file,int lfile)1995 int grib_f_index_add_file__(int* iid, char* file, int lfile) {
1996 return grib_f_index_add_file_(iid,file,lfile);
1997 }
1998
grib_f_index_add_file(int * iid,char * file,int lfile)1999 int grib_f_index_add_file(int* iid, char* file, int lfile) {
2000 return grib_f_index_add_file_(iid,file,lfile);
2001 }
2002
2003 /*****************************************************************************/
grib_f_index_read_(char * file,int * gid,int lfile)2004 int grib_f_index_read_(char* file, int* gid, int lfile) {
2005 int err = 0;
2006 char fname[1024]={0,};
2007
2008 grib_index *i = NULL;
2009
2010 if (*file) {
2011 i = grib_index_read(0,cast_char(fname,file,lfile),&err);
2012 if (i) {
2013 push_index(i,gid);
2014 return GRIB_SUCCESS;
2015 } else {
2016 *gid = -1;
2017 return GRIB_END_OF_FILE;
2018 }
2019 }
2020
2021 *gid=-1;
2022 return GRIB_INVALID_FILE;
2023 }
grib_f_index_read__(char * file,int * gid,int lfile)2024 int grib_f_index_read__(char* file, int* gid, int lfile) {
2025 return grib_f_index_read_(file,gid,lfile);
2026 }
grib_f_index_read(char * file,int * gid,int lfile)2027 int grib_f_index_read(char* file, int* gid, int lfile) {
2028 return grib_f_index_read_(file,gid,lfile);
2029 }
2030
2031 /*****************************************************************************/
grib_f_index_write_(int * gid,char * file,int lfile)2032 int grib_f_index_write_(int* gid, char* file, int lfile) {
2033 grib_index *i = get_index(*gid);
2034 int err = GRIB_SUCCESS;
2035 char buf[1024];
2036
2037 if (!i) {
2038 return GRIB_INVALID_GRIB;
2039 } else {
2040 err = grib_index_write(i,cast_char(buf,file,lfile));
2041 return err;
2042 }
2043 }
grib_f_index_write__(int * gid,char * file,int lfile)2044 int grib_f_index_write__(int* gid, char* file, int lfile) {
2045 return grib_f_index_write_(gid,file,lfile);
2046 }
grib_f_index_write(int * gid,char * file,int lfile)2047 int grib_f_index_write(int* gid, char* file, int lfile) {
2048 return grib_f_index_write_(gid,file,lfile);
2049 }
2050
2051 /*****************************************************************************/
grib_f_index_release_(int * hid)2052 int grib_f_index_release_(int* hid){
2053 return clear_index(*hid);
2054 }
2055
grib_f_index_release__(int * hid)2056 int grib_f_index_release__(int* hid){
2057 return grib_f_index_release_(hid);
2058 }
2059
grib_f_index_release(int * hid)2060 int grib_f_index_release(int* hid){
2061 return grib_f_index_release_(hid);
2062 }
2063
grib_f_multi_handle_release_(int * hid)2064 int grib_f_multi_handle_release_(int* hid){
2065 return clear_multi_handle(*hid);
2066 }
2067
grib_f_multi_handle_release__(int * hid)2068 int grib_f_multi_handle_release__(int* hid){
2069 return grib_f_multi_handle_release_(hid);
2070 }
2071
grib_f_multi_handle_release(int * hid)2072 int grib_f_multi_handle_release(int* hid){
2073 return grib_f_multi_handle_release_(hid);
2074 }
2075
2076 /*****************************************************************************/
grib_f_release_(int * hid)2077 int grib_f_release_(int* hid){
2078 return clear_handle(*hid);
2079 }
grib_f_release__(int * hid)2080 int grib_f_release__(int* hid){
2081 return grib_f_release_( hid);
2082 }
grib_f_release(int * hid)2083 int grib_f_release(int* hid){
2084 return grib_f_release_( hid);
2085 }
2086
2087 /*****************************************************************************/
do_the_dump(grib_handle * h)2088 static void do_the_dump(grib_handle* h)
2089 {
2090 /* Add some debugging info too */
2091 printf("ecCodes version: "); grib_print_api_version(stdout); printf("\n");
2092 printf("Definitions path: %s\n", grib_definition_path(NULL));
2093 printf("Samples path: %s\n", grib_samples_path(NULL));
2094
2095 if (h->product_kind == PRODUCT_GRIB)
2096 {
2097 const int dump_flags = GRIB_DUMP_FLAG_VALUES
2098 | GRIB_DUMP_FLAG_READ_ONLY
2099 | GRIB_DUMP_FLAG_ALIASES
2100 | GRIB_DUMP_FLAG_TYPE;
2101 grib_dump_content(h,stdout,"debug", dump_flags, NULL);
2102 }
2103 else
2104 {
2105 grib_dump_content(h,stdout,"wmo",0,NULL);
2106 }
2107 }
grib_f_dump_(int * gid)2108 int grib_f_dump_(int* gid){
2109 grib_handle *h = get_handle(*gid);
2110
2111 if(!h)
2112 return GRIB_INVALID_GRIB;
2113 else
2114 do_the_dump(h);
2115
2116 return GRIB_SUCCESS;
2117 }
grib_f_dump__(int * gid)2118 int grib_f_dump__(int* gid){
2119 return grib_f_dump_( gid);
2120 }
grib_f_dump(int * gid)2121 int grib_f_dump(int* gid){
2122 return grib_f_dump_( gid);
2123 }
2124
2125 /*****************************************************************************/
grib_f_print_(int * gid,char * key,int len)2126 int grib_f_print_(int* gid, char* key, int len){
2127 grib_handle *h = get_handle(*gid);
2128 int err = GRIB_SUCCESS;
2129 grib_dumper* d = NULL;
2130 char buf[1024];
2131
2132 if(!h){
2133 return GRIB_INVALID_GRIB;
2134 }else{
2135 d = grib_dumper_factory("file",h,stdout,0,0);
2136 err = grib_print(h, cast_char(buf,key,len), d);
2137 grib_dumper_delete(d);
2138 return err;
2139 }
2140 }
grib_f_print__(int * gid,char * key,int len)2141 int grib_f_print__(int* gid, char* key, int len){
2142 return grib_f_print_( gid, key, len);
2143 }
grib_f_print(int * gid,char * key,int len)2144 int grib_f_print(int* gid, char* key, int len){
2145 return grib_f_print_( gid, key, len);
2146 }
2147
2148 /*****************************************************************************/
grib_f_get_error_string_(int * err,char * buf,int len)2149 int grib_f_get_error_string_(int* err, char* buf, int len){
2150 const char* err_msg = grib_get_error_message(*err);
2151 const size_t erlen = strlen(err_msg);
2152 if( len < erlen) return GRIB_ARRAY_TOO_SMALL;
2153 strncpy(buf, err_msg,(size_t)len);
2154 return GRIB_SUCCESS;
2155 }
grib_f_get_error_string__(int * err,char * buf,int len)2156 int grib_f_get_error_string__(int* err, char* buf, int len){
2157 return grib_f_get_error_string_(err,buf,len);
2158 }
grib_f_get_error_string(int * err,char * buf,int len)2159 int grib_f_get_error_string(int* err, char* buf, int len){
2160 return grib_f_get_error_string_(err,buf,len);
2161 }
2162
2163 /*****************************************************************************/
grib_f_get_api_version_(int * apiVersion,int len)2164 int grib_f_get_api_version_(int* apiVersion,int len){
2165 *apiVersion = grib_get_api_version();
2166 return GRIB_SUCCESS;
2167 }
grib_f_get_api_version__(int * apiVersion,int len)2168 int grib_f_get_api_version__(int* apiVersion, int len){
2169 return grib_f_get_api_version_(apiVersion, len);
2170 }
grib_f_get_api_version(int * apiVersion,int len)2171 int grib_f_get_api_version(int* apiVersion, int len){
2172 return grib_f_get_api_version_(apiVersion, len);
2173 }
2174
2175 /*****************************************************************************/
grib_f_get_size_int_(int * gid,char * key,int * val,int len)2176 int grib_f_get_size_int_(int* gid, char* key, int* val, int len){
2177 grib_handle *h = get_handle(*gid);
2178 int err = GRIB_SUCCESS;
2179 char buf[1024];
2180 size_t tsize = 0;
2181
2182 if(!h){
2183 return GRIB_INVALID_GRIB;
2184 }else{
2185 err = grib_get_size(h, cast_char(buf,key,len), &tsize);
2186 *val = tsize;
2187 return err;
2188 }
2189 }
grib_f_get_size_int__(int * gid,char * key,int * val,int len)2190 int grib_f_get_size_int__(int* gid, char* key, int* val, int len){
2191 return grib_f_get_size_int_( gid, key, val, len);
2192 }
grib_f_get_size_int(int * gid,char * key,int * val,int len)2193 int grib_f_get_size_int(int* gid, char* key, int* val, int len){
2194 return grib_f_get_size_int_( gid, key, val, len);
2195 }
2196
grib_f_get_size_long_(int * gid,char * key,long * val,int len)2197 int grib_f_get_size_long_(int* gid, char* key, long* val, int len){
2198 grib_handle *h = get_handle(*gid);
2199 int err = GRIB_SUCCESS;
2200 char buf[1024];
2201 size_t tsize = 0;
2202
2203 if(!h){
2204 return GRIB_INVALID_GRIB;
2205 }else{
2206 err = grib_get_size(h, cast_char(buf,key,len), &tsize);
2207 *val = tsize;
2208 return err;
2209 }
2210 }
grib_f_get_size_long__(int * gid,char * key,long * val,int len)2211 int grib_f_get_size_long__(int* gid, char* key, long* val, int len){
2212 return grib_f_get_size_long_( gid, key, val, len);
2213 }
grib_f_get_size_long(int * gid,char * key,long * val,int len)2214 int grib_f_get_size_long(int* gid, char* key, long* val, int len){
2215 return grib_f_get_size_long_( gid, key, val, len);
2216 }
2217
grib_f_index_get_size_int_(int * gid,char * key,int * val,int len)2218 int grib_f_index_get_size_int_(int* gid, char* key, int* val, int len){
2219 grib_index *h = get_index(*gid);
2220 int err = GRIB_SUCCESS;
2221 char buf[1024];
2222 size_t tsize = 0;
2223
2224 if(!h){
2225 return GRIB_INVALID_GRIB;
2226 }else{
2227 err = grib_index_get_size(h, cast_char(buf,key,len), &tsize);
2228 *val = tsize;
2229 return err;
2230 }
2231 }
grib_f_index_get_size_int__(int * gid,char * key,int * val,int len)2232 int grib_f_index_get_size_int__(int* gid, char* key, int* val, int len){
2233 return grib_f_index_get_size_int_( gid, key, val, len);
2234 }
grib_f_index_get_size_int(int * gid,char * key,int * val,int len)2235 int grib_f_index_get_size_int(int* gid, char* key, int* val, int len){
2236 return grib_f_index_get_size_int_( gid, key, val, len);
2237 }
2238
grib_f_index_get_size_long_(int * gid,char * key,long * val,int len)2239 int grib_f_index_get_size_long_(int* gid, char* key, long* val, int len){
2240 grib_index *h = get_index(*gid);
2241 int err = GRIB_SUCCESS;
2242 char buf[1024];
2243 size_t tsize = 0;
2244
2245 if(!h){
2246 return GRIB_INVALID_GRIB;
2247 }else{
2248 err = grib_index_get_size(h, cast_char(buf,key,len), &tsize);
2249 *val = tsize;
2250 return err;
2251 }
2252 }
grib_f_index_get_size_long__(int * gid,char * key,long * val,int len)2253 int grib_f_index_get_size_long__(int* gid, char* key, long* val, int len){
2254 return grib_f_index_get_size_long_( gid, key, val, len);
2255 }
grib_f_index_get_size_long(int * gid,char * key,long * val,int len)2256 int grib_f_index_get_size_long(int* gid, char* key, long* val, int len){
2257 return grib_f_index_get_size_long_( gid, key, val, len);
2258 }
2259
grib_f_get_int_(int * gid,char * key,int * val,int len)2260 int grib_f_get_int_(int* gid, char* key, int* val, int len){
2261 grib_handle *h = get_handle(*gid);
2262 long long_val;
2263 int err = GRIB_SUCCESS;
2264 char buf[1024];
2265
2266 if(!h) return GRIB_INVALID_GRIB;
2267 err = grib_get_long(h, cast_char(buf,key,len),&long_val);
2268 *val = long_val;
2269 return err;
2270 }
grib_f_get_int__(int * gid,char * key,int * val,int len)2271 int grib_f_get_int__(int* gid, char* key, int* val, int len){
2272 return grib_f_get_int_( gid, key, val, len);
2273 }
grib_f_get_int(int * gid,char * key,int * val,int len)2274 int grib_f_get_int(int* gid, char* key, int* val, int len){
2275 return grib_f_get_int_( gid, key, val, len);
2276 }
grib_f_get_long_(int * gid,char * key,long * val,int len)2277 int grib_f_get_long_(int* gid, char* key, long* val, int len){
2278 grib_handle *h = get_handle(*gid);
2279 int err = GRIB_SUCCESS;
2280 char buf[1024];
2281
2282 if(!h) return GRIB_INVALID_GRIB;
2283 err = grib_get_long(h, cast_char(buf,key,len),val);
2284 return err;
2285 }
grib_f_get_long__(int * gid,char * key,long * val,int len)2286 int grib_f_get_long__(int* gid, char* key, long* val, int len){
2287 return grib_f_get_long_( gid, key, val, len);
2288 }
grib_f_get_long(int * gid,char * key,long * val,int len)2289 int grib_f_get_long(int* gid, char* key, long* val, int len){
2290 return grib_f_get_long_( gid, key, val, len);
2291 }
2292
2293 /*****************************************************************************/
grib_f_get_int_array_(int * gid,char * key,int * val,int * size,int len)2294 int grib_f_get_int_array_(int* gid, char* key, int *val, int* size, int len){
2295
2296 grib_handle *h = get_handle(*gid);
2297 long* long_val = NULL;
2298 int err = GRIB_SUCCESS;
2299 char buf[1024];
2300 size_t lsize = *size;
2301
2302
2303 if(!h) return GRIB_INVALID_GRIB;
2304
2305 if(sizeof(long) == sizeof(int)){
2306 long_val = (long*)val;
2307 err = grib_get_long_array(h, cast_char(buf,key,len), long_val, &lsize);
2308 *size = lsize;
2309 return err;
2310 }
2311 if(*size)
2312 long_val = (long*)grib_context_malloc(h->context,(*size)*(sizeof(long)));
2313 else
2314 long_val = (long*)grib_context_malloc(h->context,(sizeof(long)));
2315
2316 if(!long_val) return GRIB_OUT_OF_MEMORY;
2317 err = grib_get_long_array(h, cast_char(buf,key,len), long_val, &lsize);
2318
2319 for(*size=0;*size<lsize;(*size)++)
2320 val[*size] = long_val[*size];
2321
2322 grib_context_free(h->context,long_val);
2323 return err;
2324 }
grib_f_get_int_array__(int * gid,char * key,int * val,int * size,int len)2325 int grib_f_get_int_array__(int* gid, char* key, int*val, int* size, int len){
2326 return grib_f_get_int_array_( gid, key, val, size, len);
2327 }
grib_f_get_int_array(int * gid,char * key,int * val,int * size,int len)2328 int grib_f_get_int_array(int* gid, char* key, int*val, int* size, int len){
2329 return grib_f_get_int_array_( gid, key, val, size, len);
2330 }
2331 /*****************************************************************************/
grib_f_get_long_array_(int * gid,char * key,long * val,int * size,int len)2332 int grib_f_get_long_array_(int* gid, char* key, long *val, int* size, int len){
2333
2334 grib_handle *h = get_handle(*gid);
2335 int err = GRIB_SUCCESS;
2336 char buf[1024];
2337 size_t lsize = *size;
2338
2339 if(!h) return GRIB_INVALID_GRIB;
2340
2341 err = grib_get_long_array(h, cast_char(buf,key,len), val, &lsize);
2342 *size=lsize;
2343
2344 return err;
2345 }
grib_f_get_long_array__(int * gid,char * key,long * val,int * size,int len)2346 int grib_f_get_long_array__(int* gid, char* key, long *val, int* size, int len){
2347 return grib_f_get_long_array_( gid, key, val, size, len);
2348 }
grib_f_get_long_array(int * gid,char * key,long * val,int * size,int len)2349 int grib_f_get_long_array(int* gid, char* key, long *val, int* size, int len){
2350 return grib_f_get_long_array_( gid, key, val, size, len);
2351 }
2352
2353 /*****************************************************************************/
grib_f_get_byte_array_(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2354 int grib_f_get_byte_array_(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
2355
2356 grib_handle *h = get_handle(*gid);
2357 int err = GRIB_SUCCESS;
2358 char buf[1024];
2359 size_t lsize = *size;
2360
2361 if(!h) return GRIB_INVALID_GRIB;
2362
2363 err = grib_get_bytes(h, cast_char(buf,key,len), val, &lsize);
2364 *size = (int) lsize;
2365
2366 return err;
2367 }
grib_f_get_byte_array__(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2368 int grib_f_get_byte_array__(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
2369 return grib_f_get_byte_array_( gid, key, val, size, len, lenv);
2370 }
grib_f_get_byte_array(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2371 int grib_f_get_byte_array(int* gid, char* key, unsigned char *val, int* size, int len, int lenv){
2372 return grib_f_get_byte_array_( gid, key, val, size, len, lenv);
2373 }
2374
2375 /*****************************************************************************/
grib_f_index_get_string_(int * gid,char * key,char * val,int * eachsize,int * size,int len)2376 int grib_f_index_get_string_(int* gid, char* key, char* val, int *eachsize,int* size, int len){
2377
2378 grib_index *h = get_index(*gid);
2379 int err = GRIB_SUCCESS;
2380 int i;
2381 char buf[1024];
2382 size_t lsize = *size;
2383 char** bufval;
2384 char* p=val;
2385
2386 if(!h) return GRIB_INVALID_GRIB;
2387
2388 bufval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)* *size);
2389
2390 err = grib_index_get_string(h, cast_char(buf,key,len), bufval, &lsize);
2391 *size = lsize;
2392
2393 if (err) return err;
2394
2395 for (i=0;i<lsize;i++) {
2396 int l=strlen(bufval[i]);
2397 int j;
2398 if (*eachsize < l ) {
2399 printf("eachsize=%d strlen(bufval[i])=%ld\n",*eachsize,(long)strlen(bufval[i]));
2400 grib_context_free(h->context,bufval);
2401 return GRIB_ARRAY_TOO_SMALL;
2402 }
2403 memcpy(p,bufval[i],l);
2404 p+=l;
2405 for (j=0;j<*eachsize-l;j++) *(p++)=' ';
2406 }
2407 for (i=0;i<lsize;i++) {
2408 grib_context_free(h->context, bufval[i]);
2409 }
2410 grib_context_free(h->context,bufval);
2411
2412 return err;
2413 }
grib_f_index_get_string__(int * gid,char * key,char * val,int * eachsize,int * size,int len)2414 int grib_f_index_get_string__(int* gid, char* key, char *val, int* eachsize, int* size, int len){
2415 return grib_f_index_get_string_(gid,key,val,eachsize,size,len);
2416 }
grib_f_index_get_string(int * gid,char * key,char * val,int * eachsize,int * size,int len)2417 int grib_f_index_get_string(int* gid, char* key, char* val, int* eachsize, int* size, int len){
2418 return grib_f_index_get_string_(gid,key,val,eachsize,size,len);
2419 }
2420
2421 /*****************************************************************************/
grib_f_index_get_long_(int * gid,char * key,long * val,int * size,int len)2422 int grib_f_index_get_long_(int* gid, char* key, long *val, int* size, int len){
2423
2424 grib_index *h = get_index(*gid);
2425 int err = GRIB_SUCCESS;
2426 char buf[1024];
2427 size_t lsize = *size;
2428
2429 if(!h) return GRIB_INVALID_GRIB;
2430 err = grib_index_get_long(h, cast_char(buf,key,len), val, &lsize);
2431 *size = lsize;
2432 return err;
2433 }
grib_f_index_get_long__(int * gid,char * key,long * val,int * size,int len)2434 int grib_f_index_get_long__(int* gid, char* key, long *val, int* size, int len){
2435 return grib_f_index_get_long_(gid,key,val,size,len);
2436 }
grib_f_index_get_long(int * gid,char * key,long * val,int * size,int len)2437 int grib_f_index_get_long(int* gid, char* key, long *val, int* size, int len){
2438 return grib_f_index_get_long_(gid,key,val,size,len);
2439 }
2440
2441 /*****************************************************************************/
grib_f_index_get_int_(int * gid,char * key,int * val,int * size,int len)2442 int grib_f_index_get_int_(int* gid, char* key, int *val, int* size, int len){
2443
2444 grib_index *h = get_index(*gid);
2445 int err = GRIB_SUCCESS;
2446 char buf[1024];
2447 size_t lsize = *size;
2448 long* lval=0;
2449 int i;
2450
2451 if(!h) return GRIB_INVALID_GRIB;
2452
2453 lval=(long*)grib_context_malloc(h->context,sizeof(long)* *size);
2454 if (!lval) return GRIB_OUT_OF_MEMORY;
2455
2456 err = grib_index_get_long(h, cast_char(buf,key,len), lval, &lsize);
2457 for (i=0;i<lsize;i++) val[i]=lval[i];
2458
2459 *size = lsize;
2460 grib_context_free(h->context, lval);
2461 return err;
2462 }
grib_f_index_get_int__(int * gid,char * key,int * val,int * size,int len)2463 int grib_f_index_get_int__(int* gid, char* key, int *val, int* size, int len){
2464 return grib_f_index_get_int_(gid,key,val,size,len);
2465 }
grib_f_index_get_int(int * gid,char * key,int * val,int * size,int len)2466 int grib_f_index_get_int(int* gid, char* key, int *val, int* size, int len){
2467 return grib_f_index_get_int_(gid,key,val,size,len);
2468 }
2469
2470 /*****************************************************************************/
grib_f_index_get_real8_(int * gid,char * key,double * val,int * size,int len)2471 int grib_f_index_get_real8_(int* gid, char* key, double *val, int* size, int len){
2472
2473 grib_index *h = get_index(*gid);
2474 int err = GRIB_SUCCESS;
2475 char buf[1024];
2476 size_t lsize = *size;
2477
2478 if(!h) return GRIB_INVALID_GRIB;
2479 err = grib_index_get_double(h, cast_char(buf,key,len), val, &lsize);
2480 *size = lsize;
2481 return err;
2482 }
grib_f_index_get_real8__(int * gid,char * key,double * val,int * size,int len)2483 int grib_f_index_get_real8__(int* gid, char* key, double *val, int* size, int len){
2484 return grib_f_index_get_real8_(gid,key,val,size,len);
2485 }
grib_f_index_get_real8(int * gid,char * key,double * val,int * size,int len)2486 int grib_f_index_get_real8(int* gid, char* key, double *val, int* size, int len){
2487 return grib_f_index_get_real8_(gid,key,val,size,len);
2488 }
2489
2490 /*****************************************************************************/
grib_f_set_int_array_(int * gid,char * key,int * val,int * size,int len)2491 int grib_f_set_int_array_(int* gid, char* key, int* val, int* size, int len){
2492 grib_handle *h = get_handle(*gid);
2493 int err = GRIB_SUCCESS;
2494 char buf[1024];
2495 long* long_val = NULL;
2496 size_t lsize = *size;
2497
2498 if(!h) return GRIB_INVALID_GRIB;
2499
2500 if(sizeof(long) == sizeof(int)){
2501 long_val = (long*)val;
2502 return grib_set_long_array(h, cast_char(buf,key,len), long_val, lsize);
2503 }
2504
2505 if(lsize)
2506 long_val = (long*)grib_context_malloc(h->context,(lsize)*(sizeof(long)));
2507 else
2508 long_val = (long*)grib_context_malloc(h->context,(sizeof(long)));
2509
2510 if(!long_val) return GRIB_OUT_OF_MEMORY;
2511
2512 for(lsize=0;lsize<(*size);lsize++)
2513 long_val[lsize] = val[lsize];
2514
2515 err = grib_set_long_array(h, cast_char(buf,key,len), long_val, lsize);
2516
2517 grib_context_free(h->context,long_val);
2518 return err;
2519 }
grib_f_set_int_array__(int * gid,char * key,int * val,int * size,int len)2520 int grib_f_set_int_array__(int* gid, char* key, int* val, int* size, int len){
2521 return grib_f_set_int_array_( gid, key, val, size, len);
2522 }
grib_f_set_int_array(int * gid,char * key,int * val,int * size,int len)2523 int grib_f_set_int_array(int* gid, char* key, int* val, int* size, int len){
2524 return grib_f_set_int_array_( gid, key, val, size, len);
2525 }
2526
2527 /*****************************************************************************/
grib_f_set_long_array_(int * gid,char * key,long * val,int * size,int len)2528 int grib_f_set_long_array_(int* gid, char* key, long* val, int* size, int len){
2529 grib_handle *h = get_handle(*gid);
2530 char buf[1024];
2531 size_t lsize = *size;
2532
2533 if(!h) return GRIB_INVALID_GRIB;
2534
2535 return grib_set_long_array(h, cast_char(buf,key,len), val, lsize);
2536 }
grib_f_set_long_array__(int * gid,char * key,long * val,int * size,int len)2537 int grib_f_set_long_array__(int* gid, char* key, long* val, int* size, int len){
2538 return grib_f_set_long_array_( gid, key, val, size, len);
2539 }
grib_f_set_long_array(int * gid,char * key,long * val,int * size,int len)2540 int grib_f_set_long_array(int* gid, char* key, long* val, int* size, int len){
2541 return grib_f_set_long_array_( gid, key, val, size, len);
2542 }
2543
2544 /*****************************************************************************/
grib_f_set_byte_array_(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2545 int grib_f_set_byte_array_(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
2546 grib_handle *h = get_handle(*gid);
2547 int err = GRIB_SUCCESS;
2548 char buf[1024];
2549 size_t lsize = *size;
2550
2551 if(!h) return GRIB_INVALID_GRIB;
2552
2553 err = grib_set_bytes(h, cast_char(buf,key,len), val, &lsize);
2554 *size = (int) lsize;
2555
2556 return err;
2557 }
grib_f_set_byte_array__(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2558 int grib_f_set_byte_array__(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
2559 return grib_f_set_byte_array_( gid, key, val, size, len, lenv);
2560 }
grib_f_set_byte_array(int * gid,char * key,unsigned char * val,int * size,int len,int lenv)2561 int grib_f_set_byte_array(int* gid, char* key, unsigned char* val, int* size, int len, int lenv){
2562 return grib_f_set_byte_array_( gid, key, val, size, len, lenv);
2563 }
2564
2565 /*****************************************************************************/
grib_f_set_int_(int * gid,char * key,int * val,int len)2566 int grib_f_set_int_(int* gid, char* key, int* val, int len){
2567 grib_handle *h = get_handle(*gid);
2568 char buf[1024];
2569 long long_val = *val;
2570 if(!h) return GRIB_INVALID_GRIB;
2571 return grib_set_long(h, cast_char(buf,key,len), long_val);
2572 }
grib_f_set_int__(int * gid,char * key,int * val,int len)2573 int grib_f_set_int__(int* gid, char* key, int* val, int len){
2574 return grib_f_set_int_( gid, key, val, len);
2575 }
grib_f_set_int(int * gid,char * key,int * val,int len)2576 int grib_f_set_int(int* gid, char* key, int* val, int len){
2577 return grib_f_set_int_( gid, key, val, len);
2578 }
2579
grib_f_set_long_(int * gid,char * key,long * val,int len)2580 int grib_f_set_long_(int* gid, char* key, long* val, int len){
2581 grib_handle *h = get_handle(*gid);
2582 char buf[1024];
2583 if(!h) return GRIB_INVALID_GRIB;
2584 return grib_set_long(h, cast_char(buf,key,len), *val);
2585 }
grib_f_set_long__(int * gid,char * key,long * val,int len)2586 int grib_f_set_long__(int* gid, char* key, long* val, int len){
2587 return grib_f_set_long_( gid, key, val, len);
2588 }
grib_f_set_long(int * gid,char * key,long * val,int len)2589 int grib_f_set_long(int* gid, char* key, long* val, int len){
2590 return grib_f_set_long_( gid, key, val, len);
2591 }
2592
2593 /*****************************************************************************/
grib_f_set_missing_(int * gid,char * key,int len)2594 int grib_f_set_missing_(int* gid, char* key,int len){
2595
2596 grib_handle *h = get_handle(*gid);
2597 char buf[1024];
2598 if(!h) return GRIB_INVALID_GRIB;
2599
2600 return grib_set_missing(h, cast_char(buf,key,len));
2601 }
grib_f_set_missing__(int * gid,char * key,int len)2602 int grib_f_set_missing__(int* gid, char* key, int len){
2603 return grib_f_set_missing_( gid, key, len);
2604 }
grib_f_set_missing(int * gid,char * key,int len)2605 int grib_f_set_missing(int* gid, char* key, int len){
2606 return grib_f_set_missing_( gid, key, len);
2607 }
2608
grib_f_is_missing_(int * gid,char * key,int * isMissing,int len)2609 int grib_f_is_missing_(int* gid, char* key,int* isMissing,int len){
2610 int err=0;
2611 grib_handle *h = get_handle(*gid);
2612 char buf[1024];
2613 if(!h) return GRIB_INVALID_GRIB;
2614
2615 *isMissing=grib_is_missing(h, cast_char(buf,key,len),&err);
2616 return err;
2617 }
grib_f_is_missing__(int * gid,char * key,int * isMissing,int len)2618 int grib_f_is_missing__(int* gid, char* key,int* isMissing,int len){
2619 return grib_f_is_missing_(gid,key,isMissing,len);
2620 }
grib_f_is_missing(int * gid,char * key,int * isMissing,int len)2621 int grib_f_is_missing(int* gid, char* key,int* isMissing,int len){
2622 return grib_f_is_missing_(gid,key,isMissing,len);
2623 }
2624
2625 /*****************************************************************************/
grib_f_is_defined_(int * gid,char * key,int * isDefined,int len)2626 int grib_f_is_defined_(int* gid, char* key,int* isDefined,int len){
2627 grib_handle *h = get_handle(*gid);
2628 char buf[1024];
2629 if(!h) return GRIB_INVALID_GRIB;
2630
2631 *isDefined=grib_is_defined(h, cast_char(buf,key,len));
2632 return GRIB_SUCCESS;
2633 }
grib_f_is_defined__(int * gid,char * key,int * isDefined,int len)2634 int grib_f_is_defined__(int* gid, char* key,int* isDefined,int len){
2635 return grib_f_is_defined_(gid,key,isDefined,len);
2636 }
grib_f_is_defined(int * gid,char * key,int * isDefined,int len)2637 int grib_f_is_defined(int* gid, char* key,int* isDefined,int len){
2638 return grib_f_is_defined_(gid,key,isDefined,len);
2639 }
2640
2641 /*****************************************************************************/
grib_f_set_real4_(int * gid,char * key,float * val,int len)2642 int grib_f_set_real4_(int* gid, char* key, float* val, int len){
2643
2644 grib_handle *h = get_handle(*gid);
2645 char buf[1024];
2646 double val8 = *val;
2647 if(!h) return GRIB_INVALID_GRIB;
2648
2649 return grib_set_double(h, cast_char(buf,key,len), val8);
2650 }
grib_f_set_real4__(int * gid,char * key,float * val,int len)2651 int grib_f_set_real4__(int* gid, char* key, float* val, int len){
2652 return grib_f_set_real4_( gid, key, val, len);
2653 }
grib_f_set_real4(int * gid,char * key,float * val,int len)2654 int grib_f_set_real4(int* gid, char* key, float* val, int len){
2655 return grib_f_set_real4_( gid, key, val, len);
2656 }
2657
grib_f_get_real4_element_(int * gid,char * key,int * index,float * val,int len)2658 int grib_f_get_real4_element_(int* gid, char* key, int* index,float* val, int len){
2659
2660 grib_handle *h = get_handle(*gid);
2661 int err = GRIB_SUCCESS;
2662 char buf[1024];
2663 double val8 = 0;
2664
2665 if(!h) return GRIB_INVALID_GRIB;
2666
2667 err = grib_get_double_element(h, cast_char(buf,key,len), *index,&val8);
2668 *val = val8;
2669 return err;
2670 }
grib_f_get_real4_element__(int * gid,char * key,int * index,float * val,int len)2671 int grib_f_get_real4_element__(int* gid, char* key,int* index, float* val,int len){
2672 return grib_f_get_real4_element_( gid, key, index, val, len);
2673 }
grib_f_get_real4_element(int * gid,char * key,int * index,float * val,int len)2674 int grib_f_get_real4_element(int* gid, char* key,int* index, float* val,int len){
2675 return grib_f_get_real4_element_( gid, key, index, val, len);
2676 }
2677
grib_f_get_real4_elements_(int * gid,char * key,int * index,float * val,int * size,int len)2678 int grib_f_get_real4_elements_(int* gid, char* key,int* index, float *val,int* size, int len){
2679
2680 grib_handle *h = get_handle(*gid);
2681 int err = GRIB_SUCCESS;
2682 char buf[1024];
2683 size_t lsize = *size;
2684 long i=0;
2685 double* val8 = NULL;
2686
2687 if(!h) return GRIB_INVALID_GRIB;
2688
2689 if(*size)
2690 val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
2691 else
2692 val8 = (double*)grib_context_malloc(h->context,sizeof(double));
2693
2694 if(!val8) return GRIB_OUT_OF_MEMORY;
2695
2696
2697 err = grib_get_double_elements(h, cast_char(buf,key,len), index,(long)lsize,val8);
2698
2699 for(i=0;i<lsize;(i)++)
2700 val[i] = val8[i];
2701
2702 grib_context_free(h->context,val8);
2703
2704 return err;
2705 }
grib_f_get_real4_elements__(int * gid,char * key,int * index,float * val,int * len,int size)2706 int grib_f_get_real4_elements__(int* gid, char* key,int* index, float* val,int* len,int size){
2707 return grib_f_get_real4_elements_( gid, key, index, val, len,size);
2708 }
grib_f_get_real4_elements(int * gid,char * key,int * index,float * val,int * len,int size)2709 int grib_f_get_real4_elements(int* gid, char* key,int* index, float* val,int* len,int size){
2710 return grib_f_get_real4_elements_( gid, key, index, val, len,size);
2711 }
2712
grib_f_get_real4_(int * gid,char * key,float * val,int len)2713 int grib_f_get_real4_(int* gid, char* key, float* val, int len){
2714
2715 grib_handle *h = get_handle(*gid);
2716 int err = GRIB_SUCCESS;
2717 char buf[1024];
2718 double val8 = 0;
2719
2720 if(!h) return GRIB_INVALID_GRIB;
2721
2722 err = grib_get_double(h, cast_char(buf,key,len), &val8);
2723 *val = val8;
2724 return err;
2725 }
grib_f_get_real4__(int * gid,char * key,float * val,int len)2726 int grib_f_get_real4__(int* gid, char* key, float* val, int len){
2727 return grib_f_get_real4_( gid, key, val, len);
2728 }
grib_f_get_real4(int * gid,char * key,float * val,int len)2729 int grib_f_get_real4(int* gid, char* key, float* val, int len){
2730 return grib_f_get_real4_( gid, key, val, len);
2731 }
2732
grib_f_get_real4_array_(int * gid,char * key,float * val,int * size,int len)2733 int grib_f_get_real4_array_(int* gid, char* key, float *val, int* size, int len)
2734 {
2735 grib_handle *h = get_handle(*gid);
2736 int err = GRIB_SUCCESS;
2737 char buf[1024];
2738 size_t lsize = *size;
2739 double* val8 = NULL;
2740 size_t i;
2741
2742 if(!h) return GRIB_INVALID_GRIB;
2743
2744 if(*size)
2745 val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
2746 else
2747 val8 = (double*)grib_context_malloc(h->context,sizeof(double));
2748
2749 if(!val8) return GRIB_OUT_OF_MEMORY;
2750
2751 err = grib_get_double_array(h, cast_char(buf,key,len), val8, &lsize);
2752 if (err) {
2753 grib_context_free(h->context,val8);
2754 return err;
2755 }
2756
2757 for(i=0;i<lsize;i++)
2758 val[i] = val8[i];
2759
2760 grib_context_free(h->context,val8);
2761
2762 return err;
2763 }
grib_f_get_real4_array__(int * gid,char * key,float * val,int * size,int len)2764 int grib_f_get_real4_array__(int* gid, char* key, float* val, int* size, int len){
2765 return grib_f_get_real4_array_( gid, key, val, size, len);
2766 }
grib_f_get_real4_array(int * gid,char * key,float * val,int * size,int len)2767 int grib_f_get_real4_array(int* gid, char* key, float* val, int* size, int len){
2768 return grib_f_get_real4_array_( gid, key, val, size, len);
2769 }
2770
2771 /*****************************************************************************/
grib_f_set_force_real4_array_(int * gid,char * key,float * val,int * size,int len)2772 int grib_f_set_force_real4_array_(int* gid, char* key, float*val, int* size, int len)
2773 {
2774 grib_handle *h = get_handle(*gid);
2775 int err = GRIB_SUCCESS;
2776 char buf[1024];
2777 size_t lsize = *size;
2778 double* val8 = NULL;
2779
2780 if(!h) return GRIB_INVALID_GRIB;
2781
2782 if(*size)
2783 val8 = (double*)grib_context_malloc(h->context,lsize*(sizeof(double)));
2784 else
2785 val8 = (double*)grib_context_malloc(h->context,sizeof(double));
2786
2787 if(!val8) return GRIB_OUT_OF_MEMORY;
2788
2789 for(lsize=0;lsize<*size;lsize++)
2790 val8[lsize] = val[lsize];
2791
2792 err = grib_set_force_double_array(h, cast_char(buf,key,len), val8, lsize);
2793 grib_context_free(h->context,val8);
2794 return err;
2795 }
grib_f_set_force_real4_array__(int * gid,char * key,float * val,int * size,int len)2796 int grib_f_set_force_real4_array__(int* gid, char* key, float*val, int* size, int len){
2797 return grib_f_set_force_real4_array_( gid, key, val, size, len);
2798 }
grib_f_set_force_real4_array(int * gid,char * key,float * val,int * size,int len)2799 int grib_f_set_force_real4_array(int* gid, char* key, float*val, int* size, int len){
2800 return grib_f_set_force_real4_array_( gid, key, val, size, len);
2801 }
2802
2803 /*****************************************************************************/
grib_f_set_real4_array_(int * gid,char * key,float * val,int * size,int len)2804 int grib_f_set_real4_array_(int* gid, char* key, float*val, int* size, int len)
2805 {
2806 grib_handle *h = get_handle(*gid);
2807 int err = GRIB_SUCCESS;
2808 char buf[1024];
2809 size_t lsize = *size;
2810 double* val8 = NULL;
2811
2812 if(!h) return GRIB_INVALID_GRIB;
2813
2814 if(*size)
2815 val8 = (double*)grib_context_malloc(h->context,lsize*(sizeof(double)));
2816 else
2817 val8 = (double*)grib_context_malloc(h->context,sizeof(double));
2818
2819 if(!val8) return GRIB_OUT_OF_MEMORY;
2820
2821 for(lsize=0;lsize<*size;lsize++)
2822 val8[lsize] = val[lsize];
2823
2824 err = grib_set_double_array(h, cast_char(buf,key,len), val8, lsize);
2825 grib_context_free(h->context,val8);
2826 return err;
2827 }
grib_f_set_real4_array__(int * gid,char * key,float * val,int * size,int len)2828 int grib_f_set_real4_array__(int* gid, char* key, float*val, int* size, int len){
2829 return grib_f_set_real4_array_( gid, key, val, size, len);
2830 }
grib_f_set_real4_array(int * gid,char * key,float * val,int * size,int len)2831 int grib_f_set_real4_array(int* gid, char* key, float*val, int* size, int len){
2832 return grib_f_set_real4_array_( gid, key, val, size, len);
2833 }
2834
2835 /*****************************************************************************/
grib_f_index_select_real8_(int * gid,char * key,double * val,int len)2836 int grib_f_index_select_real8_(int* gid, char* key, double* val, int len)
2837 {
2838 grib_index *h = get_index(*gid);
2839 char buf[1024];
2840
2841 if(!h) return GRIB_INVALID_GRIB;
2842 return grib_index_select_double(h, cast_char(buf,key,len), *val);
2843 }
grib_f_index_select_real8__(int * gid,char * key,double * val,int len)2844 int grib_f_index_select_real8__(int* gid, char* key, double* val, int len){
2845 return grib_f_index_select_real8_(gid,key,val,len);
2846 }
grib_f_index_select_real8(int * gid,char * key,double * val,int len)2847 int grib_f_index_select_real8(int* gid, char* key, double* val, int len){
2848 return grib_f_index_select_real8_(gid,key,val,len);
2849 }
2850
2851 /*****************************************************************************/
grib_f_index_select_string_(int * gid,char * key,char * val,int len,int vallen)2852 int grib_f_index_select_string_(int* gid, char* key, char* val, int len, int vallen)
2853 {
2854 grib_index *h = get_index(*gid);
2855
2856 char buf[1024];
2857 char bufval[1024];
2858
2859 if(!h) return GRIB_INVALID_GRIB;
2860 return grib_index_select_string(h, cast_char(buf,key,len), cast_char(bufval,val,vallen));
2861 }
grib_f_index_select_string__(int * gid,char * key,char * val,int len,int vallen)2862 int grib_f_index_select_string__(int* gid, char* key, char* val, int len, int vallen){
2863 return grib_f_index_select_string_(gid,key,val,len,vallen);
2864 }
grib_f_index_select_string(int * gid,char * key,char * val,int len,int vallen)2865 int grib_f_index_select_string(int* gid, char* key, char* val, int len, int vallen){
2866 return grib_f_index_select_string_(gid,key,val,len,vallen);
2867 }
2868
2869 /*****************************************************************************/
grib_f_index_select_int_(int * gid,char * key,int * val,int len)2870 int grib_f_index_select_int_(int* gid, char* key, int* val, int len)
2871 {
2872 grib_index *h = get_index(*gid);
2873 long lval=*val;
2874 char buf[1024];
2875
2876 if(!h) return GRIB_INVALID_GRIB;
2877 return grib_index_select_long(h, cast_char(buf,key,len), lval);
2878 }
grib_f_index_select_int__(int * gid,char * key,int * val,int len)2879 int grib_f_index_select_int__(int* gid, char* key, int* val, int len){
2880 return grib_f_index_select_int_(gid,key,val,len);
2881 }
grib_f_index_select_int(int * gid,char * key,int * val,int len)2882 int grib_f_index_select_int(int* gid, char* key, int* val, int len){
2883 return grib_f_index_select_int_(gid,key,val,len);
2884 }
2885
2886 /*****************************************************************************/
grib_f_index_select_long_(int * gid,char * key,long * val,int len)2887 int grib_f_index_select_long_(int* gid, char* key, long* val, int len)
2888 {
2889 grib_index *h = get_index(*gid);
2890 char buf[1024];
2891
2892 if(!h) return GRIB_INVALID_GRIB;
2893 return grib_index_select_long(h, cast_char(buf,key,len), *val);
2894 }
grib_f_index_select_long__(int * gid,char * key,long * val,int len)2895 int grib_f_index_select_long__(int* gid, char* key, long* val, int len){
2896 return grib_f_index_select_long_(gid,key,val,len);
2897 }
grib_f_index_select_long(int * gid,char * key,long * val,int len)2898 int grib_f_index_select_long(int* gid, char* key, long* val, int len){
2899 return grib_f_index_select_long_(gid,key,val,len);
2900 }
2901
2902 /*****************************************************************************/
grib_f_set_real8_(int * gid,char * key,double * val,int len)2903 int grib_f_set_real8_(int* gid, char* key, double* val, int len)
2904 {
2905 grib_handle *h = get_handle(*gid);
2906 char buf[1024];
2907
2908 if(!h) return GRIB_INVALID_GRIB;
2909 return grib_set_double(h, cast_char(buf,key,len), *val);
2910 }
grib_f_set_real8__(int * gid,char * key,double * val,int len)2911 int grib_f_set_real8__(int* gid, char* key, double* val, int len){
2912 return grib_f_set_real8_( gid, key, val, len);
2913 }
grib_f_set_real8(int * gid,char * key,double * val,int len)2914 int grib_f_set_real8(int* gid, char* key, double* val, int len){
2915 return grib_f_set_real8_( gid, key, val, len);
2916 }
2917
grib_f_get_real8_(int * gid,char * key,double * val,int len)2918 int grib_f_get_real8_(int* gid, char* key, double* val, int len)
2919 {
2920 grib_handle *h = get_handle(*gid);
2921 char buf[1024];
2922
2923 if(!h) return GRIB_INVALID_GRIB;
2924
2925 return grib_get_double(h, cast_char(buf,key,len), val);
2926
2927 }
grib_f_get_real8__(int * gid,char * key,double * val,int len)2928 int grib_f_get_real8__(int* gid, char* key, double* val, int len){
2929 return grib_f_get_real8_( gid, key, val, len);
2930 }
grib_f_get_real8(int * gid,char * key,double * val,int len)2931 int grib_f_get_real8(int* gid, char* key, double* val, int len){
2932 return grib_f_get_real8_( gid, key, val, len);
2933 }
2934
grib_f_get_real8_element_(int * gid,char * key,int * index,double * val,int len)2935 int grib_f_get_real8_element_(int* gid, char* key,int* index, double* val, int len){
2936
2937 grib_handle *h = get_handle(*gid);
2938 char buf[1024];
2939
2940 if(!h) return GRIB_INVALID_GRIB;
2941
2942 return grib_get_double_element(h, cast_char(buf,key,len), *index,val);
2943
2944 }
grib_f_get_real8_element__(int * gid,char * key,int * index,double * val,int len)2945 int grib_f_get_real8_element__(int* gid, char* key, int* index,double* val, int len){
2946 return grib_f_get_real8_element_( gid, key, index, val,len);
2947 }
grib_f_get_real8_element(int * gid,char * key,int * index,double * val,int len)2948 int grib_f_get_real8_element(int* gid, char* key, int* index,double* val, int len){
2949 return grib_f_get_real8_element_( gid, key, index, val,len);
2950 }
2951
grib_f_get_real8_elements_(int * gid,char * key,int * index,double * val,int * size,int len)2952 int grib_f_get_real8_elements_(int* gid, char* key,int* index, double* val, int *size, int len){
2953
2954 grib_handle *h = get_handle(*gid);
2955 char buf[1024];
2956
2957 if(!h) return GRIB_INVALID_GRIB;
2958
2959 return grib_get_double_elements(h, cast_char(buf,key,len), index,*size,val);
2960
2961 }
grib_f_get_real8_elements__(int * gid,char * key,int * index,double * val,int * len,int size)2962 int grib_f_get_real8_elements__(int* gid, char* key, int* index,double* val, int* len,int size){
2963 return grib_f_get_real8_elements_( gid, key, index, val,len,size);
2964 }
grib_f_get_real8_elements(int * gid,char * key,int * index,double * val,int * len,int size)2965 int grib_f_get_real8_elements(int* gid, char* key, int* index,double* val, int* len,int size){
2966 return grib_f_get_real8_elements_( gid, key, index, val,len,size);
2967 }
2968
2969 /*****************************************************************************/
grib_f_find_nearest_four_single_(int * gid,int * is_lsm,double * inlat,double * inlon,double * outlats,double * outlons,double * values,double * distances,int * indexes)2970 int grib_f_find_nearest_four_single_(int* gid,int* is_lsm,
2971 double* inlat,double* inlon,
2972 double* outlats,double* outlons,
2973 double* values,double* distances,
2974 int* indexes)
2975 {
2976 grib_nearest* nearest=NULL;
2977 int err=0, result=0;
2978 unsigned long flags=0;
2979 size_t len=4;
2980 grib_handle *h = get_handle(*gid);
2981
2982 if(!h) return GRIB_INVALID_GRIB;
2983
2984 nearest=grib_nearest_new(h,&err);
2985 if (err!=GRIB_SUCCESS) return err;
2986
2987 result = grib_nearest_find(nearest,h,*inlat,*inlon,
2988 flags,outlats,outlons,values,distances,indexes,&len);
2989
2990 grib_nearest_delete(nearest);
2991 return result;
2992 }
grib_f_find_nearest_four_single__(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes)2993 int grib_f_find_nearest_four_single__(int* gid,int* is_lsm,
2994 double* inlats,double* inlons,
2995 double* outlats,double* outlons,
2996 double* values,double* distances,
2997 int* indexes) {
2998
2999 return grib_f_find_nearest_four_single_(gid,is_lsm,
3000 inlats,inlons,outlats,outlons,values,
3001 distances,indexes);
3002 }
grib_f_find_nearest_four_single(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes)3003 int grib_f_find_nearest_four_single(int* gid,int* is_lsm,
3004 double* inlats,double* inlons,
3005 double* outlats,double* outlons,
3006 double* values,double* distances,
3007 int* indexes) {
3008
3009 return grib_f_find_nearest_four_single_(gid,is_lsm,
3010 inlats,inlons,outlats,outlons,values,
3011 distances,indexes);
3012 }
3013
3014 /*****************************************************************************/
grib_f_find_nearest_single_(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes)3015 int grib_f_find_nearest_single_(int* gid,int* is_lsm,
3016 double* inlats,double* inlons,
3017 double* outlats,double* outlons,
3018 double* values,double* distances,
3019 int* indexes) {
3020
3021 grib_handle *h = get_handle(*gid);
3022
3023 if(!h) return GRIB_INVALID_GRIB;
3024
3025 return grib_nearest_find_multiple(h,*is_lsm,
3026 inlats,inlons,1,outlats,outlons,
3027 values,distances,indexes);
3028 }
grib_f_find_nearest_single__(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes)3029 int grib_f_find_nearest_single__(int* gid,int* is_lsm,
3030 double* inlats,double* inlons,
3031 double* outlats,double* outlons,
3032 double* values,double* distances,
3033 int* indexes) {
3034
3035 return grib_f_find_nearest_single_(gid,is_lsm,
3036 inlats,inlons,outlats,outlons,values,
3037 distances,indexes);
3038 }
grib_f_find_nearest_single(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes)3039 int grib_f_find_nearest_single(int* gid,int* is_lsm,
3040 double* inlats,double* inlons,
3041 double* outlats,double* outlons,
3042 double* values,double* distances,
3043 int* indexes) {
3044
3045 return grib_f_find_nearest_single_(gid,is_lsm,
3046 inlats,inlons,outlats,outlons,values,
3047 distances,indexes);
3048 }
3049
3050 /*****************************************************************************/
grib_f_find_nearest_multiple_(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes,int * npoints)3051 int grib_f_find_nearest_multiple_(int* gid,int* is_lsm,
3052 double* inlats,double* inlons,
3053 double* outlats,double* outlons,
3054 double* values,double* distances,
3055 int* indexes, int* npoints) {
3056
3057 grib_handle *h = get_handle(*gid);
3058
3059 if(!h) return GRIB_INVALID_GRIB;
3060
3061 return grib_nearest_find_multiple(h,*is_lsm,
3062 inlats,inlons,*npoints,outlats,outlons,
3063 values,distances,indexes);
3064 }
grib_f_find_nearest_multiple__(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes,int * npoints)3065 int grib_f_find_nearest_multiple__(int* gid,int* is_lsm,
3066 double* inlats,double* inlons,
3067 double* outlats,double* outlons,
3068 double* values,double* distances,
3069 int* indexes, int* npoints) {
3070
3071 return grib_f_find_nearest_multiple_(gid,is_lsm,
3072 inlats,inlons,outlats,outlons,values,
3073 distances,indexes,npoints);
3074 }
grib_f_find_nearest_multiple(int * gid,int * is_lsm,double * inlats,double * inlons,double * outlats,double * outlons,double * values,double * distances,int * indexes,int * npoints)3075 int grib_f_find_nearest_multiple(int* gid,int* is_lsm,
3076 double* inlats,double* inlons,
3077 double* outlats,double* outlons,
3078 double* values,double* distances,
3079 int* indexes, int* npoints) {
3080
3081 return grib_f_find_nearest_multiple_(gid,is_lsm,
3082 inlats,inlons,outlats,outlons,values,
3083 distances,indexes,npoints);
3084 }
3085
3086 /*****************************************************************************/
grib_f_get_real8_array_(int * gid,char * key,double * val,int * size,int len)3087 int grib_f_get_real8_array_(int* gid, char* key, double*val, int* size, int len){
3088
3089 grib_handle *h = get_handle(*gid);
3090 int err = GRIB_SUCCESS;
3091 char buf[1024];
3092 size_t lsize = *size;
3093
3094 if(!h){
3095 return GRIB_INVALID_GRIB;
3096 }else{
3097 err = grib_get_double_array(h, cast_char(buf,key,len), val, &lsize);
3098 *size = lsize;
3099 return err;
3100 }
3101 }
grib_f_get_real8_array__(int * gid,char * key,double * val,int * size,int len)3102 int grib_f_get_real8_array__(int* gid, char* key, double*val, int* size, int len){
3103 return grib_f_get_real8_array_( gid, key, val, size, len);
3104 }
grib_f_get_real8_array(int * gid,char * key,double * val,int * size,int len)3105 int grib_f_get_real8_array(int* gid, char* key, double*val, int* size, int len){
3106 return grib_f_get_real8_array_( gid, key, val, size, len);
3107 }
3108
grib_f_set_force_real8_array__(int * gid,char * key,double * val,int * size,int len)3109 int grib_f_set_force_real8_array__(int* gid, char* key, double *val, int* size, int len){
3110 return grib_f_set_force_real8_array_( gid, key, val, size, len);
3111 }
grib_f_set_force_real8_array(int * gid,char * key,double * val,int * size,int len)3112 int grib_f_set_force_real8_array(int* gid, char* key, double *val, int* size, int len){
3113 return grib_f_set_force_real8_array_( gid, key, val, size, len);
3114 }
3115
grib_f_set_force_real8_array_(int * gid,char * key,double * val,int * size,int len)3116 int grib_f_set_force_real8_array_(int* gid, char* key, double*val, int* size, int len){
3117
3118 grib_handle *h = get_handle(*gid);
3119 char buf[1024];
3120 size_t lsize = *size;
3121
3122 if(!h) return GRIB_INVALID_GRIB;
3123
3124 return grib_set_force_double_array(h, cast_char(buf,key,len), val, lsize);
3125
3126 }
3127
3128 /*****************************************************************************/
grib_f_set_real8_array_(int * gid,char * key,double * val,int * size,int len)3129 int grib_f_set_real8_array_(int* gid, char* key, double*val, int* size, int len){
3130
3131 grib_handle *h = get_handle(*gid);
3132 char buf[1024];
3133 size_t lsize = *size;
3134
3135 if(!h) return GRIB_INVALID_GRIB;
3136
3137 return grib_set_double_array(h, cast_char(buf,key,len), val, lsize);
3138 }
grib_f_set_real8_array__(int * gid,char * key,double * val,int * size,int len)3139 int grib_f_set_real8_array__(int* gid, char* key, double *val, int* size, int len){
3140 return grib_f_set_real8_array_( gid, key, val, size, len);
3141 }
grib_f_set_real8_array(int * gid,char * key,double * val,int * size,int len)3142 int grib_f_set_real8_array(int* gid, char* key, double *val, int* size, int len){
3143 return grib_f_set_real8_array_( gid, key, val, size, len);
3144 }
3145
3146 /*****************************************************************************/
grib_f_get_string_array_(int * gid,char * key,char * val,int * nvals,int * slen,int len)3147 int grib_f_get_string_array_(int* gid, char* key, char* val,int* nvals,int* slen, int len)
3148 {
3149 grib_handle *h = get_handle(*gid);
3150 int err = GRIB_SUCCESS;
3151 size_t i;
3152 char buf[1024];
3153 size_t lsize = *nvals;
3154 char** cval=0;
3155 char* p=val;
3156
3157 if(!h) return GRIB_INVALID_GRIB;
3158
3159 cval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)*lsize);
3160 err = grib_get_string_array(h, cast_char(buf,key,len), cval, &lsize);
3161 if (err) return err;
3162
3163 if (strlen(cval[0])>*slen) err=GRIB_ARRAY_TOO_SMALL;
3164
3165 for (i=0;i<lsize;i++) {
3166 strcpy(p,cval[i]);
3167 czstr_to_fortran(p,*slen);
3168 grib_context_free(h->context,cval[i]);
3169 p+= *slen;
3170 }
3171 grib_context_free(h->context,cval);
3172
3173 return err;
3174 }
3175
grib_f_get_string_array__(int * gid,char * key,char * val,int * nvals,int * slen,int len)3176 int grib_f_get_string_array__(int* gid, char* key, char* val,int* nvals,int* slen, int len){
3177 return grib_f_get_string_array_( gid, key, val,nvals,slen,len);
3178 }
grib_f_get_string_array(int * gid,char * key,char * val,int * nvals,int * slen,int len)3179 int grib_f_get_string_array(int* gid, char* key, char* val,int* nvals,int* slen, int len){
3180 return grib_f_get_string_array_( gid, key, val, nvals, slen, len);
3181 }
3182
3183 /*****************************************************************************/
codes_f_bufr_copy_data_(int * gid1,int * gid2)3184 int codes_f_bufr_copy_data_(int* gid1,int* gid2)
3185 {
3186 grib_handle *hin = get_handle(*gid1);
3187 grib_handle *hout = get_handle(*gid2);
3188 int err = GRIB_SUCCESS;
3189
3190 if(!hin || !hout ) return GRIB_INVALID_GRIB;
3191
3192 err=codes_bufr_copy_data(hin,hout);
3193 if (err) return err;
3194
3195 return err;
3196 }
codes_f_bufr_copy_data__(int * gid1,int * gid2)3197 int codes_f_bufr_copy_data__(int* gid1,int* gid2){
3198 return codes_f_bufr_copy_data_(gid1, gid2);
3199 }
codes_f_bufr_copy_data(int * gid1,int * gid2)3200 int codes_f_bufr_copy_data(int* gid1,int* gid2){
3201 return codes_f_bufr_copy_data_(gid1, gid2);
3202 }
3203
3204
3205 /*****************************************************************************/
grib_f_set_string_array_(int * gid,char * key,char * val,int * nvals,int * slen,int len)3206 int grib_f_set_string_array_(int* gid, char* key, char* val,int* nvals,int* slen, int len)
3207 {
3208 grib_handle *h = get_handle(*gid);
3209 int err = GRIB_SUCCESS;
3210 size_t i;
3211 char buf[1024];
3212 size_t lsize = *nvals;
3213 char** cval=0;
3214 char* p=val;
3215 grib_context* c;
3216
3217 if(!h) return GRIB_INVALID_GRIB;
3218 c=h->context;
3219
3220 cval=(char**)grib_context_malloc_clear(h->context,sizeof(char*)*lsize);
3221 for (i=0;i<lsize;i++) {
3222 cval[i]=(char*)grib_context_malloc_clear(c,sizeof(char)* (*slen+1));
3223 cast_char_no_cut(cval[i],p,*slen);
3224 rtrim( cval[i] ); /* trim spaces at end of string */
3225 p+= *slen;
3226 }
3227 err = grib_set_string_array(h, cast_char(buf,key,len), (const char **)cval, lsize);
3228 if (err) return err;
3229
3230 for (i=0;i<lsize;i++) {
3231 grib_context_free(c,cval[i]);
3232 }
3233 grib_context_free(c,cval);
3234
3235 return err;
3236 }
3237
grib_f_set_string_array__(int * gid,char * key,char * val,int * nvals,int * slen,int len)3238 int grib_f_set_string_array__(int* gid, char* key, char* val,int* nvals,int* slen, int len){
3239 return grib_f_set_string_array_( gid, key, val,nvals,slen,len);
3240 }
grib_f_set_string_array(int * gid,char * key,char * val,int * nvals,int * slen,int len)3241 int grib_f_set_string_array(int* gid, char* key, char* val,int* nvals,int* slen, int len){
3242 return grib_f_set_string_array_( gid, key, val, nvals, slen, len);
3243 }
3244
3245 /*****************************************************************************/
grib_f_get_string_(int * gid,char * key,char * val,int len,int len2)3246 int grib_f_get_string_(int* gid, char* key, char* val,int len, int len2){
3247
3248 grib_handle *h = get_handle(*gid);
3249 int err = GRIB_SUCCESS;
3250 char buf[1024];
3251 size_t lsize = len2;
3252
3253 if(!h) return GRIB_INVALID_GRIB;
3254
3255 fort_char_clean(val,len2);
3256
3257 err = grib_get_string(h, cast_char(buf,key,len), val, &lsize);
3258
3259 czstr_to_fortran(val,len2);
3260
3261 return err;
3262 }
3263
grib_f_get_string__(int * gid,char * key,char * val,int len,int len2)3264 int grib_f_get_string__(int* gid, char* key, char* val, int len, int len2){
3265 return grib_f_get_string_( gid, key, val, len, len2);
3266 }
grib_f_get_string(int * gid,char * key,char * val,int len,int len2)3267 int grib_f_get_string(int* gid, char* key, char* val, int len, int len2){
3268 return grib_f_get_string_( gid, key, val, len, len2);
3269 }
3270
is_all_spaces(const char * s)3271 static int is_all_spaces(const char *s)
3272 {
3273 while (*s != '\0') {
3274 if (!isspace(*s)) return 0;
3275 s++;
3276 }
3277 return 1;
3278 }
grib_f_set_string_(int * gid,char * key,char * val,int len,int len2)3279 int grib_f_set_string_(int* gid, char* key, char* val, int len, int len2){
3280
3281 grib_handle *h = get_handle(*gid);
3282 char* val_str = NULL;
3283
3284 char buf[1024]={0,};
3285 char buf2[1024]={0,};
3286 size_t lsize = len2;
3287
3288 if(!h) return GRIB_INVALID_GRIB;
3289
3290 /* For BUFR, the value may contain spaces e.g. stationOrSiteName='CAMPO NOVO' */
3291 /* So do not use cast_char. cast_char_no_cut does not stop at first space */
3292 val_str = cast_char_no_cut(buf2,val,len2);
3293 if (val_str && !is_all_spaces(val_str)) {
3294 rtrim( val_str ); /* trim spaces at end of string */
3295 }
3296
3297 return grib_set_string(h, cast_char(buf,key,len), val_str, &lsize);
3298 }
3299
grib_f_set_string__(int * gid,char * key,char * val,int len,int len2)3300 int grib_f_set_string__(int* gid, char* key, char* val, int len, int len2){
3301 return grib_f_set_string_( gid, key, val, len, len2);
3302 }
grib_f_set_string(int * gid,char * key,char * val,int len,int len2)3303 int grib_f_set_string(int* gid, char* key, char* val, int len, int len2){
3304 return grib_f_set_string_( gid, key, val, len, len2);
3305 }
3306
3307 /*****************************************************************************/
grib_f_get_data_real4_(int * gid,float * lats,float * lons,float * values,size_t * size)3308 int grib_f_get_data_real4_(int* gid,float* lats, float* lons,float* values,size_t* size) {
3309
3310 grib_handle *h = get_handle(*gid);
3311 int err = GRIB_SUCCESS;
3312 double *lat8=NULL,*lon8=NULL,*val8 = NULL;
3313 size_t i=0;
3314
3315 if(!h) return GRIB_INVALID_GRIB;
3316
3317 val8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
3318 if(!val8) return GRIB_OUT_OF_MEMORY;
3319 lon8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
3320 if(!lon8) return GRIB_OUT_OF_MEMORY;
3321 lat8 = (double*)grib_context_malloc(h->context,(*size)*(sizeof(double)));
3322 if(!lat8) return GRIB_OUT_OF_MEMORY;
3323
3324 err=grib_get_data(h,lat8,lon8,val8);
3325
3326 for(i=0;i<*size;i++) {
3327 values[i] = val8[i];
3328 lats[i] = lat8[i];
3329 lons[i] = lon8[i];
3330 }
3331
3332 grib_context_free(h->context,val8);
3333 grib_context_free(h->context,lat8);
3334 grib_context_free(h->context,lon8);
3335
3336 return err;
3337
3338 }
grib_f_get_data_real4__(int * gid,float * lats,float * lons,float * values,size_t * size)3339 int grib_f_get_data_real4__(int* gid,float* lats, float* lons,float* values,size_t* size) {
3340 return grib_f_get_data_real4_(gid,lats,lons,values,size);
3341 }
grib_f_get_data_real4(int * gid,float * lats,float * lons,float * values,size_t * size)3342 int grib_f_get_data_real4(int* gid,float* lats, float* lons,float* values,size_t* size) {
3343 return grib_f_get_data_real4_(gid,lats,lons,values,size);
3344 }
3345
grib_f_get_data_real8_(int * gid,double * lats,double * lons,double * values,size_t * size)3346 int grib_f_get_data_real8_(int* gid,double* lats, double* lons,double* values,size_t* size) {
3347
3348 grib_handle *h = get_handle(*gid);
3349 return grib_get_data(h,lats,lons,values);
3350
3351 }
grib_f_get_data_real8__(int * gid,double * lats,double * lons,double * values,size_t * size)3352 int grib_f_get_data_real8__(int* gid,double* lats, double* lons,double* values,size_t* size) {
3353 return grib_f_get_data_real8_(gid,lats,lons,values,size);
3354 }
grib_f_get_data_real8(int * gid,double * lats,double * lons,double * values,size_t * size)3355 int grib_f_get_data_real8(int* gid,double* lats, double* lons,double* values,size_t* size) {
3356 return grib_f_get_data_real8_(gid,lats,lons,values,size);
3357 }
3358
3359 /*****************************************************************************/
grib_f_get_message_size_(int * gid,size_t * len)3360 int grib_f_get_message_size_(int* gid, size_t *len){
3361 grib_handle *h = get_handle(*gid);
3362 if(!h) return GRIB_INVALID_GRIB;
3363
3364 *len = h->buffer->ulength;
3365 return GRIB_SUCCESS;
3366
3367 }
grib_f_get_message_size__(int * gid,size_t * len)3368 int grib_f_get_message_size__(int* gid, size_t *len){
3369 return grib_f_get_message_size_( gid, len);
3370 }
grib_f_get_message_size(int * gid,size_t * len)3371 int grib_f_get_message_size(int* gid, size_t *len){
3372 return grib_f_get_message_size_( gid, len);
3373 }
3374
3375 /*****************************************************************************/
grib_f_copy_message_(int * gid,void * mess,size_t * len)3376 int grib_f_copy_message_(int* gid, void* mess,size_t* len){
3377 grib_handle *h = get_handle(*gid);
3378 if(!h)
3379 return GRIB_INVALID_GRIB;
3380
3381 if(*len < h->buffer->ulength) {
3382 grib_context_log(h->context,GRIB_LOG_ERROR,
3383 "grib_copy_message: buffer=%ld message size=%ld",*len,h->buffer->ulength);
3384 return GRIB_BUFFER_TOO_SMALL;
3385 }
3386
3387
3388 memcpy(mess,h->buffer->data,h->buffer->ulength);
3389 *len=h->buffer->ulength;
3390 return GRIB_SUCCESS;
3391
3392 }
3393
grib_f_copy_message__(int * gid,void * mess,size_t * len)3394 int grib_f_copy_message__(int* gid, void* mess,size_t* len){
3395 return grib_f_copy_message_( gid, mess, len);
3396 }
grib_f_copy_message(int * gid,void * mess,size_t * len)3397 int grib_f_copy_message(int* gid, void* mess,size_t* len){
3398 return grib_f_copy_message_( gid, mess, len);
3399 }
3400
3401 /*****************************************************************************/
grib_f_check_(int * err,char * call,char * str,int lencall,int lenstr)3402 void grib_f_check_(int* err,char* call,char* str,int lencall,int lenstr){
3403 char bufstr[1024]={0,};
3404 char bufcall[1024]={0,};
3405 grib_context* c=grib_context_get_default();
3406 if ( *err == GRIB_SUCCESS || *err == GRIB_END_OF_FILE ) return;
3407 cast_char(bufcall,call,lencall);
3408 cast_char(bufstr,str,lenstr);
3409 grib_context_log(c,GRIB_LOG_ERROR,"%s: %s %s",
3410 bufcall,bufstr,grib_get_error_message(*err));
3411 exit(*err);
3412 }
3413
grib_f_check__(int * err,char * call,char * key,int lencall,int lenkey)3414 void grib_f_check__(int* err,char* call, char* key, int lencall, int lenkey){
3415 grib_f_check_(err,call,key,lencall,lenkey);
3416 }
grib_f_check(int * err,char * call,char * key,int lencall,int lenkey)3417 void grib_f_check(int* err,char* call, char* key, int lencall, int lenkey){
3418 grib_f_check_(err,call,key,lencall,lenkey);
3419 }
3420
3421 /*****************************************************************************/
grib_f_write_(int * gid,int * fid)3422 int grib_f_write_(int* gid, int* fid) {
3423 grib_handle *h = get_handle(*gid);
3424 FILE* f = get_file(*fid);
3425 const void* mess = NULL;
3426 size_t mess_len = 0;
3427
3428 if(!f) return GRIB_INVALID_FILE;
3429 if (!h) return GRIB_INVALID_GRIB;
3430
3431 grib_get_message(h,&mess,&mess_len);
3432 if(fwrite(mess,1, mess_len,f) != mess_len) {
3433 perror("grib_write");
3434 return GRIB_IO_PROBLEM;
3435 }
3436
3437 return GRIB_SUCCESS;
3438 }
grib_f_write__(int * gid,int * fid)3439 int grib_f_write__(int* gid, int* fid) {
3440 return grib_f_write_(gid,fid);
3441 }
3442
grib_f_write(int * gid,int * fid)3443 int grib_f_write(int* gid, int* fid) {
3444 return grib_f_write_(gid,fid);
3445 }
3446
3447 /*****************************************************************************/
grib_f_multi_write_(int * gid,int * fid)3448 int grib_f_multi_write_(int* gid, int* fid) {
3449 grib_multi_handle *h = get_multi_handle(*gid);
3450 FILE* f = get_file(*fid);
3451
3452 if(!f) return GRIB_INVALID_FILE;
3453 if (!h) return GRIB_INVALID_GRIB;
3454
3455 return grib_multi_handle_write(h,f);
3456 }
3457
3458
grib_f_multi_write__(int * gid,int * fid)3459 int grib_f_multi_write__(int* gid, int* fid) {
3460 return grib_f_multi_write_(gid,fid);
3461 }
3462
grib_f_multi_write(int * gid,int * fid)3463 int grib_f_multi_write(int* gid, int* fid) {
3464 return grib_f_multi_write_(gid,fid);
3465 }
3466
grib_f_multi_append_(int * ingid,int * sec,int * mgid)3467 int grib_f_multi_append_(int* ingid, int* sec,int* mgid) {
3468 grib_handle *h = get_handle(*ingid);
3469 grib_multi_handle *mh = get_multi_handle(*mgid);
3470
3471 if (!h) return GRIB_INVALID_GRIB;
3472
3473 if (!mh) {
3474 mh=grib_multi_handle_new(h->context);
3475 push_multi_handle(mh,mgid);
3476 }
3477
3478 return grib_multi_handle_append(h,*sec,mh);
3479 }
3480
grib_f_multi_append(int * ingid,int * sec,int * mgid)3481 int grib_f_multi_append(int* ingid, int* sec,int* mgid) {
3482 return grib_f_multi_append_(ingid, sec, mgid);
3483 }
3484
grib_f_multi_append__(int * ingid,int * sec,int * mgid)3485 int grib_f_multi_append__(int* ingid, int* sec,int* mgid) {
3486 return grib_f_multi_append_(ingid, sec, mgid);
3487 }
3488
3489
3490 /*****************************************************************************/
codes_f_bufr_multi_element_constant_arrays_on_()3491 int codes_f_bufr_multi_element_constant_arrays_on_() {
3492 codes_bufr_multi_element_constant_arrays_on(NULL);
3493 return GRIB_SUCCESS;
3494 }
codes_f_bufr_multi_element_constant_arrays_on__()3495 int codes_f_bufr_multi_element_constant_arrays_on__() {
3496 return codes_f_bufr_multi_element_constant_arrays_on_();
3497 }
codes_f_bufr_multi_element_constant_arrays_on()3498 int codes_f_bufr_multi_element_constant_arrays_on() {
3499 return codes_f_bufr_multi_element_constant_arrays_on_();
3500 }
3501
codes_f_bufr_multi_element_constant_arrays_off_()3502 int codes_f_bufr_multi_element_constant_arrays_off_() {
3503 codes_bufr_multi_element_constant_arrays_off(NULL);
3504 return GRIB_SUCCESS;
3505 }
codes_f_bufr_multi_element_constant_arrays_off__()3506 int codes_f_bufr_multi_element_constant_arrays_off__() {
3507 return codes_f_bufr_multi_element_constant_arrays_off_();
3508 }
codes_f_bufr_multi_element_constant_arrays_off()3509 int codes_f_bufr_multi_element_constant_arrays_off() {
3510 return codes_f_bufr_multi_element_constant_arrays_off_();
3511 }
3512
3513
3514 /*****************************************************************************/
grib_f_set_definitions_path_(char * path,int len)3515 int grib_f_set_definitions_path_(char* path, int len){
3516 grib_context* c = grib_context_get_default();
3517 char buf[1024];
3518 grib_context_set_definitions_path(c, cast_char(buf,path,len));
3519 return GRIB_SUCCESS;
3520 }
grib_f_set_definitions_path__(char * path,int len)3521 int grib_f_set_definitions_path__(char* path, int len){
3522 return grib_f_set_definitions_path_(path, len);
3523 }
grib_f_set_definitions_path(char * path,int len)3524 int grib_f_set_definitions_path(char* path, int len){
3525 return grib_f_set_definitions_path_(path, len);
3526 }
3527
3528
grib_f_set_samples_path_(char * path,int len)3529 int grib_f_set_samples_path_(char* path, int len){
3530 grib_context* c = grib_context_get_default();
3531 char buf[1024];
3532 grib_context_set_samples_path(c, cast_char(buf,path,len));
3533 return GRIB_SUCCESS;
3534 }
grib_f_set_samples_path__(char * path,int len)3535 int grib_f_set_samples_path__(char* path, int len){
3536 return grib_f_set_samples_path_(path, len);
3537 }
grib_f_set_samples_path(char * path,int len)3538 int grib_f_set_samples_path(char* path, int len){
3539 return grib_f_set_samples_path_(path, len);
3540 }
3541
grib_f_julian_to_datetime(double * jd,long * year,long * month,long * day,long * hour,long * minute,long * second)3542 int grib_f_julian_to_datetime(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
3543 return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
3544 }
grib_f_julian_to_datetime_(double * jd,long * year,long * month,long * day,long * hour,long * minute,long * second)3545 int grib_f_julian_to_datetime_(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
3546 return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
3547 }
grib_f_julian_to_datetime__(double * jd,long * year,long * month,long * day,long * hour,long * minute,long * second)3548 int grib_f_julian_to_datetime__(double* jd,long* year,long* month,long* day,long *hour,long *minute,long *second) {
3549 return grib_julian_to_datetime(*jd,year,month,day,hour,minute,second);
3550 }
3551
grib_f_datetime_to_julian(long * year,long * month,long * day,long * hour,long * minute,long * second,double * jd)3552 int grib_f_datetime_to_julian(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
3553 return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
3554 }
grib_f_datetime_to_julian_(long * year,long * month,long * day,long * hour,long * minute,long * second,double * jd)3555 int grib_f_datetime_to_julian_(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
3556 return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
3557 }
grib_f_datetime_to_julian__(long * year,long * month,long * day,long * hour,long * minute,long * second,double * jd)3558 int grib_f_datetime_to_julian__(long* year,long* month,long* day, long* hour,long* minute,long* second,double* jd) {
3559 return grib_datetime_to_julian(*year,*month,*day,*hour,*minute,*second,jd);
3560 }
3561
3562