gcc/ada/switch-m.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                             S W I T C H - M                              --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 2001-2016, 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 Makeutl;  use Makeutl;
  28 with Osint;    use Osint;
  29 with Opt;      use Opt;
  30 with Prj;      use Prj;
  31 with Prj.Env;  use Prj.Env;
  32 with Table;
  33
  34 with System.Multiprocessors; use System.Multiprocessors;
  35
  36 package body Switch.M is
  37
  38    package Normalized_Switches is new Table.Table
  39      (Table_Component_Type => String_Access,
  40       Table_Index_Type     => Integer,
  41       Table_Low_Bound      => 1,
  42       Table_Initial        => 20,
  43       Table_Increment      => 100,
  44       Table_Name           => "Switch.M.Normalized_Switches");
  45    --  This table is used to keep the normalized switches, so that they may be
  46    --  reused for subsequent invocations of Normalize_Compiler_Switches with
  47    --  similar switches.
  48
  49    Initial_Number_Of_Switches : constant := 10;
  50
  51    Global_Switches : Argument_List_Access := null;
  52    --  Used by function Normalize_Compiler_Switches
  53
  54    ---------------------------------
  55    -- Normalize_Compiler_Switches --
  56    ---------------------------------
  57
  58    procedure Normalize_Compiler_Switches
  59      (Switch_Chars : String;
  60       Switches     : in out Argument_List_Access;
  61       Last         : out Natural)
  62    is
  63       Switch_Starts_With_Gnat : Boolean;
  64
  65       Ptr : Integer := Switch_Chars'First;
  66       Max : constant Integer := Switch_Chars'Last;
  67       C   : Character := ' ';
  68
  69       Storing      : String := Switch_Chars;
  70       First_Stored : Positive := Ptr + 1;
  71       Last_Stored  : Positive := First_Stored;
  72
  73       procedure Add_Switch_Component (S : String);
  74       --  Add a new String_Access component in Switches. If a string equal
  75       --  to S is already stored in the table Normalized_Switches, use it.
  76       --  Otherwise add a new component to the table.
  77
  78       --------------------------
  79       -- Add_Switch_Component --
  80       --------------------------
  81
  82       procedure Add_Switch_Component (S : String) is
  83       begin
  84          --  If Switches is null, allocate a new array
  85
  86          if Switches = null then
  87             Switches := new Argument_List (1 .. Initial_Number_Of_Switches);
  88
  89          --  Otherwise, if Switches is full, extend it
  90
  91          elsif Last = Switches'Last then
  92             declare
  93                New_Switches : constant Argument_List_Access :=
  94                                 new Argument_List
  95                                       (1 .. Switches'Length + Switches'Length);
  96             begin
  97                New_Switches (1 .. Switches'Length) := Switches.all;
  98                Last := Switches'Length;
  99                Switches := New_Switches;
 100             end;
 101          end if;
 102
 103          --  If this is the first switch, Last designates the first component
 104
 105          if Last = 0 then
 106             Last := Switches'First;
 107          else
 108             Last := Last + 1;
 109          end if;
 110
 111          --  Look into the table Normalized_Switches for a similar string.
 112          --  If one is found, put it at the added component, and return.
 113
 114          for Index in 1 .. Normalized_Switches.Last loop
 115             if S = Normalized_Switches.Table (Index).all then
 116                Switches (Last) := Normalized_Switches.Table (Index);
 117                return;
 118             end if;
 119          end loop;
 120
 121          --  No string equal to S was found in the table Normalized_Switches.
 122          --  Add a new component in the table.
 123
 124          Switches (Last) := new String'(S);
 125          Normalized_Switches.Append (Switches (Last));
 126       end Add_Switch_Component;
 127
 128    --  Start of processing for Normalize_Compiler_Switches
 129
 130    begin
 131       Last := 0;
 132
 133       if Ptr = Max or else Switch_Chars (Ptr) /= '-' then
 134          return;
 135       end if;
 136
 137       Ptr := Ptr + 1;
 138
 139       Switch_Starts_With_Gnat :=
 140          Ptr + 3 <= Max and then Switch_Chars (Ptr .. Ptr + 3) = "gnat";
 141
 142       if Switch_Starts_With_Gnat then
 143          Ptr := Ptr + 4;
 144          First_Stored := Ptr;
 145       end if;
 146
 147       while Ptr <= Max loop
 148          C := Switch_Chars (Ptr);
 149
 150          --  Processing for a switch
 151
 152          case Switch_Starts_With_Gnat is
 153
 154             when False =>
 155
 156                --  All switches that don't start with -gnat stay as is,
 157                --  except -pg, -Wall, -k8, -w
 158
 159                if Switch_Chars = "-pg" or else Switch_Chars = "-p" then
 160
 161                   --  The gcc driver converts -pg to -p, so that is what
 162                   --  is stored in the ALI file.
 163
 164                   Add_Switch_Component ("-p");
 165
 166                elsif Switch_Chars = "-Wall" then
 167
 168                   --  The gcc driver adds -gnatwa when -Wall is used
 169
 170                   Add_Switch_Component ("-gnatwa");
 171                   Add_Switch_Component ("-Wall");
 172
 173                elsif Switch_Chars = "-k8" then
 174
 175                   --  The gcc driver transforms -k8 into -gnatk8
 176
 177                   Add_Switch_Component ("-gnatk8");
 178
 179                elsif Switch_Chars = "-w" then
 180
 181                   --  The gcc driver adds -gnatws when -w is used
 182
 183                   Add_Switch_Component ("-gnatws");
 184                   Add_Switch_Component ("-w");
 185
 186                elsif Switch_Chars'Length > 6
 187                  and then
 188                    Switch_Chars (Switch_Chars'First .. Switch_Chars'First + 5)
 189                                                              = "--RTS="
 190                then
 191                   Add_Switch_Component (Switch_Chars);
 192
 193                   --  When --RTS=mtp is used, the gcc driver adds -mrtp
 194
 195                   if Switch_Chars = "--RTS=mtp" then
 196                      Add_Switch_Component ("-mrtp");
 197                   end if;
 198
 199                --  Special case for -fstack-check (alias for
 200                --  -fstack-check=specific)
 201
 202                elsif Switch_Chars = "-fstack-check" then
 203                   Add_Switch_Component ("-fstack-check=specific");
 204
 205                --  Take only into account switches that are transmitted to
 206                --  gnat1 by the gcc driver and stored by gnat1 in the ALI file.
 207
 208                else
 209                   case C is
 210                      when 'O' | 'W' | 'w' | 'f' | 'd' | 'g' | 'm' =>
 211                         Add_Switch_Component (Switch_Chars);
 212
 213                      when others =>
 214                         null;
 215                   end case;
 216                end if;
 217
 218                return;
 219
 220             when True =>
 221
 222                case C is
 223
 224                   --  One-letter switches
 225
 226                   when 'a' | 'A' | 'b' | 'B' | 'c' | 'C' | 'E' | 'f' |
 227                        'F' | 'g' | 'h' | 'H' | 'I' | 'L' | 'N' | 'p' |
 228                        'P' | 'q' | 'Q' | 'r' | 's' | 'S' | 't' | 'u' |
 229                        'U' | 'v' | 'x' | 'X' | 'Z' =>
 230                      Storing (First_Stored) := C;
 231                      Add_Switch_Component
 232                        (Storing (Storing'First .. First_Stored));
 233                      Ptr := Ptr + 1;
 234
 235                   --  One-letter switches followed by a positive number
 236
 237                   when 'D' | 'G' | 'j' | 'k' | 'm' | 'T' =>
 238                      Storing (First_Stored) := C;
 239                      Last_Stored := First_Stored;
 240
 241                      if Ptr <= Max and then Switch_Chars (Ptr) = '=' then
 242                         Ptr := Ptr + 1;
 243                      end if;
 244
 245                      loop
 246                         Ptr := Ptr + 1;
 247                         exit when Ptr > Max
 248                           or else Switch_Chars (Ptr) not in '0' .. '9';
 249                         Last_Stored := Last_Stored + 1;
 250                         Storing (Last_Stored) := Switch_Chars (Ptr);
 251                      end loop;
 252
 253                      Add_Switch_Component
 254                        (Storing (Storing'First .. Last_Stored));
 255
 256                   when 'd' =>
 257                      Storing (First_Stored) := 'd';
 258
 259                      while Ptr < Max loop
 260                         Ptr := Ptr + 1;
 261                         C := Switch_Chars (Ptr);
 262                         exit when C = ASCII.NUL or else C = '/'
 263                           or else C = '-';
 264
 265                         if C in '1' .. '9' or else
 266                            C in 'a' .. 'z' or else
 267                            C in 'A' .. 'Z'
 268                         then
 269                            Storing (First_Stored + 1) := C;
 270                            Add_Switch_Component
 271                              (Storing (Storing'First .. First_Stored + 1));
 272
 273                         else
 274                            Last := 0;
 275                            return;
 276                         end if;
 277                      end loop;
 278
 279                      return;
 280
 281                   when 'e' =>
 282
 283                      --  Some of the gnate... switches are not stored
 284
 285                      Storing (First_Stored) := 'e';
 286                      Ptr := Ptr + 1;
 287
 288                      if Ptr > Max then
 289                         Last := 0;
 290                         return;
 291
 292                      else
 293                         case Switch_Chars (Ptr) is
 294
 295                            when 'A' =>
 296                               Ptr := Ptr + 1;
 297                               Add_Switch_Component ("-gnateA");
 298
 299                            when 'D' =>
 300                               Storing (First_Stored + 1 ..
 301                                          First_Stored + Max - Ptr + 1) :=
 302                                   Switch_Chars (Ptr .. Max);
 303                               Add_Switch_Component
 304                                 (Storing (Storing'First ..
 305                                    First_Stored + Max - Ptr + 1));
 306                               Ptr := Max + 1;
 307
 308                            when 'E' | 'F' | 'G' | 'S' | 'u' | 'V' | 'Y' =>
 309                               Add_Switch_Component
 310                                 ("-gnate" & Switch_Chars (Ptr));
 311                               Ptr := Ptr + 1;
 312
 313                            when 'i' | 'I' =>
 314                               declare
 315                                  First : constant Positive := Ptr;
 316
 317                               begin
 318                                  Ptr := Ptr + 1;
 319
 320                                  if Ptr <= Max and then
 321                                    Switch_Chars (Ptr) = '='
 322                                  then
 323                                     Ptr := Ptr + 1;
 324                                  end if;
 325
 326                                  while Ptr <= Max and then
 327                                        Switch_Chars (Ptr) in '0' .. '9'
 328                                  loop
 329                                     Ptr := Ptr + 1;
 330                                  end loop;
 331
 332                                  Storing (First_Stored + 1 ..
 333                                             First_Stored + Ptr - First) :=
 334                                      Switch_Chars (First .. Ptr - 1);
 335                                  Add_Switch_Component
 336                                    (Storing (Storing'First ..
 337                                       First_Stored + Ptr - First));
 338                               end;
 339
 340                            when 'l' =>
 341                               Ptr := Ptr + 1;
 342                               Add_Switch_Component ("-gnatel");
 343
 344                            when 'L' =>
 345                               Ptr := Ptr + 1;
 346                               Add_Switch_Component ("-gnateL");
 347
 348                            when 'p' =>
 349                               Ptr := Ptr + 1;
 350
 351                               if Ptr = Max then
 352                                  Last := 0;
 353                                  return;
 354                               end if;
 355
 356                               if Switch_Chars (Ptr) = '=' then
 357                                  Ptr := Ptr + 1;
 358                               end if;
 359
 360                                  --  To normalize, always put a '=' after
 361                                  --  -gnatep. Because that could lengthen the
 362                                  --  switch string, declare a local variable.
 363
 364                               declare
 365                                  To_Store : String (1 .. Max - Ptr + 9);
 366                               begin
 367                                  To_Store (1 .. 8) := "-gnatep=";
 368                                  To_Store (9 .. Max - Ptr + 9) :=
 369                                    Switch_Chars (Ptr .. Max);
 370                                  Add_Switch_Component (To_Store);
 371                               end;
 372
 373                               return;
 374
 375                            when others =>
 376                               Last := 0;
 377                               return;
 378                         end case;
 379                      end if;
 380
 381                   when 'i' =>
 382                      Storing (First_Stored) := 'i';
 383
 384                      Ptr := Ptr + 1;
 385
 386                      if Ptr > Max then
 387                         Last := 0;
 388                         return;
 389                      end if;
 390
 391                      C := Switch_Chars (Ptr);
 392
 393                      if C in '1' .. '5'
 394                        or else C = '8'
 395                        or else C = 'p'
 396                        or else C = 'f'
 397                        or else C = 'n'
 398                        or else C = 'w'
 399                      then
 400                         Storing (First_Stored + 1) := C;
 401                         Add_Switch_Component
 402                           (Storing (Storing'First .. First_Stored + 1));
 403                         Ptr := Ptr + 1;
 404
 405                      else
 406                         Last := 0;
 407                         return;
 408                      end if;
 409
 410                   --  -gnatl may be -gnatl=<file name>
 411
 412                   when 'l' =>
 413                      Ptr := Ptr + 1;
 414
 415                      if Ptr > Max or else Switch_Chars (Ptr) /= '=' then
 416                         Add_Switch_Component ("-gnatl");
 417
 418                      else
 419                         Add_Switch_Component
 420                           ("-gnatl" & Switch_Chars (Ptr .. Max));
 421                         return;
 422                      end if;
 423
 424                   --  -gnatn may be -gnatn, -gnatn1, or -gnatn2
 425
 426                   when 'n' =>
 427                      Last_Stored := First_Stored;
 428                      Storing (Last_Stored) := 'n';
 429                      Ptr := Ptr + 1;
 430
 431                      if Ptr <= Max
 432                        and then Switch_Chars (Ptr) in '1' .. '2'
 433                      then
 434                         Last_Stored := Last_Stored + 1;
 435                         Storing (Last_Stored) := Switch_Chars (Ptr);
 436                         Ptr := Ptr + 1;
 437                      end if;
 438
 439                      Add_Switch_Component
 440                        (Storing (Storing'First .. Last_Stored));
 441
 442                   --  -gnato may be -gnatox or -gnatoxx, with x=0/1/2/3
 443
 444                   when 'o' =>
 445                      Last_Stored := First_Stored;
 446                      Storing (Last_Stored) := 'o';
 447                      Ptr := Ptr + 1;
 448
 449                      if Ptr <= Max
 450                        and then Switch_Chars (Ptr) in '0' .. '3'
 451                      then
 452                         Last_Stored := Last_Stored + 1;
 453                         Storing (Last_Stored) := Switch_Chars (Ptr);
 454                         Ptr := Ptr + 1;
 455
 456                         if Ptr <= Max
 457                           and then Switch_Chars (Ptr) in '0' .. '3'
 458                         then
 459                            Last_Stored := Last_Stored + 1;
 460                            Storing (Last_Stored) := Switch_Chars (Ptr);
 461                            Ptr := Ptr + 1;
 462                         end if;
 463                      end if;
 464
 465                      Add_Switch_Component
 466                        (Storing (Storing'First .. Last_Stored));
 467
 468                   --  -gnatR may be followed by '0', '1', '2' or '3',
 469                   --  then by 's'
 470
 471                   when 'R' =>
 472                      Last_Stored := First_Stored;
 473                      Storing (Last_Stored) := 'R';
 474                      Ptr := Ptr + 1;
 475
 476                      if Ptr <= Max
 477                        and then Switch_Chars (Ptr) in '0' .. '9'
 478                      then
 479                         C := Switch_Chars (Ptr);
 480
 481                         if C in '4' .. '9' then
 482                            Last := 0;
 483                            return;
 484
 485                         else
 486                            Last_Stored := Last_Stored + 1;
 487                            Storing (Last_Stored) := C;
 488                            Ptr := Ptr + 1;
 489
 490                            if Ptr <= Max
 491                              and then Switch_Chars (Ptr) = 's'
 492                            then
 493                               Last_Stored := Last_Stored + 1;
 494                               Storing (Last_Stored) := 's';
 495                               Ptr := Ptr + 1;
 496                            end if;
 497                         end if;
 498                      end if;
 499
 500                      Add_Switch_Component
 501                        (Storing (Storing'First .. Last_Stored));
 502
 503                   --  -gnatWx, x = 'h'. 'u', 's', 'e', '8' or 'b'
 504
 505                   when 'W' =>
 506                      Storing (First_Stored) := 'W';
 507                      Ptr := Ptr + 1;
 508
 509                      if Ptr <= Max then
 510                         case Switch_Chars (Ptr) is
 511                            when 'h' | 'u' | 's' | 'e' | '8' | 'b' =>
 512                               Storing (First_Stored + 1) := Switch_Chars (Ptr);
 513                               Add_Switch_Component
 514                                 (Storing (Storing'First .. First_Stored + 1));
 515                               Ptr := Ptr + 1;
 516
 517                            when others =>
 518                               Last := 0;
 519                               return;
 520                         end case;
 521                      end if;
 522
 523                   --  Multiple switches
 524
 525                   when 'V' | 'w' | 'y' =>
 526                      Storing (First_Stored) := C;
 527                      Ptr := Ptr + 1;
 528
 529                      if Ptr > Max then
 530                         if C = 'y' then
 531                            Add_Switch_Component
 532                              (Storing (Storing'First .. First_Stored));
 533
 534                         else
 535                            Last := 0;
 536                            return;
 537                         end if;
 538                      end if;
 539
 540                      --  Loop through remaining switch characters in string
 541
 542                      while Ptr <= Max loop
 543                         C := Switch_Chars (Ptr);
 544                         Ptr := Ptr + 1;
 545
 546                         --  -gnatyMxxx
 547
 548                         if C = 'M' and then Storing (First_Stored) = 'y' then
 549                            Last_Stored := First_Stored + 1;
 550                            Storing (Last_Stored) := 'M';
 551                            while Ptr <= Max loop
 552                               C := Switch_Chars (Ptr);
 553                               exit when C not in '0' .. '9';
 554                               Last_Stored := Last_Stored + 1;
 555                               Storing (Last_Stored) := C;
 556                               Ptr := Ptr + 1;
 557                            end loop;
 558
 559                            --  If there is no digit after -gnatyM,
 560                            --  the switch is invalid.
 561
 562                            if Last_Stored = First_Stored + 1 then
 563                               Last := 0;
 564                               return;
 565
 566                            else
 567                               Add_Switch_Component
 568                                 (Storing (Storing'First .. Last_Stored));
 569                            end if;
 570
 571                         --  --gnatx.x
 572
 573                         elsif C = '.' and then Ptr <= Max then
 574                            Storing (First_Stored + 1) := '.';
 575                            Storing (First_Stored + 2) := Switch_Chars (Ptr);
 576                            Ptr := Ptr + 1;
 577                            Add_Switch_Component
 578                              (Storing (Storing'First .. First_Stored + 2));
 579
 580                         --  All other switches are -gnatxx
 581
 582                         else
 583                            Storing (First_Stored + 1) := C;
 584                            Add_Switch_Component
 585                              (Storing (Storing'First .. First_Stored + 1));
 586                         end if;
 587                      end loop;
 588
 589                   --  -gnat95 -gnat05
 590
 591                   when '0' | '9' =>
 592                      Last_Stored := First_Stored;
 593                      Storing (Last_Stored) := C;
 594                      Ptr := Ptr + 1;
 595
 596                      if Ptr /= Max or else Switch_Chars (Ptr) /= '5' then
 597
 598                         --  Invalid switch
 599
 600                         Last := 0;
 601                         return;
 602
 603                      else
 604                         Last_Stored := Last_Stored + 1;
 605                         Storing (Last_Stored) := '5';
 606                         Add_Switch_Component
 607                           (Storing (Storing'First .. Last_Stored));
 608                         Ptr := Ptr + 1;
 609                      end if;
 610
 611                      --  -gnat12
 612
 613                   when '1' =>
 614                      Last_Stored := First_Stored;
 615                      Storing (Last_Stored) := C;
 616                      Ptr := Ptr + 1;
 617
 618                      if Ptr /= Max or else Switch_Chars (Ptr) /= '2' then
 619
 620                         --  Invalid switch
 621
 622                         Last := 0;
 623                         return;
 624
 625                      else
 626                         Last_Stored := Last_Stored + 1;
 627                         Storing (Last_Stored) := '2';
 628                         Add_Switch_Component
 629                           (Storing (Storing'First .. Last_Stored));
 630                         Ptr := Ptr + 1;
 631                      end if;
 632
 633                      --  -gnat2005 -gnat2012
 634
 635                   when '2' =>
 636                      if Ptr + 3 /= Max then
 637                         Last := 0;
 638                         return;
 639
 640                      elsif Switch_Chars (Ptr + 1 .. Ptr + 3) = "005" then
 641                         Last_Stored := First_Stored + 3;
 642                         Storing (First_Stored .. Last_Stored) := "2005";
 643                         Add_Switch_Component
 644                           (Storing (Storing'First .. Last_Stored));
 645                         Ptr := Max + 1;
 646
 647                      elsif Switch_Chars (Ptr + 1 .. Ptr + 3) = "012" then
 648                         Last_Stored := First_Stored + 3;
 649                         Storing (First_Stored .. Last_Stored) := "2012";
 650                         Add_Switch_Component
 651                           (Storing (Storing'First .. Last_Stored));
 652                         Ptr := Max + 1;
 653
 654                      else
 655
 656                         --  Invalid switch
 657
 658                         Last := 0;
 659                         return;
 660
 661                      end if;
 662
 663                   --  -gnat83
 664
 665                   when '8' =>
 666                      Last_Stored := First_Stored;
 667                      Storing (Last_Stored) := '8';
 668                      Ptr := Ptr + 1;
 669
 670                      if Ptr /= Max or else Switch_Chars (Ptr) /= '3' then
 671
 672                         --  Invalid switch
 673
 674                         Last := 0;
 675                         return;
 676
 677                      else
 678                         Last_Stored := Last_Stored + 1;
 679                         Storing (Last_Stored) := '3';
 680                         Add_Switch_Component
 681                           (Storing (Storing'First .. Last_Stored));
 682                         Ptr := Ptr + 1;
 683                      end if;
 684
 685                   --  Not a valid switch
 686
 687                   when others =>
 688                      Last := 0;
 689                      return;
 690
 691                end case;
 692
 693          end case;
 694       end loop;
 695    end Normalize_Compiler_Switches;
 696
 697    function Normalize_Compiler_Switches
 698      (Switch_Chars : String) return Argument_List
 699    is
 700       Last : Natural;
 701
 702    begin
 703       Normalize_Compiler_Switches (Switch_Chars, Global_Switches, Last);
 704
 705       if Last = 0 then
 706          return (1 .. 0 => null);
 707       else
 708          return Global_Switches (Global_Switches'First .. Last);
 709       end if;
 710    end Normalize_Compiler_Switches;
 711
 712    ------------------------
 713    -- Scan_Make_Switches --
 714    ------------------------
 715
 716    procedure Scan_Make_Switches
 717      (Env               : in out Prj.Tree.Environment;
 718       Switch_Chars      : String;
 719       Success           : out Boolean)
 720    is
 721       Ptr : Integer          := Switch_Chars'First;
 722       Max : constant Integer := Switch_Chars'Last;
 723       C   : Character        := ' ';
 724
 725    begin
 726       --  Assume a good switch
 727
 728       Success := True;
 729
 730       --  Skip past the initial character (must be the switch character)
 731
 732       if Ptr = Max then
 733          Bad_Switch (Switch_Chars);
 734
 735       else
 736          Ptr := Ptr + 1;
 737       end if;
 738
 739       --  A little check, "gnat" at the start of a switch is for the compiler
 740
 741       if Switch_Chars'Length >= Ptr + 3
 742         and then Switch_Chars (Ptr .. Ptr + 3) = "gnat"
 743       then
 744          Success := False;
 745          return;
 746       end if;
 747
 748       C := Switch_Chars (Ptr);
 749
 750       --  Multiple character switches
 751
 752       if Switch_Chars'Length > 2 then
 753          if Switch_Chars = "--create-missing-dirs" then
 754             Setup_Projects := True;
 755
 756          elsif Switch_Chars'Length > Subdirs_Option'Length
 757            and then
 758              Switch_Chars
 759                (Switch_Chars'First ..
 760                 Switch_Chars'First + Subdirs_Option'Length - 1) =
 761                                                             Subdirs_Option
 762          then
 763             Subdirs :=
 764               new String'
 765                 (Switch_Chars
 766                   (Switch_Chars'First + Subdirs_Option'Length ..
 767                    Switch_Chars'Last));
 768
 769          elsif Switch_Chars = Makeutl.Unchecked_Shared_Lib_Imports then
 770             Opt.Unchecked_Shared_Lib_Imports := True;
 771
 772          elsif Switch_Chars = Makeutl.Single_Compile_Per_Obj_Dir_Switch then
 773             Opt.One_Compilation_Per_Obj_Dir := True;
 774
 775          elsif Switch_Chars = Makeutl.No_Exit_Message_Option then
 776             Opt.No_Exit_Message := True;
 777
 778          elsif Switch_Chars = Makeutl.Keep_Temp_Files_Option then
 779             Opt.Keep_Temporary_Files := True;
 780
 781          elsif Switch_Chars (Ptr) = '-' then
 782             Bad_Switch (Switch_Chars);
 783
 784          elsif Switch_Chars'Length > 3
 785            and then Switch_Chars (Ptr .. Ptr + 1) = "aP"
 786          then
 787             Add_Directories
 788               (Env.Project_Path,
 789                Switch_Chars (Ptr + 2 .. Switch_Chars'Last));
 790
 791          elsif C = 'v' and then Switch_Chars'Length = 3 then
 792             Ptr := Ptr + 1;
 793             Verbose_Mode := True;
 794
 795             case Switch_Chars (Ptr) is
 796                when 'l' =>
 797                   Verbosity_Level := Opt.Low;
 798
 799                when 'm' =>
 800                   Verbosity_Level := Opt.Medium;
 801
 802                when 'h' =>
 803                   Verbosity_Level := Opt.High;
 804
 805                when others =>
 806                   Success := False;
 807             end case;
 808
 809          elsif C = 'd' then
 810
 811             --  Note: for the debug switch, the remaining characters in this
 812             --  switch field must all be debug flags, since all valid switch
 813             --  characters are also valid debug characters. This switch is not
 814             --  documented on purpose because it is only used by the
 815             --  implementors.
 816
 817             --  Loop to scan out debug flags
 818
 819             while Ptr < Max loop
 820                Ptr := Ptr + 1;
 821                C := Switch_Chars (Ptr);
 822
 823                if C in 'a' .. 'z' or else C in 'A' .. 'Z' then
 824                   Set_Debug_Flag (C);
 825                else
 826                   Bad_Switch (Switch_Chars);
 827                end if;
 828             end loop;
 829
 830          elsif C = 'e' then
 831             Ptr := Ptr + 1;
 832
 833             case Switch_Chars (Ptr) is
 834
 835                --  Processing for eI switch
 836
 837                when 'I' =>
 838                   Ptr := Ptr + 1;
 839                   Scan_Pos (Switch_Chars, Max, Ptr, Main_Index, C);
 840
 841                   if Ptr <= Max then
 842                      Bad_Switch (Switch_Chars);
 843                   end if;
 844
 845                --  Processing for eL switch
 846
 847                when 'L' =>
 848                   if Ptr /= Max then
 849                      Bad_Switch (Switch_Chars);
 850
 851                   else
 852                      Follow_Links_For_Files := True;
 853                      Follow_Links_For_Dirs  := True;
 854                   end if;
 855
 856                --  Processing for eS switch
 857
 858                when 'S' =>
 859                   if Ptr /= Max then
 860                      Bad_Switch (Switch_Chars);
 861
 862                   else
 863                      Commands_To_Stdout := True;
 864                   end if;
 865
 866                when others =>
 867                   Bad_Switch (Switch_Chars);
 868             end case;
 869
 870          elsif C = 'j' then
 871             Ptr := Ptr + 1;
 872
 873             declare
 874                Max_Proc : Nat;
 875
 876             begin
 877                Scan_Nat (Switch_Chars, Max, Ptr, Max_Proc, C);
 878
 879                if Ptr <= Max then
 880                   Bad_Switch (Switch_Chars);
 881
 882                else
 883                   if Max_Proc = 0 then
 884                      Max_Proc := Nat (Number_Of_CPUs);
 885
 886                      if Max_Proc = 0 then
 887                         Max_Proc := 1;
 888                      end if;
 889                   end if;
 890
 891                   Maximum_Processes := Positive (Max_Proc);
 892                end if;
 893             end;
 894
 895          elsif C = 'w' and then Switch_Chars'Length = 3 then
 896             Ptr := Ptr + 1;
 897
 898             if Switch_Chars = "-we" then
 899                Warning_Mode := Treat_As_Error;
 900
 901             elsif Switch_Chars = "-wn" then
 902                Warning_Mode := Normal;
 903
 904             elsif Switch_Chars = "-ws" then
 905                Warning_Mode  := Suppress;
 906
 907             else
 908                Success := False;
 909             end if;
 910
 911          else
 912             Success := False;
 913          end if;
 914
 915       --  Single-character switches
 916
 917       else
 918          Check_Switch : begin
 919
 920             case C is
 921
 922                when 'a' =>
 923                   Check_Readonly_Files := True;
 924
 925                --  Processing for b switch
 926
 927                when 'b' =>
 928                   Bind_Only  := True;
 929                   Make_Steps := True;
 930
 931                --  Processing for B switch
 932
 933                when 'B' =>
 934                   Build_Bind_And_Link_Full_Project := True;
 935
 936                --  Processing for c switch
 937
 938                when 'c' =>
 939                   Compile_Only := True;
 940                   Make_Steps   := True;
 941
 942                --  Processing for C switch
 943
 944                when 'C' =>
 945                   Opt.Create_Mapping_File := True;
 946
 947                --  Processing for D switch
 948
 949                when 'D' =>
 950                   if Object_Directory_Present then
 951                      Osint.Fail ("duplicate -D switch");
 952
 953                   else
 954                      Object_Directory_Present := True;
 955                   end if;
 956
 957                --  Processing for f switch
 958
 959                when 'f' =>
 960                   Force_Compilations := True;
 961
 962                --  Processing for F switch
 963
 964                when 'F' =>
 965                   Full_Path_Name_For_Brief_Errors := True;
 966
 967                --  Processing for h switch
 968
 969                when 'h' =>
 970                   Usage_Requested := True;
 971
 972                --  Processing for i switch
 973
 974                when 'i' =>
 975                   In_Place_Mode := True;
 976
 977                --  Processing for j switch
 978
 979                when 'j' =>
 980                   --  -j not followed by a number is an error
 981
 982                   Bad_Switch (Switch_Chars);
 983
 984                --  Processing for k switch
 985
 986                when 'k' =>
 987                   Keep_Going := True;
 988
 989                --  Processing for l switch
 990
 991                when 'l' =>
 992                   Link_Only  := True;
 993                   Make_Steps := True;
 994
 995                --  Processing for M switch
 996
 997                when 'M' =>
 998                   List_Dependencies := True;
 999
1000                --  Processing for n switch
1001
1002                when 'n' =>
1003                   Do_Not_Execute := True;
1004
1005                --  Processing for o switch
1006
1007                when 'o' =>
1008                   if Output_File_Name_Present then
1009                      Osint.Fail ("duplicate -o switch");
1010                   else
1011                      Output_File_Name_Present := True;
1012                   end if;
1013
1014                --  Processing for p switch
1015
1016                when 'p' =>
1017                   Setup_Projects := True;
1018
1019                --  Processing for q switch
1020
1021                when 'q' =>
1022                   Quiet_Output := True;
1023
1024                --  Processing for R switch
1025
1026                when 'R' =>
1027                   Run_Path_Option := False;
1028
1029                --  Processing for s switch
1030
1031                when 's' =>
1032                   Ptr := Ptr + 1;
1033                   Check_Switches := True;
1034
1035                --  Processing for v switch
1036
1037                when 'v' =>
1038                   Verbose_Mode := True;
1039                   Verbosity_Level := Opt.High;
1040
1041                   --  Processing for x switch
1042
1043                when 'x' =>
1044                   External_Unit_Compilation_Allowed := True;
1045                   Use_Include_Path_File := True;
1046
1047                   --  Processing for z switch
1048
1049                when 'z' =>
1050                   No_Main_Subprogram := True;
1051
1052                   --  Any other small letter is an illegal switch
1053
1054                when others =>
1055                   if C in 'a' .. 'z' then
1056                      Bad_Switch (Switch_Chars);
1057
1058                   else
1059                      Success := False;
1060                   end if;
1061
1062             end case;
1063          end Check_Switch;
1064       end if;
1065    end Scan_Make_Switches;
1066
1067 end Switch.M;