DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ B T

⟦e17bace1a⟧ TextFile

    Length: 13609 (0x3529)
    Types: TextFile
    Names: »B«

Derivation

└─⟦407de186f⟧ Bits:30000749 8mm tape, Rational 1000, RCFSUN
    └─ ⟦e5cd75ab4⟧ »DATA« 
        └─⟦this⟧ 

TextFile

separate (Sparc_Unix_Alsys)
function Get_Pragma_Info return Pragmas.Object is

    --
    -- PRAGMA INTERFACE_NAME
    --

    Interface_Name_Arg1 : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "Subprogram_Name",
           Valid_Miscellaneous_Names =>
              Checking.Build (Valid_Kinds => (Checking.Function_Kind => True,
                                              Checking.Procedure_Kind => True,
                                              others => False),
                              Ambiguity_Allowed => False,
                              Required_Pragmas =>
                                 (1 => Text.Build ("Interface", Target_Name)),
                              Prohibited_Pragmas => Checking.No_Pragmas,
                              For_Target => Target_Name),
           For_Target => Target_Name);

    Interface_Name_Arg2 : constant Pragmas.Argument :=
       Pragmas.Build_Expression_Argument
          (Name => "String_Literal",
           Valid_Expressions =>
              Checking.Build
                 (Expression_Type =>
                     Text.Get (Text.Build ("String", Target_Name)),
                  Constraint => Checking.Null_Constraint (Target_Name),
                  For_Target => Target_Name),
           For_Target => Target_Name);

    Interface_Name_Arguments : constant Pragmas.Argument_Array :=
       (Interface_Name_Arg1, Interface_Name_Arg2);

    Interface_Name_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "INTERFACE_NAME",
                      Valid_Locations =>
                         (Pragmas.Declaration => True, others => False),
                      Arguments => Interface_Name_Arguments,
                      Last_Required_Argument => 2,
                      For_Target => Target_Name);
    --
    -- PRAGMA INDENT  -- Used only with AdaReformat
    --

    Indent_Arg : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Special_Identifiers =>
              (Text.Build ("on", Target_Name), Text.Build ("off", Target_Name)),
           For_Target => Target_Name);

    Indent_Arguments : constant Pragmas.Argument_Array := (1 => Indent_Arg);

    Indent_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "INDENT",
                      Valid_Locations => Pragmas.All_Locations,
                      Arguments => Indent_Arguments,
                      Last_Required_Argument => 1,
                      For_Target => Target_Name);
    --
    -- pragma IMPROVE;
    --

    Improve_Arg1 : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Special_Identifiers => (Text.Build ("time", Target_Name),
                                         Text.Build ("space", Target_Name)),
           For_Target => Target_Name);

    Improve_Arg2 : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "On",
           Valid_Types =>
              Checking.Build
                 (Enforced_Type_Restrictions => Checking.No_Type_Restrictions,
                  Valid_Structural_Types =>
                     (Checking.Record_Type => True, others => False),
                  For_Target => Target_Name),
           For_Target => Target_Name);

    Improve_Arguments : constant Pragmas.Argument_Array :=
       (Improve_Arg1, Improve_Arg2);

    Improve_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "IMPROVE",
                      Valid_Locations =>
                         (Pragmas.Declaration => True, others => False),
                      Arguments => Improve_Arguments,
                      Last_Required_Argument => 2,
                      For_Target => Target_Name);

    --
    -- Pragma EXPORT
    --

    Export_Pragma_Arg1 : Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Objects => Checking.Null_Object_Set,
           Valid_Miscellaneous_Names => Checking.Null_Miscellaneous_Name_Set,
           Valid_Types => Checking.Null_Type_Set,
           Valid_Special_Identifiers =>
              (Text.Build (S => "ASSEMBLER", For_Target => Target_Name),
               Text.Build (S => "C", For_Target => Target_Name)),
           For_Target => Target_Name);



    Export_Pragma_Arg2 : Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Objects =>
              Checking.Build
                 (Valid_Kinds => (Checking.Variable => True, others => False),
                  Allowed_Types =>
                     Checking.Build
                        (Enforced_Type_Restrictions =>
                            Checking.No_Type_Restrictions,
                         Valid_Structural_Types =>
                            (Checking.Array_Type => True,
                             Checking.Integer_Type => True,
                             Checking.Enumeration_Type => True,
                             Checking.Record_Type => True,
                             Checking.Universal_Integer_Type => True,
                             others => False),
                         For_Target => Target_Name),
                  For_Target => Target_Name),
           Valid_Miscellaneous_Names => Checking.Null_Miscellaneous_Name_Set,
           Valid_Types => Checking.Null_Type_Set,
           Valid_Special_Identifiers => Checking.No_Identifiers,
           For_Target => Target_Name);



    Export_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "EXPORT",
                      Valid_Locations => (Pragmas.Declaration |  
                                          Pragmas.Comp_Unit => True,
                                          others => False),
                      Arguments => (Export_Pragma_Arg1, Export_Pragma_Arg2),
                      Last_Required_Argument => 2,
                      For_Target => Target_Name);

    --
    -- Pragma EXTERNAL_NAME
    --
    External_Name_Pragma_Arg1 : Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Objects =>
              Checking.Build
                 (Valid_Kinds => (Checking.Variable => True, others => False),
                  Allowed_Types =>
                     Checking.Build
                        (Enforced_Type_Restrictions =>
                            Checking.No_Type_Restrictions,
                         Valid_Structural_Types =>
                            (Checking.Array_Type => True,
                             Checking.Integer_Type => True,
                             Checking.Enumeration_Type => True,
                             Checking.Record_Type => True,
                             Checking.Universal_Integer_Type => True,
                             others => False),
                         For_Target => Target_Name),
                  Required_Pragmas =>
                     (1 => Text.Build ("EXPORT", For_Target => Target_Name)),
                  For_Target => Target_Name),
           Valid_Miscellaneous_Names => Checking.Null_Miscellaneous_Name_Set,
           Valid_Types => Checking.Null_Type_Set,
           Valid_Special_Identifiers => Checking.No_Identifiers,
           For_Target => Target_Name);



    External_Name_Pragma_Arg2 : constant Pragmas.Argument :=
       Pragmas.Build_Expression_Argument
          (Name => "",
           Valid_Expressions =>
              Checking.Build
                 (Expression_Type => "STRING",
                  Constraint =>
                     Checking.Null_Constraint (For_Target => Target_Name),
                  For_Target => Target_Name),
           For_Target => Target_Name);



    External_Name_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "EXTERNAL_NAME",
                      Valid_Locations => (Pragmas.Declaration |  
                                          Pragmas.Comp_Unit => True,
                                          others => False),
                      Arguments => (External_Name_Pragma_Arg1,
                                    External_Name_Pragma_Arg2),
                      Last_Required_Argument => 2,
                      For_Target => Target_Name);

    --
    -- Pragma INLINE_GENERIC
    --
    Inline_Generic_Arg : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "Ada_designator",
           Valid_Miscellaneous_Names =>
              Checking.Build (Valid_Kinds =>
                                 (Checking.Generic_Function_Kind => True,
                                  Checking.Generic_Procedure_Kind => True,
                                  Checking.Generic_Package_Kind => True,
                                  others => False),
                              Ambiguity_Allowed => False,
                              Prohibited_Pragmas => Checking.No_Pragmas,
                              For_Target => Target_Name),
           For_Target => Target_Name);

    Inline_Generic_Arguments : constant Pragmas.Argument_Array :=
       (1 .. 100 => Inline_Generic_Arg);

    Inline_Generic_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "INLINE_GENERIC",
                      Valid_Locations =>
                         (Pragmas.Declaration => True, others => False),
                      Arguments => Inline_Generic_Arguments,
                      Last_Required_Argument => 1,
                      For_Target => Target_Name);

    --
    -- Pragma NO_IMAGE
    --
    No_Image_Arg : constant Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Types =>
              Checking.Build
                 (Enforced_Type_Restrictions => Checking.No_Type_Restrictions,
                  Valid_Structural_Types =>
                     (Checking.Enumeration_Type => True, others => False),
                  For_Target => Target_Name),
           For_Target => Target_Name);

    No_Image_Arguments : constant Pragmas.Argument_Array := (1 => No_Image_Arg);

    No_Image_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "NO_IMAGE",
                      Valid_Locations =>
                         (Pragmas.Declaration => True, others => False),
                      Arguments => No_Image_Arguments,
                      Last_Required_Argument => 1,
                      For_Target => Target_Name);

    --
    -- Pragma CALL_IN
    --
    Call_In_Pragma_Arg1 : Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "",
           Valid_Objects => Checking.Null_Object_Set,
           Valid_Miscellaneous_Names => Checking.Null_Miscellaneous_Name_Set,
           Valid_Types => Checking.Null_Type_Set,
           Valid_Special_Identifiers =>
              (Text.Build (S => "ASSEMBLER", For_Target => Target_Name),
               Text.Build (S => "C", For_Target => Target_Name)),
           For_Target => Target_Name);

    Call_In_Pragma_Arg2 : Pragmas.Argument :=
       Pragmas.Build_Name_Argument
          (Name => "Subprogram_Name",
           Valid_Miscellaneous_Names =>
              Checking.Build (Valid_Kinds => (Checking.Function_Kind => True,
                                              Checking.Procedure_Kind => True,
                                              others => False),
                              Ambiguity_Allowed => False,
                              Prohibited_Pragmas => Checking.No_Pragmas,
                              For_Target => Target_Name),
           For_Target => Target_Name);

    Call_In_Arguments : constant Pragmas.Argument_Array :=
       (Call_In_Pragma_Arg1, Call_In_Pragma_Arg2);

    Call_In_Pragma : constant Pragmas.Target_Pragma :=
       Pragmas.Build (Name => "CALL_IN",
                      Valid_Locations =>
                         (Pragmas.Declaration => True, others => False),
                      Arguments => Call_In_Arguments,
                      Last_Required_Argument => 2,
                      For_Target => Target_Name);


-- Specify the Alsys supported standard pragmas.

    Ada_Pragmas : constant Pragmas.Ada_Pragma_Array :=
       (Pragmas.Controlled_Pragma => False,  
        Pragmas.Elaborate_Pragma => True,
        Pragmas.Inline_Pragma => True,  
        Pragmas.Interface_Pragma => True,  
        Pragmas.List_Pragma => True,
        Pragmas.Memory_Size_Pragma => False,
        Pragmas.Optimize_Pragma => False,
        Pragmas.Pack_Pragma => True,  
        Pragmas.Page_Pragma => True,
        Pragmas.Priority_Pragma => True,  
        Pragmas.Shared_Pragma => True,
        Pragmas.Storage_Unit_Pragma => False,
        Pragmas.Suppress_Pragma => True,  
        Pragmas.System_Name_Pragma => False);



    Pragma_List : constant Pragmas.Target_Pragma_Array :=
       (Call_In_Pragma, Inline_Generic_Pragma, Interface_Name_Pragma,
        Indent_Pragma, Improve_Pragma, Export_Pragma,
        External_Name_Pragma, No_Image_Pragma);


    -- Pg. 3 Alsys Applications Developers Guide Appendix F
    Pragma_Object : Pragmas.Object :=
       Pragmas.Build (Supported_Ada_Pragmas => Ada_Pragmas,
                      Target_Pragmas => Pragma_List,
                      Interface_Languages =>
                         (Text.Build ("Assembly", Target_Name),
                          Text.Build ("C", Target_Name),
                          Text.Build ("Fortran", Target_Name),
                          Text.Build ("Ada", Target_Name)),
                      For_Target => Target_Name);

begin
    return Pragma_Object;
end Get_Pragma_Info;