File : s-ststop.adb
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
4 -- --
5 -- S Y S T E M . S T R I N G S . S T R E A M _ O P S --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 2008-2013, 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 -- --
19 -- --
20 -- --
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 pragma Compiler_Unit_Warning;
33
34 with Ada.Streams; use Ada.Streams;
35 with Ada.Streams.Stream_IO; use Ada.Streams.Stream_IO;
36 with Ada.Unchecked_Conversion;
37
38 with System; use System;
39 with System.Storage_Elements; use System.Storage_Elements;
40 with System.Stream_Attributes;
41
42 package body System.Strings.Stream_Ops is
43
44 -- The following type describes the low-level IO mechanism used in package
45 -- Stream_Ops_Internal.
46
47 type IO_Kind is (Byte_IO, Block_IO);
48
49 -- The following package provides an IO framework for strings. Depending
50 -- on the version of System.Stream_Attributes as well as the size of
51 -- formal parameter Element_Type, the package will either utilize block
52 -- IO or element-by-element IO.
53
54 generic
55 type Element_Type is private;
56 type Index_Type is range <>;
57 type Array_Type is array (Index_Type range <>) of Element_Type;
58
59 package Stream_Ops_Internal is
60 function Input
61 (Strm : access Root_Stream_Type'Class;
62 IO : IO_Kind) return Array_Type;
63
64 procedure Output
65 (Strm : access Root_Stream_Type'Class;
66 Item : Array_Type;
67 IO : IO_Kind);
68
69 procedure Read
70 (Strm : access Root_Stream_Type'Class;
71 Item : out Array_Type;
72 IO : IO_Kind);
73
74 procedure Write
75 (Strm : access Root_Stream_Type'Class;
76 Item : Array_Type;
77 IO : IO_Kind);
78 end Stream_Ops_Internal;
79
80 -------------------------
81 -- Stream_Ops_Internal --
82 -------------------------
83
84 package body Stream_Ops_Internal is
85
86 -- The following value represents the number of BITS allocated for the
87 -- default block used in string IO. The sizes of all other types are
88 -- calculated relative to this value.
89
90 Default_Block_Size : constant := 512 * 8;
91
92 -- Shorthand notation for stream element and element type sizes
93
94 ET_Size : constant Integer := Element_Type'Size;
95 SE_Size : constant Integer := Stream_Element'Size;
96
97 -- The following constants describe the number of array elements or
98 -- stream elements that can fit into a default block.
99
100 AE_In_Default_Block : constant Index_Type :=
101 Index_Type (Default_Block_Size / ET_Size);
102 -- Number of array elements in a default block
103
104 SE_In_Default_Block : constant Integer := Default_Block_Size / SE_Size;
105 -- Number of storage elements in a default block
106
107 -- Buffer types
108
109 subtype Default_Block is Stream_Element_Array
110 (1 .. Stream_Element_Offset (SE_In_Default_Block));
111
112 subtype Array_Block is
113 Array_Type (Index_Type range 1 .. AE_In_Default_Block);
114
115 -- Conversions to and from Default_Block
116
117 function To_Default_Block is
118 new Ada.Unchecked_Conversion (Array_Block, Default_Block);
119
120 function To_Array_Block is
121 new Ada.Unchecked_Conversion (Default_Block, Array_Block);
122
123 -----------
124 -- Input --
125 -----------
126
127 function Input
128 (Strm : access Root_Stream_Type'Class;
129 IO : IO_Kind) return Array_Type
130 is
131 begin
132 if Strm = null then
133 raise Constraint_Error;
134 end if;
135
136 declare
137 Low : Index_Type;
138 High : Index_Type;
139
140 begin
141 -- Read the bounds of the string
142
143 Index_Type'Read (Strm, Low);
144 Index_Type'Read (Strm, High);
145
146 -- Read the character content of the string
147
148 declare
149 Item : Array_Type (Low .. High);
150 begin
151 Read (Strm, Item, IO);
152 return Item;
153 end;
154 end;
155 end Input;
156
157 ------------
158 -- Output --
159 ------------
160
161 procedure Output
162 (Strm : access Root_Stream_Type'Class;
163 Item : Array_Type;
164 IO : IO_Kind)
165 is
166 begin
167 if Strm = null then
168 raise Constraint_Error;
169 end if;
170
171 -- Write the bounds of the string
172
173 Index_Type'Write (Strm, Item'First);
174 Index_Type'Write (Strm, Item'Last);
175
176 -- Write the character content of the string
177
178 Write (Strm, Item, IO);
179 end Output;
180
181 ----------
182 -- Read --
183 ----------
184
185 procedure Read
186 (Strm : access Root_Stream_Type'Class;
187 Item : out Array_Type;
188 IO : IO_Kind)
189 is
190 begin
191 if Strm = null then
192 raise Constraint_Error;
193 end if;
194
195 -- Nothing to do if the desired string is empty
196
197 if Item'Length = 0 then
198 return;
199 end if;
200
201 -- Block IO
202
203 if IO = Block_IO and then Stream_Attributes.Block_IO_OK then
204 declare
205 -- Determine the size in BITS of the block necessary to contain
206 -- the whole string.
207
208 Block_Size : constant Natural :=
209 Integer (Item'Last - Item'First + 1) * ET_Size;
210
211 -- Item can be larger than what the default block can store,
212 -- determine the number of whole reads necessary to read the
213 -- string.
214
215 Blocks : constant Natural := Block_Size / Default_Block_Size;
216
217 -- The size of Item may not be a multiple of the default block
218 -- size, determine the size of the remaining chunk in BITS.
219
220 Rem_Size : constant Natural :=
221 Block_Size mod Default_Block_Size;
222
223 -- String indexes
224
225 Low : Index_Type := Item'First;
226 High : Index_Type := Low + AE_In_Default_Block - 1;
227
228 -- End of stream error detection
229
230 Last : Stream_Element_Offset := 0;
231 Sum : Stream_Element_Offset := 0;
232
233 begin
234 -- Step 1: If the string is too large, read in individual
235 -- chunks the size of the default block.
236
237 if Blocks > 0 then
238 declare
239 Block : Default_Block;
240
241 begin
242 for Counter in 1 .. Blocks loop
243 Read (Strm.all, Block, Last);
244 Item (Low .. High) := To_Array_Block (Block);
245
246 Low := High + 1;
247 High := Low + AE_In_Default_Block - 1;
248 Sum := Sum + Last;
249 Last := 0;
250 end loop;
251 end;
252 end if;
253
254 -- Step 2: Read in any remaining elements
255
256 if Rem_Size > 0 then
257 declare
258 subtype Rem_Block is Stream_Element_Array
259 (1 .. Stream_Element_Offset (Rem_Size / SE_Size));
260
261 subtype Rem_Array_Block is
262 Array_Type (Index_Type range
263 1 .. Index_Type (Rem_Size / ET_Size));
264
265 function To_Rem_Array_Block is new
266 Ada.Unchecked_Conversion (Rem_Block, Rem_Array_Block);
267
268 Block : Rem_Block;
269
270 begin
271 Read (Strm.all, Block, Last);
272 Item (Low .. Item'Last) := To_Rem_Array_Block (Block);
273
274 Sum := Sum + Last;
275 end;
276 end if;
277
278 -- Step 3: Potential error detection. The sum of all the
279 -- chunks is less than we initially wanted to read. In other
280 -- words, the stream does not contain enough elements to fully
281 -- populate Item.
282
283 if (Integer (Sum) * SE_Size) / ET_Size < Item'Length then
284 raise End_Error;
285 end if;
286 end;
287
288 -- Byte IO
289
290 else
291 declare
292 E : Element_Type;
293 begin
294 for Index in Item'First .. Item'Last loop
295 Element_Type'Read (Strm, E);
296 Item (Index) := E;
297 end loop;
298 end;
299 end if;
300 end Read;
301
302 -----------
303 -- Write --
304 -----------
305
306 procedure Write
307 (Strm : access Root_Stream_Type'Class;
308 Item : Array_Type;
309 IO : IO_Kind)
310 is
311 begin
312 if Strm = null then
313 raise Constraint_Error;
314 end if;
315
316 -- Nothing to do if the input string is empty
317
318 if Item'Length = 0 then
319 return;
320 end if;
321
322 -- Block IO
323
324 if IO = Block_IO and then Stream_Attributes.Block_IO_OK then
325 declare
326 -- Determine the size in BITS of the block necessary to contain
327 -- the whole string.
328
329 Block_Size : constant Natural := Item'Length * ET_Size;
330
331 -- Item can be larger than what the default block can store,
332 -- determine the number of whole writes necessary to output the
333 -- string.
334
335 Blocks : constant Natural := Block_Size / Default_Block_Size;
336
337 -- The size of Item may not be a multiple of the default block
338 -- size, determine the size of the remaining chunk.
339
340 Rem_Size : constant Natural :=
341 Block_Size mod Default_Block_Size;
342
343 -- String indexes
344
345 Low : Index_Type := Item'First;
346 High : Index_Type := Low + AE_In_Default_Block - 1;
347
348 begin
349 -- Step 1: If the string is too large, write out individual
350 -- chunks the size of the default block.
351
352 for Counter in 1 .. Blocks loop
353 Write (Strm.all, To_Default_Block (Item (Low .. High)));
354 Low := High + 1;
355 High := Low + AE_In_Default_Block - 1;
356 end loop;
357
358 -- Step 2: Write out any remaining elements
359
360 if Rem_Size > 0 then
361 declare
362 subtype Rem_Block is Stream_Element_Array
363 (1 .. Stream_Element_Offset (Rem_Size / SE_Size));
364
365 subtype Rem_Array_Block is
366 Array_Type (Index_Type range
367 1 .. Index_Type (Rem_Size / ET_Size));
368
369 function To_Rem_Block is new
370 Ada.Unchecked_Conversion (Rem_Array_Block, Rem_Block);
371
372 begin
373 Write (Strm.all, To_Rem_Block (Item (Low .. Item'Last)));
374 end;
375 end if;
376 end;
377
378 -- Byte IO
379
380 else
381 for Index in Item'First .. Item'Last loop
382 Element_Type'Write (Strm, Item (Index));
383 end loop;
384 end if;
385 end Write;
386 end Stream_Ops_Internal;
387
388 -- Specific instantiations for all Ada array types handled
389
390 package Storage_Array_Ops is
391 new Stream_Ops_Internal
392 (Element_Type => Storage_Element,
393 Index_Type => Storage_Offset,
394 Array_Type => Storage_Array);
395
396 package Stream_Element_Array_Ops is
397 new Stream_Ops_Internal
398 (Element_Type => Stream_Element,
399 Index_Type => Stream_Element_Offset,
400 Array_Type => Stream_Element_Array);
401
402 package String_Ops is
403 new Stream_Ops_Internal
404 (Element_Type => Character,
405 Index_Type => Positive,
406 Array_Type => String);
407
408 package Wide_String_Ops is
409 new Stream_Ops_Internal
410 (Element_Type => Wide_Character,
411 Index_Type => Positive,
412 Array_Type => Wide_String);
413
414 package Wide_Wide_String_Ops is
415 new Stream_Ops_Internal
416 (Element_Type => Wide_Wide_Character,
417 Index_Type => Positive,
418 Array_Type => Wide_Wide_String);
419
420 -------------------------
421 -- Storage_Array_Input --
422 -------------------------
423
424 function Storage_Array_Input
425 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Storage_Array
426 is
427 begin
428 return Storage_Array_Ops.Input (Strm, Byte_IO);
429 end Storage_Array_Input;
430
431 --------------------------------
432 -- Storage_Array_Input_Blk_IO --
433 --------------------------------
434
435 function Storage_Array_Input_Blk_IO
436 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Storage_Array
437 is
438 begin
439 return Storage_Array_Ops.Input (Strm, Block_IO);
440 end Storage_Array_Input_Blk_IO;
441
442 --------------------------
443 -- Storage_Array_Output --
444 --------------------------
445
446 procedure Storage_Array_Output
447 (Strm : access Ada.Streams.Root_Stream_Type'Class;
448 Item : Storage_Array)
449 is
450 begin
451 Storage_Array_Ops.Output (Strm, Item, Byte_IO);
452 end Storage_Array_Output;
453
454 ---------------------------------
455 -- Storage_Array_Output_Blk_IO --
456 ---------------------------------
457
458 procedure Storage_Array_Output_Blk_IO
459 (Strm : access Ada.Streams.Root_Stream_Type'Class;
460 Item : Storage_Array)
461 is
462 begin
463 Storage_Array_Ops.Output (Strm, Item, Block_IO);
464 end Storage_Array_Output_Blk_IO;
465
466 ------------------------
467 -- Storage_Array_Read --
468 ------------------------
469
470 procedure Storage_Array_Read
471 (Strm : access Ada.Streams.Root_Stream_Type'Class;
472 Item : out Storage_Array)
473 is
474 begin
475 Storage_Array_Ops.Read (Strm, Item, Byte_IO);
476 end Storage_Array_Read;
477
478 -------------------------------
479 -- Storage_Array_Read_Blk_IO --
480 -------------------------------
481
482 procedure Storage_Array_Read_Blk_IO
483 (Strm : access Ada.Streams.Root_Stream_Type'Class;
484 Item : out Storage_Array)
485 is
486 begin
487 Storage_Array_Ops.Read (Strm, Item, Block_IO);
488 end Storage_Array_Read_Blk_IO;
489
490 -------------------------
491 -- Storage_Array_Write --
492 -------------------------
493
494 procedure Storage_Array_Write
495 (Strm : access Ada.Streams.Root_Stream_Type'Class;
496 Item : Storage_Array)
497 is
498 begin
499 Storage_Array_Ops.Write (Strm, Item, Byte_IO);
500 end Storage_Array_Write;
501
502 --------------------------------
503 -- Storage_Array_Write_Blk_IO --
504 --------------------------------
505
506 procedure Storage_Array_Write_Blk_IO
507 (Strm : access Ada.Streams.Root_Stream_Type'Class;
508 Item : Storage_Array)
509 is
510 begin
511 Storage_Array_Ops.Write (Strm, Item, Block_IO);
512 end Storage_Array_Write_Blk_IO;
513
514 --------------------------------
515 -- Stream_Element_Array_Input --
516 --------------------------------
517
518 function Stream_Element_Array_Input
519 (Strm : access Ada.Streams.Root_Stream_Type'Class)
520 return Stream_Element_Array
521 is
522 begin
523 return Stream_Element_Array_Ops.Input (Strm, Byte_IO);
524 end Stream_Element_Array_Input;
525
526 ---------------------------------------
527 -- Stream_Element_Array_Input_Blk_IO --
528 ---------------------------------------
529
530 function Stream_Element_Array_Input_Blk_IO
531 (Strm : access Ada.Streams.Root_Stream_Type'Class)
532 return Stream_Element_Array
533 is
534 begin
535 return Stream_Element_Array_Ops.Input (Strm, Block_IO);
536 end Stream_Element_Array_Input_Blk_IO;
537
538 ---------------------------------
539 -- Stream_Element_Array_Output --
540 ---------------------------------
541
542 procedure Stream_Element_Array_Output
543 (Strm : access Ada.Streams.Root_Stream_Type'Class;
544 Item : Stream_Element_Array)
545 is
546 begin
547 Stream_Element_Array_Ops.Output (Strm, Item, Byte_IO);
548 end Stream_Element_Array_Output;
549
550 ----------------------------------------
551 -- Stream_Element_Array_Output_Blk_IO --
552 ----------------------------------------
553
554 procedure Stream_Element_Array_Output_Blk_IO
555 (Strm : access Ada.Streams.Root_Stream_Type'Class;
556 Item : Stream_Element_Array)
557 is
558 begin
559 Stream_Element_Array_Ops.Output (Strm, Item, Block_IO);
560 end Stream_Element_Array_Output_Blk_IO;
561
562 -------------------------------
563 -- Stream_Element_Array_Read --
564 -------------------------------
565
566 procedure Stream_Element_Array_Read
567 (Strm : access Ada.Streams.Root_Stream_Type'Class;
568 Item : out Stream_Element_Array)
569 is
570 begin
571 Stream_Element_Array_Ops.Read (Strm, Item, Byte_IO);
572 end Stream_Element_Array_Read;
573
574 --------------------------------------
575 -- Stream_Element_Array_Read_Blk_IO --
576 --------------------------------------
577
578 procedure Stream_Element_Array_Read_Blk_IO
579 (Strm : access Ada.Streams.Root_Stream_Type'Class;
580 Item : out Stream_Element_Array)
581 is
582 begin
583 Stream_Element_Array_Ops.Read (Strm, Item, Block_IO);
584 end Stream_Element_Array_Read_Blk_IO;
585
586 --------------------------------
587 -- Stream_Element_Array_Write --
588 --------------------------------
589
590 procedure Stream_Element_Array_Write
591 (Strm : access Ada.Streams.Root_Stream_Type'Class;
592 Item : Stream_Element_Array)
593 is
594 begin
595 Stream_Element_Array_Ops.Write (Strm, Item, Byte_IO);
596 end Stream_Element_Array_Write;
597
598 ---------------------------------------
599 -- Stream_Element_Array_Write_Blk_IO --
600 ---------------------------------------
601
602 procedure Stream_Element_Array_Write_Blk_IO
603 (Strm : access Ada.Streams.Root_Stream_Type'Class;
604 Item : Stream_Element_Array)
605 is
606 begin
607 Stream_Element_Array_Ops.Write (Strm, Item, Block_IO);
608 end Stream_Element_Array_Write_Blk_IO;
609
610 ------------------
611 -- String_Input --
612 ------------------
613
614 function String_Input
615 (Strm : access Ada.Streams.Root_Stream_Type'Class) return String
616 is
617 begin
618 return String_Ops.Input (Strm, Byte_IO);
619 end String_Input;
620
621 -------------------------
622 -- String_Input_Blk_IO --
623 -------------------------
624
625 function String_Input_Blk_IO
626 (Strm : access Ada.Streams.Root_Stream_Type'Class) return String
627 is
628 begin
629 return String_Ops.Input (Strm, Block_IO);
630 end String_Input_Blk_IO;
631
632 -------------------
633 -- String_Output --
634 -------------------
635
636 procedure String_Output
637 (Strm : access Ada.Streams.Root_Stream_Type'Class;
638 Item : String)
639 is
640 begin
641 String_Ops.Output (Strm, Item, Byte_IO);
642 end String_Output;
643
644 --------------------------
645 -- String_Output_Blk_IO --
646 --------------------------
647
648 procedure String_Output_Blk_IO
649 (Strm : access Ada.Streams.Root_Stream_Type'Class;
650 Item : String)
651 is
652 begin
653 String_Ops.Output (Strm, Item, Block_IO);
654 end String_Output_Blk_IO;
655
656 -----------------
657 -- String_Read --
658 -----------------
659
660 procedure String_Read
661 (Strm : access Ada.Streams.Root_Stream_Type'Class;
662 Item : out String)
663 is
664 begin
665 String_Ops.Read (Strm, Item, Byte_IO);
666 end String_Read;
667
668 ------------------------
669 -- String_Read_Blk_IO --
670 ------------------------
671
672 procedure String_Read_Blk_IO
673 (Strm : access Ada.Streams.Root_Stream_Type'Class;
674 Item : out String)
675 is
676 begin
677 String_Ops.Read (Strm, Item, Block_IO);
678 end String_Read_Blk_IO;
679
680 ------------------
681 -- String_Write --
682 ------------------
683
684 procedure String_Write
685 (Strm : access Ada.Streams.Root_Stream_Type'Class;
686 Item : String)
687 is
688 begin
689 String_Ops.Write (Strm, Item, Byte_IO);
690 end String_Write;
691
692 -------------------------
693 -- String_Write_Blk_IO --
694 -------------------------
695
696 procedure String_Write_Blk_IO
697 (Strm : access Ada.Streams.Root_Stream_Type'Class;
698 Item : String)
699 is
700 begin
701 String_Ops.Write (Strm, Item, Block_IO);
702 end String_Write_Blk_IO;
703
704 -----------------------
705 -- Wide_String_Input --
706 -----------------------
707
708 function Wide_String_Input
709 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Wide_String
710 is
711 begin
712 return Wide_String_Ops.Input (Strm, Byte_IO);
713 end Wide_String_Input;
714
715 ------------------------------
716 -- Wide_String_Input_Blk_IO --
717 ------------------------------
718
719 function Wide_String_Input_Blk_IO
720 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Wide_String
721 is
722 begin
723 return Wide_String_Ops.Input (Strm, Block_IO);
724 end Wide_String_Input_Blk_IO;
725
726 ------------------------
727 -- Wide_String_Output --
728 ------------------------
729
730 procedure Wide_String_Output
731 (Strm : access Ada.Streams.Root_Stream_Type'Class;
732 Item : Wide_String)
733 is
734 begin
735 Wide_String_Ops.Output (Strm, Item, Byte_IO);
736 end Wide_String_Output;
737
738 -------------------------------
739 -- Wide_String_Output_Blk_IO --
740 -------------------------------
741
742 procedure Wide_String_Output_Blk_IO
743 (Strm : access Ada.Streams.Root_Stream_Type'Class;
744 Item : Wide_String)
745 is
746 begin
747 Wide_String_Ops.Output (Strm, Item, Block_IO);
748 end Wide_String_Output_Blk_IO;
749
750 ----------------------
751 -- Wide_String_Read --
752 ----------------------
753
754 procedure Wide_String_Read
755 (Strm : access Ada.Streams.Root_Stream_Type'Class;
756 Item : out Wide_String)
757 is
758 begin
759 Wide_String_Ops.Read (Strm, Item, Byte_IO);
760 end Wide_String_Read;
761
762 -----------------------------
763 -- Wide_String_Read_Blk_IO --
764 -----------------------------
765
766 procedure Wide_String_Read_Blk_IO
767 (Strm : access Ada.Streams.Root_Stream_Type'Class;
768 Item : out Wide_String)
769 is
770 begin
771 Wide_String_Ops.Read (Strm, Item, Block_IO);
772 end Wide_String_Read_Blk_IO;
773
774 -----------------------
775 -- Wide_String_Write --
776 -----------------------
777
778 procedure Wide_String_Write
779 (Strm : access Ada.Streams.Root_Stream_Type'Class;
780 Item : Wide_String)
781 is
782 begin
783 Wide_String_Ops.Write (Strm, Item, Byte_IO);
784 end Wide_String_Write;
785
786 ------------------------------
787 -- Wide_String_Write_Blk_IO --
788 ------------------------------
789
790 procedure Wide_String_Write_Blk_IO
791 (Strm : access Ada.Streams.Root_Stream_Type'Class;
792 Item : Wide_String)
793 is
794 begin
795 Wide_String_Ops.Write (Strm, Item, Block_IO);
796 end Wide_String_Write_Blk_IO;
797
798 ----------------------------
799 -- Wide_Wide_String_Input --
800 ----------------------------
801
802 function Wide_Wide_String_Input
803 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Wide_Wide_String
804 is
805 begin
806 return Wide_Wide_String_Ops.Input (Strm, Byte_IO);
807 end Wide_Wide_String_Input;
808
809 -----------------------------------
810 -- Wide_Wide_String_Input_Blk_IO --
811 -----------------------------------
812
813 function Wide_Wide_String_Input_Blk_IO
814 (Strm : access Ada.Streams.Root_Stream_Type'Class) return Wide_Wide_String
815 is
816 begin
817 return Wide_Wide_String_Ops.Input (Strm, Block_IO);
818 end Wide_Wide_String_Input_Blk_IO;
819
820 -----------------------------
821 -- Wide_Wide_String_Output --
822 -----------------------------
823
824 procedure Wide_Wide_String_Output
825 (Strm : access Ada.Streams.Root_Stream_Type'Class;
826 Item : Wide_Wide_String)
827 is
828 begin
829 Wide_Wide_String_Ops.Output (Strm, Item, Byte_IO);
830 end Wide_Wide_String_Output;
831
832 ------------------------------------
833 -- Wide_Wide_String_Output_Blk_IO --
834 ------------------------------------
835
836 procedure Wide_Wide_String_Output_Blk_IO
837 (Strm : access Ada.Streams.Root_Stream_Type'Class;
838 Item : Wide_Wide_String)
839 is
840 begin
841 Wide_Wide_String_Ops.Output (Strm, Item, Block_IO);
842 end Wide_Wide_String_Output_Blk_IO;
843
844 ---------------------------
845 -- Wide_Wide_String_Read --
846 ---------------------------
847
848 procedure Wide_Wide_String_Read
849 (Strm : access Ada.Streams.Root_Stream_Type'Class;
850 Item : out Wide_Wide_String)
851 is
852 begin
853 Wide_Wide_String_Ops.Read (Strm, Item, Byte_IO);
854 end Wide_Wide_String_Read;
855
856 ----------------------------------
857 -- Wide_Wide_String_Read_Blk_IO --
858 ----------------------------------
859
860 procedure Wide_Wide_String_Read_Blk_IO
861 (Strm : access Ada.Streams.Root_Stream_Type'Class;
862 Item : out Wide_Wide_String)
863 is
864 begin
865 Wide_Wide_String_Ops.Read (Strm, Item, Block_IO);
866 end Wide_Wide_String_Read_Blk_IO;
867
868 ----------------------------
869 -- Wide_Wide_String_Write --
870 ----------------------------
871
872 procedure Wide_Wide_String_Write
873 (Strm : access Ada.Streams.Root_Stream_Type'Class;
874 Item : Wide_Wide_String)
875 is
876 begin
877 Wide_Wide_String_Ops.Write (Strm, Item, Byte_IO);
878 end Wide_Wide_String_Write;
879
880 -----------------------------------
881 -- Wide_Wide_String_Write_Blk_IO --
882 -----------------------------------
883
884 procedure Wide_Wide_String_Write_Blk_IO
885 (Strm : access Ada.Streams.Root_Stream_Type'Class;
886 Item : Wide_Wide_String)
887 is
888 begin
889 Wide_Wide_String_Ops.Write (Strm, Item, Block_IO);
890 end Wide_Wide_String_Write_Blk_IO;
891
892 end System.Strings.Stream_Ops;