URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [output.adb] - Blame information for rev 303

Go to most recent revision | Details | Compare with Previous | View Log


------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                               O U T P U T                                --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2009, 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.      --
--                                                                          --
------------------------------------------------------------------------------
 
with System.OS_Lib; use System.OS_Lib;
 
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;
 
   ------------------
   -- 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;
 
   -------------
   -- 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_Standard_Error --
   ------------------------
 
   procedure Set_Standard_Error is
   begin
      if Special_Output_Proc = null then
         Flush_Buffer;
      end if;
 
      Current_FD := Standerr;
   end Set_Standard_Error;
 
   -------------------------
   -- Set_Standard_Output --
   -------------------------
 
   procedure Set_Standard_Output is
   begin
      if Special_Output_Proc = null then
         Flush_Buffer;
      end if;
 
      Current_FD := 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 space
 
      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;

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [output.adb] - Blame information for rev 303

Line No.	Rev	Author	Line
1	281	jeremybenn	`------------------------------------------------------------------------------`
2			`-- --`
3			`-- GNAT COMPILER COMPONENTS --`
4			`-- --`
5			`-- O U T P U T --`
6			`-- --`
7			`-- B o d y --`
8			`-- --`
9			`-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --`
10			`-- --`
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 3, 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. --`
17			`-- --`
18			`-- As a special exception under Section 7 of GPL version 3, you are granted --`
19			`-- additional permissions described in the GCC Runtime Library Exception, --`
20			`-- version 3.1, as published by the Free Software Foundation. --`
21			`-- --`
22			`-- You should have received a copy of the GNU General Public License and --`
23			`-- a copy of the GCC Runtime Library Exception along with this program; --`
24			`-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --`
25			`-- <http://www.gnu.org/licenses/>. --`
26			`-- --`
27			`-- GNAT was originally developed by the GNAT team at New York University. --`
28			`-- Extensive contributions were provided by Ada Core Technologies Inc. --`
29			`-- --`
30			`------------------------------------------------------------------------------`
31
32			`with System.OS_Lib; use System.OS_Lib;`
33
34			`package body Output is`
35
36			`Current_FD : File_Descriptor := Standout;`
37			`-- File descriptor for current output`
38
39			`Special_Output_Proc : Output_Proc := null;`
40			`-- Record argument to last call to Set_Special_Output. If this is`
41			`-- non-null, then we are in special output mode.`
42
43			`Indentation_Amount : constant Positive := 3;`
44			`-- Number of spaces to output for each indentation level`
45
46			`Indentation_Limit : constant Positive := 40;`
47			`-- Indentation beyond this number of spaces wraps around`
48
49			`pragma Assert (Indentation_Limit < Buffer_Max / 2);`
50			`-- Make sure this is substantially shorter than the line length`
51
52			`Cur_Indentation : Natural := 0;`
53			`-- Number of spaces to indent each line`
54
55			`-----------------------`
56			`-- Local_Subprograms --`
57			`-----------------------`
58
59			`procedure Flush_Buffer;`
60			`-- Flush buffer if non-empty and reset column counter`
61
62			`---------------------------`
63			`-- Cancel_Special_Output --`
64			`---------------------------`
65
66			`procedure Cancel_Special_Output is`
67			`begin`
68			`Special_Output_Proc := null;`
69			`end Cancel_Special_Output;`
70
71			`------------`
72			`-- Column --`
73			`------------`
74
75			`function Column return Pos is`
76			`begin`
77			`return Pos (Next_Col);`
78			`end Column;`
79
80			`------------------`
81			`-- Flush_Buffer --`
82			`------------------`
83
84			`procedure Flush_Buffer is`
85			`Write_Error : exception;`
86			`-- Raised if Write fails`
87
88			`------------------`
89			`-- Write_Buffer --`
90			`------------------`
91
92			`procedure Write_Buffer (Buf : String);`
93			`-- Write out Buf, either using Special_Output_Proc, or the normal way`
94			`-- using Write. Raise Write_Error if Write fails (presumably due to disk`
95			`-- full). Write_Error is not used in the case of Special_Output_Proc.`
96
97			`procedure Write_Buffer (Buf : String) is`
98			`begin`
99			`-- If Special_Output_Proc has been set, then use it`
100
101			`if Special_Output_Proc /= null then`
102			`Special_Output_Proc.all (Buf);`
103
104			`-- If output is not set, then output to either standard output`
105			`-- or standard error.`
106
107			`elsif Write (Current_FD, Buf'Address, Buf'Length) /= Buf'Length then`
108			`raise Write_Error;`
109
110			`end if;`
111			`end Write_Buffer;`
112
113			`Len : constant Natural := Next_Col - 1;`
114
115			`-- Start of processing for Flush_Buffer`
116
117			`begin`
118			`if Len /= 0 then`
119			`begin`
120			`-- If there's no indentation, or if the line is too long with`
121			`-- indentation, or if it's a blank line, just write the buffer.`
122
123			`if Cur_Indentation = 0`
124			`or else Cur_Indentation + Len > Buffer_Max`
125			`or else Buffer (1 .. Len) = (1 => ASCII.LF)`
126			`then`
127			`Write_Buffer (Buffer (1 .. Len));`
128
129			`-- Otherwise, construct a new buffer with preceding spaces, and`
130			`-- write that.`
131
132			`else`
133			`declare`
134			`Indented_Buffer : constant String`
135			`:= (1 .. Cur_Indentation => ' ') & Buffer (1 .. Len);`
136			`begin`
137			`Write_Buffer (Indented_Buffer);`
138			`end;`
139			`end if;`
140
141			`exception`
142			`when Write_Error =>`
143			`-- If there are errors with standard error, just quit.`
144			`-- Otherwise, set the output to standard error before reporting`
145			`-- a failure and quitting.`
146
147			`if Current_FD /= Standerr then`
148			`Current_FD := Standerr;`
149			`Next_Col := 1;`
150			`Write_Line ("fatal error: disk full");`
151			`end if;`
152
153			`OS_Exit (2);`
154			`end;`
155
156			`-- Buffer is now empty`
157
158			`Next_Col := 1;`
159			`end if;`
160			`end Flush_Buffer;`
161
162			`-------------------`
163			`-- Ignore_Output --`
164			`-------------------`
165
166			`procedure Ignore_Output (S : String) is`
167			`begin`
168			`null;`
169			`end Ignore_Output;`
170
171			`------------`
172			`-- Indent --`
173			`------------`
174
175			`procedure Indent is`
176			`begin`
177			`-- The "mod" in the following assignment is to cause a wrap around in`
178			`-- the case where there is too much indentation.`
179
180			`Cur_Indentation :=`
181			`(Cur_Indentation + Indentation_Amount) mod Indentation_Limit;`
182			`end Indent;`
183
184			`-------------`
185			`-- Outdent --`
186			`-------------`
187
188			`procedure Outdent is`
189			`begin`
190			`-- The "mod" here undoes the wrap around from Indent above`
191
192			`Cur_Indentation :=`
193			`(Cur_Indentation - Indentation_Amount) mod Indentation_Limit;`
194			`end Outdent;`
195
196			`---------------------------`
197			`-- Restore_Output_Buffer --`
198			`---------------------------`
199
200			`procedure Restore_Output_Buffer (S : Saved_Output_Buffer) is`
201			`begin`
202			`Next_Col := S.Next_Col;`
203			`Cur_Indentation := S.Cur_Indentation;`
204			`Buffer (1 .. Next_Col - 1) := S.Buffer (1 .. Next_Col - 1);`
205			`end Restore_Output_Buffer;`
206
207			`------------------------`
208			`-- Save_Output_Buffer --`
209			`------------------------`
210
211			`function Save_Output_Buffer return Saved_Output_Buffer is`
212			`S : Saved_Output_Buffer;`
213			`begin`
214			`S.Buffer (1 .. Next_Col - 1) := Buffer (1 .. Next_Col - 1);`
215			`S.Next_Col := Next_Col;`
216			`S.Cur_Indentation := Cur_Indentation;`
217			`Next_Col := 1;`
218			`Cur_Indentation := 0;`
219			`return S;`
220			`end Save_Output_Buffer;`
221
222			`------------------------`
223			`-- Set_Special_Output --`
224			`------------------------`
225
226			`procedure Set_Special_Output (P : Output_Proc) is`
227			`begin`
228			`Special_Output_Proc := P;`
229			`end Set_Special_Output;`
230
231			`------------------------`
232			`-- Set_Standard_Error --`
233			`------------------------`
234
235			`procedure Set_Standard_Error is`
236			`begin`
237			`if Special_Output_Proc = null then`
238			`Flush_Buffer;`
239			`end if;`
240
241			`Current_FD := Standerr;`
242			`end Set_Standard_Error;`
243
244			`-------------------------`
245			`-- Set_Standard_Output --`
246			`-------------------------`
247
248			`procedure Set_Standard_Output is`
249			`begin`
250			`if Special_Output_Proc = null then`
251			`Flush_Buffer;`
252			`end if;`
253
254			`Current_FD := Standout;`
255			`end Set_Standard_Output;`
256
257			`-------`
258			`-- w --`
259			`-------`
260
261			`procedure w (C : Character) is`
262			`begin`
263			`Write_Char (''');`
264			`Write_Char (C);`
265			`Write_Char (''');`
266			`Write_Eol;`
267			`end w;`
268
269			`procedure w (S : String) is`
270			`begin`
271			`Write_Str (S);`
272			`Write_Eol;`
273			`end w;`
274
275			`procedure w (V : Int) is`
276			`begin`
277			`Write_Int (V);`
278			`Write_Eol;`
279			`end w;`
280
281			`procedure w (B : Boolean) is`
282			`begin`
283			`if B then`
284			`w ("True");`
285			`else`
286			`w ("False");`
287			`end if;`
288			`end w;`
289
290			`procedure w (L : String; C : Character) is`
291			`begin`
292			`Write_Str (L);`
293			`Write_Char (' ');`
294			`w (C);`
295			`end w;`
296
297			`procedure w (L : String; S : String) is`
298			`begin`
299			`Write_Str (L);`
300			`Write_Char (' ');`
301			`w (S);`
302			`end w;`
303
304			`procedure w (L : String; V : Int) is`
305			`begin`
306			`Write_Str (L);`
307			`Write_Char (' ');`
308			`w (V);`
309			`end w;`
310
311			`procedure w (L : String; B : Boolean) is`
312			`begin`
313			`Write_Str (L);`
314			`Write_Char (' ');`
315			`w (B);`
316			`end w;`
317
318			`----------------`
319			`-- Write_Char --`
320			`----------------`
321
322			`procedure Write_Char (C : Character) is`
323			`begin`
324			`if Next_Col = Buffer'Length then`
325			`Write_Eol;`
326			`end if;`
327
328			`if C = ASCII.LF then`
329			`Write_Eol;`
330			`else`
331			`Buffer (Next_Col) := C;`
332			`Next_Col := Next_Col + 1;`
333			`end if;`
334			`end Write_Char;`
335
336			`---------------`
337			`-- Write_Eol --`
338			`---------------`
339
340			`procedure Write_Eol is`
341			`begin`
342			`-- Remove any trailing space`
343
344			`while Next_Col > 1 and then Buffer (Next_Col - 1) = ' ' loop`
345			`Next_Col := Next_Col - 1;`
346			`end loop;`
347
348			`Buffer (Next_Col) := ASCII.LF;`
349			`Next_Col := Next_Col + 1;`
350			`Flush_Buffer;`
351			`end Write_Eol;`
352
353			`---------------------------`
354			`-- Write_Eol_Keep_Blanks --`
355			`---------------------------`
356
357			`procedure Write_Eol_Keep_Blanks is`
358			`begin`
359			`Buffer (Next_Col) := ASCII.LF;`
360			`Next_Col := Next_Col + 1;`
361			`Flush_Buffer;`
362			`end Write_Eol_Keep_Blanks;`
363
364			`----------------------`
365			`-- Write_Erase_Char --`
366			`----------------------`
367
368			`procedure Write_Erase_Char (C : Character) is`
369			`begin`
370			`if Next_Col /= 1 and then Buffer (Next_Col - 1) = C then`
371			`Next_Col := Next_Col - 1;`
372			`end if;`
373			`end Write_Erase_Char;`
374
375			`---------------`
376			`-- Write_Int --`
377			`---------------`
378
379			`procedure Write_Int (Val : Int) is`
380			`begin`
381			`if Val < 0 then`
382			`Write_Char ('-');`
383			`Write_Int (-Val);`
384
385			`else`
386			`if Val > 9 then`
387			`Write_Int (Val / 10);`
388			`end if;`
389
390			`Write_Char (Character'Val ((Val mod 10) + Character'Pos ('0')));`
391			`end if;`
392			`end Write_Int;`
393
394			`----------------`
395			`-- Write_Line --`
396			`----------------`
397
398			`procedure Write_Line (S : String) is`
399			`begin`
400			`Write_Str (S);`
401			`Write_Eol;`
402			`end Write_Line;`
403
404			`------------------`
405			`-- Write_Spaces --`
406			`------------------`
407
408			`procedure Write_Spaces (N : Nat) is`
409			`begin`
410			`for J in 1 .. N loop`
411			`Write_Char (' ');`
412			`end loop;`
413			`end Write_Spaces;`
414
415			`---------------`
416			`-- Write_Str --`
417			`---------------`
418
419			`procedure Write_Str (S : String) is`
420			`begin`
421			`for J in S'Range loop`
422			`Write_Char (S (J));`
423			`end loop;`
424			`end Write_Str;`
425
426			`end Output;`