1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 2002-2007, Free Software Foundation, Inc. --
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 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
25 ------------------------------------------------------------------------------
28 with Err_Vars; use Err_Vars;
30 with Namet; use Namet;
32 with Osint; use Osint;
33 with Output; use Output;
38 with Stringt; use Stringt;
39 with Switch; use Switch;
40 with Types; use Types;
42 with Ada.Text_IO; use Ada.Text_IO;
44 with GNAT.Case_Util; use GNAT.Case_Util;
45 with GNAT.Command_Line;
46 with GNAT.Directory_Operations; use GNAT.Directory_Operations;
48 with System.OS_Lib; use System.OS_Lib;
52 Copyright_Displayed : Boolean := False;
53 -- Used to prevent multiple displays of the copyright notice
55 ------------------------
56 -- Argument Line Data --
57 ------------------------
59 Infile_Name : Name_Id := No_Name;
60 Outfile_Name : Name_Id := No_Name;
61 Deffile_Name : Name_Id := No_Name;
63 Output_Directory : Name_Id := No_Name;
64 -- Used when the specified output is an existing directory
66 Input_Directory : Name_Id := No_Name;
67 -- Used when the specified input and output are existing directories
69 Source_Ref_Pragma : Boolean := False;
70 -- Record command line options (set if -r switch set)
72 Text_Outfile : aliased Ada.Text_IO.File_Type;
73 Outfile : constant File_Access := Text_Outfile'Access;
75 File_Name_Buffer_Initial_Size : constant := 50;
76 File_Name_Buffer : String_Access :=
77 new String (1 .. File_Name_Buffer_Initial_Size);
78 -- A buffer to build output file names from input file names
84 procedure Display_Copyright;
85 -- Display the copyright notice
87 procedure Obsolescent_Check (S : Source_Ptr);
88 -- Null procedure, needed by instantiation of Scng below
91 -- Null procedure, needed by instantiation of Scng below
93 package Scanner is new Scng
101 -- The scanner for the preprocessor
103 function Is_ASCII_Letter (C : Character) return Boolean;
104 -- True if C is in 'a' .. 'z' or in 'A' .. 'Z'
106 procedure Double_File_Name_Buffer;
107 -- Double the size of the file name buffer
109 procedure Preprocess_Infile_Name;
110 -- When the specified output is a directory, preprocess the infile name
111 -- for symbol substitution, to get the output file name.
113 procedure Process_Files;
114 -- Process the single input file or all the files in the directory tree
115 -- rooted at the input directory.
117 procedure Process_Command_Line_Symbol_Definition (S : String);
118 -- Process a -D switch on the command line
120 procedure Put_Char_To_Outfile (C : Character);
121 -- Output one character to the output file. Used to initialize the
124 procedure New_EOL_To_Outfile;
125 -- Output a new line to the output file. Used to initialize the
128 procedure Scan_Command_Line;
129 -- Scan the switches and the file names
134 -----------------------
135 -- Display_Copyright --
136 -----------------------
138 procedure Display_Copyright is
140 if not Copyright_Displayed then
141 Display_Version ("GNAT Preprocessor", "1996");
142 Copyright_Displayed := True;
144 end Display_Copyright;
146 -----------------------------
147 -- Double_File_Name_Buffer --
148 -----------------------------
150 procedure Double_File_Name_Buffer is
151 New_Buffer : constant String_Access :=
152 new String (1 .. 2 * File_Name_Buffer'Length);
154 New_Buffer (File_Name_Buffer'Range) := File_Name_Buffer.all;
155 Free (File_Name_Buffer);
156 File_Name_Buffer := New_Buffer;
157 end Double_File_Name_Buffer;
163 procedure Gnatprep is
165 -- Do some initializations (order is important here!)
172 -- Initialize the preprocessor
175 (Error_Msg => Errutil.Error_Msg'Access,
176 Scan => Scanner.Scan'Access,
177 Set_Ignore_Errors => Errutil.Set_Ignore_Errors'Access,
178 Put_Char => Put_Char_To_Outfile'Access,
179 New_EOL => New_EOL_To_Outfile'Access);
181 -- Set the scanner characteristics for the preprocessor
183 Scanner.Set_Special_Character ('#');
184 Scanner.Set_Special_Character ('$');
185 Scanner.Set_End_Of_Line_As_Token (True);
187 -- Initialize the mapping table of symbols to values
189 Prep.Symbol_Table.Init (Prep.Mapping);
191 -- Parse the switches and arguments
195 if Opt.Verbose_Mode then
199 -- Test we had all the arguments needed
201 if Infile_Name = No_Name then
203 -- No input file specified, just output the usage and exit
208 elsif Outfile_Name = No_Name then
210 -- No output file specified, just output the usage and exit
216 -- If a pragma Source_File_Name, we need to keep line numbers. So, if
217 -- the deleted lines are not put as comment, we must output them as
220 if Source_Ref_Pragma and (not Opt.Comment_Deleted_Lines) then
221 Opt.Blank_Deleted_Lines := True;
224 -- If we have a definition file, parse it
226 if Deffile_Name /= No_Name then
228 Deffile : Source_File_Index;
232 Deffile := Sinput.C.Load_File (Get_Name_String (Deffile_Name));
234 -- Set Main_Source_File to the definition file for the benefit of
237 Sinput.Main_Source_File := Deffile;
239 if Deffile = No_Source_File then
240 Fail ("unable to find definition file """,
241 Get_Name_String (Deffile_Name),
245 Scanner.Initialize_Scanner (Deffile);
251 -- If there are errors in the definition file, output them and exit
253 if Total_Errors_Detected > 0 then
254 Errutil.Finalize (Source_Type => "definition");
255 Fail ("errors in definition file """,
256 Get_Name_String (Deffile_Name), """");
259 -- If -s switch was specified, print a sorted list of symbol names and
262 if Opt.List_Preprocessing_Symbols then
263 Prep.List_Symbols (Foreword => "");
266 Output_Directory := No_Name;
267 Input_Directory := No_Name;
269 -- Check if the specified output is an existing directory
271 if Is_Directory (Get_Name_String (Outfile_Name)) then
272 Output_Directory := Outfile_Name;
274 -- As the output is an existing directory, check if the input too
277 if Is_Directory (Get_Name_String (Infile_Name)) then
278 Input_Directory := Infile_Name;
282 -- And process the single input or the files in the directory tree
283 -- rooted at the input directory.
288 ---------------------
289 -- Is_ASCII_Letter --
290 ---------------------
292 function Is_ASCII_Letter (C : Character) return Boolean is
294 return C in 'A' .. 'Z' or else C in 'a' .. 'z';
297 ------------------------
298 -- New_EOL_To_Outfile --
299 ------------------------
301 procedure New_EOL_To_Outfile is
303 New_Line (Outfile.all);
304 end New_EOL_To_Outfile;
306 -----------------------
307 -- Obsolescent_Check --
308 -----------------------
310 procedure Obsolescent_Check (S : Source_Ptr) is
311 pragma Warnings (Off, S);
314 end Obsolescent_Check;
320 procedure Post_Scan is
325 ----------------------------
326 -- Preprocess_Infile_Name --
327 ----------------------------
329 procedure Preprocess_Infile_Name is
337 -- Initialize the buffer with the name of the input file
339 Get_Name_String (Infile_Name);
342 while File_Name_Buffer'Length < Len loop
343 Double_File_Name_Buffer;
346 File_Name_Buffer (1 .. Len) := Name_Buffer (1 .. Len);
348 -- Look for possible symbols in the file name
351 while First < Len loop
353 -- A symbol starts with a dollar sign followed by a letter
355 if File_Name_Buffer (First) = '$' and then
356 Is_ASCII_Letter (File_Name_Buffer (First + 1))
360 -- Find the last letter of the symbol
362 while Last < Len and then
363 Is_ASCII_Letter (File_Name_Buffer (Last + 1))
368 -- Get the symbol name id
370 Name_Len := Last - First;
371 Name_Buffer (1 .. Name_Len) :=
372 File_Name_Buffer (First + 1 .. Last);
373 To_Lower (Name_Buffer (1 .. Name_Len));
376 -- And look for this symbol name in the symbol table
378 for Index in 1 .. Symbol_Table.Last (Mapping) loop
379 Data := Mapping.Table (Index);
381 if Data.Symbol = Symbol then
383 -- We found the symbol. If its value is not a string,
384 -- replace the symbol in the file name with the value of
387 if not Data.Is_A_String then
388 String_To_Name_Buffer (Data.Value);
391 Sym_Len : constant Positive := Last - First + 1;
392 Offset : constant Integer := Name_Len - Sym_Len;
393 New_Len : constant Natural := Len + Offset;
396 while New_Len > File_Name_Buffer'Length loop
397 Double_File_Name_Buffer;
400 File_Name_Buffer (Last + 1 + Offset .. New_Len) :=
401 File_Name_Buffer (Last + 1 .. Len);
403 Last := Last + Offset;
404 File_Name_Buffer (First .. Last) :=
405 Name_Buffer (1 .. Name_Len);
413 -- Skip over the symbol name or its value: we are not checking
414 -- for another symbol name in the value.
423 -- We now have the output file name in the buffer. Get the output
424 -- path and put it in Outfile_Name.
426 Get_Name_String (Output_Directory);
427 Add_Char_To_Name_Buffer (Directory_Separator);
428 Add_Str_To_Name_Buffer (File_Name_Buffer (1 .. Len));
429 Outfile_Name := Name_Find;
430 end Preprocess_Infile_Name;
432 --------------------------------------------
433 -- Process_Command_Line_Symbol_Definition --
434 --------------------------------------------
436 procedure Process_Command_Line_Symbol_Definition (S : String) is
441 -- Check the symbol definition and get the symbol and its value.
442 -- Fail if symbol definition is illegal.
444 Check_Command_Line_Symbol_Definition (S, Data);
446 Symbol := Index_Of (Data.Symbol);
448 -- If symbol does not alrady exist, create a new entry in the mapping
451 if Symbol = No_Symbol then
452 Symbol_Table.Increment_Last (Mapping);
453 Symbol := Symbol_Table.Last (Mapping);
456 Mapping.Table (Symbol) := Data;
457 end Process_Command_Line_Symbol_Definition;
463 procedure Process_Files is
465 procedure Process_One_File;
466 -- Process input file Infile_Name and put the result in file
469 procedure Recursive_Process (In_Dir : String; Out_Dir : String);
470 -- Process recursively files in In_Dir. Results go to Out_Dir
472 ----------------------
473 -- Process_One_File --
474 ----------------------
476 procedure Process_One_File is
477 Infile : Source_File_Index;
480 -- Create the output file (fails if this does not work)
483 Create (Text_Outfile, Out_File, Get_Name_String (Outfile_Name));
488 ("unable to create output file """,
489 Get_Name_String (Outfile_Name), """");
492 -- Load the input file
494 Infile := Sinput.C.Load_File (Get_Name_String (Infile_Name));
496 if Infile = No_Source_File then
497 Fail ("unable to find input file """,
498 Get_Name_String (Infile_Name), """");
501 -- Set Main_Source_File to the input file for the benefit of
504 Sinput.Main_Source_File := Infile;
506 Scanner.Initialize_Scanner (Infile);
508 -- Output the pragma Source_Reference if asked to
510 if Source_Ref_Pragma then
513 "pragma Source_Reference (1, """ &
514 Get_Name_String (Sinput.Full_File_Name (Infile)) & """);");
517 -- Preprocess the input file
521 -- In verbose mode, if there is no error, report it
523 if Opt.Verbose_Mode and then Err_Vars.Total_Errors_Detected = 0 then
524 Errutil.Finalize (Source_Type => "input");
527 -- If we had some errors, delete the output file, and report them
529 if Err_Vars.Total_Errors_Detected > 0 then
530 if Outfile /= Standard_Output then
531 Delete (Text_Outfile);
534 Errutil.Finalize (Source_Type => "input");
538 -- Otherwise, close the output file, and we are done
540 elsif Outfile /= Standard_Output then
541 Close (Text_Outfile);
543 end Process_One_File;
545 -----------------------
546 -- Recursive_Process --
547 -----------------------
549 procedure Recursive_Process (In_Dir : String; Out_Dir : String) is
551 Name : String (1 .. 255);
553 In_Dir_Name : Name_Id;
554 Out_Dir_Name : Name_Id;
556 procedure Set_Directory_Names;
557 -- Establish or reestablish the current input and output directories
559 -------------------------
560 -- Set_Directory_Names --
561 -------------------------
563 procedure Set_Directory_Names is
565 Input_Directory := In_Dir_Name;
566 Output_Directory := Out_Dir_Name;
567 end Set_Directory_Names;
569 -- Start of processing for Recursive_Process
572 -- Open the current input directory
575 Open (Dir_In, In_Dir);
578 when Directory_Error =>
579 Fail ("could not read directory " & In_Dir);
582 -- Set the new input and output directory names
584 Name_Len := In_Dir'Length;
585 Name_Buffer (1 .. Name_Len) := In_Dir;
586 In_Dir_Name := Name_Find;
587 Name_Len := Out_Dir'Length;
588 Name_Buffer (1 .. Name_Len) := Out_Dir;
589 Out_Dir_Name := Name_Find;
593 -- Traverse the input directory
595 Read (Dir_In, Name, Last);
598 if Name (1 .. Last) /= "." and then Name (1 .. Last) /= ".." then
600 Input : constant String :=
601 In_Dir & Directory_Separator & Name (1 .. Last);
602 Output : constant String :=
603 Out_Dir & Directory_Separator & Name (1 .. Last);
606 -- If input is an ordinary file, process it
608 if Is_Regular_File (Input) then
609 -- First get the output file name
612 Name_Buffer (1 .. Name_Len) := Name (1 .. Last);
613 Infile_Name := Name_Find;
614 Preprocess_Infile_Name;
616 -- Set the input file name and process the file
618 Name_Len := Input'Length;
619 Name_Buffer (1 .. Name_Len) := Input;
620 Infile_Name := Name_Find;
623 elsif Is_Directory (Input) then
624 -- Input is a directory. If the corresponding output
625 -- directory does not already exist, create it.
627 if not Is_Directory (Output) then
629 Make_Dir (Dir_Name => Output);
632 when Directory_Error =>
633 Fail ("could not create directory """,
638 -- And process this new input directory
640 Recursive_Process (Input, Output);
642 -- Reestablish the input and output directory names
643 -- that have been modified by the recursive call.
650 end Recursive_Process;
652 -- Start of processing for Process_Files
655 if Output_Directory = No_Name then
657 -- If the output is not a directory, fail if the input is
658 -- an existing directory, to avoid possible problems.
660 if Is_Directory (Get_Name_String (Infile_Name)) then
661 Fail ("input file """ & Get_Name_String (Infile_Name) &
662 """ is a directory");
665 -- Just process the single input file
669 elsif Input_Directory = No_Name then
671 -- Get the output file name from the input file name, and process
672 -- the single input file.
674 Preprocess_Infile_Name;
678 -- Recursively process files in the directory tree rooted at the
682 (In_Dir => Get_Name_String (Input_Directory),
683 Out_Dir => Get_Name_String (Output_Directory));
687 -------------------------
688 -- Put_Char_To_Outfile --
689 -------------------------
691 procedure Put_Char_To_Outfile (C : Character) is
693 Put (Outfile.all, C);
694 end Put_Char_To_Outfile;
696 -----------------------
697 -- Scan_Command_Line --
698 -----------------------
700 procedure Scan_Command_Line is
704 -- First check for --version or --help
706 Check_Version_And_Help ("GNATPREP", "1996", Usage'Access);
708 -- Now scan the other switches
710 GNAT.Command_Line.Initialize_Option_Scan;
714 Switch := GNAT.Command_Line.Getopt ("D: b c C r s u v");
722 Process_Command_Line_Symbol_Definition
723 (S => GNAT.Command_Line.Parameter);
726 Opt.Blank_Deleted_Lines := True;
729 Opt.Comment_Deleted_Lines := True;
732 Opt.Replace_In_Comments := True;
735 Source_Ref_Pragma := True;
738 Opt.List_Preprocessing_Symbols := True;
741 Opt.Undefined_Symbols_Are_False := True;
744 Opt.Verbose_Mode := True;
747 Fail ("Invalid Switch: -" & Switch);
751 when GNAT.Command_Line.Invalid_Switch =>
752 Write_Str ("Invalid Switch: -");
753 Write_Line (GNAT.Command_Line.Full_Switch);
759 -- Get the file names
763 S : constant String := GNAT.Command_Line.Get_Argument;
766 exit when S'Length = 0;
768 Name_Len := S'Length;
769 Name_Buffer (1 .. Name_Len) := S;
771 if Infile_Name = No_Name then
772 Infile_Name := Name_Find;
773 elsif Outfile_Name = No_Name then
774 Outfile_Name := Name_Find;
775 elsif Deffile_Name = No_Name then
776 Deffile_Name := Name_Find;
778 Fail ("too many arguments specifed");
782 end Scan_Command_Line;
791 Write_Line ("Usage: gnatprep [-bcrsuv] [-Dsymbol=value] " &
792 "infile outfile [deffile]");
794 Write_Line (" infile Name of the input file");
795 Write_Line (" outfile Name of the output file");
796 Write_Line (" deffile Name of the definition file");
798 Write_Line ("gnatprep switches:");
799 Write_Line (" -b Replace preprocessor lines by blank lines");
800 Write_Line (" -c Keep preprocessor lines as comments");
801 Write_Line (" -C Do symbol replacements within comments");
802 Write_Line (" -D Associate symbol with value");
803 Write_Line (" -r Generate Source_Reference pragma");
804 Write_Line (" -s Print a sorted list of symbol names and values");
805 Write_Line (" -u Treat undefined symbols as FALSE");
806 Write_Line (" -v Verbose mode");