------------------------------------------------------------------------------ | |

-- -- | |

-- GNAT RUN-TIME COMPONENTS -- | |

-- -- | |

-- A D A . R E A L _ T I M E -- | |

-- -- | |

-- S p e c -- | |

-- -- | |

-- Copyright (C) 1992-2002 Free Software Foundation, Inc. -- | |

-- -- | |

-- This specification is derived from the Ada Reference Manual for use with -- | |

-- GNAT. The copyright notice above, and the license provisions that follow -- | |

-- apply solely to the contents of the part following the private keyword. -- | |

-- -- | |

-- GNAT is free software; you can redistribute it and/or modify it under -- | |

-- terms of the GNU General Public License as published by the Free Soft- -- | |

-- ware Foundation; either version 2, or (at your option) any later ver- -- | |

-- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |

-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |

-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- | |

-- for more details. You should have received a copy of the GNU General -- | |

-- Public License distributed with GNAT; see file COPYING. If not, write -- | |

-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -- | |

-- MA 02111-1307, USA. -- | |

-- -- | |

-- As a special exception, if other files instantiate generics from this -- | |

-- unit, or you link this unit with other files to produce an executable, -- | |

-- this unit does not by itself cause the resulting executable to be -- | |

-- covered by the GNU General Public License. This exception does not -- | |

-- however invalidate any other reasons why the executable file might be -- | |

-- covered by the GNU Public License. -- | |

-- -- | |

-- GNAT was originally developed by the GNAT team at New York University. -- | |

-- Extensive contributions were provided by Ada Core Technologies Inc. -- | |

-- -- | |

------------------------------------------------------------------------------ | |

with System.Task_Primitives.Operations; | |

pragma Elaborate_All (System.Task_Primitives.Operations); | |

package Ada.Real_Time is | |

type Time is private; | |

Time_First : constant Time; | |

Time_Last : constant Time; | |

Time_Unit : constant := 10#1.0#E-9; | |

type Time_Span is private; | |

Time_Span_First : constant Time_Span; | |

Time_Span_Last : constant Time_Span; | |

Time_Span_Zero : constant Time_Span; | |

Time_Span_Unit : constant Time_Span; | |

Tick : constant Time_Span; | |

function Clock return Time; | |

function "+" (Left : Time; Right : Time_Span) return Time; | |

function "+" (Left : Time_Span; Right : Time) return Time; | |

function "-" (Left : Time; Right : Time_Span) return Time; | |

function "-" (Left : Time; Right : Time) return Time_Span; | |

function "<" (Left, Right : Time) return Boolean; | |

function "<=" (Left, Right : Time) return Boolean; | |

function ">" (Left, Right : Time) return Boolean; | |

function ">=" (Left, Right : Time) return Boolean; | |

function "+" (Left, Right : Time_Span) return Time_Span; | |

function "-" (Left, Right : Time_Span) return Time_Span; | |

function "-" (Right : Time_Span) return Time_Span; | |

function "*" (Left : Time_Span; Right : Integer) return Time_Span; | |

function "*" (Left : Integer; Right : Time_Span) return Time_Span; | |

function "/" (Left, Right : Time_Span) return Integer; | |

function "/" (Left : Time_Span; Right : Integer) return Time_Span; | |

function "abs" (Right : Time_Span) return Time_Span; | |

function "<" (Left, Right : Time_Span) return Boolean; | |

function "<=" (Left, Right : Time_Span) return Boolean; | |

function ">" (Left, Right : Time_Span) return Boolean; | |

function ">=" (Left, Right : Time_Span) return Boolean; | |

function To_Duration (TS : Time_Span) return Duration; | |

function To_Time_Span (D : Duration) return Time_Span; | |

function Nanoseconds (NS : Integer) return Time_Span; | |

function Microseconds (US : Integer) return Time_Span; | |

function Milliseconds (MS : Integer) return Time_Span; | |

-- Seconds_Count needs 64 bits, since Time has the full range of | |

-- Duration. The delta of Duration is 10 ** (-9), so the maximum | |

-- number of seconds is 2**63/10**9 = 8*10**9 which does not quite | |

-- fit in 32 bits. | |

type Seconds_Count is range -2 ** 63 .. 2 ** 63 - 1; | |

procedure Split (T : Time; SC : out Seconds_Count; TS : out Time_Span); | |

function Time_Of (SC : Seconds_Count; TS : Time_Span) return Time; | |

private | |

type Time is new Duration; | |

Time_First : constant Time := Time'First; | |

Time_Last : constant Time := Time'Last; | |

type Time_Span is new Duration; | |

Time_Span_First : constant Time_Span := Time_Span'First; | |

Time_Span_Last : constant Time_Span := Time_Span'Last; | |

Time_Span_Zero : constant Time_Span := 0.0; | |

Time_Span_Unit : constant Time_Span := 10#1.0#E-9; | |

Tick : constant Time_Span := | |

Time_Span (System.Task_Primitives.Operations.RT_Resolution); | |

-- Time and Time_Span are represented in 64-bit Duration value in | |

-- in nanoseconds. For example, 1 second and 1 nanosecond is | |

-- represented as the stored integer 1_000_000_001. | |

pragma Import (Intrinsic, "<"); | |

pragma Import (Intrinsic, "<="); | |

pragma Import (Intrinsic, ">"); | |

pragma Import (Intrinsic, ">="); | |

pragma Import (Intrinsic, "abs"); | |

end Ada.Real_Time; |