gcc/ada/libgnat/s-stratt.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT RUN-TIME COMPONENTS                         --
   4 --                                                                          --
   5 --             S Y S T E M . S T R E A M _ A T T R I B U T E S              --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2018, 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 Ada.IO_Exceptions;
  33 with Ada.Streams; use Ada.Streams;
  34 with Ada.Unchecked_Conversion;
  35
  36 package body System.Stream_Attributes is
  37
  38    Err : exception renames Ada.IO_Exceptions.End_Error;
  39    --  Exception raised if insufficient data read (note that the RM implies
  40    --  that Data_Error might be the appropriate choice, but AI95-00132
  41    --  decides with a binding interpretation that End_Error is preferred).
  42
  43    SU : constant := System.Storage_Unit;
  44
  45    subtype SEA is Ada.Streams.Stream_Element_Array;
  46    subtype SEO is Ada.Streams.Stream_Element_Offset;
  47
  48    generic function UC renames Ada.Unchecked_Conversion;
  49
  50    --  Subtypes used to define Stream_Element_Array values that map
  51    --  into the elementary types, using unchecked conversion.
  52
  53    Thin_Pointer_Size : constant := System.Address'Size;
  54    Fat_Pointer_Size  : constant := System.Address'Size * 2;
  55
  56    subtype S_AD  is SEA (1 .. (Fat_Pointer_Size              + SU - 1) / SU);
  57    subtype S_AS  is SEA (1 .. (Thin_Pointer_Size             + SU - 1) / SU);
  58    subtype S_B   is SEA (1 .. (Boolean'Size                  + SU - 1) / SU);
  59    subtype S_C   is SEA (1 .. (Character'Size                + SU - 1) / SU);
  60    subtype S_F   is SEA (1 .. (Float'Size                    + SU - 1) / SU);
  61    subtype S_I   is SEA (1 .. (Integer'Size                  + SU - 1) / SU);
  62    subtype S_LF  is SEA (1 .. (Long_Float'Size               + SU - 1) / SU);
  63    subtype S_LI  is SEA (1 .. (Long_Integer'Size             + SU - 1) / SU);
  64    subtype S_LLF is SEA (1 .. (Long_Long_Float'Size          + SU - 1) / SU);
  65    subtype S_LLI is SEA (1 .. (Long_Long_Integer'Size        + SU - 1) / SU);
  66    subtype S_LLU is SEA (1 .. (UST.Long_Long_Unsigned'Size   + SU - 1) / SU);
  67    subtype S_LU  is SEA (1 .. (UST.Long_Unsigned'Size        + SU - 1) / SU);
  68    subtype S_SF  is SEA (1 .. (Short_Float'Size              + SU - 1) / SU);
  69    subtype S_SI  is SEA (1 .. (Short_Integer'Size            + SU - 1) / SU);
  70    subtype S_SSI is SEA (1 .. (Short_Short_Integer'Size      + SU - 1) / SU);
  71    subtype S_SSU is SEA (1 .. (UST.Short_Short_Unsigned'Size + SU - 1) / SU);
  72    subtype S_SU  is SEA (1 .. (UST.Short_Unsigned'Size       + SU - 1) / SU);
  73    subtype S_U   is SEA (1 .. (UST.Unsigned'Size             + SU - 1) / SU);
  74    subtype S_WC  is SEA (1 .. (Wide_Character'Size           + SU - 1) / SU);
  75    subtype S_WWC is SEA (1 .. (Wide_Wide_Character'Size      + SU - 1) / SU);
  76
  77    --  Unchecked conversions from the elementary type to the stream type
  78
  79    function From_AD  is new UC (Fat_Pointer,              S_AD);
  80    function From_AS  is new UC (Thin_Pointer,             S_AS);
  81    function From_F   is new UC (Float,                    S_F);
  82    function From_I   is new UC (Integer,                  S_I);
  83    function From_LF  is new UC (Long_Float,               S_LF);
  84    function From_LI  is new UC (Long_Integer,             S_LI);
  85    function From_LLF is new UC (Long_Long_Float,          S_LLF);
  86    function From_LLI is new UC (Long_Long_Integer,        S_LLI);
  87    function From_LLU is new UC (UST.Long_Long_Unsigned,   S_LLU);
  88    function From_LU  is new UC (UST.Long_Unsigned,        S_LU);
  89    function From_SF  is new UC (Short_Float,              S_SF);
  90    function From_SI  is new UC (Short_Integer,            S_SI);
  91    function From_SSI is new UC (Short_Short_Integer,      S_SSI);
  92    function From_SSU is new UC (UST.Short_Short_Unsigned, S_SSU);
  93    function From_SU  is new UC (UST.Short_Unsigned,       S_SU);
  94    function From_U   is new UC (UST.Unsigned,             S_U);
  95    function From_WC  is new UC (Wide_Character,           S_WC);
  96    function From_WWC is new UC (Wide_Wide_Character,      S_WWC);
  97
  98    --  Unchecked conversions from the stream type to elementary type
  99
 100    function To_AD  is new UC (S_AD,  Fat_Pointer);
 101    function To_AS  is new UC (S_AS,  Thin_Pointer);
 102    function To_F   is new UC (S_F,   Float);
 103    function To_I   is new UC (S_I,   Integer);
 104    function To_LF  is new UC (S_LF,  Long_Float);
 105    function To_LI  is new UC (S_LI,  Long_Integer);
 106    function To_LLF is new UC (S_LLF, Long_Long_Float);
 107    function To_LLI is new UC (S_LLI, Long_Long_Integer);
 108    function To_LLU is new UC (S_LLU, UST.Long_Long_Unsigned);
 109    function To_LU  is new UC (S_LU,  UST.Long_Unsigned);
 110    function To_SF  is new UC (S_SF,  Short_Float);
 111    function To_SI  is new UC (S_SI,  Short_Integer);
 112    function To_SSI is new UC (S_SSI, Short_Short_Integer);
 113    function To_SSU is new UC (S_SSU, UST.Short_Short_Unsigned);
 114    function To_SU  is new UC (S_SU,  UST.Short_Unsigned);
 115    function To_U   is new UC (S_U,   UST.Unsigned);
 116    function To_WC  is new UC (S_WC,  Wide_Character);
 117    function To_WWC is new UC (S_WWC, Wide_Wide_Character);
 118
 119    -----------------
 120    -- Block_IO_OK --
 121    -----------------
 122
 123    function Block_IO_OK return Boolean is
 124    begin
 125       return True;
 126    end Block_IO_OK;
 127
 128    ----------
 129    -- I_AD --
 130    ----------
 131
 132    function I_AD (Stream : not null access RST) return Fat_Pointer is
 133       T : S_AD;
 134       L : SEO;
 135
 136    begin
 137       Ada.Streams.Read (Stream.all, T, L);
 138
 139       if L < T'Last then
 140          raise Err;
 141       else
 142          return To_AD (T);
 143       end if;
 144    end I_AD;
 145
 146    ----------
 147    -- I_AS --
 148    ----------
 149
 150    function I_AS (Stream : not null access RST) return Thin_Pointer is
 151       T : S_AS;
 152       L : SEO;
 153
 154    begin
 155       Ada.Streams.Read (Stream.all, T, L);
 156
 157       if L < T'Last then
 158          raise Err;
 159       else
 160          return To_AS (T);
 161       end if;
 162    end I_AS;
 163
 164    ---------
 165    -- I_B --
 166    ---------
 167
 168    function I_B (Stream : not null access RST) return Boolean is
 169       T : S_B;
 170       L : SEO;
 171
 172    begin
 173       Ada.Streams.Read (Stream.all, T, L);
 174
 175       if L < T'Last then
 176          raise Err;
 177       else
 178          return Boolean'Val (T (1));
 179       end if;
 180    end I_B;
 181
 182    ---------
 183    -- I_C --
 184    ---------
 185
 186    function I_C (Stream : not null access RST) return Character is
 187       T : S_C;
 188       L : SEO;
 189
 190    begin
 191       Ada.Streams.Read (Stream.all, T, L);
 192
 193       if L < T'Last then
 194          raise Err;
 195       else
 196          return Character'Val (T (1));
 197       end if;
 198    end I_C;
 199
 200    ---------
 201    -- I_F --
 202    ---------
 203
 204    function I_F (Stream : not null access RST) return Float is
 205       T : S_F;
 206       L : SEO;
 207
 208    begin
 209       Ada.Streams.Read (Stream.all, T, L);
 210
 211       if L < T'Last then
 212          raise Err;
 213       else
 214          return To_F (T);
 215       end if;
 216    end I_F;
 217
 218    ---------
 219    -- I_I --
 220    ---------
 221
 222    function I_I (Stream : not null access RST) return Integer is
 223       T : S_I;
 224       L : SEO;
 225
 226    begin
 227       Ada.Streams.Read (Stream.all, T, L);
 228
 229       if L < T'Last then
 230          raise Err;
 231       else
 232          return To_I (T);
 233       end if;
 234    end I_I;
 235
 236    ----------
 237    -- I_LF --
 238    ----------
 239
 240    function I_LF (Stream : not null access RST) return Long_Float is
 241       T : S_LF;
 242       L : SEO;
 243
 244    begin
 245       Ada.Streams.Read (Stream.all, T, L);
 246
 247       if L < T'Last then
 248          raise Err;
 249       else
 250          return To_LF (T);
 251       end if;
 252    end I_LF;
 253
 254    ----------
 255    -- I_LI --
 256    ----------
 257
 258    function I_LI (Stream : not null access RST) return Long_Integer is
 259       T : S_LI;
 260       L : SEO;
 261
 262    begin
 263       Ada.Streams.Read (Stream.all, T, L);
 264
 265       if L < T'Last then
 266          raise Err;
 267       else
 268          return To_LI (T);
 269       end if;
 270    end I_LI;
 271
 272    -----------
 273    -- I_LLF --
 274    -----------
 275
 276    function I_LLF (Stream : not null access RST) return Long_Long_Float is
 277       T : S_LLF;
 278       L : SEO;
 279
 280    begin
 281       Ada.Streams.Read (Stream.all, T, L);
 282
 283       if L < T'Last then
 284          raise Err;
 285       else
 286          return To_LLF (T);
 287       end if;
 288    end I_LLF;
 289
 290    -----------
 291    -- I_LLI --
 292    -----------
 293
 294    function I_LLI (Stream : not null access RST) return Long_Long_Integer is
 295       T : S_LLI;
 296       L : SEO;
 297
 298    begin
 299       Ada.Streams.Read (Stream.all, T, L);
 300
 301       if L < T'Last then
 302          raise Err;
 303       else
 304          return To_LLI (T);
 305       end if;
 306    end I_LLI;
 307
 308    -----------
 309    -- I_LLU --
 310    -----------
 311
 312    function I_LLU
 313      (Stream : not null access RST) return UST.Long_Long_Unsigned
 314    is
 315       T : S_LLU;
 316       L : SEO;
 317
 318    begin
 319       Ada.Streams.Read (Stream.all, T, L);
 320
 321       if L < T'Last then
 322          raise Err;
 323       else
 324          return To_LLU (T);
 325       end if;
 326    end I_LLU;
 327
 328    ----------
 329    -- I_LU --
 330    ----------
 331
 332    function I_LU (Stream : not null access RST) return UST.Long_Unsigned is
 333       T : S_LU;
 334       L : SEO;
 335
 336    begin
 337       Ada.Streams.Read (Stream.all, T, L);
 338
 339       if L < T'Last then
 340          raise Err;
 341       else
 342          return To_LU (T);
 343       end if;
 344    end I_LU;
 345
 346    ----------
 347    -- I_SF --
 348    ----------
 349
 350    function I_SF (Stream : not null access RST) return Short_Float is
 351       T : S_SF;
 352       L : SEO;
 353
 354    begin
 355       Ada.Streams.Read (Stream.all, T, L);
 356
 357       if L < T'Last then
 358          raise Err;
 359       else
 360          return To_SF (T);
 361       end if;
 362    end I_SF;
 363
 364    ----------
 365    -- I_SI --
 366    ----------
 367
 368    function I_SI (Stream : not null access RST) return Short_Integer is
 369       T : S_SI;
 370       L : SEO;
 371
 372    begin
 373       Ada.Streams.Read (Stream.all, T, L);
 374
 375       if L < T'Last then
 376          raise Err;
 377       else
 378          return To_SI (T);
 379       end if;
 380    end I_SI;
 381
 382    -----------
 383    -- I_SSI --
 384    -----------
 385
 386    function I_SSI (Stream : not null access RST) return Short_Short_Integer is
 387       T : S_SSI;
 388       L : SEO;
 389
 390    begin
 391       Ada.Streams.Read (Stream.all, T, L);
 392
 393       if L < T'Last then
 394          raise Err;
 395       else
 396          return To_SSI (T);
 397       end if;
 398    end I_SSI;
 399
 400    -----------
 401    -- I_SSU --
 402    -----------
 403
 404    function I_SSU
 405      (Stream : not null access RST) return UST.Short_Short_Unsigned
 406    is
 407       T : S_SSU;
 408       L : SEO;
 409
 410    begin
 411       Ada.Streams.Read (Stream.all, T, L);
 412
 413       if L < T'Last then
 414          raise Err;
 415       else
 416          return To_SSU (T);
 417       end if;
 418    end I_SSU;
 419
 420    ----------
 421    -- I_SU --
 422    ----------
 423
 424    function I_SU (Stream : not null access RST) return UST.Short_Unsigned is
 425       T : S_SU;
 426       L : SEO;
 427
 428    begin
 429       Ada.Streams.Read (Stream.all, T, L);
 430
 431       if L < T'Last then
 432          raise Err;
 433       else
 434          return To_SU (T);
 435       end if;
 436    end I_SU;
 437
 438    ---------
 439    -- I_U --
 440    ---------
 441
 442    function I_U (Stream : not null access RST) return UST.Unsigned is
 443       T : S_U;
 444       L : SEO;
 445
 446    begin
 447       Ada.Streams.Read (Stream.all, T, L);
 448
 449       if L < T'Last then
 450          raise Err;
 451       else
 452          return To_U (T);
 453       end if;
 454    end I_U;
 455
 456    ----------
 457    -- I_WC --
 458    ----------
 459
 460    function I_WC (Stream : not null access RST) return Wide_Character is
 461       T : S_WC;
 462       L : SEO;
 463
 464    begin
 465       Ada.Streams.Read (Stream.all, T, L);
 466
 467       if L < T'Last then
 468          raise Err;
 469       else
 470          return To_WC (T);
 471       end if;
 472    end I_WC;
 473
 474    -----------
 475    -- I_WWC --
 476    -----------
 477
 478    function I_WWC (Stream : not null access RST) return Wide_Wide_Character is
 479       T : S_WWC;
 480       L : SEO;
 481
 482    begin
 483       Ada.Streams.Read (Stream.all, T, L);
 484
 485       if L < T'Last then
 486          raise Err;
 487       else
 488          return To_WWC (T);
 489       end if;
 490    end I_WWC;
 491
 492    ----------
 493    -- W_AD --
 494    ----------
 495
 496    procedure W_AD (Stream : not null access RST; Item : Fat_Pointer) is
 497       T : constant S_AD := From_AD (Item);
 498    begin
 499       Ada.Streams.Write (Stream.all, T);
 500    end W_AD;
 501
 502    ----------
 503    -- W_AS --
 504    ----------
 505
 506    procedure W_AS (Stream : not null access RST; Item : Thin_Pointer) is
 507       T : constant S_AS := From_AS (Item);
 508    begin
 509       Ada.Streams.Write (Stream.all, T);
 510    end W_AS;
 511
 512    ---------
 513    -- W_B --
 514    ---------
 515
 516    procedure W_B (Stream : not null access RST; Item : Boolean) is
 517       T : S_B;
 518    begin
 519       T (1) := Boolean'Pos (Item);
 520       Ada.Streams.Write (Stream.all, T);
 521    end W_B;
 522
 523    ---------
 524    -- W_C --
 525    ---------
 526
 527    procedure W_C (Stream : not null access RST; Item : Character) is
 528       T : S_C;
 529    begin
 530       T (1) := Character'Pos (Item);
 531       Ada.Streams.Write (Stream.all, T);
 532    end W_C;
 533
 534    ---------
 535    -- W_F --
 536    ---------
 537
 538    procedure W_F (Stream : not null access RST; Item : Float) is
 539       T : constant S_F := From_F (Item);
 540    begin
 541       Ada.Streams.Write (Stream.all, T);
 542    end W_F;
 543
 544    ---------
 545    -- W_I --
 546    ---------
 547
 548    procedure W_I (Stream : not null access RST; Item : Integer) is
 549       T : constant S_I := From_I (Item);
 550    begin
 551       Ada.Streams.Write (Stream.all, T);
 552    end W_I;
 553
 554    ----------
 555    -- W_LF --
 556    ----------
 557
 558    procedure W_LF (Stream : not null access RST; Item : Long_Float) is
 559       T : constant S_LF := From_LF (Item);
 560    begin
 561       Ada.Streams.Write (Stream.all, T);
 562    end W_LF;
 563
 564    ----------
 565    -- W_LI --
 566    ----------
 567
 568    procedure W_LI (Stream : not null access RST; Item : Long_Integer) is
 569       T : constant S_LI := From_LI (Item);
 570    begin
 571       Ada.Streams.Write (Stream.all, T);
 572    end W_LI;
 573
 574    -----------
 575    -- W_LLF --
 576    -----------
 577
 578    procedure W_LLF (Stream : not null access RST; Item : Long_Long_Float) is
 579       T : constant S_LLF := From_LLF (Item);
 580    begin
 581       Ada.Streams.Write (Stream.all, T);
 582    end W_LLF;
 583
 584    -----------
 585    -- W_LLI --
 586    -----------
 587
 588    procedure W_LLI
 589      (Stream : not null access RST; Item : Long_Long_Integer)
 590    is
 591       T : constant S_LLI := From_LLI (Item);
 592    begin
 593       Ada.Streams.Write (Stream.all, T);
 594    end W_LLI;
 595
 596    -----------
 597    -- W_LLU --
 598    -----------
 599
 600    procedure W_LLU
 601      (Stream : not null access RST; Item : UST.Long_Long_Unsigned)
 602    is
 603       T : constant S_LLU := From_LLU (Item);
 604    begin
 605       Ada.Streams.Write (Stream.all, T);
 606    end W_LLU;
 607
 608    ----------
 609    -- W_LU --
 610    ----------
 611
 612    procedure W_LU
 613      (Stream : not null access RST; Item : UST.Long_Unsigned)
 614    is
 615       T : constant S_LU := From_LU (Item);
 616    begin
 617       Ada.Streams.Write (Stream.all, T);
 618    end W_LU;
 619
 620    ----------
 621    -- W_SF --
 622    ----------
 623
 624    procedure W_SF (Stream : not null access RST; Item : Short_Float) is
 625       T : constant S_SF := From_SF (Item);
 626    begin
 627       Ada.Streams.Write (Stream.all, T);
 628    end W_SF;
 629
 630    ----------
 631    -- W_SI --
 632    ----------
 633
 634    procedure W_SI (Stream : not null access RST; Item : Short_Integer) is
 635       T : constant S_SI := From_SI (Item);
 636    begin
 637       Ada.Streams.Write (Stream.all, T);
 638    end W_SI;
 639
 640    -----------
 641    -- W_SSI --
 642    -----------
 643
 644    procedure W_SSI
 645      (Stream : not null access RST; Item : Short_Short_Integer)
 646    is
 647       T : constant S_SSI := From_SSI (Item);
 648    begin
 649       Ada.Streams.Write (Stream.all, T);
 650    end W_SSI;
 651
 652    -----------
 653    -- W_SSU --
 654    -----------
 655
 656    procedure W_SSU
 657      (Stream : not null access RST; Item : UST.Short_Short_Unsigned)
 658    is
 659       T : constant S_SSU := From_SSU (Item);
 660    begin
 661       Ada.Streams.Write (Stream.all, T);
 662    end W_SSU;
 663
 664    ----------
 665    -- W_SU --
 666    ----------
 667
 668    procedure W_SU
 669      (Stream : not null access RST; Item : UST.Short_Unsigned)
 670    is
 671       T : constant S_SU := From_SU (Item);
 672    begin
 673       Ada.Streams.Write (Stream.all, T);
 674    end W_SU;
 675
 676    ---------
 677    -- W_U --
 678    ---------
 679
 680    procedure W_U (Stream : not null access RST; Item : UST.Unsigned) is
 681       T : constant S_U := From_U (Item);
 682    begin
 683       Ada.Streams.Write (Stream.all, T);
 684    end W_U;
 685
 686    ----------
 687    -- W_WC --
 688    ----------
 689
 690    procedure W_WC (Stream : not null access RST; Item : Wide_Character) is
 691       T : constant S_WC := From_WC (Item);
 692    begin
 693       Ada.Streams.Write (Stream.all, T);
 694    end W_WC;
 695
 696    -----------
 697    -- W_WWC --
 698    -----------
 699
 700    procedure W_WWC
 701      (Stream : not null access RST; Item : Wide_Wide_Character)
 702    is
 703       T : constant S_WWC := From_WWC (Item);
 704    begin
 705       Ada.Streams.Write (Stream.all, T);
 706    end W_WWC;
 707
 708 end System.Stream_Attributes;