Home

Context Navigation

source: palm/trunk/SOURCE/posix_interface_mod.f90 @ 4749

Last change on this file since 4749 was 4652, checked in by raasch, 4 years ago
routine posix_calls_from_fortran merged into posix_interface_mod
Property svn:keywords set to `Id`
File size: 21.0 KB

Line
1	!> @file posix_interface_mod.f90
2	!--------------------------------------------------------------------------------------------------!
3	! This file is part of the PALM model system.
4	!
5	! PALM is free software: you can redistribute it and/or modify it under the terms of the GNU General
6	! Public License as published by the Free Software Foundation, either version 3 of the License, or
7	! (at your option) any later version.
8	!
9	! PALM is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
10	! implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
11	! Public License for more details.
12	!
13	! You should have received a copy of the GNU General Public License along with PALM. If not, see
14	! <http://www.gnu.org/licenses/>.
15	!
16	! Copyright 1997-2020 Leibniz Universitaet Hannover
17	!--------------------------------------------------------------------------------------------------!
18	!
19	!
20	! Current revisions:
21	! -----------------
22	!
23	!
24	! Former revisions:
25	! -----------------
26	! $Id: posix_interface_mod.f90 4652 2020-08-27 08:51:55Z maronga $
27	! Routine fortran_sleep moved from old module posix_calls_from_fortran to here
28	!
29	! 4649 2020-08-25 12:11:17Z raasch
30	! File re-formatted to follow the PALM coding standard
31	!
32	!
33	! 4628 2020-07-29 07:23:03Z raasch
34	! Extensions required for MPI-I/O of particle data to restart files
35	!
36	! 4495 2020-04-13 20:11:20Z raasch
37	! Initial version (K. Ketelsen)
38	!
39	!
40	!--------------------------------------------------------------------------------------------------!
41	! Description:
42	! ------------
43	!> Interface to some POSIX system calls, mainly used for read/write of restart files in non-parallel
44	!> mode in MPI-IO compatible format.
45	!--------------------------------------------------------------------------------------------------!
46	MODULE posix_interface
47
48	USE ISO_C_BINDING
49
50	USE kinds
51
52	IMPLICIT NONE
53
54	PRIVATE
55
56	SAVE
57
58	!
59	!-- Definitions copied from C include file fcntl.h
60	INTEGER, PARAMETER :: o_creat = 64 !< 0100 octal
61	INTEGER, PARAMETER :: o_rdonly = 0 !<
62	INTEGER, PARAMETER :: o_rdwr = 2 !<
63	INTEGER, PARAMETER :: o_wronly = 1 !<
64	INTEGER, PARAMETER :: seek_set = 0 !<
65
66
67	!
68	!-- Interfaces for POSIX calls
69	INTERFACE
70	INTEGER(C_INT) FUNCTION C_OPEN( pathname, flags, mode ) BIND( C, NAME = 'open' )
71	USE ISO_C_BINDING
72	IMPLICIT NONE
73	CHARACTER(KIND=C_CHAR), DIMENSION(128) :: pathname !<
74	INTEGER(KIND=C_INT), VALUE :: flags !<
75	INTEGER(KIND=C_INT), VALUE :: mode !<
76	END FUNCTION C_OPEN
77	END INTERFACE
78
79	INTERFACE
80	INTEGER(C_SIZE_T) FUNCTION C_LSEEK( fd, offset, whence ) BIND( C, NAME = 'lseek' )
81	USE ISO_C_BINDING
82	IMPLICIT NONE
83	INTEGER(KIND=C_INT), VALUE :: fd !<
84	INTEGER(KIND=C_SIZE_T), VALUE :: offset !<
85	INTEGER(KIND=C_INT), VALUE :: whence !<
86	END FUNCTION C_LSEEK
87	END INTERFACE
88
89	!
90	!-- The read system call uses values of type off_t. There is no Fortran C_OFF_T, therefore C_SIZE_T
91	!-- has been used here, assuming both are 8 byte integers.
92	INTERFACE
93	INTEGER(C_SIZE_T) FUNCTION C_READ( fd, buf, nr_byte ) BIND(C, NAME = 'read' )
94	USE ISO_C_BINDING
95	IMPLICIT NONE
96	INTEGER(KIND=C_INT), VALUE :: fd !<
97	INTEGER(KIND=C_SIZE_T), VALUE :: nr_byte !<
98	TYPE(C_PTR), VALUE :: buf !<
99	END FUNCTION C_READ
100	END INTERFACE
101
102	INTERFACE
103	INTEGER(C_SIZE_T) FUNCTION C_WRITE( fd, buf, nr_byte ) BIND( C, NAME = 'write' )
104	USE ISO_C_BINDING
105	IMPLICIT NONE
106	INTEGER(KIND=C_INT), VALUE :: fd !<
107	INTEGER(KIND=C_SIZE_T), VALUE :: nr_byte !<
108	TYPE(C_PTR), VALUE :: buf !<
109	END FUNCTION C_WRITE
110	END INTERFACE
111
112	INTERFACE
113	INTEGER(C_INT) FUNCTION C_CLOSE( fd ) BIND( C, NAME = 'close' )
114	USE ISO_C_BINDING
115	IMPLICIT NONE
116	INTEGER(KIND=C_INT), VALUE :: fd !<
117	END FUNCTION C_CLOSE
118	END INTERFACE
119
120	!
121	!-- Sleep function from C library
122	INTERFACE
123	FUNCTION fsleep( seconds ) BIND( C, NAME = 'sleep' )
124	IMPORT
125	INTEGER(C_INT) :: fsleep !<
126	INTEGER(C_INT), INTENT(IN), VALUE :: seconds !<
127	END FUNCTION fsleep
128	END INTERFACE
129
130	!
131	!-- PALM interfaces
132	INTERFACE fortran_sleep
133	MODULE PROCEDURE fortran_sleep
134	END INTERFACE fortran_sleep
135
136	INTERFACE posix_close
137	MODULE PROCEDURE posix_close
138	END INTERFACE posix_close
139
140	INTERFACE posix_lseek
141	MODULE PROCEDURE posix_lseek
142	END INTERFACE posix_lseek
143
144	INTERFACE posix_open
145	MODULE PROCEDURE posix_open
146	END INTERFACE posix_open
147
148	INTERFACE posix_read
149	MODULE PROCEDURE posix_read
150	MODULE PROCEDURE posix_read_char_array
151	MODULE PROCEDURE posix_read_int_1d
152	MODULE PROCEDURE posix_read_int_2d
153	MODULE PROCEDURE posix_read_i4_3d
154	MODULE PROCEDURE posix_read_i8_3d
155	MODULE PROCEDURE posix_read_offset_1d
156	MODULE PROCEDURE posix_read_real_1d
157	MODULE PROCEDURE posix_read_real_2d
158	MODULE PROCEDURE posix_read_real_3d
159	END INTERFACE posix_read
160
161	INTERFACE posix_write
162	MODULE PROCEDURE posix_write
163	MODULE PROCEDURE posix_write_char_array
164	MODULE PROCEDURE posix_write_int_1d
165	MODULE PROCEDURE posix_write_int_2d
166	MODULE PROCEDURE posix_write_i4_3d
167	MODULE PROCEDURE posix_write_i8_3d
168	MODULE PROCEDURE posix_write_offset_1d
169	MODULE PROCEDURE posix_write_real_1d
170	MODULE PROCEDURE posix_write_real_2d
171	MODULE PROCEDURE posix_write_real_3d
172	END INTERFACE posix_write
173
174	PUBLIC fortran_sleep, &
175	posix_close, &
176	posix_lseek, &
177	posix_open, &
178	posix_read, &
179	posix_write
180
181	CONTAINS
182
183	!--------------------------------------------------------------------------------------------------!
184	! Description:
185	! ------------
186	!> Wait a specified amount of seconds
187	!--------------------------------------------------------------------------------------------------!
188	SUBROUTINE fortran_sleep( seconds )
189
190	INTEGER, INTENT(IN) :: seconds !< seconds to wait
191
192	INTEGER(C_INT) :: seconds_in_c !< same as seconds
193	INTEGER(C_INT) :: sleep_return_value !< returned value to sleep
194
195	seconds_in_c = seconds
196
197	sleep_return_value = fsleep( seconds_in_c )
198
199	END SUBROUTINE fortran_sleep
200
201
202	INTEGER FUNCTION posix_open( file_name, rd_flag )
203
204	IMPLICIT NONE
205
206	CHARACTER(LEN=*), INTENT(IN) :: file_name !<
207	CHARACTER(LEN=1), DIMENSION(:), POINTER :: f_string !<
208	CHARACTER(LEN=128), TARGET :: lo_file_name !<
209
210	INTEGER(C_INT) :: fd !<
211	INTEGER(C_INT) :: flags !<
212	INTEGER(C_INT) :: name_len !<
213	INTEGER(C_INT) :: mode !<
214	INTEGER, DIMENSION(1) :: bufshape !<
215
216	LOGICAL, INTENT(IN) :: rd_flag !<
217
218	TYPE(C_PTR) :: ptr !<
219
220
221	!
222	!-- Note: There might be better solutions to convert FORTRAN string to C string but this works on
223	!-- different FORTRAN compiler
224	name_len = LEN( TRIM( file_name ) ) + 1
225	lo_file_name = TRIM( file_name ) // CHAR( 0 )
226	ptr = C_LOC( lo_file_name(1:1) )
227	bufshape(1) = name_len
228	CALL C_F_POINTER( ptr, f_string, bufshape )
229
230	mode = 420 ! Mode 644
231
232	IF ( rd_flag ) THEN
233	flags = o_rdonly
234	fd = C_OPEN( f_string, flags, mode ) ! Open for reading
235	ELSE
236	flags = o_wronly + o_creat
237	fd = C_OPEN( f_string, flags, mode ) ! Open for writing
238	ENDIF
239
240	posix_open = fd
241
242	END FUNCTION posix_open
243
244
245
246	SUBROUTINE posix_lseek( fid, offset )
247
248	IMPLICIT NONE
249
250	INTEGER, INTENT(IN) :: fid !<
251	INTEGER(KIND=C_INT) :: my_fid !<
252	INTEGER(KIND=C_SIZE_T), INTENT(IN) :: offset !<
253	INTEGER(KIND=C_SIZE_T) :: retval !<
254	INTEGER(KIND=C_INT) :: whence !<
255
256
257	my_fid = fid
258	whence = seek_set
259
260	retval = C_LSEEK( my_fid, offset, whence )
261
262	END SUBROUTINE posix_lseek
263
264
265
266	SUBROUTINE posix_read_int_1d( fid, data, nw )
267
268	IMPLICIT NONE
269
270	INTEGER :: nr_byte !<
271	INTEGER, INTENT(IN) :: fid !<
272	INTEGER, INTENT(IN) :: nw !<
273	INTEGER(KIND=iwp), INTENT(IN), TARGET, DIMENSION(:) :: data !<
274	TYPE(C_PTR) :: buf !<
275
276
277	nr_byte = nw*iwp
278	buf = C_LOC( data )
279
280	CALL posix_read( fid, buf, nr_byte )
281
282	END SUBROUTINE posix_read_int_1d
283
284
285
286	SUBROUTINE posix_read_int_2d( fid, data, nw )
287
288	IMPLICIT NONE
289
290	INTEGER :: nr_byte !<
291	INTEGER, INTENT(IN) :: fid !<
292	INTEGER, INTENT(IN) :: nw !<
293	INTEGER(KIND=iwp), INTENT(IN), TARGET, DIMENSION(:,:) :: data !<
294	TYPE(C_PTR) :: buf !<
295
296
297	nr_byte = nw * iwp
298	buf = C_LOC( data )
299
300	CALL posix_read( fid, buf, nr_byte )
301
302	END SUBROUTINE posix_read_int_2d
303
304
305
306	SUBROUTINE posix_read_i4_3d( fid, data, nw )
307
308	IMPLICIT NONE
309
310	INTEGER :: nr_byte !<
311	INTEGER, INTENT(IN) :: fid !<
312	INTEGER, INTENT(IN) :: nw !<
313	INTEGER(KIND=isp), INTENT(IN), TARGET, DIMENSION(:,:,:) :: data !<
314	TYPE(C_PTR) :: buf !<
315
316
317	nr_byte = nw * isp
318	buf = C_LOC( data )
319
320	CALL posix_read( fid, buf, nr_byte )
321
322	END SUBROUTINE posix_read_i4_3d
323
324
325
326	SUBROUTINE posix_read_i8_3d( fid, data, nw )
327
328	IMPLICIT NONE
329
330	INTEGER :: nr_byte !<
331	INTEGER, INTENT(IN) :: fid !<
332	INTEGER, INTENT(IN) :: nw !<
333	INTEGER(KIND=idp), INTENT(IN), TARGET, DIMENSION(:,:,:) :: data !<
334	TYPE(C_PTR) :: buf !<
335
336
337	nr_byte = nw * idp
338	buf = C_LOC( data )
339
340	CALL posix_read( fid, buf, nr_byte )
341
342	END SUBROUTINE posix_read_i8_3d
343
344
345
346	SUBROUTINE posix_read_offset_1d( fid, data, nw )
347
348	IMPLICIT NONE
349
350	INTEGER :: nr_byte !<
351	INTEGER, INTENT(IN) :: fid !<
352	INTEGER, INTENT(IN) :: nw !<
353	INTEGER(KIND=C_SIZE_T), INTENT(IN), TARGET, DIMENSION(:) :: data !<
354	TYPE(C_PTR) :: buf !<
355
356
357	nr_byte = nw * C_SIZE_T
358	buf = C_LOC( data )
359
360	CALL posix_read( fid, buf, nr_byte )
361
362	END SUBROUTINE posix_read_offset_1d
363
364
365
366	SUBROUTINE posix_read_real_1d( fid, data, nw )
367
368	IMPLICIT NONE
369
370	INTEGER :: nr_byte !<
371	INTEGER, INTENT(IN) :: fid !<
372	INTEGER, INTENT(IN) :: nw !<
373
374	REAL(KIND=wp), INTENT(IN), TARGET, DIMENSION(:) :: data !<
375
376	TYPE(C_PTR) :: buf !<
377
378
379	nr_byte = nw * wp
380	buf = C_LOC( data )
381
382	CALL posix_read( fid, buf, nr_byte )
383
384	END SUBROUTINE posix_read_real_1d
385
386
387
388	SUBROUTINE posix_read_real_2d( fid, data, nw )
389
390	IMPLICIT NONE
391
392	INTEGER :: nr_byte !<
393	INTEGER, INTENT(IN) :: fid !<
394	INTEGER, INTENT(IN) :: nw !<
395
396	REAL(KIND=wp), INTENT(INOUT), TARGET, DIMENSION(:,:) :: data !<
397
398	TYPE(C_PTR) :: buf !<
399
400
401	nr_byte = nw * wp
402	buf = C_LOC( data )
403
404	CALL posix_read( fid, buf, nr_byte )
405
406	END SUBROUTINE posix_read_real_2d
407
408
409
410	SUBROUTINE posix_read_real_3d( fid, data, nw )
411
412	IMPLICIT NONE
413
414	INTEGER :: nr_byte !<
415	INTEGER, INTENT(IN) :: fid !<
416	INTEGER, INTENT(IN) :: nw !<
417
418	REAL(KIND=wp), INTENT(INOUT), TARGET, DIMENSION(:,:,:) :: data !<
419
420	TYPE(C_PTR) :: buf !<
421
422
423	nr_byte = nw * wp
424	buf = C_LOC( data )
425
426	CALL posix_read( fid, buf, nr_byte )
427
428	END SUBROUTINE posix_read_real_3d
429
430
431
432	SUBROUTINE posix_read( fid, buf, nb )
433
434	IMPLICIT NONE
435
436	INTEGER, INTENT(IN) :: fid !<
437	INTEGER , INTENT(IN) :: nb !<
438	INTEGER(KIND=C_INT) :: my_fid !<
439	INTEGER(KIND=C_SIZE_T) :: nr_byte !<
440	INTEGER(KIND=C_SIZE_T) :: retval !<
441
442	TYPE(C_PTR) :: buf !<
443
444
445	my_fid = fid
446	nr_byte = nb
447
448	retval = C_READ( my_fid, buf, nr_byte )
449
450	!
451	!-- The posix standard says that it is not guaranteed that all bytes are read in one read system
452	!-- call. If retval is not equal to nr_byte, another system call has to be issued.
453	!-- However, in all Unix distributions it is commonly accepted, that all bytes are read in one call
454	!-- during during disk-IO. Therefore, here is only an error query and no reading in a while loop.
455	IF ( retval /= nr_byte ) THEN
456	WRITE( 6, * ) 'Number of bytes read does not match the number of requested bytes'
457	CALL abort
458	ENDIF
459
460	END SUBROUTINE posix_read
461
462
463
464	SUBROUTINE posix_read_char_array( fid, data )
465
466	IMPLICIT NONE
467
468	CHARACTER(LEN=*), DIMENSION(:) :: data !<
469	CHARACTER(LEN=LEN(data)), TARGET :: data_buf !<
470
471	INTEGER :: i !<
472	INTEGER, INTENT(IN) :: fid !<
473	INTEGER(KIND=C_INT) :: my_fid !<
474	INTEGER(KIND=C_SIZE_T) :: name_len !<
475	INTEGER(KIND=C_SIZE_T) :: retval !<
476
477	TYPE(C_PTR) :: ptr !<
478
479
480	my_fid = fid
481
482	DO i = 1, SIZE( data )
483	data_buf = data(i)
484	name_len = LEN( data(i) )
485	ptr = C_LOC( data_buf(1:1) )
486	retval = C_READ( my_fid, ptr, name_len )
487	data(i) = data_buf
488	ENDDO
489
490	END SUBROUTINE posix_read_char_array
491
492
493
494	SUBROUTINE posix_write_int_1d( fid, data, nw )
495
496	IMPLICIT NONE
497
498	INTEGER, INTENT(IN) :: fid !<
499	INTEGER ,INTENT(IN) :: nw !<
500	INTEGER(KIND=C_INT) :: my_fid !<
501	INTEGER(KIND=C_SIZE_T) :: nr_byte !<
502	INTEGER(KIND=C_SIZE_T) :: retval !<
503
504	INTEGER(KIND=iwp), INTENT(IN), TARGET, DIMENSION(:) :: data !<
505
506	TYPE(C_PTR) :: buf !<
507
508
509	my_fid = fid
510	nr_byte = nw * iwp
511	buf = C_LOC( data )
512
513	retval = C_WRITE( my_fid, buf, nr_byte )
514
515	END SUBROUTINE posix_write_int_1d
516
517
518
519	SUBROUTINE posix_write_int_2d( fid, data, nw )
520
521	IMPLICIT NONE
522
523	INTEGER :: nr_byte !<
524	INTEGER, INTENT(IN) :: fid !<
525	INTEGER, INTENT(IN) :: nw !<
526
527	INTEGER(KIND=iwp), INTENT(IN), TARGET, DIMENSION(:,:) :: data !<
528
529	TYPE(C_PTR) :: buf !<
530
531
532	nr_byte = nw * iwp
533	buf = C_LOC( data )
534
535	CALL posix_write( fid, buf, nr_byte )
536
537	END SUBROUTINE posix_write_int_2d
538
539
540
541	SUBROUTINE posix_write_i4_3d( fid, data, nw )
542
543	IMPLICIT NONE
544
545	INTEGER :: nr_byte !<
546	INTEGER, INTENT(IN) :: fid !<
547	INTEGER, INTENT(IN) :: nw !<
548
549	INTEGER(KIND=isp), INTENT(IN), TARGET, DIMENSION(:,:,:) :: data !<
550
551	TYPE(C_PTR) :: buf !<
552
553
554	nr_byte = nw * isp
555	buf = C_LOC( data )
556
557	CALL posix_write( fid, buf, nr_byte )
558
559	END SUBROUTINE posix_write_i4_3d
560
561
562
563	SUBROUTINE posix_write_i8_3d( fid, data, nw )
564
565	IMPLICIT NONE
566
567	INTEGER :: nr_byte !<
568	INTEGER, INTENT(IN) :: fid !<
569	INTEGER, INTENT(IN) :: nw !<
570
571	INTEGER(KIND=idp), INTENT(IN), TARGET, DIMENSION(:,:,:) :: data !<
572
573	TYPE(C_PTR) :: buf !<
574
575
576	nr_byte = nw * idp
577	buf = C_LOC( data )
578
579	CALL posix_write( fid, buf, nr_byte )
580
581	END SUBROUTINE posix_write_i8_3d
582
583
584
585	SUBROUTINE posix_write_offset_1d( fid, data, nw )
586
587	IMPLICIT NONE
588
589	INTEGER :: nr_byte !<
590	INTEGER, INTENT(IN) :: fid !<
591	INTEGER, INTENT(IN) :: nw !<
592
593	INTEGER(KIND=C_SIZE_T), INTENT(IN), TARGET, DIMENSION(:) :: data !<
594
595	TYPE(C_PTR) :: buf !<
596
597
598	nr_byte = nw * STORAGE_SIZE( data(1) ) / 8
599	buf = C_LOC( data )
600
601	CALL posix_write(fid, buf, nr_byte )
602
603	END SUBROUTINE posix_write_offset_1d
604
605
606
607	SUBROUTINE posix_write_real_1d( fid, data, nw )
608
609	IMPLICIT NONE
610
611	INTEGER :: nr_byte !<
612	INTEGER, INTENT(IN) :: fid !<
613	INTEGER, INTENT(IN) :: nw !<
614
615	REAL(KIND=wp), INTENT(IN), TARGET, DIMENSION(:) :: data !<
616
617	TYPE(C_PTR) :: buf !<
618
619
620	nr_byte = nw * wp
621	buf = C_LOC( data )
622
623	CALL posix_write( fid, buf, nr_byte )
624
625	END SUBROUTINE posix_write_real_1d
626
627
628
629	SUBROUTINE posix_write_real_2d( fid, data, nw )
630
631	IMPLICIT NONE
632
633	INTEGER :: nr_byte !<
634	INTEGER, INTENT(IN) :: fid !<
635	INTEGER, INTENT(IN) :: nw !<
636
637	REAL(KIND=wp), INTENT(INOUT), TARGET, DIMENSION(:,:) :: data !<
638
639	TYPE(C_PTR) :: buf !<
640
641
642	nr_byte = nw * wp
643	buf = C_LOC( data )
644
645	CALL posix_write( fid, buf, nr_byte )
646
647	END SUBROUTINE posix_write_real_2d
648
649
650
651	SUBROUTINE posix_write_real_3d( fid, data, nw )
652
653	IMPLICIT NONE
654
655	INTEGER :: nr_byte !<
656	INTEGER, INTENT(IN) :: fid !<
657	INTEGER, INTENT(IN) :: nw !<
658
659	REAL(KIND=wp), INTENT(INOUT), TARGET, DIMENSION(:,:,:) :: data !<
660
661	TYPE(C_PTR) :: buf !<
662
663
664	nr_byte = nw * wp
665	buf = C_LOC( data )
666
667	CALL posix_write( fid, buf, nr_byte )
668
669	END SUBROUTINE posix_write_real_3d
670
671
672
673	SUBROUTINE posix_write( fid, buf, nb )
674
675	IMPLICIT NONE
676
677	INTEGER, INTENT(IN) :: fid !<
678	INTEGER , INTENT(IN) :: nb !<
679	INTEGER(KIND=C_INT) :: my_fid !<
680	INTEGER(KIND=C_SIZE_T) :: nr_byte !<
681	INTEGER(KIND=C_SIZE_T) :: retval !<
682
683	TYPE(C_PTR) :: buf !<
684
685
686	my_fid = fid
687	nr_byte = nb
688
689	retval = C_WRITE( my_fid, buf, nr_byte )
690
691	IF ( retval /= nr_byte ) THEN
692	WRITE( 6, * ) 'Number of bytes to write does not match the number of requested bytes'
693	CALL abort
694	ENDIF
695
696	END SUBROUTINE posix_write
697
698
699
700	SUBROUTINE posix_write_char_array( fid, data )
701
702	IMPLICIT NONE
703
704	CHARACTER(LEN=*), DIMENSION(:) :: data !<
705	CHARACTER(LEN=LEN(data)+1), TARGET :: data_buf !<
706
707	INTEGER :: i !<
708	INTEGER, INTENT(IN) :: fid !<
709	INTEGER(KIND=C_INT) :: my_fid !<
710	INTEGER(KIND=C_SIZE_T) :: name_len !<
711	INTEGER(KIND=C_SIZE_T) :: retval !<
712
713	TYPE(C_PTR) :: ptr !<
714
715
716	my_fid = fid
717
718	DO i = 1, SIZE( data )
719	data_buf = data(i) // CHAR( 0 )
720	name_len = LEN( data(i) )
721	ptr = C_LOC( data_buf(1:1) )
722	retval = C_WRITE( my_fid, ptr, name_len )
723	ENDDO
724
725	END SUBROUTINE posix_write_char_array
726
727
728
729	SUBROUTINE posix_close( fid )
730
731	IMPLICIT NONE
732
733	INTEGER, INTENT(IN) :: fid !<
734	INTEGER(KIND=C_INT) :: my_fid !<
735	INTEGER(KIND=C_INT) :: retval !<
736
737
738	my_fid = fid
739
740	retval = C_CLOSE( my_fid )
741
742	END SUBROUTINE posix_close
743
744
745	END MODULE posix_interface

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |