PreviousUpNext

15.3.506  src/lib/std/src/posix-1003.1b/posix-io.api

## posix-io.api
#
# Api for POSIX 1003.1 primitive I/O operations

# Compiled by:
#     src/lib/std/src/standard-core.sublib




###        "We tried to avoid, you know, records.
###         We were told over and over that was
###         probably the most serious mistake
###         and the reason was the system would never
###         catch on, because we didn't have records."
###
###                           -- Ken Thompson



###        "Where will wants not,
###           a way opens."
###
###                -- Eowyn
###
###                   [J.R.R. Tolkein, "Lord of the Rings"]


stipulate
    package pos =  file_position;                                                               # file_position                 is from   src/lib/std/types-only/bind-position-31.pkg
herein

    api Posix_Io {
        #
        eqtype File_Descriptor;
        eqtype Process_Id;

        make_pipe:  Void -> { infd:  File_Descriptor, outfd:  File_Descriptor };                # For named pipes ("fifos") see make_named_pipe in src/lib/std/src/posix-1003.1b/posix-file.api

        dup:  File_Descriptor -> File_Descriptor;
        dup2:  { old:  File_Descriptor, new:  File_Descriptor } -> Void;
        close:  File_Descriptor -> Void;

        read_as_vector:   { file_descriptor: File_Descriptor,  max_bytes_to_read: Int } -> vector_of_one_byte_unts::Vector;
        read_into_buffer: { file_descriptor: File_Descriptor,  buffer: rw_vector_slice_of_one_byte_unts::Slice } -> Int;

        write_vector:     (File_Descriptor,    vector_slice_of_one_byte_unts::Slice) -> Int;
        write_rw_vector:  (File_Descriptor, rw_vector_slice_of_one_byte_unts::Slice) -> Int;

        Whence = SEEK_SET | SEEK_CUR | SEEK_END;

        package fd:     api {
                            include Bit_Flags;          # Bit_Flags     is from   src/lib/std/src/bit-flags.api
                            #
                            cloexec:  Flags;
                        };

        package flags:  api {
                            include Bit_Flags;          # Bit_Flags     is from   src/lib/std/src/bit-flags.api
                            #
                            append:    Flags;
                            nonblock:  Flags;
                            sync:      Flags;

                            #  Lib7-isms(?): 
                            rsync:     Flags;
                            dsync:     Flags;
                        };

    #    include Posix_Common;

        dupfd:  { old:  File_Descriptor, base:  File_Descriptor } -> File_Descriptor;
        getfd:   File_Descriptor -> fd::Flags;
        setfd:  (File_Descriptor, fd::Flags) -> Void;
        getfl:   File_Descriptor -> (flags::Flags, posix_file::Open_Mode);
        setfl:  (File_Descriptor,    flags::Flags) -> Void;

        lseek:  (File_Descriptor, pos::Int, Whence) -> pos::Int;

        fsync:  File_Descriptor -> Void;

        Lock_Type = F_RDLCK | F_WRLCK | F_UNLCK;

        package flock:      api {
                                Flock;

                                flock
                                    :
                                    { ltype:  Lock_Type,
                                      whence: Whence,
                                      start:  pos::Int,
                                      len:    pos::Int,
                                      pid:    Null_Or( Process_Id )
                                    }
                                    ->
                                    Flock;

                                ltype:     Flock -> Lock_Type;
                                whence:    Flock -> Whence;
                                start:     Flock -> pos::Int;
                                len:       Flock -> pos::Int;
                                pid:       Flock -> Null_Or( Process_Id );
                            };

         getlk:   (File_Descriptor, flock::Flock) -> flock::Flock;
         setlk:   (File_Descriptor, flock::Flock) -> flock::Flock;
         setlkw:  (File_Descriptor, flock::Flock) -> flock::Flock;


         make_data_filereader:    { file_descriptor:    File_Descriptor,                        # "data" == "binary"
                                    filename:           String,
                                    ok_to_block:        Bool                                    # Initial value for ok_to_block stateflag. We will do nonblocking I/O whenever it is FALSE.
                                  }
                                  ->
                                  winix_base_data_file_io_driver_for_posix::Filereader;

         make_text_filereader:    { file_descriptor:    File_Descriptor,
                                    filename:           String,
                                    ok_to_block:        Bool                                    # Initial value for ok_to_block stateflag. We will do nonblocking I/O whenever it is FALSE.
                                  }
                                  ->
                                  winix_base_text_file_io_driver_for_posix::Filereader;

         make_data_filewriter:    { file_descriptor:    File_Descriptor,                        # "data" == "binary"
                                    filename:           String,
                                    append_mode:        Bool,
                                    ok_to_block:        Bool,                                   # Initial value for ok_to_block stateflag. We will do nonblocking I/O whenever it is FALSE.
                                    best_io_quantum:    Int
                                  }
                                  ->
                                  winix_base_data_file_io_driver_for_posix::Filewriter;

         make_text_filewriter:    { file_descriptor:    File_Descriptor,
                                    filename:           String,
                                    append_mode:        Bool,
                                    ok_to_block:        Bool,                                   # Initial value for ok_to_block stateflag. We will do nonblocking I/O whenever it is FALSE.
                                    best_io_quantum:    Int
                                  }
                                  ->
                                  winix_base_text_file_io_driver_for_posix::Filewriter;

    }; #  Api Posix_Io 

end;

## COPYRIGHT (c) 1995 AT&T Bell Laboratories.
## Subsequent changes by Jeff Prothero Copyright (c) 2010-2012,
## released under Gnu Public Licence version 3.


Comments and suggestions to: bugs@mythryl.org

PreviousUpNext