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