| (* gm2lcc.mod generates the link command from a list of modules. |
| |
| Copyright (C) 2001-2023 Free Software Foundation, Inc. |
| Contributed by Gaius Mulley <gaius.mulley@southwales.ac.uk>. |
| |
| This file is part of GNU Modula-2. |
| |
| GNU Modula-2 is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 3, or (at your option) |
| any later version. |
| |
| GNU Modula-2 is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Modula-2; see the file COPYING3. If not see |
| <http://www.gnu.org/licenses/>. *) |
| |
| MODULE gm2lcc ; |
| |
| (* |
| Author : Gaius Mulley |
| Title : gm2lcc |
| Date : Fri Jul 24 11:45:08 BST 1992 |
| Description: generates the link command from a list of modules. |
| *) |
| |
| FROM libc IMPORT system, exit ; |
| FROM SYSTEM IMPORT ADR ; |
| FROM NameKey IMPORT Name, MakeKey, WriteKey, GetKey ; |
| FROM M2Search IMPORT FindSourceFile, PrependSearchPath ; |
| FROM M2FileName IMPORT CalculateFileName ; |
| FROM SArgs IMPORT GetArg ; |
| FROM StrLib IMPORT StrEqual, StrLen, StrCopy, StrConCat, StrRemoveWhitePrefix, IsSubString ; |
| FROM FIO IMPORT File, StdIn, StdErr, StdOut, Close, IsNoError, EOF, WriteString, WriteLine ; |
| FROM SFIO IMPORT OpenToRead, WriteS, ReadS ; |
| FROM ASCII IMPORT nul ; |
| FROM M2FileName IMPORT ExtractExtension ; |
| FROM DynamicStrings IMPORT String, InitString, KillString, ConCat, ConCatChar, Length, Slice, Equal, EqualArray, RemoveWhitePrefix, RemoveWhitePostfix, RemoveComment, string, Mark, InitStringChar, Dup, Mult, Assign, char ; |
| FROM FormatStrings IMPORT Sprintf0, Sprintf1, Sprintf2 ; |
| FROM M2Printf IMPORT fprintf0, fprintf1, fprintf2, fprintf3, fprintf4 ; |
| FROM ObjectFiles IMPORT FileObjects, InitFileObject, KillFileObject, |
| RegisterModuleObject, IsRegistered ; |
| FROM Indexing IMPORT Index, InitIndex, GetIndice, |
| HighIndice, LowIndice, IncludeIndiceIntoIndex, |
| ForeachIndiceInIndexDo ; |
| |
| |
| |
| CONST |
| Comment = '#' ; (* Comment leader. *) |
| MaxSpaces = 20 ; (* Maximum spaces after a module *) |
| (* name. *) |
| Debugging = FALSE ; |
| |
| VAR |
| DebugFound : BOOLEAN ; |
| CheckFound : BOOLEAN ; |
| VerboseFound : BOOLEAN ; |
| ProfileFound : BOOLEAN ; |
| LibrariesFound: BOOLEAN ; |
| TargetFound : BOOLEAN ; |
| ExecCommand : BOOLEAN ; (* should we execute the final cmd *) |
| UseAr : BOOLEAN ; (* use 'ar' and create archive *) |
| UseRanlib : BOOLEAN ; (* use 'ranlib' to index archive *) |
| IgnoreMain : BOOLEAN ; (* ignore main module when linking *) |
| UseLibtool : BOOLEAN ; (* use libtool and suffixes? *) |
| Shared : BOOLEAN ; (* is a shared library required? *) |
| BOption, (* the full -B option and directory. *) |
| FOptions, |
| CompilerDir, (* contains the directory after -B. *) |
| RanlibProgram, |
| ArProgram, |
| Archives, |
| Path, |
| StartupFile, |
| Libraries, |
| MainModule, |
| MainObject, |
| Command, |
| Target : String ; |
| CmdLine, |
| objects : FileObjects ; |
| CmdLineObjects: Index ; |
| fi, fo : File ; (* the input and output files *) |
| |
| |
| (* |
| FlushCommand - flush the command to the output file, |
| or execute the command. |
| *) |
| |
| PROCEDURE FlushCommand () : INTEGER ; |
| BEGIN |
| IF ExecCommand |
| THEN |
| IF VerboseFound |
| THEN |
| Command := WriteS (StdOut, Command) ; |
| fprintf0 (StdOut, '\n') |
| END ; |
| RETURN system (string (Command)) |
| ELSE |
| Command := WriteS (fo, Command) |
| END ; |
| RETURN 0 |
| END FlushCommand ; |
| |
| |
| (* |
| GenerateLinkCommand - generate the appropriate linkage command |
| with the correct options. |
| *) |
| |
| PROCEDURE GenerateLinkCommand ; |
| BEGIN |
| IF UseAr |
| THEN |
| Command := ConCat (ArProgram, InitString (' rc ')) ; |
| IF TargetFound |
| THEN |
| Command := ConCat (Command, Target) ; |
| Command := ConCatChar (Command, ' ') |
| ELSE |
| WriteString (StdErr, 'need target with ar') ; WriteLine (StdErr) ; Close (StdErr) ; |
| exit (1) |
| END |
| ELSIF UseLibtool |
| THEN |
| Command := InitString ('libtool --tag=CC --mode=link gcc ') ; |
| IF BOption # NIL |
| THEN |
| Command := ConCat (Command, Dup (BOption)) ; |
| Command := ConCatChar (Command, ' ') |
| END ; |
| IF DebugFound |
| THEN |
| Command := ConCat (Command, Mark (InitString ('-g '))) |
| END ; |
| IF ProfileFound |
| THEN |
| Command := ConCat(Command, Mark(InitString ('-p '))) |
| END ; |
| Command := ConCat (Command, FOptions) ; |
| IF Shared |
| THEN |
| Command := ConCat (Command, Mark (InitString ('-shared '))) |
| END ; |
| IF TargetFound |
| THEN |
| Command := ConCat (Command, Mark (InitString ('-o '))) ; |
| Command := ConCat (Command, Target) ; |
| Command := ConCatChar (Command, ' ') |
| END ; |
| IF ProfileFound |
| THEN |
| Command := ConCat (Command, Mark (InitString ('-lgmon '))) |
| END |
| END |
| END GenerateLinkCommand ; |
| |
| |
| (* |
| GenerateRanlibCommand - generate the appropriate ranlib command. |
| *) |
| |
| PROCEDURE GenerateRanlibCommand ; |
| BEGIN |
| Command := ConCat (RanlibProgram, Mark (InitStringChar (' '))) ; |
| IF TargetFound |
| THEN |
| Command := ConCat (Command, Target) ; |
| Command := ConCatChar (Command, ' ') |
| ELSE |
| WriteString (StdErr, 'need target with ranlib') ; WriteLine (StdErr) ; Close (StdErr) ; |
| exit (1) |
| END |
| END GenerateRanlibCommand ; |
| |
| |
| (* |
| RemoveLinkOnly - removes the <onlylink> prefix, if present. This will occur |
| for a definition for "C" module where there is no |
| module constructor/destructor (_init and _finish pairs). |
| Otherwise, s, is returned. |
| *) |
| |
| PROCEDURE RemoveLinkOnly (s: String) : String ; |
| VAR |
| t: String ; |
| BEGIN |
| t := InitString ('<onlylink>') ; |
| IF Equal (Mark (Slice (s, 0, Length (t)-1)), t) |
| THEN |
| RETURN RemoveWhitePrefix (Slice (Mark (s), Length (t), 0)) |
| ELSE |
| RETURN s |
| END |
| END RemoveLinkOnly ; |
| |
| |
| (* |
| ConCatStartupFile - check to see if the startup object file has not been added |
| to the command line and if so add it. |
| *) |
| |
| PROCEDURE ConCatStartupFile ; |
| BEGIN |
| IF RegisterModuleObject (objects, StartupFile) |
| THEN |
| IF UseLibtool |
| THEN |
| Command := ConCat (Command, Mark (Sprintf1 (Mark (InitString ('%s.lo')), |
| StartupFile))) |
| ELSE |
| Command := ConCat (Command, Mark (Sprintf1 (Mark (InitString ('%s.o')), |
| StartupFile))) |
| END |
| END |
| END ConCatStartupFile ; |
| |
| |
| (* |
| GenObjectSuffix - |
| *) |
| |
| PROCEDURE GenObjectSuffix () : String ; |
| BEGIN |
| IF UseLibtool |
| THEN |
| RETURN InitString ('lo') |
| ELSE |
| RETURN InitString ('o') |
| END |
| END GenObjectSuffix ; |
| |
| |
| (* |
| GenArchiveSuffix - |
| *) |
| |
| PROCEDURE GenArchiveSuffix () : String ; |
| BEGIN |
| IF UseLibtool |
| THEN |
| RETURN InitString ('la') |
| ELSE |
| RETURN InitString ('a') |
| END |
| END GenArchiveSuffix ; |
| |
| |
| (* |
| LookupObjectFile - attempts to lookup the location of file name.extension |
| from using the -fobject-path path. NIL is retured if |
| the object file is not found. extension will be |
| marked and deleted. |
| *) |
| |
| PROCEDURE LookupObjectFile (name, extension: String) : String ; |
| VAR |
| location, |
| filename: String ; |
| BEGIN |
| filename := CalculateFileName (name, Mark (extension)) ; |
| IF FindSourceFile (filename, location) |
| THEN |
| RETURN location |
| ELSE |
| RETURN NIL |
| END |
| END LookupObjectFile ; |
| |
| |
| (* |
| ConCatModuleObject - this object will be associated with a module, therefore |
| we remember it and make sure that it is not duplicated on the |
| command line by the user. |
| *) |
| |
| PROCEDURE ConCatModuleObject (module: String) ; |
| VAR |
| location: String ; |
| BEGIN |
| location := LookupObjectFile (module, GenObjectSuffix ()) ; |
| IF location = NIL |
| THEN |
| location := LookupObjectFile (module, GenArchiveSuffix ()) ; |
| IF location # NIL |
| THEN |
| Archives := ConCatChar (ConCat (Archives, location), ' ') |
| END |
| ELSE |
| IF RegisterModuleObject (objects, location) |
| THEN |
| Command := ConCat (ConCatChar (Command, ' '), location) |
| END |
| END |
| END ConCatModuleObject ; |
| |
| |
| (* |
| FindModulesInFileList - |
| *) |
| |
| PROCEDURE FindModulesInFileList ; |
| VAR |
| text: String ; |
| BEGIN |
| REPEAT |
| text := RemoveComment (RemoveWhitePrefix( ReadS (fi)), Comment) ; |
| IF (NOT EqualArray (text, '')) AND (NOT (IgnoreMain AND Equal (text, MainModule))) |
| THEN |
| text := RemoveLinkOnly (text) ; |
| ConCatModuleObject (text) |
| END |
| UNTIL EOF (fi) ; |
| IF (NOT EqualArray (MainObject, "")) AND RegisterModuleObject (objects, MainObject) |
| THEN |
| Command := ConCat (ConCatChar (Command, ' '), MainObject) |
| END |
| END FindModulesInFileList ; |
| |
| |
| (* |
| CollectObjects - |
| *) |
| |
| PROCEDURE CollectObjects (Command: String) : String ; |
| VAR |
| i, h: CARDINAL ; |
| name: String ; |
| BEGIN |
| i := 1 ; |
| h := HighIndice (CmdLineObjects) ; |
| WHILE i <= h DO |
| name := GetIndice (CmdLineObjects, i) ; |
| IF NOT IsRegistered (objects, name) |
| THEN |
| Command := ConCat (ConCatChar (Command, ' '), Dup (name)) |
| END ; |
| INC (i) |
| END ; |
| IF Debugging |
| THEN |
| fprintf1 (StdErr, "objects on command line: %s\n", Command) |
| END ; |
| RETURN Command |
| END CollectObjects ; |
| |
| |
| (* |
| CollectArchives - |
| *) |
| |
| PROCEDURE CollectArchives (Command: String) : String ; |
| BEGIN |
| IF LibrariesFound |
| THEN |
| Command := ConCat (ConCatChar (Command, ' '), Libraries) |
| END ; |
| RETURN Command |
| END CollectArchives ; |
| |
| |
| (* |
| AddProgramModule - add the program module to the Command string, providing |
| that the user did not specify it on the command line. |
| *) |
| |
| PROCEDURE AddProgramModule (Command: String) : String ; |
| BEGIN |
| IF Debugging |
| THEN |
| fprintf1 (StdErr, "mainobject: %s\n", MainObject) |
| END ; |
| IF (NOT EqualArray (MainObject, "")) AND RegisterModuleObject (objects, MainObject) |
| THEN |
| IF Debugging |
| THEN |
| fprintf1 (StdErr, "first time: %s\n", MainObject) |
| END ; |
| Command := ConCat (ConCatChar (Command, ' '), MainObject) |
| ELSE |
| IF Debugging |
| THEN |
| fprintf0 (StdErr, "(ignored)\n") |
| END |
| END ; |
| RETURN Command |
| END AddProgramModule ; |
| |
| |
| (* |
| GenCC - writes out the linkage command for the C compiler. |
| *) |
| |
| PROCEDURE GenCC ; |
| VAR |
| Error: INTEGER ; |
| BEGIN |
| GenerateLinkCommand ; |
| ConCatStartupFile ; |
| FindModulesInFileList ; |
| Command := AddProgramModule (Command) ; |
| Command := ConCat (Command, Archives) ; |
| Command := CollectObjects (Command) ; |
| Command := CollectArchives (Command) ; |
| Error := FlushCommand () ; |
| IF Error=0 |
| THEN |
| IF UseRanlib |
| THEN |
| GenerateRanlibCommand ; |
| Error := FlushCommand () ; |
| IF Error#0 |
| THEN |
| fprintf1 (StdErr, 'ranlib failed with exit code %d\n', Error) ; |
| Close (StdErr) ; |
| exit (Error) |
| END |
| END |
| ELSE |
| fprintf1 (StdErr, 'ar failed with exit code %d\n', Error) ; |
| Close (StdErr) ; |
| exit (Error) |
| END |
| END GenCC ; |
| |
| |
| (* |
| WriteModuleName - displays a module name, ModuleName, with formatted spaces |
| after the string. |
| *) |
| |
| (* |
| PROCEDURE WriteModuleName (ModuleName: String) ; |
| BEGIN |
| ModuleName := WriteS (fo, ModuleName) ; |
| IF KillString (WriteS (fo, Mark (Mult (Mark (InitString (' ')), MaxSpaces-Length(ModuleName))))) = NIL |
| THEN |
| END |
| END WriteModuleName ; |
| *) |
| |
| |
| (* |
| CheckCC - checks to see whether all the object files can be found |
| for each module. |
| *) |
| |
| PROCEDURE CheckCC ; |
| VAR |
| s, t, u: String ; |
| Error : INTEGER ; |
| BEGIN |
| Error := 0 ; |
| REPEAT |
| s := RemoveComment (RemoveWhitePrefix (ReadS (fi)), Comment) ; |
| IF NOT EqualArray (s, '') |
| THEN |
| s := RemoveLinkOnly (s) ; |
| t := Dup (s) ; |
| t := CalculateFileName (s, Mark (GenObjectSuffix ())) ; |
| IF FindSourceFile (t, u) |
| THEN |
| IF KillString (WriteS (fo, Mark (Sprintf2 (Mark (InitString ('%-20s : %s\n')), t, u)))) = NIL |
| THEN |
| END ; |
| u := KillString (u) |
| ELSE |
| t := KillString (t) ; |
| (* try finding .a archive *) |
| t := CalculateFileName (s, Mark (GenArchiveSuffix ())) ; |
| IF FindSourceFile (t, u) |
| THEN |
| IF KillString (WriteS (fo, Mark (Sprintf2 (Mark (InitString ('%-20s : %s\n')), t, u)))) = NIL |
| THEN |
| END ; |
| u := KillString (u) |
| ELSE |
| IF KillString (WriteS (fo, Mark (Sprintf1 (InitString ('%-20s : distinct object or archive not found\n'), t)))) = NIL |
| THEN |
| END ; |
| Error := 1 |
| END |
| END |
| END |
| UNTIL EOF (fi) ; |
| Close (fo) ; |
| exit (Error) |
| END CheckCC ; |
| |
| |
| (* |
| ProcessTarget - copies the specified target file into Target |
| and sets the boolean TargetFound. |
| *) |
| |
| PROCEDURE ProcessTarget (i: CARDINAL) ; |
| BEGIN |
| IF NOT GetArg (Target, i) |
| THEN |
| fprintf0 (StdErr, 'cannot get target argument after -o\n') ; |
| Close (StdErr) ; |
| exit (1) |
| END ; |
| TargetFound := TRUE |
| END ProcessTarget ; |
| |
| |
| (* |
| StripModuleExtension - returns a String without an extension from, s. |
| It only considers '.obj', '.o' and '.lo' as |
| extensions. |
| *) |
| |
| PROCEDURE StripModuleExtension (s: String) : String ; |
| VAR |
| t: String ; |
| BEGIN |
| t := ExtractExtension (s, Mark (InitString ('.lo'))) ; |
| IF s=t |
| THEN |
| t := ExtractExtension (s, Mark (InitString ('.obj'))) ; |
| IF s=t |
| THEN |
| RETURN ExtractExtension (s, Mark(InitString('.o'))) |
| END |
| END ; |
| RETURN t |
| END StripModuleExtension ; |
| |
| |
| (* |
| ProcessStartupFile - copies the specified startup file name into StartupFile. |
| *) |
| |
| PROCEDURE ProcessStartupFile (i: CARDINAL) ; |
| BEGIN |
| IF GetArg (StartupFile, i) |
| THEN |
| StartupFile := StripModuleExtension (StartupFile) |
| ELSE |
| fprintf0 (StdErr, 'cannot get startup argument after --startup\n') ; |
| Close (StdErr) ; |
| exit (1) |
| END |
| END ProcessStartupFile ; |
| |
| |
| (* |
| IsALibrary - returns TRUE if, a, is a library. If TRUE we add it to the |
| Libraries string. |
| *) |
| |
| PROCEDURE IsALibrary (s: String) : BOOLEAN ; |
| BEGIN |
| IF EqualArray (Mark (Slice (s, 0, 2)), '-l') |
| THEN |
| LibrariesFound := TRUE ; |
| Libraries := ConCat (ConCatChar (Libraries, ' '), s) ; |
| RETURN TRUE |
| ELSE |
| RETURN FALSE |
| END |
| END IsALibrary ; |
| |
| |
| (* |
| IsALibraryPath - |
| *) |
| |
| PROCEDURE IsALibraryPath (s: String) : BOOLEAN ; |
| BEGIN |
| IF EqualArray (Mark (Slice (s, 0, 2)), '-L') |
| THEN |
| IF UseLibtool |
| THEN |
| LibrariesFound := TRUE ; |
| Libraries := ConCat (ConCatChar (Libraries, ' '), s) |
| END ; |
| RETURN TRUE |
| ELSE |
| RETURN FALSE |
| END |
| END IsALibraryPath ; |
| |
| |
| (* |
| AddCommandLineObject - adds, s, to a list of objects specified on the command line. |
| *) |
| |
| PROCEDURE AddCommandLineObject (s: String) ; |
| BEGIN |
| s := Dup (s) ; |
| IncludeIndiceIntoIndex (CmdLineObjects, s) ; |
| IF RegisterModuleObject (CmdLine, s) |
| THEN |
| IF Debugging |
| THEN |
| fprintf1 (StdErr, "object registered first time: %s\n", s) |
| END |
| ELSE |
| IF Debugging |
| THEN |
| fprintf1 (StdErr, " object ignored: %s\n", s) |
| END |
| END |
| END AddCommandLineObject ; |
| |
| |
| (* |
| IsAnObject - returns TRUE if, a, is a library. |
| *) |
| |
| PROCEDURE IsAnObject (s: String) : BOOLEAN ; |
| BEGIN |
| IF ((Length (s) > 2) AND EqualArray (Mark (Slice (s, -2, 0)), '.o')) OR |
| ((Length (s) > 4) AND EqualArray (Mark (Slice (s, -4, 0)), '.obj')) |
| THEN |
| RETURN TRUE |
| ELSE |
| RETURN FALSE |
| END |
| END IsAnObject ; |
| |
| |
| (* |
| AdditionalFOptions - add an -f option to the compiler. |
| *) |
| |
| PROCEDURE AdditionalFOptions (s: String) ; |
| BEGIN |
| FOptions := ConCat (FOptions, Mark (s)) ; |
| FOptions := ConCatChar (FOptions, ' ') |
| END AdditionalFOptions ; |
| |
| |
| (* |
| DisplayHelp - |
| *) |
| |
| PROCEDURE DisplayHelp ; |
| BEGIN |
| fprintf0 (StdErr, 'Usage: gm2lcc [-c][-g][-h][--help][--main mainmodule]\n'); |
| fprintf0 (StdErr, ' [--mainobject objectname][-Bdirectory][-p][--exec][-fshared]\n'); |
| fprintf0 (StdErr, ' [--ignoremain][--ar][-fobject-path=path][-ftarget-ar=arname]\n'); |
| fprintf0 (StdErr, ' [-ftarget-ranlib=ranlibname][-o outputname][--startup filename]\n') ; |
| fprintf0 (StdErr, ' [-foption][-llibname][-Lpath] filename\n'); |
| exit (0) |
| END DisplayHelp ; |
| |
| |
| (* |
| ScanArguments - scans arguments for flags: -fobject-path= -g and -B |
| *) |
| |
| PROCEDURE ScanArguments ; |
| VAR |
| filename, |
| s : String ; |
| i : CARDINAL ; |
| FoundFile: BOOLEAN ; |
| BEGIN |
| FoundFile := FALSE ; |
| filename := NIL ; |
| i := 1 ; |
| WHILE GetArg (s, i) DO |
| IF EqualArray (s, '-h') OR EqualArray (s, '--help') |
| THEN |
| DisplayHelp |
| ELSIF EqualArray (s, '-g') |
| THEN |
| DebugFound := TRUE |
| ELSIF EqualArray (s, '-c') |
| THEN |
| CheckFound := TRUE |
| ELSIF EqualArray (s, '--main') |
| THEN |
| INC (i) ; |
| IF NOT GetArg (MainModule, i) |
| THEN |
| fprintf0 (StdErr, 'expecting modulename after the --main option\n') ; |
| Close (StdErr) ; |
| exit (1) |
| END |
| ELSIF EqualArray (s, '--mainobject') |
| THEN |
| INC (i) ; |
| IF GetArg (MainObject, i) |
| THEN |
| (* do nothing. *) |
| ELSE |
| fprintf0 (StdErr, 'expecting an object file after the --mainobject option\n') ; |
| Close (StdErr) ; |
| exit (1) |
| END |
| ELSIF EqualArray (Mark (Slice (s, 0, 2)), '-B') |
| THEN |
| CompilerDir := KillString (CompilerDir) ; |
| IF Length (s) = 2 |
| THEN |
| INC(i) ; |
| IF NOT GetArg (CompilerDir, i) |
| THEN |
| fprintf0 (StdErr, 'expecting path after -B option\n') ; |
| Close (StdErr) ; |
| exit (1) |
| END |
| ELSE |
| CompilerDir := Slice (s, 2, 0) |
| END ; |
| BOption := Dup (s) |
| ELSIF EqualArray (s, '-p') |
| THEN |
| ProfileFound := TRUE |
| ELSIF EqualArray (s, '-v') |
| THEN |
| VerboseFound := TRUE |
| ELSIF EqualArray (s, '--exec') |
| THEN |
| ExecCommand := TRUE |
| ELSIF EqualArray (s, '-fshared') |
| THEN |
| Shared := TRUE |
| ELSIF EqualArray (s, '--ignoremain') |
| THEN |
| IgnoreMain := TRUE |
| ELSIF EqualArray (s, '--ar') |
| THEN |
| UseAr := TRUE ; |
| UseRanlib := TRUE ; |
| UseLibtool := FALSE |
| ELSIF EqualArray (Mark (Slice (s, 0, 14)), '-fobject-path=') |
| THEN |
| PrependSearchPath (Slice (s, 14, 0)) |
| ELSIF EqualArray (Mark (Slice (s, 0, 12)), '-ftarget-ar=') |
| THEN |
| ArProgram := KillString (ArProgram) ; |
| ArProgram := Slice (s, 12, 0) |
| ELSIF EqualArray (Mark (Slice (s, 0, 16)), '-ftarget-ranlib=') |
| THEN |
| RanlibProgram := KillString (RanlibProgram) ; |
| RanlibProgram := Slice (s, 16, 0) |
| ELSIF EqualArray (s, '-o') |
| THEN |
| INC (i) ; (* Target found *) |
| ProcessTarget (i) |
| ELSIF EqualArray (s, '--startup') |
| THEN |
| INC (i) ; (* Target found. *) |
| ProcessStartupFile (i) |
| ELSIF EqualArray (Mark (Slice (s, 0, 2)), '-f') |
| THEN |
| AdditionalFOptions (s) |
| ELSIF IsALibrary (s) OR IsALibraryPath (s) |
| THEN |
| ELSIF IsAnObject (s) |
| THEN |
| AddCommandLineObject (s) |
| ELSE |
| IF FoundFile |
| THEN |
| fprintf2 (StdErr, 'already specified input filename (%s), unknown option (%s)\n', filename, s) ; |
| Close (StdErr) ; |
| exit (1) |
| ELSE |
| (* must be input filename. *) |
| Close (StdIn) ; |
| fi := OpenToRead (s) ; |
| IF NOT IsNoError (fi) |
| THEN |
| fprintf1 (StdErr, 'failed to open %s\n', s) ; |
| Close (StdErr) ; |
| exit (1) |
| END ; |
| FoundFile := TRUE ; |
| filename := Dup (s) |
| END |
| END ; |
| INC (i) |
| END |
| END ScanArguments ; |
| |
| |
| (* |
| Init - initializes the global variables. |
| *) |
| |
| PROCEDURE Init ; |
| BEGIN |
| DebugFound := FALSE ; |
| CheckFound := FALSE ; |
| TargetFound := FALSE ; |
| ProfileFound := FALSE ; |
| IgnoreMain := FALSE ; |
| UseAr := FALSE ; |
| UseLibtool := FALSE ; |
| UseRanlib := FALSE ; |
| VerboseFound := FALSE ; |
| Shared := FALSE ; |
| ArProgram := InitString ('ar') ; |
| RanlibProgram := InitString ('ranlib') ; |
| MainModule := InitString ('') ; |
| StartupFile := InitString ('mod_init') ; |
| fi := StdIn ; |
| fo := StdOut ; |
| ExecCommand := FALSE ; |
| |
| CompilerDir := InitString ('') ; |
| |
| FOptions := InitString ('') ; |
| Archives := NIL ; |
| Path := NIL ; |
| LibrariesFound:= FALSE ; |
| Libraries := InitString ('') ; |
| Command := NIL ; |
| Target := NIL ; |
| BOption := NIL ; |
| objects := InitFileObject () ; |
| CmdLine := InitFileObject () ; |
| CmdLineObjects:= InitIndex (1) ; |
| MainObject := InitString ('') ; |
| |
| ScanArguments ; |
| IF CheckFound |
| THEN |
| CheckCC |
| ELSE |
| GenCC |
| END ; |
| Close (fo) |
| END Init ; |
| |
| |
| BEGIN |
| Init |
| END gm2lcc. |
