README
1This directory contains the 3.80 release of GNU Make.
2
3See the file NEWS for the user-visible changes from previous releases.
4In addition, there have been bugs fixed.
5
6Please check the system-specific notes below for any caveats related to
7your operating system.
8
9For general building and installation instructions, see the file INSTALL.
10
11If you need to build GNU Make and have no other `make' program to use,
12you can use the shell script `build.sh' instead. To do this, first run
13`configure' as described in INSTALL. Then, instead of typing `make' to
14build the program, type `sh build.sh'. This should compile the program
15in the current directory. Then you will have a Make program that you can
16use for `./make install', or whatever else.
17
18Some systems' Make programs are broken and cannot process the Makefile for
19GNU Make. If you get errors from your system's Make when building GNU
20Make, try using `build.sh' instead.
21
22
23GNU Make is free software. See the file COPYING for copying conditions.
24
25
26Downloading
27-----------
28
29GNU Make can be obtained in many different ways. See a description here:
30
31 http://www.gnu.org/software/software.html
32
33
34Documentation
35-------------
36
37GNU make is fully documented in the GNU Make manual, which is contained
38in this distribution as the file make.texinfo. You can also find
39on-line and preformatted (PostScript and DVI) versions at the FSF's web
40site. There is information there about ordering hardcopy documentation.
41
42 http://www.gnu.org/
43 http://www.gnu.org/doc/doc.html
44 http://www.gnu.org/manual/manual.html
45
46
47Development
48-----------
49
50GNU Make development is hosted by Savannah, the FSF's online development
51management tool. Savannah is here:
52
53 http://savannah.gnu.org
54
55And the GNU Make development page is here:
56
57 http://savannah.gnu.org/projects/make/
58
59You can find most information concerning the development of GNU Make at
60this site.
61
62
63Bug Reporting
64-------------
65
66You can send GNU make bug reports to <bug-make@gnu.org>. Please see the
67section of the GNU make manual entitled `Problems and Bugs' for
68information on submitting useful and complete bug reports.
69
70You can also use the online bug tracking system in the Savannah GNU Make
71project to submit new problem reports or search for existing ones:
72
73 http://savannah.gnu.org/bugs/?group_id=71
74
75If you need help using GNU make, try these forums:
76
77 help-make@gnu.org
78 help-utils@gnu.org
79 news:gnu.utils.help
80 news:gnu.utils.bug
81
82 http://savannah.gnu.org/support/?group_id=71
83
84You may also find interesting patches to GNU Make available here:
85
86 http://savannah.gnu.org/patch/?group_id=71
87
88Note these patches are provided by our users as a service and we make no
89statements regarding their correctness. Please contact the authors
90directly if you have a problem or suggestion for a patch available on
91this page.
92
93
94CVS Access
95----------
96
97The GNU make source repository is available via anonymous CVS from the
98GNU Subversions CVS server; look here for details:
99
100 http://savannah.gnu.org/cvs/?group_id=71
101
102Please note: you won't be able to build GNU make from CVS without
103installing appropriate maintainer's tools, such as GNU m4, automake,
104autoconf, Perl, GNU make, and GCC. See the README.cvs file for hints on
105how to build GNU make once these tools are available. We make no
106guarantees about the contents or quality of the latest code in the CVS
107repository: it is not unheard of for code that is known to be broken to
108be checked in. Use at your own risk.
109
110
111System-specific Notes
112---------------------
113
114It has been reported that the XLC 1.2 compiler on AIX 3.2 is buggy such
115that if you compile make with `cc -O' on AIX 3.2, it will not work correctly.
116It is said that using `cc' without `-O' does work.
117
118One area that is often a problem in configuration and porting is the code
119to check the system's current load average. To make it easier to test and
120debug this code, you can do `make check-loadavg' to see if it works
121properly on your system. (You must run `configure' beforehand, but you
122need not build Make itself to run this test.)
123
124Another potential source of porting problems is the support for large
125files (LFS) in configure for those operating systems that provide it.
126Please report any bugs that you find in this area. If you run into
127difficulties, then as a workaround you should be able to disable LFS by
128adding the `--disable-largefile' option to the `configure' script.
129
130On systems that support micro- and nano-second timestamp values and
131where stat(2) provides this information, GNU make will use it when
132comparing timestamps to get the most accurate possible result. However,
133note that many current implementations of tools that *set* timestamps do
134not preserve micro- or nano-second granularity. This means that "cp -p"
135and other similar tools (tar, etc.) may not exactly duplicate timestamps
136with micro- and nano-second granularity on some systems. If your build
137system contains rules that depend on proper behavior of tools like "cp
138-p", you should consider using the .LOW_RESOLUTION_TIME pseudo-target to
139force make to treat them properly. See the manual for details.
140
141
142Ports
143-----
144
145 - See README.customs for details on integrating GNU make with the
146 Customs distributed build environment from the Pmake distribution.
147
148 - See readme.vms for details about GNU Make on OpenVMS.
149
150 - See README.Amiga for details about GNU Make on AmigaDOS.
151
152 - See README.W32 for details about GNU Make on Windows NT, 95, or 98.
153
154 - See README.DOS for compilation instructions on MS-DOS and MS-Windows
155 using DJGPP tools.
156
157 A precompiled binary of the MSDOS port of GNU Make is available as part
158 of DJGPP; see the WWW page http://www.delorie.com/djgpp/ for more
159 information.
160
161Please note there are two _separate_ ports of GNU make for Microsoft
162systems: a native Windows tool built with (for example) MSVC or Cygwin,
163and a DOS-based tool built with DJGPP. Please be sure you are looking
164at the right README!
165
README.Amiga
1Short: Port of GNU make with SAS/C (no ixemul.library required)
2Author: GNU, Amiga port by Aaron "Optimizer" Digulla
3Uploader: Aaron "Optimizer" Digulla (digulla@fh-konstanz.de)
4Type: dev/c
5
6This is a pure Amiga port of GNU make. It needs no extra libraries or
7anything. It has the following features (in addition to any features of
8GNU make):
9
10- Runs Amiga-Commands with SystemTags() (Execute)
11- Can run multi-line statements
12- Allows to use Device-Names in targets:
13
14 c:make : make.o
15
16 is ok. To distinguish between device-names and target : or ::, MAKE
17 looks for spaces. If there are any around :, it's taken as a target
18 delimiter, if there are none, it's taken as the name of a device. Note
19 that "make:make.o" tries to create "make.o" on the device "make:".
20- Replaces @@ by a newline in any command line:
21
22 if exists make @@\
23 delete make.bak quiet @@\
24 rename make make.bak @@\
25 endif @@\
26 $(CC) Link Make.o To make
27
28 works. Note that the @@ must stand alone (ie. "make@@\" is illegal).
29 Also be carefull that there is a space after the "\" (ie, at the
30 beginning of the next line).
31- Can be made resident to save space and time
32- Amiga specific wildcards can be used in $(wildcard ...)
33
34BUGS:
35- The line
36
37 dummy.h : src/*.c
38
39tries to make dummy.h from "src/*.c" (ie. no wildcard-expansion takes
40place). You have to use "$(wildcard src/*.c)" instead.
41
42COMPILING FROM SCRATCH
43----------------------
44
45To recompile, you need SAS/C 6.51. make itself is not neccessary, there
46is an smakefile.
47
481. Copy config.ami to config.h
492. If you use make to compie, copy Makefile.ami to Makefile and
50 glob/Makefile.ami to glob/Makefile. Copy make into the current
51 directory.
52
533. Run smake/make
54
55INSTALLATION
56
57Copy make somewhere in your search path (eg. sc:c or sc:bin).
58If you plan to use recursive makes, install make resident:
59
60 Resident make Add
61
62
README.customs
1 -*-indented-text-*-
2
3GNU make can utilize the Customs library, distributed with Pmake, to
4provide builds distributed across multiple hosts.
5
6In order to utilize this capability, you must first download and build
7the Customs library. It is contained in the Pmake distribution, which
8can be obtained at:
9
10 ftp://ftp.icsi.berkeley.edu/pub/ai/stolcke/software/
11
12This integration was tested (superficially) with Pmake 2.1.33.
13
14
15BUILDING CUSTOMS
16----------------
17
18First, build pmake and Customs. You need to build pmake first, because
19Customs require pmake to build. Unfortunately, this is not trivial;
20please see the pmake and Customs documentation for details. The best
21place to look for instructions is in the pmake-2.1.33/INSTALL file.
22
23Note that the 2.1.33 Pmake distribution comes with a set of patches to
24GNU make, distributed in the pmake-2.1.33/etc/gnumake/ directory. These
25patches are based on GNU make 3.75 (there are patches for earlier
26versions of GNU make, also). The parts of this patchfile which relate
27directly to Customs support have already been incorporated into this
28version of GNU make, so you should _NOT_ apply the patch file.
29
30However, there are a few non-Customs specific (as far as I could tell)
31changes here which are not incorporated (for example, the modification
32to try expanding -lfoo to libfoo.so). If you rely on these changes
33you'll need to re-apply them by hand.
34
35Install the Customs library and header files according to the
36documentation. You should also install the man pages (contrary to
37comments in the documentation, they weren't installed automatically for
38me; I had to cd to the ``pmake-2.1.33/doc'' directory and run ``pmake
39install'' there directly).
40
41
42BUILDING GNU MAKE
43-----------------
44
45Once you've installed Customs, you can build GNU make to use it. When
46configuring GNU make, merely use the ``--with-customs=DIR'' option.
47Provide the directory containing the ``lib'' and ``include/customs''
48subdirectories as DIR. For example, if you installed the customs
49library in /usr/local/lib and the headers in /usr/local/include/customs,
50then you'd pass ``--with-customs=/usr/local'' as an option to configure.
51
52Run make (or use build.sh) normally to build GNU make as described in
53the INSTALL file.
54
55See the documentation for Customs for information on starting and
56configuring Customs.
57
58
59INVOKING CUSTOMS-IZED GNU MAKE
60-----------------------------
61
62One thing you should be aware of is that the default build environment
63for Customs requires root permissions. Practically, this means that GNU
64make must be installed setuid root to use Customs.
65
66If you don't want to do this, you can build Customs such that root
67permissions are not necessary. Andreas Stolcke <stolcke@speech.sri.com>
68writes:
69
70 > pmake, gnumake or any other customs client program is not required to
71 > be suid root if customs was compiled WITHOUT the USE_RESERVED_PORTS
72 > option in customs/config.h. Make sure the "customs" service in
73 > /etc/services is defined accordingly (port 8231 instead of 1001).
74
75 > Not using USE_RESERVED_PORTS means that a user with programming
76 > skills could impersonate another user by writing a fake customs
77 > client that pretends to be someone other than himself. See the
78 > discussion in etc/SECURITY.
79
80
81PROBLEMS
82--------
83
84SunOS 4.1.x:
85 The customs/sprite.h header file #includes the <malloc.h> header
86 files; this conflicts with GNU make's configuration so you'll get a
87 compile error if you use GCC (or any other ANSI-capable C compiler).
88
89 I commented out the #include in sprite.h:107:
90
91 #if defined(sun) || defined(ultrix) || defined(hpux) || defined(sgi)
92 /* #include <malloc.h> */
93 #else
94
95 YMMV.
96
README.DOS
1Port of GNU Make to 32-bit protected mode on MSDOS and MS-Windows.
2
3Builds with DJGPP v2 port of GNU C/C++ compiler and utilities.
4
5
6New (since 3.74) DOS-specific features:
7
8 1. Supports long filenames when run from DOS box on Windows 9x.
9
10 2. Supports both stock DOS COMMAND.COM and Unix-style shells
11 (details in ``Notes'' below).
12
13 3. Supports DOS drive letters in dependencies and pattern rules.
14
15 4. Better support for DOS-style backslashes in pathnames (but see
16 ``Notes'' below).
17
18 5. The $(shell) built-in can run arbitrary complex commands,
19 including pipes and redirection, even when COMMAND.COM is your
20 shell.
21
22 6. Can be built without floating-point code (see below).
23
24 7. Supports signals in child programs and restores the original
25 directory if the child was interrupted.
26
27 8. Can be built without (a previous version of) Make.
28
29 9. The build process requires only standard tools. (Optional
30 targets like "install:" and "clean:" still need additional
31 programs, though, see below.)
32
33 10. Beginning with v3.78, the test suite works in the DJGPP
34 environment (requires Perl and auxiliary tools; see below).
35
36
37To install a binary distribution:
38
39 Simply unzip the makNNNb.zip file (where NNN is the version number)
40 preserving the directory structure (-d switch if you use PKUNZIP).
41 If you are installing Make on Windows 9X or Windows 2000, use an
42 unzip program that supports long filenames in zip files. After
43 unzipping, make sure the directory with make.exe is on your PATH,
44 and that's all you need to use Make.
45
46
47To build from sources:
48
49 1. Unzip the archive, preserving the directory structure (-d switch
50 if you use PKUNZIP). If you build Make on Windows 9X or Windows
51 2000, use an unzip program that supports long filenames in zip
52 files.
53
54 If you are unpacking an official GNU source distribution, use
55 either DJTAR (which is part of the DJGPP development
56 environment), or the DJGPP port of GNU Tar.
57
58 2. Invoke the `configure.bat' batch file.
59
60 If you are building Make in-place, i.e. in the same directory
61 where its sources are kept, just type "configure.bat" and press
62 [Enter]. Otherwise, you need to supply the path to the source
63 directory as an argument to the batch file, like this:
64
65 c:\djgpp\gnu\make-3.80\configure.bat c:/djgpp/gnu/make-3.80
66
67 Note the forward slashes in the source path argument: you MUST
68 use them here.
69
70 3. If configure.bat doesn't find a working Make, it will suggest to
71 use the `dosbuild.bat' batch file to build Make. Either do as it
72 suggests or install another Make program (a pre-compiled binary
73 should be available from the usual DJGPP sites) and rerun
74 configure.bat.
75
76 4. If you will need to run Make on machines without an FPU, you
77 might consider building a version of Make which doesn't issue
78 floating-point instructions (they don't help much on MSDOS
79 anyway). To this end, edit the Makefile created by
80 configure.bat and add -DNO_FLOAT to the value of CPPFLAGS.
81
82 5. Invoke Make.
83
84 If you are building from outside of the source directory, you
85 need to tell Make where the sources are, like this:
86
87 make srcdir=c:/djgpp/gnu/make-3.80
88
89 (configure.bat will tell you this when it finishes). You MUST
90 use a full, not relative, name of the source directory here, or
91 else Make might fail.
92
93 6. After Make finishes, if you have a Unix-style shell installed,
94 you can use the `install' target to install the package. You
95 will also need GNU Fileutils and GNU Sed for this (they should
96 be available from the DJGPP sites).
97
98 By default, GNU make will install into your DJGPP installation
99 area. If you wish to use a different directory, override the
100 DESTDIR variable when invoking "make install", like this:
101
102 make install DESTDIR=c:/other/dir
103
104 This causes the make executable to be placed in c:/other/dir/bin,
105 the man pages in c:/other/dir/man, etc.
106
107 Without a Unix-style shell, you will have to install programs
108 and the docs manually. Copy make.exe to a directory on your
109 PATH, make.i* info files to your Info directory, and update the
110 file `dir' in your Info directory by adding the following item
111 to the main menu:
112
113 * Make: (make.info). The GNU make utility.
114
115 If you have the `install-info' program (from the GNU Texinfo
116 package), it will do that for you if you invoke it like this:
117
118 install-info --info-dir=c:/djgpp/info c:/djgpp/info/make.info
119
120 (If your Info directory is other than C:\DJGPP\INFO, change this
121 command accordingly.)
122
123 7. The `clean' targets also require Unix-style shell, and GNU Sed
124 and `rm' programs (the latter from Fileutils).
125
126 8. To run the test suite, type "make check". This requires a Unix
127 shell (I used the DJGPP port of Bash 2.03), Perl, Sed, Fileutils
128 and Sh-utils.
129
130
131Notes:
132-----
133
134 1. The shell issue.
135
136 This is probably the most significant improvement, first
137 introduced in the port of GNU Make 3.75.
138
139 The original behavior of GNU Make is to invoke commands
140 directly, as long as they don't include characters special to
141 the shell or internal shell commands, because that is faster.
142 When shell features like redirection or filename wildcards are
143 involved, Make calls the shell.
144
145 This port supports both DOS shells (the stock COMMAND.COM and its
146 4DOS/NDOS replacements), and Unix-style shells (tested with the
147 venerable Stewartson's `ms_sh' 2.3 and the DJGPP port of `bash' by
148 Daisuke Aoyama <jack@st.rim.or.jp>).
149
150 When the $SHELL variable points to a Unix-style shell, Make
151 works just like you'd expect on Unix, calling the shell for any
152 command that involves characters special to the shell or
153 internal shell commands. The only difference is that, since
154 there is no standard way to pass command lines longer than the
155 infamous DOS 126-character limit, this port of Make writes the
156 command line to a temporary disk file and then invokes the shell
157 on that file.
158
159 If $SHELL points to a DOS-style shell, however, Make will not
160 call it automatically, as it does with Unix shells. Stock
161 COMMAND.COM is too dumb and would unnecessarily limit the
162 functionality of Make. For example, you would not be able to
163 use long command lines in commands that use redirection or
164 pipes. Therefore, when presented with a DOS shell, this port of
165 Make will emulate most of the shell functionality, like
166 redirection and pipes, and shall only call the shell when a
167 batch file or a command internal to the shell is invoked. (Even
168 when a command is an internal shell command, Make will first
169 search the $PATH for it, so that if a Makefile calls `mkdir',
170 you can install, say, a port of GNU `mkdir' and have it called
171 in that case.)
172
173 The key to all this is the extended functionality of `spawn' and
174 `system' functions from the DJGPP library; this port just calls
175 `system' where it would invoke the shell on Unix. The most
176 important aspect of these functions is that they use a special
177 mechanism to pass long (up to 16KB) command lines to DJGPP
178 programs. In addition, `system' emulates some internal
179 commands, like `cd' (so that you can now use forward slashes
180 with it, and can also change the drive if the directory is on
181 another drive). Another aspect worth mentioning is that you can
182 call Unix shell scripts directly, provided that the shell whose
183 name is mentioned on the first line of the script is installed
184 anywhere along the $PATH. It is impossible to tell here
185 everything about these functions; refer to the DJGPP library
186 reference for more details.
187
188 The $(shell) built-in is implemented in this port by calling
189 `popen'. Since `popen' calls `system', the above considerations
190 are valid for $(shell) as well. In particular, you can put
191 arbitrary complex commands, including pipes and redirection,
192 inside $(shell), which is in many cases a valid substitute for
193 the Unix-style command substitution (`command`) feature.
194
195
196 2. "SHELL=/bin/sh" -- or is it?
197
198 Many Unix Makefiles include a line which sets the SHELL, for
199 those versions of Make which don't have this as the default.
200 Since many DOS systems don't have `sh' installed (in fact, most
201 of them don't even have a `/bin' directory), this port takes
202 such directives with a grain of salt. It will only honor such a
203 directive if the basename of the shell name (like `sh' in the
204 above example) can indeed be found in the directory that is
205 mentioned in the SHELL= line (`/bin' in the above example), or
206 in the current working directory, or anywhere on the $PATH (in
207 that order). If the basename doesn't include a filename
208 extension, Make will look for any known extension that indicates
209 an executable file (.exe, .com, .bat, .btm, .sh, and even .sed
210 and .pl). If any such file is found, then $SHELL will be
211 defined to the exact pathname of that file, and that shell will
212 hence be used for the rest of processing. But if the named
213 shell is *not* found, the line which sets it will be effectively
214 ignored, leaving the value of $SHELL as it was before. Since a
215 lot of decisions that this port makes depend on the gender of
216 the shell, I feel it doesn't make any sense to tailor Make's
217 behavior to a shell which is nowhere to be found.
218
219 Note that the above special handling of "SHELL=" only happens
220 for Makefiles; if you set $SHELL in the environment or on the
221 Make command line, you are expected to give the complete
222 pathname of the shell, including the filename extension.
223
224 The default value of $SHELL is computed as on Unix (see the Make
225 manual for details), except that if $SHELL is not defined in the
226 environment, $COMSPEC is used. Also, if an environment variable
227 named $MAKESHELL is defined, it takes precedence over both
228 $COMSPEC and $SHELL. Note that, unlike Unix, $SHELL in the
229 environment *is* used to set the shell (since on MSDOS, it's
230 unlikely that the interactive shell will not be suitable for
231 Makefile processing).
232
233 The bottom line is that you can now write Makefiles where some
234 of the targets require a real (i.e. Unix-like) shell, which will
235 nevertheless work when such shell is not available (provided, of
236 course, that the commands which should always work, don't
237 require such a shell). More important, you can convert Unix
238 Makefiles to MSDOS and leave the line which sets the shell
239 intact, so that people who do have Unixy shell could use it for
240 targets which aren't converted to DOS (like `install' and
241 `uninstall', for example).
242
243
244 3. Default directories.
245
246 GNU Make knows about standard directories where it searches for
247 library and include files mentioned in the Makefile. Since
248 MSDOS machines don't have standard places for these, this port
249 will search ${DJDIR}/lib and ${DJDIR}/include respectively.
250 $DJDIR is defined automatically by the DJGPP startup code as the
251 root of the DJGPP installation tree (unless you've tampered with
252 the DJGPP.ENV file). This should provide reasonable default
253 values, unless you moved parts of DJGPP to other directories.
254
255
256 4. Letter-case in filenames.
257
258 If you run Make on Windows 9x, you should be aware of the
259 letter-case issue. Make is internally case-sensitive, but all
260 file operations are case-insensitive on Windows 9x, so
261 e.g. files `FAQ', `faq' and `Faq' all refer to the same file, as
262 far as Windows is concerned. The underlying DJGPP C library
263 functions honor the letter-case of the filenames they get from
264 the OS, except that by default, they down-case 8+3 DOS filenames
265 which are stored in upper case in the directory and would break
266 many Makefiles otherwise. (The details of which filenames are
267 converted to lower case are explained in the DJGPP libc docs,
268 under the `_preserve_fncase' and `_lfn_gen_short_fname'
269 functions, but as a thumb rule, any filename that is stored in
270 upper case in the directory, is a valid DOS 8+3 filename and
271 doesn't include characters invalid on MSDOS FAT filesystems,
272 will be automatically down-cased.) User reports that I have
273 indicate that this default behavior is generally what you'd
274 expect; however, your input is most welcome.
275
276 In any case, if you hit a situation where you must force Make to
277 get the 8+3 DOS filenames in upper case, set FNCASE=y in the
278 environment or in the Makefile.
279
280
281 5. DOS-style pathnames.
282
283 There are a lot of places throughout the program sources which
284 make implicit assumptions about the pathname syntax. In
285 particular, the directories are assumed to be separated by `/',
286 and any pathname which doesn't begin with a `/' is assumed to be
287 relative to the current directory. This port attempts to
288 support DOS-style pathnames which might include the drive letter
289 and use backslashes instead of forward slashes. However, this
290 support is not complete; I feel that pursuing this support too
291 far might break some more important features, particularly if
292 you use a Unix-style shell (where a backslash is a quote
293 character). I only consider support of backslashes desirable
294 because some Makefiles invoke non-DJGPP programs which don't
295 understand forward slashes. A notable example of such programs
296 is the standard programs which come with MSDOS. Otherwise, you
297 are advised to stay away from backslashes whenever possible. In
298 particular, filename globbing won't work on pathnames with
299 backslashes, because the GNU `glob' library doesn't support them
300 (backslash is special in filename wildcards, and I didn't want
301 to break that).
302
303 One feature which *does* work with backslashes is the filename-
304 related built-in functions such as $(dir), $(notdir), etc.
305 Drive letters in pathnames are also fully supported.
306
307
308
309Bug reports:
310-----------
311
312 Bugs that are clearly related to the MSDOS/DJGPP port should be
313 reported first on the comp.os.msdos.djgpp news group (if you cannot
314 post to Usenet groups, write to the DJGPP mailing list,
315 <djgpp@delorie.com>, which is an email gateway into the above news
316 group). For other bugs, please follow the procedure explained in
317 the "Bugs" chapter of the Info docs. If you don't have an Info
318 reader, look up that chapter in the `make.i1' file with any text
319 browser/editor.
320
321
322 Enjoy,
323 Eli Zaretskii <eliz@is.elta.co.il>
324
readme.vms
1This is the VMS port of GNU Make done by Hartmut.Becker@compaq.com.
2
3It is based on the specific version 3.77k and on 3.78.1. 3.77k was done
4by Klaus K�mpf <kkaempf@rmi.de>, the code was based on the VMS port of
5GNU Make 3.60 by Mike Moretti.
6
7It was ported on OpenVMS/Alpha V7.1, DECC V5.7-006. It was re-build and
8tested on OpenVMS/Alpha V7.2, OpenVMS/VAX 7.1 and 5.5-2. Different
9versions of DECC were used. VAXC was tried: it fails; but it doesn't
10seem worth to get it working. There are still some PTRMISMATCH warnings
11during the compile. Although perl is working on VMS the test scripts
12don't work. The function $shell is still missing.
13
14There is a known bug in some of the VMS CRTLs. It is in the shipped
15versions of VMS V7.2 and V7.2-1 and in the currently (October 1999)
16available ECOs for VMS V7.1 and newer versions. It is fixed in versions
17shipped with newer VMS versions and all ECO kits after October 1999. It
18only shows up during the daylight saving time period (DST): stat()
19returns a modification time 1 hour ahead. This results in GNU make
20warning messages. For a just created source you will see:
21
22 $ gmake x.exe
23 gmake.exe;1: *** Warning: File `x.c' has modification time in the future (940582863 > 940579269)
24 cc /obj=x.obj x.c
25 link x.obj /exe=x.exe
26 gmake.exe;1: *** Warning: Clock skew detected. Your build may be incomplete.
27
28
29New in 3.78.1:
30
31Fix a problem with automatically remaking makefiles. GNU make uses an
32execve to restart itself after a successful remake of the makefile. On
33UNIX systems execve replaces the running program with a new one and
34resets all signal handling to the default. On VMS execve creates a child
35process, signal and exit handlers of the parent are still active, and,
36unfortunately, corrupt the exit code from the child. Fix in job.c:
37ignore SIGCHLD.
38
39Added some switches to reflect latest features of DECC. Modifications in
40makefile.vms.
41
42Set some definitions to reflect latest features of DECC. Modifications in
43config.h-vms (which is copied to config.h).
44
45Added extern strcmpi declaration to avoid 'implicitly declared' messages.
46Modification in make.h.
47
48Default rule for C++, conditionals for gcc (GCC_IS_NATIVE) or DEC/Digital/
49Compaq c/c++ compilers. Modifications in default.c.
50
51Usage of opendir() and friends, suppress file version. Modifications in dir.c.
52
53Added VMS specific code to handle ctrl+c and ctrl+y to abort make.
54Modifications in job.c.
55
56Added support to have case sensitive targets and dependencies but to
57still use case blind file names. This is especially useful for Java
58makefiles on VMS:
59
60 .SUFFIXES :
61 .SUFFIXES : .class .java
62 .java.class :
63 javac "$<
64 HelloWorld.class : HelloWorld.java
65
66A new macro WANT_CASE_SENSITIVE_TARGETS in config.h-vms was introduced.
67It needs to be enabled to get this feature; default is disabled. The
68macro HAVE_CASE_INSENSITIVE_FS must not be touched: it is still enabled.
69Modifications in file.c and config.h-vms.
70
71Bootstrap make to start building make is still makefile.com, but make
72needs to be re-made with a make to make a correct version: ignore all
73possible warnings, delete all objects, rename make.exe to a different
74name and run it.
75
76Made some minor modifications to the bootstrap build makefile.com.
77
78This is the VMS port of GNU Make.
79
80It is based on the VMS port of GNU Make 3.60 by Mike Moretti.
81
82This port was done by Klaus K�mpf <kkaempf@rmi.de>
83
84There is first-level support available from proGIS Software, Germany.
85Visit their web-site at http://www.progis.de to get information
86about other vms software and forthcoming updates to gnu make.
87
88New for 3.77:
89
90/bin/sh style I/O redirection is supported. You can now write lines like
91 mcr sys$disk:[]program.exe < input.txt > output.txt &> error.txt
92
93Makefile variables are looked up in the current environment. You can set
94symbols or logicals in DCL and evaluate them in the Makefile via
95$(<name-of-symbol-or-logical>). Variables defined in the Makefile
96override VMS symbols/logicals !
97
98Functions for file names are working now. See the GNU Make manual for
99$(dir ...) and $(wildcard ...). Unix-style and VMS-style names are
100supported as arguments.
101
102The default rules are set up for GNU C. Building an executable from a
103single source file is as easy as 'make file.exe'.
104
105The variable $(ARCH) is predefined as ALPHA or VAX resp. Makefiles for
106different VMS systems can now be written by checking $(ARCH) as in
107 ifeq ($(ARCH),ALPHA)
108 $(ECHO) "On the Alpha"
109 else
110 $(ECHO) "On the VAX"
111 endif
112
113Command lines of excessive length are correctly broken and written to a
114batch file in sys$scratch for later execution. There's no limit to the
115lengths of commands (and no need for .opt files :-) any more.
116
117Empty commands are handled correctly and don't end in a new DCL process.
118
119
120New for 3.76:
121
122John W. Eaton has updated the VMS port to support libraries and VPATH.
123
124
125To build Make, simply type @makefile. This should compile all the
126necessary files and link Make. There is also a file called
127makefile.vms. If you already have GNU Make built you can just use
128Make with this makefile to rebuild.
129
130Here are some notes about GNU Make for VMS:
131
132The cd command is supported if it's called as $(CD). This invokes
133the 'builtin_cd' command which changes the directory.
134Calling 'set def' doesn't do the trick, since a sub-shell is
135spawned for this command, the directory is changed *in this sub-shell*
136and the sub-shell ends.
137
138Libraries are not supported. They were in GNU Make 3.60 but somehow I
139didn't care porting the code. If there is enough interest, I'll do it at
140some later time.
141
142The variable $^ separates files with commas instead of spaces (It's the
143natural thing to do for VMS).
144
145See defaults.c for VMS default suffixes and my definitions for default
146rules and variables.
147
148The shell function is not implemented yet.
149
150Load average routines haven't been implemented for VMS yet.
151
152The default include directory for including other makefiles is
153SYS$SYSROOT:[SYSLIB] (I don't remember why I didn't just use
154SYS$LIBRARY: instead; maybe it wouldn't work that way).
155
156The default makefiles make looks for are: makefile.vms, gnumakefile,
157makefile., and gnumakefile. .
158
159The stat() function and handling of time stamps in VMS is broken, so I
160replaced it with a hack in vmsfunctions.c. I will provide a full rewrite
161somewhere in the future. Be warned, the time resolution inside make is
162less than what vms provides. This might be a problem on the faster Alphas.
163
164You can use a : in a filename only if you preceed it with a backslash ('\').
165E.g.- hobbes\:[bogas.files]
166
167Make ignores success, informational, or warning errors (-S-, -I-, or
168-W-). But it will stop on -E- and -F- errors. (unless you do something
169to override this in your makefile, or whatever).
170
171Remote stuff isn't implemented yet.
172
173Multiple line DCL commands, such as "if" statements, must be put inside
174command files. You can run a command file by using \@.
175
176
177VMS changes made for 3.74.3
178
179Lots of default settings are adapted for VMS. See default.c.
180
181Long command lines are now converted to command files.
182
183Comma (',') as a separator is now allowed. See makefile.vms for an example.
184
README.W32
1Port of GNU make to Windows NT and Windows 95
2Builds natively with MSVC 2.x or MSVC 4.x compilers.
3Should also build fine with MSVC 5.x and 6.x (though not confirmed).
4
5This Windows 32-bit port of GNU make is maintained primarily by Rob
6Tulloh, who is also the author of this README.
7
8To build with nmake on Windows NT, Windows 95, or Windows 98:
9
10 1. Make sure cl.exe is in your %Path%. Example:
11
12 set Path=%Path%;c:/msdev/bin
13
14 2. Make sure %include% is set to msvc include directory. Example:
15
16 set include=c:/msdev/include
17
18 3. Make sure %lib% is set to msvc lib directory. Example:
19
20 set lib=c:/msdev/lib
21
22 4. nmake /f NMakefile
23
24
25 A short cut to steps 1, 2, and 3 is to run VCVARS32.bat before
26 invoking namke. For example:
27
28 c:
29 cd \msdev\bin
30 VCVARS32.bat
31 cd \path\to\make-3.80
32 nmake /f NMakefile
33
34There is a bat file (build_w32.bat) for folks who have fear of nmake.
35
36Outputs:
37
38 WinDebug/make.exe
39 WinRel/make.exe
40
41
42-- Notes/Caveats --
43
44GNU make on Windows 32-bit platforms:
45
46 This version of make is ported natively to Windows32 platforms
47 (Windows NT 3.51, Windows NT 4.0, Windows 95, and Windows 98). It
48 does not rely on any 3rd party software or add-on packages for
49 building. The only thing needed is a version of Visual C++,
50 which is the predominant compiler used on Windows32 platforms.
51
52 Do not confuse this port of GNU make with other Windows32 projects
53 which provide a GNU make binary. These are separate projects
54 and are not connected to this port effort.
55
56GNU make and sh.exe:
57
58 This port prefers you have a working sh.exe somewhere on your
59 system. If you don't have sh.exe, the port falls back to
60 MSDOS mode for launching programs (via a batch file).
61 The MSDOS mode style execution has not been tested that
62 carefully though (The author uses GNU bash as sh.exe).
63
64 There are very few true ports of Bourne shell for NT right now.
65 There is a version of GNU bash available from Cygnus "Cygwin"
66 porting effort (http://sourceware.cygnus.com/cygwin).
67 Other possibilities are the MKS version of sh.exe, or building
68 your own with a package like NutCracker (DataFocus) or Portage
69 (Consensys).
70
71GNU make and brain-dead shells (BATCH_MODE_ONLY_SHELL):
72
73 Some versions of Bourne shell does not behave well when invoked
74 as 'sh -c' from CreateProcess(). The main problem is they seem
75 to have a hard time handling quoted strings correctly. This can
76 be circumvented by writing commands to be executed to a batch
77 file and then executing the command by calling 'sh file'.
78
79 To work around this difficulty, this version of make supports
80 a batch mode. When BATCH_MODE_ONLY_SHELL is defined at compile
81 time, make forces all command lines to be executed via script
82 files instead of by command line.
83
84 A native Windows32 system with no Bourne shell will also run
85 in batch mode. All command lines will be put into batch files
86 and executed via $(COMSPEC) (%COMSPEC%).
87
88GNU make and Cygnus GNU Windows32 tools:
89
90 Good news! Make now has native support for Cygwin sh. To enable,
91 define the HAVE_CYGWIN_SHELL in config.h and rebuild make
92 from scratch. This version of make tested with B20.1 of Cygwin.
93 Do not define BATCH_MODE_ONLY_SHELL if you use HAVE_CYGWIN_SHELL.
94
95GNU make and the MKS shell:
96
97 There is now semi-official support for the MKS shell. To turn this
98 support on, define HAVE_MKS_SHELL in the config.h.W32 before you
99 build make. Do not define BATCH_MODE_ONLY_SHELL if you turn
100 on HAVE_MKS_SHELL.
101
102GNU make handling of drive letters in pathnames (PATH, vpath, VPATH):
103
104 There is a caveat that should be noted with respect to handling
105 single character pathnames on Windows systems. When colon is
106 used in PATH variables, make tries to be smart about knowing when
107 you are using colon as a separator versus colon as a drive
108 letter. Unfortunately, something as simple as the string 'x:/'
109 could be interpreted 2 ways: (x and /) or (x:/).
110
111 Make chooses to interpret a letter plus colon (e.g. x:/) as a
112 drive letter pathname. If it is necessary to use single
113 character directories in paths (VPATH, vpath, Path, PATH), the
114 user must do one of two things:
115
116 a. Use semicolon as the separator to disambiguate colon. For
117 example use 'x;/' if you want to say 'x' and '/' are
118 separate components.
119
120 b. Qualify the directory name so that there is more than
121 one character in the path(s) used. For example, none
122 of these settings are ambiguous:
123
124 ./x:./y
125 /some/path/x:/some/path/y
126 x:/some/path/x:x:/some/path/y
127
128 Please note that you are free to mix colon and semi-colon in the
129 specification of paths. Make is able to figure out the intended
130 result and convert the paths internally to the format needed
131 when interacting with the operating system.
132
133 You are encouraged to use colon as the separator character.
134 This should ease the pain of deciding how to handle various path
135 problems which exist between platforms. If colon is used on
136 both Unix and Windows systems, then no ifdef'ing will be
137 necessary in the makefile source.
138
139GNU make test suite:
140
141 I verified all functionality with a slightly modified version
142 of make-test-3.80 (modifications to get test suite to run
143 on Windows NT). All tests pass in an environment that includes
144 sh.exe. Tests were performed on both Windows NT and Windows 95.
145
146Building GNU make on Windows NT and Windows 95/98 with Microsoft Visual C:
147
148 I did not provide a Visual C project file with this port as
149 the project file would not be considered freely distributable
150 (or so I think). It is easy enough to create one, though, if
151 you know how to use Visual C.
152
153 I build the program statically to avoid problems locating DLL's
154 on machines that may not have MSVC runtime installed. If you
155 prefer, you can change make to build with shared libraries by
156 changing /MT to /MD in the NMakefile (or in build_w32.bat).
157
158 The program has not been built for non-Intel architectures (yet).
159
160 I have not tried to build with any other compilers than MSVC. I
161 have heard that this is possible though so don't be afraid to
162 notify me of your successes!
163
164Pathnames and white space:
165
166 Unlike Unix, Windows 95/NT systems encourage pathnames which
167 contain white space (e.g. C:\Program Files\). These sorts of pathnames
168 are legal under Unix too, but are never encouraged. There is
169 at least one place in make (VPATH/vpath handling) where paths
170 containing white space will simply not work. There may be others
171 too. I chose to not try and port make in such a way so that
172 these sorts of paths could be handled. I offer these suggestions
173 as workarounds:
174
175 1. Use 8.3 notation
176 2. Rename the directory so it does not contain white space.
177
178 If you are unhappy with this choice, this is free software
179 and you are free to take a crack at making this work. The code
180 in w32/pathstuff.c and vpath.c would be the places to start.
181
182Pathnames and Case insensitivity:
183
184 Unlike Unix, Windows 95/NT systems are case insensitive but case
185 preserving. For example if you tell the file system to create a
186 file named "Target", it will preserve the case. Subsequent access to
187 the file with other case permutations will succeed (i.e. opening a
188 file named "target" or "TARGET" will open the file "Target").
189
190 By default, GNU make retains its case sensitivity when comparing
191 target names and existing files or directories. It can be
192 configured, however, into a case preserving and case insensitive
193 mode by adding a define for HAVE_CASE_INSENSITIVE_FS to
194 config.h.W32.
195
196 For example, the following makefile will create a file named
197 Target in the directory subdir which will subsequently be used
198 to satisfy the dependency of SUBDIR/DepTarget on SubDir/TARGET.
199 Without HAVE_CASE_INSENSITIVE_FS configured, the dependency link
200 will not be made:
201
202 subdir/Target:
203 touch $@
204
205 SUBDIR/DepTarget: SubDir/TARGET
206 cp $^ $@
207
208 Reliance on this behavior also eliminates the ability of GNU make
209 to use case in comparison of matching rules. For example, it is
210 not possible to set up a C++ rule using %.C that is different
211 than a C rule using %.c. GNU make will consider these to be the
212 same rule and will issue a warning.
213
214SAMBA/NTFS/VFAT:
215
216 I have not had any success building the debug version of this
217 package using SAMBA as my file server. The reason seems to be
218 related to the way VC++ 4.0 changes the case name of the pdb
219 filename it is passed on the command line. It seems to change
220 the name always to to lower case. I contend that
221 the VC++ compiler should not change the casename of files that
222 are passed as arguments on the command line. I don't think this
223 was a problem in MSVC 2.x, but I know it is a problem in MSVC 4.x.
224
225 The package builds fine on VFAT and NTFS filesystems.
226
227 Most all of the development I have done to date has been using
228 NTFS and long file names. I have not done any considerable work
229 under VFAT. VFAT users may wish to be aware that this port
230 of make does respect case sensitivity.
231
232FAT:
233
234 Version 3.76 added support for FAT filesystems. Make
235 works around some difficulties with stat'ing of
236 files and caching of filenames and directories internally.
237
238Bug reports:
239
240 Please submit bugs via the normal bug reporting mechanism which
241 is described in the GNU make manual and the base README.
242