------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- G N A T . D I R E C T O R Y _ O P E R A T I O N S -- -- -- -- B o d y -- -- -- -- Copyright (C) 1998-2006, 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- -- -- 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. -- -- -- ------------------------------------------------------------------------------ with Ada.Characters.Handling; with Ada.Strings.Fixed; with Unchecked_Deallocation; with Unchecked_Conversion; with System; use System; with System.CRTL; use System.CRTL; with GNAT.OS_Lib; package body GNAT.Directory_Operations is use Ada; type Dir_Type_Value is new System.Address; -- This is the low-level address directory structure as returned by the C -- opendir routine. Filename_Max : constant Integer := 1024; -- 1024 is the value of FILENAME_MAX in stdio.h procedure Free is new Unchecked_Deallocation (Dir_Type_Value, Dir_Type); --------------- -- Base_Name -- --------------- function Base_Name (Path : Path_Name; Suffix : String := "") return String is function Get_File_Names_Case_Sensitive return Integer; pragma Import (C, Get_File_Names_Case_Sensitive, "__gnat_get_file_names_case_sensitive"); Case_Sensitive_File_Name : constant Boolean := Get_File_Names_Case_Sensitive = 1; function Basename (Path : Path_Name; Suffix : String := "") return String; -- This function does the job. The only difference between Basename -- and Base_Name (the parent function) is that the former is case -- sensitive, while the latter is not. Path and Suffix are adjusted -- appropriately before calling Basename under platforms where the -- file system is not case sensitive. -------------- -- Basename -- -------------- function Basename (Path : Path_Name; Suffix : String := "") return String is Cut_Start : Natural := Strings.Fixed.Index (Path, Dir_Seps, Going => Strings.Backward); Cut_End : Natural; begin -- Cut_Start point to the first basename character if Cut_Start = 0 then Cut_Start := Path'First; else Cut_Start := Cut_Start + 1; end if; -- Cut_End point to the last basename character Cut_End := Path'Last; -- If basename ends with Suffix, adjust Cut_End if Suffix /= "" and then Path (Path'Last - Suffix'Length + 1 .. Cut_End) = Suffix then Cut_End := Path'Last - Suffix'Length; end if; Check_For_Standard_Dirs : declare Offset : constant Integer := Path'First - Base_Name.Path'First; BN : constant String := Base_Name.Path (Cut_Start - Offset .. Cut_End - Offset); -- Here we use Base_Name.Path to keep the original casing Has_Drive_Letter : constant Boolean := OS_Lib.Path_Separator /= ':'; -- If Path separator is not ':' then we are on a DOS based OS -- where this character is used as a drive letter separator. begin if BN = "." or else BN = ".." then return ""; elsif Has_Drive_Letter and then BN'Length > 2 and then Characters.Handling.Is_Letter (BN (BN'First)) and then BN (BN'First + 1) = ':' then -- We have a DOS drive letter prefix, remove it return BN (BN'First + 2 .. BN'Last); else return BN; end if; end Check_For_Standard_Dirs; end Basename; -- Start processing for Base_Name begin if Path'Length <= Suffix'Length then return Path; end if; if Case_Sensitive_File_Name then return Basename (Path, Suffix); else return Basename (Characters.Handling.To_Lower (Path), Characters.Handling.To_Lower (Suffix)); end if; end Base_Name; ---------------- -- Change_Dir -- ---------------- procedure Change_Dir (Dir_Name : Dir_Name_Str) is C_Dir_Name : constant String := Dir_Name & ASCII.NUL; function chdir (Dir_Name : String) return Integer; pragma Import (C, chdir, "chdir"); begin if chdir (C_Dir_Name) /= 0 then raise Directory_Error; end if; end Change_Dir; ----------- -- Close -- ----------- procedure Close (Dir : in out Dir_Type) is Discard : Integer; pragma Warnings (Off, Discard); function closedir (directory : DIRs) return Integer; pragma Import (C, closedir, "__gnat_closedir"); begin if not Is_Open (Dir) then raise Directory_Error; end if; Discard := closedir (DIRs (Dir.all)); Free (Dir); end Close; -------------- -- Dir_Name -- -------------- function Dir_Name (Path : Path_Name) return Dir_Name_Str is Last_DS : constant Natural := Strings.Fixed.Index (Path, Dir_Seps, Going => Strings.Backward); begin if Last_DS = 0 then -- There is no directory separator, returns current working directory return "." & Dir_Separator; else return Path (Path'First .. Last_DS); end if; end Dir_Name; ----------------- -- Expand_Path -- ----------------- function Expand_Path (Path : Path_Name; Mode : Environment_Style := System_Default) return Path_Name is Environment_Variable_Char : Character; pragma Import (C, Environment_Variable_Char, "__gnat_environment_char"); Result : OS_Lib.String_Access := new String (1 .. 200); Result_Last : Natural := 0; procedure Append (C : Character); procedure Append (S : String); -- Append to Result procedure Double_Result_Size; -- Reallocate Result, doubling its size function Is_Var_Prefix (C : Character) return Boolean; pragma Inline (Is_Var_Prefix); procedure Read (K : in out Positive); -- Update Result while reading current Path starting at position K. If -- a variable is found, call Var below. procedure Var (K : in out Positive); -- Translate variable name starting at position K with the associated -- environment value. ------------ -- Append -- ------------ procedure Append (C : Character) is begin if Result_Last = Result'Last then Double_Result_Size; end if; Result_Last := Result_Last + 1; Result (Result_Last) := C; end Append; procedure Append (S : String) is begin while Result_Last + S'Length - 1 > Result'Last loop Double_Result_Size; end loop; Result (Result_Last + 1 .. Result_Last + S'Length) := S; Result_Last := Result_Last + S'Length; end Append; ------------------------ -- Double_Result_Size -- ------------------------ procedure Double_Result_Size is New_Result : constant OS_Lib.String_Access := new String (1 .. 2 * Result'Last); begin New_Result (1 .. Result_Last) := Result (1 .. Result_Last); OS_Lib.Free (Result); Result := New_Result; end Double_Result_Size; ------------------- -- Is_Var_Prefix -- ------------------- function Is_Var_Prefix (C : Character) return Boolean is begin return (C = Environment_Variable_Char and then Mode = System_Default) or else (C = '$' and then (Mode = UNIX or else Mode = Both)) or else (C = '%' and then (Mode = DOS or else Mode = Both)); end Is_Var_Prefix; ---------- -- Read -- ---------- procedure Read (K : in out Positive) is P : Character; begin For_All_Characters : loop if Is_Var_Prefix (Path (K)) then P := Path (K); -- Could be a variable if K < Path'Last then if Path (K + 1) = P then -- Not a variable after all, this is a double $ or %, -- just insert one in the result string. Append (P); K := K + 1; else -- Let's parse the variable Var (K); end if; else -- We have an ending $ or % sign Append (P); end if; else -- This is a standard character, just add it to the result Append (Path (K)); end if; -- Skip to next character K := K + 1; exit For_All_Characters when K > Path'Last; end loop For_All_Characters; end Read; --------- -- Var -- --------- procedure Var (K : in out Positive) is P : constant Character := Path (K); T : Character; E : Positive; begin K := K + 1; if P = '%' or else Path (K) = '{' then -- Set terminator character if P = '%' then T := '%'; else T := '}'; K := K + 1; end if; -- Look for terminator character, k point to the first character -- for the variable name. E := K; loop E := E + 1; exit when Path (E) = T or else E = Path'Last; end loop; if Path (E) = T then -- OK found, translate with environment value declare Env : OS_Lib.String_Access := OS_Lib.Getenv (Path (K .. E - 1)); begin Append (Env.all); OS_Lib.Free (Env); end; else -- No terminator character, not a variable after all or a -- syntax error, ignore it, insert string as-is. Append (P); -- Add prefix character if T = '}' then -- If we were looking for curly bracket Append ('{'); -- terminator, add the curly bracket end if; Append (Path (K .. E)); end if; else -- The variable name is everything from current position to first -- non letter/digit character. E := K; -- Check that first chartacter is a letter if Characters.Handling.Is_Letter (Path (E)) then E := E + 1; Var_Name : loop exit Var_Name when E > Path'Last; if Characters.Handling.Is_Letter (Path (E)) or else Characters.Handling.Is_Digit (Path (E)) then E := E + 1; else exit Var_Name; end if; end loop Var_Name; E := E - 1; declare Env : OS_Lib.String_Access := OS_Lib.Getenv (Path (K .. E)); begin Append (Env.all); OS_Lib.Free (Env); end; else -- This is not a variable after all Append ('$'); Append (Path (E)); end if; end if; K := E; end Var; -- Start of processing for Expand_Path begin declare K : Positive := Path'First; begin Read (K); declare Returned_Value : constant String := Result (1 .. Result_Last); begin OS_Lib.Free (Result); return Returned_Value; end; end; end Expand_Path; -------------------- -- File_Extension -- -------------------- function File_Extension (Path : Path_Name) return String is First : Natural := Strings.Fixed.Index (Path, Dir_Seps, Going => Strings.Backward); Dot : Natural; begin if First = 0 then First := Path'First; end if; Dot := Strings.Fixed.Index (Path (First .. Path'Last), ".", Going => Strings.Backward); if Dot = 0 or else Dot = Path'Last then return ""; else return Path (Dot .. Path'Last); end if; end File_Extension; --------------- -- File_Name -- --------------- function File_Name (Path : Path_Name) return String is begin return Base_Name (Path); end File_Name; --------------------- -- Format_Pathname -- --------------------- function Format_Pathname (Path : Path_Name; Style : Path_Style := System_Default) return String is N_Path : String := Path; K : Positive := N_Path'First; Prev_Dirsep : Boolean := False; begin if Dir_Separator = '\' and then Path'Length > 1 and then Path (K .. K + 1) = "\\" then if Style = UNIX then N_Path (K .. K + 1) := "//"; end if; K := K + 2; end if; for J in K .. Path'Last loop if Strings.Maps.Is_In (Path (J), Dir_Seps) then if not Prev_Dirsep then case Style is when UNIX => N_Path (K) := '/'; when DOS => N_Path (K) := '\'; when System_Default => N_Path (K) := Dir_Separator; end case; K := K + 1; end if; Prev_Dirsep := True; else N_Path (K) := Path (J); K := K + 1; Prev_Dirsep := False; end if; end loop; return N_Path (N_Path'First .. K - 1); end Format_Pathname; --------------------- -- Get_Current_Dir -- --------------------- Max_Path : Integer; pragma Import (C, Max_Path, "__gnat_max_path_len"); function Get_Current_Dir return Dir_Name_Str is Current_Dir : String (1 .. Max_Path + 1); Last : Natural; begin Get_Current_Dir (Current_Dir, Last); return Current_Dir (1 .. Last); end Get_Current_Dir; procedure Get_Current_Dir (Dir : out Dir_Name_Str; Last : out Natural) is Path_Len : Natural := Max_Path; Buffer : String (Dir'First .. Dir'First + Max_Path + 1); procedure Local_Get_Current_Dir (Dir : System.Address; Length : System.Address); pragma Import (C, Local_Get_Current_Dir, "__gnat_get_current_dir"); begin Local_Get_Current_Dir (Buffer'Address, Path_Len'Address); if Dir'Length > Path_Len then Last := Dir'First + Path_Len - 1; else Last := Dir'Last; end if; Dir (Buffer'First .. Last) := Buffer (Buffer'First .. Last); end Get_Current_Dir; ------------- -- Is_Open -- ------------- function Is_Open (Dir : Dir_Type) return Boolean is begin return Dir /= Null_Dir and then System.Address (Dir.all) /= System.Null_Address; end Is_Open; -------------- -- Make_Dir -- -------------- procedure Make_Dir (Dir_Name : Dir_Name_Str) is C_Dir_Name : constant String := Dir_Name & ASCII.NUL; function mkdir (Dir_Name : String) return Integer; pragma Import (C, mkdir, "__gnat_mkdir"); begin if mkdir (C_Dir_Name) /= 0 then raise Directory_Error; end if; end Make_Dir; ---------- -- Open -- ---------- procedure Open (Dir : out Dir_Type; Dir_Name : Dir_Name_Str) is function opendir (file_name : String) return DIRs; pragma Import (C, opendir, "__gnat_opendir"); C_File_Name : constant String := Dir_Name & ASCII.NUL; begin Dir := new Dir_Type_Value'(Dir_Type_Value (opendir (C_File_Name))); if not Is_Open (Dir) then Free (Dir); Dir := Null_Dir; raise Directory_Error; end if; end Open; ---------- -- Read -- ---------- procedure Read (Dir : in out Dir_Type; Str : out String; Last : out Natural) is Filename_Addr : Address; Filename_Len : aliased Integer; Buffer : array (0 .. Filename_Max + 12) of Character; -- 12 is the size of the dirent structure (see dirent.h), without the -- field for the filename. function readdir_gnat (Directory : System.Address; Buffer : System.Address; Last : access Integer) return System.Address; pragma Import (C, readdir_gnat, "__gnat_readdir"); begin if not Is_Open (Dir) then raise Directory_Error; end if; Filename_Addr := readdir_gnat (System.Address (Dir.all), Buffer'Address, Filename_Len'Access); if Filename_Addr = System.Null_Address then Last := 0; return; end if; if Str'Length > Filename_Len then Last := Str'First + Filename_Len - 1; else Last := Str'Last; end if; declare subtype Path_String is String (1 .. Filename_Len); type Path_String_Access is access Path_String; function Address_To_Access is new Unchecked_Conversion (Source => Address, Target => Path_String_Access); Path_Access : constant Path_String_Access := Address_To_Access (Filename_Addr); begin for J in Str'First .. Last loop Str (J) := Path_Access (J - Str'First + 1); end loop; end; end Read; ------------------------- -- Read_Is_Thread_Sage -- ------------------------- function Read_Is_Thread_Safe return Boolean is function readdir_is_thread_safe return Integer; pragma Import (C, readdir_is_thread_safe, "__gnat_readdir_is_thread_safe"); begin return (readdir_is_thread_safe /= 0); end Read_Is_Thread_Safe; ---------------- -- Remove_Dir -- ---------------- procedure Remove_Dir (Dir_Name : Dir_Name_Str; Recursive : Boolean := False) is C_Dir_Name : constant String := Dir_Name & ASCII.NUL; Current_Dir : constant Dir_Name_Str := Get_Current_Dir; Last : Integer; Str : String (1 .. Filename_Max); Success : Boolean; Working_Dir : Dir_Type; begin -- Remove the directory only if it is empty if not Recursive then rmdir (C_Dir_Name); if GNAT.OS_Lib.Is_Directory (Dir_Name) then raise Directory_Error; end if; -- Remove directory and all files and directories that it may contain else Change_Dir (Dir_Name); Open (Working_Dir, "."); loop Read (Working_Dir, Str, Last); exit when Last = 0; if GNAT.OS_Lib.Is_Directory (Str (1 .. Last)) then if Str (1 .. Last) /= "." and then Str (1 .. Last) /= ".." then Remove_Dir (Str (1 .. Last), True); Remove_Dir (Str (1 .. Last)); end if; else GNAT.OS_Lib.Delete_File (Str (1 .. Last), Success); if not Success then Change_Dir (Current_Dir); raise Directory_Error; end if; end if; end loop; Change_Dir (Current_Dir); Close (Working_Dir); Remove_Dir (Dir_Name); end if; end Remove_Dir; end GNAT.Directory_Operations;