diff options
Diffstat (limited to 'gcc-4.9/gcc/ada/output.adb')
| -rw-r--r-- | gcc-4.9/gcc/ada/output.adb | 455 |
1 files changed, 455 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/ada/output.adb b/gcc-4.9/gcc/ada/output.adb new file mode 100644 index 000000000..0a739370a --- /dev/null +++ b/gcc-4.9/gcc/ada/output.adb @@ -0,0 +1,455 @@ +------------------------------------------------------------------------------ +-- -- +-- GNAT COMPILER COMPONENTS -- +-- -- +-- O U T P U T -- +-- -- +-- B o d y -- +-- -- +-- Copyright (C) 1992-2013, 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. -- +-- -- +-- As a special exception under Section 7 of GPL version 3, you are granted -- +-- additional permissions described in the GCC Runtime Library Exception, -- +-- version 3.1, as published by the Free Software Foundation. -- +-- -- +-- You should have received a copy of the GNU General Public License and -- +-- a copy of the GCC Runtime Library Exception along with this program; -- +-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- +-- <http://www.gnu.org/licenses/>. -- +-- -- +-- GNAT was originally developed by the GNAT team at New York University. -- +-- Extensive contributions were provided by Ada Core Technologies Inc. -- +-- -- +------------------------------------------------------------------------------ + +package body Output is + + Current_FD : File_Descriptor := Standout; + -- File descriptor for current output + + Special_Output_Proc : Output_Proc := null; + -- Record argument to last call to Set_Special_Output. If this is + -- non-null, then we are in special output mode. + + Indentation_Amount : constant Positive := 3; + -- Number of spaces to output for each indentation level + + Indentation_Limit : constant Positive := 40; + -- Indentation beyond this number of spaces wraps around + + pragma Assert (Indentation_Limit < Buffer_Max / 2); + -- Make sure this is substantially shorter than the line length + + Cur_Indentation : Natural := 0; + -- Number of spaces to indent each line + + ----------------------- + -- Local_Subprograms -- + ----------------------- + + procedure Flush_Buffer; + -- Flush buffer if non-empty and reset column counter + + --------------------------- + -- Cancel_Special_Output -- + --------------------------- + + procedure Cancel_Special_Output is + begin + Special_Output_Proc := null; + end Cancel_Special_Output; + + ------------ + -- Column -- + ------------ + + function Column return Pos is + begin + return Pos (Next_Col); + end Column; + + ---------------------- + -- Delete_Last_Char -- + ---------------------- + + procedure Delete_Last_Char is + begin + if Next_Col /= 1 then + Next_Col := Next_Col - 1; + end if; + end Delete_Last_Char; + + ------------------ + -- Flush_Buffer -- + ------------------ + + procedure Flush_Buffer is + Write_Error : exception; + -- Raised if Write fails + + ------------------ + -- Write_Buffer -- + ------------------ + + procedure Write_Buffer (Buf : String); + -- Write out Buf, either using Special_Output_Proc, or the normal way + -- using Write. Raise Write_Error if Write fails (presumably due to disk + -- full). Write_Error is not used in the case of Special_Output_Proc. + + procedure Write_Buffer (Buf : String) is + begin + -- If Special_Output_Proc has been set, then use it + + if Special_Output_Proc /= null then + Special_Output_Proc.all (Buf); + + -- If output is not set, then output to either standard output + -- or standard error. + + elsif Write (Current_FD, Buf'Address, Buf'Length) /= Buf'Length then + raise Write_Error; + + end if; + end Write_Buffer; + + Len : constant Natural := Next_Col - 1; + + -- Start of processing for Flush_Buffer + + begin + if Len /= 0 then + begin + -- If there's no indentation, or if the line is too long with + -- indentation, or if it's a blank line, just write the buffer. + + if Cur_Indentation = 0 + or else Cur_Indentation + Len > Buffer_Max + or else Buffer (1 .. Len) = (1 => ASCII.LF) + then + Write_Buffer (Buffer (1 .. Len)); + + -- Otherwise, construct a new buffer with preceding spaces, and + -- write that. + + else + declare + Indented_Buffer : constant String := + (1 .. Cur_Indentation => ' ') & + Buffer (1 .. Len); + begin + Write_Buffer (Indented_Buffer); + end; + end if; + + exception + when Write_Error => + + -- If there are errors with standard error just quit. Otherwise + -- set the output to standard error before reporting a failure + -- and quitting. + + if Current_FD /= Standerr then + Current_FD := Standerr; + Next_Col := 1; + Write_Line ("fatal error: disk full"); + end if; + + OS_Exit (2); + end; + + -- Buffer is now empty + + Next_Col := 1; + end if; + end Flush_Buffer; + + ------------------- + -- Ignore_Output -- + ------------------- + + procedure Ignore_Output (S : String) is + begin + null; + end Ignore_Output; + + ------------ + -- Indent -- + ------------ + + procedure Indent is + begin + -- The "mod" in the following assignment is to cause a wrap around in + -- the case where there is too much indentation. + + Cur_Indentation := + (Cur_Indentation + Indentation_Amount) mod Indentation_Limit; + end Indent; + + --------------- + -- Last_Char -- + --------------- + + function Last_Char return Character is + begin + if Next_Col /= 1 then + return Buffer (Next_Col - 1); + else + return ASCII.NUL; + end if; + end Last_Char; + + ------------- + -- Outdent -- + ------------- + + procedure Outdent is + begin + -- The "mod" here undoes the wrap around from Indent above + + Cur_Indentation := + (Cur_Indentation - Indentation_Amount) mod Indentation_Limit; + end Outdent; + + --------------------------- + -- Restore_Output_Buffer -- + --------------------------- + + procedure Restore_Output_Buffer (S : Saved_Output_Buffer) is + begin + Next_Col := S.Next_Col; + Cur_Indentation := S.Cur_Indentation; + Buffer (1 .. Next_Col - 1) := S.Buffer (1 .. Next_Col - 1); + end Restore_Output_Buffer; + + ------------------------ + -- Save_Output_Buffer -- + ------------------------ + + function Save_Output_Buffer return Saved_Output_Buffer is + S : Saved_Output_Buffer; + begin + S.Buffer (1 .. Next_Col - 1) := Buffer (1 .. Next_Col - 1); + S.Next_Col := Next_Col; + S.Cur_Indentation := Cur_Indentation; + Next_Col := 1; + Cur_Indentation := 0; + return S; + end Save_Output_Buffer; + + ------------------------ + -- Set_Special_Output -- + ------------------------ + + procedure Set_Special_Output (P : Output_Proc) is + begin + Special_Output_Proc := P; + end Set_Special_Output; + + ---------------- + -- Set_Output -- + ---------------- + + procedure Set_Output (FD : File_Descriptor) is + begin + if Special_Output_Proc = null then + Flush_Buffer; + end if; + + Current_FD := FD; + end Set_Output; + + ------------------------ + -- Set_Standard_Error -- + ------------------------ + + procedure Set_Standard_Error is + begin + Set_Output (Standerr); + end Set_Standard_Error; + + ------------------------- + -- Set_Standard_Output -- + ------------------------- + + procedure Set_Standard_Output is + begin + Set_Output (Standout); + end Set_Standard_Output; + + ------- + -- w -- + ------- + + procedure w (C : Character) is + begin + Write_Char ('''); + Write_Char (C); + Write_Char ('''); + Write_Eol; + end w; + + procedure w (S : String) is + begin + Write_Str (S); + Write_Eol; + end w; + + procedure w (V : Int) is + begin + Write_Int (V); + Write_Eol; + end w; + + procedure w (B : Boolean) is + begin + if B then + w ("True"); + else + w ("False"); + end if; + end w; + + procedure w (L : String; C : Character) is + begin + Write_Str (L); + Write_Char (' '); + w (C); + end w; + + procedure w (L : String; S : String) is + begin + Write_Str (L); + Write_Char (' '); + w (S); + end w; + + procedure w (L : String; V : Int) is + begin + Write_Str (L); + Write_Char (' '); + w (V); + end w; + + procedure w (L : String; B : Boolean) is + begin + Write_Str (L); + Write_Char (' '); + w (B); + end w; + + ---------------- + -- Write_Char -- + ---------------- + + procedure Write_Char (C : Character) is + begin + if Next_Col = Buffer'Length then + Write_Eol; + end if; + + if C = ASCII.LF then + Write_Eol; + else + Buffer (Next_Col) := C; + Next_Col := Next_Col + 1; + end if; + end Write_Char; + + --------------- + -- Write_Eol -- + --------------- + + procedure Write_Eol is + begin + -- Remove any trailing spaces + + while Next_Col > 1 and then Buffer (Next_Col - 1) = ' ' loop + Next_Col := Next_Col - 1; + end loop; + + Buffer (Next_Col) := ASCII.LF; + Next_Col := Next_Col + 1; + Flush_Buffer; + end Write_Eol; + + --------------------------- + -- Write_Eol_Keep_Blanks -- + --------------------------- + + procedure Write_Eol_Keep_Blanks is + begin + Buffer (Next_Col) := ASCII.LF; + Next_Col := Next_Col + 1; + Flush_Buffer; + end Write_Eol_Keep_Blanks; + + ---------------------- + -- Write_Erase_Char -- + ---------------------- + + procedure Write_Erase_Char (C : Character) is + begin + if Next_Col /= 1 and then Buffer (Next_Col - 1) = C then + Next_Col := Next_Col - 1; + end if; + end Write_Erase_Char; + + --------------- + -- Write_Int -- + --------------- + + procedure Write_Int (Val : Int) is + begin + if Val < 0 then + Write_Char ('-'); + Write_Int (-Val); + + else + if Val > 9 then + Write_Int (Val / 10); + end if; + + Write_Char (Character'Val ((Val mod 10) + Character'Pos ('0'))); + end if; + end Write_Int; + + ---------------- + -- Write_Line -- + ---------------- + + procedure Write_Line (S : String) is + begin + Write_Str (S); + Write_Eol; + end Write_Line; + + ------------------ + -- Write_Spaces -- + ------------------ + + procedure Write_Spaces (N : Nat) is + begin + for J in 1 .. N loop + Write_Char (' '); + end loop; + end Write_Spaces; + + --------------- + -- Write_Str -- + --------------- + + procedure Write_Str (S : String) is + begin + for J in S'Range loop + Write_Char (S (J)); + end loop; + end Write_Str; + +end Output; |