825 lines
25 KiB
Ada
825 lines
25 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- G P R E P --
|
|
-- --
|
|
-- B o d y --
|
|
-- --
|
|
-- Copyright (C) 2002-2011, 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 3, 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 COPYING3. If not, go to --
|
|
-- http://www.gnu.org/licenses for a complete copy of the license. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
with Csets;
|
|
with Err_Vars; use Err_Vars;
|
|
with Errutil;
|
|
with Namet; use Namet;
|
|
with Opt;
|
|
with Osint; use Osint;
|
|
with Output; use Output;
|
|
with Prep; use Prep;
|
|
with Scng;
|
|
with Sinput.C;
|
|
with Snames;
|
|
with Stringt; use Stringt;
|
|
with Switch; use Switch;
|
|
with Types; use Types;
|
|
|
|
with Ada.Text_IO; use Ada.Text_IO;
|
|
|
|
with GNAT.Case_Util; use GNAT.Case_Util;
|
|
with GNAT.Command_Line;
|
|
with GNAT.Directory_Operations; use GNAT.Directory_Operations;
|
|
|
|
with System.OS_Lib; use System.OS_Lib;
|
|
|
|
package body GPrep is
|
|
|
|
Copyright_Displayed : Boolean := False;
|
|
-- Used to prevent multiple displays of the copyright notice
|
|
|
|
------------------------
|
|
-- Argument Line Data --
|
|
------------------------
|
|
|
|
Unix_Line_Terminators : Boolean := False;
|
|
-- Set to True with option -T
|
|
|
|
type String_Array is array (Boolean) of String_Access;
|
|
Yes_No : constant String_Array :=
|
|
(False => new String'("YES"),
|
|
True => new String'("NO"));
|
|
|
|
Infile_Name : Name_Id := No_Name;
|
|
Outfile_Name : Name_Id := No_Name;
|
|
Deffile_Name : Name_Id := No_Name;
|
|
|
|
Output_Directory : Name_Id := No_Name;
|
|
-- Used when the specified output is an existing directory
|
|
|
|
Input_Directory : Name_Id := No_Name;
|
|
-- Used when the specified input and output are existing directories
|
|
|
|
Source_Ref_Pragma : Boolean := False;
|
|
-- Record command line options (set if -r switch set)
|
|
|
|
Text_Outfile : aliased Ada.Text_IO.File_Type;
|
|
Outfile : constant File_Access := Text_Outfile'Access;
|
|
|
|
File_Name_Buffer_Initial_Size : constant := 50;
|
|
File_Name_Buffer : String_Access :=
|
|
new String (1 .. File_Name_Buffer_Initial_Size);
|
|
-- A buffer to build output file names from input file names
|
|
|
|
-----------------
|
|
-- Subprograms --
|
|
-----------------
|
|
|
|
procedure Display_Copyright;
|
|
-- Display the copyright notice
|
|
|
|
procedure Post_Scan;
|
|
-- Null procedure, needed by instantiation of Scng below
|
|
|
|
package Scanner is new Scng
|
|
(Post_Scan,
|
|
Errutil.Error_Msg,
|
|
Errutil.Error_Msg_S,
|
|
Errutil.Error_Msg_SC,
|
|
Errutil.Error_Msg_SP,
|
|
Errutil.Style);
|
|
-- The scanner for the preprocessor
|
|
|
|
function Is_ASCII_Letter (C : Character) return Boolean;
|
|
-- True if C is in 'a' .. 'z' or in 'A' .. 'Z'
|
|
|
|
procedure Double_File_Name_Buffer;
|
|
-- Double the size of the file name buffer
|
|
|
|
procedure Preprocess_Infile_Name;
|
|
-- When the specified output is a directory, preprocess the infile name
|
|
-- for symbol substitution, to get the output file name.
|
|
|
|
procedure Process_Files;
|
|
-- Process the single input file or all the files in the directory tree
|
|
-- rooted at the input directory.
|
|
|
|
procedure Process_Command_Line_Symbol_Definition (S : String);
|
|
-- Process a -D switch on the command line
|
|
|
|
procedure Put_Char_To_Outfile (C : Character);
|
|
-- Output one character to the output file. Used to initialize the
|
|
-- preprocessor.
|
|
|
|
procedure New_EOL_To_Outfile;
|
|
-- Output a new line to the output file. Used to initialize the
|
|
-- preprocessor.
|
|
|
|
procedure Scan_Command_Line;
|
|
-- Scan the switches and the file names
|
|
|
|
procedure Usage;
|
|
-- Display the usage
|
|
|
|
-----------------------
|
|
-- Display_Copyright --
|
|
-----------------------
|
|
|
|
procedure Display_Copyright is
|
|
begin
|
|
if not Copyright_Displayed then
|
|
Display_Version ("GNAT Preprocessor", "1996");
|
|
Copyright_Displayed := True;
|
|
end if;
|
|
end Display_Copyright;
|
|
|
|
-----------------------------
|
|
-- Double_File_Name_Buffer --
|
|
-----------------------------
|
|
|
|
procedure Double_File_Name_Buffer is
|
|
New_Buffer : constant String_Access :=
|
|
new String (1 .. 2 * File_Name_Buffer'Length);
|
|
begin
|
|
New_Buffer (File_Name_Buffer'Range) := File_Name_Buffer.all;
|
|
Free (File_Name_Buffer);
|
|
File_Name_Buffer := New_Buffer;
|
|
end Double_File_Name_Buffer;
|
|
|
|
--------------
|
|
-- Gnatprep --
|
|
--------------
|
|
|
|
procedure Gnatprep is
|
|
begin
|
|
-- Do some initializations (order is important here!)
|
|
|
|
Csets.Initialize;
|
|
Snames.Initialize;
|
|
Stringt.Initialize;
|
|
Prep.Initialize;
|
|
|
|
-- Initialize the preprocessor
|
|
|
|
Prep.Setup_Hooks
|
|
(Error_Msg => Errutil.Error_Msg'Access,
|
|
Scan => Scanner.Scan'Access,
|
|
Set_Ignore_Errors => Errutil.Set_Ignore_Errors'Access,
|
|
Put_Char => Put_Char_To_Outfile'Access,
|
|
New_EOL => New_EOL_To_Outfile'Access);
|
|
|
|
-- Set the scanner characteristics for the preprocessor
|
|
|
|
Scanner.Set_Special_Character ('#');
|
|
Scanner.Set_Special_Character ('$');
|
|
Scanner.Set_End_Of_Line_As_Token (True);
|
|
|
|
-- Initialize the mapping table of symbols to values
|
|
|
|
Prep.Symbol_Table.Init (Prep.Mapping);
|
|
|
|
-- Parse the switches and arguments
|
|
|
|
Scan_Command_Line;
|
|
|
|
if Opt.Verbose_Mode then
|
|
Display_Copyright;
|
|
end if;
|
|
|
|
-- Test we had all the arguments needed
|
|
|
|
if Infile_Name = No_Name then
|
|
|
|
-- No input file specified, just output the usage and exit
|
|
|
|
Usage;
|
|
return;
|
|
|
|
elsif Outfile_Name = No_Name then
|
|
|
|
-- No output file specified, just output the usage and exit
|
|
|
|
Usage;
|
|
return;
|
|
end if;
|
|
|
|
-- If a pragma Source_File_Name, we need to keep line numbers. So, if
|
|
-- the deleted lines are not put as comment, we must output them as
|
|
-- blank lines.
|
|
|
|
if Source_Ref_Pragma and (not Opt.Comment_Deleted_Lines) then
|
|
Opt.Blank_Deleted_Lines := True;
|
|
end if;
|
|
|
|
-- If we have a definition file, parse it
|
|
|
|
if Deffile_Name /= No_Name then
|
|
declare
|
|
Deffile : Source_File_Index;
|
|
|
|
begin
|
|
Errutil.Initialize;
|
|
Deffile := Sinput.C.Load_File (Get_Name_String (Deffile_Name));
|
|
|
|
-- Set Main_Source_File to the definition file for the benefit of
|
|
-- Errutil.Finalize.
|
|
|
|
Sinput.Main_Source_File := Deffile;
|
|
|
|
if Deffile = No_Source_File then
|
|
Fail ("unable to find definition file """
|
|
& Get_Name_String (Deffile_Name)
|
|
& """");
|
|
end if;
|
|
|
|
Scanner.Initialize_Scanner (Deffile);
|
|
|
|
Prep.Parse_Def_File;
|
|
end;
|
|
end if;
|
|
|
|
-- If there are errors in the definition file, output them and exit
|
|
|
|
if Total_Errors_Detected > 0 then
|
|
Errutil.Finalize (Source_Type => "definition");
|
|
Fail ("errors in definition file """
|
|
& Get_Name_String (Deffile_Name)
|
|
& """");
|
|
end if;
|
|
|
|
-- If -s switch was specified, print a sorted list of symbol names and
|
|
-- values, if any.
|
|
|
|
if Opt.List_Preprocessing_Symbols then
|
|
Prep.List_Symbols (Foreword => "");
|
|
end if;
|
|
|
|
Output_Directory := No_Name;
|
|
Input_Directory := No_Name;
|
|
|
|
-- Check if the specified output is an existing directory
|
|
|
|
if Is_Directory (Get_Name_String (Outfile_Name)) then
|
|
Output_Directory := Outfile_Name;
|
|
|
|
-- As the output is an existing directory, check if the input too
|
|
-- is a directory.
|
|
|
|
if Is_Directory (Get_Name_String (Infile_Name)) then
|
|
Input_Directory := Infile_Name;
|
|
end if;
|
|
end if;
|
|
|
|
-- And process the single input or the files in the directory tree
|
|
-- rooted at the input directory.
|
|
|
|
Process_Files;
|
|
end Gnatprep;
|
|
|
|
---------------------
|
|
-- Is_ASCII_Letter --
|
|
---------------------
|
|
|
|
function Is_ASCII_Letter (C : Character) return Boolean is
|
|
begin
|
|
return C in 'A' .. 'Z' or else C in 'a' .. 'z';
|
|
end Is_ASCII_Letter;
|
|
|
|
------------------------
|
|
-- New_EOL_To_Outfile --
|
|
------------------------
|
|
|
|
procedure New_EOL_To_Outfile is
|
|
begin
|
|
New_Line (Outfile.all);
|
|
end New_EOL_To_Outfile;
|
|
|
|
---------------
|
|
-- Post_Scan --
|
|
---------------
|
|
|
|
procedure Post_Scan is
|
|
begin
|
|
null;
|
|
end Post_Scan;
|
|
|
|
----------------------------
|
|
-- Preprocess_Infile_Name --
|
|
----------------------------
|
|
|
|
procedure Preprocess_Infile_Name is
|
|
Len : Natural;
|
|
First : Positive;
|
|
Last : Natural;
|
|
Symbol : Name_Id;
|
|
Data : Symbol_Data;
|
|
|
|
begin
|
|
-- Initialize the buffer with the name of the input file
|
|
|
|
Get_Name_String (Infile_Name);
|
|
Len := Name_Len;
|
|
|
|
while File_Name_Buffer'Length < Len loop
|
|
Double_File_Name_Buffer;
|
|
end loop;
|
|
|
|
File_Name_Buffer (1 .. Len) := Name_Buffer (1 .. Len);
|
|
|
|
-- Look for possible symbols in the file name
|
|
|
|
First := 1;
|
|
while First < Len loop
|
|
|
|
-- A symbol starts with a dollar sign followed by a letter
|
|
|
|
if File_Name_Buffer (First) = '$' and then
|
|
Is_ASCII_Letter (File_Name_Buffer (First + 1))
|
|
then
|
|
Last := First + 1;
|
|
|
|
-- Find the last letter of the symbol
|
|
|
|
while Last < Len and then
|
|
Is_ASCII_Letter (File_Name_Buffer (Last + 1))
|
|
loop
|
|
Last := Last + 1;
|
|
end loop;
|
|
|
|
-- Get the symbol name id
|
|
|
|
Name_Len := Last - First;
|
|
Name_Buffer (1 .. Name_Len) :=
|
|
File_Name_Buffer (First + 1 .. Last);
|
|
To_Lower (Name_Buffer (1 .. Name_Len));
|
|
Symbol := Name_Find;
|
|
|
|
-- And look for this symbol name in the symbol table
|
|
|
|
for Index in 1 .. Symbol_Table.Last (Mapping) loop
|
|
Data := Mapping.Table (Index);
|
|
|
|
if Data.Symbol = Symbol then
|
|
|
|
-- We found the symbol. If its value is not a string,
|
|
-- replace the symbol in the file name with the value of
|
|
-- the symbol.
|
|
|
|
if not Data.Is_A_String then
|
|
String_To_Name_Buffer (Data.Value);
|
|
|
|
declare
|
|
Sym_Len : constant Positive := Last - First + 1;
|
|
Offset : constant Integer := Name_Len - Sym_Len;
|
|
New_Len : constant Natural := Len + Offset;
|
|
|
|
begin
|
|
while New_Len > File_Name_Buffer'Length loop
|
|
Double_File_Name_Buffer;
|
|
end loop;
|
|
|
|
File_Name_Buffer (Last + 1 + Offset .. New_Len) :=
|
|
File_Name_Buffer (Last + 1 .. Len);
|
|
Len := New_Len;
|
|
Last := Last + Offset;
|
|
File_Name_Buffer (First .. Last) :=
|
|
Name_Buffer (1 .. Name_Len);
|
|
end;
|
|
end if;
|
|
|
|
exit;
|
|
end if;
|
|
end loop;
|
|
|
|
-- Skip over the symbol name or its value: we are not checking
|
|
-- for another symbol name in the value.
|
|
|
|
First := Last + 1;
|
|
|
|
else
|
|
First := First + 1;
|
|
end if;
|
|
end loop;
|
|
|
|
-- We now have the output file name in the buffer. Get the output
|
|
-- path and put it in Outfile_Name.
|
|
|
|
Get_Name_String (Output_Directory);
|
|
Add_Char_To_Name_Buffer (Directory_Separator);
|
|
Add_Str_To_Name_Buffer (File_Name_Buffer (1 .. Len));
|
|
Outfile_Name := Name_Find;
|
|
end Preprocess_Infile_Name;
|
|
|
|
--------------------------------------------
|
|
-- Process_Command_Line_Symbol_Definition --
|
|
--------------------------------------------
|
|
|
|
procedure Process_Command_Line_Symbol_Definition (S : String) is
|
|
Data : Symbol_Data;
|
|
Symbol : Symbol_Id;
|
|
|
|
begin
|
|
-- Check the symbol definition and get the symbol and its value.
|
|
-- Fail if symbol definition is illegal.
|
|
|
|
Check_Command_Line_Symbol_Definition (S, Data);
|
|
|
|
Symbol := Index_Of (Data.Symbol);
|
|
|
|
-- If symbol does not already exist, create a new entry in the mapping
|
|
-- table.
|
|
|
|
if Symbol = No_Symbol then
|
|
Symbol_Table.Increment_Last (Mapping);
|
|
Symbol := Symbol_Table.Last (Mapping);
|
|
end if;
|
|
|
|
Mapping.Table (Symbol) := Data;
|
|
end Process_Command_Line_Symbol_Definition;
|
|
|
|
-------------------
|
|
-- Process_Files --
|
|
-------------------
|
|
|
|
procedure Process_Files is
|
|
|
|
procedure Process_One_File;
|
|
-- Process input file Infile_Name and put the result in file
|
|
-- Outfile_Name.
|
|
|
|
procedure Recursive_Process (In_Dir : String; Out_Dir : String);
|
|
-- Process recursively files in In_Dir. Results go to Out_Dir
|
|
|
|
----------------------
|
|
-- Process_One_File --
|
|
----------------------
|
|
|
|
procedure Process_One_File is
|
|
Infile : Source_File_Index;
|
|
|
|
Modified : Boolean;
|
|
pragma Warnings (Off, Modified);
|
|
|
|
begin
|
|
-- Create the output file (fails if this does not work)
|
|
|
|
begin
|
|
Create
|
|
(File => Text_Outfile,
|
|
Mode => Out_File,
|
|
Name => Get_Name_String (Outfile_Name),
|
|
Form => "Text_Translation=" &
|
|
Yes_No (Unix_Line_Terminators).all);
|
|
|
|
exception
|
|
when others =>
|
|
Fail
|
|
("unable to create output file """
|
|
& Get_Name_String (Outfile_Name)
|
|
& """");
|
|
end;
|
|
|
|
-- Load the input file
|
|
|
|
Infile := Sinput.C.Load_File (Get_Name_String (Infile_Name));
|
|
|
|
if Infile = No_Source_File then
|
|
Fail ("unable to find input file """
|
|
& Get_Name_String (Infile_Name)
|
|
& """");
|
|
end if;
|
|
|
|
-- Set Main_Source_File to the input file for the benefit of
|
|
-- Errutil.Finalize.
|
|
|
|
Sinput.Main_Source_File := Infile;
|
|
|
|
Scanner.Initialize_Scanner (Infile);
|
|
|
|
-- Output the pragma Source_Reference if asked to
|
|
|
|
if Source_Ref_Pragma then
|
|
Put_Line
|
|
(Outfile.all,
|
|
"pragma Source_Reference (1, """ &
|
|
Get_Name_String (Sinput.Full_File_Name (Infile)) & """);");
|
|
end if;
|
|
|
|
-- Preprocess the input file
|
|
|
|
Prep.Preprocess (Modified);
|
|
|
|
-- In verbose mode, if there is no error, report it
|
|
|
|
if Opt.Verbose_Mode and then Err_Vars.Total_Errors_Detected = 0 then
|
|
Errutil.Finalize (Source_Type => "input");
|
|
end if;
|
|
|
|
-- If we had some errors, delete the output file, and report them
|
|
|
|
if Err_Vars.Total_Errors_Detected > 0 then
|
|
if Outfile /= Standard_Output then
|
|
Delete (Text_Outfile);
|
|
end if;
|
|
|
|
Errutil.Finalize (Source_Type => "input");
|
|
|
|
OS_Exit (0);
|
|
|
|
-- Otherwise, close the output file, and we are done
|
|
|
|
elsif Outfile /= Standard_Output then
|
|
Close (Text_Outfile);
|
|
end if;
|
|
end Process_One_File;
|
|
|
|
-----------------------
|
|
-- Recursive_Process --
|
|
-----------------------
|
|
|
|
procedure Recursive_Process (In_Dir : String; Out_Dir : String) is
|
|
Dir_In : Dir_Type;
|
|
Name : String (1 .. 255);
|
|
Last : Natural;
|
|
In_Dir_Name : Name_Id;
|
|
Out_Dir_Name : Name_Id;
|
|
|
|
procedure Set_Directory_Names;
|
|
-- Establish or reestablish the current input and output directories
|
|
|
|
-------------------------
|
|
-- Set_Directory_Names --
|
|
-------------------------
|
|
|
|
procedure Set_Directory_Names is
|
|
begin
|
|
Input_Directory := In_Dir_Name;
|
|
Output_Directory := Out_Dir_Name;
|
|
end Set_Directory_Names;
|
|
|
|
-- Start of processing for Recursive_Process
|
|
|
|
begin
|
|
-- Open the current input directory
|
|
|
|
begin
|
|
Open (Dir_In, In_Dir);
|
|
|
|
exception
|
|
when Directory_Error =>
|
|
Fail ("could not read directory " & In_Dir);
|
|
end;
|
|
|
|
-- Set the new input and output directory names
|
|
|
|
Name_Len := In_Dir'Length;
|
|
Name_Buffer (1 .. Name_Len) := In_Dir;
|
|
In_Dir_Name := Name_Find;
|
|
Name_Len := Out_Dir'Length;
|
|
Name_Buffer (1 .. Name_Len) := Out_Dir;
|
|
Out_Dir_Name := Name_Find;
|
|
|
|
Set_Directory_Names;
|
|
|
|
-- Traverse the input directory
|
|
loop
|
|
Read (Dir_In, Name, Last);
|
|
exit when Last = 0;
|
|
|
|
if Name (1 .. Last) /= "." and then Name (1 .. Last) /= ".." then
|
|
declare
|
|
Input : constant String :=
|
|
In_Dir & Directory_Separator & Name (1 .. Last);
|
|
Output : constant String :=
|
|
Out_Dir & Directory_Separator & Name (1 .. Last);
|
|
|
|
begin
|
|
-- If input is an ordinary file, process it
|
|
|
|
if Is_Regular_File (Input) then
|
|
-- First get the output file name
|
|
|
|
Name_Len := Last;
|
|
Name_Buffer (1 .. Name_Len) := Name (1 .. Last);
|
|
Infile_Name := Name_Find;
|
|
Preprocess_Infile_Name;
|
|
|
|
-- Set the input file name and process the file
|
|
|
|
Name_Len := Input'Length;
|
|
Name_Buffer (1 .. Name_Len) := Input;
|
|
Infile_Name := Name_Find;
|
|
Process_One_File;
|
|
|
|
elsif Is_Directory (Input) then
|
|
-- Input is a directory. If the corresponding output
|
|
-- directory does not already exist, create it.
|
|
|
|
if not Is_Directory (Output) then
|
|
begin
|
|
Make_Dir (Dir_Name => Output);
|
|
|
|
exception
|
|
when Directory_Error =>
|
|
Fail ("could not create directory """
|
|
& Output
|
|
& """");
|
|
end;
|
|
end if;
|
|
|
|
-- And process this new input directory
|
|
|
|
Recursive_Process (Input, Output);
|
|
|
|
-- Reestablish the input and output directory names
|
|
-- that have been modified by the recursive call.
|
|
|
|
Set_Directory_Names;
|
|
end if;
|
|
end;
|
|
end if;
|
|
end loop;
|
|
end Recursive_Process;
|
|
|
|
-- Start of processing for Process_Files
|
|
|
|
begin
|
|
if Output_Directory = No_Name then
|
|
|
|
-- If the output is not a directory, fail if the input is
|
|
-- an existing directory, to avoid possible problems.
|
|
|
|
if Is_Directory (Get_Name_String (Infile_Name)) then
|
|
Fail ("input file """ & Get_Name_String (Infile_Name) &
|
|
""" is a directory");
|
|
end if;
|
|
|
|
-- Just process the single input file
|
|
|
|
Process_One_File;
|
|
|
|
elsif Input_Directory = No_Name then
|
|
|
|
-- Get the output file name from the input file name, and process
|
|
-- the single input file.
|
|
|
|
Preprocess_Infile_Name;
|
|
Process_One_File;
|
|
|
|
else
|
|
-- Recursively process files in the directory tree rooted at the
|
|
-- input directory.
|
|
|
|
Recursive_Process
|
|
(In_Dir => Get_Name_String (Input_Directory),
|
|
Out_Dir => Get_Name_String (Output_Directory));
|
|
end if;
|
|
end Process_Files;
|
|
|
|
-------------------------
|
|
-- Put_Char_To_Outfile --
|
|
-------------------------
|
|
|
|
procedure Put_Char_To_Outfile (C : Character) is
|
|
begin
|
|
Put (Outfile.all, C);
|
|
end Put_Char_To_Outfile;
|
|
|
|
-----------------------
|
|
-- Scan_Command_Line --
|
|
-----------------------
|
|
|
|
procedure Scan_Command_Line is
|
|
Switch : Character;
|
|
|
|
procedure Check_Version_And_Help is new Check_Version_And_Help_G (Usage);
|
|
|
|
-- Start of processing for Scan_Command_Line
|
|
|
|
begin
|
|
-- First check for --version or --help
|
|
|
|
Check_Version_And_Help ("GNATPREP", "1996");
|
|
|
|
-- Now scan the other switches
|
|
|
|
GNAT.Command_Line.Initialize_Option_Scan;
|
|
|
|
loop
|
|
begin
|
|
Switch := GNAT.Command_Line.Getopt ("D: b c C r s T u v");
|
|
|
|
case Switch is
|
|
|
|
when ASCII.NUL =>
|
|
exit;
|
|
|
|
when 'D' =>
|
|
Process_Command_Line_Symbol_Definition
|
|
(S => GNAT.Command_Line.Parameter);
|
|
|
|
when 'b' =>
|
|
Opt.Blank_Deleted_Lines := True;
|
|
|
|
when 'c' =>
|
|
Opt.Comment_Deleted_Lines := True;
|
|
|
|
when 'C' =>
|
|
Opt.Replace_In_Comments := True;
|
|
|
|
when 'r' =>
|
|
Source_Ref_Pragma := True;
|
|
|
|
when 's' =>
|
|
Opt.List_Preprocessing_Symbols := True;
|
|
|
|
when 'T' =>
|
|
Unix_Line_Terminators := True;
|
|
|
|
when 'u' =>
|
|
Opt.Undefined_Symbols_Are_False := True;
|
|
|
|
when 'v' =>
|
|
Opt.Verbose_Mode := True;
|
|
|
|
when others =>
|
|
Fail ("Invalid Switch: -" & Switch);
|
|
end case;
|
|
|
|
exception
|
|
when GNAT.Command_Line.Invalid_Switch =>
|
|
Write_Str ("Invalid Switch: -");
|
|
Write_Line (GNAT.Command_Line.Full_Switch);
|
|
Usage;
|
|
OS_Exit (1);
|
|
end;
|
|
end loop;
|
|
|
|
-- Get the file names
|
|
|
|
loop
|
|
declare
|
|
S : constant String := GNAT.Command_Line.Get_Argument;
|
|
|
|
begin
|
|
exit when S'Length = 0;
|
|
|
|
Name_Len := S'Length;
|
|
Name_Buffer (1 .. Name_Len) := S;
|
|
|
|
if Infile_Name = No_Name then
|
|
Infile_Name := Name_Find;
|
|
elsif Outfile_Name = No_Name then
|
|
Outfile_Name := Name_Find;
|
|
elsif Deffile_Name = No_Name then
|
|
Deffile_Name := Name_Find;
|
|
else
|
|
Fail ("too many arguments specified");
|
|
end if;
|
|
end;
|
|
end loop;
|
|
end Scan_Command_Line;
|
|
|
|
-----------
|
|
-- Usage --
|
|
-----------
|
|
|
|
procedure Usage is
|
|
begin
|
|
Display_Copyright;
|
|
Write_Line ("Usage: gnatprep [-bcrsuv] [-Dsymbol=value] " &
|
|
"infile outfile [deffile]");
|
|
Write_Eol;
|
|
Write_Line (" infile Name of the input file");
|
|
Write_Line (" outfile Name of the output file");
|
|
Write_Line (" deffile Name of the definition file");
|
|
Write_Eol;
|
|
Write_Line ("gnatprep switches:");
|
|
Display_Usage_Version_And_Help;
|
|
Write_Line (" -b Replace preprocessor lines by blank lines");
|
|
Write_Line (" -c Keep preprocessor lines as comments");
|
|
Write_Line (" -C Do symbol replacements within comments");
|
|
Write_Line (" -D Associate symbol with value");
|
|
Write_Line (" -r Generate Source_Reference pragma");
|
|
Write_Line (" -s Print a sorted list of symbol names and values");
|
|
Write_Line (" -T Use LF as line terminators");
|
|
Write_Line (" -u Treat undefined symbols as FALSE");
|
|
Write_Line (" -v Verbose mode");
|
|
Write_Eol;
|
|
end Usage;
|
|
|
|
end GPrep;
|