DataMuseum.dk

top - download

    Length: 7339 (0x1cab)
    Types: TextFile
    Names: »V«

└─⟦d10a02448⟧ Bits:30000409 8mm tape, Rational 1000, ENVIRONMENT, D_12_7_3
    └─ ⟦fc9b38f02⟧ »DATA« 
        └─⟦9b46a407a⟧ 
            └─⟦12c68c704⟧ 
                └─⟦this⟧ 
└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦458657fb6⟧ 
            └─⟦220843204⟧ 
                └─⟦this⟧ 

TextFile

with Device_Independent_Io;

package Tape_Tools is

    pragma Subsystem (Input_Output);
    pragma Module_Name (4, 3974);

    type Logical_Device is private;

    subtype Vol_Id_String    is String;  -- (1 .. 6);
    subtype Vol_Name_String  is String;  -- (1 .. 76);
    subtype Owner_String     is String;  -- (1 .. 13);
    subtype File_Id_String   is String;  --  (1 .. 17);
    subtype File_Name_String is String;  -- (1 .. 532);

    subtype User_Label_Number is Natural range 0 .. 255;

    subtype Byte  is Device_Independent_Io.Byte;
    subtype Bytes is Device_Independent_Io.Byte_String;

    procedure Initialize (Tape   : out Logical_Device;
                          Format :     String := "R1000");

    function Initialize (Format : String := "R1000") return Logical_Device;

    procedure Connect_For_Input (Tape        : in out Logical_Device;
                                 Vol_Id      :        Vol_Id_String;
                                 Vol_Name    :        Vol_Name_String := "";
                                 To_Operator :        String := "Thank You");

    -- Request tape with given Vol_Id/Vol_Name be mounted on a drive for
    -- the purpose of reading.

    procedure Connect_For_Output (Tape        : in out Logical_Device;
                                  Vol_Id      :        Vol_Id_String;
                                  Vol_Name    :        Vol_Name_String := "";
                                  Owner       :        String := "";
                                  To_Operator :        String := "Thank You");

    -- request a tape be mounted on a drive for writing; Assign the
    -- Vol_Id/Vol_Name/Owner per given parameters;

    function Vol_Id (Tape : Logical_Device) return String;
    -- Volume Id of mounted tape.

    function Vol_Name (Tape : Logical_Device) return String;

    -- Volume name of mounted tape (format dependent)

    function Owner (Tape : Logical_Device) return String;

    -- Owner of mounted tape (format dependent)


    procedure Label (Tape   : Logical_Device;
                     Number : User_Label_Number;
                     Label  : String);

    -- Define a User Label for the next Create.
    -- Up to 256 labels may be defined for one file

    type Record_Format is (Fixed_Length, Variable_Length, Spanned, Undefined);

    Default_Record_Format : constant Record_Format := Variable_Length;
    Default_Record_Length : constant Natural       := 512;
    Default_Block_Length  : constant Natural       := 2048;

    procedure Format (Tape          : Logical_Device;
                      Kind          : Record_Format := Default_Record_Format;
                      Record_Length : Natural       := Default_Record_Length;
                      Block_Length  : Natural       := Default_Block_Length);

    -- Define the record format for the next Create.  When the
    -- Logical_Device is initialized the record format is set to the above
    -- defaults.  An changes made by this procedure remain in effect until
    -- the next call of this procedure or the tape is disconnected.

    procedure Create (Tape : in out Logical_Device;
                      Id   :        File_Id_String;
                      Name :        File_Name_String := "");

    -- Start a new output file with the given Id (and Name) and any user
    -- labels defined before this call.

    procedure Open (Tape : in out Logical_Device);

    -- Open the next file on the tape;

    function File_Id (Tape : Logical_Device) return String;

    -- File Id of currently open tape file.

    function File_Name (Tape : Logical_Device) return String;

    -- File name of file opened/created on tape; (Format dependent);

    function Labels (Tape : Logical_Device) return Natural;

    -- number of user labels associated with the currently open file

    function Label (Tape : Logical_Device; Index : Natural) return String;
    function Label (Tape : Logical_Device; Index : Natural) return Natural;

    -- Index-th user label text or number associated with currently open file.
    -- Index must be less than the value returned by Labels

    function Format (Tape : Logical_Device) return Record_Format;

    -- The record format of the currently open file

    function Block_Length (Tape : Logical_Device) return Natural;

    -- The block length of the currently open file

    function Record_Length (Tape : Logical_Device) return Natural;

    -- The Record Length of the currently open file

    procedure Skip (Tape : Logical_Device; Number : Integer := 1);

    procedure Put_Line (Tape : Logical_Device; Line : String);
    function  Get_Line (Tape : Logical_Device) return String;
    procedure Get_Line (Tape   :     Logical_Device;
                        Line   : out String;
                        Length : out Natural);
    procedure Get_Line (Tape   :     Logical_Device;
                        Line   : out String;
                        Length : out Natural;
                        Eof    : out Boolean);

    procedure Put (Tape : Logical_Device; Data : Bytes);
    function  Get (Tape : Logical_Device) return Bytes;
    procedure Get (Tape   :     Logical_Device;
                   Data   : out Bytes;
                   Length : out Natural);
    procedure Get (Tape   :     Logical_Device;
                   Data   : out Bytes;
                   Length : out Natural;
                   Eof    : out Boolean);

    function End_Of_File (Tape : Logical_Device) return Boolean;
    function End_Of_Tape (Tape : Logical_Device) return Boolean;

    procedure Close      (Tape : Logical_Device);
    procedure Disconnect (Tape : Logical_Device);
    procedure Abandon    (Tape : Logical_Device);

    type Condition is (No_Errors, Vol_Already_Open_Or_Created,
                       Vol_Not_Open_Or_Created, Not_Initialized,
                       Not_Original_Client, Read_While_Writing,
                       Write_While_Reading, Position_While_Writing,
                       Previous_Fatal_Error, File_Still_Being_Written,
                       File_Still_Being_Read, File_Not_Created,
                       File_Not_Open, Retry_Count_Exhausted, Vol_Set_Error,
                       Unexpected_Tape_Error, No_Drive_Available,
                       Desired_Drive_Unavailable, Desired_Volume_Not_Found,
                       Vol_Access_Denied, File_Access_Denied,
                       File_Expired, End_Of_Vol_Set_Encountered,
                       Incorrect_File_Seq_No, Incorrect_File_Sect_No,
                       Need_Vol_Completion, Not_At_Eof, Not_At_Eov, Not_At_Eovs,
                       Incorrect_Buffer_Size, Block_Length_Too_Short,
                       Block_Length_Too_Long, File_Not_In_Vol_Set,
                       Record_Not_In_File, Format_Violation,
                       Unimplemented_Format, Attempt_To_Read_While_Writing,
                       Attempt_To_Write_While_Reading, Other_Error);

    function Status   (Tape : Logical_Device) return Condition;
    function Status   (Tape : Logical_Device) return String;
    function Is_Fatal (Error : Condition)     return Boolean;
    function Is_Fatal (Tape : Logical_Device) return Boolean;
private
    type Logical_Device_Record;
    type Logical_Device is access Logical_Device_Record;
    pragma Segmented_Heap (Logical_Device);
end Tape_Tools;