home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / programming / ada_1 / !Ada_ada_predef < prev    next >
Encoding:
Text File  |  1994-08-27  |  24.6 KB  |  756 lines
  1. -- 
  2. -- 
  3. --               ********************************** 
  4. --               *                                *  
  5. --               *           T  e  x  t           * 
  6. --               *                                *  
  7. --               *     Input / Output  Package    * 
  8. --         *                  *
  9. --         *         and other          *
  10. --         *                  *
  11. --         *        Predefined Units      *
  12. --               *                                *  
  13. --               *                                *  
  14. --         *         ADA Project      *
  15. --         *      Courant Institute      *
  16. --         *     New York University      *
  17. --         *      251 Mercer Street,      *
  18. --         *      New York, NY 10012      *
  19. --               *                                *  
  20. --               ********************************** 
  21. -- 
  22. -- 
  23. --
  24. pragma page;
  25. --  This file contains several of the predefined Ada package spec-
  26. --  ifications.  They do not actually implement the package's
  27. --  operations, which are coded in the implementation language C,
  28. --  but they provide an interface to them through the standard 
  29. --  procedure/function calling mechanism. The predefined packages are:
  30. --
  31. --      . The SYSTEM package.
  32. --
  33. --      . The IO_EXCEPTIONS package.
  34. --
  35. --      . The generic SEQUENTIAL_IO package.
  36. --
  37. --      . The generic DIRECT_IO package.
  38. -- 
  39. --      . The TEXT_IO package.  
  40. --
  41. --    . The CALENDAR package and the predefined subprograms 
  42. --      UNCHECKED_CONVERSION and UNCHECKED_DEALLOCATION.
  43. --
  44. --
  45. pragma page;
  46.  
  47. package SYSTEM is
  48.  
  49.    type NAME    is (ELXSI_BSD, ELXSI_ENIX, PC_DOS, 
  50.              SUN_UNIX, VAX_UNIX, VAX_VMS, RISC_OS) ; 
  51.  
  52.    SYSTEM_NAME  : constant NAME := RISC_OS;
  53.    STORAGE_UNIT : constant      := 32;
  54.    MEMORY_SIZE  : constant      := 2**16 - 1;
  55.  
  56.    -- System Dependent Named Numbers:
  57.  
  58.    MIN_INT      : constant      := -2**31;
  59.    MAX_INT      : constant      :=  2**31-1;
  60.    MAX_DIGITS   : constant      := 6;
  61.    MAX_MANTISSA : constant      := 31;
  62.    FINE_DELTA   : constant      := 2.0**(-30);
  63.    TICK         : constant      := 0.01;
  64.  
  65.    -- Other System Dependent Declarations
  66.  
  67.    subtype PRIORITY is INTEGER range 1 .. 4;
  68.  
  69.    type SEGMENT_TYPE is new INTEGER range 0..255;
  70.    type OFFSET_TYPE  is new INTEGER range 0..32767;
  71. --   type ADDRESS is record
  72. --        SEGMENT : SEGMENT_TYPE := SEGMENT_TYPE'LAST;
  73. --        OFFSET  : OFFSET_TYPE  := OFFSET_TYPE'LAST;
  74. --   end record;
  75.    type DONTEVERTRYTOUSETHISTYPE is limited private;
  76.    type ADDRESS is access DONTEVERTRYTOUSETHISTYPE;
  77.  
  78.    SYSTEM_ERROR : exception;
  79.  
  80. private
  81.  
  82.    type DONTEVERTRYTOUSETHISTYPE is new INTEGER;
  83.  
  84. end SYSTEM;
  85.  
  86. package IO_EXCEPTIONS is
  87.  
  88.    STATUS_ERROR : exception;
  89.    MODE_ERROR   : exception;
  90.    NAME_ERROR   : exception;
  91.    USE_ERROR    : exception;
  92.    DEVICE_ERROR : exception;
  93.    END_ERROR    : exception;
  94.    DATA_ERROR   : exception;
  95.    LAYOUT_ERROR : exception;
  96.  
  97. end IO_EXCEPTIONS;
  98.  
  99. pragma page;
  100. with IO_EXCEPTIONS;
  101. generic
  102.     type ELEMENT_TYPE is private;
  103.  
  104. package SEQUENTIAL_IO is
  105.  
  106.     type FILE_TYPE is limited private;
  107.     
  108.     type FILE_MODE is (IN_FILE, OUT_FILE);
  109.       
  110.  
  111.     -- File management
  112.  
  113.  
  114.     procedure CREATE   (FILE : in out FILE_TYPE;
  115.                         MODE : in FILE_MODE := OUT_FILE;
  116.                         NAME : in STRING    := "";
  117.                         FORM : in STRING    := "");
  118.     pragma IO_interface(CREATE,SIO_CREATE,ELEMENT_TYPE);
  119.  
  120.     procedure OPEN     (FILE : in out FILE_TYPE;
  121.                         MODE : in FILE_MODE;
  122.                         NAME : in STRING;
  123.                         FORM : in STRING := "");
  124.     pragma IO_interface(OPEN,SIO_OPEN,ELEMENT_TYPE);
  125.  
  126.     procedure CLOSE    (FILE : in out FILE_TYPE);
  127.     pragma IO_interface(CLOSE,SIO_CLOSE);
  128.  
  129.     procedure DELETE   (FILE : in out FILE_TYPE);
  130.     pragma IO_interface(DELETE,SIO_DELETE);
  131.  
  132.     procedure RESET    (FILE : in out FILE_TYPE; MODE : in  FILE_MODE);
  133.     pragma IO_interface(RESET,SIO_RESET_MODE,ELEMENT_TYPE);
  134.     procedure RESET    (FILE : in out FILE_TYPE);
  135.     pragma IO_interface(RESET,SIO_RESET,ELEMENT_TYPE);
  136.  
  137.     function  MODE     (FILE : in FILE_TYPE)  return FILE_MODE;
  138.     pragma IO_interface(MODE,SIO_MODE);
  139.  
  140.     function  NAME     (FILE : in FILE_TYPE)  return STRING;
  141.     pragma IO_interface(NAME,SIO_NAME);
  142.  
  143.     function  FORM     (FILE : in FILE_TYPE)  return STRING;
  144.     pragma IO_interface(FORM,SIO_FORM);
  145.     
  146.     function  IS_OPEN  (FILE : in FILE_TYPE)  return BOOLEAN;
  147.     pragma IO_interface(IS_OPEN,SIO_IS_OPEN);
  148.  
  149.     -- Input and Output Operations:
  150.  
  151.     procedure READ   (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);
  152.     pragma IO_interface(READ,SIO_READ,ELEMENT_TYPE);
  153.  
  154.     procedure WRITE  (FILE : in FILE_TYPE; ITEM : in ELEMENT_TYPE);
  155.     pragma IO_interface(WRITE,SIO_WRITE,ELEMENT_TYPE);
  156.  
  157.     function  END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;
  158.     pragma IO_interface(END_OF_FILE,SIO_END_OF_FILE);
  159.  
  160.     -- Exceptions:
  161.  
  162.     STATUS_ERROR : exception renames IO_EXCEPTIONS.STATUS_ERROR;
  163.     MODE_ERROR   : exception renames IO_EXCEPTIONS.MODE_ERROR;
  164.     NAME_ERROR     : exception renames IO_EXCEPTIONS.NAME_ERROR;
  165.     USE_ERROR     : exception renames IO_EXCEPTIONS.USE_ERROR;
  166.     DEVICE_ERROR : exception renames IO_EXCEPTIONS.DEVICE_ERROR;
  167.     END_ERROR     : exception renames IO_EXCEPTIONS.END_ERROR;
  168.     DATA_ERROR     : exception renames IO_EXCEPTIONS.DATA_ERROR;
  169.  
  170. private
  171.  
  172.     UNINITIALIZED: constant := 0;
  173.     type FILE_TYPE is record
  174.                          FILENUM: INTEGER := UNINITIALIZED; 
  175.                       end record;
  176.  
  177. end SEQUENTIAL_IO;
  178.  
  179. package body SEQUENTIAL_IO is
  180. end SEQUENTIAL_IO;
  181.  
  182. pragma page;
  183. with IO_EXCEPTIONS;
  184. generic
  185.     type ELEMENT_TYPE is private;
  186.  
  187. package DIRECT_IO is
  188.  
  189.     type  FILE_TYPE  is limited private;
  190.  
  191.     type    FILE_MODE       is (IN_FILE, INOUT_FILE, OUT_FILE);
  192.     type    COUNT           is range 0 .. INTEGER'LAST;
  193.     subtype POSITIVE_COUNT  is COUNT range 1 .. COUNT'LAST;    
  194.       
  195.  
  196.     -- File management
  197.  
  198.  
  199.     procedure CREATE   (FILE : in out FILE_TYPE;
  200.                         MODE : in FILE_MODE := INOUT_FILE;
  201.                         NAME : in STRING := "";
  202.                         FORM : in STRING := "");
  203.     pragma IO_interface(CREATE,DIO_CREATE,ELEMENT_TYPE);
  204.  
  205.     procedure OPEN     (FILE : in out FILE_TYPE;
  206.                         MODE : in FILE_MODE;
  207.                         NAME : in STRING;
  208.                         FORM : in STRING := "");
  209.     pragma IO_interface(OPEN,DIO_OPEN,ELEMENT_TYPE);
  210.  
  211.     procedure CLOSE    (FILE : in out FILE_TYPE);
  212.     pragma IO_interface(CLOSE,DIO_CLOSE);
  213.  
  214.     procedure DELETE   (FILE : in out FILE_TYPE);
  215.     pragma IO_interface(DELETE,DIO_DELETE);
  216.  
  217.     procedure RESET    (FILE : in out FILE_TYPE; MODE : in  FILE_MODE);
  218.     pragma IO_interface(RESET,DIO_RESET_MODE,ELEMENT_TYPE);
  219.     procedure RESET    (FILE : in out FILE_TYPE);
  220.     pragma IO_interface(RESET,DIO_RESET,ELEMENT_TYPE);
  221.  
  222.     function  MODE     (FILE : in FILE_TYPE)  return FILE_MODE;
  223.     pragma IO_interface(MODE,DIO_MODE);
  224.  
  225.     function  NAME     (FILE : in FILE_TYPE)  return STRING;
  226.     pragma IO_interface(NAME,DIO_NAME);
  227.  
  228.     function  FORM     (FILE : in FILE_TYPE)  return STRING;
  229.     pragma IO_interface(FORM,DIO_FORM);
  230.     
  231.     function  IS_OPEN  (FILE : in FILE_TYPE)  return BOOLEAN;
  232.     pragma IO_interface(IS_OPEN,DIO_IS_OPEN);
  233.  
  234.     -- Input and Output Operations:
  235.  
  236.     procedure READ   (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE);
  237.     pragma IO_interface(READ,DIO_READ,ELEMENT_TYPE);
  238.     procedure READ   (FILE : in FILE_TYPE; ITEM : out ELEMENT_TYPE;
  239.                                            FROM : in POSITIVE_COUNT);
  240.     pragma IO_interface(READ,DIO_READ_FROM,ELEMENT_TYPE);
  241.  
  242.     procedure WRITE  (FILE : in FILE_TYPE;  ITEM : in ELEMENT_TYPE);
  243.     pragma IO_interface(WRITE,DIO_WRITE,ELEMENT_TYPE);
  244.     procedure WRITE  (FILE : in FILE_TYPE;  ITEM : in ELEMENT_TYPE;
  245.                                             TO   : in POSITIVE_COUNT);
  246.     pragma IO_interface(WRITE,DIO_WRITE_TO,ELEMENT_TYPE);
  247.  
  248.     procedure SET_INDEX(FILE : in FILE_TYPE; TO :in POSITIVE_COUNT);
  249.     pragma IO_interface(SET_INDEX,DIO_SET_INDEX);
  250.    
  251.     function  INDEX    (FILE : in FILE_TYPE)  return POSITIVE_COUNT;
  252.     pragma IO_interface(INDEX,DIO_INDEX);
  253.  
  254.     function  SIZE     (FILE : in FILE_TYPE)  return COUNT;
  255.     pragma IO_interface(SIZE,DIO_SIZE);
  256.       
  257.     function  END_OF_FILE(FILE : in FILE_TYPE) return BOOLEAN;
  258.     pragma IO_interface(END_OF_FILE,DIO_END_OF_FILE);
  259.  
  260.     -- Exceptions:
  261.  
  262.     STATUS_ERROR : exception renames IO_EXCEPTIONS.STATUS_ERROR;
  263.     MODE_ERROR   : exception renames IO_EXCEPTIONS.MODE_ERROR;
  264.     NAME_ERROR     : exception renames IO_EXCEPTIONS.NAME_ERROR;
  265.     USE_ERROR     : exception renames IO_EXCEPTIONS.USE_ERROR;
  266.     DEVICE_ERROR : exception renames IO_EXCEPTIONS.DEVICE_ERROR;
  267.     END_ERROR     : exception renames IO_EXCEPTIONS.END_ERROR;
  268.     DATA_ERROR     : exception renames IO_EXCEPTIONS.DATA_ERROR;
  269.  
  270. private
  271.  
  272.     UNINITIALIZED: constant := 0;
  273.     type FILE_TYPE is record
  274.                          FILENUM: INTEGER := UNINITIALIZED; 
  275.                       end record;
  276.  
  277. end DIRECT_IO;
  278.  
  279. package body DIRECT_IO is
  280. end DIRECT_IO;
  281.  
  282. pragma page;
  283. with IO_EXCEPTIONS;
  284. package TEXT_IO is 
  285.      
  286.   type FILE_TYPE  is limited private;
  287.  
  288.   type FILE_MODE  is (IN_FILE, OUT_FILE);
  289.  
  290.   type COUNT is range 0 .. 32767;
  291.  
  292.   subtype POSITIVE_COUNT IS COUNT range 1 .. COUNT'LAST;
  293.  
  294.   UNBOUNDED : constant COUNT := 0; -- line and page length
  295.  
  296.   subtype FIELD is INTEGER range 0 .. 100 ;
  297.   subtype NUMBER_BASE is INTEGER range 2 .. 16;
  298.  
  299.   type TYPE_SET is (LOWER_CASE, UPPER_CASE);
  300.  
  301.   -- File Management
  302.  
  303.      
  304.   procedure CREATE (FILE : in out FILE_TYPE;
  305.                     MODE : in FILE_MODE := OUT_FILE;
  306.                     NAME : in STRING    := "";
  307.                     FORM : in STRING    := "");
  308.   pragma IO_interface(CREATE,TIO_CREATE);
  309.     
  310.   procedure OPEN   (FILE : in out FILE_TYPE;
  311.                     MODE : in FILE_MODE;
  312.                     NAME : in STRING;
  313.                     FORM : in STRING := "");
  314.   pragma IO_interface(OPEN,TIO_OPEN);
  315.  
  316.   procedure CLOSE  (FILE : in out FILE_TYPE);
  317.   pragma IO_interface(CLOSE,TIO_CLOSE);
  318.     
  319.   procedure DELETE (FILE : in out FILE_TYPE);
  320.   pragma IO_interface(DELETE,TIO_DELETE);
  321.  
  322.   procedure RESET  (FILE : in out FILE_TYPE; MODE : in FILE_MODE);
  323.   pragma IO_interface(RESET,TIO_RESET_MODE);
  324.   procedure RESET  (FILE : in out FILE_TYPE);
  325.   pragma IO_interface(RESET,TIO_RESET);
  326.  
  327.   function MODE (FILE : in FILE_TYPE)     return FILE_MODE;
  328.   pragma IO_interface(MODE,TIO_MODE);
  329.  
  330.   function NAME (FILE : in FILE_TYPE)     return STRING;
  331.   pragma IO_interface(NAME,TIO_NAME);
  332.  
  333.   function FORM (FILE : in FILE_TYPE)     return STRING;      
  334.   pragma IO_interface(FORM,TIO_FORM);
  335.  
  336.   function IS_OPEN (FILE : in FILE_TYPE)  return BOOLEAN;
  337.   pragma IO_interface(IS_OPEN,TIO_IS_OPEN);
  338.  
  339.   -- Control of default input and output files
  340.      
  341.   procedure SET_INPUT  (FILE : in FILE_TYPE);
  342.   pragma IO_interface(SET_INPUT,SET_INPUT);
  343.   procedure SET_OUTPUT (FILE : in FILE_TYPE);
  344.   pragma IO_interface(SET_OUTPUT,SET_OUTPUT);
  345.  
  346.   function STANDARD_INPUT  return FILE_TYPE;
  347.   pragma IO_interface(STANDARD_INPUT,STANDARD_INPUT);
  348.   function STANDARD_OUTPUT return FILE_TYPE;
  349.   pragma IO_interface(STANDARD_OUTPUT,STANDARD_OUTPUT);
  350.  
  351.   function CURRENT_INPUT  return FILE_TYPE;
  352.   pragma IO_interface(CURRENT_INPUT,CURRENT_INPUT);
  353.   function CURRENT_OUTPUT return FILE_TYPE;
  354.   pragma IO_interface(CURRENT_OUTPUT,CURRENT_OUTPUT);
  355.  
  356.   -- Specification of line and page lengths
  357.  
  358.   procedure SET_LINE_LENGTH (FILE : in FILE_TYPE;  TO : in COUNT);
  359.   pragma IO_interface(SET_LINE_LENGTH,SET_LINE_LENGTH_FILE);
  360.   procedure SET_LINE_LENGTH (TO : in COUNT);    -- default output file
  361.   pragma IO_interface(SET_LINE_LENGTH,SET_LINE_LENGTH);
  362.  
  363.   procedure SET_PAGE_LENGTH (FILE : in FILE_TYPE;  TO : in COUNT);
  364.   pragma IO_interface(SET_PAGE_LENGTH,SET_PAGE_LENGTH_FILE);
  365.   procedure SET_PAGE_LENGTH (TO : in COUNT);    -- default output file
  366.   pragma IO_interface(SET_PAGE_LENGTH,SET_PAGE_LENGTH);
  367.  
  368.   function LINE_LENGTH (FILE : in FILE_TYPE)  return COUNT;
  369.   pragma IO_interface(LINE_LENGTH,LINE_LENGTH_FILE);
  370.   function LINE_LENGTH return COUNT;  -- default output file
  371.   pragma IO_interface(LINE_LENGTH,LINE_LENGTH);
  372.      
  373.   
  374.   function PAGE_LENGTH (FILE : in FILE_TYPE)  return COUNT;
  375.   pragma IO_interface(PAGE_LENGTH,PAGE_LENGTH_FILE);
  376.   function PAGE_LENGTH return COUNT; -- default output file
  377.   pragma IO_interface(PAGE_LENGTH,PAGE_LENGTH);
  378.  
  379.   -- Column, Line and Page Control
  380.  
  381.   procedure NEW_LINE (FILE : in FILE_TYPE;  SPACING : in POSITIVE_COUNT := 1);
  382.   pragma IO_interface(NEW_LINE,NEW_LINE_FILE);
  383.   procedure NEW_LINE (SPACING : in POSITIVE_COUNT := 1); 
  384.   pragma IO_interface(NEW_LINE,NEW_LINE);
  385.  
  386.   procedure SKIP_LINE (FILE : in FILE_TYPE;  SPACING : in POSITIVE_COUNT := 1);
  387.   pragma IO_interface(SKIP_LINE,SKIP_LINE_FILE);
  388.   procedure SKIP_LINE (SPACING : in POSITIVE_COUNT := 1);
  389.   pragma IO_interface(SKIP_LINE,SKIP_LINE);
  390.  
  391.   function END_OF_LINE (FILE : in FILE_TYPE) return BOOLEAN;
  392.   pragma IO_interface(END_OF_LINE,END_OF_LINE_FILE);
  393.   function END_OF_LINE return BOOLEAN; -- default input file
  394.   pragma IO_interface(END_OF_LINE,END_OF_LINE);
  395.  
  396.   procedure NEW_PAGE (FILE : in FILE_TYPE);
  397.   pragma IO_interface(NEW_PAGE,NEW_PAGE_FILE);
  398.   procedure NEW_PAGE; -- default output file
  399.   pragma IO_interface(NEW_PAGE,NEW_PAGE);
  400.  
  401.   procedure SKIP_PAGE (FILE : in FILE_TYPE);
  402.   pragma IO_interface(SKIP_PAGE,SKIP_PAGE_FILE);
  403.   procedure SKIP_PAGE; -- default input file
  404.   pragma IO_interface(SKIP_PAGE,SKIP_PAGE);
  405.  
  406.   function END_OF_PAGE (FILE : in FILE_TYPE) return BOOLEAN;
  407.   pragma IO_interface(END_OF_PAGE,END_OF_PAGE_FILE);
  408.   function END_OF_PAGE return BOOLEAN;      
  409.   pragma IO_interface(END_OF_PAGE,END_OF_PAGE);
  410.  
  411.   function END_OF_FILE (FILE : in FILE_TYPE) return BOOLEAN;
  412.   pragma IO_interface(END_OF_FILE,TIO_END_OF_FILE_FILE);
  413.   function END_OF_FILE return BOOLEAN;      
  414.   pragma IO_interface(END_OF_FILE,TIO_END_OF_FILE);
  415.  
  416.   procedure SET_COL(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);
  417.   pragma IO_interface(SET_COL,SET_COL_FILE);
  418.   procedure SET_COL(TO : in POSITIVE_COUNT); -- default output file
  419.   pragma IO_interface(SET_COL,SET_COL);
  420.  
  421.   procedure SET_LINE(FILE : in FILE_TYPE; TO : in POSITIVE_COUNT);
  422.   pragma IO_interface(SET_LINE,SET_LINE_FILE);
  423.   procedure SET_LINE(TO : in POSITIVE_COUNT); -- default output file
  424.   pragma IO_interface(SET_LINE,SET_LINE);
  425.   
  426.   function COL(FILE : in FILE_TYPE) return POSITIVE_COUNT;
  427.   pragma IO_interface(COL,COL_FILE);
  428.   function COL return POSITIVE_COUNT; -- default output file
  429.   pragma IO_interface(COL,COL);
  430.  
  431.   function LINE(FILE : in FILE_TYPE) return POSITIVE_COUNT;
  432.   pragma IO_interface(LINE,LINE_FILE);
  433.   function LINE return POSITIVE_COUNT; -- default output file
  434.   pragma IO_interface(LINE,LINE);
  435.  
  436.   function PAGE(FILE : in FILE_TYPE) return POSITIVE_COUNT;
  437.   pragma IO_interface(PAGE,PAGE_FILE);
  438.   function PAGE return POSITIVE_COUNT; -- default output file
  439.   pragma IO_interface(PAGE,PAGE);
  440.  
  441.  
  442.   -- Character Input-Output
  443.  
  444.   procedure GET (FILE : in  FILE_TYPE;  ITEM : out CHARACTER);
  445.   pragma IO_interface(GET,GET_CHAR_FILE_ITEM);
  446.   procedure GET (ITEM : out CHARACTER);
  447.   pragma IO_interface(GET,GET_CHAR_ITEM);
  448.   procedure PUT (FILE : in  FILE_TYPE;  ITEM : in CHARACTER);
  449.   pragma IO_interface(PUT,PUT_CHAR_FILE_ITEM);
  450.   procedure PUT (ITEM : in  CHARACTER);
  451.   pragma IO_interface(PUT,PUT_CHAR_ITEM);
  452.  
  453.     
  454.   -- String Input-Output
  455.     
  456.   procedure GET (FILE : in  FILE_TYPE;  ITEM : out STRING);
  457.   pragma IO_interface(GET,GET_STRING_FILE_ITEM);
  458.   procedure GET (ITEM : out STRING);    
  459.   pragma IO_interface(GET,GET_STRING_ITEM);
  460.   procedure PUT (FILE : in  FILE_TYPE;  ITEM : in STRING);
  461.   pragma IO_interface(PUT,PUT_STRING_FILE_ITEM);
  462.   procedure PUT (ITEM : in  STRING);
  463.   pragma IO_interface(PUT,PUT_STRING_ITEM);
  464.  
  465.   procedure GET_LINE (FILE : in FILE_TYPE; ITEM : out STRING;
  466.                                            LAST : out NATURAL);
  467.   pragma IO_interface(GET_LINE,GET_LINE_FILE);
  468.   procedure GET_LINE (ITEM : out  STRING; LAST : out NATURAL);
  469.   pragma IO_interface(GET_LINE,GET_LINE);
  470.  
  471.   procedure PUT_LINE (FILE : in FILE_TYPE; ITEM : in STRING);
  472.   pragma IO_interface(PUT_LINE,PUT_LINE_FILE);
  473.   procedure PUT_LINE (ITEM : in STRING);
  474.   pragma IO_interface(PUT_LINE,PUT_LINE);
  475.     
  476.   -- Generic package for Input-Output of Integer Types
  477.  
  478.   generic
  479.     type NUM is range <>;
  480.   package INTEGER_IO is
  481.  
  482.     DEFAULT_WIDTH : FIELD := NUM'WIDTH;
  483.     DEFAULT_BASE  : NUMBER_BASE := 10;
  484.  
  485.     procedure GET (FILE  : in FILE_TYPE;  ITEM : out NUM; 
  486.                                           WIDTH : in FIELD := 0);
  487.     pragma IO_interface(GET,GET_INTEGER_FILE_ITEM,NUM);
  488.  
  489.     procedure GET (ITEM  : out NUM; WIDTH : in FIELD := 0);
  490.     pragma IO_interface(GET,GET_INTEGER_ITEM,NUM);
  491.  
  492.     procedure PUT (FILE  : in FILE_TYPE;
  493.                ITEM  : in NUM;
  494.                WIDTH : in FIELD := DEFAULT_WIDTH;
  495.                BASE  : in NUMBER_BASE := DEFAULT_BASE);
  496.     pragma IO_interface(PUT,PUT_INTEGER_FILE_ITEM,NUM);
  497.     procedure PUT (ITEM  : in NUM;
  498.                WIDTH : in FIELD := DEFAULT_WIDTH;
  499.                BASE  : in NUMBER_BASE := DEFAULT_BASE);
  500.     pragma IO_interface(PUT,PUT_INTEGER_ITEM,NUM);
  501.     
  502.     procedure GET (FROM : in STRING; ITEM: out NUM; LAST: out POSITIVE);
  503.     pragma IO_interface(GET,GET_INTEGER_STRING,NUM);
  504.     procedure PUT (TO   : out STRING;
  505.                    ITEM : in  NUM;
  506.                    BASE : in  NUMBER_BASE := DEFAULT_BASE);
  507.     pragma IO_interface(PUT,PUT_INTEGER_STRING,NUM);
  508.  
  509.   end INTEGER_IO;
  510.  
  511.  
  512.   -- Generic packages for Input-Output of Real Types
  513.  
  514.   generic
  515.     type NUM is digits <>;
  516.   package FLOAT_IO is
  517.  
  518.     DEFAULT_FORE : FIELD := 2;
  519.     DEFAULT_AFT  : FIELD := NUM'DIGITS-1;
  520.     DEFAULT_EXP  : FIELD := 3;
  521.  
  522.     procedure GET (FILE : in FILE_TYPE; ITEM : out NUM;
  523.                                         WIDTH : in FIELD := 0);
  524.     pragma IO_interface(GET,GET_FLOAT_FILE_ITEM,NUM);
  525.     procedure GET (ITEM : out NUM; WIDTH : in FIELD := 0);
  526.     pragma IO_interface(GET,GET_FLOAT_ITEM,NUM);
  527.  
  528.     procedure PUT (FILE        : in FILE_TYPE;
  529.            ITEM        : in NUM;
  530.            FORE            : in FIELD := DEFAULT_FORE;
  531.            AFT      : in FIELD := DEFAULT_AFT;
  532.            EXP       : in FIELD := DEFAULT_EXP);
  533.     pragma IO_interface(PUT,PUT_FLOAT_FILE_ITEM,NUM);
  534.  
  535.     procedure PUT (ITEM        : in NUM;
  536.            FORE       : in FIELD := DEFAULT_FORE;
  537.            AFT      : in FIELD := DEFAULT_AFT;
  538.            EXP      : in FIELD := DEFAULT_EXP);
  539.     pragma IO_interface(PUT,PUT_FLOAT_ITEM,NUM);
  540.     
  541.     procedure GET (FROM : in STRING; ITEM: out NUM; LAST: out POSITIVE);
  542.     pragma IO_interface(GET,GET_FLOAT_STRING,NUM);
  543.     procedure PUT (TO   : out STRING;
  544.                    ITEM : in NUM;
  545.                    AFT  : in FIELD := DEFAULT_AFT;
  546.                    EXP  : in FIELD := DEFAULT_EXP);
  547.     pragma IO_interface(PUT,PUT_FLOAT_STRING,NUM);
  548.  
  549.   end FLOAT_IO;
  550.  
  551.  
  552.   generic
  553.     type NUM is delta <>;
  554.   package FIXED_IO is
  555.  
  556.     DEFAULT_FORE : FIELD := NUM'FORE;
  557.     DEFAULT_AFT  : FIELD := NUM'AFT;
  558.     DEFAULT_EXP  : FIELD := 0;
  559.  
  560.     procedure GET (FILE : in FILE_TYPE; ITEM : out NUM;
  561.                                         WIDTH : in FIELD := 0);
  562.     pragma IO_interface(GET,GET_FIXED_FILE_ITEM,NUM);
  563.     procedure GET (ITEM : out NUM; WIDTH : in FIELD := 0);
  564.     pragma IO_interface(GET,GET_FIXED_ITEM,NUM);
  565.  
  566.     procedure PUT (FILE        : in FILE_TYPE;
  567.            ITEM        : in NUM;
  568.            FORE     : in FIELD := DEFAULT_FORE;
  569.            AFT      : in FIELD := DEFAULT_AFT;
  570.                    EXP          : in FIELD := DEFAULT_EXP);
  571.     pragma IO_interface(PUT,PUT_FIXED_FILE_ITEM,NUM);
  572.  
  573.     procedure PUT (ITEM        : in NUM;
  574.            FORE     : in FIELD := DEFAULT_FORE;
  575.            AFT      : in FIELD := DEFAULT_AFT;
  576.                    EXP          : in FIELD := DEFAULT_EXP);
  577.     pragma IO_interface(PUT,PUT_FIXED_ITEM,NUM);
  578.  
  579.     procedure GET (FROM : in STRING; ITEM: out NUM; LAST: out POSITIVE);
  580.     pragma IO_interface(GET,GET_FIXED_STRING,NUM);
  581.     procedure PUT (TO   : out STRING;
  582.                    ITEM : in  NUM;
  583.                    AFT  : in  FIELD := DEFAULT_AFT;
  584.                    EXP  : in  FIELD := DEFAULT_EXP);
  585.     pragma IO_interface(PUT,PUT_FIXED_STRING,NUM);
  586.  
  587.   end FIXED_IO;
  588.  
  589.       
  590.   -- Generic package for Input-Output of Enumeration Types
  591.  
  592.   generic
  593.     type ENUM is (<>);
  594.   package ENUMERATION_IO is
  595.  
  596.     DEFAULT_WIDTH   : FIELD := 0;
  597.     DEFAULT_SETTING : TYPE_SET := UPPER_CASE;
  598.  
  599.     procedure GET (FILE : in FILE_TYPE; ITEM : out ENUM);
  600.     pragma IO_interface(GET,GET_ENUM_FILE_ITEM,ENUM);
  601.     procedure GET (ITEM : out ENUM);
  602.     pragma IO_interface(GET,GET_ENUM_ITEM,ENUM);
  603.  
  604.     procedure PUT (FILE       :    in FILE_TYPE;
  605.            ITEM       :    in ENUM;
  606.            WIDTH      :    in FIELD    := DEFAULT_WIDTH;
  607.            SET        : in TYPE_SET := DEFAULT_SETTING);
  608.     pragma IO_interface(PUT,PUT_ENUM_FILE_ITEM,ENUM);
  609.  
  610.     procedure PUT (ITEM       :    in ENUM;
  611.            WIDTH      :    in FIELD    := DEFAULT_WIDTH;
  612.            SET        :    in TYPE_SET := DEFAULT_SETTING);
  613.     pragma IO_interface(PUT,PUT_ENUM_ITEM,ENUM);
  614.  
  615.     procedure GET(FROM : in STRING; ITEM: out ENUM; LAST: out POSITIVE);
  616.     pragma IO_interface(GET,GET_ENUM_STRING,ENUM);
  617.     procedure PUT (TO   : out STRING;
  618.                    ITEM : in  ENUM;
  619.                    SET  : in  TYPE_SET := DEFAULT_SETTING);
  620.     pragma IO_interface(PUT,PUT_ENUM_STRING,ENUM);
  621.  
  622.   end ENUMERATION_IO;
  623.  
  624.  
  625.   -- Exceptions:
  626.   --  
  627.   -- These are the exceptions whose names are visible to the   
  628.   -- calling environment.   
  629.      
  630.   STATUS_ERROR    : exception renames IO_EXCEPTIONS.STATUS_ERROR;
  631.   MODE_ERROR    : exception renames IO_EXCEPTIONS.MODE_ERROR;
  632.   NAME_ERROR    : exception renames IO_EXCEPTIONS.NAME_ERROR;
  633.   USE_ERROR    : exception renames IO_EXCEPTIONS.USE_ERROR;
  634.   DEVICE_ERROR    : exception renames IO_EXCEPTIONS.DEVICE_ERROR;
  635.   END_ERROR    : exception renames IO_EXCEPTIONS.END_ERROR;
  636.   DATA_ERROR    : exception renames IO_EXCEPTIONS.DATA_ERROR;
  637.   LAYOUT_ERROR    : exception renames IO_EXCEPTIONS.LAYOUT_ERROR;
  638.  
  639.  
  640.     
  641. private
  642.  
  643.     UNINITIALIZED: constant := 0;
  644.     type FILE_TYPE is record
  645.                          FILENUM: INTEGER := UNINITIALIZED; 
  646.                       end record;
  647.  
  648. end TEXT_IO; 
  649.  
  650. package body TEXT_IO is
  651.  
  652.    package body INTEGER_IO is
  653.    end INTEGER_IO;
  654.  
  655.    package body FLOAT_IO is
  656.    end FLOAT_IO;
  657.  
  658.    package body FIXED_IO is
  659.    end FIXED_IO;
  660.  
  661.    package body ENUMERATION_IO is
  662.    end ENUMERATION_IO;
  663.  
  664. end TEXT_IO;
  665.  
  666. pragma page;
  667. -- Predefined library units:  calendar & generic subprograms
  668.  
  669. package CALENDAR is
  670.    type TIME is private;
  671.  
  672.    subtype YEAR_NUMBER  is INTEGER  range 1901 .. 2099;
  673.    subtype MONTH_NUMBER is INTEGER  range 1 .. 12;
  674.    subtype DAY_NUMBER   is INTEGER  range 1 .. 31;
  675.    subtype DAY_DURATION is DURATION range 0.0 .. 86_400.0;
  676.  
  677.    function CLOCK return TIME;
  678.    pragma IO_interface(CLOCK,CLOCK);
  679.  
  680.    function YEAR   (DATE    : TIME) return YEAR_NUMBER;
  681.    pragma IO_interface(YEAR,YEAR);
  682.    function MONTH  (DATE    : TIME) return MONTH_NUMBER;
  683.    pragma IO_interface(MONTH,MONTH);
  684.    function DAY    (DATE    : TIME) return DAY_NUMBER;
  685.    pragma IO_interface(DAY,DAY);
  686.    function SECONDS(DATE    : TIME) return DAY_DURATION;
  687.    pragma IO_interface(SECONDS,SECONDS);
  688.  
  689.    procedure SPLIT (DATE    : in  TIME;
  690.                     YEAR    : out YEAR_NUMBER;
  691.                     MONTH   : out MONTH_NUMBER;
  692.                     DAY     : out DAY_NUMBER;
  693.                     SECONDS : out DAY_DURATION);
  694.    pragma IO_interface(SPLIT,SPLIT);
  695.  
  696.    function TIME_OF(YEAR    : YEAR_NUMBER;
  697.                     MONTH   : MONTH_NUMBER;
  698.                     DAY     : DAY_NUMBER;
  699.                     SECONDS : DAY_DURATION := 0.0) return TIME;
  700.    pragma IO_interface(TIME_OF,TIME_OF);
  701.  
  702.    function "+"  (LEFT : TIME;     RIGHT : DURATION) return TIME;
  703.    pragma IO_interface("+",ADD_TIME_DUR);
  704.    function "+"  (LEFT : DURATION; RIGHT : TIME)     return TIME;
  705.    pragma IO_interface("+",ADD_DUR_TIME);
  706.    function "-"  (LEFT : TIME;     RIGHT : DURATION) return TIME;
  707.    pragma IO_interface("-",SUB_TIME_DUR);
  708.    function "-"  (LEFT : TIME;     RIGHT : TIME)     return DURATION;
  709.    pragma IO_interface("-",SUB_TIME_TIME,DURATION);
  710.  
  711.    function "<"  (LEFT, RIGHT : TIME) return BOOLEAN;
  712.    pragma IO_interface("<",LT_TIME);
  713.    function "<=" (LEFT, RIGHT : TIME) return BOOLEAN;
  714.    pragma IO_interface("<=",LE_TIME);
  715.    function ">"  (LEFT, RIGHT : TIME) return BOOLEAN;
  716.    pragma IO_interface(">",GT_TIME);
  717.    function ">=" (LEFT, RIGHT : TIME) return BOOLEAN;
  718.    pragma IO_interface(">=",GE_TIME);
  719.  
  720.    TIME_ERROR : exception;   --   can be raised by TIME_OF, "+", "-"
  721.  
  722. private 
  723.  
  724.    type TIME is record
  725.                    Y_N : YEAR_NUMBER;
  726.                    M_N : MONTH_NUMBER;
  727.                    D_N : DAY_NUMBER;
  728.                    D_D : DURATION;
  729.                 end record;
  730.  
  731. end CALENDAR;
  732.  
  733. package body CALENDAR is
  734. end CALENDAR;
  735.  
  736. pragma page;
  737. generic
  738.    type OBJECT is limited private;
  739.    type NAME   is access OBJECT;
  740. procedure UNCHECKED_DEALLOCATION(X : in out NAME);
  741. procedure UNCHECKED_DEALLOCATION(X : in out NAME) is
  742. begin
  743.    X := null;
  744. end;
  745.  
  746. generic
  747.    type SOURCE is limited private;
  748.    type TARGET is limited private;
  749. function UNCHECKED_CONVERSION(S : SOURCE) return TARGET;
  750. function UNCHECKED_CONVERSION(S : SOURCE) return TARGET is
  751. NOT_USED_ANYWAY: TARGET;
  752. begin
  753.    raise PROGRAM_ERROR;
  754.    return NOT_USED_ANYWAY;
  755. end;
  756.