gcc/ada/switch-c.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                             S W I T C H - C                              --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 2001-2010, 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.  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 COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 with Debug;    use Debug;
  27 with Lib;      use Lib;
  28 with Osint;    use Osint;
  29 with Opt;      use Opt;
  30 with Prepcomp; use Prepcomp;
  31 with Validsw;  use Validsw;
  32 with Sem_Warn; use Sem_Warn;
  33 with Stylesw;  use Stylesw;
  34
  35 with System.Strings;
  36 with System.WCh_Con; use System.WCh_Con;
  37
  38 package body Switch.C is
  39
  40    RTS_Specified : String_Access := null;
  41    --  Used to detect multiple use of --RTS= flag
  42
  43    function Switch_Subsequently_Cancelled
  44      (C        : String;
  45       Args     : Argument_List;
  46       Arg_Rank : Positive) return Boolean;
  47    --  This function is called from Scan_Front_End_Switches. It determines if
  48    --  the switch currently being scanned is followed by a switch of the form
  49    --  "-gnat-" & C, where C is the argument. If so, then True is returned,
  50    --  and Scan_Front_End_Switches will cancel the effect of the switch. If
  51    --  no such switch is found, False is returned.
  52
  53    -----------------------------
  54    -- Scan_Front_End_Switches --
  55    -----------------------------
  56
  57    procedure Scan_Front_End_Switches
  58      (Switch_Chars : String;
  59       Args         : Argument_List;
  60       Arg_Rank     : Positive)
  61    is
  62       First_Switch : Boolean := True;
  63       --  False for all but first switch
  64
  65       Max : constant Natural := Switch_Chars'Last;
  66       Ptr : Natural;
  67       C   : Character := ' ';
  68       Dot : Boolean;
  69
  70       Store_Switch : Boolean;
  71       --  For -gnatxx switches, the normal processing, signalled by this flag
  72       --  being set to True, is to store the switch on exit from the case
  73       --  statement, the switch stored is -gnat followed by the characters
  74       --  from First_Char to Ptr-1. For cases like -gnaty, where the switch
  75       --  is stored in separate pieces, this flag is set to False, and the
  76       --  appropriate calls to Store_Compilation_Switch are made from within
  77       --  the case branch.
  78
  79       First_Char : Positive;
  80       --  Marks start of switch to be stored
  81
  82    begin
  83       Ptr := Switch_Chars'First;
  84
  85       --  Skip past the initial character (must be the switch character)
  86
  87       if Ptr = Max then
  88          Bad_Switch (C);
  89       else
  90          Ptr := Ptr + 1;
  91       end if;
  92
  93       --  Handle switches that do not start with -gnat
  94
  95       if Ptr + 3 > Max
  96         or else Switch_Chars (Ptr .. Ptr + 3) /= "gnat"
  97       then
  98          --  There are two front-end switches that do not start with -gnat:
  99          --  -I, --RTS
 100
 101          if Switch_Chars (Ptr) = 'I' then
 102
 103             --  Set flag Search_Directory_Present if switch is "-I" only:
 104             --  the directory will be the next argument.
 105
 106             if Ptr = Max then
 107                Search_Directory_Present := True;
 108                return;
 109             end if;
 110
 111             Ptr := Ptr + 1;
 112
 113             --  Find out whether this is a -I- or regular -Ixxx switch
 114
 115             --  Note: -I switches are not recorded in the ALI file, since the
 116             --  meaning of the program depends on the source files compiled,
 117             --  not where they came from.
 118
 119             if Ptr = Max and then Switch_Chars (Ptr) = '-' then
 120                Look_In_Primary_Dir := False;
 121             else
 122                Add_Src_Search_Dir (Switch_Chars (Ptr .. Max));
 123             end if;
 124
 125          --  Processing of the --RTS switch. --RTS may have been modified by
 126          --  gcc into -fRTS (for GCC targets).
 127
 128          elsif Ptr + 3 <= Max
 129            and then (Switch_Chars (Ptr .. Ptr + 3) = "fRTS"
 130                        or else
 131                      Switch_Chars (Ptr .. Ptr + 3) = "-RTS")
 132          then
 133             Ptr := Ptr + 1;
 134
 135             if Ptr + 4 > Max
 136               or else Switch_Chars (Ptr + 3) /= '='
 137             then
 138                Osint.Fail ("missing path for --RTS");
 139             else
 140                --  Check that this is the first time --RTS is specified or if
 141                --  it is not the first time, the same path has been specified.
 142
 143                if RTS_Specified = null then
 144                   RTS_Specified := new String'(Switch_Chars (Ptr + 4 .. Max));
 145
 146                elsif
 147                  RTS_Specified.all /= Switch_Chars (Ptr + 4 .. Max)
 148                then
 149                   Osint.Fail ("--RTS cannot be specified multiple times");
 150                end if;
 151
 152                --  Valid --RTS switch
 153
 154                Opt.No_Stdinc := True;
 155                Opt.RTS_Switch := True;
 156
 157                RTS_Src_Path_Name :=
 158                  Get_RTS_Search_Dir
 159                    (Switch_Chars (Ptr + 4 .. Max), Include);
 160
 161                RTS_Lib_Path_Name :=
 162                  Get_RTS_Search_Dir
 163                    (Switch_Chars (Ptr + 4 .. Max), Objects);
 164
 165                if RTS_Src_Path_Name /= null
 166                  and then RTS_Lib_Path_Name /= null
 167                then
 168                   --  Store the -fRTS switch (Note: Store_Compilation_Switch
 169                   --  changes -fRTS back into --RTS for the actual output).
 170
 171                   Store_Compilation_Switch (Switch_Chars);
 172
 173                elsif RTS_Src_Path_Name = null
 174                  and then RTS_Lib_Path_Name = null
 175                then
 176                   Osint.Fail ("RTS path not valid: missing " &
 177                               "adainclude and adalib directories");
 178
 179                elsif RTS_Src_Path_Name = null then
 180                   Osint.Fail ("RTS path not valid: missing " &
 181                               "adainclude directory");
 182
 183                elsif RTS_Lib_Path_Name = null then
 184                   Osint.Fail ("RTS path not valid: missing " &
 185                               "adalib directory");
 186                end if;
 187             end if;
 188
 189             --  There are no other switches not starting with -gnat
 190
 191          else
 192             Bad_Switch (Switch_Chars);
 193          end if;
 194
 195       --  Case of switch starting with -gnat
 196
 197       else
 198          Ptr := Ptr + 4;
 199
 200          --  Loop to scan through switches given in switch string
 201
 202          while Ptr <= Max loop
 203             First_Char := Ptr;
 204             Store_Switch := True;
 205
 206             C := Switch_Chars (Ptr);
 207
 208             case C is
 209
 210             when 'a' =>
 211                Ptr := Ptr + 1;
 212                Assertions_Enabled := True;
 213                Debug_Pragmas_Enabled := True;
 214
 215             --  Processing for A switch
 216
 217             when 'A' =>
 218                Ptr := Ptr + 1;
 219                Config_File := False;
 220
 221             --  Processing for b switch
 222
 223             when 'b' =>
 224                Ptr := Ptr + 1;
 225                Brief_Output := True;
 226
 227             --  Processing for B switch
 228
 229             when 'B' =>
 230                Ptr := Ptr + 1;
 231                Assume_No_Invalid_Values := True;
 232
 233             --  Processing for c switch
 234
 235             when 'c' =>
 236                if not First_Switch then
 237                   Osint.Fail
 238                     ("-gnatc must be first if combined with other switches");
 239                end if;
 240
 241                Ptr := Ptr + 1;
 242                Operating_Mode := Check_Semantics;
 243
 244             --  Processing for C switch
 245
 246             when 'C' =>
 247                Ptr := Ptr + 1;
 248
 249                if not CodePeer_Mode then
 250                   CodePeer_Mode := True;
 251
 252                   --  Suppress compiler warnings by default, since what we are
 253                   --  interested in here is what CodePeer can find out. Note
 254                   --  that if -gnatwxxx is specified after -gnatC on the
 255                   --  command line, we do not want to override this setting in
 256                   --  Adjust_Global_Switches, and assume that the user wants to
 257                   --  get both warnings from GNAT and CodePeer messages.
 258
 259                   Warning_Mode := Suppress;
 260                end if;
 261
 262             --  Processing for d switch
 263
 264             when 'd' =>
 265                Store_Switch := False;
 266                Dot := False;
 267
 268                --  Note: for the debug switch, the remaining characters in this
 269                --  switch field must all be debug flags, since all valid switch
 270                --  characters are also valid debug characters.
 271
 272                --  Loop to scan out debug flags
 273
 274                while Ptr < Max loop
 275                   Ptr := Ptr + 1;
 276                   C := Switch_Chars (Ptr);
 277                   exit when C = ASCII.NUL or else C = '/' or else C = '-';
 278
 279                   if C in '1' .. '9' or else
 280                      C in 'a' .. 'z' or else
 281                      C in 'A' .. 'Z'
 282                   then
 283                      if Dot then
 284                         Set_Dotted_Debug_Flag (C);
 285                         Store_Compilation_Switch ("-gnatd." & C);
 286                      else
 287                         Set_Debug_Flag (C);
 288                         Store_Compilation_Switch ("-gnatd" & C);
 289                      end if;
 290
 291                   elsif C = '.' then
 292                      Dot := True;
 293
 294                   elsif Dot then
 295                      Bad_Switch ("-gnatd." & Switch_Chars (Ptr .. Max));
 296                   else
 297                      Bad_Switch ("-gnatd" & Switch_Chars (Ptr .. Max));
 298                   end if;
 299                end loop;
 300
 301                return;
 302
 303             --  Processing for D switch
 304
 305             when 'D' =>
 306                Ptr := Ptr + 1;
 307
 308                --  Scan optional integer line limit value
 309
 310                if Nat_Present (Switch_Chars, Max, Ptr) then
 311                   Scan_Nat (Switch_Chars, Max, Ptr, Sprint_Line_Limit, 'D');
 312                   Sprint_Line_Limit := Nat'Max (Sprint_Line_Limit, 40);
 313                end if;
 314
 315                --  Note: -gnatD also sets -gnatx (to turn off cross-reference
 316                --  generation in the ali file) since otherwise this generation
 317                --  gets confused by the "wrong" Sloc values put in the tree.
 318
 319                Debug_Generated_Code := True;
 320                Xref_Active := False;
 321                Set_Debug_Flag ('g');
 322
 323             --  -gnate? (extended switches)
 324
 325             when 'e' =>
 326                Ptr := Ptr + 1;
 327
 328                --  The -gnate? switches are all double character switches
 329                --  so we must always have a character after the e.
 330
 331                if Ptr > Max then
 332                   Bad_Switch ("-gnate");
 333                end if;
 334
 335                case Switch_Chars (Ptr) is
 336
 337                   --  -gnatea (initial delimiter of explicit switches)
 338
 339                   --  All switches that come before -gnatea have been added by
 340                   --  the GCC driver and are not stored in the ALI file.
 341                   --  See also -gnatez below.
 342
 343                   when 'a' =>
 344                      Store_Switch := False;
 345                      Enable_Switch_Storing;
 346                      Ptr := Ptr + 1;
 347
 348                   --  -gnatec (configuration pragmas)
 349
 350                   when 'c' =>
 351                      Store_Switch := False;
 352                      Ptr := Ptr + 1;
 353
 354                      --  There may be an equal sign between -gnatec and
 355                      --  the path name of the config file.
 356
 357                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 358                         Ptr := Ptr + 1;
 359                      end if;
 360
 361                      if Ptr > Max then
 362                         Bad_Switch ("-gnatec");
 363                      end if;
 364
 365                      declare
 366                         Config_File_Name : constant String_Access :=
 367                                              new String'
 368                                                   (Switch_Chars (Ptr .. Max));
 369
 370                      begin
 371                         if Config_File_Names = null then
 372                            Config_File_Names :=
 373                              new String_List'(1 => Config_File_Name);
 374
 375                         else
 376                            declare
 377                               New_Names : constant String_List_Access :=
 378                                             new String_List
 379                                               (1 ..
 380                                                Config_File_Names'Length + 1);
 381
 382                            begin
 383                               for Index in Config_File_Names'Range loop
 384                                  New_Names (Index) :=
 385                                    Config_File_Names (Index);
 386                                  Config_File_Names (Index) := null;
 387                               end loop;
 388
 389                               New_Names (New_Names'Last) := Config_File_Name;
 390                               Free (Config_File_Names);
 391                               Config_File_Names := New_Names;
 392                            end;
 393                         end if;
 394                      end;
 395
 396                      return;
 397
 398                   --  -gnateC switch (CodePeer SCIL generation)
 399
 400                   --  Not enabled for now, keep it for later???
 401                   --  use -gnatd.I only for now
 402
 403                   --  when 'C' =>
 404                   --     Ptr := Ptr + 1;
 405                   --     Generate_SCIL := True;
 406
 407                   --  -gnateD switch (preprocessing symbol definition)
 408
 409                   when 'D' =>
 410                      Store_Switch := False;
 411                      Ptr := Ptr + 1;
 412
 413                      if Ptr > Max then
 414                         Bad_Switch ("-gnateD");
 415                      end if;
 416
 417                      Add_Symbol_Definition (Switch_Chars (Ptr .. Max));
 418
 419                      --  Store the switch
 420
 421                      Store_Compilation_Switch
 422                        ("-gnateD" & Switch_Chars (Ptr .. Max));
 423                      Ptr := Max + 1;
 424
 425                   --  -gnatef (full source path for brief error messages)
 426
 427                   when 'f' =>
 428                      Store_Switch := False;
 429                      Ptr := Ptr + 1;
 430                      Full_Path_Name_For_Brief_Errors := True;
 431
 432                   --  -gnateG (save preprocessor output)
 433
 434                   when 'G' =>
 435                      Generate_Processed_File := True;
 436                      Ptr := Ptr + 1;
 437
 438                   --  -gnateI (index of unit in multi-unit source)
 439
 440                   when 'I' =>
 441                      Ptr := Ptr + 1;
 442                      Scan_Pos (Switch_Chars, Max, Ptr, Multiple_Unit_Index, C);
 443
 444                   --  -gnatem (mapping file)
 445
 446                   when 'm' =>
 447                      Store_Switch := False;
 448                      Ptr := Ptr + 1;
 449
 450                      --  There may be an equal sign between -gnatem and
 451                      --  the path name of the mapping file.
 452
 453                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 454                         Ptr := Ptr + 1;
 455                      end if;
 456
 457                      if Ptr > Max then
 458                         Bad_Switch ("-gnatem");
 459                      end if;
 460
 461                      Mapping_File_Name :=
 462                        new String'(Switch_Chars (Ptr .. Max));
 463                      return;
 464
 465                   --  -gnatep (preprocessing data file)
 466
 467                   when 'p' =>
 468                      Store_Switch := False;
 469                      Ptr := Ptr + 1;
 470
 471                      --  There may be an equal sign between -gnatep and
 472                      --  the path name of the mapping file.
 473
 474                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 475                         Ptr := Ptr + 1;
 476                      end if;
 477
 478                      if Ptr > Max then
 479                         Bad_Switch ("-gnatep");
 480                      end if;
 481
 482                      Preprocessing_Data_File :=
 483                        new String'(Switch_Chars (Ptr .. Max));
 484
 485                      --  Store the switch, normalizing to -gnatep=
 486
 487                      Store_Compilation_Switch
 488                        ("-gnatep=" & Preprocessing_Data_File.all);
 489
 490                      Ptr := Max + 1;
 491
 492                   --  -gnatez (final delimiter of explicit switches)
 493
 494                   --  All switches that come after -gnatez have been added by
 495                   --  the GCC driver and are not stored in the ALI file. See
 496                   --  also -gnatea above.
 497
 498                   when 'z' =>
 499                      Store_Switch := False;
 500                      Disable_Switch_Storing;
 501                      Ptr := Ptr + 1;
 502
 503                   --  -gnateS (generate SCO information)
 504
 505                   --  Include Source Coverage Obligation information in ALI
 506                   --  files for the benefit of source coverage analysis tools
 507                   --  (xcov).
 508
 509                   when 'S' =>
 510                      Generate_SCO := True;
 511                      Ptr := Ptr + 1;
 512
 513                   --  All other -gnate? switches are unassigned
 514
 515                   when others =>
 516                      Bad_Switch ("-gnate" & Switch_Chars (Ptr .. Max));
 517                end case;
 518
 519             --  -gnatE (dynamic elaboration checks)
 520
 521             when 'E' =>
 522                Ptr := Ptr + 1;
 523                Dynamic_Elaboration_Checks := True;
 524
 525             --  -gnatf (full error messages)
 526
 527             when 'f' =>
 528                Ptr := Ptr + 1;
 529                All_Errors_Mode := True;
 530
 531             --  Processing for F switch
 532
 533             when 'F' =>
 534                Ptr := Ptr + 1;
 535                External_Name_Exp_Casing := Uppercase;
 536                External_Name_Imp_Casing := Uppercase;
 537
 538             --  Processing for g switch
 539
 540             when 'g' =>
 541                Ptr := Ptr + 1;
 542                GNAT_Mode := True;
 543                Identifier_Character_Set := 'n';
 544                System_Extend_Unit := Empty;
 545                Warning_Mode := Treat_As_Error;
 546
 547                --  Set Ada 2012 mode explicitly. We don't want to rely on the
 548                --  implicit setting here, since for example, we want
 549                --  Preelaborate_05 treated as Preelaborate
 550
 551                Ada_Version := Ada_2012;
 552                Ada_Version_Explicit := Ada_Version;
 553
 554                --  Set default warnings and style checks for -gnatg
 555
 556                Set_GNAT_Mode_Warnings;
 557                Set_GNAT_Style_Check_Options;
 558
 559             --  Processing for G switch
 560
 561             when 'G' =>
 562                Ptr := Ptr + 1;
 563                Print_Generated_Code := True;
 564
 565                --  Scan optional integer line limit value
 566
 567                if Nat_Present (Switch_Chars, Max, Ptr) then
 568                   Scan_Nat (Switch_Chars, Max, Ptr, Sprint_Line_Limit, 'G');
 569                   Sprint_Line_Limit := Nat'Max (Sprint_Line_Limit, 40);
 570                end if;
 571
 572             --  Processing for h switch
 573
 574             when 'h' =>
 575                Ptr := Ptr + 1;
 576                Usage_Requested := True;
 577
 578             --  Processing for H switch
 579
 580             when 'H' =>
 581                Ptr := Ptr + 1;
 582                HLO_Active := True;
 583
 584             --  Processing for i switch
 585
 586             when 'i' =>
 587                if Ptr = Max then
 588                   Bad_Switch ("-gnati");
 589                end if;
 590
 591                Ptr := Ptr + 1;
 592                C := Switch_Chars (Ptr);
 593
 594                if C in '1' .. '5'
 595                  or else C = '8'
 596                  or else C = '9'
 597                  or else C = 'p'
 598                  or else C = 'f'
 599                  or else C = 'n'
 600                  or else C = 'w'
 601                then
 602                   Identifier_Character_Set := C;
 603                   Ptr := Ptr + 1;
 604
 605                else
 606                   Bad_Switch ("-gnati" & Switch_Chars (Ptr .. Max));
 607                end if;
 608
 609             --  Processing for I switch
 610
 611             when 'I' =>
 612                Ptr := Ptr + 1;
 613                Ignore_Rep_Clauses := True;
 614
 615             --  Processing for j switch
 616
 617             when 'j' =>
 618                Ptr := Ptr + 1;
 619                Scan_Nat (Switch_Chars, Max, Ptr, Error_Msg_Line_Length, C);
 620
 621             --  Processing for k switch
 622
 623             when 'k' =>
 624                Ptr := Ptr + 1;
 625                   Scan_Pos
 626                     (Switch_Chars, Max, Ptr, Maximum_File_Name_Length, C);
 627
 628             --  Processing for l switch
 629
 630             when 'l' =>
 631                Ptr := Ptr + 1;
 632                Full_List := True;
 633
 634                --  There may be an equal sign between -gnatl and a file name
 635
 636                if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 637                   if Ptr = Max then
 638                      Osint.Fail ("file name for -gnatl= is null");
 639                   else
 640                      Opt.Full_List_File_Name :=
 641                        new String'(Switch_Chars (Ptr + 1 .. Max));
 642                      Ptr := Max + 1;
 643                   end if;
 644                end if;
 645
 646             --  Processing for L switch
 647
 648             when 'L' =>
 649                Ptr := Ptr + 1;
 650                Dump_Source_Text := True;
 651
 652             --  Processing for m switch
 653
 654             when 'm' =>
 655                Ptr := Ptr + 1;
 656                Scan_Nat (Switch_Chars, Max, Ptr, Maximum_Messages, C);
 657
 658             --  Processing for n switch
 659
 660             when 'n' =>
 661                Ptr := Ptr + 1;
 662                Inline_Active := True;
 663
 664             --  Processing for N switch
 665
 666             when 'N' =>
 667                Ptr := Ptr + 1;
 668                Inline_Active := True;
 669                Front_End_Inlining := True;
 670
 671             --  Processing for o switch
 672
 673             when 'o' =>
 674                Ptr := Ptr + 1;
 675                Suppress_Options (Overflow_Check) := False;
 676                Opt.Enable_Overflow_Checks := True;
 677
 678             --  Processing for O switch
 679
 680             when 'O' =>
 681                Store_Switch := False;
 682                Ptr := Ptr + 1;
 683                Output_File_Name_Present := True;
 684
 685             --  Processing for p switch
 686
 687             when 'p' =>
 688                Ptr := Ptr + 1;
 689
 690                --  Skip processing if cancelled by subsequent -gnat-p
 691
 692                if Switch_Subsequently_Cancelled ("p", Args, Arg_Rank) then
 693                   Store_Switch := False;
 694
 695                else
 696                   --  Set all specific options as well as All_Checks in the
 697                   --  Suppress_Options array, excluding Elaboration_Check,
 698                   --  since this is treated specially because we do not want
 699                   --  -gnatp to disable static elaboration processing.
 700
 701                   for J in Suppress_Options'Range loop
 702                      if J /= Elaboration_Check then
 703                         Suppress_Options (J) := True;
 704                      end if;
 705                   end loop;
 706
 707                   Validity_Checks_On         := False;
 708                   Opt.Suppress_Checks        := True;
 709                   Opt.Enable_Overflow_Checks := False;
 710                end if;
 711
 712             --  Processing for P switch
 713
 714             when 'P' =>
 715                Ptr := Ptr + 1;
 716                Polling_Required := True;
 717
 718             --  Processing for q switch
 719
 720             when 'q' =>
 721                Ptr := Ptr + 1;
 722                Try_Semantics := True;
 723
 724             --  Processing for Q switch
 725
 726             when 'Q' =>
 727                Ptr := Ptr + 1;
 728                Force_ALI_Tree_File := True;
 729                Try_Semantics := True;
 730
 731                --  Processing for r switch
 732
 733             when 'r' =>
 734                Ptr := Ptr + 1;
 735                Treat_Restrictions_As_Warnings := True;
 736
 737             --  Processing for R switch
 738
 739             when 'R' =>
 740                Back_Annotate_Rep_Info := True;
 741                List_Representation_Info := 1;
 742
 743                Ptr := Ptr + 1;
 744                while Ptr <= Max loop
 745                   C := Switch_Chars (Ptr);
 746
 747                   if C in '1' .. '3' then
 748                      List_Representation_Info :=
 749                        Character'Pos (C) - Character'Pos ('0');
 750
 751                   elsif Switch_Chars (Ptr) = 's' then
 752                      List_Representation_Info_To_File := True;
 753
 754                   elsif Switch_Chars (Ptr) = 'm' then
 755                      List_Representation_Info_Mechanisms := True;
 756
 757                   else
 758                      Bad_Switch ("-gnatR" & Switch_Chars (Ptr .. Max));
 759                   end if;
 760
 761                   Ptr := Ptr + 1;
 762                end loop;
 763
 764             --  Processing for s switch
 765
 766             when 's' =>
 767                if not First_Switch then
 768                   Osint.Fail
 769                     ("-gnats must be first if combined with other switches");
 770                end if;
 771
 772                Ptr := Ptr + 1;
 773                Operating_Mode := Check_Syntax;
 774
 775             --  Processing for S switch
 776
 777             when 'S' =>
 778                Print_Standard := True;
 779                Ptr := Ptr + 1;
 780
 781             --  Processing for t switch
 782
 783             when 't' =>
 784                Ptr := Ptr + 1;
 785                Tree_Output := True;
 786                Back_Annotate_Rep_Info := True;
 787
 788             --  Processing for T switch
 789
 790             when 'T' =>
 791                Ptr := Ptr + 1;
 792                Scan_Pos (Switch_Chars, Max, Ptr, Table_Factor, C);
 793
 794             --  Processing for u switch
 795
 796             when 'u' =>
 797                Ptr := Ptr + 1;
 798                List_Units := True;
 799
 800             --  Processing for U switch
 801
 802             when 'U' =>
 803                Ptr := Ptr + 1;
 804                Unique_Error_Tag := True;
 805
 806             --  Processing for v switch
 807
 808             when 'v' =>
 809                Ptr := Ptr + 1;
 810                Verbose_Mode := True;
 811
 812             --  Processing for V switch
 813
 814             when 'V' =>
 815                Store_Switch := False;
 816                Ptr := Ptr + 1;
 817
 818                if Ptr > Max then
 819                   Bad_Switch ("-gnatV");
 820
 821                else
 822                   declare
 823                      OK  : Boolean;
 824
 825                   begin
 826                      Set_Validity_Check_Options
 827                        (Switch_Chars (Ptr .. Max), OK, Ptr);
 828
 829                      if not OK then
 830                         Bad_Switch ("-gnatV" & Switch_Chars (Ptr .. Max));
 831                      end if;
 832
 833                      for Index in First_Char + 1 .. Max loop
 834                         Store_Compilation_Switch
 835                           ("-gnatV" & Switch_Chars (Index));
 836                      end loop;
 837                   end;
 838                end if;
 839
 840                Ptr := Max + 1;
 841
 842             --  Processing for w switch
 843
 844             when 'w' =>
 845                Store_Switch := False;
 846                Ptr := Ptr + 1;
 847
 848                if Ptr > Max then
 849                   Bad_Switch ("-gnatw");
 850                end if;
 851
 852                while Ptr <= Max loop
 853                   C := Switch_Chars (Ptr);
 854
 855                   --  Case of dot switch
 856
 857                   if C = '.' and then Ptr < Max then
 858                      Ptr := Ptr + 1;
 859                      C := Switch_Chars (Ptr);
 860
 861                      if Set_Dot_Warning_Switch (C) then
 862                         Store_Compilation_Switch ("-gnatw." & C);
 863                      else
 864                         Bad_Switch ("-gnatw." & Switch_Chars (Ptr .. Max));
 865                      end if;
 866
 867                      --  Normal case, no dot
 868
 869                   else
 870                      if Set_Warning_Switch (C) then
 871                         Store_Compilation_Switch ("-gnatw" & C);
 872                      else
 873                         Bad_Switch ("-gnatw" & Switch_Chars (Ptr .. Max));
 874                      end if;
 875                   end if;
 876
 877                   Ptr := Ptr + 1;
 878                end loop;
 879
 880                return;
 881
 882             --  Processing for W switch
 883
 884             when 'W' =>
 885                Ptr := Ptr + 1;
 886
 887                if Ptr > Max then
 888                   Bad_Switch ("-gnatW");
 889                end if;
 890
 891                begin
 892                   Wide_Character_Encoding_Method :=
 893                     Get_WC_Encoding_Method (Switch_Chars (Ptr));
 894                exception
 895                   when Constraint_Error =>
 896                      Bad_Switch ("-gnatW" & Switch_Chars (Ptr .. Max));
 897                end;
 898
 899                Wide_Character_Encoding_Method_Specified := True;
 900
 901                Upper_Half_Encoding :=
 902                  Wide_Character_Encoding_Method in
 903                    WC_Upper_Half_Encoding_Method;
 904
 905                Ptr := Ptr + 1;
 906
 907             --  Processing for x switch
 908
 909             when 'x' =>
 910                Ptr := Ptr + 1;
 911                Xref_Active := False;
 912
 913             --  Processing for X switch
 914
 915             when 'X' =>
 916                Ptr := Ptr + 1;
 917                Extensions_Allowed := True;
 918                Ada_Version := Ada_Version_Type'Last;
 919                Ada_Version_Explicit := Ada_Version_Type'Last;
 920
 921             --  Processing for y switch
 922
 923             when 'y' =>
 924                Ptr := Ptr + 1;
 925
 926                if Ptr > Max then
 927                   Set_Default_Style_Check_Options;
 928
 929                else
 930                   Store_Switch := False;
 931
 932                   declare
 933                      OK  : Boolean;
 934
 935                   begin
 936                      Set_Style_Check_Options
 937                        (Switch_Chars (Ptr .. Max), OK, Ptr);
 938
 939                      if not OK then
 940                         Osint.Fail
 941                           ("bad -gnaty switch (" &
 942                            Style_Msg_Buf (1 .. Style_Msg_Len) & ')');
 943                      end if;
 944
 945                      Ptr := First_Char + 1;
 946                      while Ptr <= Max loop
 947                         if Switch_Chars (Ptr) = 'M' then
 948                            First_Char := Ptr;
 949                            loop
 950                               Ptr := Ptr + 1;
 951                               exit when Ptr > Max
 952                                 or else Switch_Chars (Ptr) not in '0' .. '9';
 953                            end loop;
 954
 955                            Store_Compilation_Switch
 956                              ("-gnaty" & Switch_Chars (First_Char .. Ptr - 1));
 957
 958                         else
 959                            Store_Compilation_Switch
 960                              ("-gnaty" & Switch_Chars (Ptr));
 961                            Ptr := Ptr + 1;
 962                         end if;
 963                      end loop;
 964                   end;
 965                end if;
 966
 967             --  Processing for z switch
 968
 969             when 'z' =>
 970
 971                --  -gnatz must be the first and only switch in Switch_Chars,
 972                --  and is a two-letter switch.
 973
 974                if Ptr /= Switch_Chars'First + 5
 975                  or else (Max - Ptr + 1) > 2
 976                then
 977                   Osint.Fail
 978                     ("-gnatz* may not be combined with other switches");
 979                end if;
 980
 981                if Ptr = Max then
 982                   Bad_Switch ("-gnatz");
 983                end if;
 984
 985                Ptr := Ptr + 1;
 986
 987                --  Only one occurrence of -gnat* is permitted
 988
 989                if Distribution_Stub_Mode = No_Stubs then
 990                   case Switch_Chars (Ptr) is
 991                      when 'r' =>
 992                         Distribution_Stub_Mode := Generate_Receiver_Stub_Body;
 993
 994                      when 'c' =>
 995                         Distribution_Stub_Mode := Generate_Caller_Stub_Body;
 996
 997                      when others =>
 998                         Bad_Switch ("-gnatz" & Switch_Chars (Ptr .. Max));
 999                   end case;
1000
1001                   Ptr := Ptr + 1;
1002
1003                else
1004                   Osint.Fail ("only one -gnatz* switch allowed");
1005                end if;
1006
1007             --  Processing for Z switch
1008
1009             when 'Z' =>
1010                Ptr := Ptr + 1;
1011                Osint.Fail
1012                  ("-gnatZ is no longer supported: consider using --RTS=zcx");
1013
1014             --  Processing for 83 switch
1015
1016             when '8' =>
1017                if Ptr = Max then
1018                   Bad_Switch ("-gnat8");
1019                end if;
1020
1021                Ptr := Ptr + 1;
1022
1023                if Switch_Chars (Ptr) /= '3' then
1024                   Bad_Switch ("-gnat8" & Switch_Chars (Ptr .. Max));
1025                else
1026                   Ptr := Ptr + 1;
1027                   Ada_Version := Ada_83;
1028                   Ada_Version_Explicit := Ada_Version;
1029                end if;
1030
1031             --  Processing for 95 switch
1032
1033             when '9' =>
1034                if Ptr = Max then
1035                   Bad_Switch ("-gnat9");
1036                end if;
1037
1038                Ptr := Ptr + 1;
1039
1040                if Switch_Chars (Ptr) /= '5' then
1041                   Bad_Switch ("-gnat9" & Switch_Chars (Ptr .. Max));
1042                else
1043                   Ptr := Ptr + 1;
1044                   Ada_Version := Ada_95;
1045                   Ada_Version_Explicit := Ada_Version;
1046                end if;
1047
1048             --  Processing for 05 switch
1049
1050             when '0' =>
1051                if Ptr = Max then
1052                   Bad_Switch ("-gnat0");
1053                end if;
1054
1055                Ptr := Ptr + 1;
1056
1057                if Switch_Chars (Ptr) /= '5' then
1058                   Bad_Switch ("-gnat0" & Switch_Chars (Ptr .. Max));
1059                else
1060                   Ptr := Ptr + 1;
1061                   Ada_Version := Ada_05;
1062                   Ada_Version_Explicit := Ada_Version;
1063                end if;
1064
1065             --  Processing for 12 switch
1066
1067             when '1' =>
1068                if Ptr = Max then
1069                   Bad_Switch ("-gnat1");
1070                end if;
1071
1072                Ptr := Ptr + 1;
1073
1074                if Switch_Chars (Ptr) /= '2' then
1075                   Bad_Switch ("-gnat1" & Switch_Chars (Ptr .. Max));
1076                else
1077                   Ptr := Ptr + 1;
1078                   Ada_Version := Ada_2012;
1079                   Ada_Version_Explicit := Ada_Version;
1080                end if;
1081
1082             --  Processing for 2005 and 2012 switches
1083
1084             when '2' =>
1085                if Ptr > Max - 3 then
1086                   Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Max));
1087
1088                elsif Switch_Chars (Ptr .. Ptr + 3) = "2005" then
1089                   Ada_Version := Ada_05;
1090
1091                elsif Switch_Chars (Ptr .. Ptr + 3) = "2012" then
1092                   Ada_Version := Ada_2012;
1093
1094                else
1095                   Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Ptr + 3));
1096                end if;
1097
1098                Ada_Version_Explicit := Ada_Version;
1099                Ptr := Ptr + 4;
1100
1101             --  Switch cancellation, currently only -gnat-p is allowed.
1102             --  All we do here is the error checking, since the actual
1103             --  processing for switch cancellation is done by calls to
1104             --  Switch_Subsequently_Cancelled at the appropriate point.
1105
1106             when '-' =>
1107
1108                --  Simple ignore -gnat-p
1109
1110                if Switch_Chars = "-gnat-p" then
1111                   return;
1112
1113                --  Any other occurrence of minus is ignored. This is for
1114                --  maximum compatibility with previous version which ignored
1115                --  all occurrences of minus.
1116
1117                else
1118                   Store_Switch := False;
1119                   Ptr := Ptr + 1;
1120                end if;
1121
1122             --  We ignore '/' in switches, this is historical, still needed???
1123
1124             when '/' =>
1125                Store_Switch := False;
1126
1127             --  Anything else is an error (illegal switch character)
1128
1129             when others =>
1130                Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Max));
1131             end case;
1132
1133             if Store_Switch then
1134                Store_Compilation_Switch
1135                  ("-gnat" & Switch_Chars (First_Char .. Ptr - 1));
1136             end if;
1137
1138             First_Switch := False;
1139          end loop;
1140       end if;
1141    end Scan_Front_End_Switches;
1142
1143    -----------------------------------
1144    -- Switch_Subsequently_Cancelled --
1145    -----------------------------------
1146
1147    function Switch_Subsequently_Cancelled
1148      (C        : String;
1149       Args     : Argument_List;
1150       Arg_Rank : Positive) return Boolean
1151    is
1152       use type System.Strings.String_Access;
1153
1154    begin
1155       --  Loop through arguments following the current one
1156
1157       for Arg in Arg_Rank + 1 .. Args'Last loop
1158          if Args (Arg).all = "-gnat-" & C then
1159             return True;
1160          end if;
1161       end loop;
1162
1163       --  No match found, not cancelled
1164
1165       return False;
1166    end Switch_Subsequently_Cancelled;
1167
1168 end Switch.C;