Mercurial > hg > CbC > CbC_gcc
comparison gcc/ada/libgnat/a-textio.ads @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 ------------------------------------------------------------------------------ | |
2 -- -- | |
3 -- GNAT RUN-TIME COMPONENTS -- | |
4 -- -- | |
5 -- A D A . T E X T _ I O -- | |
6 -- -- | |
7 -- S p e c -- | |
8 -- -- | |
9 -- Copyright (C) 1992-2017, Free Software Foundation, Inc. -- | |
10 -- -- | |
11 -- This specification is derived from the Ada Reference Manual for use with -- | |
12 -- GNAT. The copyright notice above, and the license provisions that follow -- | |
13 -- apply solely to the contents of the part following the private keyword. -- | |
14 -- -- | |
15 -- GNAT is free software; you can redistribute it and/or modify it under -- | |
16 -- terms of the GNU General Public License as published by the Free Soft- -- | |
17 -- ware Foundation; either version 3, or (at your option) any later ver- -- | |
18 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
19 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |
20 -- or FITNESS FOR A PARTICULAR PURPOSE. -- | |
21 -- -- | |
22 -- As a special exception under Section 7 of GPL version 3, you are granted -- | |
23 -- additional permissions described in the GCC Runtime Library Exception, -- | |
24 -- version 3.1, as published by the Free Software Foundation. -- | |
25 -- -- | |
26 -- You should have received a copy of the GNU General Public License and -- | |
27 -- a copy of the GCC Runtime Library Exception along with this program; -- | |
28 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- | |
29 -- <http://www.gnu.org/licenses/>. -- | |
30 -- -- | |
31 -- GNAT was originally developed by the GNAT team at New York University. -- | |
32 -- Extensive contributions were provided by Ada Core Technologies Inc. -- | |
33 -- -- | |
34 ------------------------------------------------------------------------------ | |
35 | |
36 -- Note: the generic subpackages of Text_IO (Integer_IO, Float_IO, Fixed_IO, | |
37 -- Modular_IO, Decimal_IO and Enumeration_IO) appear as private children in | |
38 -- GNAT. These children are with'ed automatically if they are referenced, so | |
39 -- this rearrangement is invisible to user programs, but has the advantage | |
40 -- that only the needed parts of Text_IO are processed and loaded. | |
41 | |
42 with Ada.IO_Exceptions; | |
43 with Ada.Streams; | |
44 | |
45 with System; | |
46 with System.File_Control_Block; | |
47 with System.WCh_Con; | |
48 | |
49 package Ada.Text_IO is | |
50 pragma Elaborate_Body; | |
51 | |
52 type File_Type is limited private; | |
53 type File_Mode is (In_File, Out_File, Append_File); | |
54 | |
55 -- The following representation clause allows the use of unchecked | |
56 -- conversion for rapid translation between the File_Mode type | |
57 -- used in this package and System.File_IO. | |
58 | |
59 for File_Mode use | |
60 (In_File => 0, -- System.FIle_IO.File_Mode'Pos (In_File) | |
61 Out_File => 2, -- System.File_IO.File_Mode'Pos (Out_File) | |
62 Append_File => 3); -- System.File_IO.File_Mode'Pos (Append_File) | |
63 | |
64 type Count is range 0 .. Natural'Last; | |
65 -- The value of Count'Last must be large enough so that the assumption that | |
66 -- the Line, Column and Page counts can never exceed this value is valid. | |
67 | |
68 subtype Positive_Count is Count range 1 .. Count'Last; | |
69 | |
70 Unbounded : constant Count := 0; | |
71 -- Line and page length | |
72 | |
73 subtype Field is Integer range 0 .. 255; | |
74 -- Note: if for any reason, there is a need to increase this value, then it | |
75 -- will be necessary to change the corresponding value in System.Img_Real | |
76 -- in file s-imgrea.adb. | |
77 | |
78 subtype Number_Base is Integer range 2 .. 16; | |
79 | |
80 type Type_Set is (Lower_Case, Upper_Case); | |
81 | |
82 --------------------- | |
83 -- File Management -- | |
84 --------------------- | |
85 | |
86 procedure Create | |
87 (File : in out File_Type; | |
88 Mode : File_Mode := Out_File; | |
89 Name : String := ""; | |
90 Form : String := ""); | |
91 | |
92 procedure Open | |
93 (File : in out File_Type; | |
94 Mode : File_Mode; | |
95 Name : String; | |
96 Form : String := ""); | |
97 | |
98 procedure Close (File : in out File_Type); | |
99 procedure Delete (File : in out File_Type); | |
100 procedure Reset (File : in out File_Type; Mode : File_Mode); | |
101 procedure Reset (File : in out File_Type); | |
102 | |
103 function Mode (File : File_Type) return File_Mode; | |
104 function Name (File : File_Type) return String; | |
105 function Form (File : File_Type) return String; | |
106 | |
107 function Is_Open (File : File_Type) return Boolean; | |
108 | |
109 ------------------------------------------------------ | |
110 -- Control of default input, output and error files -- | |
111 ------------------------------------------------------ | |
112 | |
113 procedure Set_Input (File : File_Type); | |
114 procedure Set_Output (File : File_Type); | |
115 procedure Set_Error (File : File_Type); | |
116 | |
117 function Standard_Input return File_Type; | |
118 function Standard_Output return File_Type; | |
119 function Standard_Error return File_Type; | |
120 | |
121 function Current_Input return File_Type; | |
122 function Current_Output return File_Type; | |
123 function Current_Error return File_Type; | |
124 | |
125 type File_Access is access constant File_Type; | |
126 | |
127 function Standard_Input return File_Access; | |
128 function Standard_Output return File_Access; | |
129 function Standard_Error return File_Access; | |
130 | |
131 function Current_Input return File_Access; | |
132 function Current_Output return File_Access; | |
133 function Current_Error return File_Access; | |
134 | |
135 -------------------- | |
136 -- Buffer control -- | |
137 -------------------- | |
138 | |
139 -- Note: The parameter file is IN OUT in the RM, but this is clearly | |
140 -- an oversight, and was intended to be IN, see AI95-00057. | |
141 | |
142 procedure Flush (File : File_Type); | |
143 procedure Flush; | |
144 | |
145 -------------------------------------------- | |
146 -- Specification of line and page lengths -- | |
147 -------------------------------------------- | |
148 | |
149 procedure Set_Line_Length (File : File_Type; To : Count); | |
150 procedure Set_Line_Length (To : Count); | |
151 | |
152 procedure Set_Page_Length (File : File_Type; To : Count); | |
153 procedure Set_Page_Length (To : Count); | |
154 | |
155 function Line_Length (File : File_Type) return Count; | |
156 function Line_Length return Count; | |
157 | |
158 function Page_Length (File : File_Type) return Count; | |
159 function Page_Length return Count; | |
160 | |
161 ------------------------------------ | |
162 -- Column, Line, and Page Control -- | |
163 ------------------------------------ | |
164 | |
165 procedure New_Line (File : File_Type; Spacing : Positive_Count := 1); | |
166 procedure New_Line (Spacing : Positive_Count := 1); | |
167 | |
168 procedure Skip_Line (File : File_Type; Spacing : Positive_Count := 1); | |
169 procedure Skip_Line (Spacing : Positive_Count := 1); | |
170 | |
171 function End_Of_Line (File : File_Type) return Boolean; | |
172 function End_Of_Line return Boolean; | |
173 | |
174 procedure New_Page (File : File_Type); | |
175 procedure New_Page; | |
176 | |
177 procedure Skip_Page (File : File_Type); | |
178 procedure Skip_Page; | |
179 | |
180 function End_Of_Page (File : File_Type) return Boolean; | |
181 function End_Of_Page return Boolean; | |
182 | |
183 function End_Of_File (File : File_Type) return Boolean; | |
184 function End_Of_File return Boolean; | |
185 | |
186 procedure Set_Col (File : File_Type; To : Positive_Count); | |
187 procedure Set_Col (To : Positive_Count); | |
188 | |
189 procedure Set_Line (File : File_Type; To : Positive_Count); | |
190 procedure Set_Line (To : Positive_Count); | |
191 | |
192 function Col (File : File_Type) return Positive_Count; | |
193 function Col return Positive_Count; | |
194 | |
195 function Line (File : File_Type) return Positive_Count; | |
196 function Line return Positive_Count; | |
197 | |
198 function Page (File : File_Type) return Positive_Count; | |
199 function Page return Positive_Count; | |
200 | |
201 ---------------------------- | |
202 -- Character Input-Output -- | |
203 ---------------------------- | |
204 | |
205 procedure Get (File : File_Type; Item : out Character); | |
206 procedure Get (Item : out Character); | |
207 procedure Put (File : File_Type; Item : Character); | |
208 procedure Put (Item : Character); | |
209 | |
210 procedure Look_Ahead | |
211 (File : File_Type; | |
212 Item : out Character; | |
213 End_Of_Line : out Boolean); | |
214 | |
215 procedure Look_Ahead | |
216 (Item : out Character; | |
217 End_Of_Line : out Boolean); | |
218 | |
219 procedure Get_Immediate | |
220 (File : File_Type; | |
221 Item : out Character); | |
222 | |
223 procedure Get_Immediate | |
224 (Item : out Character); | |
225 | |
226 procedure Get_Immediate | |
227 (File : File_Type; | |
228 Item : out Character; | |
229 Available : out Boolean); | |
230 | |
231 procedure Get_Immediate | |
232 (Item : out Character; | |
233 Available : out Boolean); | |
234 | |
235 ------------------------- | |
236 -- String Input-Output -- | |
237 ------------------------- | |
238 | |
239 procedure Get (File : File_Type; Item : out String); | |
240 procedure Get (Item : out String); | |
241 procedure Put (File : File_Type; Item : String); | |
242 procedure Put (Item : String); | |
243 | |
244 procedure Get_Line | |
245 (File : File_Type; | |
246 Item : out String; | |
247 Last : out Natural); | |
248 | |
249 procedure Get_Line | |
250 (Item : out String; | |
251 Last : out Natural); | |
252 | |
253 function Get_Line (File : File_Type) return String; | |
254 pragma Ada_05 (Get_Line); | |
255 | |
256 function Get_Line return String; | |
257 pragma Ada_05 (Get_Line); | |
258 | |
259 procedure Put_Line | |
260 (File : File_Type; | |
261 Item : String); | |
262 | |
263 procedure Put_Line | |
264 (Item : String); | |
265 | |
266 --------------------------------------- | |
267 -- Generic packages for Input-Output -- | |
268 --------------------------------------- | |
269 | |
270 -- The generic packages: | |
271 | |
272 -- Ada.Text_IO.Integer_IO | |
273 -- Ada.Text_IO.Modular_IO | |
274 -- Ada.Text_IO.Float_IO | |
275 -- Ada.Text_IO.Fixed_IO | |
276 -- Ada.Text_IO.Decimal_IO | |
277 -- Ada.Text_IO.Enumeration_IO | |
278 | |
279 -- are implemented as separate child packages in GNAT, so the | |
280 -- spec and body of these packages are to be found in separate | |
281 -- child units. This implementation detail is hidden from the | |
282 -- Ada programmer by special circuitry in the compiler that | |
283 -- treats these child packages as though they were nested in | |
284 -- Text_IO. The advantage of this special processing is that | |
285 -- the subsidiary routines needed if these generics are used | |
286 -- are not loaded when they are not used. | |
287 | |
288 ---------------- | |
289 -- Exceptions -- | |
290 ---------------- | |
291 | |
292 Status_Error : exception renames IO_Exceptions.Status_Error; | |
293 Mode_Error : exception renames IO_Exceptions.Mode_Error; | |
294 Name_Error : exception renames IO_Exceptions.Name_Error; | |
295 Use_Error : exception renames IO_Exceptions.Use_Error; | |
296 Device_Error : exception renames IO_Exceptions.Device_Error; | |
297 End_Error : exception renames IO_Exceptions.End_Error; | |
298 Data_Error : exception renames IO_Exceptions.Data_Error; | |
299 Layout_Error : exception renames IO_Exceptions.Layout_Error; | |
300 | |
301 private | |
302 | |
303 -- The following procedures have a File_Type formal of mode IN OUT because | |
304 -- they may close the original file. The Close operation may raise an | |
305 -- exception, but in that case we want any assignment to the formal to | |
306 -- be effective anyway, so it must be passed by reference (or the caller | |
307 -- will be left with a dangling pointer). | |
308 | |
309 pragma Export_Procedure | |
310 (Internal => Close, | |
311 External => "", | |
312 Mechanism => Reference); | |
313 pragma Export_Procedure | |
314 (Internal => Delete, | |
315 External => "", | |
316 Mechanism => Reference); | |
317 pragma Export_Procedure | |
318 (Internal => Reset, | |
319 External => "", | |
320 Parameter_Types => (File_Type), | |
321 Mechanism => Reference); | |
322 pragma Export_Procedure | |
323 (Internal => Reset, | |
324 External => "", | |
325 Parameter_Types => (File_Type, File_Mode), | |
326 Mechanism => (File => Reference)); | |
327 | |
328 ----------------------------------- | |
329 -- Handling of Format Characters -- | |
330 ----------------------------------- | |
331 | |
332 -- Line marks are represented by the single character ASCII.LF (16#0A#). | |
333 -- In DOS and similar systems, underlying file translation takes care | |
334 -- of translating this to and from the standard CR/LF sequences used in | |
335 -- these operating systems to mark the end of a line. On output there is | |
336 -- always a line mark at the end of the last line, but on input, this | |
337 -- line mark can be omitted, and is implied by the end of file. | |
338 | |
339 -- Page marks are represented by the single character ASCII.FF (16#0C#), | |
340 -- The page mark at the end of the file may be omitted, and is normally | |
341 -- omitted on output unless an explicit New_Page call is made before | |
342 -- closing the file. No page mark is added when a file is appended to, | |
343 -- so, in accordance with the permission in (RM A.10.2(4)), there may | |
344 -- or may not be a page mark separating preexisting text in the file | |
345 -- from the new text to be written. | |
346 | |
347 -- A file mark is marked by the physical end of file. In DOS translation | |
348 -- mode on input, an EOF character (SUB = 16#1A#) gets translated to the | |
349 -- physical end of file, so in effect this character is recognized as | |
350 -- marking the end of file in DOS and similar systems. | |
351 | |
352 LM : constant := Character'Pos (ASCII.LF); | |
353 -- Used as line mark | |
354 | |
355 PM : constant := Character'Pos (ASCII.FF); | |
356 -- Used as page mark, except at end of file where it is implied | |
357 | |
358 -------------------------------- | |
359 -- Text_IO File Control Block -- | |
360 -------------------------------- | |
361 | |
362 Default_WCEM : System.WCh_Con.WC_Encoding_Method := | |
363 System.WCh_Con.WCEM_UTF8; | |
364 -- This gets modified during initialization (see body) using | |
365 -- the default value established in the call to Set_Globals. | |
366 | |
367 package FCB renames System.File_Control_Block; | |
368 | |
369 type Text_AFCB; | |
370 type File_Type is access all Text_AFCB; | |
371 | |
372 type Text_AFCB is new FCB.AFCB with record | |
373 Page : Count := 1; | |
374 Line : Count := 1; | |
375 Col : Count := 1; | |
376 Line_Length : Count := 0; | |
377 Page_Length : Count := 0; | |
378 | |
379 Self : aliased File_Type; | |
380 -- Set to point to the containing Text_AFCB block. This is used to | |
381 -- implement the Current_{Error,Input,Output} functions which return | |
382 -- a File_Access, the file access value returned is a pointer to | |
383 -- the Self field of the corresponding file. | |
384 | |
385 Before_LM : Boolean := False; | |
386 -- This flag is used to deal with the anomalies introduced by the | |
387 -- peculiar definition of End_Of_File and End_Of_Page in Ada. These | |
388 -- functions require looking ahead more than one character. Since | |
389 -- there is no convenient way of backing up more than one character, | |
390 -- what we do is to leave ourselves positioned past the LM, but set | |
391 -- this flag, so that we know that from an Ada point of view we are | |
392 -- in front of the LM, not after it. A little odd, but it works. | |
393 | |
394 Before_LM_PM : Boolean := False; | |
395 -- This flag similarly handles the case of being physically positioned | |
396 -- after a LM-PM sequence when logically we are before the LM-PM. This | |
397 -- flag can only be set if Before_LM is also set. | |
398 | |
399 WC_Method : System.WCh_Con.WC_Encoding_Method := Default_WCEM; | |
400 -- Encoding method to be used for this file. Text_IO does not deal with | |
401 -- wide characters, but it does deal with upper half characters in the | |
402 -- range 16#80#-16#FF# which may need encoding, e.g. in UTF-8 mode. | |
403 | |
404 Before_Upper_Half_Character : Boolean := False; | |
405 -- This flag is set to indicate that an encoded upper half character has | |
406 -- been read by Text_IO.Look_Ahead. If it is set to True, then it means | |
407 -- that the stream is logically positioned before the character but is | |
408 -- physically positioned after it. The character involved must be in | |
409 -- the range 16#80#-16#FF#, i.e. if the flag is set, then we know the | |
410 -- next character has a code greater than 16#7F#, and the value of this | |
411 -- character is saved in Saved_Upper_Half_Character. | |
412 | |
413 Saved_Upper_Half_Character : Character; | |
414 -- This field is valid only if Before_Upper_Half_Character is set. It | |
415 -- contains an upper-half character read by Look_Ahead. If Look_Ahead | |
416 -- reads a character in the range 16#00# to 16#7F#, then it can use | |
417 -- ungetc to put it back, but ungetc cannot be called more than once, | |
418 -- so for characters above this range, we don't try to back up the | |
419 -- file. Instead we save the character in this field and set the flag | |
420 -- Before_Upper_Half_Character to True to indicate that we are logically | |
421 -- positioned before this character even though the stream is physically | |
422 -- positioned after it. | |
423 | |
424 end record; | |
425 | |
426 function AFCB_Allocate (Control_Block : Text_AFCB) return FCB.AFCB_Ptr; | |
427 | |
428 procedure AFCB_Close (File : not null access Text_AFCB); | |
429 procedure AFCB_Free (File : not null access Text_AFCB); | |
430 | |
431 procedure Read | |
432 (File : in out Text_AFCB; | |
433 Item : out Ada.Streams.Stream_Element_Array; | |
434 Last : out Ada.Streams.Stream_Element_Offset); | |
435 -- Read operation used when Text_IO file is treated directly as Stream | |
436 | |
437 procedure Write | |
438 (File : in out Text_AFCB; | |
439 Item : Ada.Streams.Stream_Element_Array); | |
440 -- Write operation used when Text_IO file is treated directly as Stream | |
441 | |
442 ------------------------ | |
443 -- The Standard Files -- | |
444 ------------------------ | |
445 | |
446 Standard_In_AFCB : aliased Text_AFCB; | |
447 Standard_Out_AFCB : aliased Text_AFCB; | |
448 Standard_Err_AFCB : aliased Text_AFCB; | |
449 | |
450 Standard_In : aliased File_Type := Standard_In_AFCB'Access; | |
451 Standard_Out : aliased File_Type := Standard_Out_AFCB'Access; | |
452 Standard_Err : aliased File_Type := Standard_Err_AFCB'Access; | |
453 -- Standard files | |
454 | |
455 Current_In : aliased File_Type := Standard_In; | |
456 Current_Out : aliased File_Type := Standard_Out; | |
457 Current_Err : aliased File_Type := Standard_Err; | |
458 -- Current files | |
459 | |
460 function EOF_Char return Integer; | |
461 -- Returns the system-specific character indicating the end of a text file. | |
462 -- This is exported for use by child packages such as Enumeration_Aux to | |
463 -- eliminate their needing to depend directly on Interfaces.C_Streams, | |
464 -- which is not available in certain target environments (such as AAMP). | |
465 | |
466 procedure Initialize_Standard_Files; | |
467 -- Initializes the file control blocks for the standard files. Called from | |
468 -- the elaboration routine for this package, and from Reset_Standard_Files | |
469 -- in package Ada.Text_IO.Reset_Standard_Files. | |
470 | |
471 end Ada.Text_IO; |