DataMuseum.dk

top - metrics - download

    Length: 6506 (0x196a)
    Types: TextFile
    Names: »B«

└─⟦180fe333a⟧ Bits:30000405 8mm tape, Rational 1000, SW CATALOG, 10_20_0
└─⟦180fe333a⟧ Bits:30000537 8mm tape, Rational 1000, SW Catalog 10_20_0
    └─⟦5cb1d1d7f⟧ »DATA« 
        └─⟦3b1ee7bd8⟧ 
            └─⟦this⟧ 

TextFile

with Names;
with Defaults;
with Pathnames;
with Directory_Tools;
with String_Utilities;
with System_Utilities;
package body Arguments is

    function Is_Default_User (This_Argument : in Argument) return Boolean is
    begin
        return (String_Utilities.Upper_Case (This_Argument) = Default_User);
    end Is_Default_User;

    function User_From (User_Argument : in Argument) return User_Name is
    begin
        if (Is_Default_User (User_Argument)) then
            return (System_Utilities.User_Name);
        end if;
        if (not Names.Is_User_Name (User_Argument)) then
            raise Invalid_Username;
        end if;
        return (String_Utilities.Upper_Case (User_Argument));
    end User_From;

    function Is_Default (This_Argument : in Argument) return Boolean is
    begin
        return (String_Utilities.Upper_Case (This_Argument) = Default);
    end Is_Default;

    function Catalog_From
                (This_Catalog_Argument : in Argument) return Full_Name is
    begin
        if (Is_Default (This_Catalog_Argument)) then
            return (Catalog_For (This_User => System_Utilities.User_Name));
        end if;
        declare
            The_Catalog : constant Full_Name :=
               Pathnames.Full_Catalog_Name
                  (This_Catalog => This_Catalog_Argument);
        begin
            Pathnames.Assert_Is_Valid_Catalog_Name (The_Catalog);
            return (The_Catalog);
        end;
        --
    exception
        when Defaults.Io_Failure =>
            raise Io_Failure;  
        when Pathnames.Invalid_Catalog_Name =>
            raise Invalid_Catalog;
        when others =>
            raise;
            --
    end Catalog_From;

    function Simple_Catalog_From
                (This_Catalog_Argument : in Argument) return Simple_Name is
    begin
        return (Directory_Tools.Naming.Simple_Name
                   (Arguments.Catalog_From (This_Catalog_Argument)));
    end Simple_Catalog_From;

    function Catalog_For (This_User : in Argument) return Full_Name is
    begin  
        declare
            The_Catalog : constant Full_Name :=
               Defaults.Full_Catalog (For_User =>
                                         Arguments.User_From (This_User));
        begin
            if (not Pathnames.Is_Valid_Catalog_Name (The_Catalog)) then
                raise Invalid_Catalog;
            end if;
            return (The_Catalog);
        end;
        --
    exception
        when Invalid_Username | Invalid_Catalog =>
            raise;
        when others =>
            raise Io_Failure;
            --
    end Catalog_For;

    function Simple_Catalog_For (This_User : in Argument) return Simple_Name is
    begin
        return (Directory_Tools.Naming.Simple_Name
                   (Arguments.Catalog_For (This_User)));
    end Simple_Catalog_For;

    function Version_From
                (This_Catalog_Argument : in Argument;
                 This_Version_Argument : in Argument) return Full_Name is
    begin  
        declare
            The_Catalog : constant Full_Name :=
               Catalog_From (This_Catalog_Argument);
        begin  
            Pathnames.Assert_Is_Valid_Catalog_Name (The_Catalog);
            if (Is_Default (This_Version_Argument)) then
                declare
                    The_Simple_Version : constant Simple_Name :=
                       Defaults.Version (System_Utilities.User_Name);
                    The_Full_Version : constant Simple_Name :=
                       Pathnames.Full_Version_Name
                          (This_Catalog => The_Catalog,
                           This_Version => The_Simple_Version);
                begin
                    Pathnames.Assert_Is_Valid_Version_Name (The_Full_Version);
                    return (The_Full_Version);
                end;
            end if;
            declare
                The_Version : constant Full_Name :=
                   Pathnames.Full_Version_Name
                      (This_Catalog => The_Catalog,
                       This_Version => This_Version_Argument);
            begin
                Pathnames.Assert_Is_Valid_Version_Name (The_Version);
                return (The_Version);
            end;  
        end;
        --
    exception
        when Defaults.Io_Failure =>
            raise Io_Failure;
        when Pathnames.Invalid_Catalog_Name =>
            raise Invalid_Catalog;
        when Pathnames.Invalid_Version_Name =>
            raise Invalid_Version;
        when others =>
            raise;
            --
    end Version_From;

    function Simple_Version_From
                (This_Catalog_Argument : in Argument;
                 This_Version_Argument : in Argument) return Simple_Name is
    begin
        return (Directory_Tools.Naming.Simple_Name
                   (Version_From (This_Catalog_Argument,
                                  This_Version_Argument)));
    end Simple_Version_From;

    function Version_For (This_User : in Argument) return Full_Name is
    begin  
        declare
            The_Version : constant Full_Name :=
               Defaults.Full_Version (For_User =>
                                         Arguments.User_From (This_User));
        begin
            if (not Pathnames.Is_Valid_Version_Name (The_Version)) then
                raise Invalid_Version;
            end if;
            return (The_Version);
        end;
        --
    exception
        when Invalid_Username | Invalid_Version =>
            raise;
        when others =>
            raise Io_Failure;
            --
    end Version_For;

    function Simple_Version_For (This_User : in Argument) return Simple_Name is
    begin
        return (Directory_Tools.Naming.Simple_Name
                   (Arguments.Version_For (This_User)));
    end Simple_Version_For;

    function Is_Default_Catalog_Library
                (This_Argument : in Argument) return Boolean is
    begin
        return (String_Utilities.Upper_Case (This_Argument) =
                Default_Catalog_Library);
    end Is_Default_Catalog_Library;

    function Browser_Version_From
                (This_Library : in String; This_Default_Version : in Full_Name)
                return Full_Name is
    begin
        if (Is_Default_Catalog_Library (This_Library)) then
            return (String_Utilities.Upper_Case (This_Default_Version));
        else
            return (String_Utilities.Upper_Case (This_Library));
        end if;
    end Browser_Version_From;

end Arguments;