gcc/ada/prepcomp.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                             P R E P C O M P                              --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 2003-2005, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  19 -- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
  20 -- Boston, MA 02110-1301, USA.                                              --
  21 --                                                                          --
  22 -- GNAT was originally developed  by the GNAT team at  New York University. --
  23 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  24 --                                                                          --
  25 ------------------------------------------------------------------------------
  26
  27 with Ada.Unchecked_Deallocation;
  28
  29 with Errout;   use Errout;
  30 with Namet;    use Namet;
  31 with Lib.Writ; use Lib.Writ;
  32 with Opt;      use Opt;
  33 with Osint;    use Osint;
  34 with Prep;     use Prep;
  35 with Scans;    use Scans;
  36 with Scn;      use Scn;
  37 with Sinput.L; use Sinput.L;
  38 with Stringt;  use Stringt;
  39 with Table;
  40
  41 package body Prepcomp is
  42
  43    No_Preprocessing : Boolean := True;
  44    --  Set to True if there is at least one source that needs to be
  45    --  preprocessed.
  46
  47    Source_Index_Of_Preproc_Data_File : Source_File_Index := No_Source_File;
  48
  49    --  The following variable should be a constant, but this is not
  50    --  possible. Warnings are Off because it is never assigned a value.
  51
  52    pragma Warnings (Off);
  53    No_Mapping : Prep.Symbol_Table.Instance;
  54    pragma Warnings (On);
  55
  56    type String_Ptr is access String;
  57    type String_Array is array (Positive range <>) of String_Ptr;
  58    type String_Array_Ptr is access String_Array;
  59
  60    procedure Free is
  61       new Ada.Unchecked_Deallocation (String_Array, String_Array_Ptr);
  62
  63    Symbol_Definitions : String_Array_Ptr := new String_Array (1 .. 4);
  64    --  An extensible array to temporarily stores symbol definitions specified
  65    --  on the command line with -gnateD switches.
  66
  67    Last_Definition : Natural := 0;
  68    --  Index of last symbol definition in array Symbol_Definitions
  69
  70    type Preproc_Data is record
  71       Mapping      : Symbol_Table.Instance;
  72       File_Name    : Name_Id   := No_Name;
  73       Deffile      : String_Id := No_String;
  74       Undef_False  : Boolean   := False;
  75       Always_Blank : Boolean   := False;
  76       Comments     : Boolean   := False;
  77       List_Symbols : Boolean   := False;
  78       Processed    : Boolean   := False;
  79    end record;
  80    --  Structure to keep the preprocessing data for a file name or for the
  81    --  default (when Name_Id = No_Name).
  82
  83    No_Preproc_Data : constant Preproc_Data :=
  84      (Mapping      => No_Mapping,
  85       File_Name    => No_Name,
  86       Deffile      => No_String,
  87       Undef_False  => False,
  88       Always_Blank => False,
  89       Comments     => False,
  90       List_Symbols => False,
  91       Processed    => False);
  92
  93    Default_Data : Preproc_Data := No_Preproc_Data;
  94    --  The preprocessing data to be used when no specific preprocessing data
  95    --  is specified for a source.
  96
  97    Default_Data_Defined : Boolean := False;
  98    --  True if source for which no specific preprocessing is specified need to
  99    --  be preprocess with the Default_Data.
 100
 101    Current_Data : Preproc_Data := No_Preproc_Data;
 102
 103    package Preproc_Data_Table is new Table.Table
 104      (Table_Component_Type => Preproc_Data,
 105       Table_Index_Type     => Int,
 106       Table_Low_Bound      => 1,
 107       Table_Initial        => 5,
 108       Table_Increment      => 5,
 109       Table_Name           => "Prepcomp.Preproc_Data_Table");
 110    --  Table to store the specific preprocessing data
 111
 112    Command_Line_Symbols : Symbol_Table.Instance;
 113    --  A table to store symbol definitions specified on the command line with
 114    --  -gnateD switches.
 115
 116    package Dependencies is new Table.Table
 117      (Table_Component_Type => Source_File_Index,
 118       Table_Index_Type     => Int,
 119       Table_Low_Bound      => 1,
 120       Table_Initial        => 5,
 121       Table_Increment      => 5,
 122       Table_Name           => "Prepcomp.Dependencies");
 123    --  Table to store the dependencies on preprocessing files
 124
 125    procedure Add_Command_Line_Symbols;
 126    --  Add the command line symbol definitions, if any, to the
 127    --  Prep.Mapping table.
 128
 129    procedure Skip_To_End_Of_Line;
 130    --  Ignore errors and scan up to the next end of line or the end of file
 131
 132    ------------------------------
 133    -- Add_Command_Line_Symbols --
 134    ------------------------------
 135
 136    procedure Add_Command_Line_Symbols is
 137       Symbol_Id : Prep.Symbol_Id;
 138
 139    begin
 140       for J in 1 .. Symbol_Table.Last (Command_Line_Symbols) loop
 141          Symbol_Id := Prep.Index_Of (Command_Line_Symbols.Table (J).Symbol);
 142
 143          if Symbol_Id = No_Symbol then
 144             Symbol_Table.Increment_Last (Prep.Mapping);
 145             Symbol_Id := Symbol_Table.Last (Prep.Mapping);
 146          end if;
 147
 148          Prep.Mapping.Table (Symbol_Id) := Command_Line_Symbols.Table (J);
 149       end loop;
 150    end Add_Command_Line_Symbols;
 151
 152    ----------------------
 153    -- Add_Dependencies --
 154    ----------------------
 155
 156    procedure Add_Dependencies is
 157    begin
 158       for Index in 1 .. Dependencies.Last loop
 159          Add_Preprocessing_Dependency (Dependencies.Table (Index));
 160       end loop;
 161    end Add_Dependencies;
 162
 163    ---------------------------
 164    -- Add_Symbol_Definition --
 165    ---------------------------
 166
 167    procedure Add_Symbol_Definition (Def : String) is
 168    begin
 169       --  If Symbol_Definitions is not large enough, double it
 170
 171       if Last_Definition = Symbol_Definitions'Last then
 172          declare
 173             New_Symbol_Definitions : constant String_Array_Ptr :=
 174               new String_Array (1 .. 2 * Last_Definition);
 175
 176          begin
 177             New_Symbol_Definitions (Symbol_Definitions'Range) :=
 178               Symbol_Definitions.all;
 179             Free (Symbol_Definitions);
 180             Symbol_Definitions := New_Symbol_Definitions;
 181          end;
 182       end if;
 183
 184       Last_Definition := Last_Definition + 1;
 185       Symbol_Definitions (Last_Definition) := new String'(Def);
 186    end Add_Symbol_Definition;
 187
 188    -------------------
 189    -- Check_Symbols --
 190    -------------------
 191
 192    procedure Check_Symbols is
 193    begin
 194       --  If there is at least one switch -gnateD specified
 195
 196       if Symbol_Table.Last (Command_Line_Symbols) >= 1 then
 197          Current_Data := No_Preproc_Data;
 198          No_Preprocessing := False;
 199          Current_Data.Processed := True;
 200
 201          --  Start with an empty, initialized mapping table; use Prep.Mapping,
 202          --  because Prep.Index_Of uses Prep.Mapping.
 203
 204          Prep.Mapping := No_Mapping;
 205          Symbol_Table.Init (Prep.Mapping);
 206
 207          --  Add the command line symbols
 208
 209          Add_Command_Line_Symbols;
 210
 211          --  Put the resulting Prep.Mapping in Current_Data, and immediately
 212          --  set Prep.Mapping to nil.
 213
 214          Current_Data.Mapping := Prep.Mapping;
 215          Prep.Mapping := No_Mapping;
 216
 217          --  Set the default data
 218
 219          Default_Data := Current_Data;
 220          Default_Data_Defined := True;
 221       end if;
 222    end Check_Symbols;
 223
 224    ------------------------------
 225    -- Parse_Preprocessing_Data --
 226    ------------------------------
 227
 228    procedure Parse_Preprocessing_Data_File (N : File_Name_Type) is
 229       OK            : Boolean := False;
 230       Dash_Location : Source_Ptr;
 231       Symbol_Data   : Prep.Symbol_Data;
 232       Symbol_Id     : Prep.Symbol_Id;
 233       T             : constant Nat := Total_Errors_Detected;
 234
 235    begin
 236       --  Load the preprocessing data file
 237
 238       Source_Index_Of_Preproc_Data_File := Load_Preprocessing_Data_File (N);
 239
 240       --  Fail if preprocessing data file cannot be found
 241
 242       if Source_Index_Of_Preproc_Data_File = No_Source_File then
 243          Get_Name_String (N);
 244          Fail ("preprocessing data file """,
 245                Name_Buffer (1 .. Name_Len),
 246                """ not found");
 247       end if;
 248
 249       --  Initialize the sanner and set its behavior for a processing data file
 250
 251       Scn.Scanner.Initialize_Scanner
 252         (No_Unit, Source_Index_Of_Preproc_Data_File);
 253       Scn.Scanner.Set_End_Of_Line_As_Token (True);
 254       Scn.Scanner.Reset_Special_Characters;
 255
 256       For_Each_Line : loop
 257          <<Scan_Line>>
 258          Scan;
 259
 260          exit For_Each_Line when Token = Tok_EOF;
 261
 262          if Token = Tok_End_Of_Line then
 263             goto Scan_Line;
 264          end if;
 265
 266          --  Line is not empty
 267
 268          OK := False;
 269          No_Preprocessing := False;
 270          Current_Data := No_Preproc_Data;
 271
 272          case Token is
 273             when Tok_Asterisk =>
 274
 275                --  Default data
 276
 277                if Default_Data_Defined then
 278                   Error_Msg
 279                     ("multiple default preprocessing data", Token_Ptr);
 280
 281                else
 282                   OK := True;
 283                   Default_Data_Defined := True;
 284                end if;
 285
 286             when Tok_String_Literal =>
 287
 288                --  Specific data
 289
 290                String_To_Name_Buffer (String_Literal_Id);
 291                Canonical_Case_File_Name (Name_Buffer (1 .. Name_Len));
 292                Current_Data.File_Name := Name_Find;
 293                OK := True;
 294
 295                for Index in 1 .. Preproc_Data_Table.Last loop
 296                   if Current_Data.File_Name =
 297                        Preproc_Data_Table.Table (Index).File_Name
 298                   then
 299                      Error_Msg_Name_1 := Current_Data.File_Name;
 300                      Error_Msg
 301                        ("multiple preprocessing data for{", Token_Ptr);
 302                      OK := False;
 303                      exit;
 304                   end if;
 305                end loop;
 306
 307             when others =>
 308                Error_Msg ("`'*` or literal string expected", Token_Ptr);
 309          end case;
 310
 311          --  If there is a problem, skip the line
 312
 313          if not OK then
 314             Skip_To_End_Of_Line;
 315             goto Scan_Line;
 316          end if;
 317
 318          --  Scan past the * or the literal string
 319
 320          Scan;
 321
 322          --  A literal string in second position is a definition file
 323
 324          if Token = Tok_String_Literal then
 325             Current_Data.Deffile := String_Literal_Id;
 326             Current_Data.Processed := False;
 327             Scan;
 328
 329          else
 330             --  If there is no definition file, set Processed to True now
 331
 332             Current_Data.Processed := True;
 333          end if;
 334
 335          --  Start with an empty, initialized mapping table; use Prep.Mapping,
 336          --  because Prep.Index_Of uses Prep.Mapping.
 337
 338          Prep.Mapping := No_Mapping;
 339          Symbol_Table.Init (Prep.Mapping);
 340
 341          --  Check the switches that may follow
 342
 343          while Token /= Tok_End_Of_Line and then Token /= Tok_EOF loop
 344             if Token /= Tok_Minus then
 345                Error_Msg ("`'-` expected", Token_Ptr);
 346                Skip_To_End_Of_Line;
 347                goto Scan_Line;
 348             end if;
 349
 350             --  Keep the location of the '-' for possible error reporting
 351
 352             Dash_Location := Token_Ptr;
 353
 354             --  Scan past the '-'
 355
 356             Scan;
 357             OK := False;
 358             Change_Reserved_Keyword_To_Symbol;
 359
 360             --  An identifier (or a reserved word converted to an
 361             --  identifier) is expected and there must be no blank space
 362             --  between the '-' and the identifier.
 363
 364             if Token = Tok_Identifier
 365               and then Token_Ptr = Dash_Location + 1
 366             then
 367                Get_Name_String (Token_Name);
 368
 369                --  Check the character in the source, because the case is
 370                --  significant.
 371
 372                case Sinput.Source (Token_Ptr) is
 373                   when 'u' =>
 374
 375                      --  Undefined symbol are False
 376
 377                      if Name_Len = 1 then
 378                         Current_Data.Undef_False := True;
 379                         OK := True;
 380                      end if;
 381
 382                   when 'b' =>
 383
 384                      --  Blank lines
 385
 386                      if Name_Len = 1 then
 387                         Current_Data.Always_Blank := True;
 388                         OK := True;
 389                      end if;
 390
 391                   when 'c' =>
 392
 393                      --  Comment removed lines
 394
 395                      if Name_Len = 1 then
 396                         Current_Data.Comments := True;
 397                         OK := True;
 398                      end if;
 399
 400                   when 's' =>
 401
 402                      --  List symbols
 403
 404                      if Name_Len = 1 then
 405                         Current_Data.List_Symbols := True;
 406                         OK := True;
 407                      end if;
 408
 409                   when 'D' =>
 410
 411                      --  Symbol definition
 412
 413                      OK := Name_Len > 1;
 414
 415                      if OK then
 416
 417                         --  A symbol must be an Ada identifier; it cannot start
 418                         --  with an underline or a digit.
 419
 420                         if Name_Buffer (2) = '_'
 421                           or Name_Buffer (2) in '0' .. '9'
 422                         then
 423                            Error_Msg ("symbol expected", Token_Ptr + 1);
 424                            Skip_To_End_Of_Line;
 425                            goto Scan_Line;
 426                         end if;
 427
 428                         --  Get the name id of the symbol
 429
 430                         Symbol_Data.On_The_Command_Line := True;
 431                         Name_Buffer (1 .. Name_Len - 1) :=
 432                           Name_Buffer (2 .. Name_Len);
 433                         Name_Len := Name_Len - 1;
 434                         Symbol_Data.Symbol := Name_Find;
 435
 436                         if Name_Buffer (1 .. Name_Len) = "if"
 437                           or else Name_Buffer (1 .. Name_Len) = "else"
 438                           or else Name_Buffer (1 .. Name_Len) = "elsif"
 439                           or else Name_Buffer (1 .. Name_Len) = "end"
 440                           or else Name_Buffer (1 .. Name_Len) = "not"
 441                           or else Name_Buffer (1 .. Name_Len) = "and"
 442                           or else Name_Buffer (1 .. Name_Len) = "then"
 443                         then
 444                            Error_Msg ("symbol expected", Token_Ptr + 1);
 445                            Skip_To_End_Of_Line;
 446                            goto Scan_Line;
 447                         end if;
 448
 449                         --  Get the name id of the original symbol, with
 450                         --  possibly capital letters.
 451
 452                         Name_Len := Integer (Scan_Ptr - Token_Ptr - 1);
 453
 454                         for J in 1 .. Name_Len loop
 455                            Name_Buffer (J) :=
 456                              Sinput.Source (Token_Ptr + Text_Ptr (J));
 457                         end loop;
 458
 459                         Symbol_Data.Original := Name_Find;
 460
 461                         --  Scan past D<symbol>
 462
 463                         Scan;
 464
 465                         if Token /= Tok_Equal then
 466                            Error_Msg ("`=` expected", Token_Ptr);
 467                            Skip_To_End_Of_Line;
 468                            goto Scan_Line;
 469                         end if;
 470
 471                         --  Scan past '='
 472
 473                         Scan;
 474
 475                         --  Here any reserved word is OK
 476
 477                         Change_Reserved_Keyword_To_Symbol
 478                           (All_Keywords => True);
 479
 480                         --  Value can be an identifier (or a reserved word)
 481                         --  or a literal string.
 482
 483                         case Token is
 484                            when Tok_String_Literal =>
 485                               Symbol_Data.Is_A_String := True;
 486                               Symbol_Data.Value := String_Literal_Id;
 487
 488                            when Tok_Identifier =>
 489                               Symbol_Data.Is_A_String := False;
 490                               Start_String;
 491
 492                               for J in Token_Ptr .. Scan_Ptr - 1 loop
 493                                  Store_String_Char (Sinput.Source (J));
 494                               end loop;
 495
 496                               Symbol_Data.Value := End_String;
 497
 498                            when others =>
 499                               Error_Msg
 500                                 ("literal string or identifier expected",
 501                                  Token_Ptr);
 502                               Skip_To_End_Of_Line;
 503                               goto Scan_Line;
 504                         end case;
 505
 506                         --  If symbol already exists, replace old definition
 507                         --  by new one.
 508
 509                         Symbol_Id := Prep.Index_Of (Symbol_Data.Symbol);
 510
 511                         --  Otherwise, add a new entry in the table
 512
 513                         if Symbol_Id = No_Symbol then
 514                            Symbol_Table.Increment_Last (Prep.Mapping);
 515                            Symbol_Id := Symbol_Table.Last (Mapping);
 516                         end if;
 517
 518                         Prep.Mapping.Table (Symbol_Id) := Symbol_Data;
 519                      end if;
 520
 521                   when others =>
 522                      null;
 523                end case;
 524
 525                Scan;
 526             end if;
 527
 528             if not OK then
 529                Error_Msg ("invalid switch", Dash_Location);
 530                Skip_To_End_Of_Line;
 531                goto Scan_Line;
 532             end if;
 533          end loop;
 534
 535          --  Add the command line symbols, if any, possibly replacing symbols
 536          --  just defined.
 537
 538          Add_Command_Line_Symbols;
 539
 540          --  Put the resulting Prep.Mapping in Current_Data, and immediately
 541          --  set Prep.Mapping to nil.
 542
 543          Current_Data.Mapping := Prep.Mapping;
 544          Prep.Mapping := No_Mapping;
 545
 546          --  Record Current_Data
 547
 548          if Current_Data.File_Name = No_Name then
 549             Default_Data := Current_Data;
 550
 551          else
 552             Preproc_Data_Table.Increment_Last;
 553             Preproc_Data_Table.Table (Preproc_Data_Table.Last) := Current_Data;
 554          end if;
 555
 556          Current_Data := No_Preproc_Data;
 557       end loop For_Each_Line;
 558
 559       Scn.Scanner.Set_End_Of_Line_As_Token (False);
 560
 561       --  Fail if there were errors in the preprocessing data file
 562
 563       if Total_Errors_Detected > T then
 564          Errout.Finalize;
 565          Fail ("errors found in preprocessing data file """,
 566                Get_Name_String (N),
 567                """");
 568       end if;
 569
 570       --  Record the dependency on the preprocessor data file
 571
 572       Dependencies.Increment_Last;
 573       Dependencies.Table (Dependencies.Last) :=
 574         Source_Index_Of_Preproc_Data_File;
 575    end Parse_Preprocessing_Data_File;
 576
 577    ---------------------------
 578    -- Prepare_To_Preprocess --
 579    ---------------------------
 580
 581    procedure Prepare_To_Preprocess
 582      (Source               : File_Name_Type;
 583       Preprocessing_Needed : out Boolean)
 584    is
 585       Default : Boolean := False;
 586       Index   : Int := 0;
 587
 588    begin
 589       --  By default, preprocessing is not needed
 590
 591       Preprocessing_Needed := False;
 592
 593       if No_Preprocessing then
 594          return;
 595       end if;
 596
 597       --  First, look for preprocessing data specific to the current source
 598
 599       for J in 1 .. Preproc_Data_Table.Last loop
 600          if Preproc_Data_Table.Table (J).File_Name = Source then
 601             Index := J;
 602             Current_Data := Preproc_Data_Table.Table (J);
 603             exit;
 604          end if;
 605       end loop;
 606
 607       --  If no specific preprocessing data, then take the default
 608
 609       if Index = 0 then
 610          if Default_Data_Defined then
 611             Current_Data := Default_Data;
 612             Default := True;
 613
 614          else
 615             --  If no default, then nothing to do
 616
 617             return;
 618          end if;
 619       end if;
 620
 621       --  Set the preprocessing flags according to the preprocessing data
 622
 623       if Current_Data.Comments and then not Current_Data.Always_Blank then
 624          Comment_Deleted_Lines := True;
 625          Blank_Deleted_Lines   := False;
 626
 627       else
 628          Comment_Deleted_Lines := False;
 629          Blank_Deleted_Lines   := True;
 630       end if;
 631
 632       Undefined_Symbols_Are_False := Current_Data.Undef_False;
 633       List_Preprocessing_Symbols  := Current_Data.List_Symbols;
 634
 635       --  If not already done it, process the definition file
 636
 637       if Current_Data.Processed then
 638
 639          --  Set Prep.Mapping
 640
 641          Prep.Mapping := Current_Data.Mapping;
 642
 643       else
 644          --  First put the mapping in Prep.Mapping, because Prep.Parse_Def_File
 645          --  works on Prep.Mapping.
 646
 647          Prep.Mapping := Current_Data.Mapping;
 648
 649          String_To_Name_Buffer (Current_Data.Deffile);
 650
 651          declare
 652             N : constant Name_Id := Name_Find;
 653             Deffile : constant Source_File_Index :=  Load_Definition_File (N);
 654             Add_Deffile : Boolean := True;
 655             T : constant Nat := Total_Errors_Detected;
 656
 657          begin
 658             if Deffile = No_Source_File then
 659                Fail ("definition file """,
 660                      Get_Name_String (N),
 661                      """ cannot be found");
 662             end if;
 663
 664             --  Initialize the preprocessor and set the characteristics of the
 665             --  scanner for a definition file.
 666
 667             Prep.Initialize
 668               (Error_Msg         => Errout.Error_Msg'Access,
 669                Scan              => Scn.Scanner.Scan'Access,
 670                Set_Ignore_Errors => Errout.Set_Ignore_Errors'Access,
 671                Put_Char          => null,
 672                New_EOL           => null);
 673
 674             Scn.Scanner.Set_End_Of_Line_As_Token (True);
 675             Scn.Scanner.Reset_Special_Characters;
 676
 677             --  Initialize the scanner and process the definition file
 678
 679             Scn.Scanner.Initialize_Scanner (No_Unit, Deffile);
 680             Prep.Parse_Def_File;
 681
 682             --  Reset the behaviour of the scanner to the default
 683
 684             Scn.Scanner.Set_End_Of_Line_As_Token (False);
 685
 686             --  Fail if errors were found while processing the definition file
 687
 688             if T /= Total_Errors_Detected then
 689                Errout.Finalize;
 690                Fail ("errors found in definition file """,
 691                      Get_Name_String (N),
 692                      """");
 693             end if;
 694
 695             for Index in 1 .. Dependencies.Last loop
 696                if Dependencies.Table (Index) = Deffile then
 697                   Add_Deffile := False;
 698                   exit;
 699                end if;
 700             end loop;
 701
 702             if Add_Deffile then
 703                Dependencies.Increment_Last;
 704                Dependencies.Table (Dependencies.Last) := Deffile;
 705             end if;
 706          end;
 707
 708          --  Get back the mapping, indicate that the definition file is
 709          --  processed and store back the preprocessing data.
 710
 711          Current_Data.Mapping := Prep.Mapping;
 712          Current_Data.Processed := True;
 713
 714          if Default then
 715             Default_Data := Current_Data;
 716
 717          else
 718             Preproc_Data_Table.Table (Index) := Current_Data;
 719          end if;
 720       end if;
 721
 722       Preprocessing_Needed := True;
 723    end Prepare_To_Preprocess;
 724
 725    ---------------------------------------------
 726    -- Process_Command_Line_Symbol_Definitions --
 727    ---------------------------------------------
 728
 729    procedure Process_Command_Line_Symbol_Definitions is
 730       Symbol_Data : Prep.Symbol_Data;
 731       Found : Boolean := False;
 732
 733    begin
 734       Symbol_Table.Init (Command_Line_Symbols);
 735
 736       --  The command line definitions have been stored temporarily in
 737       --  array Symbol_Definitions.
 738
 739       for Index in 1 .. Last_Definition loop
 740          --  Check each symbol definition, fail immediately if syntax is not
 741          --  correct.
 742
 743          Check_Command_Line_Symbol_Definition
 744            (Definition => Symbol_Definitions (Index).all,
 745             Data => Symbol_Data);
 746          Found := False;
 747
 748          --  If there is already a definition for this symbol, replace the old
 749          --  definition by this one.
 750
 751          for J in 1 .. Symbol_Table.Last (Command_Line_Symbols) loop
 752             if Command_Line_Symbols.Table (J).Symbol = Symbol_Data.Symbol then
 753                Command_Line_Symbols.Table (J) := Symbol_Data;
 754                Found := True;
 755                exit;
 756             end if;
 757          end loop;
 758
 759          --  Otherwise, create a new entry in the table
 760
 761          if not Found then
 762             Symbol_Table.Increment_Last (Command_Line_Symbols);
 763             Command_Line_Symbols.Table
 764               (Symbol_Table.Last (Command_Line_Symbols)) := Symbol_Data;
 765          end if;
 766       end loop;
 767    end Process_Command_Line_Symbol_Definitions;
 768
 769    -------------------------
 770    -- Skip_To_End_Of_Line --
 771    -------------------------
 772
 773    procedure Skip_To_End_Of_Line is
 774    begin
 775       Set_Ignore_Errors (To => True);
 776
 777       while Token /= Tok_End_Of_Line and then Token /= Tok_EOF loop
 778          Scan;
 779       end loop;
 780
 781       Set_Ignore_Errors (To => False);
 782    end Skip_To_End_Of_Line;
 783
 784 end Prepcomp;