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                   --  -gnateE (extra exception information)
 426
 427                   when 'E' =>
 428                      Exception_Extra_Info := True;
 429                      Ptr := Ptr + 1;
 430
 431                   --  -gnatef (full source path for brief error messages)
 432
 433                   when 'f' =>
 434                      Store_Switch := False;
 435                      Ptr := Ptr + 1;
 436                      Full_Path_Name_For_Brief_Errors := True;
 437
 438                   --  -gnateG (save preprocessor output)
 439
 440                   when 'G' =>
 441                      Generate_Processed_File := True;
 442                      Ptr := Ptr + 1;
 443
 444                   --  -gnateI (index of unit in multi-unit source)
 445
 446                   when 'I' =>
 447                      Ptr := Ptr + 1;
 448                      Scan_Pos (Switch_Chars, Max, Ptr, Multiple_Unit_Index, C);
 449
 450                   --  -gnatem (mapping file)
 451
 452                   when 'm' =>
 453                      Store_Switch := False;
 454                      Ptr := Ptr + 1;
 455
 456                      --  There may be an equal sign between -gnatem and
 457                      --  the path name of the mapping file.
 458
 459                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 460                         Ptr := Ptr + 1;
 461                      end if;
 462
 463                      if Ptr > Max then
 464                         Bad_Switch ("-gnatem");
 465                      end if;
 466
 467                      Mapping_File_Name :=
 468                        new String'(Switch_Chars (Ptr .. Max));
 469                      return;
 470
 471                   --  -gnatep (preprocessing data file)
 472
 473                   when 'p' =>
 474                      Store_Switch := False;
 475                      Ptr := Ptr + 1;
 476
 477                      --  There may be an equal sign between -gnatep and
 478                      --  the path name of the mapping file.
 479
 480                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 481                         Ptr := Ptr + 1;
 482                      end if;
 483
 484                      if Ptr > Max then
 485                         Bad_Switch ("-gnatep");
 486                      end if;
 487
 488                      Preprocessing_Data_File :=
 489                        new String'(Switch_Chars (Ptr .. Max));
 490
 491                      --  Store the switch, normalizing to -gnatep=
 492
 493                      Store_Compilation_Switch
 494                        ("-gnatep=" & Preprocessing_Data_File.all);
 495
 496                      Ptr := Max + 1;
 497
 498                   --  -gnateP (Treat pragma Pure/Preelaborate errs as warnings)
 499
 500                   when 'P' =>
 501                      Treat_Categorization_Errors_As_Warnings := True;
 502
 503                   --  -gnatez (final delimiter of explicit switches)
 504
 505                   --  All switches that come after -gnatez have been added by
 506                   --  the GCC driver and are not stored in the ALI file. See
 507                   --  also -gnatea above.
 508
 509                   when 'z' =>
 510                      Store_Switch := False;
 511                      Disable_Switch_Storing;
 512                      Ptr := Ptr + 1;
 513
 514                   --  -gnateS (generate SCO information)
 515
 516                   --  Include Source Coverage Obligation information in ALI
 517                   --  files for the benefit of source coverage analysis tools
 518                   --  (xcov).
 519
 520                   when 'S' =>
 521                      Generate_SCO := True;
 522                      Ptr := Ptr + 1;
 523
 524                   --  All other -gnate? switches are unassigned
 525
 526                   when others =>
 527                      Bad_Switch ("-gnate" & Switch_Chars (Ptr .. Max));
 528                end case;
 529
 530             --  -gnatE (dynamic elaboration checks)
 531
 532             when 'E' =>
 533                Ptr := Ptr + 1;
 534                Dynamic_Elaboration_Checks := True;
 535
 536             --  -gnatf (full error messages)
 537
 538             when 'f' =>
 539                Ptr := Ptr + 1;
 540                All_Errors_Mode := True;
 541
 542             --  Processing for F switch
 543
 544             when 'F' =>
 545                Ptr := Ptr + 1;
 546                External_Name_Exp_Casing := Uppercase;
 547                External_Name_Imp_Casing := Uppercase;
 548
 549             --  Processing for g switch
 550
 551             when 'g' =>
 552                Ptr := Ptr + 1;
 553                GNAT_Mode := True;
 554                Identifier_Character_Set := 'n';
 555                System_Extend_Unit := Empty;
 556                Warning_Mode := Treat_As_Error;
 557
 558                --  Set Ada 2012 mode explicitly. We don't want to rely on the
 559                --  implicit setting here, since for example, we want
 560                --  Preelaborate_05 treated as Preelaborate
 561
 562                Ada_Version := Ada_2012;
 563                Ada_Version_Explicit := Ada_Version;
 564
 565                --  Set default warnings and style checks for -gnatg
 566
 567                Set_GNAT_Mode_Warnings;
 568                Set_GNAT_Style_Check_Options;
 569
 570                --  Other special modes set by -gnatg
 571
 572                Treat_Categorization_Errors_As_Warnings := True;
 573
 574             --  Processing for G switch
 575
 576             when 'G' =>
 577                Ptr := Ptr + 1;
 578                Print_Generated_Code := True;
 579
 580                --  Scan optional integer line limit value
 581
 582                if Nat_Present (Switch_Chars, Max, Ptr) then
 583                   Scan_Nat (Switch_Chars, Max, Ptr, Sprint_Line_Limit, 'G');
 584                   Sprint_Line_Limit := Nat'Max (Sprint_Line_Limit, 40);
 585                end if;
 586
 587             --  Processing for h switch
 588
 589             when 'h' =>
 590                Ptr := Ptr + 1;
 591                Usage_Requested := True;
 592
 593             --  Processing for H switch
 594
 595             when 'H' =>
 596                Ptr := Ptr + 1;
 597                HLO_Active := True;
 598
 599             --  Processing for i switch
 600
 601             when 'i' =>
 602                if Ptr = Max then
 603                   Bad_Switch ("-gnati");
 604                end if;
 605
 606                Ptr := Ptr + 1;
 607                C := Switch_Chars (Ptr);
 608
 609                if C in '1' .. '5'
 610                  or else C = '8'
 611                  or else C = '9'
 612                  or else C = 'p'
 613                  or else C = 'f'
 614                  or else C = 'n'
 615                  or else C = 'w'
 616                then
 617                   Identifier_Character_Set := C;
 618                   Ptr := Ptr + 1;
 619
 620                else
 621                   Bad_Switch ("-gnati" & Switch_Chars (Ptr .. Max));
 622                end if;
 623
 624             --  Processing for I switch
 625
 626             when 'I' =>
 627                Ptr := Ptr + 1;
 628                Ignore_Rep_Clauses := True;
 629
 630             --  Processing for j switch
 631
 632             when 'j' =>
 633                Ptr := Ptr + 1;
 634                Scan_Nat (Switch_Chars, Max, Ptr, Error_Msg_Line_Length, C);
 635
 636             --  Processing for k switch
 637
 638             when 'k' =>
 639                Ptr := Ptr + 1;
 640                   Scan_Pos
 641                     (Switch_Chars, Max, Ptr, Maximum_File_Name_Length, C);
 642
 643             --  Processing for l switch
 644
 645             when 'l' =>
 646                Ptr := Ptr + 1;
 647                Full_List := True;
 648
 649                --  There may be an equal sign between -gnatl and a file name
 650
 651                if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 652                   if Ptr = Max then
 653                      Osint.Fail ("file name for -gnatl= is null");
 654                   else
 655                      Opt.Full_List_File_Name :=
 656                        new String'(Switch_Chars (Ptr + 1 .. Max));
 657                      Ptr := Max + 1;
 658                   end if;
 659                end if;
 660
 661             --  Processing for L switch
 662
 663             when 'L' =>
 664                Ptr := Ptr + 1;
 665                Dump_Source_Text := True;
 666
 667             --  Processing for m switch
 668
 669             when 'm' =>
 670                Ptr := Ptr + 1;
 671                Scan_Nat (Switch_Chars, Max, Ptr, Maximum_Messages, C);
 672
 673             --  Processing for n switch
 674
 675             when 'n' =>
 676                Ptr := Ptr + 1;
 677                Inline_Active := True;
 678
 679             --  Processing for N switch
 680
 681             when 'N' =>
 682                Ptr := Ptr + 1;
 683                Inline_Active := True;
 684                Front_End_Inlining := True;
 685
 686             --  Processing for o switch
 687
 688             when 'o' =>
 689                Ptr := Ptr + 1;
 690                Suppress_Options (Overflow_Check) := False;
 691                Opt.Enable_Overflow_Checks := True;
 692
 693             --  Processing for O switch
 694
 695             when 'O' =>
 696                Store_Switch := False;
 697                Ptr := Ptr + 1;
 698                Output_File_Name_Present := True;
 699
 700             --  Processing for p switch
 701
 702             when 'p' =>
 703                Ptr := Ptr + 1;
 704
 705                --  Skip processing if cancelled by subsequent -gnat-p
 706
 707                if Switch_Subsequently_Cancelled ("p", Args, Arg_Rank) then
 708                   Store_Switch := False;
 709
 710                else
 711                   --  Set all specific options as well as All_Checks in the
 712                   --  Suppress_Options array, excluding Elaboration_Check,
 713                   --  since this is treated specially because we do not want
 714                   --  -gnatp to disable static elaboration processing.
 715
 716                   for J in Suppress_Options'Range loop
 717                      if J /= Elaboration_Check then
 718                         Suppress_Options (J) := True;
 719                      end if;
 720                   end loop;
 721
 722                   Validity_Checks_On         := False;
 723                   Opt.Suppress_Checks        := True;
 724                   Opt.Enable_Overflow_Checks := False;
 725                end if;
 726
 727             --  Processing for P switch
 728
 729             when 'P' =>
 730                Ptr := Ptr + 1;
 731                Polling_Required := True;
 732
 733             --  Processing for q switch
 734
 735             when 'q' =>
 736                Ptr := Ptr + 1;
 737                Try_Semantics := True;
 738
 739             --  Processing for Q switch
 740
 741             when 'Q' =>
 742                Ptr := Ptr + 1;
 743                Force_ALI_Tree_File := True;
 744                Try_Semantics := True;
 745
 746                --  Processing for r switch
 747
 748             when 'r' =>
 749                Ptr := Ptr + 1;
 750                Treat_Restrictions_As_Warnings := True;
 751
 752             --  Processing for R switch
 753
 754             when 'R' =>
 755                Back_Annotate_Rep_Info := True;
 756                List_Representation_Info := 1;
 757
 758                Ptr := Ptr + 1;
 759                while Ptr <= Max loop
 760                   C := Switch_Chars (Ptr);
 761
 762                   if C in '1' .. '3' then
 763                      List_Representation_Info :=
 764                        Character'Pos (C) - Character'Pos ('0');
 765
 766                   elsif Switch_Chars (Ptr) = 's' then
 767                      List_Representation_Info_To_File := True;
 768
 769                   elsif Switch_Chars (Ptr) = 'm' then
 770                      List_Representation_Info_Mechanisms := True;
 771
 772                   else
 773                      Bad_Switch ("-gnatR" & Switch_Chars (Ptr .. Max));
 774                   end if;
 775
 776                   Ptr := Ptr + 1;
 777                end loop;
 778
 779             --  Processing for s switch
 780
 781             when 's' =>
 782                if not First_Switch then
 783                   Osint.Fail
 784                     ("-gnats must be first if combined with other switches");
 785                end if;
 786
 787                Ptr := Ptr + 1;
 788                Operating_Mode := Check_Syntax;
 789
 790             --  Processing for S switch
 791
 792             when 'S' =>
 793                Print_Standard := True;
 794                Ptr := Ptr + 1;
 795
 796             --  Processing for t switch
 797
 798             when 't' =>
 799                Ptr := Ptr + 1;
 800                Tree_Output := True;
 801                Back_Annotate_Rep_Info := True;
 802
 803             --  Processing for T switch
 804
 805             when 'T' =>
 806                Ptr := Ptr + 1;
 807                Scan_Pos (Switch_Chars, Max, Ptr, Table_Factor, C);
 808
 809             --  Processing for u switch
 810
 811             when 'u' =>
 812                Ptr := Ptr + 1;
 813                List_Units := True;
 814
 815             --  Processing for U switch
 816
 817             when 'U' =>
 818                Ptr := Ptr + 1;
 819                Unique_Error_Tag := True;
 820
 821             --  Processing for v switch
 822
 823             when 'v' =>
 824                Ptr := Ptr + 1;
 825                Verbose_Mode := True;
 826
 827             --  Processing for V switch
 828
 829             when 'V' =>
 830                Store_Switch := False;
 831                Ptr := Ptr + 1;
 832
 833                if Ptr > Max then
 834                   Bad_Switch ("-gnatV");
 835
 836                else
 837                   declare
 838                      OK  : Boolean;
 839
 840                   begin
 841                      Set_Validity_Check_Options
 842                        (Switch_Chars (Ptr .. Max), OK, Ptr);
 843
 844                      if not OK then
 845                         Bad_Switch ("-gnatV" & Switch_Chars (Ptr .. Max));
 846                      end if;
 847
 848                      for Index in First_Char + 1 .. Max loop
 849                         Store_Compilation_Switch
 850                           ("-gnatV" & Switch_Chars (Index));
 851                      end loop;
 852                   end;
 853                end if;
 854
 855                Ptr := Max + 1;
 856
 857             --  Processing for w switch
 858
 859             when 'w' =>
 860                Store_Switch := False;
 861                Ptr := Ptr + 1;
 862
 863                if Ptr > Max then
 864                   Bad_Switch ("-gnatw");
 865                end if;
 866
 867                while Ptr <= Max loop
 868                   C := Switch_Chars (Ptr);
 869
 870                   --  Case of dot switch
 871
 872                   if C = '.' and then Ptr < Max then
 873                      Ptr := Ptr + 1;
 874                      C := Switch_Chars (Ptr);
 875
 876                      if Set_Dot_Warning_Switch (C) then
 877                         Store_Compilation_Switch ("-gnatw." & C);
 878                      else
 879                         Bad_Switch ("-gnatw." & Switch_Chars (Ptr .. Max));
 880                      end if;
 881
 882                      --  Normal case, no dot
 883
 884                   else
 885                      if Set_Warning_Switch (C) then
 886                         Store_Compilation_Switch ("-gnatw" & C);
 887                      else
 888                         Bad_Switch ("-gnatw" & Switch_Chars (Ptr .. Max));
 889                      end if;
 890                   end if;
 891
 892                   Ptr := Ptr + 1;
 893                end loop;
 894
 895                return;
 896
 897             --  Processing for W switch
 898
 899             when 'W' =>
 900                Ptr := Ptr + 1;
 901
 902                if Ptr > Max then
 903                   Bad_Switch ("-gnatW");
 904                end if;
 905
 906                begin
 907                   Wide_Character_Encoding_Method :=
 908                     Get_WC_Encoding_Method (Switch_Chars (Ptr));
 909                exception
 910                   when Constraint_Error =>
 911                      Bad_Switch ("-gnatW" & Switch_Chars (Ptr .. Max));
 912                end;
 913
 914                Wide_Character_Encoding_Method_Specified := True;
 915
 916                Upper_Half_Encoding :=
 917                  Wide_Character_Encoding_Method in
 918                    WC_Upper_Half_Encoding_Method;
 919
 920                Ptr := Ptr + 1;
 921
 922             --  Processing for x switch
 923
 924             when 'x' =>
 925                Ptr := Ptr + 1;
 926                Xref_Active := False;
 927
 928             --  Processing for X switch
 929
 930             when 'X' =>
 931                Ptr := Ptr + 1;
 932                Extensions_Allowed := True;
 933                Ada_Version := Ada_Version_Type'Last;
 934                Ada_Version_Explicit := Ada_Version_Type'Last;
 935
 936             --  Processing for y switch
 937
 938             when 'y' =>
 939                Ptr := Ptr + 1;
 940
 941                if Ptr > Max then
 942                   Set_Default_Style_Check_Options;
 943
 944                else
 945                   Store_Switch := False;
 946
 947                   declare
 948                      OK  : Boolean;
 949
 950                   begin
 951                      Set_Style_Check_Options
 952                        (Switch_Chars (Ptr .. Max), OK, Ptr);
 953
 954                      if not OK then
 955                         Osint.Fail
 956                           ("bad -gnaty switch (" &
 957                            Style_Msg_Buf (1 .. Style_Msg_Len) & ')');
 958                      end if;
 959
 960                      Ptr := First_Char + 1;
 961                      while Ptr <= Max loop
 962                         if Switch_Chars (Ptr) = 'M' then
 963                            First_Char := Ptr;
 964                            loop
 965                               Ptr := Ptr + 1;
 966                               exit when Ptr > Max
 967                                 or else Switch_Chars (Ptr) not in '0' .. '9';
 968                            end loop;
 969
 970                            Store_Compilation_Switch
 971                              ("-gnaty" & Switch_Chars (First_Char .. Ptr - 1));
 972
 973                         else
 974                            Store_Compilation_Switch
 975                              ("-gnaty" & Switch_Chars (Ptr));
 976                            Ptr := Ptr + 1;
 977                         end if;
 978                      end loop;
 979                   end;
 980                end if;
 981
 982             --  Processing for z switch
 983
 984             when 'z' =>
 985
 986                --  -gnatz must be the first and only switch in Switch_Chars,
 987                --  and is a two-letter switch.
 988
 989                if Ptr /= Switch_Chars'First + 5
 990                  or else (Max - Ptr + 1) > 2
 991                then
 992                   Osint.Fail
 993                     ("-gnatz* may not be combined with other switches");
 994                end if;
 995
 996                if Ptr = Max then
 997                   Bad_Switch ("-gnatz");
 998                end if;
 999
1000                Ptr := Ptr + 1;
1001
1002                --  Only one occurrence of -gnat* is permitted
1003
1004                if Distribution_Stub_Mode = No_Stubs then
1005                   case Switch_Chars (Ptr) is
1006                      when 'r' =>
1007                         Distribution_Stub_Mode := Generate_Receiver_Stub_Body;
1008
1009                      when 'c' =>
1010                         Distribution_Stub_Mode := Generate_Caller_Stub_Body;
1011
1012                      when others =>
1013                         Bad_Switch ("-gnatz" & Switch_Chars (Ptr .. Max));
1014                   end case;
1015
1016                   Ptr := Ptr + 1;
1017
1018                else
1019                   Osint.Fail ("only one -gnatz* switch allowed");
1020                end if;
1021
1022             --  Processing for Z switch
1023
1024             when 'Z' =>
1025                Ptr := Ptr + 1;
1026                Osint.Fail
1027                  ("-gnatZ is no longer supported: consider using --RTS=zcx");
1028
1029             --  Processing for 83 switch
1030
1031             when '8' =>
1032                if Ptr = Max then
1033                   Bad_Switch ("-gnat8");
1034                end if;
1035
1036                Ptr := Ptr + 1;
1037
1038                if Switch_Chars (Ptr) /= '3' then
1039                   Bad_Switch ("-gnat8" & Switch_Chars (Ptr .. Max));
1040                else
1041                   Ptr := Ptr + 1;
1042                   Ada_Version := Ada_83;
1043                   Ada_Version_Explicit := Ada_Version;
1044                end if;
1045
1046             --  Processing for 95 switch
1047
1048             when '9' =>
1049                if Ptr = Max then
1050                   Bad_Switch ("-gnat9");
1051                end if;
1052
1053                Ptr := Ptr + 1;
1054
1055                if Switch_Chars (Ptr) /= '5' then
1056                   Bad_Switch ("-gnat9" & Switch_Chars (Ptr .. Max));
1057                else
1058                   Ptr := Ptr + 1;
1059                   Ada_Version := Ada_95;
1060                   Ada_Version_Explicit := Ada_Version;
1061                end if;
1062
1063             --  Processing for 05 switch
1064
1065             when '0' =>
1066                if Ptr = Max then
1067                   Bad_Switch ("-gnat0");
1068                end if;
1069
1070                Ptr := Ptr + 1;
1071
1072                if Switch_Chars (Ptr) /= '5' then
1073                   Bad_Switch ("-gnat0" & Switch_Chars (Ptr .. Max));
1074                else
1075                   Ptr := Ptr + 1;
1076                   Ada_Version := Ada_2005;
1077                   Ada_Version_Explicit := Ada_Version;
1078                end if;
1079
1080             --  Processing for 12 switch
1081
1082             when '1' =>
1083                if Ptr = Max then
1084                   Bad_Switch ("-gnat1");
1085                end if;
1086
1087                Ptr := Ptr + 1;
1088
1089                if Switch_Chars (Ptr) /= '2' then
1090                   Bad_Switch ("-gnat1" & Switch_Chars (Ptr .. Max));
1091                else
1092                   Ptr := Ptr + 1;
1093                   Ada_Version := Ada_2012;
1094                   Ada_Version_Explicit := Ada_Version;
1095                end if;
1096
1097             --  Processing for 2005 and 2012 switches
1098
1099             when '2' =>
1100                if Ptr > Max - 3 then
1101                   Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Max));
1102
1103                elsif Switch_Chars (Ptr .. Ptr + 3) = "2005" then
1104                   Ada_Version := Ada_2005;
1105
1106                elsif Switch_Chars (Ptr .. Ptr + 3) = "2012" then
1107                   Ada_Version := Ada_2012;
1108
1109                else
1110                   Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Ptr + 3));
1111                end if;
1112
1113                Ada_Version_Explicit := Ada_Version;
1114                Ptr := Ptr + 4;
1115
1116             --  Switch cancellation, currently only -gnat-p is allowed.
1117             --  All we do here is the error checking, since the actual
1118             --  processing for switch cancellation is done by calls to
1119             --  Switch_Subsequently_Cancelled at the appropriate point.
1120
1121             when '-' =>
1122
1123                --  Simple ignore -gnat-p
1124
1125                if Switch_Chars = "-gnat-p" then
1126                   return;
1127
1128                --  Any other occurrence of minus is ignored. This is for
1129                --  maximum compatibility with previous version which ignored
1130                --  all occurrences of minus.
1131
1132                else
1133                   Store_Switch := False;
1134                   Ptr := Ptr + 1;
1135                end if;
1136
1137             --  We ignore '/' in switches, this is historical, still needed???
1138
1139             when '/' =>
1140                Store_Switch := False;
1141
1142             --  Anything else is an error (illegal switch character)
1143
1144             when others =>
1145                Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Max));
1146             end case;
1147
1148             if Store_Switch then
1149                Store_Compilation_Switch
1150                  ("-gnat" & Switch_Chars (First_Char .. Ptr - 1));
1151             end if;
1152
1153             First_Switch := False;
1154          end loop;
1155       end if;
1156    end Scan_Front_End_Switches;
1157
1158    -----------------------------------
1159    -- Switch_Subsequently_Cancelled --
1160    -----------------------------------
1161
1162    function Switch_Subsequently_Cancelled
1163      (C        : String;
1164       Args     : Argument_List;
1165       Arg_Rank : Positive) return Boolean
1166    is
1167       use type System.Strings.String_Access;
1168
1169    begin
1170       --  Loop through arguments following the current one
1171
1172       for Arg in Arg_Rank + 1 .. Args'Last loop
1173          if Args (Arg).all = "-gnat-" & C then
1174             return True;
1175          end if;
1176       end loop;
1177
1178       --  No match found, not cancelled
1179
1180       return False;
1181    end Switch_Subsequently_Cancelled;
1182
1183 end Switch.C;