gcc/ada/a-stzfix.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT RUNTIME COMPONENTS                          --
   4 --                                                                          --
   5 --               A D A . S T R I N G S . W I D E _ F I X E D                --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2005 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 2,  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.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  19 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  20 -- MA 02111-1307, USA.                                                      --
  21 --                                                                          --
  22 -- As a special exception,  if other files  instantiate  generics from this --
  23 -- unit, or you link  this unit with other files  to produce an executable, --
  24 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  25 -- covered  by the  GNU  General  Public  License.  This exception does not --
  26 -- however invalidate  any other reasons why  the executable file  might be --
  27 -- covered by the  GNU Public License.                                      --
  28 --                                                                          --
  29 -- GNAT was originally developed  by the GNAT team at  New York University. --
  30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  31 --                                                                          --
  32 ------------------------------------------------------------------------------
  33
  34 with Ada.Strings.Wide_Wide_Maps; use Ada.Strings.Wide_Wide_Maps;
  35 with Ada.Strings.Wide_Wide_Search;
  36
  37 package body Ada.Strings.Wide_Wide_Fixed is
  38
  39    ------------------------
  40    -- Search Subprograms --
  41    ------------------------
  42
  43    function Index
  44      (Source  : Wide_Wide_String;
  45       Pattern : Wide_Wide_String;
  46       Going   : Direction := Forward;
  47       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
  48                   Wide_Wide_Maps.Identity)
  49       return Natural
  50    renames Ada.Strings.Wide_Wide_Search.Index;
  51
  52    function Index
  53      (Source  : Wide_Wide_String;
  54       Pattern : Wide_Wide_String;
  55       Going   : Direction := Forward;
  56       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function)
  57       return Natural
  58    renames Ada.Strings.Wide_Wide_Search.Index;
  59
  60    function Index
  61      (Source : Wide_Wide_String;
  62       Set    : Wide_Wide_Maps.Wide_Wide_Character_Set;
  63       Test   : Membership := Inside;
  64       Going  : Direction  := Forward) return Natural
  65    renames Ada.Strings.Wide_Wide_Search.Index;
  66
  67    function Index
  68      (Source  : Wide_Wide_String;
  69       Pattern : Wide_Wide_String;
  70       From    : Positive;
  71       Going   : Direction := Forward;
  72       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
  73                   Wide_Wide_Maps.Identity)
  74       return Natural
  75    renames Ada.Strings.Wide_Wide_Search.Index;
  76
  77    function Index
  78      (Source  : Wide_Wide_String;
  79       Pattern : Wide_Wide_String;
  80       From    : Positive;
  81       Going   : Direction := Forward;
  82       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function)
  83       return Natural
  84    renames Ada.Strings.Wide_Wide_Search.Index;
  85
  86    function Index
  87      (Source  : Wide_Wide_String;
  88       Set     : Wide_Wide_Maps.Wide_Wide_Character_Set;
  89       From    : Positive;
  90       Test    : Membership := Inside;
  91       Going   : Direction := Forward) return Natural
  92    renames Ada.Strings.Wide_Wide_Search.Index;
  93
  94    function Index_Non_Blank
  95      (Source : Wide_Wide_String;
  96       Going  : Direction := Forward) return Natural
  97       renames Ada.Strings.Wide_Wide_Search.Index_Non_Blank;
  98
  99    function Index_Non_Blank
 100      (Source : Wide_Wide_String;
 101       From   : Positive;
 102       Going  : Direction := Forward) return Natural
 103    renames Ada.Strings.Wide_Wide_Search.Index_Non_Blank;
 104
 105    function Count
 106      (Source  : Wide_Wide_String;
 107       Pattern : Wide_Wide_String;
 108       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping :=
 109                   Wide_Wide_Maps.Identity)
 110       return Natural
 111    renames Ada.Strings.Wide_Wide_Search.Count;
 112
 113    function Count
 114      (Source  : Wide_Wide_String;
 115       Pattern : Wide_Wide_String;
 116       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function)
 117       return Natural
 118    renames Ada.Strings.Wide_Wide_Search.Count;
 119
 120    function Count
 121      (Source : Wide_Wide_String;
 122       Set    : Wide_Wide_Maps.Wide_Wide_Character_Set) return Natural
 123    renames Ada.Strings.Wide_Wide_Search.Count;
 124
 125    procedure Find_Token
 126      (Source : Wide_Wide_String;
 127       Set    : Wide_Wide_Maps.Wide_Wide_Character_Set;
 128       Test   : Membership;
 129       First  : out Positive;
 130       Last   : out Natural)
 131    renames Ada.Strings.Wide_Wide_Search.Find_Token;
 132
 133    ---------
 134    -- "*" --
 135    ---------
 136
 137    function "*"
 138      (Left  : Natural;
 139       Right : Wide_Wide_Character) return Wide_Wide_String
 140    is
 141       Result : Wide_Wide_String (1 .. Left);
 142
 143    begin
 144       for J in Result'Range loop
 145          Result (J) := Right;
 146       end loop;
 147
 148       return Result;
 149    end "*";
 150
 151    function "*"
 152      (Left  : Natural;
 153       Right : Wide_Wide_String) return Wide_Wide_String
 154    is
 155       Result : Wide_Wide_String (1 .. Left * Right'Length);
 156       Ptr    : Integer := 1;
 157
 158    begin
 159       for J in 1 .. Left loop
 160          Result (Ptr .. Ptr + Right'Length - 1) := Right;
 161          Ptr := Ptr + Right'Length;
 162       end loop;
 163
 164       return Result;
 165    end "*";
 166
 167    ------------
 168    -- Delete --
 169    ------------
 170
 171    function Delete
 172      (Source  : Wide_Wide_String;
 173       From    : Positive;
 174       Through : Natural) return Wide_Wide_String
 175    is
 176    begin
 177       if From not in Source'Range
 178         or else Through > Source'Last
 179       then
 180          raise Index_Error;
 181
 182       elsif From > Through then
 183          return Source;
 184
 185       else
 186          declare
 187             Len    : constant Integer := Source'Length - (Through - From + 1);
 188             Result : constant Wide_Wide_String
 189                        (Source'First .. Source'First + Len - 1) :=
 190                           Source (Source'First .. From - 1) &
 191                           Source (Through + 1 .. Source'Last);
 192          begin
 193             return Result;
 194          end;
 195       end if;
 196    end Delete;
 197
 198    procedure Delete
 199      (Source  : in out Wide_Wide_String;
 200       From    : Positive;
 201       Through : Natural;
 202       Justify : Alignment := Left;
 203       Pad     : Wide_Wide_Character := Wide_Wide_Space)
 204    is
 205    begin
 206       Move (Source  => Delete (Source, From, Through),
 207             Target  => Source,
 208             Justify => Justify,
 209             Pad     => Pad);
 210    end Delete;
 211
 212    ----------
 213    -- Head --
 214    ----------
 215
 216    function Head
 217      (Source : Wide_Wide_String;
 218       Count  : Natural;
 219       Pad    : Wide_Wide_Character := Wide_Wide_Space) return Wide_Wide_String
 220    is
 221       Result : Wide_Wide_String (1 .. Count);
 222
 223    begin
 224       if Count <= Source'Length then
 225          Result := Source (Source'First .. Source'First + Count - 1);
 226
 227       else
 228          Result (1 .. Source'Length) := Source;
 229
 230          for J in Source'Length + 1 .. Count loop
 231             Result (J) := Pad;
 232          end loop;
 233       end if;
 234
 235       return Result;
 236    end Head;
 237
 238    procedure Head
 239      (Source  : in out Wide_Wide_String;
 240       Count   : Natural;
 241       Justify : Alignment := Left;
 242       Pad     : Wide_Wide_Character := Ada.Strings.Wide_Wide_Space)
 243    is
 244    begin
 245       Move (Source  => Head (Source, Count, Pad),
 246             Target  => Source,
 247             Drop    => Error,
 248             Justify => Justify,
 249             Pad     => Pad);
 250    end Head;
 251
 252    ------------
 253    -- Insert --
 254    ------------
 255
 256    function Insert
 257      (Source   : Wide_Wide_String;
 258       Before   : Positive;
 259       New_Item : Wide_Wide_String) return Wide_Wide_String
 260    is
 261       Result : Wide_Wide_String (1 .. Source'Length + New_Item'Length);
 262
 263    begin
 264       if Before < Source'First or else Before > Source'Last + 1 then
 265          raise Index_Error;
 266       end if;
 267
 268       Result := Source (Source'First .. Before - 1) & New_Item &
 269                 Source (Before .. Source'Last);
 270       return Result;
 271    end Insert;
 272
 273    procedure Insert
 274      (Source   : in out Wide_Wide_String;
 275       Before   : Positive;
 276       New_Item : Wide_Wide_String;
 277       Drop     : Truncation := Error)
 278    is
 279    begin
 280       Move (Source => Insert (Source, Before, New_Item),
 281             Target => Source,
 282             Drop   => Drop);
 283    end Insert;
 284
 285    ----------
 286    -- Move --
 287    ----------
 288
 289    procedure Move
 290      (Source  : Wide_Wide_String;
 291       Target  : out Wide_Wide_String;
 292       Drop    : Truncation := Error;
 293       Justify : Alignment  := Left;
 294       Pad     : Wide_Wide_Character  := Wide_Wide_Space)
 295    is
 296       Sfirst  : constant Integer := Source'First;
 297       Slast   : constant Integer := Source'Last;
 298       Slength : constant Integer := Source'Length;
 299
 300       Tfirst  : constant Integer := Target'First;
 301       Tlast   : constant Integer := Target'Last;
 302       Tlength : constant Integer := Target'Length;
 303
 304       function Is_Padding (Item : Wide_Wide_String) return Boolean;
 305       --  Determinbe if all characters in Item are pad characters
 306
 307       function Is_Padding (Item : Wide_Wide_String) return Boolean is
 308       begin
 309          for J in Item'Range loop
 310             if Item (J) /= Pad then
 311                return False;
 312             end if;
 313          end loop;
 314
 315          return True;
 316       end Is_Padding;
 317
 318    --  Start of processing for Move
 319
 320    begin
 321       if Slength = Tlength then
 322          Target := Source;
 323
 324       elsif Slength > Tlength then
 325
 326          case Drop is
 327             when Left =>
 328                Target := Source (Slast - Tlength + 1 .. Slast);
 329
 330             when Right =>
 331                Target := Source (Sfirst .. Sfirst + Tlength - 1);
 332
 333             when Error =>
 334                case Justify is
 335                   when Left =>
 336                      if Is_Padding (Source (Sfirst + Tlength .. Slast)) then
 337                         Target :=
 338                           Source (Sfirst .. Sfirst + Target'Length - 1);
 339                      else
 340                         raise Length_Error;
 341                      end if;
 342
 343                   when Right =>
 344                      if Is_Padding (Source (Sfirst .. Slast - Tlength)) then
 345                         Target := Source (Slast - Tlength + 1 .. Slast);
 346                      else
 347                         raise Length_Error;
 348                      end if;
 349
 350                   when Center =>
 351                      raise Length_Error;
 352                end case;
 353
 354          end case;
 355
 356       --  Source'Length < Target'Length
 357
 358       else
 359          case Justify is
 360             when Left =>
 361                Target (Tfirst .. Tfirst + Slength - 1) := Source;
 362
 363                for J in Tfirst + Slength .. Tlast loop
 364                   Target (J) := Pad;
 365                end loop;
 366
 367             when Right =>
 368                for J in Tfirst .. Tlast - Slength loop
 369                   Target (J) := Pad;
 370                end loop;
 371
 372                Target (Tlast - Slength + 1 .. Tlast) := Source;
 373
 374             when Center =>
 375                declare
 376                   Front_Pad   : constant Integer := (Tlength - Slength) / 2;
 377                   Tfirst_Fpad : constant Integer := Tfirst + Front_Pad;
 378
 379                begin
 380                   for J in Tfirst .. Tfirst_Fpad - 1 loop
 381                      Target (J) := Pad;
 382                   end loop;
 383
 384                   Target (Tfirst_Fpad .. Tfirst_Fpad + Slength - 1) := Source;
 385
 386                   for J in Tfirst_Fpad + Slength .. Tlast loop
 387                      Target (J) := Pad;
 388                   end loop;
 389                end;
 390          end case;
 391       end if;
 392    end Move;
 393
 394    ---------------
 395    -- Overwrite --
 396    ---------------
 397
 398    function Overwrite
 399      (Source   : Wide_Wide_String;
 400       Position : Positive;
 401       New_Item : Wide_Wide_String) return Wide_Wide_String
 402    is
 403    begin
 404       if Position not in Source'First .. Source'Last + 1 then
 405          raise Index_Error;
 406       else
 407          declare
 408             Result_Length : constant Natural :=
 409                               Natural'Max
 410                                 (Source'Length,
 411                                  Position - Source'First + New_Item'Length);
 412
 413             Result : Wide_Wide_String (1 .. Result_Length);
 414
 415          begin
 416             Result := Source (Source'First .. Position - 1) & New_Item &
 417                         Source (Position + New_Item'Length .. Source'Last);
 418             return Result;
 419          end;
 420       end if;
 421    end Overwrite;
 422
 423    procedure Overwrite
 424      (Source   : in out Wide_Wide_String;
 425       Position : Positive;
 426       New_Item : Wide_Wide_String;
 427       Drop     : Truncation := Right)
 428    is
 429    begin
 430       Move (Source => Overwrite (Source, Position, New_Item),
 431             Target => Source,
 432             Drop   => Drop);
 433    end Overwrite;
 434
 435    -------------------
 436    -- Replace_Slice --
 437    -------------------
 438
 439    function Replace_Slice
 440      (Source : Wide_Wide_String;
 441       Low    : Positive;
 442       High   : Natural;
 443       By     : Wide_Wide_String) return Wide_Wide_String
 444    is
 445       Result_Length : Natural;
 446
 447    begin
 448       if Low > Source'Last + 1 or else High < Source'First - 1 then
 449          raise Index_Error;
 450       else
 451          Result_Length :=
 452            Source'Length - Natural'Max (High - Low + 1, 0) + By'Length;
 453
 454          declare
 455             Result : Wide_Wide_String (1 .. Result_Length);
 456
 457          begin
 458             if High >= Low then
 459                Result :=
 460                   Source (Source'First .. Low - 1) & By &
 461                   Source (High + 1 .. Source'Last);
 462             else
 463                Result := Source (Source'First .. Low - 1) & By &
 464                          Source (Low .. Source'Last);
 465             end if;
 466
 467             return Result;
 468          end;
 469       end if;
 470    end Replace_Slice;
 471
 472    procedure Replace_Slice
 473      (Source   : in out Wide_Wide_String;
 474       Low      : Positive;
 475       High     : Natural;
 476       By       : Wide_Wide_String;
 477       Drop     : Truncation := Error;
 478       Justify  : Alignment  := Left;
 479       Pad      : Wide_Wide_Character  := Wide_Wide_Space)
 480    is
 481    begin
 482       Move (Replace_Slice (Source, Low, High, By), Source, Drop, Justify, Pad);
 483    end Replace_Slice;
 484
 485    ----------
 486    -- Tail --
 487    ----------
 488
 489    function Tail
 490      (Source : Wide_Wide_String;
 491       Count  : Natural;
 492       Pad    : Wide_Wide_Character := Wide_Wide_Space) return Wide_Wide_String
 493    is
 494       Result : Wide_Wide_String (1 .. Count);
 495
 496    begin
 497       if Count < Source'Length then
 498          Result := Source (Source'Last - Count + 1 .. Source'Last);
 499
 500       --  Pad on left
 501
 502       else
 503          for J in 1 .. Count - Source'Length loop
 504             Result (J) := Pad;
 505          end loop;
 506
 507          Result (Count - Source'Length + 1 .. Count) := Source;
 508       end if;
 509
 510       return Result;
 511    end Tail;
 512
 513    procedure Tail
 514      (Source  : in out Wide_Wide_String;
 515       Count   : Natural;
 516       Justify : Alignment := Left;
 517       Pad     : Wide_Wide_Character := Ada.Strings.Wide_Wide_Space)
 518    is
 519    begin
 520       Move (Source  => Tail (Source, Count, Pad),
 521             Target  => Source,
 522             Drop    => Error,
 523             Justify => Justify,
 524             Pad     => Pad);
 525    end Tail;
 526
 527    ---------------
 528    -- Translate --
 529    ---------------
 530
 531    function Translate
 532      (Source  : Wide_Wide_String;
 533       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping)
 534       return Wide_Wide_String
 535    is
 536       Result : Wide_Wide_String (1 .. Source'Length);
 537
 538    begin
 539       for J in Source'Range loop
 540          Result (J - (Source'First - 1)) := Value (Mapping, Source (J));
 541       end loop;
 542
 543       return Result;
 544    end Translate;
 545
 546    procedure Translate
 547      (Source  : in out Wide_Wide_String;
 548       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping)
 549    is
 550    begin
 551       for J in Source'Range loop
 552          Source (J) := Value (Mapping, Source (J));
 553       end loop;
 554    end Translate;
 555
 556    function Translate
 557      (Source  : Wide_Wide_String;
 558       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function)
 559       return Wide_Wide_String
 560    is
 561       Result : Wide_Wide_String (1 .. Source'Length);
 562
 563    begin
 564       for J in Source'Range loop
 565          Result (J - (Source'First - 1)) := Mapping (Source (J));
 566       end loop;
 567
 568       return Result;
 569    end Translate;
 570
 571    procedure Translate
 572      (Source  : in out Wide_Wide_String;
 573       Mapping : Wide_Wide_Maps.Wide_Wide_Character_Mapping_Function)
 574    is
 575    begin
 576       for J in Source'Range loop
 577          Source (J) := Mapping (Source (J));
 578       end loop;
 579    end Translate;
 580
 581    ----------
 582    -- Trim --
 583    ----------
 584
 585    function Trim
 586      (Source : Wide_Wide_String;
 587       Side   : Trim_End) return Wide_Wide_String
 588    is
 589       Low  : Natural := Source'First;
 590       High : Natural := Source'Last;
 591
 592    begin
 593       if Side = Left or else Side = Both then
 594          while Low <= High and then Source (Low) = Wide_Wide_Space loop
 595             Low := Low + 1;
 596          end loop;
 597       end if;
 598
 599       if Side = Right or else Side = Both then
 600          while High >= Low and then Source (High) = Wide_Wide_Space loop
 601             High := High - 1;
 602          end loop;
 603       end if;
 604
 605       --  All blanks case
 606
 607       if Low > High then
 608          return "";
 609
 610       --  At least one non-blank
 611
 612       else
 613          declare
 614             Result : constant Wide_Wide_String (1 .. High - Low + 1) :=
 615                        Source (Low .. High);
 616
 617          begin
 618             return Result;
 619          end;
 620       end if;
 621    end Trim;
 622
 623    procedure Trim
 624      (Source  : in out Wide_Wide_String;
 625       Side    : Trim_End;
 626       Justify : Alignment      := Left;
 627       Pad     : Wide_Wide_Character := Wide_Wide_Space)
 628    is
 629    begin
 630       Move (Source  => Trim (Source, Side),
 631             Target  => Source,
 632             Justify => Justify,
 633             Pad     => Pad);
 634    end Trim;
 635
 636    function Trim
 637       (Source : Wide_Wide_String;
 638        Left   : Wide_Wide_Maps.Wide_Wide_Character_Set;
 639        Right  : Wide_Wide_Maps.Wide_Wide_Character_Set) return Wide_Wide_String
 640    is
 641       Low  : Natural := Source'First;
 642       High : Natural := Source'Last;
 643
 644    begin
 645       while Low <= High and then Is_In (Source (Low), Left) loop
 646          Low := Low + 1;
 647       end loop;
 648
 649       while High >= Low and then Is_In (Source (High), Right) loop
 650          High := High - 1;
 651       end loop;
 652
 653       --  Case where source comprises only characters in the sets
 654
 655       if Low > High then
 656          return "";
 657       else
 658          declare
 659             subtype WS is Wide_Wide_String (1 .. High - Low + 1);
 660
 661          begin
 662             return WS (Source (Low .. High));
 663          end;
 664       end if;
 665    end Trim;
 666
 667    procedure Trim
 668       (Source  : in out Wide_Wide_String;
 669        Left    : Wide_Wide_Maps.Wide_Wide_Character_Set;
 670        Right   : Wide_Wide_Maps.Wide_Wide_Character_Set;
 671        Justify : Alignment      := Strings.Left;
 672        Pad     : Wide_Wide_Character := Wide_Wide_Space)
 673    is
 674    begin
 675       Move (Source  => Trim (Source, Left, Right),
 676             Target  => Source,
 677             Justify => Justify,
 678             Pad     => Pad);
 679    end Trim;
 680
 681 end Ada.Strings.Wide_Wide_Fixed;