1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- G N A T . D I R E C T O R Y _ O P E R A T I O N S . I T E R A T I O N --
9 -- Copyright (C) 2001-2008, AdaCore --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 with Ada.Characters.Handling;
35 with Ada.Strings.Fixed;
36 with Ada.Strings.Maps;
40 package body GNAT.Directory_Operations.Iteration is
49 (Root_Directory : Dir_Name_Str;
50 File_Pattern : String)
52 File_Regexp : constant Regexp.Regexp := Regexp.Compile (File_Pattern);
56 procedure Read_Directory (Directory : Dir_Name_Str);
57 -- Open Directory and read all entries. This routine is called
58 -- recursively for each sub-directories.
60 function Make_Pathname (Dir, File : String) return String;
61 -- Returns the pathname for File by adding Dir as prefix
67 function Make_Pathname (Dir, File : String) return String is
69 if Dir (Dir'Last) = '/' or else Dir (Dir'Last) = '\' then
72 return Dir & Dir_Separator & File;
80 procedure Read_Directory (Directory : Dir_Name_Str) is
81 Buffer : String (1 .. 2_048);
85 pragma Warnings (Off, Dir);
88 Open (Dir, Directory);
91 Read (Dir, Buffer, Last);
95 Dir_Entry : constant String := Buffer (1 .. Last);
96 Pathname : constant String :=
97 Make_Pathname (Directory, Dir_Entry);
100 if Regexp.Match (Dir_Entry, File_Regexp) then
104 Action (Pathname, Index, Quit);
114 -- Recursively call for sub-directories, except for . and ..
116 if not (Dir_Entry = "." or else Dir_Entry = "..")
117 and then OS_Lib.Is_Directory (Pathname)
119 Read_Directory (Pathname);
130 Read_Directory (Root_Directory);
133 -----------------------
134 -- Wildcard_Iterator --
135 -----------------------
137 procedure Wildcard_Iterator (Path : Path_Name) is
139 Index : Natural := 0;
143 File_Pattern : String;
144 Suffix_Pattern : String);
145 -- Read entries in Directory and call user's callback if the entry
146 -- match File_Pattern and Suffix_Pattern is empty otherwise it will go
147 -- down one more directory level by calling Next_Level routine above.
150 (Current_Path : String;
151 Suffix_Path : String);
152 -- Extract next File_Pattern from Suffix_Path and call Read routine
160 (Current_Path : String;
161 Suffix_Path : String)
164 SP : String renames Suffix_Path;
168 and then SP (SP'First) = '.'
169 and then Strings.Maps.Is_In (SP (SP'First + 1), Dir_Seps)
171 -- Starting with "./"
173 DS := Strings.Fixed.Index
174 (SP (SP'First + 2 .. SP'Last),
181 Read (Current_Path & ".", "*", "");
186 Read (Current_Path & ".",
187 SP (SP'First + 2 .. DS - 1),
192 and then SP (SP'First .. SP'First + 1) = ".."
193 and then Strings.Maps.Is_In (SP (SP'First + 2), Dir_Seps)
195 -- Starting with "../"
197 DS := Strings.Fixed.Index
198 (SP (SP'First + 3 .. SP'Last), Dir_Seps);
204 Read (Current_Path & "..", "*", "");
209 Read (Current_Path & "..",
210 SP (SP'First + 3 .. DS - 1),
214 elsif Current_Path = ""
215 and then SP'Length > 1
216 and then Characters.Handling.Is_Letter (SP (SP'First))
217 and then SP (SP'First + 1) = ':'
219 -- Starting with "<drive>:"
222 and then Strings.Maps.Is_In (SP (SP'First + 2), Dir_Seps)
224 -- Starting with "<drive>:\"
226 DS := Strings.Fixed.Index
227 (SP (SP'First + 3 .. SP'Last), Dir_Seps);
231 -- We have "<drive>:\dir"
233 Read (SP (SP'First .. SP'First + 2),
234 SP (SP'First + 3 .. SP'Last),
238 -- We have "<drive>:\dir\kkk"
240 Read (SP (SP'First .. SP'First + 2),
241 SP (SP'First + 3 .. DS - 1),
246 -- Starting with "<drive>:" and the drive letter not followed
247 -- by a directory separator. The proper semantic on Windows is
248 -- to read the content of the current selected directory on
249 -- this drive. For example, if drive C current selected
250 -- directory is c:\temp the suffix pattern "c:m*" is
251 -- equivalent to c:\temp\m*.
253 DS := Strings.Fixed.Index
254 (SP (SP'First + 2 .. SP'Last), Dir_Seps);
258 -- We have "<drive>:dir"
263 -- We have "<drive>:dir/kkk"
265 Read (SP (SP'First .. DS - 1), "", SP (DS .. SP'Last));
269 elsif Strings.Maps.Is_In (SP (SP'First), Dir_Seps) then
273 DS := Strings.Fixed.Index
274 (SP (SP'First + 1 .. SP'Last), Dir_Seps);
280 Read (Current_Path, SP (SP'First + 1 .. SP'Last), "");
282 -- We have "/dir/kkk"
285 SP (SP'First + 1 .. DS - 1),
290 -- Starting with a name
292 DS := Strings.Fixed.Index (SP, Dir_Seps);
298 Read (Current_Path & '.', SP, "");
302 Read (Current_Path & '.',
303 SP (SP'First .. DS - 1),
314 Quit : Boolean := False;
315 -- Global state to be able to exit all recursive calls
319 File_Pattern : String;
320 Suffix_Pattern : String)
322 File_Regexp : constant Regexp.Regexp :=
323 Regexp.Compile (File_Pattern, Glob => True);
326 pragma Warnings (Off, Dir);
328 Buffer : String (1 .. 2_048);
332 if OS_Lib.Is_Directory (Directory & Dir_Separator) then
333 Open (Dir, Directory & Dir_Separator);
336 Read (Dir, Buffer, Last);
337 exit Dir_Iterator when Last = 0;
340 Dir_Entry : constant String := Buffer (1 .. Last);
341 Pathname : constant String :=
342 Directory & Dir_Separator & Dir_Entry;
344 -- Handle "." and ".." only if explicit use in the
348 ((Dir_Entry = "." and then File_Pattern /= ".")
350 (Dir_Entry = ".." and then File_Pattern /= ".."))
352 if Regexp.Match (Dir_Entry, File_Regexp) then
353 if Suffix_Pattern = "" then
355 -- No more matching needed, call user's callback
360 Action (Pathname, Index, Quit);
371 (Directory & Dir_Separator & Dir_Entry,
378 -- Exit if Quit set by call to Action, either at this level
379 -- or at some lower recursive call to Next_Level.
381 exit Dir_Iterator when Quit;
382 end loop Dir_Iterator;
388 -- Start of processing for Wildcard_Iterator
395 Next_Level ("", Path);
396 end Wildcard_Iterator;
398 end GNAT.Directory_Operations.Iteration;