g-string.adb, [...]: Replace GNAT.xxx by System.xxx when appropriate.

2007-04-20  Robert Dewar  <dewar@adacore.com>

	* g-string.adb, s-proinf-irix-athread.adb, s-gloloc-mingw.adb,
	s-tfsetr-default.adb, gnatfind.adb, gnatxref.adb, gprep.adb,
	g-regexp.adb, g-regexp.ads, g-regpat.ads, g-tasloc.adb, g-tasloc.ads,
	output.adb, switch-m.ads, tree_in.ads, tree_io.ads, indepsw.ads,
	g-utf_32.adb, g-utf_32.ads, a-wichun.adb, a-wichun.ads, a-zchuni.adb,
	a-zchuni.ads: Replace GNAT.xxx by System.xxx when appropriate.

	* s-utf_32.adb, s-utf_32.ads, s-os_lib.adb, s-os_lib.ads, s-regexp.adb,
	s-regexp.ads, s-regpat.adb, s-regpat.ads, s-string.adb, s-string.ads,
	s-tasloc.adb, s-tasloc.ads: New files.

From-SVN: r125360

1 files changed, 7 insertions, 98 deletions

diff --git a/gcc/ada/g-regexp.ads b/gcc/ada/g-regexp.ads
index 7dada9c..e26d0c6 100644
--- a/gcc/ada/g-regexp.ads
+++ b/gcc/ada/g-regexp.ads
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---                     Copyright (C) 1998-2005, AdaCore                     --
+--                     Copyright (C) 1998-2007, AdaCore                     --
 --                                                                          --
 -- 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- --
@@ -37,6 +37,8 @@
 --  pattern matching algorithm, using a subset of the syntax of regular
 --  expressions copied from familiar Unix style utilities.
 
+--  See file s-regexp.ads for full documentation of the interface
+
 ------------------------------------------------------------
 -- Summary of Pattern Matching Packages in GNAT Hierarchy --
 ------------------------------------------------------------
@@ -45,14 +47,14 @@
 --  the following is an outline of these packages, to help you determine
 --  which is best for your needs.
 
---     GNAT.Regexp (files g-regexp.ads/g-regexp.adb)
+--     GNAT.Regexp (files g-regexp.ads/s-regexp.ads/s-regexp.adb)
 --       This is a simple package providing Unix-style regular expression
 --       matching with the restriction that it matches entire strings. It
 --       is particularly useful for file name matching, and in particular
 --       it provides "globbing patterns" that are useful in implementing
 --       unix or DOS style wild card matching for file names.
 
---     GNAT.Regpat (files g-regpat.ads/g-regpat.adb)
+--     GNAT.Regpat (files g-regpat.ads/s-regpat.ads/g-regpat.adb)
 --       This is a more complete implementation of Unix-style regular
 --       expressions, copied from the original V7 style regular expression
 --       library written in C by Henry Spencer. It is functionally the
@@ -65,99 +67,6 @@
 --       language is modeled on context free grammars, with context sensitive
 --       extensions that provide full (type 0) computational capabilities.
 
-with Ada.Finalization;
-
-package GNAT.Regexp is
-
-   --  The regular expression must first be compiled, using the Compile
-   --  function, which creates a finite state matching table, allowing
-   --  very fast matching once the expression has been compiled.
-
-   --  The following is the form of a regular expression, expressed in Ada
-   --  reference manual style BNF is as follows
-
-   --     regexp ::= term
-
-   --     regexp ::= term | term          -- alternation (term or term ...)
-
-   --     term ::= item
-
-   --     term ::= item item ...          -- concatenation (item then item)
-
-   --     item ::= elmt                   -- match elmt
-   --     item ::= elmt *                 -- zero or more elmt's
-   --     item ::= elmt +                 -- one or more elmt's
-   --     item ::= elmt ?                 -- matches elmt or nothing
-
-   --     elmt ::= nchr                   -- matches given character
-   --     elmt ::= [nchr nchr ...]        -- matches any character listed
-   --     elmt ::= [^ nchr nchr ...]      -- matches any character not listed
-   --     elmt ::= [char - char]          -- matches chars in given range
-   --     elmt ::= .                      -- matches any single character
-   --     elmt ::= ( regexp )             -- parens used for grouping
-
-   --     char ::= any character, including special characters
-   --     nchr ::= any character except \()[].*+?^ or \char to match char
-   --     ... is used to indication repetition (one or more terms)
-
-   --  See also regexp(1) man page on Unix systems for further details
-
-   --  A second kind of regular expressions is provided. This one is more
-   --  like the wild card patterns used in file names by the Unix shell (or
-   --  DOS prompt) command lines. The grammar is the following:
-
-   --     regexp ::= term
-
-   --     term   ::= elmt
-
-   --     term   ::= elmt elmt ...     -- concatenation (elmt then elmt)
-   --     term   ::= *                 -- any string of 0 or more characters
-   --     term   ::= ?                 -- matches any character
-   --     term   ::= [char char ...]   -- matches any character listed
-   --     term   ::= [char - char]     -- matches any character in given range
-   --     term   ::= {elmt, elmt, ...} -- alternation (matches any of elmt)
-
-   --  Important note : This package was mainly intended to match regular
-   --  expressions against file names. The whole string has to match the
-   --  regular expression. If only a substring matches, then the function
-   --  Match will return False.
-
-   type Regexp is private;
-   --  Private type used to represent a regular expression
-
-   Error_In_Regexp : exception;
-   --  Exception raised when an error is found in the regular expression
-
-   function Compile
-     (Pattern        : String;
-      Glob           : Boolean := False;
-      Case_Sensitive : Boolean := True) return Regexp;
-   --  Compiles a regular expression S. If the syntax of the given
-   --  expression is invalid (does not match above grammar, Error_In_Regexp
-   --  is raised. If Glob is True, the pattern is considered as a 'globbing
-   --  pattern', that is a pattern as given by the second grammar above.
-   --  As a special case, if Pattern is the empty string it will always
-   --  match.
-
-   function Match (S : String; R : Regexp) return Boolean;
-   --  True if S matches R, otherwise False. Raises Constraint_Error if
-   --  R is an uninitialized regular expression value.
-
-private
-   type Regexp_Value;
-
-   type Regexp_Access is access Regexp_Value;
-
-   type Regexp is new Ada.Finalization.Controlled with record
-      R : Regexp_Access := null;
-   end record;
-
-   pragma Finalize_Storage_Only (Regexp);
-
-   procedure Finalize (R : in out Regexp);
-   --  Free the memory occupied by R
-
-   procedure Adjust (R : in out Regexp);
-   --  Called after an assignment (do a copy of the Regexp_Access.all)
+with System.Regexp;
 
-end GNAT.Regexp;
+package GNAT.Regexp renames System.Regexp;