1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- V M S _ C O N V -- 6-- -- 7-- B o d y -- 8-- -- 9-- Copyright (C) 1996-2012, 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 26with Gnatvsn; use Gnatvsn; 27with Hostparm; 28with Opt; 29with Osint; use Osint; 30with Targparm; use Targparm; 31 32with Ada.Characters.Handling; use Ada.Characters.Handling; 33with Ada.Command_Line; use Ada.Command_Line; 34with Ada.Text_IO; use Ada.Text_IO; 35 36package body VMS_Conv is 37 38 ------------------------- 39 -- Internal Structures -- 40 ------------------------- 41 42 -- The switches and commands are defined by strings in the previous 43 -- section so that they are easy to modify, but internally, they are 44 -- kept in a more conveniently accessible form described in this 45 -- section. 46 47 -- Commands, command qualifiers and options have a similar common format 48 -- so that searching for matching names can be done in a common manner. 49 50 type Item_Id is (Id_Command, Id_Switch, Id_Option); 51 52 type Translation_Type is 53 ( 54 T_Direct, 55 -- A qualifier with no options. 56 -- Example: GNAT MAKE /VERBOSE 57 58 T_Directories, 59 -- A qualifier followed by a list of directories 60 -- Example: GNAT COMPILE /SEARCH=([], [.FOO], [.BAR]) 61 62 T_Directory, 63 -- A qualifier followed by one directory 64 -- Example: GNAT LIBRARY /SET=[.VAXFLOATLIB] 65 66 T_File, 67 -- A qualifier followed by a filename 68 -- Example: GNAT LINK /EXECUTABLE=FOO.EXE 69 70 T_No_Space_File, 71 -- A qualifier followed by a filename 72 -- Example: GNAT MAKE /PROJECT_FILE=PRJ.GPR 73 74 T_Numeric, 75 -- A qualifier followed by a numeric value. 76 -- Example: GNAT CHOP /FILE_NAME_MAX_LENGTH=39 77 78 T_String, 79 -- A qualifier followed by a quoted string. Only used by 80 -- /IDENTIFICATION qualifier. 81 -- Example: GNAT LINK /IDENTIFICATION="3.14a1 version" 82 83 T_Options, 84 -- A qualifier followed by a list of options. 85 -- Example: GNAT COMPILE /REPRESENTATION_INFO=(ARRAYS,OBJECTS) 86 87 T_Commands, 88 -- A qualifier followed by a list. Only used for 89 -- MAKE /COMPILER_QUALIFIERS /BINDER_QUALIFIERS /LINKER_QUALIFIERS 90 -- (gnatmake -cargs -bargs -largs ) 91 -- Example: GNAT MAKE ... /LINKER_QUALIFIERS /VERBOSE FOOBAR.OBJ 92 93 T_Other, 94 -- A qualifier passed directly to the linker. Only used 95 -- for LINK and SHARED if no other match is found. 96 -- Example: GNAT LINK FOO.ALI /SYSSHR 97 98 T_Alphanumplus 99 -- A qualifier followed by a legal linker symbol prefix. Only used 100 -- for BIND /BUILD_LIBRARY (gnatbind -Lxyz). 101 -- Example: GNAT BIND /BUILD_LIBRARY=foobar 102 ); 103 104 type Item (Id : Item_Id); 105 type Item_Ptr is access all Item; 106 107 type Item (Id : Item_Id) is record 108 Name : String_Ptr; 109 -- Name of the command, switch (with slash) or option 110 111 Next : Item_Ptr; 112 -- Pointer to next item on list, always has the same Id value 113 114 Command : Command_Type := Undefined; 115 116 Unix_String : String_Ptr := null; 117 -- Corresponding Unix string. For a command, this is the unix command 118 -- name and possible default switches. For a switch or option it is 119 -- the unix switch string. 120 121 case Id is 122 123 when Id_Command => 124 125 Switches : Item_Ptr; 126 -- Pointer to list of switch items for the command, linked 127 -- through the Next fields with null terminating the list. 128 129 Usage : String_Ptr; 130 -- Usage information, used only for errors and the default 131 -- list of commands output. 132 133 Params : Parameter_Ref; 134 -- Array of parameters 135 136 Defext : String (1 .. 3); 137 -- Default extension. If non-blank, then this extension is 138 -- supplied by default as the extension for any file parameter 139 -- which does not have an extension already. 140 141 when Id_Switch => 142 143 Translation : Translation_Type; 144 -- Type of switch translation. For all cases, except Options, 145 -- this is the only field needed, since the Unix translation 146 -- is found in Unix_String. 147 148 Options : Item_Ptr; 149 -- For the Options case, this field is set to point to a list 150 -- of options item (for this case Unix_String is null in the 151 -- main switch item). The end of the list is marked by null. 152 153 when Id_Option => 154 155 null; 156 -- No special fields needed, since Name and Unix_String are 157 -- sufficient to completely described an option. 158 159 end case; 160 end record; 161 162 subtype Command_Item is Item (Id_Command); 163 subtype Switch_Item is Item (Id_Switch); 164 subtype Option_Item is Item (Id_Option); 165 166 Keep_Temps_Option : constant Item_Ptr := 167 new Item' 168 (Id => Id_Option, 169 Name => 170 new String'("/KEEP_TEMPORARY_FILES"), 171 Next => null, 172 Command => Undefined, 173 Unix_String => null); 174 175 Param_Count : Natural := 0; 176 -- Number of parameter arguments so far 177 178 Arg_Num : Natural; 179 -- Argument number 180 181 Arg_File : Ada.Text_IO.File_Type; 182 -- A file where arguments are read from 183 184 Commands : Item_Ptr; 185 -- Pointer to head of list of command items, one for each command, with 186 -- the end of the list marked by a null pointer. 187 188 Last_Command : Item_Ptr; 189 -- Pointer to last item in Commands list 190 191 Command : Item_Ptr; 192 -- Pointer to command item for current command 193 194 Make_Commands_Active : Item_Ptr := null; 195 -- Set to point to Command entry for COMPILE, BIND, or LINK as appropriate 196 -- if a COMMANDS_TRANSLATION switch has been encountered while processing 197 -- a MAKE Command. 198 199 Output_File_Expected : Boolean := False; 200 -- True for GNAT LINK after -o switch, so that the ".ali" extension is 201 -- not added to the executable file name. 202 203 package Buffer is new Table.Table 204 (Table_Component_Type => Character, 205 Table_Index_Type => Integer, 206 Table_Low_Bound => 1, 207 Table_Initial => 4096, 208 Table_Increment => 100, 209 Table_Name => "Buffer"); 210 -- Table to store the command to be used 211 212 package Cargs_Buffer is new Table.Table 213 (Table_Component_Type => Character, 214 Table_Index_Type => Integer, 215 Table_Low_Bound => 1, 216 Table_Initial => 4096, 217 Table_Increment => 100, 218 Table_Name => "Cargs_Buffer"); 219 -- Table to store the compiler switches for GNAT COMPILE 220 221 Cargs : Boolean := False; 222 -- When True, commands should go to Cargs_Buffer instead of Buffer table 223 224 function Init_Object_Dirs return Argument_List; 225 -- Get the list of the object directories 226 227 function Invert_Sense (S : String) return VMS_Data.String_Ptr; 228 -- Given a unix switch string S, computes the inverse (adding or 229 -- removing ! characters as required), and returns a pointer to 230 -- the allocated result on the heap. 231 232 function Is_Extensionless (F : String) return Boolean; 233 -- Returns true if the filename has no extension 234 235 function Match (S1, S2 : String) return Boolean; 236 -- Determines whether S1 and S2 match (this is a case insensitive match) 237 238 function Match_Prefix (S1, S2 : String) return Boolean; 239 -- Determines whether S1 matches a prefix of S2. This is also a case 240 -- insensitive match (for example Match ("AB","abc") is True). 241 242 function Matching_Name 243 (S : String; 244 Itm : Item_Ptr; 245 Quiet : Boolean := False) return Item_Ptr; 246 -- Determines if the item list headed by Itm and threaded through the 247 -- Next fields (with null marking the end of the list), contains an 248 -- entry that uniquely matches the given string. The match is case 249 -- insensitive and permits unique abbreviation. If the match succeeds, 250 -- then a pointer to the matching item is returned. Otherwise, an 251 -- appropriate error message is written. Note that the discriminant 252 -- of Itm is used to determine the appropriate form of this message. 253 -- Quiet is normally False as shown, if it is set to True, then no 254 -- error message is generated in a not found situation (null is still 255 -- returned to indicate the not-found situation). 256 257 function OK_Alphanumerplus (S : String) return Boolean; 258 -- Checks that S is a string of alphanumeric characters, 259 -- returning True if all alphanumeric characters, 260 -- False if empty or a non-alphanumeric character is present. 261 262 function OK_Integer (S : String) return Boolean; 263 -- Checks that S is a string of digits, returning True if all digits, 264 -- False if empty or a non-digit is present. 265 266 procedure Place (C : Character); 267 -- Place a single character in the buffer, updating Ptr 268 269 procedure Place (S : String); 270 -- Place a string character in the buffer, updating Ptr 271 272 procedure Place_Lower (S : String); 273 -- Place string in buffer, forcing letters to lower case, updating Ptr 274 275 procedure Place_Unix_Switches (S : VMS_Data.String_Ptr); 276 -- Given a unix switch string, place corresponding switches in Buffer, 277 -- updating Ptr appropriately. Note that in the case of use of ! the 278 -- result may be to remove a previously placed switch. 279 280 procedure Preprocess_Command_Data; 281 -- Preprocess the string form of the command and options list into the 282 -- internal form. 283 284 procedure Process_Argument (The_Command : in out Command_Type); 285 -- Process one argument from the command line, or one line from 286 -- from a command line file. For the first call, set The_Command. 287 288 procedure Process_Buffer (S : String); 289 -- Process the characters in the Buffer table or the Cargs_Buffer table 290 -- to convert these into arguments. 291 292 procedure Validate_Command_Or_Option (N : VMS_Data.String_Ptr); 293 -- Check that N is a valid command or option name, i.e. that it is of the 294 -- form of an Ada identifier with upper case letters and underscores. 295 296 procedure Validate_Unix_Switch (S : VMS_Data.String_Ptr); 297 -- Check that S is a valid switch string as described in the syntax for 298 -- the switch table item UNIX_SWITCH or else begins with a backquote. 299 300 ---------------------- 301 -- Init_Object_Dirs -- 302 ---------------------- 303 304 function Init_Object_Dirs return Argument_List is 305 Object_Dirs : Integer; 306 Object_Dir : Argument_List (1 .. 256); 307 Object_Dir_Name : String_Access; 308 309 begin 310 Object_Dirs := 0; 311 Object_Dir_Name := new String'(Object_Dir_Default_Prefix); 312 Get_Next_Dir_In_Path_Init (Object_Dir_Name); 313 314 loop 315 declare 316 Dir : constant String_Access := 317 Get_Next_Dir_In_Path (Object_Dir_Name); 318 begin 319 exit when Dir = null; 320 Object_Dirs := Object_Dirs + 1; 321 Object_Dir (Object_Dirs) := 322 new String'("-L" & 323 To_Canonical_Dir_Spec 324 (To_Host_Dir_Spec 325 (Normalize_Directory_Name (Dir.all).all, 326 True).all, True).all); 327 end; 328 end loop; 329 330 Object_Dirs := Object_Dirs + 1; 331 Object_Dir (Object_Dirs) := new String'("-lgnat"); 332 333 if OpenVMS_On_Target then 334 Object_Dirs := Object_Dirs + 1; 335 Object_Dir (Object_Dirs) := new String'("-ldecgnat"); 336 end if; 337 338 return Object_Dir (1 .. Object_Dirs); 339 end Init_Object_Dirs; 340 341 ---------------- 342 -- Initialize -- 343 ---------------- 344 345 procedure Initialize is 346 begin 347 Command_List := 348 (Bind => 349 (Cname => new S'("BIND"), 350 Usage => new S'("GNAT BIND file[.ali] /qualifiers"), 351 VMS_Only => False, 352 Unixcmd => new S'("gnatbind"), 353 Unixsws => null, 354 Switches => Bind_Switches'Access, 355 Params => new Parameter_Array'(1 => Unlimited_Files), 356 Defext => "ali"), 357 358 Chop => 359 (Cname => new S'("CHOP"), 360 Usage => new S'("GNAT CHOP file [directory] /qualifiers"), 361 VMS_Only => False, 362 Unixcmd => new S'("gnatchop"), 363 Unixsws => null, 364 Switches => Chop_Switches'Access, 365 Params => new Parameter_Array'(1 => File, 2 => Optional_File), 366 Defext => " "), 367 368 Clean => 369 (Cname => new S'("CLEAN"), 370 Usage => new S'("GNAT CLEAN /qualifiers files"), 371 VMS_Only => False, 372 Unixcmd => new S'("gnatclean"), 373 Unixsws => null, 374 Switches => Clean_Switches'Access, 375 Params => new Parameter_Array'(1 => File), 376 Defext => " "), 377 378 Compile => 379 (Cname => new S'("COMPILE"), 380 Usage => new S'("GNAT COMPILE filespec[,...] /qualifiers"), 381 VMS_Only => False, 382 Unixcmd => new S'("gnatmake"), 383 Unixsws => new Argument_List'(1 => new String'("-f"), 384 2 => new String'("-u"), 385 3 => new String'("-c")), 386 Switches => GCC_Switches'Access, 387 Params => new Parameter_Array'(1 => Files_Or_Wildcard), 388 Defext => " "), 389 390 Check => 391 (Cname => new S'("CHECK"), 392 Usage => new S'("GNAT CHECK name /qualifiers"), 393 VMS_Only => False, 394 Unixcmd => new S'("gnatcheck"), 395 Unixsws => null, 396 Switches => Check_Switches'Access, 397 Params => new Parameter_Array'(1 => Unlimited_Files), 398 Defext => " "), 399 400 Sync => 401 (Cname => new S'("SYNC"), 402 Usage => new S'("GNAT SYNC name /qualifiers"), 403 VMS_Only => False, 404 Unixcmd => new S'("gnatsync"), 405 Unixsws => null, 406 Switches => Sync_Switches'Access, 407 Params => new Parameter_Array'(1 => Unlimited_Files), 408 Defext => " "), 409 410 Elim => 411 (Cname => new S'("ELIM"), 412 Usage => new S'("GNAT ELIM name /qualifiers"), 413 VMS_Only => False, 414 Unixcmd => new S'("gnatelim"), 415 Unixsws => null, 416 Switches => Elim_Switches'Access, 417 Params => new Parameter_Array'(1 => Other_As_Is), 418 Defext => "ali"), 419 420 Find => 421 (Cname => new S'("FIND"), 422 Usage => new S'("GNAT FIND pattern[:sourcefile[:line" 423 & "[:column]]] filespec[,...] /qualifiers"), 424 VMS_Only => False, 425 Unixcmd => new S'("gnatfind"), 426 Unixsws => null, 427 Switches => Find_Switches'Access, 428 Params => new Parameter_Array'(1 => Other_As_Is, 429 2 => Files_Or_Wildcard), 430 Defext => "ali"), 431 432 Krunch => 433 (Cname => new S'("KRUNCH"), 434 Usage => new S'("GNAT KRUNCH file [/COUNT=nnn]"), 435 VMS_Only => False, 436 Unixcmd => new S'("gnatkr"), 437 Unixsws => null, 438 Switches => Krunch_Switches'Access, 439 Params => new Parameter_Array'(1 => File), 440 Defext => " "), 441 442 Link => 443 (Cname => new S'("LINK"), 444 Usage => new S'("GNAT LINK file[.ali]" 445 & " [extra obj_&_lib_&_exe_&_opt files]" 446 & " /qualifiers"), 447 VMS_Only => False, 448 Unixcmd => new S'("gnatlink"), 449 Unixsws => null, 450 Switches => Link_Switches'Access, 451 Params => new Parameter_Array'(1 => Unlimited_Files), 452 Defext => "ali"), 453 454 List => 455 (Cname => new S'("LIST"), 456 Usage => new S'("GNAT LIST /qualifiers object_or_ali_file"), 457 VMS_Only => False, 458 Unixcmd => new S'("gnatls"), 459 Unixsws => null, 460 Switches => List_Switches'Access, 461 Params => new Parameter_Array'(1 => Unlimited_Files), 462 Defext => "ali"), 463 464 Make => 465 (Cname => new S'("MAKE"), 466 Usage => new S'("GNAT MAKE file(s) /qualifiers (includes " 467 & "COMPILE /qualifiers)"), 468 VMS_Only => False, 469 Unixcmd => new S'("gnatmake"), 470 Unixsws => null, 471 Switches => Make_Switches'Access, 472 Params => new Parameter_Array'(1 => Unlimited_Files), 473 Defext => " "), 474 475 Metric => 476 (Cname => new S'("METRIC"), 477 Usage => new S'("GNAT METRIC /qualifiers source_file"), 478 VMS_Only => False, 479 Unixcmd => new S'("gnatmetric"), 480 Unixsws => null, 481 Switches => Metric_Switches'Access, 482 Params => new Parameter_Array'(1 => Unlimited_Files), 483 Defext => " "), 484 485 Name => 486 (Cname => new S'("NAME"), 487 Usage => new S'("GNAT NAME /qualifiers naming-pattern " 488 & "[naming-patterns]"), 489 VMS_Only => False, 490 Unixcmd => new S'("gnatname"), 491 Unixsws => null, 492 Switches => Name_Switches'Access, 493 Params => new Parameter_Array'(1 => Unlimited_As_Is), 494 Defext => " "), 495 496 Preprocess => 497 (Cname => new S'("PREPROCESS"), 498 Usage => 499 new S'("GNAT PREPROCESS ifile ofile dfile /qualifiers"), 500 VMS_Only => False, 501 Unixcmd => new S'("gnatprep"), 502 Unixsws => null, 503 Switches => Prep_Switches'Access, 504 Params => new Parameter_Array'(1 .. 3 => File), 505 Defext => " "), 506 507 Pretty => 508 (Cname => new S'("PRETTY"), 509 Usage => new S'("GNAT PRETTY /qualifiers source_file"), 510 VMS_Only => False, 511 Unixcmd => new S'("gnatpp"), 512 Unixsws => null, 513 Switches => Pretty_Switches'Access, 514 Params => new Parameter_Array'(1 => Unlimited_Files), 515 Defext => " "), 516 517 Shared => 518 (Cname => new S'("SHARED"), 519 Usage => new S'("GNAT SHARED [obj_&_lib_&_exe_&_opt" 520 & "files] /qualifiers"), 521 VMS_Only => True, 522 Unixcmd => new S'("gcc"), 523 Unixsws => 524 new Argument_List'(new String'("-shared") & Init_Object_Dirs), 525 Switches => Shared_Switches'Access, 526 Params => new Parameter_Array'(1 => Unlimited_Files), 527 Defext => " "), 528 529 Stack => 530 (Cname => new S'("STACK"), 531 Usage => new S'("GNAT STACK /qualifiers ci_files"), 532 VMS_Only => False, 533 Unixcmd => new S'("gnatstack"), 534 Unixsws => null, 535 Switches => Stack_Switches'Access, 536 Params => new Parameter_Array'(1 => Unlimited_Files), 537 Defext => "ci" & ASCII.NUL), 538 539 Stub => 540 (Cname => new S'("STUB"), 541 Usage => new S'("GNAT STUB file [directory]/qualifiers"), 542 VMS_Only => False, 543 Unixcmd => new S'("gnatstub"), 544 Unixsws => null, 545 Switches => Stub_Switches'Access, 546 Params => new Parameter_Array'(1 => File, 2 => Optional_File), 547 Defext => " "), 548 549 Test => 550 (Cname => new S'("TEST"), 551 Usage => new S'("GNAT TEST file(s) /qualifiers"), 552 VMS_Only => False, 553 Unixcmd => new S'("gnattest"), 554 Unixsws => null, 555 Switches => Make_Switches'Access, 556 Params => new Parameter_Array'(1 => Unlimited_Files), 557 Defext => " "), 558 559 Xref => 560 (Cname => new S'("XREF"), 561 Usage => new S'("GNAT XREF filespec[,...] /qualifiers"), 562 VMS_Only => False, 563 Unixcmd => new S'("gnatxref"), 564 Unixsws => null, 565 Switches => Xref_Switches'Access, 566 Params => new Parameter_Array'(1 => Files_Or_Wildcard), 567 Defext => "ali") 568 ); 569 end Initialize; 570 571 ------------------ 572 -- Invert_Sense -- 573 ------------------ 574 575 function Invert_Sense (S : String) return VMS_Data.String_Ptr is 576 Sinv : String (1 .. S'Length * 2); 577 -- Result (for sure long enough) 578 579 Sinvp : Natural := 0; 580 -- Pointer to output string 581 582 begin 583 for Sp in S'Range loop 584 if Sp = S'First or else S (Sp - 1) = ',' then 585 if S (Sp) = '!' then 586 null; 587 else 588 Sinv (Sinvp + 1) := '!'; 589 Sinv (Sinvp + 2) := S (Sp); 590 Sinvp := Sinvp + 2; 591 end if; 592 593 else 594 Sinv (Sinvp + 1) := S (Sp); 595 Sinvp := Sinvp + 1; 596 end if; 597 end loop; 598 599 return new String'(Sinv (1 .. Sinvp)); 600 end Invert_Sense; 601 602 ---------------------- 603 -- Is_Extensionless -- 604 ---------------------- 605 606 function Is_Extensionless (F : String) return Boolean is 607 begin 608 for J in reverse F'Range loop 609 if F (J) = '.' then 610 return False; 611 elsif F (J) = '/' or else F (J) = ']' or else F (J) = ':' then 612 return True; 613 end if; 614 end loop; 615 616 return True; 617 end Is_Extensionless; 618 619 ----------- 620 -- Match -- 621 ----------- 622 623 function Match (S1, S2 : String) return Boolean is 624 Dif : constant Integer := S2'First - S1'First; 625 626 begin 627 628 if S1'Length /= S2'Length then 629 return False; 630 631 else 632 for J in S1'Range loop 633 if To_Lower (S1 (J)) /= To_Lower (S2 (J + Dif)) then 634 return False; 635 end if; 636 end loop; 637 638 return True; 639 end if; 640 end Match; 641 642 ------------------ 643 -- Match_Prefix -- 644 ------------------ 645 646 function Match_Prefix (S1, S2 : String) return Boolean is 647 begin 648 if S1'Length > S2'Length then 649 return False; 650 else 651 return Match (S1, S2 (S2'First .. S2'First + S1'Length - 1)); 652 end if; 653 end Match_Prefix; 654 655 ------------------- 656 -- Matching_Name -- 657 ------------------- 658 659 function Matching_Name 660 (S : String; 661 Itm : Item_Ptr; 662 Quiet : Boolean := False) return Item_Ptr 663 is 664 P1, P2 : Item_Ptr; 665 666 procedure Err; 667 -- Little procedure to output command/qualifier/option as appropriate 668 -- and bump error count. 669 670 --------- 671 -- Err -- 672 --------- 673 674 procedure Err is 675 begin 676 if Quiet then 677 return; 678 end if; 679 680 Errors := Errors + 1; 681 682 if Itm /= null then 683 case Itm.Id is 684 when Id_Command => 685 Put (Standard_Error, "command"); 686 687 when Id_Switch => 688 if Hostparm.OpenVMS then 689 Put (Standard_Error, "qualifier"); 690 else 691 Put (Standard_Error, "switch"); 692 end if; 693 694 when Id_Option => 695 Put (Standard_Error, "option"); 696 697 end case; 698 else 699 Put (Standard_Error, "input"); 700 701 end if; 702 703 Put (Standard_Error, ": "); 704 Put (Standard_Error, S); 705 end Err; 706 707 -- Start of processing for Matching_Name 708 709 begin 710 -- If exact match, that's the one we want 711 712 P1 := Itm; 713 while P1 /= null loop 714 if Match (S, P1.Name.all) then 715 return P1; 716 else 717 P1 := P1.Next; 718 end if; 719 end loop; 720 721 -- Now check for prefix matches 722 723 P1 := Itm; 724 while P1 /= null loop 725 if P1.Name.all = "/<other>" then 726 return P1; 727 728 elsif not Match_Prefix (S, P1.Name.all) then 729 P1 := P1.Next; 730 731 else 732 -- Here we have found one matching prefix, so see if there is 733 -- another one (which is an ambiguity) 734 735 P2 := P1.Next; 736 while P2 /= null loop 737 if Match_Prefix (S, P2.Name.all) then 738 if not Quiet then 739 Put (Standard_Error, "ambiguous "); 740 Err; 741 Put (Standard_Error, " (matches "); 742 Put (Standard_Error, P1.Name.all); 743 744 while P2 /= null loop 745 if Match_Prefix (S, P2.Name.all) then 746 Put (Standard_Error, ','); 747 Put (Standard_Error, P2.Name.all); 748 end if; 749 750 P2 := P2.Next; 751 end loop; 752 753 Put_Line (Standard_Error, ")"); 754 end if; 755 756 return null; 757 end if; 758 759 P2 := P2.Next; 760 end loop; 761 762 -- If we fall through that loop, then there was only one match 763 764 return P1; 765 end if; 766 end loop; 767 768 -- If we fall through outer loop, there was no match 769 770 if not Quiet then 771 Put (Standard_Error, "unrecognized "); 772 Err; 773 New_Line (Standard_Error); 774 end if; 775 776 return null; 777 end Matching_Name; 778 779 ----------------------- 780 -- OK_Alphanumerplus -- 781 ----------------------- 782 783 function OK_Alphanumerplus (S : String) return Boolean is 784 begin 785 if S'Length = 0 then 786 return False; 787 788 else 789 for J in S'Range loop 790 if not (Is_Alphanumeric (S (J)) or else 791 S (J) = '_' or else S (J) = '$') 792 then 793 return False; 794 end if; 795 end loop; 796 797 return True; 798 end if; 799 end OK_Alphanumerplus; 800 801 ---------------- 802 -- OK_Integer -- 803 ---------------- 804 805 function OK_Integer (S : String) return Boolean is 806 begin 807 if S'Length = 0 then 808 return False; 809 810 else 811 for J in S'Range loop 812 if not Is_Digit (S (J)) then 813 return False; 814 end if; 815 end loop; 816 817 return True; 818 end if; 819 end OK_Integer; 820 821 -------------------- 822 -- Output_Version -- 823 -------------------- 824 825 procedure Output_Version is 826 begin 827 if AAMP_On_Target then 828 Put ("GNAAMP "); 829 else 830 Put ("GNAT "); 831 end if; 832 833 Put_Line (Gnatvsn.Gnat_Version_String); 834 Put_Line ("Copyright 1996-" & 835 Current_Year & 836 ", Free Software Foundation, Inc."); 837 end Output_Version; 838 839 ----------- 840 -- Place -- 841 ----------- 842 843 procedure Place (C : Character) is 844 begin 845 if Cargs then 846 Cargs_Buffer.Append (C); 847 else 848 Buffer.Append (C); 849 end if; 850 end Place; 851 852 procedure Place (S : String) is 853 begin 854 for J in S'Range loop 855 Place (S (J)); 856 end loop; 857 end Place; 858 859 ----------------- 860 -- Place_Lower -- 861 ----------------- 862 863 procedure Place_Lower (S : String) is 864 begin 865 for J in S'Range loop 866 Place (To_Lower (S (J))); 867 end loop; 868 end Place_Lower; 869 870 ------------------------- 871 -- Place_Unix_Switches -- 872 ------------------------- 873 874 procedure Place_Unix_Switches (S : VMS_Data.String_Ptr) is 875 P1, P2, P3 : Natural; 876 Remove : Boolean; 877 Slen, Sln2 : Natural; 878 Wild_Card : Boolean := False; 879 880 begin 881 P1 := S'First; 882 while P1 <= S'Last loop 883 if S (P1) = '!' then 884 P1 := P1 + 1; 885 Remove := True; 886 else 887 Remove := False; 888 end if; 889 890 P2 := P1; 891 pragma Assert (S (P1) = '-' or else S (P1) = '`'); 892 893 while P2 < S'Last and then S (P2 + 1) /= ',' loop 894 P2 := P2 + 1; 895 end loop; 896 897 -- Switch is now in S (P1 .. P2) 898 899 Slen := P2 - P1 + 1; 900 901 if Remove then 902 Wild_Card := S (P2) = '*'; 903 904 if Wild_Card then 905 Slen := Slen - 1; 906 P2 := P2 - 1; 907 end if; 908 909 P3 := 1; 910 while P3 <= Buffer.Last - Slen loop 911 if Buffer.Table (P3) = ' ' 912 and then String (Buffer.Table (P3 + 1 .. P3 + Slen)) = 913 S (P1 .. P2) 914 and then (Wild_Card 915 or else 916 P3 + Slen = Buffer.Last 917 or else 918 Buffer.Table (P3 + Slen + 1) = ' ') 919 then 920 Sln2 := Slen; 921 922 if Wild_Card then 923 while P3 + Sln2 /= Buffer.Last 924 and then Buffer.Table (P3 + Sln2 + 1) /= ' ' 925 loop 926 Sln2 := Sln2 + 1; 927 end loop; 928 end if; 929 930 Buffer.Table (P3 .. Buffer.Last - Sln2 - 1) := 931 Buffer.Table (P3 + Sln2 + 1 .. Buffer.Last); 932 Buffer.Set_Last (Buffer.Last - Sln2 - 1); 933 934 else 935 P3 := P3 + 1; 936 end if; 937 end loop; 938 939 if Wild_Card then 940 P2 := P2 + 1; 941 end if; 942 943 else 944 pragma Assert (S (P2) /= '*'); 945 Place (' '); 946 947 if S (P1) = '`' then 948 P1 := P1 + 1; 949 end if; 950 951 Place (S (P1 .. P2)); 952 end if; 953 954 P1 := P2 + 2; 955 end loop; 956 end Place_Unix_Switches; 957 958 ----------------------------- 959 -- Preprocess_Command_Data -- 960 ----------------------------- 961 962 procedure Preprocess_Command_Data is 963 begin 964 for C in Real_Command_Type loop 965 declare 966 Command : constant Item_Ptr := new Command_Item; 967 968 Last_Switch : Item_Ptr; 969 -- Last switch in list 970 971 begin 972 -- Link new command item into list of commands 973 974 if Last_Command = null then 975 Commands := Command; 976 else 977 Last_Command.Next := Command; 978 end if; 979 980 Last_Command := Command; 981 982 -- Fill in fields of new command item 983 984 Command.Name := Command_List (C).Cname; 985 Command.Usage := Command_List (C).Usage; 986 Command.Command := C; 987 988 if Command_List (C).Unixsws = null then 989 Command.Unix_String := Command_List (C).Unixcmd; 990 else 991 declare 992 Cmd : String (1 .. 5_000); 993 Last : Natural := 0; 994 Sws : constant Argument_List_Access := 995 Command_List (C).Unixsws; 996 997 begin 998 Cmd (1 .. Command_List (C).Unixcmd'Length) := 999 Command_List (C).Unixcmd.all; 1000 Last := Command_List (C).Unixcmd'Length; 1001 1002 for J in Sws'Range loop 1003 Last := Last + 1; 1004 Cmd (Last) := ' '; 1005 Cmd (Last + 1 .. Last + Sws (J)'Length) := 1006 Sws (J).all; 1007 Last := Last + Sws (J)'Length; 1008 end loop; 1009 1010 Command.Unix_String := new String'(Cmd (1 .. Last)); 1011 end; 1012 end if; 1013 1014 Command.Params := Command_List (C).Params; 1015 Command.Defext := Command_List (C).Defext; 1016 1017 Validate_Command_Or_Option (Command.Name); 1018 1019 -- Process the switch list 1020 1021 for S in Command_List (C).Switches'Range loop 1022 declare 1023 SS : constant VMS_Data.String_Ptr := 1024 Command_List (C).Switches (S); 1025 P : Natural := SS'First; 1026 Sw : Item_Ptr := new Switch_Item; 1027 1028 Last_Opt : Item_Ptr; 1029 -- Pointer to last option 1030 1031 begin 1032 -- Link new switch item into list of switches 1033 1034 if Last_Switch = null then 1035 Command.Switches := Sw; 1036 else 1037 Last_Switch.Next := Sw; 1038 end if; 1039 1040 Last_Switch := Sw; 1041 1042 -- Process switch string, first get name 1043 1044 while SS (P) /= ' ' and then SS (P) /= '=' loop 1045 P := P + 1; 1046 end loop; 1047 1048 Sw.Name := new String'(SS (SS'First .. P - 1)); 1049 1050 -- Direct translation case 1051 1052 if SS (P) = ' ' then 1053 Sw.Translation := T_Direct; 1054 Sw.Unix_String := new String'(SS (P + 1 .. SS'Last)); 1055 Validate_Unix_Switch (Sw.Unix_String); 1056 1057 if SS (P - 1) = '>' then 1058 Sw.Translation := T_Other; 1059 1060 elsif SS (P + 1) = '`' then 1061 null; 1062 1063 -- Create the inverted case (/NO ..) 1064 1065 elsif SS (SS'First + 1 .. SS'First + 2) /= "NO" then 1066 Sw := new Switch_Item; 1067 Last_Switch.Next := Sw; 1068 Last_Switch := Sw; 1069 1070 Sw.Name := 1071 new String'("/NO" & SS (SS'First + 1 .. P - 1)); 1072 Sw.Translation := T_Direct; 1073 Sw.Unix_String := Invert_Sense (SS (P + 1 .. SS'Last)); 1074 Validate_Unix_Switch (Sw.Unix_String); 1075 end if; 1076 1077 -- Directories translation case 1078 1079 elsif SS (P + 1) = '*' then 1080 pragma Assert (SS (SS'Last) = '*'); 1081 Sw.Translation := T_Directories; 1082 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1083 Validate_Unix_Switch (Sw.Unix_String); 1084 1085 -- Directory translation case 1086 1087 elsif SS (P + 1) = '%' then 1088 pragma Assert (SS (SS'Last) = '%'); 1089 Sw.Translation := T_Directory; 1090 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1091 Validate_Unix_Switch (Sw.Unix_String); 1092 1093 -- File translation case 1094 1095 elsif SS (P + 1) = '@' then 1096 pragma Assert (SS (SS'Last) = '@'); 1097 Sw.Translation := T_File; 1098 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1099 Validate_Unix_Switch (Sw.Unix_String); 1100 1101 -- No space file translation case 1102 1103 elsif SS (P + 1) = '<' then 1104 pragma Assert (SS (SS'Last) = '>'); 1105 Sw.Translation := T_No_Space_File; 1106 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1107 Validate_Unix_Switch (Sw.Unix_String); 1108 1109 -- Numeric translation case 1110 1111 elsif SS (P + 1) = '#' then 1112 pragma Assert (SS (SS'Last) = '#'); 1113 Sw.Translation := T_Numeric; 1114 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1115 Validate_Unix_Switch (Sw.Unix_String); 1116 1117 -- Alphanumerplus translation case 1118 1119 elsif SS (P + 1) = '|' then 1120 pragma Assert (SS (SS'Last) = '|'); 1121 Sw.Translation := T_Alphanumplus; 1122 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1123 Validate_Unix_Switch (Sw.Unix_String); 1124 1125 -- String translation case 1126 1127 elsif SS (P + 1) = '"' then 1128 pragma Assert (SS (SS'Last) = '"'); 1129 Sw.Translation := T_String; 1130 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last - 1)); 1131 Validate_Unix_Switch (Sw.Unix_String); 1132 1133 -- Commands translation case 1134 1135 elsif SS (P + 1) = '?' then 1136 Sw.Translation := T_Commands; 1137 Sw.Unix_String := new String'(SS (P + 2 .. SS'Last)); 1138 1139 -- Options translation case 1140 1141 else 1142 Sw.Translation := T_Options; 1143 Sw.Unix_String := new String'(""); 1144 1145 P := P + 1; -- bump past = 1146 while P <= SS'Last loop 1147 declare 1148 Opt : constant Item_Ptr := new Option_Item; 1149 Q : Natural; 1150 1151 begin 1152 -- Link new option item into options list 1153 1154 if Last_Opt = null then 1155 Sw.Options := Opt; 1156 else 1157 Last_Opt.Next := Opt; 1158 end if; 1159 1160 Last_Opt := Opt; 1161 1162 -- Fill in fields of new option item 1163 1164 Q := P; 1165 while SS (Q) /= ' ' loop 1166 Q := Q + 1; 1167 end loop; 1168 1169 Opt.Name := new String'(SS (P .. Q - 1)); 1170 Validate_Command_Or_Option (Opt.Name); 1171 1172 P := Q + 1; 1173 Q := P; 1174 1175 while Q <= SS'Last and then SS (Q) /= ' ' loop 1176 Q := Q + 1; 1177 end loop; 1178 1179 Opt.Unix_String := new String'(SS (P .. Q - 1)); 1180 Validate_Unix_Switch (Opt.Unix_String); 1181 P := Q + 1; 1182 end; 1183 end loop; 1184 end if; 1185 end; 1186 end loop; 1187 end; 1188 end loop; 1189 end Preprocess_Command_Data; 1190 1191 ---------------------- 1192 -- Process_Argument -- 1193 ---------------------- 1194 1195 procedure Process_Argument (The_Command : in out Command_Type) is 1196 Argv : String_Access; 1197 Arg_Idx : Integer; 1198 1199 function Get_Arg_End 1200 (Argv : String; 1201 Arg_Idx : Integer) return Integer; 1202 -- Begins looking at Arg_Idx + 1 and returns the index of the 1203 -- last character before a slash or else the index of the last 1204 -- character in the string Argv. 1205 1206 ----------------- 1207 -- Get_Arg_End -- 1208 ----------------- 1209 1210 function Get_Arg_End 1211 (Argv : String; 1212 Arg_Idx : Integer) return Integer 1213 is 1214 begin 1215 for J in Arg_Idx + 1 .. Argv'Last loop 1216 if Argv (J) = '/' then 1217 return J - 1; 1218 end if; 1219 end loop; 1220 1221 return Argv'Last; 1222 end Get_Arg_End; 1223 1224 -- Start of processing for Process_Argument 1225 1226 begin 1227 Cargs := False; 1228 1229 -- If an argument file is open, read the next non empty line 1230 1231 if Is_Open (Arg_File) then 1232 declare 1233 Line : String (1 .. 256); 1234 Last : Natural; 1235 begin 1236 loop 1237 Get_Line (Arg_File, Line, Last); 1238 exit when Last /= 0 or else End_Of_File (Arg_File); 1239 end loop; 1240 1241 -- If the end of the argument file has been reached, close it 1242 1243 if End_Of_File (Arg_File) then 1244 Close (Arg_File); 1245 1246 -- If the last line was empty, return after increasing Arg_Num 1247 -- to go to the next argument on the comment line. 1248 1249 if Last = 0 then 1250 Arg_Num := Arg_Num + 1; 1251 return; 1252 end if; 1253 end if; 1254 1255 Argv := new String'(Line (1 .. Last)); 1256 Arg_Idx := 1; 1257 1258 if Argv (1) = '@' then 1259 Put_Line (Standard_Error, "argument file cannot contain @cmd"); 1260 raise Error_Exit; 1261 end if; 1262 end; 1263 1264 else 1265 -- No argument file is open, get the argument on the command line 1266 1267 Argv := new String'(Argument (Arg_Num)); 1268 Arg_Idx := Argv'First; 1269 1270 -- Check if this is the specification of an argument file 1271 1272 if Argv (Arg_Idx) = '@' then 1273 -- The first argument on the command line cannot be an argument 1274 -- file. 1275 1276 if Arg_Num = 1 then 1277 Put_Line 1278 (Standard_Error, 1279 "Cannot specify argument line before command"); 1280 raise Error_Exit; 1281 end if; 1282 1283 -- Open the file, after conversion of the name to canonical form. 1284 -- Fail if file is not found. 1285 1286 declare 1287 Canonical_File_Name : String_Access := 1288 To_Canonical_File_Spec (Argv (Arg_Idx + 1 .. Argv'Last)); 1289 begin 1290 Open (Arg_File, In_File, Canonical_File_Name.all); 1291 Free (Canonical_File_Name); 1292 return; 1293 1294 exception 1295 when others => 1296 Put (Standard_Error, "Cannot open argument file """); 1297 Put (Standard_Error, Argv (Arg_Idx + 1 .. Argv'Last)); 1298 Put_Line (Standard_Error, """"); 1299 raise Error_Exit; 1300 end; 1301 end if; 1302 end if; 1303 1304 <<Tryagain_After_Coalesce>> 1305 loop 1306 declare 1307 Next_Arg_Idx : Integer; 1308 Arg : String_Access; 1309 1310 begin 1311 Next_Arg_Idx := Get_Arg_End (Argv.all, Arg_Idx); 1312 Arg := new String'(Argv (Arg_Idx .. Next_Arg_Idx)); 1313 1314 -- The first one must be a command name 1315 1316 if Arg_Num = 1 and then Arg_Idx = Argv'First then 1317 Command := Matching_Name (Arg.all, Commands); 1318 1319 if Command = null then 1320 raise Error_Exit; 1321 end if; 1322 1323 The_Command := Command.Command; 1324 Output_File_Expected := False; 1325 1326 -- Give usage information if only command given 1327 1328 if Argument_Count = 1 1329 and then Next_Arg_Idx = Argv'Last 1330 then 1331 Output_Version; 1332 New_Line; 1333 Put_Line 1334 ("List of available qualifiers and options"); 1335 New_Line; 1336 1337 Put (Command.Usage.all); 1338 Set_Col (53); 1339 Put_Line (Command.Unix_String.all); 1340 1341 declare 1342 Sw : Item_Ptr := Command.Switches; 1343 1344 begin 1345 while Sw /= null loop 1346 Put (" "); 1347 Put (Sw.Name.all); 1348 1349 case Sw.Translation is 1350 1351 when T_Other => 1352 Set_Col (53); 1353 Put_Line (Sw.Unix_String.all & 1354 "/<other>"); 1355 1356 when T_Direct => 1357 Set_Col (53); 1358 Put_Line (Sw.Unix_String.all); 1359 1360 when T_Directories => 1361 Put ("=(direc,direc,..direc)"); 1362 Set_Col (53); 1363 Put (Sw.Unix_String.all); 1364 Put (" direc "); 1365 Put (Sw.Unix_String.all); 1366 Put_Line (" direc ..."); 1367 1368 when T_Directory => 1369 Put ("=directory"); 1370 Set_Col (53); 1371 Put (Sw.Unix_String.all); 1372 1373 if Sw.Unix_String (Sw.Unix_String'Last) 1374 /= '=' 1375 then 1376 Put (' '); 1377 end if; 1378 1379 Put_Line ("directory "); 1380 1381 when T_File | T_No_Space_File => 1382 Put ("=file"); 1383 Set_Col (53); 1384 Put (Sw.Unix_String.all); 1385 1386 if Sw.Translation = T_File 1387 and then Sw.Unix_String 1388 (Sw.Unix_String'Last) /= '=' 1389 then 1390 Put (' '); 1391 end if; 1392 1393 Put_Line ("file "); 1394 1395 when T_Numeric => 1396 Put ("=nnn"); 1397 Set_Col (53); 1398 1399 if Sw.Unix_String 1400 (Sw.Unix_String'First) = '`' 1401 then 1402 Put (Sw.Unix_String 1403 (Sw.Unix_String'First + 1 1404 .. Sw.Unix_String'Last)); 1405 else 1406 Put (Sw.Unix_String.all); 1407 end if; 1408 1409 Put_Line ("nnn"); 1410 1411 when T_Alphanumplus => 1412 Put ("=xyz"); 1413 Set_Col (53); 1414 1415 if Sw.Unix_String 1416 (Sw.Unix_String'First) = '`' 1417 then 1418 Put (Sw.Unix_String 1419 (Sw.Unix_String'First + 1 1420 .. Sw.Unix_String'Last)); 1421 else 1422 Put (Sw.Unix_String.all); 1423 end if; 1424 1425 Put_Line ("xyz"); 1426 1427 when T_String => 1428 Put ("="); 1429 Put ('"'); 1430 Put ("<string>"); 1431 Put ('"'); 1432 Set_Col (53); 1433 1434 Put (Sw.Unix_String.all); 1435 1436 if Sw.Unix_String 1437 (Sw.Unix_String'Last) /= '=' 1438 then 1439 Put (' '); 1440 end if; 1441 1442 Put ("<string>"); 1443 New_Line; 1444 1445 when T_Commands => 1446 Put (" (switches for "); 1447 Put (Sw.Unix_String 1448 (Sw.Unix_String'First + 7 1449 .. Sw.Unix_String'Last)); 1450 Put (')'); 1451 Set_Col (53); 1452 Put (Sw.Unix_String 1453 (Sw.Unix_String'First 1454 .. Sw.Unix_String'First + 5)); 1455 Put_Line (" switches"); 1456 1457 when T_Options => 1458 declare 1459 Opt : Item_Ptr := Sw.Options; 1460 1461 begin 1462 Put_Line ("=(option,option..)"); 1463 1464 while Opt /= null loop 1465 Put (" "); 1466 Put (Opt.Name.all); 1467 1468 if Opt = Sw.Options then 1469 Put (" (D)"); 1470 end if; 1471 1472 Set_Col (53); 1473 Put_Line (Opt.Unix_String.all); 1474 Opt := Opt.Next; 1475 end loop; 1476 end; 1477 1478 end case; 1479 1480 Sw := Sw.Next; 1481 end loop; 1482 end; 1483 1484 raise Normal_Exit; 1485 end if; 1486 1487 -- Special handling for internal debugging switch /? 1488 1489 elsif Arg.all = "/?" then 1490 Display_Command := True; 1491 Output_File_Expected := False; 1492 1493 -- Special handling of internal option /KEEP_TEMPORARY_FILES 1494 1495 elsif Arg'Length >= 7 1496 and then Matching_Name 1497 (Arg.all, Keep_Temps_Option, True) /= null 1498 then 1499 Opt.Keep_Temporary_Files := True; 1500 1501 -- Copy -switch unchanged, as well as +rule 1502 1503 elsif Arg (Arg'First) = '-' or else Arg (Arg'First) = '+' then 1504 Place (' '); 1505 Place (Arg.all); 1506 1507 -- Set Output_File_Expected for the next argument 1508 1509 Output_File_Expected := 1510 Arg.all = "-o" and then The_Command = Link; 1511 1512 -- Copy quoted switch with quotes stripped 1513 1514 elsif Arg (Arg'First) = '"' then 1515 if Arg (Arg'Last) /= '"' then 1516 Put (Standard_Error, "misquoted argument: "); 1517 Put_Line (Standard_Error, Arg.all); 1518 Errors := Errors + 1; 1519 1520 else 1521 Place (' '); 1522 Place (Arg (Arg'First + 1 .. Arg'Last - 1)); 1523 end if; 1524 1525 Output_File_Expected := False; 1526 1527 -- Parameter Argument 1528 1529 elsif Arg (Arg'First) /= '/' 1530 and then Make_Commands_Active = null 1531 then 1532 Param_Count := Param_Count + 1; 1533 1534 if Param_Count <= Command.Params'Length then 1535 1536 case Command.Params (Param_Count) is 1537 1538 when File | Optional_File => 1539 declare 1540 Normal_File : constant String_Access := 1541 To_Canonical_File_Spec 1542 (Arg.all); 1543 1544 begin 1545 Place (' '); 1546 Place_Lower (Normal_File.all); 1547 1548 if Is_Extensionless (Normal_File.all) 1549 and then Command.Defext /= " " 1550 then 1551 Place ('.'); 1552 Place (Command.Defext); 1553 end if; 1554 end; 1555 1556 when Unlimited_Files => 1557 declare 1558 Normal_File : constant String_Access := 1559 To_Canonical_File_Spec 1560 (Arg.all); 1561 1562 File_Is_Wild : Boolean := False; 1563 File_List : String_Access_List_Access; 1564 1565 begin 1566 for J in Arg'Range loop 1567 if Arg (J) = '*' 1568 or else Arg (J) = '%' 1569 then 1570 File_Is_Wild := True; 1571 end if; 1572 end loop; 1573 1574 if File_Is_Wild then 1575 File_List := To_Canonical_File_List 1576 (Arg.all, False); 1577 1578 for J in File_List.all'Range loop 1579 Place (' '); 1580 Place_Lower (File_List.all (J).all); 1581 end loop; 1582 1583 else 1584 Place (' '); 1585 Place_Lower (Normal_File.all); 1586 1587 -- Add extension if not present, except after 1588 -- switch -o. 1589 1590 if Is_Extensionless (Normal_File.all) 1591 and then Command.Defext /= " " 1592 and then not Output_File_Expected 1593 then 1594 Place ('.'); 1595 Place (Command.Defext); 1596 end if; 1597 end if; 1598 1599 Param_Count := Param_Count - 1; 1600 end; 1601 1602 when Other_As_Is => 1603 Place (' '); 1604 Place (Arg.all); 1605 1606 when Unlimited_As_Is => 1607 Place (' '); 1608 Place (Arg.all); 1609 Param_Count := Param_Count - 1; 1610 1611 when Files_Or_Wildcard => 1612 1613 -- Remove spaces from a comma separated list 1614 -- of file names and adjust control variables 1615 -- accordingly. 1616 1617 while Arg_Num < Argument_Count and then 1618 (Argv (Argv'Last) = ',' xor 1619 Argument (Arg_Num + 1) 1620 (Argument (Arg_Num + 1)'First) = ',') 1621 loop 1622 Argv := new String' 1623 (Argv.all & Argument (Arg_Num + 1)); 1624 Arg_Num := Arg_Num + 1; 1625 Arg_Idx := Argv'First; 1626 Next_Arg_Idx := 1627 Get_Arg_End (Argv.all, Arg_Idx); 1628 Arg := new String' 1629 (Argv (Arg_Idx .. Next_Arg_Idx)); 1630 end loop; 1631 1632 -- Parse the comma separated list of VMS 1633 -- filenames and place them on the command 1634 -- line as space separated Unix style 1635 -- filenames. Lower case and add default 1636 -- extension as appropriate. 1637 1638 declare 1639 Arg1_Idx : Integer := Arg'First; 1640 1641 function Get_Arg1_End 1642 (Arg : String; 1643 Arg_Idx : Integer) return Integer; 1644 -- Begins looking at Arg_Idx + 1 and 1645 -- returns the index of the last character 1646 -- before a comma or else the index of the 1647 -- last character in the string Arg. 1648 1649 ------------------ 1650 -- Get_Arg1_End -- 1651 ------------------ 1652 1653 function Get_Arg1_End 1654 (Arg : String; 1655 Arg_Idx : Integer) return Integer 1656 is 1657 begin 1658 for J in Arg_Idx + 1 .. Arg'Last loop 1659 if Arg (J) = ',' then 1660 return J - 1; 1661 end if; 1662 end loop; 1663 1664 return Arg'Last; 1665 end Get_Arg1_End; 1666 1667 begin 1668 loop 1669 declare 1670 Next_Arg1_Idx : 1671 constant Integer := 1672 Get_Arg1_End (Arg.all, Arg1_Idx); 1673 1674 Arg1 : 1675 constant String := 1676 Arg (Arg1_Idx .. Next_Arg1_Idx); 1677 1678 Normal_File : 1679 constant String_Access := 1680 To_Canonical_File_Spec (Arg1); 1681 1682 begin 1683 Place (' '); 1684 Place_Lower (Normal_File.all); 1685 1686 if Is_Extensionless (Normal_File.all) 1687 and then Command.Defext /= " " 1688 then 1689 Place ('.'); 1690 Place (Command.Defext); 1691 end if; 1692 1693 Arg1_Idx := Next_Arg1_Idx + 1; 1694 end; 1695 1696 exit when Arg1_Idx > Arg'Last; 1697 1698 -- Don't allow two or more commas in 1699 -- a row 1700 1701 if Arg (Arg1_Idx) = ',' then 1702 Arg1_Idx := Arg1_Idx + 1; 1703 if Arg1_Idx > Arg'Last or else 1704 Arg (Arg1_Idx) = ',' 1705 then 1706 Put_Line 1707 (Standard_Error, 1708 "Malformed Parameter: " & 1709 Arg.all); 1710 Put (Standard_Error, "usage: "); 1711 Put_Line (Standard_Error, 1712 Command.Usage.all); 1713 raise Error_Exit; 1714 end if; 1715 end if; 1716 1717 end loop; 1718 end; 1719 end case; 1720 end if; 1721 1722 -- Reset Output_File_Expected, in case it was True 1723 1724 Output_File_Expected := False; 1725 1726 -- Qualifier argument 1727 1728 else 1729 Output_File_Expected := False; 1730 1731 Cargs := Command.Name.all = "COMPILE"; 1732 1733 -- This code is too heavily nested, should be 1734 -- separated out as separate subprogram ??? 1735 1736 declare 1737 Sw : Item_Ptr; 1738 SwP : Natural; 1739 P2 : Natural; 1740 Endp : Natural := 0; -- avoid warning! 1741 Opt : Item_Ptr; 1742 1743 begin 1744 SwP := Arg'First; 1745 while SwP < Arg'Last 1746 and then Arg (SwP + 1) /= '=' 1747 loop 1748 SwP := SwP + 1; 1749 end loop; 1750 1751 -- At this point, the switch name is in 1752 -- Arg (Arg'First..SwP) and if that is not the 1753 -- whole switch, then there is an equal sign at 1754 -- Arg (SwP + 1) and the rest of Arg is what comes 1755 -- after the equal sign. 1756 1757 -- If make commands are active, see if we have 1758 -- another COMMANDS_TRANSLATION switch belonging 1759 -- to gnatmake. 1760 1761 if Make_Commands_Active /= null then 1762 Sw := 1763 Matching_Name 1764 (Arg (Arg'First .. SwP), 1765 Command.Switches, 1766 Quiet => True); 1767 1768 if Sw /= null 1769 and then Sw.Translation = T_Commands 1770 then 1771 null; 1772 1773 else 1774 Sw := 1775 Matching_Name 1776 (Arg (Arg'First .. SwP), 1777 Make_Commands_Active.Switches, 1778 Quiet => False); 1779 end if; 1780 1781 -- For case of GNAT MAKE or CHOP, if we cannot 1782 -- find the switch, then see if it is a 1783 -- recognized compiler switch instead, and if 1784 -- so process the compiler switch. 1785 1786 elsif Command.Name.all = "MAKE" 1787 or else Command.Name.all = "CHOP" then 1788 Sw := 1789 Matching_Name 1790 (Arg (Arg'First .. SwP), 1791 Command.Switches, 1792 Quiet => True); 1793 1794 if Sw = null then 1795 Sw := 1796 Matching_Name 1797 (Arg (Arg'First .. SwP), 1798 Matching_Name 1799 ("COMPILE", Commands).Switches, 1800 Quiet => False); 1801 end if; 1802 1803 -- For all other cases, just search the relevant 1804 -- command. 1805 1806 else 1807 Sw := 1808 Matching_Name 1809 (Arg (Arg'First .. SwP), 1810 Command.Switches, 1811 Quiet => False); 1812 1813 -- Special case for GNAT COMPILE /UNCHECKED... 1814 -- because the corresponding switch --unchecked... is 1815 -- for gnatmake, not for the compiler. 1816 1817 if Cargs 1818 and then Sw.Name.all = "/UNCHECKED_SHARED_LIB_IMPORTS" 1819 then 1820 Cargs := False; 1821 end if; 1822 end if; 1823 1824 if Sw /= null then 1825 if Cargs 1826 and then Sw.Name /= null 1827 and then 1828 (Sw.Name.all = "/PROJECT_FILE" or else 1829 Sw.Name.all = "/MESSAGES_PROJECT_FILE" or else 1830 Sw.Name.all = "/EXTERNAL_REFERENCE") 1831 then 1832 Cargs := False; 1833 end if; 1834 1835 case Sw.Translation is 1836 when T_Direct => 1837 Place_Unix_Switches (Sw.Unix_String); 1838 1839 if SwP < Arg'Last 1840 and then Arg (SwP + 1) = '=' 1841 then 1842 Put (Standard_Error, 1843 "qualifier options ignored: "); 1844 Put_Line (Standard_Error, Arg.all); 1845 end if; 1846 1847 when T_Directories => 1848 if SwP + 1 > Arg'Last then 1849 Put (Standard_Error, 1850 "missing directories for: "); 1851 Put_Line (Standard_Error, Arg.all); 1852 Errors := Errors + 1; 1853 1854 elsif Arg (SwP + 2) /= '(' then 1855 SwP := SwP + 2; 1856 Endp := Arg'Last; 1857 1858 elsif Arg (Arg'Last) /= ')' then 1859 1860 -- Remove spaces from a comma separated 1861 -- list of file names and adjust 1862 -- control variables accordingly. 1863 1864 if Arg_Num < Argument_Count and then 1865 (Argv (Argv'Last) = ',' xor 1866 Argument (Arg_Num + 1) 1867 (Argument (Arg_Num + 1)'First) = ',') 1868 then 1869 Argv := 1870 new String'(Argv.all 1871 & Argument 1872 (Arg_Num + 1)); 1873 Arg_Num := Arg_Num + 1; 1874 Arg_Idx := Argv'First; 1875 Next_Arg_Idx := 1876 Get_Arg_End (Argv.all, Arg_Idx); 1877 Arg := 1878 new String'(Argv (Arg_Idx .. Next_Arg_Idx)); 1879 goto Tryagain_After_Coalesce; 1880 end if; 1881 1882 Put (Standard_Error, 1883 "incorrectly parenthesized " & 1884 "or malformed argument: "); 1885 Put_Line (Standard_Error, Arg.all); 1886 Errors := Errors + 1; 1887 1888 else 1889 SwP := SwP + 3; 1890 Endp := Arg'Last - 1; 1891 end if; 1892 1893 while SwP <= Endp loop 1894 declare 1895 Dir_Is_Wild : Boolean := False; 1896 Dir_Maybe_Is_Wild : Boolean := False; 1897 1898 Dir_List : String_Access_List_Access; 1899 1900 begin 1901 P2 := SwP; 1902 1903 while P2 < Endp 1904 and then Arg (P2 + 1) /= ',' 1905 loop 1906 -- A wildcard directory spec on VMS will 1907 -- contain either * or % or ... 1908 1909 if Arg (P2) = '*' then 1910 Dir_Is_Wild := True; 1911 1912 elsif Arg (P2) = '%' then 1913 Dir_Is_Wild := True; 1914 1915 elsif Dir_Maybe_Is_Wild 1916 and then Arg (P2) = '.' 1917 and then Arg (P2 + 1) = '.' 1918 then 1919 Dir_Is_Wild := True; 1920 Dir_Maybe_Is_Wild := False; 1921 1922 elsif Dir_Maybe_Is_Wild then 1923 Dir_Maybe_Is_Wild := False; 1924 1925 elsif Arg (P2) = '.' 1926 and then Arg (P2 + 1) = '.' 1927 then 1928 Dir_Maybe_Is_Wild := True; 1929 1930 end if; 1931 1932 P2 := P2 + 1; 1933 end loop; 1934 1935 if Dir_Is_Wild then 1936 Dir_List := 1937 To_Canonical_File_List 1938 (Arg (SwP .. P2), True); 1939 1940 for J in Dir_List.all'Range loop 1941 Place_Unix_Switches (Sw.Unix_String); 1942 Place_Lower (Dir_List.all (J).all); 1943 end loop; 1944 1945 else 1946 Place_Unix_Switches (Sw.Unix_String); 1947 Place_Lower 1948 (To_Canonical_Dir_Spec 1949 (Arg (SwP .. P2), False).all); 1950 end if; 1951 1952 SwP := P2 + 2; 1953 end; 1954 end loop; 1955 1956 when T_Directory => 1957 if SwP + 1 > Arg'Last then 1958 Put (Standard_Error, 1959 "missing directory for: "); 1960 Put_Line (Standard_Error, Arg.all); 1961 Errors := Errors + 1; 1962 1963 else 1964 Place_Unix_Switches (Sw.Unix_String); 1965 1966 -- Some switches end in "=", no space here 1967 1968 if Sw.Unix_String 1969 (Sw.Unix_String'Last) /= '=' 1970 then 1971 Place (' '); 1972 end if; 1973 1974 Place_Lower 1975 (To_Canonical_Dir_Spec 1976 (Arg (SwP + 2 .. Arg'Last), False).all); 1977 end if; 1978 1979 when T_File | T_No_Space_File => 1980 if SwP + 2 > Arg'Last then 1981 Put (Standard_Error, "missing file for: "); 1982 Put_Line (Standard_Error, Arg.all); 1983 Errors := Errors + 1; 1984 1985 else 1986 Place_Unix_Switches (Sw.Unix_String); 1987 1988 -- Some switches end in "=", no space here. 1989 1990 if Sw.Translation = T_File 1991 and then Sw.Unix_String 1992 (Sw.Unix_String'Last) /= '=' 1993 then 1994 Place (' '); 1995 end if; 1996 1997 Place_Lower 1998 (To_Canonical_File_Spec 1999 (Arg (SwP + 2 .. Arg'Last)).all); 2000 end if; 2001 2002 when T_Numeric => 2003 if OK_Integer (Arg (SwP + 2 .. Arg'Last)) then 2004 Place_Unix_Switches (Sw.Unix_String); 2005 Place (Arg (SwP + 2 .. Arg'Last)); 2006 2007 else 2008 Put (Standard_Error, "argument for "); 2009 Put (Standard_Error, Sw.Name.all); 2010 Put_Line (Standard_Error, " must be numeric"); 2011 Errors := Errors + 1; 2012 end if; 2013 2014 when T_Alphanumplus => 2015 if OK_Alphanumerplus 2016 (Arg (SwP + 2 .. Arg'Last)) 2017 then 2018 Place_Unix_Switches (Sw.Unix_String); 2019 Place (Arg (SwP + 2 .. Arg'Last)); 2020 2021 else 2022 Put (Standard_Error, "argument for "); 2023 Put (Standard_Error, Sw.Name.all); 2024 Put_Line (Standard_Error, 2025 " must be alphanumeric"); 2026 Errors := Errors + 1; 2027 end if; 2028 2029 when T_String => 2030 2031 -- A String value must be extended to the end of 2032 -- the Argv, otherwise strings like "foo/bar" get 2033 -- split at the slash. 2034 2035 -- The beginning and ending of the string are 2036 -- flagged with embedded nulls which are removed 2037 -- when building the Spawn call. Nulls are use 2038 -- because they won't show up in a /? output. 2039 -- Quotes aren't used because that would make it 2040 -- difficult to embed them. 2041 2042 Place_Unix_Switches (Sw.Unix_String); 2043 2044 if Next_Arg_Idx /= Argv'Last then 2045 Next_Arg_Idx := Argv'Last; 2046 Arg := 2047 new String'(Argv (Arg_Idx .. Next_Arg_Idx)); 2048 2049 SwP := Arg'First; 2050 while SwP < Arg'Last 2051 and then Arg (SwP + 1) /= '=' 2052 loop 2053 SwP := SwP + 1; 2054 end loop; 2055 end if; 2056 2057 Place (ASCII.NUL); 2058 Place (Arg (SwP + 2 .. Arg'Last)); 2059 Place (ASCII.NUL); 2060 2061 when T_Commands => 2062 2063 -- Output -largs/-bargs/-cargs 2064 2065 Place (' '); 2066 Place (Sw.Unix_String 2067 (Sw.Unix_String'First .. 2068 Sw.Unix_String'First + 5)); 2069 2070 if Sw.Unix_String 2071 (Sw.Unix_String'First + 7 .. 2072 Sw.Unix_String'Last) = "MAKE" 2073 then 2074 Make_Commands_Active := null; 2075 2076 else 2077 -- Set source of new commands, also setting this 2078 -- non-null indicates that we are in the special 2079 -- commands mode for processing the -xargs case. 2080 2081 Make_Commands_Active := 2082 Matching_Name 2083 (Sw.Unix_String 2084 (Sw.Unix_String'First + 7 .. 2085 Sw.Unix_String'Last), 2086 Commands); 2087 end if; 2088 2089 when T_Options => 2090 if SwP + 1 > Arg'Last then 2091 Place_Unix_Switches (Sw.Options.Unix_String); 2092 SwP := Endp + 1; 2093 2094 elsif Arg (SwP + 2) /= '(' then 2095 SwP := SwP + 2; 2096 Endp := Arg'Last; 2097 2098 elsif Arg (Arg'Last) /= ')' then 2099 Put (Standard_Error, 2100 "incorrectly parenthesized argument: "); 2101 Put_Line (Standard_Error, Arg.all); 2102 Errors := Errors + 1; 2103 SwP := Endp + 1; 2104 2105 else 2106 SwP := SwP + 3; 2107 Endp := Arg'Last - 1; 2108 end if; 2109 2110 while SwP <= Endp loop 2111 P2 := SwP; 2112 while P2 < Endp 2113 and then Arg (P2 + 1) /= ',' 2114 loop 2115 P2 := P2 + 1; 2116 end loop; 2117 2118 -- Option name is in Arg (SwP .. P2) 2119 2120 Opt := Matching_Name (Arg (SwP .. P2), 2121 Sw.Options); 2122 2123 if Opt /= null then 2124 Place_Unix_Switches (Opt.Unix_String); 2125 end if; 2126 2127 SwP := P2 + 2; 2128 end loop; 2129 2130 when T_Other => 2131 Place_Unix_Switches 2132 (new String'(Sw.Unix_String.all & Arg.all)); 2133 2134 end case; 2135 end if; 2136 end; 2137 end if; 2138 2139 Arg_Idx := Next_Arg_Idx + 1; 2140 end; 2141 2142 exit when Arg_Idx > Argv'Last; 2143 2144 end loop; 2145 2146 if not Is_Open (Arg_File) then 2147 Arg_Num := Arg_Num + 1; 2148 end if; 2149 end Process_Argument; 2150 2151 -------------------- 2152 -- Process_Buffer -- 2153 -------------------- 2154 2155 procedure Process_Buffer (S : String) is 2156 P1, P2 : Natural; 2157 Inside_Nul : Boolean := False; 2158 Arg : String (1 .. 1024); 2159 Arg_Ctr : Natural; 2160 2161 begin 2162 P1 := 1; 2163 while P1 <= S'Last and then S (P1) = ' ' loop 2164 P1 := P1 + 1; 2165 end loop; 2166 2167 Arg_Ctr := 1; 2168 Arg (Arg_Ctr) := S (P1); 2169 2170 while P1 <= S'Last loop 2171 if S (P1) = ASCII.NUL then 2172 if Inside_Nul then 2173 Inside_Nul := False; 2174 else 2175 Inside_Nul := True; 2176 end if; 2177 end if; 2178 2179 if S (P1) = ' ' and then not Inside_Nul then 2180 P1 := P1 + 1; 2181 Arg_Ctr := Arg_Ctr + 1; 2182 Arg (Arg_Ctr) := S (P1); 2183 2184 else 2185 Last_Switches.Increment_Last; 2186 P2 := P1; 2187 2188 while P2 < S'Last 2189 and then (S (P2 + 1) /= ' ' or else 2190 Inside_Nul) 2191 loop 2192 P2 := P2 + 1; 2193 Arg_Ctr := Arg_Ctr + 1; 2194 Arg (Arg_Ctr) := S (P2); 2195 if S (P2) = ASCII.NUL then 2196 Arg_Ctr := Arg_Ctr - 1; 2197 2198 if Inside_Nul then 2199 Inside_Nul := False; 2200 else 2201 Inside_Nul := True; 2202 end if; 2203 end if; 2204 end loop; 2205 2206 Last_Switches.Table (Last_Switches.Last) := 2207 new String'(String (Arg (1 .. Arg_Ctr))); 2208 P1 := P2 + 2; 2209 2210 exit when P1 > S'Last; 2211 2212 Arg_Ctr := 1; 2213 Arg (Arg_Ctr) := S (P1); 2214 end if; 2215 end loop; 2216 end Process_Buffer; 2217 2218 -------------------------------- 2219 -- Validate_Command_Or_Option -- 2220 -------------------------------- 2221 2222 procedure Validate_Command_Or_Option (N : VMS_Data.String_Ptr) is 2223 begin 2224 pragma Assert (N'Length > 0); 2225 2226 for J in N'Range loop 2227 if N (J) = '_' then 2228 pragma Assert (N (J - 1) /= '_'); 2229 null; 2230 else 2231 pragma Assert (Is_Upper (N (J)) or else Is_Digit (N (J))); 2232 null; 2233 end if; 2234 end loop; 2235 end Validate_Command_Or_Option; 2236 2237 -------------------------- 2238 -- Validate_Unix_Switch -- 2239 -------------------------- 2240 2241 procedure Validate_Unix_Switch (S : VMS_Data.String_Ptr) is 2242 begin 2243 if S (S'First) = '`' then 2244 return; 2245 end if; 2246 2247 pragma Assert (S (S'First) = '-' or else S (S'First) = '!'); 2248 2249 for J in S'First + 1 .. S'Last loop 2250 pragma Assert (S (J) /= ' '); 2251 2252 if S (J) = '!' then 2253 pragma Assert (S (J - 1) = ',' and then S (J + 1) = '-'); 2254 null; 2255 end if; 2256 end loop; 2257 end Validate_Unix_Switch; 2258 2259 -------------------- 2260 -- VMS_Conversion -- 2261 -------------------- 2262 2263 procedure VMS_Conversion (The_Command : out Command_Type) is 2264 Result : Command_Type := Undefined; 2265 Result_Set : Boolean := False; 2266 2267 begin 2268 Buffer.Init; 2269 2270 -- First we must preprocess the string form of the command and options 2271 -- list into the internal form that we use. 2272 2273 Preprocess_Command_Data; 2274 2275 -- If no parameters, give complete list of commands 2276 2277 if Argument_Count = 0 then 2278 Output_Version; 2279 New_Line; 2280 Put_Line ("List of available commands"); 2281 New_Line; 2282 2283 while Commands /= null loop 2284 2285 -- No usage for GNAT SYNC 2286 2287 if Commands.Command /= Sync then 2288 Put (Commands.Usage.all); 2289 Set_Col (53); 2290 Put_Line (Commands.Unix_String.all); 2291 end if; 2292 2293 Commands := Commands.Next; 2294 end loop; 2295 2296 raise Normal_Exit; 2297 end if; 2298 2299 -- Loop through arguments 2300 2301 Arg_Num := 1; 2302 while Arg_Num <= Argument_Count loop 2303 Process_Argument (Result); 2304 2305 if not Result_Set then 2306 The_Command := Result; 2307 Result_Set := True; 2308 end if; 2309 end loop; 2310 2311 -- Gross error checking that the number of parameters is correct. 2312 -- Not applicable to Unlimited_Files parameters. 2313 2314 if (Param_Count = Command.Params'Length - 1 2315 and then Command.Params (Param_Count + 1) = Unlimited_Files) 2316 or else Param_Count <= Command.Params'Length 2317 then 2318 null; 2319 2320 else 2321 Put_Line (Standard_Error, 2322 "Parameter count of " 2323 & Integer'Image (Param_Count) 2324 & " not equal to expected " 2325 & Integer'Image (Command.Params'Length)); 2326 Put (Standard_Error, "usage: "); 2327 Put_Line (Standard_Error, Command.Usage.all); 2328 Errors := Errors + 1; 2329 end if; 2330 2331 if Errors > 0 then 2332 raise Error_Exit; 2333 else 2334 -- Prepare arguments for a call to spawn, filtering out 2335 -- embedded nulls place there to delineate strings. 2336 2337 Process_Buffer (String (Buffer.Table (1 .. Buffer.Last))); 2338 2339 if Cargs_Buffer.Last > 1 then 2340 Last_Switches.Append (new String'("-cargs")); 2341 Process_Buffer 2342 (String (Cargs_Buffer.Table (1 .. Cargs_Buffer.Last))); 2343 end if; 2344 end if; 2345 end VMS_Conversion; 2346 2347end VMS_Conv; 2348