2008-04-08 Pascal Obry <obry@adacore.com>

	* g-sercom.ads, g-sercom.adb (Data_Rate): Add B115200.
	(Stop_Bits_Number): New type.
	(Parity_Check): Likewise.
	(Set): Add parameter to set the number of stop bits and
	the parity. Parameter timeout is now a duration instead
	of a plain integer.

	* g-sercom-linux.adb:
	Implement the stop bits and parity support for GNU/Linux.
	Fix handling of timeout, it must be given in tenth of seconds.
	
	* g-sercom-mingw.adb:
	Implement the stop bits and parity support for Windows.
	Use new s-win32.ads unit instead of declaring Win32 services
	directly into this body.
	Update handling of timeout as now a duration.

	* s-win32.ads, s-winext.ads: New files.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@134003 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 295 insertions, 0 deletions

diff --git a/gcc/ada/s-win32.ads b/gcc/ada/s-win32.ads
new file mode 100644
index 00000000000..2d2648514b8
--- /dev/null
+++ b/gcc/ada/s-win32.ads
@@ -0,0 +1,295 @@
+------------------------------------------------------------------------------
+--                                                                          --
+--                        GNAT RUN-TIME COMPONENTS                          --
+--                                                                          --
+--                         S Y S T E M . W I N 3 2                          --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--            Copyright (C) 2008, Free Software Foundation, Inc.            --
+--                                                                          --
+-- 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,  51  Franklin  Street,  Fifth  Floor, --
+-- Boston, MA 02110-1301, 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.      --
+--                                                                          --
+------------------------------------------------------------------------------
+
+--  This package plus its child provide the low level interface to the Win32
+--  API. The core part of the Win32 API (commont to RTX and Win32) is in this
+--  package, and an additional part of the Win32 API which is not supported by
+--  RTX is in package System.Win33.Ext.
+
+with Interfaces.C;
+
+package System.Win32 is
+   pragma Pure;
+
+   -------------------
+   -- General Types --
+   -------------------
+
+   --  The LARGE_INTEGER type is actually a fixed point type
+   --  that only can represent integers. The reason for this is
+   --  easier conversion to Duration or other fixed point types.
+   --  (See Operations.Clock)
+
+   type LARGE_INTEGER is delta 1.0 range -2.0**63 .. 2.0**63 - 1.0;
+
+   subtype PVOID is Address;
+
+   type HANDLE is new Interfaces.C.long;
+
+   INVALID_HANDLE_VALUE : constant HANDLE := -1;
+
+   type DWORD  is new Interfaces.C.unsigned_long;
+   type WORD   is new Interfaces.C.unsigned_short;
+   type BYTE   is new Interfaces.C.unsigned_char;
+   type LONG   is new Interfaces.C.long;
+   type CHAR   is new Interfaces.C.char;
+
+   type BOOL   is new Interfaces.C.int;
+   for BOOL'Size use Interfaces.C.int'Size;
+
+   type Bits1  is range 0 .. 2 ** 1 - 1;
+   type Bits2  is range 0 .. 2 ** 2 - 1;
+   type Bits17 is range 0 .. 2 ** 17 - 1;
+   for Bits1'Size  use 1;
+   for Bits2'Size  use 2;
+   for Bits17'Size use 17;
+
+   FALSE : constant := 0;
+   TRUE  : constant := 1;
+
+   function GetLastError return DWORD;
+   pragma Import (Stdcall, GetLastError, "GetLastError");
+
+   -----------
+   -- Files --
+   -----------
+
+   GENERIC_READ  : constant := 16#80000000#;
+   GENERIC_WRITE : constant := 16#40000000#;
+
+   CREATE_NEW        : constant := 1;
+   CREATE_ALWAYS     : constant := 2;
+   OPEN_EXISTING     : constant := 3;
+   OPEN_ALWAYS       : constant := 4;
+   TRUNCATE_EXISTING : constant := 5;
+
+   FILE_SHARE_DELETE : constant := 16#00000004#;
+   FILE_SHARE_READ   : constant := 16#00000001#;
+   FILE_SHARE_WRITE  : constant := 16#00000002#;
+
+   FILE_BEGIN        : constant := 0;
+   FILE_CURRENT      : constant := 1;
+   FILE_END          : constant := 2;
+
+   PAGE_NOACCESS       : constant := 16#0001#;
+   PAGE_READONLY       : constant := 16#0002#;
+   PAGE_READWRITE      : constant := 16#0004#;
+   PAGE_WRITECOPY      : constant := 16#0008#;
+   PAGE_EXECUTE        : constant := 16#0010#;
+
+   FILE_MAP_ALL_ACCESS : constant := 16#F001f#;
+   FILE_MAP_READ       : constant := 4;
+   FILE_MAP_WRITE      : constant := 2;
+   FILE_MAP_COPY       : constant := 1;
+
+   FILE_ADD_FILE             : constant := 16#0002#;
+   FILE_ADD_SUBDIRECTORY     : constant := 16#0004#;
+   FILE_APPEND_DATA          : constant := 16#0004#;
+   FILE_CREATE_PIPE_INSTANCE : constant := 16#0004#;
+   FILE_DELETE_CHILD         : constant := 16#0040#;
+   FILE_EXECUTE              : constant := 16#0020#;
+   FILE_LIST_DIRECTORY       : constant := 16#0001#;
+   FILE_READ_ATTRIBUTES      : constant := 16#0080#;
+   FILE_READ_DATA            : constant := 16#0001#;
+   FILE_READ_EA              : constant := 16#0008#;
+   FILE_TRAVERSE             : constant := 16#0020#;
+   FILE_WRITE_ATTRIBUTES     : constant := 16#0100#;
+   FILE_WRITE_DATA           : constant := 16#0002#;
+   FILE_WRITE_EA             : constant := 16#0010#;
+   STANDARD_RIGHTS_READ      : constant := 16#20000#;
+   STANDARD_RIGHTS_WRITE     : constant := 16#20000#;
+   SYNCHRONIZE               : constant := 16#100000#;
+
+   FILE_ATTRIBUTE_READONLY            : constant := 16#00000001#;
+   FILE_ATTRIBUTE_HIDDEN              : constant := 16#00000002#;
+   FILE_ATTRIBUTE_SYSTEM              : constant := 16#00000004#;
+   FILE_ATTRIBUTE_DIRECTORY           : constant := 16#00000010#;
+   FILE_ATTRIBUTE_ARCHIVE             : constant := 16#00000020#;
+   FILE_ATTRIBUTE_DEVICE              : constant := 16#00000040#;
+   FILE_ATTRIBUTE_NORMAL              : constant := 16#00000080#;
+   FILE_ATTRIBUTE_TEMPORARY           : constant := 16#00000100#;
+   FILE_ATTRIBUTE_SPARSE_FILE         : constant := 16#00000200#;
+   FILE_ATTRIBUTE_REPARSE_POINT       : constant := 16#00000400#;
+   FILE_ATTRIBUTE_COMPRESSED          : constant := 16#00000800#;
+   FILE_ATTRIBUTE_OFFLINE             : constant := 16#00001000#;
+   FILE_ATTRIBUTE_NOT_CONTENT_INDEXED : constant := 16#00002000#;
+   FILE_ATTRIBUTE_ENCRYPTED           : constant := 16#00004000#;
+   FILE_ATTRIBUTE_VALID_FLAGS         : constant := 16#00007fb7#;
+   FILE_ATTRIBUTE_VALID_SET_FLAGS     : constant := 16#000031a7#;
+
+   type OVERLAPPED is record
+      Internal     : DWORD;
+      InternalHigh : DWORD;
+      Offset       : DWORD;
+      OffsetHigh   : DWORD;
+      hEvent       : HANDLE;
+   end record;
+
+   type SECURITY_ATTRIBUTES is record
+      nLength             : DWORD;
+      pSecurityDescriptor : PVOID;
+      bInheritHandle      : BOOL;
+   end record;
+
+   function CreateFile
+     (lpFileName            : Address;
+      dwDesiredAccess       : DWORD;
+      dwShareMode           : DWORD;
+      lpSecurityAttributes  : access SECURITY_ATTRIBUTES;
+      dwCreationDisposition : DWORD;
+      dwFlagsAndAttributes  : DWORD;
+      hTemplateFile         : HANDLE) return HANDLE;
+   pragma Import (Stdcall, CreateFile, "CreateFileA");
+
+   function GetFileSize
+     (hFile          : HANDLE;
+      lpFileSizeHigh : access DWORD) return BOOL;
+   pragma Import (Stdcall, GetFileSize, "GetFileSize");
+
+   function SetFilePointer
+     (hFile                : HANDLE;
+      lDistanceToMove      : LONG;
+      lpDistanceToMoveHigh : access LONG;
+      dwMoveMethod         : DWORD) return DWORD;
+   pragma Import (Stdcall, SetFilePointer, "SetFilePointer");
+
+   function WriteFile
+     (hFile                  : HANDLE;
+      lpBuffer               : Address;
+      nNumberOfBytesToWrite  : DWORD;
+      lpNumberOfBytesWritten : access DWORD;
+      lpOverlapped           : access OVERLAPPED) return BOOL;
+   pragma Import (Stdcall, WriteFile, "WriteFile");
+
+   function ReadFile
+     (hFile                : HANDLE;
+      lpBuffer             : Address;
+      nNumberOfBytesToRead : DWORD;
+      lpNumberOfBytesRead  : access DWORD;
+      lpOverlapped         : access OVERLAPPED) return BOOL;
+   pragma Import (Stdcall, ReadFile, "ReadFile");
+
+   function CloseHandle (hObject : HANDLE) return BOOL;
+   pragma Import (Stdcall, CloseHandle, "CloseHandle");
+
+   function CreateFileMapping
+     (hFile                : HANDLE;
+      lpSecurityAttributes : access SECURITY_ATTRIBUTES;
+      flProtect            : DWORD;
+      dwMaximumSizeHigh    : DWORD;
+      dwMaximumSizeLow     : DWORD;
+      lpName               : Address) return HANDLE;
+   pragma Import (Stdcall, CreateFileMapping, "CreateFileMappingA");
+
+   function MapViewOfFile
+     (hFileMappingObject   : HANDLE;
+      dwDesiredAccess      : DWORD;
+      dwFileOffsetHigh     : DWORD;
+      dwFileOffsetLow      : DWORD;
+      dwNumberOfBytesToMap : DWORD) return System.Address;
+   pragma Import (Stdcall, MapViewOfFile, "MapViewOfFile");
+
+   function UnmapViewOfFile (lpBaseAddress : System.Address) return BOOL;
+   pragma Import (Stdcall, UnmapViewOfFile, "UnmapViewOfFile");
+
+   ------------------------
+   -- System Information --
+   ------------------------
+
+   subtype ProcessorId is DWORD;
+
+   type SYSTEM_INFO is record
+      dwOemId                     : DWORD;
+      dwPageSize                  : DWORD;
+      lpMinimumApplicationAddress : PVOID;
+      lpMaximumApplicationAddress : PVOID;
+      dwActiveProcessorMask       : DWORD;
+      dwNumberOfProcessors        : DWORD;
+      dwProcessorType             : DWORD;
+      dwAllocationGranularity     : DWORD;
+      dwReserved                  : DWORD;
+   end record;
+
+   procedure GetSystemInfo (SI : access SYSTEM_INFO);
+   pragma Import (Stdcall, GetSystemInfo, "GetSystemInfo");
+
+   ---------------------
+   -- Time Management --
+   ---------------------
+
+   type SYSTEMTIME is record
+      wYear         : WORD;
+      wMonth        : WORD;
+      wDayOfWeek    : WORD;
+      wDay          : WORD;
+      wHour         : WORD;
+      wMinute       : WORD;
+      wSecond       : WORD;
+      wMilliseconds : WORD;
+   end record;
+
+   procedure GetSystemTime (pSystemTime : access SYSTEMTIME);
+   pragma Import (Stdcall, GetSystemTime, "GetSystemTime");
+
+   procedure GetSystemTimeAsFileTime (lpFileTime : access Long_Long_Integer);
+   pragma Import (Stdcall, GetSystemTimeAsFileTime, "GetSystemTimeAsFileTime");
+
+   function FileTimeToSystemTime
+     (lpFileTime   : access Long_Long_Integer;
+      lpSystemTime : access SYSTEMTIME) return BOOL;
+   pragma Import (Stdcall, FileTimeToSystemTime, "FileTimeToSystemTime");
+
+   function SystemTimeToFileTime
+     (lpSystemTime : access SYSTEMTIME;
+      lpFileTime   : access Long_Long_Integer) return BOOL;
+   pragma Import (Stdcall, SystemTimeToFileTime, "SystemTimeToFileTime");
+
+   function FileTimeToLocalFileTime
+     (lpFileTime      : access Long_Long_Integer;
+      lpLocalFileTime : access Long_Long_Integer) return BOOL;
+   pragma Import (Stdcall, FileTimeToLocalFileTime, "FileTimeToLocalFileTime");
+
+   function LocalFileTimeToFileTime
+     (lpFileTime      : access Long_Long_Integer;
+      lpLocalFileTime : access Long_Long_Integer) return BOOL;
+   pragma Import (Stdcall, LocalFileTimeToFileTime, "LocalFileTimeToFileTime");
+
+   procedure Sleep (dwMilliseconds : DWORD);
+   pragma Import (Stdcall, Sleep, External_Name => "Sleep");
+
+   function QueryPerformanceCounter
+     (lpPerformanceCount : access LARGE_INTEGER) return BOOL;
+   pragma Import
+     (Stdcall, QueryPerformanceCounter, "QueryPerformanceCounter");
+
+end System.Win32;