make-3.70/README 444 12241 13 2635 5512120661 6327 This directory contains the 3.70 test release of GNU Make. All bugs reported for previous test releases have been fixed. Some bugs surely remain. For general building and installation instructions, see the file INSTALL. If you need to build GNU Make and have no other `make' program to use, you can use the shell script `build.sh' instead. To do this, first run `configure' as described in INSTALL. Then, instead of typing `make' to build the program, type `sh build.sh'. This should compile the program in the current directory. Then you will have a Make program that you can use for `make install', or whatever else. It has been reported that the XLC 1.2 compiler on AIX 3.2 is buggy such that if you compile make with `cc -O' on AIX 3.2, it will not work correctly. It is said that using `cc' without `-O' does work. One area that is often a problem in configuration and porting is the code to check the system's current load average. To make it easier to test and debug this code, you can do `make check-loadavg' to see if it works properly on your system. (You must run `configure' beforehand, but you need not build Make itself to run this test.) See the file NEWS for what has changed since previous releases. GNU Make is fully documented in make.texinfo. See the section entitled `Problems and Bugs' for information on submitting bug reports. GNU Make is free software. See the file COPYING for copying conditions. make-3.70/INSTALL 777 21570 13 12335 5445717646 6560 This is a generic INSTALL file for utilities distributions. If this package does not come with, e.g., installable documentation or data files, please ignore the references to them below. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation, and creates the Makefile(s) (one in each subdirectory of the source directory). In some packages it creates a C header file containing system-dependent definitions. It also creates a file `config.status' that you can run in the future to recreate the current configuration. To compile this package: 1. Configure the package for your system. Normally, you just `cd' to the directory containing the package's source code and type `./configure'. If you're using `csh' on an old version of System V, you might need to type `sh configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes a minute or two. While it is running, it prints some messages that tell what it is doing. If you don't want to see the messages, run `configure' with its standard output redirected to `/dev/null'; for example, `./configure >/dev/null'. To compile the package in a different directory from the one containing the source code, you must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If for some reason `configure' is not in the source code directory that you are configuring, then it will report that it can't find the source code. In that case, run `configure' with the option `--srcdir=DIR', where DIR is the directory that contains the source code. By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PATH'. Alternately, you can do so by consistently giving a value for the `prefix' variable when you run `make', e.g., make prefix=/usr/gnu make prefix=/usr/gnu install You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PATH' or set the `make' variable `exec_prefix' to PATH, the package will use PATH as the prefix for installing programs and libraries. Data files and documentation will still use the regular prefix. Normally, all files are installed using the same prefix. Some packages pay attention to `--with-PACKAGE' options to `configure', where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The README should mention any `--with-' options that the package recognizes. `configure' ignores any other arguments that you give it. On systems that require unusual options for compilation or linking that the package's `configure' script does not know about, you can give `configure' initial values for variables by setting them in the environment. In Bourne-compatible shells, you can do that on the command line like this: CC='gcc -traditional' LIBS=-lposix ./configure Here are the `make' variables that you might want to override with environment variables when running `configure'. For these variables, any value given in the environment overrides the value that `configure' would choose: - Variable: CC C compiler program. The default is `cc'. - Variable: INSTALL Program to use to install files. The default is `install' if you have it, `cp' otherwise. For these variables, any value given in the environment is added to the value that `configure' chooses: - Variable: DEFS Configuration options, in the form `-Dfoo -Dbar...'. Do not use this variable in packages that create a configuration header file. - Variable: LIBS Libraries to link with, in the form `-lfoo -lbar...'. If you need to do unusual things to compile the package, we encourage you to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the README so we can include them in the next release. 2. Type `make' to compile the package. If you want, you can override the `make' variables CFLAGS and LDFLAGS like this: make CFLAGS=-O2 LDFLAGS=-s 3. If the package comes with self-tests and you want to run them, type `make check'. If you're not sure whether there are any, try it; if `make' responds with something like make: *** No way to make target `check'. Stop. then the package does not come with self-tests. 4. Type `make install' to install programs, data files, and documentation. 5. You can remove the program binaries and object files from the source directory by typing `make clean'. To also remove the Makefile(s), the header file containing system-dependent definitions (if the package uses one), and `config.status' (all the files that `configure' created), type `make distclean'. The file `configure.in' is used to create `configure' by a program called `autoconf'. You only need it if you want to regenerate `configure' using a newer version of `autoconf'. make-3.70/COPYING 666 12241 13 43076 5022524147 6537 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program 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 2 of the License, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. make-3.70/ChangeLog 666 12241 13 1036675 5512120472 7323 Mon Jan 3 17:50:25 1994 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.70 released. Thu Dec 23 14:46:54 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.69.3. * read.c (parse_file_seq): Inside multi-word archive ref translation loop, check NEW1==0 at end and break out of the loop. * GNUmakefile (make-$(version).tar): Distribute install.sh. * install.sh: New file. * configure.in (SCCS_GET_MINUS_G check): Put redirection for admin cmds outside subshell parens, to avoid "command not found" msgs from the shell. Wed Dec 22 17:00:43 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in (SCCS_GET_MINUS_G check): Put -G flag last in get cmd. Redirect output & error from get to /dev/null. Fix reversed sense of test. Fri Dec 17 15:31:36 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in (SCCS_GET_MINUS_G check): Use parens instead of braces inside if condition command; some shells lose. Thu Dec 16 15:10:23 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.69.2. * arscan.c [M_UNIX]: Move #undef M_XENIX for PORTAR stuff. (PORTAR) [M_XENIX]: Define to 0 instead of 1. * main.c (define_makeflags): Only export MAKEFLAGS if !ALL. Wed Dec 15 17:47:48 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (main): Cast result of pointer arith to unsigned int before passing to define_variable for envars. Matters when sizeof(unsigned)!=sizeof(ptrdiff_t). Tue Dec 14 14:21:16 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in: Add new check for SCCS_GET_MINUS_G. * config.h.in: Add #undef SCCS_GET_MINUS_G. * default.c (default_terminal_rules): Use `$(SCCS_OUTPUT_OPTION)' in place of `-G $@' in SCCS commands. (default_variables) [SCCS_GET_MINUS_G]: Define SCCS_OUTPUT_OPTION to "-G$@". * configure.in (AC_OUTPUT): Put touch stamp-config in second arg (so it goes in config.status), rather than afterward. * ar.c (ar_member_date): Don't call enter_file on the archive file if it doesn't exist (by file_exists_p). * compatMakefile ($(infodir)/make.info): Replace `$$d/foo.info' with `$$dir/make.info' in install-info invocation (oops). * vpath.c (construct_vpath_list): Only set LASTPATH set PATH when we do not unlink and free PATH. * file.c (print_file_data_base): Fix inverted calculation for average files per hash bucket. * read.c (readline): When we see a NUL, give only a warning and synthesize a newline to terminate the building line (used to fatal). Move fgets call into the loop condition, and after the loop test ferror (used to test !feof in the loop). Fri Dec 3 16:40:31 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in: Check for strerror in AC_HAVE_FUNCS. Thu Dec 2 15:37:50 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) Differentiate different flavors of missing makefile error msgs, removing gratuitous `fopen: ' and giving caller for included makefiles. * misc.c [! HAVE_STRERROR]: Define our own strerror here. (perror_with_name, pfatal_with_name): Use strerror instead of replicating its functionality. * read.c (read_makefile): Return int instead of void. (read_all_makefiles, read_makefile): Change callers to notice zero return and give error msg. Thu Nov 11 11:47:36 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.69.1. * default.c: Put `-G $@' before $< in SCCS cmds. Wed Nov 10 06:06:14 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): After trying a variable defn, notice if the line begins with a tab, and diagnose an error. Sun Nov 7 08:07:37 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.69. Wed Nov 3 06:54:33 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.10. * implicit.c (try_implicit_rule): Look for a normal rule before an archive rule. Fri Oct 29 16:45:28 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * function.c (expand_function: `sort'): Double NWORDS when it overflows, instead of adding five. * compatMakefile (clean): Remove loadavg. Wed Oct 27 17:58:33 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.9. * file.h (NEW_MTIME): Define new macro. * main.c (main): Set time of NEW_FILES to NEW_MTIME, not to current time returned from system. Removed variable NOW. * remake.c (notice_finished_file): Use NEW_MTIME in place of current time here too. Tue Oct 26 19:45:35 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.8. * remake.c (update_file_1): Don't clear MUST_MAKE when FILE has no cmds and !DEPS_CHANGED unless also !NOEXIST. Mon Oct 25 15:25:21 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (parse_file_seq): When converting multi-word archive refs, ignore a word beginning with a '('. Fri Oct 22 02:53:38 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in: Check for sys/timeb.h. * make.h [HAVE_SYS_TIMEB_H]: Test this before including it. Thu Oct 21 16:48:17 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.7. * rule.c (convert_suffix_rule): New local TARGPERCENT. Set it to TARGNAME+1 for "(%.o)", to TARGNAME for "%.?". Use it in place of TARGNAME to initialize PERCENTS[0]. Mon Oct 18 06:49:35 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in: Use AC_HAVE_HEADERS(unistd.h) instead of AC_UNISTD_H. Remove AC_USG; it is no longer used. * file.c (print_file): New function, broken out of print_file_data_base. (print_file_data_base): Call it. * rule.c (print_rule): New function, broken out of print_rule_data_base. (print_rule_data_base): Call it. Thu Oct 14 14:54:03 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * default.c (install_default_suffix_rules): New function, broken out of install_default_implicit_rules. (install_default_implicit_rules): Move suffix rule code there. * make.h: Declare install_default_suffix_rules. * main.c (main): Call install_default_suffix_rules before reading makefiles. Move convert_to_pattern call before install_default_implicit_rules. * job.h (struct child): Make `pid' member type `pid_t' instead of `int'. * compatMakefile (RANLIB): New variable, set by configure. (glob/libglob.a): Pass RANLIB value down to submake. Fixes for SCO 3.2 "devsys 4.2" from pss@tfn.com (Peter Salvitti). * make.h: Include before for SCO lossage. * job.c [! getdtablesize] [! HAVE_GETDTABLESIZE]: If NOFILE is not defined but NOFILES_MAX is, define it to be that. Mon Oct 11 19:47:33 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * GNUmakefile (make-$(version).tar): Depend on acconfig.h, so it is distributed. Sun Oct 3 15:15:33 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * default.c (default_terminal_rules): Add `-G $@' to SCCS get cmds. Tue Sep 28 14:18:20 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): Add ^ to SH_CHARS; it is another symbol for | in some shells. * main.c (main): Add it to CMD_DEFS quoting list as well. Mon Sep 20 18:05:24 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): Remove '=' from SH_CHARS. Only punt on '=' if it is unquoted in a word before the first word without an unquoted '='. * main.c (define_makeflags): Set v_export for MAKEFLAGS. Fri Sep 17 00:37:18 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (update_file_1): Use .DEFAULT cmds for phony targets. * make.h [_AIX && _POSIX_SOURCE]: Define POSIX. * commands.c (delete_child_targets): Don't delete phony files. * job.c (start_job_command): Set COMMANDS_RECURSE in FLAGS if we see a `+' at the beginning of the command line. Thu Sep 9 17:57:14 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.6. Wed Sep 8 20:14:21 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (define_makeflags): Define MAKEFLAGS with o_file, not o_env. Mon Aug 30 12:31:58 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * expand.c (variable_expand): Fatal on an unterminated reference. Thu Aug 19 16:27:53 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.5. * variable.c (define_automatic_variables): Define new o_default variable `MAKE_VERSION' from version_string and remote_description. * make.h (version_string, remote_description): Declare these here. * main.c: Don't declare version_string. (print_version): Don't declare remote_description. Wed Aug 18 15:01:24 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): Free space pointed to by CONDITIONALS before restoring the old pointer. Mon Aug 16 17:33:36 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile ($(objs)): Depend on config.h. * GNUmakefile (build.sh.in): Depend on compatMakefile. * configure.in: Touch stamp-config after AC_OUTPUT. Fri Aug 13 16:04:22 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.4. Thu Aug 12 17:18:57 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h: Include instead of "config.h". Wed Aug 11 02:35:25 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (main): Make all variables interned from ENVP be v_export. * variable.c (try_variable_definition): In v_default case, don't check for an o_file variable that `getenv' finds. * job.c (reap_children): New local variable ANY_LOCAL; set it while setting ANY_REMOTE. If !ANY_LOCAL, don't wait for local kids. * main.c (main): Don't call decode_env_switches on MFLAGS. DOC THIS. * function.c (expand_function): #if 0 out freeing of ENVP since it is environ. Mon Aug 9 17:37:20 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.3. * remote-stub.c (remote_status): Set errno to ECHILD before return. * job.c (reap_children): Scan the chain for remote children and never call remote_status if there are none. * function.c (expand_function: `shell'): #if 0 out calling target_environment; just set ENVP to environ instead. * job.c (reap_children): Check for negative return from remote_status and fatal for it. When blocking local child wait returns 0, then try a blocking call to remote_status. Tue Aug 3 00:19:00 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (clean): Delete make.info* and make.dvi here. (distclean): Not here. * dep.h (RM_*): Use #defines instead of enum to avoid lossage from compilers that don't like enum values used as ints. Mon Aug 2 16:46:34 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (loadavg): Add $(LOADLIBES). Sun Aug 1 16:01:15 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.2. * compatMakefile (loadavg, check-loadavg): New targets. (check): Depend on check-loadavg. * compatMakefile (glob/libglob.a): Depend on config.h. * misc.c (log_access): Write to stderr instead of stdout. Fri Jul 30 00:07:02 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68.1. Thu Jul 29 23:26:40 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in (SYS_SIGLIST_DECLARED): In test program include #ifdef HAVE_UNISTD_H. * compatMakefile (.PHONY): Put after `all' et al. * configure.in: Add AC_IRIX_SUN. Wed Jul 28 17:41:12 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.68. Mon Jul 26 14:36:49 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.8. Sun Jul 25 22:09:08 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.7. * compatMakefile ($(infodir)/make.info): Don't use $(instname). Run install-info script if present. Fri Jul 23 16:03:50 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h [STAT_MACROS_BROKEN]: Test this instead of [uts]. * configure.in: Add AC_STAT_MACROS_BROKEN. Wed Jul 14 18:48:11 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.6. * read.c (read_makefile): Recognize directive `-include', like `include' but sets RM_DONTCARE flag. * variable.c (target_environment): If FILE is nil, use current_variable_set_list in place of FILE->variables. * function.c (expand_function: `shell'): Get an environment for the child from target_environment instead of using environ. * dep.h: Declare read_all_makefiles here. (RM_*): Define new enum constants. * read.c (read_makefile): Second arg is FLAGS instead of TYPE. Treat it as a bit mask containing RM_*. (read_all_makefiles): For default makefiles, set D->changed to RM_DONTCARE instead of 1. * main.c: Don't declare read_all_makefiles here. (main): Check `changed' member of read_makefiles elts for RM_* flags instead of specific integer values. Mon Jul 12 22:42:17 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h [sequent && i386]: #undef POSIX. From trost@cse.ogi.edu. Thu Jul 8 19:51:23 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * vpath.c (construct_vpath_list): If ELEM is zero 0, free PATTERN as well as VPATH. (build_vpath_lists): Empty `vpaths' around construct_vpath_list call for $(VPATH). Expand $(strip $(VPATH)), not just $(VPATH). * rule.c (convert_suffix_rule): Use alloca instead of xmalloc for PERCENTS, whose storage is not consumed by create_pattern_rule. * make.h [__mips && _SYSTYPE_SVR3]: #undef POSIX. Wed Jun 30 18:11:40 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.5. * rule.c (max_pattern_targets): New variable. (count_implicit_rule_limits): Compute its value. * rule.h: Declare it. * implicit.c (pattern_search): Make TRYRULES max_target_patterns times bigger. Move adding new TRYRULES elt inside the inner targets loop, so each matching target gets its own elt in MATCHES and CHECKED_LASTSLASH. * file.c (remove_intermediates): If SIG!=0 say `intermediate file' instead of just `file' in error msg. Fri Jun 25 14:55:15 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (construct_command_argv): Turn off --warn-undefined-variables around expansion of SHELL and IFS. * read.c (tilde_expand): Likewise for HOME. (read_all_makefiles): Likewise for MAKEFILES. * vpath.c (build_vpath_lists): Likewise for VPATH. * main.c (warn_undefined_variables_flag): New flag variable. (switches): Add --warn-undefined-variables. * make.h (warn_undefined_variables_flag): Declare it. * expand.c (warn_undefined): New function. (reference_variable): Call it if the variable is undefined. (variable_expand): In substitution ref, call warn_undefined if the variable is undefined. * default.c (default_pattern_rules): Add `%.c: %.w %.ch' and `%.tex: %.w %.ch' rules. (default_suffix_rules: .w.c, .w.tex): Pass three args: $< - $@. (default_suffixes): Add `.ch'. Mon Jun 21 17:55:39 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * default.c (default_suffixes): Replace `.cweb' with `.w'. (default_suffix_rules): Rename `.cweb.c' and `.cweb.tex' to `.w.c' and `.w.tex'. Fri Jun 11 14:42:09 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile ($(bindir)/$(instname)): Add missing backslash. Thu Jun 10 18:14:08 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.4. * read.c (multi_glob): Don't free OLD and OLD->name in the FOUND!=0 fork. Use new block-local variable F instead of clobbering OLD. * ar.c (glob_pattern_p): New function, snarfed from glob/glob.c. (ar_glob): Call it; return nil immediately if MEMBER_PATTERN contains no metacharacters. Wed Jun 9 16:25:35 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * ar.c (ar_glob{_match,_alphacompare}): New function. * dep.h [! NO_ARCHIVES]: Declare it. * read.c (multi_glob) [! NO_ARCHIVES]: Use it on archive member elts. * read.c (read_makefile): Pass flag (1) to parse_file_seq, not to multi_glob (which doesn't take a 3rd arg). * rule.c (install_pattern_rule): Likewise. * default.c (set_default_suffixes): Here too. * function.c (string_glob): Don't pass gratuitous arg to multi_glob. * read.c (parse_file_seq) [! NO_ARCHIVES]: Add post-processing loop to translate archive refs "lib(a b)" into "lib(a) lib(b)". Mon Jun 7 19:26:51 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (installdirs): Actually pass directory names. ($(bindir)/$(instname)): Test chgrp&&chmod exit status with `if'; if it fails, echo a warning msg, but don't make the rule fail. * read.c (tilde_expand): New function, broken out of tilde_expand. (multi_glob): Call it. (construct_include_path): Expand ~ in directory names. * dep.h: Declare tilde_expand. * main.c (enter_command_line_file): Expand ~ at the start of NAME. (main): Expand ~ in -C args. * read.c (read_makefile): Expand ~ in FILENAME unless TYPE==2. Fri Jun 4 13:34:47 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (decode_env_switches): Use xmalloc instead of alloca for ARGS. * main.c (main): Put result of alloca in temporary variable with simple assignment, to make SGI compiler happy. Thu Jun 3 20:15:46 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.3. * main.c (main): Before re-execing, remove intermediate files, and print the data base under -p. Sexier debugging message. * implicit.c (pattern_search): Allocate an extra copy of the name of a winning intermediate file when putting it in FOUND_FILES. Wed Jun 2 16:38:08 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): Pass flag (1) to parse_file_seq, not to multi_glob (which doesn't take a 3rd arg). * dir.c (dir_contents_file_exists_p): When reading dirents, ignore chars within D_NAMLEN that are NULs. * main.c (decode_switches): Don't savestring ARGV[0] to put it into `other_args'. For string switch, don't savestring `optarg'. (main): Don't free elts of makefiles->list that are "-". Use alloca'd rather than savestring'd storage for elts of makefiles->list that are temporary file names. * read.c (read_all_makefiles): Don't free *MAKEFILES. * file.c (enter_file): Don't strip `./'s. * main.c (enter_command_line_file): New function. (main): Use it in place of enter_file for command-line goals from other_files, and for old_files and new_files. Mon May 31 18:41:40 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.2. * compatMakefile (.SUFFIXES): Add .info. ($(infodir)/$(instname).info): Find make.info* in cwd if there, else in $srcdir. Use basename to remove dir name from installed name. Thu May 27 17:35:02 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * implicit.c (pattern_search): When interning FOUND_FILES, try lookup_file first; if found, free the storage for our copy of the name. Wed May 26 14:31:20 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67.1. * main.c (decode_switches): In usage msg, write `--switch=ARG' or `--switch[=OPTARG]' rather than `--switch ARG' or `--switch [ARG]'. Mon May 24 16:17:31 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * rule.c (convert_suffix_rule): New function. (convert_to_pattern): Use it instead of doing all the work here several times. For target suffix `.a', generate both the archive magic rule and the normal rule. * compatMakefile (distclean): Remove stamp-config. Sat May 22 16:15:18 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.67. * file.c (remove_intermediates): Don't write extra space after `rm'. * main.c (struct command_switch.type): Remove `usage_and_exit'. (print_usage_flag): New variable. (switches: --help): Make type `flag', to set print_usage_flag. (init_switches): Remove `usage_and_exit' case. (decode_switches): Likewise. (decode_switches): Print usage if print_usage_flag is set. When printing usage, die with status of BAD. (main): Die with 0 if print_version_flag. Fri May 21 16:09:28 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.66. Wed May 19 21:30:44 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (installdirs): New target. (install): Depend on it. Sun May 16 20:15:07 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.65.2. Fri May 14 16:40:09 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * vpath.c (construct_vpath_list): In removal loop for DIRPATH==0, set LASTPATH to PATH, not NEXT. * dir.c (read_dirstream): Break out of loop after incrementing DS->buckets such that it reaches DIRFILE_BUCKETS; avoid trying to dereference DS->contents->files[DIRFILE_BUCKETS]. * read.c (read_makefile): Clear no_targets after reading a targetful rule line. * main.c (main): If print_version_flag is set, exit after printing the version. (switches): Change --version docstring to say it exits. * make.h [butterfly]: #undef POSIX. Wed May 12 15:20:21 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.65.1. * arscan.c (ar_scan) [! AIAMAG]: Don't declare LONG_NAME. [AIAMAG]: Pass TRUNCATE flag arg to (*FUNCTION), always zero. * function.c (handle_function): Use fatal instead of makefile_fatal when reading_filename is nil. * configure.in: Add AC_GETGROUPS_T. * job.c (search_path): Use GETGROUPS_T in place of gid_t. Sun May 9 15:41:25 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.65. Fri May 7 18:34:56 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * function.c (handle_function): Fatal for unmatched paren. Thu May 6 16:13:41 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.64.3. * commands.c (handling_fatal_signal): New variable. (fatal_error_signal): Set it. * job.c (reap_children): Avoid nonreentrant operations if that is set. * make.h: Declare handling_fatal_signal. * expand.c (reference_variable): New function, snippet of code broken out of simple-reference case of variable_expand. (variable_expand): Use it for simple refs. (variable_expand): When checking for a computed variable name, notice a colon that comes before the final CLOSEPAREN. Expand only up to the colon, and then replace the pending text with a copy containing the expanded name and fall through to subst ref handling. (variable_expand): Don't bother expanding the name if a colon appears before the first $. (expand_argument): Use alloca instead of savestring. (variable_expand): For subst ref, expand both sides of = before passing to [pat]subst_expand. Use find_percent instead of lindex to check the lhs for a %. Wed May 5 14:45:52 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.64.2. Mon May 3 17:00:32 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * arscan.c (ar_name_equal) [AIAMAG]: Abort if TRUNCATED is nonzero. * read.c (read_makefile): Pass extra arg of 1 to parse_file_seq, not to multi_glob. Thu Apr 29 19:47:33 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.64.1. * arscan.c (ar_scan): New local flag var LONG_NAME. Set it when we read the member name in any of the fashions that allow it to be arbitrarily long. Pass its negation to FUNCTION. (describe_member): Take TRUNCATED from ar_scan and print it. (ar_name_equal): Take new arg TRUNCATED; if nonzero, compare only the first sizeof (struct ar_hdr.ar_name) chars. (ar_member_pos): Take TRUNCATED from ar_scan, pass to ar_name_equal. * ar.c (ar_member_date_1): Likewise. Wed Apr 28 21:18:22 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (reap_children): Before calling start_job_command to start the next command line, reset C->remote by calling start_remote_job_p. Mon Apr 26 15:56:15 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * arscan.c (ar_scan): New local var NAMEMAP. In loop, rename NAME to NAMEBUF; new var NAME is a pointer; new flag IS_NAMEMAP. When extracting the member name, always put a null at its end first. If the name is "//" or "/ARFILENAMES", set IS_NAMEMAP. If we have already read in NAMEMAP, and NAME looks like " /N", get full name from NAMEMAP+N. Else if NAME looks like "#1/N", read N chars from the elt data to be the full name. At end of loop, if IS_NAMEMAP, read the elt's data into alloca'd NAMEMAP. (ar_name_equal): #if 0 truncating code. * make.h: Don't declare vfork at all. It returns int anyway, unless declared it; and we conflicted with some systems. * main.c (define_makeflags): If FLAGSTRING[1] is '-', define MAKEFLAGS to all of FLAGSTRING, not &FLAGSTRING[1]. Don't want to define it to something like "-no-print-directory". Use %g format instead of %f for floating-valued things. Thu Apr 22 18:40:58 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * GNUmakefile (Makefile.in): Use a substitution ref on nolib-deps to change remote-%.dep to remote-stub.dep. Wed Apr 21 15:17:54 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.64. Fri Apr 16 14:22:22 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (install): Remove - prefix from chgrp+chmod. * Version 3.63.8. Thu Apr 15 18:24:07 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * acconfig.h: New file; contains "#undef SCCS_GET" for autoheader. * configure.in: If /usr/sccs/get exists, define SCCS_GET to that, else to "get". * default.c (default_variables): Set GET to macro SCCS_GET. * read.c (parse_file_seq): Take extra arg STRIP; strip `./' only if nonzero. I hope this is the last time this argument is added or removed. (read_makefile): Pass it 1 when parsing include file names. Pass it 1 when parsing target file names. Pass it 1 when parsing static pattern target pattern names. * rule.c (install_pattern_rule): Pass it 1 when parsing rule deps. * default.c (set_default_suffixes): Pass it 1 when parsing default_suffixes. * function.c (string_glob): Pass it 0 here. Wed Apr 14 11:32:05 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * misc.c (log_access): New function. ({init,user,make,child}_access): Call it. (child_access): Abort if !access_inited. * main.c (switches: --no-print-directory): Use 1 instead of -1 for single-letter option. (init_switches, decode_switches, define_makeflags): An option with no single-letter version is no longer indicated by a value of -1; instead a value that is !isalnum. (init_switches): Don't put such switches into the string, only into the long_option table. * make.h [!NSIG] [!_NSIG]: #define NSIG 32. * job.c [HAVE_WAITPID]: Remove #undef HAVE_UNION_WAIT. AIX's bsdcc defined WIF* to use union wait. * main.c (struct command_switch): Change member `c' to type int. (switches): Make const. (decode_switches): Use `const struct command_switch *'. (define_makeflags): Likewise. * default.c (default_suffix_rules): Add `-o $@' to makeinfo rules. Mon Apr 12 12:30:04 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.63.7. * configure.in (AC_HAVE_HEADERS): Check for string.h and memory.h. Removed AC_MEMORY_H. * make.h [USG, NeXT]: Don't test these. [HAVE_STRING_H]: Test this to include string.h and define ANSI_STRING. [HAVE_MEMORY_H]: Test this instead of NEED_MEMORY_H. [! ANSI_STRING]: Put decls of bcopy et al here. [sparc]: Don't test this for alloca.h; HAVE_ALLOCA_H is sufficient. [HAVE_SIGSETMASK]: Test this rather than USG. [__GNU_LIBRARY__ || POSIX]: Don't #include again. * main.c (main): Handle SIGCHLD if defined, and SIGCLD if defined. It doesn't hurt to do both if they are both defined, and testing USG is useless. * dir.c: Rationalize directory header conditionals. * arscan.c [HAVE_FCNTL_H]: Test this rather than USG || POSIX. * default.c (default_suffixes): Add `.txinfo'. (default_suffix_rules): Add `.txinfo.info' and `.txinfo.dvi' rules. * variable.c (try_variable_definition): Replace RECURSIVE flag with enum FLAVOR, which can be simple, recursive, or append. Recognize += as append flavor. Set new variable VALUE in a switch on FLAVOR. For append flavor, prepend the variable's old value. If the variable was previously defined recursive, set FLAVOR to recursive; if it was defined simple, expand the new value before appending it to the old value. Pass RECURSIVE flag to define_variable iff FLAVOR == recursive. * variable.c (try_variable_definition): Use alloca and bcopy for NAME, instead of savestring. Might as well use stack storage since we free it immediately anyway. Thu Apr 8 18:04:43 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (start_waiting_jobs): Move decl of JOB outside of loop. * main.c (define_makeflags): Rename `struct flag' member `switch' to `cs', which is not a reserved word. Wed Apr 7 15:30:51 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (new_job): Call start_waiting_jobs first thing. (start_waiting_job): Changed return type from void to int. Return 0 when putting the child on the waiting_jobs chain. (start_waiting_jobs): Don't check load and job_slots here. Always take a job off the chain and call start_waiting_job on it; give up and return when start_waiting_job returns zero. * main.c (define_makeflags: struct flag): Change member `char c' to `struct command_switch *switch'. (ADD_FLAG): Set that to CS instead of CS->c. If CS->c is -1, increment FLAGSLEN for the long name. When writing out FLAGS, handle FLAGS->switch->c == -1 and write the long name instead. * compatMakefile (stamp-config): New target of old config.h rule. Touch stamp-config after running config.status. (config.h): Just depend on stamp-config, and have empty commands. Mon Apr 5 20:14:02 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c [HAVE_WAITPID]: #undef HAVE_UNION_WAIT. * configure.in (AC_HAVE_FUNCS): Check for psignal. Fri Apr 2 17:15:46 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (long_option_aliases): Remove "new"; it is already an unambiguous prefix of "new-file". Sun Mar 28 16:57:17 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.63.6. Wed Mar 24 14:26:19 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * vpath.c (selective_vpath_search): When adding the name-within-directory at the end of NAME, and we don't add a slash, don't copy FILENAME in one char too far into NAME. * variable.c (define_automatic_variables): Find default_shell's length with strlen, not numerology. Wed Mar 17 20:02:27 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (define_makeflags): Add the elts of a string option in reverse order, so they come out right when reversed again. Fri Mar 12 15:38:45 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (make.info): Use `-o make.info'. Thu Mar 11 14:13:00 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (REMOTE): Set to @REMOTE@; change comments to reflect new use. (objs): Replace remote.o with remote-$(REMOTE).o. (srcs): Replace remote.c with remote-$(REMOTE).c. (remote.o): Rule removed. * configure.in (REMOTE): Subst this in Makefile et al; default "stub". Use AC_WITH to grok --with-customs arg to set REMOTE=cstms. * GNUmakefile (build.sh.in): Filter out remote-% from objs list. * build.template (REMOTE): New var; set to @REMOTE@. (objs): Add remote-${REMOTE}.o. Wed Mar 10 15:12:24 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.63.5. * implicit.c (pattern_search): Fix "dependent"->"dependency" in "Rejecting impossible" -d msg. * file.c (file_hash_enter): New local vars {OLD,NEW}BUCKET. Store mod'd values there; never mod {OLD,NEW}HASH. Mon Mar 8 13:32:48 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * remake.c [eta10]: Include instead of . * compatMakefile (VPATH): Set this to @srcdir@. (srcdir): Set this to $(VPATH). * main.c (main): New local var DIRECTORY_BEFORE_CHDIR. Save in it a copy of CURRENT_DIRECTORY after the first getcwd. Use it instead of CURRENT_DIRECTORY when chdir'ing back before re-execing. * remake.c (notice_finished_file): Pass missing SEARCH arg to f_mtime. * read.c (read_makefile): Remove extraneous arg to parse_file_seq. Mon Feb 22 14:19:38 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile ($(infodir)/$(instname).info): Use , instead of / as the sed delimiter char. Sun Feb 21 14:11:04 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.63.4. * rule.h (struct rule): Removed `subdir' member. * rule.c (new_pattern_rule): No need to clear it. (count_implicit_rule_limits): Set the `changed' flag in each dep that refers to a nonexistent directory. No longer set rule-global `subdir' flag with that information. (print_rule_data_base): Don't record info on `subdir' flags. * implicit.c (pattern_search): Check the DEP->changed flag rather than the (now gone) RULE->subdir flag. Also test CHECK_LASTSLASH; if it is set, the file might exist even though the DEP->changed flag is set. * rule.c (count_implicit_rule_limits): Pass "", not ".", as file name arg to dir_file_exists_p to check for existence of directory. * implicit.c (pattern_search): Inside dep-finding loop, set CHECK_LASTSLASH from the value recorded in CHECKED_LASTSLASH[I], rather than computing it anew. * commands.c (set_file_variables): Must alloca space for PERCENT and copy it, to avoid leaving the trailing `)' in the value. * misc.c (remove_comments): Fixed backslash-checking loop condition to allow it to look at the first char on the line. P2 >= LINE, not P2 > LINE. * compatMakefile ($(bindir)/$(instname)): Before moving $@.new to $@, rm $@.old and mv $@ to $@.old. * variable.c (try_variable_definition): Take new args FILENAME and LINENO. Fatal if the variable name is empty. * read.c (read_makefile): Change callers. * main.c (main): Likewise. * compatMakefile (group): Define to @KMEM_GROUP@, autoconf magic that configure will replace with the group owning /dev/kmem. Mon Feb 8 14:26:43 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * vpath.c (vpath_search): Take second arg MTIME_PTR, pass thru to selective_vpath_search. (selective_vpath_search): Take second arg MTIME_PTR. If the dir cache thinks a file exists, stat it to make sure, and put the modtime in *MTIME_PTR. * remake.c (library_search): Take second arg MTIME_PTR. When we find a match, record its mtime there. Pass MTIME_PTR through to vpath_search to do same. (f_mtime): Pass &MTIME as new 2nd arg to {vpath,library}_search; store it in FILE->last_mtime if set nonzero. * implicit.c (pattern_search): Pass nil 2nd arg to vpath_search. * compatMakefile (remote.o): Prepend `$(srcdir)/' to `remote-*.c', so globbing looks somewhere it will find things. * compatMakefile ($(infodir)/$(instname).info): Install `make.info*' not `$(srcdir)/make.info*'; no need to use basename. Fri Feb 5 12:52:43 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.63.3. * compatMakefile (install): Add missing ;\s. Make -, @, and + prefixes on a pre-expanded command line affect all lines in the expansion, not just the first. * commands.h (struct commands): Replace `lines_recurse' member with `lines_flags'. (COMMANDS_{RECURSE,SILENT,NOERROR}): New macros, bits to set in that flag byte. * commands.c (chop_commands): Set `lines_flags' instead of `lines_recurse'. Record not only + but also @ and - prefixes. * remake.c (notice_finished_file): Check the COMMANDS_RECURSE bit in FILE->cmds->lines_flags, rather than FILE->cmds->lines_recurse. * job.c (start_job_command): Replaced RECURSIVE and NOPRINT local var with FLAGS; initialize it to the appropriate `lines_flags' byte. Set CHILD->noerror if the COMMANDS_NOERROR bit is set in FLAGS. Set the COMMANDS_SILENT bit in FLAGS for a @ prefix. * remake.c (update_goal_chain): Set G->file to its prev after checking for G being finished, since that check needs to examine G->file. * configure.in (union wait check) [HAVE_WAITPID]: Try using waitpid with a `union wait' STATUS arg. If waitpid and union wait don't work together, we should not use union wait. * Version 3.63.2. * remake.c (update_goal_chain): When G->file->updated, move G->file to its prev. We aren't finished until G->file is nil. Thu Feb 4 12:53:04 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (starting_directory): New global variable. (main): Set it to cwd after doing -Cs. (log_working_directory): Use it, rather than computing each time. * make.h: Declare it. * compatMakefile (SHELL): Define to /bin/sh for losing Unix makes. * main.c (decode_env_switches): Allocate (1 + LEN + 1) words for ARGV, rather than LEN words plus one byte. Wed Feb 3 18:13:52 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile ($(bindir)/$(instname)): Put - before install_setgid command line, so its failure won't be an error. (infodir): New variable. (install): Depend on $(infodir)/$(instname).info. ($(infodir)/$(instname).info): New target. * read.c (read_makefile): If FILENAMES is nil when we see a line starting with a tab, don't treat it as a command. Just fall through, rather than giving an error. * read.c (read_makefile): If the NO_TARGETS flag is set when we see a command line, don't clear it before continuing. We want subsequent command lines to be ignored as well. * job.c (new_job): Before expanding each command line, collapse backslash-newline combinations that are inside var or fn references. Mon Feb 1 16:00:13 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (exec_prefix): Default to $(prefix), not /usr/local. * compatMakefile (make.info): Pass -I$(srcdir) to makeinfo. * job.c [POSIX] (unblock_sigs): Made global. [!POSIX] (unblock_sigs): Move defns to job.h. * job.h [POSIX] (unblock_sigs): Declare. Sun Jan 31 19:11:05 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * read.c (read_makefile): In vpath parsing, after finding the pattern token, take entire rest of line as the search path, not just the next token. * compatMakefile (remote.o): Depend on remote-*.c. Thu Jan 28 16:40:29 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * commands.c (set_file_variables): Don't define any F or D versions. * variable.c (define_automatic_variables): Define them here as recursively-expanded variables that use the dir and notdir funcs. * variable.c (target_environment): In v_default case, don't export o_default or o_automatic variables. * configure.in (union wait check): Remove ` and ' inside C code; they confuse the shell script. Mon Jan 25 13:10:42 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.63.1. * vpath.c (construct_vpath_list): When skipping further processing of an elt that is ".", don't also skip the code that pushes P past the next separator. * compatMakefile (distclean): Don't remove make-*. * configure.in (HAVE_UNION_WAIT): Try to use WEXITSTATUS if it's defined. If one cannot use WEXITSTATUS with a `union wait' argument, we don't want to believe the system has `union wait' at all. * remake.c (update_file): Do nothing to print "up to date" msgs. (update_goal_chain): Do it here instead. Use the `changed' flag of each goal's `struct dep' to keep track of whether files_remade (now commands_started) changed around a call to update_file for that goal. When a goal is finished, and its file's update_status is zero (i.e., success or nothing done), test the `changed' flag and give an "up to date" msg iff it is clear. * make.h (files_remade): Renamed to commands_started. * remake.c: Changed defn. (update_goal_chain): Changed uses. * job.c (start_job_command): Increment commands_started here. (reap_children): Not here. * remake.c (update_goal_chain): Don't do anything with files' `prev' members. update_file now completely handles this. * variable.c (target_environment): Don't expand recursive variables if they came from the environment. * main.c (define_makeflags): For flags with omitted optional args, store {"", 0} with ADD_FLAG. When constructing FLAGSTRING, a flag so stored cannot have more flags appended to the same word. Fri Jan 22 14:46:16 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * variable.c (print_variable_set): In vars/bucket calculation, don't spuriously multiply by 100. * Version 3.63. * job.c [!HAVE_UNION_WAIT] (WTERMSIG, WCOREDUMP, WEXITSTATUS): Don't define if already defined. * remake.c (update_file): Don't keep track of the command_state before calling update_file_1. Remove local variable COMMANDS_FINISHED, and don't test it to decide to print the "is up to date" msg. Testing for files_remade having changed should always be sufficient. The old method lost when we are called in the goal chain run on a makefile, because the makefile's command_state is already `cs_finished' from the makefile chain run. * misc.c [HAVE_SETRE[GU]ID]: Test these to decl setre[gu]id. * configure.in: Rewrote wait checking. Use AC_HAVE_HEADERS to check for . Use AC_HAVE_FUNCS to check for waitpid and wait3. Use a compile check to test just for `union wait'. * job.c: Rewrote conditionals accordingly. [HAVE_WAITPID]: Test this only to define WAIT_NOHANG. [HAVE_WAIT3]: Likewise. [HAVE_UNION_WAIT]: Test this to define WAIT_T and W*. * configure.in: Set CFLAGS and LDFLAGS before all checks. * dir.c: Add static forward decls of {open,read}_dirstream. Thu Jan 21 17:18:00 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.31. * job.c [NGROUPS_MAX && NGROUPS_MAX==0]: #undef NGROUPS_MAX. * compatMakefile (CFLAGS, LDFLAGS): Set to @CFLAGS@/@LDFLAGS@. * build.template (CFLAGS, LDFLAGS): Same here. * configure.in: AC_SUBST(CFLAGS) and LDFLAGS. Set them to -g if not defined in the environment. * remake.c (library_search): Use LIBNAME consistently, setting it only once, to be the passed name sans `-l'. Pass new var FILE to be modified by vpath_search. Mon Jan 18 14:53:54 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.30. * job.c (start_waiting_jobs): Return when job_slots_used is equal to job_slots. * configure.in: Add AC_CONST for the sake of getopt. * read.c (read_makefile): Continue after parsing `override' directive, rather than falling through to lossage. Check for EOL or blank after "override define". * compatMakefile (.c.o, remote.o): Put $(CFLAGS) after other switches. Fri Jan 15 12:52:52 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.29. * main.c (define_makeflags): After writing everything into FLAGSTRING, only back up two chars if [-1] is a dash, meaning we just wrote " -". Always terminate the string at *P. * remake.c (library_search): When constructing names in std dirs, use &(*LIB)[2] for the stem, not LIBNAME (which points at the buffer we are writing into!). Thu Jan 14 13:50:06 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): Set IN_IGNORED_DEFINE for "override define" when IGNORING is true. * compatMakefile (distclean): Remove config.status and build.sh. Wed Jan 13 16:01:12 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.28. * misc.c (xmalloc, xrealloc): Cast result of malloc/realloc to (char *). * arscan.c (ar_scan) [AIAMAG]: Cast read arg to (char *). * variable.c (define_automatic_variables): Override SHELL value for origin o_env_override as well as o_env. * GNUmakefile (build.sh.in): Don't replace %globobjs%. Instead, add the names of the glob objects (w/subdir) to %objs%. * build.template (globobjs): Removed. Take basename of $objs before linking. Tue Jan 12 12:31:06 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.27. * configure.in (AC_OUTPUT): Also edit build.sh. * build.template: New file. * GNUmakefile (build.sh.in): New rule to create it from build.template. (make-$(version).tar.Z): Depend on build.sh.in. * main.c (die): Call print_data_base if -p. (main): Don't call it here. * compatMakefile (defines): Add @DEFS@. configure should turn this into -DHAVE_CONFIG_H. Mon Jan 11 14:39:23 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.26. * misc.c (init_access): Surround with #ifdef GETLOADAVG_PRIVILEGED. ({make,user,child}_access) [! GETLOADAVG_PRIVILEGED]: Make no-op. * compatMakefile (install_setgid): New var, set by configure. (install): Install setgid $(group) only if $(install_setgid) is true. Fri Jan 8 15:31:55 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (load_too_high): If getloadavg fails with errno==0, give a message saying that load limits are not supported. * vpath.c (construct_vpath_list): Rewrote path deletion code to not try to use PATH's next link after freeing PATH. * main.c (define_makeflags): Rewritten; now handles string-valued option, and has no arbitrary limits. (switches): Set `toenv' flag for -I and -v. * main.c (decode_env_switches): Cast return value of alloca to char *. * misc.c (child_access) [HAVE_SETREUID, HAVE_SETREGID]: Use setre[gu]id in place of set[gu]id. Wed Jan 6 15:06:12 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (main): Define MAKEOVERRIDES, MAKE, and MAKE_COMMAND with origin o_default. * make.h [POSIX]: Don't test this to use ANSI_STRING. Testing STDC_HEADERS should be sufficient. * job.h: Declare start_waiting_jobs. * read.c (read_makefile): Add missing parens in if stmt that find conditional directives. * main.c (main): Declare init_dir. * implicit.c (pattern_search): Always use two % specs in a DEBUGP2, and always pass two non-nil args. Cast field width args to int. Add missing parens in !RULE->subdir if stmt. * function.c (expand_function, patsubst_expand): Add parens around assignments inside `while' stmts. * commands.c (print_commands): Cast field width args to int. * read.c (do_define): Cast return value of alloca to (char *). * main.c (init_switches): New function, broken out of decode_switches. (decode_switches): Take new arg ENV. If set, ignore non-option args; print no error msgs; ignore options with clear `env' flags. (decode_env_switches): Rewritten to chop envar value into words and pass them to decode_switches. (switches): Set `env' flag for -I and -v. * dir.c (init_dir): Cast free to __glob_closedir_hook's type. Tue Jan 5 14:52:15 1993 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.25. * job.c [HAVE_SYS_WAIT || !USG]: Don't #include and . interacts badly with , and we don't need these anyway. * configure.in (AC_HAVE_FUNCS): Check for setre[gu]id. * misc.c ({user,make}_access): Test #ifndef HAVE_SETRE[GU]ID, not #ifdef POSIX || USG. SunOS 4.1 is supposedly POSIX.1 compliant, but its set[gu]id functions aren't; its setre[gu]id functions work. * misc.c ({user,make,child}_access): Give name of caller in error msgs. * job.c (load_too_high): Say "cannot enforce load limit" in error msg. * configure.in: Call AC_PROG_CC. * compatMakefile (CC): Define to @CC@ (autoconf magic). * compatMakefile: Add .NOEXPORT magic target. Mon Jan 4 17:00:03 1993 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (print_version): Updated copyright to include 93. Thu Dec 31 12:26:15 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * make.h [_AIX]: Don't declare alloca. Tue Dec 29 13:45:13 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.24. * compatMakefile (objs): Add signame.o. (srcs): Add signame.[ch]. * compatMakefile (srcs): Add config.h.in. (remote.o): Add -I. before -I$(srcdir). Mon Dec 28 15:51:26 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.23. * read.c (readline): Fatal when LEN==0, indicating a line starting with a NUL. (readline): Take new arg LINENO, for use in error msg. (read_makefile, do_define): Pass it. * compatMakefile (glob/libglob.a): Pass -DHAVE_CONFIG_H in CPPFLAGS. (.c.o): Add -I. before -I$(srcdir). Wed Dec 23 12:12:04 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): Accept and ignore a rule with no targets. * compatMakefile (ALLOCA_SRC): New variable. (srcs): Include its value. * read.c (struct conditional): Renamed member `max_ignoring' to `allocated'; added new member `seen_else'. (conditional_line): Initialize seen_else flag when starting an `if...'; set it when we see an `else'; fatal if set when we see `else'. (read_makefile): Fatal "missing `endif'" if there are any pending conditionals, not just if we are still ignoring. Tue Dec 22 15:36:28 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (manext): Set to 1, not l. ($(mandir)/$(instname).$(manext)): Use $(srcdir) for make.man in cmds. * file.c (file_hash_enter): Don't call uniquize_deps here. * read.c (record_files): Likewise. * implicit.c (pattern_search): Likewise. * commands.c (set_file_variables): Call it only here. * default.c (default_variables) [__convex__]: FC=fc. * variable.c (target_environment): Expand the values of recursively expanded variables when putting them into the environment. * expand.c (recursively_expand): Made global. * make.h (recursively_expand): Declare it. * remake.c (check_dep): Set FILE->command_state to cs_deps_running when a dep's command_state is cs_running or cs_deps_running. * read.c (read_makefile): Changed error msg for spurious cmds to not say "first target". Sun Dec 20 17:56:09 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * configure.in: Do AC_CONFIG_HEADER right after AC_INIT. * make.h (HAVE_CONFIG_H): #include "config.h", then #define this. * compatMakefile (config.h, configure, config.h.in): New rules. (defines): Removed @DEFS@. Thu Dec 17 16:11:40 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (realclean): Just depend on distclean; no cmds. (distclean): Do what realclean did before; also remove Makefile and config.h; don't remove configure. (info, dvi): New targets; depend on make.{info,dvi}. (doc): Removed target. (MAKEINFO, TEXI2DVI): New vars. (make.info, make.dvi): Use them instead of explicit cmds. Wed Dec 16 16:25:24 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * configure.in: Added fcntl.h to AC_HAVE_HEADERS. getloadavg cares. Wed Dec 9 15:21:01 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (long_option_aliases): Add --new-file alias for -W. * default.c (default_variables): Change all C++ to CXX and C++FLAGS to CXXFLAGS. * read.c (do_define): Expand the variable name before using it. * main.c (main): Define variable "MAKE_COMMAND" to argv[0]; define "MAKE=$(MAKE_COMMAND) $(MAKEOVERRIDES)" always. * remake.c (library_search): Search for libNAME.a in cwd; look in vpath before looking in standard dirs, not after. Changed order of std dirs to: /lib, /usr/lib, ${prefix}/lib. Mon Nov 23 14:57:34 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * default.c (default_pattern_rules, default_terminal_rules): Added brackets around initializers. * variable.c (try_variable_definition): Don't check for LINE[0]=='\t'. (try_variable_definition): Expand the name before defining the var. * job.c (init_siglist): Removed function. Removed decl of `sys_siglist'. * make.h [! HAVE_SYS_SIGLIST]: #include "signame.h". [HAVE_SYS_SIGLIST && !SYS_SIGLIST_DECLARED]: Declare sys_siglist only under these conditions. * main.c (main): Don't declare init_siglist. (main) [! HAVE_SYS_SIGLIST]: Call signame_init instead of init_siglist. Wed Nov 18 14:52:51 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (record_files): Don't try to append to FIRSTDEPS if it's nil; instead just set it to MOREDEPS. Mon Nov 16 17:49:17 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * vpath.c (construct_vpath_list): Initialize P to DIRPATH before loop that sets MAXELEM. Fri Nov 13 18:23:18 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.22. Thu Nov 12 15:45:31 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (start_job_command): Under -n, increment files_remade after processing (i.e., printing) all command lines. Tue Nov 10 15:33:53 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * read.c (record_files): Append new deps if this rule has no commands; prepend them to existing deps if this rule has no commands. * dir.c (open_dirstream): Return nil if DIR->contents->files is nil. * read.c (parse_file_seq): Removed last arg STRIP. Always strip `./'s. (read_makefile): Changed callers. * function.c (string_glob): Likewise. * rule.c (install_pattern_rule): Likewise. Mon Nov 9 17:50:16 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (files_remade): Made global. (notice_finished_file): Don't increment files_remade here; this function gets called in many situations where no remaking was in fact done. * job.c (reap_children): Do it here instead, when we know that actual commands have been run for the file. * make.h (files_remade): Declare it. Thu Nov 5 18:26:10 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * vpath.c (construct_vpath_list): Allow blanks as well as colons to separate elts in the search path. * read.c (read_makefile): Don't fatal on extra tokens in `vpath'. The search path can contain spaces now. Tue Nov 3 20:44:32 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (check): New target; no-op. * file.c (file_hash_enter): Mod OLDHASH by FILE_BUCKETS after testing for OLDHASH==0 but before using the value. (rename_file): Don't mod OLDHASH by FILE_BUCKETS before passing it to file_hash_enter. * file.c (rename_file): Notice when OLDFILE->cmds came from default.c, and don't try to print ->filename in that case. Sun Oct 25 01:48:23 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (update_file): Don't process F->also_make here. (notice_finished_file): Don't process FILE->also_make if no attempt to update FILE was actually made. Fixed to call f_mtime directly to refresh their modtimes. Sat Oct 24 22:08:59 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (find_percent): Don't increment P again after skipping an escaped %. * expand.c (variable_expand): In call to patsubst_expand, don't find `%'s ourselves; let that function do it. * read.c (read_makefile: record_waiting_files): Don't call record_files if FILENAMES is nil. (read_makefile): All alternatives in the parsing, except for rule lines, fall through to the end of the loop. At the end of the loop, do record_waiting_files so we notice later spurious cmds. Fri Oct 23 15:57:37 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * variable.c (define_automatic_variables): Free old value of SHELL before replacing it. Thu Oct 15 18:57:56 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (.c.o): Add -I$(srcdir)/glob to flags. * dir.c (open_dirstream): Cast return value to __ptr_t. * default.c (default_variables: "GET") [_IBMR2]: Use USG defn. * make.h (MAXPATHLEN): Moved out of #ifndef POSIX. (GET_PATH_MAX): Moved from #ifdef POSIX to #ifdef PATH_MAX #else. Define as (get_path_max ()). [! PATH_MAX] (NEED_GET_PATH_MAX): Define. [! PATH_MAX] (get_path_max): Declare fn. * misc.c [NEED_GET_PATH_MAX] (get_path_max): New function. Mon Oct 12 13:34:45 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.21. * job.c (sys_siglist): Only declare #ifndef SYS_SIGLIST_DECLARED. * make.h [! HAVE_SYS_SIGLIST && HAVE__SYS_SIGLIST]: #define SYS_SIGLIST_DECLARED. * dir.c (file_impossible): When initializing DIR->contents, set DIR->contents->dirstream to nil. * compatMakefile (GLOB): Define new variable. (objs): Use it, rather than glob/libglob.a explicitly. * read.c (parse_file_seq): When stripping "./", handle cases like ".///foo" and "./////". * file.c (lookup_file, enter_file): Likewise. Sun Oct 11 17:00:35 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * dir.c (struct dirstream, {open,read}_dirstream): New data type and functions to read a directory sequentially. (init_dir): New function to hook it into glob. * main.c (main): Call init_dir. * compatMakefile (objs): Added glob/libglob.a. * configure.in: Remove code to test for glob. Fri Oct 9 12:08:30 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (record_files): Generalized test for NAME pointing somewhere into F->name. * variable.c (define_variable_in_set): Free old value when replacing. * read.c (do_define): Free the linebuffer before returning. (record_files): When clearing .SUFFIXES deps, free their data. (multi_glob): Free OLD and its data when replacing it with results of glob run. * commands.c (set_file_variables): Use alloca in place of xmalloc for temp space for $^, $?, et al. * dir.c (struct directory): New member `contents' replaces `files' and `dirstream'. (struct directory_contents): New type. (directories_contents): New hash table. (dir_struct_file_exists_p): Take a struct directory_contents. (dir_file_exists_p): Pass it the `contents' member of the dir found. (dir_struct_file_exists_p): Renamed to dir_contents_file_exists_p; made static. Return 0 if DIR is nil (meaning it couldn't be stat'd). (dir_file_exists_p, find_directory): Change all callers. (file_impossible): Use DIR->contents, initializing it if nil. (print_dir_data_base): Use DIR->contents, and print out device and inode numbers with each directory. * Changes for performance win from John Gilmore : * dir.c (DIRECTORY_BUCKETS): Increase to 199. (DIRFILE_BUCKETS): Decrease to 107. (find_directory): Allocate and zero a multiple of sizeof (struct dirfile *), not of sizeof (struct dirfile). (dir_struct_file_exists_p): New function, nearly all code from dir_file_exists_p. (dir_file_exists_p): Just call find_directory+dir_struct_file_exists_p. * vpath.c (selective_vpath_search): Remove redundant dir_file_exists_p call. * configure.in: Comment out glob check; always use our code. Fri Oct 2 19:41:20 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * make.h [! HAVE_SYS_SIGLIST && HAVE__SYS_SIGLIST]: #define HAVE_SYS_SIGLIST; after doing #define sys_siglist _sys_siglist, we do have it. Wed Sep 30 19:21:01 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (main): Don't do -w automatically if -s. Tue Sep 29 21:07:55 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (printed_version): Move variable inside print_version. (print_version): Return immediately if printed_version is set. (die): Don't test printed_version here. (decode_switches): Under -v, do print_version before giving usage. (DESCRIPTION_COLUMN): New macro. (decode_switches): Use it when printing the usage message. Leave at least two spaces between options and their descriptions. Fri Sep 25 13:12:42 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.20. Wed Sep 16 16:15:22 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * read.c (read_makefile): Save errno value from trying to open FILENAME, and restore it before erring; otherwise we get the errno value from the last elt of the search path. Tue Sep 15 15:12:47 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (long_option_aliases): Add --stop for -S. * read.c (word1eq): Do strncmp before dereferencing someplace that may be out in space. Wed Sep 9 15:50:41 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (notice_finished_file): If all the command lines were recursive, don't do the touching. * job.c (start_job_command): Don't check for + here. * commands.c (chop_commands): Do it here instead. * default.c (default_terminal_rules): Prepend + to cmds for RCS. Wed Sep 2 17:53:08 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (objs): Include $(ALLOCA). * make.h [CRAY]: Move #define signal bsdsignal to before #includes. Thu Aug 27 17:45:43 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * read.c (default_include_directories): Add INCLUDEDIR first. * compatMakefile (includedir): Define. (defines): Add -D for INCLUDEDIR="$(includedir)". * read.c (read_makefile): Grok multiple files in `include'; globbing too. * remake.c (library_search): New function. (library_file_mtime): Remove function. (f_mtime): Use library_search instead of library_file_mtime. * compatMakefile (libdir): Define. (defines): Add -D for LIBDIR="$(libdir)". * make.texinfo (Libraries/Search): Document change. * file.c (rename_file): Fix file_hash_enter call with missing arg. Wed Aug 26 17:10:46 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.19. * main.c (main): Set command_state to cs_finished for temp files made for stdin makefiles. * main.c (decode_switches): Don't tell getopt to return non-option args in order. Ignore an argument of `-'. Thu Aug 20 13:36:04 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c (start_job_command): If (touch_flag && !RECURSIVE), ignore the command line and go to the next. (notice_finished_file): Under -t, touch FILE. * remake.c (remake_file): Don't touch it here. Wed Aug 19 16:06:09 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * function.c (pattern_matches): Use temporary for strlen (WORD) instead of two function calls. * compatMakefile (LOAD_AVG): Remove variable and comments. Tue Aug 18 14:58:58 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * make.texinfo (Running): Node renamed to `make Invocation'. Fri Aug 14 12:27:10 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * arscan.c (ar_name_equal): Don't compare [MAX-3..MAX] if NAMELEN != MEMLEN. Thu Aug 13 17:50:09 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.18. * main.c: Don't #include ; make.h already does. Mon Aug 10 17:03:01 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * implicit.c (pattern_search): Fixed copying of suffix when building also_make elts. * function.c (expand_function: `shell'): Make sure BUFFER is null-terminated before replacing newlines. * compatMakefile (mandir): Use man$(manext), not always manl. Sun Aug 2 01:42:50 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * rule.c (new_pattern_rule): Not static. * rule.h: Declare it. * file.c (file_hash_enter): New function, most code from rename_file. (rename_file): Call it. * file.h (file_hash_enter): Declare it. * dep.h: Doc fix. Thu Jul 30 15:40:48 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (decode_switches): Handle usage_and_exit when building long options vector. * default.c (default_terminal_rules): Make RCS rules use $(CHECKOUT,v). (default_variables): Define CHECKOUT,v (hairy). * make.h [!HAVE_SYS_SIGLIST && HAVE__SYS_SIGLIST]: #define sys_siglist to _sys_siglist. Sun Jul 26 16:56:32 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * NEWS: Add header and tail copyright info like Emacs NEWS. * make.h [ANSI_STRING]: Don't #define index, rindex, bcmp, bzero, bcopy if already #define'd. [STDC_HEADERS] (qsort, abort, exit): Declare here. [! __GNU_LIBRARY__ && !POSIX]: Not here. * make.h [_AIX]: #pragma alloca first thing. * job.c (start_waiting_job): Set the command_state to cs_running when we queue a job on waiting_jobs. Fri Jul 24 02:16:28 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * variable.c (define_automatic_variables): Use "" instead of nil for empty value. Thu Jul 23 22:31:18 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.17. * main.c (struct command_switch.type): Add alternative usage_and_exit. (command_switches): Add -h/--help. Thu Jul 16 14:27:50 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * GNUmakefile (make-$(version).tar.Z): Include NEWS, not CHANGES. * README.template: Mention NEWS. * CHANGES: Renamed to NEWS. * main.c [! STDC_HEADERS] [sun]: Don't declare exit. Tue Jul 14 18:48:41 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (main): Set -o files' command_states to cs_finished. * rule.c (count_implicit_rule_limits): Decrement num_pattern_rules when tossing a rule. * main.c (main): Use alloca only in simple local var assignment, for braindead SGI compiler. * rule.c (print_rule_data_base): Barf if num_pattern_rules is inconsistent with the number computed when listing them. Mon Jul 13 17:51:53 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * commands.c (set_file_variables): For $? and $^ elts that are archive member refs, use member name only. Fri Jul 10 00:05:04 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * variable.h (struct variable.export): Add new alternative v_ifset. * variable.c (target_environment): Check for it. (define_automatic_variables): Set it for MAKEFILES. Thu Jul 9 21:24:28 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (objs): Remove getloadavg.o; $(extras) gets it. (remote.o): Use $(srcdir)/remote.c, not $remote.c<. (distclean, mostlyclean): New targets. Tue Jul 7 19:12:49 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.16. * compatMakefile (config.status): Remove rule. * job.c (start_waiting_job): Free C after using C->file, not before. Sat Jul 4 20:51:49 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * commands.c, job.c, main.c, make.h, remote-cstms.c: Use #ifdef HAVE_* instead of #ifndef *_MISSING. * configure.in: Use AC_HAVE_FUNCS instead of AC_MISSING_FUNCS (gone). Thu Jul 2 18:47:52 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * main.c (main): makelevel>0 or -C implies -w. Tue Jun 30 20:50:17 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * file.c, job.c, function.c: Don't #include . make.h: Do it here instead. * arscan.c (ar_member_touch): Don't declare errno. Thu Jun 25 17:06:55 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * GNUmakefile (make-$(version).tar.Z): Depend on INSTALL, configure.in. * remake.c (update_file): If commands or deps are running after update_file_1 returns, break out of the :: rule (->prev) loop and just return. * job.c (job_next_command): New function; code from start_job. (start_job_command): Renamed from start_job. Call job_next_command and recurse for empty command lines and -n. (start_waiting_job): Call start_job_command, not start_job. (new_job): Call job_next_command to prime the child structure, and then call start_waiting_job. (reap_children): Use job_next_command and start_job_command. (start_waiting_job): Call start_remote_job_p here, and store its result in C->remote. If zero, check the load average and maybe put C on waiting_jobs. (start_job_command): Test CHILD->remote rather than calling start_remote_job_p. Don't do load avg checking at all here. * main.c (main): Don't handle SIGILL, SIGIOT, SIGEMT, SIGBUS, SIGSEGV, SIGFPE or SIGTRAP. * compatMakefile (glob/libglob.a): Don't pass srcdir to sub-make. configure will set it in glob/Makefile. Wed Jun 24 19:40:34 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * dir.c [DIRENT] (direct): Don't define to dirent. [! DIRENT] (direct): Define to dirent. (dir_file_exists_p): Use struct dirent instead of struct direct. * make.h (getcwd): No space between macro and ( for args! * job.c (start_job): Don't put the job on waiting_jobs if job_slots_used==0. * make.texinfo (Missing): Shortened title. Tue Jun 23 18:42:21 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * file.c (remove_intermediates): Print "rm" commands under -n. Mon Jun 22 16:20:02 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.15. Fri Jun 19 16:20:26 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * arscan.c [M_UNIX]: #undef M_XENIX. Wed Jun 17 17:59:28 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * default.c (default_terminal_rules): Put @ prefix on RCS cmds. Tue Jun 16 19:24:17 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (getloadavg.o): Removed special rule. (CFLAGS): Don't include $(defines). (.c.o): Define suffix rule. (glob/libglob.a): Pass CPPFLAGS=$(defines) to submake. (GETOPT_SRC, srcs, tagsrcs): Prefix files with $(srcdir)/. * arscan.c (ar_name_equal): Moved local vars inside #if'd block. * make.h (max): Removed. * expand.c (variable_buffer_output): Don't use it. * compatMakefile (INSTALL): Define. (Makefile): New rule to make from Makefile.in. (srcdir): Define. (VPATH): Define. (getloadavg.o, remote.o): Use autoconf $foo< hack. * commands.c (fatal_error_signal): Removed return. Mon Jun 15 17:42:51 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.14. * make.texinfo (Summary): New node. (Special Targets): Mention .EXPORT_ALL_VARIABLES here. * variable.c (max): Moved to make.h. * compatMakefile (objs, srcs): Added ar & arscan. * job.c (start_waiting_job): New function, 2nd half of new_job. (new_job): Call it. (start_waiting_jobs): New function. * remake.c (update_goal_chain): Call start_waiting_jobs at the top of the main loop. * compatMakefile (objs, srcs): Removed load, added getloadavg. Fri Jun 12 19:33:16 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c (load_too_high): New function. Uses getloadavg. (waiting_jobs): New variable. (start_job): Don't call wait_to_start_job. Instead, if load_too_high returns nonzero, add the child to the `waiting_jobs' chain and return without starting the job. Thu Jun 11 00:05:28 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * expand.c (variable_buffer_output): Made global again. * variable.h: And declare it. * arscan.c (PORTAR): Define for all systems if PORT5AR is not defined. (AR_NAMELEN, AR_TRAILING_SLASH): Removed. (ar_scan): Don't use it. Don't #ifdef AR_TRAILING_SLASH; just look for a slash in the archive at run time. (ar_name_equal): Rewrote .o hacking to not use AR_NAMELEN, and to cope with trailing-slash and non-trailing-slash archives. * main.c (main) [! SETVBUF_REVERSED]: Test this instead of USGr3 et al. [SETVBUF_REVERSED]: Always allocate a buffer ourselves. * load.c (load_average) [sgi]: Use sysmp call. * compatMakefile (INSTALL_DATA, INSTALL_PROGRAM): Define. ($(bindir)/$(instname), $(mandir)/make.$(manext)): Use them. * make.h [HAVE_VFORK_H]: #include . (vfork, VFORK_NAME): Don't define. * job.c (start_job): Use "vfork" in place of VFORK_NAME. * make.h [HAVE_LIMITS_H, HAVE_SYS_PARAM_H]: If #define'd, #include the each file. Rearranged PATH_MAX hacking. * job.c: Rearranged NGROUPS_MAX hacking. * remake.c (fstat, time): Don't declare. * compatMakefile (defines): Value is @DEFS@. (LOADLIBES): Value is @LIBS@. (extras): Value is @LIBOBJS@. (ARCHIVES, ARCHIVES_SRC, ALLOCASRC): Removed. * arscan.c, ar.c: Surround body with #ifndef NO_ARCHIVES. * misc.c [! HAVE_UNISTD_H]: Test instead of !POSIX to decl get*id. * make.h [GETCWD_MISSING]: Test instead of !USG && !POSIX et al. (getcwd): Just declare if present. If not, declare as a macro using getwd, and declare getwd. [PATH_MAX] (GET_PATH_MAX): #define to PATH_MAX. * main.c (main, log_working_directory): Use getcwd instead of getwd. * main.c (main) [SETLINEBUF_MISSING]: Test this instead of USG. * make.h (SIGHANDLER, SIGNAL): Removed. (RETSIGTYPE): Define if not #define'd. * main.c (main): Use signal in place of SIGNAL. * main.c [SYS_SIGLIST_MISSING]: Test instead of USG. * job.c (search_path) [GETGROUPS_MISSING]: Test instead of USG. [HAVE_UNISTD_H]: Test instead of POSIX to not decl getgroups. * main.c [! HAVE_UNISTD_H]: Test instead of !POSIX to decl chdir. [! STDC_HEADERS]: Test instead of !POSIX to decl exit & atof. * job.c (child_handler), commands.c (fatal_error_signal): Return RETSIGTYPE instead of int. * main.c (main): Declare fatal_error_signal and child_handler here to return RETSIGTYPE; removed top-level decl of former. * commands.c (fatal_error_signal), job.c (unblock_sigs, start_job), main.c [SIGSETMASK_MISSING]: Test this instead of USG. Wed Jun 10 22:06:13 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c [HAVE_WAITPID]: Test this instead of USG. [! HAVE_UNISTD_H]: Test this instead of !POSIX to declare misc fns. (GID_T): Don't #define. (search_path): Use gid_t instead of GID_T. [GETDTABLESIZE_MISSING, SYS_SIGLIST_MISSING, DUP2_MISSING]: Test these individually instead of USG for all. * make.h (ctime): Don't declare. #include time.h instead. [HAVE_UNISTD_H]: #include and #define POSIX #ifdef _POSIX_VERSION. * dir.c [__GNU_LIBRARY__] (D_NAMLEN): Define to use d_namlen member. * make.h [NEED_MEMORY_H]: Only include memory.h #ifdef this. * arscan.c: Removed #ifdef mess about string.h et al. Just #include make.h instead. * make.h (fstat, atol): Declare. * commands.c (fatal_error_signal): Don't use sigmask to check for propagated signals; use ||s instead. (PROPAGATED_SIGNAL_MASK): Removed. (fatal_error_signal) [POSIX]: Use sigprocmask in place of sigsetmask. * variable.c (variable_buffer, variable_buffer_length, initialize_variable_output, variable_output): Moved to expand.c; made all static. (struct output_state, save_variable_output, restore_variable_output): Removed. * expand.c (initialize_variable_output): Put a NUL at the beginning of the new buffer after allocating it. (allocated_variable_expand_for_file): Don't use {save,restore}_variable_output. Do it by hand instead, keeping state on the stack instead of malloc'ing it. (allocated_variable_expand): Removed. * variable.h (allocated_variable_expand): Define here as macro. (variable_buffer_output, initialize_variable_output, save_variable_output, restore_variable_output): Removed decls. * read.c (conditional_line): For an if cmd, if any elt of the conditionals stack is ignoring, just push a new level that ignores and return 1; don't evaluate the condition. Thu Jun 4 21:01:20 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (main): Put #ifdef's around frobbing SIGSYS and SIGBUS. * job.c (getdtablesize): Don't declare or #define if already #define'd. Wed Jun 3 23:42:36 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * file.c (snap_deps): If `.EXPORT_ALL_VARIABLES' is a target, set export_all_variables. * make.texinfo (Variables/Recursion): Document .EXPORT_ALL_VARIABLES. Tue Jun 2 21:08:35 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.13. * commands.c (set_file_variables): Calculate length for ^D and ?D individually, making sure to give them at least enough space for "./". * make.h [CRAY]: #define signal to bsdsignal. * default.c (default_variables) [CRAY]: Define PC, SEGLDR, CF77PPFLAGS, CF77PP, CFT, CF, and FC. * arscan.c (AR_HDR_SIZE): Define to sizeof (struct ar_hdr), if it wasn't defined by . Thu May 28 00:56:53 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.12. Tue May 26 01:26:30 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * rule.c (new_pattern_rule): Initialize LASTRULE to nil, not pattern_rules. Mon May 25 19:02:15 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (decode_switches): Initialize all the long_option elt members. Thu May 21 16:34:24 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * make.texinfo (Text Functions): Correct filter-out description. Tue May 19 20:50:01 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * compatMakefile (realclean): Don't remove backup files. * main.c (decode_switches): Allocate ARGC+1 elts in `other_args'. Sun May 17 16:38:48 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.62.11. Thu May 14 16:42:33 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * job.c (reap_children): Don't die if wait returns EINTR. Wed May 13 18:28:25 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c (reap_children): Always run the next command for a successful target. If we are going to die, we don't want to leave the target partially made. Tue May 12 00:39:19 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): After loop, if we only have one word, check it for being a shell command. * main.c (decode_switches): Allocate ARGC slots in other_args to begin with, so we never need to worry about growing it. If we get a non-option arg and POSIXLY_CORRECT is in the environment, break out of the loop. After the loop, add all remaining args to other_args list. * main.c (decode_switches): For positive_int and floating switches when optarg is nil, use next arg if it looks right (start with a digit, or maybe decimal point for floating). * variable.c (define_automatic_variables): Always set SHELL to default if it comes from the environment. Set its export bit. * make.texinfo (Environment): Document change. Mon May 11 00:32:46 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.62.10. * compatMakefile (tags, TAGS): Use vars for cmds. (ETAGS, CTAGS): Define. * main.c (decode_switches): If a switches elt has a nil long_name, make the long option name elt be "". Fixed loop to not ignore all the options. * make.texinfo (Option Summary): Added long options. * main.c (switches): Changed -m's description to "-b". (decode_switches): When printing the usage message, don't print switches whose descriptions start with -. When constructing the list of names for switch -C, search the switches vector for switches whose descriptions are "-C". * main.c (switches): Call -S --no-keep-going, not --dont-keep-going. Call -I --include-dir, not --include-path. (long_option_aliases): Added --new == -W, --assume-new == -W, --assume-old == -o, --max-load == -l, --dry-run == -n, --recon == -n, --makefile == -f. * main.c (switches): Removed bogus "silent" elt. (long_option_aliases): Define new var. (decode_switches): Add long_option_aliases onto the end of the long options vector created for getopt_long. Look through long_option_aliases for extra names to list in usage message. Sat May 9 00:21:05 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (log_working_directory): Fixed to properly not print the leaving message when we haven't printed the entering message. Fri May 8 21:55:35 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (struct command_switch): Added elts `long_name', `description', and `argdesc'. (switches): Added initializers for new members. (decode_switches): Rewritten to use getopt_long. * compatMakefile (GETOPT, GETOPT_SRC): Define. (objs, srcs): Include them. * job.c (child_died): Renamed to dead_children; made static. (child_handler): Increment dead_children instead of setting child_died. (reap_children): Decrement dead_children instead of clearing child_died. The point of all this is to avoid printing "waiting for unfinished jobs" when we don't actually need to block. This happened when multiple SIGCHLDs before reap_children was called. * job.c (reap_children): If ERR is set, so we don't call start_job on the child being reaped, instead set its command_state to cs_finished. (reap_children, child_handler, new_job): I added several debugging printf's while fixing this. I left them in if (debug_flag) because they may be useful for debugging this stuff again. Wed May 6 22:02:37 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * read.c (read_makefile): v_export is not 1. Mon May 4 17:27:37 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.9. * variable.c (export_all_variables): New variable. (target_environment): Export variables whose `export' member is v_default if export_all_variables is set and their names are benign. * variable.h: Declare export_all_variables. * read.c (read_makefile): If export or unexport is given with no args, set or clear export_all_variables, respectively. * variable.c (target_environment): Exclude MAKELEVEL in the loop, so it isn't duplicated when we add it at the end. Sun May 3 17:44:48 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.8. * variable.h (struct variable): Added new member `export'. * variable.c (define_variable_in_set): Initialize it to v_default. (target_environment): Don't check for .NOEXPORT. Export variables whose `export' member is v_default and that would have been exported under .NOEXPORT, and variables whose `export' member is v_export. (try_variable_definition): Return the variable defined. * variable.h (try_variable_definition): Changed decl. * read.c (read_makefile): Recognize `export' and `unexport' directives. Fri May 1 11:39:38 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * main.c (main) [POSIX]: Reversed args to sigaddset. Thu Apr 30 17:33:32 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c [POSIX || !USG] (unblock_sigs): New fn. (start_job): Block signals before forking. (new_job): Unblock signals after putting the new child on the chain. * main.c (main) [POSIX]: Use sigset_t fatal_signal_set instead of int fatal_signal_mask. * load.c [sgi] (LDAV_CVT): Define. Wed Apr 29 17:15:59 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.62.7. * load.c (load_average) [sgi]: Clear the high bit of the address from the symbol table before looking it up in kmem. * misc.c (fatal, makefile_fatal): Put *** in fatal error messages. (remake_file): No longer needed in message here. * main.c (die): Call reap_children with BLOCK==1. Tue Apr 28 20:44:35 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * rule.c (freerule): Don't set LASTRULE->next if LASTRULE is nil. Sun Apr 26 15:09:51 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * rule.c (count_implicit_rule_limits): Initialize LASTRULE to nil, not to head of chain. Extract next ptr before we might do freerule, and use that for next iteration. (freerule): Still do next ptr frobbing if LASTRULE is nil. Tue Apr 21 03:16:29 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * job.c (child_error): Removed extra %s from error msg format. * Version 3.62.6. * job.c (reap_children): Don't start later commands in a sequence if ERR is nonzero. * job.c (new_job): Always call reap_children with BLOCK==0 first thing. * job.c (reap_children): New function; work that used to be done in child_handler. (child_died): New global var. (child_handler): Now just sets child_died. (wait_for_children): Removed. (unknown_children_possible, block_signals, unblock_signals, push_signals_blocked_p, pop_signals_blocked_p): Removed. (child_execute_job): Removed call to unblock_signals. (new_job): Removed calls to push_signals_blocked_p and pop_signals_blocked_p. * job.h: Declare reap_children, not wait_for_children. * commands.c (fatal_error_signal), job.c (new_job), load.c [LDAV_BASED] (wait_to_start_job), main.c (die), remake.c (update_goal_chain), function.c (expand_function: `shell'): Changed wait_for_children calls to reap_children. Some needed to be loops to wait for all children to die. * commands.c (fatal_error_signal), main.c (main, log_working_directory), function.c (expand_function): Removed calls to push_signals_blocked_p and pop_signals_blocked_p. * job.h: Removed decls. * job.h: Added copyright notice. Wed Apr 15 02:02:40 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (child_error): No *** for ignored error. Tue Apr 14 18:31:21 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * implicit.c (DEBUGP2): Use do ... while (0) instead of if ... else to avoid compiler warnings. * read.c (parse_file_seq): Don't remove ./ when it is followed by a blank. Mon Apr 13 21:56:15 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h (DEBUGPR): Use do ... while (0) instead of if ... else to avoid compiler warnings. * remake.c (notice_finished_file): Run file_mtime on the also_make files, so vpath_search can happen. * GNUmakefile (tests): Use perl test suite from csa@sw.stratus.com. (alpha-files): Include test suite tar file. Fri Apr 3 00:50:13 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.62.5. Wed Apr 1 05:31:18 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (update_file, update_file_1): Do check_renamed on elts of dep chains when traversing them. Something unrelated might have renamed one of the files the dep chain points to. * file.c (rename_file): If FILE has been renamed, follow its `renamed' ptr, so we get to the final real FILE. Using the renamed ones loses because they are not in the hash table, so the removal code loops infinitely. * read.c (read_all_makefiles): Clobber null terminator into MAKEFILES expansion, so string passed to read_makefile is properly terminated. Mon Mar 30 20:18:02 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * commands.c (set_file_variables): $* for archive member with explicit cmds is stem of member, not of whole `lib(member)'. Thu Mar 26 15:24:38 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.62.4. Tue Mar 24 05:20:51 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * rule.c (new_pattern_rule): Rules are identical only if all their targets match (regardless of order). Wed Mar 11 13:49:54 1992 Roland McGrath (roland@geech.gnu.ai.mit.edu) * remake.c (remake_file): Changed error "no way to make" to "no rule to make". Fiat Hugh. * make.texinfo (Last Resort): Describe %:: rules and new .DEFAULT behavior. * remake.c (update_file_1): Only use .DEFAULT cmds if FILE is not a target. Tue Mar 10 18:13:13 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * remote-stub.c, remote-cstms.c (start_remote_job): Take new arg, environment to pass to child. * job.c (start_job): Pass it. Mon Mar 9 19:00:11 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * file.c (enter_file): Also strip ./s here, to get command-line target names. * remote-cstms.c: Add comment telling people to leave me alone. * compatMakefile (manpage install): Remove target before copying. Tue Mar 3 18:43:21 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.texinfo (Missing): Renamed to "Incompatibilities and ...". Added paragraph describing $? incompatibility with Unix and POSIX.2. Sun Mar 1 15:50:54 1992 Roland McGrath (roland@nutrimat.gnu.ai.mit.edu) * function.c (expand_function: `shell'): Don't declare fork or pipe. Use vfork instead of fork. Tue Feb 25 22:05:32 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * make.texinfo (Chained Rules): Clarify .PRECIOUS to save intermediate files. * load.c [sun] (LDAV_CVT): Define to divide by FSCALE. Sun Feb 16 02:05:16 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * Version 3.62.3. Sat Feb 15 17:12:20 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * compatMakefile (makeinfo): Use emacs batch-texinfo-format fn. Fri Feb 14 00:11:55 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * read.c (read_makefile): Correctly handle define & endef in ifdefs. * read.c (record_files): Pass arg for %s in error msg. * main.c (main) [__IBMR2, POSIX]: Use correct (a la USGr3) setvbuf call. Wed Feb 12 12:07:39 1992 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * make.texinfo (Libraries/Search): Say it does /usr/local/lib too. Sun Feb 9 23:06:24 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (read_makefile): Check for extraneous `endef' when ignoring. Thu Feb 6 16:15:48 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62.2. Tue Feb 4 20:04:46 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): Correctly ignore whitespace after backslash-NL. Fri Jan 31 18:30:05 1992 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile: Ignore errors from chgrp and chmod when installing. Wed Jan 29 18:13:30 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * main.c (main): When setting MAKELEVEL in the env to re-exec, allocate space so as not to clobber past the end of the old string. * make.h [HAVE_ALLOCA_H]: Include * compatMakefile (defines): Document HAVE_ALLOCA_H. Mon Jan 20 13:40:05 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * make.h [VFORK_MISSING]: Use fork instead. * compatMakefile (defines): Document same. * job.c (construct_command_argv_internal): Don't create an empty arg if backslash-NL is at beginning of word. Sun Jan 19 16:26:53 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * main.c [DGUX]: Call setvbuf as for USGr3. * job.c (construct_command_argv_internal): Notice correctly that backslash-NL is the end of the arg (because it is replaced with a space). Thu Jan 16 18:42:38 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): If SHELL is nil, set it to default_shell before proceeding. * make.h [sgi]: No alloca.h, after all. Wed Jan 15 12:30:04 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * read.c (multi_glob): Cons up the chain of the results of glob from back to front, so it comes out in forward order. * job.c (construct_command_argv_internal): Don't eat char following backslash-NL. Mon Jan 13 19:16:56 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.62.1. * default.c (default_variables) [ultrix]: GET=get, like USG. * job.c (construct_command_argv_internal): Remove tabs following backslash-NL combos in the input line, so they don't show up when that line is printed. * read.c (read_makefile): Don't collapse_continuations the line on input; do it on the copy we do remove_comments on. For rule lines, collapse_continuations the line after chopping ";cmds" off the end, so we don't eat conts in the cmds. Give error for ";cmds" with no rule. * job.c (construct_command_argv_internal): Eat backslash-NL combos when constructing the line to recurse on for slow, too. Sat Jan 11 02:20:27 1992 Roland McGrath (roland@albert.gnu.ai.mit.edu) * file.c (enter_file): Don't strip leading `./'s. * read.c (parse_file_seq): Take new arg STRIP; if nonzero, do it here. * default.c (set_default_suffixes), function.c (string_glob), read.c (read_makefile), rule.c (install_pattern_rule): Change callers. * default.c (default_variables) [_IBMR2]: FC=xlf * job.c (construct_command_argv_internal): Turn backslash-NL and following whitespace into a single space, rather than just eating the backslash. * make.texinfo (Copying): @include gpl.texinfo, rather than duplicating its contents. Fri Nov 8 20:06:03 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): Make sure not to bother processing an empty line. * Version 3.62.0. * job.c (construct_command_argv_internal): Always recurse for slow; simple case didn't handle finding newlines. Tue Nov 5 18:51:10 1991 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * job.c (construct_command_argv_internal): Set RESTP properly when slow; don't \ify past a newline. Fri Nov 1 19:34:28 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h [sgi]: #include . Tue Oct 29 20:57:36 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.62. * remake.c (update_file_1): Check for deps still running before giving up if any dep has failed. Sat Oct 26 16:20:00 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h [uts]: #undef S_ISREG and S_ISDIR if defined. Fri Oct 25 19:50:39 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.17. Thu Oct 24 16:58:36 1991 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * job.c (start_job): Don't check for empty cmds before tweaking the command_ptr. Just let construct_command_argv do it. Tue Oct 22 20:21:03 1991 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * remake.c, arscan.c [POSIX]: instead of . * make.h [POSIX]: Declare vfork as pid_t. Mon Oct 21 15:37:30 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.16. * job.c (construct_command_argv, construct_command_argv_internal): Take new 2nd arg RESTP. If non-NULL, stop parsing at newline, and store addr of the NL in *RESTP. (start_job): Don't chop expanded cmd lines up; use above code to do it. * function.c (expand_function: `shell'): Pass RESTP==NULL. Sat Oct 19 15:36:34 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.15. Fri Oct 18 15:26:55 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c (start_job): If on the same cmds->command_lines elt, look at cmds->lines_recurse[CHILD->command_line - 1] instead of [CHILD->command_line]. * dir.c [sgi]: , not ndir or anything else. Thu Oct 17 16:28:55 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * file.c (print_file_data_base): Remove unused var. * make.h [NeXT]: No #define ANSI_STRING. Tue Oct 15 20:08:41 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.60.14. Fri Oct 11 16:23:52 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * make.h: Use PATH_MAX for getwd defn. * make.h: Move getcwd/getwd outside of #ifndef POSIX, and make it #if USG||POSIX. Thu Oct 10 11:53:31 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.60.13. * read.c (read_all_makefiles): When processing MAKEFILES, save the malloc'd ptr to be freed, instead of freeing part-way thru it. * remake.c (update_file_1): Don't tweak FILE->also_make. (update_file): Do it here. After calling update_file_1, set the command_state, update_status, and updated members of each also_make elt to FILE's values. Tue Oct 8 14:56:04 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.60.12. * remake.c (notice_finished_file): Set command_state of FILE and its also_make chain to cs_finished here. * commands.c (execute_file_commands), job.c (child_handler), remake.c (remake_file): Don't set it before calling notice_finished_file. * file.h (struct file): Changed `also_make' to struct dep *. * job.c (delete_child_targets), file.c (print_file_data_base), remake.c (notice_finished_file), implicit.c (pattern_search): Use dep chain instead of array of file names. Mon Oct 7 17:04:33 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.60.11. * arscan.c: Declare open. * misc.c: Declare {get,set}{re,}[ug]id. * variable.c (target_environment): Declare getenv. Sat Oct 5 15:13:03 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * make.h [NeXT]: instead of . Fri Oct 4 16:05:41 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * default.c (default_suffixes, defualt_suffix_rules): Add .texi just like .texinfo. * Version 3.60.10. * job.c: Move vfork decl into make.h. Fri Sep 27 18:45:30 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * compatMakefile (glob/libglob.a): Pass CC value to submake. Thu Sep 26 00:08:15 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * load.c (load_average): Made not static. * load.c [ultrix && vax]: Define LDAV_TYPE and LDAV_CVT for Ultrix 4.2. Tue Sep 24 00:17:20 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.9. * read.c (record_files): Warn about extra cmds even if the target's name begins with a dot. I think the lusers can handle this. Mon Sep 23 22:33:26 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h, arscan.c: Don't declare bcmp, bzero, or bcopy if they're #define'd. * make.h: Declare write and open. * default.c (default_suffixes, default_suffix_rules, default_variables): Add .C just like .cc. * make.texinfo (Catalogue of Rules): Document .C. * make.man (-w): Fix gramo. Fri Sep 20 17:18:16 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h: No text after #endif. Sun Sep 15 16:20:46 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.60.8. * implicit.c (pattern_search): In the second pass, recurse on rule deps that don't have a %. Why did I make it not do this? Fri Sep 14 18:29:39 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * read.c (record_files): For extra cmds, use the last ones given. If the target's name doesn't begin with a dot (bletch!!), emit a two-line warning, one line giving the old cmds' location and the other the new cmds' location. * misc.c (makefile_error, makefile_fatal): New fns. * make.h: Declare them. * Use them instead of error/fatal for all msgs including a file name and line number. Thu Sep 13 16:35:54 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * make.h: Declare define_default_variables. Declare ar_parse_name, instead of ar_name_parse (M-t). Mon Sep 10 18:35:40 1991 Roland McGrath (roland@wookumz.gnu.ai.mit.edu) * Version 3.60.7. * make.texinfo (Variables: Setting): Say whitespace is removed if "immediately after =", rather than simply "after =". * job.c: Don't declare wait #ifdef POSIX. * make.h [__GNUC__]: #undef alloca and then #define it. * main.c (main): When pruning makefiles which might loop from the read_makefiles chain, look at all `prev' entries of double-colon rules. Fri Sep 7 00:41:53 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * main.c (main): Only remove makefiles with cmds but no deps from the list of makefiles to be rebuilt if they are :: targets. : targets with cmds and no deps are not dangerous. Wed Sep 5 17:35:51 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile (defines): Add comment that some compilers take ENUM_BITFIELDS but produce bogus code. (LOAD_AVG): Fix examples to \ "s. (LOADLIBES): Add comment that SGI Irix needs -lmld for nlist. Tue Sep 4 20:26:26 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.6. Fri Aug 30 19:34:04 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * remake.c (update_file_1): When checking the command_state of deps, check through the prev chain. (update_goal_chain): When a target is finished, start checking its prev (if it has one) instead. Wed Aug 7 17:32:03 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * rule.c (convert_to_pattern): Allow files with deps to define suffix rules (really this time). Mon Aug 5 17:09:21 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * misc.c (user_access, make_access): Do saved-IDs (USG) flavor #ifdef POSIX. * file.c (enter_file): Strip ./s here. * read.c (parse_file_seq): Not here. Tue Jul 23 23:34:30 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * compatMakefile: Added comment that -lPW alloca is broken on HPUX. Thu Jul 18 03:10:41 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.5. * read.c (read_makefile): Ignore lines containing chars that are all isspace, not just all isblank. * make.texinfo (Copying): @include gpl.texinfo, rather than copying the text. * gpl.texinfo: New file (symlink to /gd/gnu/doc/gpl.texinfo). * GNUmakefile: Put gpl.texinfo in distribution. Tue Jul 16 12:50:35 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * make.h: #define _GNU_SOURCE before including headers. Include and define isblank if doesn't. * commands.c: Don't include here. * *.c: Use isblank instead of explicit ' ' || '\t'. Mon Jul 15 17:43:38 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * function.c (expand_function: `filter'/`filter-out'): Fixed to not loop infinitely. Fri Jul 12 12:18:12 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * function.c (expand_function: `filter'/`filter-out'): Rewritten to handle filter-out of multiple patterns properly. Also no longer mallocs and reallocs for temp array; uses alloca and a linked-list instead. Wed Jul 10 22:34:54 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.4. * make.texinfo: Moved some @groups that were outside @examples to be inside them. * load.c [apollo] (load_average): Define using special syscall for Apollo DOMAIN/OS SR10.n. Thu Jul 4 12:32:53 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * make.texinfo (Missing): Added Unix excessive implicit rule search; mention that POSIX.2 doesn't require any of the missing features. (Top): Updated printed manual price to $15. Wed Jul 3 18:17:50 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * file.c (rename_file): Carry over last_mtime when merging files. * remake.c (f_mtime): Tail-recurse after renaming VPATH file, to check for saved date in existing renamed-to file. * remote-cstms.c (start_remote_job): Use PATH_VAR. * commands.c [POSIX || __GNU_LIBRARY__]: Don't declare getpid. * compatMakefile (glob-{clean,realclean}): Run clean/realclean in glob. (clean, realclean): Require those. * make.h: Always declare environ. Don't declare old glob functions. * GNUmakefile: Make no-lib deps for load.c and remote.c. Tue Jul 2 18:35:20 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * Version 3.60.3. Mon Jul 1 16:58:30 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * read.c (multi_glob): Don't pass GLOB_QUOTE flag to glob. * make.h [POSIX]: Include , and don't declare things that should be there. * main.c (main) [USG && sgi]: malloc a buffer for broken sgi stdio. Sat Jun 29 11:22:21 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * function.c (expand_function: `shell'): Use alloca for the error msg buffer, instead of assuming an arbitrary max size. Fri Jun 28 18:15:08 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * job.c [POSIX] (search_path): Do real 1003.1 goop to get NGROUPS_MAX. Wed Jun 26 11:04:44 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * default.c (define_default_variables): New fn. (install_default_implicit_rules): Code for above fn moved there. * main.c (main): Do define_default_variables before reading the makefile. Tue Jun 25 17:30:46 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * main.c (main): Quote ; in MAKEOVERRIDES. Tue Jun 18 13:56:30 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * compatMakefile: Fixed typo in comment. Tue Jun 11 00:14:59 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * Version 3.60.2. Mon Jun 10 14:46:37 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h: Always include . [POSIX]: Include and #define MAXPATHLEN to be PATH_MAX. * default.c (default_suffix_rules: .texinfo.dvi): Use $(TEXI2DVI). (default_variables): Define TEXI2DVI. Thu Jun 6 16:49:19 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.60.1. * make.h (SIGNAL): Cast handler arg to SIGHANDLER type. Wed Jun 5 06:00:43 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * read.c (multi_glob): Use POSIX.2 `glob' function. If a glob pattern matches nothing, leave it as is (a la sh, bash). Also, if can't find USER for ~USER, leave it as is (a la bash). Mon Jun 3 16:36:00 1991 Roland McGrath (roland@albert.gnu.ai.mit.edu) * compatMakefile: Rewrote comments about -Ds to be easier to use. * make.h, arscan.c, remake.c, main.c, dir.c, job.c: Changed tests of _POSIX_SOURCE to POSIX. * job.c: Take getdtablesize out of #ifdef __GNU_LIBRARY__. Put separately #ifdef USG. * COPYING: Replaced with version 2. * Changed copyright notices to refer to GPL v2. Thu May 30 00:31:11 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * make.h: Don't declare sigblock for POSIX. * main.c (main, log_working_directory) [USG]: Get getcwd failure mode from errno, not passed buffer like BSD getwd. * misc.c (child_access): New fn to set access for a child process; like user_access, but you can't change back. * make.h: Declare it. * job.c (exec_command): Use it in place of user_access. Wed May 29 23:28:48 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * default.c (default_variables) [pyr]: PC = pascal. Tue May 28 20:24:56 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) * variable.c (print_variable): Put a newline before `endef'. Sat May 25 02:39:52 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.60. Wed May 22 19:41:37 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * Version 3.59.5. Thu May 16 13:59:24 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * main.c (main): Do USGr3 setvbuf behavior #ifdef APOLLO. Don't handle SIGCHLD #ifdef USG (Apollo is USG but defines SIGCHLD). Fri May 10 14:59:33 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * remake.c [sgi]: Don't include . Wed May 8 01:54:08 1991 Roland McGrath (roland@geech.gnu.ai.mit.edu) * make.h (SIGHANDLER): #define as (void *) #if __STDC__, else (int (*)()). (SIGNAL): Use it to cast return value. * main.c (main): Cast SIG_IGN to SIGHANDLER when comparing. * job.c (block_signals, unblock_signals): Use SIGNAL instead of signal. * main.c: Declare mktemp to return char*, not int. * job.c (new_job): Don't increment files_remade. * remake.c (notice_finished_file): Do it here. * read.c (do_define): Don't clobber DEFINITION[-1] on empty defns. Free storage that is no longer needed. Wed Apr 24 20:49:48 1991 Roland McGrath (roland at churchy.gnu.ai.mit.edu) * misc.c (message): New fn to print informational msgs with leading "make: " or "make[N]: ". * make.h: Declare it. * remake.c (update_file): Use it instead of printf. Fri Apr 19 05:52:45 1991 Roland McGrath (roland at churchy.gnu.ai.mit.edu) * main.c (main): When there are no targets, if there were no makefiles, print a different error message, which mentions makefiles. Tue Apr 16 03:22:45 1991 Roland McGrath (roland at geech.gnu.ai.mit.edu) * remake.c (update_file): Print "nothing to be done" instead of "is up to date" if FILE->cmds == 0. * job.c [!WIFEXITED]: Define if not already defined. Thu Apr 11 18:00:50 1991 Roland McGrath (roland at wookumz.gnu.ai.mit.edu) * arscan.c (ar_name_equal): Fixed truncation comparison. Tue Apr 2 16:17:35 1991 Roland McGrath (roland at churchy.gnu.ai.mit.edu) * glob.c: Use common version from djm. * dir.c: Snarfed #ifdef mess for or whatever from glob.c. (dir_file_exists_p): Ignore directory entries with d_ino==0. Mon Apr 1 20:49:45 1991 Roland McGrath (roland at albert.gnu.ai.mit.edu) * Version 3.59.4. Fri Mar 29 19:16:18 1991 Roland McGrath (roland at albert.gnu.ai.mit.edu) * job.c (free_child): Free CHILD->environment and its elts. Sat Mar 23 14:08:09 1991 Roland McGrath (roland at albert.gnu.ai.mit.edu) * read.c (read_makefile): Don't ignore lines containing only comments if they start with a tab. Such lines should be passed to the shell for it to decide about the comments. * job.c (free_child): Free CHILD->command_lines and its elts, not CHILD->commands (which is obsolete). * job.h, job.c: Remove obsolete `commands' member of `struct child'. Sun Mar 17 18:40:53 1991 Roland McGrath (roland at albert.ai.mit.edu) * remake.c (update_file): Print a msg for a top-level up-to-date phony target (a different one than for a real file). * read.c (conditional_line): Boundary check so we don't check the value of the -1th elt of the stack (which is bogus). Sat Mar 16 16:58:47 1991 Roland McGrath (roland at albert.ai.mit.edu) * read.c (conditional_line): Don't evaluate an if* when we're already ignoring. Instead, just push a new level, with a value of 1, to keep ignoring. Tue Mar 12 00:16:52 1991 Roland McGrath (roland at geech.ai.mit.edu) * Version 3.59.3. Mon Mar 11 23:56:57 1991 Roland McGrath (roland at geech.ai.mit.edu) * job.c (construct_command_argv_internal): Quote backslashes when building the shell -c line. Fri Mar 8 01:40:18 1991 Roland McGrath (roland at geech.ai.mit.edu) * job.c (exec_command): Call user_access rather than setgid(getgid()). * misc.c (remove_comments): Renamed from collapse_line; took out collapse_continuations call. * make.h: Change decl. * read.c (read_makefile): Collapse continuations on the line buffer immediately after reading it. Call remove_comments rather than collapse_line (which is now defunct). Thu Feb 21 18:06:51 1991 Roland McGrath (mcgrath at cygint.cygnus.com) * misc.c (user_access, make_access): New fns to toggle btwn permissions for user data (files and spawning children), and permissions for make (for taking the load average, mostly). * make.h: Declare them. * job.c (start_job): Call make_access before wait_to_start_job, and user_access after. * main.c (main): Call user_access before doing much. Mon Feb 3 15:02:03 1991 Roland McGrath (roland at albert.ai.mit.edu) * Version 3.59.2. Tue Jan 29 20:30:50 1991 Roland McGrath (roland at cygint.cygnus.com) * read.c (read_all_makefiles): Use allocated_variable_expand to expand `$(MAKEFILES)', since the results are used across calls to read_makefile, which could clobber them. Wed Jan 23 00:24:10 1991 Roland McGrath (roland at cygint.cygnus.com) * main.c (main): Call install_default_implicit_rules after reading makefiles, not before. * default.c (install_default_implicit_rules): If a suffix-rule file entry has cmds, don't give it any from default_suffix_rules. Fri Jan 17 17:39:49 1991 Roland McGrath (roland at albert.ai.mit.edu) * arscan.c: Added support for AIX archives. * remake.c: Don't include ar.h. * main.c: Removed unused atol decl. * arscan.c (ar_scan): Declare arg FUNCTION to return long int. * ar.c (ar_touch): Don't perror for an invalid archive. * make.h: Declare lseek as long int. * job.c [hpux]: Define getdtablesize a la USG. Sun Jan 12 21:08:34 1991 Roland McGrath (roland at albert.ai.mit.edu) * Version 3.59.1. Fri Jan 10 03:48:08 1991 Roland McGrath (roland at albert.ai.mit.edu) * job.c (search_path): Take new arg, place to put full pathname (rather than mallocing it). (exec_command): Pass it, using auto storage. * main.c (print_version): Updated copyright years. Wed Jan 8 19:46:19 1991 Roland McGrath (roland at albert.ai.mit.edu) * job.c [_POSIX_SOURCE]: Just #include , and define macro WAIT_NOHANG in terms of waitpid. [!_POSIX_SOURCE && (HAVE_SYS_WAIT || !USG)]: Don't #include (make.h does). Define macro WAIT_NOHANG in terms of wait3. (child_handler): #ifdef on WAIT_NOHANG, not HAVE_SYS_WAIT || !USG. Use WAIT_NOHANG macro instead of wait3. * file.h (struct file.command_state): Remove unused elt. Wed Dec 26 18:10:26 1990 Roland McGrath (roland at albert.ai.mit.edu) * commands.c (set_file_variables): If FILE got its commands from .DEFAULT, make $< == $@ (4.3 BSD/POSIX.2d11 compat). Mon Dec 24 17:36:27 1990 Roland McGrath (roland at albert.ai.mit.edu) * default.c (default_variables): Rename 2nd LINK.s defn to LINK.S. Fri Dec 14 15:05:25 1990 Roland McGrath (roland at albert.ai.mit.edu) * vpath.c (selective_vpath_search): Check for makefile-mentioned before checking for actual existence. The old order loses if the containing directory doesn't exist (but a rule might make it). * make.h [__GNUC__]: Don't #define alloca if already #define'd. * rule.c (convert_to_pattern): Don't look at the target constructed for the empty rule when making the null-suffix rule. Construct it over again, since the former may have been freed already. Thu Dec 13 17:21:03 1990 Roland McGrath (roland at churchy.ai.mit.edu) * make.h [__GNU_LIBRARY__]: Include to get random fn decls. Wed Dec 12 17:12:59 1990 Roland McGrath (roland at churchy.ai.mit.edu) * make.h, arscan.c, glob.c: Only include #ifdef USG. * variable.c (define_variable_in_set): Replace env_overrides check that wasn't really redundant (undoing Sep 28 change). Add comment saying why this check is necessary. * job.c, main.c [DGUX]: Needs siglist like USG. Mon Dec 11 01:19:29 1990 Roland McGrath (roland at albert.ai.mit.edu) * default.c [M_XENIX]: For rules that are different for Xenix, use the generic Unix version #ifdef __GNUC__. * main.c [M_XENIX]: Use USGr3-style setvbuf call. * read.c (find_percent): Do backslash folding correctly, not leaving extra crud on the end of the string. Sun Dec 10 21:48:36 1990 Roland McGrath (roland at albert.ai.mit.edu) * job.c: Don't declare wait3 if it's #defined. * GNUmakefile, compatMakefile, make.texinfo: Change make-info to make.info. Thu Dec 7 21:20:01 1990 Roland McGrath (roland at churchy.ai.mit.edu) * make.h [STDC_HEADERS || __GNU_LIBRARY__ || _POSIX_SOURCE]: Use ANSI and names for str/mem functions. Use to declare misc fns rather than explicit decls. [_POSIX_SOURCE]: Don't declare kill ( will). Include before because some braindead nonconformant 1003.1 implementation needs it. * misc.c: Don't declare malloc, realloc. Do it in make.h. * arscan.c, glob.c: Use sequence for string fns from make.h verbatim. * make.h (S_ISDIR, S_ISREG): Declare if necessary. * commands.c (delete_child_targets), job.c (search_path), read.c (construct_include_path): Use S_ISfoo(m) instead of (m & S_IFMT) == S_IFfoo. * dir.c, glob.c [_POSIX_SOURCE]: Use dirent. Wed Nov 29 22:53:32 1990 Roland McGrath (roland at geech.ai.mit.edu) * Version 3.59. Tue Nov 28 16:00:04 1990 Roland McGrath (roland at churchy.ai.mit.edu) * arscan.c (ar_name_equal) [APOLLO]: Don't do `.o' hacking. On Apollos the full file name is elsewhere, and there is no length restriction (or so I'm told). Thu Nov 23 17:33:11 1990 Roland McGrath (roland at albert.ai.mit.edu) * load.c [hp300 && BSD] (LDAV_CVT): Define for this system. Tue Nov 21 07:58:40 1990 Roland McGrath (roland at albert.ai.mit.edu) * read.c (record_files): Fix trivial bug with deciding to free storage for a file name. Thu Nov 16 06:21:38 1990 Roland McGrath (roland at geech.ai.mit.edu) * compatMakefile ($(bindir)/make): Install it setgid kmem. Thu Nov 1 16:12:55 1990 Roland McGrath (roland at churchy.ai.mit.edu) * GNUmakefile (make-*.tar.Z): Use `h' option to tar (dereference symlinks), to grab texinfo.tex from wherever it lives. Tue Oct 30 16:15:20 1990 Roland McGrath (roland at churchy.ai.mit.edu) * Version 3.58.13. Fri Oct 26 14:33:34 1990 Roland McGrath (roland at churchy.ai.mit.edu) * GNUmakefile: make-*.tar.Z: Include texinfo.tex. Tue Oct 23 19:34:33 1990 Roland McGrath (roland at churchy.ai.mit.edu) * main.c (define_makeflags): When there are no flags to write, make sure the array has two leading nulls, since `MAKEFLAGS' is defined from &flags[1]. * main.c (default_keep_going_flag): New variable (constant one). (command_switches: -k, -S): Use above for default value. (define_makeflags): Only write flag/flag_off switches if they are on, and either there is no default value, or they are not the default. Mon Oct 22 16:14:44 1990 Roland McGrath (roland at churchy.ai.mit.edu) * main.c (struct command_switch): New member `no_makefile'. (command_switches: -n, -q, -t): Set no_makefile == 1. (define_makeflags): Take new arg MAKEFILE: if nonzero, don't use options whose `no_makefile' flags are set. (main): Call define_makeflags with MAKEFILE==1 before remaking makefiles, and again with MAKEFILE==0 before remaking goals. Tue Oct 2 17:16:45 1990 Roland McGrath (roland at geech.ai.mit.edu) * Version 3.58.12. Mon Oct 1 15:43:23 1990 Roland McGrath (roland at churchy.ai.mit.edu) * arscan.c [HPUX]: Use PORTAR==1 format. Sat Sep 29 16:38:05 1990 Roland McGrath (roland at churchy.ai.mit.edu) * make.h, remake.c, arscan.c: Don't declare `open'. Fri Sep 28 04:46:23 1990 Roland McGrath (roland at churchy.ai.mit.edu) * variable.c (define_variable_in_set): Remove redundant -e check. Wed Sep 26 00:28:59 1990 Roland McGrath (roland at geech.ai.mit.edu) * job.c (start_job): Set RECURSIVE from the right elt of CHILD->file->cmds->lines_recurse. * commands.c (chop_commands): Don't botch the line count for allocating CMDS->lines_recurse. * Version 3.58.11. * job.c (start_job): Don't always increment CHILD->command_line! Only do it when CHILD->command_ptr has run out! (Dumb bug. Sigh.) Thu Sep 20 02:18:51 1990 Roland McGrath (roland at geech.ai.mit.edu) * GNUmakefile [ARCH]: Give explicit rule for remote.{c,dep} to use variable `REMOTE' for more flags. ($(prog)): Link in $(LOADLIBES). Wed Sep 19 02:30:36 1990 Roland McGrath (roland at churchy.ai.mit.edu) * commands.h (struct commands): New member `ncommand_lines', the number of elts in `command_lines' et al. * commands.c (chop_commands): Set `ncommand_lines' elt of CMDS, and don't put a nil pointer at the end of `command_lines'. * job.h (struct child): New member `command_lines' to hold variable-expanded command lines. * job.c (new_job): Store expanded command lines in `command_lines' member of new child. Don't clobber FILE->cmds. (start_job): Use CHILD->command_lines in place of CHILD->file->cmds->command_lines. * variable.h, variable.c, job.c, expand.c: Undo yesterday's change, which is no longer necessary since we have cleverly avoided the issue. * job.c (start_job): Don't variable-expand each command line. (new_job): Do them all here, storing the expansions in the array. Tue Sep 18 01:23:13 1990 Roland McGrath (roland at churchy.ai.mit.edu) * variable.h (struct variable): Remove `expanding' member. * variable.c (define_variable_in_set): Don't initialize it. * expand.c (struct variable_expanding): New type, a linked list containing `struct variable' pointers. (variables_expanding): New variable, the chain of variables currently being expanded. (recursively_expand): Don't test and set `expanding' member. Instead, run through the `variables_expanding' chain looking for a link referring to V to find self-reference. Add a new link to the chain, describing V, before recursive expansion, and pop it off afterward. * job.c (child_handler): Save `variables_expanding' and clear it before calling start_job, and restore it afterward. This avoids major lossage when the SIGCHLD comes in the middle of variable expansion. Mon Sep 17 14:46:26 1990 Roland McGrath (roland at geech.ai.mit.edu) * job.c, commands.c: Don't define sigmask. * make.h: Put it here instead. * variable.c (target_environment): If `.NOEXPORT' was specified as a target, only export command-line and environment variables, and file-origin variables that were in the original environment. * make.man: Add missing ?roff control for `-I' option description. Thu Sep 13 14:10:02 1990 Roland McGrath (roland at churchy.ai.mit.edu) * load.c [UMAX]: Move #include to [not UMAX_43]. Wed Sep 12 15:10:15 1990 Roland McGrath (roland at churchy.ai.mit.edu) * expand.c (recursively_expand): Don't use `reading_filename' and `reading_lineno_ptr' if they're nil. Thu Aug 30 17:32:50 1990 Roland McGrath (roland at geech) * Version 3.58.10. Tue Aug 28 04:06:29 1990 Roland McGrath (roland at churchy.ai.mit.edu) * job.c [USG] (unknown_children_possible): New variable, set nonzero when it's possible for children not in the `children' chain to die. (block_signals) [USG]: Set it. (unblock_signals) [USG]: Clear it. (child_handler) [USG]: Don't complain about unknown children if `unknown_children_possible' is set. * read.c (do_define): Make sure there's enough space for the newline, so we don't write off the end of allocated space. * arscan.c (ar_name_equal): Fixed to work when MEM is AR_NAMELEN-1 but NAME is not the same length. Sat Aug 25 16:17:14 1990 Roland McGrath (roland at geech) * job.c (construct_command_argv_internal): Use a static char array for a constant, since old C has no auto aggregate initializers. Thu Aug 23 16:11:03 1990 Roland McGrath (roland at churchy.ai.mit.edu) * job.c (search_path): If PATH is nil or "" use a default path. Wed Aug 22 01:05:32 1990 Roland McGrath (roland at churchy.ai.mit.edu) * Version 3.58.9. * job.c (exec_command): Don't take PATH and SHELL args. Get them from ENVP. (child_execute_job): Don't take FILE arg, and don't pass path and shell to exec_command. (start_job): Don't pass FILE arg to child_execute_job. * function.c (expand_function: `shell'): Ditto. * main.c (main): Don't pass path and shell to exec_command. Fri Aug 17 23:17:27 1990 Roland McGrath (roland at geech) * job.c (construct_command_argv_internal): New fn broken out of construct_command_argv. Takes strings SHELL and IFS instead of doing variable expansion for them. Recurse to make an argv for SHELL, passing SHELL==0. When SHELL==0, don't recurse for shell argv; make a simple one using /bin/sh. (construct_command_argv): Do the variable expansions and call above. Thu Aug 16 19:03:14 1990 Roland McGrath (roland at geech) * read.c (multi_glob): For ~USER/FILE, if USER isn't found, don't change the file name at all. Tue Aug 7 18:33:28 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * function.c (expand_function: `suffix'/`notdir'): Don't kill the last space if we never wrote one. * function.c (expand_function: `suffix'): Retain the dot, like the documentation says. Mon Aug 6 14:35:06 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.58.8. * main.c (decode_switches): For positive_int and floating cases, move SW past the arg (and don't set it to ""), so another switch can follow. Fri Aug 3 00:43:15 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * job.c (child_execute_job): Use unblock_signals instead of push_signals_blocked_p (0). * main.c (fatal_signal_mask): New variable, mask of signals caught with fatal_error_signal. (main): Set it. * job.c ({block,unblock}_children): Renamed to {block,unblock}_signals. Block/unblock both child signal and signals in fatal_signal_mask. (children_blocked_p_{stack,max,depth}, {push,pop}_children_blocked_p): Renamed from children to signals. Use {block,unblock}_signals instead of {block,unblock}_children. * commands.c (fatal_error_signal), job.c (wait_for_children, new_job, child_execute_job, main, log_working_directory), function.c (expand_function: `shell'), job.h: Rename {push,pop}_children_blocked_p to {push,pop}_signals_blocked_p. * job.c (child_handler): Call {block,unblock}_signals instead of just {block,unblock}_remote_children. We need to block the fatal signals. Thu Aug 2 22:41:06 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * main.c, function.c: Fixed typos in comments. * file.c (print_file_data_base): Fix computation of avg files/bucket. Tue Jul 31 22:11:14 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.58.7. Wed Jul 25 16:32:38 1990 Roland McGrath (mcgrath at tully.Berkeley.EDU) * arscan.c (ar_name_equal): Fixed to really do it right. (ar_member_pos): Fixed order of args. * ar.c (ar_member_date_1): Ditto. Fri Jul 20 15:30:26 1990 Roland McGrath (mcgrath at tully.Berkeley.EDU) * arscan.c (ar_name_equal): Rewritten. Accounts for a possible trailing slash in MEM. * remake.c (f_mtime): Keep track of whether ARNAME is used and free it if not. Also free MEMNAME. * ar.c (ar_member_date, ar_touch): Ditto. * arscan.c (arscan) [HPUX or hpux]: Treat same as USGr3 PORTAR==1. * make.h: If NSIG is not defined, but _NSIG is, #define NSIG _NSIG. * compatMakefile: Don't use $* in explicit rules. * default.c (default_variables: "PREPROCESS.S"): Include $(CPPFLAGS). * remake.c (f_mtime): If FILE is an ar ref, get the member modtime. * function.c (string_glob): Terminate the string properly when it's empty. Wed Jul 18 11:26:56 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.58.6. * commands.c (set_file_variables): Fixed computation for ^F/?F elt len. Sat Jul 14 13:41:24 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * job.c (construct_command_argv): Always use allocated_variable_expand_for_file instead of variable_expand_for_file because we might be called from inside a variable expansion (for the `shell' function). * function.c (expand_function: `shell'): Free the arglist's storage correctly. construct_command_argv only allocates ARGV and ARGV[0]. * job.c (children_blocked_p_idx): Renamed to children_blocked_p_depth. (push_children_blocked_p, pop_children_blocked_p): Use ..._depth instead of ..._idx, and do it right! Wed Jul 11 15:35:43 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.h (SIGNAL): New macro to replace `signal' calls. Does arg and ret value casts to (void *) #ifdef __STDC__ to avoid conflicts btwn ANSI and BSD `signal' and handler types. * main.c (main), job.c (child_handler): Use it. Fri Jul 6 00:00:38 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * ar.c (ar_member_date, ar_touch): Pass 2nd arg to f_mtime. * read.c (read_makefile): Search the include path for MAKEFILES variable makefiles (TYPE == 1), like it says in the manual. * file.h (struct file), main.c (struct command_switch): Remove trailing commas from enums. * commands.c (execute_file_commands): Remove unused variables. * commands.h: Declare chop_commands. * make.h: Declare uniquize_deps. * main.c (main): Remove unused variable. (decode_switches): Remove unused label. * remake.c: Include "ar.h" for ar_parse_name decl. * implicit.c (try_implicit_rule): Remove unused variable. * function.c (expand_function: `shell'): Declare fork, pipe. * ar.c: Declare ar_name_equal. * GNUmakefile: If using gcc, add warning flags to CFLAGS. * remake.c: Remove decl of ar_member_date, since it's done in make.h. * remake.c (f_mtime): For ar refs, allow the archive to be found via VPATH search if we're searching, and change the ar ref accordingly. * ar.c (ar_parse_name): New global fn to parse archive-member references into the archive and member names. (ar_member_date, ar_touch): Use it. * make.h: Declare it. * remake.c (f_mtime): After doing rename_file, do check_renamed instead of assuming rename_file will always set FILE->renamed (which it won't). * vpath.c (selective_vpath_search): Only accept prospective files that don't actually exist yet are mentioned in a makefile if the file we are searching for isn't a target. Wed Jul 4 04:11:55 1990 Roland McGrath (mcgrath at helen.Berkeley.EDU) * remake.c (update_goal_chain): Do check_renamed after calling file_mtime. (check_dep): Ditto after update_file. * file.c (rename_file): Prettied up long message for merging cmds. * remake.c (update_file_1): Get each dep file's modtime, and allow for it being renamed, before checking for a circular dep, since a renaming may have introduced one. Tue Jul 3 18:15:01 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * ar.c (ar_touch): Don't free ARNAME since enter_file holds onto the storage. * function.c (string_glob): Don't leave a trailing space. * read.c (do_define): Allow leading whitespace before `endef'. Mon Jul 2 14:10:16 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * implicit.c (pattern_search): No longer take NAME arg. Instead take ARCHIVE flag. If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)"; rule for "(MEMBER)" is searched for, and LASTSLASH is set to nil. Since NAME was only non-nil when it was the archive member name passed by try_implicit_rule, this change easily allows turning off LASTSLASH checking for archive members without excessive kludgery. (try_implicit_rule): Pass ARCHIVE flag instead of file name. * Version 3.58.5. * commands./c (set_file_variables): Don't kill last char of $(^D) elts. Sat Jun 30 00:53:38 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * ar.c (ar_member_date): Don't free ARNAME since enter_file holds onto the storage. * arscan.c (ar_scan) [sun386 && PORTAR == 1]: Treat like USGr3. Wed Jun 27 14:38:49 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * main.c (main): Put a newline on the debugging message when deciding not to remake a makefile to avoid a possible loop. Only decide not to remake makefiles that have commands (as well as being targets and having no deps). Fri Jun 22 12:35:37 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * default.c (default_variables): Define `LINK.s' and `LINK.S'. (default_suffix_rules): Define .S.o rule. * job.c (construct_command_argv): If we decide to go the slow route, free all storage for the chopped args. (start_job): Free the argument list's storage correctly. construct_command_argv only allocates ARGV and ARGV[0]. Tue Jun 19 18:27:43 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.58.4. Fri Jun 15 21:12:10 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * glob.c: New version from ai-lab which doesn't do [^abc]. Thu Jun 7 00:30:46 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * dir.c: Copied dirent vs direct et al mess from glob.c. * glob.c: Replaced with updated version from djm. * glob.c: Check macro DIRENT instead of _POSIX_SOURCE for . __GNU_LIBRARY__ implies DIRENT and STDC_HEADERS. Thu May 31 22:19:49 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * vpath.c (vpath_search): Don't stop the loop if a pattern matches but the search fails. All matching patterns have their paths searched (like it says in the manual). * make.texinfo (Rules: Directory Search: Selective Search): Say that multiple `vpath' directives with the same pattern DO accumulate, not supersede earlier ones. * vpath.c (print_vpath_data_base): Increment the count of vpaths on each loop iteration, rather than letting it stay zero. * Version 3.58.3. * job.c (block_children, unblock_children): Made static. (push_children_blocked_p, pop_children_blocked_p): New functions to push and pop whether children are blocked or not. * job.h: Declare push_children_blocked_p, pop_children_blocked_p and not block_children, unblock_children. * commands.c (fatal_error_signal), job.c (wait_for_children, new_job, child_execute_job), main.c (main, log_working_directory): Use sequences of push_children_blocked_p (1) and pop_children_blocked_p () instead of explicitly blocking and unblocking children. * function.c (expand_function: `shell'): Don't unblock children. The push-pop sequence in wait_for_children makes it unnecessary. Tue May 29 21:30:00 1990 Roland McGrath (mcgrath at helen.Berkeley.EDU) * read.c (do_define): Don't include the last newline in the definition. * function.c (expand_function: `shell'): Call construct_command_argv before forking and don't fork if it returns nil. Free the argument list's storage before finishing. * job.c (start_job): Free the storage for the child's argument list in the parent side of the fork after the child has been spawned. * job.c (start_job): If construct_command_argv returns nil, go to the next command line. * job.c (construct_command_argv): Use the shell if the command contains an unterminated quote. Wed May 23 19:54:10 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.58.2. * read.c (read_makefile): Parse "override define" correctly. Thu May 17 15:25:58 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * arscan.c [USG]: Don't declare memcpy and memcmp. should do this anyway (and lack of declarations is harmless). * remote-customs.c: Renamed to remote-cstms.c for System V. * remote.c [CUSTOMS]: Changed accordingly. Sun May 13 14:38:39 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * GNUmakefile: Use same cmds for doc tar.Z as for dist tar.Z (so the contents go in make-N.NN). Thu Apr 26 19:33:25 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.58.1. Wed Apr 25 20:27:52 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * job.c (init_siglist): Don't do SIGUSR1 and SIGUSR2 if they are the same as SIGIO and SIGURG (true on Cray). Tue Apr 24 20:26:41 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * arscan.c (ar_scan): Do behavior for PORTAR == 1 and USGr3 also #ifdef APOLLO. Wed Apr 11 10:00:39 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * job.c (exec_command): Set the effective GID to the real GID. Somehow this code got lost. * implicit.c (pattern_search): Use the right index variable when seeing if we need to expand FILE->also_make. Sun Mar 4 09:18:58 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.58.0. * remake.c (remake_file): Treat non-targets without commands under -t the same as anything else without commands. Sat Feb 24 17:46:04 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * default.c (default_variables: PREPROCESS.S): Removed $< from defn. * main.c (main): Ignore arguments that are the empty string, rather than feeding them to enter_file and barfing therein. Wed Feb 14 16:28:37 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * main.c (main): Call construct_include_path after doing chdirs. Thu Feb 8 13:43:44 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.58. Sat Feb 3 22:06:55 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.57.7. * make.texinfo (Implicit: Catalogue of Rules): For RCS, noted that working files are never overwritten by the default rule. Thu Feb 1 17:27:54 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * rule.c (count_implicit_rule_limits): Redid loop control to not run twice on freed rules. * GNUmakefile: Made `.dep' files be architecture-specific too. * main.c (main, log_working_directory) [USG]: Block children around calls to `getwd' (actually `getcwd' on USG), because that function sometimes spawns a child running /bin/pwd on USG. Tue Jan 30 14:02:50 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * function.c (subst_expand): Pay attention to SUFFIX_ONLY, putz. Wed Jan 24 21:03:29 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * make.man: Fixed repeated word. * make.texinfo (Missing): Reworded a buggy sentence. Mon Jan 22 12:39:22 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * main.c (print_version): Added 1990 to copyright notice. * Version 3.57.6. Sat Jan 20 11:52:01 1990 Roland McGrath (mcgrath at homer.Berkeley.EDU) * file.c (rename_file): Don't free the storage for the old name, since it might not have been malloc'd. * job.c (construct_command_argv): Call allocated_variable_expand_for_file instead of variable_expand_for_file to expand `$(SHELL)'. * make.texinfo (Bugs): Change address from roland@wheaties.ai.mit.edu to roland@prep.ai.mit.edu. Tue Jan 16 19:22:33 1990 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.57.5. Sun Jan 14 16:48:01 1990 Roland McGrath (mcgrath at helen.Berkeley.EDU) * job.c (start_job): Only call wait_to_start_job for the first command line in each sequence. Thu Jan 4 14:27:20 1990 Roland McGrath (mcgrath at helen.Berkeley.EDU) * load.c [LDAV_BASED] (wait_to_start_job): Loop while job_slots_used > 0, not > 1. * job.c (search_path): Don't return a pointer to local storage. Allocate data space for the pathname instead. * function.c (expand_function: `shell'): Don't write garbage if the child wrote no output. Wed Jan 3 15:28:30 1990 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.57.4. * file.h (struct file): New member `renamed', a `struct file *' that is the place this file has been renamed to (or nil). (check_renamed): Macro to check for a file having been renamed. Dereferences the renaming and sets the given variable. * file.c (rename_file): Completely rewritten. Renames in place if possible, or moves FILE to a different hash bucket if there is no existing file with the new name. If there is an existing file with the new name, FILE is merged into it and FILE->renamed is set to point to it. * variable.c (merge_variable_sets): New fn to merge two variable sets. (merge_variable_set_lists): New fn to merge two variable set lists. * variable.h: Declare merge_variable_set_lists. * remake.c (update_file_1, check_dep): Run `check_renamed' after calling file_mtime, check_dep. (update_file): Same after update_file_1. (update_goal_chain, update_file_1, check_dep): Same after update_file. * read.c (uniquize_deps): New fn, broken out of record_files, to remove duplicate deps from a chain. (record_files): Use it. * implicit.c (pattern_search): Use uniquize_deps. * file.h (file_mtime_1): New macro, like file_mtime, but take second arg, passed to f_mtime. (file_mtime): Implement as file_mtime_1 (file, 1). (file_mtime_no_search): New macro: file_mtime (file, 0). * remake.c (f_mtime): Take new arg SEARCH. Only do VPATH and `-lNAME' searching if it is nonzero. * main.c (main): Use file_mtime_no_search for makefiles. * remake.c (update_goal_chain): Use file_mtime_no_search if MAKEFILES. * main.c (printed_version): New variable, init'd to zero. (print_version): Set it to nonzero before returning. (die): If -v and !printed_version, call print_version before clean up and death. * main.c (log_working_directory): Keep track of whether or not the "Entering" message has been printed, and return without printing the "Leaving" message if not. * main.c (decode_switches): Don't complain about missing args before checking for a noarg_value elt in the command_switch structure. Tue Jan 2 15:41:08 1990 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.texinfo (Commands: Recursion: Options/Recursion): Document special case of -j. * make.texinfo, main.c, job.c: Changed copyright notices to include 1990. * make.texinfo (Top): Fixed introductory paragraph, which said that `make' itself (instead of the manual) has various chapters. (Variables: Advanced: Substitution Refs): When pxref'ing about `patsubst', use node `Text Functions', not `Functions'. Add an xref about `patsubst' after description of $(var:a%b=c%d). (Functions: Syntax of Functions): Explain why mixing delimiters in function/var refs is unwise. Clarify fn arg evaluation order. (Options): Reworded sentence about `-e'. (Implicit: Implicit Variables): Don't say `RM' is unused. Say the dflt values for the flag vars is empty unless otherwise noted, since some have defaults. (Implicit: Pattern Rules: Pattern Examples): Clarified use of $< and $@ in first example. (Implicit: Last Resort): Don't say the .DEFAULT example creates files "silently". It's automatic, but not silent. (Implicit: Search Algorithm): Fixed confusing ungrammatical sentence for item 5.1. (Archives: Archive Update): Added missing `next' pointer. (Archives: Archive Symbols): Note that GNU `ar' deals with this automatically. * job.c (search_path): New fn, to search for an executable file in a search path (broken out of exec_command). (exec_command): Take fourth arg, the shell program to use (if necessary). Use search_path for the program, and the shell program. Pass args "file args ..." to shell program (with no -c), where FILE is the full pathname of the program (script) to be run. (child_execute_job): Pass shell program to exec_command. * main.c (main): Ditto. * main.c (main): Don't write a message if exec_command returns, because it will never return. Fri Dec 22 16:19:58 1989 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * default.c (default_variables: "LINK.cc"): Use $(C++FLAGS) instead of $(CFLAGS). Wed Dec 20 09:58:48 1989 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * job.c (new_job): If start_job set the child's `command_state' to `cs_finished', call notice_finished_file. Sun Dec 17 19:45:41 1989 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * Version 3.57.3. Wed Dec 13 17:57:12 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * rule.c (convert_to_pattern): Accept files with dependencies as suffix rules. Thu Nov 30 15:47:13 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.57.2. * function.c (expand_function: `shell'): Don't clobber BUFFER and then try to free it. * remake.c (update_file_1): Took code to force remake of nonexistent deps out of #if 0, and changed the test to nonexistent non-intermediate deps. In version 4, I think removing this test completely will implement the new feature that if a: b and b: c and c is newer than a, b need not be remade. Sun Nov 26 16:12:41 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * compatMakefile (load.o, remote.o): Use $*.c instead of explicit file names so that using VPATH works. Tue Nov 21 14:57:18 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.57.1. Fri Nov 10 03:28:40 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remake.c (check_dep): Set *MUST_MAKE_PTR if FILE does not exist after being updated. (The exact opposite test was here before; why???) (update_file_1): Set a dep's `changed' member after updating it if it is phony and has commands (because they will then always be executed). Thu Nov 9 13:47:12 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * load.c [UMAX]: #ifdef UMAX_43 include different headers for the `inq_stats' call. * compatMakefile (LOAD_AVG): Document UMAX_43. * Version 3.57.0. * commands.c (chop_commands): New function to chop commands into lines. * job.c (new_job): Break that code out, and call chop_commands. * remake.c (remake_file): Call chop_commands before looking at FILE->cmds->any_recurse. * make.texinfo (Running: Goals): Don't say that the default target won't be taken from an included makefile. * remake.c (update_file_1): #if 0 out setting MUST_MAKE if a dep doesn't exist. Fri Nov 3 15:53:03 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.57. * variable.c (try_variable_definition): Don't calculate useless value. * main.c (define_makeflags): Fixed -j propagation. * commands.c (execute_file_commands): Removed unused variable. Sun Oct 29 11:11:15 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (execute_file_commands): If the commands are empty, call notice_finished_file before returning. Sat Oct 28 23:06:32 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remake.c (update_file_1): Don't always update a target that has no deps. Only do this for double-colon targets. Wed Oct 25 16:36:16 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * main.c (main) [hpux]: hpux == HPUX. * compatMakefile (defines): Document that HPUX should be defined. Tue Oct 24 19:19:48 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.8. * job.c (exec_command): Fixed what mode bits are checked. * remake.c (update_file_1): "No cmds and no deps actually changed" loses if ! FILE->is_target. * make.texinfo (Variables: Setting): Don't say that spaces after a variable definition are ignored (since they aren't). Mon Oct 23 14:34:23 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.7. * remake.c (update_file_1): If, after being updated, any dependency does not exist, remake the target. * remake.c (update_file_1): Always update if FILE has commands but no deps. * commands.c (execute_file_commands): If we return early because there are no commands, set FILE->updated. Thu Oct 19 18:47:37 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * arscan.c (ar_scan) [M_XENIX]: Don't run atoi or atol on the `struct ar_hdr' members that are int or long int on Xenix. Sat Oct 14 10:43:03 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * arscan.c (ar_scan): Cosmetic clean ups. (ar_name_equal): New function to compare names, handling truncated member names and special `.o' truncation. (ar_member_pos): Use ar_name_equal. * ar.c (ar_member_date_1): Use ar_name_equal. * Version 3.56.6. * file.h (struct file): Made `update_status' a `short int', and moved it before `command_state' so the bitfields can be packed better. * remake.c (files_remade): Made global. (notice_finished_file): Don't increment files_remade. * job.c (new_job): Do. * job.c (start_job): Don't return a value. Always set CHILD->file->command_state to either cs_running or cs_finished. (new_job, child_handler): Don't expect start_job to return a value. Instead, look at the file's command_state. * commands.c (chop_commands): Merged into job.c (new_job). * commands.h: Don't declare chop_commands. * job.c (start_job): Made static. (new_job): New function to create a `struct child' and call start_job. (free_child): New function to free a `struct child'. (child_handler, new_job): Call it. * job.h: Don't declare start_job. Do declare new_job. * commands.c (execute_file_commands): Call new_job. * commands.c (execute_file_commands): Don't set FILE->update_status if start_job fails. * function.c (expand_function): Don't use `reading_filename' and `reading_lineno_ptr' if they're nil. Fri Oct 13 18:16:00 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * read.c (find_semicolon): New function to look for an unquoted ; not preceded by an unquoted # in a string. (read_makefile): Call it before expanding the line. If it finds a ;, cut the line short there before expanding it. If not, call it again after expanding. * commands.c (execute_file_commands): Don't check FILE->command_state. We won't get called unless it's cs_not_started. * read.c (read_makefile): Call collapse_line on the variable-expanded rule line after checking for ; and #. * job.c (start_job): When there are no more commands, always return 0. * commands.c (execute_file_commands): Don't put the new child in the `children' chain unless FILE->command_state is cs_running. * read.c (read_makefile): Rewrote ;-handling to only do it once (why did I do it twice??) and to check for a # before the ;. * job.c (start_job): Set CHILD->file->update_status to 0 when we run out of commands. Set it to 1 before returning failure. (child_handler): Don't set C->file->update_status to 0 when start_job returns success and commands are not running. * read.c (read_makefile): If there is a # before the ; for commands, forget the ; and commands. Thu Oct 12 15:48:16 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * job.c (child_execute_job): Pass -c to the shell. Wed Oct 11 18:41:10 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.5. * main.c (define_makeflags): Cleaned up to keep better track of dashes written, etc. * function.c (expand_function: `shell'): When converting newlines to spaces in output, search with `index' calls rather than a simple loop. * main.c (main): Make sure stdout is line-buffered. * main.c (decode_switches): Always check for missing switch arg. Mon Oct 9 17:17:23 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.4. Sat Oct 7 00:32:25 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (set_file_variables): #ifdef NO_ARCHIVES, still set $@ and $%. * commands.c (set_file_variables): Include a trailing slash in the directory variables (@D, etc.). * job.c (child_handler): Call notice_finished_file after changing a child's state to `cs_finished'. * remake.c (update_file_1): Don't call notice_finished_file if FILE->command_state == cs_finished. Wed Oct 4 16:09:33 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.3. Tue Oct 3 21:09:51 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * read.c (read_all_makefiles): When setting elements of MAKEFILES from the contents of read_makefiles, make sure we're using the right element. * dir.c, glob.c [USGr3 || DIRENT]: Don't define d_ino as d_fileno. * Version 3.56.2. * remake.c (update_file_1): Return zero after calling remake_file if FILE->command_state != cs_finished. Test update_status thoroughly. * commands.c (execute_file_commands): Don't call notice_finished_file. * remake.c (remake_file): Return immediately after calling execute_file_commands. Sat Sep 30 14:57:05 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56.1 (alpha). * file.h (struct file): Made `update_status' not be a bitfield, since some broken compilers don't handle it right. * function.c (expand_function: `join'): Don't clobber the pointers and then try to free them. * job.c (exec_command): Fixed & vs = precedence problem. Thu Sep 28 17:29:56 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remake.c (update_file_1): Fixed typo in debugging output. * remake.c (library_file_mtime): Search for /usr/local/lib/libLIB.a after /usr/lib/libLIB.a. Tue Sep 26 16:07:58 1989 Roland McGrath (mcgrath at helen.Berkeley.EDU) * read.c (conditional_line): For `ifeq (a, b)', swallow space after the comma. Sun Sep 24 13:25:32 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * function.c (patsubst_function): If BY_WORD and the match is not a full word, update the text pointer correctly. * function.c (expand_function: `word'): Don't lose track of the second arg's expansion and free something else instead. Fri Sep 22 16:15:29 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.56. Thu Sep 21 14:28:42 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * main.c (main): Make an array of the mtimes of the makefiles before updating them, and compare their file_mtimes against this later. Don't re-exec if a makefile was successfully updated but didn't change. If a makefile failed to be remade and no longer exists, die. If a makefile failed to be remade, but changed anyway, re-exec. If a makefile failed to be remade, but is unchanged, continue on. Wed Sep 20 18:02:07 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.55.6. * implicit.c (pattern_search): Maintain an array CHECK_LASTSLASH of the CHECK_LASTSLASH flag values used to match each member of TRYRULES. When making FILE->stem, if CHECKED_LASTSLASH[FOUNDRULE], prepend the part of FILENAME before LASTSLASH. Tue Sep 19 17:44:08 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * dir.c (dir_file_exists_p): Check for FILENAME being nil before checking for it being "". * main.c (define_makeflags): Fixed test for whether a flag/flag_off option was non-default. Also changed to generate a string that Unix Make will grok (except for FP/int values and new flags). * job.c (child_execute_job): Don't use the shell's -c option. Also fixed an off-by-one bug in the ARGV -> shell arg list copying. Mon Sep 18 15:17:31 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.55.5. * read.c (parse_file_seq): Check the beginning of the file name for a `./', not the two chars after the end of the name (Q rather than P). * job.c (child_execute_job): Include all of ARGV in the arg list for the shell. * main.c (define_makeflags): Don't include floating and positive_int options in !PF. * job.c (exec_command): Set the effective gid to the real gid before execing. * job.c (child_execute_job): Don't clobber the arg list when execing the shell. Sun Sep 17 15:27:19 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * main.c (define_makeflags): Moved all the checking inside the switch. * load.c [LDAV_BASED] (load_average): When we can't get the load average, return zero instead of running off the end. * file.c: Include variables.h. * job.c: Declare dup2 and {block,unblock}_remote_children. * file.h: Declare f_mtime. * job.c: Don't declare construct_command_argv, since job.h does. * function.c, main.c, load.c, remake.c: Include job.h. * load.c [LDAV_BASED] (load_average): Declare nlist. * variable.h: Declare print_file_variables. * job.c [!USG]: Don't declare sigsetmask. [!USG]: Declare getdtablesize. Don't declare load_average. Do declare wait_to_start_job. Declare vfork, gete[gu]id, execve. * commands.c: Declare remote_kill, getpid. * make.h: Declare kill, exit, sigblock, pipe, close, ctime, open, lseek, read. * make.h [not USG]: Declare sigsetmask. * job.h: Declare wait_for_children and {block,unblock}_children. * dir.c (dir_file_exists_p): If FILENAME is nil, read in the whole directory. (find_directory): When we want to read in the whole directory, call dir_file_exists_p with nil instead of "". * file.h (struct file), job.h (struct child), variable.h (struct variable): Use bitfields for flags. * make.h (ENUM_BITFIELD): If GCC or #ifdef ENUM_BITFIELDS, define as :BITS, else empty. * compatMakefile (defines): Document ENUM_BITFIELDS. Sat Sep 16 12:38:58 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.55.4 (alpha). * GNUmakefile (dist): Depend on default and doc. * load.c [LDAV_BASED]: Include rather than ; #ifdef NLIST_NAME_UNION, use n_un.n_name instead of n_name. * compatMakefile (LOAD_AVG): Document NLIST_NAME_UNION. * job.c [USG-ish]: Don't redefine WIF{SIGNALED,EXITED} if they're already defined. Fri Sep 15 13:59:42 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * glob.c, dir.c [USGr3 or DIRENT]: If neither d_ino, nor d_fileno is defined, define d_ino as d_fileno. Thu Sep 14 18:29:38 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * job.c: Don't declare exec_command static. * make.texinfo (Name Index): Changed title to include directives. * Version 3.55.3 (alpha). * make.texinfo (Running: Options): Document -e. * main.c (main): Always give imported environment variables origin `o_env'. * variable.c (define_variable_in_set): Under -e, if ORIGIN, or an existing variable's origin, is `o_env', make it `o_env_override'. * load.c: Use the symbol KERNEL_FILE_NAME instead of KERNEL_FILE. * compatMakefile: Changed the comment for `LOAD_AVG' accordinly. Thu Sep 7 16:46:26 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.55.2 (alpha). * variable.c (print_variable_set), rule.c (print_rule_data_base), file.c (print_file_data_base): If NO_FLOAT is defined, don't use floating-point for printing statistics. * compatMakefile (defines): Document NO_FLOAT. * make.h (HASH): New macro to add the hashing value of one char to a variable.c. * file.c (lookup_file, enter_file, rename_file): Use it. * dir.c (find_directory, dir_file_exists_p, file_impossible_p): Ditto. * variable.c (define_variable_in_set, lookup_variable): Same here. * variable.c, file.c, dir.c: Don't define *_BUCKETS if they are already defined. * compatMakefile (defines): Added comment about defining NO_ARCHIVES. (ARCHIVES, ARCHIVES_SRC): New variables for {ar,arscan}.[oc]. (objs, srcs): Use $(ARCHIVES) and $(ARCHIVES_SRC). * commands.c (set_file_variables), dir.c (file_exists_p), remake.c (touch_file, name_mtime), implicit.c (try_implicit_rule, pattern_search), make.h: If NO_ARCHIVES is #defined, don't do any archive stuff. * commands.c (set_file_variables): Don't kill the last char of directory names in $([@*<%?^]D). Wed Sep 6 15:23:11 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * default.c (default_terminal_rules {%:: %,v}, {%:: RCS/%,v}): Don't run co if the target exists. * glob.c (glob_match): [!xyz], rather than [^xyz], means none of [xyz]. * glob.c: Misc minor cosmetic changes. Tue Sep 5 14:49:56 1989 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * load.c [LDAV_BASED] (load_average): Check for == -1, rather than < 0 to see if lseek fails. On some systems, `avenrun' is at an offset > (2**31)-1, and lseek succeeds, returning a negative value. Mon Sep 4 11:07:58 1989 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * rule.c (new_pattern_rule): Return `int' instead of `void': nonzero if the passed rule was used, zero if not. (install_pattern_rule): Pay attention to the return from new_pattern_rule, and don't set the rule's `terminal' flag or give it commands unless it's used. (create_pattern_rule): Same idea. * dir.c (find_directory): Removed unused variable. * commands.c (execute_file_commands): Removed unused variable. * read.c (record_files): Don't use NAME after freeing it. Sat Sep 2 00:33:19 1989 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * Version 3.55.1 (alpha). * function.c (string_glob): Don't add spaces after file names that aren't added. (Also means don't add spaces without checking the size of the buffer.) * remake.c (update_goal_chain): Don't remove makefiles with cmds and no deps from the chain. * main.c (main): Do it here, before calling update_goal_chain. * remake.c (update_goal_chain): When updating fails, change STATUS even if MAKEFILES is set. Also stop remaking when updating fails if not under -k and MAKEFILES is not set. * remake.c (remake_file, update_file_1, notice_finished_file), commands.c (execute_file_commands), make.h, commands.h: The functions remake_file, notice_finished_file, and execute_file_commands no longer return values, and their callers no longer expect values returned. * remake.c (notice_finished_file): Don't set FILE's modtime to now if it is a non-target with no commands. Fri Sep 1 00:04:39 1989 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * read.c (read_all_makefiles): After freeing each element on MAKEFILES, replace it with the name stored in read_makefiles by read_makefile. * remake.c (update_file_1): Don't decide not to remake if FILE has no cmds and no deps actually changed if FILE doesn't have any deps. * file.c (remove_intermediate): Remove precious files that also have the `dontcare' flag set. * remake.c (update_file_1): Don't always remake if FILE has cmds but no deps; only if FILE is double-colon. (I don't know why this should be done for double-colon targets, but that's what Unix make does.) * load.c [LDAV_BASED] (load_average): Write error messages if the various system calls fail. Keep track of if we've failed before. The first time we fail, write a message saying -l won't be enforced. The first time we succeed after having failed, write a message saying -l will be enforced again. * remake.c [USG]: Don't #include * load.c [generic Unix LDAV_BASED]: #include #ifdef USG, else instead. * job.c [USG && !USGr3 && !HAVE_DUP2]: Remove redundant #include and declaration of `errno'. [...] (dup2): Fixed so it won't always lose. * default.c (default_suffix_rules: .texinfo.dvi): Copy, rather than move, the aux and index files, so the TeX run can use them. * compatMakefile: Remove redundant comment. * load.c [generic Unix LDAV_BASED]: Include instead of , since the `struct nlist' declaration in varies more than the one in . (load_average): Use the `n_un.n_name' field of the `struct nlist', since the declaration uses the union. * main.c (main): For the temporary files made for stdin makefiles, set the `intermediate' and `dontcare' flags. * file.c (remove_intermediates): Don't print any messages for files whose `dontcare' flag is set. (The only files that will be intermediate and `dontcare' will be the temporary files made for stdin makefiles.) * job.c (exec_command): Made global. * job.h: Declare it. * main.c (main): Use exec_command when re-execing. * make.h: Declare environ. * make.c: Don't. * job.c (child_execute_job): New function to perform everything done in the child side of a fork (for a job or `shell' function). (start_job): Call it. * job.h: Declare construct_command_argv and child_execute_job. * function.c (expand_function: `shell'): Use child_execute_job. Thu Aug 31 18:42:51 1989 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * function.c (expand_function: `shell'): Remove a trailing newline instead of turning it into a space. * main.c (main): Do init_siglist #ifdef HAVE_SIGLIST. * job.c [WTERMSIG || (USG && !HAVE_SYS_WAIT)]: Test each W* macro separately and define all those that aren't defined. Sat Aug 26 15:13:21 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * ar.c (ar_name): Return zero for `(foo)'. * Version 3.55. * make.texinfo (Rules: Multiple Targets): Make this node's `next' pointer point to `Static Pattern'. * make.texinfo (Makefiles: MAKEFILES Variable): Make this node's `prev' pointer point to `Makefile Names'. * make.1: Renamed to make.man. * compatMakefile: Define `mandir' and `manext'. (install): Depend on $(mandir)/make.$(manext). ($(mandir)/make.$(manext)): Depend on make.man and copy it to $@. ($(bindir)/make): Use `make' rather than $<; so Unix make can grok it. Thu Aug 24 03:35:48 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * variable.c (target_environment): Allow variables that start with underscores. Wed Aug 23 22:50:32 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * variable.c (target_environment): Reject variables that don't start with letters. Tue Aug 22 04:14:29 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * GNUmakefile (make-$(version).tar.Z): Put make.1 (the Unix manual page) in the tar file. * variable.c (target_environment): Don't write variables with origin o_default (i.e., ones from default.c). * make.texinfo (Commands: Recursion: Variables/Recursion): Document that default variables are not put in the environment. * remake.c (update_file_1): Remake all targets with commands but no deps. Sat Aug 19 06:03:16 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (update_file_1): In the final loop, set the deps' `changed' members if they are newer than FILE. * remake.c (update_goal_chain): Under -d, print a message if we decide not to remake a makefile so as to avoid a possible infinite loop. Fri Aug 18 20:30:14 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (remake_file): Cleaned up. * commands.c (execute_file_commands): If the commands are empty, set FILE->update_status to zero before returning. * remake.c (notice_finished_file): Set `last_mtime' fields to zero instead of calling name_mtime; file_mtime will do that later if anybody cares. Thu Aug 17 10:01:11 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * make.texinfo (Rules: Wildcards: Wildcard Examples): Give this node a `prev' pointer. * Version 3.54.9 (alpha). * make.texinfo: Fixed some @nodes. * remake.c (check_dep): Don't set *MUST_MAKE_PTR if FILE doesn't exist after running update_file. * remake.c (notice_finished_file): If FILE has no commands, pretend its modtime is now. * remake.c (update_file_1): In the loops that call update_file on the deps, compare modtimes before and after (unless deps are still being made) and set the deps' `changed' members. Do not set the `changed' members in the loop that prints the newer/older debugging messages. * remake.c (update_file_1): If no deps changed and FILE has no commands, decide it doesn't need remaking. * remake.c (update_file_1): Print a debugging message if we take commands from default_file. * make.texinfo (Rules: Directory Search: Selective Search): Removed note about warning for `vpath' with a constant pathname, since it isn't warned about anymore. * remake.c (update_goal_chain): If MAKEFILES, remove makefiles which are targets and have no deps. * make.texinfo (Makefiles: Remaking Makefiles): Document that makefiles will not be remade if they are targets but have no dependencies. Tue Aug 15 00:00:08 1989 Roland McGrath (roland at apple-gunkies.ai.mit.edu) * remake.c (notice_finished_file): Increment files_remade for non-phony files if they didn't exist before (even if they still don't). * job.c: Include and declare errno. * job.c (exec_command): If the execve fails with ENOEXEC (Exec format error), return instead of exiting the child process. * job.c (start_job): In the child side, if exec_command fails, try using the shell. * job.c (start_job): In the child side, call unblock_children instead of sigsetmask. * remake.c (notice_finished_file): Under -n or -q, always increment files_remade for non-phony files. * rule.c (intall_pattern_rule): Use find_percent. * vpath.c (vpath_search): Pass the `percent' members to pattern_matches. Mon Aug 14 23:30:24 1989 Roland McGrath (roland at apple-gunkies.ai.mit.edu) * vpath.c (struct vpath): New member `percent', to hold a pointer into the pattern where the % is. (construct_vpath_list): Call find_percent on the pattern and set the new `percent' member. * read.c (read_makefile): Don't run find_percent on `vpath' directive patterns. * function.c (pattern_matches): Take new arg PERCENT, a pointer into PATTERN where the % is. If PERCENT is nil, copy PATTERN into local space and run find_percent on it. (expand_function: `filter', `filter-out'): Pass new arg to pattern_matches. * read.c (record_files): Pass PATTERN_PERCENT to pattern_matches for static pattern rules. Save the percent pointer into implicit rule targets, and pass them to create_pattern_rule. * rule.c (convert_to_pattern): Pass new arg to create_pattern_rule. (create_pattern_rule): Take new arg TARGET_PERCENTS, nil or an array of pointers into the corresponding elements of TARGETS, where the %s are. Sun Aug 13 00:29:19 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54.8. * README.templatate, README-doc.template: New files, turned into README and README-doc to go into the two distribution tar files. * GNUmakefile: Added a rule to edit the version number in README.template and README-doc.template, producing README and README-doc. * remake.c (update_goal_chain): If -n or -q is in effect for a makefile, and it got updated, don't change STATUS, so we can still return -1 (meaning nothing was done). This avoids an infinite loop on "make -n Makefile". Sat Aug 12 23:14:24 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (notice_finished_file): Treat -q the same as -n. * remake.c (update_goal_chain): Fixed handling of return from update_file. If -n or -q is in effect, ignore it. * job.c (start_job): Don't test for -t. We should never get called in that case. Fri Aug 11 04:09:14 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * function.c (expand_function): Removed unused variables. (handle_function): Removed unused variable. * main.c (main): Removed unused variable. Wed Aug 9 09:37:10 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54.7. * remake.c (notice_finished_file): If FILE's modtime actually changed, increment files_remade. (remake_file): Don't increment files_remade. * remake.c (update_file): Don't print "up to date" messages for phony files. * job.c (child_handler): Don't set C->file->update_status to 1 if start_job returns nonzero under -n or -t. * expand.c (variable_expand): Count parens in $(foo:a=b) refs. * main.c: Removed old declaration of `glob_tilde' (which hasn't existed for a few months). Tue Aug 8 23:53:43 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * job.c (exec_command): Fixed to not ignore the last path component and to do the right thing with an empty path. Fri Aug 4 15:58:19 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (library_file_mtime): Look for libLIB.a, not /libLIB.a. Do VPATH search on libLIB.a, not /usr/lib/libLIB.a Thu Aug 3 20:42:00 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * job.c [HAVE_SYS_WAIT or not USG]: If WIFSIGNALED is not defined by , define it as (WTERMSIG != 0). Tue Aug 1 19:25:34 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (remake_file): If FILE has no commands and is a target, don't set its time to now. The time gets reset by notice_finished_file anyway, and it isn't needed since check_dep checks for nonexistence. * Version 3.54.6. * read.c (read_makefile): Don't read off the end of the string after an `include'. * job.c (exec_command): New function to search the path for a file and execute it. (start_job): Use exec_command rather than execvp. * read.c (read_makefile): Expand `include' directive args before parsing them. Allow trailing whitespace after filename. * variable.c (target_environment): Put makelevel + 1, rather than makelevel, in the `MAKELEVEL' envariable. Sat Jul 29 10:27:04 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * remake.c (notice_finished_file): Don't get the new modtime of phony files. * remake.c (remake_file): Run commands instead of touching under -t if FILE->cmds->any_recurse is set. * commands.h (struct commands): Add new member `any_recurse', to be set nonzero if any `lines_recurse' element is nonzero. * commands.c (chop_commands): Set the `any_recurse' member. * commands.c (execute_file_commands): Split chopping of commands into lines into new function chop_commands. * commands.h: Declare chop_commands. * read.c (read_makefile): Test for a line beginning with a tab after checking for conditional lines, but before all other checks. Fri Jul 28 18:10:29 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * read.c (read_makefile): Match directives against collapsed line and use that for their args. * read.c (read_makefile): Warn about extra text after `include'. Tue Jul 25 14:34:25 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * make.texinfo (Rules: Directory Search: Selective Search): Fixed example to use correct `vpath' syntax. Mon Jul 24 12:10:58 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54.5. * job.c (start_job): In the child side, unblock SIGCHLD. Fri Jul 21 18:25:59 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * make.h: Don't include #ifdef sun. Mon Jul 17 14:29:10 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * implicit.c (pattern_search): If ar_name (FILENAME), don't check for directory names. * job.c (wait_for_children): Changed "waiting for children" message to "waiting for unfinished jobs". Fri Jul 14 13:17:13 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * load.c (load_average): Use an unsigned offset into kmem. Thu Jul 13 18:44:49 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * variable.c (pop_variable_scope): Don't free the head of the chain of variables in each bucket twice. Tue Jul 11 06:45:24 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * GNUmakefile: Include COPYING in the doc tar file. * variable.c, read.c, misc.c, job.c, function.c: Replace some identical "for" loops with next_token or end_of_token calls. Mon Jul 10 16:55:08 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54.4. * compatMakefile: Documented new conditionals. * job.c: Don't define sys_siglist if HAVE_SIGLIST is defined. Don't define dup2 if HAVE_DUP2 is defined. * job.c (child_handler): Interpret the return from start_job correctly. * remake.c (update_file_1): Don't write "target not remade because of errors" message under -n or -q. * read.c: Declare getpwnam. * glob.c: Use if DIRENT is defined. [USG]: Don't declare memcpy, since does. Fri Jul 7 20:53:13 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * misc.c (collapse_line): Copy the line over in the right place. Fri Jul 7 18:33:24 1989 Roland McGrath (fsf at void.ai.mit.edu) * remake.c: Conditionalize inclusion of on not USG, since HP-UX defines a `struct file' there. Fri Jul 7 12:11:30 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * job.c: If WTERMSIG is defined by , define WAIT_T as int, and don't define other macros; this covers HP-UX. If WTERMSIG is not defined, use int or union wait based on USG and HAVE_SYS_WAIT; this covers BSD and SysV. * Version 3.54.3 (alpha). * job.c [USG and not USGr3]: Include and declare errno. * job.c (unblock_children [USG]): Declare child_handler. * job.c: Renamed WRETCODE to WEXITSTATUS. [HAVE_SYS_WAIT or not USG]: Undefine WTERMSIG, WCOREDUMP, and WEXITSTATUS before defining them. The HP-UX defines them. * main.c (main): If there are no goals, fatal AFTER printing the data base under -p. Thu Jul 6 22:43:33 1989 Roland McGrath (roland at apple-gunkies.ai.mit.edu) * glob.c [USG]: #define rindex as strrchr. * job.c [USG]: Include and #define getdtablesize() as NOFILE. Wed Jul 5 09:36:00 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54.2 (alpha). * expand.c (variable_expand): When expanding recursive variable references (${${a}}), use the correct delimiters in the constructed variable reference. Mon Jul 3 18:29:26 1989 Roland McGrath (roland at apple-gunkies.ai.mit.edu) * compatMakefile: Clear out and redefine the .SUFFIXES list because silly Sun 4 make defines .cps.h. * compatMakefile: Fix comment about -DNO_MINUS_C_MINUS_O. * remake.c: Include for O_* on 4.2. * commands.c: Define sigmask if it's not defined. Fri Jun 30 07:33:08 1989 Roland McGrath (roland at apple-gunkies.ai.mit.edu) * remake.c (remake_file): Don't always increment files_remade. * variable.c (push_new_variable_scope): Zero the new variable hash table. Thu Jun 29 17:14:32 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * expand.c (variable_expand): When terminating the variable expansion buffer, use variable_buffer_output instead of a simply zero store, because the buffer may need to be enlarged. Wed Jun 28 16:53:47 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.54. * default.c (default_suffixes): Added `.ln'. (default_suffix_rules): Changed lint rules to use -C. Thu Jun 22 20:49:35 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * job.c (start_job): Set `environ' to CHILD->environment before execing in the child process! Tue Jun 20 17:23:13 1989 Roland McGrath (roland at spiff.ai.mit.edu) * compatMakefile: Put job.h and rule.h in `srcs'. * Version 3.53. Mon Jun 19 16:25:18 1989 Roland McGrath (roland at spiff.ai.mit.edu) * job.c (start_job): If there are no more commands, return nonzero under -n or -t. * compatMakefile (make): Pass `-f' to mv. * GNUmakefile: If `ARCH' or `machine' is defined, make $(ARCH)/*.o and $(ARCH)/make instead of *.o and make. * function.c (string_glob): Don't try to use freed storage! * read.c (readline): If there is only one byte of space in the buffer, enlarge the buffer before reading more. * arscan.c [M_XENIX]: Miscellaneous minor changes for Xenix. Sun Jun 18 13:07:45 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * GNUmakefile (depend): Split commands into two lines so they won't be so long when variable-expanded. * compatMakefile: Documented MINUS_C_MINUS_O meaning. The line describing it got removed when the USG/wait stuff was documented. Sat Jun 17 22:56:54 1989 Roland McGrath (roland at hobbes.ai.mit.edu) * Version 3.52. Mon Jun 12 17:45:11 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remake.c (check_dep): Drop circular dependencies instead of fataling. (update_file_1 already does this.) * default.c (default_suffix_rules): For .s -> .o, put the -o flag to the assembler before the source file name. Sun Jun 11 12:00:52 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.51. * make.texinfo (Features): Noted 1003.2 requirement of `+' meaning. * file.c (remove_intermediates): If !SIG, write a single "rm" command line, listing all files. * read.c (read_makefile): Don't free the storage for the passed filename, since it might not be malloc'd. When doing an included makefile, free the name's storage. (read_all_makefiles): Use variable_expand to find the value of `MAKEFILES'. Free the storage for the names of -f makefiles. (read_makefile): Allocate storage for the makefile name in the `struct file' in read_makefiles. * make.texinfo (Running: Instead of Execution): Document the effect of + and $(MAKE)/${MAKE}. * make.texinfo (Functions: Foreach Function): Document that if the iteration variable was undefined before the `foreach' call, it will be undefined after the call. * commands.c: Split into commands.c, job.h, and job.c. * rule.c (try_implicit_rule, pattern_search): Moved to new file implicit.c. * rule.c: Split into rule.h, rule.c, and default.c. * default.c (install_default_pattern_rules): Renamed to install_default_implicit_rules. * make.h, main.c (main): Renamed uses. * make.c: Renamed to misc.c. * make.c (main, log_working_directory, decode_switches, decode_env_switches, define_makeflags, die, print_version, print_data_base): Moved to new file main.c. * commands.c (execute_file_commands): Don't collapse backslash-newlines here. When chopping the commands up into lines, don't chop at backslash-newlines. (start_job): Collapse backslash-newlines after printing the line. * commands.c (start_job): Don't collapse backslash-newlines here. (execute_file_commands): Collapse backslash-newlines before chopping the commands up into lines. * commands.c (set_file_variables): Initialize the length counters for $^ and $? to zero! * commands.c (start_job): Use vfork instead of fork. Someone else says the child and parent DO have separate file descriptors. * variable.c: Split internals into variable.c, function expansion into function.c, and variable expansion into expand.c. * function.c (handle_function): New function to check for a function invocation and expand it. * expand.c (variable_expand): Use handle_function. * variable.c (push_new_variable_scope): New function to push a new empty variable set onto the current setlist. (pop_variable_scope): New function to pop the topmost set from the current setlist and free its storage. * function.c (expand_function: `foreach'): Push a new variable scope for the iteration variable and pop the scope when finished. * variable.h: Declare new functions. * variable.c (initialize_variable_output): New function to return a pointer to the beginning of the output buffer. (save_variable_output): New function to save the variable output state. (restore_variable_output): New function to restore it. * expand.c (variable_expand): Use initialize_variable_output. (allocated_variable_expand): Use {save,restore}_variable_output. * variable.c (current_setlist): Renamed to current_variable_set_list and made global. Sat Jun 10 00:11:25 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remake.c (library_file_mtime): Check for libNAME.a in the current directory before doing VPATH search. * variable.c (print_variable_set): Don't write "# Variables", and write fewer blank lines. (print_variable_data_base): Precede the variables with "# Variables". * make.c (main): Print the data base under -p after doing everything else, just before exitting. This way it gets info determined in updating the goal targets. * variable.c (print_variable_data_base): Split into print_variable, which prints one variable, and print_variable_set, which prints a set. Replaced with a call to print_variable_set for the global set. (print_file_variables): New function to print a given file's local variables. * file.c (print_file_data_base): Call print_file_variables to print each file's local variables. * commands.c (set_file_variables): Actually define the values for the $^ and $? variables!!! * make.texinfo (Implicit: Pattern Rules: Automatic): Document new D and F versions of $^ and $?. * commands.c (start_job): In the child fork, use getdtablesize and a loop to close all file descriptors other than 0, 1, and 2. We need to do this since not only the bad stdin pipe, but also some directories, may be open. * commands.c (start_job): Use fork instead of vfork, because a vfork parent and child share file descriptors, and our child needs to diddle with stdin. * variable.c (initialize_file_variables): When created a new variable set, zero out the hash table. * variable.c (target_environment): Don't use variables whose names are not made up of alphanumerics and underscores. * remake.c (update_file_1): Set the `parent' member of each dependency to FILE before updating it. * file.h (struct file): Add `parent' member. * variable.c (initialize_file_variables): Don't take second arg PARENT. Use FILE->parent instead. If FILE->parent->variables is nil, recurse to initialize it. * variable.h: Declare {allocated_}variable_expand_for_file. * variable.c (allocated_variable_expand): Now allocated_variable_expand_for_file, calling variable_expand_for_file, and taking second arg FILE. (allocated_variable_expand): New function, a wrapper around allocated_variable_expand_for_file, passing a nil second arg. Fri Jun 9 12:11:45 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (start_job): On the child side of the fork, always close the bad stdin file descriptor. * commands.c (struct child): New member `environment', to hold the environment for the child. (execute_file_commands): Set the new childs `environment' member to nil before calling start_job. (start_job): Set up CHILD->environment before running the commands if it is nil. * make.c (main): Don't call new_environ. `shell' functions will now be run with the environment make was called with. * commands.c (child_handler): Don't check C->command_ptr before calling start_job since we now have to check C->file->cmds->command_lines and it's easier to let start_job handle all that. * commands.c (struct child): New member `command_line', to hold an index into file->cmds->command_lines. (execute_file_commands): Set the new child's `command_line' to 0 and its `commands' and `commands_ptr' to nil. (start_job): When CHILD->command_ptr runs out, increment CHILD->command_line and run the corresponding line from CHILD->file->cmds->command_lines. Run it even under -t, -q, or -n if the CHILD->file->cmds->lines_recurse element for that line is set. * commands.c (execute_file_commands): Chop CMDS up into lines, setting its `command_lines' and `lines_recurse' members, if it wasn't already chopped. * commands.h (struct commands): New members `command_lines' and `lines_recurse'. The first is an array of chopped-up lines; the second is an array of flags, each nonzero if the corresponding line is recursive. * variable.c (variable_expand_for_file): If FILE is nil, just do a vanilla variable_expand. (expand_function: `shell'): Pass second arg (as nil) to construct_command_argv. * commands.c (construct_command_argv): Use variable_expand_for_file on `$(SHELL)' and `$(IFS)' instead of lookup_variable to check those variables. This handles file-local and recursive values correctly. To support this, take an additional argument FILE. * variable.c (initialize_file_variables): New function to initialize FILE's variable set list from PARENT's setlist. PARENT is the immediate dependent that caused FILE to be remade, or nil if FILE is a goal. (When user-level per-file variables are implemented, PARENT should be passed as nil when defining per-file variables.) * variable.c (variable_expand_for_file): New function to expand a line using the variable set of a given file, and reporting error messages for the file and line number of that file's commands. * variable.h: Don't declare lookup_variable_for_file. * variable.c (lookup_variable_*): Turned back into lookup_variable. It now uses current_setlist. (global_setlist): New static `struct variable_set_list', a setlist containing global_variable_set. (current_setlist): New static `struct variable_set_list *', a pointer to the current variable set list. (define_variable): Define in the current top-level set, not the global set. * commands.c (set_file_variables): New function to set up the automatic variables for a file in its own variable set. (execute_file_commands): Use set_file_variables. * variable.c (new_environ): Replaced with target_environment, taking an argument FILE, and returning an environment for FILE's commands. * variable.c, variable.h: Remove all global special variable pointers. * variable.c (define_variable_for_file): New function like define_variable, but takes additional arg FILE, and defines the variable in the variable set at the top of FILE's chain. (lookup_variable_for_file): New function like lookup_variable, but takes additional arg FILE, and looks the variable up in all of FILE's variable sets. * file.h (struct file): New member `variables', a `struct variable_set_list' containing the list of variable sets used in the expansion of the file's commands. * variable.c (variables): Replaced with static `struct variable_set' global_variable_set. (define_variable): Now define_variable_in_set, taking additional argument SET, the `struct variable_set' to define it in. (define_variable): Use define_variable_in_set with global_variable_set. (lookup_variable): Now lookup_variable_in_set, taking additional argument SET, the `struct variable_set' to look it up in. (lookup_variable): Use lookup_variable_in_set with global_variable_set. (lookup_variable_in_setlist): New function to look up a variable in a `struct variable_set_list' using lookup_variable_in_set. * variable.h (struct variable_set): New structure, containing a hash table and the number of hash buckets. (struct variable_set_list): New structure, containing a link for a linked-list, and a `struct variable_set'. * commands.c (start_job): Under -n, return what the recursive start_job call returns, since it might actually start a child. * make.texinfo (Rules: Wildcards): Document ~ and ~USER expansion. * commands.c (execute_file_commands): If start_job returns failure, but -t is set, set FILE->update_status to success. (start_job): If -t is set, and the commands are not recursive, return failure (is is done for -q). * remake.c (touch_file): New function to touch FILE. (remake_file): Use touch_file. When touching a file, still do execute_file_commands. * remake.c (remake_file): Don't check question_flag (-q), since we can't know here if the commands are recursive. * commands.c (start_job): Don't use the `recursive' member of CHILD->file->cmds. Instead, check for leading +s and $(MAKE) or ${MAKE} in the command line here. * commands.h (struct commands): Remove `recursive' member. * rule.c (install_default_pattern_rules): Remove use of `recursive' member. * read.c (record_files): Don't check commands from $(MAKE) and set their `recursive' member. * commands.c (fatal_error_signal): Treat SIGQUIT like SIGINT, SIGHUP, and SIGTERM, but don't send it to ourselves because it will cause a core dump. Thu Jun 8 20:30:04 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.50. * variable.c (variable_expand): Use allocated_variable_expand instead of expand_argument in a few places. * variable.c (allocated_variable_expand): Do static variable shuffling here instead of using expand_argument. (expand_argument): Use allocated_variable_expand. * variable.c (recursively_expand): New function to recursively expand its argument (a `struct variable'), returning the malloc'd value. (variable_expand): Use recursively_expand. Sun May 28 12:49:27 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (main): Fixed buggy fix in deciding to increase space for command-line variable definitions. (First it never did it, then it always did it; now it does it when necessary.) Sat May 27 14:01:54 1989 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * make.c (main): Fixed bug in deciding to increase space for command-line variable definitions. Fri May 26 15:48:01 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * read.c (multi_glob): Use allocated_expand_variable for checking `HOME' variable for ~ expansion, since this may be called from inside a `wildcard' function expansion. * variable.h: Declare allocated_expand_variable. * variable.c (allocated_expand_variable): New function to do variable expansion in an allocated buffer, rather than the static one. * make.c (main): Don't set glob_tilde (it no longer exists). * variable.c (string_glob): Use multi_glob and parse_file_seq. * read.c (multi_glob): Do ~ expansion here. * glob.c (glob_tilde, glob_filename): Removed ~ expansion. * variable.c (define_variable, lookup_variable): Use a smarter hashing algorithm (the same one used for files and directories). (VARIABLE_BUCKETS): Increased to 523. * file.c (enter_file, lookup_file, rename_file): Use a smarter hashing algorithm, spreading the bits about somewhat. * make.c (log_working_directory): Under `-p', precede the directory message with a `#'. * make.c (print_version): Under `-p', precede each line with a `#'. (print_data_base): Precede the header line with a `#' and include the date and time on it. * vpath.c (print_vpath_data_base): Precede non-directive lines with `#'s. * commands.c (print_commands): Precede the non-command line with a `#'. * rule.c (print_rule_data_base), file.c (print_file_data_base): Precede non-rule lines with `#'s. * dir.c (print_dir_data_base): Precede all lines with `#'s. * variable.c (print_variable_data_base): Changed format so that it can be makefile input. Lines that are not variable definitions are preceded with `#'. Nonrecursive variable definitions are made with all dollar signs doubled to reproduce the initial value. Recursive variable definitions containing newlines are done with `define' directives. Nonrecursive variable definitions containing newlines, and variable names containing :, =, or newlines, will come out garbled. Wed May 24 00:20:04 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.49. Tue May 23 19:18:00 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * variable.c (expand_function: `filter'/`filter-out'): Use find_percent instead of pattern_p. * variable.c (expand_function: `patsubst'): Pass new args (both nil) to patsubst_expand. (variable_expand): For $(var:pat%=rep%) references, pass new args to patsubst_expand so as to avoid find_percent and thus disallow quoting the %s. * read.c (record_files): Pass new args to patsubst_expand. * variable.c (patsubst_expand): Take two new args: PATTERN_PERCENT and REPLACE_PERCENT. Each of these, if non-nil, means that PATTERN (or REPLACE) has already been run through find_percent, and PATTERN_PERCENT (or REPLACE_PERCENT) is the result. * make.h: Declare find_percent instead of pattern_p. * read.c (pattern_p): Changed to find_percent, returning a pointer to the %, or nil if there is none. (record_files): Take another arg, PATTERN_PERCENT, a pointer to the % in PATTERN. (read_makefile): Pass PATTERN_PERCENT to record_files. * make.texinfo (Rules: Static Pattern: Static Usage, Rules: Directory Search: Selective Search, Functions: Text Functions): Documented that `%' can be quoted. * variable.c (expand_function: `filter'/`filter-out'): Use pattern_p to allow quoted %s in patterns. * variable.c (patsubst_expand): Use pattern_p on PATTERN and REPLACE to allow quoted %s. Quoting backslashes are removed from REPLACE even if PATTERN contains no unquoted %. * read.c (pattern_p): Made global. * make.h: Declare pattern_p. * read.c (pattern_p): New function to search for an unquoted % in a string. Backslashes quote %s and backslashes. Quoting backslashes are removed from the string by compacting it into itself. Returns nonzero if an unquoted % was found, zero if not. (record_files): Use pattern_p to check for implicit rules. (read_makefile): Use pattern_p to check for static pattern rules. Also use it to allow quoted %s in `vpath' patterns; warn about `vpath' patterns with no %s. Mon May 22 16:31:52 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * glob.c (glob_filename): Replace a `1' with the `l' that should have been there. This incidentally stops it from dumping core. * glob.c (glob_filename): If the path is just a directory, with no file name pattern, return the directory alone. * glob.c (glob_tilde): New global variable (int), defaults to zero. (glob_filename): If glob_tilde is nonzero, expand ~ or ~USER. * variable.c (string_glob): Keep a static allocated buffer for file names taken from the list, instead of allocating and freeing one every time. Fri May 19 18:06:26 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.c (decode_switches): Get floating numbers from the right string. Sun May 14 13:48:04 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * commands.c (delete_child_targets): When deleting `also_make' files, include the target's name in the message: make: *** [foo] Deleting file `bar' Sat May 13 17:34:26 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (max_load_average, default_load_average): Default to -1. * load.c (wait_to_start_job): Return if max_load_average is < 0.0, not equal. Fri May 12 16:08:05 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * variable.c (variable_buffer_output): Don't try to do pointer arithmetic between objects not in the same array. Wed May 10 15:55:29 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * rule.c [M_XENIX] (default_suffix_rules, default_variables): Minor changes to allow for strange compiler syntax. * rule.c (default_variables): Don't include "> $@" in $(PREPROCESS.S), since it's already in the .S.s rule. * file.c (enter_file): Make a new double-colon file the `prev' member of the bottom `prev' file (the one whose `prev' is nil). * read.c (do_define): Append newlines after copying the lines into the value buffer, so we end up with a trailing newline. * make.c (print_version): If the global variable `remote_description' is not nil or "", append "-%s" (its value) to the version number. * remote-*.c: Define remote_description appropriately. Sun May 7 15:15:53 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (error_status): Converted to new function child_error, taking new arguments TARGET_NAME and IGNORED, and writing an error message: "*** [target] Error 1" (or signal #, etc.), appending " (ignored)" if IGNORED is nonzero. (child_handler): Use child_error instead of error_status. * compatMakefile (all): Don't depend on `doc'. * compatMakefile (clean): Don't remove make-info*. (realclean): New rule, depends on `clean', removes tags, TAGS, and all Info and TeX files. Thu May 4 17:00:46 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * variable.c (print_variable_data_base), file.c (print_file_data_base), rule.c (print_rule_data_base), Use floating-point for averages and percentages. * make.c (print_data_base): Print messages before and after the data base information. * commands.c (print_commands): Changed output format to separate lines in commands and prefix them with tabs. * dir.c (print_dir_data_base): Changed output format slightly. * vpath.c (struct vpath, construct_vpath_list, selective_vpath_search): Remove the `exists' member and its uses. * vpath.c (print_vpath_data_base): New function to print all selective and general VPATH search paths (for -p). * make.c (print_data_base): Call print_vpath_data_base. * file.c (print_file_data_base): Changed format to look more like a makefile rule. Now reports all information in the `struct file'. * rule.c (print_rule_data_base): Changed format of display from: %: (terminal) depends on: RCS/%,v to: %: RCS/%,v is terminal. references nonexistent subdirectory. Also include number and percent that refer to nonexistent subdirectories. Thu Apr 27 15:45:40 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.c (main): Figure out the level of recursion before writing the `Entering directory' message. * variable.c (define_automatic_variables): Don't figure out the level of recursion from `MAKELEVEL'. It's now done in main. * Version 3.48. Wed Apr 26 16:39:17 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (child_handler): Set `update_status' to zero when there are no more commands. * make.c (log_working_directory): If MAKELEVEL > 0, indicate the recurson in the message (make[1]: ...). * commands.c (child_handler): Change status to `cs_finished' when commands fail. * commands.c (start_job): Return 0 (success) if there were no more commands for the child. (child_handler): Change the status to `cs_finished' when start_job fails to start the commands. * make.c (main): Don't handle SIGEMT if it's not defined. Do handle SIGDANGER if it is defined. * commands.c (child_handler): Reorganized inner loop so that it doesn't try to inspect the child before finding it. Tue Apr 25 16:28:24 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.c (end_of_token): Fixed bug wherein backslashes caused immediate return. * Version 3.47. * make.texinfo (Implicit: Pattern Rules: Automatic): Document setting of `$*' for explicit rules. Add note clarifying that automatic variables, though referred to in the documentation as `$<', etc. are no different than `$(<)', etc. Fri Apr 21 18:00:12 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * file.c (enter_file): Don't strip leading `./'s. * read.c (parse_file_seq): Strip leading `./'s. Thu Apr 13 17:26:41 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.texinfo (Commands: Parallel, Running: Options): Document that -l with no argument removes a previous load limit. * make.c (struct command_switch): New member `default_value'. (default_job_slots): Default value (of 1) for -j. (default_load_average): Default value (of 0, unlimited) for -l. (command_switches): Use default values for -j and -l. Also, -l without an arg now means no load limit. (define_makeflags): Don't write positive_int or floating options whose values are their defaults. * make.c (main): Under -w, write a `Leaving directory' message before re-execing. Tue Apr 11 16:46:29 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.46. * Makefile: Provide an easy place for system-specific definitions (-DUSG, etc.) and extra object files (for whatever). * make.texinfo: Miscellaneous fixes from RMS. Mon Apr 10 19:31:34 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * rule.c (pattern_search): Put rules with `subdir' flags set in TRYRULES, since these might be valid with VPATHs. In the TRYRULES loop, don't do lookup_file or file_exists_p calls for dependencies of rules with `subdir' flags set, but still do vpath_search calls and intermediate-file searches. Thu Apr 6 16:33:00 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.texinfo (Implicit: Pattern Rules: Automatic): Document the new definition of $* for explicit rules. * commands.c (execute_file_commands): If FILE->stem is nil, figure out if FILE->name ends in a suffix in the .SUFFIXES list; if so, store the name sans suffix in FILE->stem (and $*). Wed Apr 5 15:24:48 1989 Roland McGrath (mcgrath at helen.Berkeley.EDU) * file.c (remove_intermediates): Don't use `file_exists_p' to check for the existence of intermediate files, because the hashed directories will probably be out of date. * commands.c (child_handler): Free the good stdin before running the next command line. * commands.c [USG] (init_siglist): Don't case SIGEMT if it's not defined. Do case SIGDANGER (for IBM RT) if it is defined. * commands.c: Changed `SYS_WAIT' to `HAVE_SYS_WAIT'. (child_handler): Use `wait3' if HAVE_SYS_WAIT is #defined. * file.c (enter_file): If any `./'s are stripped off, allocate a new copy of the shortened name. * rule.c (pattern_search): Allocate the right length strings for `also_make' members. Sat Apr 1 13:28:38 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.45. * GNUmakefile: Make a separate tarfile of the DVI and info files. * make.c (define_makeflags): If a switch that takes an argument has its default value, put the switch in MAKEFLAGS with no arguments. * make.c (command_switches): Pass `-l' in MAKEFLAGS. Wed Mar 29 17:50:05 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * GNUmakefile: Don't include the DVI and info files in the dist. * commands.c (child_handler): Don't call check_changed_{directories,vpaths}. * make.h: Don't declare check_changed_{directories,vpaths}. * vpath.c (check_changed_vpaths): Removed this function. * dir.c (struct directory): Remove `modtime' member. (find_directory): Don't set `modtime' member. (check_changed_directories): Removed this function. * remake.c (update_file_1): Set FILE->command_state to cs_finished if it didn't need to be remade. * remake.c (update_file): Only write the "up to date" message if the target went from `not_started' state to `finished' state without incrementing the count of files remade. * commands.c [USG] (init_siglist): If both SIGCHLD and SIGCLD are defined, don't put them both in the `switch'. Tue Mar 28 15:37:02 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * file.c (rename_file): Change FILE's name!!! * rule.c (create_pattern_rule): Set the `terminal' member of the new rule after calling new_pattern_rule, which zeros it. * rule.c (default_variables): Use $(C++) in $(COMPILE.cc)! Sun Mar 26 15:52:30 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Makefile: Added a `clean' target. Fri Mar 24 15:08:46 1989 Roland McGrath (mcgrath at helen.Berkeley.EDU) * Version 3.44. * file.c (rename_file): If a `struct file' for the renamed-to name exists, and it is a target or has deps or commands, barf. If not just remove the old one for put in the new one. * remake.c (update_file_1, check_dep): Changed it back so that equal modtimes to NOT make dependencies be considered newer. RCS checks out files with equal modtimes as the RCS files, so this screws it. * make.h, glob.c: If __GNUC__ is defined, use __builtin_alloca. * Makefile: Use variables `ALLOCA' and `ALLOCASRC' so systems without a good standard alloca can get it from the Emacs distribution (or somewhere). * dir.c: Don't include , since make.h does. * make.c: Removed debugging version of getwd. Thu Mar 23 16:16:27 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.43. * remake.c (update_file_1): If a dependency loop is found, don't fatal. Emit an error message and remove the dependency. * remake.c (library_file_mtime): Fixed to use the right names. (update_file_1, check_dep): Consider a dependency "newer" than its dependent if they have the same modification time. Wed Mar 22 19:31:35 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * file.c (remove_intermediates): Don't try to remove nonexistent files. Mon Mar 20 10:21:22 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.42. * rule.c (default_variables): Set F77 to $(FC) and F77FLAGS to $(FFLAGS) so explicit rules expecting these (which are in System V) will work. However, there is no way to make setting these affect the implicit rules, unless we trash FC and FFLAGS (which BSD uses). [USG]: Set GET to `get' rather than `/usr/sccs/get'. Sun Mar 19 20:00:27 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * vpath.c (construct_vpath_list): Don't replace VPATH[ELEM] with dir_name (V), because the latter may get freed. Sat Mar 18 15:01:39 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.41. * make.texinfo: Cleaned-up edition 0.1 Beta from RMS and Bob Chassell. * file.c (rename_file): If a file with the new name already existed, use the same storage space, after freeing the old file's name, deps, and `also_make' member, preserving the link in the chain. Also write an error message telling the user to report the incident; I don't think this should be able to happen, but I'm not sure. * file.c (rename_file): Don't add the hash values of the old and new names together! Reset HASHVAL before computing the second value. * dir.c (check_changed_directories): Zero the new file hash table after allocating it. * dir.c (dir_file_exists_p): If FILENAME is "", return 1 if the directory exists. * vpath.c (check_changed_vpaths): New function to run through the search paths of all VPATHs, making the `exists' members correspond to reality. * commands.c (child_handler): Call check_changed_vpaths. * make.h: Declare check_changed_vpaths. * vpath.c (struct vpath): New element `exists', an array of char flags; exists[N] is nonzero if searchpath[N] exists. (construct_vpath_list): Set the `exists' member. (selective_vpath_search): Don't search directories whose `exists' elements are zero. * read.c (read_makefile): Set the `dontcare' flag of makefiles from the MAKEFILES variable if they were not mentioned anywhere but in the MAKEFILES variable. * read.c (read_makefile): Don't write an error message if fopen fails for a makefile from the MAKEFILES variable. * dir.c (struct directory): Add `modtime' member to record the modification time of the directory when it was opened. (check_changed_directories): New function to check all known directories; if their modtimes have changed since they were opened, their file tables are cleared and they are reset to be read in. * commands.c (child_handler): Call check_changed_directories before returning. make.h: Declare check_changed_directories. Tue Mar 14 20:07:13 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.40. * make.c (print_version): Made the copyright say 1988, 1989. * read.c (read_all_makefiles): Don't set *MAKEFILES to the name of the end of the read_makefiles chain, since the latter may be from an included makefile. (Why did I do this before?) * make.c (main): Set argv[0] to "" if it was nil. Don't put the command-line variable definitions into argv[0], only into the MAKE variable! Sun Mar 5 20:44:08 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * ar.c (ar_member_date, ar_touch): Remove the trailing ) from the member name. Fri Mar 3 18:15:15 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (construct_command_argv): Initialize NEW_ARGV to 0. At `slow' label, if NEW_ARGV is not 0, free it; then allocate 4 strings. Tue Feb 28 14:29:39 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.39. * COPYING, make.texinfo: New GNU General Public License, version 1. * *.c, *.h, Makefile: New copyright notices for the new GNU General Public License, version 1. * commands.c [USG]: Define WRETCODE correctly (again). * variable.c (expand_function: `shell'): Don't capture the standard error output of the shell command. * ar.c (ar_touch, ar_member_date): Allocate MEMNAME with the right length. * load.c [not UMAX] (load_average): Don't clobber the first nlist member when trying to set the second! Thu Feb 23 13:13:53 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * commands.c (child_handler): Really ignore errors under -i and for - lines, don't just print a different message. * make.c (decode_switches): Fixed handling of arguments (or lack thereof) to switches. Wed Feb 22 16:25:39 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * commands.c (construct_command_argv): Don't clobber LINE when checking the IFS variable. Sun Feb 19 11:17:07 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * load.c [UMAX, not NO_LDAV] (load_average): Return 0.0 rather than randomness when calls fail. * Version 3.38. * commands.c (fatal_error_signal): If handling a user kill signal (TERM, INT, HUP), wait for the children without printing the "Waiting for children" message, since they will die quickly. * Version 3.37. * remote-stub.c (remote_status): Take another arg, BLOCK. If this is nonzero block waiting for remote children. If not, return 0 if we would have to block. * commands.c (child_handler) [not USG]: If called as a signal handler, use wait3 and don't block. [USG]: If called as a signal handler, return after handling one child. Sat Feb 18 13:37:04 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * file.c (snap_deps): Process all double-colon entries of each file, not just the first one. * Version 3.36. * remote-stub.c: remote.c renamed. remote.c: Just include remote-stub.c * commands.c (child_handler): If we were called as a signal handler, return after handling one child. * commands.c [not USG]: Include and define `sigmask' if doesn't. (block_children, unblock_children): Use sigmask rather than bitshifting explicitly (and incorrectly). * remote.c (remote_kill): New function to send a signal to a remote child. * commands.c (fatal_error_signal): If we get a SIGTERM, send one to each living child. If we get a SIGTERM, SIGINT, or SIGHUP, delete all pending targets before waiting for children. (struct child): Add new member `deleted'. (start_job): Initialize `deleted' member to 0. (delete_child_targets): New function to delete a given child's targets, unless the `deleted' flag in the `struct child' says they have already been deleted. Sets this flag before returning. Thu Feb 16 18:32:07 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c [USG]: Define `WRETCODE' correctly (X & 0xff00). Tue Feb 14 16:05:00 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (construct_command_argv): Don't make the 0th element of the argument list be "sh" when executing /bin/sh, because start_job uses the 0th element as the program name. Sun Feb 12 17:42:05 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.35. * read.c (readline): Put a null in the beginning of the buffer before starting the reading loop. * read.c (read_makefile): Made main reading loop while !feof (infile), and removed EOF check after calling readline. Sun Feb 5 19:52:38 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * remote.c (block_remote_children, unblock_remote_children): New (stub) functions to block and restore asynchronous notification of remote child death. * commands.c (block_children): Call block_remote_children. (unblock_children): Call unblock_remote_children. (child_handler): If called as a signal handler, block remote children on entry and unblock them before returning. * commands.c (child_handler): For unknown children, if they are remote, give their remote ID; if local, give their PID and make's. * commands.c (execute_file_command): Don't put a new child in the chain unless start_job succeeds. Block children before calling start_job, and unblock them after putting the child in the chain and incrementing `job_slots_used' (if start_job succeeded). * commands.c (block_children, unblock_children): Make these globally visible (not `static'). commands.h: Declare block_children and unblock_children. * variable.c (expand_function: `shell'): Use `shell_function_completed'. Block children before forking and unblock after `shell_function_pid' is set properly and `shell_functon_completed' is reset to 0. * commands.c (child_handler): When the child of the `shell' function completes, set `shell_function_completed' to 1 if it actually ran, or -1 if it didn't (due to fork or exec failure). * commands.c (block_children, unblock_children): New functions to block and unblock the child termination signal. (wait_for_children): Use block_children and unblock_children. (execute_file_commands): Block children around the critical section wherein a new child is put on the chain. * make.c (main): Change the environment to contain the correct MAKELEVEL before re-execing. Sat Feb 4 18:28:48 1989 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.34. Fri Feb 3 16:36:49 1989 Roland McGrath (mcgrath at helen.Berkeley.EDU) * rule.c (default_variables): Fixed $(LINK.c). Wed Feb 1 18:05:07 1989 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Version 3.33. * version.c: Removed copyright notice, since this is a one-line file. * commands.c (error_status): Made it return BUF, rather than running off the end (this apparently worked on Sun 3s for some reason). * ar.c, commands.c, dep.h, load.c, make.c, make.h, read.c, remake.c, rule.c, variable.c, Makefile: Changed copyrght notices to cover 1989. Mon Jan 30 15:51:28 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.32. Fri Jan 27 20:09:24 1989 Roland McGrath (mcgrath at tully.Berkeley.EDU) * remake.c (remake_file): Don't touch phony targets. * rule.c (convert_to_pattern): Fixed an incorrect length passed to savestring. * variable.c (expand_function: `shell'): Close the read side of the pipe on the parent side of the fork. * commands.c (start_job): On the child of the fork, close the BAD_STDIN fd if we're not using it. * read.c (record_files): A file beginning with a dot can be a default target if it also contains a slash (as in `../foo'). * commands.c (wait_for_children): For BSD, block SIGCHLD rather than ignoring it to avoid a race condition when child_handler is returning. * commands.c (child_handler): Do blocking waits. (error_status): Return a string describing exit status. (Split out of child_handler). * read.c (multi_glob): Change VECTOR to VEC for Alliant. Thu Jan 5 00:06:51 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.31. * make.texinfo (Features): Noted $(foo:PAT=SUB) from SunOS 4.0. * make.texinfo (Options/Recursion): -d and -p go in the environment. * load.c: Include "commands.h". Wed Jan 4 17:49:25 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * make.c (switches): -d and -p can come from the environment and are put into it. * read.c (record_files): Fixed the checking for duplicate deps so it doesn't clobber the first one. * make.texinfo: Documented default implicit rule changes. * rule.c: Revamped default suffix rules. They now use Sun's style of using variables `COMPILE.c', `LINK.c', etc. for each suffix, and use `TARGET_ARCH' and `TARGET_MACH' variable where appropriate. Also support Modula-2 compilation (suffixes .sym, .def, and .mod). Ratfor Yacc support is gone, since nobody has yacc -r. All EFL support is gone, since nobody uses EFL. * ar.c, arscan.c: Don't assume `long int' and `int' are the same. * commands.c [USG]: Fixed wait status bit encoding. [USG and not USGr3] (dup2): Define this for SysVr2. * make.h, dep.h, make.c [iAPX286]: Make allowances for this brain-damaged compiler. * make.texinfo (Variables: Flavors): Fixed a typo. Tue Jan 3 18:09:31 1989 Roland McGrath (mcgrath at homer.Berkeley.EDU) * ar.c (ar_member_date, ar_touch): Truncate member names to 15 chars. * Version 3.30. * commands.c [SYS_WAIT]: If this is defined, use BSD and wait3 even if USG. * read.c (record_files): Defining .DEFAULT with no deps or commands clears its commands. * rule.c (default_suffixes): Added `.sh'. (default_suffix_rules): Added single-suffix .sh rule, copies source to target and makes target executable. make.texinfo (Catalogue of Rules): Documented .sh rule and its use in conjunction with SCCS. * rule.c (set_default_suffixes): Define variable `SUFFIXES' to the default list ("" under -r). make.texinfo (Suffix Rules): Document `SUFFIXES' variable. * rule.c (default_variables), make.texinfo (Implicit Variables): Variable AR defaults to `ar', ARFLAGS to `rv', and RM to `rm -f'. * rule.c (install_default_pattern_rules): Default variables are made recursive. (default_variables): Added "CPP", defined to "$(CC) -E". (default_suffixes): Added `.S', before `.s'. (default_suffix_rules): New rule for .S to .s, runs CPP. All rules that use CPP now include "$(CPPFLAGS)". make.texinfo (Catalogue of Implicit Rules, Implicit Variables): Documented above changes. * commands.c [USG] (sys_siglist): Don't define. [USG] (init_siglist): New function to initialize sys_siglist. * make.texinfo (Variables: Reference): Documented `$(foo:PAT=SUB)' references. * variable.c (variable_expand): A reference `$(foo:PAT=SUB)' is equivalent to `$(patsubst PAT,SUB,$(foo))'. * variable.c (variable_expand): Free the storage for the expansion of a recursive variable when it is nod longer needed. * variable.c (variable_expand): When checking for `$($(foo))', use lindex so as not to search for the second `$' outside the parens. * make.c (struct stringlist, main, decode_switches): Changed `index' member to `idx'. Sat Dec 24 16:02:32 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (wait_for_children [USG]): Handle SIGCLD with SIG_DFL, rather than SIG_IGN. Ignoring SIGCLD reportedly makes wait return -1. * arscan.c [USGr3]: Define PORTAR to 1 (as with sun386). (ar_scan [USGr3]): Remove trailing slashes from member names. Thu Dec 22 17:54:05 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * make.texinfo (Makefiles: Overriding Makefiles): New node documenting use of .DEFAULT to have one makefile defer unmakeable targets to another. * make.texinfo (Implicit: Using Implicit, Implicit: Last Resort): Mention empty commands and xref node `Empty Commands'. Wed Dec 21 20:12:40 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.29. * make.c (struct command_switch, command_switches, et al): New member `noarg_value', if not nil, ptr to value to use if no arg is given to a switch that would otherwise require one. The -j option can now be given w/o an arg, to mean infinite jobs. * commands.c: If job_slots is zero, infinite jobs. * read.c (read_all_makefiles, read_makefile): Make makefiles precious. * make.c (decode_switches): For a positive_int or floating option, if we moved to the next argument word, but found no argument for the option, move back to the correct word. * make.c (decode_switches): If we got any unknown options, die after processing all arguments. * GNUmakefile: Moved `include depend' to the end, so the default goal will be set before then. * load.c (wait_to_start_job [Unix, UMAX]): Merged into one version under #ifdef LDAV_BASED. Only loop while we have jobs running. Sleep for increasing amounts (increase one second per iteration) before checking the load average (after the first check). Get the load average from function load_average. (wait_to_start_job [not LDAV_BASED]): Always return. (load_average [UMAX]): Fetch load average for Encore UMAX. (load_average [not NO_LDAV]): Fetch load average from /dev/kmem. [not NO_LDAV]: Define LDAV_BASED. Tue Dec 20 18:54:50 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.28. * commands.c (wait_for_children): Take second arg, ERROR. If nonzero, and there are children, print a message on stderr. (execute_file_commands, fatal_error_signal): Pass second arg. * make.c (die), remake.c (update_goal_chain), variable.c (expand_function: `shell'): Ditto. Sat Dec 17 01:05:38 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * commands.c (start_job): Call wait_to_start_job before forking. * load.c (load_average): Converted to wait_to_start_job. * remote.c: New file for remote execution functions. (start_remote_job_p): Return nonzero if the next job should be run remotely. (start_remote_job): Start a remote job and return an ID for it. (remote_status): Get status of dead remote children. Fri Dec 16 16:51:07 1988 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * commands.c (start_job): If start_remote_job_p () returns nonzero, call start_remote_job to start the job rather than fork and exec. (child_handler): * commands.c (execute_file_commands): Moved load average checking to start_job. * commands.c (child_handler: USG): Record the pid wait returns. * load.c (UMAX): Added some #include's needed for UMAX. * read.c (multi_glob), variable.c (string_glob): Ignore a (char **) -1 return from glob_filename. * variable.c (variable_expand): Make sure we don't increment past the end of the string we were passed. * variable.c (variable_expand): Terminate the expansion. * file.c (rename_file): If there is already a file under the new name, set its contents equal to FILE's (ick). * variable.c (define_automatic_variables): Pass all the args to define_variable when defining MAKELEVEL! * commands.c (execute_file_commands): If max_load_average > 0, and we have children running, don't start up another child until the load average goes below max_load_average. * make.c: New variable `max_load_average'. (struct command_switch, decode_switches, decode_env_switches): Handle floating-point (double) args. (command_switches): Added `-l' switch to set `max_load_average'. * load.c (load_average): New file and function to return a double that is the current load average (1.00 scale). * GNUmakefile, oldMakefile: Pass flags in $(LOAD_AVG) for load.c. Thu Dec 15 15:22:08 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Makefile: Renamed to oldMakefile. * GNUmakefile: Make Makefile from oldMakefile and depend. * read.c (read_all_makefiles): When putting the default makefiles in the read_makefiles chain so they will be remade, put them in the right order. * remake.c (update_goal_chain): If MAKEFILES is nonzero, always make in serial, and return as soon as one goal whose `changed' member is nonzero is successfully remade. * commands.c: Don't include . * commands.c (construct_command_argv): Added ` to sh_chars. * make.h: Don't declare construct_makeflags. * make.c (main): Set up MAKEFLAGS and MFLAGS and make an environment both before and after reading the makefiles, so the makefiles can use them and possible change them, and later children will get the right information. (construct_makeflags): Replaced with define_makeflags (static void), which defines the two variables. * variable.c (define_automatic_variables): Don't define MAKEFLAGS and MFLAGS. Mon Dec 12 14:40:31 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * Version 3.27. * commands.c (child_handler): Reset the handler to ourselves when called for USG, since it has no safe signals. * commands.c: For USG, use an int rather than a `union wait' for wait calls, and dissect it with bitmasks. (child_handler): No wait3 system call in USG. Since we can't protect from hanging, always return immediately if we have no children we know about and we're not running a `shell' function. (There is still the danger of hanging waiting for a child that died without our being notified.) * remake.c: Include instead of . What we need is really in , and while BSD includes , USG doesn't. * make.c (main): Figure out the program name before doing anything which might need it (in a call to error or fatal). * dir.c, glob.c: Use `struct dirent' and for USGr3. * arscan.c (ar_scan): Added missing & before buf (which is an int) if SARMAG is not defined (SysV). Fri Dec 9 18:44:13 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Version 3.26. * dir.c (find_directory, dir_file_exists_p): Keep track of how many directories we have open and don't let it be more than MAX_OPEN_DIRECTORIES (currently 10). * variable.c (expand_function: `foreach'): Use expand_argument rather than variable_expand so each repetition doesn't clobber the last!!! Mon Dec 5 15:58:46 1988 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * Version 3.25. * Makefile: Define `install' target. * GNUmakefile: Don't include GNUmakefile or depend in the distribution file. Wed Nov 30 15:53:42 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * commands.c (execute_file_commands): Don't clobber a null into random storage if there were no $^ and/or $? words. * remake.c (check_dep): Set *MUST_MAKE_PTR nonzero if a dependency doesn't exist. * ar.c (ar_member_date, ar_touch): Make sure the modtime of the archive file itself is known before we fetch or change the modtime of one of its members. * read.c (read_makefile): Expand variable and function references before parsing rules so variable can contain special characters (colons and semicolons). Sat Nov 26 11:36:31 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * variable.c (expand_function: `filter', `filter-out'): Fixed so that filter-out works right. * variable.c (expand_function: `filter', `filter-out'): Made these functions use each word of their first argument as a pattern. Fri Nov 25 10:51:47 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.24. * read.c (record_files): If a target is listed more than once in a single rule (that defines commands), give a warning message rather than the counter-intuitive message saying commands were already defined (in the same place). * make.c (fatal, error): Made them both take 6 args since there is at least one error message that need that many. Too bad vfprintf is not universal! * Version 3.23. * read.c (read_makefile): Moved the construction of the `struct commands' into record_files. Call record_files before recursing for an included makefile so the higher-up will determine the default goal. (record_files): Take arguments COMMANDS, COMMANDS_IDX and COMMANDS_STARTED and construct a `struct commands. Thu Nov 24 14:36:33 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.22. * make.c (main): Made it a fatal error if we can't move back to the directory we started in before re-execing. * make.c (main): Get the current directory before doing anything else, so we know it even if we don't need it for the value of `MAKE', since we might want it when re-execing. Wed Nov 23 13:34:44 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.21. * read.c (record_files): Eliminate duplicate deps in a chain. * variable.c (expand_function: `sort'): Pass the right number to qsort, not one less. * remake.c (remake_file): Always call notice_finished_file if FILE->command_state == cs_finished. * commands.c (execute_file_commands): Call notice_finished_file to set FILE's status correctly when start_job fails (because it's out of commands or running under -n). Fri Nov 18 15:31:12 1988 Roland McGrath (mcgrath at saffron.Berkeley.EDU) * Version 3.20. * remake.c (update_file_1): Set the `update_status' of FILE to nonzero and set FILE's `updated' bit if we have decided to give up on remaking FILE because of errors in the dependencies. * rule.c (pattern_search): Debugging messages use `dependency' (vs. `dependent') properly. * make.texinfo (Conditionals: Conditional Syntax): Function index entries for `ifndef' and `ifneq'. * variable.c (define_automatic_variables): Define `MAKELEVEL' to the decimal number of the makelevel, since it may be malformed or blank. * remake.c (remake_file): Call notice_finished_file after touching. Sat Nov 12 19:29:34 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.19. * GNUmakefile (dist): Pass the `-f' flag to compress. * vpath.c (build_vpath_lists): Check for VPATHS being nil after constructing the general VPATH list from the `VPATH' variable. Fri Nov 11 08:02:26 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (fatal, error): Made error messages for recursive runs be shorter. Thu Nov 10 16:51:36 1988 Roland McGrath (mcgrath at basil.Berkeley.EDU) * Version 3.18. * read.c (read_makefile): Made it eat leading spaces and formfeeds (but not tabs), like it's documented to. * read.c (read_makefile): Let included makefiles determine the default goal, as is done by System V Make. Tue Nov 1 19:03:08 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * variable.c (new_environ): Don't increment VCNT when a variable is rejected. Fri Oct 28 16:54:15 1988 Roland McGrath (mcgrath at basil.Berkeley.EDU) * Version 3.17. * rule.c (convert_to_pattern): Don't use the same storage for a name in two rules since new_pattern_rule may free this storage when a rule is discarded. * rule.c (new_pattern_rule): Undid useless change I made Oct 25. Thu Oct 27 19:17:53 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.16. * GNUmakefile, Makefile: Fixed a typo in a comment. * Makefile: Removed malloc.o from object file list. * variable.c: Removed old debugging #define's for xmalloc and xrealloc so non-ANSI cpp's won't barf. * make.c (main): Made local array for temp file name static so compilers that don't do auto aggregate initialization won't barf. * read.c: Removed static declaration of copy_dep_chain since it is no longer static. Tue Oct 25 16:59:30 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * rule.c (new_pattern_rule): If we threw out the new rule because it matched an old one and OVERRIDE was zero, don't put the freed pointer in the chain! Wed Oct 19 15:07:43 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Version 3.15. * variable.c (expand_function: `sort'): Don't do the sorting and writing out if there were no words in the first place. * remake.c (remake_file): Only fail with a "no way to make" message for a dependency (non-target) file. If we don't know how to remake a target file, pretend it was successfully remade and is very new. * remake.c (remake_file): Don't increment `files_remade' for a non-target file we don't know how to remake. * read.c (record_files): Don't die with "both : and :: entries" for a file whose `is_target' flag is not set. Tue Oct 18 17:24:11 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * variable.c (expand_function: `patsubst', `subst'): Free the right things! * variable.c (expand_function: `subst'): Don't clobber the pointer to the end of the second arg and then try to use it!!! Mon Oct 17 16:44:45 1988 Roland McGrath (mcgrath at catnip.Berkeley.EDU) * variable.c (expand_function: `patsubst'): Don't clobber the pointer to the end of the second arg and then try to use it!!! * variable.c (expand_function: `word' function): Made it parse its second argument correctly. * ar.c (ar_touch): Return 1 rather than -1 for on errors. Sat Oct 15 15:12:16 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.14. * GNUmakefile: Removed explicit rule for make.dvi since the built-in implicit rule now works. * rule.c (default_suffix_rules): Fixed .texinfo.dvi rule yet again so that it really works, now that parens are counted. * remake.c (update_file_1): Set FILE's `updated' flag after calling remake_file if it failed or finished immediately. * remake.c (update_file): Use the `updated' flag rather than the command state to decide if a file was fully considered, and therefore might give an "up to date" message. * variable.c (expand_function): Made all functions that take more than one argument count parens of the appropriate flavor in their args and ignore commands nested in parens. Fri Oct 14 18:35:00 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * read.c (read_all_makefiles): Pass second arg to read_makefile for default makefiles. Thu Oct 13 16:40:08 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.13. * GNUmakefile: Added an explicit rule for make.dvi since the built-in .texinfo.dvi implicit rule is screwed up. * rule.c (default_suffix_rules): Added a comment that the .texinfo.dvi rule does not work because of an ahem, feature of Make that at some point will be fixed--er, enhanced to alleviate this difficulty. * rule.c (default_suffix_rules): Fixed Texinfo -> DVI rule (again). * make.texinfo (Commands: Execution): Documented new competing for standard input among children. * commands.c (struct child): Added `good_stdin' flag to tell if this child has the stdin that doesn't point into nirvana. (good_stdin_used): New variable to tell if any child has the good standard input. (child_handler): Reset `good_stdin_used' if a dead child's `good_stdin' flag is set. (start_job): Give the new child the good standard input if `good_stdin_used' is no set, and set the child's `good_stdin' flag appropriately. * rule.c (default_suffix_rules): Changed Texinfo -> DVI rule to work better (I hope). * read.c (read_all_makefiles): Stop reading default makefiles after one is found. * read.c (read_makefile): Reset `reading_filename' and `reading_lineno_ptr' after recursing for an included makefile. * GNUmakefile: New GNU Make-specific makefile that does everything Makefile does plus distribution stuff, and doesn't contain any hacks to try to work with Unix make. * Makefile: Removed distribution stuff. * make.c (main): Use mktemp to construct the names of temporary files used for standard input makefiles. * make.c (main): Don't turn standard input into a broken pipe. * commands.c (start_job): Keep two extra file descriptors around: a good standard input, and a bad one that reads from a broken pipe. On the child side of the fork, if there are other children, give this one the broken pipe so they won't compete; if this is the only one, give it the good standard input. * make.h: Declare notice_finished_file. * commands.c (execute_file_commands): Use noticed_finished_file after waiting for the child when there is only one job slot. * remake.c (notice_finished_file): New function to re-check mtime's and such things to be done when commands finish. (update_file_1): Use notice_finished_file. * commands.c (child_handler, execute_file_commands): Use new variable `job_slots_used' to record the number of jobs currently running, rather than diddling with `job_slots'. (execute_file_commands): Increment `job_slots_used' before calling start_job and decrement it on failure to avoid race condition. If there is only one job slot, wait for the child to finish and return its status so commands are run in linear order, as if there were no parallelism. Wed Oct 12 15:59:03 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * remake.c (remake_file): Don't print a "No way to make" message for targets whose `dontcare' flags are set. * read.c (read_all_makefiles): Set the `dontcare' flag of the `struct file' each default makefile added to the chain. * file.h (struct file): Add `dontcare' member. * read.c (read_all_makefiles): When no default makefiles are found, put the names of all those tried in the `read_makefiles' chain so they will be updated if possible, giving their `struct dep's' `changed' members the value of 0 so we won't care if they cannot be found or remade. * make.texinfo (Makefiles: Remaking Makefiles): Documented that default makefiles will be remade if not found. * read.c (read_all_makefiles): If no default makefiles can be found, go through the list of default names, trying to make one, stopping if one is made. * remake.c (remake_file): Set STATUS to 0 after successfully touching. * dir.c (file_impossible, file_impossible_p): Don't clobber FILENAME to "" and then try to to a strcmp on it!!! Mon Oct 10 16:09:18 1988 Roland McGrath (mcgrath at cinnamon.Berkeley.EDU) * make.c (main): Don't do `dir_load (".")'. * rule.c (count_implicit_rule_limits), vpath.c (construct_vpath_list): Test the existence of a given directory by `dir_file_exists_p (DIR, ".")' and assume that if this returns zero, it means the directory really does not exist. * dir.c (struct dirdata): Replaced with `struct directory' for directories, each containing a chain of `struct dirfiles', one for each file (real or impossible). (dir_load): Removed. (find_directory): New function to find the `struct directory' for a named directory and return it (possibly creating a new one). (dir_file_exists_p): Read the directory on the fly if its stream is still valid (and ever was) if the file we're looking for is not already in the hash tables. (file_impossible, file_impossible_p, dir_name, print_dir_data_base): Use the new directory/file scheme. * make.texinfo: Miscellaneous editorial changes and clarifiactions. * commands.c (struct child): Remove `environ' member. (child_handler, start_job, execute_file_commands): Remove use of `environ' member and new_environ. * make.c (main): Call new_environ after reading makefiles. * variable.h: Declare `new_environ' to return void. * variable.c (new_environ): Put the environment in `environ' and return void. Fri Oct 7 15:48:39 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Version 3.12. * Makefile: Don't make the uncompressed tar file. * variable.c (expand_function: `shell' function): Made it not expect read to null-terminate the buffer. * Makefile: Made it use a temporary symlink to . rather than a temporary directory to make the distribution tar file. Thu Oct 6 17:52:35 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.11. * make.texinfo: Fixed a line that got garbaged somehow. Mon Oct 3 16:14:39 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * make.c (main): Try to move back to the directory we started in before re-exec ourself. * remake.c (update_file_1): A double-colon target with no deps always needs to be remade. * remake.c (remake_file): Changed "No way to make" message to say `target' rather than `file'. Sun Oct 2 12:50:47 1988 Roland McGrath (mcgrath at catnip.Berkeley.EDU) * remake.c (update_file_1): Set FILE->update_status to the return value of remake_file. * rule.c (convert_to_pattern): Fixed swapped lengths passed to xmalloc for source/target suffixes. * make.texinfo: Documented that MAKEFLAGS and MFLAGS are read in from makefiles. Updated the `Features' section a bit. * make.c (main): Read switches from MAKEFLAGS and MFLAGS variables after reading in makefiles. * make.c (main): Put a line "/tmp/foo:;" rather than ".PHONY: /tmp/foo" in front of temp files made for stdin makefiles. * remake.c (update_file): Test the state of the right `struct file' for double-colon files. * make.c (main): Put a ".PHONY: /tmp/foo" line in front of temp files made for stdin makefiles so they won't be remade when we re-exec. Kludge-o-matic!! * remake.c (update_goal_chain): Judge files as being finished based on their `updated' flag, not their state. * read.c (read_makefile): Don't check for FILENAME being "-". (read_all_makefiles): Set each element of MAKEFILES to the name put in READ_MAKEFILES by read_makefile, since read_makefile may free the storage for the name it is passed, and someone might want to look at the elements of MAKEFILES again. * make.c (main): For each `-f' flag with arg `-' (standard input), read standard input into a temp file and pass the temp file's name to read_all_makefiles, after making sure it will not be remade. * make.c (construct_makeflags): Always put out `-j1'. Sat Oct 1 00:19:59 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * commands.c (execute_file_commands): If commands are nothing but whitespace, set the state to `cs_finished' before returning 0. * make.c (decode_switches): Allocate space for args in stringlists so they can be freed later. * make.h: Declare `makelevel'. * variable.c (makelevel): Moved to make.c (and made global). * make.c (fatal, error): Print the makelevel if it's > 0. (perror_with_name): Use error rather than calling fprintf directly. (pfatal_with_name): Use fatal rather than fprintf and die. * variable.c (new_environ): Don't put default variables (origin `o_default') into the environment; they just take up space. * read.c (read_makefile): Don't add FILENAME to the chain of read makefiles if it's "-" (standard input). * remake.c (update_goal_chain): Set STATUS correctly when nothing happens (as well as in all other situations). * make.c (construct_makeflags): Put a `-' before each switch and spaces between them. * Version 3.10. * commands.c (wait_for_children): Don't check if `children' is nil. This is the case when waiting for the child of a `shell' function. * dir.c (dir_load): Don't add a hash-table entry for directory DIRNAME and filename "" if DIRNAME doesn't exist. * commands.c (execute_file_commands): Return 0 after start_job returns 1 (failure) under the -n flag. * remake.c (remake_file): Set the state to `cs_finished' when not calling execute_file_commands. * remake.c (update_goal_chain): Second arg is now MAKEFILES, nonzero meaning to disable -t, -q, and -n for each target unless the target was also given on the command-line. * read.c (read_makefile): Enter the `struct file's for the makefiles added to the `read_makefiles' `struct dep' chain. * remake.c (update_goal_chain): Made it not enter the files for the goals in the chain. It will already have been done. * rule.c (convert_to_pattern): Null-terminate the names of targets and deps of the pattern rules properly. Fri Sep 30 18:56:20 1988 Roland McGrath (mcgrath at nutmeg.Berkeley.EDU) * make.c (main): Call install_default_pattern_rules. * make.h: Declare copy_dep_chain. * read.c (copy_dep_chain): Moved to make.c (and made global). * make.c (main): Call update_goal_chain to update goals. Update read makefiles and re-exec self if they change. * remake.c (update_file): Make this function static. (update_goal_chain): New function to update a `struct dep' chain of goals, waiting until they are all finished before returning. * make.h: Don't declare update_file. Declare update_goal_chain. * make.c (main): Call snap_deps, etc. that were in read_all_makefiles. * read.c (find_makefile): Removed this function. (read_all_makefiles): Don't update makefiles, don't diddle with pattern rules, don't call snap_deps, etc. Return a `struct dep' chain of all makefiles read. (read_makefile): Now takes two args: FILENAME and TYPE, which is 0 for a normal makefile, 1 for MAKEFILES variable or 2 for an included makefile. Add a `struct dep' containing the name of the makefile (as it was found in the search path for type 2s), and TYPE in the `changed' member to the global `read_makefiles' chain. * make.h, rule.c (displace_pattern_rules, add_displaced_pattern_rules): Removed these functions. * read.c (read_makefile): Variable-expand the name of an `include'd makefile before calling find_makefile on it. * file.c (snap_deps): If the `struct file' for a `struct dep' already exists, free the `struct dep's `name' member before setting it to nil (since this info is in the `struct file'). * read.c (copy_dep_chain): Made it copy each name rather than leaving multiple `struct dep's with the same pointers. Thu Sep 29 19:08:13 1988 Roland McGrath (mcgrath at catnip.Berkeley.EDU) * make.c (decode_switches): Fixed second decode_env_switches call to use correct length of "MFLAGS" (6, not 5). * read.c (read_makefile): Don't stop reading when readline returns zero lines read. Only stop when the stream reaches EOF. This makes it recognize the last line of a makefile without a newline. * remake.c (remake_file): If we don't know how to make FILE, set its command state to `cs_finished'. * remake.c (update_file): Don't write the "up to date" message if update_file_1 returned a nonzero status. Wed Sep 28 16:30:07 1988 Roland McGrath (mcgrath at catnip.Berkeley.EDU) * commands.c (child_handler): Set the `update_status' member properly for ignored errors. * rule.c (convert_to_pattern): Made it not care about if the target suffix comes before the source suffix in the .SUFFIXES list. * make.texinfo: Misc editorial changes. * commands.c (wait_for_children): Return immediately if `children' is nil (there are no children). Tue Sep 27 15:33:14 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Version 3.09. * commands.c (struct child): New member `command_ptr' to hold the current position in the commands. The `commands' member is never changed. (start_job, child_handler, execute_file_commands): Use new method for `commands' and `command_ptr' members. * make.c (decode_env_switches): Skip past an invalid letter (instead of looping forever). * commands.c (struct child): Add `environ' member to hold the environment for this child. (execute_file_commands): Get a new environment from new_environ and put in the the new `struct child's `environ' member. (child_handler): When freeing a child, free its `commands' member, the elements of its `environ' array and its `environ' member itself. (start_job): Set `environ' to the child's `environ' member before exec'ing the command. * variable.h, variable.c (new_environ): Made it return the new environment, not putting it in `environ'. * remake.c (update_file): Don't give a "is up to date" message unless no files were remade and the state went from `cs_not_started' to `cs_finished', so repeat calls to finish jobs won't get the message. Mon Sep 26 16:26:08 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * Version 3.08. * make.texinfo (Commands: Execution): Documented that children will be waited for rather than killed. * commands.c (fatal_error_signal): Wait for children. (kill_children): Removed this function. * make.c (main, die): Wait for children to die, don't kill them. * variable.c (expand_function): Use wait_for_children. * make.c (main): Use wait_for_children rather than child_handler. * commands.c (wait_for_children): New function to block waiting for children, insuring that child_handler is not called recursively. (execute_file_commands, kill_children): Use wait_for_children. * commands.c (child_handler): Start up additional commands in a sequence after an ignored error. * remake.c (update_file): Don't print "`foo' is up to date" messages when update_file_1 returns while commands are executing. * remake.c (update_file_1): Pass the file name to name_mtime, not the bloody `struct file', dammit!! * commands.c (child_handler): Print out the "*** ..." error message when not under -i. (I somehow forgot this.) * remake.c (update_file_1): Use name_mtime rather than file_mtime to re-get the mtime of a file whose commands have finished. * make.c (command_switches, decode_switches, decode_env_switches): Make all switches that take string args allow them right after the switch letter. * commands.c (child_handler): Check for a child being the `shell' function's command returning and set the global variable for expand_function to check. * variable.c (expand_function): For the `shell' function, instead of waiting for the child shell ourselves, let child_handler do it and loop around waiting for something to happen. * make.c (print_version): Made the copyright year static, not dynamic. * make.h, make.c: Remove construct_argv function. * make.c (main): Say "no goal target" instead of "no target". * make.texinfo (Commands: Parallel): Don't send SIGKILL. * commands.c (kill_children): Don't send SIGKILL to children that aren't killed by the first signal. * make.c (main), commands.c (kill_children): Decide between SIGCHLD and SIGCLD based on whether or not SIGCHLD is defined, not on USG. * Makefile: Link make with $(LOADLIBES). * read.c (construct_include_path): Fixed another bad xrealloc call. * make.c (decode_switches): Fixed an xrealloc call with no first arg. Sat Sep 24 01:16:21 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * Version 3.07. * remake.c (update_file_1): If deps are running, set state to `cs_deps_running' and return 0. If deps are done, run commands. * commands.c (child_handler): Made it delete non-precious targets killed by fatal signals. * make.texinfo: Documented parallelism. Fri Sep 23 16:52:27 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * remake.c (update_file_1): Don't return if FILE's state is `cs_deps_running'. In that case, we need to run through and check the states of all our dependencies. * commands.c (execute_file_commands): Decrement `job_slots' after starting a new job to run file commands. * commands.c (start_job): Made it set the state to `cs_running'. * make.c (main): Fixed usage of `g', `lastgoal', and `goals' in the goal-making loop. * commands.c (child_handler): When commands finish, set the corresponding file's `update_status' and `updated' flags as appropriate, and reset the modtimes of the file and any `also_make' files it has. * remake.c (remake_file): Don't re-set `last_mtime' and set `updated'. * commands.c (fatal_error_signal): Don't swallow all the children with a loop around `wait ((union wait *) 0)'!!! * make.c (struct command_switch): Added `positive_int' type. (switches): Added -j (job_slots). (construct_makeflags, decode_switches, decode_env_switches): Handle`positive_int'-type switches. * glob.c (glob_vector): Rename local variable `vector' to `VeCtOr'. This is said to avoid a conflict with some system's global `vector' variable. * variable.c (expand_function): Made the `shell' function use construct_command_argv and do its own child control and piping. * make.c (main): Turn standard input into a broken pipe after reading in all makefiles (the last time it will be needed). * commands.c (struct child): Remove `pipe_fd' member. We don't use pipes any more. (start_job): Return 0 for success, 1 or failure (rather than void). Don't use pipes. Don't turn the child's stdin into a broken pipe. (child_handler): Print "*** Error" messages when necessary. Die on failed commands when -k was not given. (execute_file_commands): Check the return of start_job and remove the child from the chain and return failure if it is nonzero. * make.c (die): New function to clean up and exit. (fatal, pfatal_with_name): Use die. Thu Sep 22 14:27:11 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * commands.c (struct child): Added `commands', `pipe_fd', and `noerror' members to keep track of info about a command thread. (start_job): New function to start a job and update the argument `struct child' to reflect its status. (execute_file_commands): Merged run_file_commands back in. Made it use new start_job function. * rule.c (freerule): Don't free the `struct commands' of the discarded rule. It may be used in more than one place. * commands.c (execute_command_line): Made it not try to delete the possibly partly-made file. The child_handler function will do this. (fatal_error_signal): Ditto + call kill_children. * make.h: Declare job_slots. * make.c (main): Collect goals in a dep chain and run through this chain waiting for a child, eliminating finished goals, updating all remaining goals, and quitting if they fail and not -k. * commands.c (child_handler): If called with SIG < 0, - SIG is the max number of children to bury. * commands.c (child_handler): If called with SIG as zero, block waiting for running children. (kill_children): Call child_handler with zero rather than SIGCHLD. * remake.c (update_file_1): Use the `command_state' member of FILE and its dependencies to determine what commands are running, what to do, etc. If commands or dep commands are running when we are called, return success (0). If commands finished since the last time we were called, return their status. * commands.h: Declare kill_children. * commands.c: Define `struct child' to keep track of child processes, with the chain in `children'. (child_handler): New function to catch child-termination signals (SIGCHLD, or SIGCLD for USG), store the returned status in the appropriate structure, take the now-obsolete `struct child' out of the chain, and free its storage. (execute_file_commands): Put all of the stuff invloving running the commands into new function run_file_commands. Execute_file_commands now does process management for the commands, while run_file_commands (which is run in a subprocess) runs the commands. (kill_children): New function to kill all running children by sending them signal SIG. If there are any children still living after they are all sent SIG, they are all sent SIGKILL. * make.c (main): Catch SIGCHLD (SIGCLD for USG) with child_handler. * commands.h: Declare child_handler function. * commands.c (execute_file_commands): Check the `command_state' member of FILE and return 0 if it is `cs_running' or `cs_deps_running' and return the stored status if it is `cs_finished'. * file.h (struct file): Added `command_state' member. * commands.c (execute_command_line): Add `$' to the list of characters special to the shell. Wed Sep 21 15:57:41 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * read.c (read_all_makefiles): Call convert_to_pattern before recomputing the limits after adding the displaced rules. * make.c (main): Move calls to snap_deps, convert_to_pattern, and build_vpath_lists to read_all_makefiles. * read.c (read_all_makefiles): Install the default pattern rules before checking to remake the makefiles, displace these rules before reading in the makefiles, and then add the displaced rules to the chain after reading in all the makefiles. * make.c (main): Don't call install_default_pattern_rules or count_implicit_rule_limits. * make.h: Declare displace_pattern_rules and add_displaced_pattern_rules. * rule.c (displace_pattern_rules, add_displaced_pattern_rules): New functions to stow the chain and add the stowed chain on the end of the current chain. * make.texinfo (Implicit: Search Algorithm): Fixed PREV reference. * make.c (main): Call construct_include_path right after decoding the switches. * read.c (find_makefile): Use rename_file. * file.h: Declare rename_file. * file.c (rename_file): New function to rename a `struct file' and put it in the correct hash bucket. * read.c (find_makefile): New function to find and update a makefile. (read_all_makefilese): Use find_makefile. (read_makefile): Don't do updating. Removed UPDATEIT arg. * remake.c (update_file_1): Took out setting the `updated' member to -1 rather than 1 sometimes. * make.c (main): Made it print version info before doing anything else. * remake.c (library_file_mtime, f_mtime): Removed use of last two arguments to vpath_search. * rule.c (pattern_search): Removed use of last two arguments to vpath_search. * vpath.c (vpath_search, selective_vpath_search): Removed unused DIRPREFIX and DPLEN args. * read.c (read_makefile): Also turn off -n when updating makefiles. Tue Sep 20 17:01:10 1988 Roland McGrath (mcgrath at pepper.Berkeley.EDU) * Makefile: Put tags files in the tarfile. * read.c (read_makefile): Get the modtime of the makefile via a stat call so that a later file_mtime call won't do VPATH search for it. * read.c (read_makefile): Don't turn off -t and -q if the makefile was a command-line target. * make.c (main): Enter command-line targets as files and set their `cmd_target' members. * file.h (struct file): Added `cmd_target' member. * read.c (read_makefile): Temporarily turn off -t and -q while updating makefiles. * make.c (main): Don't use arg 0 from other_args (which is now argv[0]; i.e., the program's name). * read.c (read_makefile): Only return nonzero if commands were actually run to remake the makefile. * remake.c (update_file_1): Set FILE->updated to -1 if no commands were actually run (because no update was done or -t was given). * make.c (decode_switches): Fixed bug wherein xrealloc was passed bad args if it tried to expand other_args->list. * read.c (read_all_makefiles): Made it not look at the `MAKE' variable, just use argv[0]. Sun Sep 18 17:34:11 1988 Roland McGrath (mcgrath at paris.Berkeley.EDU) * read.c (rerun_make): New function to re-exec make. * make.c (construct_makeflags, construct_argv): New functions to construct the `MAKEFLAGS' variable and to construct an arg list from parsed info. * read.c (read_makefile): New arg UPDATEIT, if nonzero, says to update the makefile as a target before reading it in. When reading included makefiles, pass this as zero. Now returns nonzero if the makefile was updated, zero if not. (read_all_makefiles): Pass a nonzero UPDATEIT arg to read_makefile for all default and -f makefiles and all makefiles from the `MAKEFILES' variable. If any of the makefiles has changed, re-exec self to re-read them. * remake.c (update_file): Print a "File `foo' up to date'" message under -p. * commands.c (execute_file_commands): Allocate one byte for each of $^ and $< rather than zero if they are to be empty. Fri Sep 16 13:59:59 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Version 3.06. * make.c (command_switches): Fixed entry for `-o' switch. * make.texinfo: Renamed -c switch to -C. * make.c: Renamed -c switch to -C. * Miscellaneous de-linting. * read.c (record_files): Made it not free the storage for the name if it started with `./' and was therefore not quite the same as in the `struct file'. * read.c (record_files): If commands were specified twice, the error message specifies in what files and at what line numbers. * make.c (main): If any of the signals we usually fatal on were ignored by the parent (probably a shell), ignore them. * make.c (main): Print version info for -v, -p, or -d. (print_data_base): Don't print version info. It will be done in main. * variable.c: Increased number of hash buckets to 257. * file.c: Increased number of hash buckets to 1007. * rule.c (count_implicit_rule_limits): Moved comptation of `maxsuffix' to convert_to_pattern, since that function uses `maxsuffix', and must be called before count_implicit_rule_limits. * rule.c (pattern_search): If an existent (non-intermediate) dependendency was found via a terminal rule, set its `tried_implicit' flag, so it will never have implicit rule search done. * glob.c: Bug fix to avoid alloca(0). * arscan.c: USG and Sun386i fixes. Thu Sep 15 19:40:26 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * make.texinfo: Fixed some typos and spelling errors. Wed Sep 7 14:20:39 1988 Roland McGrath (mcgrath at helen.Berkeley.EDU) * make.c (decode_switches): Fixed bug wherein a bad option would give a useless error message and loop forever. Tue Sep 6 14:36:02 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.texinfo: Documented `shell' function. * variable.c (expand_function): New function `shell', does backquote-style command expansion of its arg. * commands.c (execute_command_line): Second arg OUTBUF, if not nil, gets filled in with a malloc'd buffer containing the piped stdout of the command. (execute_file_commands): Use above (pass nil). Mon Sep 5 17:03:49 1988 Roland McGrath (mcgrath at hecuba.Berkeley.EDU) * Makefile: Added copyright notice. Added a comment about defining `NO_MINUS_C_MINUS_O' if necessary. * Version 3.05. * rule.c (default_suffix_rules): Don't pass `-o' switches with `-c' switches if `NO_MINUS_C_MINUS_O' is #define'd. * make.texinfo: Documented `GNUmakefile'. * read.c (read_all_makefiles): Made it try default makefile `GNUmakefile' before others. * make.texinfo: Added new-style Texinfo header thingies. Sat Sep 3 18:09:39 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * Version 3.04. * make.texinfo (Chained Rules): Added a @cindex about using .PRECIOUS to preserve intermediate files. * remake.c (update_file_1): Made it not just return before executing commands under -p. * rule.c (default_pattern_rules, default_variables): Made it use `$(AR)' for `ar r' (to put files in archives). * vpath.c (build_vpath_lists): Made it recursively expand the `VPATH' variable (by using variable_expand instead of lookup_variable). * read.c (conditional_line): Made it not swallow whitespace after the comma in an `ifeq' using the `(a,b)' syntax. * rule.c (count_implicit_rule_limits): Made it not crash if a pattern rule dep begins with `/'. Sun Aug 28 15:51:12 1988 Roland McGrath (mcgrath at homer.Berkeley.EDU) * make.texinfo: Clarified that the arg to the `origin' function is a variable *name*, not a reference. * make.texinfo: Clarified that both -Idir and -I dir are allowed. Sat Aug 27 13:49:28 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * remake.c (remake_file): Made touching phonies work right. Wed Aug 24 20:40:48 1988 Roland McGrath (mcgrath at nutmeg.Berkeley.EDU) * make.texinfo: Removed reference to `RANLIB' variable. * Version 3.03. * variables.c (expand_function): Added `origin' function. * make.texinfo: Documented same. * read.c (record_files): Made double-colon entries work. Sat Aug 20 21:09:39 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (collapse_continuations): Bug fix from RMS. * rule.c (install_default_pattern_rules): Made it set the `in_use' flag of the created rules to zero, rather than letting it be random garbage. * rule.c (pattern_search): Fixed putting `also make' targets into file strucutres. * read.c (record_files): Fixed bug which made double-colon entries make it read off into space. * make.c (decode_switches): Made it understand `ignored' switches rather than dumping core. Sun Aug 14 16:49:00 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * read.c (read_makefile): Made `include' filenames be variable-expanded. * read.c (read_makefile): Fixed an error message. * read.c (read_makefile): Made it accept ^L's as whitespace. * make.c (next_token, end_of_token): Ditto. * vpath.c (vpath_search): Fixed it so that the general VPATH (from the variable) is always checked, even if a selective VPATH (from a directive) matched the filename. Sat Aug 13 14:20:46 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (decode_switches, main): Made the command switches be processed from a table of switches, variables, and types. No functions are passed argc and argv any more. They are passed arrays of strings they need to process. * read.c (read_all_makefiles): Made it take an array rather than argc and argv. (construct_include_path): Ditto. * make.c (collapse_continuations): Made it work right (I hope). * make.texinfo: Minor editorial changes. * read.c (read_makefile): Minor speed improvement by freeing and then mallocing something rather than reallocing it to avoid the unnecessary bcopy. Thu Aug 11 00:10:43 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.texinfo: Fixed some unquoted @'s. * make.texinfo: Documented multiple-target pattern rules. Miscellaneous minor editorial changes and corrections. * make.texinfo (Implicit: Catalogue of Rules): Removed the list of variables. That's what the next section is for. (Implicit: Implicit Variables): Made it agree with reality. Wed Aug 10 00:55:39 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * variable.c (print_variable_data_base): Fixed bug which made -p dump core. (This was a really idiotic bug.) * rule.c (pattern_search): Fixed a bug which made it make the `also_make' member of the file in question nil if the first of the successful rule's targets was the matching one. Made it use only as much storage as necessary in the `also_make' member. (create_pattern): Made it use only as much storage as necessary in the `lens' and `suffixes' members of the created rule. * remake.c (library_file_mtime): Made it `static'. * file.c: Added a declaration for `errno', which is declared in some 's, but not all. * file.h (struct file): Added `also_make' member for multiple-target implicit rules. * rule.c (pattern_search): Made it put the names of files updated by the given file's commands in its `also_make' member. * remake.c (update_file_1): Made it mark the files in a file's `also_make' member as updated when the file is updated. * variable.c (try_variable_definition): Fixed a bug which made it define a variable with the name of the whole definition when there was no space before the = or :=. * make.texinfo (Features): Made the changes which were made in RCS revision 2.7 but somehow lost since then. Added -W. Tue Aug 9 10:04:50 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * variable.h: Added `o_default' to `enum variable_origin'. * variable.c (print_variable_data_base): Made it print the origins of the variables. * rule.c (install_default_pattern_rules): Made it define the default variables with origin `o_default'. * make.texinfo: Documented -W. * make.c (decode_switches, main): Added the -W flag to give files a time-stamp of now, for a `what if' effect when used with -n. * commands.c (print_commands): Made it say `(built-in)' for commands that are built into the default ruleset. * read.c (record_file): Made .SUFFIXES get its deps frontwards (again). * rule.c (set_default_suffixes, convert_to_pattern): Made it read .SUFFIXES's deps frontwards, so the converted rules will not be in reverse order. * rule.c (new_pattern_rule): Fixed a bug wherein it would keep searching after it had removed a matching rule and ended up diddling with freed storage. * rule.c (freerule): Made it take the given rule off the chain. (new_pattern_rule, count_implicit_rule_limits): Use freerule to remove rules from the chain. * vpath.c (construct_vpath_list): Made it return after cleaning out all previous searchpaths when given a nil DIRPATH arg, so it won't go into the construction code and dump core dereferencing a nil pointer. * variable.c (patsubst_expand): Fixed a bug which made it not match correctly and sometimes dump core. Mon Aug 8 16:35:48 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * rule.c (default_suffix_rules): Made the .texinfo.dvi rule remove the files used in the comparison to determine whether or not a second TeX run is necessary. * make.texinfo: Fixed some overfull TeX hboxes. * make.texinfo (Implicit: Catalogue of Rules): Fixed a Texinfo error. * rule.c (create_pattern_rule): Fixed bug wherein index was not being passed its second arg. * read.c (getline): Merged back into readline. * rule.c (default_suffixes, default_suffix_rules, default_variables): Added .texinfo.info rule. * make.texinfo (Implicit: Catalogue of Rules): Documented .texinfo.dvi and .texinfo.info rules. * make.texinfo (Top): Changed `last updated' date to be correct (for the last time it was updated, not today). Changed `for version 3.00' since it's not going to be called that. Sat Aug 6 19:51:10 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * commands.c (print_commands): Added this function to print the contents of a `struct commands' for -p. * rule.c (print_rule_data_base): Use above. * file.c (print_file_data_base): Ditto. * rule.c (count_implicit_rule_limits, new_pattern_rule, install_pattern_rule, print_rule_data_base): Made it understand the changed `struct rule' and act accordingly. (freerule): Added this function to free all the storage used by a rule. * rule.c (pattern_search): Made it grok multiple targets of pattern rules. The matching is done properly, but at present, only the matching pattern's target is used to give deps and commands. Fri Aug 5 18:00:29 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * rule.c (struct rule): Changed name, namelen, and patsuffix members to targets, lens, and suffixes, which are arrays, for multiple targets. (create_pattern_rule): Now takes first arg TARGETS, a nil-terminated array of targets, rather than a single target and patsuffix pointer. * read.c (record_files): If it finds an implicit pattern rule, it collects all the targets into an array and passes the whole thing to create_pattern_rule. If there are non-pattern targets, it is a fatal error. Tue Aug 2 15:06:38 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (readline): Split backslash-newline checking from reading and buffer-expanding. (getline): Created to do the reading and buffer-expanding formerly done in readline. * rule.c (pattern_search): Made it reject nonterminal match-anything rules when a specific rule has matched, rather than rejecting terminal match-anything rules in this case. * rule.c (convert_to_pattern): Fixed a bug caused when the change to make it only recognize two-suffix rules whose target suffixes precede their dependency suffixes which made it work in the opposite direction (even worse than it started out). * rule.c (pattern_search): Made it reject nonterminal match-anything rules as intermediate targets when searching for both real and intermediate dependencies, rather than only when searching for intermediate ones. Sun Jul 31 00:33:56 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * rule.c (convert_to_pattern): Made it only recognize two-suffix rules whose target suffix comes before the dependency suffix in the .SUFFIXES list. * variable.c (define_automatic_variables): Made all automatic variables be defined with origin `o_automatic'. * variable.h: Added `o_automatic' to `enum variable_origin' * file.c (remove_intermediates): Made it not print an error message if the error was that the file does not exist. * rule.c: Removed `recursive' member from `struct rule'. * remake.c (library_file_mtime): Made it not use the directory hash functions, as reading in and hashing /usr/lib and /lib is slow and most likely unnecessary. * remake.c (remake_file): Changed message from ``No specification for making'' to ``No way to make'' so it will be short enough that most filenames will fit on a line. Made it look at the `recursive' member of the `struct commands', rather than of the `struct file' (which no longer has one). * commands.c (execute_file_commands): Made it look at the `recursive' member of the `struct commands', rather than of the `struct file' (which no longer has one). * file.h: Removed `recursive' member from `struct file'. * commands.h: Added `recursive' member to `struct commands'. * dep.h: Removed unused `quotedparen' member from `struct nameseq' and `struct dep'. * read.c (dequote): Removed this function. (multi_glob): Removed reference to `quotedparen' member of a `struct nameseq' and calls to dequote. * read.c (record_files): Made it set the stem for $* for all static pattern rules, not just those with commands given at that time. Removed check for recursive commands. Made it check for pairs of .SUFFIXES dependencies to reject as default goals as well as single ones (that don't start with dots). (read_makefile): Added checks for recursive commands to set the `recursive' flag in the `struct commands'. Sat Jul 30 15:47:23 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (find_next_token): Made the LENGTHPTR arg optionally nil. * make.c: Removed `files_made' variable which is defined static in remake.c and used only there. (main): Cleaned up somewhat. (decode_switches): Cleaned up a bit. Made an unknown option be a non-fatal error. (decode_env_switches): Made LEN arg unsigned. Cleaned up. (print_version): Made it say ``see the source'' rather than ``see the source file'', since there is more than one. * file.h: Made `num_intermediates' declared unsigned. * file.c: Made `num_intermediates' variable unsigned. (remove_intermediates): Removed unused FORMAT arg. (enter_file): Made it handle double-colon files properly, adding the new entry as the old entry's prev pointer. * dir.c: Re-indented the `struct dir' definition to be right. (dir_load): Cleaned up slighty. (file_exists_p): Removed comment saying we could use `access', since that is a bad idea (except for setuid programs). Cleaned up slightly. * commands.c: Changed some comments slightly. (execute_file_commands): Cleaned up a bit. Changed some comments, added others. Moved freeing of storage for $^ and $? to the same place as for the other automatic variables. (execute_command_line): Made `#' trigger a shell. Added some comments. Cleaned up a bit. Put all the special chars that trigger shells into an array easily changeable at the top. * ar.c: Added comments explaining each function. (ar_scan_1): Merged into ar_member_date. (ar_member_date): Changed call to ar_scan_1 to the body of that function. (ar_member_date_1): Simplified to a ?: expression rather than an if-else statement. (ar_member_touch): Changed error handling around a bit. None of these errors are fatal now. * variable.c (subst_expand): Added a new arg BY_WORD, to do substs only on full words. (patsubst_expand): Fixed bug which made calls whose patterns contained no `%' to not work correctly, by using above. (variable_expand): Pass extra arg to `subst_expand'. * variable.c (expand_function): Fixed bug which made `foreach' calls with one-word lists run off into never-never land. Fri Jul 29 20:12:36 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * variable.c (expand_function): Made a very minor speed improvement by avoiding an unnecessary strlen call. Wed Jul 27 16:01:47 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * rule.c (default_suffixes): Rearranged the list somewhat; added `.el' and `.elc' to speed things up (especially when building Emacs), for the same reason `.h' is there. * read.c (record_files): Changed `lineno' from `long' to `unsigned int'. Sun Jul 24 02:15:30 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * variable.c (expand_function): Eliminated use of `wstok' because it is non-reentrant and unreliable. Fixed a minor bug which would cause something not to be freed. * make.c (wstok): Removed `wstok' because it is no longer used. * variable.c (expand_function): Made `foreach' function put spaces between output texts like it's supposed to. Sat Jul 23 17:32:55 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * rule.c (default_suffixes, default_suffix_rules): Added rule to make %.dvi from %.texinfo. * dir.c (print_dir_data_base): Made it say a bit more. Fri Jul 22 23:13:16 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * make.c (print_data_base): Split this function up into one for each thing. * variable.c (print_variable_data_base): One of the above. * rule.c (print_rule_data_base): Ditto. * file.c (print_file_data_base): Ditto. * dir.c (print_dir_data_base): Ditto. * rule.c (install_pattern_rule): Fixed a bug which caused the terminal and recursive flags to always be zero for rules entered by this function. * make.texinfo (Rules: Double-colon): Added a paragraph explaining the purpose of double-colon rules. * make.texinfo (Implicit: Catalogue of Rules): Updated to reflect new C++, TeX, Web, and Texinfo rules. Other slight editorial changes. * commands.c (execute_file_commands): Fixed a bug wherein random memory could get written for files with no deps. Wed Jul 20 19:30:31 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * read.c (readline): Fix bug wherein it would not recognize a backslash-newline if the buffer filled up and was enlarged right before reading the newline. Tue Jul 19 19:55:02 1988 Roland McGrath (mcgrath at chilli.Berkeley.EDU) * read.c: Added default suffix rules for .cc (using $(C++), which defaults to `g++', and $(C++FLAGS)), .tex, .dvi, .web and .cweb (using $(TEX), $(WEAVE), $(TANGLE), $(CWEAVE) and $(CTANGLE)). Sat Jul 16 21:24:28 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Made error formats use %u rather than %ld for line numbers, which are now unsigned int's rather than long's. * read.c (conditional_line): Fixed some bugs caused by use of unsigned int rather than int in one place. * read.c (conditional_line): Put the info about active conditionals in a struct. (read_makefile): Make a new struct of info about conditionals for included makefiles and restore the old one after the included makefile has been read. * read.c (read_makefile): Don't try to read a makefile with name "" after giving an error message because an `include' directive gave no filename. * read.c (read_makefile): Give an error message for non-whitespace text after the filename in an `include' directive. * make.c (error): Take five args, like `fatal'. It managed to lose with only two. Is there a better way to do this without vfprintf? * read.c (read_makefile): Commands consisting of only whitespace are not the same as no commands. I thought I'd fixed this bug months ago; it seems to have come back. * make.c (collapse_continuations): All whitespace around a backslash-newline combination is turned into a single space. * Added COPYING file and copyright notices to all files. * make.texinfo (Running: Goals): Fix a typo. * read.c (do_define): Take an arg for the origin of the variable being defined. (read_makefile): Grok `override define'. * make.texinfo (Variables: Override Directive, Defining): Document the `override define' combination directive. * ar.c (ar_member_date): Make a 0 return from `ar_scan' return (time_t) -1 (nonexistent file), rather than (time_t) 0, which, when put in the `struct file', makes `file_mtime' try to get the mtime over and over again. * variable.c (pattern_matches): Fix a bug that made patterns not beginning with `%' never match. Fri Jul 15 21:01:44 1988 Roland McGrath (mcgrath at tully.Berkeley.EDU) * Took Make out of RCS. * Split the monolithic `make.c' into several smaller files. make-3.70/NEWS 666 12241 13 44107 5503454670 6206 GNU make NEWS -- history of user-visible changes. 14 December 1993 Copyright (C) 1992, 1993 Free Software Foundation, Inc. See the end for copying conditions. Please send GNU make bug reports to bug-gnu-utils@prep.ai.mit.edu. Version 3.70 * It is no longer a fatal error to have a NUL character in a makefile. You should never put a NUL in a makefile because it can have strange results, but otherwise empty lines full of NULs (such as produced by the `xmkmf' program) will always work fine. * The error messages for nonexistent included makefiles now refer to the makefile name and line number where the `include' appeared, so Emacs's C-x ` command takes you there (in case it's a typo you need to fix). Version 3.69 * Implicit rule search for archive member references is now done in the opposite order from previous versions: the whole target name `LIB(MEM)' first, and just the member name and parentheses `(MEM)' second. * Make now gives an error for an unterminated variable or function reference. For example, `$(foo' with no matching `)' or `${bar' with no matching `}'. * The new default variable `MAKE_VERSION' gives the version number of Make, and a string describing the remote job support compiled in (if any). Thus the value (in this release) is something like `3.69' or `3.69-Customs'. * Commands in an invocation of the `shell' function are no longer run with a modified environment like target commands are. As in versions before 3.68, they now run with the environment that `make' started with. We have reversed the change made in version 3.68 because it turned out to cause a paradoxical situation in cases like: export variable = $(shell echo value) When Make attempted to put this variable in the environment for a target command, it would try expand the value by running the shell command `echo value'. In version 3.68, because it constructed an environment for that shell command in the same way, Make would begin to go into an infinite loop and then get a fatal error when it detected the loop. * The commands given for `.DEFAULT' are now used for phony targets with no commands. Version 3.68 * You can list several archive member names inside parenthesis: `lib(mem1 mem2 mem3)' is equivalent to `lib(mem1) lib(mem2) lib(mem3)'. * You can use wildcards inside archive member references. For example, `lib(*.o)' expands to all existing members of `lib' whose names end in `.o' (e.g. `lib(a.o) lib(b.o)'); `*.a(*.o)' expands to all such members of all existing files whose names end in `.a' (e.g. `foo.a(a.o) foo.a(b.o) bar.a(c.o) bar.a(d.o)'. * A suffix rule `.X.a' now produces two pattern rules: (%.o): %.X # Previous versions produced only this. %.a: %.X # Now produces this as well, just like other suffixes. * The new flag `--warn-undefined-variables' says to issue a warning message whenever Make expands a reference to an undefined variable. * The new `-include' directive is just like `include' except that there is no error (not even a warning) for a nonexistent makefile. * Commands in an invocation of the `shell' function are now run with a modified environment like target commands are, so you can use `export' et al to set up variables for them. They used to run with the environment that `make' started with. Version 3.66 * `make --version' (or `make -v') now exits immediately after printing the version number. Version 3.65 * Make now supports long-named members in `ar' archive files. Version 3.64 * Make now supports the `+=' syntax for a variable definition which appends to the variable's previous value. See the section `Appending More Text to Variables' in the manual for full details. * The new option `--no-print-directory' inhibits the `-w' or `--print-directory' feature. Make turns on `--print-directory' automatically if you use `-C' or `--directory', and in sub-makes; some users have found this behavior undesirable. * The built-in implicit rules now support the alternative extension `.txinfo' for Texinfo files, just like `.texinfo' and `.texi'. Version 3.63 * Make now uses a standard GNU `configure' script. See the new file INSTALL for the new (and much simpler) installation procedure. * There is now a shell script to build Make the first time, if you have no other `make' program. `build.sh' is created by `configure'; see README. * GNU Make now completely conforms to the POSIX.2 specification for `make'. * Elements of the `$^' and `$?' automatic variables that are archive member references now list only the member name, as in Unix and POSIX.2. * You should no longer ever need to specify the `-w' switch, which prints the current directory before and after Make runs. The `-C' switch to change directory, and recursive use of Make, now set `-w' automatically. * Multiple double-colon rules for the same target will no longer have their commands run simultaneously under -j, as this could result in the two commands trying to change the file at the same time and interfering with one another. * The `SHELL' variable is now never taken from the environment. Each makefile that wants a shell other than the default (/bin/sh) must set SHELL itself. SHELL is always exported to child processes. This change was made for compatibility with POSIX.2. * Make now accepts long options. There is now an informative usage message that tells you what all the options are and what they do. Try `make --help'. * There are two new directives: `export' and `unexport'. All variables are no longer automatically put into the environments of the commands that Make runs. Instead, only variables specified on the command line or in the environment are exported by default. To export others, use: export VARIABLE or you can define variables with: export VARIABLE = VALUE or: export VARIABLE := VALUE You can use just: export or: .EXPORT_ALL_VARIABLES: to get the old behavior. See the node `Variables/Recursion' in the manual for a full description. * The commands from the `.DEFAULT' special target are only applied to targets which have no rules at all, not all targets with no commands. This change was made for compatibility with Unix make. * All fatal error messages now contain `***', so they are easy to find in compilation logs. * Dependency file names like `-lNAME' are now replaced with the actual file name found, as with files found by normal directory search (VPATH). The library file `libNAME.a' may now be found in the current directory, which is checked before VPATH; the standard set of directories (/lib, /usr/lib, /usr/local/lib) is now checked last. See the node `Libraries/Search' in the manual for full details. * A single `include' directive can now specify more than one makefile to include, like this: include file1 file2 You can also use shell file name patterns in an `include' directive: include *.mk * The default directories to search for included makefiles, and for libraries specified with `-lNAME', are now set by configuration. * You can now use blanks as well as colons to separate the directories in a search path for the `vpath' directive or the `VPATH' variable. * You can now use variables and functions in the left hand side of a variable assignment, as in "$(foo)bar = value". * The `MAKE' variable is always defined as `$(MAKE_COMMAND) $(MAKEOVERRIDES)'. The `MAKE_COMMAND' variable is now defined to the name with which make was invoked. * The built-in rules for C++ compilation now use the variables `$(CXX)' and `$(CXXFLAGS)' instead of `$(C++)' and `$(C++FLAGS)'. The old names had problems with shells that cannot have `+' in environment variable names. * The value of a recursively expanded variable is now expanded when putting it into the environment for child processes. This change was made for compatibility with Unix make. * A rule with no targets before the `:' is now accepted and ignored. This change was made for compatibility with SunOS 4 make. We do not recommend that you write your makefiles to take advantage of this. * The `-I' switch can now be used in MAKEFLAGS, and are put there automatically just like other switches. Version 3.61 * Built-in rules for C++ source files with the `.C' suffix. We still recommend that you use `.cc' instead. * If commands are given too many times for a single target, the last set given is used, and a warning message is printed. * Error messages about makefiles are in standard GNU error format, so C-x ` in Emacs works on them. * Dependencies of pattern rules which contain no % need not actually exist if they can be created (just like dependencies which do have a %). Version 3.60 * A message is always printed when Make decides there is nothing to be done. It used to be that no message was printed for top-level phony targets (because "`phony' is up to date" isn't quite right). Now a different message "Nothing to be done for `phony'" is printed in that case. * Archives on AIX now supposedly work. * When the commands specified for .DEFAULT are used to update a target, the $< automatic variable is given the same value as $@ for that target. This is how Unix make behaves, and this behavior is mandated by POSIX.2. Version 3.59 * The -n, -q, and -t options are not put in the `MAKEFLAGS' and `MFLAG' variables while remaking makefiles, so recursive makes done while remaking makefiles will behave properly. * If the special target `.NOEXPORT' is specified in a makefile, only variables that came from the environment and variables defined on the command line are exported. Version 3.58 * Suffix rules may have dependencies (which are ignored). Version 3.57 * Dependencies of the form `-lLIB' are searched for as /usr/local/lib/libLIB.a as well as libLIB.a in /usr/lib, /lib, the current directory, and VPATH. Version 3.55 * There is now a Unix man page for GNU Make. It is certainly not a replacement for the Texinfo manual, but it documents the basic functionality and the switches. For full documentation, you should still read the Texinfo manual. Thanks to Dennis Morse of Stanford University for contributing the initial version of this. * Variables which are defined by default (e.g., `CC') will no longer be put into the environment for child processes. (If these variables are reset by the environment, makefiles, or the command line, they will still go into the environment.) * Makefiles which have commands but no dependencies (and thus are always considered out of date and in need of remaking), will not be remade (if they were being remade only because they were makefiles). This means that GNU Make will no longer go into an infinite loop when fed the makefiles that `imake' (necessary to build X Windows) produces. * There is no longer a warning for using the `vpath' directive with an explicit pathname (instead of a `%' pattern). Version 3.51 * When removing intermediate files, only one `rm' command line is printed, listing all file names. * There are now automatic variables `$(^D)', `$(^F)', `$(?D)', and `$(?F)'. These are the directory-only and file-only versions of `$^' and `$?'. * Library dependencies given as `-lNAME' will use "libNAME.a" in the current directory if it exists. * The automatic variable `$($/)' is no longer defined. * Leading `+' characters on a command line make that line be executed even under -n, -t, or -q (as if the line contained `$(MAKE)'). * For command lines containing `$(MAKE)', `${MAKE}', or leading `+' characters, only those lines are executed, not their entire rules. (This is how Unix make behaves for lines containing `$(MAKE)' or `${MAKE}'.) Version 3.50 * Filenames in rules will now have ~ and ~USER expanded. * The `-p' output has been changed so it can be used as a makefile. (All information that isn't specified by makefiles is prefaced with comment characters.) Version 3.49 * The % character can be quoted with backslash in implicit pattern rules, static pattern rules, `vpath' directives, and `patsubst', `filter', and `filter-out' functions. A warning is issued if a `vpath' directive's pattern contains no %. * The `wildcard' variable expansion function now expands ~ and ~USER. * Messages indicating failed commands now contain the target name: make: *** [target] Error 1 * The `-p' output format has been changed somewhat to look more like makefile rules and to give all information that Make has about files. Version 3.48 Version 3.47 * The `-l' switch with no argument removes any previous load-average limit. * When the `-w' switch is in effect, and Make has updated makefiles, it will write a `Leaving directory' messagfe before re-executing itself. This makes the `directory change tracking' changes to Emacs's compilation commands work properly. Version 3.46 * The automatic variable `$*' is now defined for explicit rules, as it is in Unix make. Version 3.45 * The `-j' switch is now put in the MAKEFLAGS and MFLAGS variables when specified without an argument (indicating infinite jobs). The `-l' switch is not always put in the MAKEFLAGS and MFLAGS variables. * Make no longer checks hashed directories after running commands. The behavior implemented in 3.41 caused too much slowdown. Version 3.44 * A dependency is NOT considered newer than its dependent if they have the same modification time. The behavior implemented in 3.43 conflicts with RCS. Version 3.43 * Dependency loops are no longer fatal errors. * A dependency is considered newer than its dependent if they have the same modification time. Version 3.42 * The variables F77 and F77FLAGS are now set by default to $(FC) and $(FFLAGS). Makefiles designed for System V make may use these variables in explicit rules and expect them to be set. Unfortunately, there is no way to make setting these affect the Fortran implicit rules unless FC and FFLAGS are not used (and these are used by BSD make). Version 3.41 * Make now checks to see if its hashed directories are changed by commands. Other makes that hash directories (Sun, 4.3 BSD) don't do this. Version 3.39 * The `shell' function no longer captures standard error output. Version 3.32 * A file beginning with a dot can be the default target if it also contains a slash (e.g., `../bin/foo'). (Unix make allows this as well.) Version 3.31 * Archive member names are truncated to 15 characters. * Yet more USG stuff. * Minimal support for Microport System V (a 16-bit machine and a brain-damaged compiler). This has even lower priority than other USG support, so if it gets beyond trivial, I will take it out completely. * Revamped default implicit rules (not much visible change). * The -d and -p options can come from the environment. Version 3.30 * Improved support for USG and HPUX (hopefully). * A variable reference like `$(foo:a=b)', if `a' contains a `%', is equivalent to `$(patsubst a,b,$(foo))'. * Defining .DEFAULT with no deps or commands clears its commands. * New default implicit rules for .S (cpp, then as), and .sh (copy and make executable). All default implicit rules that use cpp (even indirectly), use $(CPPFLAGS). Version 3.29 * Giving the -j option with no arguments gives you infinite jobs. Version 3.28 * New option: "-l LOAD" says not to start any new jobs while others are running if the load average is not below LOAD (a floating-point number). * There is support in place for implementations of remote command execution in Make. See the file remote.c. Version 3.26 * No more than 10 directories will be kept open at once. (This number can be changed by redefining MAX_OPEN_DIRECTORIES in dir.c.) Version 3.25 * Archive files will have their modification times recorded before doing anything that might change their modification times by updating an archive member. Version 3.20 * The `MAKELEVEL' variable is defined for use by makefiles. Version 3.19 * The recursion level indications in error messages are much shorter than they were in version 3.14. Version 3.18 * Leading spaces before directives are ignored (as documented). * Included makefiles can determine the default goal target. (System V Make does it this way, so we are being compatible). Version 3.14. * Variables that are defaults built into Make will not be put in the environment for children. This just saves some environment space and, except under -e, will be transparent to sub-makes. * Error messages from sub-makes will indicate the level of recursion. * Hopefully some speed-up for large directories due to a change in the directory hashing scheme. * One child will always get a standard input that is usable. * Default makefiles that don't exist will be remade and read in. Version 3.13. * Count parentheses inside expansion function calls so you can have nested calls: `$(sort $(foreach x,a b,$(x)))'. Version 3.12. * Several bug fixes, including USG and Sun386i support. * `shell' function to expand shell commands a la ` * If the `-d' flag is given, version information will be printed. * The `-c' option has been renamed to `-C' for compatibility with tar. * The `-p' option no longer inhibits other normal operation. * Makefiles will be updated and re-read if necessary. * Can now run several commands at once (parallelism), -j option. * Error messages will contain the level of Make recursion, if any. * The `MAKEFLAGS' and `MFLAGS' variables will be scanned for options after makefiles are read. * A double-colon rule with no dependencies will always have its commands run. (This is how both the BSD and System V versions of Make do it.) Version 3.05 (Changes from versions 1 through 3.05 were never recorded. Sorry.) ---------------------------------------------------------------------- Copyright information: Copyright (C) 1992, 1993 Free Software Foundation, Inc. Permission is granted to anyone to make or distribute verbatim copies of this document as received, in any medium, provided that the copyright notice and this permission notice are preserved, thus giving the recipient permission to redistribute in turn. Permission is granted to distribute modified versions of this document, or of portions of it, under the above conditions, provided also that they carry prominent notices stating who last changed them. Local variables: version-control: never end: make-3.70/configure 777 12241 13 166563 5506426726 7455 #!/bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated automatically using autoconf version 1.7.1 # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. # This configure script 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 2, or (at your option) # any later version. # This script 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 this program; if not, write to the Free Software # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. # Usage: configure [--srcdir=DIR] [--host=HOST] [--gas] [--nfp] # [--prefix=PREFIX] [--exec-prefix=PREFIX] [--with-PACKAGE[=VALUE]] # Ignores all args except --srcdir, --prefix, --exec-prefix, and # --with-PACKAGE[=VALUE] unless this script has special code to handle it. for arg do # Handle --exec-prefix with a space before the argument. if test x$next_exec_prefix = xyes; then exec_prefix=$arg; next_exec_prefix= # Handle --host with a space before the argument. elif test x$next_host = xyes; then next_host= # Handle --prefix with a space before the argument. elif test x$next_prefix = xyes; then prefix=$arg; next_prefix= # Handle --srcdir with a space before the argument. elif test x$next_srcdir = xyes; then srcdir=$arg; next_srcdir= else case $arg in # For backward compatibility, recognize -exec-prefix and --exec_prefix. -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* | --exec=* | --exe=* | --ex=* | --e=*) exec_prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- | --exec | --exe | --ex | --e) next_exec_prefix=yes ;; -gas | --gas | --ga | --g) ;; -host=* | --host=* | --hos=* | --ho=* | --h=*) ;; -host | --host | --hos | --ho | --h) next_host=yes ;; -nfp | --nfp | --nf) ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=`echo $arg | sed 's/[-a-z_]*=//'` ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) next_prefix=yes ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*) srcdir=`echo $arg | sed 's/[-a-z_]*=//'` ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s) next_srcdir=yes ;; -with-* | --with-*) package=`echo $arg|sed -e 's/-*with-//' -e 's/=.*//'` # Reject names that aren't valid shell variable names. if test -n "`echo $package| sed 's/[-a-zA-Z0-9_]//g'`"; then echo "configure: $package: invalid package name" >&2; exit 1 fi package=`echo $package| sed 's/-/_/g'` case "$arg" in *=*) val="`echo $arg|sed 's/[^=]*=//'`" ;; *) val=1 ;; esac eval "with_$package='$val'" ;; -v | -verbose | --verbose | --verbos | --verbo | --verb | --ver | --ve | --v) verbose=yes ;; *) ;; esac fi done trap 'rm -fr conftest* confdefs* core $ac_clean_files; exit 1' 1 3 15 trap 'rm -f confdefs* $ac_clean_files' 0 # NLS nuisances. # These must not be set unconditionally because not all systems understand # e.g. LANG=C (notably SCO). if test "${LC_ALL+set}" = 'set' ; then LC_ALL=C; export LC_ALL; fi if test "${LANG+set}" = 'set' ; then LANG=C; export LANG; fi rm -rf conftest* confdefs.h # AIX cpp loses on an empty file, so make sure it contains at least a newline. echo > confdefs.h compile='${CC-cc} $CFLAGS conftest.c -o conftest $LIBS >/dev/null 2>&1' # A filename unique to this package, relative to the directory that # configure is in, which we can look for to find out if srcdir is correct. unique_file=vpath.c # Find the source files, if location was not specified. if test -z "$srcdir"; then srcdirdefaulted=yes # Try the directory containing this script, then `..'. prog=$0 confdir=`echo $prog|sed 's%/[^/][^/]*$%%'` test "X$confdir" = "X$prog" && confdir=. srcdir=$confdir if test ! -r $srcdir/$unique_file; then srcdir=.. fi fi if test ! -r $srcdir/$unique_file; then if test x$srcdirdefaulted = xyes; then echo "configure: Can not find sources in \`${confdir}' or \`..'." 1>&2 else echo "configure: Can not find sources in \`${srcdir}'." 1>&2 fi exit 1 fi # Preserve a srcdir of `.' to avoid automounter screwups with pwd. # But we can't avoid them for `..', to make subdirectories work. case $srcdir in .|/*|~*) ;; *) srcdir=`cd $srcdir; pwd` ;; # Make relative path absolute. esac # Save the original args to write them into config.status later. configure_args="$*" # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g test -z "$LDFLAGS" && LDFLAGS=-g if test -z "$CC"; then # Extract the first word of `gcc', so it can be a program name with args. set dummy gcc; word=$2 echo checking for $word IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/$word; then CC="gcc" break fi done IFS="$saveifs" fi test -z "$CC" && CC="cc" test -n "$CC" && test -n "$verbose" && echo " setting CC to $CC" # Find out if we are using GNU C, under whatever name. cat > conftest.c < conftest.out 2>&1 if egrep yes conftest.out >/dev/null 2>&1; then GCC=1 # For later tests. fi rm -f conftest* # Make sure to not get the incompatible SysV /etc/install and # /usr/sbin/install, which might be in PATH before a BSD-like install, # or the SunOS /usr/etc/install directory, or the AIX /bin/install, # or the AFS install, which mishandles nonexistent args, or # /usr/ucb/install on SVR4, which tries to use the nonexistent group # `staff'. On most BSDish systems install is in /usr/bin, not /usr/ucb # anyway. Sigh. if test "z${INSTALL}" = "z" ; then echo checking for install IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do #test -z "$dir" && dir=. case "$dir" in ''|.|/etc|/usr/sbin|/usr/etc|/usr/afsws/bin|/usr/ucb) ;; *) if test -f $dir/installbsd; then INSTALL="$dir/installbsd -c" # OSF1 INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi if test -f $dir/install; then if grep dspmsg $dir/install >/dev/null 2>&1; then : # AIX else INSTALL="$dir/install -c" INSTALL_PROGRAM='$(INSTALL)' INSTALL_DATA='$(INSTALL) -m 644' break fi fi ;; esac done IFS="$saveifs" fi if test -z "$INSTALL"; then if test -f ${srcdir}/install.sh; then # As a last resort, use the slow shell script. # We want the top-level source directory, not the subdir's srcdir, # so expand srcdir now rather than in the Makefile. INSTALL="${srcdir}/install.sh -c" else echo "warning: ${srcdir}/install.sh not found; using cp" INSTALL=cp fi fi test -n "$verbose" && echo " setting INSTALL to $INSTALL" INSTALL_PROGRAM=${INSTALL_PROGRAM-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_PROGRAM to $INSTALL_PROGRAM" INSTALL_DATA=${INSTALL_DATA-'$(INSTALL)'} test -n "$verbose" && echo " setting INSTALL_DATA to $INSTALL_DATA" if test -z "$RANLIB"; then # Extract the first word of `ranlib', so it can be a program name with args. set dummy ranlib; word=$2 echo checking for $word IFS="${IFS= }"; saveifs="$IFS"; IFS="${IFS}:" for dir in $PATH; do test -z "$dir" && dir=. if test -f $dir/$word; then RANLIB="ranlib" break fi done IFS="$saveifs" fi test -z "$RANLIB" && RANLIB=":" test -n "$RANLIB" && test -n "$verbose" && echo " setting RANLIB to $RANLIB" echo checking how to run the C preprocessor if test -z "$CPP"; then # This must be in double quotes, not single quotes, because CPP may get # substituted into the Makefile and ``${CC-cc}'' will simply confuse # make. It must be expanded now. CPP="${CC-cc} -E" cat > conftest.c < Syntax Error EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then : else rm -rf conftest* CPP="${CC-cc} -E -traditional-cpp" cat > conftest.c < Syntax Error EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then : else rm -rf conftest* CPP=/lib/cpp fi rm -f conftest* fi rm -f conftest* fi test ".${verbose}" != "." && echo " setting CPP to $CPP" echo checking for AIX cat > conftest.c < conftest.out 2>&1" if egrep "yes" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining _ALL_SOURCE" echo "#define _ALL_SOURCE 1" >> confdefs.h DEFS="$DEFS -D_ALL_SOURCE=1" SEDDEFS="${SEDDEFS}\${SEDdA}_ALL_SOURCE\${SEDdB}_ALL_SOURCE\${SEDdC}1\${SEDdD} \${SEDuA}_ALL_SOURCE\${SEDuB}_ALL_SOURCE\${SEDuC}1\${SEDuD} \${SEDeA}_ALL_SOURCE\${SEDeB}_ALL_SOURCE\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for POSIXized ISC if test -d /etc/conf/kconfig.d && grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1 then ISC=1 # If later tests want to check for ISC. { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define _POSIX_SOURCE 1" >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD} \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD} \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD} " } if test -n "$GCC"; then CC="$CC -posix" else CC="$CC -Xp" fi fi echo checking for minix/config.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* MINIX=1 fi rm -f conftest* # The Minix shell can't assign to the same variable on the same line! if test -n "$MINIX"; then { test -n "$verbose" && \ echo " defining _POSIX_SOURCE" echo "#define _POSIX_SOURCE 1" >> confdefs.h DEFS="$DEFS -D_POSIX_SOURCE=1" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_SOURCE\${SEDdB}_POSIX_SOURCE\${SEDdC}1\${SEDdD} \${SEDuA}_POSIX_SOURCE\${SEDuB}_POSIX_SOURCE\${SEDuC}1\${SEDuD} \${SEDeA}_POSIX_SOURCE\${SEDeB}_POSIX_SOURCE\${SEDeC}1\${SEDeD} " } { test -n "$verbose" && \ echo " defining _POSIX_1_SOURCE to be 2" echo "#define _POSIX_1_SOURCE 2" >> confdefs.h DEFS="$DEFS -D_POSIX_1_SOURCE=2" SEDDEFS="${SEDDEFS}\${SEDdA}_POSIX_1_SOURCE\${SEDdB}_POSIX_1_SOURCE\${SEDdC}2\${SEDdD} \${SEDuA}_POSIX_1_SOURCE\${SEDuB}_POSIX_1_SOURCE\${SEDuC}2\${SEDuD} \${SEDeA}_POSIX_1_SOURCE\${SEDeB}_POSIX_1_SOURCE\${SEDeC}2\${SEDeD} " } { test -n "$verbose" && \ echo " defining _MINIX" echo "#define _MINIX 1" >> confdefs.h DEFS="$DEFS -D_MINIX=1" SEDDEFS="${SEDDEFS}\${SEDdA}_MINIX\${SEDdB}_MINIX\${SEDdC}1\${SEDdD} \${SEDuA}_MINIX\${SEDuB}_MINIX\${SEDuC}1\${SEDuD} \${SEDeA}_MINIX\${SEDeB}_MINIX\${SEDeC}1\${SEDeD} " } fi echo checking for ANSI C header files cat > conftest.c < #include #include #include EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* # SunOS 4.x string.h does not declare mem*, contrary to ANSI. echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "memchr" conftest.out >/dev/null 2>&1; then rm -rf conftest* # SGI's /bin/cc from Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. cat > conftest.c < #define ISLOWER(c) ('a' <= (c) && (c) <= 'z') #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #define XOR(e,f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2); exit (0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "free" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining STDC_HEADERS" echo "#define STDC_HEADERS 1" >> confdefs.h DEFS="$DEFS -DSTDC_HEADERS=1" SEDDEFS="${SEDDEFS}\${SEDdA}STDC_HEADERS\${SEDdB}STDC_HEADERS\${SEDdC}1\${SEDdD} \${SEDuA}STDC_HEADERS\${SEDuB}STDC_HEADERS\${SEDuC}1\${SEDuD} \${SEDeA}STDC_HEADERS\${SEDeB}STDC_HEADERS\${SEDeC}1\${SEDeD} " } fi rm -f conftest* fi rm -fr conftest* fi rm -f conftest* fi rm -f conftest* echo checking for directory library header dirheader= if test -z "$dirheader"; then echo checking for dirent.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = 0; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining DIRENT" echo "#define DIRENT 1" >> confdefs.h DEFS="$DEFS -DDIRENT=1" SEDDEFS="${SEDDEFS}\${SEDdA}DIRENT\${SEDdB}DIRENT\${SEDdC}1\${SEDdD} \${SEDuA}DIRENT\${SEDuB}DIRENT\${SEDuC}1\${SEDuD} \${SEDeA}DIRENT\${SEDeB}DIRENT\${SEDeC}1\${SEDeD} " } dirheader=dirent.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for sys/ndir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = 0; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining SYSNDIR" echo "#define SYSNDIR 1" >> confdefs.h DEFS="$DEFS -DSYSNDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}SYSNDIR\${SEDdB}SYSNDIR\${SEDdC}1\${SEDdD} \${SEDuA}SYSNDIR\${SEDuB}SYSNDIR\${SEDuC}1\${SEDuD} \${SEDeA}SYSNDIR\${SEDeB}SYSNDIR\${SEDeC}1\${SEDeD} " } dirheader=sys/ndir.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for sys/dir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = 0; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining SYSDIR" echo "#define SYSDIR 1" >> confdefs.h DEFS="$DEFS -DSYSDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}SYSDIR\${SEDdB}SYSDIR\${SEDdC}1\${SEDdD} \${SEDuA}SYSDIR\${SEDuB}SYSDIR\${SEDuC}1\${SEDuD} \${SEDeA}SYSDIR\${SEDeB}SYSDIR\${SEDeC}1\${SEDeD} " } dirheader=sys/dir.h fi rm -f conftest* fi if test -z "$dirheader"; then echo checking for ndir.h cat > conftest.c < #include int main() { exit(0); } int t() { DIR *dirp = 0; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining NDIR" echo "#define NDIR 1" >> confdefs.h DEFS="$DEFS -DNDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}NDIR\${SEDdB}NDIR\${SEDdC}1\${SEDdD} \${SEDuA}NDIR\${SEDuB}NDIR\${SEDuC}1\${SEDuD} \${SEDeA}NDIR\${SEDeB}NDIR\${SEDeC}1\${SEDeD} " } dirheader=ndir.h fi rm -f conftest* fi echo checking for closedir return value cat > conftest.c < #include <$dirheader> int closedir(); main() { exit(closedir(opendir(".")) != 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then : else { test -n "$verbose" && \ echo " defining VOID_CLOSEDIR" echo "#define VOID_CLOSEDIR 1" >> confdefs.h DEFS="$DEFS -DVOID_CLOSEDIR=1" SEDDEFS="${SEDDEFS}\${SEDdA}VOID_CLOSEDIR\${SEDdB}VOID_CLOSEDIR\${SEDdC}1\${SEDdD} \${SEDuA}VOID_CLOSEDIR\${SEDuB}VOID_CLOSEDIR\${SEDuC}1\${SEDuD} \${SEDeA}VOID_CLOSEDIR\${SEDeB}VOID_CLOSEDIR\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* echo checking for uid_t in sys/types.h echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "uid_t" conftest.out >/dev/null 2>&1; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining uid_t to be int" echo "#define uid_t int" >> confdefs.h DEFS="$DEFS -Duid_t=int" SEDDEFS="${SEDDEFS}\${SEDdA}uid_t\${SEDdB}uid_t\${SEDdC}int\${SEDdD} \${SEDuA}uid_t\${SEDuB}uid_t\${SEDuC}int\${SEDuD} \${SEDeA}uid_t\${SEDeB}uid_t\${SEDeC}int\${SEDeD} " } { test -n "$verbose" && \ echo " defining gid_t to be int" echo "#define gid_t int" >> confdefs.h DEFS="$DEFS -Dgid_t=int" SEDDEFS="${SEDDEFS}\${SEDdA}gid_t\${SEDdB}gid_t\${SEDdC}int\${SEDdD} \${SEDuA}gid_t\${SEDuB}gid_t\${SEDuC}int\${SEDuD} \${SEDeA}gid_t\${SEDeB}gid_t\${SEDeC}int\${SEDeD} " } fi rm -f conftest* echo checking for type of array argument to getgroups prog='/* Thanks to Mike Rendell for this test. */ #include #define NGID 256 #undef MAX #define MAX(x,y) ((x) > (y) ? (x) : (y)) main() { gid_t gidset[NGID]; int i, n; union { gid_t gval; long lval; } val; val.lval = -1; for (i = 0; i < NGID; i++) gidset[i] = val.gval; n = getgroups (sizeof (gidset) / MAX (sizeof (int), sizeof (gid_t)) - 1, gidset); /* Exit non-zero if getgroups seems to require an array of ints. This happens when gid_t is short but getgroups modifies an array of ints. */ exit ((n > 0 && gidset[n] != val.gval) ? 1 : 0); }' cat > conftest.c </dev/null; then { test -n "$verbose" && \ echo " defining GETGROUPS_T to be gid_t" echo "#define GETGROUPS_T gid_t" >> confdefs.h DEFS="$DEFS -DGETGROUPS_T=gid_t" SEDDEFS="${SEDDEFS}\${SEDdA}GETGROUPS_T\${SEDdB}GETGROUPS_T\${SEDdC}gid_t\${SEDdD} \${SEDuA}GETGROUPS_T\${SEDuB}GETGROUPS_T\${SEDuC}gid_t\${SEDuD} \${SEDeA}GETGROUPS_T\${SEDeB}GETGROUPS_T\${SEDeC}gid_t\${SEDeD} " } else { test -n "$verbose" && \ echo " defining GETGROUPS_T to be int" echo "#define GETGROUPS_T int" >> confdefs.h DEFS="$DEFS -DGETGROUPS_T=int" SEDDEFS="${SEDDEFS}\${SEDdA}GETGROUPS_T\${SEDdB}GETGROUPS_T\${SEDdC}int\${SEDdD} \${SEDuA}GETGROUPS_T\${SEDuB}GETGROUPS_T\${SEDuC}int\${SEDuD} \${SEDeA}GETGROUPS_T\${SEDeB}GETGROUPS_T\${SEDeC}int\${SEDeD} " } fi rm -fr conftest* echo checking for pid_t in sys/types.h echo '#include "confdefs.h" #include ' > conftest.c eval "$CPP conftest.c > conftest.out 2>&1" if egrep "pid_t" conftest.out >/dev/null 2>&1; then : else rm -rf conftest* { test -n "$verbose" && \ echo " defining pid_t to be int" echo "#define pid_t int" >> confdefs.h DEFS="$DEFS -Dpid_t=int" SEDDEFS="${SEDDEFS}\${SEDdA}pid_t\${SEDdB}pid_t\${SEDdC}int\${SEDdD} \${SEDuA}pid_t\${SEDuB}pid_t\${SEDuC}int\${SEDuD} \${SEDeA}pid_t\${SEDeB}pid_t\${SEDeC}int\${SEDeD} " } fi rm -f conftest* echo checking for return type of signal handlers cat > conftest.c < #include #ifdef signal #undef signal #endif extern void (*signal ()) (); int main() { exit(0); } int t() { int i; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining RETSIGTYPE to be void" echo "#define RETSIGTYPE void" >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=void" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}void\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}void\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}void\${SEDeD} " } else rm -rf conftest* { test -n "$verbose" && \ echo " defining RETSIGTYPE to be int" echo "#define RETSIGTYPE int" >> confdefs.h DEFS="$DEFS -DRETSIGTYPE=int" SEDDEFS="${SEDDEFS}\${SEDdA}RETSIGTYPE\${SEDdB}RETSIGTYPE\${SEDdC}int\${SEDdD} \${SEDuA}RETSIGTYPE\${SEDuB}RETSIGTYPE\${SEDuC}int\${SEDuD} \${SEDeA}RETSIGTYPE\${SEDeB}RETSIGTYPE\${SEDeC}int\${SEDeD} " } fi rm -f conftest* for hdr in unistd.h limits.h sys/param.h fcntl.h string.h memory.h \ sys/timeb.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define ${trhdr} 1" >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done echo checking whether $CC and cc understand -c and -o together echo 'foo(){}' > conftest.c # Make sure it works both with $CC and with simple cc. # We do the test twice because some compilers refuse to overwrite an # existing .o file with -o, though they will create one. if ${CC-cc} -c conftest.c -o conftest.o >/dev/null 2>&1 \ && test -f conftest.o && ${CC-cc} -c conftest.c -o conftest.o >/dev/null 2>&1 then # Test first that cc exists at all. if cc -c conftest.c >/dev/null 2>&1 then if cc -c conftest.c -o conftest2.o >/dev/null 2>&1 && \ test -f conftest2.o && cc -c conftest.c -o conftest2.o >/dev/null 2>&1 then : else { test -n "$verbose" && \ echo " defining NO_MINUS_C_MINUS_O" echo "#define NO_MINUS_C_MINUS_O 1" >> confdefs.h DEFS="$DEFS -DNO_MINUS_C_MINUS_O=1" SEDDEFS="${SEDDEFS}\${SEDdA}NO_MINUS_C_MINUS_O\${SEDdB}NO_MINUS_C_MINUS_O\${SEDdC}1\${SEDdD} \${SEDuA}NO_MINUS_C_MINUS_O\${SEDuB}NO_MINUS_C_MINUS_O\${SEDuC}1\${SEDuD} \${SEDeA}NO_MINUS_C_MINUS_O\${SEDeB}NO_MINUS_C_MINUS_O\${SEDeC}1\${SEDeD} " } fi fi else { test -n "$verbose" && \ echo " defining NO_MINUS_C_MINUS_O" echo "#define NO_MINUS_C_MINUS_O 1" >> confdefs.h DEFS="$DEFS -DNO_MINUS_C_MINUS_O=1" SEDDEFS="${SEDDEFS}\${SEDdA}NO_MINUS_C_MINUS_O\${SEDdB}NO_MINUS_C_MINUS_O\${SEDdC}1\${SEDdD} \${SEDuA}NO_MINUS_C_MINUS_O\${SEDuB}NO_MINUS_C_MINUS_O\${SEDuC}1\${SEDuD} \${SEDeA}NO_MINUS_C_MINUS_O\${SEDeB}NO_MINUS_C_MINUS_O\${SEDeC}1\${SEDeD} " } fi rm -f conftest* prog='/* Ultrix mips cc rejects this. */ typedef int charset[2]; const charset x; /* SunOS 4.1.1 cc rejects this. */ char const *const *ccp; char **p; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; ccp = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++ccp; p = (char**) ccp; ccp = (char const *const *) p; { /* SCO 3.2v4 cc rejects this. */ char *t; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25,17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; }; struct s *b; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; }' echo checking for lack of working const cat > conftest.c <> confdefs.h DEFS="$DEFS -Dconst=" SEDDEFS="${SEDDEFS}\${SEDdA}const\${SEDdB}const\${SEDdC}\${SEDdD} \${SEDuA}const\${SEDuB}const\${SEDuC}\${SEDuD} \${SEDeA}const\${SEDeB}const\${SEDeC}\${SEDeD} " } fi rm -f conftest* echo checking for broken stat file mode macros cat > conftest.c < #include #ifdef S_ISBLK #if S_ISBLK (S_IFDIR) You lose. #endif #ifdef S_IFCHR #if S_ISBLK (S_IFCHR) You lose. #endif #endif /* S_IFCHR */ #endif /* S_ISBLK */ #ifdef S_ISLNK #if S_ISLNK (S_IFREG) You lose. #endif #endif /* S_ISLNK */ #ifdef S_ISSOCK #if S_ISSOCK (S_IFREG) You lose. #endif #endif /* S_ISSOCK */ EOF eval "$CPP conftest.c > conftest.out 2>&1" if egrep "You lose" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining STAT_MACROS_BROKEN" echo "#define STAT_MACROS_BROKEN 1" >> confdefs.h DEFS="$DEFS -DSTAT_MACROS_BROKEN=1" SEDDEFS="${SEDDEFS}\${SEDdA}STAT_MACROS_BROKEN\${SEDdB}STAT_MACROS_BROKEN\${SEDdC}1\${SEDdD} \${SEDuA}STAT_MACROS_BROKEN\${SEDuB}STAT_MACROS_BROKEN\${SEDuC}1\${SEDuD} \${SEDeA}STAT_MACROS_BROKEN\${SEDeB}STAT_MACROS_BROKEN\${SEDeC}1\${SEDeD} " } fi rm -f conftest* for func in getdtablesize sys_siglist _sys_siglist psignal \ dup2 getcwd sigsetmask getgroups setlinebuf \ setreuid setregid strerror do trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'` echo checking for ${func} cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trfunc}" echo "#define ${trfunc} 1" >> confdefs.h DEFS="$DEFS -D${trfunc}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD} \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD} \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works # for constant arguments. Useless! echo checking for working alloca.h cat > conftest.c < int main() { exit(0); } int t() { char *p = alloca(2 * sizeof(int)); } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_ALLOCA_H" echo "#define HAVE_ALLOCA_H 1" >> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA_H\${SEDdB}HAVE_ALLOCA_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ALLOCA_H\${SEDuB}HAVE_ALLOCA_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ALLOCA_H\${SEDeB}HAVE_ALLOCA_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* decl="#ifdef __GNUC__ #define alloca __builtin_alloca #else #if HAVE_ALLOCA_H #include #else #ifdef _AIX #pragma alloca #else char *alloca (); #endif #endif #endif " echo checking for alloca cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_ALLOCA=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_ALLOCA\${SEDdB}HAVE_ALLOCA\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_ALLOCA\${SEDuB}HAVE_ALLOCA\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_ALLOCA\${SEDeB}HAVE_ALLOCA\${SEDeC}1\${SEDeD} " } else rm -rf conftest* alloca_missing=1 cat > conftest.c < conftest.out 2>&1" if egrep "winnitude" conftest.out >/dev/null 2>&1; then rm -rf conftest* echo checking for _getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub__getb67) || defined (__stub____getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char _getb67(); _getb67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining CRAY_STACKSEG_END to be _getb67" echo "#define CRAY_STACKSEG_END _getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=_getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}_getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}_getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}_getb67\${SEDeD} " } else rm -rf conftest* echo checking for GETB67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_GETB67) || defined (__stub___GETB67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char GETB67(); GETB67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining CRAY_STACKSEG_END to be GETB67" echo "#define CRAY_STACKSEG_END GETB67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=GETB67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}GETB67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}GETB67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}GETB67\${SEDeD} " } else rm -rf conftest* echo checking for getb67 cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_getb67) || defined (__stub___getb67) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char getb67(); getb67(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining CRAY_STACKSEG_END to be getb67" echo "#define CRAY_STACKSEG_END getb67" >> confdefs.h DEFS="$DEFS -DCRAY_STACKSEG_END=getb67" SEDDEFS="${SEDDEFS}\${SEDdA}CRAY_STACKSEG_END\${SEDdB}CRAY_STACKSEG_END\${SEDdC}getb67\${SEDdD} \${SEDuA}CRAY_STACKSEG_END\${SEDuB}CRAY_STACKSEG_END\${SEDuC}getb67\${SEDuD} \${SEDeA}CRAY_STACKSEG_END\${SEDeB}CRAY_STACKSEG_END\${SEDeC}getb67\${SEDeD} " } fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* fi rm -f conftest* if test -n "$alloca_missing"; then # The SVR3 libPW and SVR4 libucb both contain incompatible functions # that cause trouble. Some versions do not even contain alloca or # contain a buggy version. If you still want to use their alloca, # use ar to extract alloca.o from them instead of compiling alloca.c. ALLOCA=alloca.o { test -n "$verbose" && \ echo " defining C_ALLOCA" echo "#define C_ALLOCA 1" >> confdefs.h DEFS="$DEFS -DC_ALLOCA=1" SEDDEFS="${SEDDEFS}\${SEDdA}C_ALLOCA\${SEDdB}C_ALLOCA\${SEDdC}1\${SEDdD} \${SEDuA}C_ALLOCA\${SEDuB}C_ALLOCA\${SEDuC}1\${SEDuD} \${SEDeA}C_ALLOCA\${SEDeB}C_ALLOCA\${SEDeC}1\${SEDeD} " } echo 'checking stack direction for C alloca' echo checking whether cross-compiling # If we cannot run a trivial program, we must be cross compiling. cat > conftest.c </dev/null; then : else cross_compiling=1 fi rm -fr conftest* if test -n "$cross_compiling" then { test -n "$verbose" && \ echo " defining STACK_DIRECTION to be 0" echo "#define STACK_DIRECTION 0" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=0" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}0\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}0\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}0\${SEDeD} " } else cat > conftest.c < addr) ? 1 : -1; } main () { exit (find_stack_direction() < 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining STACK_DIRECTION to be 1" echo "#define STACK_DIRECTION 1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}1\${SEDeD} " } else { test -n "$verbose" && \ echo " defining STACK_DIRECTION to be -1" echo "#define STACK_DIRECTION -1" >> confdefs.h DEFS="$DEFS -DSTACK_DIRECTION=-1" SEDDEFS="${SEDDEFS}\${SEDdA}STACK_DIRECTION\${SEDdB}STACK_DIRECTION\${SEDdC}-1\${SEDdD} \${SEDuA}STACK_DIRECTION\${SEDuB}STACK_DIRECTION\${SEDuC}-1\${SEDuD} \${SEDeA}STACK_DIRECTION\${SEDeB}STACK_DIRECTION\${SEDeC}-1\${SEDeD} " } fi fi rm -fr conftest* fi echo checking for vfork.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_VFORK_H" echo "#define HAVE_VFORK_H 1" >> confdefs.h DEFS="$DEFS -DHAVE_VFORK_H=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_VFORK_H\${SEDdB}HAVE_VFORK_H\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_VFORK_H\${SEDuB}HAVE_VFORK_H\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_VFORK_H\${SEDeB}HAVE_VFORK_H\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for working vfork cat > conftest.c < #include #include #include #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_VFORK_H #include #endif static int signalled; static RETSIGTYPE catch (s) int s; { signalled = 1; } main() { pid_t parent = getpid (); pid_t child; signal (SIGINT, catch); child = vfork (); if (child == 0) { /* On sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include , but some compilers (e.g. gcc -O) don't grok . Test for this by using lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can't possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. */ pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); /* Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. */ if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1); /* On some systems (e.g. SunOS 5.2), if the parent is catching a signal, the child ignores the signal before execing, and the parent later receives that signal, the parent dumps core. Test for this by ignoring SIGINT in the child. */ signal (SIGINT, SIG_IGN); /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent from child file descriptors. If the child closes a descriptor before it execs or exits, this munges the parent's descriptor as well. Test for this by closing stdout in the child. */ _exit(close(fileno(stdout)) != 0); } else { int status; struct stat st; while (wait(&status) != child) ; exit( /* Was there some problem with vforking? */ child < 0 /* Did the child fail? (This shouldn't happen.) */ || status /* Did the vfork/compiler bug occur? */ || parent != getpid() /* Did the signal handling bug occur? */ || kill(parent, SIGINT) != 0 || signalled != 1 /* Did the file descriptor bug occur? */ || fstat(fileno(stdout), &st) != 0 ); } } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then : else { test -n "$verbose" && \ echo " defining vfork to be fork" echo "#define vfork fork" >> confdefs.h DEFS="$DEFS -Dvfork=fork" SEDDEFS="${SEDDEFS}\${SEDdA}vfork\${SEDdB}vfork\${SEDdC}fork\${SEDdD} \${SEDuA}vfork\${SEDuB}vfork\${SEDuC}fork\${SEDuD} \${SEDeA}vfork\${SEDeB}vfork\${SEDeC}fork\${SEDeD} " } fi rm -fr conftest* cat > conftest.c < /* If setvbuf has the reversed format, exit 0. */ main () { /* This call has the arguments reversed. A reversed system may check and see that the address of main is not _IOLBF, _IONBF, or _IOFBF, and return nonzero. */ if (setvbuf(stdout, _IOLBF, (char *) main, BUFSIZ) != 0) exit(1); putc('\r', stdout); exit(0); /* Non-reversed systems segv here. */ } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining SETVBUF_REVERSED" echo "#define SETVBUF_REVERSED 1" >> confdefs.h DEFS="$DEFS -DSETVBUF_REVERSED=1" SEDDEFS="${SEDDEFS}\${SEDdA}SETVBUF_REVERSED\${SEDdB}SETVBUF_REVERSED\${SEDdC}1\${SEDdD} \${SEDuA}SETVBUF_REVERSED\${SEDuB}SETVBUF_REVERSED\${SEDuC}1\${SEDuD} \${SEDeA}SETVBUF_REVERSED\${SEDeB}SETVBUF_REVERSED\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* rm -f core # Some definitions of getloadavg require that the program be installed setgid. NEED_SETGID=false need_func=true # Check for the 4.4BSD definition of getloadavg. LIBS_save="${LIBS}" LIBS="${LIBS} -lutil" have_lib="" echo checking for -lutil cat > conftest.c < conftest.c < conftest.c < conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then : else rm -rf conftest* LIBOBJS="$LIBOBJS ${func}.o" test -n "$verbose" && echo " using ${func}.o instead" fi rm -f conftest* done case "$LIBOBJS" in *getloadavg*) need_func=true echo checking for sys/dg_sys_info.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining DGUX" echo "#define DGUX 1" >> confdefs.h DEFS="$DEFS -DDGUX=1" SEDDEFS="${SEDDEFS}\${SEDdA}DGUX\${SEDdB}DGUX\${SEDdC}1\${SEDdD} \${SEDuA}DGUX\${SEDuB}DGUX\${SEDuC}1\${SEDuD} \${SEDeA}DGUX\${SEDeB}DGUX\${SEDeC}1\${SEDeD} " } need_func=false # Some versions of DGUX need -ldgc for dg_sys_info. LIBS_save="${LIBS}" LIBS="${LIBS} -ldgc" have_lib="" echo checking for -ldgc cat > conftest.c <> confdefs.h DEFS="$DEFS -DHAVE_LIBDGC=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_LIBDGC\${SEDdB}HAVE_LIBDGC\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_LIBDGC\${SEDuB}HAVE_LIBDGC\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_LIBDGC\${SEDeB}HAVE_LIBDGC\${SEDeC}1\${SEDeD} " } LIBS="${LIBS} -ldgc" fi fi rm -f conftest* if $need_func; then # We cannot check for , because Solaris 2 does not use dwarf (it # uses stabs), but it's still SVR4. We cannot check for because # Irix 4.0.5F has the header but not the library. LIBS_save="${LIBS}" LIBS="${LIBS} -lelf" have_lib="" echo checking for -lelf cat > conftest.c <> confdefs.h DEFS="$DEFS -DSVR4=1" SEDDEFS="${SEDDEFS}\${SEDdA}SVR4\${SEDdB}SVR4\${SEDdC}1\${SEDdD} \${SEDuA}SVR4\${SEDuB}SVR4\${SEDuC}1\${SEDuD} \${SEDeA}SVR4\${SEDeB}SVR4\${SEDeC}1\${SEDeD} " } LIBS="$LIBS -lelf" need_func=false LIBS_save="${LIBS}" LIBS="${LIBS} -lkvm" have_lib="" echo checking for -lkvm cat > conftest.c < conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining UMAX4_3" echo "#define UMAX4_3 1" >> confdefs.h DEFS="$DEFS -DUMAX4_3=1" SEDDEFS="${SEDDEFS}\${SEDdA}UMAX4_3\${SEDdB}UMAX4_3\${SEDdC}1\${SEDdD} \${SEDuA}UMAX4_3\${SEDuB}UMAX4_3\${SEDuC}1\${SEDuD} \${SEDeA}UMAX4_3\${SEDeB}UMAX4_3\${SEDeC}1\${SEDeD} " } { test -n "$verbose" && \ echo " defining UMAX" echo "#define UMAX 1" >> confdefs.h DEFS="$DEFS -DUMAX=1" SEDDEFS="${SEDDEFS}\${SEDdA}UMAX\${SEDdB}UMAX\${SEDdC}1\${SEDdD} \${SEDuA}UMAX\${SEDuB}UMAX\${SEDuC}1\${SEDuD} \${SEDeA}UMAX\${SEDeB}UMAX\${SEDeC}1\${SEDeD} " } need_func=false fi rm -f conftest* fi if $need_func; then echo checking for sys/cpustats.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining UMAX" echo "#define UMAX 1" >> confdefs.h DEFS="$DEFS -DUMAX=1" SEDDEFS="${SEDDEFS}\${SEDdA}UMAX\${SEDdB}UMAX\${SEDdC}1\${SEDdD} \${SEDuA}UMAX\${SEDuB}UMAX\${SEDuC}1\${SEDuD} \${SEDeA}UMAX\${SEDeB}UMAX\${SEDeC}1\${SEDeD} " } need_func=false fi rm -f conftest* fi if $need_func; then for hdr in mach/mach.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define ${trhdr} 1" >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done fi echo checking for nlist.h cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining NLIST_STRUCT" echo "#define NLIST_STRUCT 1" >> confdefs.h DEFS="$DEFS -DNLIST_STRUCT=1" SEDDEFS="${SEDDEFS}\${SEDdA}NLIST_STRUCT\${SEDdB}NLIST_STRUCT\${SEDdC}1\${SEDdD} \${SEDuA}NLIST_STRUCT\${SEDuB}NLIST_STRUCT\${SEDuC}1\${SEDuD} \${SEDeA}NLIST_STRUCT\${SEDeB}NLIST_STRUCT\${SEDeC}1\${SEDeD} " } echo checking for n_un in struct nlist cat > conftest.c < int main() { exit(0); } int t() { struct nlist n; n.n_un.n_name = 0; } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining NLIST_NAME_UNION" echo "#define NLIST_NAME_UNION 1" >> confdefs.h DEFS="$DEFS -DNLIST_NAME_UNION=1" SEDDEFS="${SEDDEFS}\${SEDdA}NLIST_NAME_UNION\${SEDdB}NLIST_NAME_UNION\${SEDdC}1\${SEDdD} \${SEDuA}NLIST_NAME_UNION\${SEDuB}NLIST_NAME_UNION\${SEDuC}1\${SEDuD} \${SEDeA}NLIST_NAME_UNION\${SEDeB}NLIST_NAME_UNION\${SEDeC}1\${SEDeD} " } fi rm -f conftest* fi rm -f conftest* # Figure out whether we will need to install setgid. cat > conftest.c < conftest.out 2>&1" if egrep "Yowza Am I SETGID yet" conftest.out >/dev/null 2>&1; then rm -rf conftest* { test -n "$verbose" && \ echo " defining GETLOADAVG_PRIVILEGED" echo "#define GETLOADAVG_PRIVILEGED 1" >> confdefs.h DEFS="$DEFS -DGETLOADAVG_PRIVILEGED=1" SEDDEFS="${SEDDEFS}\${SEDdA}GETLOADAVG_PRIVILEGED\${SEDdB}GETLOADAVG_PRIVILEGED\${SEDdC}1\${SEDdD} \${SEDuA}GETLOADAVG_PRIVILEGED\${SEDuB}GETLOADAVG_PRIVILEGED\${SEDuC}1\${SEDuD} \${SEDeA}GETLOADAVG_PRIVILEGED\${SEDeB}GETLOADAVG_PRIVILEGED\${SEDeC}1\${SEDeD} " } NEED_SETGID=true fi rm -f conftest* ;; *) { test -n "$verbose" && \ echo " defining HAVE_GETLOADAVG" echo "#define HAVE_GETLOADAVG 1" >> confdefs.h DEFS="$DEFS -DHAVE_GETLOADAVG=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_GETLOADAVG\${SEDdB}HAVE_GETLOADAVG\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_GETLOADAVG\${SEDuB}HAVE_GETLOADAVG\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_GETLOADAVG\${SEDeB}HAVE_GETLOADAVG\${SEDeC}1\${SEDeD} " } ;; esac if $NEED_SETGID; then # Figure out what group owns /dev/kmem. # The installed program will need to be setgid and owned by that group. # On Solaris, /dev/kmem is a symlink. Get info on the real file. ls_output=`ls -lgL /dev/kmem 2>/dev/null` # If we got an error (system does not support symlinks), try without -L. test -z "$ls_output" && ls_output=`ls -lg /dev/kmem` KMEM_GROUP=`echo $ls_output \ | sed -ne 's/[ ][ ]*/ /g; s/^.[sSrwx-]* *[0-9]* *\([^0-9]*\) *.*/\1/; / /s/.* //;p;'` fi echo checking for strcoll cat > conftest.c < main () { exit (strcoll ("abc", "def") >= 0 || strcoll ("ABC", "DEF") >= 0 || strcoll ("123", "456") >= 0); } EOF eval $compile if test -s conftest && (./conftest; exit) 2>/dev/null; then { test -n "$verbose" && \ echo " defining HAVE_STRCOLL" echo "#define HAVE_STRCOLL 1" >> confdefs.h DEFS="$DEFS -DHAVE_STRCOLL=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_STRCOLL\${SEDdB}HAVE_STRCOLL\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_STRCOLL\${SEDuB}HAVE_STRCOLL\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_STRCOLL\${SEDeB}HAVE_STRCOLL\${SEDeC}1\${SEDeD} " } fi rm -fr conftest* for hdr in sys/wait.h do trhdr=HAVE_`echo $hdr | tr '[a-z]./' '[A-Z]__'` echo checking for ${hdr} cat > conftest.c < EOF err=`eval "($CPP conftest.c >/dev/null) 2>&1"` if test -z "$err"; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trhdr}" echo "#define ${trhdr} 1" >> confdefs.h DEFS="$DEFS -D${trhdr}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trhdr}\${SEDdB}${trhdr}\${SEDdC}1\${SEDdD} \${SEDuA}${trhdr}\${SEDuB}${trhdr}\${SEDuC}1\${SEDuD} \${SEDeA}${trhdr}\${SEDeB}${trhdr}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done for func in waitpid wait3 do trfunc=HAVE_`echo $func | tr '[a-z]' '[A-Z]'` echo checking for ${func} cat > conftest.c < int main() { exit(0); } int t() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_${func}) || defined (__stub___${func}) choke me #else /* Override any gcc2 internal prototype to avoid an error. */ extern char ${func}(); ${func}(); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining ${trfunc}" echo "#define ${trfunc} 1" >> confdefs.h DEFS="$DEFS -D${trfunc}=1" SEDDEFS="${SEDDEFS}\${SEDdA}${trfunc}\${SEDdB}${trfunc}\${SEDdC}1\${SEDdD} \${SEDuA}${trfunc}\${SEDuB}${trfunc}\${SEDuC}1\${SEDuD} \${SEDeA}${trfunc}\${SEDeB}${trfunc}\${SEDeC}1\${SEDeD} " } fi rm -f conftest* done echo checking for union wait cat > conftest.c < #include int main() { exit(0); } int t() { union wait status; int pid; pid = wait (&status); #ifdef WEXITSTATUS /* Some POSIXoid systems have both the new-style macros and the old union wait type, and they do not work together. If union wait conflicts with WEXITSTATUS et al, we don't want to use it at all. */ if (WEXITSTATUS (status) != 0) pid = -1; #endif #ifdef HAVE_WAITPID /* Make sure union wait works with waitpid. */ pid = waitpid (-1, &status, 0); #endif } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining HAVE_UNION_WAIT" echo "#define HAVE_UNION_WAIT 1" >> confdefs.h DEFS="$DEFS -DHAVE_UNION_WAIT=1" SEDDEFS="${SEDDEFS}\${SEDdA}HAVE_UNION_WAIT\${SEDdB}HAVE_UNION_WAIT\${SEDdC}1\${SEDdD} \${SEDuA}HAVE_UNION_WAIT\${SEDuB}HAVE_UNION_WAIT\${SEDuC}1\${SEDuD} \${SEDeA}HAVE_UNION_WAIT\${SEDeB}HAVE_UNION_WAIT\${SEDeC}1\${SEDeD} " } fi rm -f conftest* echo checking for sys_siglist declaration in signal.h or unistd.h cat > conftest.c < /* NetBSD declares sys_siglist in . */ #ifdef HAVE_UNISTD_H #include #endif int main() { exit(0); } int t() { char *msg = *(sys_siglist + 1); } EOF if eval $compile; then rm -rf conftest* { test -n "$verbose" && \ echo " defining SYS_SIGLIST_DECLARED" echo "#define SYS_SIGLIST_DECLARED 1" >> confdefs.h DEFS="$DEFS -DSYS_SIGLIST_DECLARED=1" SEDDEFS="${SEDDEFS}\${SEDdA}SYS_SIGLIST_DECLARED\${SEDdB}SYS_SIGLIST_DECLARED\${SEDdC}1\${SEDdD} \${SEDuA}SYS_SIGLIST_DECLARED\${SEDuB}SYS_SIGLIST_DECLARED\${SEDuC}1\${SEDuD} \${SEDeA}SYS_SIGLIST_DECLARED\${SEDeB}SYS_SIGLIST_DECLARED\${SEDeC}1\${SEDeD} " } fi rm -f conftest* # The presence of the following is not meant to imply # that make necessarily works on those systems. LIBS_save="${LIBS}" LIBS="${LIBS} -lseq" have_lib="" echo checking for -lseq cat > conftest.c < conftest.c < conftest.out 2>&1" if egrep "yes" conftest.out >/dev/null 2>&1; then rm -rf conftest* XENIX=1 fi rm -f conftest* if test -n "$XENIX"; then LIBS="$LIBS -lx" case "$DEFS" in *SYSNDIR*) ;; *) LIBS="-ldir $LIBS" ;; # Make sure -ldir precedes any -lx. esac fi LIBS_save="${LIBS}" LIBS="${LIBS} -lsun" have_lib="" echo checking for -lsun cat > conftest.c <> confdefs.h DEFS="$DEFS -DSCCS_GET=\"/usr/sccs/get\"" SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET\${SEDdB}SCCS_GET\${SEDdC}\"/usr/sccs/get\"\${SEDdD} \${SEDuA}SCCS_GET\${SEDuB}SCCS_GET\${SEDuC}\"/usr/sccs/get\"\${SEDuD} \${SEDeA}SCCS_GET\${SEDeB}SCCS_GET\${SEDeC}\"/usr/sccs/get\"\${SEDeD} " } else SCCS_GET=get { test -n "$verbose" && \ echo " defining SCCS_GET to be \"get\"" echo "#define SCCS_GET \"get\"" >> confdefs.h DEFS="$DEFS -DSCCS_GET=\"get\"" SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET\${SEDdB}SCCS_GET\${SEDdC}\"get\"\${SEDdD} \${SEDuA}SCCS_GET\${SEDuB}SCCS_GET\${SEDuC}\"get\"\${SEDuD} \${SEDeA}SCCS_GET\${SEDeB}SCCS_GET\${SEDeC}\"get\"\${SEDeD} " } fi ac_clean_files="$ac_clean_files s.conftest conftoast" # Remove these later. if ( /usr/sccs/admin -n s.conftest || admin -n s.conftest ) >/dev/null 2>&1 && test -f s.conftest; then # We successfully created an SCCS file. echo checking if SCCS get command understands -G if $SCCS_GET s.conftest -Gconftoast >/dev/null 2>&1 && test -f conftoast; then { test -n "$verbose" && \ echo " defining SCCS_GET_MINUS_G" echo "#define SCCS_GET_MINUS_G 1" >> confdefs.h DEFS="$DEFS -DSCCS_GET_MINUS_G=1" SEDDEFS="${SEDDEFS}\${SEDdA}SCCS_GET_MINUS_G\${SEDdB}SCCS_GET_MINUS_G\${SEDdC}1\${SEDdD} \${SEDuA}SCCS_GET_MINUS_G\${SEDuB}SCCS_GET_MINUS_G\${SEDuC}1\${SEDuD} \${SEDeA}SCCS_GET_MINUS_G\${SEDeB}SCCS_GET_MINUS_G\${SEDeC}1\${SEDeD} " } fi fi rm -f s.conftest conftoast # Set default prefixes. if test "z$prefix" != 'z' ; then test "z$exec_prefix" = 'z' && exec_prefix='${prefix}' prsub="s%^prefix\\([ ]*\\)=\\([ ]*\\).*$%prefix\\1=\\2$prefix%" fi if test -n "$exec_prefix"; then prsub="$prsub s%^exec_prefix\\([ ]*\\)=\\([ ]*\\).*$%exec_prefix\\1=\\2$exec_prefix%" fi # Quote sed substitution magic chars in DEFS. cat >conftest.def < config.status </dev/null | sed 1q`: # # $0 $configure_args for arg do case "\$arg" in -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) echo running \${CONFIG_SHELL-/bin/sh} $0 $configure_args exec \${CONFIG_SHELL-/bin/sh} $0 $configure_args ;; *) echo "Usage: config.status --recheck" 2>&1; exit 1 ;; esac done trap 'rm -fr Makefile build.sh glob/Makefile config.h conftest*; exit 1' 1 3 15 CFLAGS='$CFLAGS' LDFLAGS='$LDFLAGS' CC='$CC' INSTALL='$INSTALL' INSTALL_PROGRAM='$INSTALL_PROGRAM' INSTALL_DATA='$INSTALL_DATA' RANLIB='$RANLIB' CPP='$CPP' LIBOBJS='$LIBOBJS' ALLOCA='$ALLOCA' NEED_SETGID='$NEED_SETGID' KMEM_GROUP='$KMEM_GROUP' REMOTE='$REMOTE' LIBS='$LIBS' srcdir='$srcdir' prefix='$prefix' exec_prefix='$exec_prefix' prsub='$prsub' extrasub='$extrasub' EOF cat >> config.status <<\EOF top_srcdir=$srcdir CONFIG_FILES=${CONFIG_FILES-"Makefile build.sh glob/Makefile"} for file in .. ${CONFIG_FILES}; do if test "x$file" != x..; then srcdir=$top_srcdir # Remove last slash and all that follows it. Not all systems have dirname. dir=`echo $file|sed 's%/[^/][^/]*$%%'` if test "$dir" != "$file"; then test "$top_srcdir" != . && srcdir=$top_srcdir/$dir test ! -d "$dir" && mkdir "$dir" fi echo creating "$file" rm -f "$file" comment_str="Generated automatically from `echo $file|sed 's|.*/||'`.in by configure." case "$file" in *.c | *.h | *.C | *.cc | *.m ) echo "/* $comment_str */" > "$file" ;; * ) echo "# $comment_str" > "$file" ;; esac sed -e " $prsub $extrasub s%@CFLAGS@%$CFLAGS%g s%@LDFLAGS@%$LDFLAGS%g s%@CC@%$CC%g s%@INSTALL@%$INSTALL%g s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g s%@INSTALL_DATA@%$INSTALL_DATA%g s%@RANLIB@%$RANLIB%g s%@CPP@%$CPP%g s%@LIBOBJS@%$LIBOBJS%g s%@ALLOCA@%$ALLOCA%g s%@NEED_SETGID@%$NEED_SETGID%g s%@KMEM_GROUP@%$KMEM_GROUP%g s%@REMOTE@%$REMOTE%g s%@LIBS@%$LIBS%g s%@srcdir@%$srcdir%g s%@DEFS@%-DHAVE_CONFIG_H%" $top_srcdir/${file}.in >> $file fi; done CONFIG_HEADERS=${CONFIG_HEADERS-"config.h"} for file in .. ${CONFIG_HEADERS}; do if test "x$file" != x..; then echo creating $file # These sed commands are put into SEDDEFS when defining a macro. # They are broken into pieces to make the sed script easier to manage. # They are passed to sed as "A NAME B NAME C VALUE D", where NAME # is the cpp macro being defined and VALUE is the value it is being given. # Each defining turns into a single global substitution command. # Hopefully no one uses "!" as a variable value. # Other candidates for the sed separators, like , and @, do get used. # # SEDd sets the value in "#define NAME VALUE" lines. SEDdA='s!^\([ ]*\)#\([ ]*define[ ][ ]*\)' SEDdB='\([ ][ ]*\)[^ ]*!\1#\2' SEDdC='\3' SEDdD='!g' # SEDu turns "#undef NAME" with trailing blanks into "#define NAME VALUE". SEDuA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDuB='\([ ]\)!\1#\2define\3' SEDuC=' ' SEDuD='\4!g' # SEDe turns "#undef NAME" without trailing blanks into "#define NAME VALUE". SEDeA='s!^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)' SEDeB='$!\1#\2define\3' SEDeC=' ' SEDeD='!g' rm -f conftest.sed EOF # Turn off quoting long enough to insert the sed commands. rm -f conftest.sh cat > conftest.sh < conftest.s1 # Like head -20. sed 1,${maxshlines}d conftest.sh > conftest.s2 # Like tail +21. # Write a limited-size here document to append to conftest.sed. echo 'cat >> conftest.sed <> config.status cat conftest.s1 >> config.status echo 'CONFEOF' >> config.status rm -f conftest.s1 conftest.sh mv conftest.s2 conftest.sh done rm -f conftest.sh # Now back to your regularly scheduled config.status. cat >> config.status <<\EOF # This sed command replaces #undef's with comments. This is necessary, for # example, in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it in # config.h. cat >> conftest.sed <<\CONFEOF s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */, CONFEOF rm -f conftest.h # Break up the sed commands because old seds have small limits. maxsedlines=20 cp $top_srcdir/$file.in conftest.h1 while : do lines=`grep -c . conftest.sed` if test -z "$lines" || test "$lines" -eq 0; then break; fi rm -f conftest.s1 conftest.s2 conftest.h2 sed ${maxsedlines}q conftest.sed > conftest.s1 # Like head -20. sed 1,${maxsedlines}d conftest.sed > conftest.s2 # Like tail +21. sed -f conftest.s1 < conftest.h1 > conftest.h2 rm -f conftest.s1 conftest.h1 conftest.sed mv conftest.h2 conftest.h1 mv conftest.s2 conftest.sed done rm -f conftest.sed conftest.h echo "/* $file. Generated automatically by configure. */" > conftest.h cat conftest.h1 >> conftest.h rm -f conftest.h1 if cmp -s $file conftest.h 2>/dev/null; then # The file exists and we would not be changing it. echo "$file is unchanged" rm -f conftest.h else rm -f $file mv conftest.h $file fi fi; done # Makefile uses this timestamp file to know when to remake Makefile, # build.sh, and glob/Makefile. touch stamp-config exit 0 EOF chmod +x config.status ${CONFIG_SHELL-/bin/sh} config.status make-3.70/Makefile.in 666 12241 13 24343 5512122115 7536 # NOTE: If you have no `make' program at all to process this makefile, run # `build.sh' instead. # # Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. # This file is part of GNU Make. # # GNU Make 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 2, or (at your option) # any later version. # # GNU Make 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 Make; see the file COPYING. If not, write to # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. # # Makefile for GNU Make # # Ultrix 2.2 make doesn't expand the value of VPATH. VPATH = @srcdir@ srcdir = $(VPATH) CC = @CC@ CFLAGS = @CFLAGS@ LDFLAGS = @LDFLAGS@ # How to invoke ranlib. This is only used by the `glob' subdirectory. RANLIB = @RANLIB@ # Define these for your system as follows: # -DNO_ARCHIVES To disable `ar' archive support. # -DNO_FLOAT To avoid using floating-point numbers. # -DENUM_BITFIELDS If the compiler isn't GCC but groks enum foo:2. # Some compilers apparently accept this # without complaint but produce losing code, # so beware. # NeXT 1.0a uses an old version of GCC, which required -D__inline=inline. # See also `config.h'. defines = @DEFS@ -DLIBDIR=\"$(libdir)\" -DINCLUDEDIR=\"$(includedir)\" # Which flavor of remote job execution support to use. # The code is found in `remote-$(REMOTE).c'. REMOTE = @REMOTE@ # If you are using the GNU C library, or have the GNU getopt functions in # your C library, you can comment these out. GETOPT = getopt.o getopt1.o GETOPT_SRC = $(srcdir)/getopt.c $(srcdir)/getopt1.c $(srcdir)/getopt.h # If you are using the GNU C library, or have the GNU glob functions in # your C library, you can comment this out. GNU make uses special hooks # into the glob functions to be more efficient (by using make's directory # cache for globbing), so you must use the GNU functions even if your # system's C library has the 1003.2 glob functions already. Also, the glob # functions in the AIX and HPUX C libraries are said to be buggy. GLOB = glob/libglob.a # If your system doesn't have alloca, or the one provided is bad, define this. ALLOCA = @ALLOCA@ ALLOCA_SRC = $(srcdir)/alloca.c # If your system needs extra libraries loaded in, define them here. # System V probably need -lPW for alloca. HP-UX 7.0's alloca in # libPW.a is broken on HP9000s300 and HP9000s400 machines. Use # alloca.c instead on those machines. LOADLIBES = @LIBS@ # Any extra object files your system needs. extras = @LIBOBJS@ # Common prefix for machine-independent installed files. prefix = /usr/local # Common prefix for machine-dependent installed files. exec_prefix = $(prefix) # Name under which to install GNU make. instname = make # Directory to install `make' in. bindir = $(exec_prefix)/bin # Directory to find libraries in for `-lXXX'. libdir = $(exec_prefix)/lib # Directory to search by default for included makefiles. includedir = $(prefix)/include # Directory to install the Info files in. infodir = $(prefix)/info # Directory to install the man page in. mandir = $(prefix)/man/man$(manext) # Number to put on the man page filename. manext = 1 # Whether or not make needs to be installed setgid. # The value should be either `true' or `false'. # On many systems, the getloadavg function (used to implement the `-l' # switch) will not work unless make is installed setgid kmem. install_setgid = @NEED_SETGID@ # Install make setgid to this group so it can read /dev/kmem. group = @KMEM_GROUP@ # Program to install `make'. INSTALL_PROGRAM = @INSTALL_PROGRAM@ # Program to install the man page. INSTALL_DATA = @INSTALL_DATA@ # Generic install program. INSTALL = @INSTALL@ # Program to format Texinfo source into Info files. MAKEINFO = makeinfo # Program to format Texinfo source into DVI files. TEXI2DVI = texi2dvi # Programs to make tags files. ETAGS = etags -tw CTAGS = ctags -tw objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o \ rule.o implicit.o default.o variable.o expand.o function.o \ vpath.o version.o ar.o arscan.o signame.o remote-$(REMOTE).o \ $(GLOB) $(GETOPT) $(ALLOCA) $(extras) srcs = $(srcdir)/commands.c $(srcdir)/job.c $(srcdir)/dir.c \ $(srcdir)/file.c $(srcdir)/getloadavg.c $(srcdir)/misc.c \ $(srcdir)/main.c $(srcdir)/read.c $(srcdir)/remake.c \ $(srcdir)/rule.c $(srcdir)/implicit.c $(srcdir)/default.c \ $(srcdir)/variable.c $(srcdir)/expand.c $(srcdir)/function.c \ $(srcdir)/vpath.c $(srcdir)/version.c \ $(srcdir)/remote-$(REMOTE).c \ $(srcdir)/ar.c $(srcdir)/arscan.c \ $(srcdir)/signame.c $(srcdir)/signame.h $(GETOPT_SRC) \ $(srcdir)/commands.h $(srcdir)/dep.h $(srcdir)/file.h \ $(srcdir)/job.h $(srcdir)/make.h $(srcdir)/rule.h \ $(srcdir)/variable.h $(ALLOCA_SRC) $(srcdir)/config.h.in .SUFFIXES: .SUFFIXES: .o .c .h .ps .dvi .info .texinfo all: make check: # No tests. info: make.info dvi: make.dvi # Some makes apparently use .PHONY as the default goal is it is before `all'. .PHONY: all check info dvi make.info: make.texinfo $(MAKEINFO) -I$(srcdir) $(srcdir)/make.texinfo -o make.info make.dvi: make.texinfo $(TEXI2DVI) $(srcdir)/make.texinfo make.ps: make.dvi dvi2ps make.dvi > make.ps make: $(objs) $(CC) $(LDFLAGS) $(objs) $(LOADLIBES) -o make.new mv -f make.new make # -I. is needed to find config.h in the build directory. .c.o: $(CC) $(defines) -c -I. -I$(srcdir) -I$(srcdir)/glob \ $(CFLAGS) $< $(OUTPUT_OPTION) # For some losing Unix makes. SHELL = /bin/sh MAKE = make glob/libglob.a: FORCE config.h cd glob; $(MAKE) CC='$(CC)' CFLAGS='$(CFLAGS) -I..' \ CPPFLAGS='$(CPPFLAGS) -DHAVE_CONFIG_H' \ RANLIB='$(RANLIB)' \ libglob.a FORCE: tagsrcs = $(srcs) $(srcdir)/remote-*.c TAGS: $(tagsrcs) $(ETAGS) $(tagsrcs) tags: $(tagsrcs) $(CTAGS) $(tagsrcs) .PHONY: install installdirs install: installdirs \ $(bindir)/$(instname) $(infodir)/make.info \ $(mandir)/$(instname).$(manext) installdirs: $(SHELL) ${srcdir}/mkinstalldirs $(bindir) $(infodir) $(mandir) $(bindir)/$(instname): make $(INSTALL_PROGRAM) make $@.new @if $(install_setgid); then \ if chgrp $(group) $@.new && chmod g+s $@.new; then \ echo "chgrp $(group) $@.new && chmod g+s $@.new"; \ else \ echo "$@ needs to be owned by group $(group) and setgid;"; \ echo "otherwise the \`-l' option will probably not work."; \ echo "You may need special priveleges to install $@."; \ fi; \ else true; fi # Some systems can't deal with renaming onto a running binary. -rm -f $@.old -mv $@ $@.old mv $@.new $@ $(infodir)/make.info: make.info if [ -r ./make.info ]; then dir=.; else dir=$(srcdir); fi; \ for file in $${dir}/make.info*; do \ name="`basename $$file`"; \ $(INSTALL_DATA) $$file \ `echo $@ | sed "s,make.info\$$,$$name,"`; \ done # Run install-info only if it exists. # Use `if' instead of just prepending `-' to the # line so we notice real errors from install-info. # We use `$(SHELL) -c' because some shells do not # fail gracefully when there is an unknown command. if $(SHELL) -c 'install-info --version' >/dev/null 2>&1; then \ install-info --infodir=$(infodir) $$dir/make.info; \ else true; fi $(mandir)/$(instname).$(manext): make.man $(INSTALL_DATA) $(srcdir)/make.man $@ loadavg: getloadavg.c config.h $(CC) $(defines) -DTEST -I. -I$(srcdir) $(CFLAGS) $(LDFLAGS) \ $(srcdir)/getloadavg.c $(LOADLIBES) -o $@ check-loadavg: loadavg @echo The system uptime program believes the load average to be: -uptime @echo The GNU load average checking code believes: ./loadavg check: check-loadavg .PHONY: clean realclean distclean mostlyclean clean: glob-clean -rm -f make loadavg *.o core make.info* make.dvi distclean: clean glob-realclean -rm -f Makefile config.h config.status build.sh stamp-config -rm -f TAGS tags -rm -f make.?? make.??s make.log make.toc make.*aux realclean: distclean mostlyclean: clean .PHONY: glob-clean glob-realclean glob-clean glob-realclean: cd glob; $(MAKE) $@ Makefile: config.status $(srcdir)/Makefile.in $(SHELL) config.status config.h: stamp-config ; stamp-config: config.status $(srcdir)/config.h.in $(SHELL) config.status touch stamp-config configure: configure.in autoconf $(ACFLAGS) config.h.in: configure.in autoheader $(ACFLAGS) # This tells versions [3.59,3.63) of GNU make not to export all variables. .NOEXPORT: # The automatically generated dependencies below may omit config.h # because it is included with ``#include '' rather than # ``#include "config.h"''. So we add the explicit dependency to make sure. $(objs): config.h # Automatically generated dependencies will be put at the end of the file. # Automatically generated dependencies. commands.o : commands.c make.h config.h dep.h commands.h file.h variable.h job.h job.o : job.c make.h config.h commands.h job.h file.h variable.h dir.o : dir.c make.h config.h file.o : file.c make.h config.h commands.h dep.h file.h variable.h misc.o : misc.c make.h config.h dep.h main.o : main.c make.h config.h commands.h dep.h file.h variable.h job.h getopt.h read.o : read.c make.h config.h commands.h dep.h file.h variable.h glob/glob.h remake.o : remake.c make.h config.h commands.h job.h dep.h file.h rule.o : rule.c make.h config.h commands.h dep.h file.h variable.h rule.h implicit.o : implicit.c make.h config.h rule.h dep.h file.h default.o : default.c make.h config.h rule.h dep.h file.h commands.h variable.h variable.o : variable.c make.h config.h commands.h variable.h dep.h file.h expand.o : expand.c make.h config.h commands.h file.h variable.h function.o : function.c make.h config.h variable.h dep.h commands.h job.h vpath.o : vpath.c make.h config.h file.h variable.h version.o : version.c ar.o : ar.c make.h config.h file.h dep.h arscan.o : arscan.c make.h config.h signame.o : signame.c config.h signame.h remote-stub.o : remote-stub.c make.h config.h commands.h getopt.o : getopt.c config.h getopt.h getopt1.o : getopt1.c config.h getopt.h getloadavg.o : getloadavg.c config.h make-3.70/configure.in 666 12241 13 5740 5506372652 10002 dnl Process this file with autoconf to produce a configure script. AC_INIT(vpath.c) dnl A distinctive file to look for in srcdir. AC_CONFIG_HEADER(config.h) # We want these before the checks, so the checks can modify their values. test -z "$CFLAGS" && CFLAGS=-g AC_SUBST(CFLAGS) test -z "$LDFLAGS" && LDFLAGS=-g AC_SUBST(LDFLAGS) AC_PROG_CC AC_PROG_INSTALL AC_PROG_RANLIB AC_PROG_CPP dnl Later checks need this. AC_AIX AC_ISC_POSIX AC_MINIX AC_STDC_HEADERS AC_DIR_HEADER AC_UID_T dnl Also does gid_t. AC_GETGROUPS_T AC_PID_T AC_RETSIGTYPE AC_HAVE_HEADERS(unistd.h limits.h sys/param.h fcntl.h string.h memory.h \ sys/timeb.h) AC_MINUS_C_MINUS_O AC_CONST dnl getopt needs this. AC_STAT_MACROS_BROKEN AC_SUBST(LIBOBJS) AC_HAVE_FUNCS(getdtablesize sys_siglist _sys_siglist psignal \ dup2 getcwd sigsetmask getgroups setlinebuf \ setreuid setregid strerror) AC_ALLOCA AC_VFORK AC_SETVBUF_REVERSED AC_GETLOADAVG AC_STRCOLL dnl Check out the wait reality. AC_HAVE_HEADERS(sys/wait.h) AC_HAVE_FUNCS(waitpid wait3) AC_COMPILE_CHECK(union wait, [#include #include ], [union wait status; int pid; pid = wait (&status); #ifdef WEXITSTATUS /* Some POSIXoid systems have both the new-style macros and the old union wait type, and they do not work together. If union wait conflicts with WEXITSTATUS et al, we don't want to use it at all. */ if (WEXITSTATUS (status) != 0) pid = -1; #endif #ifdef HAVE_WAITPID /* Make sure union wait works with waitpid. */ pid = waitpid (-1, &status, 0); #endif ], AC_DEFINE(HAVE_UNION_WAIT)) AC_COMPILE_CHECK(sys_siglist declaration in signal.h or unistd.h, [#include /* NetBSD declares sys_siglist in . */ #ifdef HAVE_UNISTD_H #include #endif], [char *msg = *(sys_siglist + 1);], AC_DEFINE(SYS_SIGLIST_DECLARED)) # The presence of the following is not meant to imply # that make necessarily works on those systems. AC_DYNIX_SEQ AC_XENIX_DIR AC_IRIX_SUN AC_SUBST(REMOTE) REMOTE=stub AC_WITH(customs, [REMOTE=cstms LIBS="$LIBS libcustoms.a"]) echo checking for location of SCCS get command if test -f /usr/sccs/get; then SCCS_GET=/usr/sccs/get AC_DEFINE(SCCS_GET, "/usr/sccs/get") else SCCS_GET=get AC_DEFINE(SCCS_GET, "get") fi ac_clean_files="$ac_clean_files s.conftest conftoast" # Remove these later. if ( /usr/sccs/admin -n s.conftest || admin -n s.conftest ) >/dev/null 2>&1 && test -f s.conftest; then # We successfully created an SCCS file. echo checking if SCCS get command understands -G if $SCCS_GET s.conftest -Gconftoast >/dev/null 2>&1 && test -f conftoast; then AC_DEFINE(SCCS_GET_MINUS_G) fi fi rm -f s.conftest conftoast AC_OUTPUT(Makefile build.sh glob/Makefile, [ # Makefile uses this timestamp file to know when to remake Makefile, # build.sh, and glob/Makefile. touch stamp-config]) dnl Local Variables: dnl comment-start: "dnl " dnl comment-end: "" dnl comment-start-skip: "\\bdnl\\b\\s *" dnl compile-command: "make configure config.h.in" dnl End: make-3.70/build.sh.in 666 12241 13 4411 5504170127 7512 #!/bin/sh # Shell script to build GNU Make in the absence of any `make' program. # Copyright (C) 1993 Free Software Foundation, Inc. # This file is part of GNU Make. # # GNU Make 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 2, or (at your option) # any later version. # # GNU Make 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 Make; see the file COPYING. If not, write to # the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. # See Makefile.in for comments describing these variables. srcdir='@srcdir@' CC='@CC@' CFLAGS='@CFLAGS@' LDFLAGS='@LDFLAGS@' defines='@DEFS@ -DLIBDIR="${libdir}" -DINCLUDEDIR="${includedir}"' ALLOCA='@ALLOCA@' LOADLIBES='@LIBS@' extras='@LIBOBJS@' REMOTE='@REMOTE@' # Common prefix for machine-independent installed files. prefix=/usr/local # Common prefix for machine-dependent installed files. exec_prefix=/usr/local # Directory to find libraries in for `-lXXX'. libdir=${exec_prefix}/lib # Directory to search by default for included makefiles. includedir=${prefix}/include # Exit as soon as any command fails. set -e # These are all the objects we need to link together. objs="commands.o job.o dir.o file.o misc.o main.o read.o remake.o rule.o implicit.o default.o variable.o expand.o function.o vpath.o version.o ar.o arscan.o signame.o getopt.o getopt1.o glob/glob.o glob/fnmatch.o remote-${REMOTE}.o ${extras} ${ALLOCA}" # Compile the source files into those objects. for file in `echo ${objs} | sed 's/\.o/.c/g'`; do echo compiling ${file}... $CC $CFLAGS $defines -c -I. -I${srcdir} -I${srcdir}/glob ${srcdir}/$file done # The object files were actually all put in the current directory. # Remove the source directory names from the list. srcobjs="$objs" objs= for obj in $srcobjs; do objs="$objs `basename $obj`" done # Link all the objects together. echo linking make... $CC $LDFLAGS $objs $LOADLIBES -o make.new echo done mv -f make.new make make-3.70/mkinstalldirs 777 21570 13 1153 5432727042 10271 #!/bin/sh # Make directory hierarchy. # Written by Noah Friedman # Public domain. defaultIFS=' ' IFS="${IFS-${defaultIFS}}" errstatus=0 for file in ${1+"$@"} ; do oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${file} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' for d in ${1+"$@"} ; do pathcomp="${pathcomp}${d}" if test ! -d "${pathcomp}"; then echo "mkdir $pathcomp" 1>&2 mkdir "${pathcomp}" || errstatus=$? fi pathcomp="${pathcomp}/" done done exit $errstatus # eof make-3.70/acconfig.h 666 12241 13 256 5503432473 7363 /* Define to the name of the SCCS `get' command. */ #undef SCCS_GET /* Define this if the SCCS `get' command understands the `-G' option. */ #undef SCCS_GET_MINUS_G make-3.70/commands.c 666 12241 13 26333 5446240454 7454 /* Command processing for GNU Make. Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "dep.h" #include "commands.h" #include "file.h" #include "variable.h" #include "job.h" extern int remote_kill (); #ifndef HAVE_UNISTD_H extern int getpid (); #endif /* Set FILE's automatic variables up. */ static void set_file_variables (file) register struct file *file; { register char *p; char *at, *percent, *star, *less; #ifndef NO_ARCHIVES /* If the target is an archive member `lib(member)', then $@ is `lib' and $% is `member'. */ if (ar_name (file->name)) { unsigned int len; p = index (file->name, '('); at = (char *) alloca (p - file->name + 1); bcopy (file->name, at, p - file->name); at[p - file->name] = '\0'; len = strlen (p + 1); percent = (char *) alloca (len); bcopy (p + 1, percent, len - 1); percent[len - 1] = '\0'; } else #endif /* NO_ARCHIVES. */ { at = file->name; percent = ""; } /* $* is the stem from an implicit or static pattern rule. */ if (file->stem == 0) { /* In Unix make, $* is set to the target name with any suffix in the .SUFFIXES list stripped off for explicit rules. We store this in the `stem' member. */ register struct dep *d; char *name; unsigned int len; #ifndef NO_ARCHIVES if (ar_name (file->name)) { name = index (file->name, '(') + 1; len = strlen (name) - 1; } else #endif { name = file->name; len = strlen (name); } for (d = enter_file (".SUFFIXES")->deps; d != 0; d = d->next) { unsigned int slen = strlen (dep_name (d)); if (len > slen && !strncmp (dep_name (d), name + len - slen, slen)) { file->stem = savestring (name, len - slen); break; } } if (d == 0) file->stem = ""; } star = file->stem; /* $< is the first dependency. */ less = file->deps != 0 ? dep_name (file->deps) : ""; if (file->cmds == default_file->cmds) /* This file got its commands from .DEFAULT. In this case $< is the same as $@. */ less = at; #define DEFINE_VARIABLE(name, len, value) \ (void) define_variable_for_file (name, len, value, o_automatic, 0, file) /* Define the variables. */ DEFINE_VARIABLE ("<", 1, less); DEFINE_VARIABLE ("*", 1, star); DEFINE_VARIABLE ("@", 1, at); DEFINE_VARIABLE ("%", 1, percent); /* Make sure that no dependencies are repeated. This does not really matter for the purpose of updating targets, but it might make some names be listed twice for $^ and $?. */ uniquize_deps (file->deps); /* Compute the values for $^ and $?. */ { register unsigned int caret_len, qmark_len; char *caret_value; register char *cp; char *qmark_value; register char *qp; register struct dep *d; unsigned int len; caret_len = qmark_len = 0; for (d = file->deps; d != 0; d = d->next) { register unsigned int i = strlen (dep_name (d)) + 1; caret_len += i; if (d->changed) qmark_len += i; } len = caret_len == 0 ? 1 : caret_len; cp = caret_value = (char *) alloca (len); len = qmark_len == 0 ? 1 : qmark_len; qp = qmark_value = (char *) alloca (len); for (d = file->deps; d != 0; d = d->next) { char *c = dep_name (d); #ifndef NO_ARCHIVES if (ar_name (c)) { c = index (c, '(') + 1; len = strlen (c) - 1; } else #endif len = strlen (c); bcopy (c, cp, len); cp += len; *cp++ = ' '; if (d->changed) { bcopy (c, qp, len); qp += len; *qp++ = ' '; } } /* Kill the last spaces and define the variables. */ cp[cp > caret_value ? -1 : 0] = '\0'; DEFINE_VARIABLE ("^", 1, caret_value); qp[qp > qmark_value ? -1 : 0] = '\0'; DEFINE_VARIABLE ("?", 1, qmark_value); } #undef DEFINE_VARIABLE } /* Chop CMDS up into individual command lines if necessary. Also set the `lines_flag' and `any_recurse' members. */ void chop_commands (cmds) register struct commands *cmds; { if (cmds != 0 && cmds->command_lines == 0) { /* Chop CMDS->commands up into lines in CMDS->command_lines. Also set the corresponding CMDS->lines_flags elements, and the CMDS->any_recurse flag. */ register char *p; unsigned int nlines, idx; char **lines; nlines = 5; lines = (char **) xmalloc (5 * sizeof (char *)); idx = 0; p = cmds->commands; while (*p != '\0') { char *end = p; find_end:; end = index (end, '\n'); if (end == 0) end = p + strlen (p); else if (end > p && end[-1] == '\\') { int backslash = 1; register char *b; for (b = end - 2; b >= p && *b == '\\'; --b) backslash = !backslash; if (backslash) { ++end; goto find_end; } } if (idx == nlines) { nlines += 2; lines = (char **) xrealloc ((char *) lines, nlines * sizeof (char *)); } lines[idx++] = savestring (p, end - p); p = end; if (*p != '\0') ++p; } if (idx != nlines) { nlines = idx; lines = (char **) xrealloc ((char *) lines, nlines * sizeof (char *)); } cmds->ncommand_lines = nlines; cmds->command_lines = lines; cmds->any_recurse = 0; cmds->lines_flags = (char *) xmalloc (nlines); for (idx = 0; idx < nlines; ++idx) { int flags = 0; for (p = lines[idx]; isblank (*p) || *p == '-' || *p == '@' || *p == '+'; ++p) switch (*p) { case '+': flags |= COMMANDS_RECURSE; break; case '@': flags |= COMMANDS_SILENT; break; case '-': flags |= COMMANDS_NOERROR; break; } if (!(flags & COMMANDS_RECURSE)) { unsigned int len = strlen (p); if (sindex (p, len, "$(MAKE)", 7) != 0 || sindex (p, len, "${MAKE}", 7) != 0) flags |= COMMANDS_RECURSE; } cmds->lines_flags[idx] = flags; cmds->any_recurse |= flags & COMMANDS_RECURSE; } } } /* Execute the commands to remake FILE. If they are currently executing, return or have already finished executing, just return. Otherwise, fork off a child process to run the first command line in the sequence. */ void execute_file_commands (file) struct file *file; { register char *p; /* Don't go through all the preparations if the commands are nothing but whitespace. */ for (p = file->cmds->commands; *p != '\0'; ++p) if (!isspace (*p) && *p != '-' && *p != '@') break; if (*p == '\0') { /* We are all out of commands. If we have gotten this far, all the previous commands have run successfully, so we have winning update status. */ file->update_status = 0; notice_finished_file (file); return; } /* First set the automatic variables according to this file. */ initialize_file_variables (file); set_file_variables (file); /* Start the commands running. */ new_job (file); } /* This is set while we are inside fatal_error_signal, so things can avoid nonreentrant operations. */ int handling_fatal_signal = 0; /* Handle fatal signals. */ RETSIGTYPE fatal_error_signal (sig) int sig; { handling_fatal_signal = 1; signal (sig, SIG_DFL); #ifdef POSIX { sigset_t set; sigemptyset (&set); (void) sigprocmask (SIG_SETMASK, &set, (sigset_t *) 0); } #else #ifdef HAVE_SIGSETMASK (void) sigsetmask (0); #endif #endif /* A termination signal won't be sent to the entire process group, but it means we want to kill the children. */ if (sig == SIGTERM) { register struct child *c; for (c = children; c != 0; c = c->next) if (!c->remote) (void) kill (c->pid, SIGTERM); } /* If we got a signal that means the user wanted to kill make, remove pending targets. */ if (sig == SIGTERM || sig == SIGINT || sig == SIGHUP || sig == SIGQUIT) { register struct child *c; /* Remote children won't automatically get signals sent to the process group, so we must send them. */ for (c = children; c != 0; c = c->next) if (c->remote) (void) remote_kill (c->pid, sig); for (c = children; c != 0; c = c->next) delete_child_targets (c); /* Clean up the children. We don't just use the call below because we don't want to print the "Waiting for children" message. */ while (job_slots_used > 0) reap_children (1, 0); } else /* Wait for our children to die. */ while (job_slots_used > 0) reap_children (1, 1); /* Delete any non-precious intermediate files that were made. */ remove_intermediates (1); if (sig == SIGQUIT) /* We don't want to send ourselves SIGQUIT, because it will cause a core dump. Just exit instead. */ exit (1); /* Signal the same code; this time it will really be fatal. */ if (kill (getpid (), sig) < 0) /* It shouldn't return, but if it does, die anyway. */ pfatal_with_name ("kill"); } /* Delete all non-precious targets of CHILD unless they were already deleted. Set the flag in CHILD to say they've been deleted. */ void delete_child_targets (child) struct child *child; { struct stat st; struct dep *d; if (child->deleted) return; /* Delete the file unless it's precious or not actually a file (phony). */ if (!child->file->precious && !child->file->phony && stat (child->file->name, &st) == 0 && S_ISREG (st.st_mode) && (time_t) st.st_mtime != child->file->last_mtime) { error ("*** Deleting file `%s'", child->file->name); if (unlink (child->file->name) < 0) perror_with_name ("unlink: ", child->file->name); } /* Also remove any non-precious targets listed in the `also_make' member. */ for (d = child->file->also_make; d != 0; d = d->next) if (!d->file->precious && !d->file->phony) if (stat (d->file->name, &st) == 0 && S_ISREG (st.st_mode) && (time_t) st.st_mtime != d->file->last_mtime) { error ("*** [%s] Deleting file `%s'", child->file->name, d->file->name); if (unlink (d->file->name) < 0) perror_with_name ("unlink: ", d->file->name); } child->deleted = 1; } /* Print out the commands in CMDS. */ void print_commands (cmds) register struct commands *cmds; { register char *s; fputs ("# commands to execute", stdout); if (cmds->filename == 0) puts (" (built-in):"); else printf (" (from `%s', line %u):\n", cmds->filename, cmds->lineno); s = cmds->commands; while (*s != '\0') { char *end; while (isspace (*s)) ++s; end = index (s, '\n'); if (end == 0) end = s + strlen (s); printf ("\t%.*s\n", (int) (end - s), s); s = end; } } make-3.70/job.c 666 12241 13 112104 5457321664 6442 /* Job execution and handling for GNU Make. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "job.h" #include "file.h" #include "variable.h" /* Default path to search for executables. */ static char default_path[] = ":/bin:/usr/bin"; /* Default shell to use. */ char default_shell[] = "/bin/sh"; /* If NGROUPS_MAX == 0 then try other methods for finding a real value. */ #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0 #undef NGROUPS_MAX #endif /* NGROUPS_MAX == 0 */ #ifndef NGROUPS_MAX #ifdef POSIX #define GET_NGROUPS_MAX sysconf (_SC_NGROUPS_MAX) #else /* Not POSIX. */ #define NGROUPS_MAX NGROUPS #endif /* POSIX. */ #endif #ifdef HAVE_SYS_WAIT_H #include #endif #ifdef HAVE_WAITPID #define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG) #else /* Don't have waitpid. */ #ifdef HAVE_WAIT3 #ifndef wait3 extern int wait3 (); #endif #define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0) #endif /* Have wait3. */ #endif /* Have waitpid. */ #if !defined (wait) && !defined (POSIX) extern int wait (); #endif #ifndef HAVE_UNION_WAIT #define WAIT_T int #ifndef WTERMSIG #define WTERMSIG(x) ((x) & 0x7f) #endif #ifndef WCOREDUMP #define WCOREDUMP(x) ((x) & 0x80) #endif #ifndef WEXITSTATUS #define WEXITSTATUS(x) (((x) >> 8) & 0xff) #endif #ifndef WIFSIGNALED #define WIFSIGNALED(x) (WTERMSIG (x) != 0) #endif #ifndef WIFEXITED #define WIFEXITED(x) (WTERMSIG (x) == 0) #endif #else /* Have `union wait'. */ #define WAIT_T union wait #ifndef WTERMSIG #define WTERMSIG(x) ((x).w_termsig) #endif #ifndef WCOREDUMP #define WCOREDUMP(x) ((x).w_coredump) #endif #ifndef WEXITSTATUS #define WEXITSTATUS(x) ((x).w_retcode) #endif #ifndef WIFSIGNALED #define WIFSIGNALED(x) (WTERMSIG(x) != 0) #endif #ifndef WIFEXITED #define WIFEXITED(x) (WTERMSIG(x) == 0) #endif #endif /* Don't have `union wait'. */ #ifndef HAVE_UNISTD_H extern int dup2 (); extern int execve (); extern void _exit (); extern int geteuid (), getegid (); extern int setgid (), getgid (); #endif #ifndef getdtablesize #ifdef HAVE_GETDTABLESIZE extern int getdtablesize (); #else #include #define getdtablesize() NOFILE #if !defined (NOFILE) && defined (NOFILES_MAX) /* SCO 3.2 "devsys 4.2" defines NOFILES_{MIN,MAX} in lieu of NOFILE. */ #define NOFILE NOFILES_MAX #endif #endif #endif extern int getloadavg (); extern int start_remote_job_p (); extern int start_remote_job (), remote_status (); RETSIGTYPE child_handler (); static void free_child (), start_job_command (); static int load_too_high (), job_next_command (); /* Chain of all live (or recently deceased) children. */ struct child *children = 0; /* Number of children currently running. */ unsigned int job_slots_used = 0; /* Nonzero if the `good' standard input is in use. */ static int good_stdin_used = 0; /* Chain of children waiting to run until the load average goes down. */ static struct child *waiting_jobs = 0; /* Write an error message describing the exit status given in EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME. Append "(ignored)" if IGNORED is nonzero. */ static void child_error (target_name, exit_code, exit_sig, coredump, ignored) char *target_name; int exit_code, exit_sig, coredump; int ignored; { if (exit_sig == 0) error (ignored ? "[%s] Error %d (ignored)" : "*** [%s] Error %d", target_name, exit_code); else { char *coredump_string = coredump ? " (core dumped)" : ""; if (exit_sig > 0 && exit_sig < NSIG) error ("*** [%s] %s%s", target_name, sys_siglist[exit_sig], coredump_string); else error ("*** [%s] Signal %d%s", target_name, exit_sig, coredump_string); } } static unsigned int dead_children = 0; /* Notice that a child died. reap_children should be called when convenient. */ RETSIGTYPE child_handler (sig) int sig; { ++dead_children; if (debug_flag) printf ("Got a SIGCHLD; %d unreaped children.\n", dead_children); } extern int shell_function_pid, shell_function_completed; /* Reap dead children, storing the returned status and the new command state (`cs_finished') in the `file' member of the `struct child' for the dead child, and removing the child from the chain. If BLOCK nonzero, reap at least one child, waiting for it to die if necessary. If ERR is nonzero, print an error message first. */ void reap_children (block, err) int block, err; { WAIT_T status; while ((children != 0 || shell_function_pid != 0) && (block || dead_children > 0)) { int remote = 0; register int pid; int exit_code, exit_sig, coredump; register struct child *lastc, *c; int child_failed; int any_remote, any_local; if (err && dead_children == 0) { /* We might block for a while, so let the user know why. */ fflush (stdout); error ("*** Waiting for unfinished jobs...."); } /* We have one less dead child to reap. The test and decrement are not atomic; if it is compiled into: register = dead_children - 1; dead_children = register; a SIGCHLD could come between the two instructions. child_handler increments dead_children. The second instruction here would lose that increment. But the only effect of dead_children being wrong is that we might wait longer than necessary to reap a child, and lose some parallelism; and we might print the "Waiting for unfinished jobs" message above when not necessary. */ if (dead_children != 0) --dead_children; any_remote = 0; any_local = shell_function_pid != -1; for (c = children; c != 0; c = c->next) { any_remote |= c->remote; any_local |= ! c->remote; if (debug_flag) printf ("Live child 0x%08lx PID %d%s\n", (unsigned long int) c, c->pid, c->remote ? " (remote)" : ""); } /* First, check for remote children. */ if (any_remote) pid = remote_status (&exit_code, &exit_sig, &coredump, 0); else pid = 0; if (pid < 0) { remote_status_lose: #ifdef EINTR if (errno == EINTR) continue; #endif pfatal_with_name ("remote_status"); } else if (pid == 0) { /* No remote children. Check for local children. */ if (any_local) { #ifdef WAIT_NOHANG if (!block) pid = WAIT_NOHANG (&status); else #endif pid = wait (&status); } else pid = 0; if (pid < 0) { #ifdef EINTR if (errno == EINTR) continue; #endif pfatal_with_name ("wait"); } else if (pid == 0) { /* No local children. */ if (block && any_remote) { /* Now try a blocking wait for a remote child. */ pid = remote_status (&exit_code, &exit_sig, &coredump, 1); if (pid < 0) goto remote_status_lose; else if (pid == 0) /* No remote children either. Finally give up. */ break; else /* We got a remote child. */ remote = 1; } else break; } else { /* Chop the status word up. */ exit_code = WEXITSTATUS (status); exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0; coredump = WCOREDUMP (status); } } else /* We got a remote child. */ remote = 1; /* Check if this is the child of the `shell' function. */ if (!remote && pid == shell_function_pid) { /* It is. Leave an indicator for the `shell' function. */ if (exit_sig == 0 && exit_code == 127) shell_function_completed = -1; else shell_function_completed = 1; break; } child_failed = exit_sig != 0 || exit_code != 0; /* Search for a child matching the deceased one. */ lastc = 0; for (c = children; c != 0; lastc = c, c = c->next) if (c->remote == remote && c->pid == pid) break; if (c == 0) { /* An unknown child died. */ char buf[100]; sprintf (buf, "Unknown%s job %d", remote ? " remote" : "", pid); if (child_failed) child_error (buf, exit_code, exit_sig, coredump, ignore_errors_flag); else error ("%s finished.", buf); } else { if (debug_flag) printf ("Reaping %s child 0x%08lx PID %d%s\n", child_failed ? "losing" : "winning", (unsigned long int) c, c->pid, c->remote ? " (remote)" : ""); /* If this child had the good stdin, say it is now free. */ if (c->good_stdin) good_stdin_used = 0; if (child_failed && !c->noerror && !ignore_errors_flag) { /* The commands failed. Write an error message, delete non-precious targets, and abort. */ child_error (c->file->name, exit_code, exit_sig, coredump, 0); c->file->update_status = 1; if (exit_sig != 0) delete_child_targets (c); } else { if (child_failed) { /* The commands failed, but we don't care. */ child_error (c->file->name, exit_code, exit_sig, coredump, 1); child_failed = 0; } /* If there are more commands to run, try to start them. */ if (job_next_command (c)) { if (handling_fatal_signal) { /* Never start new commands while we are dying. Since there are more commands that wanted to be run, the target was not completely remade. So we treat this as if a command had failed. */ c->file->command_state = cs_finished; c->file->update_status = 1; } else { /* Check again whether to start remotely. Whether or not we want to changes over time. Also, start_remote_job may need state set up by start_remote_job_p. */ c->remote = start_remote_job_p (); start_job_command (c); } } switch (c->file->command_state) { case cs_running: /* Successfully started. Loop to reap more children. */ continue; case cs_finished: if (c->file->update_status != 0) /* We failed to start the commands. */ delete_child_targets (c); break; default: error ("internal error: `%s' has bogus command_state \ %d in reap_children", c->file->name, (int) c->file->command_state); abort (); break; } } if (! handling_fatal_signal) /* Notice if the target of the commands has been changed. */ notice_finished_file (c->file); if (debug_flag) printf ("Removing child 0x%08lx PID %d%s from chain.\n", (unsigned long int) c, c->pid, c->remote ? " (remote)" : ""); /* Remove the child from the chain and free it. */ if (lastc == 0) children = c->next; else lastc->next = c->next; if (! handling_fatal_signal) /* Avoid nonreentrancy. */ free_child (c); /* There is now another slot open. */ --job_slots_used; /* If the job failed, and the -k flag was not given, die, unless we are already in the process of dying. */ if (!err && child_failed && !keep_going_flag) die (1); } /* Only block for one child. */ block = 0; } } /* Free the storage allocated for CHILD. */ static void free_child (child) register struct child *child; { if (child->command_lines != 0) { register unsigned int i; for (i = 0; i < child->file->cmds->ncommand_lines; ++i) free (child->command_lines[i]); free ((char *) child->command_lines); } if (child->environment != 0) { register char **ep = child->environment; while (*ep != 0) free (*ep++); free ((char *) child->environment); } free ((char *) child); } #ifdef POSIX extern sigset_t fatal_signal_set; void unblock_sigs () { sigset_t empty; sigemptyset (&empty); sigprocmask (SIG_SETMASK, &empty, (sigset_t *) 0); } #endif /* Start a job to run the commands specified in CHILD. CHILD is updated to reflect the commands and ID of the child process. */ static void start_job_command (child) register struct child *child; { static int bad_stdin = -1; register char *p; int flags = child->file->cmds->lines_flags[child->command_line - 1]; char **argv; p = child->command_ptr; child->noerror = flags & COMMANDS_NOERROR; while (*p != '\0') { if (*p == '@') flags |= COMMANDS_SILENT; else if (*p == '+') flags |= COMMANDS_RECURSE; else if (*p == '-') child->noerror = 1; else if (!isblank (*p) && *p != '+') break; ++p; } /* If -q was given, just say that updating `failed'. */ if (question_flag && !(flags & COMMANDS_RECURSE)) goto error; /* There may be some preceding whitespace left if there was nothing but a backslash on the first line. */ p = next_token (p); /* Figure out an argument list from this command line. */ { char *end; argv = construct_command_argv (p, &end, child->file); if (end == NULL) child->command_ptr = NULL; else { *end++ = '\0'; child->command_ptr = end; } } if (touch_flag && !(flags & COMMANDS_RECURSE)) { /* Go on to the next command. It might be the recursive one. We construct ARGV only to find the end of the command line. */ free (argv[0]); free ((char *) argv); argv = 0; } if (argv == 0) { /* This line has no commands. Go to the next. */ if (job_next_command (child)) start_job_command (child); return; } /* Print out the command. */ if (just_print_flag || (!(flags & COMMANDS_SILENT) && !silent_flag)) puts (p); /* Tell update_goal_chain that a command has been started on behalf of this target. It is important that this happens here and not in reap_children (where we used to do it), because reap_children might be reaping children from a different target. We want this increment to guaranteedly indicate that a command was started for the dependency chain (i.e., update_file recursion chain) we are processing. */ ++commands_started; /* If -n was given, recurse to get the next line in the sequence. */ if (just_print_flag && !(flags & COMMANDS_RECURSE)) { free (argv[0]); free ((char *) argv); if (job_next_command (child)) start_job_command (child); return; } /* Flush the output streams so they won't have things written twice. */ fflush (stdout); fflush (stderr); /* Set up a bad standard input that reads from a broken pipe. */ if (bad_stdin == -1) { /* Make a file descriptor that is the read end of a broken pipe. This will be used for some children's standard inputs. */ int pd[2]; if (pipe (pd) == 0) { /* Close the write side. */ (void) close (pd[1]); /* Save the read side. */ bad_stdin = pd[0]; } } /* Decide whether to give this child the `good' standard input (one that points to the terminal or whatever), or the `bad' one that points to the read side of a broken pipe. */ child->good_stdin = !good_stdin_used; if (child->good_stdin) good_stdin_used = 1; child->deleted = 0; /* Set up the environment for the child. */ if (child->environment == 0) child->environment = target_environment (child->file); /* start_waiting_job has set CHILD->remote if we can start a remote job. */ if (child->remote) { int is_remote, id, used_stdin; if (start_remote_job (argv, child->environment, child->good_stdin ? 0 : bad_stdin, &is_remote, &id, &used_stdin)) goto error; else { if (child->good_stdin && !used_stdin) { child->good_stdin = 0; good_stdin_used = 0; } child->remote = is_remote; child->pid = id; } } else { /* Fork the child process. */ #ifdef POSIX (void) sigprocmask (SIG_BLOCK, &fatal_signal_set, (sigset_t *) 0); #else #ifdef HAVE_SIGSETMASK (void) sigblock (fatal_signal_mask); #endif #endif child->remote = 0; child->pid = vfork (); if (child->pid == 0) { /* We are the child side. */ unblock_sigs (); child_execute_job (child->good_stdin ? 0 : bad_stdin, 1, argv, child->environment); } else if (child->pid < 0) { /* Fork failed! */ unblock_sigs (); perror_with_name ("vfork", ""); goto error; } } /* We are the parent side. Set the state to say the commands are running and return. */ child->file->command_state = cs_running; /* Free the storage used by the child's argument list. */ free (argv[0]); free ((char *) argv); return; error:; child->file->update_status = 1; child->file->command_state = cs_finished; } /* Try to start a child running. Returns nonzero if the child was started (and maybe finished), or zero if the load was too high and the child was put on the `waiting_jobs' chain. */ static int start_waiting_job (c) struct child *c; { /* If we can start a job remotely, we always want to, and don't care about the local load average. We record that the job should be started remotely in C->remote for start_job_command to test. */ c->remote = start_remote_job_p (); /* If this job is to be started locally, and we are already running some jobs, make this one wait if the load average is too high. */ if (!c->remote && job_slots_used > 0 && load_too_high ()) { /* Put this child on the chain of children waiting for the load average to go down. */ c->file->command_state = cs_running; c->next = waiting_jobs; waiting_jobs = c; return 0; } /* Start the first command; reap_children will run later command lines. */ start_job_command (c); switch (c->file->command_state) { case cs_running: c->next = children; if (debug_flag) printf ("Putting child 0x%08lx PID %05d%s on the chain.\n", (unsigned long int) c, c->pid, c->remote ? " (remote)" : ""); children = c; /* One more job slot is in use. */ ++job_slots_used; unblock_sigs (); break; case cs_finished: notice_finished_file (c->file); free_child (c); break; default: error ("internal error: `%s' command_state == %d in new_job", c->file->name, (int) c->file->command_state); abort (); break; } return 1; } /* Create a `struct child' for FILE and start its commands running. */ void new_job (file) register struct file *file; { register struct commands *cmds = file->cmds; register struct child *c; char **lines; register unsigned int i; /* Let any previously decided-upon jobs that are waiting for the load to go down start before this new one. */ start_waiting_jobs (); /* Reap any children that might have finished recently. */ reap_children (0, 0); /* Chop the commands up into lines if they aren't already. */ chop_commands (cmds); if (job_slots != 0) /* Wait for a job slot to be freed up. */ while (job_slots_used == job_slots) reap_children (1, 0); /* Expand the command lines and store the results in LINES. */ lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *)); for (i = 0; i < cmds->ncommand_lines; ++i) { /* Collapse backslash-newline combinations that are inside variable or function references. These are left alone by the parser so that they will appear in the echoing of commands (where they look nice); and collapsed by construct_command_argv when it tokenizes. But letting them survive inside function invocations loses because we don't want the functions to see them as part of the text. */ char *in, *out, *ref; /* IN points to where in the line we are scanning. OUT points to where in the line we are writing. When we collapse a backslash-newline combination, IN gets ahead out OUT. */ in = out = cmds->command_lines[i]; while ((ref = index (in, '$')) != 0) { ++ref; /* Move past the $. */ if (out != in) /* Copy the text between the end of the last chunk we processed (where IN points) and the new chunk we are about to process (where REF points). */ bcopy (in, out, ref - in); /* Move both pointers past the boring stuff. */ out += ref - in; in = ref; if (*ref == '(' || *ref == '{') { char openparen = *ref; char closeparen = openparen == '(' ? ')' : '}'; int count; char *p; *out++ = *in++; /* Copy OPENPAREN. */ /* IN now points past the opening paren or brace. Count parens or braces until it is matched. */ count = 0; while (*in != '\0') { if (*in == closeparen && --count < 0) break; else if (*in == '\\' && in[1] == '\n') { /* We have found a backslash-newline inside a variable or function reference. Eat it and any following whitespace. */ int quoted = 0; for (p = in - 1; p > ref && *p == '\\'; --p) quoted = !quoted; if (quoted) /* There were two or more backslashes, so this is not really a continuation line. We don't collapse the quoting backslashes here as is done in collapse_continuations, because the line will be collapsed again after expansion. */ *out++ = *in++; else { /* Skip the backslash, newline and any following whitespace. */ in = next_token (in + 2); /* Discard any preceding whitespace that has already been written to the output. */ while (out > ref && isblank (out[-1])) --out; /* Replace it all with a single space. */ *out++ = ' '; } } else { if (*in == openparen) ++count; *out++ = *in++; } } } } /* There are no more references in this line to worry about. Copy the remaining uninteresting text to the output. */ if (out != in) strcpy (out, in); /* Finally, expand the line. */ lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i], file); } /* Start the command sequence, record it in a new `struct child', and add that to the chain. */ c = (struct child *) xmalloc (sizeof (struct child)); c->file = file; c->command_lines = lines; c->command_line = 0; c->command_ptr = 0; c->environment = 0; /* Fetch the first command line to be run. */ if (! job_next_command (c)) /* There were no commands! */ free_child (c); else { /* The job is now primed. Start it running. */ start_waiting_job (c); if (job_slots == 1) /* Since there is only one job slot, make things run linearly. Wait for the child to die, setting the state to `cs_finished'. */ while (file->command_state == cs_running) reap_children (1, 0); } } /* Move CHILD's pointers to the next command for it to execute. Returns nonzero if there is another command. */ static int job_next_command (child) struct child *child; { if (child->command_ptr == 0 || *child->command_ptr == '\0') { /* There are no more lines in the expansion of this line. */ if (child->command_line == child->file->cmds->ncommand_lines) { /* There are no more lines to be expanded. */ child->command_ptr = 0; child->file->command_state = cs_finished; child->file->update_status = 0; return 0; } else /* Get the next line to run. */ child->command_ptr = child->command_lines[child->command_line++]; } return 1; } static int load_too_high () { extern int getloadavg (); double load; if (max_load_average < 0) return 0; make_access (); if (getloadavg (&load, 1) != 1) { static int lossage = -1; /* Complain only once for the same error. */ if (lossage == -1 || errno != lossage) { if (errno == 0) /* An errno value of zero means getloadavg is just unsupported. */ error ("cannot enforce load limits on this operating system"); else perror_with_name ("cannot enforce load limit: ", "getloadavg"); } lossage = errno; load = 0; } user_access (); return load >= max_load_average; } /* Start jobs that are waiting for the load to be lower. */ void start_waiting_jobs () { struct child *job; if (waiting_jobs == 0) return; do { /* Check for recently deceased descendants. */ reap_children (0, 0); /* Take a job off the waiting list. */ job = waiting_jobs; waiting_jobs = job->next; /* Try to start that job. We break out of the loop as soon as start_waiting_job puts one back on the waiting list. */ } while (start_waiting_job (job) && waiting_jobs != 0); } /* Replace the current process with one executing the command in ARGV. STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is the environment of the new program. This function does not return. */ void child_execute_job (stdin_fd, stdout_fd, argv, envp) int stdin_fd, stdout_fd; char **argv, **envp; { if (stdin_fd != 0) (void) dup2 (stdin_fd, 0); if (stdout_fd != 1) (void) dup2 (stdout_fd, 1); /* Free up file descriptors. */ { register int d; int max = getdtablesize (); for (d = 3; d < max; ++d) (void) close (d); } /* Run the command. */ exec_command (argv, envp); } /* Search PATH for FILE. If successful, store the full pathname in PROGRAM and return 1. If not sucessful, return zero. */ static int search_path (file, path, program) char *file, *path, *program; { if (path == 0 || path[0] == '\0') path = default_path; if (index (file, '/') != 0) { strcpy (program, file); return 1; } else { unsigned int len; #ifdef HAVE_GETGROUPS #ifndef HAVE_UNISTD_H extern int getgroups (); #endif static int ngroups = -1; #ifdef NGROUPS_MAX static GETGROUPS_T groups[NGROUPS_MAX]; #define ngroups_max NGROUPS_MAX #else static GETGROUPS_T *groups = 0; static int ngroups_max; if (groups == 0) { ngroups_max = GET_NGROUPS_MAX; groups = (GETGROUPS_T *) malloc (ngroups_max * sizeof (GETGROUPS_T)); } #endif if (groups != 0 && ngroups == -1) ngroups = getgroups (ngroups_max, groups); #endif /* Have getgroups. */ len = strlen (file) + 1; do { struct stat st; int perm; char *p; p = index (path, ':'); if (p == 0) p = path + strlen (path); if (p == path) bcopy (file, program, len); else { bcopy (path, program, p - path); program[p - path] = '/'; bcopy (file, program + (p - path) + 1, len); } if (stat (program, &st) == 0 && S_ISREG (st.st_mode)) { if (st.st_uid == geteuid ()) perm = (st.st_mode & 0100); else if (st.st_gid == getegid ()) perm = (st.st_mode & 0010); else { #ifdef HAVE_GETGROUPS register int i; for (i = 0; i < ngroups; ++i) if (groups[i] == st.st_gid) break; if (i < ngroups) perm = (st.st_mode & 0010); else #endif /* Have getgroups. */ perm = (st.st_mode & 0001); } if (perm != 0) return 1; } path = p + 1; } while (*path != '\0'); } return 0; } /* Replace the current process with one running the command in ARGV, with environment ENVP. This function does not return. */ void exec_command (argv, envp) char **argv, **envp; { char *shell, *path; PATH_VAR (program); register char **ep; shell = path = 0; for (ep = envp; *ep != 0; ++ep) { if (shell == 0 && !strncmp(*ep, "SHELL=", 6)) shell = &(*ep)[6]; else if (path == 0 && !strncmp(*ep, "PATH=", 5)) path = &(*ep)[5]; else if (path != 0 && shell != 0) break; } /* Be the user, permanently. */ child_access (); if (!search_path (argv[0], path, program)) error ("%s: Command not found", argv[0]); else { /* Run the program. */ execve (program, argv, envp); if (errno == ENOEXEC) { PATH_VAR (shell_program); char *shell_path; if (shell == 0) shell_path = default_shell; else { if (search_path (shell, path, shell_program)) shell_path = shell_program; else { shell_path = 0; error ("%s: Shell program not found", shell); } } if (shell_path != 0) { char **new_argv; int argc; argc = 1; while (argv[argc] != 0) ++argc; new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *)); new_argv[0] = shell_path; new_argv[1] = program; while (argc > 0) { new_argv[1 + argc] = argv[argc]; --argc; } execve (shell_path, new_argv, envp); perror_with_name ("execve: ", shell_path); } } else perror_with_name ("execve: ", program); } _exit (127); } /* Figure out the argument list necessary to run LINE as a command. Try to avoid using a shell. This routine handles only ' quoting. Starting quotes may be escaped with a backslash. If any of the characters in sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[] is the first word of a line, the shell is used. If RESTP is not NULL, *RESTP is set to point to the first newline in LINE. If *RESTP is NULL, newlines will be ignored. SHELL is the shell to use, or nil to use the default shell. IFS is the value of $IFS, or nil (meaning the default). */ static char ** construct_command_argv_internal (line, restp, shell, ifs) char *line, **restp; char *shell, *ifs; { static char sh_chars[] = "#;\"*?[]&|<>(){}$`^"; static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login", "logout", "set", "umask", "wait", "while", "for", "case", "if", ":", ".", "break", "continue", "export", "read", "readonly", "shift", "times", "trap", "switch", 0 }; register int i; register char *p; register char *ap; char *end; int instring, word_has_equals, seen_nonequals; char **new_argv = 0; if (restp != NULL) *restp = NULL; /* Make sure not to bother processing an empty line. */ while (isblank (*line)) ++line; if (*line == '\0') return 0; /* See if it is safe to parse commands internally. */ if (shell == 0) shell = default_shell; else if (strcmp (shell, default_shell)) goto slow; if (ifs != 0) for (ap = ifs; *ap != '\0'; ++ap) if (*ap != ' ' && *ap != '\t' && *ap != '\n') goto slow; i = strlen (line) + 1; /* More than 1 arg per character is impossible. */ new_argv = (char **) xmalloc (i * sizeof (char *)); /* All the args can fit in a buffer as big as LINE is. */ ap = new_argv[0] = (char *) xmalloc (i); end = ap + i; /* I is how many complete arguments have been found. */ i = 0; instring = word_has_equals = seen_nonequals = 0; for (p = line; *p != '\0'; ++p) { if (ap > end) abort (); if (instring) { /* Inside a string, just copy any char except a closing quote. */ if (*p == '\'') instring = 0; else *ap++ = *p; } else if (index (sh_chars, *p) != 0) /* Not inside a string, but it's a special char. */ goto slow; else /* Not a special char. */ switch (*p) { case '=': /* Equals is a special character in leading words before the first word with no equals sign in it. This is not the case with sh -k, but we never get here when using nonstandard shell flags. */ if (! seen_nonequals) goto slow; word_has_equals = 1; *ap++ = '='; break; case '\\': /* Backslash-newline combinations are eaten. */ if (p[1] == '\n') { /* Eat the backslash, the newline, and following whitespace, replacing it all with a single space. */ p += 2; /* If there is a tab after a backslash-newline, remove it from the source line which will be echoed, since it was most likely used to line up the continued line with the previous one. */ if (*p == '\t') strcpy (p, p + 1); if (ap != new_argv[i]) /* Treat this as a space, ending the arg. But if it's at the beginning of the arg, it should just get eaten, rather than becoming an empty arg. */ goto end_of_arg; else p = next_token (p) - 1; } else if (p[1] != '\0') /* Copy and skip the following char. */ *ap++ = *++p; break; case '\'': instring = 1; break; case '\n': if (restp != NULL) { /* End of the command line. */ *restp = p; goto end_of_line; } else /* Newlines are not special. */ *ap++ = '\n'; break; case ' ': case '\t': end_of_arg: /* We have the end of an argument. Terminate the text of the argument. */ *ap++ = '\0'; new_argv[++i] = ap; /* Update SEEN_NONEQUALS, which tells us if every word heretofore has contained an `='. */ seen_nonequals |= ! word_has_equals; if (word_has_equals && ! seen_nonequals) /* An `=' in a word before the first word without one is magical. */ goto slow; word_has_equals = 0; /* Prepare for the next word. */ /* If this argument is the command name, see if it is a built-in shell command. If so, have the shell handle it. */ if (i == 1) { register int j; for (j = 0; sh_cmds[j] != 0; ++j) if (streq (sh_cmds[j], new_argv[0])) goto slow; } /* Ignore multiple whitespace chars. */ p = next_token (p); /* Next iteration should examine the first nonwhite char. */ --p; break; default: *ap++ = *p; break; } } end_of_line: if (instring) /* Let the shell deal with an unterminated quote. */ goto slow; /* Terminate the last argument and the argument list. */ *ap = '\0'; if (new_argv[i][0] != '\0') ++i; new_argv[i] = 0; if (i == 1) { register int j; for (j = 0; sh_cmds[j] != 0; ++j) if (streq (sh_cmds[j], new_argv[0])) goto slow; } if (new_argv[0] == 0) /* Line was empty. */ return 0; else return new_argv; slow:; /* We must use the shell. */ if (new_argv != 0) { /* Free the old argument list we were working on. */ free (new_argv[0]); free (new_argv); } { /* SHELL may be a multi-word command. Construct a command line "SHELL -c LINE", with all special chars in LINE escaped. Then recurse, expanding this command line to get the final argument list. */ unsigned int shell_len = strlen (shell); static char minus_c[] = " -c "; unsigned int line_len = strlen (line); char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1) + (line_len * 2) + 1); ap = new_line; bcopy (shell, ap, shell_len); ap += shell_len; bcopy (minus_c, ap, sizeof (minus_c) - 1); ap += sizeof (minus_c) - 1; for (p = line; *p != '\0'; ++p) { if (restp != NULL && *p == '\n') { *restp = p; break; } else if (*p == '\\' && p[1] == '\n') { /* Eat the backslash, the newline, and following whitespace, replacing it all with a single space (which is escaped from the shell). */ p += 2; /* If there is a tab after a backslash-newline, remove it from the source line which will be echoed, since it was most likely used to line up the continued line with the previous one. */ if (*p == '\t') strcpy (p, p + 1); p = next_token (p); --p; *ap++ = '\\'; *ap++ = ' '; continue; } if (*p == '\\' || *p == '\'' || isspace (*p) || index (sh_chars, *p) != 0) *ap++ = '\\'; *ap++ = *p; } *ap = '\0'; new_argv = construct_command_argv_internal (new_line, (char **) NULL, (char *) 0, (char *) 0); } return new_argv; } /* Figure out the argument list necessary to run LINE as a command. Try to avoid using a shell. This routine handles only ' quoting. Starting quotes may be escaped with a backslash. If any of the characters in sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[] is the first word of a line, the shell is used. If RESTP is not NULL, *RESTP is set to point to the first newline in LINE. If *RESTP is NULL, newlines will be ignored. FILE is the target whose commands these are. It is used for variable expansion for $(SHELL) and $(IFS). */ char ** construct_command_argv (line, restp, file) char *line, **restp; struct file *file; { char *shell, *ifs; char **argv; { /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */ int save = warn_undefined_variables_flag; warn_undefined_variables_flag = 0; shell = allocated_variable_expand_for_file ("$(SHELL)", file); ifs = allocated_variable_expand_for_file ("$(IFS)", file); warn_undefined_variables_flag = save; } argv = construct_command_argv_internal (line, restp, shell, ifs); free (shell); free (ifs); return argv; } #ifndef HAVE_DUP2 int dup2 (old, new) int old, new; { int fd; (void) close (new); fd = dup (old); if (fd != new) { (void) close (fd); errno = EMFILE; return -1; } return fd; } #endif make-3.70/dir.c 666 12241 13 34750 5403212005 6413 /* Directory hashing for GNU Make. Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #if defined (POSIX) || defined (DIRENT) || defined (__GNU_LIBRARY__) #include #ifndef __GNU_LIBRARY__ #define D_NAMLEN(d) strlen((d)->d_name) #else /* GNU C library. */ #define D_NAMLEN(d) ((d)->d_namlen) #endif /* Not GNU C library. */ #else /* Not POSIX or DIRENT. */ #define direct dirent #define D_NAMLEN(d) ((d)->d_namlen) #ifdef SYSNDIR #include #endif /* SYSNDIR */ #ifdef SYSDIR #include #endif /* SYSDIR */ #ifdef NDIR #include #endif /* NDIR */ #endif /* POSIX or DIRENT or __GNU_LIBRARY__. */ #if defined (POSIX) && !defined (__GNU_LIBRARY__) /* Posix does not require that the d_ino field be present, and some systems do not provide it. */ #define REAL_DIR_ENTRY(dp) 1 #else #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0) #endif /* POSIX */ /* Hash table of directories. */ #ifndef DIRECTORY_BUCKETS #define DIRECTORY_BUCKETS 199 #endif struct directory_contents { struct directory_contents *next; int dev, ino; /* Device and inode numbers of this dir. */ struct dirfile **files; /* Files in this directory. */ DIR *dirstream; /* Stream reading this directory. */ }; /* Table of directory contents hashed by device and inode number. */ static struct directory_contents *directories_contents[DIRECTORY_BUCKETS]; struct directory { struct directory *next; char *name; /* Name of the directory. */ /* The directory's contents. This data may be shared by several entries in the hash table, which refer to the same directory (identified uniquely by `dev' and `ino') under different names. */ struct directory_contents *contents; }; /* Table of directories hashed by name. */ static struct directory *directories[DIRECTORY_BUCKETS]; /* Never have more than this many directories open at once. */ #define MAX_OPEN_DIRECTORIES 10 static unsigned int open_directories = 0; /* Hash table of files in each directory. */ struct dirfile { struct dirfile *next; char *name; /* Name of the file. */ char impossible; /* This file is impossible. */ }; #ifndef DIRFILE_BUCKETS #define DIRFILE_BUCKETS 107 #endif static int dir_contents_file_exists_p (); /* Find the directory named NAME and return its `struct directory'. */ static struct directory * find_directory (name) register char *name; { register unsigned int hash = 0; register char *p; register struct directory *dir; for (p = name; *p != '\0'; ++p) HASH (hash, *p); hash %= DIRECTORY_BUCKETS; for (dir = directories[hash]; dir != 0; dir = dir->next) if (streq (dir->name, name)) break; if (dir == 0) { struct stat st; /* The directory was not found. Create a new entry for it. */ dir = (struct directory *) xmalloc (sizeof (struct directory)); dir->next = directories[hash]; directories[hash] = dir; dir->name = savestring (name, p - name); /* The directory is not in the name hash table. Find its device and inode numbers, and look it up by them. */ if (stat (name, &st) < 0) /* Couldn't stat the directory. Mark this by setting the `contents' member to a nil pointer. */ dir->contents = 0; else { /* Search the contents hash table; device and inode are the key. */ struct directory_contents *dc; hash = ((unsigned int) st.st_dev << 16) | (unsigned int) st.st_ino; hash %= DIRECTORY_BUCKETS; for (dc = directories_contents[hash]; dc != 0; dc = dc->next) if (dc->dev == st.st_dev && dc->ino == st.st_ino) break; if (dc == 0) { /* Nope; this really is a directory we haven't seen before. */ dc = (struct directory_contents *) xmalloc (sizeof (struct directory_contents)); /* Enter it in the contents hash table. */ dc->dev = st.st_dev; dc->ino = st.st_ino; dc->next = directories_contents[hash]; directories_contents[hash] = dc; dc->dirstream = opendir (name); if (dc->dirstream == 0) /* Couldn't open the directory. Mark this by setting the `files' member to a nil pointer. */ dc->files = 0; else { /* Allocate an array of buckets for files and zero it. */ dc->files = (struct dirfile **) xmalloc (sizeof (struct dirfile *) * DIRFILE_BUCKETS); bzero ((char *) dc->files, sizeof (struct dirfile *) * DIRFILE_BUCKETS); /* Keep track of how many directories are open. */ ++open_directories; if (open_directories == MAX_OPEN_DIRECTORIES) /* We have too many directories open already. Read the entire directory and then close it. */ (void) dir_contents_file_exists_p (dc, (char *) 0); } } /* Point the name-hashed entry for DIR at its contents data. */ dir->contents = dc; } } return dir; } /* Return 1 if the name FILENAME is entered in DIR's hash table. FILENAME must contain no slashes. */ static int dir_contents_file_exists_p (dir, filename) register struct directory_contents *dir; register char *filename; { register unsigned int hash; register char *p; register struct dirfile *df; register struct dirent *d; if (dir == 0 || dir->files == 0) /* The directory could not be stat'd or opened. */ return 0; hash = 0; if (filename != 0) { if (*filename == '\0') /* Checking if the directory exists. */ return 1; for (p = filename; *p != '\0'; ++p) HASH (hash, *p); hash %= DIRFILE_BUCKETS; /* Search the list of hashed files. */ for (df = dir->files[hash]; df != 0; df = df->next) if (streq (df->name, filename)) return !df->impossible; } /* The file was not found in the hashed list. Try to read the directory further. */ if (dir->dirstream == 0) /* The directory has been all read in. */ return 0; while ((d = readdir (dir->dirstream)) != 0) { /* Enter the file in the hash table. */ register unsigned int newhash = 0; unsigned int len; register unsigned int i; if (!REAL_DIR_ENTRY (d)) continue; len = D_NAMLEN (d); while (d->d_name[len - 1] == '\0') --len; for (i = 0; i < len; ++i) HASH (newhash, d->d_name[i]); newhash %= DIRFILE_BUCKETS; df = (struct dirfile *) xmalloc (sizeof (struct dirfile)); df->next = dir->files[newhash]; dir->files[newhash] = df; df->name = savestring (d->d_name, len); df->impossible = 0; /* Check if the name matches the one we're searching for. */ if (filename != 0 && newhash == hash && streq (d->d_name, filename)) return 1; } /* If the directory has been completely read in, close the stream and reset the pointer to nil. */ if (d == 0) { --open_directories; closedir (dir->dirstream); dir->dirstream = 0; } return 0; } /* Return 1 if the name FILENAME in directory DIRNAME is entered in the dir hash table. FILENAME must contain no slashes. */ int dir_file_exists_p (dirname, filename) register char *dirname; register char *filename; { return dir_contents_file_exists_p (find_directory (dirname)->contents, filename); } /* Return 1 if the file named NAME exists. */ int file_exists_p (name) register char *name; { char *dirend; char *dirname; #ifndef NO_ARCHIVES if (ar_name (name)) return ar_member_date (name) != (time_t) -1; #endif dirend = rindex (name, '/'); if (dirend == 0) return dir_file_exists_p (".", name); dirname = (char *) alloca (dirend - name + 1); bcopy (name, dirname, dirend - name); dirname[dirend - name] = '\0'; return dir_file_exists_p (dirname, dirend + 1); } /* Mark FILENAME as `impossible' for `file_impossible_p'. This means an attempt has been made to search for FILENAME as an intermediate file, and it has failed. */ void file_impossible (filename) register char *filename; { char *dirend; register char *p = filename; register unsigned int hash; register struct directory *dir; register struct dirfile *new; dirend = rindex (p, '/'); if (dirend == 0) dir = find_directory ("."); else { char *dirname = (char *) alloca (dirend - p + 1); bcopy (p, dirname, dirend - p); dirname[dirend - p] = '\0'; dir = find_directory (dirname); filename = p = dirend + 1; } for (hash = 0; *p != '\0'; ++p) HASH (hash, *p); hash %= DIRFILE_BUCKETS; if (dir->contents == 0) { /* The directory could not be stat'd. We allocate a contents structure for it, but leave it out of the contents hash table. */ dir->contents = (struct directory_contents *) xmalloc (sizeof (struct directory_contents)); dir->contents->dev = dir->contents->ino = 0; dir->contents->files = 0; dir->contents->dirstream = 0; } if (dir->contents->files == 0) { /* The directory was not opened; we must allocate the hash buckets. */ dir->contents->files = (struct dirfile **) xmalloc (sizeof (struct dirfile) * DIRFILE_BUCKETS); bzero ((char *) dir->contents->files, sizeof (struct dirfile) * DIRFILE_BUCKETS); } /* Make a new entry and put it in the table. */ new = (struct dirfile *) xmalloc (sizeof (struct dirfile)); new->next = dir->contents->files[hash]; dir->contents->files[hash] = new; new->name = savestring (filename, strlen (filename)); new->impossible = 1; } /* Return nonzero if FILENAME has been marked impossible. */ int file_impossible_p (filename) char *filename; { char *dirend; register char *p = filename; register unsigned int hash; register struct directory_contents *dir; register struct dirfile *next; dirend = rindex (filename, '/'); if (dirend == 0) dir = find_directory (".")->contents; else { char *dirname = (char *) alloca (dirend - filename + 1); bcopy (p, dirname, dirend - p); dirname[dirend - p] = '\0'; dir = find_directory (dirname)->contents; p = dirend + 1; } if (dir == 0 || dir->files == 0) /* There are no files entered for this directory. */ return 0; for (hash = 0; *p != '\0'; ++p) HASH (hash, *p); hash %= DIRFILE_BUCKETS; for (next = dir->files[hash]; next != 0; next = next->next) if (streq (filename, next->name)) return next->impossible; return 0; } /* Return the already allocated name in the directory hash table that matches DIR. */ char * dir_name (dir) char *dir; { return find_directory (dir)->name; } /* Print the data base of directories. */ void print_dir_data_base () { register unsigned int i, dirs, files, impossible; register struct directory *dir; puts ("\n# Directories\n"); dirs = files = impossible = 0; for (i = 0; i < DIRECTORY_BUCKETS; ++i) for (dir = directories[i]; dir != 0; dir = dir->next) { ++dirs; if (dir->contents == 0) printf ("# %s: could not be stat'd.\n", dir->name); else if (dir->contents->files == 0) printf ("# %s (device %d, inode %d): could not be opened.\n", dir->name, dir->contents->dev, dir->contents->ino); else { register unsigned int f = 0, im = 0; register unsigned int j; register struct dirfile *df; for (j = 0; j < DIRFILE_BUCKETS; ++j) for (df = dir->contents->files[j]; df != 0; df = df->next) if (df->impossible) ++im; else ++f; printf ("# %s (device %d, inode %d): ", dir->name, dir->contents->dev, dir->contents->ino); if (f == 0) fputs ("No", stdout); else printf ("%u", f); fputs (" files, ", stdout); if (im == 0) fputs ("no", stdout); else printf ("%u", im); fputs (" impossibilities", stdout); if (dir->contents->dirstream == 0) puts ("."); else puts (" so far."); files += f; impossible += im; } } fputs ("\n# ", stdout); if (files == 0) fputs ("No", stdout); else printf ("%u", files); fputs (" files, ", stdout); if (impossible == 0) fputs ("no", stdout); else printf ("%u", impossible); printf (" impossibilities in %u directories.\n", dirs); } /* Hooks for globbing. */ #include /* Structure describing state of iterating through a directory hash table. */ struct dirstream { struct directory_contents *contents; /* The directory being read. */ unsigned int bucket; /* Current hash bucket. */ struct dirfile *elt; /* Current elt in bucket. */ }; /* Forward declarations. */ static __ptr_t open_dirstream __P ((const char *)); static const char *read_dirstream __P ((__ptr_t)); static __ptr_t open_dirstream (directory) const char *directory; { struct dirstream *new; struct directory *dir = find_directory (directory); if (dir->contents == 0 || dir->contents->files == 0) /* DIR->contents is nil if the directory could not be stat'd. DIR->contents->files is nil if it could not be opened. */ return 0; /* Read all the contents of the directory now. There is no benefit in being lazy, since glob will want to see every file anyway. */ (void) dir_contents_file_exists_p (dir->contents, (char *) 0); new = (struct dirstream *) xmalloc (sizeof (struct dirstream)); new->contents = dir->contents; new->bucket = 0; new->elt = new->contents->files[0]; return (__ptr_t) new; } static const char * read_dirstream (stream) __ptr_t stream; { struct dirstream *const ds = (struct dirstream *) stream; register struct dirfile *df; while (ds->bucket < DIRFILE_BUCKETS) { while ((df = ds->elt) != 0) { ds->elt = df->next; if (!df->impossible) return df->name; } if (++ds->bucket == DIRFILE_BUCKETS) break; ds->elt = ds->contents->files[ds->bucket]; } return 0; } void init_dir () { __glob_opendir_hook = open_dirstream; __glob_readdir_hook = read_dirstream; __glob_closedir_hook = (void (*) __P ((__ptr_t stream))) free; } make-3.70/file.c 666 12241 13 30360 5503412713 6556 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "dep.h" #include "file.h" #include "variable.h" /* Hash table of files the makefile knows how to make. */ #ifndef FILE_BUCKETS #define FILE_BUCKETS 1007 #endif static struct file *files[FILE_BUCKETS]; /* Number of files with the `intermediate' flag set. */ unsigned int num_intermediates = 0; /* Access the hash table of all file records. lookup_file given a name, return the struct file * for that name, or nil if there is none. enter_file similar, but create one if there is none. */ struct file * lookup_file (name) char *name; { register struct file *f; register char *n; register unsigned int hashval; if (*name == '\0') abort (); /* This is also done in parse_file_seq, so this is redundant for names read from makefiles. It is here for names passed on the command line. */ while (name[0] == '.' && name[1] == '/' && name[2] != '\0') { name += 2; while (*name == '/') /* Skip following slashes: ".//foo" is "foo", not "/foo". */ ++name; } if (*name == '\0') /* It was all slashes after a dot. */ name = "./"; hashval = 0; for (n = name; *n != '\0'; ++n) HASH (hashval, *n); hashval %= FILE_BUCKETS; for (f = files[hashval]; f != 0; f = f->next) if (streq (f->name, name)) return f; return 0; } struct file * enter_file (name) char *name; { register struct file *f, *new; register char *n; register unsigned int hashval; if (*name == '\0') abort (); hashval = 0; for (n = name; *n != '\0'; ++n) HASH (hashval, *n); hashval %= FILE_BUCKETS; for (f = files[hashval]; f != 0; f = f->next) if (streq (f->name, name)) break; if (f != 0 && !f->double_colon) return f; new = (struct file *) xmalloc (sizeof (struct file)); bzero ((char *) new, sizeof (struct file)); new->name = name; new->update_status = -1; if (f == 0) { /* This is a completely new file. */ new->next = files[hashval]; files[hashval] = new; } else { /* There is already a double-colon entry for this file. */ while (f->prev != 0) f = f->prev; f->prev = new; } return new; } /* Rename FILE to NAME. This is not as simple as resetting the `name' member, since it must be put in a new hash bucket, and possibly merged with an existing file called NAME. */ void rename_file (file, name) register struct file *file; char *name; { char *oldname = file->name; register unsigned int oldhash; register char *n; while (file->renamed != 0) file = file->renamed; /* Find the hash values of the old and new names. */ oldhash = 0; for (n = oldname; *n != '\0'; ++n) HASH (oldhash, *n); file_hash_enter (file, name, oldhash, file->name); } void file_hash_enter (file, name, oldhash, oldname) register struct file *file; char *name; unsigned int oldhash; char *oldname; { unsigned int oldbucket = oldhash % FILE_BUCKETS; register unsigned int newhash, newbucket; struct file *oldfile; register char *n; register struct file *f; newhash = 0; for (n = name; *n != '\0'; ++n) HASH (newhash, *n); newbucket = newhash % FILE_BUCKETS; /* Look for an existing file under the new name. */ for (oldfile = files[newbucket]; oldfile != 0; oldfile = oldfile->next) if (streq (oldfile->name, name)) break; if (oldhash != 0 && (newbucket != oldbucket || oldfile != 0)) { /* Remove FILE from its hash bucket. */ struct file *lastf = 0; for (f = files[oldbucket]; f != file; f = f->next) lastf = f; if (lastf == 0) files[oldbucket] = f->next; else lastf->next = f->next; } /* Give FILE its new name. */ for (f = file; f != 0; f = f->prev) f->name = name; if (oldfile == 0) { /* There is no existing file with the new name. */ if (newbucket != oldbucket) { /* Put FILE in its new hash bucket. */ file->next = files[newbucket]; files[newbucket] = file; } } else { /* There is an existing file with the new name. We must merge FILE into the existing file. */ register struct dep *d; if (file->cmds != 0) { if (oldfile->cmds == 0) oldfile->cmds = file->cmds; else if (file->cmds != oldfile->cmds) { /* We have two sets of commands. We will go with the one given in the rule explicitly mentioning this name, but give a message to let the user know what's going on. */ if (oldfile->cmds->filename != 0) makefile_error (file->cmds->filename, file->cmds->lineno, "Commands were specified for \ file `%s' at %s:%u,", oldname, oldfile->cmds->filename, oldfile->cmds->lineno); else makefile_error (file->cmds->filename, file->cmds->lineno, "Commands for file `%s' were found by \ implicit rule search,", oldname); makefile_error (file->cmds->filename, file->cmds->lineno, "but `%s' is now considered the same file \ as `%s'.", oldname, name); makefile_error (file->cmds->filename, file->cmds->lineno, "Commands for `%s' will be ignored \ in favor of those for `%s'.", name, oldname); } } /* Merge the dependencies of the two files. */ d = oldfile->deps; if (d == 0) oldfile->deps = file->deps; else { while (d->next != 0) d = d->next; d->next = file->deps; } merge_variable_set_lists (&oldfile->variables, file->variables); if (oldfile->double_colon && !file->double_colon) fatal ("can't rename single-colon `%s' to double-colon `%s'", oldname, name); if (!oldfile->double_colon && file->double_colon) fatal ("can't rename double-colon `%s' to single-colon `%s'", oldname, name); if (file->last_mtime > oldfile->last_mtime) /* %%% Kludge so -W wins on a file that gets vpathized. */ oldfile->last_mtime = file->last_mtime; #define MERGE(field) oldfile->field |= file->field MERGE (precious); MERGE (tried_implicit); MERGE (updating); MERGE (updated); MERGE (is_target); MERGE (cmd_target); MERGE (phony); #undef MERGE file->renamed = oldfile; } } /* Remove all nonprecious intermediate files. If SIG is nonzero, this was caused by a fatal signal, meaning that a different message will be printed, and the message will go to stderr rather than stdout. */ void remove_intermediates (sig) int sig; { register int i; register struct file *f; char doneany; if (!sig && just_print_flag) return; doneany = 0; for (i = 0; i < FILE_BUCKETS; ++i) for (f = files[i]; f != 0; f = f->next) if (f->intermediate && (f->dontcare || !f->precious)) { int status; if (just_print_flag) status = 0; else { status = unlink (f->name); if (status < 0 && errno == ENOENT) continue; } if (!f->dontcare) { if (sig) error ("*** Deleting intermediate file `%s'", f->name); else if (!silent_flag) { if (! doneany) { fputs ("rm ", stdout); doneany = 1; } else putchar (' '); fputs (f->name, stdout); fflush (stdout); } if (status < 0) perror_with_name ("unlink: ", f->name); } } if (doneany && !sig) { putchar ('\n'); fflush (stdout); } } /* For each dependency of each file, make the `struct dep' point at the appropriate `struct file' (which may have to be created). Also mark the files depended on by .PRECIOUS and .PHONY. */ void snap_deps () { register struct file *f, *f2; register struct dep *d; register int i; /* Enter each dependency name as a file. */ for (i = 0; i < FILE_BUCKETS; ++i) for (f = files[i]; f != 0; f = f->next) for (f2 = f; f2 != 0; f2 = f2->prev) for (d = f2->deps; d != 0; d = d->next) if (d->name != 0) { d->file = lookup_file (d->name); if (d->file == 0) d->file = enter_file (d->name); else free (d->name); d->name = 0; } for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev) for (d = f->deps; d != 0; d = d->next) for (f2 = d->file; f2 != 0; f2 = f2->prev) f2->precious = 1; for (f = lookup_file (".PHONY"); f != 0; f = f->prev) for (d = f->deps; d != 0; d = d->next) for (f2 = d->file; f2 != 0; f2 = f2->prev) { /* Mark this file as phony and nonexistent. */ f2->phony = 1; f2->last_mtime = (time_t) -1; } f = lookup_file (".EXPORT_ALL_VARIABLES"); if (f != 0 && f->is_target) export_all_variables = 1; } /* Print the data base of files. */ static void print_file (f) struct file *f; { register struct dep *d; putchar ('\n'); if (!f->is_target) puts ("# Not a target:"); printf ("%s:%s", f->name, f->double_colon ? ":" : ""); for (d = f->deps; d != 0; d = d->next) printf (" %s", dep_name (d)); putchar ('\n'); if (f->precious) puts ("# Precious file (dependency of .PRECIOUS)."); if (f->phony) puts ("# Phony target (dependency of .PHONY)."); if (f->cmd_target) puts ("# Command-line target."); if (f->dontcare) puts ("# A default or MAKEFILES makefile."); printf ("# Implicit rule search has%s been done.\n", f->tried_implicit ? "" : " not"); if (f->stem != 0) printf ("# Implicit/static pattern stem: `%s'\n", f->stem); if (f->intermediate) puts ("# File is an intermediate dependency."); if (f->also_make != 0) { fputs ("# Also makes:", stdout); for (d = f->also_make; d != 0; d = d->next) printf (" %s", dep_name (d)); putchar ('\n'); } if (f->last_mtime == (time_t) 0) puts ("# Modification time never checked."); else if (f->last_mtime == (time_t) -1) puts ("# File does not exist."); else printf ("# Last modified %.24s (%ld)\n", ctime (&f->last_mtime), (long int) f->last_mtime); printf ("# File has%s been updated.\n", f->updated ? "" : " not"); switch (f->command_state) { case cs_running: puts ("# Commands currently running (THIS IS A BUG)."); break; case cs_deps_running: puts ("# Dependencies commands running (THIS IS A BUG)."); break; case cs_not_started: case cs_finished: switch (f->update_status) { case -1: break; case 0: puts ("# Successfully updated."); break; case 1: puts ("# Failed to be updated."); break; default: puts ("# Invalid value in `update_status' member!"); fflush (stdout); fflush (stderr); abort (); } break; default: puts ("# Invalid value in `command_state' member!"); fflush (stdout); fflush (stderr); abort (); } if (f->variables != 0) print_file_variables (f); if (f->cmds != 0) print_commands (f->cmds); } void print_file_data_base () { register unsigned int i, nfiles, per_bucket; register struct file *file; puts ("\n# Files"); per_bucket = nfiles = 0; for (i = 0; i < FILE_BUCKETS; ++i) { register unsigned int this_bucket = 0; for (file = files[i]; file != 0; file = file->next) { register struct file *f; ++this_bucket; for (f = file; f != 0; f = f->prev) print_file (f); } nfiles += this_bucket; if (this_bucket > per_bucket) per_bucket = this_bucket; } if (nfiles == 0) puts ("\n# No files."); else { printf ("\n# %u files in %u hash buckets.\n", nfiles, FILE_BUCKETS); #ifndef NO_FLOAT printf ("# average %.1f files per bucket, max %u files in one bucket.\n", ((double) nfiles) / ((double) FILE_BUCKETS) * 100.0, per_bucket); #endif } } make-3.70/getloadavg.c 666 12241 1 51700 5465726274 7753 /* Get the system load averages. Copyright (C) 1985, 86, 87, 88, 89, 91, 92, 93 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Compile-time symbols that this file uses: FIXUP_KERNEL_SYMBOL_ADDR() Adjust address in returned struct nlist. KERNEL_FILE Pathname of the kernel to nlist. LDAV_CVT() Scale the load average from the kernel. Returns a double. LDAV_SYMBOL Name of kernel symbol giving load average. LOAD_AVE_TYPE Type of the load average array in the kernel. Must be defined unless one of apollo, DGUX, NeXT, or UMAX is defined; otherwise, no load average is available. NLIST_STRUCT Include nlist.h, not a.out.h, and the nlist n_name element is a pointer, not an array. NLIST_NAME_UNION struct nlist has an n_un member, not n_name. LINUX_LDAV_FILE [__linux__]: File containing load averages. Specific system predefines this file uses, aside from setting default values if not emacs: apollo BSD Real BSD, not just BSD-like. DGUX eunice UNIX emulator under VMS. hpux NeXT sgi sequent Sequent Dynix 3.x.x (BSD) _SEQUENT_ Sequent DYNIX/ptx 1.x.x (SYSV) sony_news NEWS-OS (works at least for 4.1C) UMAX UMAX4_3 VMS __linux__ Linux: assumes /proc filesystem mounted. Support from Michael K. Johnson. __NetBSD__ NetBSD: assumes /kern filesystem mounted. In addition, to avoid nesting many #ifdefs, we internally set LDAV_DONE to indicate that the load average has been computed. We also #define LDAV_PRIVILEGED if a program will require special installation to be able to call getloadavg. */ #include /* Both the Emacs and non-Emacs sections want this. Some configuration files' definitions for the LOAD_AVE_CVT macro (like sparc.h's) use macros like FSCALE, defined here. */ #ifdef unix #include #endif #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif /* Exclude all the code except the test program at the end if the system has its own `getloadavg' function. */ #ifndef HAVE_GETLOADAVG /* The existing Emacs configuration files define a macro called LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and returns the load average multiplied by 100. What we actually want is a macro called LDAV_CVT, which returns the load average as an unmultiplied double. For backwards compatibility, we'll define LDAV_CVT in terms of LOAD_AVE_CVT, but future machine config files should just define LDAV_CVT directly. */ #if !defined(LDAV_CVT) && defined(LOAD_AVE_CVT) #define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0) #endif #if !defined (BSD) && defined (ultrix) /* Ultrix behaves like BSD on Vaxen. */ #define BSD #endif #ifdef NeXT /* NeXT in the 2.{0,1,2} releases defines BSD in , which conflicts with the definition understood in this file, that this really is BSD. */ #undef BSD /* NeXT defines FSCALE in . However, we take FSCALE being defined to mean that the nlist method should be used, which is not true. */ #undef FSCALE #endif /* Set values that are different from the defaults, which are set a little farther down with #ifndef. */ /* Some shorthands. */ #if defined (HPUX) && !defined (hpux) #define hpux #endif #if defined(hp300) && !defined(hpux) #define MORE_BSD #endif #if defined(ultrix) && defined(mips) #define decstation #endif #if defined(sun) && defined(SVR4) #define SUNOS_5 #endif #if defined (__osf__) && (defined (__alpha) || defined (__alpha__)) #define OSF_ALPHA #endif #if defined (__osf__) && (defined (mips) || defined (__mips__)) #define OSF_MIPS #include #endif /* UTek's /bin/cc on the 4300 has no architecture specific cpp define by default, but _MACH_IND_SYS_TYPES is defined in . Combine that with a couple of other things and we'll have a unique match. */ #if !defined (tek4300) && defined (unix) && defined (m68k) && defined (mc68000) && defined (mc68020) && defined (_MACH_IND_SYS_TYPES) #define tek4300 /* Define by emacs, but not by other users. */ #endif /* VAX C can't handle multi-line #ifs, or lines longer than 256 chars. */ #ifndef LOAD_AVE_TYPE #ifdef MORE_BSD #define LOAD_AVE_TYPE long #endif #ifdef sun #define LOAD_AVE_TYPE long #endif #ifdef decstation #define LOAD_AVE_TYPE long #endif #ifdef _SEQUENT_ #define LOAD_AVE_TYPE long #endif #ifdef sgi #define LOAD_AVE_TYPE long #endif #ifdef SVR4 #define LOAD_AVE_TYPE long #endif #ifdef sony_news #define LOAD_AVE_TYPE long #endif #ifdef sequent #define LOAD_AVE_TYPE long #endif #ifdef OSF_ALPHA #define LOAD_AVE_TYPE long #endif #if defined (ardent) && defined (titan) #define LOAD_AVE_TYPE long #endif #ifdef tek4300 #define LOAD_AVE_TYPE long #endif #endif /* No LOAD_AVE_TYPE. */ #ifdef OSF_ALPHA /* defines an incorrect value for FSCALE on Alpha OSF/1, according to ghazi@noc.rutgers.edu. */ #undef FSCALE #define FSCALE 1024.0 #endif #ifndef FSCALE /* SunOS and some others define FSCALE in sys/param.h. */ #ifdef MORE_BSD #define FSCALE 2048.0 #endif #if defined(MIPS) || defined(SVR4) || defined(decstation) #define FSCALE 256 #endif #if defined (sgi) || defined (sequent) /* Sometimes both MIPS and sgi are defined, so FSCALE was just defined above under #ifdef MIPS. But we want the sgi value. */ #undef FSCALE #define FSCALE 1000.0 #endif #if defined (ardent) && defined (titan) #define FSCALE 65536.0 #endif #ifdef tek4300 #define FSCALE 100.0 #endif #endif /* Not FSCALE. */ #if !defined (LDAV_CVT) && defined (FSCALE) #define LDAV_CVT(n) (((double) (n)) / FSCALE) #endif /* VAX C can't handle multi-line #ifs, or lines longer that 256 characters. */ #ifndef NLIST_STRUCT #ifdef MORE_BSD #define NLIST_STRUCT #endif #ifdef sun #define NLIST_STRUCT #endif #ifdef decstation #define NLIST_STRUCT #endif #ifdef hpux #define NLIST_STRUCT #endif #if defined (_SEQUENT_) || defined (sequent) #define NLIST_STRUCT #endif #ifdef sgi #define NLIST_STRUCT #endif #ifdef SVR4 #define NLIST_STRUCT #endif #ifdef sony_news #define NLIST_STRUCT #endif #ifdef OSF_ALPHA #define NLIST_STRUCT #endif #if defined (ardent) && defined (titan) #define NLIST_STRUCT #endif #ifdef tex4300 #define NLIST_STRUCT #endif #ifdef butterfly #define NLIST_STRUCT #endif #endif /* defined (NLIST_STRUCT) */ #if defined(sgi) || (defined(mips) && !defined(BSD)) #define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_value &= ~(1 << 31)) #endif #if !defined (KERNEL_FILE) && defined (sequent) #define KERNEL_FILE "/dynix" #endif #if !defined (KERNEL_FILE) && defined (hpux) #define KERNEL_FILE "/hp-ux" #endif #if !defined(KERNEL_FILE) && (defined(_SEQUENT_) || defined(MIPS) || defined(SVR4) || defined(ISC) || defined (sgi) || defined(SVR4) || (defined (ardent) && defined (titan))) #define KERNEL_FILE "/unix" #endif #if !defined (LDAV_SYMBOL) && defined (alliant) #define LDAV_SYMBOL "_Loadavg" #endif #if !defined(LDAV_SYMBOL) && ((defined(hpux) && !defined(hp9000s300)) || defined(_SEQUENT_) || defined(SVR4) || defined(ISC) || defined(sgi) || (defined (ardent) && defined (titan))) #define LDAV_SYMBOL "avenrun" #endif #ifdef HAVE_UNISTD_H #include #endif #include #include #ifndef errno extern int errno; #endif /* LOAD_AVE_TYPE should only get defined if we're going to use the nlist method. */ #if !defined(LOAD_AVE_TYPE) && (defined(BSD) || defined(LDAV_CVT) || defined(KERNEL_FILE) || defined(LDAV_SYMBOL)) #define LOAD_AVE_TYPE double #endif #ifdef LOAD_AVE_TYPE #ifndef VMS #ifndef NLIST_STRUCT #include #else /* NLIST_STRUCT */ #include #endif /* NLIST_STRUCT */ #ifdef SUNOS_5 #include #include #endif #ifndef KERNEL_FILE #define KERNEL_FILE "/vmunix" #endif /* KERNEL_FILE */ #ifndef LDAV_SYMBOL #define LDAV_SYMBOL "_avenrun" #endif /* LDAV_SYMBOL */ #else /* VMS */ #ifndef eunice #include #include #else /* eunice */ #include #endif /* eunice */ #endif /* VMS */ #ifndef LDAV_CVT #define LDAV_CVT(n) ((double) (n)) #endif /* !LDAV_CVT */ #endif /* LOAD_AVE_TYPE */ #ifdef NeXT #ifdef HAVE_MACH_MACH_H #include #else #include #endif #endif /* NeXT */ #ifdef sgi #include #endif /* sgi */ #ifdef UMAX #include #include #include #include #include #ifdef UMAX_43 #include #include #include #include #include #else /* Not UMAX_43. */ #include #include #include #include #include #include #endif /* Not UMAX_43. */ #endif /* UMAX */ #ifdef DGUX #include #endif #if defined(HAVE_FCNTL_H) || defined(_POSIX_VERSION) #include #else #include #endif /* Avoid static vars inside a function since in HPUX they dump as pure. */ #ifdef NeXT static processor_set_t default_set; static int getloadavg_initialized; #endif /* NeXT */ #ifdef UMAX static unsigned int cpus = 0; static unsigned int samples; #endif /* UMAX */ #ifdef DGUX static struct dg_sys_info_load_info load_info; /* what-a-mouthful! */ #endif /* DGUX */ #ifdef LOAD_AVE_TYPE /* File descriptor open to /dev/kmem or VMS load ave driver. */ static int channel; /* Nonzero iff channel is valid. */ static int getloadavg_initialized; /* Offset in kmem to seek to read load average, or 0 means invalid. */ static long offset; #if !defined(VMS) && !defined(sgi) static struct nlist nl[2]; #endif /* Not VMS or sgi */ #ifdef SUNOS_5 static kvm_t *kd; #endif /* SUNOS_5 */ #endif /* LOAD_AVE_TYPE */ /* Put the 1 minute, 5 minute and 15 minute load averages into the first NELEM elements of LOADAVG. Return the number written (never more than 3, but may be less than NELEM), or -1 if an error occurred. */ int getloadavg (loadavg, nelem) double loadavg[]; int nelem; { int elem = 0; /* Return value. */ #ifdef NO_GET_LOAD_AVG #define LDAV_DONE /* Set errno to zero to indicate that there was no particular error; this function just can't work at all on this system. */ errno = 0; elem = -1; #endif #if !defined (LDAV_DONE) && defined (__linux__) #define LDAV_DONE #undef LOAD_AVE_TYPE #ifndef LINUX_LDAV_FILE #define LINUX_LDAV_FILE "/proc/loadavg" #endif char ldavgbuf[40]; double load_ave[3]; int fd, count; fd = open (LINUX_LDAV_FILE, O_RDONLY); if (fd == -1) return -1; count = read (fd, ldavgbuf, 40); (void) close (fd); if (count <= 0) return -1; count = sscanf (ldavgbuf, "%lf %lf %lf", &load_ave[0], &load_ave[1], &load_ave[2]); if (count < 1) return -1; for (elem = 0; elem < nelem && elem < count; elem++) loadavg[elem] = load_ave[elem]; return elem; #endif /* __linux__ */ #if !defined (LDAV_DONE) && defined (__NetBSD__) #define LDAV_DONE #undef LOAD_AVE_TYPE #ifndef NETBSD_LDAV_FILE #define NETBSD_LDAV_FILE "/kern/loadavg" #endif unsigned long int load_ave[3], scale; int count; FILE *fp; fp = fopen (NETBSD_LDAV_FILE, "r"); if (fp == NULL) return -1; count = fscanf (fp, "%lu %lu %lu %lu\n", &load_ave[0], &load_ave[1], &load_ave[2], &scale); (void) fclose (fp); if (count != 4) return -1; for (elem = 0; elem < nelem; elem++) loadavg[elem] = (double) load_ave[elem] / (double) scale; return elem; #endif /* __NetBSD__ */ #if !defined (LDAV_DONE) && defined (NeXT) #define LDAV_DONE /* The NeXT code was adapted from iscreen 3.2. */ host_t host; struct processor_set_basic_info info; unsigned info_count; /* We only know how to get the 1-minute average for this system, so even if the caller asks for more than 1, we only return 1. */ if (!getloadavg_initialized) { if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS) getloadavg_initialized = 1; } if (getloadavg_initialized) { info_count = PROCESSOR_SET_BASIC_INFO_COUNT; if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host, (processor_set_info_t) &info, &info_count) != KERN_SUCCESS) getloadavg_initialized = 0; else { if (nelem > 0) loadavg[elem++] = (double) info.load_average / LOAD_SCALE; } } if (!getloadavg_initialized) return -1; #endif /* NeXT */ #if !defined (LDAV_DONE) && defined (UMAX) #define LDAV_DONE /* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not have a /dev/kmem. Information about the workings of the running kernel can be gathered with inq_stats system calls. We only know how to get the 1-minute average for this system. */ struct proc_summary proc_sum_data; struct stat_descr proc_info; double load; register unsigned int i, j; if (cpus == 0) { register unsigned int c, i; struct cpu_config conf; struct stat_descr desc; desc.sd_next = 0; desc.sd_subsys = SUBSYS_CPU; desc.sd_type = CPUTYPE_CONFIG; desc.sd_addr = (char *) &conf; desc.sd_size = sizeof conf; if (inq_stats (1, &desc)) return -1; c = 0; for (i = 0; i < conf.config_maxclass; ++i) { struct class_stats stats; bzero ((char *) &stats, sizeof stats); desc.sd_type = CPUTYPE_CLASS; desc.sd_objid = i; desc.sd_addr = (char *) &stats; desc.sd_size = sizeof stats; if (inq_stats (1, &desc)) return -1; c += stats.class_numcpus; } cpus = c; samples = cpus < 2 ? 3 : (2 * cpus / 3); } proc_info.sd_next = 0; proc_info.sd_subsys = SUBSYS_PROC; proc_info.sd_type = PROCTYPE_SUMMARY; proc_info.sd_addr = (char *) &proc_sum_data; proc_info.sd_size = sizeof (struct proc_summary); proc_info.sd_sizeused = 0; if (inq_stats (1, &proc_info) != 0) return -1; load = proc_sum_data.ps_nrunnable; j = 0; for (i = samples - 1; i > 0; --i) { load += proc_sum_data.ps_nrun[j]; if (j++ == PS_NRUNSIZE) j = 0; } if (nelem > 0) loadavg[elem++] = load / samples / cpus; #endif /* UMAX */ #if !defined (LDAV_DONE) && defined (DGUX) #define LDAV_DONE /* This call can return -1 for an error, but with good args it's not supposed to fail. The first argument is for no apparent reason of type `long int *'. */ dg_sys_info ((long int *) &load_info, DG_SYS_INFO_LOAD_INFO_TYPE, DG_SYS_INFO_LOAD_VERSION_0); if (nelem > 0) loadavg[elem++] = load_info.one_minute; if (nelem > 1) loadavg[elem++] = load_info.five_minute; if (nelem > 2) loadavg[elem++] = load_info.fifteen_minute; #endif /* DGUX */ #if !defined (LDAV_DONE) && defined (apollo) #define LDAV_DONE /* Apollo code from lisch@mentorg.com (Ray Lischner). This system call is not documented. The load average is obtained as three long integers, for the load average over the past minute, five minutes, and fifteen minutes. Each value is a scaled integer, with 16 bits of integer part and 16 bits of fraction part. I'm not sure which operating system first supported this system call, but I know that SR10.2 supports it. */ extern void proc1_$get_loadav (); unsigned long load_ave[3]; proc1_$get_loadav (load_ave); if (nelem > 0) loadavg[elem++] = load_ave[0] / 65536.0; if (nelem > 1) loadavg[elem++] = load_ave[1] / 65536.0; if (nelem > 2) loadavg[elem++] = load_ave[2] / 65536.0; #endif /* apollo */ #if !defined (LDAV_DONE) && defined (OSF_MIPS) #define LDAV_DONE struct tbl_loadavg load_ave; table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave)); loadavg[elem++] = (load_ave.tl_lscale == 0 ? load_ave.tl_avenrun.d[0] : (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale)); #endif /* OSF_MIPS */ #if !defined (LDAV_DONE) && defined (VMS) /* VMS specific code -- read from the Load Ave driver. */ LOAD_AVE_TYPE load_ave[3]; static int getloadavg_initialized = 0; #ifdef eunice struct { int dsc$w_length; char *dsc$a_pointer; } descriptor; #endif /* Ensure that there is a channel open to the load ave device. */ if (!getloadavg_initialized) { /* Attempt to open the channel. */ #ifdef eunice descriptor.dsc$w_length = 18; descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE"; #else $DESCRIPTOR (descriptor, "LAV0:"); #endif if (sys$assign (&descriptor, &channel, 0, 0) & 1) getloadavg_initialized = 1; } /* Read the load average vector. */ if (getloadavg_initialized && !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0, load_ave, 12, 0, 0, 0, 0) & 1)) { sys$dassgn (channel); getloadavg_initialized = 0; } if (!getloadavg_initialized) return -1; #endif /* VMS */ #if !defined (LDAV_DONE) && defined(LOAD_AVE_TYPE) && !defined(VMS) /* UNIX-specific code -- read the average from /dev/kmem. */ #define LDAV_PRIVILEGED /* This code requires special installation. */ LOAD_AVE_TYPE load_ave[3]; /* Get the address of LDAV_SYMBOL. */ if (offset == 0) { #ifndef sgi #ifndef NLIST_STRUCT strcpy (nl[0].n_name, LDAV_SYMBOL); strcpy (nl[1].n_name, ""); #else /* NLIST_STRUCT */ #ifdef NLIST_NAME_UNION nl[0].n_un.n_name = LDAV_SYMBOL; nl[1].n_un.n_name = 0; #else /* not NLIST_NAME_UNION */ nl[0].n_name = LDAV_SYMBOL; nl[1].n_name = 0; #endif /* not NLIST_NAME_UNION */ #endif /* NLIST_STRUCT */ #ifndef SUNOS_5 if (nlist (KERNEL_FILE, nl) >= 0) /* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i. */ { #ifdef FIXUP_KERNEL_SYMBOL_ADDR FIXUP_KERNEL_SYMBOL_ADDR (nl); #endif offset = nl[0].n_value; } #endif /* !SUNOS_5 */ #else /* sgi */ int ldav_off; ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN); if (ldav_off != -1) offset = (long) ldav_off & 0x7fffffff; #endif /* sgi */ } /* Make sure we have /dev/kmem open. */ if (!getloadavg_initialized) { #ifndef SUNOS_5 channel = open ("/dev/kmem", 0); if (channel >= 0) getloadavg_initialized = 1; #else /* SUNOS_5 */ /* We pass 0 for the kernel, corefile, and swapfile names to use the currently running kernel. */ kd = kvm_open (0, 0, 0, O_RDONLY, 0); if (kd != 0) { /* nlist the currently running kernel. */ kvm_nlist (kd, nl); offset = nl[0].n_value; getloadavg_initialized = 1; } #endif /* SUNOS_5 */ } /* If we can, get the load average values. */ if (offset && getloadavg_initialized) { /* Try to read the load. */ #ifndef SUNOS_5 if (lseek (channel, offset, 0) == -1L || read (channel, (char *) load_ave, sizeof (load_ave)) != sizeof (load_ave)) { close (channel); getloadavg_initialized = 0; } #else /* SUNOS_5 */ if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave)) != sizeof (load_ave)) { kvm_close (kd); getloadavg_initialized = 0; } #endif /* SUNOS_5 */ } if (offset == 0 || !getloadavg_initialized) return -1; #endif /* LOAD_AVE_TYPE and not VMS */ #if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS. */ if (nelem > 0) loadavg[elem++] = LDAV_CVT (load_ave[0]); if (nelem > 1) loadavg[elem++] = LDAV_CVT (load_ave[1]); if (nelem > 2) loadavg[elem++] = LDAV_CVT (load_ave[2]); #define LDAV_DONE #endif /* !LDAV_DONE && LOAD_AVE_TYPE */ #ifdef LDAV_DONE return elem; #else /* Set errno to zero to indicate that there was no particular error; this function just can't work at all on this system. */ errno = 0; return -1; #endif } #endif /* ! HAVE_GETLOADAVG */ #ifdef TEST void main (argc, argv) int argc; char **argv; { int naptime = 0; if (argc > 1) naptime = atoi (argv[1]); while (1) { double avg[3]; int loads; errno = 0; /* Don't be misled if it doesn't set errno. */ loads = getloadavg (avg, 3); if (loads == -1) { perror ("Error getting load average"); exit (1); } if (loads > 0) printf ("1-minute: %f ", avg[0]); if (loads > 1) printf ("5-minute: %f ", avg[1]); if (loads > 2) printf ("15-minute: %f ", avg[2]); if (loads > 0) putchar ('\n'); if (naptime == 0) break; sleep (naptime); } exit (0); } #endif /* TEST */ make-3.70/misc.c 666 12241 13 35533 5477451032 6610 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "dep.h" /* Compare strings *S1 and *S2. Return negative if the first is less, positive if it is greater, zero if they are equal. */ int alpha_compare (s1, s2) char **s1, **s2; { if (**s1 != **s2) return **s1 - **s2; return strcmp (*s1, *s2); } /* Discard each backslash-newline combination from LINE. Backslash-backslash-newline combinations become backslash-newlines. This is done by copying the text at LINE into itself. */ void collapse_continuations (line) char *line; { register char *in, *out, *p; register int backslash; register unsigned int bs_write; in = index (line, '\n'); if (in == 0) return; out = in; if (out > line) while (out[-1] == '\\') --out; while (*in != '\0') { /* BS_WRITE gets the number of quoted backslashes at the end just before IN, and BACKSLASH gets nonzero if the next character is quoted. */ backslash = 0; bs_write = 0; for (p = in - 1; p >= line && *p == '\\'; --p) { if (backslash) ++bs_write; backslash = !backslash; /* It should be impossible to go back this far without exiting, but if we do, we can't get the right answer. */ if (in == out - 1) abort (); } /* Output the appropriate number of backslashes. */ while (bs_write-- > 0) *out++ = '\\'; /* Skip the newline. */ ++in; /* If the newline is quoted, discard following whitespace and any preceding whitespace; leave just one space. */ if (backslash) { in = next_token (in); while (out > line && isblank (out[-1])) --out; *out++ = ' '; } else /* If the newline isn't quoted, put it in the output. */ *out++ = '\n'; /* Now copy the following line to the output. Stop when we find backslashes followed by a newline. */ while (*in != '\0') if (*in == '\\') { p = in + 1; while (*p == '\\') ++p; if (*p == '\n') { in = p; break; } while (in < p) *out++ = *in++; } else *out++ = *in++; } *out = '\0'; } /* Remove comments from LINE. This is done by copying the text at LINE onto itself. */ void remove_comments (line) char *line; { register char *p, *p2; register int backslash; register unsigned int bs_write; while (1) { p = index (line, '#'); if (p == 0) break; backslash = 0; bs_write = 0; for (p2 = p - 1; p2 >= line && *p2 == '\\'; --p2) { if (backslash) ++bs_write; backslash = !backslash; } if (!backslash) { /* Cut off the line at the #. */ *p = '\0'; break; } /* strcpy better copy left to right. */ line = p; strcpy (p2 + 1 + bs_write, line); } } /* Print N spaces (used by DEBUGPR for target-depth). */ void print_spaces (n) register unsigned int n; { while (n-- > 0) putchar (' '); } /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */ char * concat (s1, s2, s3) register char *s1, *s2, *s3; { register unsigned int len1, len2, len3; register char *result; len1 = *s1 != '\0' ? strlen (s1) : 0; len2 = *s2 != '\0' ? strlen (s2) : 0; len3 = *s3 != '\0' ? strlen (s3) : 0; result = (char *) xmalloc (len1 + len2 + len3 + 1); if (*s1 != '\0') bcopy (s1, result, len1); if (*s2 != '\0') bcopy (s2, result + len1, len2); if (*s3 != '\0') bcopy (s3, result + len1 + len2, len3); *(result + len1 + len2 + len3) = '\0'; return result; } /* Print a message on stdout. */ void message (s1, s2, s3, s4, s5, s6) char *s1, *s2, *s3, *s4, *s5, *s6; { if (makelevel == 0) printf ("%s: ", program); else printf ("%s[%u]: ", program, makelevel); printf (s1, s2, s3, s4, s5, s6); putchar ('\n'); fflush (stdout); } /* Print an error message and exit. */ /* VARARGS1 */ void fatal (s1, s2, s3, s4, s5, s6) char *s1, *s2, *s3, *s4, *s5, *s6; { if (makelevel == 0) fprintf (stderr, "%s: *** ", program); else fprintf (stderr, "%s[%u]: *** ", program, makelevel); fprintf (stderr, s1, s2, s3, s4, s5, s6); fputs (". Stop.\n", stderr); die (1); } /* Print error message. `s1' is printf control string, `s2' is arg for it. */ /* VARARGS1 */ void error (s1, s2, s3, s4, s5, s6) char *s1, *s2, *s3, *s4, *s5, *s6; { if (makelevel == 0) fprintf (stderr, "%s: ", program); else fprintf (stderr, "%s[%u]: ", program, makelevel); fprintf (stderr, s1, s2, s3, s4, s5, s6); putc ('\n', stderr); fflush (stderr); } void makefile_error (file, lineno, s1, s2, s3, s4, s5, s6) char *file; unsigned int lineno; char *s1, *s2, *s3, *s4, *s5, *s6; { fprintf (stderr, "%s:%u: ", file, lineno); fprintf (stderr, s1, s2, s3, s4, s5, s6); putc ('\n', stderr); fflush (stderr); } void makefile_fatal (file, lineno, s1, s2, s3, s4, s5, s6) char *file; unsigned int lineno; char *s1, *s2, *s3, *s4, *s5, *s6; { fprintf (stderr, "%s:%u: *** ", file, lineno); fprintf (stderr, s1, s2, s3, s4, s5, s6); fputs (". Stop.\n", stderr); die (1); } #ifndef HAVE_STRERROR char * strerror (errnum) int errnum; { extern int errno, sys_nerr; extern char *sys_errlist[]; static char buf[] = "Unknown error 12345678901234567890"; if (errno < sys_nerr) return sys_errlist[errnum]; sprintf ("Unknown error %d", buf, errnum); return buf; } #endif /* Print an error message from errno. */ void perror_with_name (str, name) char *str, *name; { error ("%s%s: %s", str, name, strerror (errno)); } /* Print an error message from errno and exit. */ void pfatal_with_name (name) char *name; { fatal ("%s: %s", name, strerror (errno)); /* NOTREACHED */ } /* Like malloc but get fatal error if memory is exhausted. */ #undef xmalloc #undef xrealloc char * xmalloc (size) unsigned int size; { char *result = (char *) malloc (size); if (result == 0) fatal ("virtual memory exhausted"); return result; } char * xrealloc (ptr, size) char *ptr; unsigned int size; { char *result = (char *) realloc (ptr, size); if (result == 0) fatal ("virtual memory exhausted"); return result; } char * savestring (str, length) char *str; unsigned int length; { register char *out = (char *) xmalloc (length + 1); if (length > 0) bcopy (str, out, length); out[length] = '\0'; return out; } /* Search string BIG (length BLEN) for an occurrence of string SMALL (length SLEN). Return a pointer to the beginning of the first occurrence, or return nil if none found. */ char * sindex (big, blen, small, slen) char *big; unsigned int blen; char *small; unsigned int slen; { register unsigned int b; if (blen < 1) blen = strlen (big); if (slen < 1) slen = strlen (small); for (b = 0; b < blen; ++b) if (big[b] == *small && !strncmp (&big[b + 1], small + 1, slen - 1)) return (&big[b]); return 0; } /* Limited INDEX: Search through the string STRING, which ends at LIMIT, for the character C. Returns a pointer to the first occurrence, or nil if none is found. Like INDEX except that the string searched ends where specified instead of at the first null. */ char * lindex (s, limit, c) register char *s, *limit; int c; { while (s < limit) if (*s++ == c) return s - 1; return 0; } /* Return the address of the first whitespace or null in the string S. */ char * end_of_token (s) char *s; { register char *p = s; register int backslash = 0; while (*p != '\0' && (backslash || !isblank (*p))) { if (*p++ == '\\') { backslash = !backslash; while (*p == '\\') { backslash = !backslash; ++p; } } else backslash = 0; } return p; } /* Return the address of the first nonwhitespace or null in the string S. */ char * next_token (s) char *s; { register char *p = s; while (isblank (*p)) ++p; return p; } /* Find the next token in PTR; return the address of it, and store the length of the token into *LENGTHPTR if LENGTHPTR is not nil. */ char * find_next_token (ptr, lengthptr) char **ptr; unsigned int *lengthptr; { char *p = next_token (*ptr); char *end; if (*p == '\0') return 0; *ptr = end = end_of_token (p); if (lengthptr != 0) *lengthptr = end - p; return p; } /* Copy a chain of `struct dep', making a new chain with the same contents as the old one. */ struct dep * copy_dep_chain (d) register struct dep *d; { register struct dep *c; struct dep *firstnew = 0; struct dep *lastnew; while (d != 0) { c = (struct dep *) xmalloc (sizeof (struct dep)); bcopy ((char *) d, (char *) c, sizeof (struct dep)); if (c->name != 0) c->name = savestring (c->name, strlen (c->name)); c->next = 0; if (firstnew == 0) firstnew = lastnew = c; else lastnew = lastnew->next = c; d = d->next; } return firstnew; } #ifdef iAPX286 /* The losing compiler on this machine can't handle this macro. */ char * dep_name (dep) struct dep *dep; { return dep->name == 0 ? dep->file->name : dep->name; } #endif #ifdef GETLOADAVG_PRIVILEGED #ifndef HAVE_UNISTD_H extern int getuid (), getgid (), geteuid (), getegid (); extern int setuid (), setgid (); #ifdef HAVE_SETREUID extern int setreuid (); #endif /* Have setreuid. */ #ifdef HAVE_SETREGID extern int setregid (); #endif /* Have setregid. */ #endif /* No . */ /* Keep track of the user and group IDs for user- and make- access. */ static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1; #define access_inited (user_uid != -1) static enum { make, user } current_access; /* Under -d, write a message describing the current IDs. */ static void log_access (flavor) char *flavor; { if (! debug_flag) return; /* All the other debugging messages go to stdout, but we write this one to stderr because it might be run in a child fork whose stdout is piped. */ fprintf (stderr, "%s access: user %d (real %d), group %d (real %d)\n", flavor, geteuid (), getuid (), getegid (), getgid ()); fflush (stderr); } static void init_access () { user_uid = getuid (); user_gid = getgid (); make_uid = geteuid (); make_gid = getegid (); /* Do these ever fail? */ if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1) pfatal_with_name ("get{e}[gu]id"); log_access ("Initialized"); current_access = make; } #endif /* GETLOADAVG_PRIVILEGED */ /* Give the process appropriate permissions for access to user data (i.e., to stat files, or to spawn a child process). */ void user_access () { #ifdef GETLOADAVG_PRIVILEGED if (!access_inited) init_access (); if (current_access == user) return; /* We are in "make access" mode. This means that the effective user and group IDs are those of make (if it was installed setuid or setgid). We now want to set the effective user and group IDs to the real IDs, which are the IDs of the process that exec'd make. */ #ifndef HAVE_SETREUID /* System V has only the setuid/setgid calls to set user/group IDs. There is an effective ID, which can be set by setuid/setgid. It can be set (unless you are root) only to either what it already is (returned by geteuid/getegid, now in make_uid/make_gid), the real ID (return by getuid/getgid, now in user_uid/user_gid), or the saved set ID (what the effective ID was before this set-ID executable (make) was exec'd). */ if (setuid (user_uid) < 0) pfatal_with_name ("user_access: setuid"); #else /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs. They may be set to themselves or each other. So you have two alternatives at any one time. If you use setuid/setgid, the effective will be set to the real, leaving only one alternative. Using setreuid/setregid, however, you can toggle between your two alternatives by swapping the values in a single setreuid or setregid call. */ if (setreuid (make_uid, user_uid) < 0) pfatal_with_name ("user_access: setreuid"); #endif #ifndef HAVE_SETREGID if (setgid (user_gid) < 0) pfatal_with_name ("user_access: setgid"); #else if (setregid (make_gid, user_gid) < 0) pfatal_with_name ("user_access: setregid"); #endif current_access = user; log_access ("User"); #endif /* GETLOADAVG_PRIVILEGED */ } /* Give the process appropriate permissions for access to make data (i.e., the load average). */ void make_access () { #ifdef GETLOADAVG_PRIVILEGED if (!access_inited) init_access (); if (current_access == make) return; /* See comments in user_access, above. */ #ifndef HAVE_SETREUID if (setuid (make_uid) < 0) pfatal_with_name ("make_access: setuid"); #else if (setreuid (user_uid, make_uid) < 0) pfatal_with_name ("make_access: setreuid"); #endif #ifndef HAVE_SETREGID if (setgid (make_gid) < 0) pfatal_with_name ("make_access: setgid"); #else if (setregid (user_gid, make_gid) < 0) pfatal_with_name ("make_access: setregid"); #endif current_access = make; log_access ("Make"); #endif /* GETLOADAVG_PRIVILEGED */ } /* Give the process appropriate permissions for a child process. This is like user_access, but you can't get back to make_access. */ void child_access () { #ifdef GETLOADAVG_PRIVILEGED if (!access_inited) abort (); /* Set both the real and effective UID and GID to the user's. They cannot be changed back to make's. */ #ifndef HAVE_SETREUID if (setuid (user_uid) < 0) pfatal_with_name ("child_access: setuid"); #else if (setreuid (user_uid, user_uid) < 0) pfatal_with_name ("child_access: setreuid"); #endif #ifndef HAVE_SETREGID if (setgid (user_gid) < 0) pfatal_with_name ("child_access: setgid"); #else if (setregid (user_gid, user_gid) < 0) pfatal_with_name ("child_access: setregid"); #endif log_access ("Child"); #endif /* GETLOADAVG_PRIVILEGED */ } #ifdef NEED_GET_PATH_MAX unsigned int get_path_max () { static unsigned int value; if (value == 0) { long int x = pathconf ("/", _PC_PATH_MAX); if (x > 0) value = x; else return MAXPATHLEN; } return value; } #endif make-3.70/main.c 666 12241 13 136500 5504140274 6607 /* Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "dep.h" #include "file.h" #include "variable.h" #include "job.h" #include "getopt.h" extern void print_variable_data_base (); extern void print_dir_data_base (); extern void print_rule_data_base (); extern void print_file_data_base (); extern void print_vpath_data_base (); #ifndef HAVE_UNISTD_H extern int chdir (); #endif #ifndef STDC_HEADERS #ifndef sun /* Sun has an incorrect decl in a header. */ extern void exit (); #endif extern double atof (); #endif extern char *mktemp (); static void log_working_directory (); static void print_data_base (), print_version (); static void decode_switches (), decode_env_switches (); static void define_makeflags (); /* The structure that describes an accepted command switch. */ struct command_switch { char c; /* The switch character. */ enum /* Type of the value. */ { flag, /* Turn int flag on. */ flag_off, /* Turn int flag off. */ string, /* One string per switch. */ positive_int, /* A positive integer. */ floating, /* A floating-point number (double). */ ignore /* Ignored. */ } type; char *value_ptr; /* Pointer to the value-holding variable. */ unsigned int env:1; /* Can come from MAKEFLAGS. */ unsigned int toenv:1; /* Should be put in MAKEFLAGS. */ unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */ char *noarg_value; /* Pointer to value used if no argument is given. */ char *default_value;/* Pointer to default value. */ char *long_name; /* Long option name. */ char *argdesc; /* Descriptive word for argument. */ char *description; /* Description for usage message. */ }; /* The structure used to hold the list of strings given in command switches of a type that takes string arguments. */ struct stringlist { char **list; /* Nil-terminated list of strings. */ unsigned int idx; /* Index into above. */ unsigned int max; /* Number of pointers allocated. */ }; /* The recognized command switches. */ /* Nonzero means do not print commands to be executed (-s). */ int silent_flag; /* Nonzero means just touch the files that would appear to need remaking (-t) */ int touch_flag; /* Nonzero means just print what commands would need to be executed, don't actually execute them (-n). */ int just_print_flag; /* Print debugging trace info (-d). */ int debug_flag = 0; /* Environment variables override makefile definitions. */ int env_overrides = 0; /* Nonzero means ignore status codes returned by commands executed to remake files. Just treat them all as successful (-i). */ int ignore_errors_flag = 0; /* Nonzero means don't remake anything, just print the data base that results from reading the makefile (-p). */ int print_data_base_flag = 0; /* Nonzero means don't remake anything; just return a nonzero status if the specified targets are not up to date (-q). */ int question_flag = 0; /* Nonzero means do not use any of the builtin rules (-r). */ int no_builtin_rules_flag = 0; /* Nonzero means keep going even if remaking some file fails (-k). */ int keep_going_flag; int default_keep_going_flag = 0; /* Nonzero means print directory before starting and when done (-w). */ int print_directory_flag = 0; /* Nonzero means ignore print_directory_flag and never print the directory. This is necessary because print_directory_flag is set implicitly. */ int inhibit_print_directory_flag = 0; /* Nonzero means print version information. */ int print_version_flag = 0; /* List of makefiles given with -f switches. */ static struct stringlist *makefiles = 0; /* Number of job slots (commands that can be run at once). */ unsigned int job_slots = 1; unsigned int default_job_slots = 1; /* Value of job_slots that means no limit. */ static unsigned int inf_jobs = 0; /* Maximum load average at which multiple jobs will be run. Negative values mean unlimited, while zero means limit to zero load (which could be useful to start infinite jobs remotely but one at a time locally). */ double max_load_average = -1.0; double default_load_average = -1.0; /* List of directories given with -C switches. */ static struct stringlist *directories = 0; /* List of include directories given with -I switches. */ static struct stringlist *include_directories = 0; /* List of files given with -o switches. */ static struct stringlist *old_files = 0; /* List of files given with -W switches. */ static struct stringlist *new_files = 0; /* If nonzero, we should just print usage and exit. */ static int print_usage_flag = 0; /* If nonzero, we should print a warning message for each reference to an undefined variable. */ int warn_undefined_variables_flag; /* The table of command switches. */ static const struct command_switch switches[] = { { 'b', ignore, 0, 0, 0, 0, 0, 0, 0, 0, "Ignored for compatibility" }, { 'C', string, (char *) &directories, 0, 0, 0, 0, 0, "directory", "DIRECTORY", "Change to DIRECTORY before doing anything" }, { 'd', flag, (char *) &debug_flag, 1, 1, 0, 0, 0, "debug", 0, "Print lots of debugging information" }, { 'e', flag, (char *) &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", 0, "Environment variables override makefiles" }, { 'f', string, (char *) &makefiles, 0, 0, 0, 0, 0, "file", "FILE", "Read FILE as a makefile" }, { 'h', flag, (char *) &print_usage_flag, 0, 0, 0, 0, 0, "help", 0, "Print this message and exit" }, { 'i', flag, (char *) &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors", 0, "Ignore errors from commands" }, { 'I', string, (char *) &include_directories, 1, 1, 0, 0, 0, "include-dir", "DIRECTORY", "Search DIRECTORY for included makefiles" }, { 'j', positive_int, (char *) &job_slots, 1, 1, 0, (char *) &inf_jobs, (char *) &default_job_slots, "jobs", "N", "Allow N jobs at once; infinite jobs with no arg" }, { 'k', flag, (char *) &keep_going_flag, 1, 1, 0, 0, (char *) &default_keep_going_flag, "keep-going", 0, "Keep going when some targets can't be made" }, { 'l', floating, (char *) &max_load_average, 1, 1, 0, (char *) &default_load_average, (char *) &default_load_average, "load-average", "N", "Don't start multiple jobs unless load is below N" }, { 'm', ignore, 0, 0, 0, 0, 0, 0, 0, 0, "-b" }, { 'n', flag, (char *) &just_print_flag, 1, 1, 1, 0, 0, "just-print", 0, "Don't actually run any commands; just print them" }, { 'o', string, (char *) &old_files, 0, 0, 0, 0, 0, "old-file", "FILE", "Consider FILE to be very old and don't remake it" }, { 'p', flag, (char *) &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base", 0, "Print make's internal database" }, { 'q', flag, (char *) &question_flag, 1, 1, 1, 0, 0, "question", 0, "Run no commands; exit status says if up to date" }, { 'r', flag, (char *) &no_builtin_rules_flag, 1, 1, 0, 0, 0, "no-builtin-rules", 0, "Disable the built-in implicit rules" }, { 's', flag, (char *) &silent_flag, 1, 1, 0, 0, 0, "silent", 0, "Don't echo commands" }, { 'S', flag_off, (char *) &keep_going_flag, 1, 1, 0, 0, (char *) &default_keep_going_flag, "no-keep-going", 0, "Turns off -k" }, { 't', flag, (char *) &touch_flag, 1, 1, 1, 0, 0, "touch", 0, "Touch targets instead of remaking them" }, { 'v', flag, (char *) &print_version_flag, 1, 1, 0, 0, 0, "version", 0, "Print the version number of make and exit" }, { 'w', flag, (char *) &print_directory_flag, 1, 1, 0, 0, 0, "print-directory", 0, "Print the current directory" }, { 1, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0, "no-print-directory", 0, "Turn off -w, even if it was turned on implicitly" }, { 'W', string, (char *) &new_files, 0, 0, 0, 0, 0, "what-if", "FILE", "Consider FILE to be infinitely new" }, { 2, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0, "warn-undefined-variables", 0, "Warn when an undefined variable is referenced" }, { '\0', } }; /* Secondary long names for options. */ static struct option long_option_aliases[] = { { "quiet", no_argument, 0, 's' }, { "stop", no_argument, 0, 'S' }, { "new-file", required_argument, 0, 'W' }, { "assume-new", required_argument, 0, 'W' }, { "assume-old", required_argument, 0, 'o' }, { "max-load", optional_argument, 0, 'l' }, { "dry-run", no_argument, 0, 'n' }, { "recon", no_argument, 0, 'n' }, { "makefile", required_argument, 0, 'f' }, }; /* The usage message prints the descriptions of options starting in this column. Make sure it leaves enough room for the longest description to fit in less than 80 characters. */ #define DESCRIPTION_COLUMN 30 /* List of non-switch arguments. */ struct stringlist *other_args = 0; /* The name we were invoked with. */ char *program; /* Our current directory after processing all -C options. */ char *starting_directory; /* Value of the MAKELEVEL variable at startup (or 0). */ unsigned int makelevel; /* First file defined in the makefile whose name does not start with `.'. This is the default to remake if the command line does not specify. */ struct file *default_goal_file; /* Pointer to structure for the file .DEFAULT whose commands are used for any file that has none of its own. This is zero if the makefiles do not define .DEFAULT. */ struct file *default_file; /* Mask of signals that are being caught with fatal_error_signal. */ #ifdef POSIX sigset_t fatal_signal_set; #else #ifdef HAVE_SIGSETMASK int fatal_signal_mask; #endif #endif static struct file * enter_command_line_file (name) char *name; { if (name[0] == '~') { char *expanded = tilde_expand (name); if (expanded != 0) name = expanded; /* Memory leak; I don't care. */ } /* This is also done in parse_file_seq, so this is redundant for names read from makefiles. It is here for names passed on the command line. */ while (name[0] == '.' && name[1] == '/' && name[2] != '\0') { name += 2; while (*name == '/') /* Skip following slashes: ".//foo" is "foo", not "/foo". */ ++name; } if (*name == '\0') { /* It was all slashes! Move back to the dot and truncate it after the first slash, so it becomes just "./". */ do --name; while (name[0] != '.'); name[2] = '\0'; } return enter_file (savestring (name, strlen (name))); } int main (argc, argv, envp) int argc; char **argv; char **envp; { extern void init_dir (); extern RETSIGTYPE fatal_error_signal (), child_handler (); register struct file *f; register unsigned int i; register char *cmd_defs; register unsigned int cmd_defs_len, cmd_defs_idx; char **p; struct dep *goals = 0; register struct dep *lastgoal; struct dep *read_makefiles; PATH_VAR (current_directory); char *directory_before_chdir; default_goal_file = 0; reading_filename = 0; reading_lineno_ptr = 0; #ifndef HAVE_SYS_SIGLIST signame_init (); #endif #ifdef POSIX sigemptyset (&fatal_signal_set); #define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig) #else #ifdef HAVE_SIGSETMASK fatal_signal_mask = 0; #define ADD_SIG(sig) fatal_signal_mask |= sigmask (sig) #else #define ADD_SIG(sig) #endif #endif #define FATAL_SIG(sig) \ if (signal ((sig), fatal_error_signal) == SIG_IGN) \ (void) signal ((sig), SIG_IGN); \ else \ ADD_SIG (sig); FATAL_SIG (SIGHUP); FATAL_SIG (SIGQUIT); FATAL_SIG (SIGINT); FATAL_SIG (SIGTERM); #ifdef SIGDANGER FATAL_SIG (SIGDANGER); #endif #ifdef SIGXCPU FATAL_SIG (SIGXCPU); #endif #ifdef SIGXFSZ FATAL_SIG (SIGXFSZ); #endif #undef FATAL_SIG /* Make sure stdout is line-buffered. */ #ifdef HAVE_SETLINEBUF setlinebuf (stdout); #else #ifndef SETVBUF_REVERSED setvbuf (stdout, (char *) 0, _IOLBF, BUFSIZ); #else /* setvbuf not reversed. */ /* Some buggy systems lose if we pass 0 instead of allocating ourselves. */ setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ); #endif /* setvbuf reversed. */ #endif /* setlinebuf missing. */ /* Initialize the directory hashing code. */ init_dir (); /* Set up to access user data (files). */ user_access (); /* Figure out where this program lives. */ if (argv[0] == 0) argv[0] = ""; if (argv[0][0] == '\0') program = "make"; else { program = rindex (argv[0], '/'); if (program == 0) program = argv[0]; else ++program; } /* Figure out where we are. */ if (getcwd (current_directory, GET_PATH_MAX) == 0) { #ifdef HAVE_GETCWD perror_with_name ("getcwd: ", ""); #else error ("getwd: %s", current_directory); #endif current_directory[0] = '\0'; directory_before_chdir = 0; } else directory_before_chdir = savestring (current_directory, strlen (current_directory)); /* Read in variables from the environment. It is important that this be done before `MAKE' and `MAKEOVERRIDES' are figured out so their definitions will not be ones from the environment. */ for (i = 0; envp[i] != 0; ++i) { register char *ep = envp[i]; while (*ep != '=') ++ep; /* The result of pointer arithmetic is cast to unsigned int for machines where ptrdiff_t is a different size that doesn't widen the same. */ define_variable (envp[i], (unsigned int) (ep - envp[i]), ep + 1, o_env, 1) /* Force exportation of every variable culled from the environment. We used to rely on target_environment's v_default code to do this. But that does not work for the case where an environment variable is redefined in a makefile with `override'; it should then still be exported, because it was originally in the environment. */ ->export = v_export; } /* Decode the switches. */ decode_env_switches ("MAKEFLAGS", 9); #if 0 /* People write things like: MFLAGS="CC=gcc -pipe" "CFLAGS=-g" and we set the -p, -i and -e switches. Doesn't seem quite right. */ decode_env_switches ("MFLAGS", 6); #endif decode_switches (argc, argv, 0); /* Print version information. */ if (print_version_flag || print_data_base_flag || debug_flag) print_version (); /* `make --version' is supposed to just print the version and exit. */ if (print_version_flag) die (0); /* Search for command line arguments that define variables, and do the definitions. Also save up the text of these arguments in CMD_DEFS so we can put them into the values of $(MAKEOVERRIDES) and $(MAKE). */ cmd_defs_len = 200; cmd_defs = (char *) xmalloc (cmd_defs_len); cmd_defs_idx = 0; for (i = 1; other_args->list[i] != 0; ++i) { if (other_args->list[i][0] == '\0') /* Ignore empty arguments, so they can't kill enter_file. */ continue; /* Try a variable definition. */ if (try_variable_definition ((char *) 0, 0, other_args->list[i], o_command)) { /* It succeeded. The variable is already defined. Backslash-quotify it and append it to CMD_DEFS, then clobber it to 0 in the list so that it won't be taken for a goal target. */ register char *p = other_args->list[i]; unsigned int l = strlen (p); if (cmd_defs_idx + (l * 2) + 1 > cmd_defs_len) { if (l * 2 > cmd_defs_len) cmd_defs_len += l * 2; else cmd_defs_len *= 2; cmd_defs = (char *) xrealloc (cmd_defs, cmd_defs_len); } while (*p != '\0') { if (index ("^;'\"*?[]$<>(){}|&~`\\ \t\r\n\f\v", *p) != 0) cmd_defs[cmd_defs_idx++] = '\\'; cmd_defs[cmd_defs_idx++] = *p++; } cmd_defs[cmd_defs_idx++] = ' '; } else { /* It was not a variable definition, so it is a target to be made. Enter it as a file and add it to the dep chain of goals. */ f = enter_command_line_file (other_args->list[i]); f->cmd_target = 1; if (goals == 0) { goals = (struct dep *) xmalloc (sizeof (struct dep)); lastgoal = goals; } else { lastgoal->next = (struct dep *) xmalloc (sizeof (struct dep)); lastgoal = lastgoal->next; } lastgoal->name = 0; lastgoal->file = f; } } if (cmd_defs_idx > 0) { cmd_defs[cmd_defs_idx - 1] = '\0'; (void) define_variable ("MAKEOVERRIDES", 13, cmd_defs, o_default, 0); } free (cmd_defs); /* Set the "MAKE_COMMAND" variable to the name we were invoked with. (If it is a relative pathname with a slash, prepend our directory name so the result will run the same program regardless of the current dir. If it is a name with no slash, we can only hope that PATH did not find it in the current directory.) */ if (current_directory[0] != '\0' && argv[0] != 0 && argv[0][0] != '/' && index (argv[0], '/') != 0) argv[0] = concat (current_directory, "/", argv[0]); (void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0); /* Append the command-line variable definitions gathered above so sub-makes will get them as command-line definitions. */ (void) define_variable ("MAKE", 4, "$(MAKE_COMMAND) $(MAKEOVERRIDES)", o_default, 1); /* If there were -C flags, move ourselves about. */ if (directories != 0) for (i = 0; directories->list[i] != 0; ++i) { char *dir = directories->list[i]; if (dir[0] == '~') { char *expanded = tilde_expand (dir); if (expanded != 0) dir = expanded; } if (chdir (dir) < 0) pfatal_with_name (dir); if (dir != directories->list[i]) free (dir); } /* Figure out the level of recursion. */ { struct variable *v = lookup_variable ("MAKELEVEL", 9); if (v != 0 && *v->value != '\0' && *v->value != '-') makelevel = (unsigned int) atoi (v->value); else makelevel = 0; } /* Except under -s, always do -w in sub-makes and under -C. */ if (!silent_flag && (directories != 0 || makelevel > 0)) print_directory_flag = 1; /* Let the user disable that with --no-print-directory. */ if (inhibit_print_directory_flag) print_directory_flag = 0; /* Construct the list of include directories to search. */ construct_include_path (include_directories == 0 ? (char **) 0 : include_directories->list); /* Figure out where we are now, after chdir'ing. */ if (directories == 0) /* We didn't move, so we're still in the same place. */ starting_directory = current_directory; else { if (getcwd (current_directory, GET_PATH_MAX) == 0) { #ifdef HAVE_GETCWD perror_with_name ("getcwd: ", ""); #else error ("getwd: %s", current_directory); #endif starting_directory = 0; } else starting_directory = current_directory; } /* Tell the user where he is. */ if (print_directory_flag) log_working_directory (1); /* Read any stdin makefiles into temporary files. */ if (makefiles != 0) { register unsigned int i; for (i = 0; i < makefiles->idx; ++i) if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0') { /* This makefile is standard input. Since we may re-exec and thus re-read the makefiles, we read standard input into a temporary file and read from that. */ static char name[] = "/tmp/GmXXXXXX"; FILE *outfile; /* Make a unique filename. */ (void) mktemp (name); outfile = fopen (name, "w"); if (outfile == 0) pfatal_with_name ("fopen (temporary file)"); while (!feof (stdin)) { char buf[2048]; int n = fread (buf, 1, sizeof(buf), stdin); if (n > 0 && fwrite (buf, 1, n, outfile) != n) pfatal_with_name ("fwrite (temporary file)"); } /* Try to make sure we won't remake the temporary file when we are re-exec'd. Kludge-o-matic! */ fprintf (outfile, "%s:;\n", name); (void) fclose (outfile); /* Replace the name that read_all_makefiles will see with the name of the temporary file. */ { char *temp; /* SGI compiler requires alloca's result be assigned simply. */ temp = (char *) alloca (sizeof (name)); bcopy (name, temp, sizeof (name)); makefiles->list[i] = temp; } /* Make sure the temporary file will not be remade. */ f = enter_file (savestring (name, sizeof name - 1)); f->updated = 1; f->update_status = 0; f->command_state = cs_finished; /* Let it be removed when we're done. */ f->intermediate = 1; /* But don't mention it. */ f->dontcare = 1; } } /* Set up to handle children dying. This must be done before reading in the makefiles so that `shell' function calls will work. */ #ifdef SIGCHLD (void) signal (SIGCHLD, child_handler); #endif #ifdef SIGCLD (void) signal (SIGCLD, child_handler); #endif /* Define the initial list of suffixes for old-style rules. */ set_default_suffixes (); /* Define the file rules for the built-in suffix rules. These will later be converted into pattern rules. We used to do this in install_default_implicit_rules, but since that happens after reading makefiles, it results in the built-in pattern rules taking precedence over makefile-specified suffix rules, which is wrong. */ install_default_suffix_rules (); /* Define some internal and special variables. */ define_automatic_variables (); /* Set up the MAKEFLAGS and MFLAGS variables so makefiles can look at them. */ define_makeflags (0, 0); /* Define the default variables. */ define_default_variables (); /* Read all the makefiles. */ default_file = enter_file (".DEFAULT"); read_makefiles = read_all_makefiles (makefiles == 0 ? (char **) 0 : makefiles->list); /* Decode switches again, in case the variables were set by the makefile. */ decode_env_switches ("MAKEFLAGS", 9); #if 0 decode_env_switches ("MFLAGS", 6); #endif /* Set up MAKEFLAGS and MFLAGS again, so they will be right. */ define_makeflags (1, 0); ignore_errors_flag |= lookup_file (".IGNORE") != 0; silent_flag |= lookup_file (".SILENT") != 0; /* Make each `struct dep' point at the `struct file' for the file depended on. */ snap_deps (); /* Convert old-style suffix rules to pattern rules. It is important to do this before installing the built-in pattern rules below, so that makefile-specified suffix rules take precedence over built-in pattern rules. */ convert_to_pattern (); /* Install the default implicit pattern rules. This used to be done before reading the makefiles. But in that case, built-in pattern rules were in the chain before user-defined ones, so they matched first. */ install_default_implicit_rules (); /* Compute implicit rule limits. */ count_implicit_rule_limits (); /* Construct the listings of directories in VPATH lists. */ build_vpath_lists (); /* Mark files given with -o flags as very old (00:00:01.00 Jan 1, 1970) and as having been updated already, and files given with -W flags as brand new (time-stamp as far as possible into the future). */ if (old_files != 0) for (p = old_files->list; *p != 0; ++p) { f = enter_command_line_file (*p); f->last_mtime = (time_t) 1; f->updated = 1; f->update_status = 0; f->command_state = cs_finished; } if (new_files != 0) { for (p = new_files->list; *p != 0; ++p) { f = enter_command_line_file (*p); f->last_mtime = NEW_MTIME; } } if (read_makefiles != 0) { /* Update any makefiles if necessary. */ time_t *makefile_mtimes = 0; unsigned int mm_idx = 0; if (debug_flag) puts ("Updating makefiles...."); /* Remove any makefiles we don't want to try to update. Also record the current modtimes so we can compare them later. */ { register struct dep *d, *last; last = 0; d = read_makefiles; while (d != 0) { register struct file *f = d->file; if (f->double_colon) do { if (f->deps == 0 && f->cmds != 0) { /* This makefile is a :: target with commands, but no dependencies. So, it will always be remade. This might well cause an infinite loop, so don't try to remake it. (This will only happen if your makefiles are written exceptionally stupidly; but if you work for Athena, that's how you write your makefiles.) */ if (debug_flag) printf ("Makefile `%s' might loop; not remaking it.\n", f->name); if (last == 0) read_makefiles = d->next; else last->next = d->next; /* Free the storage. */ free ((char *) d); d = last == 0 ? 0 : last->next; break; } f = f->prev; } while (f != NULL); if (f == NULL || !f->double_colon) { if (makefile_mtimes == 0) makefile_mtimes = (time_t *) xmalloc (sizeof (time_t)); else makefile_mtimes = (time_t *) xrealloc ((char *) makefile_mtimes, (mm_idx + 1) * sizeof (time_t)); makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file); last = d; d = d->next; } } } /* Set up `MAKEFLAGS' specially while remaking makefiles. */ define_makeflags (1, 1); switch (update_goal_chain (read_makefiles, 1)) { default: abort (); case -1: /* Did nothing. */ break; case 1: /* Failed to update. Figure out if we care. */ { /* Nonzero if any makefile was successfully remade. */ int any_remade = 0; /* Nonzero if any makefile we care about failed in updating or could not be found at all. */ int any_failed = 0; register unsigned int i; for (i = 0; read_makefiles != 0; ++i) { struct dep *d = read_makefiles; read_makefiles = d->next; if (d->file->updated) { /* This makefile was updated. */ if (d->file->update_status == 0) { /* It was successfully updated. */ any_remade |= (file_mtime_no_search (d->file) != makefile_mtimes[i]); } else if (! (d->changed & RM_DONTCARE)) { time_t mtime; /* The update failed and this makefile was not from the MAKEFILES variable, so we care. */ error ("Failed to remake makefile `%s'.", d->file->name); mtime = file_mtime_no_search (d->file); any_remade |= (mtime != (time_t) -1 && mtime != makefile_mtimes[i]); } } else /* This makefile was not found at all. */ if (! (d->changed & RM_DONTCARE)) { /* This is a makefile we care about. See how much. */ if (d->changed & RM_INCLUDED) /* An included makefile. We don't need to die, but we do want to complain. */ error ("Included makefile `%s' was not found.", dep_name (d)); else { /* A normal makefile. We must die later. */ error ("Makefile `%s' was not found", dep_name (d)); any_failed = 1; } } free ((char *) d); } if (any_remade) goto re_exec; else if (any_failed) die (1); else break; } case 0: re_exec: /* Updated successfully. Re-exec ourselves. */ remove_intermediates (0); if (print_data_base_flag) print_data_base (); if (print_directory_flag) log_working_directory (0); if (makefiles != 0) { /* These names might have changed. */ register unsigned int i, j = 0; for (i = 1; i < argc; ++i) if (!strcmp (argv[i], "-f")) /* XXX */ { char *p = &argv[i][2]; if (*p == '\0') argv[++i] = makefiles->list[j]; else argv[i] = concat ("-f", makefiles->list[j], ""); ++j; } } if (directories != 0 && directories->idx > 0) { char bad; if (directory_before_chdir != 0) { if (chdir (directory_before_chdir) < 0) { perror_with_name ("chdir", ""); bad = 1; } else bad = 0; } else bad = 1; if (bad) fatal ("Couldn't change back to original directory."); } for (p = environ; *p != 0; ++p) if (!strncmp (*p, "MAKELEVEL=", 10)) { /* The SGI compiler apparently can't understand the concept of storing the result of a function in something other than a local variable. */ char *sgi_loses; sgi_loses = (char *) alloca (40); *p = sgi_loses; sprintf (*p, "MAKELEVEL=%u", makelevel); break; } if (debug_flag) { char **p; fputs ("Re-executing:", stdout); for (p = argv; *p != 0; ++p) printf (" %s", *p); puts (""); } fflush (stdout); fflush (stderr); exec_command (argv, environ); /* NOTREACHED */ } } /* Set up `MAKEFLAGS' again for the normal targets. */ define_makeflags (1, 0); { int status; /* If there were no command-line goals, use the default. */ if (goals == 0) { if (default_goal_file != 0) { goals = (struct dep *) xmalloc (sizeof (struct dep)); goals->next = 0; goals->name = 0; goals->file = default_goal_file; } } else lastgoal->next = 0; if (goals != 0) { /* Update the goals. */ if (debug_flag) puts ("Updating goal targets...."); switch (update_goal_chain (goals, 0)) { case -1: /* Nothing happened. */ case 0: /* Updated successfully. */ status = 0; break; case 1: /* Updating failed. */ status = 1; break; default: abort (); } } else { if (read_makefiles == 0) fatal ("No targets specified and no makefile found"); else fatal ("No targets"); } /* Exit. */ die (status); } return 0; } /* Parsing of arguments, decoding of switches. */ static char options[sizeof (switches) / sizeof (switches[0]) * 3]; static struct option long_options[(sizeof (switches) / sizeof (switches[0])) + (sizeof (long_option_aliases) / sizeof (long_option_aliases[0]))]; /* Fill in the string and vector for getopt. */ static void init_switches () { register char *p; register int c; register unsigned int i; if (options[0] != '\0') /* Already done. */ return; p = options; for (i = 0; switches[i].c != '\0'; ++i) { long_options[i].name = (switches[i].long_name == 0 ? "" : switches[i].long_name); long_options[i].flag = 0; long_options[i].val = switches[i].c; if (isalnum (switches[i].c)) *p++ = switches[i].c; switch (switches[i].type) { case flag: case flag_off: case ignore: long_options[i].has_arg = no_argument; break; case string: case positive_int: case floating: if (isalnum (switches[i].c)) *p++ = ':'; if (switches[i].noarg_value != 0) { if (isalnum (switches[i].c)) *p++ = ':'; long_options[i].has_arg = optional_argument; } else long_options[i].has_arg = required_argument; break; } } *p = '\0'; for (c = 0; c < (sizeof (long_option_aliases) / sizeof (long_option_aliases[0])); ++c) long_options[i++] = long_option_aliases[c]; long_options[i].name = 0; } /* Decode switches from ARGC and ARGV. They came from the environment if ENV is nonzero. */ static void decode_switches (argc, argv, env) int argc; char **argv; int env; { int bad = 0; register const struct command_switch *cs; register struct stringlist *sl; register int c; if (!env) { other_args = (struct stringlist *) xmalloc (sizeof (struct stringlist)); other_args->max = argc + 1; other_args->list = (char **) xmalloc ((argc + 1) * sizeof (char *)); other_args->idx = 1; other_args->list[0] = argv[0]; } /* getopt does most of the parsing for us. First, get its vectors set up. */ init_switches (); /* Let getopt produce error messages for the command line, but not for options from the environment. */ opterr = !env; /* Reset getopt's state. */ optind = 0; while ((c = getopt_long (argc, argv, options, long_options, (int *) 0)) != EOF) { if (c == '?') /* Bad option. We will print a usage message and die later. But continue to parse the other options so the user can see all he did wrong. */ bad = 1; else for (cs = switches; cs->c != '\0'; ++cs) if (cs->c == c) { /* Whether or not we will actually do anything with this switch. We test this individually inside the switch below rather than just once outside it, so that options which are to be ignored still consume args. */ int doit = !env || cs->env; switch (cs->type) { default: abort (); case ignore: break; case flag: case flag_off: if (doit) *(int *) cs->value_ptr = cs->type == flag; break; case string: if (!doit) break; if (optarg == 0) optarg = cs->noarg_value; sl = *(struct stringlist **) cs->value_ptr; if (sl == 0) { sl = (struct stringlist *) xmalloc (sizeof (struct stringlist)); sl->max = 5; sl->idx = 0; sl->list = (char **) xmalloc (5 * sizeof (char *)); *(struct stringlist **) cs->value_ptr = sl; } else if (sl->idx == sl->max - 1) { sl->max += 5; sl->list = (char **) xrealloc ((char *) sl->list, sl->max * sizeof (char *)); } sl->list[sl->idx++] = optarg; sl->list[sl->idx] = 0; break; case positive_int: if (optarg == 0 && argc > optind && isdigit (argv[optind][0])) optarg = argv[optind++]; if (!doit) break; if (optarg != 0) { int i = atoi (optarg); if (i < 1) { if (doit) error ("the `-%c' option requires a \ positive integral argument", cs->c); bad = 1; } else *(unsigned int *) cs->value_ptr = i; } else *(unsigned int *) cs->value_ptr = *(unsigned int *) cs->noarg_value; break; case floating: if (optarg == 0 && optind < argc && (isdigit (argv[optind][0]) || argv[optind][0] == '.')) optarg = argv[optind++]; if (doit) *(double *) cs->value_ptr = (optarg != 0 ? atof (optarg) : *(double *) cs->noarg_value); break; } /* We've found the switch. Stop looking. */ break; } } if (!env) { /* Collect the remaining args in the `other_args' string list. */ while (optind < argc) { char *arg = argv[optind++]; if (arg[0] != '-' || arg[1] != '\0') other_args->list[other_args->idx++] = arg; } other_args->list[other_args->idx] = 0; } if (!env && (bad || print_usage_flag)) { /* Print a nice usage message. */ if (print_version_flag) print_version (); fprintf (stderr, "Usage: %s [options] [target] ...\n", program); fputs ("Options:\n", stderr); for (cs = switches; cs->c != '\0'; ++cs) { char buf[1024], shortarg[50], longarg[50], *p; if (cs->description[0] == '-') continue; switch (long_options[cs - switches].has_arg) { case no_argument: shortarg[0] = longarg[0] = '\0'; break; case required_argument: sprintf (longarg, "=%s", cs->argdesc); sprintf (shortarg, " %s", cs->argdesc); break; case optional_argument: sprintf (longarg, "[=%s]", cs->argdesc); sprintf (shortarg, " [%s]", cs->argdesc); break; } p = buf; if (isalnum (cs->c)) { sprintf (buf, " -%c%s", cs->c, shortarg); p += strlen (p); } if (cs->long_name != 0) { unsigned int i; sprintf (p, "%s--%s%s", !isalnum (cs->c) ? " " : ", ", cs->long_name, longarg); p += strlen (p); for (i = 0; i < (sizeof (long_option_aliases) / sizeof (long_option_aliases[0])); ++i) if (long_option_aliases[i].val == cs->c) { sprintf (p, ", --%s%s", long_option_aliases[i].name, longarg); p += strlen (p); } } { const struct command_switch *ncs = cs; while ((++ncs)->c != '\0') if (ncs->description[0] == '-' && ncs->description[1] == cs->c) { /* This is another switch that does the same one as the one we are processing. We want to list them all together on one line. */ sprintf (p, ", -%c%s", ncs->c, shortarg); p += strlen (p); if (ncs->long_name != 0) { sprintf (p, ", --%s%s", ncs->long_name, longarg); p += strlen (p); } } } if (p - buf > DESCRIPTION_COLUMN - 2) /* The list of option names is too long to fit on the same line with the description, leaving at least two spaces. Print it on its own line instead. */ { fprintf (stderr, "%s\n", buf); buf[0] = '\0'; } fprintf (stderr, "%*s%s.\n", - DESCRIPTION_COLUMN, buf, cs->description); } die (bad); } } /* Decode switches from environment variable ENVAR (which is LEN chars long). We do this by chopping the value into a vector of words, prepending a dash to the first word if it lacks one, and passing the vector to decode_switches. */ static void decode_env_switches (envar, len) char *envar; unsigned int len; { char *varref = (char *) alloca (2 + len + 2); char *value, *args; int argc; char **argv; /* Get the variable's value. */ varref[0] = '$'; varref[1] = '('; bcopy (envar, &varref[2], len); varref[2 + len] = ')'; varref[2 + len + 1] = '\0'; value = variable_expand (varref); /* Skip whitespace, and check for an empty value. */ value = next_token (value); len = strlen (value); if (len == 0) return; /* Make a copy of the value in ARGS, where we will munge it. If it does not begin with a dash, prepend one. We must allocate lasting storage for this (and we never free it) because decode_switches may save pointers into it for string-valued switches. */ args = (char *) xmalloc (1 + len + 2); if (value[0] != '-') args[0] = '-'; bcopy (value, value[0] == '-' ? args : &args[1], len + 1); /* Write an extra null terminator so our loop below will never be in danger of looking past the end of the string. */ args[(value[0] == '-' ? 0 : 1) + len + 1] = '\0'; /* Allocate a vector that is definitely big enough. */ argv = (char **) alloca ((1 + len + 1) * sizeof (char *)); /* getopt will look at the arguments starting at ARGV[1]. Prepend a spacer word. */ argv[0] = 0; argc = 1; do { argv[argc++] = args; args = end_of_token (args); *args++ = '\0'; } while (*args != '\0'); argv[argc] = 0; /* Parse those words. */ decode_switches (argc, argv, 1); } /* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the command switches. Include options with args if ALL is nonzero. Don't include options with the `no_makefile' flag set if MAKEFILE. */ static void define_makeflags (all, makefile) int all, makefile; { register const struct command_switch *cs; char *flagstring; struct variable *v; /* We will construct a linked list of `struct flag's describing all the flags which need to go in MAKEFLAGS. Then, once we know how many there are and their lengths, we can put them all together in a string. */ struct flag { struct flag *next; const struct command_switch *cs; char *arg; unsigned int arglen; }; struct flag *flags = 0; unsigned int flagslen = 0; #define ADD_FLAG(ARG, LEN) \ do { \ struct flag *new = (struct flag *) alloca (sizeof (struct flag)); \ new->cs = cs; \ new->arg = (ARG); \ new->arglen = (LEN); \ new->next = flags; \ flags = new; \ if (new->arg == 0) \ ++flagslen; /* Just a single flag letter. */ \ else \ flagslen += 1 + 1 + 1 + 1 + new->arglen; /* " -x foo" */ \ if (!isalnum (cs->c)) \ /* This switch has no single-letter version, so we use the long. */ \ flagslen += 2 + strlen (cs->long_name); \ } while (0) for (cs = switches; cs->c != '\0'; ++cs) if (cs->toenv && (!makefile || !cs->no_makefile)) switch (cs->type) { default: abort (); case ignore: break; case flag: case flag_off: if (!*(int *) cs->value_ptr == (cs->type == flag_off) && (cs->default_value == 0 || *(int *) cs->value_ptr != *(int *) cs->default_value)) ADD_FLAG (0, 0); break; case positive_int: if (all) { if ((cs->default_value != 0 && (*(unsigned int *) cs->value_ptr == *(unsigned int *) cs->default_value))) break; else if (cs->noarg_value != 0 && (*(unsigned int *) cs->value_ptr == *(unsigned int *) cs->noarg_value)) ADD_FLAG ("", 0); /* Optional value omitted; see below. */ else if (cs->c == 'j') /* Special case for `-j'. */ ADD_FLAG ("1", 1); else { char *buf = (char *) alloca (30); sprintf (buf, "%u", *(unsigned int *) cs->value_ptr); ADD_FLAG (buf, strlen (buf)); } } break; case floating: if (all) { if (cs->default_value != 0 && (*(double *) cs->value_ptr == *(double *) cs->default_value)) break; else if (cs->noarg_value != 0 && (*(double *) cs->value_ptr == *(double *) cs->noarg_value)) ADD_FLAG ("", 0); /* Optional value omitted; see below. */ else { char *buf = (char *) alloca (100); sprintf (buf, "%g", *(double *) cs->value_ptr); ADD_FLAG (buf, strlen (buf)); } } break; case string: if (all) { struct stringlist *sl = *(struct stringlist **) cs->value_ptr; if (sl != 0) { /* Add the elements in reverse order, because all the flags get reversed below; and the order matters for some switches (like -I). */ register unsigned int i = sl->idx; while (i-- > 0) ADD_FLAG (sl->list[i], strlen (sl->list[i])); } } break; } #undef ADD_FLAG if (flags == 0) /* No flags. Use a string of two nulls so [1] works below. */ flagstring = "\0"; else { /* Construct the value in FLAGSTRING. We allocate enough space for a preceding dash and trailing null. */ register char *p; flagstring = (char *) alloca (1 + flagslen + 1); p = flagstring; *p++ = '-'; do { /* Add the flag letter or name to the string. */ if (!isalnum (flags->cs->c)) { *p++ = '-'; strcpy (p, flags->cs->long_name); p += strlen (p); } else *p++ = flags->cs->c; if (flags->arg != 0) { /* A flag that takes an optional argument which in this case is omitted is specified by ARG being "" and ARGLEN being 0. We must distinguish because a following flag appended without an intervening " -" is considered the arg for the first. */ if (flags->arglen > 0) { /* Add its argument too. */ *p++ = !isalnum (flags->cs->c) ? '=' : ' '; bcopy (flags->arg, p, flags->arglen); p += flags->arglen; } /* Write a following space and dash, for the next flag. */ *p++ = ' '; *p++ = '-'; } else if (!isalnum (flags->cs->c)) { /* Long options must each go in their own word, so we write the following space and dash. */ *p++ = ' '; *p++ = '-'; } flags = flags->next; } while (flags != 0); if (p[-1] == '-') /* Kill the final space and dash. */ p -= 2; /* Terminate the string. */ *p = '\0'; } v = define_variable ("MAKEFLAGS", 9, /* On Sun, the value of MFLAGS starts with a `-' but the value of MAKEFLAGS lacks the `-'. Be compatible with this unless FLAGSTRING starts with a long option `--foo', since removing the first dash would result in the bogus `-foo'. */ flagstring[1] == '-' ? flagstring : &flagstring[1], /* This used to use o_env, but that lost when a makefile defined MAKEFLAGS. Makefiles set MAKEFLAGS to add switches, but we still want to redefine its value with the full set of switches. Of course, an override or command definition will still take precedence. */ o_file, 0); if (! all) /* The first time we are called, set MAKEFLAGS to always be exported. We should not do this again on the second call, because that is after reading makefiles which might have done `unexport MAKEFLAGS'. */ v->export = v_export; /* Since MFLAGS is not parsed for flags, there is no reason to override any makefile redefinition. */ (void) define_variable ("MFLAGS", 6, flagstring, o_env, 0); } /* Print version information. */ static void print_version () { static int printed_version = 0; char *precede = print_data_base_flag ? "# " : ""; if (printed_version) /* Do it only once. */ return; printf ("%sGNU Make version %s", precede, version_string); if (remote_description != 0 && *remote_description != '\0') printf ("-%s", remote_description); printf (", by Richard Stallman and Roland McGrath.\n\ %sCopyright (C) 1988, 89, 90, 91, 92, 93 Free Software Foundation, Inc.\n\ %sThis is free software; see the source for copying conditions.\n\ %sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\ %sPARTICULAR PURPOSE.\n\n", precede, precede, precede, precede); printed_version = 1; /* Flush stdout so the user doesn't have to wait to see the version information while things are thought about. */ fflush (stdout); } /* Print a bunch of information about this and that. */ static void print_data_base () { extern char *ctime (); time_t when; when = time ((time_t *) 0); printf ("\n# Make data base, printed on %s", ctime (&when)); print_variable_data_base (); print_dir_data_base (); print_rule_data_base (); print_file_data_base (); print_vpath_data_base (); when = time ((time_t *) 0); printf ("\n# Finished Make data base on %s\n", ctime (&when)); } /* Exit with STATUS, cleaning up as necessary. */ void die (status) int status; { static char dying = 0; if (!dying) { int err; dying = 1; if (print_version_flag) print_version (); /* Wait for children to die. */ for (err = status != 0; job_slots_used > 0; err = 0) reap_children (1, err); /* Remove the intermediate files. */ remove_intermediates (0); if (print_data_base_flag) print_data_base (); if (print_directory_flag) log_working_directory (0); } exit (status); } /* Write a message indicating that we've just entered or left (according to ENTERING) the current directory. */ static void log_working_directory (entering) int entering; { static int entered = 0; char *message = entering ? "Entering" : "Leaving"; if (entering) entered = 1; else if (!entered) /* Don't print the leaving message if we haven't printed the entering message. */ return; if (print_data_base_flag) fputs ("# ", stdout); if (makelevel == 0) printf ("%s: %s ", program, message); else printf ("%s[%u]: %s ", program, makelevel, message); if (starting_directory == 0) puts ("an unknown directory"); else printf ("directory `%s'\n", starting_directory); } make-3.70/read.c 666 12241 13 147353 5506421005 6602 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "dep.h" #include "file.h" #include "variable.h" /* This is POSIX.2, but most systems using -DPOSIX probably don't have it. */ #ifdef HAVE_GLOB_H #include #else #include "glob/glob.h" #endif #include struct passwd *getpwnam (); static int read_makefile (); static unsigned int readline (), do_define (); static int conditional_line (); static void record_files (); static char *find_semicolon (); /* A `struct linebuffer' is a structure which holds a line of text. `readline' reads a line from a stream into a linebuffer and works regardless of the length of the line. */ struct linebuffer { /* Note: This is the number of bytes malloc'ed for `buffer' It does not indicate `buffer's real length. Instead, a null char indicates end-of-string. */ unsigned int size; char *buffer; }; #define initbuffer(lb) (lb)->buffer = (char *) xmalloc ((lb)->size = 200) #define freebuffer(lb) free ((lb)->buffer) /* A `struct conditionals' contains the information describing all the active conditionals in a makefile. The global variable `conditionals' contains the conditionals information for the current makefile. It is initialized from the static structure `toplevel_conditionals' and is later changed to new structures for included makefiles. */ struct conditionals { unsigned int if_cmds; /* Depth of conditional nesting. */ unsigned int allocated; /* Elts allocated in following arrays. */ char *ignoring; /* Are we ignoring or interepreting? */ char *seen_else; /* Have we already seen an `else'? */ }; static struct conditionals toplevel_conditionals; static struct conditionals *conditionals = &toplevel_conditionals; /* Default directories to search for include files in */ static char *default_include_directories[] = { INCLUDEDIR, "/usr/gnu/include", "/usr/local/include", "/usr/include", 0 }; /* List of directories to search for include files in */ static char **include_directories; /* Maximum length of an element of the above. */ static unsigned int max_incl_len; /* The filename and pointer to line number of the makefile currently being read in. */ char *reading_filename; unsigned int *reading_lineno_ptr; /* The chain of makefiles read by read_makefile. */ static struct dep *read_makefiles = 0; /* Read in all the makefiles and return the chain of their names. */ struct dep * read_all_makefiles (makefiles) char **makefiles; { unsigned int num_makefiles = 0; if (debug_flag) puts ("Reading makefiles..."); /* If there's a non-null variable MAKEFILES, its value is a list of files to read first thing. But don't let it prevent reading the default makefiles and don't let the default goal come from there. */ { char *value; char *name, *p; unsigned int length; { /* Turn off --warn-undefined-variables while we expand MAKEFILES. */ int save = warn_undefined_variables_flag; warn_undefined_variables_flag = 0; value = allocated_variable_expand ("$(MAKEFILES)"); warn_undefined_variables_flag = save; } /* Set NAME to the start of next token and LENGTH to its length. MAKEFILES is updated for finding remaining tokens. */ p = value; while ((name = find_next_token (&p, &length)) != 0) { if (*p != '\0') *p++ = '\0'; (void) read_makefile (name, RM_NO_DEFAULT_GOAL | RM_INCLUDED | RM_DONTCARE); } free (value); } /* Read makefiles specified with -f switches. */ if (makefiles != 0) while (*makefiles != 0) { struct dep *tail = read_makefiles; register struct dep *d; if (! read_makefile (*makefiles, 0)) perror_with_name ("", *makefiles); /* Find the right element of read_makefiles. */ d = read_makefiles; while (d->next != tail) d = d->next; /* Use the storage read_makefile allocates. */ *makefiles = dep_name (d); ++num_makefiles; ++makefiles; } /* If there were no -f switches, try the default names. */ if (num_makefiles == 0) { static char *default_makefiles[] = { "GNUmakefile", "makefile", "Makefile", 0 }; register char **p = default_makefiles; while (*p != 0 && !file_exists_p (*p)) ++p; if (*p != 0) { if (! read_makefile (*p, 0)) perror_with_name ("", *p); } else { /* No default makefile was found. Add the default makefiles to the `read_makefiles' chain so they will be updated if possible. */ struct dep *tail = read_makefiles; for (p = default_makefiles; *p != 0; ++p) { struct dep *d = (struct dep *) xmalloc (sizeof (struct dep)); d->name = 0; d->file = enter_file (*p); d->file->dontcare = 1; /* Tell update_goal_chain to bail out as soon as this file is made, and main not to die if we can't make this file. */ d->changed = RM_DONTCARE; if (tail == 0) read_makefiles = d; else tail->next = d; tail = d; } if (tail != 0) tail->next = 0; } } return read_makefiles; } /* Read file FILENAME as a makefile and add its contents to the data base. FLAGS contains bits as above. FILENAME is added to the `read_makefiles' chain. Returns 1 if a file was found and read, 0 if not. */ static int read_makefile (filename, flags) char *filename; int flags; { static char *collapsed = 0; static unsigned int collapsed_length = 0; register FILE *infile; struct linebuffer lb; unsigned int commands_len = 200; char *commands = (char *) xmalloc (200); unsigned int commands_idx = 0; unsigned int commands_started; register char *p; char *p2; int ignoring = 0, in_ignored_define = 0; int no_targets = 0; /* Set when reading a rule without targets. */ struct nameseq *filenames = 0; struct dep *deps; unsigned int lineno = 1; unsigned int nlines = 0; int two_colon; char *pattern = 0, *pattern_percent; int makefile_errno; #define record_waiting_files() \ do \ { \ if (filenames != 0) \ record_files (filenames, pattern, pattern_percent, deps, \ commands_started, commands, commands_idx, \ two_colon, filename, lineno, \ !(flags & RM_NO_DEFAULT_GOAL)); \ filenames = 0; \ commands_idx = 0; \ pattern = 0; \ } while (0) #ifdef lint /* Suppress `used before set' messages. */ two_colon = 0; #endif /* First, get a stream to read. */ /* Expand ~ in FILENAME unless it came from `include', in which case it was already done. */ if (!(flags & RM_NO_TILDE) && filename[0] == '~') { char *expanded = tilde_expand (filename); /* This is a possible memory leak, but I don't care. */ if (expanded != 0) filename = expanded; } infile = fopen (filename, "r"); /* Save the error code so we print the right message later. */ makefile_errno = errno; /* If the makefile wasn't found and it's either a makefile from the `MAKEFILES' variable or an included makefile, search the included makefile search path for this makefile. */ if (infile == 0 && (flags & RM_INCLUDED) && *filename != '/') { register unsigned int i; for (i = 0; include_directories[i] != 0; ++i) { char *name = concat (include_directories[i], "/", filename); infile = fopen (name, "r"); if (infile == 0) free (name); else { filename = name; break; } } } /* Add FILENAME to the chain of read makefiles. */ deps = (struct dep *) xmalloc (sizeof (struct dep)); deps->next = read_makefiles; read_makefiles = deps; deps->name = 0; deps->file = lookup_file (filename); if (deps->file == 0) { deps->file = enter_file (savestring (filename, strlen (filename))); if (flags & RM_DONTCARE) deps->file->dontcare = 1; } filename = deps->file->name; deps->file->precious = 1; deps->changed = flags; deps = 0; /* If the makefile can't be found at all, give up entirely. */ if (infile == 0) { /* If we did some searching, errno has the error from the last attempt, rather from FILENAME itself. Restore it in case the caller wants to use it in a message. */ errno = makefile_errno; return 0; } reading_filename = filename; reading_lineno_ptr = &lineno; /* Loop over lines in the file. The strategy is to accumulate target names in FILENAMES, dependencies in DEPS and commands in COMMANDS. These are used to define a rule when the start of the next rule (or eof) is encountered. */ initbuffer (&lb); while (!feof (infile)) { lineno += nlines; nlines = readline (&lb, infile, filename, lineno); if (collapsed_length < lb.size) { collapsed_length = lb.size; if (collapsed != 0) free (collapsed); collapsed = (char *) xmalloc (collapsed_length); } strcpy (collapsed, lb.buffer); /* Collapse continuation lines. */ collapse_continuations (collapsed); remove_comments (collapsed); p = collapsed; while (isspace (*p)) ++p; /* We cannot consider a line containing just a tab to be empty because it might constitute an empty command for a target. */ if (*p == '\0' && lb.buffer[0] != '\t') continue; /* strncmp is first to avoid dereferencing out into space. */ #define word1eq(s, l) (!strncmp (s, p, l) \ && (p[l] == '\0' || isblank (p[l]))) if (!in_ignored_define && (word1eq ("ifdef", 5) || word1eq ("ifndef", 6) || word1eq ("ifeq", 4) || word1eq ("ifneq", 5) || word1eq ("else", 4) || word1eq ("endif", 5))) { int i = conditional_line (p, filename, lineno); if (i >= 0) ignoring = i; else makefile_fatal (filename, lineno, "invalid syntax in conditional"); continue; } else if (word1eq ("endef", 5)) { if (in_ignored_define) in_ignored_define = 0; else makefile_fatal (filename, lineno, "extraneous `endef'"); continue; } else if (word1eq ("define", 6)) { if (ignoring) in_ignored_define = 1; else { p2 = next_token (p + 6); p = end_of_token (p2); lineno = do_define (p2, p - p2, o_file, lineno, infile, filename); } continue; } else if (word1eq ("override", 8)) { p2 = next_token (p + 8); if (p2 == 0) makefile_error (filename, lineno, "empty `override' directive"); if (!strncmp (p2, "define", 6) && (isblank (p2[6]) || p2[6] == '\0')) { if (ignoring) in_ignored_define = 1; else { unsigned int len; p2 = end_of_token (p2); p = find_next_token (&p2, &len); lineno = do_define (p, len, o_override, lineno, infile, filename); } } else if (!ignoring && !try_variable_definition (filename, lineno, p2, o_override)) makefile_error (filename, lineno, "empty `override' directive"); continue; } if (ignoring) /* Ignore the line. We continue here so conditionals can appear in the middle of a rule. */ continue; else if (lb.buffer[0] == '\t') { /* This line is a shell command. */ unsigned int len; if (no_targets) /* Ignore the commands in a rule with no targets. */ continue; /* If there is no preceding rule line, don't treat this line as a command, even though it begins with a tab character. SunOS 4 make appears to behave this way. */ if (filenames != 0) { /* Append this command line to the line being accumulated. */ p = lb.buffer; if (commands_idx == 0) commands_started = lineno; len = strlen (p); if (len + 1 + commands_idx > commands_len) { commands_len = (len + 1 + commands_idx) * 2; commands = (char *) xrealloc (commands, commands_len); } bcopy (p, &commands[commands_idx], len); commands_idx += len; commands[commands_idx++] = '\n'; continue; } } if (word1eq ("export", 6)) { struct variable *v; p2 = next_token (p + 6); if (*p2 == '\0') export_all_variables = 1; v = try_variable_definition (filename, lineno, p2, o_file); if (v != 0) v->export = v_export; else { unsigned int len; for (p = find_next_token (&p2, &len); p != 0; p = find_next_token (&p2, &len)) { v = lookup_variable (p, len); if (v == 0) v = define_variable (p, len, "", o_file, 0); v->export = v_export; } } } else if (word1eq ("unexport", 8)) { unsigned int len; struct variable *v; p2 = next_token (p + 8); if (*p2 == '\0') export_all_variables = 0; for (p = find_next_token (&p2, &len); p != 0; p = find_next_token (&p2, &len)) { v = lookup_variable (p, len); if (v == 0) v = define_variable (p, len, "", o_file, 0); v->export = v_noexport; } } else if (word1eq ("include", 7) || word1eq ("-include", 8)) { /* We have found an `include' line specifying a nested makefile to be read at this point. */ struct conditionals *save, new_conditionals; struct nameseq *files; /* "-include" (vs "include") says no error if the file does not exist. */ int noerror = p[0] == '-'; p = allocated_variable_expand (next_token (p + (noerror ? 9 : 8))); if (*p == '\0') { makefile_error (filename, lineno, "no file name for `%sinclude'", noerror ? "-" : ""); continue; } /* Parse the list of file names. */ p2 = p; files = multi_glob (parse_file_seq (&p2, '\0', sizeof (struct nameseq), 1), sizeof (struct nameseq)); free (p); /* Save the state of conditionals and start the included makefile with a clean slate. */ save = conditionals; bzero ((char *) &new_conditionals, sizeof new_conditionals); conditionals = &new_conditionals; /* Record the rules that are waiting so they will determine the default goal before those in the included makefile. */ record_waiting_files (); /* Read each included makefile. */ while (files != 0) { struct nameseq *next = files->next; char *name = files->name; free (files); files = next; if (! read_makefile (name, (RM_INCLUDED | RM_NO_TILDE | (noerror ? RM_DONTCARE : 0)))) makefile_error (filename, lineno, "%s: %s", name, strerror (errno)); } /* Free any space allocated by conditional_line. */ if (conditionals->ignoring) free (conditionals->ignoring); if (conditionals->seen_else) free (conditionals->seen_else); /* Restore state. */ conditionals = save; reading_filename = filename; reading_lineno_ptr = &lineno; } else if (word1eq ("vpath", 5)) { char *pattern; unsigned int len; p2 = variable_expand (p + 5); p = find_next_token (&p2, &len); if (p != 0) { pattern = savestring (p, len); p = find_next_token (&p2, &len); /* No searchpath means remove all previous selective VPATH's with the same pattern. */ } else /* No pattern means remove all previous selective VPATH's. */ pattern = 0; construct_vpath_list (pattern, p); if (pattern != 0) free (pattern); } #undef word1eq else if (try_variable_definition (filename, lineno, p, o_file)) /* This line has been dealt with. */ ; else if (lb.buffer[0] == '\t') /* This line starts with a tab but was not caught above because there was no preceding target, and the line might have been usable as a variable definition. But now it is definitely lossage. */ makefile_fatal (filename, lineno, "commands commence before first target"); else { /* This line describes some target files. */ char *cmdleft; /* Record the previous rule. */ record_waiting_files (); /* Look for a semicolon in the unexpanded line. */ cmdleft = find_semicolon (lb.buffer); if (cmdleft != 0) /* Found one. Cut the line short there before expanding it. */ *cmdleft = '\0'; collapse_continuations (lb.buffer); /* Expand variable and function references before doing anything else so that special characters can be inside variables. */ p = variable_expand (lb.buffer); if (cmdleft == 0) /* Look for a semicolon in the expanded line. */ cmdleft = find_semicolon (p); if (cmdleft != 0) /* Cut the line short at the semicolon. */ *cmdleft = '\0'; /* Remove comments from the line. */ remove_comments (p); p2 = next_token (p); if (*p2 == '\0') { if (cmdleft != 0) makefile_fatal (filename, lineno, "missing rule before commands"); else /* This line contained a variable reference that expanded to nothing but whitespace. */ continue; } else if (*p2 == ':') { /* We accept and ignore rules without targets for compatibility with SunOS 4 make. */ no_targets = 1; continue; } filenames = multi_glob (parse_file_seq (&p2, ':', sizeof (struct nameseq), 1), sizeof (struct nameseq)); if (*p2++ == '\0') makefile_fatal (filename, lineno, "missing separator"); /* Is this a one-colon or two-colon entry? */ two_colon = *p2 == ':'; if (two_colon) p2++; /* We have some targets, so don't ignore the following commands. */ no_targets = 0; /* Is this a static pattern rule: `target: %targ: %dep; ...'? */ p = index (p2, ':'); while (p != 0 && p[-1] == '\\') { register char *q = &p[-1]; register int backslash = 0; while (*q-- == '\\') backslash = !backslash; if (backslash) p = index (p + 1, ':'); else break; } if (p != 0) { struct nameseq *target; target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1); ++p2; if (target == 0) makefile_fatal (filename, lineno, "missing target pattern"); else if (target->next != 0) makefile_fatal (filename, lineno, "multiple target patterns"); pattern = target->name; pattern_percent = find_percent (pattern); if (pattern_percent == 0) makefile_fatal (filename, lineno, "target pattern contains no `%%'"); } else pattern = 0; /* Parse the dependencies. */ deps = (struct dep *) multi_glob (parse_file_seq (&p2, '\0', sizeof (struct dep), 1), sizeof (struct dep)); commands_idx = 0; if (cmdleft != 0) { /* Semicolon means rest of line is a command. */ unsigned int len = strlen (cmdleft + 1); commands_started = lineno; /* Add this command line to the buffer. */ if (len + 2 > commands_len) { commands_len = (len + 2) * 2; commands = (char *) xrealloc (commands, commands_len); } bcopy (cmdleft + 1, commands, len); commands_idx += len; commands[commands_idx++] = '\n'; } continue; } /* We get here except in the case that we just read a rule line. Record now the last rule we read, so following spurious commands are properly diagnosed. */ record_waiting_files (); no_targets = 0; } if (conditionals->if_cmds) makefile_fatal (filename, lineno, "missing `endif'"); /* At eof, record the last rule. */ record_waiting_files (); freebuffer (&lb); free ((char *) commands); fclose (infile); reading_filename = 0; reading_lineno_ptr = 0; return 1; } /* Execute a `define' directive. The first line has already been read, and NAME is the name of the variable to be defined. The following lines remain to be read. LINENO, INFILE and FILENAME refer to the makefile being read. The value returned is LINENO, updated for lines read here. */ static unsigned int do_define (name, namelen, origin, lineno, infile, filename) char *name; unsigned int namelen; enum variable_origin origin; unsigned int lineno; FILE *infile; char *filename; { struct linebuffer lb; unsigned int nlines = 0; unsigned int length = 100; char *definition = (char *) xmalloc (100); register unsigned int idx = 0; register char *p; /* Expand the variable name. */ char *var = (char *) alloca (namelen + 1); bcopy (name, var, namelen); var[namelen] = '\0'; var = variable_expand (var); initbuffer (&lb); while (!feof (infile)) { lineno += nlines; nlines = readline (&lb, infile, filename, lineno); p = next_token (lb.buffer); if ((p[5] == '\0' || isblank (p[5])) && !strncmp (p, "endef", 5)) { p += 5; collapse_continuations (p); remove_comments (p); if (*next_token (p) != '\0') makefile_error (filename, lineno, "Extraneous text after `endef' directive"); /* Define the variable. */ if (idx == 0) definition[0] = '\0'; else definition[idx - 1] = '\0'; (void) define_variable (var, strlen (var), definition, origin, 1); free (definition); freebuffer (&lb); return lineno; } else { unsigned int len = strlen (p); /* Increase the buffer size if necessary. */ if (idx + len + 1 > length) { length = (idx + len) * 2; definition = (char *) xrealloc (definition, length + 1); } bcopy (p, &definition[idx], len); idx += len; /* Separate lines with a newline. */ definition[idx++] = '\n'; } } /* No `endef'!! */ makefile_fatal (filename, lineno, "missing `endef', unterminated `define'"); /* NOTREACHED */ return 0; } /* Interpret conditional commands "ifdef", "ifndef", "ifeq", "ifneq", "else" and "endif". LINE is the input line, with the command as its first word. FILENAME and LINENO are the filename and line number in the current makefile. They are used for error messages. Value is -1 if the line is invalid, 0 if following text should be interpreted, 1 if following text should be ignored. */ static int conditional_line (line, filename, lineno) char *line; char *filename; unsigned int lineno; { int notdef; char *cmdname; register unsigned int i; if (*line == 'i') { /* It's an "if..." command. */ notdef = line[2] == 'n'; if (notdef) { cmdname = line[3] == 'd' ? "ifndef" : "ifneq"; line += cmdname[3] == 'd' ? 7 : 6; } else { cmdname = line[2] == 'd' ? "ifdef" : "ifeq"; line += cmdname[2] == 'd' ? 6 : 5; } } else { /* It's an "else" or "endif" command. */ notdef = line[1] == 'n'; cmdname = notdef ? "endif" : "else"; line += notdef ? 5 : 4; } line = next_token (line); if (*cmdname == 'e') { if (*line != '\0') makefile_error (filename, lineno, "Extraneous text after `%s' directive", cmdname); /* "Else" or "endif". */ if (conditionals->if_cmds == 0) makefile_fatal (filename, lineno, "extraneous `%s'", cmdname); /* NOTDEF indicates an `endif' command. */ if (notdef) --conditionals->if_cmds; else if (conditionals->seen_else[conditionals->if_cmds - 1]) makefile_fatal (filename, lineno, "only one `else' per conditional"); else { /* Toggle the state of ignorance. */ conditionals->ignoring[conditionals->if_cmds - 1] = !conditionals->ignoring[conditionals->if_cmds - 1]; /* Record that we have seen an `else' in this conditional. A second `else' will be erroneous. */ conditionals->seen_else[conditionals->if_cmds - 1] = 1; } for (i = 0; i < conditionals->if_cmds; ++i) if (conditionals->ignoring[i]) return 1; return 0; } if (conditionals->allocated == 0) { conditionals->allocated = 5; conditionals->ignoring = (char *) xmalloc (conditionals->allocated); conditionals->seen_else = (char *) xmalloc (conditionals->allocated); } ++conditionals->if_cmds; if (conditionals->if_cmds > conditionals->allocated) { conditionals->allocated += 5; conditionals->ignoring = (char *) xrealloc (conditionals->ignoring, conditionals->allocated); conditionals->seen_else = (char *) xrealloc (conditionals->seen_else, conditionals->allocated); } /* Record that we have seen an `if...' but no `else' so far. */ conditionals->seen_else[conditionals->if_cmds - 1] = 0; /* Search through the stack to see if we're already ignoring. */ for (i = 0; i < conditionals->if_cmds - 1; ++i) if (conditionals->ignoring[i]) { /* We are already ignoring, so just push a level to match the next "else" or "endif", and keep ignoring. We don't want to expand variables in the condition. */ conditionals->ignoring[conditionals->if_cmds - 1] = 1; return 1; } if (cmdname[notdef ? 3 : 2] == 'd') { /* "Ifdef" or "ifndef". */ struct variable *v; register char *p = end_of_token (line); i = p - line; p = next_token (p); if (*p != '\0') return -1; v = lookup_variable (line, i); conditionals->ignoring[conditionals->if_cmds - 1] = (v != 0 && *v->value != '\0') == notdef; } else { /* "Ifeq" or "ifneq". */ char *s1, *s2; unsigned int len; char termin = *line == '(' ? ',' : *line; if (termin != ',' && termin != '"' && termin != '\'') return -1; s1 = ++line; /* Find the end of the first string. */ if (termin == ',') { register int count = 0; for (; *line != '\0'; ++line) if (*line == '(') ++count; else if (*line == ')') --count; else if (*line == ',' && count <= 0) break; } else while (*line != '\0' && *line != termin) ++line; if (*line == '\0') return -1; *line++ = '\0'; s2 = variable_expand (s1); /* We must allocate a new copy of the expanded string because variable_expand re-uses the same buffer. */ len = strlen (s2); s1 = (char *) alloca (len + 1); bcopy (s2, s1, len + 1); if (termin != ',') /* Find the start of the second string. */ line = next_token (line); termin = termin == ',' ? ')' : *line; if (termin != ')' && termin != '"' && termin != '\'') return -1; /* Find the end of the second string. */ if (termin == ')') { register int count = 0; s2 = next_token (line); for (line = s2; *line != '\0'; ++line) { if (*line == '(') ++count; else if (*line == ')') if (count <= 0) break; else --count; } } else { ++line; s2 = line; while (*line != '\0' && *line != termin) ++line; } if (*line == '\0') return -1; *line = '\0'; line = next_token (++line); if (*line != '\0') makefile_error (filename, lineno, "Extraneous text after `%s' directive", cmdname); s2 = variable_expand (s2); conditionals->ignoring[conditionals->if_cmds - 1] = streq (s1, s2) == notdef; } /* Search through the stack to see if we're ignoring. */ for (i = 0; i < conditionals->if_cmds; ++i) if (conditionals->ignoring[i]) return 1; return 0; } /* Remove duplicate dependencies in CHAIN. */ void uniquize_deps (chain) struct dep *chain; { register struct dep *d; /* Make sure that no dependencies are repeated. This does not really matter for the purpose of updating targets, but it might make some names be listed twice for $^ and $?. */ for (d = chain; d != 0; d = d->next) { struct dep *last, *next; last = d; next = d->next; while (next != 0) if (streq (dep_name (d), dep_name (next))) { struct dep *n = next->next; last->next = n; if (next->name != 0 && next->name != d->name) free (next->name); if (next != d) free ((char *) next); next = n; } else { last = next; next = next->next; } } } /* Record a description line for files FILENAMES, with dependencies DEPS, commands to execute described by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED. TWO_COLON is nonzero if a double colon was used. If not nil, PATTERN is the `%' pattern to make this a static pattern rule, and PATTERN_PERCENT is a pointer to the `%' within it. The links of FILENAMES are freed, and so are any names in it that are not incorporated into other data structures. */ static void record_files (filenames, pattern, pattern_percent, deps, commands_started, commands, commands_idx, two_colon, filename, lineno, set_default) struct nameseq *filenames; char *pattern, *pattern_percent; struct dep *deps; unsigned int commands_started; char *commands; unsigned int commands_idx; int two_colon; char *filename; unsigned int lineno; int set_default; { struct nameseq *nextf; int implicit = 0; unsigned int max_targets, target_idx; char **targets = 0, **target_percents = 0; struct commands *cmds; if (commands_idx > 0) { cmds = (struct commands *) xmalloc (sizeof (struct commands)); cmds->filename = filename; cmds->lineno = commands_started; cmds->commands = savestring (commands, commands_idx); cmds->command_lines = 0; } else cmds = 0; for (; filenames != 0; filenames = nextf) { register char *name = filenames->name; register struct file *f; register struct dep *d; struct dep *this; char *implicit_percent; nextf = filenames->next; free ((char *) filenames); implicit_percent = find_percent (name); implicit |= implicit_percent != 0; if (implicit && pattern != 0) makefile_fatal (filename, lineno, "mixed implicit and static pattern rules"); if (implicit && implicit_percent == 0) makefile_fatal (filename, lineno, "mixed implicit and normal rules"); if (implicit) { if (targets == 0) { max_targets = 5; targets = (char **) xmalloc (5 * sizeof (char *)); target_percents = (char **) xmalloc (5 * sizeof (char *)); target_idx = 0; } else if (target_idx == max_targets - 1) { max_targets += 5; targets = (char **) xrealloc ((char *) targets, max_targets * sizeof (char *)); target_percents = (char **) xrealloc ((char *) target_percents, max_targets * sizeof (char *)); } targets[target_idx] = name; target_percents[target_idx] = implicit_percent; ++target_idx; continue; } /* If there are multiple filenames, copy the chain DEPS for all but the last one. It is not safe for the same deps to go in more than one place in the data base. */ this = nextf != 0 ? copy_dep_chain (deps) : deps; if (pattern != 0) /* If this is an extended static rule: `targets: target%pattern: dep%pattern; cmds', translate each dependency pattern into a plain filename using the target pattern and this target's name. */ if (!pattern_matches (pattern, pattern_percent, name)) { /* Give a warning if the rule is meaningless. */ makefile_error (filename, lineno, "target `%s' doesn't match the target pattern", name); this = 0; } else { /* We use patsubst_expand to do the work of translating the target pattern, the target's name and the dependencies' patterns into plain dependency names. */ char *buffer = variable_expand (""); for (d = this; d != 0; d = d->next) { char *o; char *percent = find_percent (d->name); if (percent == 0) continue; o = patsubst_expand (buffer, name, pattern, d->name, pattern_percent, percent); free (d->name); d->name = savestring (buffer, o - buffer); } } if (!two_colon) { /* Single-colon. Combine these dependencies with others in file's existing record, if any. */ f = enter_file (name); if (f->double_colon) makefile_fatal (filename, lineno, "target file `%s' has both : and :: entries", f->name); /* If CMDS == F->CMDS, this target was listed in this rule more than once. Just give a warning since this is harmless. */ if (cmds != 0 && cmds == f->cmds) makefile_error (filename, lineno, "target `%s' given more than once in the same rule.", f->name); /* Check for two single-colon entries both with commands. Check is_target so that we don't lose on files such as .c.o whose commands were preinitialized. */ else if (cmds != 0 && f->cmds != 0 && f->is_target) { makefile_error (cmds->filename, cmds->lineno, "warning: overriding commands for target `%s'", f->name); makefile_error (f->cmds->filename, f->cmds->lineno, "warning: ignoring old commands for target `%s'", f->name); } f->is_target = 1; /* Defining .DEFAULT with no deps or cmds clears it. */ if (f == default_file && this == 0 && cmds == 0) f->cmds = 0; if (cmds != 0) f->cmds = cmds; /* Defining .SUFFIXES with no dependencies clears out the list of suffixes. */ if (f == suffix_file && this == 0) { d = f->deps; while (d != 0) { struct dep *nextd = d->next; free (d->name); free (d); d = nextd; } f->deps = 0; } else if (f->deps != 0) { /* Add the file's old deps and the new ones in THIS together. */ struct dep *firstdeps, *moredeps; if (cmds != 0) { /* This is the rule with commands, so put its deps first. The rationale behind this is that $< expands to the first dep in the chain, and commands use $< expecting to get the dep that rule specifies. */ firstdeps = this; moredeps = f->deps; } else { /* Append the new deps to the old ones. */ firstdeps = f->deps; moredeps = this; } if (firstdeps == 0) firstdeps = moredeps; else { d = firstdeps; while (d->next != 0) d = d->next; d->next = moredeps; } f->deps = firstdeps; } else f->deps = this; /* If this is a static pattern rule, set the file's stem to the part of its name that matched the `%' in the pattern, so you can use $* in the commands. */ if (pattern != 0) { static char *percent = "%"; char *buffer = variable_expand (""); char *o = patsubst_expand (buffer, name, pattern, percent, pattern_percent, percent); f->stem = savestring (buffer, o - buffer); } } else { /* Double-colon. Make a new record even if the file already has one. */ f = lookup_file (name); /* Check for both : and :: rules. Check is_target so we don't lose on default suffix rules or makefiles. */ if (f != 0 && f->is_target && !f->double_colon) makefile_fatal (filename, lineno, "target file `%s' has both : and :: entries", f->name); f = enter_file (name); /* If there was an existing entry and it was a double-colon entry, enter_file will have returned a new one, making it the prev pointer of the old one. */ f->is_target = 1; f->double_colon = 1; f->deps = this; f->cmds = cmds; } /* Free name if not needed further. */ if (f != 0 && name != f->name && (name < f->name || name > f->name + strlen (f->name))) { free (name); name = f->name; } /* See if this is first target seen whose name does not start with a `.', unless it contains a slash. */ if (default_goal_file == 0 && set_default && (*name != '.' || index (name, '/') != 0)) { int reject = 0; /* If this file is a suffix, don't let it be the default goal file. */ for (d = suffix_file->deps; d != 0; d = d->next) { register struct dep *d2; if (*dep_name (d) != '.' && streq (name, dep_name (d))) { reject = 1; break; } for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next) { register unsigned int len = strlen (dep_name (d2)); if (strncmp (name, dep_name (d2), len)) continue; if (streq (name + len, dep_name (d))) { reject = 1; break; } } if (reject) break; } if (!reject) default_goal_file = f; } } if (implicit) { targets[target_idx] = 0; target_percents[target_idx] = 0; create_pattern_rule (targets, target_percents, two_colon, deps, cmds, 1); free ((char *) target_percents); } } /* Search STRING for an unquoted ; that is not after an unquoted #. */ static char * find_semicolon (string) char *string; { char *found, *p; found = index (string, ';'); while (found != 0 && found[-1] == '\\') { register char *q = &found[-1]; register int backslash = 0; while (*q-- == '\\') backslash = !backslash; if (backslash) found = index (found + 1, ';'); else break; } if (found == 0) return 0; /* Look for a comment character (#) before the ; we found. */ p = lindex (string, found, '#'); while (p != 0 && p[-1] == '\\') { register char *q = &p[-1]; register int backslash = 0; while (*q-- == '\\') backslash = !backslash; if (backslash) p = lindex (p + 1, found, '#'); else break; } if (p == 0) return found; return 0; } /* Search PATTERN for an unquoted %. Backslashes quote % and backslash. Quoting backslashes are removed from PATTERN by compacting it into itself. Returns a pointer to the first unquoted % if there is one, or nil if there are none. */ char * find_percent (pattern) char *pattern; { unsigned int pattern_len = strlen (pattern); register char *p = pattern; while ((p = index (p, '%')) != 0) if (p > pattern && p[-1] == '\\') { /* Search for more backslashes. */ register int i = -2; while (&p[i] >= pattern && p[i] == '\\') --i; ++i; /* The number of backslashes is now -I. Copy P over itself to swallow half of them. */ bcopy (&p[i / 2], &p[i], (pattern_len - (p - pattern)) - (i / 2) + 1); p += i / 2; if (i % 2 == 0) /* All the backslashes quoted each other; the % was unquoted. */ return p; /* The % was quoted by a backslash. Look for another. */ } else /* No backslash in sight. */ return p; /* Never hit a %. */ return 0; } /* Parse a string into a sequence of filenames represented as a chain of struct nameseq's in reverse order and return that chain. The string is passed as STRINGP, the address of a string pointer. The string pointer is updated to point at the first character not parsed, which either is a null char or equals STOPCHAR. SIZE is how big to construct chain elements. This is useful if we want them actually to be other structures that have room for additional info. If STRIP is nonzero, strip `./'s off the beginning. */ struct nameseq * parse_file_seq (stringp, stopchar, size, strip) char **stringp; char stopchar; unsigned int size; int strip; { register struct nameseq *new = 0; register struct nameseq *new1; register char *p = *stringp; char *q; char *name; register int c; while (1) { /* Skip whitespace; see if any more names are left. */ p = next_token (p); if (*p == '\0') break; if (*p == stopchar) break; /* Yes, find end of next name. */ q = p; while (1) { c = *p++; if (c == '\0') break; else if (c == '\\' && (*p == '\\' || isblank (*p) || *p == stopchar)) ++p; else if (isblank (c) || c == stopchar) break; } p--; if (strip) /* Skip leading `./'s. */ while (p - q > 2 && q[0] == '.' && q[1] == '/') { q += 2; /* Skip "./". */ while (q < p && *q == '/') /* Skip following slashes: ".//foo" is "foo", not "/foo". */ ++q; } /* Extract the filename just found, and skip it. */ if (q == p) /* ".///" was stripped to "". */ name = savestring ("./", 2); else name = savestring (q, p - q); /* Add it to the front of the chain. */ new1 = (struct nameseq *) xmalloc (size); new1->name = name; new1->next = new; new = new1; } #ifndef NO_ARCHIVES /* Look for multi-word archive references. They are indicated by a elt ending with an unmatched `)' and an elt further down the chain (i.e., previous in the file list) with an unmatched `(' (e.g., "lib(mem"). */ for (new1 = new; new1 != 0; new1 = new1->next) if (new1->name[0] != '(' /* Don't catch "(%)" and suchlike. */ && new1->name[strlen (new1->name) - 1] == ')' && index (new1->name, '(') == 0) { /* NEW1 ends with a `)' but does not contain a `('. Look back for an elt with an opening `(' but no closing `)'. */ struct nameseq *n = new1->next, *lastn = new1; char *paren; while (n != 0 && (paren = index (n->name, '(')) == 0) { lastn = n; n = n->next; } if (n != 0 /* Ignore something starting with `(', as that cannot actually be an archive-member reference (and treating it as such results in an empty file name, which causes much lossage). */ && n->name[0] != '(') { /* N is the first element in the archive group. Its name looks like "lib(mem" (with no closing `)'). */ char *libname; /* Copy "lib(" into LIBNAME. */ ++paren; libname = (char *) alloca (paren - n->name + 1); bcopy (n->name, libname, paren - n->name); libname[paren - n->name] = '\0'; if (*paren == '\0') { /* N was just "lib(", part of something like "lib( a b)". Edit it out of the chain and free its storage. */ lastn->next = n->next; free (n->name); free ((char *) n); /* LASTN->next is the new stopping elt for the loop below. */ n = lastn->next; } else { /* Replace N's name with the full archive reference. */ name = concat (libname, paren, ")"); free (n->name); n->name = name; } if (new1->name[1] == '\0') { /* NEW1 is just ")", part of something like "lib(a b )". Omit it from the chain and free its storage. */ lastn = new1; new1 = new1->next; if (new == lastn) new = new1; free (lastn->name); free ((char *) lastn); } else { /* Replace also NEW1->name, which already has closing `)'. */ name = concat (libname, new1->name, ""); free (new1->name); new1->name = name; new1 = new1->next; } /* Trace back from NEW1 (the end of the list) until N (the beginning of the list), rewriting each name with the full archive reference. */ while (new1 != n) { name = concat (libname, new1->name, ")"); free (new1->name); new1->name = name; new1 = new1->next; } if (new1 == 0) /* We might have slurped up the whole list, and continuing the loop would dereference NEW1. */ break; } } #endif *stringp = p; return new; } /* Read a line of text from STREAM into LINEBUFFER. Combine continuation lines into one line. Return the number of actual lines read (> 1 if hacked continuation lines). */ static unsigned int readline (linebuffer, stream, filename, lineno) struct linebuffer *linebuffer; FILE *stream; char *filename; unsigned int lineno; { char *buffer = linebuffer->buffer; register char *p = linebuffer->buffer; register char *end = p + linebuffer->size; register int len, lastlen = 0; register char *p2; register unsigned int nlines = 0; register int backslash; *p = '\0'; while (fgets (p, end - p, stream) != 0) { len = strlen (p); if (len == 0) { /* This only happens when the first thing on the line is a '\0'. It is a pretty hopeless case, but (wonder of wonders) Athena lossage strikes again! (xmkmf puts NULs in its makefiles.) There is nothing really to be done; we synthesize a newline so the following line doesn't appear to be part of this line. */ makefile_error (filename, lineno, "warning: NUL character seen; rest of line ignored"); p[0] = '\n'; len = 1; } p += len; if (p[-1] != '\n') { /* Probably ran out of buffer space. */ register unsigned int p_off = p - buffer; linebuffer->size *= 2; buffer = (char *) xrealloc (buffer, linebuffer->size); p = buffer + p_off; end = buffer + linebuffer->size; linebuffer->buffer = buffer; *p = '\0'; lastlen = len; continue; } ++nlines; if (len == 1 && p > buffer) /* P is pointing at a newline and it's the beginning of the buffer returned by the last fgets call. However, it is not necessarily the beginning of a line if P is pointing past the beginning of the holding buffer. If the buffer was just enlarged (right before the newline), we must account for that, so we pretend that the two lines were one line. */ len += lastlen; lastlen = len; backslash = 0; for (p2 = p - 2; --len > 0; --p2) { if (*p2 == '\\') backslash = !backslash; else break; } if (!backslash) { p[-1] = '\0'; break; } if (end - p <= 1) { /* Enlarge the buffer. */ register unsigned int p_off = p - buffer; linebuffer->size *= 2; buffer = (char *) xrealloc (buffer, linebuffer->size); p = buffer + p_off; end = buffer + linebuffer->size; linebuffer->buffer = buffer; } } if (ferror (stream)) pfatal_with_name (filename); return nlines; } /* Construct the list of include directories from the arguments and the default list. */ void construct_include_path (arg_dirs) char **arg_dirs; { register unsigned int i; struct stat stbuf; /* Table to hold the dirs. */ register unsigned int defsize = (sizeof (default_include_directories) / sizeof (default_include_directories[0])); register unsigned int max = 5; register char **dirs = (char **) xmalloc ((5 + defsize) * sizeof (char *)); register unsigned int idx = 0; /* First consider any dirs specified with -I switches. Ignore dirs that don't exist. */ if (arg_dirs != 0) while (*arg_dirs != 0) { char *dir = *arg_dirs++; if (dir[0] == '~') { char *expanded = tilde_expand (dir); if (expanded != 0) dir = expanded; } if (stat (dir, &stbuf) == 0 && S_ISDIR (stbuf.st_mode)) { if (idx == max - 1) { max += 5; dirs = (char **) xrealloc ((char *) dirs, (max + defsize) * sizeof (char *)); } dirs[idx++] = dir; } else if (dir != arg_dirs[-1]) free (dir); } /* Now add at the end the standard default dirs. */ for (i = 0; default_include_directories[i] != 0; ++i) if (stat (default_include_directories[i], &stbuf) == 0 && S_ISDIR (stbuf.st_mode)) dirs[idx++] = default_include_directories[i]; dirs[idx] = 0; /* Now compute the maximum length of any name in it. */ max_incl_len = 0; for (i = 0; i < idx; ++i) { unsigned int len = strlen (dirs[i]); /* If dir name is written with a trailing slash, discard it. */ if (dirs[i][len - 1] == '/') /* We can't just clobber a null in because it may have come from a literal string and literal strings may not be writable. */ dirs[i] = savestring (dirs[i], len - 1); if (len > max_incl_len) max_incl_len = len; } include_directories = dirs; } /* Expand ~ or ~USER at the beginning of NAME. Return a newly malloc'd string or 0. */ char * tilde_expand (name) char *name; { if (name[1] == '/' || name[1] == '\0') { extern char *getenv (); char *home_dir; int is_variable; { /* Turn off --warn-undefined-variables while we expand HOME. */ int save = warn_undefined_variables_flag; warn_undefined_variables_flag = 0; home_dir = allocated_variable_expand ("$(HOME)"); warn_undefined_variables_flag = save; } is_variable = home_dir[0] != '\0'; if (!is_variable) { free (home_dir); home_dir = getenv ("HOME"); } if (home_dir == 0 || home_dir[0] == '\0') { extern char *getlogin (); char *name = getlogin (); home_dir = 0; if (name != 0) { struct passwd *p = getpwnam (name); if (p != 0) home_dir = p->pw_dir; } } if (home_dir != 0) { char *new = concat (home_dir, "", name + 1); if (is_variable) free (home_dir); return new; } } else { struct passwd *pwent; char *userend = index (name + 1, '/'); if (userend != 0) *userend = '\0'; pwent = getpwnam (name + 1); if (pwent != 0) { if (userend == 0) return savestring (pwent->pw_dir, strlen (pwent->pw_dir)); else return concat (pwent->pw_dir, "/", userend + 1); } else if (userend != 0) *userend = '/'; } return 0; } /* Given a chain of struct nameseq's describing a sequence of filenames, in reverse of the intended order, return a new chain describing the result of globbing the filenames. The new chain is in forward order. The links of the old chain are freed or used in the new chain. Likewise for the names in the old chain. SIZE is how big to construct chain elements. This is useful if we want them actually to be other structures that have room for additional info. */ struct nameseq * multi_glob (chain, size) struct nameseq *chain; unsigned int size; { register struct nameseq *new = 0; register struct nameseq *old; struct nameseq *nexto; for (old = chain; old != 0; old = nexto) { glob_t gl; #ifndef NO_ARCHIVES char *memname; #endif nexto = old->next; if (old->name[0] == '~') { char *newname = tilde_expand (old->name); if (newname != 0) { free (old->name); old->name = newname; } } #ifndef NO_ARCHIVES if (ar_name (old->name)) { /* OLD->name is an archive member reference. Replace it with the archive file name, and save the member name in MEMNAME. We will glob on the archive name and then reattach MEMNAME later. */ char *arname; ar_parse_name (old->name, &arname, &memname); free (old->name); old->name = arname; } else memname = 0; #endif switch (glob (old->name, GLOB_NOCHECK, NULL, &gl)) { case 0: /* Success. */ { register int i = gl.gl_pathc; while (i-- > 0) { #ifndef NO_ARCHIVES if (memname != 0) { /* Try to glob on MEMNAME within the archive. */ struct nameseq *found = ar_glob (gl.gl_pathv[i], memname, size); if (found == 0) { /* No matches. Use MEMNAME as-is. */ struct nameseq *elt = (struct nameseq *) xmalloc (size); unsigned int alen = strlen (gl.gl_pathv[i]); unsigned int mlen = strlen (memname); elt->name = (char *) xmalloc (alen + 1 + mlen + 2); bcopy (gl.gl_pathv[i], elt->name, alen); elt->name[alen] = '('; bcopy (memname, &elt->name[alen + 1], mlen); elt->name[alen + 1 + mlen] = ')'; elt->name[alen + 1 + mlen + 1] = '\0'; elt->next = new; new = elt; } else { /* Find the end of the FOUND chain. */ struct nameseq *f = found; while (f->next != 0) f = f->next; /* Attach the chain being built to the end of the FOUND chain, and make FOUND the new NEW chain. */ f->next = new; new = found; } free (memname); } else #endif { struct nameseq *elt = (struct nameseq *) xmalloc (size); elt->name = savestring (gl.gl_pathv[i], strlen (gl.gl_pathv[i])); elt->next = new; new = elt; } } globfree (&gl); free (old->name); free (old); break; } case GLOB_NOSPACE: fatal ("virtual memory exhausted"); break; default: old->next = new; new = old; break; } } return new; } make-3.70/remake.c 666 12241 13 62157 5463571302 7121 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "job.h" #include "dep.h" #include "file.h" #ifdef HAVE_FCNTL_H #include #else #include #endif extern int try_implicit_rule (); /* Incremented when a command is started (under -n, when one would be). */ unsigned int commands_started = 0; static int update_file (), update_file_1 (), check_dep (), touch_file (); static void remake_file (); static time_t name_mtime (); static int library_search (); extern time_t f_mtime (); /* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing was done, 0 if all goals were updated successfully, or 1 if a goal failed. If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should be disabled for them unless they were also command-line targets, and we should only make one goal at a time and return as soon as one goal whose `changed' member is nonzero is successfully made. */ int update_goal_chain (goals, makefiles) register struct dep *goals; int makefiles; { int t = touch_flag, q = question_flag, n = just_print_flag; unsigned int j = job_slots; int status = -1; #define MTIME(file) (makefiles ? file_mtime_no_search (file) \ : file_mtime (file)) /* Duplicate the chain so we can remove things from it. */ goals = copy_dep_chain (goals); { /* Clear the `changed' flag of each goal in the chain. We will use the flag below to notice when any commands have actually been run for a target. When no commands have been run, we give an "up to date" diagnostic. */ struct dep *g; for (g = goals; g != 0; g = g->next) g->changed = 0; } if (makefiles) /* Only run one job at a time. */ job_slots = 1; /* Update all the goals until they are all finished. */ while (goals != 0) { register struct dep *g, *lastgoal; /* Start jobs that are waiting for the load to go down. */ start_waiting_jobs (); /* Wait for a child to die. */ reap_children (1, 0); lastgoal = 0; g = goals; while (g != 0) { unsigned int ocommands_started; int x; time_t mtime = MTIME (g->file); check_renamed (g->file); if (makefiles) { if (g->file->cmd_target) { touch_flag = t; question_flag = q; just_print_flag = n; } else touch_flag = question_flag = just_print_flag = 0; } /* Save the old value of `commands_started' so we can compare later. It will be incremented when any commands are actually run. */ ocommands_started = commands_started; x = update_file (g->file, makefiles ? 1 : 0); check_renamed (g->file); /* Set the goal's `changed' flag if any commands were started by calling update_file above. We check this flag below to decide when to give an "up to date" diagnostic. */ g->changed += commands_started - ocommands_started; if (x != 0 || g->file->updated) { int stop = 0; /* If STATUS was not already 1, set it to 1 if updating failed, or to 0 if updating succeeded. Leave STATUS as it is if no updating was done. */ if (status < 1) { if (g->file->update_status != 0) { /* Updating failed. */ status = 1; stop = !keep_going_flag && !makefiles; } else if (MTIME (g->file) != mtime) { /* Updating was done. If this is a makefile and just_print_flag or question_flag is set (meaning -n or -q was given and this file was specified as a command-line target), don't change STATUS. If STATUS is changed, we will get re-exec'd, and fall into an infinite loop. */ if (!makefiles || (!just_print_flag && !question_flag)) status = 0; if (makefiles && g->file->dontcare) /* This is a default makefile. Stop remaking. */ stop = 1; } } if (stop || g->file->prev == 0) { /* If we have found nothing whatever to do for the goal, print a message saying nothing needs doing. */ if (!makefiles /* If the update_status is zero, we updated successfully or not at all. G->changed will have been set above if any commands were actually started for this goal. */ && g->file->update_status == 0 && !g->changed /* Never give a message under -s or -q. */ && !silent_flag && !question_flag) { if (g->file->phony || g->file->cmds == 0) message ("Nothing to be done for `%s'.", g->file->name); else message ("`%s' is up to date.", g->file->name); fflush (stdout); } /* This goal is finished. Remove it from the chain. */ if (lastgoal == 0) goals = g->next; else lastgoal->next = g->next; /* Free the storage. */ free ((char *) g); g = lastgoal == 0 ? goals : lastgoal->next; } else if (g->file->updated) /* This instance of the target is done being updated. Go to the next instance (:: rule). update_file cycles through all instances, but under -j, update_file can return while the file is running, then reap_children can change its command state and updated flag, leaving G->file done, but some of its other instances needing work. */ g->file = g->file->prev; if (stop) break; } else { lastgoal = g; g = g->next; } } } if (makefiles) { touch_flag = t; question_flag = q; just_print_flag = n; job_slots = j; } return status; } /* If FILE is not up to date, execute the commands for it. Return 0 if successful, 1 if unsuccessful; but with some flag settings, just call `exit' if unsuccessful. DEPTH is the depth in recursions of this function. We increment it during the consideration of our dependencies, then decrement it again after finding out whether this file is out of date. If there are multiple double-colon entries for FILE, each is considered in turn. */ static int update_file (file, depth) struct file *file; unsigned int depth; { register int status = 0; register struct file *f; for (f = file; f != 0; f = f->prev) { status |= update_file_1 (f, depth); check_renamed (f); if (status != 0 && !keep_going_flag) return status; switch (f->command_state) { case cs_finished: /* The file is done being remade. */ break; case cs_running: case cs_deps_running: /* Don't run the other :: rules for this file until this rule is finished. */ return 0; default: error ("internal error: `%s' command_state == %d in update_file", f->name, (int) f->command_state); abort (); break; } } return status; } /* Consider a single `struct file' and update it as appropriate. */ static int update_file_1 (file, depth) struct file *file; unsigned int depth; { register time_t this_mtime; int noexist, must_make, deps_changed; int dep_status = 0; register struct dep *d, *lastd; int running = 0; DEBUGPR ("Considering target file `%s'.\n"); if (file->updated) { if (file->update_status > 0) { DEBUGPR ("Recently tried and failed to update file `%s'.\n"); return file->update_status; } DEBUGPR ("File `%s' was considered already.\n"); return 0; } switch (file->command_state) { case cs_not_started: case cs_deps_running: break; case cs_running: DEBUGPR ("Still updating file `%s'.\n"); return 0; case cs_finished: DEBUGPR ("Finished updating file `%s'.\n"); return file->update_status; default: abort (); } ++depth; /* Notice recursive update of the same file. */ file->updating = 1; /* Looking at the file's modtime beforehand allows the possibility that its name may be changed by a VPATH search, and thus it may not need an implicit rule. If this were not done, the file might get implicit commands that apply to its initial name, only to have that name replaced with another found by VPATH search. */ this_mtime = file_mtime (file); check_renamed (file); noexist = this_mtime == (time_t) -1; if (noexist) DEBUGPR ("File `%s' does not exist.\n"); must_make = noexist; /* If file was specified as a target with no commands, come up with some default commands. */ if (!file->phony && file->cmds == 0 && !file->tried_implicit) { if (try_implicit_rule (file, depth)) DEBUGPR ("Found an implicit rule for `%s'.\n"); else DEBUGPR ("No implicit rule found for `%s'.\n"); file->tried_implicit = 1; } if (file->cmds == 0 && !file->is_target && default_file != 0 && default_file->cmds != 0) { DEBUGPR ("Using default commands for `%s'.\n"); file->cmds = default_file->cmds; } /* Update all non-intermediate files we depend on, if necessary, and see whether any of them is more recent than this file. */ lastd = 0; d = file->deps; while (d != 0) { time_t mtime; check_renamed (d->file); mtime = file_mtime (d->file); check_renamed (d->file); if (d->file->updating) { error ("Circular %s <- %s dependency dropped.", file->name, d->file->name); if (lastd == 0) { file->deps = d->next; free ((char *) d); d = file->deps; } else { lastd->next = d->next; free ((char *) d); d = lastd->next; } continue; } d->file->parent = file; dep_status |= check_dep (d->file, depth, this_mtime, &must_make); check_renamed (d->file); { register struct file *f = d->file; do { running |= (f->command_state == cs_running || f->command_state == cs_deps_running); f = f->prev; } while (f != 0); } if (dep_status != 0 && !keep_going_flag) break; if (!running) d->changed = file_mtime (d->file) != mtime; lastd = d; d = d->next; } /* Now we know whether this target needs updating. If it does, update all the intermediate files we depend on. */ if (must_make) { for (d = file->deps; d != 0; d = d->next) if (d->file->intermediate) { time_t mtime = file_mtime (d->file); check_renamed (d->file); d->file->parent = file; dep_status |= update_file (d->file, depth); check_renamed (d->file); { register struct file *f = d->file; do { running |= (f->command_state == cs_running || f->command_state == cs_deps_running); f = f->prev; } while (f != 0); } if (dep_status != 0 && !keep_going_flag) break; if (!running) d->changed = ((file->phony && file->cmds != 0) || file_mtime (d->file) != mtime); } } file->updating = 0; DEBUGPR ("Finished dependencies of target file `%s'.\n"); if (running) { file->command_state = cs_deps_running; --depth; DEBUGPR ("The dependencies of `%s' are being made.\n"); return 0; } /* If any dependency failed, give up now. */ if (dep_status != 0) { file->command_state = cs_finished; file->update_status = dep_status; file->updated = 1; depth--; DEBUGPR ("Giving up on target file `%s'.\n"); if (depth == 0 && keep_going_flag && !just_print_flag && !question_flag) error ("Target `%s' not remade because of errors.", file->name); return dep_status; } file->command_state = cs_not_started; /* Now record which dependencies are more recent than this file, so we can define $?. */ deps_changed = 0; for (d = file->deps; d != 0; d = d->next) { time_t d_mtime = file_mtime (d->file); check_renamed (d->file); #if 1 /* %%% In version 4, remove this code completely to implement not remaking deps if their deps are newer than their parents. */ if (d_mtime == (time_t) -1 && !d->file->intermediate) /* We must remake if this dep does not exist and is not intermediate. */ must_make = 1; #endif /* Set DEPS_CHANGED if this dep actually changed. */ deps_changed |= d->changed; /* Set D->changed if either this dep actually changed, or its dependent, FILE, is older or does not exist. */ d->changed |= noexist || d_mtime > this_mtime; if (debug_flag && !noexist) { print_spaces (depth); if (d_mtime == (time_t) -1) printf ("Dependency `%s' does not exist.\n", dep_name (d)); else printf ("Dependency `%s' is %s than dependent `%s'.\n", dep_name (d), d->changed ? "newer" : "older", file->name); fflush (stdout); } } /* Here depth returns to the value it had when we were called. */ depth--; if (file->double_colon && file->deps == 0) { must_make = 1; DEBUGPR ("Target `%s' is double-colon and has no dependencies.\n"); } else if (!noexist && file->is_target && !deps_changed && file->cmds == 0) { must_make = 0; DEBUGPR ("No commands for `%s' and no dependencies actually changed.\n"); } if (!must_make) { DEBUGPR ("No need to remake target `%s'.\n"); file->command_state = cs_finished; file->update_status = 0; file->updated = 1; return 0; } DEBUGPR ("Must remake target `%s'.\n"); /* Now, take appropriate actions to remake the file. */ remake_file (file); if (file->command_state != cs_finished) { DEBUGPR ("Commands of `%s' are being run.\n"); return 0; } switch (file->update_status) { case 1: DEBUGPR ("Failed to remake target file `%s'.\n"); break; case 0: DEBUGPR ("Successfully remade target file `%s'.\n"); break; case -1: error ("internal error: `%s' update_status is -1 at cs_finished!", file->name); abort (); default: error ("internal error: `%s' update_status invalid!", file->name); abort (); } file->updated = 1; return file->update_status; } /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all files listed in its `also_make' member. Under -t, this function also touches FILE. */ void notice_finished_file (file) register struct file *file; { struct dep *d; file->command_state = cs_finished; file->updated = 1; if (touch_flag /* The update status will be: -1 if no commands were run; 0 if some commands (+ or ${MAKE}) were run and won; 1 if some commands were run and lost. The only time we don't want to touch the target is if it had some recursive commands, and they lost. */ && file->update_status != 1) { if (file->cmds != 0 && file->cmds->any_recurse) { /* If all the command lines were recursive, we don't want to do the touching. */ unsigned int i; for (i = 0; i < file->cmds->ncommand_lines; ++i) if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE)) goto have_nonrecursing; } else { have_nonrecursing: if (file->phony) file->update_status = 0; else /* Should set file's modification date and do nothing else. */ file->update_status = touch_file (file); } } if (!file->phony) { if (just_print_flag || question_flag || (file->is_target && file->cmds == 0)) file->last_mtime = NEW_MTIME; else file->last_mtime = 0; } if (file->update_status != -1) /* We actually tried to update FILE, which has updated its also_make's as well (if it worked). If it didn't work, it wouldn't work again for them. So mark them as updated with the same status. */ for (d = file->also_make; d != 0; d = d->next) { d->file->command_state = cs_finished; d->file->updated = 1; d->file->update_status = file->update_status; if (!d->file->phony) /* Fetch the new modification time. We do this instead of just invalidating the cached time so that a vpath_search can happen. Otherwise, it would never be done because the target is already updated. */ (void) f_mtime (d->file, 0); } } /* Check whether another file (whose mtime is THIS_MTIME) needs updating on account of a dependency which is file FILE. If it does, store 1 in *MUST_MAKE_PTR. In the process, update any non-intermediate files that FILE depends on (including FILE itself). Return nonzero if any updating failed. */ static int check_dep (file, depth, this_mtime, must_make_ptr) struct file *file; unsigned int depth; time_t this_mtime; int *must_make_ptr; { register struct dep *d; int dep_status = 0; ++depth; file->updating = 1; if (!file->intermediate) /* If this is a non-intermediate file, update it and record whether it is newer than THIS_MTIME. */ { time_t mtime; dep_status = update_file (file, depth); check_renamed (file); mtime = file_mtime (file); check_renamed (file); if (mtime == (time_t) -1 || mtime > this_mtime) *must_make_ptr = 1; } else { /* FILE is an intermediate file. Update all non-intermediate files we depend on, if necessary, and see whether any of them is more recent than the file on whose behalf we are checking. */ register struct dep *lastd; lastd = 0; d = file->deps; while (d != 0) { if (d->file->updating) { error ("Circular %s <- %s dependency dropped.", file->name, d->file->name); if (lastd == 0) { file->deps = d->next; free ((char *) d); d = file->deps; } else { lastd->next = d->next; free ((char *) d); d = lastd->next; } continue; } d->file->parent = file; dep_status |= check_dep (d->file, depth, this_mtime, must_make_ptr); check_renamed (d->file); if (dep_status != 0 && !keep_going_flag) break; if (d->file->command_state == cs_running || d->file->command_state == cs_deps_running) /* Record that some of FILE's dependencies are still being made. This tells the upper levels to wait on processing it until the commands are finished. */ file->command_state = cs_deps_running; lastd = d; d = d->next; } } file->updating = 0; return dep_status; } /* Touch FILE. Return zero if successful, one if not. */ #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1) static int touch_file (file) register struct file *file; { if (!silent_flag) { printf ("touch %s\n", file->name); fflush (stdout); } #ifndef NO_ARCHIVES if (ar_name (file->name)) return ar_touch (file->name); else #endif { int fd = open (file->name, O_RDWR | O_CREAT, 0666); if (fd < 0) TOUCH_ERROR ("touch: open: "); else { struct stat statbuf; char buf; if (fstat (fd, &statbuf) < 0) TOUCH_ERROR ("touch: fstat: "); /* Rewrite character 0 same as it already is. */ if (read (fd, &buf, 1) < 0) TOUCH_ERROR ("touch: read: "); if (lseek (fd, 0L, 0) < 0L) TOUCH_ERROR ("touch: lseek: "); if (write (fd, &buf, 1) < 0) TOUCH_ERROR ("touch: write: "); /* If file length was 0, we just changed it, so change it back. */ if (statbuf.st_size == 0) { (void) close (fd); fd = open (file->name, O_RDWR | O_TRUNC, 0666); if (fd < 0) TOUCH_ERROR ("touch: open: "); } (void) close (fd); } } return 0; } /* Having checked and updated the dependencies of FILE, do whatever is appropriate to remake FILE itself. Return the status from executing FILE's commands. */ static void remake_file (file) struct file *file; { if (file->cmds == 0) { if (file->phony) /* Phony target. Pretend it succeeded. */ file->update_status = 0; else if (file->is_target) /* This is a nonexistent target file we cannot make. Pretend it was successfully remade. */ file->update_status = 0; else { /* This is a dependency file we cannot remake. Fail. */ static char noway[] = "No rule to make target"; if (keep_going_flag || file->dontcare) { if (!file->dontcare) error ("*** %s `%s'.", noway, file->name); file->update_status = 1; } else fatal ("%s `%s'", noway, file->name); } } else { chop_commands (file->cmds); if (!touch_flag || file->cmds->any_recurse) { execute_file_commands (file); return; } } /* This does the touching under -t. */ notice_finished_file (file); } /* Return the mtime of a file, given a `struct file'. Caches the time in the struct file to avoid excess stat calls. If the file is not found, and SEARCH is nonzero, VPATH searching and replacement is done. If that fails, a library (-lLIBNAME) is tried and the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into FILE. */ time_t f_mtime (file, search) register struct file *file; int search; { time_t mtime; /* File's mtime is not known; must get it from the system. */ #ifndef NO_ARCHIVES if (ar_name (file->name)) { /* This file is an archive-member reference. */ char *arname, *memname; struct file *arfile; int arname_used = 0; /* Find the archive's name. */ ar_parse_name (file->name, &arname, &memname); /* Find the modification time of the archive itself. Also allow for its name to be changed via VPATH search. */ arfile = lookup_file (arname); if (arfile == 0) { arfile = enter_file (arname); arname_used = 1; } mtime = f_mtime (arfile, search); check_renamed (arfile); if (search && strcmp (arfile->name, arname)) { /* The archive's name has changed. Change the archive-member reference accordingly. */ unsigned int arlen, memlen; if (!arname_used) { free (arname); arname_used = 1; } arname = arfile->name; arlen = strlen (arname); memlen = strlen (memname); free (file->name); file->name = (char *) xmalloc (arlen + 1 + memlen + 2); bcopy (arname, file->name, arlen); file->name[arlen] = '('; bcopy (memname, file->name + arlen + 1, memlen); file->name[arlen + 1 + memlen] = ')'; file->name[arlen + 1 + memlen + 1] = '\0'; } if (!arname_used) free (arname); free (memname); if (mtime == (time_t) -1) /* The archive doesn't exist, so it's members don't exist either. */ return (time_t) -1; mtime = ar_member_date (file->name); } else #endif { mtime = name_mtime (file->name); if (mtime == (time_t) -1 && search) { /* If name_mtime failed, search VPATH. */ char *name = file->name; if (vpath_search (&name, &mtime) /* Last resort, is it a library (-lxxx)? */ || (name[0] == '-' && name[1] == 'l' && library_search (&name, &mtime))) { if (mtime != 0) /* vpath_search and library_search store zero in MTIME if they didn't need to do a stat call for their work. */ file->last_mtime = mtime; rename_file (file, name); check_renamed (file); return file_mtime (file); } } } /* Store the mtime into all the entries for this file. */ do { file->last_mtime = mtime; file = file->prev; } while (file != 0); return mtime; } /* Return the mtime of the file or archive-member reference NAME. */ static time_t name_mtime (name) register char *name; { struct stat st; if (stat (name, &st) < 0) return (time_t) -1; return (time_t) st.st_mtime; } /* Search for a library file specified as -lLIBNAME, searching for a suitable library file in the system library directories and the VPATH directories. */ static int library_search (lib, mtime_ptr) char **lib; time_t *mtime_ptr; { static char *dirs[] = { "/lib", "/usr/lib", LIBDIR, /* Defined by configuration. */ 0 }; char *libname = &(*lib)[2]; /* Name without the `-l'. */ time_t mtime; /* Buffer to construct possible names in. */ char *buf = xmalloc (sizeof (LIBDIR) + 8 + strlen (libname) + 4 + 2 + 1); char *file, **dp; /* Look first for `libNAME.a' in the current directory. */ sprintf (buf, "lib%s.a", libname); mtime = name_mtime (buf); if (mtime != (time_t) -1) { *lib = buf; if (mtime_ptr != 0) *mtime_ptr = mtime; return 1; } /* Now try VPATH search on that. */ file = buf; if (vpath_search (&file, mtime_ptr)) { free (buf); *lib = file; return 1; } /* Now try the standard set of directories. */ for (dp = dirs; *dp != 0; ++dp) { sprintf (buf, "%s/lib%s.a", *dp, libname); mtime = name_mtime (buf); if (mtime != (time_t) -1) { *lib = buf; if (mtime_ptr != 0) *mtime_ptr = mtime; return 1; } } free (buf); return 0; } make-3.70/rule.c 666 12241 13 36576 5461572610 6633 /* Pattern and suffix rule internals for GNU Make. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "dep.h" #include "file.h" #include "variable.h" #include "rule.h" static void freerule (); /* Chain of all pattern rules. */ struct rule *pattern_rules; /* Pointer to last rule in the chain, so we can add onto the end. */ struct rule *last_pattern_rule; /* Number of rules in the chain. */ unsigned int num_pattern_rules; /* Maximum number of target patterns of any pattern rule. */ unsigned int max_pattern_targets; /* Maximum number of dependencies of any pattern rule. */ unsigned int max_pattern_deps; /* Maximum length of the name of a dependencies of any pattern rule. */ unsigned int max_pattern_dep_length; /* Pointer to structure for the file .SUFFIXES whose dependencies are the suffixes to be searched. */ struct file *suffix_file; /* Maximum length of a suffix. */ unsigned int maxsuffix; /* Compute the maximum dependency length and maximum number of dependencies of all implicit rules. Also sets the subdir flag for a rule when appropriate, possibly removing the rule completely when appropriate. */ void count_implicit_rule_limits () { char *name; unsigned int namelen; register struct rule *rule, *lastrule; num_pattern_rules = max_pattern_targets = max_pattern_deps = 0; max_pattern_dep_length = 0; name = 0; namelen = 0; rule = pattern_rules; lastrule = 0; while (rule != 0) { unsigned int ndeps = 0; register struct dep *dep; struct rule *next = rule->next; unsigned int ntargets; ++num_pattern_rules; ntargets = 0; while (rule->targets[ntargets] != 0) ++ntargets; if (ntargets > max_pattern_targets) max_pattern_targets = ntargets; for (dep = rule->deps; dep != 0; dep = dep->next) { unsigned int len = strlen (dep->name); char *p = rindex (dep->name, '/'); char *p2 = p != 0 ? index (dep->name, '%') : 0; ndeps++; if (len > max_pattern_dep_length) max_pattern_dep_length = len; if (p != 0 && p2 > p) { /* There is a slash before the % in the dep name. Extract the directory name. */ if (p == dep->name) ++p; if (p - dep->name > namelen) { if (name != 0) free (name); namelen = p - dep->name; name = (char *) xmalloc (namelen + 1); } bcopy (dep->name, name, p - dep->name); name[p - dep->name] = '\0'; /* In the deps of an implicit rule the `changed' flag actually indicates that the dependency is in a nonexistent subdirectory. */ dep->changed = !dir_file_exists_p (name, ""); if (dep->changed && *name == '/') { /* The name is absolute and the directory does not exist. This rule can never possibly match, since this dependency can never possibly exist. So just remove the rule from the list. */ freerule (rule, lastrule); --num_pattern_rules; goto end_main_loop; } } else /* This dependency does not reside in a subdirectory. */ dep->changed = 0; } if (ndeps > max_pattern_deps) max_pattern_deps = ndeps; lastrule = rule; end_main_loop: rule = next; } if (name != 0) free (name); } /* Create a pattern rule from a suffix rule. TARGET is the target suffix; SOURCE is the source suffix. CMDS are the commands. If TARGET is nil, it means the target pattern should be `(%.o)'. If SOURCE is nil, it means there should be no deps. */ static void convert_suffix_rule (target, source, cmds) char *target, *source; struct commands *cmds; { char *targname, *targpercent, *depname; char **names, **percents; struct dep *deps; unsigned int len; if (target == 0) /* Special case: TARGET being nil means we are defining a `.X.a' suffix rule; the target pattern is always `(%.o)'. */ { targname = savestring ("(%.o)", 5); targpercent = targname + 1; } else { /* Construct the target name. */ len = strlen (target); targname = xmalloc (1 + len + 1); targname[0] = '%'; bcopy (target, targname + 1, len + 1); targpercent = targname; } names = (char **) xmalloc (2 * sizeof (char *)); percents = (char **) alloca (2 * sizeof (char *)); names[0] = targname; percents[0] = targpercent; names[1] = percents[1] = 0; if (source == 0) deps = 0; else { /* Construct the dependency name. */ len = strlen (source); depname = xmalloc (1 + len + 1); depname[0] = '%'; bcopy (source, depname + 1, len + 1); deps = (struct dep *) xmalloc (sizeof (struct dep)); deps->next = 0; deps->name = depname; } create_pattern_rule (names, percents, 0, deps, cmds, 0); } /* Convert old-style suffix rules to pattern rules. All rules for the suffixes on the .SUFFIXES list are converted and added to the chain of pattern rules. */ void convert_to_pattern () { register struct dep *d, *d2; register struct file *f; register char *rulename; register unsigned int slen, s2len; /* Compute maximum length of all the suffixes. */ maxsuffix = 0; for (d = suffix_file->deps; d != 0; d = d->next) { register unsigned int namelen = strlen (dep_name (d)); if (namelen > maxsuffix) maxsuffix = namelen; } rulename = (char *) alloca ((maxsuffix * 2) + 1); for (d = suffix_file->deps; d != 0; d = d->next) { /* Make a rule that is just the suffix, with no deps or commands. This rule exists solely to disqualify match-anything rules. */ convert_suffix_rule (dep_name (d), (char *) 0, (struct commands *) 0); f = d->file; if (f->cmds != 0) /* Record a pattern for this suffix's null-suffix rule. */ convert_suffix_rule ("", dep_name (d), f->cmds); /* Record a pattern for each of this suffix's two-suffix rules. */ slen = strlen (dep_name (d)); bcopy (dep_name (d), rulename, slen); for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next) { s2len = strlen (dep_name (d2)); if (slen == s2len && streq (dep_name (d), dep_name (d2))) continue; bcopy (dep_name (d2), rulename + slen, s2len + 1); f = lookup_file (rulename); if (f == 0 || f->cmds == 0) continue; if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a') /* A suffix rule `.X.a:' generates the pattern rule `(%.o): %.X'. It also generates a normal `%.a: %.X' rule below. */ convert_suffix_rule ((char *) 0, /* Indicates `(%.o)'. */ dep_name (d), f->cmds); /* The suffix rule `.X.Y:' is converted to the pattern rule `%.Y: %.X'. */ convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds); } } } /* Install the pattern rule RULE (whose fields have been filled in) at the end of the list (so that any rules previously defined will take precedence). If this rule duplicates a previous one (identical target and dependencies), the old one is replaced if OVERRIDE is nonzero, otherwise this new one is thrown out. When an old rule is replaced, the new one is put at the end of the list. Return nonzero if RULE is used; zero if not. */ int new_pattern_rule (rule, override) register struct rule *rule; int override; { register struct rule *r, *lastrule; register unsigned int i, j; rule->in_use = 0; rule->terminal = 0; rule->next = 0; /* Search for an identical rule. */ lastrule = 0; for (r = pattern_rules; r != 0; lastrule = r, r = r->next) for (i = 0; rule->targets[i] != 0; ++i) { for (j = 0; r->targets[j] != 0; ++j) if (!streq (rule->targets[i], r->targets[j])) break; if (r->targets[j] == 0) /* All the targets matched. */ { register struct dep *d, *d2; for (d = rule->deps, d2 = r->deps; d != 0 && d2 != 0; d = d->next, d2 = d2->next) if (!streq (dep_name (d), dep_name (d2))) break; if (d == 0 && d2 == 0) /* All the dependencies matched. */ if (override) { /* Remove the old rule. */ freerule (r, lastrule); /* Install the new one. */ if (pattern_rules == 0) pattern_rules = rule; else last_pattern_rule->next = rule; last_pattern_rule = rule; /* We got one. Stop looking. */ goto matched; } else { /* The old rule stays intact. Destroy the new one. */ freerule (rule, (struct rule *) 0); return 0; } } } matched:; if (r == 0) { /* There was no rule to replace. */ if (pattern_rules == 0) pattern_rules = rule; else last_pattern_rule->next = rule; last_pattern_rule = rule; } return 1; } /* Install an implicit pattern rule based on the three text strings in the structure P points to. These strings come from one of the arrays of default implicit pattern rules. TERMINAL specifies what the `terminal' field of the rule should be. */ void install_pattern_rule (p, terminal) struct pspec *p; int terminal; { register struct rule *r; char *ptr; r = (struct rule *) xmalloc (sizeof (struct rule)); r->targets = (char **) xmalloc (2 * sizeof (char *)); r->suffixes = (char **) xmalloc (2 * sizeof (char *)); r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); r->targets[1] = 0; r->suffixes[1] = 0; r->lens[1] = 0; r->lens[0] = strlen (p->target); /* These will all be string literals, but we malloc space for them anyway because somebody might want to free them later on. */ r->targets[0] = savestring (p->target, r->lens[0]); r->suffixes[0] = find_percent (r->targets[0]); if (r->suffixes[0] == 0) /* Programmer-out-to-lunch error. */ abort (); else ++r->suffixes[0]; ptr = p->dep; r->deps = (struct dep *) multi_glob (parse_file_seq (&ptr, '\0', sizeof (struct dep), 1), sizeof (struct dep)); if (new_pattern_rule (r, 0)) { r->terminal = terminal; r->cmds = (struct commands *) xmalloc (sizeof (struct commands)); r->cmds->filename = 0; r->cmds->lineno = 0; /* These will all be string literals, but we malloc space for them anyway because somebody might want to free them later. */ r->cmds->commands = savestring (p->commands, strlen (p->commands)); r->cmds->command_lines = 0; } } /* Free all the storage used in RULE and take it out of the pattern_rules chain. LASTRULE is the rule whose next pointer points to RULE. */ static void freerule (rule, lastrule) register struct rule *rule, *lastrule; { struct rule *next = rule->next; register unsigned int i; for (i = 0; rule->targets[i] != 0; ++i) free (rule->targets[i]); free ((char *) rule->targets); free ((char *) rule->suffixes); free ((char *) rule->lens); /* We can't free the storage for the commands because there are ways that they could be in more than one place: * If the commands came from a suffix rule, they could also be in the `struct file's for other suffix rules or plain targets given on the same makefile line. * If two suffixes that together make a two-suffix rule were each given twice in the .SUFFIXES list, and in the proper order, two identical pattern rules would be created and the second one would be discarded here, but both would contain the same `struct commands' pointer from the `struct file' for the suffix rule. */ free ((char *) rule); if (pattern_rules == rule) if (lastrule != 0) abort (); else pattern_rules = next; else if (lastrule != 0) lastrule->next = next; if (last_pattern_rule == rule) last_pattern_rule = lastrule; } /* Create a new pattern rule with the targets in the nil-terminated array TARGETS. If TARGET_PERCENTS is not nil, it is an array of pointers into the elements of TARGETS, where the `%'s are. The new rule has dependencies DEPS and commands from COMMANDS. It is a terminal rule if TERMINAL is nonzero. This rule overrides identical rules with different commands if OVERRIDE is nonzero. The storage for TARGETS and its elements is used and must not be freed until the rule is destroyed. The storage for TARGET_PERCENTS is not used; it may be freed. */ void create_pattern_rule (targets, target_percents, terminal, deps, commands, override) char **targets, **target_percents; int terminal; struct dep *deps; struct commands *commands; int override; { register struct rule *r = (struct rule *) xmalloc (sizeof (struct rule)); register unsigned int max_targets, i; r->cmds = commands; r->deps = deps; r->targets = targets; max_targets = 2; r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); r->suffixes = (char **) xmalloc (2 * sizeof (char *)); for (i = 0; targets[i] != 0; ++i) { if (i == max_targets - 1) { max_targets += 5; r->lens = (unsigned int *) xrealloc ((char *) r->lens, max_targets * sizeof (unsigned int)); r->suffixes = (char **) xrealloc ((char *) r->suffixes, max_targets * sizeof (char *)); } r->lens[i] = strlen (targets[i]); r->suffixes[i] = (target_percents == 0 ? find_percent (targets[i]) : target_percents[i]) + 1; if (r->suffixes[i] == 0) abort (); } if (i < max_targets - 1) { r->lens = (unsigned int *) xrealloc ((char *) r->lens, (i + 1) * sizeof (unsigned int)); r->suffixes = (char **) xrealloc ((char *) r->suffixes, (i + 1) * sizeof (char *)); } if (new_pattern_rule (r, override)) r->terminal = terminal; } /* Print the data base of rules. */ static void /* Useful to call from gdb. */ print_rule (r) struct rule *r; { register unsigned int i; register struct dep *d; for (i = 0; r->targets[i] != 0; ++i) { fputs (r->targets[i], stdout); if (r->targets[i + 1] != 0) putchar (' '); else putchar (':'); } if (r->terminal) putchar (':'); for (d = r->deps; d != 0; d = d->next) printf (" %s", dep_name (d)); putchar ('\n'); if (r->cmds != 0) print_commands (r->cmds); } void print_rule_data_base () { register unsigned int rules, terminal; register struct rule *r; puts ("\n# Implicit Rules"); rules = terminal = 0; for (r = pattern_rules; r != 0; r = r->next) { ++rules; putchar ('\n'); print_rule (r); if (r->terminal) ++terminal; } if (rules == 0) puts ("\n# No implicit rules."); else { printf ("\n# %u implicit rules, %u", rules, terminal); #ifndef NO_FLOAT printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0); #endif puts (" terminal."); } if (num_pattern_rules != rules) fatal ("BUG: num_pattern_rules wrong! %u != %u", num_pattern_rules, rules); } make-3.70/implicit.c 666 12241 13 44500 5465716152 7465 /* Implicit rule searching for GNU Make. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "rule.h" #include "dep.h" #include "file.h" static int pattern_search (); /* For a FILE which has no commands specified, try to figure out some from the implicit pattern rules. Returns 1 if a suitable implicit rule was found, after modifying FILE to contain the appropriate commands and deps, or returns 0 if no implicit rule was found. */ int try_implicit_rule (file, depth) struct file *file; unsigned int depth; { DEBUGPR ("Looking for an implicit rule for `%s'.\n"); /* The order of these searches was previously reversed. My logic now is that since the non-archive search uses more information in the target (the archive search omits the archive name), it is more specific and should come first. */ if (pattern_search (file, 0, depth, 0)) return 1; #ifndef NO_ARCHIVES /* If this is an archive member reference, use just the archive member name to search for implicit rules. */ if (ar_name (file->name)) { DEBUGPR ("Looking for archive-member implicit rule for `%s'.\n"); if (pattern_search (file, 1, depth, 0)) return 1; } #endif return 0; } #define DEBUGP2(msg, a1, a2) \ do { \ if (debug_flag) \ { print_spaces (depth); printf (msg, a1, a2); fflush (stdout); } \ } while (0) /* Search the pattern rules for a rule with an existing dependency to make FILE. If a rule is found, the appropriate commands and deps are put in FILE and 1 is returned. If not, 0 is returned. If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for "(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into directory and filename parts. If an intermediate file is found by pattern search, the intermediate file is set up as a target by the recursive call and is also made a dependency of FILE. DEPTH is used for debugging messages. */ static int pattern_search (file, archive, depth, recursions) struct file *file; int archive; unsigned int depth; unsigned int recursions; { /* Filename we are searching for a rule for. */ char *filename = archive ? index (file->name, '(') : file->name; /* Length of FILENAME. */ unsigned int namelen = strlen (filename); /* The last slash in FILENAME (or nil if there is none). */ char *lastslash; /* This is a file-object used as an argument in recursive calls. It never contains any data except during a recursive call. */ struct file *intermediate_file = 0; /* List of dependencies found recursively. */ struct file **intermediate_files = (struct file **) alloca (max_pattern_deps * sizeof (struct file *)); /* List of the patterns used to find intermediate files. */ char **intermediate_patterns = (char **) alloca (max_pattern_deps * sizeof (char *)); /* This buffer records all the dependencies actually found for a rule. */ char **found_files = (char **) alloca (max_pattern_deps * sizeof (char *)); /* Number of dep names now in FOUND_FILES. */ unsigned int deps_found; /* Names of possible dependencies are constructed in this buffer. */ register char *depname = (char *) alloca (namelen + max_pattern_dep_length); /* The start and length of the stem of FILENAME for the current rule. */ register char *stem; register unsigned int stemlen; /* Buffer in which we store all the rules that are possibly applicable. */ struct rule **tryrules = (struct rule **) alloca (num_pattern_rules * max_pattern_targets * sizeof (struct rule *)); /* Number of valid elements in TRYRULES. */ unsigned int nrules; /* The numbers of the rule targets of each rule in TRYRULES that matched the target file. */ unsigned int *matches = (unsigned int *) alloca (num_pattern_rules * sizeof (unsigned int)); /* Each element is nonzero if LASTSLASH was used in matching the corresponding element of TRYRULES. */ char *checked_lastslash = (char *) alloca (num_pattern_rules * sizeof (char)); /* The index in TRYRULES of the rule we found. */ unsigned int foundrule; /* Nonzero if should consider intermediate files as dependencies. */ int intermed_ok; /* Nonzero if we have matched a pattern-rule target that is not just `%'. */ int specific_rule_matched = 0; register unsigned int i; register struct rule *rule; register struct dep *dep; char *p; #ifndef NO_ARCHIVES if (archive || ar_name (filename)) lastslash = 0; else #endif { /* Set LASTSLASH to point at the last slash in FILENAME but not counting any slash at the end. (foo/bar/ counts as bar/ in directory foo/, not empty in directory foo/bar/.) */ lastslash = rindex (filename, '/'); if (lastslash != 0 && lastslash[1] == '\0') lastslash = 0; } /* First see which pattern rules match this target and may be considered. Put them in TRYRULES. */ nrules = 0; for (rule = pattern_rules; rule != 0; rule = rule->next) { /* If the pattern rule has deps but no commands, ignore it. Users cancel built-in rules by redefining them without commands. */ if (rule->deps != 0 && rule->cmds == 0) continue; /* If this rule is in use by a parent pattern_search, don't use it here. */ if (rule->in_use) { DEBUGP2 ("Avoiding implicit rule recursion.%s%s\n", "", ""); continue; } for (i = 0; rule->targets[i] != 0; ++i) { char *target = rule->targets[i]; char *suffix = rule->suffixes[i]; int check_lastslash; /* Rules that can match any filename and are not terminal are ignored if we're recursing, so that they cannot be intermediate files. */ if (recursions > 0 && target[1] == '\0' && !rule->terminal) continue; if (rule->lens[i] > namelen) /* It can't possibly match. */ continue; /* From the lengths of the filename and the pattern parts, find the stem: the part of the filename that matches the %. */ stem = filename + (suffix - target - 1); stemlen = namelen - rule->lens[i] + 1; /* Set CHECK_LASTSLASH if FILENAME contains a directory prefix and the target pattern does not contain a slash. */ check_lastslash = lastslash != 0 && index (target, '/') == 0; if (check_lastslash) { /* In that case, don't include the directory prefix in STEM here. */ unsigned int difference = lastslash - filename + 1; if (difference > stemlen) continue; stemlen -= difference; stem += difference; } /* Check that the rule pattern matches the text before the stem. */ if (check_lastslash) { if (stem > (lastslash + 1) && strncmp (target, lastslash + 1, stem - lastslash - 1)) continue; } else if (stem > filename && strncmp (target, filename, stem - filename)) continue; /* Check that the rule pattern matches the text after the stem. We could test simply use streq, but this way we compare the first two characters immediately. This saves time in the very common case where the first character matches because it is a period. */ if (*suffix != stem[stemlen] || (*suffix != '\0' && !streq (&suffix[1], &stem[stemlen + 1]))) continue; /* Record if we match a rule that not all filenames will match. */ if (target[1] != '\0') specific_rule_matched = 1; /* A rule with no dependencies and no commands exists solely to set specific_rule_matched when it matches. Don't try to use it. */ if (rule->deps == 0 && rule->cmds == 0) continue; /* Record this rule in TRYRULES and the index of the matching target in MATCHES. If several targets of the same rule match, that rule will be in TRYRULES more than once. */ tryrules[nrules] = rule; matches[nrules] = i; checked_lastslash[nrules] = check_lastslash; ++nrules; } } /* If we have found a matching rule that won't match all filenames, retroactively reject any "terminal" rules that do always match. */ if (specific_rule_matched) for (i = 0; i < nrules; ++i) if (!tryrules[i]->terminal) { register unsigned int j; for (j = 0; tryrules[i]->targets[j] != 0; ++j) if (tryrules[i]->targets[j][1] == '\0') break; if (tryrules[i]->targets[j] != 0) tryrules[i] = 0; } /* Try each rule once without intermediate files, then once with them. */ for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok) { /* Try each pattern rule till we find one that applies. If it does, copy the names of its dependencies (as substituted) and store them in FOUND_FILES. DEPS_FOUND is the number of them. */ for (i = 0; i < nrules; i++) { int check_lastslash; rule = tryrules[i]; /* RULE is nil when we discover that a rule, already placed in TRYRULES, should not be applied. */ if (rule == 0) continue; /* Reject any terminal rules if we're looking to make intermediate files. */ if (intermed_ok && rule->terminal) continue; /* Mark this rule as in use so a recursive pattern_search won't try to use it. */ rule->in_use = 1; /* From the lengths of the filename and the matching pattern parts, find the stem: the part of the filename that matches the %. */ stem = filename + (rule->suffixes[matches[i]] - rule->targets[matches[i]]) - 1; stemlen = namelen - rule->lens[matches[i]] + 1; check_lastslash = checked_lastslash[i]; if (check_lastslash) { stem += lastslash - filename + 1; stemlen -= (lastslash - filename) + 1; } DEBUGP2 ("Trying pattern rule with stem `%.*s'.\n", (int) stemlen, stem); /* Try each dependency; see if it "exists". */ deps_found = 0; for (dep = rule->deps; dep != 0; dep = dep->next) { /* If the dependency name has a %, substitute the stem. */ p = index (dep_name (dep), '%'); if (p != 0) { register unsigned int i; if (check_lastslash) { /* Copy directory name from the original FILENAME. */ i = lastslash - filename + 1; bcopy (filename, depname, i); } else i = 0; bcopy (dep_name (dep), depname + i, p - dep_name (dep)); i += p - dep_name (dep); bcopy (stem, depname + i, stemlen); i += stemlen; strcpy (depname + i, p + 1); p = depname; } else p = dep_name (dep); /* P is now the actual dependency name as substituted. */ if (file_impossible_p (p)) { /* If this dependency has already been ruled "impossible", then the rule fails and don't bother trying it on the second pass either since we know that will fail too. */ DEBUGP2 ("Rejecting impossible %s dependency `%s'.\n", p == depname ? "implicit" : "rule", p); tryrules[i] = 0; break; } intermediate_files[deps_found] = 0; DEBUGP2 ("Trying %s dependency `%s'.\n", p == depname ? "implicit" : "rule", p); /* The DEP->changed flag says that this dependency resides in a nonexistent directory. So we normally can skip looking for the file. However, if CHECK_LASTSLASH is set, then the dependency file we are actually looking for is in a different directory (the one gotten by prepending FILENAME's directory), so it might actually exist. */ if ((!dep->changed || check_lastslash) && (lookup_file (p) != 0 || file_exists_p (p))) { found_files[deps_found++] = savestring (p, strlen (p)); continue; } /* This code, given FILENAME = "lib/foo.o", dependency name "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */ if (vpath_search (&p, (time_t *) 0)) { DEBUGP2 ("Found dependency as `%s'.%s\n", p, ""); found_files[deps_found++] = p; continue; } /* We could not find the file in any place we should look. Try to make this dependency as an intermediate file, but only on the second pass. */ if (intermed_ok) { if (intermediate_file == 0) intermediate_file = (struct file *) alloca (sizeof (struct file)); DEBUGP2 ("Looking for a rule with %s file `%s'.\n", "intermediate", p); bzero ((char *) intermediate_file, sizeof (struct file)); intermediate_file->name = p; if (pattern_search (intermediate_file, 0, depth + 1, recursions + 1)) { p = savestring (p, strlen (p)); intermediate_patterns[deps_found] = intermediate_file->name; intermediate_file->name = p; intermediate_files[deps_found] = intermediate_file; intermediate_file = 0; /* Allocate an extra copy to go in FOUND_FILES, because every elt of FOUND_FILES is consumed or freed later. */ found_files[deps_found] = savestring (p, strlen (p)); ++deps_found; continue; } /* If we have tried to find P as an intermediate file and failed, mark that name as impossible so we won't go through the search again later. */ file_impossible (p); } /* A dependency of this rule does not exist. Therefore, this rule fails. */ break; } /* This rule is no longer `in use' for recursive searches. */ rule->in_use = 0; if (dep != 0) { /* This pattern rule does not apply. If some of its dependencies succeeded, free the data structure describing them. */ while (deps_found-- > 0) { register struct file *f = intermediate_files[deps_found]; free (found_files[deps_found]); if (f != 0 && (f->stem < f->name || f->stem > f->name + strlen (f->name))) free (f->stem); } } else /* This pattern rule does apply. Stop looking for one. */ break; } /* If we found an applicable rule without intermediate files, don't try with them. */ if (i < nrules) break; rule = 0; } /* RULE is nil if the loop went all the way through the list and everything failed. */ if (rule == 0) return 0; foundrule = i; /* If we are recursing, store the pattern that matched FILENAME in FILE->name for use in upper levels. */ if (recursions > 0) /* Kludge-o-matic */ file->name = rule->targets[matches[foundrule]]; /* FOUND_FILES lists the dependencies for the rule we found. This includes the intermediate files, if any. Convert them into entries on the deps-chain of FILE. */ while (deps_found-- > 0) { register char *s; if (intermediate_files[deps_found] != 0) { /* If we need to use an intermediate file, make sure it is entered as a target, with the info that was found for it in the recursive pattern_search call. We know that the intermediate file did not already exist as a target; therefore we can assume that the deps and cmds of F below are null before we change them. */ struct file *imf = intermediate_files[deps_found]; register struct file *f = enter_file (imf->name); f->deps = imf->deps; f->cmds = imf->cmds; f->stem = imf->stem; imf = lookup_file (intermediate_patterns[deps_found]); if (imf != 0 && imf->precious) f->precious = 1; f->intermediate = 1; f->tried_implicit = 1; for (dep = f->deps; dep != 0; dep = dep->next) { dep->file = enter_file (dep->name); dep->name = 0; dep->file->tried_implicit |= dep->changed; } num_intermediates++; } dep = (struct dep *) xmalloc (sizeof (struct dep)); s = found_files[deps_found]; if (recursions == 0) { dep->name = 0; dep->file = lookup_file (s); if (dep->file == 0) /* enter_file consumes S's storage. */ dep->file = enter_file (s); else /* A copy of S is already allocated in DEP->file->name. So we can free S. */ free (s); } else { dep->name = s; dep->file = 0; dep->changed = 0; } if (intermediate_files[deps_found] == 0 && tryrules[foundrule]->terminal) { /* If the file actually existed (was not an intermediate file), and the rule that found it was a terminal one, then we want to mark the found file so that it will not have implicit rule search done for it. If we are not entering a `struct file' for it now, we indicate this with the `changed' flag. */ if (dep->file == 0) dep->changed = 1; else dep->file->tried_implicit = 1; } dep->next = file->deps; file->deps = dep; } if (!checked_lastslash[foundrule]) file->stem = stem[stemlen] == '\0' ? stem : savestring (stem, stemlen); else { /* We want to prepend the directory from the original FILENAME onto the stem. */ file->stem = (char *) xmalloc (((lastslash + 1) - filename) + stemlen + 1); bcopy (filename, file->stem, (lastslash + 1) - filename); bcopy (stem, file->stem + ((lastslash + 1) - filename), stemlen); file->stem[((lastslash + 1) - filename) + stemlen] = '\0'; } file->cmds = rule->cmds; /* Put the targets other than the one that matched into FILE's `also_make' member. */ /* If there was only one target, there is nothing to do. */ if (rule->targets[1] != 0) for (i = 0; rule->targets[i] != 0; ++i) if (i != matches[foundrule]) { struct dep *new = (struct dep *) xmalloc (sizeof (struct dep)); new->name = p = (char *) xmalloc (rule->lens[i] + stemlen + 1); bcopy (rule->targets[i], p, rule->suffixes[i] - rule->targets[i] - 1); p += rule->suffixes[i] - rule->targets[i] - 1; bcopy (stem, p, stemlen); p += stemlen; bcopy (rule->suffixes[i], p, rule->lens[i] - (rule->suffixes[i] - rule->targets[i]) + 1); new->file = enter_file (new->name); new->next = file->also_make; file->also_make = new; } return 1; } make-3.70/default.c 666 12241 13 23340 5503433535 7270 /* Data base of default implicit rules for GNU Make. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "rule.h" #include "dep.h" #include "file.h" #include "commands.h" #include "variable.h" /* This is the default list of suffixes for suffix rules. `.s' must come last, so that a `.o' file will be made from a `.c' or `.p' or ... file rather than from a .s file. */ static char default_suffixes[] = ".out .a .ln .o .c .cc .C .p .f .F .r .y .l .s .S \ .mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \ .w .ch .web .sh .elc .el"; static struct pspec default_pattern_rules[] = { { "(%)", "%", "$(AR) $(ARFLAGS) $@ $<" }, /* The X.out rules are only in BSD's default set because BSD Make has no null-suffix rules, so `foo.out' and `foo' are the same thing. */ { "%.out", "%", "@rm -f $@ \n cp $< $@" }, /* Syntax is "ctangle foo.w foo.ch foo.c". */ { "%.c", "%.w %.ch", "$(CTANGLE) $^ $@" }, { "%.tex", "%.w %.ch", "$(CWEAVE) $^ $@" }, { 0, 0, 0 } }; static struct pspec default_terminal_rules[] = { /* RCS. */ { "%", "%,v", "+$(CHECKOUT,v)" }, { "%", "RCS/%,v", "+$(CHECKOUT,v)" }, /* SCCS. */ { "%", "s.%", "$(GET) $(GFLAGS) $< $(SCCS_OUTPUT_OPTION)" }, { "%", "SCCS/s.%", "$(GET) $(GFLAGS) $< $(SCCS_OUTPUT_OPTION)" }, { 0, 0, 0 } }; static char *default_suffix_rules[] = { ".o", "$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".s", "$(LINK.s) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".S", "$(LINK.S) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".c", "$(LINK.c) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".cc", "$(LINK.cc) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".C", "$(LINK.C) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".f", "$(LINK.f) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".p", "$(LINK.p) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".F", "$(LINK.F) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".r", "$(LINK.r) $^ $(LOADLIBES) $(LDLIBS) -o $@", ".mod", "$(COMPILE.mod) -o $@ -e $@ $^", ".def.sym", "$(COMPILE.def) -o $@ $<", ".sh", "cat $< >$@ \n chmod a+x $@", ".s.o", #if !defined(M_XENIX) || defined(__GNUC__) "$(COMPILE.s) -o $@ $<", #else /* Xenix. */ "$(COMPILE.s) -o$@ $<", #endif /* Not Xenix. */ ".S.o", #if !defined(M_XENIX) || defined(__GNUC__) "$(COMPILE.S) -o $@ $<", #else /* Xenix. */ "$(COMPILE.S) -o$@ $<", #endif /* Not Xenix. */ ".c.o", "$(COMPILE.c) $< $(OUTPUT_OPTION)", ".cc.o", "$(COMPILE.cc) $< $(OUTPUT_OPTION)", ".C.o", "$(COMPILE.C) $< $(OUTPUT_OPTION)", ".f.o", "$(COMPILE.f) $< $(OUTPUT_OPTION)", ".p.o", "$(COMPILE.p) $< $(OUTPUT_OPTION)", ".F.o", "$(COMPILE.F) $< $(OUTPUT_OPTION)", ".r.o", "$(COMPILE.r) $< $(OUTPUT_OPTION)", ".mod.o", "$(COMPILE.mod) -o $@ $<", ".c.ln", "$(LINT.c) -C$* $<", ".y.ln", "$(YACC.y) $< \n $(LINT.c) -C$* y.tab.c \n $(RM) y.tab.c", ".l.ln", "@$(RM) $*.c\n $(LEX.l) $< > $*.c\n$(LINT.c) -i $*.c -o $@\n $(RM) $*.c", ".y.c", "$(YACC.y) $< \n mv -f y.tab.c $@", ".l.c", "@$(RM) $@ \n $(LEX.l) $< > $@", ".F.f", "$(PREPROCESS.F) $< $(OUTPUT_OPTION)", ".r.f", "$(PREPROCESS.r) $< $(OUTPUT_OPTION)", /* This might actually make lex.yy.c if there's no %R% directive in $*.l, but in that case why were you trying to make $*.r anyway? */ ".l.r", "$(LEX.l) $< > $@ \n mv -f lex.yy.r $@", ".S.s", "$(PREPROCESS.S) $< > $@", ".texinfo.info", "$(MAKEINFO) $< -o $@", ".texi.info", "$(MAKEINFO) $< -o $@", ".txinfo.info", "$(MAKEINFO) $< -o $@", ".tex.dvi", "$(TEX) $<", ".texinfo.dvi", "$(TEXI2DVI) $<", ".texi.dvi", "$(TEXI2DVI) $<", ".txinfo.dvi", "$(TEXI2DVI) $<", ".w.c", "$(CTANGLE) $< - $@", /* The `-' says there is no `.ch' file. */ ".web.p", "$(TANGLE) $<", ".w.tex", "$(CWEAVE) $< - $@", /* The `-' says there is no `.ch' file. */ ".web.tex", "$(WEAVE) $<", 0, 0, }; static char *default_variables[] = { "AR", "ar", "ARFLAGS", "rv", "AS", "as", "CC", "cc", "CXX", "g++", /* This expands to $(CO) $(COFLAGS) $< $@ if $@ does not exist, and to the empty string if $@ does exist. */ "CHECKOUT,v", "$(patsubst $@-noexist,$(CO) $(COFLAGS) $< $@,\ $(filter-out $@,$(firstword $(wildcard $@) $@-noexist)))", "CO", "co", "CPP", "$(CC) -E", #ifdef CRAY "CF77PPFLAGS", "-P", "CF77PP", "/lib/cpp", "CFT", "cft77", "CF", "cf77", "FC", "$(CF)", #else /* Not CRAY. */ #ifdef _IBMR2 "FC", "xlf", #else #ifdef __convex__ "FC", "fc", #else "FC", "f77", #endif /* __convex__ */ #endif /* _IBMR2 */ /* System V uses these, so explicit rules using them should work. However, there is no way to make implicit rules use them and FC. */ "F77", "$(FC)", "F77FLAGS", "$(FFLAGS)", #endif /* Cray. */ "GET", SCCS_GET, "LD", "ld", "LEX", "lex", "LINT", "lint", "M2C", "m2c", #ifdef pyr "PC", "pascal", #else #ifdef CRAY "PC", "PASCAL", "SEGLDR", "segldr", #else "PC", "pc", #endif /* CRAY. */ #endif /* pyr. */ "YACC", "yacc", /* Or "bison -y" */ "MAKEINFO", "makeinfo", "TEX", "tex", "TEXI2DVI", "texi2dvi", "WEAVE", "weave", "CWEAVE", "cweave", "TANGLE", "tangle", "CTANGLE", "ctangle", "RM", "rm -f", "LINK.o", "$(CC) $(LDFLAGS) $(TARGET_ARCH)", "COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", "LINK.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", "COMPILE.C", "$(COMPILE.cc)", "LINK.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "LINK.C", "$(LINK.cc)", "YACC.y", "$(YACC) $(YFLAGS)", "LEX.l", "$(LEX) $(LFLAGS) -t", "COMPILE.f", "$(FC) $(FFLAGS) $(TARGET_ARCH) -c", "LINK.f", "$(FC) $(FFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "COMPILE.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", "LINK.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "COMPILE.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -c", "LINK.r", "$(FC) $(FFLAGS) $(RFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "COMPILE.def", "$(M2C) $(M2FLAGS) $(DEFFLAGS) $(TARGET_ARCH)", "COMPILE.mod", "$(M2C) $(M2FLAGS) $(MODFLAGS) $(TARGET_ARCH)", "COMPILE.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", "LINK.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", "LINK.s", "$(CC) $(ASFLAGS) $(LDFLAGS) $(TARGET_MACH)", "COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)", "LINK.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_MACH)", "COMPILE.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_MACH) -c", #if !defined(M_XENIX) || defined(__GNUC__) "PREPROCESS.S", "$(CC) -E $(CPPFLAGS)", #else /* Xenix. */ "PREPROCESS.S", "$(CC) -EP $(CPPFLAGS)", #endif /* Not Xenix. */ "PREPROCESS.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -F", "PREPROCESS.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -F", "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", #ifndef NO_MINUS_C_MINUS_O #if !defined(M_XENIX) || defined(__GNUC__) "OUTPUT_OPTION", "-o $@", #else /* Xenix. */ "OUTPUT_OPTION", "-Fo$@", #endif /* Not Xenix. */ #endif #ifdef SCCS_GET_MINUS_G "SCCS_OUTPUT_OPTION", "-G$@", #endif 0, 0 }; /* Set up the default .SUFFIXES list. */ void set_default_suffixes () { suffix_file = enter_file (".SUFFIXES"); if (no_builtin_rules_flag) (void) define_variable ("SUFFIXES", 8, "", o_default, 0); else { char *p = default_suffixes; suffix_file->deps = (struct dep *) multi_glob (parse_file_seq (&p, '\0', sizeof (struct dep), 1), sizeof (struct dep)); (void) define_variable ("SUFFIXES", 8, default_suffixes, o_default, 0); } } /* Enter the default suffix rules as file rules. This used to be done in install_default_implicit_rules, but that loses because we want the suffix rules installed before reading makefiles, and thee pattern rules installed after. */ void install_default_suffix_rules () { register char **s; if (no_builtin_rules_flag) return; for (s = default_suffix_rules; *s != 0; s += 2) { register struct file *f = enter_file (s[0]); /* Don't clobber cmds given in a makefile if there were any. */ if (f->cmds == 0) { f->cmds = (struct commands *) xmalloc (sizeof (struct commands)); f->cmds->filename = 0; f->cmds->commands = s[1]; f->cmds->command_lines = 0; } } } /* Install the default pattern rules. */ void install_default_implicit_rules () { register struct pspec *p; if (no_builtin_rules_flag) return; for (p = default_pattern_rules; p->target != 0; ++p) install_pattern_rule (p, 0); for (p = default_terminal_rules; p->target != 0; ++p) install_pattern_rule (p, 1); } void define_default_variables () { register char **s; for (s = default_variables; *s != 0; s += 2) (void) define_variable (s[0], strlen (s[0]), s[1], o_default, 1); } make-3.70/variable.c 666 12241 13 52632 5434762065 7445 /* Internals of variables for GNU Make. Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "variable.h" #include "dep.h" #include "file.h" /* Hash table of all global variable definitions. */ #ifndef VARIABLE_BUCKETS #define VARIABLE_BUCKETS 523 #endif #ifndef PERFILE_VARIABLE_BUCKETS #define PERFILE_VARIABLE_BUCKETS 23 #endif #ifndef SMALL_SCOPE_VARIABLE_BUCKETS #define SMALL_SCOPE_VARIABLE_BUCKETS 13 #endif static struct variable *variable_table[VARIABLE_BUCKETS]; static struct variable_set global_variable_set = { variable_table, VARIABLE_BUCKETS }; static struct variable_set_list global_setlist = { 0, &global_variable_set }; struct variable_set_list *current_variable_set_list = &global_setlist; /* Implement variables. */ /* Define variable named NAME with value VALUE in SET. VALUE is copied. LENGTH is the length of NAME, which does not need to be null-terminated. ORIGIN specifies the origin of the variable (makefile, command line or environment). If RECURSIVE is nonzero a flag is set in the variable saying that it should be recursively re-expanded. */ static struct variable * define_variable_in_set (name, length, value, origin, recursive, set) char *name; unsigned int length; char *value; enum variable_origin origin; int recursive; struct variable_set *set; { register unsigned int i; register unsigned int hashval; register struct variable *v; hashval = 0; for (i = 0; i < length; ++i) HASH (hashval, name[i]); hashval %= set->buckets; for (v = set->table[hashval]; v != 0; v = v->next) if (*v->name == *name && !strncmp (v->name + 1, name + 1, length - 1) && v->name[length] == '\0') break; if (env_overrides && origin == o_env) origin = o_env_override; if (v != 0) { if (env_overrides && v->origin == o_env) /* V came from in the environment. Since it was defined before the switches were parsed, it wasn't affected by -e. */ v->origin = o_env_override; /* A variable of this name is already defined. If the old definition is from a stronger source than this one, don't redefine it. */ if ((int) origin >= (int) v->origin) { if (v->value != 0) free (v->value); v->value = savestring (value, strlen (value)); v->origin = origin; v->recursive = recursive; } return v; } /* Create a new variable definition and add it to the hash table. */ v = (struct variable *) xmalloc (sizeof (struct variable)); v->name = savestring (name, length); v->value = savestring (value, strlen (value)); v->origin = origin; v->recursive = recursive; v->expanding = 0; v->export = v_default; v->next = set->table[hashval]; set->table[hashval] = v; return v; } /* Define a variable in the current variable set. */ struct variable * define_variable (name, length, value, origin, recursive) char *name; unsigned int length; char *value; enum variable_origin origin; int recursive; { return define_variable_in_set (name, length, value, origin, recursive, current_variable_set_list->set); } /* Define a variable in FILE's variable set. */ struct variable * define_variable_for_file (name, length, value, origin, recursive, file) char *name; unsigned int length; char *value; enum variable_origin origin; int recursive; struct file *file; { return define_variable_in_set (name, length, value, origin, recursive, file->variables->set); } /* Lookup a variable whose name is a string starting at NAME and with LENGTH chars. NAME need not be null-terminated. Returns address of the `struct variable' containing all info on the variable, or nil if no such variable is defined. */ struct variable * lookup_variable (name, length) char *name; unsigned int length; { register struct variable_set_list *setlist; register unsigned int i; register unsigned int rawhash = 0; for (i = 0; i < length; ++i) HASH (rawhash, name[i]); for (setlist = current_variable_set_list; setlist != 0; setlist = setlist->next) { register struct variable_set *set = setlist->set; register unsigned int hashval = rawhash % set->buckets; register struct variable *v; for (v = set->table[hashval]; v != 0; v = v->next) if (*v->name == *name && !strncmp (v->name + 1, name + 1, length - 1) && v->name[length] == 0) return v; } return 0; } /* Initialize FILE's variable set list. If FILE already has a variable set list, the topmost variable set is left intact, but the the rest of the chain is replaced with FILE->parent's setlist. */ void initialize_file_variables (file) struct file *file; { register struct variable_set_list *l = file->variables; if (l == 0) { l = (struct variable_set_list *) xmalloc (sizeof (struct variable_set_list)); l->set = (struct variable_set *) xmalloc (sizeof (struct variable_set)); l->set->buckets = PERFILE_VARIABLE_BUCKETS; l->set->table = (struct variable **) xmalloc (l->set->buckets * sizeof (struct variable *)); bzero ((char *) l->set->table, l->set->buckets * sizeof (struct variable *)); file->variables = l; } if (file->parent == 0) l->next = &global_setlist; else { if (file->parent->variables == 0) initialize_file_variables (file->parent); l->next = file->parent->variables; } } /* Pop the top set off the current variable set list, and free all its storage. */ void pop_variable_scope () { register struct variable_set_list *setlist = current_variable_set_list; register struct variable_set *set = setlist->set; register unsigned int i; current_variable_set_list = setlist->next; free ((char *) setlist); for (i = 0; i < set->buckets; ++i) { register struct variable *next = set->table[i]; while (next != 0) { register struct variable *v = next; next = v->next; free (v->name); free ((char *) v); } } free ((char *) set->table); free ((char *) set); } /* Create a new variable set and push it on the current setlist. */ void push_new_variable_scope () { register struct variable_set_list *setlist; register struct variable_set *set; set = (struct variable_set *) xmalloc (sizeof (struct variable_set)); set->buckets = SMALL_SCOPE_VARIABLE_BUCKETS; set->table = (struct variable **) xmalloc (set->buckets * sizeof (struct variable *)); bzero ((char *) set->table, set->buckets * sizeof (struct variable *)); setlist = (struct variable_set_list *) xmalloc (sizeof (struct variable_set_list)); setlist->set = set; setlist->next = current_variable_set_list; current_variable_set_list = setlist; } /* Merge SET1 into SET0, freeing unused storage in SET1. */ static void merge_variable_sets (set0, set1) struct variable_set *set0, *set1; { register unsigned int bucket1; for (bucket1 = 0; bucket1 < set1->buckets; ++bucket1) { register struct variable *v1 = set1->table[bucket1]; while (v1 != 0) { struct variable *next = v1->next; unsigned int bucket0; register struct variable *v0; if (set1->buckets >= set0->buckets) bucket0 = bucket1; else { register char *n; bucket0 = 0; for (n = v1->name; *n != '\0'; ++n) HASH (bucket0, *n); } bucket0 %= set0->buckets; for (v0 = set0->table[bucket0]; v0 != 0; v0 = v0->next) if (streq (v0->name, v1->name)) break; if (v0 == 0) { /* There is no variable in SET0 with the same name. */ v1->next = set0->table[bucket0]; set0->table[bucket0] = v1; } else { /* The same variable exists in both sets. SET0 takes precedence. */ free (v1->value); free ((char *) v1); } v1 = next; } } } /* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */ void merge_variable_set_lists (setlist0, setlist1) struct variable_set_list **setlist0, *setlist1; { register struct variable_set_list *list0 = *setlist0; struct variable_set_list *last0 = 0; while (setlist1 != 0 && list0 != 0) { struct variable_set_list *next = setlist1; setlist1 = setlist1->next; merge_variable_sets (list0->set, next->set); free ((char *) next); last0 = list0; list0 = list0->next; } if (setlist1 != 0) { if (last0 == 0) *setlist0 = setlist1; else last0->next = setlist1; } } /* Define the automatic variables, and record the addresses of their structures so we can change their values quickly. */ void define_automatic_variables () { extern char default_shell[]; register struct variable *v; char buf[200]; sprintf (buf, "%u", makelevel); (void) define_variable ("MAKELEVEL", 9, buf, o_env, 0); sprintf (buf, "%s%s%s", version_string, (remote_description == 0 || remote_description[0] == '\0') ? "" : "-", (remote_description == 0 || remote_description[0] == '\0') ? "" : remote_description); (void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0); /* This won't override any definition, but it will provide one if there isn't one there. */ v = define_variable ("SHELL", 5, default_shell, o_default, 0); v->export = v_export; /* Always export SHELL. */ /* Don't let SHELL come from the environment. */ if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override) { free (v->value); v->origin = o_file; v->value = savestring (default_shell, strlen (default_shell)); } /* Make sure MAKEFILES gets exported if it is set. */ v = define_variable ("MAKEFILES", 9, "", o_default, 0); v->export = v_ifset; /* Define the magic D and F variables in terms of the automatic variables they are variations of. */ define_variable ("@D", 2, "$(dir $@)", o_automatic, 1); define_variable ("%D", 2, "$(dir $%)", o_automatic, 1); define_variable ("*D", 2, "$(dir $*)", o_automatic, 1); define_variable ("variables; /* Find the lowest number of buckets in any set in the list. */ s = set_list; buckets = s->set->buckets; for (s = s->next; s != 0; s = s->next) if (s->set->buckets < buckets) buckets = s->set->buckets; /* Find the hash value of the bucket `MAKELEVEL' will fall into. */ { char *p = "MAKELEVEL"; mklev_hash = 0; while (*p != '\0') HASH (mklev_hash, *p++); } /* Temporarily allocate a table with that many buckets. */ table = (struct variable_bucket **) alloca (buckets * sizeof (struct variable_bucket *)); bzero ((char *) table, buckets * sizeof (struct variable_bucket *)); /* Run through all the variable sets in the list, accumulating variables in TABLE. */ nvariables = 0; for (s = set_list; s != 0; s = s->next) { register struct variable_set *set = s->set; for (i = 0; i < set->buckets; ++i) { register struct variable *v; for (v = set->table[i]; v != 0; v = v->next) { unsigned int j = i % buckets; register struct variable_bucket *ov; register char *p = v->name; if (i == mklev_hash % set->buckets && streq (v->name, "MAKELEVEL")) /* Don't include MAKELEVEL because it will be added specially at the end. */ continue; switch (v->export) { case v_default: if (v->origin == o_default || v->origin == o_automatic) /* Only export default variables by explicit request. */ continue; if (! export_all_variables && v->origin != o_command && v->origin != o_env && v->origin != o_env_override) continue; if (*p != '_' && (*p < 'A' || *p > 'Z') && (*p < 'a' || *p > 'z')) continue; for (++p; *p != '\0'; ++p) if (*p != '_' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9')) break; if (*p != '\0') continue; case v_export: break; case v_noexport: continue; case v_ifset: if (v->origin == o_default) continue; break; } for (ov = table[j]; ov != 0; ov = ov->next) if (streq (v->name, ov->variable->name)) break; if (ov == 0) { register struct variable_bucket *entry; entry = (struct variable_bucket *) alloca (sizeof (struct variable_bucket)); entry->next = table[j]; entry->variable = v; table[j] = entry; ++nvariables; } } } } result = (char **) xmalloc ((nvariables + 2) * sizeof (char *)); nvariables = 0; for (i = 0; i < buckets; ++i) { register struct variable_bucket *b; for (b = table[i]; b != 0; b = b->next) { register struct variable *v = b->variable; /* If V is recursively expanded and didn't come from the environment, expand its value. If it came from the environment, it should go back into the environment unchanged. */ if (v->recursive && v->origin != o_env && v->origin != o_env_override) { char *value = recursively_expand (v); result[nvariables++] = concat (v->name, "=", value); free (value); } else result[nvariables++] = concat (v->name, "=", v->value); } } result[nvariables] = (char *) xmalloc (100); (void) sprintf (result[nvariables], "MAKELEVEL=%u", makelevel + 1); result[++nvariables] = 0; return result; } /* Try to interpret LINE (a null-terminated string) as a variable definition. ORIGIN may be o_file, o_override, o_env, o_env_override, or o_command specifying that the variable definition comes from a makefile, an override directive, the environment with or without the -e switch, or the command line. A variable definition has the form "name = value" or "name := value". Any whitespace around the "=" or ":=" is removed. The first form defines a variable that is recursively re-evaluated. The second form defines a variable whose value is variable-expanded at the time of definition and then is evaluated only once at the time of expansion. If a variable was defined, a pointer to its `struct variable' is returned. If not, NULL is returned. */ struct variable * try_variable_definition (filename, lineno, line, origin) char *filename; unsigned int lineno; char *line; enum variable_origin origin; { register int c; register char *p = line; register char *beg; register char *end; enum { bogus, simple, recursive, append } flavor = bogus; char *name, *expanded_name, *value; struct variable *v; while (1) { c = *p++; if (c == '\0' || c == '#') return 0; if (c == '=') { end = p - 1; flavor = recursive; break; } else if (c == ':') if (*p == '=') { end = p++ - 1; flavor = simple; break; } else /* A colon other than := is a rule line, not a variable defn. */ return 0; else if (c == '+' && *p == '=') { end = p++ - 1; flavor = append; break; } } while (isblank (end[-1])) --end; beg = next_token (line); p = next_token (p); /* Expand the name, so "$(foo)bar = baz" works. */ name = (char *) alloca (end - beg + 1); bcopy (beg, name, end - beg); name[end - beg] = '\0'; expanded_name = allocated_variable_expand (name); if (expanded_name[0] == '\0') { if (filename == 0) fatal ("empty variable name"); else makefile_fatal (filename, lineno, "empty variable name"); } /* Calculate the variable's new value in VALUE. */ switch (flavor) { case bogus: /* Should not be possible. */ abort (); break; case simple: /* A simple variable definition "var := value". Expand the value. */ value = variable_expand (p); break; case recursive: /* A recursive variable definition "var = value". The value is used verbatim. */ value = p; break; case append: /* An appending variable definition "var += value". Extract the old value and append the new one. */ v = lookup_variable (expanded_name, strlen (expanded_name)); if (v == 0) { /* There was no old value. This becomes a normal recursive definition. */ value = p; flavor = recursive; } else { /* Paste the old and new values together in VALUE. */ unsigned int oldlen, newlen; if (v->recursive) /* The previous definition of the variable was recursive. The new value comes from the unexpanded old and new values. */ flavor = recursive; else /* The previous definition of the variable was simple. The new value comes from the old value, which was expanded when it was set; and from the expanded new value. */ p = variable_expand (p); oldlen = strlen (v->value); newlen = strlen (p); value = (char *) alloca (oldlen + 1 + newlen + 1); bcopy (v->value, value, oldlen); value[oldlen] = ' '; bcopy (p, &value[oldlen + 1], newlen + 1); } } v = define_variable (expanded_name, strlen (expanded_name), value, origin, flavor == recursive); free (expanded_name); return v; } /* Print information for variable V, prefixing it with PREFIX. */ static void print_variable (v, prefix) register struct variable *v; char *prefix; { char *origin; switch (v->origin) { case o_default: origin = "default"; break; case o_env: origin = "environment"; break; case o_file: origin = "makefile"; break; case o_env_override: origin = "environment under -e"; break; case o_command: origin = "command line"; break; case o_override: origin = "`override' directive"; break; case o_automatic: origin = "automatic"; break; case o_invalid: default: abort (); break; } printf ("# %s\n", origin); fputs (prefix, stdout); /* Is this a `define'? */ if (v->recursive && index (v->value, '\n') != 0) printf ("define %s\n%s\nendef\n", v->name, v->value); else { register char *p; printf ("%s %s= ", v->name, v->recursive ? "" : ":"); /* Check if the value is just whitespace. */ p = next_token (v->value); if (p != v->value && *p == '\0') /* All whitespace. */ printf ("$(subst ,,%s)", v->value); else if (v->recursive) fputs (v->value, stdout); else /* Double up dollar signs. */ for (p = v->value; *p != '\0'; ++p) { if (*p == '$') putchar ('$'); putchar (*p); } putchar ('\n'); } } /* Print all the variables in SET. PREFIX is printed before the actual variable definitions (everything else is comments). */ static void print_variable_set (set, prefix) register struct variable_set *set; char *prefix; { register unsigned int i, nvariables, per_bucket; register struct variable *v; per_bucket = nvariables = 0; for (i = 0; i < set->buckets; ++i) { register unsigned int this_bucket = 0; for (v = set->table[i]; v != 0; v = v->next) { ++this_bucket; print_variable (v, prefix); } nvariables += this_bucket; if (this_bucket > per_bucket) per_bucket = this_bucket; } if (nvariables == 0) puts ("# No variables."); else { printf ("# %u variables in %u hash buckets.\n", nvariables, set->buckets); #ifndef NO_FLOAT printf ("# average of %.1f variables per bucket, \ max %u in one bucket.\n", (double) nvariables / (double) set->buckets, per_bucket); #endif } } /* Print the data base of variables. */ void print_variable_data_base () { puts ("\n# Variables\n"); print_variable_set (&global_variable_set, ""); } /* Print all the local variables of FILE. */ void print_file_variables (file) struct file *file; { if (file->variables != 0) print_variable_set (file->variables->set, "# "); } make-3.70/expand.c 666 12241 13 30005 5440425563 7121 /* Variable expansion functions for GNU Make. Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "file.h" #include "variable.h" /* The next two describe the variable output buffer. This buffer is used to hold the variable-expansion of a line of the makefile. It is made bigger with realloc whenever it is too small. variable_buffer_length is the size currently allocated. variable_buffer is the address of the buffer. */ static unsigned int variable_buffer_length; static char *variable_buffer; /* Subroutine of variable_expand and friends: The text to add is LENGTH chars starting at STRING to the variable_buffer. The text is added to the buffer at PTR, and the updated pointer into the buffer is returned as the value. Thus, the value returned by each call to variable_buffer_output should be the first argument to the following call. */ char * variable_buffer_output (ptr, string, length) char *ptr, *string; unsigned int length; { register unsigned int newlen = length + (ptr - variable_buffer); if (newlen > variable_buffer_length) { unsigned int offset = ptr - variable_buffer; variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length ? newlen + 100 : 2 * variable_buffer_length); variable_buffer = (char *) xrealloc (variable_buffer, variable_buffer_length); ptr = variable_buffer + offset; } bcopy (string, ptr, length); return ptr + length; } /* Return a pointer to the beginning of the variable buffer. */ static char * initialize_variable_output () { /* If we don't have a variable output buffer yet, get one. */ if (variable_buffer == 0) { variable_buffer_length = 200; variable_buffer = (char *) xmalloc (variable_buffer_length); variable_buffer[0] = '\0'; } return variable_buffer; } /* Recursively expand V. The returned string is malloc'd. */ char * recursively_expand (v) register struct variable *v; { char *value; if (v->expanding) { /* Expanding V causes infinite recursion. Lose. */ if (reading_filename == 0) fatal ("Recursive variable `%s' references itself (eventually)", v->name); else makefile_fatal (reading_filename, *reading_lineno_ptr, "Recursive variable `%s' references itself (eventually)", v->name); } v->expanding = 1; value = allocated_variable_expand (v->value); v->expanding = 0; return value; } /* Warn that NAME is an undefined variable. */ #ifdef __GNUC__ __inline #endif static void warn_undefined (name, length) char *name; unsigned int length; { if (warn_undefined_variables_flag) { static const char warnmsg[] = "warning: undefined variable `%.*s'"; if (reading_filename != 0) makefile_error (reading_filename, *reading_lineno_ptr, warnmsg, length, name); else error (warnmsg, length, name); } } /* Expand a simple reference to variable NAME, which is LENGTH chars long. */ #ifdef __GNUC__ __inline #endif static char * reference_variable (o, name, length) char *o; char *name; unsigned int length; { register struct variable *v = lookup_variable (name, length); if (v == 0) warn_undefined (name, length); if (v != 0 && *v->value != '\0') { char *value = (v->recursive ? recursively_expand (v) : v->value); o = variable_buffer_output (o, value, strlen (value)); if (v->recursive) free (value); } return o; } /* Scan LINE for variable references and expansion-function calls. Build in `variable_buffer' the result of expanding the references and calls. Return the address of the resulting string, which is null-terminated and is valid only until the next time this function is called. */ char * variable_expand (line) register char *line; { register struct variable *v; register char *p, *o, *p1; p = line; o = initialize_variable_output (); while (1) { /* Copy all following uninteresting chars all at once to the variable output buffer, and skip them. Uninteresting chars end at the next $ or the end of the input. */ p1 = index (p, '$'); o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1); if (p1 == 0) break; p = p1 + 1; /* Dispatch on the char that follows the $. */ switch (*p) { case '$': /* $$ seen means output one $ to the variable output buffer. */ o = variable_buffer_output (o, p, 1); break; case '(': case '{': /* $(...) or ${...} is the general case of substitution. */ { char openparen = *p; char closeparen = (openparen == '(') ? ')' : '}'; register char *beg = p + 1; char *op, *begp; char *end; char *colon = 0; op = o; begp = p; if (handle_function (&op, &begp)) { o = op; p = begp; break; } /* Is there a variable reference inside the parens or braces? If so, expand it before expanding the entire reference. */ p1 = index (beg, closeparen); if (p1 != 0) p1 = lindex (beg, p1, '$'); if (p1 != 0 && lindex (beg, p1, ':') == 0) { /* BEG now points past the opening paren or brace. Count parens or braces until it is matched. */ int count = 0; for (p = beg; *p != '\0'; ++p) { if (*p == openparen) ++count; else if (*p == closeparen && --count < 0) break; else if (colon == 0 && count == 0 && *p == ':') /* Record where we found a colon, which indicates a substitution reference. We want to expand the text before the reference only. */ colon = p; } /* If COUNT is >= 0, there were unmatched opening parens or braces, so we go to the simple case of a variable name such as `$($(a)'. */ if (count < 0) { char *name = expand_argument (beg, colon == 0 ? p : colon); unsigned int namelen = strlen (name); if (colon == 0) { /* This is a simple reference to the expanded name. */ o = reference_variable (o, name, namelen); free (name); break; } else { /* This is a substitution reference to the expanded name. We replace the pending text with a copy containing the expanded name in place of the original name, and then fall through to the normal substitution reference code below. */ unsigned int restlen = strlen (colon) + 1; beg = (char *) alloca (namelen + restlen); bcopy (name, beg, namelen); bcopy (colon, &beg[namelen], restlen); /* Point COLON into the new copy. */ colon = &beg[namelen]; } } } /* This is not a reference to a built-in function and it does not contain any variable references inside. There are several things it could be. */ if (colon == 0) colon = index (beg, ':'); if (colon != 0 && lindex (beg, colon, closeparen) == 0) { /* This is a substitution reference: $(FOO:A=B). */ int count; char *subst_beg, *subst_end, *replace_beg, *replace_end; v = lookup_variable (beg, colon - beg); if (v == 0) warn_undefined (beg, colon - beg); subst_beg = colon + 1; count = 0; for (p = subst_beg; *p != '\0'; ++p) { if (*p == openparen) ++count; else if (*p == closeparen) --count; else if (*p == '=' && count <= 0) break; } if (count > 0) /* There were unmatched opening parens. */ return initialize_variable_output (); subst_end = p; replace_beg = p + 1; count = 0; for (p = replace_beg; *p != '\0'; ++p) { if (*p == openparen) ++count; else if (*p == closeparen && --count < 0) break; } if (count > 0) /* There were unmatched opening parens. */ return initialize_variable_output (); end = p; replace_end = p; p = expand_argument (subst_beg, subst_end); p1 = expand_argument (replace_beg, replace_end); if (v != 0 && *v->value != '\0') { char *value = (v->recursive ? recursively_expand (v) : v->value); char *percent = find_percent (p); if (percent != 0) o = patsubst_expand (o, value, p, p1, percent, (char *) 0); else o = subst_expand (o, value, p, p1, strlen (p), strlen (p1), 0, 1); if (v->recursive) free (value); } free (p); free (p1); } /* No, this must be an ordinary variable reference. */ else { /* Look up the value of the variable. */ end = index (beg, closeparen); if (end == 0) { /* Unterminated variable reference. */ if (reading_filename != 0) makefile_fatal (reading_filename, *reading_lineno_ptr, "unterminated variable reference"); else fatal ("unterminated variable reference"); } o = reference_variable (o, beg, end - beg); } /* Advance p past the variable reference to resume scan. */ p = end; } break; case '\0': break; default: if (isblank (p[-1])) break; /* A $ followed by a random char is a variable reference: $a is equivalent to $(a). */ { /* We could do the expanding here, but this way avoids code repetition at a small performance cost. */ char name[5]; name[0] = '$'; name[1] = '('; name[2] = *p; name[3] = ')'; name[4] = '\0'; p1 = allocated_variable_expand (name); o = variable_buffer_output (o, p1, strlen (p1)); free (p1); } break; } if (*p == '\0') break; else ++p; } (void) variable_buffer_output (o, "", 1); return initialize_variable_output (); } /* Expand an argument for an expansion function. The text starting at STR and ending at END is variable-expanded into a null-terminated string that is returned as the value. This is done without clobbering `variable_buffer' or the current variable-expansion that is in progress. */ char * expand_argument (str, end) char *str, *end; { char *tmp; if (*end == '\0') tmp = str; else { tmp = (char *) alloca (end - str + 1); bcopy (str, tmp, end - str); tmp[end - str] = '\0'; } return allocated_variable_expand (tmp); } /* Expand LINE for FILE. Error messages refer to the file and line where FILE's commands were found. Expansion uses FILE's variable set list. */ char * variable_expand_for_file (line, file) char *line; register struct file *file; { char *result; struct variable_set_list *save; if (file == 0) return variable_expand (line); save = current_variable_set_list; current_variable_set_list = file->variables; reading_filename = file->cmds->filename; reading_lineno_ptr = &file->cmds->lineno; result = variable_expand (line); current_variable_set_list = save; reading_filename = 0; reading_lineno_ptr = 0; return result; } /* Like variable_expand_for_file, but the returned string is malloc'd. This function is called a lot. It wants to be efficient. */ char * allocated_variable_expand_for_file (line, file) char *line; struct file *file; { char *value; char *obuf = variable_buffer; unsigned int olen = variable_buffer_length; variable_buffer = 0; value = variable_expand_for_file (line, file); #if 0 /* Waste a little memory and save time. */ value = xrealloc (value, strlen (value)) #endif variable_buffer = obuf; variable_buffer_length = olen; return value; } make-3.70/function.c 666 12241 13 74373 5464310070 7477 /* Variable function expansion for GNU Make. Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "variable.h" #include "dep.h" #include "commands.h" #include "job.h" static char *string_glob (); /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is nonzero, substitutions are done only on matches which are complete whitespace-delimited words. If SUFFIX_ONLY is nonzero, substitutions are done only at the ends of whitespace-delimited words. */ char * subst_expand (o, text, subst, replace, slen, rlen, by_word, suffix_only) char *o; char *text; char *subst, *replace; unsigned int slen, rlen; int by_word, suffix_only; { register char *t = text; register char *p; if (slen == 0 && !by_word && !suffix_only) { /* The first occurrence of "" in any string is its end. */ o = variable_buffer_output (o, t, strlen (t)); if (rlen > 0) o = variable_buffer_output (o, replace, rlen); return o; } while ((p = sindex (t, 0, subst, slen)) != 0) { /* Output everything before this occurrence of the string to replace. */ if (p > t) o = variable_buffer_output (o, t, p - t); /* If we're substituting only by fully matched words, or only at the ends of words, check that this case qualifies. */ if ((by_word && ((p > t && !isblank (p[-1])) || (p[slen] != '\0' && !isblank (p[slen])))) || (suffix_only && (p[slen] != '\0' && !isblank (p[slen])))) /* Struck out. Output the rest of the string that is no longer to be replaced. */ o = variable_buffer_output (o, subst, slen); else if (rlen > 0) /* Output the replacement string. */ o = variable_buffer_output (o, replace, rlen); /* Advance T past the string to be replaced. */ t = p + slen; } /* Output everything left on the end. */ if (*t != '\0') o = variable_buffer_output (o, t, strlen (t)); return o; } /* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing strings matching PATTERN with REPLACE. If PATTERN_PERCENT is not nil, PATTERN has already been run through find_percent, and PATTERN_PERCENT is the result. If REPLACE_PERCENT is not nil, REPLACE has already been run through find_percent, and REPLACE_PERCENT is the result. */ char * patsubst_expand (o, text, pattern, replace, pattern_percent, replace_percent) char *o; char *text; register char *pattern, *replace; register char *pattern_percent, *replace_percent; { register int pattern_prepercent_len, pattern_postpercent_len; register int replace_prepercent_len, replace_postpercent_len; register char *t; unsigned int len; int doneany = 0; /* We call find_percent on REPLACE before checking PATTERN so that REPLACE will be collapsed before we call subst_expand if PATTERN has no %. */ if (replace_percent == 0) replace_percent = find_percent (replace); if (replace_percent != 0) { /* Record the length of REPLACE before and after the % so we don't have to compute these lengths more than once. */ replace_prepercent_len = replace_percent - replace; replace_postpercent_len = strlen (replace_percent + 1); } else /* We store the length of the replacement so we only need to compute it once. */ replace_prepercent_len = strlen (replace); if (pattern_percent == 0) pattern_percent = find_percent (pattern); if (pattern_percent == 0) /* With no % in the pattern, this is just a simple substitution. */ return subst_expand (o, text, pattern, replace, strlen (pattern), strlen (replace), 1, 0); /* Record the length of PATTERN before and after the % so we don't have to compute it more than once. */ pattern_prepercent_len = pattern_percent - pattern; pattern_postpercent_len = strlen (pattern_percent + 1); while ((t = find_next_token (&text, &len)) != 0) { int fail = 0; /* Is it big enough to match? */ if (len < pattern_prepercent_len + pattern_postpercent_len) fail = 1; /* Does the prefix match? */ if (!fail && pattern_prepercent_len > 0 && (*t != *pattern || t[pattern_prepercent_len - 1] != pattern_percent[-1] || strncmp (t + 1, pattern + 1, pattern_prepercent_len - 1))) fail = 1; /* Does the suffix match? */ if (!fail && pattern_postpercent_len > 0 && (t[len - 1] != pattern_percent[pattern_postpercent_len] || t[len - pattern_postpercent_len] != pattern_percent[1] || strncmp (&t[len - pattern_postpercent_len], &pattern_percent[1], pattern_postpercent_len - 1))) fail = 1; if (fail) /* It didn't match. Output the string. */ o = variable_buffer_output (o, t, len); else { /* It matched. Output the replacement. */ /* Output the part of the replacement before the %. */ o = variable_buffer_output (o, replace, replace_prepercent_len); if (replace_percent != 0) { /* Output the part of the matched string that matched the % in the pattern. */ o = variable_buffer_output (o, t + pattern_prepercent_len, len - (pattern_prepercent_len + pattern_postpercent_len)); /* Output the part of the replacement after the %. */ o = variable_buffer_output (o, replace_percent + 1, replace_postpercent_len); } } /* Output a space, but not if the replacement is "". */ if (fail || replace_prepercent_len > 0 || (replace_percent != 0 && len + replace_postpercent_len > 0)) { o = variable_buffer_output (o, " ", 1); doneany = 1; } } if (doneany) /* Kill the last space. */ --o; return o; } /* Handle variable-expansion-time functions such as $(dir foo/bar) ==> foo/ */ /* These enumeration constants distinguish the various expansion-time built-in functions. */ enum function { function_subst, function_addsuffix, function_addprefix, function_dir, function_notdir, function_suffix, function_basename, function_wildcard, function_firstword, function_word, function_words, function_findstring, function_strip, function_join, function_patsubst, function_filter, function_filter_out, function_foreach, function_sort, function_origin, function_shell, function_invalid }; /* Greater than the length of any function name. */ #define MAXFUNCTIONLEN 11 /* The function names and lengths of names, for looking them up. */ static struct { char *name; unsigned int len; enum function function; } function_table[] = { { "subst", 5, function_subst }, { "addsuffix", 9, function_addsuffix }, { "addprefix", 9, function_addprefix }, { "dir", 3, function_dir }, { "notdir", 6, function_notdir }, { "suffix", 6, function_suffix }, { "basename", 8, function_basename }, { "wildcard", 8, function_wildcard }, { "firstword", 9, function_firstword }, { "word", 4, function_word }, { "words", 5, function_words }, { "findstring", 10, function_findstring }, { "strip", 5, function_strip }, { "join", 4, function_join }, { "patsubst", 8, function_patsubst }, { "filter", 6, function_filter }, { "filter-out", 10, function_filter_out }, { "foreach", 7, function_foreach }, { "sort", 4, function_sort }, { "origin", 6, function_origin }, { "shell", 5, function_shell }, { 0, 0, function_invalid } }; /* Return 1 if PATTERN matches WORD, 0 if not. */ int pattern_matches (pattern, percent, word) register char *pattern, *percent, *word; { unsigned int sfxlen, wordlen; if (percent == 0) { unsigned int len = strlen (pattern) + 1; char *new = (char *) alloca (len); bcopy (pattern, new, len); pattern = new; percent = find_percent (pattern); if (percent == 0) return streq (pattern, word); } sfxlen = strlen (percent + 1); wordlen = strlen (word); if (wordlen < (percent - pattern) + sfxlen || strncmp (pattern, word, percent - pattern)) return 0; return !strcmp (percent + 1, word + (wordlen - sfxlen)); } int shell_function_pid = 0, shell_function_completed; /* Perform the function specified by FUNCTION on the text at TEXT. END is points to the end of the argument text (exclusive). The output is written into VARIABLE_BUFFER starting at O. */ /* Note this absorbs a semicolon and is safe to use in conditionals. */ #define BADARGS(func) \ if (reading_filename != 0) \ makefile_fatal (reading_filename, *reading_lineno_ptr, \ "insufficient arguments to function `%s'", \ func); \ else \ fatal ("insufficient arguments to function `%s'", func) static char * expand_function (o, function, text, end) char *o; enum function function; char *text; char *end; { char *p, *p2, *p3; unsigned int i, len; int doneany = 0; int count; char endparen = *end, startparen = *end == ')' ? '(' : '{'; switch (function) { default: abort (); break; case function_shell: { char **argv, **envp; char *error_prefix; int pipedes[2]; int pid; /* Expand the command line. */ text = expand_argument (text, end); /* Construct the argument list. */ argv = construct_command_argv (text, (char *) NULL, (struct file *) 0); if (argv == 0) break; /* Using a target environment for `shell' loses in cases like: export var = $(shell echo foobie) because target_environment hits a loop trying to expand $(var) to put it in the environment. This is even more confusing when var was not explicitly exported, but just appeared in the calling environment. */ #if 1 envp = environ; #else /* Construct the environment. */ envp = target_environment ((struct file *) 0); #endif /* For error messages. */ if (reading_filename != 0) { error_prefix = (char *) alloca (strlen (reading_filename) + 100); sprintf (error_prefix, "%s:%u: ", reading_filename, *reading_lineno_ptr); } else error_prefix = ""; if (pipe (pipedes) < 0) { perror_with_name (error_prefix, "pipe"); break; } pid = vfork (); if (pid < 0) perror_with_name (error_prefix, "fork"); else if (pid == 0) child_execute_job (0, pipedes[1], argv, envp); else { /* We are the parent. */ char *buffer; unsigned int maxlen; int cc; /* Free the storage only the child needed. */ free (argv[0]); free ((char *) argv); #if 0 for (i = 0; envp[i] != 0; ++i) free (envp[i]); free ((char *) envp); #endif /* Record the PID for reap_children. */ shell_function_pid = pid; shell_function_completed = 0; /* Set up and read from the pipe. */ maxlen = 200; buffer = (char *) xmalloc (maxlen + 1); /* Close the write side of the pipe. */ (void) close (pipedes[1]); /* Read from the pipe until it gets EOF. */ i = 0; do { if (i == maxlen) { maxlen += 512; buffer = (char *) xrealloc (buffer, maxlen + 1); } errno = 0; cc = read (pipedes[0], &buffer[i], maxlen - i); if (cc > 0) i += cc; } #ifdef EINTR while (cc > 0 || errno == EINTR); #else while (cc > 0); #endif /* Close the read side of the pipe. */ (void) close (pipedes[0]); /* Loop until child_handler sets shell_function_completed to the status of our child shell. */ while (shell_function_completed == 0) reap_children (1, 0); shell_function_pid = 0; /* The child_handler function will set shell_function_completed to 1 when the child dies normally, or to -1 if it dies with status 127, which is most likely an exec fail. */ if (shell_function_completed == -1) { /* This most likely means that the execvp failed, so we should just write out the error message that came in over the pipe from the child. */ fputs (buffer, stderr); fflush (stderr); } else { /* The child finished normally. Replace all newlines in its output with spaces, and put that in the variable output buffer. */ if (i > 0) { if (buffer[i - 1] == '\n') buffer[--i] = '\0'; else buffer[i] = '\0'; p = buffer; while ((p = index (p, '\n')) != 0) *p++ = ' '; o = variable_buffer_output (o, buffer, i); } } free (buffer); } free (text); break; } case function_origin: /* Expand the argument. */ text = expand_argument (text, end); { register struct variable *v = lookup_variable (text, strlen (text)); if (v == 0) o = variable_buffer_output (o, "undefined", 9); else switch (v->origin) { default: case o_invalid: abort (); break; case o_default: o = variable_buffer_output (o, "default", 7); break; case o_env: o = variable_buffer_output (o, "environment", 11); break; case o_file: o = variable_buffer_output (o, "file", 4); break; case o_env_override: o = variable_buffer_output (o, "environment override", 20); break; case o_command: o = variable_buffer_output (o, "command line", 12); break; case o_override: o = variable_buffer_output (o, "override", 8); break; case o_automatic: o = variable_buffer_output (o, "automatic", 9); break; } } free (text); break; case function_sort: /* Expand the argument. */ text = expand_argument (text, end); { char **words = (char **) xmalloc (10 * sizeof (char *)); unsigned int nwords = 10; register unsigned int wordi = 0; char *t; /* Chop TEXT into words and put them in WORDS. */ t = text; while ((p = find_next_token (&t, &len)) != 0) { if (wordi >= nwords - 1) { nwords *= 2; words = (char **) xrealloc ((char *) words, nwords * sizeof (char *)); } words[wordi++] = savestring (p, len); } if (wordi > 0) { /* Now sort the list of words. */ qsort ((char *) words, wordi, sizeof (char *), alpha_compare); /* Now write the sorted list. */ for (i = 0; i < wordi; ++i) { len = strlen (words[i]); if (i == wordi - 1 || strlen (words[i + 1]) != len || strcmp (words[i], words[i + 1])) { o = variable_buffer_output (o, words[i], len); o = variable_buffer_output (o, " ", 1); } free (words[i]); } /* Kill the last space. */ --o; } free ((char *) words); } free (text); break; case function_foreach: { /* Get three comma-separated arguments but expand only the first two. */ char *var, *list; register struct variable *v; count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("foreach"); var = expand_argument (text, p); p2 = p + 1; count = 0; for (p = p2; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("foreach"); list = expand_argument (p2, p); ++p; text = savestring (p, end - p); push_new_variable_scope (); v = define_variable (var, strlen (var), "", o_automatic, 0); p3 = list; while ((p = find_next_token (&p3, &len)) != 0) { char *result; char save = p[len]; p[len] = '\0'; v->value = p; result = allocated_variable_expand (text); p[len] = save; o = variable_buffer_output (o, result, strlen (result)); o = variable_buffer_output (o, " ", 1); doneany = 1; free (result); } if (doneany) /* Kill the last space. */ --o; pop_variable_scope (); free (var); free (list); free (text); } break; case function_filter: case function_filter_out: { struct word { struct word *next; char *word; int matched; } *words, *wordtail, *wp; /* Get two comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS (function == function_filter ? "filter" : "filter-out"); p2 = expand_argument (text, p); text = expand_argument (p + 1, end); /* Chop TEXT up into words and then run each pattern through. */ words = wordtail = 0; p3 = text; while ((p = find_next_token (&p3, &len)) != 0) { struct word *w = (struct word *) alloca (sizeof (struct word)); if (words == 0) words = w; else wordtail->next = w; wordtail = w; if (*p3 != '\0') ++p3; p[len] = '\0'; w->word = p; w->matched = 0; } if (words != 0) { wordtail->next = 0; /* Run each pattern through the words, killing words. */ p3 = p2; while ((p = find_next_token (&p3, &len)) != 0) { char *percent; char save = p[len]; p[len] = '\0'; percent = find_percent (p); for (wp = words; wp != 0; wp = wp->next) wp->matched |= (percent == 0 ? streq (p, wp->word) : pattern_matches (p, percent, wp->word)); p[len] = save; } /* Output the words that matched (or didn't, for filter-out). */ for (wp = words; wp != 0; wp = wp->next) if (function == function_filter ? wp->matched : !wp->matched) { o = variable_buffer_output (o, wp->word, strlen (wp->word)); o = variable_buffer_output (o, " ", 1); doneany = 1; } if (doneany) /* Kill the last space. */ --o; } free (p2); free (text); } break; case function_patsubst: /* Get three comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("patsubst"); p2 = p; count = 0; for (++p; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("patsubst"); text = expand_argument (text, p2); p3 = expand_argument (p2 + 1, p); p2 = expand_argument (p + 1, end); o = patsubst_expand (o, p2, text, p3, (char *) 0, (char *) 0); free (text); free (p3); free (p2); break; case function_join: /* Get two comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("join"); text = expand_argument (text, p); p = expand_argument (p + 1, end); { /* Write each word of the first argument directly followed by the corresponding word of the second argument. If the two arguments have a different number of words, the excess words are just output separated by blanks. */ register char *tp, *pp; p2 = text; p3 = p; do { unsigned int tlen, plen; tp = find_next_token (&p2, &tlen); if (tp != 0) o = variable_buffer_output (o, tp, tlen); pp = find_next_token (&p3, &plen); if (pp != 0) o = variable_buffer_output (o, pp, plen); if (tp != 0 || pp != 0) { o = variable_buffer_output (o, " ", 1); doneany = 1; } } while (tp != 0 || pp != 0); if (doneany) /* Kill the last blank. */ --o; } free (text); free (p); break; case function_strip: /* Expand the argument. */ text = expand_argument (text, end); p2 = text; while ((p = find_next_token (&p2, &i)) != 0) { o = variable_buffer_output (o, p, i); o = variable_buffer_output (o, " ", 1); doneany = 1; } if (doneany) /* Kill the last space. */ --o; free (text); break; case function_wildcard: text = expand_argument (text, end); p = string_glob (text); o = variable_buffer_output (o, p, strlen (p)); free (text); break; case function_subst: /* Get three comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("subst"); p2 = p; count = 0; for (++p; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("subst"); text = expand_argument (text, p2); p3 = expand_argument (p2 + 1, p); p2 = expand_argument (p + 1, end); o = subst_expand (o, p2, text, p3, strlen (text), strlen (p3), 0, 0); free (text); free (p3); free (p2); break; case function_firstword: /* Expand the argument. */ text = expand_argument (text, end); /* Find the first word in TEXT. */ p2 = text; p = find_next_token (&p2, &i); if (p != 0) o = variable_buffer_output (o, p, i); free (text); break; case function_word: /* Get two comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("word"); text = expand_argument (text, p); p3 = expand_argument (p + 1, end); /* Check the first argument. */ for (p2 = text; *p2 != '\0'; ++p2) if (*p2 < '0' || *p2 > '9') { if (reading_filename != 0) makefile_fatal (reading_filename, *reading_lineno_ptr, "non-numeric first argument to `word' function"); else fatal ("non-numeric first argument to `word' function"); } i = (unsigned int) atoi (text); if (i == 0) { if (reading_filename != 0) makefile_fatal (reading_filename, *reading_lineno_ptr, "the `word' function takes a one-origin \ index argument"); else fatal ("the `word' function takes a one-origin index argument"); } p2 = p3; while ((p = find_next_token (&p2, &len)) != 0) if (--i == 0) break; if (i == 0) o = variable_buffer_output (o, p, len); free (text); free (p3); break; case function_words: /* Expand the argument. */ text = expand_argument (text, end); i = 0; p2 = text; while (find_next_token (&p2, (unsigned int *) 0) != 0) ++i; { char buf[20]; sprintf (buf, "%d", i); o = variable_buffer_output (o, buf, strlen (buf)); } free (text); break; case function_findstring: /* Get two comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS ("findstring"); text = expand_argument (text, p); p = expand_argument (p + 1, end); /* Find the first occurrence of the first string in the second. */ i = strlen (text); if (sindex (p, 0, text, i) != 0) o = variable_buffer_output (o, text, i); free (p); free (text); break; case function_addsuffix: case function_addprefix: /* Get two comma-separated arguments and expand each one. */ count = 0; for (p = text; p < end; ++p) { if (*p == startparen) ++count; else if (*p == endparen) --count; else if (*p == ',' && count <= 0) break; } if (p == end) BADARGS (function == function_addsuffix ? "addsuffix" : "addprefix"); text = expand_argument (text, p); i = strlen (text); p2 = expand_argument (p + 1, end); p3 = p2; while ((p = find_next_token (&p3, &len)) != 0) { if (function == function_addprefix) o = variable_buffer_output (o, text, i); o = variable_buffer_output (o, p, len); if (function == function_addsuffix) o = variable_buffer_output (o, text, i); o = variable_buffer_output (o, " ", 1); doneany = 1; } if (doneany) /* Kill last space. */ --o; free (p2); free (text); break; case function_dir: case function_basename: /* Expand the argument. */ text = expand_argument (text, end); p3 = text; while ((p2 = find_next_token (&p3, &len)) != 0) { p = p2 + len; while (p >= p2 && *p != (function == function_dir ? '/' : '.')) --p; if (p >= p2) { if (function == function_dir) ++p; o = variable_buffer_output (o, p2, p - p2); } else if (function == function_dir) o = variable_buffer_output (o, "./", 2); else /* The entire name is the basename. */ o = variable_buffer_output (o, p2, len); o = variable_buffer_output (o, " ", 1); doneany = 1; } if (doneany) /* Kill last space. */ --o; free (text); break; case function_notdir: case function_suffix: /* Expand the argument. */ text = expand_argument (text, end); p3 = text; while ((p2 = find_next_token (&p3, &len)) != 0) { p = p2 + len; while (p >= p2 && *p != (function == function_notdir ? '/' : '.')) --p; if (p >= p2) { if (function == function_notdir) ++p; o = variable_buffer_output (o, p, len - (p - p2)); } else if (function == function_notdir) o = variable_buffer_output (o, p2, len); if (function == function_notdir || p >= p2) { o = variable_buffer_output (o, " ", 1); doneany = 1; } } if (doneany) /* Kill last space. */ --o; free (text); break; } return o; } /* Check for a function invocation in *STRINGP. *STRINGP points at the opening ( or { and is not null-terminated. If a function invocation is found, expand it into the buffer at *OP, updating *OP, incrementing *STRINGP past the reference and returning nonzero. If not, return zero. */ int handle_function (op, stringp) char **op; char **stringp; { register unsigned int code; unsigned int maxlen; char *beg = *stringp + 1; char *endref; endref = lindex (beg, beg + MAXFUNCTIONLEN, '\0'); maxlen = endref != 0 ? endref - beg : MAXFUNCTIONLEN; for (code = 0; function_table[code].name != 0; ++code) { if (maxlen < function_table[code].len) continue; endref = beg + function_table[code].len; if (isblank (*endref) && !strncmp (function_table[code].name, beg, function_table[code].len)) break; } if (function_table[code].name != 0) { /* We have found a call to an expansion-time function. Find the end of the arguments, and do the function. */ char openparen = beg[-1], closeparen = openparen == '(' ? ')' : '}'; int count = 0; char *argbeg; register char *p; /* Space after function name isn't part of the args. */ p = next_token (endref); argbeg = p; /* Count nested use of whichever kind of parens we use, so that nested calls and variable refs work. */ for (; *p != '\0'; ++p) { if (*p == openparen) ++count; else if (*p == closeparen && --count < 0) break; } if (count >= 0) { static const char errmsg[] = "unterminated call to function `%s': missing `%c'"; if (reading_filename == 0) fatal (errmsg, function_table[code].name, closeparen); else makefile_fatal (reading_filename, *reading_lineno_ptr, errmsg, function_table[code].name, closeparen); } /* We found the end; expand the function call. */ *op = expand_function (*op, function_table[code].function, argbeg, p); *stringp = p; return 1; } return 0; } /* Glob-expand LINE. The returned pointer is only good until the next call to string_glob. */ static char * string_glob (line) char *line; { static char *result = 0; static unsigned int length; register struct nameseq *chain; register unsigned int idx; chain = multi_glob (parse_file_seq (&line, '\0', sizeof (struct nameseq), /* We do not want parse_file_seq to strip `./'s. That would break examples like: $(patsubst ./%.c,obj/%.o,$(wildcard ./*.c)). */ 0), sizeof (struct nameseq)); if (result == 0) { length = 100; result = (char *) xmalloc (100); } idx = 0; while (chain != 0) { register char *name = chain->name; unsigned int len = strlen (name); struct nameseq *next = chain->next; free ((char *) chain); chain = next; /* multi_glob will pass names without globbing metacharacters through as is, but we want only files that actually exist. */ if (file_exists_p (name)) { if (idx + len + 1 > length) { length += (len + 1) * 2; result = (char *) xrealloc (result, length); } bcopy (name, &result[idx], len); idx += len; result[idx++] = ' '; } free (name); } /* Kill the last space and terminate the string. */ if (idx == 0) result[0] = '\0'; else result[idx - 1] = '\0'; return result; } make-3.70/vpath.c 666 12241 13 32525 5506220665 6774 /* Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "file.h" #include "variable.h" /* Structure used to represent a selective VPATH searchpath. */ struct vpath { struct vpath *next; /* Pointer to next struct in the linked list. */ char *pattern; /* The pattern to match. */ char *percent; /* Pointer into `pattern' where the `%' is. */ unsigned int patlen;/* Length of the pattern. */ char **searchpath; /* Null-terminated list of directories. */ unsigned int maxlen;/* Maximum length of any entry in the list. */ }; /* Linked-list of all selective VPATHs. */ static struct vpath *vpaths; /* Structure for the general VPATH given in the variable. */ static struct vpath *general_vpath; static int selective_vpath_search (); /* Reverse the chain of selective VPATH lists so they will be searched in the order given in the makefiles and construct the list from the VPATH variable. */ void build_vpath_lists () { register struct vpath *new = 0; register struct vpath *old, *nexto; register char *p; /* Reverse the chain. */ for (old = vpaths; old != 0; old = nexto) { nexto = old->next; old->next = new; new = old; } vpaths = new; /* If there is a VPATH variable with a nonnull value, construct the general VPATH list from it. We use variable_expand rather than just calling lookup_variable so that it will be recursively expanded. */ { /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */ int save = warn_undefined_variables_flag; warn_undefined_variables_flag = 0; p = variable_expand ("$(strip $(VPATH))"); warn_undefined_variables_flag = save; } if (*p != '\0') { /* Save the list of vpaths. */ struct vpath *save_vpaths = vpaths; /* Empty `vpaths' so the new one will have no next, and `vpaths' will still be nil if P contains no existing directories. */ vpaths = 0; /* Parse P. */ construct_vpath_list ("%", p); /* Store the created path as the general path, and restore the old list of vpaths. */ general_vpath = vpaths; vpaths = save_vpaths; } } /* Construct the VPATH listing for the pattern and searchpath given. This function is called to generate selective VPATH lists and also for the general VPATH list (which is in fact just a selective VPATH that is applied to everything). The returned pointer is either put in the linked list of all selective VPATH lists or in the GENERAL_VPATH variable. If SEARCHPATH is nil, remove all previous listings with the same pattern. If PATTERN is nil, remove all VPATH listings. Existing and readable directories that are not "." given in the searchpath separated by colons are loaded into the directory hash table if they are not there already and put in the VPATH searchpath for the given pattern with trailing slashes stripped off if present (and if the directory is not the root, "/"). The length of the longest entry in the list is put in the structure as well. The new entry will be at the head of the VPATHS chain. */ void construct_vpath_list (pattern, dirpath) char *pattern, *dirpath; { register unsigned int elem; register char *p; register char **vpath; register unsigned int maxvpath; unsigned int maxelem; char *percent; if (pattern != 0) { pattern = savestring (pattern, strlen (pattern)); percent = find_percent (pattern); } if (dirpath == 0) { /* Remove matching listings. */ register struct vpath *path, *lastpath; lastpath = 0; path = vpaths; while (path != 0) { struct vpath *next = path->next; if (pattern == 0 || (((percent == 0 && path->percent == 0) || (percent - pattern == path->percent - path->pattern)) && streq (pattern, path->pattern))) { /* Remove it from the linked list. */ if (lastpath == 0) vpaths = path->next; else lastpath->next = next; /* Free its unused storage. */ free (path->pattern); free ((char *) path->searchpath); free ((char *) path); } else lastpath = path; path = next; } if (pattern != 0) free (pattern); return; } /* Figure out the maximum number of VPATH entries and put it in MAXELEM. We start with 2, one before the first colon and one nil, the list terminator and increment our estimated number for each colon or blank we find. */ maxelem = 2; p = dirpath; while (*p != '\0') if (*p++ == ':' || isblank (*p)) ++maxelem; vpath = (char **) xmalloc (maxelem * sizeof (char *)); maxvpath = 0; /* Skip over any initial colons and blanks. */ p = dirpath; while (*p == ':' || isblank (*p)) ++p; elem = 0; while (*p != '\0') { char *v; unsigned int len; /* Find the end of this entry. */ v = p; while (*p != '\0' && *p != ':' && !isblank (*p)) ++p; len = p - v; /* Make sure there's no trailing slash, but still allow "/" as a directory. */ if (len > 1 && p[-1] == '/') --len; if (len > 1 || *v != '.') { v = savestring (v, len); /* Verify that the directory actually exists. */ if (dir_file_exists_p (v, "")) { /* It does. Put it in the list. */ vpath[elem++] = dir_name (v); free (v); if (len > maxvpath) maxvpath = len; } else /* The directory does not exist. Omit from the list. */ free (v); } /* Skip over colons and blanks between entries. */ while (*p == ':' || isblank (*p)) ++p; } if (elem > 0) { struct vpath *path; /* ELEM is now incremented one element past the last entry, to where the nil-pointer terminator goes. Usually this is maxelem - 1. If not, shrink down. */ if (elem < (maxelem - 1)) vpath = (char **) xrealloc ((char *) vpath, (elem + 1) * sizeof (char *)); /* Put the nil-pointer terminator on the end of the VPATH list. */ vpath[elem] = 0; /* Construct the vpath structure and put it into the linked list. */ path = (struct vpath *) xmalloc (sizeof (struct vpath)); path->searchpath = vpath; path->maxlen = maxvpath; path->next = vpaths; vpaths = path; /* Set up the members. */ path->pattern = pattern; path->percent = percent; path->patlen = strlen (pattern); } else { /* There were no entries, so free whatever space we allocated. */ free ((char *) vpath); if (pattern != 0) free (pattern); } } /* Search the VPATH list whose pattern matches *FILE for a directory where the name pointed to by FILE exists. If it is found, we set *FILE to the newly malloc'd name of the existing file, *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no stat call was done), and return 1. Otherwise we return 0. */ int vpath_search (file, mtime_ptr) char **file; time_t *mtime_ptr; { register struct vpath *v; /* If there are no VPATH entries or FILENAME starts at the root, there is nothing we can do. */ if (**file == '/' || (vpaths == 0 && general_vpath == 0)) return 0; for (v = vpaths; v != 0; v = v->next) if (pattern_matches (v->pattern, v->percent, *file)) if (selective_vpath_search (v, file, mtime_ptr)) return 1; if (general_vpath != 0 && selective_vpath_search (general_vpath, file, mtime_ptr)) return 1; return 0; } /* Search the given VPATH list for a directory where the name pointed to by FILE exists. If it is found, we set *FILE to the newly malloc'd name of the existing file, *MTIME_PTR (if MTIME_PTR is not NULL) to its modtime (or zero if no stat call was done), and we return 1. Otherwise we return 0. */ static int selective_vpath_search (path, file, mtime_ptr) struct vpath *path; char **file; time_t *mtime_ptr; { int not_target; char *name, *n; char *filename; register char **vpath = path->searchpath; unsigned int maxvpath = path->maxlen; register unsigned int i; unsigned int flen, vlen, name_dplen; int exists = 0; /* Find out if *FILE is a target. If and only if it is NOT a target, we will accept prospective files that don't exist but are mentioned in a makefile. */ { struct file *f = lookup_file (*file); not_target = f == 0 || !f->is_target; } flen = strlen (*file); /* Split *FILE into a directory prefix and a name-within-directory. NAME_DPLEN gets the length of the prefix; FILENAME gets the pointer to the name-within-directory and FLEN is its length. */ n = rindex (*file, '/'); name_dplen = n != 0 ? n - *file : 0; filename = name_dplen > 0 ? n + 1 : *file; if (name_dplen > 0) flen -= name_dplen + 1; /* Allocate enough space for the biggest VPATH entry, a slash, the directory prefix that came with *FILE, another slash (although this one may not always be necessary), the filename, and a null terminator. */ name = (char *) alloca (maxvpath + 1 + name_dplen + 1 + flen + 1); /* Try each VPATH entry. */ for (i = 0; vpath[i] != 0; ++i) { int exists_in_cache = 0; n = name; /* Put the next VPATH entry into NAME at N and increment N past it. */ vlen = strlen (vpath[i]); bcopy (vpath[i], n, vlen); n += vlen; /* Add the directory prefix already in *FILE. */ if (name_dplen > 0) { *n++ = '/'; bcopy (*file, n, name_dplen); n += name_dplen; } /* Now add the name-within-directory at the end of NAME. */ if (n != name && n[-1] != '/') { *n = '/'; bcopy (filename, n + 1, flen + 1); } else bcopy (filename, n, flen + 1); /* Check if the file is mentioned in a makefile. If *FILE is not a target, that is enough for us to decide this file exists. If *FILE is a target, then the file must be mentioned in the makefile also as a target to be chosen. The restriction that *FILE must not be a target for a makefile-mentioned file to be chosen was added by an inadequately commented change in July 1990; I am not sure off hand what problem it fixes. In December 1993 I loosened of this restriction to allow a file to be chosen if it is mentioned as a target in a makefile. This seem logical. */ { struct file *f = lookup_file (name); if (f != 0) exists = not_target || f->is_target; } if (!exists) { /* That file wasn't mentioned in the makefile. See if it actually exists. */ /* Clobber a null into the name at the last slash. Now NAME is the name of the directory to look in. */ *n = '\0'; /* We know the directory is in the hash table now because either construct_vpath_list or the code just above put it there. Does the file we seek exist in it? */ exists_in_cache = exists = dir_file_exists_p (name, filename); } if (exists) { /* The file is in the directory cache. Now check that it actually exists in the filesystem. The cache may be out of date. When vpath thinks a file exists, but stat fails for it, confusion results in the higher levels. */ struct stat st; /* Put the slash back in NAME. */ *n = '/'; if (!exists_in_cache /* Makefile-mentioned file need not exist. */ || stat (name, &st) == 0) /* Does it really exist? */ { /* We have found a file. Store the name we found into *FILE for the caller. */ *file = savestring (name, (n + 1 - name) + flen); if (mtime_ptr != 0) /* Store the modtime into *MTIME_PTR for the caller. If we have had no need to stat the file here, we record a zero modtime to indicate this. */ *mtime_ptr = exists_in_cache ? st.st_mtime : (time_t) 0; return 1; } } } return 0; } /* Print the data base of VPATH search paths. */ void print_vpath_data_base () { register unsigned int nvpaths; register struct vpath *v; puts ("\n# VPATH Search Paths\n"); nvpaths = 0; for (v = vpaths; v != 0; v = v->next) { register unsigned int i; ++nvpaths; printf ("vpath %s ", v->pattern); for (i = 0; v->searchpath[i] != 0; ++i) printf ("%s%c", v->searchpath[i], v->searchpath[i + 1] == 0 ? '\n' : ':'); } if (vpaths == 0) puts ("# No `vpath' search paths."); else printf ("\n# %u `vpath' search paths.\n", nvpaths); if (general_vpath == 0) puts ("\n# No general (`VPATH' variable) search path."); else { register char **path = general_vpath->searchpath; register unsigned int i; fputs ("\n# General (`VPATH' variable) search path:\n# ", stdout); for (i = 0; path[i] != 0; ++i) printf ("%s%c", path[i], path[i + 1] == 0 ? '\n' : ':'); } } make-3.70/version.c 666 12241 13 133 5512120461 7253 char *version_string = "3.70"; /* Local variables: version-control: never End: */ make-3.70/remote-cstms.c 666 12241 13 17113 5334260431 10262 /* This file implements an interface to the Customs daemon to do remote execution of commands under GNU make. THIS CODE IS NOT SUPPORTED BY THE GNU PROJECT. Please do not send bug reports or questions about it to the Make maintainers. Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" #include "job.h" #include #include #define __STRICT_BSD__ /* Don't make conflicting declarations. */ #include "customs.h" char *remote_description = "Customs"; /* File name of the Customs `export' client command. A full path name can be used to avoid some path-searching overhead. */ #define EXPORT_COMMAND "/usr/local/bin/export" /* ExportPermit gotten by start_remote_job_p, and used by start_remote_job. */ static ExportPermit permit; /* Normalized path name of the current directory. */ static char *normalized_cwd; /* Return nonzero if the next job should be done remotely. */ int start_remote_job_p () { static int inited = 0; int status; /* Allow the user to turn off job exportation (useful while he is debugging Customs, for example). */ if (getenv ("GNU_MAKE_NO_CUSTOMS") != 0) return 0; if (!inited) { /* For secure Customs, make is installed setuid root and Customs requires a privileged source port be used. */ make_access (); /* Ping the daemon once to see if it is there. */ inited = Customs_Ping () == RPC_SUCCESS ? 1 : -1; /* Return to normal user access. */ user_access (); if (starting_directory == 0) /* main couldn't figure it out. */ inited = -1; else { /* Normalize the current directory path name to something that should work on all machines exported to. */ normalized_cwd = (char *) xmalloc (GET_PATH_MAX); strcpy (normalized_cwd, starting_directory); if (Customs_NormPath (normalized_cwd, GET_PATH_MAX) < 0) /* Path normalization failure means using Customs won't work, but it's not really an error. */ inited = -1; } } if (inited < 0) return 0; status = Customs_Host (EXPORT_SAME, &permit); if (status != RPC_SUCCESS) { if (debug_flag) printf ("Customs won't export: %s\n", Rpc_ErrorMessage (status)); return 0; } return !CUSTOMS_FAIL (&permit.addr); } /* Start a remote job running the command in ARGV, with environment from ENVP. It gets standard input from STDIN_FD. On failure, return nonzero. On success, return zero, and set *USED_STDIN to nonzero if it will actually use STDIN_FD, zero if not, set *ID_PTR to a unique identification, and set *IS_REMOTE to nonzero if the job is remote, zero if it is local (meaning *ID_PTR is a process ID). */ int start_remote_job (argv, envp, stdin_fd, is_remote, id_ptr, used_stdin) char **argv, **envp; int stdin_fd; int *is_remote; int *id_ptr; int *used_stdin; { extern int vfork (), execve (); char waybill[MAX_DATA_SIZE], msg[128]; struct timeval timeout; struct sockaddr_in sin; int len; int retsock, retport, sock; Rpc_Stat status; int pid; /* Create the return socket. */ retsock = Rpc_UdpCreate (True, 0); if (retsock < 0) { error ("exporting: Couldn't create return socket."); return 1; } /* Get the return socket's port number. */ len = sizeof (sin); if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0) { (void) close (retsock); perror_with_name ("exporting: ", "getsockname"); return 1; } retport = sin.sin_port; /* Create the TCP socket for talking to the remote child. */ sock = Rpc_TcpCreate (False, 0); /* Create a WayBill to give to the server. */ len = Customs_MakeWayBill (&permit, normalized_cwd, argv[0], argv, envp, retport, waybill); /* Modify the waybill as if the remote child had done `child_access ()'. */ { WayBill *wb = (WayBill *) waybill; wb->euid = wb->ruid; wb->rgid = wb->rgid; } /* Send the request to the server, timing out in 20 seconds. */ timeout.tv_usec = 0; timeout.tv_sec = 20; sin.sin_family = AF_INET; sin.sin_port = htons (Customs_Port ()); sin.sin_addr = permit.addr; status = Rpc_Call (sock, &sin, (Rpc_Proc) CUSTOMS_IMPORT, len, (Rpc_Opaque) waybill, sizeof(msg), (Rpc_Opaque) msg, 1, &timeout); if (status != RPC_SUCCESS) { (void) close (retsock); (void) close (sock); error ("exporting: %s", Rpc_ErrorMessage (status)); return 1; } else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0') { (void) close (retsock); (void) close (sock); error ("CUSTOMS_IMPORT: %s", msg); return 1; } else if (debug_flag) { struct hostent *host = gethostbyaddr (&permit.addr, sizeof (permit.addr), AF_INET); printf ("Job exported to %s ID %u\n", host == 0 ? inet_ntoa (permit.addr) : host->h_name, permit.id); } fflush (stdout); fflush (stderr); pid = vfork (); if (pid < 0) { /* The fork failed! */ perror_with_name ("vfork", ""); return 1; } else if (pid == 0) { /* Child side. Run `export' to handle the connection. */ static char sock_buf[20], retsock_buf[20], id_buf[20]; static char *new_argv[6] = { EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 }; /* Set up the arguments. */ (void) sprintf (sock_buf, "%d", sock); (void) sprintf (retsock_buf, "%d", retsock); (void) sprintf (id_buf, "%x", permit.id); /* Get the right stdin. */ if (stdin_fd != 0) (void) dup2 (stdin_fd, 0); /* Unblock signals in the child. */ unblock_sigs (); /* Run the command. */ exec_command (new_argv, envp); } /* Parent side. Return the `export' process's ID. */ (void) close (retsock); (void) close (sock); *is_remote = 0; *id_ptr = pid; return 0; } /* Get the status of a dead remote child. Block waiting for one to die if BLOCK is nonzero. Set *EXIT_CODE_PTR to the exit status, *SIGNAL_PTR to the termination signal or zero if it exited normally, and *COREDUMP_PTR nonzero if it dumped core. Return the ID of the child that died, 0 if we would have to block and !BLOCK, or < 0 if there were none. */ int remote_status (exit_code_ptr, signal_ptr, coredump_ptr, block) int *exit_code_ptr, *signal_ptr, *coredump_ptr; int block; { return -1; } /* Block asynchronous notification of remote child death. If this notification is done by raising the child termination signal, do not block that signal. */ void block_remote_children () { return; } /* Restore asynchronous notification of remote child death. If this is done by raising the child termination signal, do not unblock that signal. */ void unblock_remote_children () { return; } /* Send signal SIG to child ID. Return 0 if successful, -1 if not. */ int remote_kill (id, sig) int id; int sig; { return -1; } make-3.70/ar.c 666 12241 13 16562 5503425331 6251 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #ifndef NO_ARCHIVES #include "file.h" #include "dep.h" #include /* Defined in arscan.c. */ extern long int ar_scan (); extern int ar_member_touch (); extern int ar_name_equal (); /* Return nonzero if NAME is an archive-member reference, zero if not. An archive-member reference is a name like `lib(member)'. If a name like `lib((entry))' is used, a fatal error is signaled at the attempt to use this unsupported feature. */ int ar_name (name) char *name; { char *p = index (name, '('), *end = name + strlen (name) - 1; if (p == 0 || p == name || *end != ')') return 0; if (p[1] == '(' && end[-1] == ')') fatal ("attempt to use unsupported feature: `%s'", name); return 1; } /* Parse the archive-member reference NAME into the archive and member names. Put the malloc'd archive name in *ARNAME_P if ARNAME_P is non-nil; put the malloc'd member name in *MEMNAME_P if MEMNAME_P is non-nil. */ void ar_parse_name (name, arname_p, memname_p) char *name, **arname_p, **memname_p; { char *p = index (name, '('), *end = name + strlen (name) - 1; if (arname_p != 0) *arname_p = savestring (name, p - name); if (memname_p != 0) *memname_p = savestring (p + 1, end - (p + 1)); } static long int ar_member_date_1 (); /* Return the modtime of NAME. */ time_t ar_member_date (name) char *name; { char *arname; int arname_used = 0; char *memname; long int val; ar_parse_name (name, &arname, &memname); /* Make sure we know the modtime of the archive itself because we are likely to be called just before commands to remake a member are run, and they will change the archive itself. But we must be careful not to enter_file the archive itself if it does not exist, because pattern_search assumes that files found in the data base exist or can be made. */ { struct file *arfile; arfile = lookup_file (arname); if (arfile == 0 && file_exists_p (arname)) { arfile = enter_file (arname); arname_used = 1; } if (arfile != 0) (void) f_mtime (arfile, 0); } val = ar_scan (arname, ar_member_date_1, (long int) memname); if (!arname_used) free (arname); free (memname); return (val <= 0 ? (time_t) -1 : (time_t) val); } /* This function is called by `ar_scan' to find which member to look at. */ /* ARGSUSED */ static long int ar_member_date_1 (desc, mem, truncated, hdrpos, datapos, size, date, uid, gid, mode, name) int desc; char *mem; int truncated; long int hdrpos, datapos, size, date; int uid, gid, mode; char *name; { return ar_name_equal (name, mem, truncated) ? date : 0; } /* Set the archive-member NAME's modtime to now. */ int ar_touch (name) char *name; { char *arname, *memname; int arname_used = 0; register int val; ar_parse_name (name, &arname, &memname); /* Make sure we know the modtime of the archive itself before we touch the member, since this will change the archive itself. */ { struct file *arfile; arfile = lookup_file (arname); if (arfile == 0) { arfile = enter_file (arname); arname_used = 1; } (void) f_mtime (arfile, 0); } val = 1; switch (ar_member_touch (arname, memname)) { case -1: error ("touch: Archive `%s' does not exist", arname); break; case -2: error ("touch: `%s' is not a valid archive", arname); break; case -3: perror_with_name ("touch: ", arname); break; case 1: error ("touch: Member `%s' does not exist in `%s'", memname, arname); break; case 0: val = 0; break; default: error ("touch: Bad return code from ar_member_touch on `%s'", name); } if (!arname_used) free (arname); free (memname); return val; } /* State of an `ar_glob' run, passed to `ar_glob_match'. */ struct ar_glob_state { char *arname; char *pattern; unsigned int size; struct nameseq *chain; unsigned int n; }; /* This function is called by `ar_scan' to match one archive element against the pattern in STATE. */ static long int ar_glob_match (desc, mem, truncated, hdrpos, datapos, size, date, uid, gid, mode, state) int desc; char *mem; int truncated; long int hdrpos, datapos, size, date; int uid, gid, mode; struct ar_glob_state *state; { if (fnmatch (state->pattern, mem, FNM_PATHNAME|FNM_PERIOD) == 0) { /* We have a match. Add it to the chain. */ struct nameseq *new = (struct nameseq *) xmalloc (state->size); new->name = concat (state->arname, mem, ")"); new->next = state->chain; state->chain = new; ++state->n; } return 0L; } /* Alphabetic sorting function for `qsort'. */ static int ar_glob_alphacompare (a, b) char **a, **b; { return strcmp (*a, *b); } /* Return nonzero if PATTERN contains any metacharacters. Metacharacters can be quoted with backslashes if QUOTE is nonzero. */ static int glob_pattern_p (pattern, quote) const char *pattern; const int quote; { register const char *p; int open = 0; for (p = pattern; *p != '\0'; ++p) switch (*p) { case '?': case '*': return 1; case '\\': if (quote) ++p; break; case '[': open = 1; break; case ']': if (open) return 1; break; } return 0; } /* Glob for MEMBER_PATTERN in archive ARNAME. Return a malloc'd chain of matching elements (or nil if none). */ struct nameseq * ar_glob (arname, member_pattern, size) char *arname, *member_pattern; unsigned int size; { struct ar_glob_state state; char **names; struct nameseq *n; unsigned int i; if (! glob_pattern_p (member_pattern, 1)) return 0; /* Scan the archive for matches. ar_glob_match will accumulate them in STATE.chain. */ i = strlen (arname); state.arname = (char *) alloca (i + 2); bcopy (arname, state.arname, i); state.arname[i] = '('; state.arname[i + 1] = '\0'; state.pattern = member_pattern; state.size = size; state.chain = 0; state.n = 0; (void) ar_scan (arname, ar_glob_match, (long int) &state); if (state.chain == 0) return 0; /* Now put the names into a vector for sorting. */ names = (char **) alloca (state.n * sizeof (char *)); i = 0; for (n = state.chain; n != 0; n = n->next) names[i++] = n->name; /* Sort them alphabetically. */ qsort ((char *) names, i, sizeof (*names), ar_glob_alphacompare); /* Put them back into the chain in the sorted order. */ i = 0; for (n = state.chain; n != 0; n = n->next) n->name = names[i++]; return state.chain; } #endif /* Not NO_ARCHIVES. */ make-3.70/arscan.c 666 12241 13 32003 5504167067 7114 /* Library function for scanning an archive file. Copyright (C) 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #ifdef HAVE_FCNTL_H #include #else #include #endif #ifndef NO_ARCHIVES /* SCO Unix's compiler defines both of these. */ #ifdef M_UNIX #undef M_XENIX #endif /* On the sun386i and in System V rel 3, ar.h defines two different archive formats depending upon whether you have defined PORTAR (normal) or PORT5AR (System V Release 1). There is no default, one or the other must be defined to have a nonzero value. */ #if (!defined (PORTAR) || PORTAR == 0) && (!defined (PORT5AR) || PORT5AR == 0) #undef PORTAR #ifdef M_XENIX /* According to Jim Sievert , for SCO XENIX defining PORTAR to 1 gets the wrong archive format, and defining it to 0 gets the right one. */ #define PORTAR 0 #else #define PORTAR 1 #endif #endif #include /* Cray's apparently defines this. */ #ifndef AR_HDR_SIZE #define AR_HDR_SIZE (sizeof (struct ar_hdr)) #endif /* Takes three arguments ARCHIVE, FUNCTION and ARG. Open the archive named ARCHIVE, find its members one by one, and for each one call FUNCTION with the following arguments: archive file descriptor for reading the data, member name, member name might be truncated flag, member header position in file, member data position in file, member data size, member date, member uid, member gid, member protection mode, ARG. The descriptor is poised to read the data of the member when FUNCTION is called. It does not matter how much data FUNCTION reads. If FUNCTION returns nonzero, we immediately return what FUNCTION returned. Returns -1 if archive does not exist, Returns -2 if archive has invalid format. Returns 0 if have scanned successfully. */ long int ar_scan (archive, function, arg) char *archive; long int (*function) (); long int arg; { #ifdef AIAMAG FL_HDR fl_header; #else int long_name = 0; #endif char *namemap = 0; register int desc = open (archive, O_RDONLY, 0); if (desc < 0) return -1; #ifdef SARMAG { char buf[SARMAG]; register int nread = read (desc, buf, SARMAG); if (nread != SARMAG || bcmp (buf, ARMAG, SARMAG)) { (void) close (desc); return -2; } } #else #ifdef AIAMAG { register int nread = read (desc, (char *) &fl_header, FL_HSZ); if (nread != FL_HSZ || bcmp (fl_header.fl_magic, AIAMAG, SAIAMAG)) { (void) close (desc); return -2; } } #else { #ifndef M_XENIX int buf; #else unsigned short int buf; #endif register int nread = read(desc, &buf, sizeof (buf)); if (nread != sizeof (buf) || buf != ARMAG) { (void) close (desc); return -2; } } #endif #endif /* Now find the members one by one. */ { #ifdef SARMAG register long int member_offset = SARMAG; #else #ifdef AIAMAG long int member_offset; long int last_member_offset; sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset); sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset); #else #ifndef M_XENIX register long int member_offset = sizeof (int); #else /* Xenix. */ register long int member_offset = sizeof (unsigned short int); #endif /* Not Xenix. */ #endif #endif while (1) { register int nread; struct ar_hdr member_header; #ifdef AIAMAG char name[256]; int name_len; long int dateval; int uidval, gidval; long int data_offset; #else char namebuf[sizeof member_header.ar_name + 1]; char *name; int is_namemap; /* Nonzero if this entry maps long names. */ #endif long int eltsize; int eltmode; long int fnval; if (lseek (desc, member_offset, 0) < 0) { (void) close (desc); return -2; } #ifdef AIAMAG #define AR_MEMHDR (AR_HDR_SIZE - sizeof (member_header._ar_name)) nread = read (desc, (char *) &member_header, AR_MEMHDR); if (nread != AR_MEMHDR) { (void) close (desc); return -2; } sscanf (member_header.ar_namlen, "%4d", &name_len); nread = read (desc, name, name_len); if (nread != name_len) { (void) close (desc); return -2; } name[name_len] = 0; sscanf (member_header.ar_date, "%12ld", &dateval); sscanf (member_header.ar_uid, "%12d", &uidval); sscanf (member_header.ar_gid, "%12d", &gidval); sscanf (member_header.ar_mode, "%12o", &eltmode); sscanf (member_header.ar_size, "%12ld", &eltsize); if ((data_offset = member_offset + AR_MEMHDR + name_len + 2) % 2) ++data_offset; fnval = (*function) (desc, name, 0, member_offset, data_offset, eltsize, dateval, uidval, gidval, eltmode, arg); #else /* Not AIAMAG. */ nread = read (desc, (char *) &member_header, AR_HDR_SIZE); if (nread == 0) /* No data left means end of file; that is OK. */ break; if (nread != AR_HDR_SIZE #ifdef ARFMAG || bcmp (member_header.ar_fmag, ARFMAG, 2) #endif ) { (void) close (desc); return -2; } name = namebuf; bcopy (member_header.ar_name, name, sizeof member_header.ar_name); { register char *p = name + sizeof member_header.ar_name; do *p = '\0'; while (p > name && *--p == ' '); #ifndef AIAMAG /* If the member name is "//" or "ARFILENAMES/" this may be a list of file name mappings. The maximum file name length supported by the standard archive format is 14 characters. This member will actually always be the first or second entry in the archive, but we don't check that. */ is_namemap = (!strcmp (name, "//") || !strcmp (name, "ARFILENAMES/")); #endif /* Not AIAMAG. */ /* On some systems, there is a slash after each member name. */ if (*p == '/') *p = '\0'; #ifndef AIAMAG /* If the member name starts with a space or a slash, this is an index into the file name mappings (used by GNU ar). Otherwise if the member name looks like #1/NUMBER the real member name appears in the element data (used by 4.4BSD). */ if (! is_namemap && (name[0] == ' ' || name[0] == '/') && namemap != 0) { name = namemap + atoi (name + 1); long_name = 1; } else if (name[0] == '#' && name[1] == '1' && name[2] == '/') { int namesize = atoi (name + 3); name = (char *) alloca (namesize + 1); nread = read (desc, name, namesize); if (nread != namesize) { close (desc); return -2; } name[namesize] = '\0'; long_name = 1; } #endif /* Not AIAMAG. */ } #ifndef M_XENIX sscanf (member_header.ar_mode, "%o", &eltmode); eltsize = atol (member_header.ar_size); #else /* Xenix. */ eltmode = (unsigned short int) member_header.ar_mode; eltsize = member_header.ar_size; #endif /* Not Xenix. */ fnval = (*function) (desc, name, ! long_name, member_offset, member_offset + AR_HDR_SIZE, eltsize, #ifndef M_XENIX atol (member_header.ar_date), atoi (member_header.ar_uid), atoi (member_header.ar_gid), #else /* Xenix. */ member_header.ar_date, member_header.ar_uid, member_header.ar_gid, #endif /* Not Xenix. */ eltmode, arg); #endif /* AIAMAG. */ if (fnval) { (void) close (desc); return fnval; } #ifdef AIAMAG if (member_offset == last_member_offset) /* End of the chain. */ break; sscanf (member_header.ar_nxtmem, "%12ld", &member_offset); if (lseek (desc, member_offset, 0) != member_offset) { (void) close (desc); return -2; } #else /* If this member maps archive names, we must read it in. The name map will always precede any members whose names must be mapped. */ if (is_namemap) { char *clear; char *limit; namemap = (char *) alloca (eltsize); nread = read (desc, namemap, eltsize); if (nread != eltsize) { (void) close (desc); return -2; } /* The names are separated by newlines. Some formats have a trailing slash. Null terminate the strings for convenience. */ limit = namemap + eltsize; for (clear = namemap; clear < limit; clear++) { if (*clear == '\n') { *clear = '\0'; if (clear[-1] == '/') clear[-1] = '\0'; } } is_namemap = 0; } member_offset += AR_HDR_SIZE + eltsize; if (member_offset % 2 != 0) member_offset++; #endif } } close (desc); return 0; } /* Return nonzero iff NAME matches MEM. If TRUNCATED is nonzero, MEM may be truncated to sizeof (struct ar_hdr.ar_name) - 1. */ int ar_name_equal (name, mem, truncated) char *name, *mem; int truncated; { char *p; p = rindex (name, '/'); if (p != 0) name = p + 1; /* We no longer use this kludge, since we now support long archive member names. */ #if 0 && !defined (AIAMAG) && !defined (APOLLO) { /* `reallylongname.o' matches `reallylongnam.o'. If member names have a trailing slash, that's `reallylongna.o'. */ struct ar_hdr h; unsigned int max = sizeof (h.ar_name); unsigned int namelen, memlen; if (strncmp (name, mem, max - 3)) return 0; namelen = strlen (name); memlen = strlen (mem); if (namelen > memlen && memlen >= max - 1 && name[namelen - 2] == '.' && name[namelen - 1] == 'o' && mem[memlen - 2] == '.' && mem[memlen - 1] == 'o') return 1; if (namelen != memlen) return 0; return (namelen < max - 3 || !strcmp (name + max - 3, mem + max - 3)); } #else /* AIX or APOLLO. */ if (truncated) { #ifdef AIAMAG /* TRUNCATED should never be set on this system. */ abort (); #else struct ar_hdr hdr; return !strncmp (name, mem, sizeof (hdr.ar_name) - 1); #endif } return !strcmp (name, mem); #endif } /* ARGSUSED */ static long int ar_member_pos (desc, mem, truncated, hdrpos, datapos, size, date, uid, gid, mode, name) int desc; char *mem; int truncated; long int hdrpos, datapos, size, date; int uid, gid, mode; char *name; { if (!ar_name_equal (name, mem, truncated)) return 0; return hdrpos; } /* Set date of member MEMNAME in archive ARNAME to current time. Returns 0 if successful, -1 if file ARNAME does not exist, -2 if not a valid archive, -3 if other random system call error (including file read-only), 1 if valid but member MEMNAME does not exist. */ int ar_member_touch (arname, memname) char *arname, *memname; { register long int pos = ar_scan (arname, ar_member_pos, (long int) memname); register int fd; struct ar_hdr ar_hdr; register int i; struct stat statbuf; if (pos < 0) return (int) pos; if (!pos) return 1; fd = open (arname, O_RDWR, 0666); if (fd < 0) return -3; /* Read in this member's header */ if (lseek (fd, pos, 0) < 0) goto lose; if (AR_HDR_SIZE != read (fd, (char *) &ar_hdr, AR_HDR_SIZE)) goto lose; /* Write back the header, thus touching the archive file. */ if (lseek (fd, pos, 0) < 0) goto lose; if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE)) goto lose; /* The file's mtime is the time we we want. */ fstat (fd, &statbuf); #if defined(ARFMAG) || defined(AIAMAG) /* Advance member's time to that time */ for (i = 0; i < sizeof ar_hdr.ar_date; i++) ar_hdr.ar_date[i] = ' '; sprintf (ar_hdr.ar_date, "%ld", (long int) statbuf.st_mtime); #ifdef AIAMAG ar_hdr.ar_date[strlen(ar_hdr.ar_date)] = ' '; #endif #else ar_hdr.ar_date = statbuf.st_mtime; #endif /* Write back this member's header */ if (lseek (fd, pos, 0) < 0) goto lose; if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE)) goto lose; close (fd); return 0; lose: i = errno; close (fd); errno = i; return -3; } #ifdef TEST long int describe_member (desc, name, truncated, hdrpos, datapos, size, date, uid, gid, mode) int desc; char *name; int truncated; long int hdrpos, datapos, size, date; int uid, gid, mode; { extern char *ctime (); printf ("Member `%s'%s: %ld bytes at %ld (%ld).\n", name, truncated ? " (name might be truncated)" : "", size, hdrpos, datapos); printf (" Date %s", ctime (&date)); printf (" uid = %d, gid = %d, mode = 0%o.\n", uid, gid, mode); return 0; } main (argc, argv) int argc; char **argv; { ar_scan (argv[1], describe_member); return 0; } #endif /* TEST. */ #endif /* NO_ARCHIVES. */ make-3.70/signame.c 777 12241 1 16412 5447406210 7246 /* Convert between signal names and numbers. Copyright (C) 1990, 1992, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include /* Some systems need this for . */ #include #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif /* Some systems do not define NSIG in . */ #ifndef NSIG #ifdef _NSIG #define NSIG _NSIG #else #define NSIG 32 #endif #endif #if !__STDC__ #define const #endif #include "signame.h" #ifndef HAVE_SYS_SIGLIST /* There is too much variation in Sys V signal numbers and names, so we must initialize them at runtime. */ static const char undoc[] = "unknown signal"; const char *sys_siglist[NSIG]; #else /* HAVE_SYS_SIGLIST. */ #ifndef SYS_SIGLIST_DECLARED extern char *sys_siglist[]; #endif /* Not SYS_SIGLIST_DECLARED. */ #endif /* Not HAVE_SYS_SIGLIST. */ /* Table of abbreviations for signals. Note: A given number can appear more than once with different abbreviations. */ typedef struct { int number; const char *abbrev; } num_abbrev; static num_abbrev sig_table[NSIG*2]; /* Number of elements of sig_table used. */ static int sig_table_nelts = 0; /* Enter signal number NUMBER into the tables with ABBREV and NAME. */ static void init_sig (number, abbrev, name) int number; const char *abbrev; const char *name; { #ifndef HAVE_SYS_SIGLIST sys_siglist[number] = name; #endif sig_table[sig_table_nelts].number = number; sig_table[sig_table_nelts++].abbrev = abbrev; } void signame_init () { #ifndef HAVE_SYS_SIGLIST int i; /* Initialize signal names. */ for (i = 0; i < NSIG; i++) sys_siglist[i] = undoc; #endif /* !HAVE_SYS_SIGLIST */ /* Initialize signal names. */ #if defined (SIGHUP) init_sig (SIGHUP, "HUP", "Hangup"); #endif #if defined (SIGINT) init_sig (SIGINT, "INT", "Interrupt"); #endif #if defined (SIGQUIT) init_sig (SIGQUIT, "QUIT", "Quit"); #endif #if defined (SIGILL) init_sig (SIGILL, "ILL", "Illegal Instruction"); #endif #if defined (SIGTRAP) init_sig (SIGTRAP, "TRAP", "Trace/breakpoint trap"); #endif /* If SIGIOT == SIGABRT, we want to print it as SIGABRT because SIGABRT is in ANSI and POSIX.1 and SIGIOT isn't. */ #if defined (SIGABRT) init_sig (SIGABRT, "ABRT", "Aborted"); #endif #if defined (SIGIOT) init_sig (SIGIOT, "IOT", "IOT trap"); #endif #if defined (SIGEMT) init_sig (SIGEMT, "EMT", "EMT trap"); #endif #if defined (SIGFPE) init_sig (SIGFPE, "FPE", "Floating point exception"); #endif #if defined (SIGKILL) init_sig (SIGKILL, "KILL", "Killed"); #endif #if defined (SIGBUS) init_sig (SIGBUS, "BUS", "Bus error"); #endif #if defined (SIGSEGV) init_sig (SIGSEGV, "SEGV", "Segmentation fault"); #endif #if defined (SIGSYS) init_sig (SIGSYS, "SYS", "Bad system call"); #endif #if defined (SIGPIPE) init_sig (SIGPIPE, "PIPE", "Broken pipe"); #endif #if defined (SIGALRM) init_sig (SIGALRM, "ALRM", "Alarm clock"); #endif #if defined (SIGTERM) init_sig (SIGTERM, "TERM", "Terminated"); #endif #if defined (SIGUSR1) init_sig (SIGUSR1, "USR1", "User defined signal 1"); #endif #if defined (SIGUSR2) init_sig (SIGUSR2, "USR2", "User defined signal 2"); #endif /* If SIGCLD == SIGCHLD, we want to print it as SIGCHLD because that is what is in POSIX.1. */ #if defined (SIGCHLD) init_sig (SIGCHLD, "CHLD", "Child exited"); #endif #if defined (SIGCLD) init_sig (SIGCLD, "CLD", "Child exited"); #endif #if defined (SIGPWR) init_sig (SIGPWR, "PWR", "Power failure"); #endif #if defined (SIGTSTP) init_sig (SIGTSTP, "TSTP", "Stopped"); #endif #if defined (SIGTTIN) init_sig (SIGTTIN, "TTIN", "Stopped (tty input)"); #endif #if defined (SIGTTOU) init_sig (SIGTTOU, "TTOU", "Stopped (tty output)"); #endif #if defined (SIGSTOP) init_sig (SIGSTOP, "STOP", "Stopped (signal)"); #endif #if defined (SIGXCPU) init_sig (SIGXCPU, "XCPU", "CPU time limit exceeded"); #endif #if defined (SIGXFSZ) init_sig (SIGXFSZ, "XFSZ", "File size limit exceeded"); #endif #if defined (SIGVTALRM) init_sig (SIGVTALRM, "VTALRM", "Virtual timer expired"); #endif #if defined (SIGPROF) init_sig (SIGPROF, "PROF", "Profiling timer expired"); #endif #if defined (SIGWINCH) /* "Window size changed" might be more accurate, but even if that is all that it means now, perhaps in the future it will be extended to cover other kinds of window changes. */ init_sig (SIGWINCH, "WINCH", "Window changed"); #endif #if defined (SIGCONT) init_sig (SIGCONT, "CONT", "Continued"); #endif #if defined (SIGURG) init_sig (SIGURG, "URG", "Urgent I/O condition"); #endif #if defined (SIGIO) /* "I/O pending" has also been suggested. A disadvantage is that signal only happens when the process has asked for it, not everytime I/O is pending. Another disadvantage is the confusion from giving it a different name than under Unix. */ init_sig (SIGIO, "IO", "I/O possible"); #endif #if defined (SIGWIND) init_sig (SIGWIND, "WIND", "SIGWIND"); #endif #if defined (SIGPHONE) init_sig (SIGPHONE, "PHONE", "SIGPHONE"); #endif #if defined (SIGPOLL) init_sig (SIGPOLL, "POLL", "I/O possible"); #endif #if defined (SIGLOST) init_sig (SIGLOST, "LOST", "Resource lost"); #endif #if defined (SIGDANGER) init_sig (SIGDANGER, "DANGER", "Danger signal"); #endif } /* Return the abbreviation for signal NUMBER. */ char * sig_abbrev (number) int number; { int i; if (sig_table_nelts == 0) signame_init (); for (i = 0; i < sig_table_nelts; i++) if (sig_table[i].number == number) return (char *)sig_table[i].abbrev; return NULL; } /* Return the signal number for an ABBREV, or -1 if there is no signal by that name. */ int sig_number (abbrev) const char *abbrev; { int i; if (sig_table_nelts == 0) signame_init (); /* Skip over "SIG" if present. */ if (abbrev[0] == 'S' && abbrev[1] == 'I' && abbrev[2] == 'G') abbrev += 3; for (i = 0; i < sig_table_nelts; i++) if (abbrev[0] == sig_table[i].abbrev[0] && strcmp (abbrev, sig_table[i].abbrev) == 0) return sig_table[i].number; return -1; } #ifndef HAVE_PSIGNAL /* Print to standard error the name of SIGNAL, preceded by MESSAGE and a colon, and followed by a newline. */ void psignal (signal, message) int signal; const char *message; { if (signal <= 0 || signal >= NSIG) fprintf (stderr, "%s: unknown signal", message); else fprintf (stderr, "%s: %s\n", message, sys_siglist[signal]); } #endif make-3.70/signame.h 777 12241 1 3430 5425036236 7232 /* Convert between signal names and numbers. Copyright (C) 1990, 1992, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #if defined (__STDC__) && __STDC__ /* Initialize `sys_siglist'. */ void signame_init (void); /* Return the abbreviation (e.g. ABRT, FPE, etc.) for signal NUMBER. Do not return this as a const char *. The caller might want to assign it to a char *. */ char *sig_abbrev (int number); /* Return the signal number for an ABBREV, or -1 if there is no signal by that name. */ int sig_number (const char *abbrev); /* Avoid conflicts with a system header file that might define these two. */ #ifndef HAVE_PSIGNAL /* Print to standard error the name of SIGNAL, preceded by MESSAGE and a colon, and followed by a newline. */ void psignal (int signal, const char *message); #endif #if !defined (HAVE_SYS_SIGLIST) /* Names for signals from 0 to NSIG-1. */ extern const char *sys_siglist[]; #endif #else void signame_init (); char *sig_abbrev (); int sig_number (); #if !defined (HAVE_SYS_SIGLIST) && !defined (HAVE_PSIGNAL) void psignal (); #endif #if !defined (HAVE_SYS_SIGLIST) extern char *sys_siglist[]; #endif #endif make-3.70/getopt.c 777 12241 1 52267 5506706214 7140 /* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu before changing it! Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * This tells Alpha OSF/1 not to define a getopt prototype in . * Ditto for AIX 3.2 and . */ #ifndef _NO_PROTO #define _NO_PROTO #endif #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ #include #endif /* GNU C library. */ /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a long-named option. Because this is not POSIX.2 compliant, it is being phased out. */ /* #define GETOPT_COMPAT */ /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg = 0; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* XXX 1003.2 says this must be 1 before any call. */ int optind = 0; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return EOF with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ #include #define my_index strchr #else /* Avoid depending on library functions or files whose names are inconsistent. */ char *getenv (); static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } /* If using GCC, we can safely declare strlen this way. If not using GCC, it is ok not to declare it. (Supposedly there are some machines where it might get a warning, but changing this conditional to __STDC__ is too risky.) */ #ifdef __GNUC__ #ifdef IN_GCC #include "gstddef.h" #else #include #endif extern size_t strlen (const char *); #endif #endif /* GNU C library. */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ static void exchange (argv) char **argv; { int bottom = first_nonopt; int middle = last_nonopt; int top = optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns `EOF'. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { int option_index; optarg = 0; /* Initialize the internal data when the first call is made. Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ if (optind == 0) { first_nonopt = last_nonopt = optind = 1; nextchar = NULL; /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (getenv ("POSIXLY_CORRECT") != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; } if (nextchar == NULL || *nextchar == '\0') { if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Now skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && (argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) optind++; last_nonopt = optind; } /* Special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return EOF; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if ((argv[optind][0] != '-' || argv[optind][1] == '\0') #ifdef GETOPT_COMPAT && (longopts == NULL || argv[optind][0] != '+' || argv[optind][1] == '\0') #endif /* GETOPT_COMPAT */ ) { if (ordering == REQUIRE_ORDER) return EOF; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Start decoding its characters. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } if (longopts != NULL && ((argv[optind][0] == '-' && (argv[optind][1] == '-' || long_only)) #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ )) { const struct option *p; char *s = nextchar; int exact = 0; int ambig = 0; const struct option *pfound = NULL; int indfound; while (*s && *s != '=') s++; /* Test all options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, s - nextchar)) { if (s - nextchar == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (opterr) fprintf (stderr, "%s: option `%s' is ambiguous\n", argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*s) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = s + 1; else { if (opterr) { if (argv[optind - 1][1] == '-') /* --option */ fprintf (stderr, "%s: option `--%s' doesn't allow an argument\n", argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, "%s: option `%c%s' doesn't allow an argument\n", argv[0], argv[optind - 1][0], pfound->name); } nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (opterr) fprintf (stderr, "%s: option `%s' requires an argument\n", argv[0], argv[optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' #ifdef GETOPT_COMPAT || argv[optind][0] == '+' #endif /* GETOPT_COMPAT */ || my_index (optstring, *nextchar) == NULL) { if (opterr) { if (argv[optind][1] == '-') /* --option */ fprintf (stderr, "%s: unrecognized option `--%s'\n", argv[0], nextchar); else /* +option or -option */ fprintf (stderr, "%s: unrecognized option `%c%s'\n", argv[0], argv[optind][0], nextchar); } nextchar = (char *) ""; optind++; return '?'; } } /* Look at and handle the next option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (opterr) { #if 0 if (c < 040 || c >= 0177) fprintf (stderr, "%s: unrecognized option, character code 0%o\n", argv[0], c); else fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c); #endif } optopt = c; return '?'; } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = 0; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (opterr) { #if 0 fprintf (stderr, "%s: option `-%c' requires an argument\n", argv[0], c); #else /* 1003.2 specifies the format of this message. */ fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], c); #endif } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == EOF) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ make-3.70/getopt1.c 777 12241 1 10640 5447406211 7204 /* getopt_long and getopt_long_only entry points for GNU getopt. Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include "getopt.h" #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ #include #else char *getenv (); #endif #ifndef NULL #define NULL 0 #endif int getopt_long (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 0); } /* Like getopt_long, but '-' as well as '--' can indicate a long option. If an option that starts with '-' (not '--') doesn't match a long option, but does match a short option, it is parsed as a short option instead. */ int getopt_long_only (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 1); } #endif /* _LIBC or not __GNU_LIBRARY__. */ #ifdef TEST #include int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; int option_index = 0; static struct option long_options[] = { {"add", 1, 0, 0}, {"append", 0, 0, 0}, {"delete", 1, 0, 0}, {"verbose", 0, 0, 0}, {"create", 0, 0, 0}, {"file", 1, 0, 0}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "abc:d:0123456789", long_options, &option_index); if (c == EOF) break; switch (c) { case 0: printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case 'd': printf ("option d with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ make-3.70/getopt.h 777 12241 1 10474 5372534261 7141 /* Declarations for getopt. Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program 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 2, or (at your option) any later version. This program 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 this program; if not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _GETOPT_H #define _GETOPT_H 1 #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns EOF, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { #if __STDC__ const char *name; #else char *name; #endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ #define no_argument 0 #define required_argument 1 #define optional_argument 2 #if __STDC__ #if defined(__GNU_LIBRARY__) /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int argc, char *const *argv, const char *shortopts); #else /* not __GNU_LIBRARY__ */ extern int getopt (); #endif /* not __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); extern int getopt_long_only (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind, int long_only); #else /* not __STDC__ */ extern int getopt (); extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); #endif /* not __STDC__ */ #ifdef __cplusplus } #endif #endif /* _GETOPT_H */ make-3.70/commands.h 666 12241 13 3211 5334565335 7433 /* Copyright (C) 1988, 1989, 1991, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Structure that gives the commands to make a file and information about where these commands came from. */ struct commands { char *filename; /* File that contains commands. */ unsigned int lineno; /* Line number in file. */ char *commands; /* Commands text. */ unsigned int ncommand_lines;/* Number of command lines. */ char **command_lines; /* Commands chopped up into lines. */ char *lines_flags; /* One set of flag bits for each line. */ int any_recurse; /* Nonzero if any `lines_recurse' elt has */ /* the COMMANDS_RECURSE bit set. */ }; /* Bits in `lines_flags'. */ #define COMMANDS_RECURSE 1 /* Recurses: + or $(MAKE). */ #define COMMANDS_SILENT 2 /* Silent: @. */ #define COMMANDS_NOERROR 4 /* No errors: -. */ extern void execute_file_commands (); extern void print_commands (); extern void delete_child_targets (); extern void chop_commands (); make-3.70/dep.h 666 12241 13 3765 5427363460 6416 /* Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Structure representing one dependency of a file. Each struct file's `deps' points to a chain of these, chained through the `next'. Note that the first two words of this match a struct nameseq. */ struct dep { struct dep *next; char *name; struct file *file; int changed; }; /* Structure used in chains of names, for parsing and globbing. */ struct nameseq { struct nameseq *next; char *name; }; extern struct nameseq *multi_glob (), *parse_file_seq (); extern char *tilde_expand (); #ifndef NO_ARCHIVES extern struct nameseq *ar_glob (); #endif #ifndef iAPX286 #define dep_name(d) ((d)->name == 0 ? (d)->file->name : (d)->name) #else /* Buggy compiler can't hack this. */ extern char *dep_name (); #endif extern struct dep *read_all_makefiles (); /* Flag bits for the second argument to `read_makefile'. These flags are saved in the `changed' field of each `struct dep' in the chain returned by `read_all_makefiles'. */ #define RM_NO_DEFAULT_GOAL (1 << 0) /* Do not set default goal. */ #define RM_INCLUDED (1 << 1) /* Search makefile search path. */ #define RM_DONTCARE (1 << 2) /* No error if it doesn't exist. */ #define RM_NO_TILDE (1 << 3) /* Don't expand ~ in file name. */ #define RM_NOFLAG 0 make-3.70/file.h 666 12241 13 10476 5463572326 6605 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Structure that represents the info on one file that the makefile says how to make. All of these are chained together through `next'. */ struct file { struct file *next; char *name; struct dep *deps; struct commands *cmds; /* Commands to execute for this target */ char *stem; /* Implicit stem, if an implicit rule has been used */ struct dep *also_make; /* Targets that are made by making this. */ time_t last_mtime; /* File's modtime, if already known. */ struct file *prev; /* Previous entry for same file name; used when there are multiple double-colon entries for the same file. */ /* File that this file was renamed to. After any time that a file could be renamed, call `check_renamed' (below). */ struct file *renamed; /* List of variable sets used for this file. */ struct variable_set_list *variables; /* Immediate dependent that caused this target to be remade, or nil if there isn't one. */ struct file *parent; short int update_status; /* Status of the last attempt to update, or -1 if none has been made. */ enum /* State of the commands. */ { /* Note: It is important that cs_not_started be zero. */ cs_not_started, /* Not yet started. */ cs_deps_running, /* Dep commands running. */ cs_running, /* Commands running. */ cs_finished /* Commands finished. */ } command_state ENUM_BITFIELD (2); unsigned int double_colon:1;/* Nonzero for double-colon entry */ unsigned int precious:1; /* Non-0 means don't delete file on quit */ unsigned int tried_implicit:1; /* Nonzero if have searched for implicit rule for making this file; don't search again. */ unsigned int updating:1; /* Nonzero while updating deps of this file */ unsigned int updated:1; /* Nonzero if this file has been remade. */ unsigned int is_target:1; /* Nonzero if file is described as target. */ unsigned int cmd_target:1; /* Nonzero if file was given on cmd line. */ unsigned int phony:1; /* Nonzero if this is a phony file i.e., a dependency of .PHONY. */ unsigned int intermediate:1;/* Nonzero if this is an intermediate file. */ unsigned int dontcare:1; /* Nonzero if no complaint is to be made if this target cannot be remade. */ }; /* Number of intermediate files entered. */ extern unsigned int num_intermediates; extern struct file *default_goal_file, *suffix_file, *default_file; extern struct file *lookup_file (), *enter_file (); extern void remove_intermediates (), snap_deps (); extern void rename_file (), file_hash_enter (); extern time_t f_mtime (); #define file_mtime_1(f, v) \ ((f)->last_mtime != (time_t) 0 ? (f)->last_mtime : f_mtime ((f), v)) #define file_mtime(f) file_mtime_1 ((f), 1) #define file_mtime_no_search(f) file_mtime_1 ((f), 0) /* Modtime value to use for `infinitely new'. We used to get the current time from the system and use that whenever we wanted `new'. But that causes trouble when the machine running make and the machine holding a file have different ideas about what time it is; and can also lose for `force' targets, which need to be considered newer than anything that depends on them, even if said dependents' modtimes are in the future. NOTE: This assumes 32-bit `time_t's, but I cannot think of a portable way to produce the largest representable integer of a given signed type. */ #define NEW_MTIME ((time_t) 0x7fffffff) #define check_renamed(file) \ while ((file)->renamed != 0) (file) = (file)->renamed /* No ; here. */ make-3.70/job.h 666 12241 13 3671 5457342101 6404 /* Copyright (C) 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Structure describing a running or dead child process. */ struct child { struct child *next; /* Link in the chain. */ struct file *file; /* File being remade. */ char **environment; /* Environment for commands. */ char **command_lines; /* Array of variable-expanded cmd lines. */ unsigned int command_line; /* Index into above. */ char *command_ptr; /* Ptr into command_lines[command_line]. */ pid_t pid; /* Child process's ID number. */ unsigned int remote:1; /* Nonzero if executing remotely. */ unsigned int noerror:1; /* Nonzero if commands contained a `-'. */ unsigned int good_stdin:1; /* Nonzero if this child has a good stdin. */ unsigned int deleted:1; /* Nonzero if targets have been deleted. */ }; extern struct child *children; extern void new_job (); extern void reap_children (); extern void start_waiting_jobs (); extern char **construct_command_argv (); extern void child_execute_job (); extern void exec_command (); extern unsigned int job_slots_used; #ifdef POSIX extern void unblock_sigs (); #else #ifdef HAVE_SIGSETMASK extern int fatal_signal_mask; #define unblock_sigs() sigsetmask (0) #else #define unblock_sigs() #endif #endif make-3.70/make.h 666 12241 13 20026 5463606652 6573 /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* AIX requires this to be the first thing in the file. */ #if defined (_AIX) && !defined (__GNUC__) #pragma alloca #endif /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because make.h was found in $srcdir). */ #include #undef HAVE_CONFIG_H #define HAVE_CONFIG_H #ifdef CRAY /* This must happen before #include so that the declaration therein is changed. */ #define signal bsdsignal #endif #define _GNU_SOURCE #include #include #include #include #include #ifdef HAVE_SYS_TIMEB_H /* SCO 3.2 "devsys 4.2" has a prototype for `ftime' in that bombs unless has been included first. Does every system have a ? If any does not, configure should check for it. */ #include #endif #include #include #ifndef errno extern int errno; #endif #ifndef isblank #define isblank(c) ((c) == ' ' || (c) == '\t') #endif #ifdef HAVE_UNISTD_H #include #ifdef _POSIX_VERSION #define POSIX #endif #endif /* Some systems define _POSIX_VERSION but are not really POSIX.1. */ #if (defined (butterfly) || \ (defined (__mips) && defined (_SYSTYPE_SVR3)) || \ (defined (sequent) && defined (i386))) #undef POSIX #endif #if !defined (POSIX) && defined (_AIX) && defined (_POSIX_SOURCE) #define POSIX #endif #if !defined (HAVE_SYS_SIGLIST) && defined (HAVE__SYS_SIGLIST) #define sys_siglist _sys_siglist #define HAVE_SYS_SIGLIST /* Now we have it. */ /* It was declared in , with who knows what type. Don't declare it again and risk conflicting. */ #define SYS_SIGLIST_DECLARED #endif #ifdef HAVE_SYS_SIGLIST #ifndef SYS_SIGLIST_DECLARED extern char *sys_siglist[]; #endif #else #include "signame.h" #endif /* Some systems do not define NSIG in . */ #ifndef NSIG #ifdef _NSIG #define NSIG _NSIG #else #define NSIG 32 #endif #endif #ifndef RETSIGTYPE #define RETSIGTYPE void #endif #ifndef sigmask #define sigmask(sig) (1 << ((sig) - 1)) #endif #ifdef HAVE_LIMITS_H #include #endif #ifdef HAVE_SYS_PARAM_H #include #endif #ifndef PATH_MAX #ifndef POSIX #define PATH_MAX MAXPATHLEN #endif /* Not POSIX. */ #endif /* No PATH_MAX. */ #ifndef MAXPATHLEN #define MAXPATHLEN 1024 #endif /* No MAXPATHLEN. */ #ifdef PATH_MAX #define GET_PATH_MAX PATH_MAX #define PATH_VAR(var) char var[PATH_MAX] #else #define NEED_GET_PATH_MAX extern unsigned int get_path_max (); #define GET_PATH_MAX (get_path_max ()) #define PATH_VAR(var) char *var = (char *) alloca (GET_PATH_MAX) #endif #ifdef STAT_MACROS_BROKEN #ifdef S_ISREG #undef S_ISREG #endif #ifdef S_ISDIR #undef S_ISDIR #endif #endif /* STAT_MACROS_BROKEN. */ #ifndef S_ISREG #define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) #endif #ifndef S_ISDIR #define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) #endif #if (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__)) #include #include #define ANSI_STRING #else /* No standard headers. */ #ifdef HAVE_STRING_H #include #define ANSI_STRING #else #include #endif #ifdef HAVE_MEMORY_H #include #endif extern char *malloc (), *realloc (); extern void free (); extern void qsort (); extern void abort (), exit (); #endif /* Standard headers. */ #ifdef ANSI_STRING #ifndef index #define index(s, c) strchr((s), (c)) #endif #ifndef rindex #define rindex(s, c) strrchr((s), (c)) #endif #ifndef bcmp #define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) #endif #ifndef bzero #define bzero(s, n) memset ((s), 0, (n)) #endif #ifndef bcopy #define bcopy(s, d, n) memcpy ((d), (s), (n)) #endif #else /* Not ANSI_STRING. */ #ifndef bcmp extern int bcmp (); #endif #ifndef bzero extern void bzero (); #endif #ifndef bcopy extern void bcopy (); #endif #endif /* ANSI_STRING. */ #undef ANSI_STRING #ifdef __GNUC__ #undef alloca #define alloca(n) __builtin_alloca (n) #else /* Not GCC. */ #ifdef HAVE_ALLOCA_H #include #else /* Not HAVE_ALLOCA_H. */ #ifndef _AIX extern char *alloca (); #endif /* Not AIX. */ #endif /* HAVE_ALLOCA_H. */ #endif /* GCC. */ #ifndef iAPX286 #define streq(a, b) \ ((a) == (b) || \ (*(a) == *(b) && (*(a) == '\0' || !strcmp ((a) + 1, (b) + 1)))) #else /* Buggy compiler can't handle this. */ #define streq(a, b) (strcmp ((a), (b)) == 0) #endif /* Add to VAR the hashing value of C, one character in a name. */ #define HASH(var, c) \ ((var += (c)), (var = ((var) << 7) + ((var) >> 20))) #if defined(__GNUC__) || defined(ENUM_BITFIELDS) #define ENUM_BITFIELD(bits) :bits #else #define ENUM_BITFIELD(bits) #endif extern void die (); extern void message (), fatal (), error (); extern void makefile_error (), makefile_fatal (); extern void pfatal_with_name (), perror_with_name (); extern char *savestring (), *concat (); extern char *xmalloc (), *xrealloc (); extern char *find_next_token (), *next_token (), *end_of_token (); extern void collapse_continuations (), remove_comments (); extern char *sindex (), *lindex (); extern int alpha_compare (); extern void print_spaces (); extern struct dep *copy_dep_chain (); extern char *find_percent (); #ifndef NO_ARCHIVES extern int ar_name (); extern void ar_parse_name (); extern int ar_touch (); extern time_t ar_member_date (); #endif extern void dir_load (); extern int dir_file_exists_p (), file_exists_p (), file_impossible_p (); extern void file_impossible (); extern char *dir_name (); extern void define_default_variables (); extern void set_default_suffixes (), install_default_suffix_rules (); extern void install_default_implicit_rules (), count_implicit_rule_limits (); extern void convert_to_pattern (), create_pattern_rule (); extern void build_vpath_lists (), construct_vpath_list (); extern int vpath_search (); extern void construct_include_path (); extern void uniquize_deps (); extern int update_goal_chain (); extern void notice_finished_file (); extern void user_access (), make_access (), child_access (); #ifdef HAVE_VFORK_H #include #endif #if !defined (__GNU_LIBRARY__) && !defined (POSIX) #ifdef HAVE_SIGSETMASK extern int sigsetmask (); extern int sigblock (); #endif extern int kill (); extern int atoi (); extern long int atol (); extern int unlink (), stat (), fstat (); extern int pipe (), close (), read (), write (), open (); extern long int lseek (); #endif /* Not GNU C library or POSIX. */ #ifdef HAVE_GETCWD extern char *getcwd (); #else extern char *getwd (); #define getcwd(buf, len) getwd (buf) #endif extern char **environ; extern char *reading_filename; extern unsigned int *reading_lineno_ptr; extern int just_print_flag, silent_flag, ignore_errors_flag, keep_going_flag; extern int debug_flag, print_data_base_flag, question_flag, touch_flag; extern int env_overrides, no_builtin_rules_flag, print_version_flag; extern int print_directory_flag, warn_undefined_variables_flag; extern unsigned int job_slots; extern double max_load_average; extern char *program; extern char *starting_directory; extern unsigned int makelevel; extern char *version_string, *remote_description; extern unsigned int commands_started; extern int handling_fatal_signal; #define DEBUGPR(msg) \ do if (debug_flag) { print_spaces (depth); printf (msg, file->name); \ fflush (stdout); } while (0) make-3.70/rule.h 666 12241 13 3265 5414413335 6601 /* Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Structure used for pattern rules. */ struct rule { struct rule *next; char **targets; /* Targets of the rule. */ unsigned int *lens; /* Lengths of each target. */ char **suffixes; /* Suffixes (after `%') of each target. */ struct dep *deps; /* Dependencies of the rule. */ struct commands *cmds; /* Commands to execute. */ char terminal; /* If terminal (double-colon). */ char in_use; /* If in use by a parent pattern_search. */ }; /* For calling install_pattern_rule. */ struct pspec { char *target, *dep, *commands; }; extern struct rule *pattern_rules; extern struct rule *last_pattern_rule; extern unsigned int num_pattern_rules; extern unsigned int max_pattern_deps; extern unsigned int max_pattern_targets; extern unsigned int max_pattern_dep_length; extern struct file *suffix_file; extern unsigned int maxsuffix; extern void install_pattern_rule (); int new_pattern_rule (); make-3.70/variable.h 666 12241 13 6672 5315724111 7421 /* Copyright (C) 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Codes in a variable definition saying where the definition came from. Increasing numeric values signify less-overridable definitions. */ enum variable_origin { o_default, /* Variable from the default set. */ o_env, /* Variable from environment. */ o_file, /* Variable given in a makefile. */ o_env_override, /* Variable from environment, if -e. */ o_command, /* Variable given by user. */ o_override, /* Variable from an `override' directive. */ o_automatic, /* Automatic variable -- cannot be set. */ o_invalid /* Core dump time. */ }; /* Structure that represents one variable definition. Each bucket of the hash table is a chain of these, chained through `next'. */ struct variable { struct variable *next; /* Link in the chain. */ char *name; /* Variable name. */ char *value; /* Variable value. */ enum variable_origin origin ENUM_BITFIELD (3); /* Variable origin. */ unsigned int recursive:1; /* Gets recursively re-evaluated. */ unsigned int expanding:1; /* Nonzero if currently being expanded. */ enum { v_export, /* Export this variable. */ v_noexport, /* Don't export this variable. */ v_ifset, /* Export it if it has a non-default value. */ v_default /* Decide in target_environment. */ } export ENUM_BITFIELD (2); }; /* Structure that represents a variable set. */ struct variable_set { struct variable **table; /* Hash table of variables. */ unsigned int buckets; /* Number of hash buckets in `table'. */ }; /* Structure that represents a list of variable sets. */ struct variable_set_list { struct variable_set_list *next; /* Link in the chain. */ struct variable_set *set; /* Variable set. */ }; extern struct variable_set_list *current_variable_set_list; extern void push_new_variable_scope (), pop_variable_scope (); extern int handle_function (); extern char *variable_buffer_output (); extern char *variable_expand (), *variable_expand_for_file (); extern char *allocated_variable_expand_for_file (); #define allocated_variable_expand(line) \ allocated_variable_expand_for_file (line, (struct file *) 0) extern char *expand_argument (); extern void define_automatic_variables (); extern void initialize_file_variables (); extern void print_file_variables (); extern void merge_variable_set_lists (); extern struct variable *try_variable_definition (); extern struct variable *lookup_variable (), *define_variable (); extern struct variable *define_variable_for_file (); extern int pattern_matches (); extern char *subst_expand (), *patsubst_expand (), *recursively_expand (); extern char **target_environment (); extern int export_all_variables; make-3.70/alloca.c 777 12120 1 33333 5447406222 7056 /* alloca.c -- allocate automatically reclaimed memory (Mostly) portable public-domain implementation -- D A Gwyn This implementation of the PWB library alloca function, which is used to allocate space off the run-time stack so that it is automatically reclaimed upon procedure exit, was inspired by discussions with J. Q. Johnson of Cornell. J.Otto Tennant contributed the Cray support. There are some preprocessor constants that can be defined when compiling for your specific system, for improved efficiency; however, the defaults should be okay. The general concept of this implementation is to keep track of all alloca-allocated blocks, and reclaim any that are found to be deeper in the stack than the current invocation. This heuristic does not reclaim storage as soon as it becomes invalid, but it will do so eventually. As a special case, alloca(0) reclaims storage without allocating any. It is a good idea to use alloca(0) in your main control loop, etc. to force garbage collection. */ #ifdef HAVE_CONFIG_H #if defined (emacs) || defined (CONFIG_BROKETS) #include #else #include "config.h" #endif #endif /* If compiling with GCC 2, this file's not needed. */ #if !defined (__GNUC__) || __GNUC__ < 2 /* If someone has defined alloca as a macro, there must be some other way alloca is supposed to work. */ #ifndef alloca #ifdef emacs #ifdef static /* actually, only want this if static is defined as "" -- this is for usg, in which emacs must undefine static in order to make unexec workable */ #ifndef STACK_DIRECTION you lose -- must know STACK_DIRECTION at compile-time #endif /* STACK_DIRECTION undefined */ #endif /* static */ #endif /* emacs */ /* If your stack is a linked list of frames, you have to provide an "address metric" ADDRESS_FUNCTION macro. */ #if defined (CRAY) && defined (CRAY_STACKSEG_END) long i00afunc (); #define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) #else #define ADDRESS_FUNCTION(arg) &(arg) #endif #if __STDC__ typedef void *pointer; #else typedef char *pointer; #endif #define NULL 0 /* Different portions of Emacs need to call different versions of malloc. The Emacs executable needs alloca to call xmalloc, because ordinary malloc isn't protected from input signals. On the other hand, the utilities in lib-src need alloca to call malloc; some of them are very simple, and don't have an xmalloc routine. Non-Emacs programs expect this to call use xmalloc. Callers below should use malloc. */ #ifndef emacs #define malloc xmalloc #endif extern pointer malloc (); /* Define STACK_DIRECTION if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #ifndef STACK_DIRECTION #define STACK_DIRECTION 0 /* Direction unknown. */ #endif #if STACK_DIRECTION != 0 #define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ #else /* STACK_DIRECTION == 0; need run-time code. */ static int stack_dir; /* 1 or -1 once known. */ #define STACK_DIR stack_dir static void find_stack_direction () { static char *addr = NULL; /* Address of first `dummy', once known. */ auto char dummy; /* To get stack address. */ if (addr == NULL) { /* Initial entry. */ addr = ADDRESS_FUNCTION (dummy); find_stack_direction (); /* Recurse once. */ } else { /* Second entry. */ if (ADDRESS_FUNCTION (dummy) > addr) stack_dir = 1; /* Stack grew upward. */ else stack_dir = -1; /* Stack grew downward. */ } } #endif /* STACK_DIRECTION == 0 */ /* An "alloca header" is used to: (a) chain together all alloca'ed blocks; (b) keep track of stack depth. It is very important that sizeof(header) agree with malloc alignment chunk size. The following default should work okay. */ #ifndef ALIGN_SIZE #define ALIGN_SIZE sizeof(double) #endif typedef union hdr { char align[ALIGN_SIZE]; /* To force sizeof(header). */ struct { union hdr *next; /* For chaining headers. */ char *deep; /* For stack depth measure. */ } h; } header; static header *last_alloca_header = NULL; /* -> last alloca header. */ /* Return a pointer to at least SIZE bytes of storage, which will be automatically reclaimed upon exit from the procedure that called alloca. Originally, this space was supposed to be taken from the current stack frame of the caller, but that method cannot be made to work for some implementations of C, for example under Gould's UTX/32. */ pointer alloca (size) unsigned size; { auto char probe; /* Probes stack depth: */ register char *depth = ADDRESS_FUNCTION (probe); #if STACK_DIRECTION == 0 if (STACK_DIR == 0) /* Unknown growth direction. */ find_stack_direction (); #endif /* Reclaim garbage, defined as all alloca'd storage that was allocated from deeper in the stack than currently. */ { register header *hp; /* Traverses linked list. */ for (hp = last_alloca_header; hp != NULL;) if ((STACK_DIR > 0 && hp->h.deep > depth) || (STACK_DIR < 0 && hp->h.deep < depth)) { register header *np = hp->h.next; free ((pointer) hp); /* Collect garbage. */ hp = np; /* -> next header. */ } else break; /* Rest are not deeper. */ last_alloca_header = hp; /* -> last valid storage. */ } if (size == 0) return NULL; /* No allocation required. */ /* Allocate combined header + user data storage. */ { register pointer new = malloc (sizeof (header) + size); /* Address of header. */ ((header *) new)->h.next = last_alloca_header; ((header *) new)->h.deep = depth; last_alloca_header = (header *) new; /* User storage begins just after header. */ return (pointer) ((char *) new + sizeof (header)); } } #if defined (CRAY) && defined (CRAY_STACKSEG_END) #ifdef DEBUG_I00AFUNC #include #endif #ifndef CRAY_STACK #define CRAY_STACK #ifndef CRAY2 /* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ struct stack_control_header { long shgrow:32; /* Number of times stack has grown. */ long shaseg:32; /* Size of increments to stack. */ long shhwm:32; /* High water mark of stack. */ long shsize:32; /* Current size of stack (all segments). */ }; /* The stack segment linkage control information occurs at the high-address end of a stack segment. (The stack grows from low addresses to high addresses.) The initial part of the stack segment linkage control information is 0200 (octal) words. This provides for register storage for the routine which overflows the stack. */ struct stack_segment_linkage { long ss[0200]; /* 0200 overflow words. */ long sssize:32; /* Number of words in this segment. */ long ssbase:32; /* Offset to stack base. */ long:32; long sspseg:32; /* Offset to linkage control of previous segment of stack. */ long:32; long sstcpt:32; /* Pointer to task common address block. */ long sscsnm; /* Private control structure number for microtasking. */ long ssusr1; /* Reserved for user. */ long ssusr2; /* Reserved for user. */ long sstpid; /* Process ID for pid based multi-tasking. */ long ssgvup; /* Pointer to multitasking thread giveup. */ long sscray[7]; /* Reserved for Cray Research. */ long ssa0; long ssa1; long ssa2; long ssa3; long ssa4; long ssa5; long ssa6; long ssa7; long sss0; long sss1; long sss2; long sss3; long sss4; long sss5; long sss6; long sss7; }; #else /* CRAY2 */ /* The following structure defines the vector of words returned by the STKSTAT library routine. */ struct stk_stat { long now; /* Current total stack size. */ long maxc; /* Amount of contiguous space which would be required to satisfy the maximum stack demand to date. */ long high_water; /* Stack high-water mark. */ long overflows; /* Number of stack overflow ($STKOFEN) calls. */ long hits; /* Number of internal buffer hits. */ long extends; /* Number of block extensions. */ long stko_mallocs; /* Block allocations by $STKOFEN. */ long underflows; /* Number of stack underflow calls ($STKRETN). */ long stko_free; /* Number of deallocations by $STKRETN. */ long stkm_free; /* Number of deallocations by $STKMRET. */ long segments; /* Current number of stack segments. */ long maxs; /* Maximum number of stack segments so far. */ long pad_size; /* Stack pad size. */ long current_address; /* Current stack segment address. */ long current_size; /* Current stack segment size. This number is actually corrupted by STKSTAT to include the fifteen word trailer area. */ long initial_address; /* Address of initial segment. */ long initial_size; /* Size of initial segment. */ }; /* The following structure describes the data structure which trails any stack segment. I think that the description in 'asdef' is out of date. I only describe the parts that I am sure about. */ struct stk_trailer { long this_address; /* Address of this block. */ long this_size; /* Size of this block (does not include this trailer). */ long unknown2; long unknown3; long link; /* Address of trailer block of previous segment. */ long unknown5; long unknown6; long unknown7; long unknown8; long unknown9; long unknown10; long unknown11; long unknown12; long unknown13; long unknown14; }; #endif /* CRAY2 */ #endif /* not CRAY_STACK */ #ifdef CRAY2 /* Determine a "stack measure" for an arbitrary ADDRESS. I doubt that "lint" will like this much. */ static long i00afunc (long *address) { struct stk_stat status; struct stk_trailer *trailer; long *block, size; long result = 0; /* We want to iterate through all of the segments. The first step is to get the stack status structure. We could do this more quickly and more directly, perhaps, by referencing the $LM00 common block, but I know that this works. */ STKSTAT (&status); /* Set up the iteration. */ trailer = (struct stk_trailer *) (status.current_address + status.current_size - 15); /* There must be at least one stack segment. Therefore it is a fatal error if "trailer" is null. */ if (trailer == 0) abort (); /* Discard segments that do not contain our argument address. */ while (trailer != 0) { block = (long *) trailer->this_address; size = trailer->this_size; if (block == 0 || size == 0) abort (); trailer = (struct stk_trailer *) trailer->link; if ((block <= address) && (address < (block + size))) break; } /* Set the result to the offset in this segment and add the sizes of all predecessor segments. */ result = address - block; if (trailer == 0) { return result; } do { if (trailer->this_size <= 0) abort (); result += trailer->this_size; trailer = (struct stk_trailer *) trailer->link; } while (trailer != 0); /* We are done. Note that if you present a bogus address (one not in any segment), you will get a different number back, formed from subtracting the address of the first block. This is probably not what you want. */ return (result); } #else /* not CRAY2 */ /* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. Determine the number of the cell within the stack, given the address of the cell. The purpose of this routine is to linearize, in some sense, stack addresses for alloca. */ static long i00afunc (long address) { long stkl = 0; long size, pseg, this_segment, stack; long result = 0; struct stack_segment_linkage *ssptr; /* Register B67 contains the address of the end of the current stack segment. If you (as a subprogram) store your registers on the stack and find that you are past the contents of B67, you have overflowed the segment. B67 also points to the stack segment linkage control area, which is what we are really interested in. */ stkl = CRAY_STACKSEG_END (); ssptr = (struct stack_segment_linkage *) stkl; /* If one subtracts 'size' from the end of the segment, one has the address of the first word of the segment. If this is not the first segment, 'pseg' will be nonzero. */ pseg = ssptr->sspseg; size = ssptr->sssize; this_segment = stkl - size; /* It is possible that calling this routine itself caused a stack overflow. Discard stack segments which do not contain the target address. */ while (!(this_segment <= address && address <= stkl)) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); #endif if (pseg == 0) break; stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; this_segment = stkl - size; } result = address - this_segment; /* If you subtract pseg from the current end of the stack, you get the address of the previous stack segment's end. This seems a little convoluted to me, but I'll bet you save a cycle somewhere. */ while (pseg != 0) { #ifdef DEBUG_I00AFUNC fprintf (stderr, "%011o %011o\n", pseg, size); #endif stkl = stkl - pseg; ssptr = (struct stack_segment_linkage *) stkl; size = ssptr->sssize; pseg = ssptr->sspseg; result += size; } return (result); } #endif /* not CRAY2 */ #endif /* CRAY */ #endif /* no alloca */ #endif /* not GCC version 2 */ make-3.70/config.h.in 666 12241 13 13117 5506427031 7521 /* config.h.in. Generated automatically from configure.in by autoheader. */ /* Define if on AIX 3. System headers sometimes define this. We just want to avoid a redefinition error message. */ #ifndef _ALL_SOURCE #undef _ALL_SOURCE #endif /* Define if using alloca.c. */ #undef C_ALLOCA /* Define to empty if the keyword does not work. */ #undef const /* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. This function is required for alloca.c support on those systems. */ #undef CRAY_STACKSEG_END /* Define for DGUX with . */ #undef DGUX /* Define if you have dirent.h. */ #undef DIRENT /* Define to the type of elements in the array set by `getgroups'. Usually this is either `int' or `gid_t'. */ #undef GETGROUPS_T /* Define if the `getloadavg' function needs to be run setuid or setgid. */ #undef GETLOADAVG_PRIVILEGED /* Define to `int' if doesn't define. */ #undef gid_t /* Define if you have alloca.h and it should be used (not Ultrix). */ #undef HAVE_ALLOCA_H /* Define if your system has its own `getloadavg' function. */ #undef HAVE_GETLOADAVG /* Define if you have the strcoll function and it is properly defined. */ #undef HAVE_STRCOLL /* Define if `union wait' is the type of the first arg to wait functions. */ #undef HAVE_UNION_WAIT /* Define if you have vfork.h. */ #undef HAVE_VFORK_H /* Define if on MINIX. */ #undef _MINIX /* Define if you don't have dirent.h, but have ndir.h. */ #undef NDIR /* Define if your struct nlist has an n_un member. */ #undef NLIST_NAME_UNION /* Define if you have nlist.h. */ #undef NLIST_STRUCT /* Define if your C compiler doesn't accept -c and -o together. */ #undef NO_MINUS_C_MINUS_O /* Define to `int' if doesn't define. */ #undef pid_t /* Define if the system does not provide POSIX.1 features except with this defined. */ #undef _POSIX_1_SOURCE /* Define if you need to in order for stat and other things to work. */ #undef _POSIX_SOURCE /* Define as the return type of signal handlers (int or void). */ #undef RETSIGTYPE /* Define if the setvbuf function takes the buffering type as its second argument and the buffer pointer as the third, as on System V before release 3. */ #undef SETVBUF_REVERSED /* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION /* Define if the `S_IS*' macros in do not work properly. */ #undef STAT_MACROS_BROKEN /* Define if you have the ANSI C header files. */ #undef STDC_HEADERS /* Define on System V Release 4. */ #undef SVR4 /* Define if you don't have dirent.h, but have sys/dir.h. */ #undef SYSDIR /* Define if you don't have dirent.h, but have sys/ndir.h. */ #undef SYSNDIR /* Define if `sys_siglist' is declared by . */ #undef SYS_SIGLIST_DECLARED /* Define to `int' if doesn't define. */ #undef uid_t /* Define for Encore UMAX. */ #undef UMAX /* Define for Encore UMAX 4.3 that has instead of . */ #undef UMAX4_3 /* Define vfork as fork if vfork does not work. */ #undef vfork /* Define if the closedir function returns void instead of int. */ #undef VOID_CLOSEDIR /* Define to the name of the SCCS `get' command. */ #undef SCCS_GET /* Define this if the SCCS `get' command understands the `-G' option. */ #undef SCCS_GET_MINUS_G /* Define if you have _sys_siglist. */ #undef HAVE__SYS_SIGLIST /* Define if you have dup2. */ #undef HAVE_DUP2 /* Define if you have getcwd. */ #undef HAVE_GETCWD /* Define if you have getdtablesize. */ #undef HAVE_GETDTABLESIZE /* Define if you have getgroups. */ #undef HAVE_GETGROUPS /* Define if you have psignal. */ #undef HAVE_PSIGNAL /* Define if you have setlinebuf. */ #undef HAVE_SETLINEBUF /* Define if you have setregid. */ #undef HAVE_SETREGID /* Define if you have setreuid. */ #undef HAVE_SETREUID /* Define if you have sigsetmask. */ #undef HAVE_SIGSETMASK /* Define if you have strerror. */ #undef HAVE_STRERROR /* Define if you have sys_siglist. */ #undef HAVE_SYS_SIGLIST /* Define if you have wait3. */ #undef HAVE_WAIT3 /* Define if you have waitpid. */ #undef HAVE_WAITPID /* Define if you have the header file. */ #undef HAVE_FCNTL_H /* Define if you have the header file. */ #undef HAVE_LIMITS_H /* Define if you have the header file. */ #undef HAVE_MACH_MACH_H /* Define if you have the header file. */ #undef HAVE_MEMORY_H /* Define if you have the header file. */ #undef HAVE_STRING_H /* Define if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define if you have the header file. */ #undef HAVE_SYS_TIMEB_H /* Define if you have the header file. */ #undef HAVE_SYS_WAIT_H /* Define if you have the header file. */ #undef HAVE_UNISTD_H /* Define if you have the dgc library (-ldgc). */ #undef HAVE_DGC /* Define if you have the elf library (-lelf). */ #undef HAVE_ELF /* Define if you have the getloadavg library (-lgetloadavg). */ #undef HAVE_GETLOADAVG /* Define if you have the kvm library (-lkvm). */ #undef HAVE_KVM /* Define if you have the seq library (-lseq). */ #undef HAVE_SEQ /* Define if you have the sun library (-lsun). */ #undef HAVE_SUN /* Define if you have the util library (-lutil). */ #undef HAVE_UTIL make-3.70/remote-stub.c 666 12241 13 5135 5431547004 10071 /* Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. This file is part of GNU Make. GNU Make 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 2, or (at your option) any later version. GNU Make 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 Make; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "make.h" #include "commands.h" char *remote_description = 0; /* Return nonzero if the next job should be done remotely. */ int start_remote_job_p () { return 0; } /* Start a remote job running the command in ARGV, with environment from ENVP. It gets standard input from STDIN_FD. On failure, return nonzero. On success, return zero, and set *USED_STDIN to nonzero if it will actually use STDIN_FD, zero if not, set *ID_PTR to a unique identification, and set *IS_REMOTE to zero if the job is local, nonzero if it is remote (meaning *ID_PTR is a process ID). */ int start_remote_job (argv, envp, stdin_fd, is_remote, id_ptr, used_stdin) char **argv, **envp; int stdin_fd; int *is_remote; int *id_ptr; int *used_stdin; { return -1; } /* Get the status of a dead remote child. Block waiting for one to die if BLOCK is nonzero. Set *EXIT_CODE_PTR to the exit status, *SIGNAL_PTR to the termination signal or zero if it exited normally, and *COREDUMP_PTR nonzero if it dumped core. Return the ID of the child that died, 0 if we would have to block and !BLOCK, or < 0 if there were none. */ int remote_status (exit_code_ptr, signal_ptr, coredump_ptr, block) int *exit_code_ptr, *signal_ptr, *coredump_ptr; int block; { errno = ECHILD; return -1; } /* Block asynchronous notification of remote child death. If this notification is done by raising the child termination signal, do not block that signal. */ void block_remote_children () { return; } /* Restore asynchronous notification of remote child death. If this is done by raising the child termination signal, do not unblock that signal. */ void unblock_remote_children () { return; } /* Send signal SIG to child ID. Return 0 if successful, -1 if not. */ int remote_kill (id, sig) int id; int sig; { return -1; } make-3.70/glob/COPYING.LIB 777 12241 13 61261 5022523171 10062 GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS Appendix: How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! make-3.70/glob/Makefile.in 666 12241 13 3372 5365610424 10453 # Makefile for standalone distribution of libglob.a (fnmatch, glob). # Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. # This file is part of the GNU C Library. # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Library General Public License # as published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # This library 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 # Library General Public License for more details. # You should have received a copy of the GNU Library General Public # License along with this library; see the file COPYING.LIB. If # not, write to the Free Software Foundation, Inc., 675 Mass Ave, # Cambridge, MA 02139, USA. # Ultrix 2.2 make doesn't expand the value of VPATH. VPATH = @srcdir@ srcdir = $(VPATH) CPPFLAGS = @DEFS@ # How the invoke ar. AR = ar ARFLAGS = rv # How to invoke ranlib. RANLIB = @RANLIB@ .PHONY: all all: libglob.a libglob.a: glob.o fnmatch.o $(AR) $(ARFLAGS) $@ glob.o fnmatch.o $(RANLIB) $@ # For some reason, Unix make wants the dependencies on the source files. # Otherwise it refuses to use an implicit rule! # And, get this: it doesn't work to use $(srcdir)/foo.c!! glob.o: $(srcdir)/glob.h $(srcdir)/fnmatch.h glob.c fnmatch.o: $(srcdir)/fnmatch.h fnmatch.c .c.o: $(CC) -I. -I$(srcdir) -c $(CPPFLAGS) $(CFLAGS) $< $(OUTPUT_OPTION) .PHONY: clean realclean glob-clean glob-realclean clean glob-clean: -rm -f libglob.a *.o core realclean glob-realclean: clean -rm -f TAGS tags Makefile # For inside the C library. glob.tar glob.tar.Z: $(MAKE) -C .. $@ make-3.70/glob/glob.c 777 12241 13 37450 5432540371 7522 /* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* AIX requires this to be the first thing in the file. */ #if defined (_AIX) && !defined (__GNUC__) #pragma alloca #endif #ifdef HAVE_CONFIG_H #include #endif #include #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) #ifdef STDC_HEADERS #include #endif #ifdef HAVE_UNISTD_H #include #ifndef POSIX #ifdef _POSIX_VERSION #define POSIX #endif #endif #endif #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS) extern int errno; #endif #ifndef NULL #define NULL 0 #endif #if defined (POSIX) || defined (DIRENT) || defined (__GNU_LIBRARY__) #include #ifndef __GNU_LIBRARY__ #define D_NAMLEN(d) strlen((d)->d_name) #else /* GNU C library. */ #define D_NAMLEN(d) ((d)->d_namlen) #endif /* Not GNU C library. */ #else /* Not POSIX or DIRENT. */ #define direct dirent #define D_NAMLEN(d) ((d)->d_namlen) #ifdef SYSNDIR #include #endif /* SYSNDIR */ #ifdef SYSDIR #include #endif /* SYSDIR */ #ifdef NDIR #include #endif /* NDIR */ #endif /* POSIX or DIRENT or __GNU_LIBRARY__. */ #if defined (POSIX) && !defined (__GNU_LIBRARY__) /* Posix does not require that the d_ino field be present, and some systems do not provide it. */ #define REAL_DIR_ENTRY(dp) 1 #else #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0) #endif /* POSIX */ #if (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__)) #include #include #define ANSI_STRING #else /* No standard headers. */ #ifdef HAVE_STRING_H #include #define ANSI_STRING #else #include #endif #ifdef HAVE_MEMORY_H #include #endif extern char *malloc (), *realloc (); extern void free (); extern void qsort (); extern void abort (), exit (); #endif /* Standard headers. */ #ifndef ANSI_STRING #ifndef bzero extern void bzero (); #endif #ifndef bcopy extern void bcopy (); #endif #define memcpy(d, s, n) bcopy ((s), (d), (n)) #define strrchr rindex /* memset is only used for zero here, but let's be paranoid. */ #define memset(s, better_be_zero, n) \ ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0))) #endif /* Not ANSI_STRING. */ #ifndef HAVE_STRCOLL #define strcoll strcmp #endif #ifndef __GNU_LIBRARY__ #ifdef __GNUC__ __inline #endif static char * my_realloc (p, n) char *p; unsigned int n; { /* These casts are the for sake of the broken Ultrix compiler, which warns of illegal pointer combinations otherwise. */ if (p == NULL) return (char *) malloc (n); return (char *) realloc (p, n); } #define realloc my_realloc #endif #if !defined(__alloca) && !defined(__GNU_LIBRARY__) #ifdef __GNUC__ #undef alloca #define alloca(n) __builtin_alloca (n) #else /* Not GCC. */ #if defined (sparc) || defined (HAVE_ALLOCA_H) #include #else /* Not sparc or HAVE_ALLOCA_H. */ #ifndef _AIX extern char *alloca (); #endif /* Not _AIX. */ #endif /* sparc or HAVE_ALLOCA_H. */ #endif /* GCC. */ #define __alloca alloca #endif #ifndef STDC_HEADERS #undef size_t #define size_t unsigned int #endif /* Some system header files erroneously define these. We want our own definitions from to take precedence. */ #undef FNM_PATHNAME #undef FNM_NOESCAPE #undef FNM_PERIOD #include /* Some system header files erroneously define these. We want our own definitions from to take precedence. */ #undef GLOB_ERR #undef GLOB_MARK #undef GLOB_NOSORT #undef GLOB_DOOFFS #undef GLOB_NOCHECK #undef GLOB_APPEND #undef GLOB_NOESCAPE #undef GLOB_PERIOD #include __ptr_t (*__glob_opendir_hook) __P ((const char *directory)); const char *(*__glob_readdir_hook) __P ((__ptr_t stream)); void (*__glob_closedir_hook) __P ((__ptr_t stream)); static int glob_pattern_p __P ((const char *pattern, int quote)); static int glob_in_dir __P ((const char *pattern, const char *directory, int flags, int (*errfunc) __P ((const char *, int)), glob_t *pglob)); static int prefix_array __P ((const char *prefix, char **array, size_t n)); static int collated_compare __P ((const __ptr_t, const __ptr_t)); /* Do glob searching for PATTERN, placing results in PGLOB. The bits defined above may be set in FLAGS. If a directory cannot be opened or read and ERRFUNC is not nil, it is called with the pathname that caused the error, and the `errno' value from the failing call; if it returns non-zero `glob' returns GLOB_ABEND; if it returns zero, the error is ignored. If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned. Otherwise, `glob' returns zero. */ int glob (pattern, flags, errfunc, pglob) const char *pattern; int flags; int (*errfunc) __P ((const char *, int)); glob_t *pglob; { const char *filename; char *dirname; size_t dirlen; int status; int oldcount; if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0) { errno = EINVAL; return -1; } /* Find the filename. */ filename = strrchr (pattern, '/'); if (filename == NULL) { filename = pattern; dirname = (char *) "."; dirlen = 0; } else if (filename == pattern) { /* "/pattern". */ dirname = (char *) "/"; dirlen = 1; ++filename; } else { dirlen = filename - pattern; dirname = (char *) __alloca (dirlen + 1); memcpy (dirname, pattern, dirlen); dirname[dirlen] = '\0'; ++filename; } if (filename[0] == '\0' && dirlen > 1) /* "pattern/". Expand "pattern", appending slashes. */ { int ret = glob (dirname, flags | GLOB_MARK, errfunc, pglob); if (ret == 0) pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK); return ret; } if (!(flags & GLOB_APPEND)) { pglob->gl_pathc = 0; pglob->gl_pathv = NULL; } oldcount = pglob->gl_pathc; if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE))) { /* The directory name contains metacharacters, so we have to glob for the directory, and then glob for the pattern in each directory found. */ glob_t dirs; register int i; status = glob (dirname, ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) | GLOB_NOSORT), errfunc, &dirs); if (status != 0) return status; /* We have successfully globbed the preceding directory name. For each name we found, call glob_in_dir on it and FILENAME, appending the results to PGLOB. */ for (i = 0; i < dirs.gl_pathc; ++i) { int oldcount; #ifdef SHELL { /* Make globbing interruptible in the bash shell. */ extern int interrupt_state; if (interrupt_state) { globfree (&dirs); globfree (&files); return GLOB_ABEND; } } #endif /* SHELL. */ oldcount = pglob->gl_pathc; status = glob_in_dir (filename, dirs.gl_pathv[i], (flags | GLOB_APPEND) & ~GLOB_NOCHECK, errfunc, pglob); if (status == GLOB_NOMATCH) /* No matches in this directory. Try the next. */ continue; if (status != 0) { globfree (&dirs); globfree (pglob); return status; } /* Stick the directory on the front of each name. */ if (prefix_array (dirs.gl_pathv[i], &pglob->gl_pathv[oldcount], pglob->gl_pathc - oldcount)) { globfree (&dirs); globfree (pglob); return GLOB_NOSPACE; } } flags |= GLOB_MAGCHAR; if (pglob->gl_pathc == oldcount) /* No matches. */ if (flags & GLOB_NOCHECK) { const size_t len = strlen (pattern) + 1; char *patcopy = (char *) malloc (len); if (patcopy == NULL) return GLOB_NOSPACE; memcpy (patcopy, pattern, len); pglob->gl_pathv = (char **) realloc (pglob->gl_pathv, (pglob->gl_pathc + ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) + 1 + 1) * sizeof (char *)); if (pglob->gl_pathv == NULL) { free (patcopy); return GLOB_NOSPACE; } if (flags & GLOB_DOOFFS) while (pglob->gl_pathc < pglob->gl_offs) pglob->gl_pathv[pglob->gl_pathc++] = NULL; pglob->gl_pathv[pglob->gl_pathc++] = patcopy; pglob->gl_pathv[pglob->gl_pathc] = NULL; pglob->gl_flags = flags; } else return GLOB_NOMATCH; } else { status = glob_in_dir (filename, dirname, flags, errfunc, pglob); if (status != 0) return status; if (dirlen > 0) { /* Stick the directory on the front of each name. */ if (prefix_array (dirname, &pglob->gl_pathv[oldcount], pglob->gl_pathc - oldcount)) { globfree (pglob); return GLOB_NOSPACE; } } } if (!(flags & GLOB_NOSORT)) /* Sort the vector. */ qsort ((__ptr_t) & pglob->gl_pathv[oldcount], pglob->gl_pathc - oldcount, sizeof (char *), collated_compare); return 0; } /* Free storage allocated in PGLOB by a previous `glob' call. */ void globfree (pglob) register glob_t *pglob; { if (pglob->gl_pathv != NULL) { register int i; for (i = 0; i < pglob->gl_pathc; ++i) if (pglob->gl_pathv[i] != NULL) free ((__ptr_t) pglob->gl_pathv[i]); free ((__ptr_t) pglob->gl_pathv); } } /* Do a collated comparison of A and B. */ static int collated_compare (a, b) const __ptr_t a; const __ptr_t b; { const char *const s1 = *(const char *const * const) a; const char *const s2 = *(const char *const * const) b; if (s1 == s2) return 0; if (s1 == NULL) return 1; if (s2 == NULL) return -1; return strcoll (s1, s2); } /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's elements in place. Return nonzero if out of memory, zero if successful. A slash is inserted between DIRNAME and each elt of ARRAY, unless DIRNAME is just "/". Each old element of ARRAY is freed. */ static int prefix_array (dirname, array, n) const char *dirname; char **array; const size_t n; { register size_t i; size_t dirlen = strlen (dirname); if (dirlen == 1 && dirname[0] == '/') /* DIRNAME is just "/", so normal prepending would get us "//foo". We want "/foo" instead, so don't prepend any chars from DIRNAME. */ dirlen = 0; for (i = 0; i < n; ++i) { const size_t eltlen = strlen (array[i]) + 1; char *new = (char *) malloc (dirlen + 1 + eltlen); if (new == NULL) { while (i > 0) free ((__ptr_t) array[--i]); return 1; } memcpy (new, dirname, dirlen); new[dirlen] = '/'; memcpy (&new[dirlen + 1], array[i], eltlen); free ((__ptr_t) array[i]); array[i] = new; } return 0; } /* Return nonzero if PATTERN contains any metacharacters. Metacharacters can be quoted with backslashes if QUOTE is nonzero. */ static int glob_pattern_p (pattern, quote) const char *pattern; const int quote; { register const char *p; int open = 0; for (p = pattern; *p != '\0'; ++p) switch (*p) { case '?': case '*': return 1; case '\\': if (quote) ++p; break; case '[': open = 1; break; case ']': if (open) return 1; break; } return 0; } /* Like `glob', but PATTERN is a final pathname component, and matches are searched for in DIRECTORY. The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done. The GLOB_APPEND flag is assumed to be set (always appends). */ static int glob_in_dir (pattern, directory, flags, errfunc, pglob) const char *pattern; const char *directory; int flags; int (*errfunc) __P ((const char *, int)); glob_t *pglob; { __ptr_t stream; struct globlink { struct globlink *next; char *name; }; struct globlink *names = NULL; size_t nfound = 0; if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE))) { stream = NULL; flags |= GLOB_NOCHECK; } else { flags |= GLOB_MAGCHAR; stream = (__glob_opendir_hook ? (*__glob_opendir_hook) (directory) : (__ptr_t) opendir (directory)); if (stream == NULL) { if ((errfunc != NULL && (*errfunc) (directory, errno)) || (flags & GLOB_ERR)) return GLOB_ABEND; } else while (1) { const char *name; size_t len; if (__glob_readdir_hook) { name = (*__glob_readdir_hook) (stream); if (name == NULL) break; len = 0; } else { struct dirent *d = readdir ((DIR *) stream); if (d == NULL) break; if (! REAL_DIR_ENTRY (d)) continue; name = d->d_name; #ifdef HAVE_D_NAMLEN len = d->d_namlen; #else len = 0; #endif } if (fnmatch (pattern, name, (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0) { struct globlink *new = (struct globlink *) __alloca (sizeof (struct globlink)); if (len == 0) len = strlen (name); new->name = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1); if (new->name == NULL) goto memory_error; memcpy ((__ptr_t) new->name, name, len); if (flags & GLOB_MARK) new->name[len++] = '/'; new->name[len] = '\0'; new->next = names; names = new; ++nfound; } } } if (nfound == 0 && (flags & GLOB_NOCHECK)) { size_t len = strlen (pattern); nfound = 1; names = (struct globlink *) __alloca (sizeof (struct globlink)); names->next = NULL; names->name = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1); if (names->name == NULL) goto memory_error; memcpy (names->name, pattern, len); if (flags & GLOB_MARK) names->name[len++] = '/'; names->name[len] = '\0'; } pglob->gl_pathv = (char **) realloc (pglob->gl_pathv, (pglob->gl_pathc + ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) + nfound + 1) * sizeof (char *)); if (pglob->gl_pathv == NULL) goto memory_error; if (flags & GLOB_DOOFFS) while (pglob->gl_pathc < pglob->gl_offs) pglob->gl_pathv[pglob->gl_pathc++] = NULL; for (; names != NULL; names = names->next) pglob->gl_pathv[pglob->gl_pathc++] = names->name; pglob->gl_pathv[pglob->gl_pathc] = NULL; pglob->gl_flags = flags; if (stream != NULL) { int save = errno; if (__glob_closedir_hook) (*__glob_closedir_hook) (stream); else (void) closedir ((DIR *) stream); errno = save; } return nfound == 0 ? GLOB_NOMATCH : 0; memory_error: { int save = errno; if (__glob_closedir_hook) (*__glob_closedir_hook) (stream); else (void) closedir ((DIR *) stream); errno = save; } while (names != NULL) { if (names->name != NULL) free ((__ptr_t) names->name); names = names->next; } return GLOB_NOSPACE; } #endif /* _LIBC or not __GNU_LIBRARY__. */ make-3.70/glob/fnmatch.c 777 12241 13 12027 5456545256 10225 /* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #if defined (CONFIG_BROKETS) /* We use instead of "config.h" so that a compilation using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h (which it would do because it found this file in $srcdir). */ #include #else #include "config.h" #endif #endif #include #include #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #if defined (_LIBC) || !defined (__GNU_LIBRARY__) #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS) extern int errno; #endif /* Match STRING against the filename pattern PATTERN, returning zero if it matches, nonzero if not. */ int fnmatch (pattern, string, flags) const char *pattern; const char *string; int flags; { register const char *p = pattern, *n = string; register char c; /* Note that this evalutes C many times. */ #define FOLD(c) ((flags & FNM_CASEFOLD) && isupper (c) ? tolower (c) : (c)) while ((c = *p++) != '\0') { c = FOLD (c); switch (c) { case '?': if (*n == '\0') return FNM_NOMATCH; else if ((flags & FNM_FILE_NAME) && *n == '/') return FNM_NOMATCH; else if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; break; case '\\': if (!(flags & FNM_NOESCAPE)) { c = *p++; c = FOLD (c); } if (FOLD (*n) != c) return FNM_NOMATCH; break; case '*': if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; for (c = *p++; c == '?' || c == '*'; c = *p++, ++n) if (((flags & FNM_FILE_NAME) && *n == '/') || (c == '?' && *n == '\0')) return FNM_NOMATCH; if (c == '\0') return 0; { char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c; c1 = FOLD (c1); for (--p; *n != '\0'; ++n) if ((c == '[' || FOLD (*n) == c1) && fnmatch (p, n, flags & ~FNM_PERIOD) == 0) return 0; return FNM_NOMATCH; } case '[': { /* Nonzero if the sense of the character class is inverted. */ register int not; if (*n == '\0') return FNM_NOMATCH; if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; not = (*p == '!' || *p == '^'); if (not) ++p; c = *p++; for (;;) { register char cstart = c, cend = c; if (!(flags & FNM_NOESCAPE) && c == '\\') cstart = cend = *p++; cstart = cend = FOLD (cstart); if (c == '\0') /* [ (unterminated) loses. */ return FNM_NOMATCH; c = *p++; c = FOLD (c); if ((flags & FNM_FILE_NAME) && c == '/') /* [/] can never match. */ return FNM_NOMATCH; if (c == '-' && *p != ']') { cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == '\\') cend = *p++; if (cend == '\0') return FNM_NOMATCH; cend = FOLD (cend); c = *p++; } if (FOLD (*n) >= cstart && FOLD (*n) <= cend) goto matched; if (c == ']') break; } if (!not) return FNM_NOMATCH; break; matched:; /* Skip the rest of the [...] that already matched. */ while (c != ']') { if (c == '\0') /* [... (unterminated) loses. */ return FNM_NOMATCH; c = *p++; if (!(flags & FNM_NOESCAPE) && c == '\\') /* XXX 1003.2d11 is unclear if this is right. */ ++p; } if (not) return FNM_NOMATCH; } break; default: if (c != FOLD (*n)) return FNM_NOMATCH; } ++n; } if (*n == '\0') return 0; if ((flags & FNM_LEADING_DIR) && *n == '/') /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; } #endif /* _LIBC or not __GNU_LIBRARY__. */ make-3.70/glob/glob.h 777 12241 13 7075 5266145411 7510 /* Copyright (C) 1991, 1992 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _GLOB_H #define _GLOB_H 1 #ifdef __cplusplus extern "C" { #endif #undef __ptr_t #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) #undef __P #define __P(args) args #define __ptr_t void * #else /* Not C++ or ANSI C. */ #undef __P #define __P(args) () #undef const #define const #define __ptr_t char * #endif /* C++ or ANSI C. */ /* Bits set in the FLAGS argument to `glob'. */ #define GLOB_ERR (1 << 0)/* Return on read errors. */ #define GLOB_MARK (1 << 1)/* Append a slash to each name. */ #define GLOB_NOSORT (1 << 2)/* Don't sort the names. */ #define GLOB_DOOFFS (1 << 3)/* Insert PGLOB->gl_offs NULLs. */ #define GLOB_NOCHECK (1 << 4)/* If nothing matches, return the pattern. */ #define GLOB_APPEND (1 << 5)/* Append to results of a previous call. */ #define GLOB_NOESCAPE (1 << 6)/* Backslashes don't quote metacharacters. */ #define GLOB_PERIOD (1 << 7)/* Leading `.' can be matched by metachars. */ #define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \ GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND|GLOB_PERIOD) #if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_BSD_SOURCE) #define GLOB_MAGCHAR (1 << 8)/* Set in gl_flags if any metachars seen. */ #endif /* Error returns from `glob'. */ #define GLOB_NOSPACE 1 /* Ran out of memory. */ #define GLOB_ABEND 2 /* Read error. */ #define GLOB_NOMATCH 3 /* No matches found. */ /* Structure describing a globbing run. */ typedef struct { int gl_pathc; /* Count of paths matched by the pattern. */ char **gl_pathv; /* List of matched pathnames. */ int gl_offs; /* Slots to reserve in `gl_pathv'. */ int gl_flags; /* Set to FLAGS, maybe | GLOB_MAGCHAR. */ } glob_t; /* Do glob searching for PATTERN, placing results in PGLOB. The bits defined above may be set in FLAGS. If a directory cannot be opened or read and ERRFUNC is not nil, it is called with the pathname that caused the error, and the `errno' value from the failing call; if it returns non-zero `glob' returns GLOB_ABEND; if it returns zero, the error is ignored. If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned. Otherwise, `glob' returns zero. */ extern int glob __P ((const char *__pattern, int __flags, int (*__errfunc) __P ((const char *, int)), glob_t *__pglob)); /* Free storage allocated in PGLOB by a previous `glob' call. */ extern void globfree __P ((glob_t *__pglob)); #if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE) /* If they are not NULL, `glob' uses these functions to read directories. */ extern __ptr_t (*__glob_opendir_hook) __P ((const char *__directory)); extern const char *(*__glob_readdir_hook) __P ((__ptr_t __stream)); extern void (*__glob_closedir_hook) __P ((__ptr_t __stream)); #endif #ifdef __cplusplus } #endif #endif /* glob.h */ make-3.70/glob/fnmatch.h 777 12241 13 4455 5503415702 10201 /* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef _FNMATCH_H #define _FNMATCH_H 1 #ifdef __cplusplus extern "C" { #endif #if defined (__cplusplus) || (defined (__STDC__) && __STDC__) #undef __P #define __P(args) args #else /* Not C++ or ANSI C. */ #undef __P #define __P(args) () /* We can get away without defining `const' here only because in this file it is used only inside the prototype for `fnmatch', which is elided in non-ANSI C where `const' is problematical. */ #endif /* C++ or ANSI C. */ /* We #undef these before defining them because some losing systems (HP-UX A.08.07 for example) define these in . */ #undef FNM_PATHNAME #undef FNM_NOESCAPE #undef FNM_PERIOD /* Bits set in the FLAGS argument to `fnmatch'. */ #define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */ #define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */ #define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */ #if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE) #define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */ #define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */ #define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */ #endif /* Value returned by `fnmatch' if STRING does not match PATTERN. */ #define FNM_NOMATCH 1 /* Match STRING against the filename pattern PATTERN, returning zero if it matches, FNM_NOMATCH if not. */ extern int fnmatch __P ((const char *__pattern, const char *__string, int __flags)); #ifdef __cplusplus } #endif #endif /* fnmatch.h */ make-3.70/make.texinfo 666 12241 13 1174203 5503455532 10062 \input texinfo @c -*- Texinfo -*- @c %**start of header @setfilename make.info @settitle GNU @code{make} @setchapternewpage odd @c %**end of header @c FSF publishers: format makebook.texi instead of using this file directly. @set EDITION 0.45 @set VERSION 3.70 Beta @set UPDATED 14 December 1993 @set UPDATE-MONTH December 1993 @c finalout @c ISPELL CHECK: done, 10 June 1993 --roland @c Combine the variable and function indices: @syncodeindex vr fn @c Combine the program and concept indices: @syncodeindex pg cp @ifinfo This file documents the GNU Make utility, which determines automatically which pieces of a large program need to be recompiled, and issues the commands to recompile them. This is Edition @value{EDITION}, last updated @value{UPDATED}, of @cite{The GNU Make Manual}, for @code{make}, Version @value{VERSION}. Copyright (C) 1988, '89, '90, '91, '92, '93 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. @ignore Permission is granted to process this file through TeX and print the results, provided the printed document carries copying permission notice identical to this one except for the removal of this paragraph (this paragraph not being relevant to the printed manual). @end ignore Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation. @end ifinfo @iftex @shorttitlepage GNU Make @end iftex @titlepage @title GNU Make @subtitle A Program for Directing Recompilation @subtitle Edition @value{EDITION}, for @code{make} Version @value{VERSION}. @subtitle @value{UPDATE-MONTH} @author Richard M. Stallman and Roland McGrath @page @vskip 0pt plus 1filll Copyright @copyright{} 1988, '89, '90, '91, '92, '93 Free Software Foundation, Inc. @sp 2 Published by the Free Software Foundation @* 675 Massachusetts Avenue, @* Cambridge, MA 02139 USA @* Printed copies are available for $20 each. @* ISBN 1-882114-16-7 @* Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Free Software Foundation. @sp 2 Cover art by Etienne Suvasa. @end titlepage @page @ifinfo @node Top, Overview, (dir), (dir) @top Make The GNU @code{make} utility automatically determines which pieces of a large program need to be recompiled, and issues the commands to recompile them.@refill This is Edition @value{EDITION} of the @cite{GNU Make Manual}, last updated @value{UPDATED} for @code{make} Version @value{VERSION}.@refill This manual describes @code{make} and contains the following chapters:@refill @end ifinfo @menu * Overview:: Overview of @code{make}. * Introduction:: An introduction to @code{make}. * Makefiles:: Makefiles tell @code{make} what to do. * Rules:: Rules describe when a file must be remade. * Commands:: Commands say how to remake a file. * Using Variables:: You can use variables to avoid repetition. * Conditionals:: Use or ignore parts of the makefile based on the values of variables. * Functions:: Many powerful ways to manipulate text. * make Invocation: Running. How to invoke @code{make} on the command line. * Implicit Rules:: Use implicit rules to treat many files alike, based on their file names. * Archives:: How @code{make} can update library archives. * Features:: Features GNU @code{make} has over other @code{make}s. * Missing:: What GNU @code{make} lacks from other @code{make}s. * Makefile Conventions:: Conventions for makefiles in GNU programs. * Quick Reference:: A quick reference for experienced users. * Complex Makefile:: A real example of a straightforward, but nontrivial, makefile. * Concept Index:: Index of Concepts * Name Index:: Index of Functions, Variables, & Directives --- The Detailed Node Listing --- Overview of @code{make} * Preparing:: Preparing and Running Make * Reading:: On Reading this Text * Bugs:: Problems and Bugs An Introduction to Makefiles * Rule Introduction:: What a rule looks like. * Simple Makefile:: A Simple Makefile * How Make Works:: How @code{make} Processes This Makefile * Variables Simplify:: Variables Make Makefiles Simpler * make Deduces:: Letting @code{make} Deduce the Commands * Combine By Dependency:: Another Style of Makefile * Cleanup:: Rules for Cleaning the Directory Writing Makefiles * Makefile Contents:: What makefiles contain. * Makefile Names:: How to name your makefile. * Include:: How one makefile can use another makefile. * MAKEFILES Variable:: The environment can specify extra makefiles. * Remaking Makefiles:: How makefiles get remade. * Overriding Makefiles:: How to override part of one makefile with another makefile. Writing Rules * Rule Example:: An example explained. * Rule Syntax:: General syntax explained. * Wildcards:: Using wildcard characters such as `*'. * Directory Search:: Searching other directories for source files. * Phony Targets:: Using a target that is not a real file's name. * Force Targets:: You can use a target without commands or dependencies to mark other targets as phony. * Empty Targets:: When only the date matters and the files are empty. * Special Targets:: Targets with special built-in meanings. * Multiple Targets:: When to make use of several targets in a rule. * Multiple Rules:: How to use several rules with the same target. * Static Pattern:: Static pattern rules apply to multiple targets and can vary the dependencies according to the target name. * Double-Colon:: How to use a special kind of rule to allow several independent rules for one target. * Automatic Dependencies:: How to automatically generate rules giving dependencies from the source files themselves. Using Wildcard Characters in File Names * Wildcard Examples:: Several examples * Wildcard Pitfall:: Problems to avoid. * Wildcard Function:: How to cause wildcard expansion where it does not normally take place. Searching Directories for Dependencies * General Search:: Specifying a search path that applies to every dependency. * Selective Search:: Specifying a search path for a specified class of names. * Commands/Search:: How to write shell commands that work together with search paths. * Implicit/Search:: How search paths affect implicit rules. * Libraries/Search:: Directory search for link libraries. Static Pattern Rules * Static Usage:: The syntax of static pattern rules. * Static versus Implicit:: When are they better than implicit rules? Writing the Commands in Rules * Echoing:: How to control when commands are echoed. * Execution:: How commands are executed. * Parallel:: How commands can be executed in parallel. * Errors:: What happens after a command execution error. * Interrupts:: What happens when a command is interrupted. * Recursion:: Invoking @code{make} from makefiles. * Sequences:: Defining canned sequences of commands. * Empty Commands:: Defining useful, do-nothing commands. Recursive Use of @code{make} * MAKE Variable:: The special effects of using @samp{$(MAKE)}. * Variables/Recursion:: How to communicate variables to a sub-@code{make}. * Options/Recursion:: How to communicate options to a sub-@code{make}. * -w Option:: How the @samp{-w} or @samp{--print-directory} option helps debug use of recursive @code{make} commands. How to Use Variables * Reference:: How to use the value of a variable. * Flavors:: Variables come in two flavors. * Advanced:: Advanced features for referencing a variable. * Values:: All the ways variables get their values. * Setting:: How to set a variable in the makefile. * Appending:: How to append more text to the old value of a variable. * Override Directive:: How to set a variable in the makefile even if the user has set it with a command argument. * Defining:: An alternate way to set a variable to a verbatim string. * Environment:: Variable values can come from the environment. Advanced Features for Reference to Variables * Substitution Refs:: Referencing a variable with substitutions on the value. * Computed Names:: Computing the name of the variable to refer to. Conditional Parts of Makefiles * Conditional Example:: Example of a conditional * Conditional Syntax:: The syntax of conditionals. * Testing Flags:: Conditionals that test flags. Functions for Transforming Text * Syntax of Functions:: How to write a function call. * Text Functions:: General-purpose text manipulation functions. * Filename Functions:: Functions for manipulating file names. * Foreach Function:: Repeat some text with controlled variation. * Origin Function:: Find where a variable got its value. * Shell Function:: Substitute the output of a shell command. How to Run @code{make} * Makefile Arguments:: How to specify which makefile to use. * Goals:: How to use goal arguments to specify which parts of the makefile to use. * Instead of Execution:: How to use mode flags to specify what kind of thing to do with the commands in the makefile other than simply execute them. * Avoiding Compilation:: How to avoid recompiling certain files. * Overriding:: How to override a variable to specify an alternate compiler and other things. * Testing:: How to proceed past some errors, to test compilation. * Options Summary:: Summary of Options Using Implicit Rules * Using Implicit:: How to use an existing implicit rule to get the commands for updating a file. * Catalogue of Rules:: A list of built-in implicit rules. * Implicit Variables:: How to change what predefined rules do. * Chained Rules:: How to use a chain of implicit rules. * Pattern Rules:: How to define new implicit rules. * Last Resort:: How to defining commands for rules which cannot find any. * Suffix Rules:: The old-fashioned style of implicit rule. * Search Algorithm:: The precise algorithm for applying implicit rules. Defining and Redefining Pattern Rules * Pattern Intro:: An introduction to pattern rules. * Pattern Examples:: Examples of pattern rules. * Automatic:: How to use automatic variables in the commands of implicit rules. * Pattern Match:: How patterns match. * Match-Anything Rules:: Precautions you should take prior to defining rules that can match any target file whatever. * Canceling Rules:: How to override or cancel built-in rules. Using @code{make} to Update Archive Files * Archive Members:: Archive members as targets. * Archive Update:: The implicit rule for archive member targets. * Archive Suffix Rules:: You can write a special kind of suffix rule for updating archives. Implicit Rule for Archive Member Targets * Archive Symbols:: How to update archive symbol directories. @end menu @node Overview, Introduction, Top, Top @comment node-name, next, previous, up @chapter Overview of @code{make} The @code{make} utility automatically determines which pieces of a large program need to be recompiled, and issues commands to recompile them. This manual describes GNU @code{make}, which was implemented by Richard Stallman and Roland McGrath. GNU @code{make} conforms to section 6.2 of @cite{IEEE Standard 1003.2-1992} (POSIX.2). @cindex POSIX @cindex IEEE Standard 1003.2 @cindex standards conformance Our examples show C programs, since they are most common, but you can use @code{make} with any programming language whose compiler can be run with a shell command. Indeed, @code{make} is not limited to programs. You can use it to describe any task where some files must be updated automatically from others whenever the others change. @menu * Preparing:: Preparing and Running Make * Reading:: On Reading this Text * Bugs:: Problems and Bugs @end menu @node Preparing, Reading, , Overview @ifinfo @heading Preparing and Running Make @end ifinfo To prepare to use @code{make}, you must write a file called the @dfn{makefile} that describes the relationships among files in your program and provides commands for updating each file. In a program, typically, the executable file is updated from object files, which are in turn made by compiling source files.@refill Once a suitable makefile exists, each time you change some source files, this simple shell command: @example make @end example @noindent suffices to perform all necessary recompilations. The @code{make} program uses the makefile data base and the last-modification times of the files to decide which of the files need to be updated. For each of those files, it issues the commands recorded in the data base. You can provide command line arguments to @code{make} to control which files should be recompiled, or how. @xref{Running, ,How to Run @code{make}}. @node Reading, Bugs, Preparing, Overview @section How to Read This Manual If you are new to @code{make}, or are looking for a general introduction, read the first few sections of each chapter, skipping the later sections. In each chapter, the first few sections contain introductory or general information and the later sections contain specialized or technical information. @ifinfo The exception is the second chapter, @ref{Introduction, ,An Introduction to Makefiles}, all of which is introductory. @end ifinfo @iftex The exception is @ref{Introduction, ,An Introduction to Makefiles}, all of which is introductory. @end iftex If you are familiar with other @code{make} programs, see @ref{Features, ,Features of GNU @code{make}}, which lists the enhancements GNU @code{make} has, and @ref{Missing, ,Incompatibilities and Missing Features}, which explains the few things GNU @code{make} lacks that others have. For a quick summary, see @ref{Options Summary}, @ref{Quick Reference}, and @ref{Special Targets}. @node Bugs, , Reading, Overview @section Problems and Bugs @cindex reporting bugs @cindex bugs, reporting @cindex problems and bugs, reporting If you have problems with GNU @code{make} or think you've found a bug, please report it to the developers; we cannot promise to do anything but we might well want to fix it. Before reporting a bug, make sure you've actually found a real bug. Carefully reread the documentation and see if it really says you can do what you're trying to do. If it's not clear whether you should be able to do something or not, report that too; it's a bug in the documentation! Before reporting a bug or trying to fix it yourself, try to isolate it to the smallest possible makefile that reproduces the problem. Then send us the makefile and the exact results @code{make} gave you. Also say what you expected to occur; this will help us decide whether the problem was really in the documentation. Once you've got a precise problem, please send electronic mail either through the Internet or via UUCP: @example @group @r{Internet address:} bug-gnu-utils@@prep.ai.mit.edu @r{UUCP path:} mit-eddie!prep.ai.mit.edu!bug-gnu-utils @end group @end example @noindent Please include the version number of @code{make} you are using. You can get this information with the command @samp{make --version}. Be sure also to include the type of machine and operating system you are using. If possible, include the contents of the file @file{config.h} that is generated by the configuration process. Non-bug suggestions are always welcome as well. If you have questions about things that are unclear in the documentation or are just obscure features, contact Roland McGrath; he will try to help you out, although he may not have time to fix the problem.@refill You can send electronic mail to Roland McGrath either through the @w{Internet} or via UUCP: @example @group @r{Internet address:} roland@@prep.ai.mit.edu @r{UUCP path:} mit-eddie!prep.ai.mit.edu!roland @end group @end example @node Introduction, Makefiles, Overview, Top @comment node-name, next, previous, up @chapter An Introduction to Makefiles You need a file called a @dfn{makefile} to tell @code{make} what to do. Most often, the makefile tells @code{make} how to compile and link a program. @cindex makefile In this chapter, we will discuss a simple makefile that describes how to compile and link a text editor which consists of eight C source files and three header files. The makefile can also tell @code{make} how to run miscellaneous commands when explicitly asked (for example, to remove certain files as a clean-up operation). To see a more complex example of a makefile, see @ref{Complex Makefile}. When @code{make} recompiles the editor, each changed C source file must be recompiled. If a header file has changed, each C source file that includes the header file must be recompiled to be safe. Each compilation produces an object file corresponding to the source file. Finally, if any source file has been recompiled, all the object files, whether newly made or saved from previous compilations, must be linked together to produce the new executable editor. @cindex recompilation @cindex editor @menu * Rule Introduction:: What a rule looks like. * Simple Makefile:: A Simple Makefile * How Make Works:: How @code{make} Processes This Makefile * Variables Simplify:: Variables Make Makefiles Simpler * make Deduces:: Letting @code{make} Deduce the Commands * Combine By Dependency:: Another Style of Makefile * Cleanup:: Rules for Cleaning the Directory @end menu @node Rule Introduction, Simple Makefile, , Introduction @comment node-name, next, previous, up @section What a Rule Looks Like @cindex rule, introduction to @cindex makefile rule parts @cindex parts of makefile rule A simple makefile consists of ``rules'' with the following shape: @cindex targets, introduction to @cindex dependencies, introduction to @cindex commands, introduction to @example @group @var{target} @dots{} : @var{dependencies} @dots{} @var{command} @dots{} @dots{} @end group @end example A @dfn{target} is usually the name of a file that is generated by a program; examples of targets are executable or object files. A target can also be the name of an action to carry out, such as @samp{clean} (@pxref{Phony Targets}). A @dfn{dependency} is a file that is used as input to create the target. A target often depends on several files. @cindex tabs in rules A @dfn{command} is an action that @code{make} carries out. A rule may have more than one command, each on its own line. @strong{Please note:} you need to put a tab character at the beginning of every command line! This is an obscurity that catches the unwary. Usually a command is in a rule with dependencies and serves to create a target file if any of the dependencies change. However, the rule that specifies commands for the target need not have dependencies. For example, the rule containing the delete command associated with the target @samp{clean} does not have dependencies. A @dfn{rule}, then, explains how and when to remake certain files which are the targets of the particular rule. @code{make} carries out the commands on the dependencies to create or update the target. A rule can also explain how and when to carry out an action. @xref{Rules, , Writing Rules}. A makefile may contain other text besides rules, but a simple makefile need only contain rules. Rules may look somewhat more complicated than shown in this template, but all fit the pattern more or less. @node Simple Makefile, How Make Works, Rule Introduction, Introduction @section A Simple Makefile @cindex simple makefile @cindex makefile, simple Here is a straightforward makefile that describes the way an executable file called @code{edit} depends on eight object files which, in turn, depend on eight C source and three header files. In this example, all the C files include @file{defs.h}, but only those defining editing commands include @file{command.h}, and only low level files that change the editor buffer include @file{buffer.h}. @example @group edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o main.o : main.c defs.h cc -c main.c kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c clean : rm edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o @end group @end example @noindent We split each long line into two lines using backslash-newline; this is like using one long line, but is easier to read. @cindex continuation lines @cindex @code{\} (backslash), for continuation lines @cindex backslash (@code{\}), for continuation lines @cindex quoting newline, in makefile @cindex newline, quoting, in makefile To use this makefile to create the executable file called @file{edit}, type: @example make @end example To use this makefile to delete the executable file and all the object files from the directory, type: @example make clean @end example In the example makefile, the targets include the executable file @samp{edit}, and the object files @samp{main.o} and @samp{kbd.o}. The dependencies are files such as @samp{main.c} and @samp{defs.h}. In fact, each @samp{.o} file is both a target and a dependency. Commands include @w{@samp{cc -c main.c}} and @w{@samp{cc -c kbd.c}}. When a target is a file, it needs to be recompiled or relinked if any of its dependencies change. In addition, any dependencies that are themselves automatically generated should be updated first. In this example, @file{edit} depends on each of the eight object files; the object file @file{main.o} depends on the source file @file{main.c} and on the header file @file{defs.h}. A shell command follows each line that contains a target and dependencies. These shell commands say how to update the target file. A tab character must come at the beginning of every command line to distinguish commands lines from other lines in the makefile. (Bear in mind that @code{make} does not know anything about how the commands work. It is up to you to supply commands that will update the target file properly. All @code{make} does is execute the commands in the rule you have specified when the target file needs to be updated.) @cindex shell command The target @samp{clean} is not a file, but merely the name of an action. Since you normally do not want to carry out the actions in this rule, @samp{clean} is not a dependency of any other rule. Consequently, @code{make} never does anything with it unless you tell it specifically. Note that this rule not only is not a dependency, it also does not have any dependencies, so the only purpose of the rule is to run the specified commands. Targets that do not refer to files but are just actions are called @dfn{phony targets}. @xref{Phony Targets}, for information about this kind of target. @xref{Errors, , Errors in Commands}, to see how to cause @code{make} to ignore errors from @code{rm} or any other command. @cindex @code{clean} target @cindex @code{rm} (shell command) @node How Make Works, Variables Simplify, Simple Makefile, Introduction @comment node-name, next, previous, up @section How @code{make} Processes a Makefile @cindex processing a makefile @cindex makefile, how @code{make} processes By default, @code{make} starts with the first rule (not counting rules whose target names start with @samp{.}). This is called the @dfn{default goal}. (@dfn{Goals} are the targets that @code{make} strives ultimately to update. @xref{Goals, , Arguments to Specify the Goals}.) @cindex default goal @cindex goal, default @cindex goal In the simple example of the previous section, the default goal is to update the executable program @file{edit}; therefore, we put that rule first. Thus, when you give the command: @example make @end example @noindent @code{make} reads the makefile in the current directory and begins by processing the first rule. In the example, this rule is for relinking @file{edit}; but before @code{make} can fully process this rule, it must process the rules for the files that @file{edit} depends on, which in this case are the object files. Each of these files is processed according to its own rule. These rules say to update each @samp{.o} file by compiling its source file. The recompilation must be done if the source file, or any of the header files named as dependencies, is more recent than the object file, or if the object file does not exist. The other rules are processed because their targets appear as dependencies of the goal. If some other rule is not depended on by the goal (or anything it depends on, etc.), that rule is not processed, unless you tell @code{make} to do so (with a command such as @w{@code{make clean}}). Before recompiling an object file, @code{make} considers updating its dependencies, the source file and header files. This makefile does not specify anything to be done for them---the @samp{.c} and @samp{.h} files are not the targets of any rules---so @code{make} does nothing for these files. But @code{make} would update automatically generated C programs, such as those made by Bison or Yacc, by their own rules at this time. After recompiling whichever object files need it, @code{make} decides whether to relink @file{edit}. This must be done if the file @file{edit} does not exist, or if any of the object files are newer than it. If an object file was just recompiled, it is now newer than @file{edit}, so @file{edit} is relinked. @cindex relinking Thus, if we change the file @file{insert.c} and run @code{make}, @code{make} will compile that file to update @file{insert.o}, and then link @file{edit}. If we change the file @file{command.h} and run @code{make}, @code{make} will recompile the object files @file{kbd.o}, @file{command.o} and @file{files.o} and then link the file @file{edit}. @node Variables Simplify, make Deduces, How Make Works, Introduction @section Variables Make Makefiles Simpler @cindex variables @cindex simplifying with variables In our example, we had to list all the object files twice in the rule for @file{edit} (repeated here): @example @group edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o @end group @end example @cindex @code{objects} Such duplication is error-prone; if a new object file is added to the system, we might add it to one list and forget the other. We can eliminate the risk and simplify the makefile by using a variable. @dfn{Variables} allow a text string to be defined once and substituted in multiple places later (@pxref{Using Variables, ,How to Use Variables}). @cindex @code{OBJECTS} @cindex @code{objs} @cindex @code{OBJS} @cindex @code{obj} @cindex @code{OBJ} It is standard practice for every makefile to have a variable named @code{objects}, @code{OBJECTS}, @code{objs}, @code{OBJS}, @code{obj}, or @code{OBJ} which is a list of all object file names. We would define such a variable @code{objects} with a line like this in the makefile:@refill @example @group objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o @end group @end example @noindent Then, each place we want to put a list of the object file names, we can substitute the variable's value by writing @samp{$(objects)} (@pxref{Using Variables, ,How to Use Variables}). Here is how the complete simple makefile looks when you use a variable for the object files: @example @group objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : main.c defs.h cc -c main.c kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c clean : rm edit $(objects) @end group @end example @node make Deduces, Combine By Dependency, Variables Simplify, Introduction @section Letting @code{make} Deduce the Commands @cindex deducing commands (implicit rules) @cindex implicit rule, introduction to @cindex rule, implicit, introduction to It is not necessary to spell out the commands for compiling the individual C source files, because @code{make} can figure them out: it has an @dfn{implicit rule} for updating a @samp{.o} file from a correspondingly named @samp{.c} file using a @samp{cc -c} command. For example, it will use the command @samp{cc -c main.c -o main.o} to compile @file{main.c} into @file{main.o}. We can therefore omit the commands from the rules for the object files. @xref{Implicit Rules, ,Using Implicit Rules}.@refill When a @samp{.c} file is used automatically in this way, it is also automatically added to the list of dependencies. We can therefore omit the @samp{.c} files from the dependencies, provided we omit the commands. Here is the entire example, with both of these changes, and a variable @code{objects} as suggested above: @example @group objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : defs.h kbd.o : defs.h command.h command.o : defs.h command.h display.o : defs.h buffer.h insert.o : defs.h buffer.h search.o : defs.h buffer.h files.o : defs.h buffer.h command.h utils.o : defs.h .PHONY : clean clean : -rm edit $(objects) @end group @end example @noindent This is how we would write the makefile in actual practice. (The complications associated with @samp{clean} are described elsewhere. See @ref{Phony Targets}, and @ref{Errors, ,Errors in Commands}.) Because implicit rules are so convenient, they are important. You will see them used frequently.@refill @node Combine By Dependency, Cleanup, make Deduces, Introduction @section Another Style of Makefile @cindex combining rules by dependency When the objects of a makefile are created only by implicit rules, an alternative style of makefile is possible. In this style of makefile, you group entries by their dependencies instead of by their targets. Here is what one looks like: @example @group objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) $(objects) : defs.h kbd.o command.o files.o : command.h display.o insert.o search.o files.o : buffer.h @end group @end example @noindent Here @file{defs.h} is given as a dependency of all the object files; @file{command.h} and @file{buffer.h} are dependencies of the specific object files listed for them. Whether this is better is a matter of taste: it is more compact, but some people dislike it because they find it clearer to put all the information about each target in one place. @node Cleanup, , Combine By Dependency, Introduction @section Rules for Cleaning the Directory @cindex cleaning up @cindex removing, to clean up Compiling a program is not the only thing you might want to write rules for. Makefiles commonly tell how to do a few other things besides compiling a program: for example, how to delete all the object files and executables so that the directory is @samp{clean}. @cindex @code{clean} target Here is how we could write a @code{make} rule for cleaning our example editor: @example @group clean: rm edit $(objects) @end group @end example In practice, we might want to write the rule in a somewhat more complicated manner to handle unanticipated situations. We would do this: @example @group .PHONY : clean clean : -rm edit $(objects) @end group @end example @noindent This prevents @code{make} from getting confused by an actual file called @file{clean} and causes it to continue in spite of errors from @code{rm}. (See @ref{Phony Targets}, and @ref{Errors, ,Errors in Commands}.) @noindent A rule such as this should not be placed at the beginning of the makefile, because we do not want it to run by default! Thus, in the example makefile, we want the rule for @code{edit}, which recompiles the editor, to remain the default goal. Since @code{clean} is not a dependency of @code{edit}, this rule will not run at all if we give the command @samp{make} with no arguments. In order to make the rule run, we have to type @samp{make clean}. @xref{Running, ,How to Run @code{make}}. @node Makefiles, Rules, Introduction, Top @chapter Writing Makefiles @cindex makefile, how to write The information that tells @code{make} how to recompile a system comes from reading a data base called the @dfn{makefile}. @menu * Makefile Contents:: What makefiles contain. * Makefile Names:: How to name your makefile. * Include:: How one makefile can use another makefile. * MAKEFILES Variable:: The environment can specify extra makefiles. * Remaking Makefiles:: How makefiles get remade. * Overriding Makefiles:: How to override part of one makefile with another makefile. @end menu @node Makefile Contents, Makefile Names, , Makefiles @section What Makefiles Contain Makefiles contain five kinds of things: @dfn{explicit rules}, @dfn{implicit rules}, @dfn{variable definitions}, @dfn{directives}, and @dfn{comments}. Rules, variables, and directives are described at length in later chapters.@refill @itemize @bullet @cindex rule, explicit, definition of @cindex explicit rule, definition of @item An @dfn{explicit rule} says when and how to remake one or more files, called the rule's targets. It lists the other files that the targets @dfn{depend on}, and may also give commands to use to create or update the targets. @xref{Rules, ,Writing Rules}. @cindex rule, implicit, definition of @cindex implicit rule, definition of @item An @dfn{implicit rule} says when and how to remake a class of files based on their names. It describes how a target may depend on a file with a name similar to the target and gives commands to create or update such a target. @xref{Implicit Rules, ,Using Implicit Rules}. @cindex variable definition @item A @dfn{variable definition} is a line that specifies a text string value for a variable that can be substituted into the text later. The simple makefile example shows a variable definition for @code{objects} as a list of all object files (@pxref{Variables Simplify, , Variables Make Makefiles Simpler}). @cindex directive @item A @dfn{directive} is a command for @code{make} to do something special while reading the makefile. These include: @itemize @bullet @item Reading another makefile (@pxref{Include, ,Including Other Makefiles}). @item Deciding (based on the values of variables) whether to use or ignore a part of the makefile (@pxref{Conditionals, ,Conditional Parts of Makefiles}). @item Defining a variable from a verbatim string containing multiple lines (@pxref{Defining, ,Defining Variables Verbatim}). @end itemize @cindex comments, in makefile @cindex @code{#} (comments), in makefile @item @samp{#} in a line of a makefile starts a @dfn{comment}. It and the rest of the line are ignored, except that a trailing backslash not escaped by another backslash will continue the comment across multiple lines. Comments may appear on any of the lines in the makefile, except within a @code{define} directive, and perhaps within commands (where the shell decides what is a comment). A line containing just a comment (with perhaps spaces before it) is effectively blank, and is ignored.@refill @end itemize @node Makefile Names, Include, Makefile Contents, Makefiles @section What Name to Give Your Makefile @cindex makefile name @cindex name of makefile @cindex default makefile name @cindex file name of makefile @c following paragraph rewritten to avoid overfull hbox By default, when @code{make} looks for the makefile, it tries the following names, in order: @file{GNUmakefile}, @file{makefile} and @file{Makefile}.@refill @findex Makefile @findex GNUmakefile @findex makefile @cindex @code{README} Normally you should call your makefile either @file{makefile} or @file{Makefile}. (We recommend @file{Makefile} because it appears prominently near the beginning of a directory listing, right near other important files such as @file{README}.) The first name checked, @file{GNUmakefile}, is not recommended for most makefiles. You should use this name if you have a makefile that is specific to GNU @code{make}, and will not be understood by other versions of @code{make}. Other @code{make} programs look for @file{makefile} and @file{Makefile}, but not @file{GNUmakefile}. If @code{make} finds none of these names, it does not use any makefile. Then you must specify a goal with a command argument, and @code{make} will attempt to figure out how to remake it using only its built-in implicit rules. @xref{Implicit Rules, ,Using Implicit Rules}. @cindex @code{-f} @cindex @code{--file} @cindex @code{--makefile} If you want to use a nonstandard name for your makefile, you can specify the makefile name with the @samp{-f} or @samp{--file} option. The arguments @w{@samp{-f @var{name}}} or @w{@samp{--file=@var{name}}} tell @code{make} to read the file @var{name} as the makefile. If you use more than one @samp{-f} or @samp{--file} option, you can specify several makefiles. All the makefiles are effectively concatenated in the order specified. The default makefile names @file{GNUmakefile}, @file{makefile} and @file{Makefile} are not checked automatically if you specify @samp{-f} or @samp{--file}.@refill @cindex specifying makefile name @cindex makefile name, how to specify @cindex name of makefile, how to specify @cindex file name of makefile, how to specify @node Include, MAKEFILES Variable, Makefile Names, Makefiles @section Including Other Makefiles @cindex including other makefiles @cindex makefile, including @findex include The @code{include} directive tells @code{make} to suspend reading the current makefile and read one or more other makefiles before continuing. The directive is a line in the makefile that looks like this: @example include @var{filenames}@dots{} @end example @noindent @var{filenames} can contain shell file name patterns. @cindex shell file name pattern (in @code{include}) @cindex shell wildcards (in @code{include}) @cindex wildcard, in @code{include} Extra spaces are allowed and ignored at the beginning of the line, but a tab is not allowed. (If the line begins with a tab, it will be considered a command line.) Whitespace is required between @code{include} and the file names, and between file names; extra whitespace is ignored there and at the end of the directive. A comment starting with @samp{#} is allowed at the end of the line. If the file names contain any variable or function references, they are expanded. @xref{Using Variables, ,How to Use Variables}. For example, if you have three @file{.mk} files, @file{a.mk}, @file{b.mk}, and @file{c.mk}, and @code{$(bar)} expands to @code{bish bash}, then the following expression @example include foo *.mk $(bar) @end example is equivalent to @example include foo a.mk b.mk c.mk bish bash @end example When @code{make} processes an @code{include} directive, it suspends reading of the containing makefile and reads from each listed file in turn. When that is finished, @code{make} resumes reading the makefile in which the directive appears. One occasion for using @code{include} directives is when several programs, handled by individual makefiles in various directories, need to use a common set of variable definitions (@pxref{Setting, ,Setting Variables}) or pattern rules (@pxref{Pattern Rules, ,Defining and Redefining Pattern Rules}). Another such occasion is when you want to generate dependencies from source files automatically; the dependencies can be put in a file that is included by the main makefile. This practice is generally cleaner than that of somehow appending the dependencies to the end of the main makefile as has been traditionally done with other versions of @code{make}. @xref{Automatic Dependencies}. @cindex dependencies, automatic generation @cindex automatic generation of dependencies @cindex generating dependencies automatically @cindex @code{-I} @cindex @code{--include-dir} @findex /usr/gnu/include @findex /usr/local/include @findex /usr/include If the specified name does not start with a slash, and the file is not found in the current directory, several other directories are searched. First, any directories you have specified with the @samp{-I} or @samp{--include-dir} option are searched (@pxref{Options Summary, ,Summary of Options}). Then the following directories (if they exist) are searched, in this order: @file{@var{prefix}/include} (normally @file{/usr/local/include}) @file{/usr/gnu/include}, @file{/usr/local/include}, @file{/usr/include}. If an included makefile cannot be found in any of these directories, a warning message is generated, but it is not an immediately fatal error; processing of the makefile containing the @code{include} continues. Once it has finished reading makefiles, @code{make} will try to remake any that are out of date or don't exist. @xref{Remaking Makefiles, ,How Makefiles Are Remade}. Only after it has tried to find a way to remake a makefile and failed, will @code{make} diagnose the missing makefile as a fatal error. If you want @code{make} to simply ignore a makefile which does not exist and cannot be remade, with no error message, use the @w{@code{-include}} directive instead of @code{include}, like this: @example -include @var{filenames}@dots{} @end example This is acts like @code{include} in every way except that there is no error (not even a warning) if any of the @var{filenames} do not exist. @node MAKEFILES Variable, Remaking Makefiles, Include, Makefiles @section The Variable @code{MAKEFILES} @cindex makefile, and @code{MAKEFILES} variable @cindex including (@code{MAKEFILES} variable) @vindex MAKEFILES If the environment variable @code{MAKEFILES} is defined, @code{make} considers its value as a list of names (separated by whitespace) of additional makefiles to be read before the others. This works much like the @code{include} directive: various directories are searched for those files (@pxref{Include, ,Including Other Makefiles}). In addition, the default goal is never taken from one of these makefiles and it is not an error if the files listed in @code{MAKEFILES} are not found.@refill @cindex recursion, and @code{MAKEFILES} variable The main use of @code{MAKEFILES} is in communication between recursive invocations of @code{make} (@pxref{Recursion, ,Recursive Use of @code{make}}). It usually is not desirable to set the environment variable before a top-level invocation of @code{make}, because it is usually better not to mess with a makefile from outside. However, if you are running @code{make} without a specific makefile, a makefile in @code{MAKEFILES} can do useful things to help the built-in implicit rules work better, such as defining search paths (@pxref{Directory Search}). Some users are tempted to set @code{MAKEFILES} in the environment automatically on login, and program makefiles to expect this to be done. This is a very bad idea, because such makefiles will fail to work if run by anyone else. It is much better to write explicit @code{include} directives in the makefiles. @xref{Include, , Including Other Makefiles}. @node Remaking Makefiles, Overriding Makefiles, MAKEFILES Variable, Makefiles @section How Makefiles Are Remade @cindex updating makefiles @cindex remaking makefiles @cindex makefile, remaking of Sometimes makefiles can be remade from other files, such as RCS or SCCS files. If a makefile can be remade from other files, you probably want @code{make} to get an up-to-date version of the makefile to read in. To this end, after reading in all makefiles, @code{make} will consider each as a goal target and attempt to update it. If a makefile has a rule which says how to update it (found either in that very makefile or in another one) or if an implicit rule applies to it (@pxref{Implicit Rules, ,Using Implicit Rules}), it will be updated if necessary. After all makefiles have been checked, if any have actually been changed, @code{make} starts with a clean slate and reads all the makefiles over again. (It will also attempt to update each of them over again, but normally this will not change them again, since they are already up to date.)@refill If the makefiles specify a double-colon rule to remake a file with commands but no dependencies, that file will always be remade (@pxref{Double-Colon}). In the case of makefiles, a makefile that has a double-colon rule with commands but no dependencies will be remade every time @code{make} is run, and then again after @code{make} starts over and reads the makefiles in again. This would cause an infinite loop: @code{make} would constantly remake the makefile, and never do anything else. So, to avoid this, @code{make} will @strong{not} attempt to remake makefiles which are specified as double-colon targets but have no dependencies.@refill If you do not specify any makefiles to be read with @samp{-f} or @samp{--file} options, @code{make} will try the default makefile names; @pxref{Makefile Names, ,What Name to Give Your Makefile}. Unlike makefiles explicitly requested with @samp{-f} or @samp{--file} options, @code{make} is not certain that these makefiles should exist. However, if a default makefile does not exist but can be created by running @code{make} rules, you probably want the rules to be run so that the makefile can be used. Therefore, if none of the default makefiles exists, @code{make} will try to make each of them in the same order in which they are searched for (@pxref{Makefile Names, ,What Name to Give Your Makefile}) until it succeeds in making one, or it runs out of names to try. Note that it is not an error if @code{make} cannot find or make any makefile; a makefile is not always necessary.@refill When you use the @samp{-t} or @samp{--touch} option (@pxref{Instead of Execution, ,Instead of Executing the Commands}), you would not want to use an out-of-date makefile to decide which targets to touch. So the @samp{-t} option has no effect on updating makefiles; they are really updated even if @samp{-t} is specified. Likewise, @samp{-q} (or @samp{--question}) and @samp{-n} (or @samp{--just-print}) do not prevent updating of makefiles, because an out-of-date makefile would result in the wrong output for other targets. Thus, @samp{make -f mfile -n foo} will update @file{mfile}, read it in, and then print the commands to update @file{foo} and its dependencies without running them. The commands printed for @file{foo} will be those specified in the updated contents of @file{mfile}. However, on occasion you might actually wish to prevent updating of even the makefiles. You can do this by specifying the makefiles as goals in the command line as well as specifying them as makefiles. When the makefile name is specified explicitly as a goal, the options @samp{-t} and so on do apply to them. Thus, @samp{make -f mfile -n mfile foo} would read the makefile @file{mfile}, print the commands needed to update it without actually running them, and then print the commands needed to update @file{foo} without running them. The commands for @file{foo} will be those specified by the existing contents of @file{mfile}. @node Overriding Makefiles, , Remaking Makefiles, Makefiles @section Overriding Part of Another Makefile @cindex overriding makefiles @cindex makefile, overriding Sometimes it is useful to have a makefile that is mostly just like another makefile. You can often use the @samp{include} directive to include one in the other, and add more targets or variable definitions. However, if the two makefiles give different commands for the same target, @code{make} will not let you just do this. But there is another way. @cindex @code{.DEFAULT}, used to override In the containing makefile (the one that wants to include the other), you can use the @code{.DEFAULT} special target to say that to remake any target that cannot be made from the information in the containing makefile, @code{make} should look in another makefile. @xref{Last Resort, , Defining Last-Resort Default Rules}, for more information on @code{.DEFAULT}. For example, if you have a makefile called @file{Makefile} that says how to make the target @samp{foo} (and other targets), you can write a makefile called @file{GNUmakefile} that contains: @example foo: frobnicate > foo .DEFAULT: @@$(MAKE) -f Makefile $@@ @end example If you say @samp{make foo}, @code{make} will find @file{GNUmakefile}, read it, and see that to make @file{foo}, it needs to run the command @samp{frobnicate > foo}. If you say @samp{make bar}, @code{make} will find no way to make @file{bar} in @file{GNUmakefile}, so it will use the commands from @code{.DEFAULT}: @samp{make -f Makefile bar}. If @file{Makefile} provides a rule for updating @file{bar}, @code{make} will apply the rule. And likewise for any other target that @file{GNUmakefile} does not say how to make.@refill @node Rules, Commands, Makefiles, Top @chapter Writing Rules @cindex writing rules @cindex rule, how to write @cindex target @cindex dependency A @dfn{rule} appears in the makefile and says when and how to remake certain files, called the rule's @dfn{targets} (most often only one per rule). It lists the other files that are the @dfn{dependencies} of the target, and @dfn{commands} to use to create or update the target. @cindex default goal @cindex goal, default The order of rules is not significant, except for determining the @dfn{default goal}: the target for @code{make} to consider, if you do not otherwise specify one. The default goal is the target of the first rule in the first makefile. If the first rule has multiple targets, only the first target is taken as the default. There are two exceptions: a target starting with a period is not a default unless it contains one or more slashes, @samp{/}, as well; and, a target that defines a pattern rule has no effect on the default goal. (@xref{Pattern Rules, ,Defining and Redefining Pattern Rules}.) Therefore, we usually write the makefile so that the first rule is the one for compiling the entire program or all the programs described by the makefile (often with a target called @samp{all}). @xref{Goals, ,Arguments to Specify the Goals}. @menu * Rule Example:: An example explained. * Rule Syntax:: General syntax explained. * Wildcards:: Using wildcard characters such as `*'. * Directory Search:: Searching other directories for source files. * Phony Targets:: Using a target that is not a real file's name. * Force Targets:: You can use a target without commands or dependencies to mark other targets as phony. * Empty Targets:: When only the date matters and the files are empty. * Special Targets:: Targets with special built-in meanings. * Multiple Targets:: When to make use of several targets in a rule. * Multiple Rules:: How to use several rules with the same target. * Static Pattern:: Static pattern rules apply to multiple targets and can vary the dependencies according to the target name. * Double-Colon:: How to use a special kind of rule to allow several independent rules for one target. * Automatic Dependencies:: How to automatically generate rules giving dependencies from the source files themselves. @end menu @ifinfo @node Rule Example, Rule Syntax, , Rules @section Rule Example Here is an example of a rule: @example foo.o : foo.c defs.h # module for twiddling the frobs cc -c -g foo.c @end example Its target is @file{foo.o} and its dependencies are @file{foo.c} and @file{defs.h}. It has one command, which is @samp{cc -c -g foo.c}. The command line starts with a tab to identify it as a command. This rule says two things: @itemize @bullet @item How to decide whether @file{foo.o} is out of date: it is out of date if it does not exist, or if either @file{foo.c} or @file{defs.h} is more recent than it. @item How to update the file @file{foo.o}: by running @code{cc} as stated. The command does not explicitly mention @file{defs.h}, but we presume that @file{foo.c} includes it, and that that is why @file{defs.h} was added to the dependencies. @end itemize @end ifinfo @node Rule Syntax, Wildcards, Rule Example, Rules @section Rule Syntax @cindex rule syntax @cindex syntax of rules In general, a rule looks like this: @example @var{targets} : @var{dependencies} @var{command} @dots{} @end example @noindent or like this: @example @var{targets} : @var{dependencies} ; @var{command} @var{command} @dots{} @end example @cindex targets @cindex rule targets The @var{targets} are file names, separated by spaces. Wildcard characters may be used (@pxref{Wildcards, ,Using Wildcard Characters in File Names}) and a name of the form @file{@var{a}(@var{m})} represents member @var{m} in archive file @var{a} (@pxref{Archive Members, ,Archive Members as Targets}). Usually there is only one target per rule, but occasionally there is a reason to have more (@pxref{Multiple Targets, , Multiple Targets in a Rule}).@refill @cindex commands @cindex tab character (in commands) The @var{command} lines start with a tab character. The first command may appear on the line after the dependencies, with a tab character, or may appear on the same line, with a semicolon. Either way, the effect is the same. @xref{Commands, ,Writing the Commands in Rules}. @cindex dollar sign (@code{$}), in rules @cindex @code{$}, in rules @cindex rule, and @code{$} Because dollar signs are used to start variable references, if you really want a dollar sign in a rule you must write two of them, @samp{$$} (@pxref{Using Variables, ,How to Use Variables}). You may split a long line by inserting a backslash followed by a newline, but this is not required, as @code{make} places no limit on the length of a line in a makefile. A rule tells @code{make} two things: when the targets are out of date, and how to update them when necessary. @cindex dependencies @cindex rule dependencies The criterion for being out of date is specified in terms of the @var{dependencies}, which consist of file names separated by spaces. (Wildcards and archive members (@pxref{Archives}) are allowed here too.) A target is out of date if it does not exist or if it is older than any of the dependencies (by comparison of last-modification times). The idea is that the contents of the target file are computed based on information in the dependencies, so if any of the dependencies changes, the contents of the existing target file are no longer necessarily valid. How to update is specified by @var{commands}. These are lines to be executed by the shell (normally @samp{sh}), but with some extra features (@pxref{Commands, ,Writing the Commands in Rules}). @node Wildcards, Directory Search, Rule Syntax, Rules @section Using Wildcard Characters in File Names @cindex wildcard @cindex file name with wildcards @cindex globbing (wildcards) @cindex @code{*} (wildcard character) @cindex @code{?} (wildcard character) @cindex @code{[@dots{}]} (wildcard characters) A single file name can specify many files using @dfn{wildcard characters}. The wildcard characters in @code{make} are @samp{*}, @samp{?} and @samp{[@dots{}]}, the same as in the Bourne shell. For example, @file{*.c} specifies a list of all the files (in the working directory) whose names end in @samp{.c}.@refill @cindex @code{~} (tilde) @cindex tilde (@code{~}) @cindex home directory The character @samp{~} at the beginning of a file name also has special significance. If alone, or followed by a slash, it represents your home directory. For example @file{~/bin} expands to @file{/home/you/bin}. If the @samp{~} is followed by a word, the string represents the home directory of the user named by that word. For example @file{~john/bin} expands to @file{/home/john/bin}.@refill Wildcard expansion happens automatically in targets, in dependencies, and in commands (where the shell does the expansion). In other contexts, wildcard expansion happens only if you request it explicitly with the @code{wildcard} function. The special significance of a wildcard character can be turned off by preceding it with a backslash. Thus, @file{foo\*bar} would refer to a specific file whose name consists of @samp{foo}, an asterisk, and @samp{bar}.@refill @menu * Wildcard Examples:: Several examples * Wildcard Pitfall:: Problems to avoid. * Wildcard Function:: How to cause wildcard expansion where it does not normally take place. @end menu @node Wildcard Examples, Wildcard Pitfall, , Wildcards @subsection Wildcard Examples Wildcards can be used in the commands of a rule, where they are expanded by the shell. For example, here is a rule to delete all the object files: @example @group clean: rm -f *.o @end group @end example @cindex @code{rm} (shell command) Wildcards are also useful in the dependencies of a rule. With the following rule in the makefile, @samp{make print} will print all the @samp{.c} files that have changed since the last time you printed them: @example print: *.c lpr -p $? touch print @end example @cindex @code{print} target @cindex @code{lpr} (shell command) @cindex @code{touch} (shell command) @noindent This rule uses @file{print} as an empty target file; see @ref{Empty Targets, ,Empty Target Files to Record Events}. (The automatic variable @samp{$?} is used to print only those files that have changed; see @ref{Automatic, ,Automatic Variables}.)@refill Wildcard expansion does not happen when you define a variable. Thus, if you write this: @example objects = *.o @end example @noindent then the value of the variable @code{objects} is the actual string @samp{*.o}. However, if you use the value of @code{objects} in a target, dependency or command, wildcard expansion will take place at that time. To set @code{objects} to the expansion, instead use: @example objects := $(wildcard *.o) @end example @noindent @xref{Wildcard Function}. @node Wildcard Pitfall, Wildcard Function, Wildcard Examples, Wildcards @subsection Pitfalls of Using Wildcards @cindex wildcard pitfalls @cindex pitfalls of wildcards @cindex mistakes with wildcards @cindex errors with wildcards @cindex problems with wildcards Now here is an example of a naive way of using wildcard expansion, that does not do what you would intend. Suppose you would like to say that the executable file @file{foo} is made from all the object files in the directory, and you write this: @example objects = *.o foo : $(objects) cc -o foo $(CFLAGS) $(objects) @end example @noindent The value of @code{objects} is the actual string @samp{*.o}. Wildcard expansion happens in the rule for @file{foo}, so that each @emph{existing} @samp{.o} file becomes a dependency of @file{foo} and will be recompiled if necessary. But what if you delete all the @samp{.o} files? When a wildcard matches no files, it is left as it is, so then @file{foo} will depend on the oddly-named file @file{*.o}. Since so such file is likely to exist, @code{make} will give you an error saying it cannot figure out how to make @file{*.o}. This is not what you want! Actually it is possible to obtain the desired result with wildcard expansion, but you need more sophisticated techniques, including the @code{wildcard} function and string substitution. @ifinfo @xref{Wildcard Function, ,The Function @code{wildcard}}. @end ifinfo @iftex These are described in the following section. @end iftex @node Wildcard Function, , Wildcard Pitfall, Wildcards @subsection The Function @code{wildcard} @findex wildcard Wildcard expansion happens automatically in rules. But wildcard expansion does not normally take place when a variable is set, or inside the arguments of a function. If you want to do wildcard expansion in such places, you need to use the @code{wildcard} function, like this: @example $(wildcard @var{pattern}@dots{}) @end example @noindent This string, used anywhere in a makefile, is replaced by a space-separated list of names of existing files that match one of the given file name patterns. If no existing file name matches a pattern, then that pattern is omitted from the output of the @code{wildcard} function. Note that this is different from how unmatched wildcards behave in rules, where they are used verbatim rather than ignored (@pxref{Wildcard Pitfall}). One use of the @code{wildcard} function is to get a list of all the C source files in a directory, like this: @example $(wildcard *.c) @end example We can change the list of C source files into a list of object files by replacing the @samp{.o} suffix with @samp{.c} in the result, like this: @example $(patsubst %.c,%.o,$(wildcard *.c)) @end example @noindent (Here we have used another function, @code{patsubst}. @xref{Text Functions, ,Functions for String Substitution and Analysis}.)@refill Thus, a makefile to compile all C source files in the directory and then link them together could be written as follows: @example objects := $(patsubst %.c,%.o,$(wildcard *.c)) foo : $(objects) cc -o foo $(objects) @end example @noindent (This takes advantage of the implicit rule for compiling C programs, so there is no need to write explicit rules for compiling the files. @xref{Flavors, ,The Two Flavors of Variables}, for an explanation of @samp{:=}, which is a variant of @samp{=}.) @node Directory Search, Phony Targets, Wildcards, Rules @section Searching Directories for Dependencies @vindex VPATH @findex vpath @cindex vpath @cindex search path for dependencies (@code{VPATH}) @cindex directory search (@code{VPATH}) For large systems, it is often desirable to put sources in a separate directory from the binaries. The @dfn{directory search} features of @code{make} facilitate this by searching several directories automatically to find a dependency. When you redistribute the files among directories, you do not need to change the individual rules, just the search paths. @menu * General Search:: Specifying a search path that applies to every dependency. * Selective Search:: Specifying a search path for a specified class of names. * Commands/Search:: How to write shell commands that work together with search paths. * Implicit/Search:: How search paths affect implicit rules. * Libraries/Search:: Directory search for link libraries. @end menu @node General Search, Selective Search, , Directory Search @subsection @code{VPATH}: Search Path for All Dependencies @vindex VPATH The value of the @code{make} variable @code{VPATH} specifies a list of directories that @code{make} should search. Most often, the directories are expected to contain dependency files that are not in the current directory; however, @code{VPATH} specifies a search list that @code{make} applies for all files, including files which are targets of rules. Thus, if a file that is listed as a target or dependency does not exist in the current directory, @code{make} searches the directories listed in @code{VPATH} for a file with that name. If a file is found in one of them, that file becomes the dependency. Rules may then specify the names of source files in the dependencies as if they all existed in the current directory. @xref{Commands/Search, ,Writing Shell Commands with Directory Search}. In the @code{VPATH} variable, directory names are separated by colons. The order in which directories are listed is the order followed by @code{make} in its search. For example, @example VPATH = src:../headers @end example @noindent specifies a path containing two directories, @file{src} and @file{../headers}, which @code{make} searches in that order. With this value of @code{VPATH}, the following rule, @example foo.o : foo.c @end example @noindent is interpreted as if it were written like this: @example foo.o : src/foo.c @end example @noindent assuming the file @file{foo.c} does not exist in the current directory but is found in the directory @file{src}. @node Selective Search, Commands/Search, General Search, Directory Search @subsection The @code{vpath} Directive @findex vpath Similar to the @code{VPATH} variable but more selective is the @code{vpath} directive (note lower case), which allows you to specify a search path for a particular class of file names, those that match a particular pattern. Thus you can supply certain search directories for one class of file names and other directories (or none) for other file names. There are three forms of the @code{vpath} directive: @table @code @item vpath @var{pattern} @var{directories} Specify the search path @var{directories} for file names that match @var{pattern}. The search path, @var{directories}, is a colon-separated list of directories to be searched, just like the search path used in the @code{VPATH} variable. @item vpath @var{pattern} Clear out the search path associated with @var{pattern}. @c Extra blank line makes sure this gets two lines. @item vpath Clear all search paths previously specified with @code{vpath} directives. @end table A @code{vpath} pattern is a string containing a @samp{%} character. The string must match the file name of a dependency that is being searched for, the @samp{%} character matching any sequence of zero or more characters (as in pattern rules; @pxref{Pattern Rules, ,Defining and Redefining Pattern Rules}). For example, @code{%.h} matches files that end in @code{.h}. (If there is no @samp{%}, the pattern must match the dependency exactly, which is not useful very often.) @cindex @code{%}, quoting in @code{vpath} @cindex @code{%}, quoting with @code{\} (backslash) @cindex @code{\} (backslash), to quote @code{%} @cindex backslash (@code{\}), to quote @code{%} @cindex quoting @code{%}, in @code{vpath} @samp{%} characters in a @code{vpath} directive's pattern can be quoted with preceding backslashes (@samp{\}). Backslashes that would otherwise quote @samp{%} characters can be quoted with more backslashes. Backslashes that quote @samp{%} characters or other backslashes are removed from the pattern before it is compared to file names. Backslashes that are not in danger of quoting @samp{%} characters go unmolested.@refill When a dependency fails to exist in the current directory, if the @var{pattern} in a @code{vpath} directive matches the name of the dependency file, then the @var{directories} in that directive are searched just like (and before) the directories in the @code{VPATH} variable. For example, @example vpath %.h ../headers @end example @noindent tells @code{make} to look for any dependency whose name ends in @file{.h} in the directory @file{../headers} if the file is not found in the current directory. If several @code{vpath} patterns match the dependency file's name, then @code{make} processes each matching @code{vpath} directive one by one, searching all the directories mentioned in each directive. @code{make} handles multiple @code{vpath} directives in the order in which they appear in the makefile; multiple directives with the same pattern are independent of each other. @need 750 Thus, @example @group vpath %.c foo vpath % blish vpath %.c bar @end group @end example @noindent will look for a file ending in @samp{.c} in @file{foo}, then @file{blish}, then @file{bar}, while @example @group vpath %.c foo:bar vpath % blish @end group @end example @noindent will look for a file ending in @samp{.c} in @file{foo}, then @file{bar}, then @file{blish}. @node Commands/Search, Implicit/Search, Selective Search, Directory Search @subsection Writing Shell Commands with Directory Search @cindex shell command, and directory search @cindex directory search (@code{VPATH}), and shell commands When a dependency is found in another directory through directory search, this cannot change the commands of the rule; they will execute as written. Therefore, you must write the commands with care so that they will look for the dependency in the directory where @code{make} finds it. This is done with the @dfn{automatic variables} such as @samp{$^} (@pxref{Automatic, ,Automatic Variables}). For instance, the value of @samp{$^} is a list of all the dependencies of the rule, including the names of the directories in which they were found, and the value of @samp{$@@} is the target. Thus:@refill @example foo.o : foo.c cc -c $(CFLAGS) $^ -o $@@ @end example @noindent (The variable @code{CFLAGS} exists so you can specify flags for C compilation by implicit rules; we use it here for consistency so it will affect all C compilations uniformly; @pxref{Implicit Variables, ,Variables Used by Implicit Rules}.) Often the dependencies include header files as well, which you do not want to mention in the commands. The automatic variable @samp{$<} is just the first dependency: @example VPATH = src:../headers foo.o : foo.c defs.h hack.h cc -c $(CFLAGS) $< -o $@@ @end example @node Implicit/Search, Libraries/Search, Commands/Search, Directory Search @subsection Directory Search and Implicit Rules @cindex @code{VPATH}, and implicit rules @cindex directory search (@code{VPATH}), and implicit rules @cindex search path for dependencies (@code{VPATH}), and implicit rules @cindex implicit rule, and directory search @cindex implicit rule, and @code{VPATH} @cindex rule, implicit, and directory search @cindex rule, implicit, and @code{VPATH} The search through the directories specified in @code{VPATH} or with @code{vpath} also happens during consideration of implicit rules (@pxref{Implicit Rules, ,Using Implicit Rules}). For example, when a file @file{foo.o} has no explicit rule, @code{make} considers implicit rules, such as the built-in rule to compile @file{foo.c} if that file exists. If such a file is lacking in the current directory, the appropriate directories are searched for it. If @file{foo.c} exists (or is mentioned in the makefile) in any of the directories, the implicit rule for C compilation is applied. The commands of implicit rules normally use automatic variables as a matter of necessity; consequently they will use the file names found by directory search with no extra effort. @node Libraries/Search, , Implicit/Search, Directory Search @subsection Directory Search for Link Libraries @cindex link libraries, and directory search @cindex libraries for linking, directory search @cindex directory search (@code{VPATH}), and link libraries @cindex @code{VPATH}, and link libraries @cindex search path for dependencies (@code{VPATH}), and link libraries @cindex @code{-l} (library search) Directory search applies in a special way to libraries used with the linker. This special feature comes into play when you write a dependency whose name is of the form @samp{-l@var{name}}. (You can tell something strange is going on here because the dependency is normally the name of a file, and the @emph{file name} of the library looks like @file{lib@var{name}.a}, not like @samp{-l@var{name}}.)@refill When a dependency's name has the form @samp{-l@var{name}}, @code{make} handles it specially by searching for the file @file{lib@var{name}.a} in the current directory, in directories specified by matching @code{vpath} search paths and the @code{VPATH} search path, and then in the directories @file{/lib}, @file{/usr/lib}, and @file{@var{prefix}/lib} (normally @file{/usr/local/lib}). For example, @example @group foo : foo.c -lcurses cc $^ -o $@@ @end group @end example @noindent would cause the command @samp{cc foo.c /usr/lib/libcurses.a -o foo} to be executed when @file{foo} is older than @file{foo.c} or than @file{/usr/lib/libcurses.a}.@refill @node Phony Targets, Force Targets, Directory Search, Rules @section Phony Targets @cindex phony targets @cindex targets, phony @cindex targets without a file A phony target is one that is not really the name of a file. It is just a name for some commands to be executed when you make an explicit request. There are two reasons to use a phony target: to avoid a conflict with a file of the same name, and to improve performance. If you write a rule whose commands will not create the target file, the commands will be executed every time the target comes up for remaking. Here is an example: @example @group clean: rm *.o temp @end group @end example @noindent Because the @code{rm} command does not create a file named @file{clean}, probably no such file will ever exist. Therefore, the @code{rm} command will be executed every time you say @samp{make clean}. @cindex @code{rm} (shell command) @findex .PHONY The phony target will cease to work if anything ever does create a file named @file{clean} in this directory. Since it has no dependencies, the file @file{clean} would inevitably be considered up to date, and its commands would not be executed. To avoid this problem, you can explicitly declare the target to be phony, using the special target @code{.PHONY} (@pxref{Special Targets, ,Special Built-in Target Names}) as follows: @example .PHONY : clean @end example @noindent Once this is done, @samp{make clean} will run the commands regardless of whether there is a file named @file{clean}. Since it knows that phony targets do not name actual files that could be remade from other files, @code{make} skips the implicit rule search for phony targets (@pxref{Implicit Rules}). This is why declaring a target phony is good for performance, even if you are not worried about the actual file existing. Thus, you first write the line that states that @code{clean} is a phony target, then you write the rule, like this: @example @group .PHONY: clean clean: rm *.o temp @end group @end example A phony target should not be a dependency of a real target file; if it is, its commands are run every time @code{make} goes to update that file. As long as a phony target is never a dependency of a real target, the phony target commands will be executed only when the phony target is a specified goal (@pxref{Goals, ,Arguments to Specify the Goals}). Phony targets can have dependencies. When one directory contains multiple programs, it is most convenient to describe all of the programs in one makefile @file{./Makefile}. Since the target remade by default will be the first one in the makefile, it is common to make this a phony target named @samp{all} and give it, as dependencies, all the individual programs. For example: @example all : prog1 prog2 prog3 .PHONY : all prog1 : prog1.o utils.o cc -o prog1 prog1.o utils.o prog2 : prog2.o cc -o prog2 prog2.o prog3 : prog3.o sort.o utils.o cc -o prog3 prog3.o sort.o utils.o @end example @noindent Now you can say just @samp{make} to remake all three programs, or specify as arguments the ones to remake (as in @samp{make prog1 prog3}). When one phony target is a dependency of another, it serves as a subroutine of the other. For example, here @samp{make cleanall} will delete the object files, the difference files, and the file @file{program}: @example .PHONY: cleanall cleanobj cleandiff cleanall : cleanobj cleandiff rm program cleanobj : rm *.o cleandiff : rm *.diff @end example @node Force Targets, Empty Targets, Phony Targets, Rules @section Rules without Commands or Dependencies @cindex force targets @cindex targets, force @cindex @code{FORCE} @cindex rule, no commands or dependencies If a rule has no dependencies or commands, and the target of the rule is a nonexistent file, then @code{make} imagines this target to have been updated whenever its rule is run. This implies that all targets depending on this one will always have their commands run. An example will illustrate this: @example @group clean: FORCE rm $(objects) FORCE: @end group @end example Here the target @samp{FORCE} satisfies the special conditions, so the target @file{clean} that depends on it is forced to run its commands. There is nothing special about the name @samp{FORCE}, but that is one name commonly used this way. As you can see, using @samp{FORCE} this way has the same results as using @samp{.PHONY: clean}. Using @samp{.PHONY} is more explicit and more efficient. However, other versions of @code{make} do not support @samp{.PHONY}; thus @samp{FORCE} appears in many makefiles. @xref{Phony Targets}. @node Empty Targets, Special Targets, Force Targets, Rules @section Empty Target Files to Record Events @cindex empty targets @cindex targets, empty @cindex recording events with empty targets The @dfn{empty target} is a variant of the phony target; it is used to hold commands for an action that you request explicitly from time to time. Unlike a phony target, this target file can really exist; but the file's contents do not matter, and usually are empty. The purpose of the empty target file is to record, with its last-modification time, when the rule's commands were last executed. It does so because one of the commands is a @code{touch} command to update the target file. The empty target file must have some dependencies. When you ask to remake the empty target, the commands are executed if any dependency is more recent than the target; in other words, if a dependency has changed since the last time you remade the target. Here is an example: @example print: foo.c bar.c lpr -p $? touch print @end example @cindex @code{print} target @cindex @code{lpr} (shell command) @cindex @code{touch} (shell command) @noindent With this rule, @samp{make print} will execute the @code{lpr} command if either source file has changed since the last @samp{make print}. The automatic variable @samp{$?} is used to print only those files that have changed (@pxref{Automatic, ,Automatic Variables}). @node Special Targets, Multiple Targets, Empty Targets, Rules @section Special Built-in Target Names @cindex special targets @cindex built-in special targets @cindex targets, built-in special Certain names have special meanings if they appear as targets. @table @code @findex .PHONY @item .PHONY The dependencies of the special target @code{.PHONY} are considered to be phony targets. When it is time to consider such a target, @code{make} will run its commands unconditionally, regardless of whether a file with that name exists or what its last-modification time is. @xref{Phony Targets, ,Phony Targets}. @findex .SUFFIXES @item .SUFFIXES The dependencies of the special target @code{.SUFFIXES} are the list of suffixes to be used in checking for suffix rules. @xref{Suffix Rules, , Old-Fashioned Suffix Rules}. @findex .DEFAULT @item .DEFAULT The commands specified for @code{.DEFAULT} are used for any target for which no rules are found (either explicit rules or implicit rules). @xref{Last Resort}. If @code{.DEFAULT} commands are specified, every file mentioned as a dependency, but not as a target in a rule, will have these commands executed on its behalf. @xref{Search Algorithm, ,Implicit Rule Search Algorithm}. @findex .PRECIOUS @item .PRECIOUS @cindex precious targets @cindex preserving with @code{.PRECIOUS} The targets which @code{.PRECIOUS} depends on are given the following special treatment: if @code{make} is killed or interrupted during the execution of their commands, the target is not deleted. @xref{Interrupts, ,Interrupting or Killing @code{make}}. Also, if the target is an intermediate file, it will not be deleted after it is no longer needed, as is normally done. @xref{Chained Rules, ,Chains of Implicit Rules}. You can also list the target pattern of an implicit rule (such as @samp{%.o}) as a dependency file of the special target @code{.PRECIOUS} to preserve intermediate files created by rules whose target patterns match that file's name. @findex .IGNORE @item .IGNORE Simply by being mentioned as a target, @code{.IGNORE} says to ignore errors in execution of commands. The dependencies and commands for @code{.IGNORE} are not meaningful. @samp{.IGNORE} exists for historical compatibility. Since @code{.IGNORE} affects every command in the makefile, it is not very useful; we recommend you use the more selective ways to ignore errors in specific commands. @xref{Errors, ,Errors in Commands}. @findex .SILENT @item .SILENT Simply by being mentioned as a target, @code{.SILENT} says not to print commands before executing them. The dependencies and commands for @code{.SILENT} are not meaningful. @samp{.SILENT} exists for historical compatibility. We recommend you use the more selective ways to silence specific commands. @xref{Echoing, ,Command Echoing}. If you want to silence all commands for a particular run of @code{make}, use the @samp{-s} or @w{@samp{--silent}} option (@pxref{Options Summary}). @findex .EXPORT_ALL_VARIABLES @item .EXPORT_ALL_VARIABLES Simply by being mentioned as a target, this tells @code{make} to export all variables to child processes by default. @xref{Variables/Recursion, ,Communicating Variables to a Sub-@code{make}}. @end table Any defined implicit rule suffix also counts as a special target if it appears as a target, and so does the concatenation of two suffixes, such as @samp{.c.o}. These targets are suffix rules, an obsolete way of defining implicit rules (but a way still widely used). In principle, any target name could be special in this way if you break it in two and add both pieces to the suffix list. In practice, suffixes normally begin with @samp{.}, so these special target names also begin with @samp{.}. @xref{Suffix Rules, ,Old-Fashioned Suffix Rules}. @node Multiple Targets, Multiple Rules, Special Targets, Rules @section Multiple Targets in a Rule @cindex multiple targets @cindex several targets in a rule @cindex targets, multiple @cindex rule, with multiple targets A rule with multiple targets is equivalent to writing many rules, each with one target, and all identical aside from that. The same commands apply to all the targets, but their effects may vary because you can substitute the actual target name into the command using @samp{$@@}. The rule contributes the same dependencies to all the targets also. This is useful in two cases. @itemize @bullet @item You want just dependencies, no commands. For example: @example kbd.o command.o files.o: command.h @end example @noindent gives an additional dependency to each of the three object files mentioned. @item Similar commands work for all the targets. The commands do not need to be absolutely identical, since the automatic variable @samp{$@@} can be used to substitute the particular target to be remade into the commands (@pxref{Automatic, ,Automatic Variables}). For example: @example @group bigoutput littleoutput : text.g generate text.g -$(subst output,,$@@) > $@@ @end group @end example @findex subst @noindent is equivalent to @example bigoutput : text.g generate text.g -big > bigoutput littleoutput : text.g generate text.g -little > littleoutput @end example @noindent Here we assume the hypothetical program @code{generate} makes two types of output, one if given @samp{-big} and one if given @samp{-little}. @xref{Text Functions, ,Functions for String Substitution and Analysis}, for an explanation of the @code{subst} function. @end itemize Suppose you would like to vary the dependencies according to the target, much as the variable @samp{$@@} allows you to vary the commands. You cannot do this with multiple targets in an ordinary rule, but you can do it with a @dfn{static pattern rule}. @xref{Static Pattern, ,Static Pattern Rules}. @node Multiple Rules, Static Pattern, Multiple Targets, Rules @section Multiple Rules for One Target @cindex multiple rules for one target @cindex several rules for one target @cindex rule, multiple for one target @cindex target, multiple rules for one One file can be the target of several rules. All the dependencies mentioned in all the rules are merged into one list of dependencies for the target. If the target is older than any dependency from any rule, the commands are executed. There can only be one set of commands to be executed for a file. If more than one rule gives commands for the same file, @code{make} uses the last set given and prints an error message. (As a special case, if the file's name begins with a dot, no error message is printed. This odd behavior is only for compatibility with other implementations of @code{make}.) There is no reason to write your makefiles this way; that is why @code{make} gives you an error message.@refill An extra rule with just dependencies can be used to give a few extra dependencies to many files at once. For example, one usually has a variable named @code{objects} containing a list of all the compiler output files in the system being made. An easy way to say that all of them must be recompiled if @file{config.h} changes is to write the following: @example objects = foo.o bar.o foo.o : defs.h bar.o : defs.h test.h $(objects) : config.h @end example This could be inserted or taken out without changing the rules that really specify how to make the object files, making it a convenient form to use if you wish to add the additional dependency intermittently. Another wrinkle is that the additional dependencies could be specified with a variable that you set with a command argument to @code{make} (@pxref{Overriding, ,Overriding Variables}). For example, @example @group extradeps= $(objects) : $(extradeps) @end group @end example @noindent means that the command @samp{make extradeps=foo.h} will consider @file{foo.h} as a dependency of each object file, but plain @samp{make} will not. If none of the explicit rules for a target has commands, then @code{make} searches for an applicable implicit rule to find some commands @pxref{Implicit Rules, ,Using Implicit Rules}). @node Static Pattern, Double-Colon, Multiple Rules, Rules @section Static Pattern Rules @cindex static pattern rule @cindex rule, static pattern @cindex pattern rules, static (not implicit) @cindex varying dependencies @cindex dependencies, varying (static pattern) @dfn{Static pattern rules} are rules which specify multiple targets and construct the dependency names for each target based on the target name. They are more general than ordinary rules with multiple targets because the targets do not have to have identical dependencies. Their dependencies must be @emph{analogous}, but not necessarily @emph{identical}. @menu * Static Usage:: The syntax of static pattern rules. * Static versus Implicit:: When are they better than implicit rules? @end menu @node Static Usage, Static versus Implicit, , Static Pattern @subsection Syntax of Static Pattern Rules @cindex static pattern rule, syntax of @cindex pattern rules, static, syntax of Here is the syntax of a static pattern rule: @example @var{targets} @dots{}: @var{target-pattern}: @var{dep-patterns} @dots{} @var{commands} @dots{} @end example @noindent The @var{targets} list specifies the targets that the rule applies to. The targets can contain wildcard characters, just like the targets of ordinary rules (@pxref{Wildcards, ,Using Wildcard Characters in File Names}). @cindex target pattern, static (not implicit) @cindex stem The @var{target-pattern} and @var{dep-patterns} say how to compute the dependencies of each target. Each target is matched against the @var{target-pattern} to extract a part of the target name, called the @dfn{stem}. This stem is substituted into each of the @var{dep-patterns} to make the dependency names (one from each @var{dep-pattern}). Each pattern normally contains the character @samp{%} just once. When the @var{target-pattern} matches a target, the @samp{%} can match any part of the target name; this part is called the @dfn{stem}. The rest of the pattern must match exactly. For example, the target @file{foo.o} matches the pattern @samp{%.o}, with @samp{foo} as the stem. The targets @file{foo.c} and @file{foo.out} do not match that pattern.@refill @cindex dependency pattern, static (not implicit) The dependency names for each target are made by substituting the stem for the @samp{%} in each dependency pattern. For example, if one dependency pattern is @file{%.c}, then substitution of the stem @samp{foo} gives the dependency name @file{foo.c}. It is legitimate to write a dependency pattern that does not contain @samp{%}; then this dependency is the same for all targets. @cindex @code{%}, quoting in static pattern @cindex @code{%}, quoting with @code{\} (backslash) @cindex @code{\} (backslash), to quote @code{%} @cindex backslash (@code{\}), to quote @code{%} @cindex quoting @code{%}, in static pattern @samp{%} characters in pattern rules can be quoted with preceding backslashes (@samp{\}). Backslashes that would otherwise quote @samp{%} characters can be quoted with more backslashes. Backslashes that quote @samp{%} characters or other backslashes are removed from the pattern before it is compared to file names or has a stem substituted into it. Backslashes that are not in danger of quoting @samp{%} characters go unmolested. For example, the pattern @file{the\%weird\\%pattern\\} has @samp{the%weird\} preceding the operative @samp{%} character, and @samp{pattern\\} following it. The final two backslashes are left alone because they cannot affect any @samp{%} character.@refill Here is an example, which compiles each of @file{foo.o} and @file{bar.o} from the corresponding @file{.c} file: @example @group objects = foo.o bar.o $(objects): %.o: %.c $(CC) -c $(CFLAGS) $< -o $@@ @end group @end example @noindent Here @samp{$<} is the automatic variable that holds the name of the dependency and @samp{$@@} is the automatic variable that holds the name of the target; see @ref{Automatic, , Automatic Variables}. Each target specified must match the target pattern; a warning is issued for each target that does not. If you have a list of files, only some of which will match the pattern, you can use the @code{filter} function to remove nonmatching file names (@pxref{Text Functions, ,Functions for String Substitution and Analysis}): @example files = foo.elc bar.o lose.o $(filter %.o,$(files)): %.o: %.c $(CC) -c $(CFLAGS) $< -o $@@ $(filter %.elc,$(files)): %.elc: %.el emacs -f batch-byte-compile $< @end example @noindent In this example the result of @samp{$(filter %.o,$(files))} is @file{bar.o lose.o}, and the first static pattern rule causes each of these object files to be updated by compiling the corresponding C source file. The result of @w{@samp{$(filter %.elc,$(files))}} is @file{foo.elc}, so that file is made from @file{foo.el}.@refill Another example shows how to use @code{$*} in static pattern rules: @vindex $*@r{, and static pattern} @example @group bigoutput littleoutput : %output : text.g generate text.g -$* > $@@ @end group @end example @noindent When the @code{generate} command is run, @code{$*} will expand to the stem, either @samp{big} or @samp{little}. @node Static versus Implicit, , Static Usage, Static Pattern @subsection Static Pattern Rules versus Implicit Rules @cindex rule, static pattern versus implicit @cindex static pattern rule, versus implicit A static pattern rule has much in common with an implicit rule defined as a pattern rule (@pxref{Pattern Rules, ,Defining and Redefining Pattern Rules}). Both have a pattern for the target and patterns for constructing the names of dependencies. The difference is in how @code{make} decides @emph{when} the rule applies. An implicit rule @emph{can} apply to any target that matches its pattern, but it @emph{does} apply only when the target has no commands otherwise specified, and only when the dependencies can be found. If more than one implicit rule appears applicable, only one applies; the choice depends on the order of rules. By contrast, a static pattern rule applies to the precise list of targets that you specify in the rule. It cannot apply to any other target and it invariably does apply to each of the targets specified. If two conflicting rules apply, and both have commands, that's an error. The static pattern rule can be better than an implicit rule for these reasons: @itemize @bullet @item You may wish to override the usual implicit rule for a few files whose names cannot be categorized syntactically but can be given in an explicit list. @item If you cannot be sure of the precise contents of the directories you are using, you may not be sure which other irrelevant files might lead @code{make} to use the wrong implicit rule. The choice might depend on the order in which the implicit rule search is done. With static pattern rules, there is no uncertainty: each rule applies to precisely the targets specified. @end itemize @node Double-Colon, Automatic Dependencies, Static Pattern, Rules @section Double-Colon Rules @cindex double-colon rules @cindex rule, double-colon (@code{::}) @cindex multiple rules for one target (@code{::}) @cindex @code{::} rules (double-colon) @dfn{Double-colon} rules are rules written with @samp{::} instead of @samp{:} after the target names. They are handled differently from ordinary rules when the same target appears in more than one rule. When a target appears in multiple rules, all the rules must be the same type: all ordinary, or all double-colon. If they are double-colon, each of them is independent of the others. Each double-colon rule's commands are executed if the target is older than any dependencies of that rule. This can result in executing none, any, or all of the double-colon rules. Double-colon rules with the same target are in fact completely separate from one another. Each double-colon rule is processed individually, just as rules with different targets are processed. The double-colon rules for a target are executed in the order they appear in the makefile. However, the cases where double-colon rules really make sense are those where the order of executing the commands would not matter. Double-colon rules are somewhat obscure and not often very useful; they provide a mechanism for cases in which the method used to update a target differs depending on which dependency files caused the update, and such cases are rare. Each double-colon rule should specify commands; if it does not, an implicit rule will be used if one applies. @xref{Implicit Rules, ,Using Implicit Rules}. @node Automatic Dependencies, , Double-Colon, Rules @section Generating Dependencies Automatically @cindex dependencies, automatic generation @cindex automatic generation of dependencies @cindex generating dependencies automatically In the makefile for a program, many of the rules you need to write often say only that some object file depends on some header file. For example, if @file{main.c} uses @file{defs.h} via an @code{#include}, you would write: @example main.o: defs.h @end example @noindent You need this rule so that @code{make} knows that it must remake @file{main.o} whenever @file{defs.h} changes. You can see that for a large program you would have to write dozens of such rules in your makefile. And, you must always be very careful to update the makefile every time you add or remove an @code{#include}. @cindex @code{#include} @cindex @code{-M} (to compiler) To avoid this hassle, most modern C compilers can write these rules for you, by looking at the @code{#include} lines in the source files. Usually this is done with the @samp{-M} option to the compiler. For example, the command: @example cc -M main.c @end example @noindent generates the output: @example main.o : main.c defs.h @end example @noindent Thus you no longer have to write all those rules yourself. The compiler will do it for you. @cindex @code{make depend} With old @code{make} programs, it was traditional practice to use this compiler feature to generate dependencies on demand with a command like @samp{make depend}. That command would create a file @file{depend} containing all the automatically-generated dependencies; then the makefile could use @code{include} to read them in (@pxref{Include}). In GNU @code{make}, the feature of remaking makefiles makes this practice obsolete---you need never tell @code{make} explicitly to regenerate the dependencies, because it always regenerates any makefile that is out of date. @xref{Remaking Makefiles}. The practice we recommend for automatic dependency generation is to have one makefile corresponding to each source file. For each source file @file{@var{name}.c} there is a makefile @file{@var{name}.d} which lists what files the object file @file{@var{name}.o} depends on. That way only the source files that have changed need to be rescanned to produce the new dependencies. Here is the pattern rule to generate a file of dependencies (i.e., a makefile) called @file{@var{name}.d} from a C source file called @file{@var{name}.c}: @example @group %.d: %.c $(SHELL) -ec '$(CC) -M $(CPPFLAGS) $< | sed '\''s/$*.o/& $@@/g'\'' > $@@' @end group @end example @noindent @xref{Pattern Rules}, for information on defining pattern rules. The @samp{-e} flag to the shell makes it exit immediately if the @code{$(CC)} command fails (exits with a nonzero status). Normally the shell exits with the status of the last command in the pipeline (@code{sed} in this case), so @code{make} would not notice a nonzero status from the compiler. @cindex @code{-e} (shell flag) @cindex @code{sed} (shell command) The purpose of the @code{sed} command is to translate (for example): @example main.o : main.c defs.h @end example @noindent into: @example main.o main.d : main.c defs.h @end example @noindent @cindex @code{.d} This makes each @samp{.d} file depend on all the source and header files that the corresponding @samp{.o} file depends on. @code{make} then knows it must regenerate the dependencies whenever any of the source or header files changes. Once you've defined the rule to remake the @samp{.d} files, you then use the @code{include} directive to read them all in. @xref{Include}. For example: @example @group sources = foo.c bar.c include $(sources:.c=.d) @end group @end example @noindent (This example uses a substitution variable reference to translate the list of source files @samp{foo.c bar.c} into a list of dependency makefiles, @samp{foo.d bar.d}. @xref{Substitution Refs}, for full information on substitution references.) Since the @samp{.d} files are makefiles like any others, @code{make} will remake them as necessary with no further work from you. @xref{Remaking Makefiles}. @node Commands, Using Variables, Rules, Top @chapter Writing the Commands in Rules @cindex commands, how to write @cindex rule commands @cindex writing rule commands The commands of a rule consist of shell command lines to be executed one by one. Each command line must start with a tab, except that the first command line may be attached to the target-and-dependencies line with a semicolon in between. Blank lines and lines of just comments may appear among the command lines; they are ignored. Users use many different shell programs, but commands in makefiles are always interpreted by @file{/bin/sh} unless the makefile specifies otherwise. @xref{Execution, ,Command Execution}. @cindex comments, in commands @cindex commands, comments in @cindex @code{#} (comments), in commands The shell that is in use determines whether comments can be written on command lines, and what syntax they use. When the shell is @file{/bin/sh}, a @samp{#} starts a comment that extends to the end of the line. The @samp{#} does not have to be at the beginning of a line. Text on a line before a @samp{#} is not part of the comment. @menu * Echoing:: How to control when commands are echoed. * Execution:: How commands are executed. * Parallel:: How commands can be executed in parallel. * Errors:: What happens after a command execution error. * Interrupts:: What happens when a command is interrupted. * Recursion:: Invoking @code{make} from makefiles. * Sequences:: Defining canned sequences of commands. * Empty Commands:: Defining useful, do-nothing commands. @end menu @node Echoing, Execution, , Commands @section Command Echoing @cindex echoing of commands @cindex silent operation @cindex @code{@@} (in commands) @cindex commands, echoing @cindex printing of commands Normally @code{make} prints each command line before it is executed. We call this @dfn{echoing} because it gives the appearance that you are typing the commands yourself. When a line starts with @samp{@@}, the echoing of that line is suppressed. The @samp{@@} is discarded before the command is passed to the shell. Typically you would use this for a command whose only effect is to print something, such as an @code{echo} command to indicate progress through the makefile: @example @@echo About to make distribution files @end example @cindex @code{-n} @cindex @code{--just-print} @cindex @code{--dry-run} @cindex @code{--recon} When @code{make} is given the flag @samp{-n} or @samp{--just-print}, echoing is all that happens, no execution. @xref{Options Summary, ,Summary of Options}. In this case and only this case, even the commands starting with @samp{@@} are printed. This flag is useful for finding out which commands @code{make} thinks are necessary without actually doing them. @cindex @code{-s} @cindex @code{--silent} @cindex @code{--quiet} @findex .SILENT The @samp{-s} or @samp{--silent} flag to @code{make} prevents all echoing, as if all commands started with @samp{@@}. A rule in the makefile for the special target @code{.SILENT} has the same effect (@pxref{Special Targets, ,Special Built-in Target Names}). @code{.SILENT} is essentially obsolete since @samp{@@} is more flexible.@refill @node Execution, Parallel, Echoing, Commands @section Command Execution @cindex commands, execution @cindex execution, of commands @cindex shell command, execution @vindex SHELL @r{(command execution)} When it is time to execute commands to update a target, they are executed by making a new subshell for each line. (In practice, @code{make} may take shortcuts that do not affect the results.) @cindex @code{cd} (shell command) @strong{Please note:} this implies that shell commands such as @code{cd} that set variables local to each process will not affect the following command lines. If you want to use @code{cd} to affect the next command, put the two on a single line with a semicolon between them. Then @code{make} will consider them a single command and pass them, together, to a shell which will execute them in sequence. For example: @example foo : bar/lose cd bar; gobble lose > ../foo @end example @cindex commands, backslash (@code{\}) in @cindex commands, quoting newlines in @cindex backslash (@code{\}), in commands @cindex @code{\} (backslash), in commands @cindex quoting newline, in commands @cindex newline, quoting, in commands If you would like to split a single shell command into multiple lines of text, you must use a backslash at the end of all but the last subline. Such a sequence of lines is combined into a single line, by deleting the backslash-newline sequences, before passing it to the shell. Thus, the following is equivalent to the preceding example: @example @group foo : bar/lose cd bar; \ gobble lose > ../foo @end group @end example @vindex SHELL The program used as the shell is taken from the variable @code{SHELL}. By default, the program @file{/bin/sh} is used. @cindex environment, @code{SHELL} in Unlike most variables, the variable @code{SHELL} is never set from the environment. This is because the @code{SHELL} environment variable is used to specify your personal choice of shell program for interactive use. It would be very bad for personal choices like this to affect the functioning of makefiles. @xref{Environment, ,Variables from the Environment}. @node Parallel, Errors, Execution, Commands @section Parallel Execution @cindex commands, execution in parallel @cindex parallel execution @cindex execution, in parallel @cindex job slots @cindex @code{-j} @cindex @code{--jobs} GNU @code{make} knows how to execute several commands at once. Normally, @code{make} will execute only one command at a time, waiting for it to finish before executing the next. However, the @samp{-j} or @samp{--jobs} option tells @code{make} to execute many commands simultaneously.@refill If the @samp{-j} option is followed by an integer, this is the number of commands to execute at once; this is called the number of @dfn{job slots}. If there is nothing looking like an integer after the @samp{-j} option, there is no limit on the number of job slots. The default number of job slots is one, which means serial execution (one thing at a time). One unpleasant consequence of running several commands simultaneously is that output from all of the commands comes when the commands send it, so messages from different commands may be interspersed. Another problem is that two processes cannot both take input from the same device; so to make sure that only one command tries to take input from the terminal at once, @code{make} will invalidate the standard input streams of all but one running command. This means that attempting to read from standard input will usually be a fatal error (a @samp{Broken pipe} signal) for most child processes if there are several. @cindex broken pipe @cindex standard input It is unpredictable which command will have a valid standard input stream (which will come from the terminal, or wherever you redirect the standard input of @code{make}). The first command run will always get it first, and the first command started after that one finishes will get it next, and so on. We will change how this aspect of @code{make} works if we find a better alternative. In the mean time, you should not rely on any command using standard input at all if you are using the parallel execution feature; but if you are not using this feature, then standard input works normally in all commands. If a command fails (is killed by a signal or exits with a nonzero status), and errors are not ignored for that command (@pxref{Errors, ,Errors in Commands}), the remaining command lines to remake the same target will not be run. If a command fails and the @samp{-k} or @samp{--keep-going} option was not given (@pxref{Options Summary, ,Summary of Options}), @code{make} aborts execution. If make terminates for any reason (including a signal) with child processes running, it waits for them to finish before actually exiting.@refill @cindex load average @cindex limiting jobs based on load @cindex jobs, limiting based on load @cindex @code{-l} (load average) @cindex @code{--max-load} @cindex @code{--load-average} When the system is heavily loaded, you will probably want to run fewer jobs than when it is lightly loaded. You can use the @samp{-l} option to tell @code{make} to limit the number of jobs to run at once, based on the load average. The @samp{-l} or @samp{--max-load} option is followed by a floating-point number. For example, @example -l 2.5 @end example @noindent will not let @code{make} start more than one job if the load average is above 2.5. The @samp{-l} option with no following number removes the load limit, if one was given with a previous @samp{-l} option.@refill More precisely, when @code{make} goes to start up a job, and it already has at least one job running, it checks the current load average; if it is not lower than the limit given with @samp{-l}, @code{make} waits until the load average goes below that limit, or until all the other jobs finish. By default, there is no load limit. @node Errors, Interrupts, Parallel, Commands @section Errors in Commands @cindex errors (in commands) @cindex commands, errors in @cindex exit status (errors) After each shell command returns, @code{make} looks at its exit status. If the command completed successfully, the next command line is executed in a new shell; after the last command line is finished, the rule is finished. If there is an error (the exit status is nonzero), @code{make} gives up on the current rule, and perhaps on all rules. Sometimes the failure of a certain command does not indicate a problem. For example, you may use the @code{mkdir} command to ensure that a directory exists. If the directory already exists, @code{mkdir} will report an error, but you probably want @code{make} to continue regardless. @cindex @code{-} (in commands) To ignore errors in a command line, write a @samp{-} at the beginning of the line's text (after the initial tab). The @samp{-} is discarded before the command is passed to the shell for execution. For example, @example @group clean: -rm -f *.o @end group @end example @cindex @code{rm} (shell command) @noindent This causes @code{rm} to continue even if it is unable to remove a file. @cindex @code{-i} @cindex @code{--ignore-errors} @findex .IGNORE When you run @code{make} with the @samp{-i} or @samp{--ignore-errors} flag, errors are ignored in all commands of all rules. A rule in the makefile for the special target @code{.IGNORE} has the same effect. These ways of ignoring errors are obsolete because @samp{-} is more flexible. When errors are to be ignored, because of either a @samp{-} or the @samp{-i} flag, @code{make} treats an error return just like success, except that it prints out a message that tells you the status code the command exited with, and says that the error has been ignored. When an error happens that @code{make} has not been told to ignore, it implies that the current target cannot be correctly remade, and neither can any other that depends on it either directly or indirectly. No further commands will be executed for these targets, since their preconditions have not been achieved. @cindex @code{-k} @cindex @code{--keep-going} Normally @code{make} gives up immediately in this circumstance, returning a nonzero status. However, if the @samp{-k} or @samp{--keep-going} flag is specified, @code{make} continues to consider the other dependencies of the pending targets, remaking them if necessary, before it gives up and returns nonzero status. For example, after an error in compiling one object file, @samp{make -k} will continue compiling other object files even though it already knows that linking them will be impossible. @xref{Options Summary, ,Summary of Options}. The usual behavior assumes that your purpose is to get the specified targets up to date; once @code{make} learns that this is impossible, it might as well report the failure immediately. The @samp{-k} option says that the real purpose is to test as many of the changes made in the program as possible, perhaps to find several independent problems so that you can correct them all before the next attempt to compile. This is why Emacs' @code{compile} command passes the @samp{-k} flag by default. @cindex Emacs (@code{M-x compile}) @node Interrupts, Recursion, Errors, Commands @section Interrupting or Killing @code{make} @cindex interrupt @cindex signal @cindex deletion of target files @cindex target, deleting on interrupt @cindex killing (interruption) If @code{make} gets a fatal signal while a command is executing, it may delete the target file that the command was supposed to update. This is done if the target file's last-modification time has changed since @code{make} first checked it. The purpose of deleting the target is to make sure that it is remade from scratch when @code{make} is next run. Why is this? Suppose you type @kbd{Ctrl-c} while a compiler is running, and it has begun to write an object file @file{foo.o}. The @kbd{Ctrl-c} kills the compiler, resulting in an incomplete file whose last-modification time is newer than the source file @file{foo.c}. But @code{make} also receives the @kbd{Ctrl-c} signal and deletes this incomplete file. If @code{make} did not do this, the next invocation of @code{make} would think that @file{foo.o} did not require updating---resulting in a strange error message from the linker when it tries to link an object file half of which is missing. @findex .PRECIOUS You can prevent the deletion of a target file in this way by making the special target @code{.PRECIOUS} depend on it. Before remaking a target, @code{make} checks to see whether it appears on the dependencies of @code{.PRECIOUS}, and thereby decides whether the target should be deleted if a signal happens. Some reasons why you might do this are that the target is updated in some atomic fashion, or exists only to record a modification-time (its contents do not matter), or must exist at all times to prevent other sorts of trouble. @node Recursion, Sequences, Interrupts, Commands @section Recursive Use of @code{make} @cindex recursion @cindex subdirectories, recursion for Recursive use of @code{make} means using @code{make} as a command in a makefile. This technique is useful when you want separate makefiles for various subsystems that compose a larger system. For example, suppose you have a subdirectory @file{subdir} which has its own makefile, and you would like the containing directory's makefile to run @code{make} on the subdirectory. You can do it by writing this: @example subsystem: cd subdir; $(MAKE) @end example @noindent or, equivalently, this (@pxref{Options Summary, ,Summary of Options}): @example subsystem: $(MAKE) -C subdir @end example @cindex @code{-C} @cindex @code{--directory} You can write recursive @code{make} commands just by copying this example, but there are many things to know about how they work and why, and about how the sub-@code{make} relates to the top-level @code{make}. @menu * MAKE Variable:: The special effects of using @samp{$(MAKE)}. * Variables/Recursion:: How to communicate variables to a sub-@code{make}. * Options/Recursion:: How to communicate options to a sub-@code{make}. * -w Option:: How the @samp{-w} or @samp{--print-directory} option helps debug use of recursive @code{make} commands. @end menu @node MAKE Variable, Variables/Recursion, , Recursion @subsection How the @code{MAKE} Variable Works @vindex MAKE @cindex recursion, and @code{MAKE} variable Recursive @code{make} commands should always use the variable @code{MAKE}, not the explicit command name @samp{make}, as shown here: @example @group subsystem: cd subdir; $(MAKE) @end group @end example The value of this variable is the file name with which @code{make} was invoked. If this file name was @file{/bin/make}, then the command executed is @samp{cd subdir; /bin/make}. If you use a special version of @code{make} to run the top-level makefile, the same special version will be executed for recursive invocations. @cindex @code{cd} (shell command) Also, any arguments that define variable values are added to @code{MAKE}, so the sub-@code{make} gets them too. Thus, if you do @samp{make CFLAGS=-O}, so that all C compilations will be optimized, the sub-@code{make} is run with @samp{cd subdir; /bin/make CFLAGS=-O}.@refill @vindex MAKE_COMMAND @vindex MAKEOVERRIDES The @code{MAKE} variable actually just refers to two other variables which contain these special values. In fact, @code{MAKE} is always defined as @samp{$(MAKE_COMMAND) $(MAKEOVERRIDES)}. The variable @code{MAKE_COMMAND} is the file name with which @code{make} was invoked (such as @file{/bin/make}, above). The variable @code{MAKEOVERRIDES} contains definitions for the variables defined on the command line; in the above example, its value is @samp{CFLAGS=-O}. If you @emph{do not} want these variable definitions done in all recursive @code{make} invocations, you can redefine the @code{MAKEOVERRIDES} variable to remove them. You do this in any of the normal ways for defining variables: in a makefile (@pxref{Setting, ,Setting Variables}); on the command line with an argument like @samp{MAKEOVERRIDES=} (@pxref{Overriding, ,Overriding Variables}); or with an environment variable (@pxref{Environment, ,Variables from the Environment}). As a special feature, using the variable @code{MAKE} in the commands of a rule alters the effects of the @samp{-t} (@samp{--touch}), @samp{-n} (@samp{--just-print}), or @samp{-q} (@w{@samp{--question}}) option. Using the @code{MAKE} variable has the same effect as using a @samp{+} character at the beginning of the command line. @xref{Instead of Execution, ,Instead of Executing the Commands}.@refill Consider the command @samp{make -t} in the above example. (The @samp{-t} option marks targets as up to date without actually running any commands; see @ref{Instead of Execution}.) Following the usual definition of @samp{-t}, a @samp{make -t} command in the example would create a file named @file{subsystem} and do nothing else. What you really want it to do is run @samp{@w{cd subdir;} @w{make -t}}; but that would require executing the command, and @samp{-t} says not to execute commands.@refill @cindex @code{-t}, and recursion @cindex recursion, and @code{-t} @cindex @code{--touch}, and recursion The special feature makes this do what you want: whenever a command line of a rule contains the variable @code{MAKE}, the flags @samp{-t}, @samp{-n} and @samp{-q} do not apply to that line. Command lines containing @code{MAKE} are executed normally despite the presence of a flag that causes most commands not to be run. The usual @code{MAKEFLAGS} mechanism passes the flags to the sub-@code{make} (@pxref{Options/Recursion, ,Communicating Options to a Sub-@code{make}}), so your request to touch the files, or print the commands, is propagated to the subsystem.@refill @node Variables/Recursion, Options/Recursion, MAKE Variable, Recursion @subsection Communicating Variables to a Sub-@code{make} @cindex sub-@code{make} @cindex environment, and recursion @cindex exporting variables @cindex variables, environment @cindex variables, exporting @cindex recursion, and environment @cindex recursion, and variables Variable values of the top-level @code{make} can be passed to the sub-@code{make} through the environment by explicit request. These variables are defined in the sub-@code{make} as defaults, but do not override what is specified in the sub-@code{make}'s makefile unless you use the @samp{-e} switch (@pxref{Options Summary, ,Summary of Options}).@refill To pass down, or @dfn{export}, a variable, @code{make} adds the variable and its value to the environment for running each command. The sub-@code{make}, in turn, uses the environment to initialize its table of variable values. @xref{Environment, ,Variables from the Environment}. Except by explicit request, @code{make} exports a variable only if it is either defined in the environment initially or set on the command line, and if its name consists only of letters, numbers, and underscores. Some shells cannot cope with environment variable names consisting of characters other than letters, numbers, and underscores. The special variables @code{SHELL} and @code{MAKEFLAGS} are always exported (unless you unexport them). @code{MAKEFILES} is exported if you set it to anything. Variables are @emph{not} normally passed down if they were created by default by @code{make} (@pxref{Implicit Variables, ,Variables Used by Implicit Rules}). The sub-@code{make} will define these for itself.@refill @findex export If you want to export specific variables to a sub-@code{make}, use the @code{export} directive, like this: @example export @var{variable} @dots{} @end example @noindent @findex unexport If you want to @emph{prevent} a variable from being exported, use the @code{unexport} directive, like this: @example unexport @var{variable} @dots{} @end example @noindent As a convenience, you can define a variable and export it at the same time by doing: @example export @var{variable} = value @end example @noindent has the same result as: @example @var{variable} = value export @var{variable} @end example @noindent and @example export @var{variable} := value @end example @noindent has the same result as: @example @var{variable} := value export @var{variable} @end example Likewise, @example export @var{variable} += value @end example @noindent is just like: @example @var{variable} += value export @var{variable} @end example @noindent @xref{Appending, ,Appending More Text to Variables}. You may notice that the @code{export} and @code{unexport} directives work in @code{make} in the same way they work in the shell, @code{sh}. If you want all variables to be exported by default, you can use @code{export} by itself: @example export @end example @noindent This tells @code{make} that variables which are not explicitly mentioned in an @code{export} or @code{unexport} directive should be exported. Any variable given in an @code{unexport} directive will still @emph{not} be exported. If you use @code{export} by itself to export variables by default, variables whose names contain characters other than alphanumerics and underscores will not be exported unless specifically mentioned in an @code{export} directive.@refill @findex .EXPORT_ALL_VARIABLES The behavior elicited by an @code{export} directive by itself was the default in older versions of GNU @code{make}. If your makefiles depend on this behavior and you want to be compatible with old versions of @code{make}, you can write a rule for the special target @code{.EXPORT_ALL_VARIABLES} instead of using the @code{export} directive. This will be ignored by old @code{make}s, while the @code{export} directive will cause a syntax error.@refill @cindex compatibility in exporting Likewise, you can use @code{unexport} by itself to tell @code{make} @emph{not} to export variables by default. Since this is the default behavior, you would only need to do this if @code{export} had been used by itself earlier (in an included makefile, perhaps). You @strong{cannot} use @code{export} and @code{unexport} by themselves to have variables exported for some commands and not for others. The last @code{export} or @code{unexport} directive that appears by itself determines the behavior for the entire run of @code{make}.@refill @vindex MAKELEVEL @cindex recursion, level of As a special feature, the variable @code{MAKELEVEL} is changed when it is passed down from level to level. This variable's value is a string which is the depth of the level as a decimal number. The value is @samp{0} for the top-level @code{make}; @samp{1} for a sub-@code{make}, @samp{2} for a sub-sub-@code{make}, and so on. The incrementation happens when @code{make} sets up the environment for a command.@refill The main use of @code{MAKELEVEL} is to test it in a conditional directive (@pxref{Conditionals, ,Conditional Parts of Makefiles}); this way you can write a makefile that behaves one way if run recursively and another way if run directly by you.@refill @vindex MAKEFILES You can use the variable @code{MAKEFILES} to cause all sub-@code{make} commands to use additional makefiles. The value of @code{MAKEFILES} is a whitespace-separated list of file names. This variable, if defined in the outer-level makefile, is passed down through the environment; then it serves as a list of extra makefiles for the sub-@code{make} to read before the usual or specified ones. @xref{MAKEFILES Variable, ,The Variable @code{MAKEFILES}}.@refill @node Options/Recursion, -w Option, Variables/Recursion, Recursion @subsection Communicating Options to a Sub-@code{make} @cindex options, and recursion @cindex recursion, and options @vindex MAKEFLAGS Flags such as @samp{-s} and @samp{-k} are passed automatically to the sub-@code{make} through the variable @code{MAKEFLAGS}. This variable is set up automatically by @code{make} to contain the flag letters that @code{make} received. Thus, if you do @w{@samp{make -ks}} then @code{MAKEFLAGS} gets the value @samp{ks}.@refill As a consequence, every sub-@code{make} gets a value for @code{MAKEFLAGS} in its environment. In response, it takes the flags from that value and processes them as if they had been given as arguments. @xref{Options Summary, ,Summary of Options}. @cindex @code{-C}, and recursion @cindex @code{-f}, and recursion @cindex @code{-I}, and recursion @cindex @code{-o}, and recursion @cindex @code{-W}, and recursion @cindex @code{--directory}, and recursion @cindex @code{--file}, and recursion @cindex @code{--include-dir}, and recursion @cindex @code{--old-file}, and recursion @cindex @code{--assume-old}, and recursion @cindex @code{--assume-new}, and recursion @cindex @code{--new-file}, and recursion @cindex recursion, and @code{-C} @cindex recursion, and @code{-f} @cindex recursion, and @code{-I} @cindex recursion, and @code{-o} @cindex recursion, and @code{-W} The options @samp{-C}, @samp{-f}, @samp{-I}, @samp{-o}, and @samp{-W} are not put into @code{MAKEFLAGS}; these options are not passed down.@refill @cindex @code{-j}, and recursion @cindex @code{--jobs}, and recursion @cindex recursion, and @code{-j} @cindex job slots, and recursion The @samp{-j} option is a special case (@pxref{Parallel, ,Parallel Execution}). If you set it to some numeric value, @samp{-j 1} is always put into @code{MAKEFLAGS} instead of the value you specified. This is because if the @w{@samp{-j}} option were passed down to sub-@code{make}s, you would get many more jobs running in parallel than you asked for. If you give @samp{-j} with no numeric argument, meaning to run as many jobs as possible in parallel, this is passed down, since multiple infinities are no more than one.@refill If you do not want to pass the other flags down, you must change the value of @code{MAKEFLAGS}, like this: @example MAKEFLAGS= subsystem: cd subdir; $(MAKE) @end example or like this: @example subsystem: cd subdir; $(MAKE) MAKEFLAGS= @end example @vindex MFLAGS A similar variable @code{MFLAGS} exists also, for historical compatibility. It has the same value as @code{MAKEFLAGS} except that it always begins with a hyphen unless it is empty (@code{MAKEFLAGS} begins with a hyphen only when it begins with an option that has no single-letter version, such as @samp{--warn-undefined-variables}). @code{MFLAGS} was traditionally used explicitly in the recursive @code{make} command, like this: @example subsystem: cd subdir; $(MAKE) $(MFLAGS) @end example @noindent but now @code{MAKEFLAGS} makes this usage redundant. @cindex setting options from environment @cindex options, setting from environment @cindex setting options in makefiles @cindex options, setting in makefiles The @code{MAKEFLAGS} and @code{MFLAGS} variables can also be useful if you want to have certain options, such as @samp{-k} (@pxref{Options Summary, ,Summary of Options}), set each time you run @code{make}. You simply put a value for @code{MAKEFLAGS} or @code{MFLAGS} in your environment. These variables may also be set in makefiles, so a makefile can specify additional flags that should also be in effect for that makefile. When @code{make} interprets the value of @code{MAKEFLAGS} or @code{MFLAGS} (either from the environment or from a makefile), it first prepends a hyphen if the value does not already begin with one. Then it chops the value into words separated by blanks, and parses these words as if they were options given on the command line (except that @samp{-C}, @samp{-f}, @samp{-h}, @samp{-o}, @samp{-W}, and their long-named versions are ignored; and there is no error for an invalid option). If you do put @code{MAKEFLAGS} or @code{MFLAGS} in your environment, you should be sure not to include any options that will drastically affect the actions of @code{make} and undermine the purpose of makefiles and of @code{make} itself. For instance, the @samp{-t}, @samp{-n}, and @samp{-q} options, if put in one of these variables, could have disastrous consequences and would certainly have at least surprising and probably annoying effects.@refill @node -w Option, , Options/Recursion, Recursion @subsection The @samp{--print-directory} Option @cindex directories, printing them @cindex printing directories @cindex recursion, and printing directories If you use several levels of recursive @code{make} invocations, the @samp{-w} or @w{@samp{--print-directory}} option can make the output a lot easier to understand by showing each directory as @code{make} starts processing it and as @code{make} finishes processing it. For example, if @samp{make -w} is run in the directory @file{/u/gnu/make}, @code{make} will print a line of the form:@refill @example make: Entering directory `/u/gnu/make'. @end example @noindent before doing anything else, and a line of the form: @example make: Leaving directory `/u/gnu/make'. @end example @noindent when processing is completed. @cindex @code{-C}, and @code{-w} @cindex @code{--directory}, and @code{--print-directory} @cindex recursion, and @code{-w} @cindex @code{-w}, and @code{-C} @cindex @code{-w}, and recursion @cindex @code{--print-directory}, and @code{--directory} @cindex @code{--print-directory}, and recursion @cindex @code{--no-print-directory} @cindex @code{--print-directory}, disabling @cindex @code{-w}, disabling Normally, you do not need to specify this option because @samp{make} does it for you: @samp{-w} is turned on automatically when you use the @samp{-C} option, and in sub-@code{make}s. @code{make} will not automatically turn on @samp{-w} if you also use @samp{-s}, which says to be silent, or if you use @samp{--no-print-directory} to explicitly disable it. @node Sequences, Empty Commands, Recursion, Commands @section Defining Canned Command Sequences @cindex sequences of commands @cindex commands, sequences of When the same sequence of commands is useful in making various targets, you can define it as a canned sequence with the @code{define} directive, and refer to the canned sequence from the rules for those targets. The canned sequence is actually a variable, so the name must not conflict with other variable names. Here is an example of defining a canned sequence of commands: @example define run-yacc yacc $(firstword $^) mv y.tab.c $@@ endef @end example @cindex @code{yacc} @noindent Here @code{run-yacc} is the name of the variable being defined; @code{endef} marks the end of the definition; the lines in between are the commands. The @code{define} directive does not expand variable references and function calls in the canned sequence; the @samp{$} characters, parentheses, variable names, and so on, all become part of the value of the variable you are defining. @xref{Defining, ,Defining Variables Verbatim}, for a complete explanation of @code{define}. The first command in this example runs Yacc on the first dependency of whichever rule uses the canned sequence. The output file from Yacc is always named @file{y.tab.c}. The second command moves the output to the rule's target file name. To use the canned sequence, substitute the variable into the commands of a rule. You can substitute it like any other variable (@pxref{Reference, ,Basics of Variable References}). Because variables defined by @code{define} are recursively expanded variables, all the variable references you wrote inside the @code{define} are expanded now. For example: @example foo.c : foo.y $(run-yacc) @end example @noindent @samp{foo.y} will be substituted for the variable @samp{$^} when it occurs in @code{run-yacc}'s value, and @samp{foo.c} for @samp{$@@}.@refill This is a realistic example, but this particular one is not needed in practice because @code{make} has an implicit rule to figure out these commands based on the file names involved (@pxref{Implicit Rules, ,Using Implicit Rules}). @cindex @@, and @code{define} @cindex -, and @code{define} @cindex +, and @code{define} In command execution, each line of a canned sequence is treated just as if the line appeared on its own in the rule, preceded by a tab. In particular, @code{make} invokes a separate subshell for each line. You can use the special prefix characters that affect command lines (@samp{@@}, @samp{-}, and @samp{+}) on each line of a canned sequence. @xref{Commands, ,Writing the Commands in Rules}. For example, using this canned sequence: @example define frobnicate @@echo "frobnicating target $@@" frob-step-1 $< -o $@@-step-1 frob-step-2 $@@-step-1 -o $@@ endef @end example @noindent @code{make} will not echo the first line, the @code{echo} command. But it @emph{will} echo the following two command lines. On the other hand, prefix characters on the command line that refers to a canned sequence apply to every line in the sequence. So the rule: @example frob.out: frob.in @@$(frobnicate) @end example @noindent does not echo @emph{any} commands. (@xref{Echoing, ,Command Echoing}, for a full explanation of @samp{@@}.) @node Empty Commands, , Sequences, Commands @section Using Empty Commands @cindex empty commands @cindex commands, empty It is sometimes useful to define commands which do nothing. This is done simply by giving a command that consists of nothing but whitespace. For example: @example target: ; @end example @noindent defines an empty command string for @file{target}. You could also use a line beginning with a tab character to define an empty command string, but this would be confusing because such a line looks empty. @findex .DEFAULT@r{, and empty commands} You may be wondering why you would want to define a command string that does nothing. The only reason this is useful is to prevent a target from getting implicit commands (from implicit rules or the @code{.DEFAULT} special target; @pxref{Implicit Rules} and @pxref{Last Resort, ,Defining Last-Resort Default Rules}).@refill You may be inclined to define empty command strings for targets that are not actual files, but only exist so that their dependencies can be remade. However, this is not the best way to do that, because the dependencies may not be remade properly if the target file actually does exist. @xref{Phony Targets, ,Phony Targets}, for a better way to do this. @node Using Variables, Conditionals, Commands, Top @chapter How to Use Variables @cindex variable @cindex value @cindex recursive variable expansion @cindex simple variable expansion A @dfn{variable} is a name defined in a makefile to represent a string of text, called the variable's @dfn{value}. These values are substituted by explicit request into targets, dependencies, commands, and other parts of the makefile. (In some other versions of @code{make}, variables are called @dfn{macros}.) @cindex macro Variables and functions in all parts of a makefile are expanded when read, except for the shell commands in rules, the right-hand sides of variable definitions using @samp{=}, and the bodies of variable definitions using the @code{define} directive.@refill Variables can represent lists of file names, options to pass to compilers, programs to run, directories to look in for source files, directories to write output in, or anything else you can imagine. A variable name may be any sequence of characters not containing @samp{:}, @samp{#}, @samp{=}, or leading or trailing whitespace. However, variable names containing characters other than letters, numbers, and underscores should be avoided, as they may be given special meanings in the future, and with some shells they cannot be passed through the environment to a sub-@code{make} (@pxref{Variables/Recursion, ,Communicating Variables to a Sub-@code{make}}). Variable names are case-sensitive. The names @samp{foo}, @samp{FOO}, and @samp{Foo} all refer to different variables. It is traditional to use upper case letters in variable names, but we recommend using lower case letters for variable names that serve internal purposes in the makefile, and reserving upper case for parameters that control implicit rules or for parameters that the user should override with command options (@pxref{Overriding, ,Overriding Variables}). @menu * Reference:: How to use the value of a variable. * Flavors:: Variables come in two flavors. * Advanced:: Advanced features for referencing a variable. * Values:: All the ways variables get their values. * Setting:: How to set a variable in the makefile. * Appending:: How to append more text to the old value of a variable. * Override Directive:: How to set a variable in the makefile even if the user has set it with a command argument. * Defining:: An alternate way to set a variable to a verbatim string. * Environment:: Variable values can come from the environment. @end menu @node Reference, Flavors, , Using Variables @section Basics of Variable References @cindex variables, how to reference @cindex reference to variables @cindex @code{$}, in variable reference @cindex dollar sign (@code{$}), in variable reference To substitute a variable's value, write a dollar sign followed by the name of the variable in parentheses or braces: either @samp{$(foo)} or @samp{$@{foo@}} is a valid reference to the variable @code{foo}. This special significance of @samp{$} is why you must write @samp{$$} to have the effect of a single dollar sign in a file name or command. Variable references can be used in any context: targets, dependencies, commands, most directives, and new variable values. Here is an example of a common case, where a variable holds the names of all the object files in a program: @example @group objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects) $(objects) : defs.h @end group @end example Variable references work by strict textual substitution. Thus, the rule @example @group foo = c prog.o : prog.$(foo) $(foo)$(foo) -$(foo) prog.$(foo) @end group @end example @noindent could be used to compile a C program @file{prog.c}. Since spaces before the variable value are ignored in variable assignments, the value of @code{foo} is precisely @samp{c}. (Don't actually write your makefiles this way!) A dollar sign followed by a character other than a dollar sign, open-parenthesis or open-brace treats that single character as the variable name. Thus, you could reference the variable @code{x} with @samp{$x}. However, this practice is strongly discouraged, except in the case of the automatic variables (@pxref{Automatic, ,Automatic Variables}). @node Flavors, Advanced, Reference, Using Variables @section The Two Flavors of Variables @cindex flavors of variables @cindex recursive variable expansion @cindex variables, flavors @cindex recursively expanded variables @cindex variables, recursively expanded There are two ways that a variable in GNU @code{make} can have a value; we call them the two @dfn{flavors} of variables. The two flavors are distinguished in how they are defined and in what they do when expanded. @cindex = The first flavor of variable is a @dfn{recursively expanded} variable. Variables of this sort are defined by lines using @samp{=} (@pxref{Setting, ,Setting Variables}) or by the @code{define} directive (@pxref{Defining, ,Defining Variables Verbatim}). The value you specify is installed verbatim; if it contains references to other variables, these references are expanded whenever this variable is substituted (in the course of expanding some other string). When this happens, it is called @dfn{recursive expansion}.@refill For example, @example foo = $(bar) bar = $(ugh) ugh = Huh? all:;echo $(foo) @end example @noindent will echo @samp{Huh?}: @samp{$(foo)} expands to @samp{$(bar)} which expands to @samp{$(ugh)} which finally expands to @samp{Huh?}.@refill This flavor of variable is the only sort supported by other versions of @code{make}. It has its advantages and its disadvantages. An advantage (most would say) is that: @example CFLAGS = $(include_dirs) -O include_dirs = -Ifoo -Ibar @end example @noindent will do what was intended: when @samp{CFLAGS} is expanded in a command, it will expand to @samp{-Ifoo -Ibar -O}. A major disadvantage is that you cannot append something on the end of a variable, as in @example CFLAGS = $(CFLAGS) -O @end example @noindent because it will cause an infinite loop in the variable expansion. (Actually @code{make} detects the infinite loop and reports an error.) @cindex loops in variable expansion @cindex variables, loops in expansion Another disadvantage is that any functions (@pxref{Functions, ,Functions for Transforming Text}) referenced in the definition will be executed every time the variable is expanded. This makes @code{make} run slower; worse, it causes the @code{wildcard} and @code{shell} functions to give unpredictable results because you cannot easily control when they are called, or even how many times. To avoid all the problems and inconveniences of recursively expanded variables, there is another flavor: simply expanded variables. @cindex simply expanded variables @cindex variables, simply expanded @cindex := @dfn{Simply expanded variables} are defined by lines using @samp{:=} (@pxref{Setting, ,Setting Variables}). The value of a simply expanded variable is scanned once and for all, expanding any references to other variables and functions, when the variable is defined. The actual value of the simply expanded variable is the result of expanding the text that you write. It does not contain any references to other variables; it contains their values @emph{as of the time this variable was defined}. Therefore, @example x := foo y := $(x) bar x := later @end example @noindent is equivalent to @example y := foo bar x := later @end example When a simply expanded variable is referenced, its value is substituted verbatim. Here is a somewhat more complicated example, illustrating the use of @samp{:=} in conjunction with the @code{shell} function. (@xref{Shell Function, , The @code{shell} Function}.) This example also shows use of the variable @code{MAKELEVEL}, which is changed when it is passed down from level to level. (@xref{Variables/Recursion, , Communicating Variables to a Sub-@code{make}}, for information about @code{MAKELEVEL}.) @vindex MAKELEVEL @vindex MAKE @example @group ifeq (0,$@{MAKELEVEL@}) cur-dir := $(shell pwd) whoami := $(shell whoami) host-type := $(shell arch) MAKE := $@{MAKE@} host-type=$@{host-type@} whoami=$@{whoami@} endif @end group @end example @noindent An advantage of this use of @samp{:=} is that a typical `descend into a directory' command then looks like this: @example @group $@{subdirs@}: $@{MAKE@} cur-dir=$@{cur-dir@}/$@@ -C $@@ all @end group @end example Simply expanded variables generally make complicated makefile programming more predictable because they work like variables in most programming languages. They allow you to redefine a variable using its own value (or its value processed in some way by one of the expansion functions) and to use the expansion functions much more efficiently (@pxref{Functions, ,Functions for Transforming Text}). @cindex spaces, in variable values @cindex whitespace, in variable values @cindex variables, spaces in values You can also use them to introduce controlled leading whitespace into variable values. Leading whitespace characters are discarded from your input before substitution of variable references and function calls; this means you can include leading spaces in a variable value by protecting them with variable references, like this: @example nullstring := space := $(nullstring) # end of the line @end example @noindent Here the value of the variable @code{space} is precisely one space. The comment @w{@samp{# end of the line}} is included here just for clarity. Since trailing space characters are @emph{not} stripped from variable values, just a space at the end of the line would have the same effect (but be rather hard to read). If you put whitespace at the end of a variable value, it is a good idea to put a comment like that at the end of the line to make your intent clear. Conversely, if you do @emph{not} want any whitespace characters at the end of your variable value, you must remember not to put a random comment on the end of the line after some whitespace, such as this: @example dir := /foo/bar # directory to put the frobs in @end example @noindent Here the value of the variable @code{dir} is @w{@samp{/foo/bar }} (with four trailing spaces), which was probably not the intention. (Imagine something like @w{@samp{$(dir)/file}} with this definition!) @node Advanced, Values, Flavors, Using Variables @section Advanced Features for Reference to Variables @cindex reference to variables This section describes some advanced features you can use to reference variables in more flexible ways. @menu * Substitution Refs:: Referencing a variable with substitutions on the value. * Computed Names:: Computing the name of the variable to refer to. @end menu @node Substitution Refs, Computed Names, , Advanced @subsection Substitution References @cindex modified variable reference @cindex substitution variable reference @cindex variables, modified reference @cindex variables, substitution reference @cindex variables, substituting suffix in @cindex suffix, substituting in variables A @dfn{substitution reference} substitutes the value of a variable with alterations that you specify. It has the form @samp{$(@var{var}:@var{a}=@var{b})} (or @samp{$@{@var{var}:@var{a}=@var{b}@}}) and its meaning is to take the value of the variable @var{var}, replace every @var{a} at the end of a word with @var{b} in that value, and substitute the resulting string. When we say ``at the end of a word'', we mean that @var{a} must appear either followed by whitespace or at the end of the value in order to be replaced; other occurrences of @var{a} in the value are unaltered. For example:@refill @example foo := a.o b.o c.o bar := $(foo:.o=.c) @end example @noindent sets @samp{bar} to @samp{a.c b.c c.c}. @xref{Setting, ,Setting Variables}. A substitution reference is actually an abbreviation for use of the @code{patsubst} expansion function (@pxref{Text Functions, ,Functions for String Substitution and Analysis}). We provide substitution references as well as @code{patsubst} for compatibility with other implementations of @code{make}. @findex patsubst Another type of substitution reference lets you use the full power of the @code{patsubst} function. It has the same form @samp{$(@var{var}:@var{a}=@var{b})} described above, except that now @var{a} must contain a single @samp{%} character. This case is equivalent to @samp{$(patsubst @var{a},@var{b},$(@var{var}))}. @xref{Text Functions, ,Functions for String Substitution and Analysis}, for a description of the @code{patsubst} function.@refill @example @group @exdent For example: foo := a.o b.o c.o bar := $(foo:%.o=%.c) @end group @end example @noindent sets @samp{bar} to @samp{a.c b.c c.c}. @node Computed Names, , Substitution Refs, Advanced @subsection Computed Variable Names @cindex nested variable reference @cindex computed variable name @cindex variables, computed names @cindex variables, nested references @cindex variables, @samp{$} in name @cindex @code{$}, in variable name @cindex dollar sign (@code{$}), in variable name Computed variable names are a complicated concept needed only for sophisticated makefile programming. For most purposes you need not consider them, except to know that making a variable with a dollar sign in its name might have strange results. However, if you are the type that wants to understand everything, or you are actually interested in what they do, read on. Variables may be referenced inside the name of a variable. This is called a @dfn{computed variable name} or a @dfn{nested variable reference}. For example, @example x = y y = z a := $($(x)) @end example @noindent defines @code{a} as @samp{z}: the @samp{$(x)} inside @samp{$($(x))} expands to @samp{y}, so @samp{$($(x))} expands to @samp{$(y)} which in turn expands to @samp{z}. Here the name of the variable to reference is not stated explicitly; it is computed by expansion of @samp{$(x)}. The reference @samp{$(x)} here is nested within the outer variable reference. The previous example shows two levels of nesting, but any number of levels is possible. For example, here are three levels: @example x = y y = z z = u a := $($($(x))) @end example @noindent Here the innermost @samp{$(x)} expands to @samp{y}, so @samp{$($(x))} expands to @samp{$(y)} which in turn expands to @samp{z}; now we have @samp{$(z)}, which becomes @samp{u}. References to recursively-expanded variables within a variable name are reexpanded in the usual fashion. For example: @example x = $(y) y = z z = Hello a := $($(x)) @end example @noindent defines @code{a} as @samp{Hello}: @samp{$($(x))} becomes @samp{$($(y))} which becomes @samp{$(z)} which becomes @samp{Hello}. Nested variable references can also contain modified references and function invocations (@pxref{Functions, ,Functions for Transforming Text}), just like any other reference. For example, using the @code{subst} function (@pxref{Text Functions, ,Functions for String Substitution and Analysis}): @example @group x = variable1 variable2 := Hello y = $(subst 1,2,$(x)) z = y a := $($($(z))) @end group @end example @noindent eventually defines @code{a} as @samp{Hello}. It is doubtful that anyone would ever want to write a nested reference as convoluted as this one, but it works: @samp{$($($(z)))} expands to @samp{$($(y))} which becomes @samp{$($(subst 1,2,$(x)))}. This gets the value @samp{variable1} from @code{x} and changes it by substitution to @samp{variable2}, so that the entire string becomes @samp{$(variable2)}, a simple variable reference whose value is @samp{Hello}.@refill A computed variable name need not consist entirely of a single variable reference. It can contain several variable references, as well as some invariant text. For example, @example @group a_dirs := dira dirb 1_dirs := dir1 dir2 @end group @group a_files := filea fileb 1_files := file1 file2 @end group @group ifeq "$(use_a)" "yes" a1 := a else a1 := 1 endif @end group @group ifeq "$(use_dirs)" "yes" df := dirs else df := files endif dirs := $($(a1)_$(df)) @end group @end example @noindent will give @code{dirs} the same value as @code{a_dirs}, @code{1_dirs}, @code{a_files} or @code{1_files} depending on the settings of @code{use_a} and @code{use_dirs}.@refill Computed variable names can also be used in substitution references: @example @group a_objects := a.o b.o c.o 1_objects := 1.o 2.o 3.o sources := $($(a1)_objects:.o=.c) @end group @end example @noindent defines @code{sources} as either @samp{a.c b.c c.c} or @samp{1.c 2.c 3.c}, depending on the value of @code{a1}. The only restriction on this sort of use of nested variable references is that they cannot specify part of the name of a function to be called. This is because the test for a recognized function name is done before the expansion of nested references. For example, @example @group ifdef do_sort func := sort else func := strip endif @end group @group bar := a d b g q c @end group @group foo := $($(func) $(bar)) @end group @end example @noindent attempts to give @samp{foo} the value of the variable @samp{sort a d b g q c} or @samp{strip a d b g q c}, rather than giving @samp{a d b g q c} as the argument to either the @code{sort} or the @code{strip} function. This restriction could be removed in the future if that change is shown to be a good idea. You can also use computed variable names in the left-hand side of a variable assignment, or in a @code{define} directive, as in: @example dir = foo $(dir)_sources := $(wildcard $(dir)/*.c) define $(dir)_print lpr $($(dir)_sources) endef @end example @noindent This example defines the variables @samp{dir}, @samp{foo_sources}, and @samp{foo_print}. Note that @dfn{nested variable references} are quite different from @dfn{recursively expanded variables} (@pxref{Flavors, ,The Two Flavors of Variables}), though both are used together in complex ways when doing makefile programming.@refill @node Values, Setting, Advanced, Using Variables @section How Variables Get Their Values @cindex variables, how they get their values @cindex value, how a variable gets it Variables can get values in several different ways: @itemize @bullet @item You can specify an overriding value when you run @code{make}. @xref{Overriding, ,Overriding Variables}. @item You can specify a value in the makefile, either with an assignment (@pxref{Setting, ,Setting Variables}) or with a verbatim definition (@pxref{Defining, ,Defining Variables Verbatim}).@refill @item Variables in the environment become @code{make} variables. @xref{Environment, ,Variables from the Environment}. @item Several @dfn{automatic} variables are given new values for each rule. Each of these has a single conventional use. @xref{Automatic, ,Automatic Variables}. @item Several variables have constant initial values. @xref{Implicit Variables, ,Variables Used by Implicit Rules}. @end itemize @node Setting, Appending, Values, Using Variables @section Setting Variables @cindex setting variables @cindex variables, setting @cindex = @cindex := To set a variable from the makefile, write a line starting with the variable name followed by @samp{=} or @samp{:=}. Whatever follows the @samp{=} or @samp{:=} on the line becomes the value. For example, @example objects = main.o foo.o bar.o utils.o @end example @noindent defines a variable named @code{objects}. Whitespace around the variable name and immediately after the @samp{=} is ignored. Variables defined with @samp{=} are @dfn{recursively expanded} variables. Variables defined with @samp{:=} are @dfn{simply expanded} variables; these definitions can contain variable references which will be expanded before the definition is made. @xref{Flavors, ,The Two Flavors of Variables}. The variable name may contain function and variable references, which are expanded when the line is read to find the actual variable name to use. There is no limit on the length of the value of a variable except the amount of swapping space on the computer. When a variable definition is long, it is a good idea to break it into several lines by inserting backslash-newline at convenient places in the definition. This will not affect the functioning of @code{make}, but it will make the makefile easier to read. Most variable names are considered to have the empty string as a value if you have never set them. Several variables have built-in initial values that are not empty, but you can set them in the usual ways (@pxref{Implicit Variables, ,Variables Used by Implicit Rules}). Several special variables are set automatically to a new value for each rule; these are called the @dfn{automatic} variables (@pxref{Automatic, ,Automatic Variables}). @node Appending, Override Directive, Setting, Using Variables @section Appending More Text to Variables @cindex += @cindex appending to variables @cindex variables, appending to Often it is useful to add more text to the value of a variable already defined. You do this with a line containing @samp{+=}, like this: @example objects += another.o @end example @noindent This takes the value of the variable @code{objects}, and adds the text @samp{another.o} to it (preceded by a single space). Thus: @example objects = main.o foo.o bar.o utils.o objects += another.o @end example @noindent sets @code{objects} to @samp{main.o foo.o bar.o utils.o another.o}. Using @samp{+=} is similar to: @example objects = main.o foo.o bar.o utils.o objects := $(objects) another.o @end example @noindent but differs in ways that become important when you use more complex values. When the variable in question has not been defined before, @samp{+=} acts just like normal @samp{=}: it defines a recursively-expanded variable. However, when there @emph{is} a previous definition, exactly what @samp{+=} does depends on what flavor of variable you defined originally. @xref{Flavors, ,The Two Flavors of Variables}, for an explanation of the two flavors of variables. When you add to a variable's value with @samp{+=}, @code{make} acts essentially as if you had included the extra text in the initial definition of the variable. If you defined it first with @samp{:=}, making it a simply-expanded variable, @samp{+=} adds to that simply-expanded definition, and expands the new text before appending it to the old value just as @samp{:=} does (@pxref{Setting, ,Setting Variables}, for a full explanation of @samp{:=}). In fact, @example variable := value variable += more @end example @noindent is exactly equivalent to: @noindent @example variable := value variable := $(variable) more @end example On the other hand, when you use @samp{+=} with a variable that you defined first to be recursively-expanded using plain @samp{=}, @code{make} does something a bit different. Recall that when you define a recursively-expanded variable, @code{make} does not expand the value you set for variable and function references immediately. Instead it stores the text verbatim, and saves these variable and function references to be expanded later, when you refer to the new variable (@pxref{Flavors, ,The Two Flavors of Variables}). When you use @samp{+=} on a recursively-expanded variable, it is this unexpanded text to which @code{make} appends the new text you specify. @example @group variable = value variable += more @end group @end example @noindent is roughly equivalent to: @example @group temp = value variable = $(temp) more @end group @end example @noindent except that of course it never defines a variable called @code{temp}. The importance of this comes when the variable's old value contains variable references. Take this common example: @example CFLAGS = $(includes) -O @dots{} CFLAGS += -pg # enable profiling @end example @noindent The first line defines the @code{CFLAGS} variable with a reference to another variable, @code{includes}. (@code{CFLAGS} is used by the rules for C compilation; @pxref{Catalogue of Rules, ,Catalogue of Implicit Rules}.) Using @samp{=} for the definition makes @code{CFLAGS} a recursively-expanded variable, meaning @w{@samp{$(includes) -O}} is @emph{not} expanded when @code{make} processes the definition of @code{CFLAGS}. Thus, @code{includes} need not be defined yet for its value to take effect. It only has to be defined before any reference to @code{CFLAGS}. If we tried to append to the value of @code{CFLAGS} without using @samp{+=}, we might do it like this: @example CFLAGS := $(CFLAGS) -pg # enable profiling @end example @noindent This is pretty close, but not quite what we want. Using @samp{:=} redefines @code{CFLAGS} as a simply-expanded variable; this means @code{make} expands the text @w{@samp{$(CFLAGS) -pg}} before setting the variable. If @code{includes} is not yet defined, we get @w{@samp{ -O -pg}}, and a later definition of @code{includes} will have no effect. Conversely, by using @samp{+=} we set @code{CFLAGS} to the @emph{unexpanded} value @w{@samp{$(includes) -O -pg}}. Thus we preserve the reference to @code{includes}, so if that variable gets defined at any later point, a reference like @samp{$(CFLAGS)} still uses its value. @node Override Directive, Defining, Appending, Using Variables @section The @code{override} Directive @findex override @cindex overriding with @code{override} @cindex variables, overriding If a variable has been set with a command argument (@pxref{Overriding, ,Overriding Variables}), then ordinary assignments in the makefile are ignored. If you want to set the variable in the makefile even though it was set with a command argument, you can use an @code{override} directive, which is a line that looks like this:@refill @example override @var{variable} = @var{value} @end example @noindent or @example override @var{variable} := @var{value} @end example To append more text to a variable defined on the command line, use: @example override @var{variable} += @var{more text} @end example @noindent @xref{Appending, ,Appending More Text to Variables}. The @code{override} directive was not invented for escalation in the war between makefiles and command arguments. It was invented so you can alter and add to values that the user specifies with command arguments. For example, suppose you always want the @samp{-g} switch when you run the C compiler, but you would like to allow the user to specify the other switches with a command argument just as usual. You could use this @code{override} directive: @example override CFLAGS += -g @end example You can also use @code{override} directives with @code{define} directives. This is done as you might expect: @example override define foo bar endef @end example @noindent @iftex See the next section for information about @code{define}. @end iftex @ifinfo @xref{Defining, ,Defining Variables Verbatim}. @end ifinfo @node Defining, Environment, Override Directive, Using Variables @section Defining Variables Verbatim @findex define @findex endef @cindex verbatim variable definition @cindex defining variables verbatim @cindex variables, defining verbatim Another way to set the value of a variable is to use the @code{define} directive. This directive has an unusual syntax which allows newline characters to be included in the value, which is convenient for defining canned sequences of commands (@pxref{Sequences, ,Defining Canned Command Sequences}). The @code{define} directive is followed on the same line by the name of the variable and nothing more. The value to give the variable appears on the following lines. The end of the value is marked by a line containing just the word @code{endef}. Aside from this difference in syntax, @code{define} works just like @samp{=}: it creates a recursively-expanded variable (@pxref{Flavors, ,The Two Flavors of Variables}). The variable name may contain function and variable references, which are expanded when the directive is read to find the actual variable name to use. @example define two-lines echo foo echo $(bar) endef @end example The value in an ordinary assignment cannot contain a newline; but the newlines that separate the lines of the value in a @code{define} become part of the variable's value (except for the final newline which precedes the @code{endef} and is not considered part of the value).@refill @need 800 The previous example is functionally equivalent to this: @example two-lines = echo foo; echo $(bar) @end example @noindent since two commands separated by semicolon behave much like two separate shell commands. However, note that using two separate lines means @code{make} will invoke the shell twice, running an independent subshell for each line. @xref{Execution, ,Command Execution}. If you want variable definitions made with @code{define} to take precedence over command-line variable definitions, you can use the @code{override} directive together with @code{define}: @example override define two-lines foo $(bar) endef @end example @noindent @xref{Override Directive, ,The @code{override} Directive}. @node Environment, , Defining, Using Variables @section Variables from the Environment @cindex variables, environment @cindex environment Variables in @code{make} can come from the environment in which @code{make} is run. Every environment variable that @code{make} sees when it starts up is transformed into a @code{make} variable with the same name and value. But an explicit assignment in the makefile, or with a command argument, overrides the environment. (If the @samp{-e} flag is specified, then values from the environment override assignments in the makefile. @xref{Options Summary, ,Summary of Options}. But this is not recommended practice.) Thus, by setting the variable @code{CFLAGS} in your environment, you can cause all C compilations in most makefiles to use the compiler switches you prefer. This is safe for variables with standard or conventional meanings because you know that no makefile will use them for other things. (But this is not totally reliable; some makefiles set @code{CFLAGS} explicitly and therefore are not affected by the value in the environment.) When @code{make} is invoked recursively, variables defined in the outer invocation can be passed to inner invocations through the environment (@pxref{Recursion, ,Recursive Use of @code{make}}). By default, only variables that came from the environment or the command line are passed to recursive invocations. You can use the @code{export} directive to pass other variables. @xref{Variables/Recursion, , Communicating Variables to a Sub-@code{make}}, for full details. Other use of variables from the environment is not recommended. It is not wise for makefiles to depend for their functioning on environment variables set up outside their control, since this would cause different users to get different results from the same makefile. This is against the whole purpose of most makefiles. Such problems would be especially likely with the variable @code{SHELL}, which is normally present in the environment to specify the user's choice of interactive shell. It would be very undesirable for this choice to affect @code{make}. So @code{make} ignores the environment value of @code{SHELL}.@refill @node Conditionals, Functions, Using Variables, Top @chapter Conditional Parts of Makefiles @cindex conditionals A @dfn{conditional} causes part of a makefile to be obeyed or ignored depending on the values of variables. Conditionals can compare the value of one variable to another, or the value of a variable to a constant string. Conditionals control what @code{make} actually ``sees'' in the makefile, so they @emph{cannot} be used to control shell commands at the time of execution.@refill @menu * Conditional Example:: Example of a conditional * Conditional Syntax:: The syntax of conditionals. * Testing Flags:: Conditionals that test flags. @end menu @node Conditional Example, Conditional Syntax, , Conditionals @section Example of a Conditional The following example of a conditional tells @code{make} to use one set of libraries if the @code{CC} variable is @samp{gcc}, and a different set of libraries otherwise. It works by controlling which of two command lines will be used as the command for a rule. The result is that @samp{CC=gcc} as an argument to @code{make} changes not only which compiler is used but also which libraries are linked. @example libs_for_gcc = -lgnu normal_libs = foo: $(objects) ifeq ($(CC),gcc) $(CC) -o foo $(objects) $(libs_for_gcc) else $(CC) -o foo $(objects) $(normal_libs) endif @end example This conditional uses three directives: one @code{ifeq}, one @code{else} and one @code{endif}. The @code{ifeq} directive begins the conditional, and specifies the condition. It contains two arguments, separated by a comma and surrounded by parentheses. Variable substitution is performed on both arguments and then they are compared. The lines of the makefile following the @code{ifeq} are obeyed if the two arguments match; otherwise they are ignored. The @code{else} directive causes the following lines to be obeyed if the previous conditional failed. In the example above, this means that the second alternative linking command is used whenever the first alternative is not used. It is optional to have an @code{else} in a conditional. The @code{endif} directive ends the conditional. Every conditional must end with an @code{endif}. Unconditional makefile text follows. As this example illustrates, conditionals work at the textual level: the lines of the conditional are treated as part of the makefile, or ignored, according to the condition. This is why the larger syntactic units of the makefile, such as rules, may cross the beginning or the end of the conditional. When the variable @code{CC} has the value @samp{gcc}, the above example has this effect: @example foo: $(objects) $(CC) -o foo $(objects) $(libs_for_gcc) @end example @noindent When the variable @code{CC} has any other value, the effect is this: @example foo: $(objects) $(CC) -o foo $(objects) $(normal_libs) @end example Equivalent results can be obtained in another way by conditionalizing a variable assignment and then using the variable unconditionally: @example libs_for_gcc = -lgnu normal_libs = ifeq ($(CC),gcc) libs=$(libs_for_gcc) else libs=$(normal_libs) endif foo: $(objects) $(CC) -o foo $(objects) $(libs) @end example @node Conditional Syntax, Testing Flags, Conditional Example, Conditionals @section Syntax of Conditionals @findex ifdef @findex ifeq @findex ifndef @findex ifneq @findex else @findex endif The syntax of a simple conditional with no @code{else} is as follows: @example @var{conditional-directive} @var{text-if-true} endif @end example @noindent The @var{text-if-true} may be any lines of text, to be considered as part of the makefile if the condition is true. If the condition is false, no text is used instead. The syntax of a complex conditional is as follows: @example @var{conditional-directive} @var{text-if-true} else @var{text-if-false} endif @end example @noindent If the condition is true, @var{text-if-true} is used; otherwise, @var{text-if-false} is used instead. The @var{text-if-false} can be any number of lines of text. The syntax of the @var{conditional-directive} is the same whether the conditional is simple or complex. There are four different directives that test different conditions. Here is a table of them: @table @code @item ifeq (@var{arg1}, @var{arg2}) @itemx ifeq '@var{arg1}' '@var{arg2}' @itemx ifeq "@var{arg1}" "@var{arg2}" @itemx ifeq "@var{arg1}" '@var{arg2}' @itemx ifeq '@var{arg1}' "@var{arg2}" Expand all variable references in @var{arg1} and @var{arg2} and compare them. If they are identical, the @var{text-if-true} is effective; otherwise, the @var{text-if-false}, if any, is effective. Often you want to test if a variable has a non-empty value. When the value results from complex expansions of variables and functions, expansions you would consider empty may actually contain whitespace characters and thus are not seen as empty. However, you can use the @code{strip} function (@pxref{Text Functions}) to avoid interpreting whitespace as a non-empty value. For example: @example @group ifeq ($(strip $(foo)),) @var{text-if-empty} endif @end group @end example @noindent will evaluate @var{text-if-empty} even if the expansion of @code{$(foo)} contains whitespace characters. @item ifneq (@var{arg1}, @var{arg2}) @itemx ifneq '@var{arg1}' '@var{arg2}' @itemx ifneq "@var{arg1}" "@var{arg2}" @itemx ifneq "@var{arg1}" '@var{arg2}' @itemx ifneq '@var{arg1}' "@var{arg2}" Expand all variable references in @var{arg1} and @var{arg2} and compare them. If they are different, the @var{text-if-true} is effective; otherwise, the @var{text-if-false}, if any, is effective. @item ifdef @var{variable-name} If the variable @var{variable-name} has a non-empty value, the @var{text-if-true} is effective; otherwise, the @var{text-if-false}, if any, is effective. Variables that have never been defined have an empty value. Note that @code{ifdef} only tests whether a variable has a value. It does not expand the variable to see if that value is nonempty. Consequently, tests using @code{ifdef} return true for all definitions except those like @code{foo =}. To test for an empty value, use @w{@code{ifeq ($(foo),)}}. For example, @example bar = foo = $(bar) ifdef foo frobozz = yes else frobozz = no endif @end example @noindent sets @samp{frobozz} to @samp{yes}, while: @example foo = ifdef foo frobozz = yes else frobozz = no endif @end example @noindent sets @samp{frobozz} to @samp{no}. @item ifndef @var{variable-name} If the variable @var{variable-name} has an empty value, the @var{text-if-true} is effective; otherwise, the @var{text-if-false}, if any, is effective. @end table Extra spaces are allowed and ignored at the beginning of the conditional directive line, but a tab is not allowed. (If the line begins with a tab, it will be considered a command for a rule.) Aside from this, extra spaces or tabs may be inserted with no effect anywhere except within the directive name or within an argument. A comment starting with @samp{#} may appear at the end of the line. The other two directives that play a part in a conditional are @code{else} and @code{endif}. Each of these directives is written as one word, with no arguments. Extra spaces are allowed and ignored at the beginning of the line, and spaces or tabs at the end. A comment starting with @samp{#} may appear at the end of the line. Conditionals affect which lines of the makefile @code{make} uses. If the condition is true, @code{make} reads the lines of the @var{text-if-true} as part of the makefile; if the condition is false, @code{make} ignores those lines completely. It follows that syntactic units of the makefile, such as rules, may safely be split across the beginning or the end of the conditional.@refill @code{make} evaluates conditionals when it reads a makefile. Consequently, you cannot use automatic variables in the tests of conditionals because they are not defined until commands are run (@pxref{Automatic, , Automatic Variables}). To prevent intolerable confusion, it is not permitted to start a conditional in one makefile and end it in another. However, you may write an @code{include} directive within a conditional, provided you do not attempt to terminate the conditional inside the included file. @node Testing Flags, , Conditional Syntax, Conditionals @section Conditionals that Test Flags You can write a conditional that tests @code{make} command flags such as @samp{-t} by using the variable @code{MAKEFLAGS} together with the @code{findstring} function (@pxref{Text Functions, , Functions for String Substitution and Analysis}). This is useful when @code{touch} is not enough to make a file appear up to date. The @code{findstring} function determines whether one string appears as a substring of another. If you want to test for the @samp{-t} flag, use @samp{t} as the first string and the value of @code{MAKEFLAGS} as the other. For example, here is how to arrange to use @samp{ranlib -t} to finish marking an archive file up to date: @example archive.a: @dots{} ifneq (,$(findstring t,$(MAKEFLAGS))) +touch archive.a +ranlib -t archive.a else ranlib archive.a endif @end example @noindent The @samp{+} prefix marks those command lines as ``recursive'' so that they will be executed despite use of the @samp{-t} flag. @xref{Recursion, ,Recursive Use of @code{make}}. @node Functions, Running, Conditionals, Top @chapter Functions for Transforming Text @cindex functions @dfn{Functions} allow you to do text processing in the makefile to compute the files to operate on or the commands to use. You use a function in a @dfn{function call}, where you give the name of the function and some text (the @dfn{arguments}) for the function to operate on. The result of the function's processing is substituted into the makefile at the point of the call, just as a variable might be substituted. @menu * Syntax of Functions:: How to write a function call. * Text Functions:: General-purpose text manipulation functions. * Filename Functions:: Functions for manipulating file names. * Foreach Function:: Repeat some text with controlled variation. * Origin Function:: Find where a variable got its value. * Shell Function:: Substitute the output of a shell command. @end menu @node Syntax of Functions, Text Functions, , Functions @section Function Call Syntax @cindex @code{$}, in function call @cindex dollar sign (@code{$}), in function call @cindex arguments of functions @cindex functions, syntax of A function call resembles a variable reference. It looks like this: @example $(@var{function} @var{arguments}) @end example @noindent or like this: @example $@{@var{function} @var{arguments}@} @end example Here @var{function} is a function name; one of a short list of names that are part of @code{make}. There is no provision for defining new functions. The @var{arguments} are the arguments of the function. They are separated from the function name by one or more spaces or tabs, and if there is more than one argument, then they are separated by commas. Such whitespace and commas are not part of an argument's value. The delimiters which you use to surround the function call, whether parentheses or braces, can appear in an argument only in matching pairs; the other kind of delimiters may appear singly. If the arguments themselves contain other function calls or variable references, it is wisest to use the same kind of delimiters for all the references; write @w{@samp{$(subst a,b,$(x))}}, not @w{@samp{$(subst a,b,$@{x@})}}. This is because it is clearer, and because only one type of delimiter is matched to find the end of the reference. The text written for each argument is processed by substitution of variables and function calls to produce the argument value, which is the text on which the function acts. The substitution is done in the order in which the arguments appear. Commas and unmatched parentheses or braces cannot appear in the text of an argument as written; leading spaces cannot appear in the text of the first argument as written. These characters can be put into the argument value by variable substitution. First define variables @code{comma} and @code{space} whose values are isolated comma and space characters, then substitute these variables where such characters are wanted, like this: @example @group comma:= , empty:= space:= $(empty) $(empty) foo:= a b c bar:= $(subst $(space),$(comma),$(foo)) # @r{bar is now `a,b,c'.} @end group @end example @noindent Here the @code{subst} function replaces each space with a comma, through the value of @code{foo}, and substitutes the result. @node Text Functions, Filename Functions, Syntax of Functions, Functions @section Functions for String Substitution and Analysis @cindex functions, for text Here are some functions that operate on strings: @table @code @item $(subst @var{from},@var{to},@var{text}) @findex subst Performs a textual replacement on the text @var{text}: each occurrence of @var{from} is replaced by @var{to}. The result is substituted for the function call. For example, @example $(subst ee,EE,feet on the street) @end example substitutes the string @samp{fEEt on the strEEt}. @item $(patsubst @var{pattern},@var{replacement},@var{text}) @findex patsubst Finds whitespace-separated words in @var{text} that match @var{pattern} and replaces them with @var{replacement}. Here @var{pattern} may contain a @samp{%} which acts as a wildcard, matching any number of any characters within a word. If @var{replacement} also contains a @samp{%}, the @samp{%} is replaced by the text that matched the @samp{%} in @var{pattern}.@refill @cindex @code{%}, quoting in @code{patsubst} @cindex @code{%}, quoting with @code{\} (backslash) @cindex @code{\} (backslash), to quote @code{%} @cindex backslash (@code{\}), to quote @code{%} @cindex quoting @code{%}, in @code{patsubst} @samp{%} characters in @code{patsubst} function invocations can be quoted with preceding backslashes (@samp{\}). Backslashes that would otherwise quote @samp{%} characters can be quoted with more backslashes. Backslashes that quote @samp{%} characters or other backslashes are removed from the pattern before it is compared file names or has a stem substituted into it. Backslashes that are not in danger of quoting @samp{%} characters go unmolested. For example, the pattern @file{the\%weird\\%pattern\\} has @samp{the%weird\} preceding the operative @samp{%} character, and @samp{pattern\\} following it. The final two backslashes are left alone because they cannot affect any @samp{%} character.@refill Whitespace between words is folded into single space characters; leading and trailing whitespace is discarded. For example, @example $(patsubst %.c,%.o,x.c.c bar.c) @end example @noindent produces the value @samp{x.c.o bar.o}. Substitution references (@pxref{Substitution Refs, ,Substitution References}) are a simpler way to get the effect of the @code{patsubst} function: @example $(@var{var}:@var{pattern}=@var{replacement}) @end example @noindent is equivalent to @example $(patsubst @var{pattern},@var{replacement},$(@var{var})) @end example The second shorthand simplifies one of the most common uses of @code{patsubst}: replacing the suffix at the end of file names. @example $(@var{var}:@var{suffix}=@var{replacement}) @end example @noindent is equivalent to @example $(patsubst %@var{suffix},%@var{replacement},$(@var{var})) @end example @noindent For example, you might have a list of object files: @example objects = foo.o bar.o baz.o @end example @noindent To get the list of corresponding source files, you could simply write: @example $(objects:.o=.c) @end example @noindent instead of using the general form: @example $(patsubst %.o,%.c,$(objects)) @end example @item $(strip @var{string}) @cindex stripping whitespace @cindex whitespace, stripping @cindex spaces, stripping @findex strip Removes leading and trailing whitespace from @var{string} and replaces each internal sequence of one or more whitespace characters with a single space. Thus, @samp{$(strip a b c )} results in @w{@samp{a b c}}. The function @code{strip} can be very useful when used in conjunction with conditionals. When comparing something with the empty string @samp{} using @code{ifeq} or @code{ifneq}, you usually want a string of just whitespace to match the empty string (@pxref{Conditionals}). Thus, the following may fail to have the desired results: @example .PHONY: all ifneq "$(needs_made)" "" all: $(needs_made) else all:;@@echo 'Nothing to make!' endif @end example @noindent Replacing the variable reference @w{@samp{$(needs_made)}} with the function call @w{@samp{$(strip $(needs_made))}} in the @code{ifneq} directive would make it more robust.@refill @item $(findstring @var{find},@var{in}) @findex findstring @cindex searching for strings @cindex finding strings @cindex strings, searching for Searches @var{in} for an occurrence of @var{find}. If it occurs, the value is @var{find}; otherwise, the value is empty. You can use this function in a conditional to test for the presence of a specific substring in a given string. Thus, the two examples, @example $(findstring a,a b c) $(findstring a,b c) @end example @noindent produce the values @samp{a} and @samp{} (the empty string), respectively. @xref{Testing Flags}, for a practical application of @code{findstring}.@refill @need 750 @findex filter @cindex filtering words @cindex words, filtering @item $(filter @var{pattern}@dots{},@var{text}) Removes all whitespace-separated words in @var{text} that do @emph{not} match any of the @var{pattern} words, returning only matching words. The patterns are written using @samp{%}, just like the patterns used in the @code{patsubst} function above.@refill The @code{filter} function can be used to separate out different types of strings (such as file names) in a variable. For example: @example sources := foo.c bar.c baz.s ugh.h foo: $(sources) cc $(filter %.c %.s,$(sources)) -o foo @end example @noindent says that @file{foo} depends of @file{foo.c}, @file{bar.c}, @file{baz.s} and @file{ugh.h} but only @file{foo.c}, @file{bar.c} and @file{baz.s} should be specified in the command to the compiler.@refill @item $(filter-out @var{pattern}@dots{},@var{text}) @findex filter-out @cindex filtering out words @cindex words, filtering out Removes all whitespace-separated words in @var{text} that @emph{do} match the @var{pattern} words, returning only the words that @emph{do not} match. This is the exact opposite of the @code{filter} function.@refill For example, given: @example @group objects=main1.o foo.o main2.o bar.o mains=main1.o main2.o @end group @end example @noindent the following generates a list which contains all the object files not in @samp{mains}: @example $(filter-out $(mains),$(objects)) @end example @need 1500 @findex sort @cindex sorting words @item $(sort @var{list}) Sorts the words of @var{list} in lexical order, removing duplicate words. The output is a list of words separated by single spaces. Thus, @example $(sort foo bar lose) @end example @noindent returns the value @samp{bar foo lose}. @cindex removing duplicate words @cindex duplicate words, removing @cindex words, removing duplicates Incidentally, since @code{sort} removes duplicate words, you can use it for this purpose even if you don't care about the sort order. @end table Here is a realistic example of the use of @code{subst} and @code{patsubst}. Suppose that a makefile uses the @code{VPATH} variable to specify a list of directories that @code{make} should search for dependency files (@pxref{General Search, , @code{VPATH} Search Path for All Dependencies}). This example shows how to tell the C compiler to search for header files in the same list of directories.@refill The value of @code{VPATH} is a list of directories separated by colons, such as @samp{src:../headers}. First, the @code{subst} function is used to change the colons to spaces: @example $(subst :, ,$(VPATH)) @end example @noindent This produces @samp{src ../headers}. Then @code{patsubst} is used to turn each directory name into a @samp{-I} flag. These can be added to the value of the variable @code{CFLAGS}, which is passed automatically to the C compiler, like this: @example override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH))) @end example @noindent The effect is to append the text @samp{-Isrc -I../headers} to the previously given value of @code{CFLAGS}. The @code{override} directive is used so that the new value is assigned even if the previous value of @code{CFLAGS} was specified with a command argument (@pxref{Override Directive, , The @code{override} Directive}). @node Filename Functions, Foreach Function, Text Functions, Functions @section Functions for File Names @cindex functions, for file names @cindex file name functions Several of the built-in expansion functions relate specifically to taking apart file names or lists of file names. Each of the following functions performs a specific transformation on a file name. The argument of the function is regarded as a series of file names, separated by whitespace. (Leading and trailing whitespace is ignored.) Each file name in the series is transformed in the same way and the results are concatenated with single spaces between them. @table @code @item $(dir @var{names}@dots{}) @findex dir @cindex directory part @cindex file name, directory part Extracts the directory-part of each file name in @var{names}. The directory-part of the file name is everything up through (and including) the last slash in it. If the file name contains no slash, the directory part is the string @samp{./}. For example, @example $(dir src/foo.c hacks) @end example @noindent produces the result @samp{src/ ./}. @item $(notdir @var{names}@dots{}) @findex notdir @cindex file name, nondirectory part @cindex nondirectory part Extracts all but the directory-part of each file name in @var{names}. If the file name contains no slash, it is left unchanged. Otherwise, everything through the last slash is removed from it. A file name that ends with a slash becomes an empty string. This is unfortunate, because it means that the result does not always have the same number of whitespace-separated file names as the argument had; but we do not see any other valid alternative. For example, @example $(notdir src/foo.c hacks) @end example @noindent produces the result @samp{foo.c hacks}. @item $(suffix @var{names}@dots{}) @findex suffix @cindex suffix, function to find @cindex file name suffix Extracts the suffix of each file name in @var{names}. If the file name contains a period, the suffix is everything starting with the last period. Otherwise, the suffix is the empty string. This frequently means that the result will be empty when @var{names} is not, and if @var{names} contains multiple file names, the result may contain fewer file names. For example, @example $(suffix src/foo.c hacks) @end example @noindent produces the result @samp{.c}. @item $(basename @var{names}@dots{}) @findex basename @cindex basename @cindex file name, basename of Extracts all but the suffix of each file name in @var{names}. If the file name contains a period, the basename is everything starting up to (and not including) the last period. Otherwise, the basename is the entire file name. For example, @example $(basename src/foo.c hacks) @end example @noindent produces the result @samp{src/foo hacks}. @c plural convention with dots (be consistent) @item $(addsuffix @var{suffix},@var{names}@dots{}) @findex addsuffix @cindex suffix, adding @cindex file name suffix, adding The argument @var{names} is regarded as a series of names, separated by whitespace; @var{suffix} is used as a unit. The value of @var{suffix} is appended to the end of each individual name and the resulting larger names are concatenated with single spaces between them. For example, @example $(addsuffix .c,foo bar) @end example @noindent produces the result @samp{foo.c bar.c}. @item $(addprefix @var{prefix},@var{names}@dots{}) @findex addprefix @cindex prefix, adding @cindex file name prefix, adding The argument @var{names} is regarded as a series of names, separated by whitespace; @var{prefix} is used as a unit. The value of @var{prefix} is prepended to the front of each individual name and the resulting larger names are concatenated with single spaces between them. For example, @example $(addprefix src/,foo bar) @end example @noindent produces the result @samp{src/foo src/bar}. @item $(join @var{list1},@var{list2}) @findex join @cindex joining lists of words @cindex words, joining lists Concatenates the two arguments word by word: the two first words (one from each argument) concatenated form the first word of the result, the two second words form the second word of the result, and so on. So the @var{n}th word of the result comes from the @var{n}th word of each argument. If one argument has more words that the other, the extra words are copied unchanged into the result. For example, @samp{$(join a b,.c .o)} produces @samp{a.c b.o}. Whitespace between the words in the lists is not preserved; it is replaced with a single space. This function can merge the results of the @code{dir} and @code{notdir} functions, to produce the original list of files which was given to those two functions.@refill @item $(word @var{n},@var{text}) @findex word @cindex words, selecting @cindex selecting words Returns the @var{n}th word of @var{text}. The legitimate values of @var{n} start from 1. If @var{n} is bigger than the number of words in @var{text}, the value is empty. For example, @example $(word 2, foo bar baz) @end example @noindent returns @samp{bar}. @c Following item phrased to prevent overfull hbox. --RJC 17 Jul 92 @item $(words @var{text}) @findex words @cindex words, finding number Returns the number of words in @var{text}. Thus, the last word of @var{text} is @w{@code{$(word $(words @var{text}),@var{text})}}.@refill @item $(firstword @var{names}@dots{}) @findex firstword @cindex words, extracting first The argument @var{names} is regarded as a series of names, separated by whitespace. The value is the first name in the series. The rest of the names are ignored. For example, @example $(firstword foo bar) @end example @noindent produces the result @samp{foo}. Although @code{$(firstword @var{text})} is the same as @code{$(word 1,@var{text})}, the @code{firstword} function is retained for its simplicity.@refill @item $(wildcard @var{pattern}) @findex wildcard @cindex wildcard, function The argument @var{pattern} is a file name pattern, typically containing wildcard characters (as in shell file name patterns). The result of @code{wildcard} is a space-separated list of the names of existing files that match the pattern. @xref{Wildcards, ,Using Wildcard Characters in File Names}. @end table @node Foreach Function, Origin Function, Filename Functions, Functions @section The @code{foreach} Function @findex foreach @cindex words, iterating over The @code{foreach} function is very different from other functions. It causes one piece of text to be used repeatedly, each time with a different substitution performed on it. It resembles the @code{for} command in the shell @code{sh} and the @code{foreach} command in the C-shell @code{csh}. The syntax of the @code{foreach} function is: @example $(foreach @var{var},@var{list},@var{text}) @end example @noindent The first two arguments, @var{var} and @var{list}, are expanded before anything else is done; note that the last argument, @var{text}, is @strong{not} expanded at the same time. Then for each word of the expanded value of @var{list}, the variable named by the expanded value of @var{var} is set to that word, and @var{text} is expanded. Presumably @var{text} contains references to that variable, so its expansion will be different each time. The result is that @var{text} is expanded as many times as there are whitespace-separated words in @var{list}. The multiple expansions of @var{text} are concatenated, with spaces between them, to make the result of @code{foreach}. This simple example sets the variable @samp{files} to the list of all files in the directories in the list @samp{dirs}: @example dirs := a b c d files := $(foreach dir,$(dirs),$(wildcard $(dir)/*)) @end example Here @var{text} is @samp{$(wildcard $(dir)/*)}. The first repetition finds the value @samp{a} for @code{dir}, so it produces the same result as @samp{$(wildcard a/*)}; the second repetition produces the result of @samp{$(wildcard b/*)}; and the third, that of @samp{$(wildcard c/*)}. This example has the same result (except for setting @samp{dirs}) as the following example: @example files := $(wildcard a/* b/* c/* d/*) @end example When @var{text} is complicated, you can improve readability by giving it a name, with an additional variable: @example find_files = $(wildcard $(dir)/*) dirs := a b c d files := $(foreach dir,$(dirs),$(find_files)) @end example @noindent Here we use the variable @code{find_files} this way. We use plain @samp{=} to define a recursively-expanding variable, so that its value contains an actual function call to be reexpanded under the control of @code{foreach}; a simply-expanded variable would not do, since @code{wildcard} would be called only once at the time of defining @code{find_files}. The @code{foreach} function has no permanent effect on the variable @var{var}; its value and flavor after the @code{foreach} function call are the same as they were beforehand. The other values which are taken from @var{list} are in effect only temporarily, during the execution of @code{foreach}. The variable @var{var} is a simply-expanded variable during the execution of @code{foreach}. If @var{var} was undefined before the @code{foreach} function call, it is undefined after the call. @xref{Flavors, ,The Two Flavors of Variables}.@refill You must take care when using complex variable expressions that result in variable names because many strange things are valid variable names, but are probably not what you intended. For example, @smallexample files := $(foreach Es escrito en espanol!,b c ch,$(find_files)) @end smallexample @noindent might be useful if the value of @code{find_files} references the variable whose name is @samp{Es escrito en espanol!} (es un nombre bastante largo, no?), but it is more likely to be a mistake. @node Origin Function, Shell Function, Foreach Function, Functions @section The @code{origin} Function @findex origin @cindex variables, origin of @cindex origin of variable The @code{origin} function is unlike most other functions in that it does not operate on the values of variables; it tells you something @emph{about} a variable. Specifically, it tells you where it came from. The syntax of the @code{origin} function is: @example $(origin @var{variable}) @end example Note that @var{variable} is the @emph{name} of a variable to inquire about; not a @emph{reference} to that variable. Therefore you would not normally use a @samp{$} or parentheses when writing it. (You can, however, use a variable reference in the name if you want the name not to be a constant.) The result of this function is a string telling you how the variable @var{variable} was defined: @table @samp @item undefined if @var{variable} was never defined. @item default if @var{variable} has a default definition, as is usual with @code{CC} and so on. @xref{Implicit Variables, ,Variables Used by Implicit Rules}. Note that if you have redefined a default variable, the @code{origin} function will return the origin of the later definition. @item environment if @var{variable} was defined as an environment variable and the @samp{-e} option is @emph{not} turned on (@pxref{Options Summary, ,Summary of Options}). @item environment override if @var{variable} was defined as an environment variable and the @w{@samp{-e}} option @emph{is} turned on (@pxref{Options Summary, ,Summary of Options}).@refill @item file if @var{variable} was defined in a makefile. @item command line if @var{variable} was defined on the command line. @item override if @var{variable} was defined with an @code{override} directive in a makefile (@pxref{Override Directive, ,The @code{override} Directive}). @item automatic if @var{variable} is an automatic variable defined for the execution of the commands for each rule (@pxref{Automatic, , Automatic Variables}). @end table This information is primarily useful (other than for your curiosity) to determine if you want to believe the value of a variable. For example, suppose you have a makefile @file{foo} that includes another makefile @file{bar}. You want a variable @code{bletch} to be defined in @file{bar} if you run the command @w{@samp{make -f bar}}, even if the environment contains a definition of @code{bletch}. However, if @file{foo} defined @code{bletch} before including @file{bar}, you do not want to override that definition. This could be done by using an @code{override} directive in @file{foo}, giving that definition precedence over the later definition in @file{bar}; unfortunately, the @code{override} directive would also override any command line definitions. So, @file{bar} could include:@refill @example @group ifdef bletch ifeq "$(origin bletch)" "environment" bletch = barf, gag, etc. endif endif @end group @end example @noindent If @code{bletch} has been defined from the environment, this will redefine it. If you want to override a previous definition of @code{bletch} if it came from the environment, even under @samp{-e}, you could instead write: @example @group ifneq "$(findstring environment,$(origin bletch))" "" bletch = barf, gag, etc. endif @end group @end example Here the redefinition takes place if @samp{$(origin bletch)} returns either @samp{environment} or @samp{environment override}. @xref{Text Functions, , Functions for String Substitution and Analysis}. @node Shell Function, , Origin Function, Functions @section The @code{shell} Function @findex shell @cindex commands, expansion @cindex backquotes @cindex shell command, function for The @code{shell} function is unlike any other function except the @code{wildcard} function (@pxref{Wildcard Function, ,The Function @code{wildcard}}) in that it communicates with the world outside of @code{make}. The @code{shell} function performs the same function that backquotes (@samp{`}) perform in most shells: it does @dfn{command expansion}. This means that it takes an argument that is a shell command and returns the output of the command. The only processing @code{make} does on the result, before substituting it into the surrounding text, is to convert newlines to spaces.@refill The commands run by calls to the @code{shell} function are run when the function calls are expanded. In most cases, this is when the makefile is read in. The exception is that function calls in the commands of the rules are expanded when the commands are run, and this applies to @code{shell} function calls like all others. Here are some examples of the use of the @code{shell} function: @example contents := $(shell cat foo) @end example @noindent sets @code{contents} to the contents of the file @file{foo}, with a space (rather than a newline) separating each line. @example files := $(shell echo *.c) @end example @noindent sets @code{files} to the expansion of @samp{*.c}. Unless @code{make} is using a very strange shell, this has the same result as @w{@samp{$(wildcard *.c)}}.@refill @node Running, Implicit Rules, Functions, Top @chapter How to Run @code{make} A makefile that says how to recompile a program can be used in more than one way. The simplest use is to recompile every file that is out of date. Usually, makefiles are written so that if you run @code{make} with no arguments, it does just that. But you might want to update only some of the files; you might want to use a different compiler or different compiler options; you might want just to find out which files are out of date without changing them. By giving arguments when you run @code{make}, you can do any of these things and many others. @menu * Makefile Arguments:: How to specify which makefile to use. * Goals:: How to use goal arguments to specify which parts of the makefile to use. * Instead of Execution:: How to use mode flags to specify what kind of thing to do with the commands in the makefile other than simply execute them. * Avoiding Compilation:: How to avoid recompiling certain files. * Overriding:: How to override a variable to specify an alternate compiler and other things. * Testing:: How to proceed past some errors, to test compilation. * Options Summary:: Summary of Options @end menu @node Makefile Arguments, Goals, , Running @section Arguments to Specify the Makefile @cindex @code{--file} @cindex @code{--makefile} @cindex @code{-f} The way to specify the name of the makefile is with the @samp{-f} or @samp{--file} option (@samp{--makefile} also works). For example, @samp{-f altmake} says to use the file @file{altmake} as the makefile. If you use the @samp{-f} flag several times and follow each @samp{-f} with an argument, all the specified files are used jointly as makefiles. If you do not use the @samp{-f} or @samp{--file} flag, the default is to try @file{GNUmakefile}, @file{makefile}, and @file{Makefile}, in that order, and use the first of these three which exists or can be made (@pxref{Makefiles, ,Writing Makefiles}).@refill @node Goals, Instead of Execution, Makefile Arguments, Running @section Arguments to Specify the Goals @cindex goal, how to specify The @dfn{goals} are the targets that @code{make} should strive ultimately to update. Other targets are updated as well if they appear as dependencies of goals, or dependencies of dependencies of goals, etc. By default, the goal is the first target in the makefile (not counting targets that start with a period). Therefore, makefiles are usually written so that the first target is for compiling the entire program or programs they describe. You can specify a different goal or goals with arguments to @code{make}. Use the name of the goal as an argument. If you specify several goals, @code{make} processes each of them in turn, in the order you name them. Any target in the makefile may be specified as a goal (unless it starts with @samp{-} or contains an @samp{=}, in which case it will be parsed as a switch or variable definition, respectively). Even targets not in the makefile may be specified, if @code{make} can find implicit rules that say how to make them. One use of specifying a goal is if you want to compile only a part of the program, or only one of several programs. Specify as a goal each file that you wish to remake. For example, consider a directory containing several programs, with a makefile that starts like this: @example .PHONY: all all: size nm ld ar as @end example If you are working on the program @code{size}, you might want to say @w{@samp{make size}} so that only the files of that program are recompiled. Another use of specifying a goal is to make files that are not normally made. For example, there may be a file of debugging output, or a version of the program that is compiled specially for testing, which has a rule in the makefile but is not a dependency of the default goal. Another use of specifying a goal is to run the commands associated with a phony target (@pxref{Phony Targets}) or empty target (@pxref{Empty Targets, ,Empty Target Files to Record Events}). Many makefiles contain a phony target named @file{clean} which deletes everything except source files. Naturally, this is done only if you request it explicitly with @w{@samp{make clean}}. Following is a list of typical phony and empty target names. @xref{Standard Targets}, for a detailed list of all the standard target names which GNU software packages use. @table @file @item all @cindex @code{all} @r{(standard target)} Make all the top-level targets the makefile knows about. @item clean @cindex @code{clean} @r{(standard target)} Delete all files that are normally created by running @code{make}. @item mostlyclean @cindex @code{mostlyclean} @r{(standard target)} Like @samp{clean}, but may refrain from deleting a few files that people normally don't want to recompile. For example, the @samp{mostlyclean} target for GCC does not delete @file{libgcc.a}, because recompiling it is rarely necessary and takes a lot of time. @item distclean @cindex @code{distclean} @r{(standard target)} @itemx realclean @cindex @code{realclean} @r{(standard target)} @itemx clobber @cindex @code{clobber} @r{(standard target)} Any of these targets might be defined to delete @emph{more} files than @samp{clean} does. For example, this would delete configuration files or links that you would normally create as preparation for compilation, even if the makefile itself cannot create these files. @item install @cindex @code{install} @r{(standard target)} Copy the executable file into a directory that users typically search for commands; copy any auxiliary files that the executable uses into the directories where it will look for them. @item print @cindex @code{print} @r{(standard target)} Print listings of the source files that have changed. @item tar @cindex @code{tar} @r{(standard target)} Create a tar file of the source files. @item shar @cindex @code{shar} @r{(standard target)} Create a shell archive (shar file) of the source files. @item dist @cindex @code{dist} @r{(standard target)} Create a distribution file of the source files. This might be a tar file, or a shar file, or a compressed version of one of the above, or even more than one of the above. @item TAGS @cindex @code{TAGS} @r{(standard target)} Update a tags table for this program. @item check @cindex @code{check} @r{(standard target)} @itemx test @cindex @code{test} @r{(standard target)} Perform self tests on the program this makefile builds. @end table @node Instead of Execution, Avoiding Compilation, Goals, Running @section Instead of Executing the Commands @cindex execution, instead of @cindex commands, instead of executing The makefile tells @code{make} how to tell whether a target is up to date, and how to update each target. But updating the targets is not always what you want. Certain options specify other activities for @code{make}. @comment Extra blank lines make it print better. @table @samp @item -n @itemx --just-print @itemx --dry-run @itemx --recon @cindex @code{--just-print} @cindex @code{--dry-run} @cindex @code{--recon} @cindex @code{-n} ``No-op''. The activity is to print what commands would be used to make the targets up to date, but not actually execute them. @item -t @itemx --touch @cindex @code{--touch} @cindex touching files @cindex target, touching @cindex @code{-t} ``Touch''. The activity is to mark the targets as up to date without actually changing them. In other words, @code{make} pretends to compile the targets but does not really change their contents. @item -q @itemx --question @cindex @code{--question} @cindex @code{-q} @cindex question mode ``Question''. The activity is to find out silently whether the targets are up to date already; but execute no commands in either case. In other words, neither compilation nor output will occur. @item -W @var{file} @itemx --what-if=@var{file} @itemx --assume-new=@var{file} @itemx --new-file=@var{file} @cindex @code{--what-if} @cindex @code{-W} @cindex @code{--assume-new} @cindex @code{--new-file} @cindex what if @cindex files, assuming new ``What if''. Each @samp{-W} flag is followed by a file name. The given files' modification times are recorded by @code{make} as being the present time, although the actual modification times remain the same. You can use the @samp{-W} flag in conjunction with the @samp{-n} flag to see what would happen if you were to modify specific files.@refill @end table With the @samp{-n} flag, @code{make} prints the commands that it would normally execute but does not execute them. With the @samp{-t} flag, @code{make} ignores the commands in the rules and uses (in effect) the command @code{touch} for each target that needs to be remade. The @code{touch} command is also printed, unless @samp{-s} or @code{.SILENT} is used. For speed, @code{make} does not actually invoke the program @code{touch}. It does the work directly. With the @samp{-q} flag, @code{make} prints nothing and executes no commands, but the exit status code it returns is zero if and only if the targets to be considered are already up to date. It is an error to use more than one of these three flags in the same invocation of @code{make}. The @samp{-n}, @samp{-t}, and @samp{-q} options do not affect command lines that begin with @samp{+} characters or contain the strings @samp{$(MAKE)} or @samp{$@{MAKE@}}. Note that only the line containing the @samp{+} character or the strings @samp{$(MAKE)} or @samp{$@{MAKE@}} is run regardless of these options. Other lines in the same rule are not run unless they too begin with @samp{+} or contain @samp{$(MAKE)} or @samp{$@{MAKE@}} (@xref{MAKE Variable, ,How the @code{MAKE} Variable Works}.) The @samp{-W} flag provides two features: @itemize @bullet @item If you also use the @samp{-n} or @samp{-q} flag, you can see what @code{make} would do if you were to modify some files. @item Without the @samp{-n} or @samp{-q} flag, when @code{make} is actually executing commands, the @samp{-W} flag can direct @code{make} to act as if some files had been modified, without actually modifying the files.@refill @end itemize Note that the options @samp{-p} and @samp{-v} allow you to obtain other information about @code{make} or about the makefiles in use (@pxref{Options Summary, ,Summary of Options}).@refill @node Avoiding Compilation, Overriding, Instead of Execution, Running @section Avoiding Recompilation of Some Files @cindex @code{-o} @cindex @code{--old-file} @cindex @code{--assume-old} @cindex files, assuming old @cindex files, avoiding recompilation of @cindex recompilation, avoiding Sometimes you may have changed a source file but you do not want to recompile all the files that depend on it. For example, suppose you add a macro or a declaration to a header file that many other files depend on. Being conservative, @code{make} assumes that any change in the header file requires recompilation of all dependent files, but you know that they do not need to be recompiled and you would rather not waste the time waiting for them to compile. If you anticipate the problem before changing the header file, you can use the @samp{-t} flag. This flag tells @code{make} not to run the commands in the rules, but rather to mark the target up to date by changing its last-modification date. You would follow this procedure: @enumerate @item Use the command @samp{make} to recompile the source files that really need recompilation. @item Make the changes in the header files. @item Use the command @samp{make -t} to mark all the object files as up to date. The next time you run @code{make}, the changes in the header files will not cause any recompilation. @end enumerate If you have already changed the header file at a time when some files do need recompilation, it is too late to do this. Instead, you can use the @w{@samp{-o @var{file}}} flag, which marks a specified file as ``old'' (@pxref{Options Summary, ,Summary of Options}). This means that the file itself will not be remade, and nothing else will be remade on its account. Follow this procedure: @enumerate @item Recompile the source files that need compilation for reasons independent of the particular header file, with @samp{make -o @var{headerfile}}. If several header files are involved, use a separate @samp{-o} option for each header file. @item Touch all the object files with @samp{make -t}. @end enumerate @node Overriding, Testing, Avoiding Compilation, Running @section Overriding Variables @cindex overriding variables with arguments @cindex variables, overriding with arguments @cindex command line variables @cindex variables, command line An argument that contains @samp{=} specifies the value of a variable: @samp{@var{v}=@var{x}} sets the value of the variable @var{v} to @var{x}. If you specify a value in this way, all ordinary assignments of the same variable in the makefile are ignored; we say they have been @dfn{overridden} by the command line argument. The most common way to use this facility is to pass extra flags to compilers. For example, in a properly written makefile, the variable @code{CFLAGS} is included in each command that runs the C compiler, so a file @file{foo.c} would be compiled something like this: @example cc -c $(CFLAGS) foo.c @end example Thus, whatever value you set for @code{CFLAGS} affects each compilation that occurs. The makefile probably specifies the usual value for @code{CFLAGS}, like this: @example CFLAGS=-g @end example Each time you run @code{make}, you can override this value if you wish. For example, if you say @samp{make CFLAGS='-g -O'}, each C compilation will be done with @samp{cc -c -g -O}. (This illustrates how you can use quoting in the shell to enclose spaces and other special characters in the value of a variable when you override it.) The variable @code{CFLAGS} is only one of many standard variables that exist just so that you can change them this way. @xref{Implicit Variables, , Variables Used by Implicit Rules}, for a complete list. You can also program the makefile to look at additional variables of your own, giving the user the ability to control other aspects of how the makefile works by changing the variables. When you override a variable with a command argument, you can define either a recursively-expanded variable or a simply-expanded variable. The examples shown above make a recursively-expanded variable; to make a simply-expanded variable, write @samp{:=} instead of @samp{=}. But, unless you want to include a variable reference or function call in the @emph{value} that you specify, it makes no difference which kind of variable you create. There is one way that the makefile can change a variable that you have overridden. This is to use the @code{override} directive, which is a line that looks like this: @samp{override @var{variable} = @var{value}} (@pxref{Override Directive, ,The @code{override} Directive}). @node Testing, Options Summary, Overriding, Running @section Testing the Compilation of a Program @cindex testing compilation @cindex compilation, testing Normally, when an error happens in executing a shell command, @code{make} gives up immediately, returning a nonzero status. No further commands are executed for any target. The error implies that the goal cannot be correctly remade, and @code{make} reports this as soon as it knows. When you are compiling a program that you have just changed, this is not what you want. Instead, you would rather that @code{make} try compiling every file that can be tried, to show you as many compilation errors as possible. @cindex @code{-k} @cindex @code{--keep-going} On these occasions, you should use the @samp{-k} or @samp{--keep-going} flag. This tells @code{make} to continue to consider the other dependencies of the pending targets, remaking them if necessary, before it gives up and returns nonzero status. For example, after an error in compiling one object file, @samp{make -k} will continue compiling other object files even though it already knows that linking them will be impossible. In addition to continuing after failed shell commands, @samp{make -k} will continue as much as possible after discovering that it does not know how to make a target or dependency file. This will always cause an error message, but without @samp{-k}, it is a fatal error (@pxref{Options Summary, ,Summary of Options}).@refill The usual behavior of @code{make} assumes that your purpose is to get the goals up to date; once @code{make} learns that this is impossible, it might as well report the failure immediately. The @samp{-k} flag says that the real purpose is to test as much as possible of the changes made in the program, perhaps to find several independent problems so that you can correct them all before the next attempt to compile. This is why Emacs' @kbd{M-x compile} command passes the @samp{-k} flag by default. @node Options Summary, , Testing, Running @section Summary of Options @cindex options @cindex flags @cindex switches Here is a table of all the options @code{make} understands: @table @samp @item -b @cindex @code{-b} @itemx -m @cindex @code{-m} These options are ignored for compatibility with other versions of @code{make}. @item -C @var{dir} @cindex @code{-C} @itemx --directory=@var{dir} @cindex @code{--directory} Change to directory @var{dir} before reading the makefiles. If multiple @samp{-C} options are specified, each is interpreted relative to the previous one: @samp{-C / -C etc} is equivalent to @samp{-C /etc}. This is typically used with recursive invocations of @code{make} (@pxref{Recursion, ,Recursive Use of @code{make}}). @item -d @cindex @code{-d} @itemx --debug @cindex @code{--debug} @c Extra blank line here makes the table look better. Print debugging information in addition to normal processing. The debugging information says which files are being considered for remaking, which file-times are being compared and with what results, which files actually need to be remade, which implicit rules are considered and which are applied---everything interesting about how @code{make} decides what to do. @item -e @cindex @code{-e} @itemx --environment-overrides @cindex @code{--environment-overrides} Give variables taken from the environment precedence over variables from makefiles. @xref{Environment, ,Variables from the Environment}. @item -f @var{file} @cindex @code{-f} @itemx --file=@var{file} @cindex @code{--file} @itemx --makefile=@var{file} @cindex @code{--makefile} Read the file named @var{file} as a makefile. @xref{Makefiles, ,Writing Makefiles}. @item -h @cindex @code{-h} @itemx --help @cindex @code{--help} @c Extra blank line here makes the table look better. Remind you of the options that @code{make} understands and then exit. @item -i @cindex @code{-i} @itemx --ignore-errors @cindex @code{--ignore-errors} Ignore all errors in commands executed to remake files. @xref{Errors, ,Errors in Commands}. @item -I @var{dir} @cindex @code{-I} @itemx --include-dir=@var{dir} @cindex @code{--include-dir} Specifies a directory @var{dir} to search for included makefiles. @xref{Include, ,Including Other Makefiles}. If several @samp{-I} options are used to specify several directories, the directories are searched in the order specified. @item -j [@var{jobs}] @cindex @code{-j} @itemx --jobs=[@var{jobs}] @cindex @code{--jobs} Specifies the number of jobs (commands) to run simultaneously. With no argument, @code{make} runs as many jobs simultaneously as possible. If there is more than one @samp{-j} option, the last one is effective. @xref{Parallel, ,Parallel Execution}, for more information on how commands are run. @item -k @cindex @code{-k} @itemx --keep-going @cindex @code{--keep-going} Continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same. @xref{Testing, ,Testing the Compilation of a Program}. @item -l [@var{load}] @cindex @code{-l} @itemx --load-average[=@var{load}] @cindex @code{--load-average} @itemx --max-load[=@var{load}] @cindex @code{--max-load} Specifies that no new jobs (commands) should be started if there are other jobs running and the load average is at least @var{load} (a floating-point number). With no argument, removes a previous load limit. @xref{Parallel, ,Parallel Execution}. @item -n @cindex @code{-n} @itemx --just-print @cindex @code{--just-print} @itemx --dry-run @cindex @code{--dry-run} @itemx --recon @cindex @code{--recon} @c Extra blank line here makes the table look better. Print the commands that would be executed, but do not execute them. @xref{Instead of Execution, ,Instead of Executing the Commands}. @item -o @var{file} @cindex @code{-o} @itemx --old-file=@var{file} @cindex @code{--old-file} @itemx --assume-old=@var{file} @cindex @code{--assume-old} Do not remake the file @var{file} even if it is older than its dependencies, and do not remake anything on account of changes in @var{file}. Essentially the file is treated as very old and its rules are ignored. @xref{Avoiding Compilation, ,Avoiding Recompilation of Some Files}.@refill @item -p @cindex @code{-p} @itemx --print-data-base @cindex @code{--print-data-base} Print the data base (rules and variable values) that results from reading the makefiles; then execute as usual or as otherwise specified. This also prints the version information given by the @samp{-v} switch (see below). To print the data base without trying to remake any files, use @w{@samp{make -p -f /dev/null}}. @item -q @cindex @code{-q} @itemx --question @cindex @code{--question} ``Question mode''. Do not run any commands, or print anything; just return an exit status that is zero if the specified targets are already up to date, nonzero otherwise. @xref{Instead of Execution, ,Instead of Executing the Commands}.@refill @item -r @cindex @code{-r} @itemx --no-builtin-rules @cindex @code{--no-builtin-rules} Eliminate use of the built-in implicit rules (@pxref{Implicit Rules, ,Using Implicit Rules}). You can still define your own by writing pattern rules (@pxref{Pattern Rules, ,Defining and Redefining Pattern Rules}). The @samp{-r} option also clears out the default list of suffixes for suffix rules (@pxref{Suffix Rules, ,Old-Fashioned Suffix Rules}). But you can still define your own suffixes with a rule for @code{.SUFFIXES}, and then define your own suffix rules. @item -s @cindex @code{-s} @itemx --silent @cindex @code{--silent} @itemx --quiet @cindex @code{--quiet} @c Extra blank line here makes the table look better. Silent operation; do not print the commands as they are executed. @xref{Echoing, ,Command Echoing}. @item -S @cindex @code{-S} @itemx --no-keep-going @cindex @code{--no-keep-going} @itemx --stop @cindex @code{--stop} @c Extra blank line here makes the table look better. Cancel the effect of the @samp{-k} option. This is never necessary except in a recursive @code{make} where @samp{-k} might be inherited from the top-level @code{make} via @code{MAKEFLAGS} (@pxref{Recursion, ,Recursive Use of @code{make}}) or if you set @samp{-k} in @code{MAKEFLAGS} in your environment.@refill @item -t @cindex @code{-t} @itemx --touch @cindex @code{--touch} @c Extra blank line here makes the table look better. Touch files (mark them up to date without really changing them) instead of running their commands. This is used to pretend that the commands were done, in order to fool future invocations of @code{make}. @xref{Instead of Execution, ,Instead of Executing the Commands}. @item -v @cindex @code{-v} @itemx --version @cindex @code{--version} Print the version of the @code{make} program plus a copyright, a list of authors, and a notice that there is no warranty; then exit. @item -w @cindex @code{-w} @itemx --print-directory @cindex @code{--print-directory} Print a message containing the working directory both before and after executing the makefile. This may be useful for tracking down errors from complicated nests of recursive @code{make} commands. @xref{Recursion, ,Recursive Use of @code{make}}. (In practice, you rarely need to specify this option since @samp{make} does it for you; see @ref{-w Option, ,The @samp{--print-directory} Option}.) @itemx --no-print-directory @cindex @code{--no-print-directory} Disable printing of the working directory under @code{-w}. This option is useful when @code{-w} is turned on automatically, but you do not want to see the extra messages. @xref{-w Option, ,The @samp{--print-directory} Option}. @item -W @var{file} @cindex @code{-W} @itemx --what-if=@var{file} @cindex @code{--what-if} @itemx --new-file=@var{file} @cindex @code{--new-file} @itemx --assume-new=@var{file} @cindex @code{--assume-new} Pretend that the target @var{file} has just been modified. When used with the @samp{-n} flag, this shows you what would happen if you were to modify that file. Without @samp{-n}, it is almost the same as running a @code{touch} command on the given file before running @code{make}, except that the modification time is changed only in the imagination of @code{make}. @xref{Instead of Execution, ,Instead of Executing the Commands}. @item --warn-undefined-variables @cindex @code{--warn-undefined-variables} @cindex variables, warning for undefined @cindex undefined variables, warning message Issue a warning message whenever @code{make} sees a reference to an undefined variable. This can be helpful when you are trying to debug makefiles which use variables in complex ways. @end table @node Implicit Rules, Archives, Running, Top @chapter Using Implicit Rules @cindex implicit rule @cindex rule, implicit Certain standard ways of remaking target files are used very often. For example, one customary way to make an object file is from a C source file using the C compiler, @code{cc}. @dfn{Implicit rules} tell @code{make} how to use customary techniques so that you do not have to specify them in detail when you want to use them. For example, there is an implicit rule for C compilation. File names determine which implicit rules are run. For example, C compilation typically takes a @file{.c} file and makes a @file{.o} file. So @code{make} applies the implicit rule for C compilation when it sees this combination of file name endings.@refill A chain of implicit rules can apply in sequence; for example, @code{make} will remake a @file{.o} file from a @file{.y} file by way of a @file{.c} file. @iftex @xref{Chained Rules, ,Chains of Implicit Rules}. @end iftex The built-in implicit rules use several variables in their commands so that, by changing the values of the variables, you can change the way the implicit rule works. For example, the variable @code{CFLAGS} controls the flags given to the C compiler by the implicit rule for C compilation. @iftex @xref{Implicit Variables, ,Variables Used by Implicit Rules}. @end iftex You can define your own implicit rules by writing @dfn{pattern rules}. @iftex @xref{Pattern Rules, ,Defining and Redefining Pattern Rules}. @end iftex @dfn{Suffix rules} are a more limited way to define implicit rules. Pattern rules are more general and clearer, but suffix rules are retained for compatibility. @iftex @xref{Suffix Rules, ,Old-Fashioned Suffix Rules}. @end iftex @menu * Using Implicit:: How to use an existing implicit rule to get the commands for updating a file. * Catalogue of Rules:: A list of built-in implicit rules. * Implicit Variables:: How to change what predefined rules do. * Chained Rules:: How to use a chain of implicit rules. * Pattern Rules:: How to define new implicit rules. * Last Resort:: How to defining commands for rules which cannot find any. * Suffix Rules:: The old-fashioned style of implicit rule. * Search Algorithm:: The precise algorithm for applying implicit rules. @end menu @node Using Implicit, Catalogue of Rules, , Implicit Rules @section Using Implicit Rules @cindex implicit rule, how to use @cindex rule, implicit, how to use To allow @code{make} to find a customary method for updating a target file, all you have to do is refrain from specifying commands yourself. Either write a rule with no command lines, or don't write a rule at all. Then @code{make} will figure out which implicit rule to use based on which kind of source file exists or can be made. For example, suppose the makefile looks like this: @example foo : foo.o bar.o cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS) @end example @noindent Because you mention @file{foo.o} but do not give a rule for it, @code{make} will automatically look for an implicit rule that tells how to update it. This happens whether or not the file @file{foo.o} currently exists. If an implicit rule is found, it can supply both commands and one or more dependencies (the source files). You would want to write a rule for @file{foo.o} with no command lines if you need to specify additional dependencies, such as header files, that the implicit rule cannot supply. Each implicit rule has a target pattern and dependency patterns. There may be many implicit rules with the same target pattern. For example, numerous rules make @samp{.o} files: one, from a @samp{.c} file with the C compiler; another, from a @samp{.p} file with the Pascal compiler; and so on. The rule that actually applies is the one whose dependencies exist or can be made. So, if you have a file @file{foo.c}, @code{make} will run the C compiler; otherwise, if you have a file @file{foo.p}, @code{make} will run the Pascal compiler; and so on. Of course, when you write the makefile, you know which implicit rule you want @code{make} to use, and you know it will choose that one because you know which possible dependency files are supposed to exist. @xref{Catalogue of Rules, ,Catalogue of Implicit Rules}, for a catalogue of all the predefined implicit rules. Above, we said an implicit rule applies if the required dependencies ``exist or can be made''. A file ``can be made'' if it is mentioned explicitly in the makefile as a target or a dependency, or if an implicit rule can be recursively found for how to make it. When an implicit dependency is the result of another implicit rule, we say that @dfn{chaining} is occurring. @xref{Chained Rules, ,Chains of Implicit Rules}. In general, @code{make} searches for an implicit rule for each target, and for each double-colon rule, that has no commands. A file that is mentioned only as a dependency is considered a target whose rule specifies nothing, so implicit rule search happens for it. @xref{Search Algorithm, ,Implicit Rule Search Algorithm}, for the details of how the search is done. Note that explicit dependencies do not influence implicit rule search. For example, consider this explicit rule: @example foo.o: foo.p @end example @noindent The dependency on @file{foo.p} does not necessarily mean that @code{make} will remake @file{foo.o} according to the implicit rule to make an object file, a @file{.o} file, from a Pascal source file, a @file{.p} file. For example, if @file{foo.c} also exists, the implicit rule to make an object file from a C source file is used instead, because it appears before the Pascal rule in the list of predefined implicit rules (@pxref{Catalogue of Rules, , Catalogue of Implicit Rules}). If you do not want an implicit rule to be used for a target that has no commands, you can give that target empty commands by writing a semicolon (@pxref{Empty Commands, ,Defining Empty Commands}). @node Catalogue of Rules, Implicit Variables, Using Implicit, Implicit Rules @section Catalogue of Implicit Rules @cindex implicit rule, predefined @cindex rule, implicit, predefined Here is a catalogue of predefined implicit rules which are always available unless the makefile explicitly overrides or cancels them. @xref{Canceling Rules, ,Canceling Implicit Rules}, for information on canceling or overriding an implicit rule. The @samp{-r} or @samp{--no-builtin-rules} option cancels all predefined rules. Not all of these rules will always be defined, even when the @samp{-r} option is not given. Many of the predefined implicit rules are implemented in @code{make} as suffix rules, so which ones will be defined depends on the @dfn{suffix list} (the list of dependencies of the special target @code{.SUFFIXES}). The default suffix list is: @code{.out}, @code{.a}, @code{.ln}, @code{.o}, @code{.c}, @code{.cc}, @code{.C}, @code{.p}, @code{.f}, @code{.F}, @code{.r}, @code{.y}, @code{.l}, @code{.s}, @code{.S}, @code{.mod}, @code{.sym}, @code{.def}, @code{.h}, @code{.info}, @code{.dvi}, @code{.tex}, @code{.texinfo}, @code{.texi}, @code{.txinfo}, @code{.w}, @code{.ch} @code{.web}, @code{.sh}, @code{.elc}, @code{.el}. All of the implicit rules described below whose dependencies have one of these suffixes are actually suffix rules. If you modify the suffix list, the only predefined suffix rules in effect will be those named by one or two of the suffixes that are on the list you specify; rules whose suffixes fail to be on the list are disabled. @xref{Suffix Rules, ,Old-Fashioned Suffix Rules}, for full details on suffix rules. @table @asis @item Compiling C programs @cindex C, rule to compile @pindex cc @pindex gcc @pindex .o @pindex .c @file{@var{n}.o} is made automatically from @file{@var{n}.c} with a command of the form @samp{$(CC) -c $(CPPFLAGS) $(CFLAGS)}.@refill @item Compiling C++ programs @cindex C++, rule to compile @pindex g++ @pindex .C @pindex .cc @file{@var{n}.o} is made automatically from @file{@var{n}.cc} or @file{@var{n}.C} with a command of the form @samp{$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)}. We encourage you to use the suffix @samp{.cc} for C++ source files instead of @samp{.C}.@refill @item Compiling Pascal programs @cindex Pascal, rule to compile @pindex pc @pindex .p @file{@var{n}.o} is made automatically from @file{@var{n}.p} with the command @samp{$(PC) -c $(PFLAGS)}.@refill @item Compiling Fortran and Ratfor programs @cindex Fortran, rule to compile @cindex Ratfor, rule to compile @pindex f77 @pindex .f @pindex .r @pindex .F @file{@var{n}.o} is made automatically from @file{@var{n}.r}, @file{@var{n}.F} or @file{@var{n}.f} by running the Fortran compiler. The precise command used is as follows:@refill @table @samp @item .f @samp{$(FC) -c $(FFLAGS)}. @item .F @samp{$(FC) -c $(FFLAGS) $(CPPFLAGS)}. @item .r @samp{$(FC) -c $(FFLAGS) $(RFLAGS)}. @end table @item Preprocessing Fortran and Ratfor programs @file{@var{n}.f} is made automatically from @file{@var{n}.r} or @file{@var{n}.F}. This rule runs just the preprocessor to convert a Ratfor or preprocessable Fortran program into a strict Fortran program. The precise command used is as follows:@refill @table @samp @item .F @samp{$(FC) -F $(CPPFLAGS) $(FFLAGS)}. @item .r @samp{$(FC) -F $(FFLAGS) $(RFLAGS)}. @end table @item Compiling Modula-2 programs @cindex Modula-2, rule to compile @pindex m2c @pindex .sym @pindex .def @pindex .mod @file{@var{n}.sym} is made from @file{@var{n}.def} with a command of the form @samp{$(M2C) $(M2FLAGS) $(DEFFLAGS)}. @file{@var{n}.o} is made from @file{@var{n}.mod}; the form is: @w{@samp{$(M2C) $(M2FLAGS) $(MODFLAGS)}}.@refill @need 1200 @item Assembling and preprocessing assembler programs @cindex assembly, rule to compile @pindex as @pindex .s @file{@var{n}.o} is made automatically from @file{@var{n}.s} by running the assembler, @code{as}. The precise command is @samp{$(AS) $(ASFLAGS)}.@refill @pindex .S @file{@var{n}.s} is made automatically from @file{@var{n}.S} by running the C preprocessor, @code{cpp}. The precise command is @w{@samp{$(CPP) $(CPPFLAGS)}}. @item Linking a single object file @cindex linking, predefined rule for @pindex ld @pindex .o @file{@var{n}} is made automatically from @file{@var{n}.o} by running the linker (usually called @code{ld}) via the C compiler. The precise command used is @w{@samp{$(CC) $(LDFLAGS) @var{n}.o $(LOADLIBES)}}. This rule does the right thing for a simple program with only one source file. It will also do the right thing if there are multiple object files (presumably coming from various other source files), one of which has a name matching that of the executable file. Thus, @example x: y.o z.o @end example @noindent when @file{x.c}, @file{y.c} and @file{z.c} all exist will execute: @example @group cc -c x.c -o x.o cc -c y.c -o y.o cc -c z.c -o z.o cc x.o y.o z.o -o x rm -f x.o rm -f y.o rm -f z.o @end group @end example @noindent In more complicated cases, such as when there is no object file whose name derives from the executable file name, you must write an explicit command for linking. Each kind of file automatically made into @samp{.o} object files will be automatically linked by using the compiler (@samp{$(CC)}, @samp{$(FC)} or @samp{$(PC)}; the C compiler @samp{$(CC)} is used to assemble @samp{.s} files) without the @samp{-c} option. This could be done by using the @samp{.o} object files as intermediates, but it is faster to do the compiling and linking in one step, so that's how it's done.@refill @item Yacc for C programs @pindex yacc @cindex Yacc, rule to run @pindex .y @file{@var{n}.c} is made automatically from @file{@var{n}.y} by running Yacc with the command @samp{$(YACC) $(YFLAGS)}. @item Lex for C programs @pindex lex @cindex Lex, rule to run @pindex .l @file{@var{n}.c} is made automatically from @file{@var{n}.l} by by running Lex. The actual command is @samp{$(LEX) $(LFLAGS)}. @item Lex for Ratfor programs @file{@var{n}.r} is made automatically from @file{@var{n}.l} by by running Lex. The actual command is @samp{$(LEX) $(LFLAGS)}. The convention of using the same suffix @samp{.l} for all Lex files regardless of whether they produce C code or Ratfor code makes it impossible for @code{make} to determine automatically which of the two languages you are using in any particular case. If @code{make} is called upon to remake an object file from a @samp{.l} file, it must guess which compiler to use. It will guess the C compiler, because that is more common. If you are using Ratfor, make sure @code{make} knows this by mentioning @file{@var{n}.r} in the makefile. Or, if you are using Ratfor exclusively, with no C files, remove @samp{.c} from the list of implicit rule suffixes with:@refill @example @group .SUFFIXES: .SUFFIXES: .o .r .f .l @dots{} @end group @end example @item Making Lint Libraries from C, Yacc, or Lex programs @pindex lint @cindex @code{lint}, rule to run @pindex .ln @file{@var{n}.ln} is made from @file{@var{n}.c} by running @code{lint}. The precise command is @w{@samp{$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i}}. The same command is used on the C code produced from @file{@var{n}.y} or @file{@var{n}.l}.@refill @item @TeX{} and Web @cindex @TeX{}, rule to run @cindex Web, rule to run @pindex tex @pindex cweave @pindex weave @pindex tangle @pindex ctangle @pindex .dvi @pindex .tex @pindex .web @pindex .w @pindex .ch @file{@var{n}.dvi} is made from @file{@var{n}.tex} with the command @samp{$(TEX)}. @file{@var{n}.tex} is made from @file{@var{n}.web} with @samp{$(WEAVE)}, or from @file{@var{n}.w} (and from @file{@var{n}.ch} if it exists or can be made) with @samp{$(CWEAVE)}. @file{@var{n}.p} is made from @file{@var{n}.web} with @samp{$(TANGLE)} and @file{@var{n}.c} is made from @file{@var{n}.w} (and from @file{@var{n}.ch} if it exists or can be made) with @samp{$(CTANGLE)}.@refill @item Texinfo and Info @cindex Texinfo, rule to format @cindex Info, rule to format @pindex texi2dvi @pindex makeinfo @pindex .texinfo @pindex .info @pindex .texi @pindex .txinfo @file{@var{n}.dvi} is made from @file{@var{n}.texinfo}, @file{@var{n}.texi}, or @file{@var{n}.txinfo}, with the @samp{$(TEXI2DVI)} command. @file{@var{n}.info} is made from @file{@var{n}.texinfo}, @file{@var{n}.texi}, or @file{@var{n}.txinfo}, with the @samp{$(MAKEINFO)} command.@refill @item RCS @cindex RCS, rule to extract from @pindex co @pindex ,v @r{(RCS file extension)} Any file @file{@var{n}} is extracted if necessary from an RCS file named either @file{@var{n},v} or @file{RCS/@var{n},v}. The precise command used is @w{@samp{$(CO) $(COFLAGS)}}. @file{@var{n}} will not be extracted from RCS if it already exists, even if the RCS file is newer. The rules for RCS are terminal (@pxref{Match-Anything Rules, ,Match-Anything Pattern Rules}), so RCS files cannot be generated from another source; they must actually exist.@refill @item SCCS @cindex SCCS, rule to extract from @pindex get @pindex s. @r{(SCCS file prefix)} Any file @file{@var{n}} is extracted if necessary from an SCCS file named either @file{s.@var{n}} or @file{SCCS/s.@var{n}}. The precise command used is @w{@samp{$(GET) $(GFLAGS)}}. The rules for SCCS are terminal (@pxref{Match-Anything Rules, ,Match-Anything Pattern Rules}), so SCCS files cannot be generated from another source; they must actually exist.@refill @pindex .sh For the benefit of SCCS, a file @file{@var{n}} is copied from @file{@var{n}.sh} and made executable (by everyone). This is for shell scripts that are checked into SCCS. Since RCS preserves the execution permission of a file, you do not need to use this feature with RCS.@refill We recommend that you avoid using of SCCS. RCS is widely held to be superior, and is also free. By choosing free software in place of comparable (or inferior) proprietary software, you support the free software movement. @end table Usually, you want to change only the variables listed in the table above, which are documented in the following section. However, the commands in built-in implicit rules actually use variables such as @code{COMPILE.c}, @code{LINK.p}, and @code{PREPROCESS.S}, whose values contain the commands listed above. @code{make} follows the convention that the rule to compile a @file{.@var{x}} source file uses the variable @code{COMPILE.@var{x}}. Similarly, the rule to produce an executable from a @file{.@var{x}} file uses @code{LINK.@var{x}}; and the rule to preprocess a @file{.@var{x}} file uses @code{PREPROCESS.@var{x}}. @vindex OUTPUT_OPTION Every rule that produces an object file uses the variable @code{OUTPUT_OPTION}. @code{make} defines this variable either to contain @samp{-o $@@}, or to be empty, depending on a compile-time option. You need the @samp{-o} option to ensure that the output goes into the right file when the source file is in a different directory, as when using @code{VPATH} (@pxref{Directory Search}). However, compilers on some systems do not accept a @samp{-o} switch for object files. If you use such a system, and use @code{VPATH}, some compilations will put their output in the wrong place. A possible workaround for this problem is to give @code{OUTPUT_OPTION} the value @w{@samp{; mv $*.o $@@}}. @node Implicit Variables, Chained Rules, Catalogue of Rules, Implicit Rules @section Variables Used by Implicit Rules @cindex flags for compilers The commands in built-in implicit rules make liberal use of certain predefined variables. You can alter these variables in the makefile, with arguments to @code{make}, or in the environment to alter how the implicit rules work without redefining the rules themselves. For example, the command used to compile a C source file actually says @samp{$(CC) -c $(CFLAGS) $(CPPFLAGS)}. The default values of the variables used are @samp{cc} and nothing, resulting in the command @samp{cc -c}. By redefining @samp{CC} to @samp{ncc}, you could cause @samp{ncc} to be used for all C compilations performed by the implicit rule. By redefining @samp{CFLAGS} to be @samp{-g}, you could pass the @samp{-g} option to each compilation. @emph{All} implicit rules that do C compilation use @samp{$(CC)} to get the program name for the compiler and @emph{all} include @samp{$(CFLAGS)} among the arguments given to the compiler.@refill The variables used in implicit rules fall into two classes: those that are names of programs (like @code{CC}) and those that contain arguments for the programs (like @code{CFLAGS}). (The ``name of a program'' may also contain some command arguments, but it must start with an actual executable program name.) If a variable value contains more than one argument, separate them with spaces. Here is a table of variables used as names of programs in built-in rules: @table @code @item AR @vindex AR Archive-maintaining program; default @samp{ar}. @pindex ar @item AS @vindex AS Program for doing assembly; default @samp{as}. @pindex as @item CC @vindex CC Program for compiling C programs; default @samp{cc}. @pindex cc @item CXX @vindex CXX Program for compiling C++ programs; default @samp{g++}. @pindex g++ @item CO @vindex CO Program for extracting a file from RCS; default @samp{co}. @pindex co @item CPP @vindex CPP Program for running the C preprocessor, with results to standard output; default @samp{$(CC) -E}. @item FC @vindex FC Program for compiling or preprocessing Fortran and Ratfor programs; default @samp{f77}. @pindex f77 @item GET @vindex GET Program for extracting a file from SCCS; default @samp{get}. @pindex get @item LEX @vindex LEX Program to use to turn Lex grammars into C programs or Ratfor programs; default @samp{lex}. @pindex lex @item PC @vindex PC Program for compiling Pascal programs; default @samp{pc}. @pindex pc @item YACC @vindex YACC Program to use to turn Yacc grammars into C programs; default @samp{yacc}. @pindex yacc @item YACCR @vindex YACCR Program to use to turn Yacc grammars into Ratfor programs; default @samp{yacc -r}. @item MAKEINFO @vindex MAKEINFO Program to convert a Texinfo source file into an Info file; default @samp{makeinfo}. @pindex makeinfo @item TEX @vindex TEX Program to make @TeX{} @sc{dvi} files from @TeX{} source; default @samp{tex}. @pindex tex @item TEXI2DVI @vindex TEXI2DVI Program to make @TeX{} @sc{dvi} files from Texinfo source; default @samp{texi2dvi}. @pindex texi2dvi @item WEAVE @vindex WEAVE Program to translate Web into @TeX{}; default @samp{weave}. @pindex weave @item CWEAVE @vindex CWEAVE Program to translate C Web into @TeX{}; default @samp{cweave}. @pindex cweave @item TANGLE @vindex TANGLE Program to translate Web into Pascal; default @samp{tangle}. @pindex tangle @item CTANGLE @vindex CTANGLE Program to translate C Web into C; default @samp{ctangle}. @pindex ctangle @item RM @vindex RM Command to remove a file; default @samp{rm -f}. @pindex rm @end table Here is a table of variables whose values are additional arguments for the programs above. The default values for all of these is the empty string, unless otherwise noted. @table @code @item ARFLAGS @vindex ARFLAGS Flags to give the archive-maintaining program; default @samp{rv}. @item ASFLAGS @vindex ASFLAGS Extra flags to give to the assembler (when explicitly invoked on a @samp{.s} or @samp{.S} file). @item CFLAGS @vindex CFLAGS Extra flags to give to the C compiler. @item CXXFLAGS @vindex CXXFLAGS Extra flags to give to the C++ compiler. @item COFLAGS @vindex COFLAGS Extra flags to give to the RCS @code{co} program. @item CPPFLAGS @vindex CPPFLAGS Extra flags to give to the C preprocessor and programs that use it (the C and Fortran compilers). @item FFLAGS @vindex FFLAGS Extra flags to give to the Fortran compiler. @item GFLAGS @vindex GFLAGS Extra flags to give to the SCCS @code{get} program. @item LDFLAGS @vindex LDFLAGS Extra flags to give to compilers when they are supposed to invoke the linker, @samp{ld}. @item LFLAGS @vindex LFLAGS Extra flags to give to Lex. @item PFLAGS @vindex PFLAGS Extra flags to give to the Pascal compiler. @item RFLAGS @vindex RFLAGS Extra flags to give to the Fortran compiler for Ratfor programs. @item YFLAGS @vindex YFLAGS Extra flags to give to Yacc. @end table @node Chained Rules, Pattern Rules, Implicit Variables, Implicit Rules @section Chains of Implicit Rules @cindex chains of rules @cindex rule, implicit, chains of Sometimes a file can be made by a sequence of implicit rules. For example, a file @file{@var{n}.o} could be made from @file{@var{n}.y} by running first Yacc and then @code{cc}. Such a sequence is called a @dfn{chain}. If the file @file{@var{n}.c} exists, or is mentioned in the makefile, no special searching is required: @code{make} finds that the object file can be made by C compilation from @file{@var{n}.c}; later on, when considering how to make @file{@var{n}.c}, the rule for running Yacc is used. Ultimately both @file{@var{n}.c} and @file{@var{n}.o} are updated.@refill @cindex intermediate files @cindex files, intermediate However, even if @file{@var{n}.c} does not exist and is not mentioned, @code{make} knows how to envision it as the missing link between @file{@var{n}.o} and @file{@var{n}.y}! In this case, @file{@var{n}.c} is called an @dfn{intermediate file}. Once @code{make} has decided to use the intermediate file, it is entered in the data base as if it had been mentioned in the makefile, along with the implicit rule that says how to create it.@refill Intermediate files are remade using their rules just like all other files. The difference is that the intermediate file is deleted when @code{make} is finished. Therefore, the intermediate file which did not exist before @code{make} also does not exist after @code{make}. The deletion is reported to you by printing a @samp{rm -f} command that shows what @code{make} is doing. (You can list the target pattern of an implicit rule (such as @samp{%.o}) as a dependency of the special target @code{.PRECIOUS} to preserve intermediate files made by implicit rules whose target patterns match that file's name; see @ref{Interrupts}.)@refill @cindex intermediate files, preserving @cindex preserving intermediate files @cindex preserving with @code{.PRECIOUS} @cindex @code{.PRECIOUS} intermediate files A chain can involve more than two implicit rules. For example, it is possible to make a file @file{foo} from @file{RCS/foo.y,v} by running RCS, Yacc and @code{cc}. Then both @file{foo.y} and @file{foo.c} are intermediate files that are deleted at the end.@refill No single implicit rule can appear more than once in a chain. This means that @code{make} will not even consider such a ridiculous thing as making @file{foo} from @file{foo.o.o} by running the linker twice. This constraint has the added benefit of preventing any infinite loop in the search for an implicit rule chain. There are some special implicit rules to optimize certain cases that would otherwise be handled by rule chains. For example, making @file{foo} from @file{foo.c} could be handled by compiling and linking with separate chained rules, using @file{foo.o} as an intermediate file. But what actually happens is that a special rule for this case does the compilation and linking with a single @code{cc} command. The optimized rule is used in preference to the step-by-step chain because it comes earlier in the ordering of rules. @node Pattern Rules, Last Resort, Chained Rules, Implicit Rules @section Defining and Redefining Pattern Rules You define an implicit rule by writing a @dfn{pattern rule}. A pattern rule looks like an ordinary rule, except that its target contains the character @samp{%} (exactly one of them). The target is considered a pattern for matching file names; the @samp{%} can match any nonempty substring, while other characters match only themselves. The dependencies likewise use @samp{%} to show how their names relate to the target name. Thus, a pattern rule @samp{%.o : %.c} says how to make any file @file{@var{stem}.o} from another file @file{@var{stem}.c}.@refill Note that expansion using @samp{%} in pattern rules occurs @strong{after} any variable or function expansions, which take place when the makefile is read. @xref{Using Variables, , How to Use Variables}, and @ref{Functions, ,Functions for Transforming Text}. @menu * Pattern Intro:: An introduction to pattern rules. * Pattern Examples:: Examples of pattern rules. * Automatic:: How to use automatic variables in the commands of implicit rules. * Pattern Match:: How patterns match. * Match-Anything Rules:: Precautions you should take prior to defining rules that can match any target file whatever. * Canceling Rules:: How to override or cancel built-in rules. @end menu @node Pattern Intro, Pattern Examples, , Pattern Rules @subsection Introduction to Pattern Rules @cindex pattern rule @cindex rule, pattern A pattern rule contains the character @samp{%} (exactly one of them) in the target; otherwise, it looks exactly like an ordinary rule. The target is a pattern for matching file names; the @samp{%} matches any nonempty substring, while other characters match only themselves. @cindex target pattern, implicit @cindex @code{%}, in pattern rules For example, @samp{%.c} as a pattern matches any file name that ends in @samp{.c}. @samp{s.%.c} as a pattern matches any file name that starts with @samp{s.}, ends in @samp{.c} and is at least five characters long. (There must be at least one character to match the @samp{%}.) The substring that the @samp{%} matches is called the @dfn{stem}.@refill @samp{%} in a dependency of a pattern rule stands for the same stem that was matched by the @samp{%} in the target. In order for the pattern rule to apply, its target pattern must match the file name under consideration, and its dependency patterns must name files that exist or can be made. These files become dependencies of the target. @cindex dependency pattern, implicit Thus, a rule of the form @example %.o : %.c ; @var{command}@dots{} @end example @noindent specifies how to make a file @file{@var{n}.o}, with another file @file{@var{n}.c} as its dependency, provided that @file{@var{n}.c} exists or can be made. There may also be dependencies that do not use @samp{%}; such a dependency attaches to every file made by this pattern rule. These unvarying dependencies are useful occasionally. A pattern rule need not have any dependencies that contain @samp{%}, or in fact any dependencies at all. Such a rule is effectively a general wildcard. It provides a way to make any file that matches the target pattern. @xref{Last Resort}. @c !!! The end of of this paragraph should be rewritten. --bob Pattern rules may have more than one target. Unlike normal rules, this does not act as many different rules with the same dependencies and commands. If a pattern rule has multiple targets, @code{make} knows that the rule's commands are responsible for making all of the targets. The commands are executed only once to make all the targets. When searching for a pattern rule to match a target, the target patterns of a rule other than the one that matches the target in need of a rule are incidental: @code{make} worries only about giving commands and dependencies to the file presently in question. However, when this file's commands are run, the other targets are marked as having been updated themselves. @cindex multiple targets, in pattern rule @cindex target, multiple in pattern rule The order in which pattern rules appear in the makefile is important since this is the order in which they are considered. Of equally applicable rules, only the first one found is used. The rules you write take precedence over those that are built in. Note however, that a rule whose dependencies actually exist or are mentioned always takes priority over a rule with dependencies that must be made by chaining other implicit rules. @cindex pattern rules, order of @cindex order of pattern rules @node Pattern Examples, Automatic, Pattern Intro, Pattern Rules @subsection Pattern Rule Examples Here are some examples of pattern rules actually predefined in @code{make}. First, the rule that compiles @samp{.c} files into @samp{.o} files:@refill @example %.o : %.c $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@@ @end example @noindent defines a rule that can make any file @file{@var{x}.o} from @file{@var{x}.c}. The command uses the automatic variables @samp{$@@} and @samp{$<} to substitute the names of the target file and the source file in each case where the rule applies (@pxref{Automatic, ,Automatic Variables}).@refill Here is a second built-in rule: @example % :: RCS/%,v $(CO) $(COFLAGS) $< @end example @noindent defines a rule that can make any file @file{@var{x}} whatsoever from a corresponding file @file{@var{x},v} in the subdirectory @file{RCS}. Since the target is @samp{%}, this rule will apply to any file whatever, provided the appropriate dependency file exists. The double colon makes the rule @dfn{terminal}, which means that its dependency may not be an intermediate file (@pxref{Match-Anything Rules, ,Match-Anything Pattern Rules}).@refill @need 500 This pattern rule has two targets: @example @group %.tab.c %.tab.h: %.y bison -d $< @end group @end example @noindent @c The following paragraph is rewritten to avoid overfull hboxes This tells @code{make} that the command @samp{bison -d @var{x}.y} will make both @file{@var{x}.tab.c} and @file{@var{x}.tab.h}. If the file @file{foo} depends on the files @file{parse.tab.o} and @file{scan.o} and the file @file{scan.o} depends on the file @file{parse.tab.h}, when @file{parse.y} is changed, the command @samp{bison -d parse.y} will be executed only once, and the dependencies of both @file{parse.tab.o} and @file{scan.o} will be satisfied. (Presumably the file @file{parse.tab.o} will be recompiled from @file{parse.tab.c} and the file @file{scan.o} from @file{scan.c}, while @file{foo} is linked from @file{parse.tab.o}, @file{scan.o}, and its other dependencies, and it will execute happily ever after.)@refill @node Automatic, Pattern Match, Pattern Examples, Pattern Rules @subsection Automatic Variables @cindex automatic variables @cindex variables, automatic @cindex variables, and implicit rule Suppose you are writing a pattern rule to compile a @samp{.c} file into a @samp{.o} file: how do you write the @samp{cc} command so that it operates on the right source file name? You cannot write the name in the command, because the name is different each time the implicit rule is applied. What you do is use a special feature of @code{make}, the @dfn{automatic variables}. These variables have values computed afresh for each rule that is executed, based on the target and dependencies of the rule. In this example, you would use @samp{$@@} for the object file name and @samp{$<} for the source file name. Here is a table of automatic variables: @table @code @vindex $@@ @vindex @@ @r{(automatic variable)} @item $@@ The file name of the target of the rule. If the target is an archive member, then @samp{$@@} is the name of the archive file. In a pattern rule that has multiple targets (@pxref{Pattern Intro, ,Introduction to Pattern Rules}), @samp{$@@} is the name of whichever target caused the rule's commands to be run. @vindex $% @vindex % @r{(automatic variable)} @item $% The target member name, when the target is an archive member. @xref{Archives}. For example, if the target is @file{foo.a(bar.o)} then @samp{$%} is @file{bar.o} and @samp{$@@} is @file{foo.a}. @samp{$%} is empty when the target is not an archive member. @vindex $< @vindex < @r{(automatic variable)} @item $< The name of the first dependency. If the target got its commands from an implicit rule, this will be the first dependency added by the implicit rule (@pxref{Implicit Rules}). @vindex $? @vindex ? @r{(automatic variable)} @item $? The names of all the dependencies that are newer than the target, with spaces between them. For dependencies which are archive members, only the member named is used (@pxref{Archives}). @cindex dependencies, list of changed @cindex list of changed dependencies @vindex $^ @vindex ^ @r{(automatic variable)} @item $^ The names of all the dependencies, with spaces between them. For dependencies which are archive members, only the member named is used (@pxref{Archives}). @cindex dependencies, list of all @cindex list of all dependencies @vindex $* @vindex * @r{(automatic variable)} @item $* The stem with which an implicit rule matches (@pxref{Pattern Match, ,How Patterns Match}). If the target is @file{dir/a.foo.b} and the target pattern is @file{a.%.b} then the stem is @file{dir/foo}. The stem is useful for constructing names of related files.@refill @cindex stem, variable for In a static pattern rule, the stem is part of the file name that matched the @samp{%} in the target pattern. In an explicit rule, there is no stem; so @samp{$*} cannot be determined in that way. Instead, if the target name ends with a recognized suffix (@pxref{Suffix Rules, ,Old-Fashioned Suffix Rules}), @samp{$*} is set to the target name minus the suffix. For example, if the target name is @samp{foo.c}, then @samp{$*} is set to @samp{foo}, since @samp{.c} is a suffix. GNU @code{make} does this bizarre thing only for compatibility with other implementations of @code{make}. You should generally avoid using @samp{$*} except in implicit rules or static pattern rules.@refill If the target name in an explicit rule does not end with a recognized suffix, @samp{$*} is set to the empty string for that rule. @end table @samp{$?} is useful even in explicit rules when you wish to operate on only the dependencies that have changed. For example, suppose that an archive named @file{lib} is supposed to contain copies of several object files. This rule copies just the changed object files into the archive: @example @group lib: foo.o bar.o lose.o win.o ar r lib $? @end group @end example Of the variables listed above, four have values that are single file names, and two have values that are lists of file names. These six have variants that get just the file's directory name or just the file name within the directory. The variant variables' names are formed by appending @samp{D} or @samp{F}, respectively. These variants are semi-obsolete in GNU @code{make} since the functions @code{dir} and @code{notdir} can be used to get an equivalent effect (@pxref{Filename Functions, , Functions for File Names}). Here is a table of the variants:@refill @table @samp @vindex $(@@D) @vindex @@D @r{(automatic variable)} @item $(@@D) The directory part of the file name of the target. If the value of @samp{$@@} is @file{dir/foo.o} then @samp{$(@@D)} is @file{dir/}. This value is @file{./} if @samp{$@@} does not contain a slash. @samp{$(@@D)} is equivalent to @w{@samp{$(dir $@@)}}.@refill @vindex $(@@F) @vindex @@F @r{(automatic variable)} @item $(@@F) The file-within-directory part of the file name of the target. If the value of @samp{$@@} is @file{dir/foo.o} then @samp{$(@@F)} is @file{foo.o}. @samp{$(@@F)} is equivalent to @samp{$(notdir $@@)}. @vindex $(*D) @vindex *D @r{(automatic variable)} @item $(*D) @vindex $(*F) @vindex *F @r{(automatic variable)} @itemx $(*F) The directory part and the file-within-directory part of the stem; @file{dir/} and @file{foo} in this example. @vindex $(%D) @vindex %D @r{(automatic variable)} @item $(%D) @vindex $(%F) @vindex %F @r{(automatic variable)} @itemx $(%F) The directory part and the file-within-directory part of the target archive member name. This makes sense only for archive member targets of the form @file{@var{archive}(@var{member})} and is useful only when @var{member} may contain a directory name. (@xref{Archive Members, ,Archive Members as Targets}.) @vindex $( tar-`sed -e '/version_string/!d' \ -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \ -e q version.c`.shar.Z @end group @group dist: $(SRCS) $(AUX) echo tar-`sed \ -e '/version_string/!d' \ -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \ -e q version.c` > .fname -rm -rf `cat .fname` mkdir `cat .fname` ln $(SRCS) $(AUX) `cat .fname` -rm -rf `cat .fname` .fname tar chZf `cat .fname`.tar.Z `cat .fname` @end group @group tar.zoo: $(SRCS) $(AUX) -rm -rf tmp.dir -mkdir tmp.dir -rm tar.zoo for X in $(SRCS) $(AUX) ; do \ echo $$X ; \ sed 's/$$/^M/' $$X \ > tmp.dir/$$X ; done cd tmp.dir ; zoo aM ../tar.zoo * -rm -rf tmp.dir @end group @end example @node Concept Index, Name Index, Complex Makefile, Top @unnumbered Index of Concepts @printindex cp @node Name Index, , Concept Index, Top @unnumbered Index of Functions, Variables, & Directives @printindex fn @summarycontents @contents @bye make-3.70/make-stds.texi 777 12120 12 47721 5432524602 10267 @comment This file is included by both standards.texi and make.texinfo. @comment It was broken out of standards.texi on 1/6/93 by roland. @node Makefile Conventions @chapter Makefile Conventions @comment standards.texi does not print an index, but make.texinfo does. @cindex makefile, conventions for @cindex conventions for makefiles @cindex standards for makefiles This chapter describes conventions for writing the Makefiles for GNU programs. @menu * Makefile Basics:: * Utilities in Makefiles:: * Standard Targets:: * Command Variables:: * Directory Variables:: @end menu @node Makefile Basics @section General Conventions for Makefiles Every Makefile should contain this line: @example SHELL = /bin/sh @end example @noindent to avoid trouble on systems where the @code{SHELL} variable might be inherited from the environment. (This is never a problem with GNU @code{make}.) Don't assume that @file{.} is in the path for command execution. When you need to run programs that are a part of your package during the make, please make sure that it uses @file{./} if the program is built as part of the make or @file{$(srcdir)/} if the file is an unchanging part of the source code. Without one of these prefixes, the current search path is used. The distinction between @file{./} and @file{$(srcdir)/} is important when using the @samp{--srcdir} option to @file{configure}. A rule of the form: @smallexample foo.1 : foo.man sedscript sed -e sedscript foo.man > foo.1 @end smallexample @noindent will fail when the current directory is not the source directory, because @file{foo.man} and @file{sedscript} are not in the current directory. When using GNU @code{make}, relying on @samp{VPATH} to find the source file will work in the case where there is a single dependency file, since the @file{make} automatic variable @samp{$<} will represent the source file wherever it is. (Many versions of @code{make} set @samp{$<} only in implicit rules.) A makefile target like @smallexample foo.o : bar.c $(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o @end smallexample @noindent should instead be written as @smallexample foo.o : bar.c $(CC) $(CFLAGS) $< -o $@@ @end smallexample @noindent in order to allow @samp{VPATH} to work correctly. When the target has multiple dependencies, using an explicit @samp{$(srcdir)} is the easiest way to make the rule work well. For example, the target above for @file{foo.1} is best written as: @smallexample foo.1 : foo.man sedscript sed -s $(srcdir)/sedscript $(srcdir)/foo.man > foo.1 @end smallexample @node Utilities in Makefiles @section Utilities in Makefiles Write the Makefile commands (and any shell scripts, such as @code{configure}) to run in @code{sh}, not in @code{csh}. Don't use any special features of @code{ksh} or @code{bash}. The @code{configure} script and the Makefile rules for building and installation should not use any utilities directly except these: @example cat cmp cp echo egrep expr grep ln mkdir mv pwd rm rmdir sed test touch @end example Stick to the generally supported options for these programs. For example, don't use @samp{mkdir -p}, convenient as it may be, because most systems don't support it. The Makefile rules for building and installation can also use compilers and related programs, but should do so via @code{make} variables so that the user can substitute alternatives. Here are some of the programs we mean: @example ar bison cc flex install ld lex make makeinfo ranlib texi2dvi yacc @end example When you use @code{ranlib}, you should test whether it exists, and run it only if it exists, so that the distribution will work on systems that don't have @code{ranlib}. If you use symbolic links, you should implement a fallback for systems that don't have symbolic links. It is ok to use other utilities in Makefile portions (or scripts) intended only for particular systems where you know those utilities to exist. @node Standard Targets @section Standard Targets for Users All GNU programs should have the following targets in their Makefiles: @table @samp @item all Compile the entire program. This should be the default target. This target need not rebuild any documentation files; Info files should normally be included in the distribution, and DVI files should be made only when explicitly asked for. @item install Compile the program and copy the executables, libraries, and so on to the file names where they should reside for actual use. If there is a simple test to verify that a program is properly installed, this target should run that test. The commands should create all the directories in which files are to be installed, if they don't already exist. This includes the directories specified as the values of the variables @code{prefix} and @code{exec_prefix}, as well as all subdirectories that are needed. One way to do this is by means of an @code{installdirs} target as described below. Use @samp{-} before any command for installing a man page, so that @code{make} will ignore any errors. This is in case there are systems that don't have the Unix man page documentation system installed. The way to install Info files is to copy them into @file{$(infodir)} with @code{$(INSTALL_DATA)} (@pxref{Command Variables}), and then run the @code{install-info} program if it is present. @code{install-info} is a script that edits the Info @file{dir} file to add or update the menu entry for the given Info file; it will be part of the Texinfo package. Here is a sample rule to install an Info file: @comment This example has been carefully formatted for the Make manual. @comment Please do not reformat it without talking to roland@gnu.ai.mit.edu. @smallexample $(infodir)/foo.info: foo.info # There may be a newer info file in . than in srcdir. -if test -f foo.info; then d=.; \ else d=$(srcdir); fi; \ $(INSTALL_DATA) $$d/foo.info $@@; \ # Run install-info only if it exists. # Use `if' instead of just prepending `-' to the # line so we notice real errors from install-info. # We use `$(SHELL) -c' because some shells do not # fail gracefully when there is an unknown command. if $(SHELL) -c 'install-info --version' \ >/dev/null 2>&1; then \ install-info --infodir=$(infodir) $$d/foo.info; \ else true; fi @end smallexample @item uninstall Delete all the installed files that the @samp{install} target would create (but not the noninstalled files such as @samp{make all} would create). @comment The gratuitous blank line here is to make the table look better @comment in the printed Make manual. Please leave it in. @item clean Delete all files from the current directory that are normally created by building the program. Don't delete the files that record the configuration. Also preserve files that could be made by building, but normally aren't because the distribution comes with them. Delete @file{.dvi} files here if they are not part of the distribution. @item distclean Delete all files from the current directory that are created by configuring or building the program. If you have unpacked the source and built the program without creating any other files, @samp{make distclean} should leave only the files that were in the distribution. @item mostlyclean Like @samp{clean}, but may refrain from deleting a few files that people normally don't want to recompile. For example, the @samp{mostlyclean} target for GCC does not delete @file{libgcc.a}, because recompiling it is rarely necessary and takes a lot of time. @item realclean Delete everything from the current directory that can be reconstructed with this Makefile. This typically includes everything deleted by @code{distclean}, plus more: C source files produced by Bison, tags tables, Info files, and so on. One exception, however: @samp{make realclean} should not delete @file{configure} even if @file{configure} can be remade using a rule in the Makefile. More generally, @samp{make realclean} should not delete anything that needs to exist in order to run @file{configure} and then begin to build the program. @item TAGS Update a tags table for this program. @item info Generate any Info files needed. The best way to write the rules is as follows: @smallexample info: foo.info foo.info: foo.texi chap1.texi chap2.texi $(MAKEINFO) $(srcdir)/foo.texi @end smallexample @noindent You must define the variable @code{MAKEINFO} in the Makefile. It should run the @code{makeinfo} program, which is part of the Texinfo distribution. @item dvi Generate DVI files for all TeXinfo documentation. For example: @smallexample dvi: foo.dvi foo.dvi: foo.texi chap1.texi chap2.texi $(TEXI2DVI) $(srcdir)/foo.texi @end smallexample @noindent You must define the variable @code{TEXI2DVI} in the Makefile. It should run the program @code{texi2dvi}, which is part of the Texinfo distribution. Alternatively, write just the dependencies, and allow GNU Make to provide the command. @item dist Create a distribution tar file for this program. The tar file should be set up so that the file names in the tar file start with a subdirectory name which is the name of the package it is a distribution for. This name can include the version number. For example, the distribution tar file of GCC version 1.40 unpacks into a subdirectory named @file{gcc-1.40}. The easiest way to do this is to create a subdirectory appropriately named, use @code{ln} or @code{cp} to install the proper files in it, and then @code{tar} that subdirectory. The @code{dist} target should explicitly depend on all non-source files that are in the distribution, to make sure they are up to date in the distribution. @xref{Releases, , Making Releases, standards, GNU Coding Standards}. @item check Perform self-tests (if any). The user must build the program before running the tests, but need not install the program; you should write the self-tests so that they work when the program is built but not installed. @end table The following targets are suggested as conventional names, for programs in which they are useful. @table @code @item installcheck Perform installation tests (if any). The user must build and install the program before running the tests. You should not assume that @file{$(bindir)} is in the search path. @item installdirs It's useful to add a target named @samp{installdirs} to create the directories where files are installed, and their parent directories. There is a script called @file{mkinstalldirs} which is convenient for this; find it in the Texinfo package.@c It's in /gd/gnu/lib/mkinstalldirs. You can use a rule like this: @comment This has been carefully formatted to look decent in the Make manual. @comment Please be sure not to make it extend any further to the right.--roland @smallexample # Make sure all installation directories (e.g. $(bindir)) # actually exist by making them if necessary. installdirs: mkinstalldirs $(srcdir)/mkinstalldirs $(bindir) $(datadir) \ $(libdir) $(infodir) \ $(mandir) @end smallexample @end table @node Command Variables @section Variables for Specifying Commands Makefiles should provide variables for overriding certain commands, options, and so on. In particular, you should run most utility programs via variables. Thus, if you use Bison, have a variable named @code{BISON} whose default value is set with @samp{BISON = bison}, and refer to it with @code{$(BISON)} whenever you need to use Bison. File management utilities such as @code{ln}, @code{rm}, @code{mv}, and so on, need not be referred to through variables in this way, since users don't need to replace them with other programs. Each program-name variable should come with an options variable that is used to supply options to the program. Append @samp{FLAGS} to the program-name variable name to get the options variable name---for example, @code{BISONFLAGS}. (The name @code{CFLAGS} is an exception to this rule, but we keep it because it is standard.) Use @code{CPPFLAGS} in any compilation command that runs the preprocessor, and use @code{LDFLAGS} in any compilation command that does linking as well as in any direct use of @code{ld}. If there are C compiler options that @emph{must} be used for proper compilation of certain files, do not include them in @code{CFLAGS}. Users expect to be able to specify @code{CFLAGS} freely themselves. Instead, arrange to pass the necessary options to the C compiler independently of @code{CFLAGS}, by writing them explicitly in the compilation commands or by defining an implicit rule, like this: @smallexample CFLAGS = -g ALL_CFLAGS = -I. $(CFLAGS) .c.o: $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $< @end smallexample Do include the @samp{-g} option in @code{CFLAGS}, because that is not @emph{required} for proper compilation. You can consider it a default that is only recommended. If the package is set up so that it is compiled with GCC by default, then you might as well include @samp{-O} in the default value of @code{CFLAGS} as well. Put @code{CFLAGS} last in the compilation command, after other variables containing compiler options, so the user can use @code{CFLAGS} to override the others. Every Makefile should define the variable @code{INSTALL}, which is the basic command for installing a file into the system. Every Makefile should also define the variables @code{INSTALL_PROGRAM} and @code{INSTALL_DATA}. (The default for each of these should be @code{$(INSTALL)}.) Then it should use those variables as the commands for actual installation, for executables and nonexecutables respectively. Use these variables as follows: @example $(INSTALL_PROGRAM) foo $(bindir)/foo $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a @end example @noindent Always use a file name, not a directory name, as the second argument of the installation commands. Use a separate command for each file to be installed. @node Directory Variables @section Variables for Installation Directories Installation directories should always be named by variables, so it is easy to install in a nonstandard place. The standard names for these variables are: @table @samp @item prefix A prefix used in constructing the default values of the variables listed below. The default value of @code{prefix} should be @file{/usr/local} (at least for now). @item exec_prefix A prefix used in constructing the default values of some of the variables listed below. The default value of @code{exec_prefix} should be @code{$(prefix)}. Generally, @code{$(exec_prefix)} is used for directories that contain machine-specific files (such as executables and subroutine libraries), while @code{$(prefix)} is used directly for other directories. @item bindir The directory for installing executable programs that users can run. This should normally be @file{/usr/local/bin}, but write it as @file{$(exec_prefix)/bin}. @item libdir The directory for installing executable files to be run by the program rather than by users. Object files and libraries of object code should also go in this directory. The idea is that this directory is used for files that pertain to a specific machine architecture, but need not be in the path for commands. The value of @code{libdir} should normally be @file{/usr/local/lib}, but write it as @file{$(exec_prefix)/lib}. @item datadir The directory for installing read-only data files which the programs refer to while they run. This directory is used for files which are independent of the type of machine being used. This should normally be @file{/usr/local/lib}, but write it as @file{$(prefix)/lib}. @item statedir The directory for installing data files which the programs modify while they run. These files should be independent of the type of machine being used, and it should be possible to share them among machines at a network installation. This should normally be @file{/usr/local/lib}, but write it as @file{$(prefix)/lib}. @item includedir @c rewritten to avoid overfull hbox --roland The directory for installing header files to be included by user programs with the C @samp{#include} preprocessor directive. This should normally be @file{/usr/local/include}, but write it as @file{$(prefix)/include}. Most compilers other than GCC do not look for header files in @file{/usr/local/include}. So installing the header files this way is only useful with GCC. Sometimes this is not a problem because some libraries are only really intended to work with GCC. But some libraries are intended to work with other compilers. They should install their header files in two places, one specified by @code{includedir} and one specified by @code{oldincludedir}. @item oldincludedir The directory for installing @samp{#include} header files for use with compilers other than GCC. This should normally be @file{/usr/include}. The Makefile commands should check whether the value of @code{oldincludedir} is empty. If it is, they should not try to use it; they should cancel the second installation of the header files. A package should not replace an existing header in this directory unless the header came from the same package. Thus, if your Foo package provides a header file @file{foo.h}, then it should install the header file in the @code{oldincludedir} directory if either (1) there is no @file{foo.h} there or (2) the @file{foo.h} that exists came from the Foo package. To tell whether @file{foo.h} came from the Foo package, put a magic string in the file---part of a comment---and grep for that string. @item mandir The directory for installing the man pages (if any) for this package. It should include the suffix for the proper section of the manual---usually @samp{1} for a utility. It will normally be @file{/usr/local/man/man1}, but you should write it as @file{$(prefix)/man/man1}. @item man1dir The directory for installing section 1 man pages. @item man2dir The directory for installing section 2 man pages. @item @dots{} Use these names instead of @samp{mandir} if the package needs to install man pages in more than one section of the manual. @strong{Don't make the primary documentation for any GNU software be a man page. Write a manual in Texinfo instead. Man pages are just for the sake of people running GNU software on Unix, which is a secondary application only.} @item manext The file name extension for the installed man page. This should contain a period followed by the appropriate digit; it should normally be @samp{.1}. @item man1ext The file name extension for installed section 1 man pages. @item man2ext The file name extension for installed section 2 man pages. @item @dots{} Use these names instead of @samp{manext} if the package needs to install man pages in more than one section of the manual. @item infodir The directory for installing the Info files for this package. By default, it should be @file{/usr/local/info}, but it should be written as @file{$(prefix)/info}. @item srcdir The directory for the sources being compiled. The value of this variable is normally inserted by the @code{configure} shell script. @end table For example: @smallexample @c I have changed some of the comments here slightly to fix an overfull @c hbox, so the make manual can format correctly. --roland # Common prefix for installation directories. # NOTE: This directory must exist when you start the install. prefix = /usr/local exec_prefix = $(prefix) # Where to put the executable for the command `gcc'. bindir = $(exec_prefix)/bin # Where to put the directories used by the compiler. libdir = $(exec_prefix)/lib # Where to put the Info files. infodir = $(prefix)/info @end smallexample If your program installs a large number of files into one of the standard user-specified directories, it might be useful to group them into a subdirectory particular to that program. If you do this, you should write the @code{install} rule to create these subdirectories. Do not expect the user to include the subdirectory name in the value of any of the variables listed above. The idea of having a uniform set of variable names for installation directories is to enable the user to specify the exact same values for several different GNU packages. In order for this to be useful, all the packages must be designed so that they will work sensibly when the user does so. make-3.70/make.cp 666 12241 12 114612 5504167707 6771 \entry {POSIX}{1}{POSIX} \entry {IEEE Standard 1003.2}{1}{IEEE Standard 1003.2} \entry {standards conformance}{1}{standards conformance} \entry {reporting bugs}{2}{reporting bugs} \entry {bugs, reporting}{2}{bugs, reporting} \entry {problems and bugs, reporting}{2}{problems and bugs, reporting} \entry {makefile}{5}{makefile} \entry {recompilation}{5}{recompilation} \entry {editor}{5}{editor} \entry {rule, introduction to}{5}{rule, introduction to} \entry {makefile rule parts}{5}{makefile rule parts} \entry {parts of makefile rule}{5}{parts of makefile rule} \entry {targets, introduction to}{5}{targets, introduction to} \entry {dependencies, introduction to}{5}{dependencies, introduction to} \entry {commands, introduction to}{5}{commands, introduction to} \entry {tabs in rules}{5}{tabs in rules} \entry {simple makefile}{6}{simple makefile} \entry {makefile, simple}{6}{makefile, simple} \entry {continuation lines}{7}{continuation lines} \entry {{\tt\indexbackslash } (backslash), for continuation lines}{7}{\code {{\tt\indexbackslash }} (backslash), for continuation lines} \entry {backslash ({\tt\indexbackslash }), for continuation lines}{7}{backslash (\code {{\tt\indexbackslash }}), for continuation lines} \entry {quoting newline, in makefile}{7}{quoting newline, in makefile} \entry {newline, quoting, in makefile}{7}{newline, quoting, in makefile} \entry {shell command}{8}{shell command} \entry {clean target}{8}{\code {clean} target} \entry {rm (shell command)}{8}{\code {rm} (shell command)} \entry {processing a makefile}{8}{processing a makefile} \entry {makefile, how make processes}{8}{makefile, how \code {make} processes} \entry {default goal}{8}{default goal} \entry {goal, default}{8}{goal, default} \entry {goal}{8}{goal} \entry {relinking}{9}{relinking} \entry {variables}{9}{variables} \entry {simplifying with variables}{9}{simplifying with variables} \entry {objects}{9}{\code {objects}} \entry {OBJECTS}{9}{\code {OBJECTS}} \entry {objs}{9}{\code {objs}} \entry {OBJS}{9}{\code {OBJS}} \entry {obj}{9}{\code {obj}} \entry {OBJ}{9}{\code {OBJ}} \entry {deducing commands (implicit rules)}{10}{deducing commands (implicit rules)} \entry {implicit rule, introduction to}{10}{implicit rule, introduction to} \entry {rule, implicit, introduction to}{10}{rule, implicit, introduction to} \entry {combining rules by dependency}{12}{combining rules by dependency} \entry {cleaning up}{12}{cleaning up} \entry {removing, to clean up}{12}{removing, to clean up} \entry {clean target}{12}{\code {clean} target} \entry {makefile, how to write}{15}{makefile, how to write} \entry {rule, explicit, definition of}{15}{rule, explicit, definition of} \entry {explicit rule, definition of}{15}{explicit rule, definition of} \entry {rule, implicit, definition of}{15}{rule, implicit, definition of} \entry {implicit rule, definition of}{15}{implicit rule, definition of} \entry {variable definition}{15}{variable definition} \entry {directive}{15}{directive} \entry {comments, in makefile}{15}{comments, in makefile} \entry {# (comments), in makefile}{15}{\code {#} (comments), in makefile} \entry {makefile name}{16}{makefile name} \entry {name of makefile}{16}{name of makefile} \entry {default makefile name}{16}{default makefile name} \entry {file name of makefile}{16}{file name of makefile} \entry {README}{16}{\code {README}} \entry {-f}{16}{\code {-f}} \entry {--file}{16}{\code {--file}} \entry {--makefile}{16}{\code {--makefile}} \entry {specifying makefile name}{16}{specifying makefile name} \entry {makefile name, how to specify}{16}{makefile name, how to specify} \entry {name of makefile, how to specify}{16}{name of makefile, how to specify} \entry {file name of makefile, how to specify}{16}{file name of makefile, how to specify} \entry {including other makefiles}{16}{including other makefiles} \entry {makefile, including}{16}{makefile, including} \entry {shell file name pattern (in include)}{16}{shell file name pattern (in \code {include})} \entry {shell wildcards (in include)}{16}{shell wildcards (in \code {include})} \entry {wildcard, in include}{16}{wildcard, in \code {include}} \entry {dependencies, automatic generation}{17}{dependencies, automatic generation} \entry {automatic generation of dependencies}{17}{automatic generation of dependencies} \entry {generating dependencies automatically}{17}{generating dependencies automatically} \entry {-I}{17}{\code {-I}} \entry {--include-dir}{17}{\code {--include-dir}} \entry {makefile, and MAKEFILES variable}{18}{makefile, and \code {MAKEFILES} variable} \entry {including (MAKEFILES variable)}{18}{including (\code {MAKEFILES} variable)} \entry {recursion, and MAKEFILES variable}{18}{recursion, and \code {MAKEFILES} variable} \entry {updating makefiles}{18}{updating makefiles} \entry {remaking makefiles}{18}{remaking makefiles} \entry {makefile, remaking of}{18}{makefile, remaking of} \entry {overriding makefiles}{20}{overriding makefiles} \entry {makefile, overriding}{20}{makefile, overriding} \entry {.DEFAULT, used to override}{20}{\code {.DEFAULT}, used to override} \entry {writing rules}{21}{writing rules} \entry {rule, how to write}{21}{rule, how to write} \entry {target}{21}{target} \entry {dependency}{21}{dependency} \entry {default goal}{21}{default goal} \entry {goal, default}{21}{goal, default} \entry {rule syntax}{21}{rule syntax} \entry {syntax of rules}{21}{syntax of rules} \entry {targets}{21}{targets} \entry {rule targets}{21}{rule targets} \entry {commands}{21}{commands} \entry {tab character (in commands)}{21}{tab character (in commands)} \entry {dollar sign ($), in rules}{22}{dollar sign (\code {$}), in rules} \entry {$, in rules}{22}{\code {$}, in rules} \entry {rule, and $}{22}{rule, and \code {$}} \entry {dependencies}{22}{dependencies} \entry {rule dependencies}{22}{rule dependencies} \entry {wildcard}{22}{wildcard} \entry {file name with wildcards}{22}{file name with wildcards} \entry {globbing (wildcards)}{22}{globbing (wildcards)} \entry {* (wildcard character)}{22}{\code {*} (wildcard character)} \entry {? (wildcard character)}{22}{\code {?} (wildcard character)} \entry {[...{}] (wildcard characters)}{22}{\code {[\dots {}]} (wildcard characters)} \entry {{\tt\char'176} (tilde)}{22}{\code {{\tt\char'176}} (tilde)} \entry {tilde ({\tt\char'176})}{22}{tilde (\code {{\tt\char'176}})} \entry {home directory}{22}{home directory} \entry {rm (shell command)}{23}{\code {rm} (shell command)} \entry {print target}{23}{\code {print} target} \entry {lpr (shell command)}{23}{\code {lpr} (shell command)} \entry {touch (shell command)}{23}{\code {touch} (shell command)} \entry {wildcard pitfalls}{24}{wildcard pitfalls} \entry {pitfalls of wildcards}{24}{pitfalls of wildcards} \entry {mistakes with wildcards}{24}{mistakes with wildcards} \entry {errors with wildcards}{24}{errors with wildcards} \entry {problems with wildcards}{24}{problems with wildcards} \entry {vpath}{25}{vpath} \entry {search path for dependencies (VPATH)}{25}{search path for dependencies (\code {VPATH})} \entry {directory search (VPATH)}{25}{directory search (\code {VPATH})} \entry {%, quoting in vpath}{27}{\code {%}, quoting in \code {vpath}} \entry {%, quoting with {\tt\indexbackslash } (backslash)}{27}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)} \entry {{\tt\indexbackslash } (backslash), to quote %}{27}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}} \entry {backslash ({\tt\indexbackslash }), to quote %}{27}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}} \entry {quoting %, in vpath}{27}{quoting \code {%}, in \code {vpath}} \entry {shell command, and directory search}{28}{shell command, and directory search} \entry {directory search (VPATH), and shell commands}{28}{directory search (\code {VPATH}), and shell commands} \entry {VPATH, and implicit rules}{28}{\code {VPATH}, and implicit rules} \entry {directory search (VPATH), and implicit rules}{28}{directory search (\code {VPATH}), and implicit rules} \entry {search path for dependencies (VPATH), and implicit rules}{28}{search path for dependencies (\code {VPATH}), and implicit rules} \entry {implicit rule, and directory search}{28}{implicit rule, and directory search} \entry {implicit rule, and VPATH}{28}{implicit rule, and \code {VPATH}} \entry {rule, implicit, and directory search}{28}{rule, implicit, and directory search} \entry {rule, implicit, and VPATH}{28}{rule, implicit, and \code {VPATH}} \entry {link libraries, and directory search}{29}{link libraries, and directory search} \entry {libraries for linking, directory search}{29}{libraries for linking, directory search} \entry {directory search (VPATH), and link libraries}{29}{directory search (\code {VPATH}), and link libraries} \entry {VPATH, and link libraries}{29}{\code {VPATH}, and link libraries} \entry {search path for dependencies (VPATH), and link libraries}{29}{search path for dependencies (\code {VPATH}), and link libraries} \entry {-l (library search)}{29}{\code {-l} (library search)} \entry {phony targets}{29}{phony targets} \entry {targets, phony}{29}{targets, phony} \entry {targets without a file}{29}{targets without a file} \entry {rm (shell command)}{30}{\code {rm} (shell command)} \entry {force targets}{31}{force targets} \entry {targets, force}{31}{targets, force} \entry {FORCE}{31}{\code {FORCE}} \entry {rule, no commands or dependencies}{31}{rule, no commands or dependencies} \entry {empty targets}{32}{empty targets} \entry {targets, empty}{32}{targets, empty} \entry {recording events with empty targets}{32}{recording events with empty targets} \entry {print target}{32}{\code {print} target} \entry {lpr (shell command)}{32}{\code {lpr} (shell command)} \entry {touch (shell command)}{32}{\code {touch} (shell command)} \entry {special targets}{32}{special targets} \entry {built-in special targets}{32}{built-in special targets} \entry {targets, built-in special}{32}{targets, built-in special} \entry {precious targets}{33}{precious targets} \entry {preserving with .PRECIOUS}{33}{preserving with \code {.PRECIOUS}} \entry {multiple targets}{34}{multiple targets} \entry {several targets in a rule}{34}{several targets in a rule} \entry {targets, multiple}{34}{targets, multiple} \entry {rule, with multiple targets}{34}{rule, with multiple targets} \entry {multiple rules for one target}{35}{multiple rules for one target} \entry {several rules for one target}{35}{several rules for one target} \entry {rule, multiple for one target}{35}{rule, multiple for one target} \entry {target, multiple rules for one}{35}{target, multiple rules for one} \entry {static pattern rule}{36}{static pattern rule} \entry {rule, static pattern}{36}{rule, static pattern} \entry {pattern rules, static (not implicit)}{36}{pattern rules, static (not implicit)} \entry {varying dependencies}{36}{varying dependencies} \entry {dependencies, varying (static pattern)}{36}{dependencies, varying (static pattern)} \entry {static pattern rule, syntax of}{36}{static pattern rule, syntax of} \entry {pattern rules, static, syntax of}{36}{pattern rules, static, syntax of} \entry {target pattern, static (not implicit)}{36}{target pattern, static (not implicit)} \entry {stem}{36}{stem} \entry {dependency pattern, static (not implicit)}{36}{dependency pattern, static (not implicit)} \entry {%, quoting in static pattern}{37}{\code {%}, quoting in static pattern} \entry {%, quoting with {\tt\indexbackslash } (backslash)}{37}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)} \entry {{\tt\indexbackslash } (backslash), to quote %}{37}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}} \entry {backslash ({\tt\indexbackslash }), to quote %}{37}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}} \entry {quoting %, in static pattern}{37}{quoting \code {%}, in static pattern} \entry {rule, static pattern versus implicit}{38}{rule, static pattern versus implicit} \entry {static pattern rule, versus implicit}{38}{static pattern rule, versus implicit} \entry {double-colon rules}{38}{double-colon rules} \entry {rule, double-colon (::)}{38}{rule, double-colon (\code {::})} \entry {multiple rules for one target (::)}{38}{multiple rules for one target (\code {::})} \entry {:: rules (double-colon)}{38}{\code {::} rules (double-colon)} \entry {dependencies, automatic generation}{39}{dependencies, automatic generation} \entry {automatic generation of dependencies}{39}{automatic generation of dependencies} \entry {generating dependencies automatically}{39}{generating dependencies automatically} \entry {#include}{39}{\code {#include}} \entry {-M (to compiler)}{39}{\code {-M} (to compiler)} \entry {make depend}{40}{\code {make depend}} \entry {-e (shell flag)}{40}{\code {-e} (shell flag)} \entry {sed (shell command)}{40}{\code {sed} (shell command)} \entry {.d}{41}{\code {.d}} \entry {commands, how to write}{43}{commands, how to write} \entry {rule commands}{43}{rule commands} \entry {writing rule commands}{43}{writing rule commands} \entry {comments, in commands}{43}{comments, in commands} \entry {commands, comments in}{43}{commands, comments in} \entry {# (comments), in commands}{43}{\code {#} (comments), in commands} \entry {echoing of commands}{43}{echoing of commands} \entry {silent operation}{43}{silent operation} \entry {{\tt\char'100} (in commands)}{43}{\code {{\tt\char'100}} (in commands)} \entry {commands, echoing}{43}{commands, echoing} \entry {printing of commands}{43}{printing of commands} \entry {-n}{43}{\code {-n}} \entry {--just-print}{43}{\code {--just-print}} \entry {--dry-run}{43}{\code {--dry-run}} \entry {--recon}{43}{\code {--recon}} \entry {-s}{43}{\code {-s}} \entry {--silent}{43}{\code {--silent}} \entry {--quiet}{43}{\code {--quiet}} \entry {commands, execution}{44}{commands, execution} \entry {execution, of commands}{44}{execution, of commands} \entry {shell command, execution}{44}{shell command, execution} \entry {cd (shell command)}{44}{\code {cd} (shell command)} \entry {commands, backslash ({\tt\indexbackslash }) in}{44}{commands, backslash (\code {{\tt\indexbackslash }}) in} \entry {commands, quoting newlines in}{44}{commands, quoting newlines in} \entry {backslash ({\tt\indexbackslash }), in commands}{44}{backslash (\code {{\tt\indexbackslash }}), in commands} \entry {{\tt\indexbackslash } (backslash), in commands}{44}{\code {{\tt\indexbackslash }} (backslash), in commands} \entry {quoting newline, in commands}{44}{quoting newline, in commands} \entry {newline, quoting, in commands}{44}{newline, quoting, in commands} \entry {environment, SHELL in}{44}{environment, \code {SHELL} in} \entry {commands, execution in parallel}{44}{commands, execution in parallel} \entry {parallel execution}{44}{parallel execution} \entry {execution, in parallel}{44}{execution, in parallel} \entry {job slots}{44}{job slots} \entry {-j}{44}{\code {-j}} \entry {--jobs}{44}{\code {--jobs}} \entry {broken pipe}{45}{broken pipe} \entry {standard input}{45}{standard input} \entry {load average}{45}{load average} \entry {limiting jobs based on load}{45}{limiting jobs based on load} \entry {jobs, limiting based on load}{45}{jobs, limiting based on load} \entry {-l (load average)}{45}{\code {-l} (load average)} \entry {--max-load}{45}{\code {--max-load}} \entry {--load-average}{45}{\code {--load-average}} \entry {errors (in commands)}{46}{errors (in commands)} \entry {commands, errors in}{46}{commands, errors in} \entry {exit status (errors)}{46}{exit status (errors)} \entry {- (in commands)}{46}{\code {-} (in commands)} \entry {rm (shell command)}{46}{\code {rm} (shell command)} \entry {-i}{46}{\code {-i}} \entry {--ignore-errors}{46}{\code {--ignore-errors}} \entry {-k}{47}{\code {-k}} \entry {--keep-going}{47}{\code {--keep-going}} \entry {Emacs (M-x compile)}{47}{Emacs (\code {M-x compile})} \entry {interrupt}{47}{interrupt} \entry {signal}{47}{signal} \entry {deletion of target files}{47}{deletion of target files} \entry {target, deleting on interrupt}{47}{target, deleting on interrupt} \entry {killing (interruption)}{47}{killing (interruption)} \entry {recursion}{48}{recursion} \entry {subdirectories, recursion for}{48}{subdirectories, recursion for} \entry {-C}{48}{\code {-C}} \entry {--directory}{48}{\code {--directory}} \entry {recursion, and MAKE variable}{48}{recursion, and \code {MAKE} variable} \entry {cd (shell command)}{48}{\code {cd} (shell command)} \entry {-t, and recursion}{49}{\code {-t}, and recursion} \entry {recursion, and -t}{49}{recursion, and \code {-t}} \entry {--touch, and recursion}{49}{\code {--touch}, and recursion} \entry {sub-make}{49}{sub-\code {make}} \entry {environment, and recursion}{49}{environment, and recursion} \entry {exporting variables}{49}{exporting variables} \entry {variables, environment}{49}{variables, environment} \entry {variables, exporting}{49}{variables, exporting} \entry {recursion, and environment}{49}{recursion, and environment} \entry {recursion, and variables}{49}{recursion, and variables} \entry {compatibility in exporting}{51}{compatibility in exporting} \entry {recursion, level of}{51}{recursion, level of} \entry {options, and recursion}{52}{options, and recursion} \entry {recursion, and options}{52}{recursion, and options} \entry {-C, and recursion}{52}{\code {-C}, and recursion} \entry {-f, and recursion}{52}{\code {-f}, and recursion} \entry {-I, and recursion}{52}{\code {-I}, and recursion} \entry {-o, and recursion}{52}{\code {-o}, and recursion} \entry {-W, and recursion}{52}{\code {-W}, and recursion} \entry {--directory, and recursion}{52}{\code {--directory}, and recursion} \entry {--file, and recursion}{52}{\code {--file}, and recursion} \entry {--include-dir, and recursion}{52}{\code {--include-dir}, and recursion} \entry {--old-file, and recursion}{52}{\code {--old-file}, and recursion} \entry {--assume-old, and recursion}{52}{\code {--assume-old}, and recursion} \entry {--assume-new, and recursion}{52}{\code {--assume-new}, and recursion} \entry {--new-file, and recursion}{52}{\code {--new-file}, and recursion} \entry {recursion, and -C}{52}{recursion, and \code {-C}} \entry {recursion, and -f}{52}{recursion, and \code {-f}} \entry {recursion, and -I}{52}{recursion, and \code {-I}} \entry {recursion, and -o}{52}{recursion, and \code {-o}} \entry {recursion, and -W}{52}{recursion, and \code {-W}} \entry {-j, and recursion}{52}{\code {-j}, and recursion} \entry {--jobs, and recursion}{52}{\code {--jobs}, and recursion} \entry {recursion, and -j}{52}{recursion, and \code {-j}} \entry {job slots, and recursion}{52}{job slots, and recursion} \entry {setting options from environment}{53}{setting options from environment} \entry {options, setting from environment}{53}{options, setting from environment} \entry {setting options in makefiles}{53}{setting options in makefiles} \entry {options, setting in makefiles}{53}{options, setting in makefiles} \entry {directories, printing them}{53}{directories, printing them} \entry {printing directories}{53}{printing directories} \entry {recursion, and printing directories}{53}{recursion, and printing directories} \entry {-C, and -w}{54}{\code {-C}, and \code {-w}} \entry {--directory, and --print-directory}{54}{\code {--directory}, and \code {--print-directory}} \entry {recursion, and -w}{54}{recursion, and \code {-w}} \entry {-w, and -C}{54}{\code {-w}, and \code {-C}} \entry {-w, and recursion}{54}{\code {-w}, and recursion} \entry {--print-directory, and --directory}{54}{\code {--print-directory}, and \code {--directory}} \entry {--print-directory, and recursion}{54}{\code {--print-directory}, and recursion} \entry {--no-print-directory}{54}{\code {--no-print-directory}} \entry {--print-directory, disabling}{54}{\code {--print-directory}, disabling} \entry {-w, disabling}{54}{\code {-w}, disabling} \entry {sequences of commands}{54}{sequences of commands} \entry {commands, sequences of}{54}{commands, sequences of} \entry {yacc}{54}{\code {yacc}} \entry {{\tt\char'100}, and define}{55}{{\tt\char'100}, and \code {define}} \entry {-, and define}{55}{-, and \code {define}} \entry {{\tt\char43}, and define}{55}{{\tt\char43}, and \code {define}} \entry {empty commands}{56}{empty commands} \entry {commands, empty}{56}{commands, empty} \entry {variable}{57}{variable} \entry {value}{57}{value} \entry {recursive variable expansion}{57}{recursive variable expansion} \entry {simple variable expansion}{57}{simple variable expansion} \entry {macro}{57}{macro} \entry {variables, how to reference}{57}{variables, how to reference} \entry {reference to variables}{57}{reference to variables} \entry {$, in variable reference}{57}{\code {$}, in variable reference} \entry {dollar sign ($), in variable reference}{57}{dollar sign (\code {$}), in variable reference} \entry {flavors of variables}{58}{flavors of variables} \entry {recursive variable expansion}{58}{recursive variable expansion} \entry {variables, flavors}{58}{variables, flavors} \entry {recursively expanded variables}{58}{recursively expanded variables} \entry {variables, recursively expanded}{58}{variables, recursively expanded} \entry {=}{58}{=} \entry {loops in variable expansion}{59}{loops in variable expansion} \entry {variables, loops in expansion}{59}{variables, loops in expansion} \entry {simply expanded variables}{59}{simply expanded variables} \entry {variables, simply expanded}{59}{variables, simply expanded} \entry {:=}{59}{:=} \entry {spaces, in variable values}{60}{spaces, in variable values} \entry {whitespace, in variable values}{60}{whitespace, in variable values} \entry {variables, spaces in values}{60}{variables, spaces in values} \entry {reference to variables}{61}{reference to variables} \entry {modified variable reference}{61}{modified variable reference} \entry {substitution variable reference}{61}{substitution variable reference} \entry {variables, modified reference}{61}{variables, modified reference} \entry {variables, substitution reference}{61}{variables, substitution reference} \entry {variables, substituting suffix in}{61}{variables, substituting suffix in} \entry {suffix, substituting in variables}{61}{suffix, substituting in variables} \entry {nested variable reference}{62}{nested variable reference} \entry {computed variable name}{62}{computed variable name} \entry {variables, computed names}{62}{variables, computed names} \entry {variables, nested references}{62}{variables, nested references} \entry {variables, $ in name}{62}{variables, \samp {$} in name} \entry {$, in variable name}{62}{\code {$}, in variable name} \entry {dollar sign ($), in variable name}{62}{dollar sign (\code {$}), in variable name} \entry {variables, how they get their values}{65}{variables, how they get their values} \entry {value, how a variable gets it}{65}{value, how a variable gets it} \entry {setting variables}{66}{setting variables} \entry {variables, setting}{66}{variables, setting} \entry {=}{66}{=} \entry {:=}{66}{:=} \entry {{\tt\char43}=}{66}{{\tt\char43}=} \entry {appending to variables}{66}{appending to variables} \entry {variables, appending to}{66}{variables, appending to} \entry {overriding with override}{68}{overriding with \code {override}} \entry {variables, overriding}{68}{variables, overriding} \entry {verbatim variable definition}{69}{verbatim variable definition} \entry {defining variables verbatim}{69}{defining variables verbatim} \entry {variables, defining verbatim}{69}{variables, defining verbatim} \entry {variables, environment}{70}{variables, environment} \entry {environment}{70}{environment} \entry {conditionals}{73}{conditionals} \entry {functions}{79}{functions} \entry {$, in function call}{79}{\code {$}, in function call} \entry {dollar sign ($), in function call}{79}{dollar sign (\code {$}), in function call} \entry {arguments of functions}{79}{arguments of functions} \entry {functions, syntax of}{79}{functions, syntax of} \entry {functions, for text}{80}{functions, for text} \entry {%, quoting in patsubst}{80}{\code {%}, quoting in \code {patsubst}} \entry {%, quoting with {\tt\indexbackslash } (backslash)}{80}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)} \entry {{\tt\indexbackslash } (backslash), to quote %}{80}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}} \entry {backslash ({\tt\indexbackslash }), to quote %}{80}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}} \entry {quoting %, in patsubst}{80}{quoting \code {%}, in \code {patsubst}} \entry {stripping whitespace}{81}{stripping whitespace} \entry {whitespace, stripping}{81}{whitespace, stripping} \entry {spaces, stripping}{81}{spaces, stripping} \entry {searching for strings}{81}{searching for strings} \entry {finding strings}{81}{finding strings} \entry {strings, searching for}{81}{strings, searching for} \entry {filtering words}{82}{filtering words} \entry {words, filtering}{82}{words, filtering} \entry {filtering out words}{82}{filtering out words} \entry {words, filtering out}{82}{words, filtering out} \entry {sorting words}{82}{sorting words} \entry {removing duplicate words}{82}{removing duplicate words} \entry {duplicate words, removing}{82}{duplicate words, removing} \entry {words, removing duplicates}{82}{words, removing duplicates} \entry {functions, for file names}{83}{functions, for file names} \entry {file name functions}{83}{file name functions} \entry {directory part}{83}{directory part} \entry {file name, directory part}{83}{file name, directory part} \entry {file name, nondirectory part}{83}{file name, nondirectory part} \entry {nondirectory part}{83}{nondirectory part} \entry {suffix, function to find}{84}{suffix, function to find} \entry {file name suffix}{84}{file name suffix} \entry {basename}{84}{basename} \entry {file name, basename of}{84}{file name, basename of} \entry {suffix, adding}{84}{suffix, adding} \entry {file name suffix, adding}{84}{file name suffix, adding} \entry {prefix, adding}{84}{prefix, adding} \entry {file name prefix, adding}{84}{file name prefix, adding} \entry {joining lists of words}{84}{joining lists of words} \entry {words, joining lists}{84}{words, joining lists} \entry {words, selecting}{85}{words, selecting} \entry {selecting words}{85}{selecting words} \entry {words, finding number}{85}{words, finding number} \entry {words, extracting first}{85}{words, extracting first} \entry {wildcard, function}{85}{wildcard, function} \entry {words, iterating over}{85}{words, iterating over} \entry {variables, origin of}{87}{variables, origin of} \entry {origin of variable}{87}{origin of variable} \entry {commands, expansion}{89}{commands, expansion} \entry {backquotes}{89}{backquotes} \entry {shell command, function for}{89}{shell command, function for} \entry {--file}{91}{\code {--file}} \entry {--makefile}{91}{\code {--makefile}} \entry {-f}{91}{\code {-f}} \entry {goal, how to specify}{91}{goal, how to specify} \entry {all (standard target)}{92}{\code {all} \r {(standard target)}} \entry {clean (standard target)}{92}{\code {clean} \r {(standard target)}} \entry {mostlyclean (standard target)}{92}{\code {mostlyclean} \r {(standard target)}} \entry {distclean (standard target)}{93}{\code {distclean} \r {(standard target)}} \entry {realclean (standard target)}{93}{\code {realclean} \r {(standard target)}} \entry {clobber (standard target)}{93}{\code {clobber} \r {(standard target)}} \entry {install (standard target)}{93}{\code {install} \r {(standard target)}} \entry {print (standard target)}{93}{\code {print} \r {(standard target)}} \entry {tar (standard target)}{93}{\code {tar} \r {(standard target)}} \entry {shar (standard target)}{93}{\code {shar} \r {(standard target)}} \entry {dist (standard target)}{93}{\code {dist} \r {(standard target)}} \entry {TAGS (standard target)}{93}{\code {TAGS} \r {(standard target)}} \entry {check (standard target)}{93}{\code {check} \r {(standard target)}} \entry {test (standard target)}{93}{\code {test} \r {(standard target)}} \entry {execution, instead of}{93}{execution, instead of} \entry {commands, instead of executing}{93}{commands, instead of executing} \entry {--just-print}{93}{\code {--just-print}} \entry {--dry-run}{93}{\code {--dry-run}} \entry {--recon}{93}{\code {--recon}} \entry {-n}{93}{\code {-n}} \entry {--touch}{93}{\code {--touch}} \entry {touching files}{93}{touching files} \entry {target, touching}{93}{target, touching} \entry {-t}{93}{\code {-t}} \entry {--question}{94}{\code {--question}} \entry {-q}{94}{\code {-q}} \entry {question mode}{94}{question mode} \entry {--what-if}{94}{\code {--what-if}} \entry {-W}{94}{\code {-W}} \entry {--assume-new}{94}{\code {--assume-new}} \entry {--new-file}{94}{\code {--new-file}} \entry {what if}{94}{what if} \entry {files, assuming new}{94}{files, assuming new} \entry {-o}{95}{\code {-o}} \entry {--old-file}{95}{\code {--old-file}} \entry {--assume-old}{95}{\code {--assume-old}} \entry {files, assuming old}{95}{files, assuming old} \entry {files, avoiding recompilation of}{95}{files, avoiding recompilation of} \entry {recompilation, avoiding}{95}{recompilation, avoiding} \entry {overriding variables with arguments}{95}{overriding variables with arguments} \entry {variables, overriding with arguments}{95}{variables, overriding with arguments} \entry {command line variables}{95}{command line variables} \entry {variables, command line}{95}{variables, command line} \entry {testing compilation}{96}{testing compilation} \entry {compilation, testing}{96}{compilation, testing} \entry {-k}{97}{\code {-k}} \entry {--keep-going}{97}{\code {--keep-going}} \entry {options}{97}{options} \entry {flags}{97}{flags} \entry {switches}{97}{switches} \entry {-b}{97}{\code {-b}} \entry {-m}{97}{\code {-m}} \entry {-C}{97}{\code {-C}} \entry {--directory}{97}{\code {--directory}} \entry {-d}{97}{\code {-d}} \entry {--debug}{97}{\code {--debug}} \entry {-e}{98}{\code {-e}} \entry {--environment-overrides}{98}{\code {--environment-overrides}} \entry {-f}{98}{\code {-f}} \entry {--file}{98}{\code {--file}} \entry {--makefile}{98}{\code {--makefile}} \entry {-h}{98}{\code {-h}} \entry {--help}{98}{\code {--help}} \entry {-i}{98}{\code {-i}} \entry {--ignore-errors}{98}{\code {--ignore-errors}} \entry {-I}{98}{\code {-I}} \entry {--include-dir}{98}{\code {--include-dir}} \entry {-j}{98}{\code {-j}} \entry {--jobs}{98}{\code {--jobs}} \entry {-k}{98}{\code {-k}} \entry {--keep-going}{98}{\code {--keep-going}} \entry {-l}{98}{\code {-l}} \entry {--load-average}{98}{\code {--load-average}} \entry {--max-load}{98}{\code {--max-load}} \entry {-n}{98}{\code {-n}} \entry {--just-print}{99}{\code {--just-print}} \entry {--dry-run}{99}{\code {--dry-run}} \entry {--recon}{99}{\code {--recon}} \entry {-o}{99}{\code {-o}} \entry {--old-file}{99}{\code {--old-file}} \entry {--assume-old}{99}{\code {--assume-old}} \entry {-p}{99}{\code {-p}} \entry {--print-data-base}{99}{\code {--print-data-base}} \entry {-q}{99}{\code {-q}} \entry {--question}{99}{\code {--question}} \entry {-r}{99}{\code {-r}} \entry {--no-builtin-rules}{99}{\code {--no-builtin-rules}} \entry {-s}{99}{\code {-s}} \entry {--silent}{99}{\code {--silent}} \entry {--quiet}{99}{\code {--quiet}} \entry {-S}{99}{\code {-S}} \entry {--no-keep-going}{99}{\code {--no-keep-going}} \entry {--stop}{99}{\code {--stop}} \entry {-t}{100}{\code {-t}} \entry {--touch}{100}{\code {--touch}} \entry {-v}{100}{\code {-v}} \entry {--version}{100}{\code {--version}} \entry {-w}{100}{\code {-w}} \entry {--print-directory}{100}{\code {--print-directory}} \entry {--no-print-directory}{100}{\code {--no-print-directory}} \entry {-W}{100}{\code {-W}} \entry {--what-if}{100}{\code {--what-if}} \entry {--new-file}{100}{\code {--new-file}} \entry {--assume-new}{100}{\code {--assume-new}} \entry {--warn-undefined-variables}{100}{\code {--warn-undefined-variables}} \entry {variables, warning for undefined}{100}{variables, warning for undefined} \entry {undefined variables, warning message}{100}{undefined variables, warning message} \entry {implicit rule}{101}{implicit rule} \entry {rule, implicit}{101}{rule, implicit} \entry {implicit rule, how to use}{101}{implicit rule, how to use} \entry {rule, implicit, how to use}{101}{rule, implicit, how to use} \entry {implicit rule, predefined}{103}{implicit rule, predefined} \entry {rule, implicit, predefined}{103}{rule, implicit, predefined} \entry {C, rule to compile}{103}{C, rule to compile} \entry {cc}{103}{\code {cc}} \entry {gcc}{103}{\code {gcc}} \entry {.o}{103}{\code {.o}} \entry {.c}{103}{\code {.c}} \entry {C{\tt\char43}{\tt\char43}, rule to compile}{103}{C{\tt\char43}{\tt\char43}, rule to compile} \entry {g{\tt\char43}{\tt\char43}}{103}{\code {g{\tt\char43}{\tt\char43}}} \entry {.C}{103}{\code {.C}} \entry {.cc}{103}{\code {.cc}} \entry {Pascal, rule to compile}{103}{Pascal, rule to compile} \entry {pc}{103}{\code {pc}} \entry {.p}{103}{\code {.p}} \entry {Fortran, rule to compile}{103}{Fortran, rule to compile} \entry {Ratfor, rule to compile}{103}{Ratfor, rule to compile} \entry {f77}{103}{\code {f77}} \entry {.f}{103}{\code {.f}} \entry {.r}{103}{\code {.r}} \entry {.F}{103}{\code {.F}} \entry {Modula-2, rule to compile}{104}{Modula-2, rule to compile} \entry {m2c}{104}{\code {m2c}} \entry {.sym}{104}{\code {.sym}} \entry {.def}{104}{\code {.def}} \entry {.mod}{104}{\code {.mod}} \entry {assembly, rule to compile}{104}{assembly, rule to compile} \entry {as}{104}{\code {as}} \entry {.s}{104}{\code {.s}} \entry {.S}{104}{\code {.S}} \entry {linking, predefined rule for}{104}{linking, predefined rule for} \entry {ld}{104}{\code {ld}} \entry {.o}{104}{\code {.o}} \entry {yacc}{105}{\code {yacc}} \entry {Yacc, rule to run}{105}{Yacc, rule to run} \entry {.y}{105}{\code {.y}} \entry {lex}{105}{\code {lex}} \entry {Lex, rule to run}{105}{Lex, rule to run} \entry {.l}{105}{\code {.l}} \entry {lint}{105}{\code {lint}} \entry {lint, rule to run}{105}{\code {lint}, rule to run} \entry {.ln}{105}{\code {.ln}} \entry {TeX{}, rule to run}{105}{\TeX{}, rule to run} \entry {Web, rule to run}{105}{Web, rule to run} \entry {tex}{105}{\code {tex}} \entry {cweave}{105}{\code {cweave}} \entry {weave}{105}{\code {weave}} \entry {tangle}{105}{\code {tangle}} \entry {ctangle}{105}{\code {ctangle}} \entry {.dvi}{105}{\code {.dvi}} \entry {.tex}{105}{\code {.tex}} \entry {.web}{105}{\code {.web}} \entry {.w}{105}{\code {.w}} \entry {.ch}{105}{\code {.ch}} \entry {Texinfo, rule to format}{105}{Texinfo, rule to format} \entry {Info, rule to format}{105}{Info, rule to format} \entry {texi2dvi}{105}{\code {texi2dvi}} \entry {makeinfo}{105}{\code {makeinfo}} \entry {.texinfo}{105}{\code {.texinfo}} \entry {.info}{105}{\code {.info}} \entry {.texi}{105}{\code {.texi}} \entry {.txinfo}{105}{\code {.txinfo}} \entry {RCS, rule to extract from}{105}{RCS, rule to extract from} \entry {co}{105}{\code {co}} \entry {,v (RCS file extension)}{105}{\code {,v \r {(RCS file extension)}}} \entry {SCCS, rule to extract from}{105}{SCCS, rule to extract from} \entry {get}{105}{\code {get}} \entry {s. (SCCS file prefix)}{105}{\code {s. \r {(SCCS file prefix)}}} \entry {.sh}{106}{\code {.sh}} \entry {flags for compilers}{106}{flags for compilers} \entry {ar}{107}{\code {ar}} \entry {as}{107}{\code {as}} \entry {cc}{107}{\code {cc}} \entry {g{\tt\char43}{\tt\char43}}{107}{\code {g{\tt\char43}{\tt\char43}}} \entry {co}{107}{\code {co}} \entry {f77}{107}{\code {f77}} \entry {get}{107}{\code {get}} \entry {lex}{107}{\code {lex}} \entry {pc}{107}{\code {pc}} \entry {yacc}{107}{\code {yacc}} \entry {makeinfo}{107}{\code {makeinfo}} \entry {tex}{107}{\code {tex}} \entry {texi2dvi}{107}{\code {texi2dvi}} \entry {weave}{107}{\code {weave}} \entry {cweave}{107}{\code {cweave}} \entry {tangle}{107}{\code {tangle}} \entry {ctangle}{107}{\code {ctangle}} \entry {rm}{107}{\code {rm}} \entry {chains of rules}{108}{chains of rules} \entry {rule, implicit, chains of}{108}{rule, implicit, chains of} \entry {intermediate files}{108}{intermediate files} \entry {files, intermediate}{108}{files, intermediate} \entry {intermediate files, preserving}{109}{intermediate files, preserving} \entry {preserving intermediate files}{109}{preserving intermediate files} \entry {preserving with .PRECIOUS}{109}{preserving with \code {.PRECIOUS}} \entry {.PRECIOUS intermediate files}{109}{\code {.PRECIOUS} intermediate files} \entry {pattern rule}{110}{pattern rule} \entry {rule, pattern}{110}{rule, pattern} \entry {target pattern, implicit}{110}{target pattern, implicit} \entry {%, in pattern rules}{110}{\code {%}, in pattern rules} \entry {dependency pattern, implicit}{110}{dependency pattern, implicit} \entry {multiple targets, in pattern rule}{110}{multiple targets, in pattern rule} \entry {target, multiple in pattern rule}{110}{target, multiple in pattern rule} \entry {pattern rules, order of}{111}{pattern rules, order of} \entry {order of pattern rules}{111}{order of pattern rules} \entry {automatic variables}{112}{automatic variables} \entry {variables, automatic}{112}{variables, automatic} \entry {variables, and implicit rule}{112}{variables, and implicit rule} \entry {dependencies, list of changed}{112}{dependencies, list of changed} \entry {list of changed dependencies}{112}{list of changed dependencies} \entry {dependencies, list of all}{112}{dependencies, list of all} \entry {list of all dependencies}{112}{list of all dependencies} \entry {stem, variable for}{112}{stem, variable for} \entry {stem}{114}{stem} \entry {match-anything rule}{114}{match-anything rule} \entry {terminal rule}{114}{terminal rule} \entry {last-resort default rules}{116}{last-resort default rules} \entry {default rules, last-resort}{116}{default rules, last-resort} \entry {old-fashioned suffix rules}{117}{old-fashioned suffix rules} \entry {suffix rule}{117}{suffix rule} \entry {implicit rule, search algorithm}{119}{implicit rule, search algorithm} \entry {search algorithm, implicit rule}{119}{search algorithm, implicit rule} \entry {archive}{121}{archive} \entry {archive member targets}{121}{archive member targets} \entry {wildcard, in archive member}{121}{wildcard, in archive member} \entry {{\_}{\_}.SYMDEF}{123}{\code {{\_}{\_}.SYMDEF}} \entry {updating archive symbol directories}{123}{updating archive symbol directories} \entry {archive symbol directory updating}{123}{archive symbol directory updating} \entry {symbol directories, updating archive}{123}{symbol directories, updating archive} \entry {directories, updating archive symbol}{123}{directories, updating archive symbol} \entry {suffix rule, for archive}{123}{suffix rule, for archive} \entry {archive, suffix rule for}{123}{archive, suffix rule for} \entry {library archive, suffix rule for}{123}{library archive, suffix rule for} \entry {.a (archives)}{123}{\code {.a} (archives)} \entry {features of GNU make}{125}{features of GNU \code {make}} \entry {portability}{125}{portability} \entry {compatibility}{125}{compatibility} \entry {incompatibilities}{129}{incompatibilities} \entry {missing features}{129}{missing features} \entry {features, missing}{129}{features, missing} \entry {makefile, conventions for}{131}{makefile, conventions for} \entry {conventions for makefiles}{131}{conventions for makefiles} \entry {standards for makefiles}{131}{standards for makefiles} make-3.70/make.fn 666 12241 12 15134 5504167707 6751 \entry {Makefile}{16}{\code {Makefile}} \entry {GNUmakefile}{16}{\code {GNUmakefile}} \entry {makefile}{16}{\code {makefile}} \entry {include}{16}{\code {include}} \entry {/usr/gnu/include}{17}{\code {/usr/gnu/include}} \entry {/usr/local/include}{17}{\code {/usr/local/include}} \entry {/usr/include}{17}{\code {/usr/include}} \entry {MAKEFILES}{18}{\code {MAKEFILES}} \entry {wildcard}{24}{\code {wildcard}} \entry {VPATH}{25}{\code {VPATH}} \entry {vpath}{25}{\code {vpath}} \entry {VPATH}{25}{\code {VPATH}} \entry {vpath}{26}{\code {vpath}} \entry {.PHONY}{30}{\code {.PHONY}} \entry {.PHONY}{32}{\code {.PHONY}} \entry {.SUFFIXES}{33}{\code {.SUFFIXES}} \entry {.DEFAULT}{33}{\code {.DEFAULT}} \entry {.PRECIOUS}{33}{\code {.PRECIOUS}} \entry {.IGNORE}{33}{\code {.IGNORE}} \entry {.SILENT}{33}{\code {.SILENT}} \entry {.EXPORT{\_}ALL{\_}VARIABLES}{33}{\code {.EXPORT{\_}ALL{\_}VARIABLES}} \entry {subst}{34}{\code {subst}} \entry {$*, and static pattern}{37}{\code {$*\r {, and static pattern}}} \entry {.SILENT}{43}{\code {.SILENT}} \entry {SHELL (command execution)}{44}{\code {SHELL \r {(command execution)}}} \entry {SHELL}{44}{\code {SHELL}} \entry {.IGNORE}{46}{\code {.IGNORE}} \entry {.PRECIOUS}{47}{\code {.PRECIOUS}} \entry {MAKE}{48}{\code {MAKE}} \entry {MAKE{\_}COMMAND}{48}{\code {MAKE{\_}COMMAND}} \entry {MAKEOVERRIDES}{48}{\code {MAKEOVERRIDES}} \entry {export}{50}{\code {export}} \entry {unexport}{50}{\code {unexport}} \entry {.EXPORT{\_}ALL{\_}VARIABLES}{51}{\code {.EXPORT{\_}ALL{\_}VARIABLES}} \entry {MAKELEVEL}{51}{\code {MAKELEVEL}} \entry {MAKEFILES}{52}{\code {MAKEFILES}} \entry {MAKEFLAGS}{52}{\code {MAKEFLAGS}} \entry {MFLAGS}{53}{\code {MFLAGS}} \entry {.DEFAULT, and empty commands}{56}{\code {.DEFAULT\r {, and empty commands}}} \entry {MAKELEVEL}{60}{\code {MAKELEVEL}} \entry {MAKE}{60}{\code {MAKE}} \entry {patsubst}{61}{\code {patsubst}} \entry {override}{68}{\code {override}} \entry {define}{69}{\code {define}} \entry {endef}{69}{\code {endef}} \entry {ifdef}{74}{\code {ifdef}} \entry {ifeq}{74}{\code {ifeq}} \entry {ifndef}{74}{\code {ifndef}} \entry {ifneq}{74}{\code {ifneq}} \entry {else}{74}{\code {else}} \entry {endif}{74}{\code {endif}} \entry {subst}{80}{\code {subst}} \entry {patsubst}{80}{\code {patsubst}} \entry {strip}{81}{\code {strip}} \entry {findstring}{81}{\code {findstring}} \entry {filter}{82}{\code {filter}} \entry {filter-out}{82}{\code {filter-out}} \entry {sort}{82}{\code {sort}} \entry {dir}{83}{\code {dir}} \entry {notdir}{83}{\code {notdir}} \entry {suffix}{84}{\code {suffix}} \entry {basename}{84}{\code {basename}} \entry {addsuffix}{84}{\code {addsuffix}} \entry {addprefix}{84}{\code {addprefix}} \entry {join}{84}{\code {join}} \entry {word}{85}{\code {word}} \entry {words}{85}{\code {words}} \entry {firstword}{85}{\code {firstword}} \entry {wildcard}{85}{\code {wildcard}} \entry {foreach}{85}{\code {foreach}} \entry {origin}{87}{\code {origin}} \entry {shell}{89}{\code {shell}} \entry {OUTPUT{\_}OPTION}{106}{\code {OUTPUT{\_}OPTION}} \entry {AR}{107}{\code {AR}} \entry {AS}{107}{\code {AS}} \entry {CC}{107}{\code {CC}} \entry {CXX}{107}{\code {CXX}} \entry {CO}{107}{\code {CO}} \entry {CPP}{107}{\code {CPP}} \entry {FC}{107}{\code {FC}} \entry {GET}{107}{\code {GET}} \entry {LEX}{107}{\code {LEX}} \entry {PC}{107}{\code {PC}} \entry {YACC}{107}{\code {YACC}} \entry {YACCR}{107}{\code {YACCR}} \entry {MAKEINFO}{107}{\code {MAKEINFO}} \entry {TEX}{107}{\code {TEX}} \entry {TEXI2DVI}{107}{\code {TEXI2DVI}} \entry {WEAVE}{107}{\code {WEAVE}} \entry {CWEAVE}{107}{\code {CWEAVE}} \entry {TANGLE}{107}{\code {TANGLE}} \entry {CTANGLE}{107}{\code {CTANGLE}} \entry {RM}{107}{\code {RM}} \entry {ARFLAGS}{108}{\code {ARFLAGS}} \entry {ASFLAGS}{108}{\code {ASFLAGS}} \entry {CFLAGS}{108}{\code {CFLAGS}} \entry {CXXFLAGS}{108}{\code {CXXFLAGS}} \entry {COFLAGS}{108}{\code {COFLAGS}} \entry {CPPFLAGS}{108}{\code {CPPFLAGS}} \entry {FFLAGS}{108}{\code {FFLAGS}} \entry {GFLAGS}{108}{\code {GFLAGS}} \entry {LDFLAGS}{108}{\code {LDFLAGS}} \entry {LFLAGS}{108}{\code {LFLAGS}} \entry {PFLAGS}{108}{\code {PFLAGS}} \entry {RFLAGS}{108}{\code {RFLAGS}} \entry {YFLAGS}{108}{\code {YFLAGS}} \entry {${\tt\char'100}}{112}{\code {${\tt\char'100}}} \entry {{\tt\char'100} (automatic variable)}{112}{\code {{\tt\char'100} \r {(automatic variable)}}} \entry {$%}{112}{\code {$%}} \entry {% (automatic variable)}{112}{\code {% \r {(automatic variable)}}} \entry {${\tt\less}}{112}{\code {${\tt\less}}} \entry {{\tt\less} (automatic variable)}{112}{\code {{\tt\less} \r {(automatic variable)}}} \entry {$?}{112}{\code {$?}} \entry {? (automatic variable)}{112}{\code {? \r {(automatic variable)}}} \entry {${\tt\hat}}{112}{\code {${\tt\hat}}} \entry {{\tt\hat} (automatic variable)}{112}{\code {{\tt\hat} \r {(automatic variable)}}} \entry {$*}{112}{\code {$*}} \entry {* (automatic variable)}{112}{\code {* \r {(automatic variable)}}} \entry {$({\tt\char'100}D)}{113}{\code {$({\tt\char'100}D)}} \entry {{\tt\char'100}D (automatic variable)}{113}{\code {{\tt\char'100}D \r {(automatic variable)}}} \entry {$({\tt\char'100}F)}{113}{\code {$({\tt\char'100}F)}} \entry {{\tt\char'100}F (automatic variable)}{113}{\code {{\tt\char'100}F \r {(automatic variable)}}} \entry {$(*D)}{113}{\code {$(*D)}} \entry {*D (automatic variable)}{113}{\code {*D \r {(automatic variable)}}} \entry {$(*F)}{113}{\code {$(*F)}} \entry {*F (automatic variable)}{113}{\code {*F \r {(automatic variable)}}} \entry {$(%D)}{113}{\code {$(%D)}} \entry {%D (automatic variable)}{113}{\code {%D \r {(automatic variable)}}} \entry {$(%F)}{113}{\code {$(%F)}} \entry {%F (automatic variable)}{113}{\code {%F \r {(automatic variable)}}} \entry {$({\tt\less}D)}{113}{\code {$({\tt\less}D)}} \entry {{\tt\less}D (automatic variable)}{113}{\code {{\tt\less}D \r {(automatic variable)}}} \entry {$({\tt\less}F)}{113}{\code {$({\tt\less}F)}} \entry {{\tt\less}F (automatic variable)}{113}{\code {{\tt\less}F \r {(automatic variable)}}} \entry {$({\tt\hat}D)}{113}{\code {$({\tt\hat}D)}} \entry {{\tt\hat}D (automatic variable)}{113}{\code {{\tt\hat}D \r {(automatic variable)}}} \entry {$({\tt\hat}F)}{114}{\code {$({\tt\hat}F)}} \entry {{\tt\hat}F (automatic variable)}{114}{\code {{\tt\hat}F \r {(automatic variable)}}} \entry {$(?D)}{114}{\code {$(?D)}} \entry {?D (automatic variable)}{114}{\code {?D \r {(automatic variable)}}} \entry {$(?F)}{114}{\code {$(?F)}} \entry {?F (automatic variable)}{114}{\code {?F \r {(automatic variable)}}} \entry {.DEFAULT}{117}{\code {.DEFAULT}} \entry {.SUFFIXES}{118}{\code {.SUFFIXES}} \entry {SUFFIXES}{119}{\code {SUFFIXES}} \entry {* (automatic variable), unsupported bizarre usage}{129}{\code {* \r {(automatic variable), unsupported bizarre usage}}} make-3.70/make.ky 666 12241 12 0 5504167627 6654 make-3.70/make.pg 666 12241 12 0 5504167627 6637 make-3.70/make.tp 666 12241 12 0 5504167627 6654 make-3.70/make.vr 666 12241 12 0 5504167627 6660 make-3.70/make.cps 666 12241 12 55272 5504167620 7134 \initial {#} \entry {\code {#} (comments), in commands}{43} \entry {\code {#} (comments), in makefile}{15} \entry {\code {#include}}{39} \initial {$} \entry {\code {$}, in function call}{79} \entry {\code {$}, in rules}{22} \entry {\code {$}, in variable name}{62} \entry {\code {$}, in variable reference}{57} \initial {%} \entry {\code {%}, in pattern rules}{110} \entry {\code {%}, quoting in \code {patsubst}}{80} \entry {\code {%}, quoting in static pattern}{37} \entry {\code {%}, quoting in \code {vpath}}{27} \entry {\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)}{27, 37, 80} \initial {*} \entry {\code {*} (wildcard character)}{22} \initial {,} \entry {\code {,v \r {(RCS file extension)}}}{105} \initial {-} \entry {\code {-} (in commands)}{46} \entry {-, and \code {define}}{55} \entry {\code {--assume-new}}{94, 100} \entry {\code {--assume-new}, and recursion}{52} \entry {\code {--assume-old}}{95, 99} \entry {\code {--assume-old}, and recursion}{52} \entry {\code {--debug}}{97} \entry {\code {--directory}}{48, 97} \entry {\code {--directory}, and \code {--print-directory}}{54} \entry {\code {--directory}, and recursion}{52} \entry {\code {--dry-run}}{43, 93, 99} \entry {\code {--environment-overrides}}{98} \entry {\code {--file}}{16, 91, 98} \entry {\code {--file}, and recursion}{52} \entry {\code {--help}}{98} \entry {\code {--ignore-errors}}{46, 98} \entry {\code {--include-dir}}{17, 98} \entry {\code {--include-dir}, and recursion}{52} \entry {\code {--jobs}}{44, 98} \entry {\code {--jobs}, and recursion}{52} \entry {\code {--just-print}}{43, 93, 99} \entry {\code {--keep-going}}{47, 97, 98} \entry {\code {--load-average}}{45, 98} \entry {\code {--makefile}}{16, 91, 98} \entry {\code {--max-load}}{45, 98} \entry {\code {--new-file}}{94, 100} \entry {\code {--new-file}, and recursion}{52} \entry {\code {--no-builtin-rules}}{99} \entry {\code {--no-keep-going}}{99} \entry {\code {--no-print-directory}}{54, 100} \entry {\code {--old-file}}{95, 99} \entry {\code {--old-file}, and recursion}{52} \entry {\code {--print-data-base}}{99} \entry {\code {--print-directory}}{100} \entry {\code {--print-directory}, and \code {--directory}}{54} \entry {\code {--print-directory}, and recursion}{54} \entry {\code {--print-directory}, disabling}{54} \entry {\code {--question}}{94, 99} \entry {\code {--quiet}}{43, 99} \entry {\code {--recon}}{43, 93, 99} \entry {\code {--silent}}{43, 99} \entry {\code {--stop}}{99} \entry {\code {--touch}}{93, 100} \entry {\code {--touch}, and recursion}{49} \entry {\code {--version}}{100} \entry {\code {--warn-undefined-variables}}{100} \entry {\code {--what-if}}{94, 100} \entry {\code {-b}}{97} \entry {\code {-C}}{48, 97} \entry {\code {-C}, and \code {-w}}{54} \entry {\code {-C}, and recursion}{52} \entry {\code {-d}}{97} \entry {\code {-e}}{98} \entry {\code {-e} (shell flag)}{40} \entry {\code {-f}}{16, 91, 98} \entry {\code {-f}, and recursion}{52} \entry {\code {-h}}{98} \entry {\code {-i}}{46, 98} \entry {\code {-I}}{17, 98} \entry {\code {-I}, and recursion}{52} \entry {\code {-j}}{44, 98} \entry {\code {-j}, and recursion}{52} \entry {\code {-k}}{47, 97, 98} \entry {\code {-l}}{98} \entry {\code {-l} (library search)}{29} \entry {\code {-l} (load average)}{45} \entry {\code {-m}}{97} \entry {\code {-M} (to compiler)}{39} \entry {\code {-n}}{43, 93, 98} \entry {\code {-o}}{95, 99} \entry {\code {-o}, and recursion}{52} \entry {\code {-p}}{99} \entry {\code {-q}}{94, 99} \entry {\code {-r}}{99} \entry {\code {-s}}{43, 99} \entry {\code {-S}}{99} \entry {\code {-t}}{93, 100} \entry {\code {-t}, and recursion}{49} \entry {\code {-v}}{100} \entry {\code {-w}}{100} \entry {\code {-W}}{94, 100} \entry {\code {-w}, and \code {-C}}{54} \entry {\code {-w}, and recursion}{54} \entry {\code {-W}, and recursion}{52} \entry {\code {-w}, disabling}{54} \initial {.} \entry {\code {.a} (archives)}{123} \entry {\code {.c}}{103} \entry {\code {.C}}{103} \entry {\code {.cc}}{103} \entry {\code {.ch}}{105} \entry {\code {.d}}{41} \entry {\code {.def}}{104} \entry {\code {.DEFAULT}, used to override}{20} \entry {\code {.dvi}}{105} \entry {\code {.f}}{103} \entry {\code {.F}}{103} \entry {\code {.info}}{105} \entry {\code {.l}}{105} \entry {\code {.ln}}{105} \entry {\code {.mod}}{104} \entry {\code {.o}}{103, 104} \entry {\code {.p}}{103} \entry {\code {.PRECIOUS} intermediate files}{109} \entry {\code {.r}}{103} \entry {\code {.s}}{104} \entry {\code {.S}}{104} \entry {\code {.sh}}{106} \entry {\code {.sym}}{104} \entry {\code {.tex}}{105} \entry {\code {.texi}}{105} \entry {\code {.texinfo}}{105} \entry {\code {.txinfo}}{105} \entry {\code {.w}}{105} \entry {\code {.web}}{105} \entry {\code {.y}}{105} \initial {:} \entry {\code {::} rules (double-colon)}{38} \entry {:=}{59, 66} \initial {=} \entry {=}{58, 66} \initial {?} \entry {\code {?} (wildcard character)}{22} \initial {[} \entry {\code {[\dots {}]} (wildcard characters)}{22} \initial {{\_}} \entry {\code {{\_}{\_}.SYMDEF}}{123} \initial {{\tt\char'100}} \entry {\code {{\tt\char'100}} (in commands)}{43} \entry {{\tt\char'100}, and \code {define}}{55} \initial {{\tt\char'176}} \entry {\code {{\tt\char'176}} (tilde)}{22} \initial {{\tt\char43}} \entry {{\tt\char43}, and \code {define}}{55} \entry {{\tt\char43}=}{66} \initial {{\tt\indexbackslash }} \entry {\code {{\tt\indexbackslash }} (backslash), for continuation lines}{7} \entry {\code {{\tt\indexbackslash }} (backslash), in commands}{44} \entry {\code {{\tt\indexbackslash }} (backslash), to quote \code {%}}{27, 37, 80} \initial {A} \entry {\code {all} \r {(standard target)}}{92} \entry {appending to variables}{66} \entry {\code {ar}}{107} \entry {archive}{121} \entry {archive member targets}{121} \entry {archive symbol directory updating}{123} \entry {archive, suffix rule for}{123} \entry {arguments of functions}{79} \entry {\code {as}}{104, 107} \entry {assembly, rule to compile}{104} \entry {automatic generation of dependencies}{17, 39} \entry {automatic variables}{112} \initial {B} \entry {backquotes}{89} \entry {backslash (\code {{\tt\indexbackslash }}), for continuation lines}{7} \entry {backslash (\code {{\tt\indexbackslash }}), in commands}{44} \entry {backslash (\code {{\tt\indexbackslash }}), to quote \code {%}}{27, 37, 80} \entry {basename}{84} \entry {broken pipe}{45} \entry {bugs, reporting}{2} \entry {built-in special targets}{32} \initial {C} \entry {C, rule to compile}{103} \entry {C{\tt\char43}{\tt\char43}, rule to compile}{103} \entry {\code {cc}}{103, 107} \entry {\code {cd} (shell command)}{44, 48} \entry {chains of rules}{108} \entry {\code {check} \r {(standard target)}}{93} \entry {\code {clean} \r {(standard target)}}{92} \entry {\code {clean} target}{8, 12} \entry {cleaning up}{12} \entry {\code {clobber} \r {(standard target)}}{93} \entry {\code {co}}{105, 107} \entry {combining rules by dependency}{12} \entry {command line variables}{95} \entry {commands}{21} \entry {commands, backslash (\code {{\tt\indexbackslash }}) in}{44} \entry {commands, comments in}{43} \entry {commands, echoing}{43} \entry {commands, empty}{56} \entry {commands, errors in}{46} \entry {commands, execution}{44} \entry {commands, execution in parallel}{44} \entry {commands, expansion}{89} \entry {commands, how to write}{43} \entry {commands, instead of executing}{93} \entry {commands, introduction to}{5} \entry {commands, quoting newlines in}{44} \entry {commands, sequences of}{54} \entry {comments, in commands}{43} \entry {comments, in makefile}{15} \entry {compatibility}{125} \entry {compatibility in exporting}{51} \entry {compilation, testing}{96} \entry {computed variable name}{62} \entry {conditionals}{73} \entry {continuation lines}{7} \entry {conventions for makefiles}{131} \entry {\code {ctangle}}{105, 107} \entry {\code {cweave}}{105, 107} \initial {D} \entry {deducing commands (implicit rules)}{10} \entry {default goal}{8, 21} \entry {default makefile name}{16} \entry {default rules, last-resort}{116} \entry {defining variables verbatim}{69} \entry {deletion of target files}{47} \entry {dependencies}{22} \entry {dependencies, automatic generation}{17, 39} \entry {dependencies, introduction to}{5} \entry {dependencies, list of all}{112} \entry {dependencies, list of changed}{112} \entry {dependencies, varying (static pattern)}{36} \entry {dependency}{21} \entry {dependency pattern, implicit}{110} \entry {dependency pattern, static (not implicit)}{36} \entry {directive}{15} \entry {directories, printing them}{53} \entry {directories, updating archive symbol}{123} \entry {directory part}{83} \entry {directory search (\code {VPATH})}{25} \entry {directory search (\code {VPATH}), and implicit rules}{28} \entry {directory search (\code {VPATH}), and link libraries}{29} \entry {directory search (\code {VPATH}), and shell commands}{28} \entry {\code {dist} \r {(standard target)}}{93} \entry {\code {distclean} \r {(standard target)}}{93} \entry {dollar sign (\code {$}), in function call}{79} \entry {dollar sign (\code {$}), in rules}{22} \entry {dollar sign (\code {$}), in variable name}{62} \entry {dollar sign (\code {$}), in variable reference}{57} \entry {double-colon rules}{38} \entry {duplicate words, removing}{82} \initial {E} \entry {echoing of commands}{43} \entry {editor}{5} \entry {Emacs (\code {M-x compile})}{47} \entry {empty commands}{56} \entry {empty targets}{32} \entry {environment}{70} \entry {environment, and recursion}{49} \entry {environment, \code {SHELL} in}{44} \entry {errors (in commands)}{46} \entry {errors with wildcards}{24} \entry {execution, in parallel}{44} \entry {execution, instead of}{93} \entry {execution, of commands}{44} \entry {exit status (errors)}{46} \entry {explicit rule, definition of}{15} \entry {exporting variables}{49} \initial {F} \entry {\code {f77}}{103, 107} \entry {features of GNU \code {make}}{125} \entry {features, missing}{129} \entry {file name functions}{83} \entry {file name of makefile}{16} \entry {file name of makefile, how to specify}{16} \entry {file name prefix, adding}{84} \entry {file name suffix}{84} \entry {file name suffix, adding}{84} \entry {file name with wildcards}{22} \entry {file name, basename of}{84} \entry {file name, directory part}{83} \entry {file name, nondirectory part}{83} \entry {files, assuming new}{94} \entry {files, assuming old}{95} \entry {files, avoiding recompilation of}{95} \entry {files, intermediate}{108} \entry {filtering out words}{82} \entry {filtering words}{82} \entry {finding strings}{81} \entry {flags}{97} \entry {flags for compilers}{106} \entry {flavors of variables}{58} \entry {\code {FORCE}}{31} \entry {force targets}{31} \entry {Fortran, rule to compile}{103} \entry {functions}{79} \entry {functions, for file names}{83} \entry {functions, for text}{80} \entry {functions, syntax of}{79} \initial {G} \entry {\code {g{\tt\char43}{\tt\char43}}}{103, 107} \entry {\code {gcc}}{103} \entry {generating dependencies automatically}{17, 39} \entry {\code {get}}{105, 107} \entry {globbing (wildcards)}{22} \entry {goal}{8} \entry {goal, default}{8, 21} \entry {goal, how to specify}{91} \initial {H} \entry {home directory}{22} \initial {I} \entry {IEEE Standard 1003.2}{1} \entry {implicit rule}{101} \entry {implicit rule, and directory search}{28} \entry {implicit rule, and \code {VPATH}}{28} \entry {implicit rule, definition of}{15} \entry {implicit rule, how to use}{101} \entry {implicit rule, introduction to}{10} \entry {implicit rule, predefined}{103} \entry {implicit rule, search algorithm}{119} \entry {including (\code {MAKEFILES} variable)}{18} \entry {including other makefiles}{16} \entry {incompatibilities}{129} \entry {Info, rule to format}{105} \entry {\code {install} \r {(standard target)}}{93} \entry {intermediate files}{108} \entry {intermediate files, preserving}{109} \entry {interrupt}{47} \initial {J} \entry {job slots}{44} \entry {job slots, and recursion}{52} \entry {jobs, limiting based on load}{45} \entry {joining lists of words}{84} \initial {K} \entry {killing (interruption)}{47} \initial {L} \entry {last-resort default rules}{116} \entry {\code {ld}}{104} \entry {\code {lex}}{105, 107} \entry {Lex, rule to run}{105} \entry {libraries for linking, directory search}{29} \entry {library archive, suffix rule for}{123} \entry {limiting jobs based on load}{45} \entry {link libraries, and directory search}{29} \entry {linking, predefined rule for}{104} \entry {\code {lint}}{105} \entry {\code {lint}, rule to run}{105} \entry {list of all dependencies}{112} \entry {list of changed dependencies}{112} \entry {load average}{45} \entry {loops in variable expansion}{59} \entry {\code {lpr} (shell command)}{23, 32} \initial {M} \entry {\code {m2c}}{104} \entry {macro}{57} \entry {\code {make depend}}{40} \entry {makefile}{5} \entry {makefile name}{16} \entry {makefile name, how to specify}{16} \entry {makefile rule parts}{5} \entry {makefile, and \code {MAKEFILES} variable}{18} \entry {makefile, conventions for}{131} \entry {makefile, how \code {make} processes}{8} \entry {makefile, how to write}{15} \entry {makefile, including}{16} \entry {makefile, overriding}{20} \entry {makefile, remaking of}{18} \entry {makefile, simple}{6} \entry {\code {makeinfo}}{105, 107} \entry {match-anything rule}{114} \entry {missing features}{129} \entry {mistakes with wildcards}{24} \entry {modified variable reference}{61} \entry {Modula-2, rule to compile}{104} \entry {\code {mostlyclean} \r {(standard target)}}{92} \entry {multiple rules for one target}{35} \entry {multiple rules for one target (\code {::})}{38} \entry {multiple targets}{34} \entry {multiple targets, in pattern rule}{110} \initial {N} \entry {name of makefile}{16} \entry {name of makefile, how to specify}{16} \entry {nested variable reference}{62} \entry {newline, quoting, in commands}{44} \entry {newline, quoting, in makefile}{7} \entry {nondirectory part}{83} \initial {O} \entry {\code {obj}}{9} \entry {\code {OBJ}}{9} \entry {\code {objects}}{9} \entry {\code {OBJECTS}}{9} \entry {\code {objs}}{9} \entry {\code {OBJS}}{9} \entry {old-fashioned suffix rules}{117} \entry {options}{97} \entry {options, and recursion}{52} \entry {options, setting from environment}{53} \entry {options, setting in makefiles}{53} \entry {order of pattern rules}{111} \entry {origin of variable}{87} \entry {overriding makefiles}{20} \entry {overriding variables with arguments}{95} \entry {overriding with \code {override}}{68} \initial {P} \entry {parallel execution}{44} \entry {parts of makefile rule}{5} \entry {Pascal, rule to compile}{103} \entry {pattern rule}{110} \entry {pattern rules, order of}{111} \entry {pattern rules, static (not implicit)}{36} \entry {pattern rules, static, syntax of}{36} \entry {\code {pc}}{103, 107} \entry {phony targets}{29} \entry {pitfalls of wildcards}{24} \entry {portability}{125} \entry {POSIX}{1} \entry {precious targets}{33} \entry {prefix, adding}{84} \entry {preserving intermediate files}{109} \entry {preserving with \code {.PRECIOUS}}{33, 109} \entry {\code {print} \r {(standard target)}}{93} \entry {\code {print} target}{23, 32} \entry {printing directories}{53} \entry {printing of commands}{43} \entry {problems and bugs, reporting}{2} \entry {problems with wildcards}{24} \entry {processing a makefile}{8} \initial {Q} \entry {question mode}{94} \entry {quoting \code {%}, in \code {patsubst}}{80} \entry {quoting \code {%}, in static pattern}{37} \entry {quoting \code {%}, in \code {vpath}}{27} \entry {quoting newline, in commands}{44} \entry {quoting newline, in makefile}{7} \initial {R} \entry {Ratfor, rule to compile}{103} \entry {RCS, rule to extract from}{105} \entry {\code {README}}{16} \entry {\code {realclean} \r {(standard target)}}{93} \entry {recompilation}{5} \entry {recompilation, avoiding}{95} \entry {recording events with empty targets}{32} \entry {recursion}{48} \entry {recursion, and \code {-C}}{52} \entry {recursion, and \code {-f}}{52} \entry {recursion, and \code {-I}}{52} \entry {recursion, and \code {-j}}{52} \entry {recursion, and \code {-o}}{52} \entry {recursion, and \code {-t}}{49} \entry {recursion, and \code {-w}}{54} \entry {recursion, and \code {-W}}{52} \entry {recursion, and environment}{49} \entry {recursion, and \code {MAKE} variable}{48} \entry {recursion, and \code {MAKEFILES} variable}{18} \entry {recursion, and options}{52} \entry {recursion, and printing directories}{53} \entry {recursion, and variables}{49} \entry {recursion, level of}{51} \entry {recursive variable expansion}{57, 58} \entry {recursively expanded variables}{58} \entry {reference to variables}{57, 61} \entry {relinking}{9} \entry {remaking makefiles}{18} \entry {removing duplicate words}{82} \entry {removing, to clean up}{12} \entry {reporting bugs}{2} \entry {\code {rm}}{107} \entry {\code {rm} (shell command)}{8, 23, 30, 46} \entry {rule commands}{43} \entry {rule dependencies}{22} \entry {rule syntax}{21} \entry {rule targets}{21} \entry {rule, and \code {$}}{22} \entry {rule, double-colon (\code {::})}{38} \entry {rule, explicit, definition of}{15} \entry {rule, how to write}{21} \entry {rule, implicit}{101} \entry {rule, implicit, and directory search}{28} \entry {rule, implicit, and \code {VPATH}}{28} \entry {rule, implicit, chains of}{108} \entry {rule, implicit, definition of}{15} \entry {rule, implicit, how to use}{101} \entry {rule, implicit, introduction to}{10} \entry {rule, implicit, predefined}{103} \entry {rule, introduction to}{5} \entry {rule, multiple for one target}{35} \entry {rule, no commands or dependencies}{31} \entry {rule, pattern}{110} \entry {rule, static pattern}{36} \entry {rule, static pattern versus implicit}{38} \entry {rule, with multiple targets}{34} \initial {S} \entry {\code {s. \r {(SCCS file prefix)}}}{105} \entry {SCCS, rule to extract from}{105} \entry {search algorithm, implicit rule}{119} \entry {search path for dependencies (\code {VPATH})}{25} \entry {search path for dependencies (\code {VPATH}), and implicit rules}{28} \entry {search path for dependencies (\code {VPATH}), and link libraries}{29} \entry {searching for strings}{81} \entry {\code {sed} (shell command)}{40} \entry {selecting words}{85} \entry {sequences of commands}{54} \entry {setting options from environment}{53} \entry {setting options in makefiles}{53} \entry {setting variables}{66} \entry {several rules for one target}{35} \entry {several targets in a rule}{34} \entry {\code {shar} \r {(standard target)}}{93} \entry {shell command}{8} \entry {shell command, and directory search}{28} \entry {shell command, execution}{44} \entry {shell command, function for}{89} \entry {shell file name pattern (in \code {include})}{16} \entry {shell wildcards (in \code {include})}{16} \entry {signal}{47} \entry {silent operation}{43} \entry {simple makefile}{6} \entry {simple variable expansion}{57} \entry {simplifying with variables}{9} \entry {simply expanded variables}{59} \entry {sorting words}{82} \entry {spaces, in variable values}{60} \entry {spaces, stripping}{81} \entry {special targets}{32} \entry {specifying makefile name}{16} \entry {standard input}{45} \entry {standards conformance}{1} \entry {standards for makefiles}{131} \entry {static pattern rule}{36} \entry {static pattern rule, syntax of}{36} \entry {static pattern rule, versus implicit}{38} \entry {stem}{36, 114} \entry {stem, variable for}{112} \entry {strings, searching for}{81} \entry {stripping whitespace}{81} \entry {sub-\code {make}}{49} \entry {subdirectories, recursion for}{48} \entry {substitution variable reference}{61} \entry {suffix rule}{117} \entry {suffix rule, for archive}{123} \entry {suffix, adding}{84} \entry {suffix, function to find}{84} \entry {suffix, substituting in variables}{61} \entry {switches}{97} \entry {symbol directories, updating archive}{123} \entry {syntax of rules}{21} \initial {T} \entry {tab character (in commands)}{21} \entry {tabs in rules}{5} \entry {\code {TAGS} \r {(standard target)}}{93} \entry {\code {tangle}}{105, 107} \entry {\code {tar} \r {(standard target)}}{93} \entry {target}{21} \entry {target pattern, implicit}{110} \entry {target pattern, static (not implicit)}{36} \entry {target, deleting on interrupt}{47} \entry {target, multiple in pattern rule}{110} \entry {target, multiple rules for one}{35} \entry {target, touching}{93} \entry {targets}{21} \entry {targets without a file}{29} \entry {targets, built-in special}{32} \entry {targets, empty}{32} \entry {targets, force}{31} \entry {targets, introduction to}{5} \entry {targets, multiple}{34} \entry {targets, phony}{29} \entry {terminal rule}{114} \entry {\code {test} \r {(standard target)}}{93} \entry {testing compilation}{96} \entry {\code {tex}}{105, 107} \entry {\TeX{}, rule to run}{105} \entry {\code {texi2dvi}}{105, 107} \entry {Texinfo, rule to format}{105} \entry {tilde (\code {{\tt\char'176}})}{22} \entry {\code {touch} (shell command)}{23, 32} \entry {touching files}{93} \initial {U} \entry {undefined variables, warning message}{100} \entry {updating archive symbol directories}{123} \entry {updating makefiles}{18} \initial {V} \entry {value}{57} \entry {value, how a variable gets it}{65} \entry {variable}{57} \entry {variable definition}{15} \entry {variables}{9} \entry {variables, \samp {$} in name}{62} \entry {variables, and implicit rule}{112} \entry {variables, appending to}{66} \entry {variables, automatic}{112} \entry {variables, command line}{95} \entry {variables, computed names}{62} \entry {variables, defining verbatim}{69} \entry {variables, environment}{49, 70} \entry {variables, exporting}{49} \entry {variables, flavors}{58} \entry {variables, how they get their values}{65} \entry {variables, how to reference}{57} \entry {variables, loops in expansion}{59} \entry {variables, modified reference}{61} \entry {variables, nested references}{62} \entry {variables, origin of}{87} \entry {variables, overriding}{68} \entry {variables, overriding with arguments}{95} \entry {variables, recursively expanded}{58} \entry {variables, setting}{66} \entry {variables, simply expanded}{59} \entry {variables, spaces in values}{60} \entry {variables, substituting suffix in}{61} \entry {variables, substitution reference}{61} \entry {variables, warning for undefined}{100} \entry {varying dependencies}{36} \entry {verbatim variable definition}{69} \entry {vpath}{25} \entry {\code {VPATH}, and implicit rules}{28} \entry {\code {VPATH}, and link libraries}{29} \initial {W} \entry {\code {weave}}{105, 107} \entry {Web, rule to run}{105} \entry {what if}{94} \entry {whitespace, in variable values}{60} \entry {whitespace, stripping}{81} \entry {wildcard}{22} \entry {wildcard pitfalls}{24} \entry {wildcard, function}{85} \entry {wildcard, in archive member}{121} \entry {wildcard, in \code {include}}{16} \entry {words, extracting first}{85} \entry {words, filtering}{82} \entry {words, filtering out}{82} \entry {words, finding number}{85} \entry {words, iterating over}{85} \entry {words, joining lists}{84} \entry {words, removing duplicates}{82} \entry {words, selecting}{85} \entry {writing rule commands}{43} \entry {writing rules}{21} \initial {Y} \entry {\code {yacc}}{54, 105, 107} \entry {Yacc, rule to run}{105} make-3.70/make.fns 666 12241 12 11522 5504167620 7123 \initial {$} \entry {\code {$%}}{112} \entry {\code {$(%D)}}{113} \entry {\code {$(%F)}}{113} \entry {\code {$(*D)}}{113} \entry {\code {$(*F)}}{113} \entry {\code {$(?D)}}{114} \entry {\code {$(?F)}}{114} \entry {\code {$({\tt\char'100}D)}}{113} \entry {\code {$({\tt\char'100}F)}}{113} \entry {\code {$({\tt\hat}D)}}{113} \entry {\code {$({\tt\hat}F)}}{114} \entry {\code {$({\tt\less}D)}}{113} \entry {\code {$({\tt\less}F)}}{113} \entry {\code {$*}}{112} \entry {\code {$*\r {, and static pattern}}}{37} \entry {\code {$?}}{112} \entry {\code {${\tt\char'100}}}{112} \entry {\code {${\tt\hat}}}{112} \entry {\code {${\tt\less}}}{112} \initial {%} \entry {\code {% \r {(automatic variable)}}}{112} \entry {\code {%D \r {(automatic variable)}}}{113} \entry {\code {%F \r {(automatic variable)}}}{113} \initial {*} \entry {\code {* \r {(automatic variable)}}}{112} \entry {\code {* \r {(automatic variable), unsupported bizarre usage}}}{129} \entry {\code {*D \r {(automatic variable)}}}{113} \entry {\code {*F \r {(automatic variable)}}}{113} \initial {.} \entry {\code {.DEFAULT}}{33, 117} \entry {\code {.DEFAULT\r {, and empty commands}}}{56} \entry {\code {.EXPORT{\_}ALL{\_}VARIABLES}}{33, 51} \entry {\code {.IGNORE}}{33, 46} \entry {\code {.PHONY}}{30, 32} \entry {\code {.PRECIOUS}}{33, 47} \entry {\code {.SILENT}}{33, 43} \entry {\code {.SUFFIXES}}{33, 118} \initial {/} \entry {\code {/usr/gnu/include}}{17} \entry {\code {/usr/include}}{17} \entry {\code {/usr/local/include}}{17} \initial {?} \entry {\code {? \r {(automatic variable)}}}{112} \entry {\code {?D \r {(automatic variable)}}}{114} \entry {\code {?F \r {(automatic variable)}}}{114} \initial {{\tt\char'100}} \entry {\code {{\tt\char'100} \r {(automatic variable)}}}{112} \entry {\code {{\tt\char'100}D \r {(automatic variable)}}}{113} \entry {\code {{\tt\char'100}F \r {(automatic variable)}}}{113} \initial {{\tt\hat}} \entry {\code {{\tt\hat} \r {(automatic variable)}}}{112} \entry {\code {{\tt\hat}D \r {(automatic variable)}}}{113} \entry {\code {{\tt\hat}F \r {(automatic variable)}}}{114} \initial {{\tt\less}} \entry {\code {{\tt\less} \r {(automatic variable)}}}{112} \entry {\code {{\tt\less}D \r {(automatic variable)}}}{113} \entry {\code {{\tt\less}F \r {(automatic variable)}}}{113} \initial {A} \entry {\code {addprefix}}{84} \entry {\code {addsuffix}}{84} \entry {\code {AR}}{107} \entry {\code {ARFLAGS}}{108} \entry {\code {AS}}{107} \entry {\code {ASFLAGS}}{108} \initial {B} \entry {\code {basename}}{84} \initial {C} \entry {\code {CC}}{107} \entry {\code {CFLAGS}}{108} \entry {\code {CO}}{107} \entry {\code {COFLAGS}}{108} \entry {\code {CPP}}{107} \entry {\code {CPPFLAGS}}{108} \entry {\code {CTANGLE}}{107} \entry {\code {CWEAVE}}{107} \entry {\code {CXX}}{107} \entry {\code {CXXFLAGS}}{108} \initial {D} \entry {\code {define}}{69} \entry {\code {dir}}{83} \initial {E} \entry {\code {else}}{74} \entry {\code {endef}}{69} \entry {\code {endif}}{74} \entry {\code {export}}{50} \initial {F} \entry {\code {FC}}{107} \entry {\code {FFLAGS}}{108} \entry {\code {filter}}{82} \entry {\code {filter-out}}{82} \entry {\code {findstring}}{81} \entry {\code {firstword}}{85} \entry {\code {foreach}}{85} \initial {G} \entry {\code {GET}}{107} \entry {\code {GFLAGS}}{108} \entry {\code {GNUmakefile}}{16} \initial {I} \entry {\code {ifdef}}{74} \entry {\code {ifeq}}{74} \entry {\code {ifndef}}{74} \entry {\code {ifneq}}{74} \entry {\code {include}}{16} \initial {J} \entry {\code {join}}{84} \initial {L} \entry {\code {LDFLAGS}}{108} \entry {\code {LEX}}{107} \entry {\code {LFLAGS}}{108} \initial {M} \entry {\code {MAKE}}{48, 60} \entry {\code {MAKE{\_}COMMAND}}{48} \entry {\code {makefile}}{16} \entry {\code {Makefile}}{16} \entry {\code {MAKEFILES}}{18, 52} \entry {\code {MAKEFLAGS}}{52} \entry {\code {MAKEINFO}}{107} \entry {\code {MAKELEVEL}}{51, 60} \entry {\code {MAKEOVERRIDES}}{48} \entry {\code {MFLAGS}}{53} \initial {N} \entry {\code {notdir}}{83} \initial {O} \entry {\code {origin}}{87} \entry {\code {OUTPUT{\_}OPTION}}{106} \entry {\code {override}}{68} \initial {P} \entry {\code {patsubst}}{61, 80} \entry {\code {PC}}{107} \entry {\code {PFLAGS}}{108} \initial {R} \entry {\code {RFLAGS}}{108} \entry {\code {RM}}{107} \initial {S} \entry {\code {shell}}{89} \entry {\code {SHELL}}{44} \entry {\code {SHELL \r {(command execution)}}}{44} \entry {\code {sort}}{82} \entry {\code {strip}}{81} \entry {\code {subst}}{34, 80} \entry {\code {suffix}}{84} \entry {\code {SUFFIXES}}{119} \initial {T} \entry {\code {TANGLE}}{107} \entry {\code {TEX}}{107} \entry {\code {TEXI2DVI}}{107} \initial {U} \entry {\code {unexport}}{50} \initial {V} \entry {\code {vpath}}{25, 26} \entry {\code {VPATH}}{25} \initial {W} \entry {\code {WEAVE}}{107} \entry {\code {wildcard}}{24, 85} \entry {\code {word}}{85} \entry {\code {words}}{85} \initial {Y} \entry {\code {YACC}}{107} \entry {\code {YACCR}}{107} \entry {\code {YFLAGS}}{108} make-3.70/make.toc 666 12241 13 14053 5504167704 7130 \chapentry {Overview of \code {make}}{1}{1} \secentry {How to Read This Manual}{1}{1}{1} \secentry {Problems and Bugs}{1}{2}{2} \chapentry {An Introduction to Makefiles}{2}{5} \secentry {What a Rule Looks Like}{2}{1}{5} \secentry {A Simple Makefile}{2}{2}{6} \secentry {How \code {make} Processes a Makefile}{2}{3}{8} \secentry {Variables Make Makefiles Simpler}{2}{4}{9} \secentry {Letting \code {make} Deduce the Commands}{2}{5}{10} \secentry {Another Style of Makefile}{2}{6}{12} \secentry {Rules for Cleaning the Directory}{2}{7}{12} \chapentry {Writing Makefiles}{3}{15} \secentry {What Makefiles Contain}{3}{1}{15} \secentry {What Name to Give Your Makefile}{3}{2}{16} \secentry {Including Other Makefiles}{3}{3}{16} \secentry {The Variable \code {MAKEFILES}}{3}{4}{18} \secentry {How Makefiles Are Remade}{3}{5}{18} \secentry {Overriding Part of Another Makefile}{3}{6}{20} \chapentry {Writing Rules}{4}{21} \secentry {Rule Syntax}{4}{1}{21} \secentry {Using Wildcard Characters in File Names}{4}{2}{22} \subsecentry {Wildcard Examples}{4}{2}{1}{23} \subsecentry {Pitfalls of Using Wildcards}{4}{2}{2}{24} \subsecentry {The Function \code {wildcard}}{4}{2}{3}{24} \secentry {Searching Directories for Dependencies}{4}{3}{25} \subsecentry {\code {VPATH}: Search Path for All Dependencies}{4}{3}{1}{25} \subsecentry {The \code {vpath} Directive}{4}{3}{2}{26} \subsecentry {Writing Shell Commands with Directory Search}{4}{3}{3}{28} \subsecentry {Directory Search and Implicit Rules}{4}{3}{4}{28} \subsecentry {Directory Search for Link Libraries}{4}{3}{5}{29} \secentry {Phony Targets}{4}{4}{29} \secentry {Rules without Commands or Dependencies}{4}{5}{31} \secentry {Empty Target Files to Record Events}{4}{6}{32} \secentry {Special Built-in Target Names}{4}{7}{32} \secentry {Multiple Targets in a Rule}{4}{8}{34} \secentry {Multiple Rules for One Target}{4}{9}{35} \secentry {Static Pattern Rules}{4}{10}{36} \subsecentry {Syntax of Static Pattern Rules}{4}{10}{1}{36} \subsecentry {Static Pattern Rules versus Implicit Rules}{4}{10}{2}{38} \secentry {Double-Colon Rules}{4}{11}{38} \secentry {Generating Dependencies Automatically}{4}{12}{39} \chapentry {Writing the Commands in Rules}{5}{43} \secentry {Command Echoing}{5}{1}{43} \secentry {Command Execution}{5}{2}{44} \secentry {Parallel Execution}{5}{3}{44} \secentry {Errors in Commands}{5}{4}{46} \secentry {Interrupting or Killing \code {make}}{5}{5}{47} \secentry {Recursive Use of \code {make}}{5}{6}{48} \subsecentry {How the \code {MAKE} Variable Works}{5}{6}{1}{48} \subsecentry {Communicating Variables to a Sub-\code {make}}{5}{6}{2}{49} \subsecentry {Communicating Options to a Sub-\code {make}}{5}{6}{3}{52} \subsecentry {The \samp {--print-directory} Option}{5}{6}{4}{53} \secentry {Defining Canned Command Sequences}{5}{7}{54} \secentry {Using Empty Commands}{5}{8}{56} \chapentry {How to Use Variables}{6}{57} \secentry {Basics of Variable References}{6}{1}{57} \secentry {The Two Flavors of Variables}{6}{2}{58} \secentry {Advanced Features for Reference to Variables}{6}{3}{61} \subsecentry {Substitution References}{6}{3}{1}{61} \subsecentry {Computed Variable Names}{6}{3}{2}{62} \secentry {How Variables Get Their Values}{6}{4}{65} \secentry {Setting Variables}{6}{5}{66} \secentry {Appending More Text to Variables}{6}{6}{66} \secentry {The \code {override} Directive}{6}{7}{68} \secentry {Defining Variables Verbatim}{6}{8}{69} \secentry {Variables from the Environment}{6}{9}{70} \chapentry {Conditional Parts of Makefiles}{7}{73} \secentry {Example of a Conditional}{7}{1}{73} \secentry {Syntax of Conditionals}{7}{2}{74} \secentry {Conditionals that Test Flags}{7}{3}{77} \chapentry {Functions for Transforming Text}{8}{79} \secentry {Function Call Syntax}{8}{1}{79} \secentry {Functions for String Substitution and Analysis}{8}{2}{80} \secentry {Functions for File Names}{8}{3}{83} \secentry {The \code {foreach} Function}{8}{4}{85} \secentry {The \code {origin} Function}{8}{5}{87} \secentry {The \code {shell} Function}{8}{6}{89} \chapentry {How to Run \code {make}}{9}{91} \secentry {Arguments to Specify the Makefile}{9}{1}{91} \secentry {Arguments to Specify the Goals}{9}{2}{91} \secentry {Instead of Executing the Commands}{9}{3}{93} \secentry {Avoiding Recompilation of Some Files}{9}{4}{95} \secentry {Overriding Variables}{9}{5}{95} \secentry {Testing the Compilation of a Program}{9}{6}{96} \secentry {Summary of Options}{9}{7}{97} \chapentry {Using Implicit Rules}{10}{101} \secentry {Using Implicit Rules}{10}{1}{101} \secentry {Catalogue of Implicit Rules}{10}{2}{103} \secentry {Variables Used by Implicit Rules}{10}{3}{106} \secentry {Chains of Implicit Rules}{10}{4}{108} \secentry {Defining and Redefining Pattern Rules}{10}{5}{109} \subsecentry {Introduction to Pattern Rules}{10}{5}{1}{110} \subsecentry {Pattern Rule Examples}{10}{5}{2}{111} \subsecentry {Automatic Variables}{10}{5}{3}{112} \subsecentry {How Patterns Match}{10}{5}{4}{114} \subsecentry {Match-Anything Pattern Rules}{10}{5}{5}{114} \subsecentry {Canceling Implicit Rules}{10}{5}{6}{116} \secentry {Defining Last-Resort Default Rules}{10}{6}{116} \secentry {Old-Fashioned Suffix Rules}{10}{7}{117} \secentry {Implicit Rule Search Algorithm}{10}{8}{119} \chapentry {Using \code {make} to Update Archive Files}{11}{121} \secentry {Archive Members as Targets}{11}{1}{121} \secentry {Implicit Rule for Archive Member Targets}{11}{2}{122} \subsecentry {Updating Archive Symbol Directories}{11}{2}{1}{123} \secentry {Suffix Rules for Archive Files}{11}{3}{123} \chapentry {Features of GNU \code {make}}{12}{125} \chapentry {Incompatibilities and Missing Features}{13}{129} \chapentry {Makefile Conventions}{14}{131} \secentry {General Conventions for Makefiles}{14}{1}{131} \secentry {Utilities in Makefiles}{14}{2}{132} \secentry {Standard Targets for Users}{14}{3}{133} \secentry {Variables for Specifying Commands}{14}{4}{135} \secentry {Variables for Installation Directories}{14}{5}{137} \chapentry {Quick Reference}{Appendix \char65}{141} \chapentry {Complex Makefile Example}{Appendix \char66}{147} \unnumbchapentry {Index of Concepts}{153} \unnumbchapentry {Index of Functions, Variables, & Directives}{163} make-3.70/make.aux 666 12241 12 36503 5504167706 7145 'xrdef {Overview-title}{Overview of \code {make}} 'xrdef {Overview-pg}{1} 'xrdef {Overview-snt}{Chapter'tie1} 'xrdef {Reading-title}{How to Read This Manual} 'xrdef {Reading-pg}{1} 'xrdef {Reading-snt}{Section'tie1.1} 'xrdef {Bugs-title}{Problems and Bugs} 'xrdef {Bugs-pg}{2} 'xrdef {Bugs-snt}{Section'tie1.2} 'xrdef {Introduction-title}{An Introduction to Makefiles} 'xrdef {Introduction-pg}{5} 'xrdef {Introduction-snt}{Chapter'tie2} 'xrdef {Rule Introduction-title}{What a Rule Looks Like} 'xrdef {Rule Introduction-pg}{5} 'xrdef {Rule Introduction-snt}{Section'tie2.1} 'xrdef {Simple Makefile-title}{A Simple Makefile} 'xrdef {Simple Makefile-pg}{6} 'xrdef {Simple Makefile-snt}{Section'tie2.2} 'xrdef {How Make Works-title}{How \code {make} Processes a Makefile} 'xrdef {How Make Works-pg}{8} 'xrdef {How Make Works-snt}{Section'tie2.3} 'xrdef {Variables Simplify-title}{Variables Make Makefiles Simpler} 'xrdef {Variables Simplify-pg}{9} 'xrdef {Variables Simplify-snt}{Section'tie2.4} 'xrdef {make Deduces-title}{Letting \code {make} Deduce the Commands} 'xrdef {make Deduces-pg}{10} 'xrdef {make Deduces-snt}{Section'tie2.5} 'xrdef {Combine By Dependency-title}{Another Style of Makefile} 'xrdef {Combine By Dependency-pg}{12} 'xrdef {Combine By Dependency-snt}{Section'tie2.6} 'xrdef {Cleanup-title}{Rules for Cleaning the Directory} 'xrdef {Cleanup-pg}{12} 'xrdef {Cleanup-snt}{Section'tie2.7} 'xrdef {Makefiles-title}{Writing Makefiles} 'xrdef {Makefiles-pg}{15} 'xrdef {Makefiles-snt}{Chapter'tie3} 'xrdef {Makefile Contents-title}{What Makefiles Contain} 'xrdef {Makefile Contents-pg}{15} 'xrdef {Makefile Contents-snt}{Section'tie3.1} 'xrdef {Makefile Names-title}{What Name to Give Your Makefile} 'xrdef {Makefile Names-pg}{16} 'xrdef {Makefile Names-snt}{Section'tie3.2} 'xrdef {Include-title}{Including Other Makefiles} 'xrdef {Include-pg}{16} 'xrdef {Include-snt}{Section'tie3.3} 'xrdef {MAKEFILES Variable-title}{The Variable \code {MAKEFILES}} 'xrdef {MAKEFILES Variable-pg}{18} 'xrdef {MAKEFILES Variable-snt}{Section'tie3.4} 'xrdef {Remaking Makefiles-title}{How Makefiles Are Remade} 'xrdef {Remaking Makefiles-pg}{18} 'xrdef {Remaking Makefiles-snt}{Section'tie3.5} 'xrdef {Overriding Makefiles-title}{Overriding Part of Another Makefile} 'xrdef {Overriding Makefiles-pg}{20} 'xrdef {Overriding Makefiles-snt}{Section'tie3.6} 'xrdef {Rules-title}{Writing Rules} 'xrdef {Rules-pg}{21} 'xrdef {Rules-snt}{Chapter'tie4} 'xrdef {Rule Syntax-title}{Rule Syntax} 'xrdef {Rule Syntax-pg}{21} 'xrdef {Rule Syntax-snt}{Section'tie4.1} 'xrdef {Wildcards-title}{Using Wildcard Characters in File Names} 'xrdef {Wildcards-pg}{22} 'xrdef {Wildcards-snt}{Section'tie4.2} 'xrdef {Wildcard Examples-title}{Wildcard Examples} 'xrdef {Wildcard Examples-pg}{23} 'xrdef {Wildcard Examples-snt}{Section'tie4.2.1} 'xrdef {Wildcard Pitfall-title}{Pitfalls of Using Wildcards} 'xrdef {Wildcard Pitfall-pg}{24} 'xrdef {Wildcard Pitfall-snt}{Section'tie4.2.2} 'xrdef {Wildcard Function-title}{The Function \code {wildcard}} 'xrdef {Wildcard Function-pg}{24} 'xrdef {Wildcard Function-snt}{Section'tie4.2.3} 'xrdef {Directory Search-title}{Searching Directories for Dependencies} 'xrdef {Directory Search-pg}{25} 'xrdef {Directory Search-snt}{Section'tie4.3} 'xrdef {General Search-title}{\code {VPATH}: Search Path for All Dependencies} 'xrdef {General Search-pg}{25} 'xrdef {General Search-snt}{Section'tie4.3.1} 'xrdef {Selective Search-title}{The \code {vpath} Directive} 'xrdef {Selective Search-pg}{26} 'xrdef {Selective Search-snt}{Section'tie4.3.2} 'xrdef {Commands/Search-title}{Writing Shell Commands with Directory Search} 'xrdef {Commands/Search-pg}{28} 'xrdef {Commands/Search-snt}{Section'tie4.3.3} 'xrdef {Implicit/Search-title}{Directory Search and Implicit Rules} 'xrdef {Implicit/Search-pg}{28} 'xrdef {Implicit/Search-snt}{Section'tie4.3.4} 'xrdef {Libraries/Search-title}{Directory Search for Link Libraries} 'xrdef {Libraries/Search-pg}{29} 'xrdef {Libraries/Search-snt}{Section'tie4.3.5} 'xrdef {Phony Targets-title}{Phony Targets} 'xrdef {Phony Targets-pg}{29} 'xrdef {Phony Targets-snt}{Section'tie4.4} 'xrdef {Force Targets-title}{Rules without Commands or Dependencies} 'xrdef {Force Targets-pg}{31} 'xrdef {Force Targets-snt}{Section'tie4.5} 'xrdef {Empty Targets-title}{Empty Target Files to Record Events} 'xrdef {Empty Targets-pg}{32} 'xrdef {Empty Targets-snt}{Section'tie4.6} 'xrdef {Special Targets-title}{Special Built-in Target Names} 'xrdef {Special Targets-pg}{32} 'xrdef {Special Targets-snt}{Section'tie4.7} 'xrdef {Multiple Targets-title}{Multiple Targets in a Rule} 'xrdef {Multiple Targets-pg}{34} 'xrdef {Multiple Targets-snt}{Section'tie4.8} 'xrdef {Multiple Rules-title}{Multiple Rules for One Target} 'xrdef {Multiple Rules-pg}{35} 'xrdef {Multiple Rules-snt}{Section'tie4.9} 'xrdef {Static Pattern-title}{Static Pattern Rules} 'xrdef {Static Pattern-pg}{36} 'xrdef {Static Pattern-snt}{Section'tie4.10} 'xrdef {Static Usage-title}{Syntax of Static Pattern Rules} 'xrdef {Static Usage-pg}{36} 'xrdef {Static Usage-snt}{Section'tie4.10.1} 'xrdef {Static versus Implicit-title}{Static Pattern Rules versus Implicit Rules} 'xrdef {Static versus Implicit-pg}{38} 'xrdef {Static versus Implicit-snt}{Section'tie4.10.2} 'xrdef {Double-Colon-title}{Double-Colon Rules} 'xrdef {Double-Colon-pg}{38} 'xrdef {Double-Colon-snt}{Section'tie4.11} 'xrdef {Automatic Dependencies-title}{Generating Dependencies Automatically} 'xrdef {Automatic Dependencies-pg}{39} 'xrdef {Automatic Dependencies-snt}{Section'tie4.12} 'xrdef {Commands-title}{Writing the Commands in Rules} 'xrdef {Commands-pg}{43} 'xrdef {Commands-snt}{Chapter'tie5} 'xrdef {Echoing-title}{Command Echoing} 'xrdef {Echoing-pg}{43} 'xrdef {Echoing-snt}{Section'tie5.1} 'xrdef {Execution-title}{Command Execution} 'xrdef {Execution-pg}{44} 'xrdef {Execution-snt}{Section'tie5.2} 'xrdef {Parallel-title}{Parallel Execution} 'xrdef {Parallel-pg}{44} 'xrdef {Parallel-snt}{Section'tie5.3} 'xrdef {Errors-title}{Errors in Commands} 'xrdef {Errors-pg}{46} 'xrdef {Errors-snt}{Section'tie5.4} 'xrdef {Interrupts-title}{Interrupting or Killing \code {make}} 'xrdef {Interrupts-pg}{47} 'xrdef {Interrupts-snt}{Section'tie5.5} 'xrdef {Recursion-title}{Recursive Use of \code {make}} 'xrdef {Recursion-pg}{48} 'xrdef {Recursion-snt}{Section'tie5.6} 'xrdef {MAKE Variable-title}{How the \code {MAKE} Variable Works} 'xrdef {MAKE Variable-pg}{48} 'xrdef {MAKE Variable-snt}{Section'tie5.6.1} 'xrdef {Variables/Recursion-title}{Communicating Variables to a Sub-\code {make}} 'xrdef {Variables/Recursion-pg}{49} 'xrdef {Variables/Recursion-snt}{Section'tie5.6.2} 'xrdef {Options/Recursion-title}{Communicating Options to a Sub-\code {make}} 'xrdef {Options/Recursion-pg}{52} 'xrdef {Options/Recursion-snt}{Section'tie5.6.3} 'xrdef {-w Option-title}{The \samp {--print-directory} Option} 'xrdef {-w Option-pg}{53} 'xrdef {-w Option-snt}{Section'tie5.6.4} 'xrdef {Sequences-title}{Defining Canned Command Sequences} 'xrdef {Sequences-pg}{54} 'xrdef {Sequences-snt}{Section'tie5.7} 'xrdef {Empty Commands-title}{Using Empty Commands} 'xrdef {Empty Commands-pg}{56} 'xrdef {Empty Commands-snt}{Section'tie5.8} 'xrdef {Using Variables-title}{How to Use Variables} 'xrdef {Using Variables-pg}{57} 'xrdef {Using Variables-snt}{Chapter'tie6} 'xrdef {Reference-title}{Basics of Variable References} 'xrdef {Reference-pg}{57} 'xrdef {Reference-snt}{Section'tie6.1} 'xrdef {Flavors-title}{The Two Flavors of Variables} 'xrdef {Flavors-pg}{58} 'xrdef {Flavors-snt}{Section'tie6.2} 'xrdef {Advanced-title}{Advanced Features for Reference to Variables} 'xrdef {Advanced-pg}{61} 'xrdef {Advanced-snt}{Section'tie6.3} 'xrdef {Substitution Refs-title}{Substitution References} 'xrdef {Substitution Refs-pg}{61} 'xrdef {Substitution Refs-snt}{Section'tie6.3.1} 'xrdef {Computed Names-title}{Computed Variable Names} 'xrdef {Computed Names-pg}{62} 'xrdef {Computed Names-snt}{Section'tie6.3.2} 'xrdef {Values-title}{How Variables Get Their Values} 'xrdef {Values-pg}{65} 'xrdef {Values-snt}{Section'tie6.4} 'xrdef {Setting-title}{Setting Variables} 'xrdef {Setting-pg}{66} 'xrdef {Setting-snt}{Section'tie6.5} 'xrdef {Appending-title}{Appending More Text to Variables} 'xrdef {Appending-pg}{66} 'xrdef {Appending-snt}{Section'tie6.6} 'xrdef {Override Directive-title}{The \code {override} Directive} 'xrdef {Override Directive-pg}{68} 'xrdef {Override Directive-snt}{Section'tie6.7} 'xrdef {Defining-title}{Defining Variables Verbatim} 'xrdef {Defining-pg}{69} 'xrdef {Defining-snt}{Section'tie6.8} 'xrdef {Environment-title}{Variables from the Environment} 'xrdef {Environment-pg}{70} 'xrdef {Environment-snt}{Section'tie6.9} 'xrdef {Conditionals-title}{Conditional Parts of Makefiles} 'xrdef {Conditionals-pg}{73} 'xrdef {Conditionals-snt}{Chapter'tie7} 'xrdef {Conditional Example-title}{Example of a Conditional} 'xrdef {Conditional Example-pg}{73} 'xrdef {Conditional Example-snt}{Section'tie7.1} 'xrdef {Conditional Syntax-title}{Syntax of Conditionals} 'xrdef {Conditional Syntax-pg}{74} 'xrdef {Conditional Syntax-snt}{Section'tie7.2} 'xrdef {Testing Flags-title}{Conditionals that Test Flags} 'xrdef {Testing Flags-pg}{77} 'xrdef {Testing Flags-snt}{Section'tie7.3} 'xrdef {Functions-title}{Functions for Transforming Text} 'xrdef {Functions-pg}{79} 'xrdef {Functions-snt}{Chapter'tie8} 'xrdef {Syntax of Functions-title}{Function Call Syntax} 'xrdef {Syntax of Functions-pg}{79} 'xrdef {Syntax of Functions-snt}{Section'tie8.1} 'xrdef {Text Functions-title}{Functions for String Substitution and Analysis} 'xrdef {Text Functions-pg}{80} 'xrdef {Text Functions-snt}{Section'tie8.2} 'xrdef {Filename Functions-title}{Functions for File Names} 'xrdef {Filename Functions-pg}{83} 'xrdef {Filename Functions-snt}{Section'tie8.3} 'xrdef {Foreach Function-title}{The \code {foreach} Function} 'xrdef {Foreach Function-pg}{85} 'xrdef {Foreach Function-snt}{Section'tie8.4} 'xrdef {Origin Function-title}{The \code {origin} Function} 'xrdef {Origin Function-pg}{87} 'xrdef {Origin Function-snt}{Section'tie8.5} 'xrdef {Shell Function-title}{The \code {shell} Function} 'xrdef {Shell Function-pg}{89} 'xrdef {Shell Function-snt}{Section'tie8.6} 'xrdef {Running-title}{How to Run \code {make}} 'xrdef {Running-pg}{91} 'xrdef {Running-snt}{Chapter'tie9} 'xrdef {Makefile Arguments-title}{Arguments to Specify the Makefile} 'xrdef {Makefile Arguments-pg}{91} 'xrdef {Makefile Arguments-snt}{Section'tie9.1} 'xrdef {Goals-title}{Arguments to Specify the Goals} 'xrdef {Goals-pg}{91} 'xrdef {Goals-snt}{Section'tie9.2} 'xrdef {Instead of Execution-title}{Instead of Executing the Commands} 'xrdef {Instead of Execution-pg}{93} 'xrdef {Instead of Execution-snt}{Section'tie9.3} 'xrdef {Avoiding Compilation-title}{Avoiding Recompilation of Some Files} 'xrdef {Avoiding Compilation-pg}{95} 'xrdef {Avoiding Compilation-snt}{Section'tie9.4} 'xrdef {Overriding-title}{Overriding Variables} 'xrdef {Overriding-pg}{95} 'xrdef {Overriding-snt}{Section'tie9.5} 'xrdef {Testing-title}{Testing the Compilation of a Program} 'xrdef {Testing-pg}{96} 'xrdef {Testing-snt}{Section'tie9.6} 'xrdef {Options Summary-title}{Summary of Options} 'xrdef {Options Summary-pg}{97} 'xrdef {Options Summary-snt}{Section'tie9.7} 'xrdef {Implicit Rules-title}{Using Implicit Rules} 'xrdef {Implicit Rules-pg}{101} 'xrdef {Implicit Rules-snt}{Chapter'tie10} 'xrdef {Using Implicit-title}{Using Implicit Rules} 'xrdef {Using Implicit-pg}{101} 'xrdef {Using Implicit-snt}{Section'tie10.1} 'xrdef {Catalogue of Rules-title}{Catalogue of Implicit Rules} 'xrdef {Catalogue of Rules-pg}{103} 'xrdef {Catalogue of Rules-snt}{Section'tie10.2} 'xrdef {Implicit Variables-title}{Variables Used by Implicit Rules} 'xrdef {Implicit Variables-pg}{106} 'xrdef {Implicit Variables-snt}{Section'tie10.3} 'xrdef {Chained Rules-title}{Chains of Implicit Rules} 'xrdef {Chained Rules-pg}{108} 'xrdef {Chained Rules-snt}{Section'tie10.4} 'xrdef {Pattern Rules-title}{Defining and Redefining Pattern Rules} 'xrdef {Pattern Rules-pg}{109} 'xrdef {Pattern Rules-snt}{Section'tie10.5} 'xrdef {Pattern Intro-title}{Introduction to Pattern Rules} 'xrdef {Pattern Intro-pg}{110} 'xrdef {Pattern Intro-snt}{Section'tie10.5.1} 'xrdef {Pattern Examples-title}{Pattern Rule Examples} 'xrdef {Pattern Examples-pg}{111} 'xrdef {Pattern Examples-snt}{Section'tie10.5.2} 'xrdef {Automatic-title}{Automatic Variables} 'xrdef {Automatic-pg}{112} 'xrdef {Automatic-snt}{Section'tie10.5.3} 'xrdef {Pattern Match-title}{How Patterns Match} 'xrdef {Pattern Match-pg}{114} 'xrdef {Pattern Match-snt}{Section'tie10.5.4} 'xrdef {Match-Anything Rules-title}{Match-Anything Pattern Rules} 'xrdef {Match-Anything Rules-pg}{114} 'xrdef {Match-Anything Rules-snt}{Section'tie10.5.5} 'xrdef {Canceling Rules-title}{Canceling Implicit Rules} 'xrdef {Canceling Rules-pg}{116} 'xrdef {Canceling Rules-snt}{Section'tie10.5.6} 'xrdef {Last Resort-title}{Defining Last-Resort Default Rules} 'xrdef {Last Resort-pg}{116} 'xrdef {Last Resort-snt}{Section'tie10.6} 'xrdef {Suffix Rules-title}{Old-Fashioned Suffix Rules} 'xrdef {Suffix Rules-pg}{117} 'xrdef {Suffix Rules-snt}{Section'tie10.7} 'xrdef {Search Algorithm-title}{Implicit Rule Search Algorithm} 'xrdef {Search Algorithm-pg}{119} 'xrdef {Search Algorithm-snt}{Section'tie10.8} 'xrdef {Archives-title}{Using \code {make} to Update Archive Files} 'xrdef {Archives-pg}{121} 'xrdef {Archives-snt}{Chapter'tie11} 'xrdef {Archive Members-title}{Archive Members as Targets} 'xrdef {Archive Members-pg}{121} 'xrdef {Archive Members-snt}{Section'tie11.1} 'xrdef {Archive Update-title}{Implicit Rule for Archive Member Targets} 'xrdef {Archive Update-pg}{122} 'xrdef {Archive Update-snt}{Section'tie11.2} 'xrdef {Archive Symbols-title}{Updating Archive Symbol Directories} 'xrdef {Archive Symbols-pg}{123} 'xrdef {Archive Symbols-snt}{Section'tie11.2.1} 'xrdef {Archive Suffix Rules-title}{Suffix Rules for Archive Files} 'xrdef {Archive Suffix Rules-pg}{123} 'xrdef {Archive Suffix Rules-snt}{Section'tie11.3} 'xrdef {Features-title}{Features of GNU \code {make}} 'xrdef {Features-pg}{125} 'xrdef {Features-snt}{Chapter'tie12} 'xrdef {Missing-title}{Incompatibilities and Missing Features} 'xrdef {Missing-pg}{129} 'xrdef {Missing-snt}{Chapter'tie13} 'xrdef {Makefile Conventions-title}{Makefile Conventions} 'xrdef {Makefile Conventions-pg}{131} 'xrdef {Makefile Conventions-snt}{Chapter'tie14} 'xrdef {Makefile Basics-title}{General Conventions for Makefiles} 'xrdef {Makefile Basics-pg}{131} 'xrdef {Makefile Basics-snt}{Section'tie14.1} 'xrdef {Utilities in Makefiles-title}{Utilities in Makefiles} 'xrdef {Utilities in Makefiles-pg}{132} 'xrdef {Utilities in Makefiles-snt}{Section'tie14.2} 'xrdef {Standard Targets-title}{Standard Targets for Users} 'xrdef {Standard Targets-pg}{133} 'xrdef {Standard Targets-snt}{Section'tie14.3} 'xrdef {Command Variables-title}{Variables for Specifying Commands} 'xrdef {Command Variables-pg}{135} 'xrdef {Command Variables-snt}{Section'tie14.4} 'xrdef {Directory Variables-title}{Variables for Installation Directories} 'xrdef {Directory Variables-pg}{137} 'xrdef {Directory Variables-snt}{Section'tie14.5} 'xrdef {Quick Reference-title}{Quick Reference} 'xrdef {Quick Reference-pg}{141} 'xrdef {Quick Reference-snt}{Appendix'tie'char65{}} 'xrdef {Complex Makefile-title}{Complex Makefile Example} 'xrdef {Complex Makefile-pg}{147} 'xrdef {Complex Makefile-snt}{Appendix'tie'char66{}} 'xrdef {Concept Index-title}{Index of Concepts} 'xrdef {Concept Index-pg}{153} 'xrdef {Concept Index-snt}{} 'xrdef {Name Index-title}{Index of Functions, Variables, & Directives} 'xrdef {Name Index-pg}{163} 'xrdef {Name Index-snt}{} make-3.70/make.man 666 12241 13 16767 5376472326 7142 .TH MAKE 1L "22 August 1989" "GNU" "LOCAL USER COMMANDS" .SH NAME make \- GNU make utility to maintain groups of programs .SH SYNOPSIS .B "make " [ .B \-f makefile ] [ option ] ... target ... .SH WARNING This man paage is an extract of the documentation of .I GNU make . It is updated only occasionally, because the GNU project does not use nroff. For complete, current documentation, refer to the Info file .B make or the DVI file .B make.dvi which are made from the Texinfo source file .BR make.texinfo . .SH DESCRIPTION .LP The purpose of the .I make utility is to determine automatically which pieces of a large program need to be recompiled, and issue the commands to recompile them. This manual describes the GNU implementation of .IR make , which was written by Richard Stallman and Roland McGrath. Our examples show C programs, since they are most common, but you can use .I make with any programming language whose compiler can be run with a shell command. In fact, .I make is not limited to programs. You can use it to describe any task where some files must be updated automatically from others whenever the others change. .LP To prepare to use .IR make , you must write a file called the .I makefile that describes the relationships among files in your program, and the states the commands for updating each file. In a program, typically the executable file is updated from object files, which are in turn made by compiling source files. .LP Once a suitable makefile exists, each time you change some source files, this simple shell command: .sp 1 .RS .B make .RE .sp 1 suffices to perform all necessary recompilations. The .I make program uses the makefile data base and the last-modification times of the files to decide which of the files need to be updated. For each of those files, it issues the commands recorded in the data base. .LP .I make executes commands in the .I makefile to update one or more target .IR names , where .I name is typically a program. If no .B \-f option is present, .I make will look for the makefiles .IR GNUmakefile , .IR makefile , and .IR Makefile , in that order. .LP Normally you should call your makefile either .I makefile or .IR Makefile . (We recommend .I Makefile because it appears prominently near the beginning of a directory listing, right near other important files such as .IR README .) The first name checked, .IR GNUmakefile , is not recommended for most makefiles. You should use this name if you have a makefile that is specific to GNU .IR make , and will not be understood by other versions of .IR make . If .I makefile is `\-', the standard input is read. .LP .I make updates a target if it depends on prerequisite files that have been modified since the target was last modified, or if the target does not exist. .SH OPTIONS .sp 1 .TP 0.5i .B \-b .TP 0.5i .B \-m These options are ignored for compatibility with other versions of .IR make . .TP 0.5i .BI "\-C " dir Change to directory .I dir before reading the makefiles or doing anything else. If multiple .B \-C options are specified, each is interpreted relative to the previous one: .BR "\-C " / .BR "\-C " etc is equivalent to .BR "\-C " /etc. This is typically used with recursive invocations of .IR make . .TP 0.5i .B \-d Print debugging information in addition to normal processing. The debugging information says which files are being considered for remaking, which file-times are being compared and with what results, which files actually need to be remade, which implicit rules are considered and which are applied---everything interesting about how .I make decides what to do. .TP 0.5i .B \-e Give variables taken from the environment precedence over variables from makefiles. .TP 0.5i .BI "\-f " file Use .I file as a makefile. .TP 0.5i .B \-i Ignore all errors in commands executed to remake files. .TP 0.5i .BI "\-I " dir Specifies a directory .I dir to search for included makefiles. If several .B \-I options are used to specify several directories, the directories are searched in the order specified. Unlike the arguments to other flags of .IR make , directories given with .B \-I flags may come directly after the flag: .BI \-I dir is allowed, as well as .BI "\-I " dir. This syntax is allowed for compatibility with the C preprocessor's .B \-I flag. .TP 0.5i .BI "\-j " jobs Specifies the number of jobs (commands) to run simultaneously. If there is more than one .B \-j option, the last one is effective. If the .B \-j option is given without an argument, .IR make will not limit the number of jobs that can run simultaneously. .TP 0.5i .B \-k Continue as much as possible after an error. While the target that failed, and those that depend on it, cannot be remade, the other dependencies of these targets can be processed all the same. .TP 0.5i .B \-l .TP 0.5i .BI "\-l " load Specifies that no new jobs (commands) should be started if there are others jobs running and the load average is at least .I load (a floating-point number). With no argument, removes a previous load limit. .TP 0.5i .B \-n Print the commands that would be executed, but do not execute them. .TP 0.5i .BI "\-o " file Do not remake the file .I file even if it is older than its dependencies, and do not remake anything on account of changes in .IR file . Essentially the file is treated as very old and its rules are ignored. .TP 0.5i .B \-p Print the data base (rules and variable values) that results from reading the makefiles; then execute as usual or as otherwise specified. This also prints the version information given by the .B \-v switch (see below). To print the data base without trying to remake any files, use .B make .B \-p .BI \-f /dev/null. .TP 0.5i .B \-q ``Question mode''. Do not run any commands, or print anything; just return an exit status that is zero if the specified targets are already up to date, nonzero otherwise. .TP 0.5i .B \-r Eliminate use of the built-in implicit rules. Also clear out the default list of suffixes for suffix rules. .TP 0.5i .B \-s Silent operation; do not print the commands as they are executed. .TP 0.5i .B \-S Cancel the effect of the .B \-k option. This is never necessary except in a recursive .I make where .B \-k might be inherited from the top-level .I make via MAKEFLAGS or if you set .B \-k in MAKEFLAGS in your environment. .TP 0.5i .B \-t Touch files (mark them up to date without really changing them) instead of running their commands. This is used to pretend that the commands were done, in order to fool future invocations of .IR make . .TP 0.5i .B \-v Print the version of the .I make program plus a copyright, a list of authors and a notice that there is no warranty. After this information is printed, processing continues normally. To get this information without doing anything else, use .B make .B \-v .BI \-f /dev/null. .TP 0.5i .B \-w Print a message containing the working directory before and after other processing. This may be useful for tracking down errors from complicated nests of recursive .I make commands. .TP 0.5i .BI "\-W " file Pretend that the target .I file has just been modified. When used with the .B \-n flag, this shows you what would happen if you were to modify that file. Without .BR \-n , it is almost the same as running a .I touch command on the given file before running .IR make , except that the modification time is changed only in the imagination of .IR make . .SH "SEE ALSO" .PD 0 .TP 2.0i /usr/local/doc/gnumake.dvi .I The GNU Make Manual .PD .SH BUGS See the chapter `Problems and Bugs' in .I "The GNU Make Manual" . .SH AUTHOR This manual page contributed by Dennis Morse of Stanford University. It has been reworked by Roland McGrath. make-3.70/texinfo.tex 444 12130 13 403674 5507202666 7724 %% TeX macros to handle texinfo files % Copyright (C) 1985, 86, 88, 90, 91, 92, 1993 Free Software Foundation, Inc. %This texinfo.tex file 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 2, or (at %your option) any later version. %This texinfo.tex file 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 this texinfo.tex file; see the file COPYING. If not, write %to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, %USA. %In other words, you are welcome to use, share and improve this program. %You are forbidden to forbid anyone else to use, share and improve %what you give them. Help stamp out software-hoarding! \def\texinfoversion{2.118} \message{Loading texinfo package [Version \texinfoversion]:} % Print the version number if in a .fmt file. \everyjob{\message{[Texinfo version \texinfoversion]}\message{}} % Save some parts of plain tex whose names we will redefine. \let\ptexlbrace=\{ \let\ptexrbrace=\} \let\ptexdots=\dots \let\ptexdot=\. \let\ptexstar=\* \let\ptexend=\end \let\ptexbullet=\bullet \let\ptexb=\b \let\ptexc=\c \let\ptexi=\i \let\ptext=\t \let\ptexl=\l \let\ptexL=\L \def\tie{\penalty 10000\ } % Save plain tex definition of ~. \message{Basics,} \chardef\other=12 % If this character appears in an error message or help string, it % starts a new line in the output. \newlinechar = `^^J % Ignore a token. % \def\gobble#1{} \hyphenation{ap-pen-dix} \hyphenation{mini-buf-fer mini-buf-fers} \hyphenation{eshell} % Margin to add to right of even pages, to left of odd pages. \newdimen \bindingoffset \bindingoffset=0pt \newdimen \normaloffset \normaloffset=\hoffset \newdimen\pagewidth \newdimen\pageheight \pagewidth=\hsize \pageheight=\vsize % Sometimes it is convenient to have everything in the transcript file % and nothing on the terminal. We don't just call \tracingall here, % since that produces some useless output on the terminal. % \def\gloggingall{\begingroup \globaldefs = 1 \loggingall \endgroup}% \def\loggingall{\tracingcommands2 \tracingstats2 \tracingpages1 \tracingoutput1 \tracinglostchars1 \tracingmacros2 \tracingparagraphs1 \tracingrestores1 \showboxbreadth\maxdimen\showboxdepth\maxdimen }% %---------------------Begin change----------------------- % %%%% For @cropmarks command. % Dimensions to add cropmarks at corners Added by P. A. MacKay, 12 Nov. 1986 % \newdimen\cornerlong \newdimen\cornerthick \newdimen \topandbottommargin \newdimen \outerhsize \newdimen \outervsize \cornerlong=1pc\cornerthick=.3pt % These set size of cropmarks \outerhsize=7in %\outervsize=9.5in % Alternative @smallbook page size is 9.25in \outervsize=9.25in \topandbottommargin=.75in % %---------------------End change----------------------- % \onepageout takes a vbox as an argument. Note that \pagecontents % does insertions itself, but you have to call it yourself. \chardef\PAGE=255 \output={\onepageout{\pagecontents\PAGE}} \def\onepageout#1{\hoffset=\normaloffset \ifodd\pageno \advance\hoffset by \bindingoffset \else \advance\hoffset by -\bindingoffset\fi {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout\vbox{{\let\hsize=\pagewidth \makeheadline} \pagebody{#1}% {\let\hsize=\pagewidth \makefootline}}}% \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} %%%% For @cropmarks command %%%% % Here is a modification of the main output routine for Near East Publications % This provides right-angle cropmarks at all four corners. % The contents of the page are centerlined into the cropmarks, % and any desired binding offset is added as an \hskip on either % site of the centerlined box. (P. A. MacKay, 12 November, 1986) % \def\croppageout#1{\hoffset=0pt % make sure this doesn't mess things up {\escapechar=`\\\relax % makes sure backslash is used in output files. \shipout \vbox to \outervsize{\hsize=\outerhsize \vbox{\line{\ewtop\hfill\ewtop}} \nointerlineskip \line{\vbox{\moveleft\cornerthick\nstop} \hfill \vbox{\moveright\cornerthick\nstop}} \vskip \topandbottommargin \centerline{\ifodd\pageno\hskip\bindingoffset\fi \vbox{ {\let\hsize=\pagewidth \makeheadline} \pagebody{#1} {\let\hsize=\pagewidth \makefootline}} \ifodd\pageno\else\hskip\bindingoffset\fi} \vskip \topandbottommargin plus1fill minus1fill \boxmaxdepth\cornerthick \line{\vbox{\moveleft\cornerthick\nsbot} \hfill \vbox{\moveright\cornerthick\nsbot}} \nointerlineskip \vbox{\line{\ewbot\hfill\ewbot}} }} \advancepageno \ifnum\outputpenalty>-20000 \else\dosupereject\fi} % % Do @cropmarks to get crop marks \def\cropmarks{\let\onepageout=\croppageout } \def\pagebody#1{\vbox to\pageheight{\boxmaxdepth=\maxdepth #1}} {\catcode`\@ =11 \gdef\pagecontents#1{\ifvoid\topins\else\unvbox\topins\fi \dimen@=\dp#1 \unvbox#1 \ifvoid\footins\else\vskip\skip\footins\footnoterule \unvbox\footins\fi \ifr@ggedbottom \kern-\dimen@ \vfil \fi} } % % Here are the rules for the cropmarks. Note that they are % offset so that the space between them is truly \outerhsize or \outervsize % (P. A. MacKay, 12 November, 1986) % \def\ewtop{\vrule height\cornerthick depth0pt width\cornerlong} \def\nstop{\vbox {\hrule height\cornerthick depth\cornerlong width\cornerthick}} \def\ewbot{\vrule height0pt depth\cornerthick width\cornerlong} \def\nsbot{\vbox {\hrule height\cornerlong depth\cornerthick width\cornerthick}} % Parse an argument, then pass it to #1. The argument is the rest of % the input line (except we remove a trailing comment). #1 should be a % macro which expects an ordinary undelimited TeX argument. % \def\parsearg#1{% \let\next = #1% \begingroup \obeylines \futurelet\temp\parseargx } % If the next token is an obeyed space (from an @example environment or % the like), remove it and recurse. Otherwise, we're done. \def\parseargx{% % \obeyedspace is defined far below, after the definition of \sepspaces. \ifx\obeyedspace\temp \expandafter\parseargdiscardspace \else \expandafter\parseargline \fi } % Remove a single space (as the delimiter token to the macro call). {\obeyspaces % \gdef\parseargdiscardspace {\futurelet\temp\parseargx}} {\obeylines % \gdef\parseargline#1^^M{% \endgroup % End of the group started in \parsearg. % % First remove any @c comment, then any @comment. % Result of each macro is put in \toks0. \argremovec #1\c\relax % \expandafter\argremovecomment \the\toks0 \comment\relax % % % Call the caller's macro, saved as \next in \parsearg. \expandafter\next\expandafter{\the\toks0}% }% } % Since all \c{,omment} does is throw away the argument, we can let TeX % do that for us. The \relax here is matched by the \relax in the call % in \parseargline; it could be more or less anything, its purpose is % just to delimit the argument to the \c. \def\argremovec#1\c#2\relax{\toks0 = {#1}} \def\argremovecomment#1\comment#2\relax{\toks0 = {#1}} % \argremovec{,omment} might leave us with trailing spaces, though; e.g., % @end itemize @c foo % will have two active spaces as part of the argument with the % `itemize'. Here we remove all active spaces from #1, and assign the % result to \toks0. % % This loses if there are any *other* active characters besides spaces % in the argument -- _ ^ +, for example -- since they get expanded. % Fortunately, Texinfo does not define any such commands. (If it ever % does, the catcode of the characters in questionwill have to be changed % here.) But this means we cannot call \removeactivespaces as part of % \argremovec{,omment}, since @c uses \parsearg, and thus the argument % that \parsearg gets might well have any character at all in it. % \def\removeactivespaces#1{% \begingroup \ignoreactivespaces \edef\temp{#1}% \global\toks0 = \expandafter{\temp}% \endgroup } % Change the active space to expand to nothing. % \begingroup \obeyspaces \gdef\ignoreactivespaces{\obeyspaces\let =\empty} \endgroup \def\flushcr{\ifx\par\lisppar \def\next##1{}\else \let\next=\relax \fi \next} %% These are used to keep @begin/@end levels from running away %% Call \inENV within environments (after a \begingroup) \newif\ifENV \ENVfalse \def\inENV{\ifENV\relax\else\ENVtrue\fi} \def\ENVcheck{% \ifENV\errmessage{Still within an environment. Type Return to continue.} \endgroup\fi} % This is not perfect, but it should reduce lossage % @begin foo is the same as @foo, for now. \newhelp\EMsimple{Type to continue.} \outer\def\begin{\parsearg\beginxxx} \def\beginxxx #1{% \expandafter\ifx\csname #1\endcsname\relax {\errhelp=\EMsimple \errmessage{Undefined command @begin #1}}\else \csname #1\endcsname\fi} % @end foo executes the definition of \Efoo. % \def\end{\parsearg\endxxx} \def\endxxx #1{% \removeactivespaces{#1}% \edef\endthing{\the\toks0}% % \expandafter\ifx\csname E\endthing\endcsname\relax \expandafter\ifx\csname \endthing\endcsname\relax % There's no \foo, i.e., no ``environment'' foo. \errhelp = \EMsimple \errmessage{Undefined command `@end \endthing'}% \else \unmatchedenderror\endthing \fi \else % Everything's ok; the right environment has been started. \csname E\endthing\endcsname \fi } % There is an environment #1, but it hasn't been started. Give an error. % \def\unmatchedenderror#1{% \errhelp = \EMsimple \errmessage{This `@end #1' doesn't have a matching `@#1'}% } % Define the control sequence \E#1 to give an unmatched @end error. % \def\defineunmatchedend#1{% \expandafter\def\csname E#1\endcsname{\unmatchedenderror{#1}}% } % Single-spacing is done by various environments (specifically, in % \nonfillstart and \quotations). \newskip\singlespaceskip \singlespaceskip = \baselineskip \def\singlespace{% % Why was this kern here? It messes up equalizing space above and below % environments. --karl, 6may93 %{\advance \baselineskip by -\singlespaceskip %\kern \baselineskip}% \baselineskip=\singlespaceskip } %% Simple single-character @ commands % @@ prints an @ % Kludge this until the fonts are right (grr). \def\@{{\tt \char '100}} % This is turned off because it was never documented % and you can use @w{...} around a quote to suppress ligatures. %% Define @` and @' to be the same as ` and ' %% but suppressing ligatures. %\def\`{{`}} %\def\'{{'}} % Used to generate quoted braces. \def\mylbrace {{\tt \char '173}} \def\myrbrace {{\tt \char '175}} \let\{=\mylbrace \let\}=\myrbrace % @: forces normal size whitespace following. \def\:{\spacefactor=1000 } % @* forces a line break. \def\*{\hfil\break\hbox{}\ignorespaces} % @. is an end-of-sentence period. \def\.{.\spacefactor=3000 } % @w prevents a word break. Without the \leavevmode, @w at the % beginning of a paragraph, when TeX is still in vertical mode, would % produce a whole line of output instead of starting the paragraph. \def\w#1{\leavevmode\hbox{#1}} % @group ... @end group forces ... to be all on one page, by enclosing % it in a TeX vbox. We use \vtop instead of \vbox to construct the box % to keep its height that of a normal line. According to the rules for % \topskip (p.114 of the TeXbook), the glue inserted is % max (\topskip - \ht (first item), 0). If that height is large, % therefore, no glue is inserted, and the space between the headline and % the text is small, which looks bad. % \def\group{\begingroup \ifnum\catcode13=\active \else \errhelp = \groupinvalidhelp \errmessage{@group invalid in context where filling is enabled}% \fi % % The \vtop we start below produces a box with normal height and large % depth; thus, TeX puts \baselineskip glue before it, and (when the % next line of text is done) \lineskip glue after it. (See p.82 of % the TeXbook.) Thus, space below is not quite equal to space % above. But it's pretty close. \def\Egroup{% \egroup % End the \vtop. \endgroup % End the \group. }% % \vtop\bgroup % We have to put a strut on the last line in case the @group is in % the midst of an example, rather than completely enclosing it. % Otherwise, the interline space between the last line of the group % and the first line afterwards is too small. But we can't put the % strut in \Egroup, since there it would be on a line by itself. % Hence this just inserts a strut at the beginning of each line. \everypar = {\strut}% % % Since we have a strut on every line, we don't need any of TeX's % normal interline spacing. \offinterlineskip % % OK, but now we have to do something about blank % lines in the input in @example-like environments, which normally % just turn into \lisppar, which will insert no space now that we've % turned off the interline space. Simplest is to make them be an % empty paragraph. \ifx\par\lisppar \edef\par{\leavevmode \par}% % % Reset ^^M's definition to new definition of \par. \obeylines \fi % % We do @comment here in case we are called inside an environment, % such as @example, where each end-of-line in the input causes an % end-of-line in the output. We don't want the end-of-line after % the `@group' to put extra space in the output. Since @group % should appear on a line by itself (according to the Texinfo % manual), we don't worry about eating any user text. \comment } % % TeX puts in an \escapechar (i.e., `@') at the beginning of the help % message, so this ends up printing `@group can only ...'. % \newhelp\groupinvalidhelp{% group can only be used in environments such as @example,^^J% where each line of input produces a line of output.} % @need space-in-mils % forces a page break if there is not space-in-mils remaining. \newdimen\mil \mil=0.001in \def\need{\parsearg\needx} % Old definition--didn't work. %\def\needx #1{\par % %% This method tries to make TeX break the page naturally %% if the depth of the box does not fit. %{\baselineskip=0pt% %\vtop to #1\mil{\vfil}\kern -#1\mil\penalty 10000 %\prevdepth=-1000pt %}} \def\needx#1{% % Go into vertical mode, so we don't make a big box in the middle of a % paragraph. \par % % Don't add any leading before our big empty box, but allow a page % break, since the best break might be right here. \allowbreak \nointerlineskip \vtop to #1\mil{\vfil}% % % TeX does not even consider page breaks if a penalty added to the % main vertical list is 10000 or more. But in order to see if the % empty box we just added fits on the page, we must make it consider % page breaks. On the other hand, we don't want to actually break the % page after the empty box. So we use a penalty of 9999. % % There is an extremely small chance that TeX will actually break the % page at this \penalty, if there are no other feasible breakpoints in % sight. (If the user is using lots of big @group commands, which % almost-but-not-quite fill up a page, TeX will have a hard time doing % good page breaking, for example.) However, I could not construct an % example where a page broke at this \penalty; if it happens in a real % document, then we can reconsider our strategy. \penalty9999 % % Back up by the size of the box, whether we did a page break or not. \kern -#1\mil % % Do not allow a page break right after this kern. \nobreak } % @br forces paragraph break \let\br = \par % @dots{} output some dots \def\dots{.$\,$.$\,$.\:} % @page forces the start of a new page \def\page{\par\vfill\supereject} % @exdent text.... % outputs text on separate line in roman font, starting at standard page margin % This records the amount of indent in the innermost environment. % That's how much \exdent should take out. \newskip\exdentamount % This defn is used inside fill environments such as @defun. \def\exdent{\parsearg\exdentyyy} \def\exdentyyy #1{{\hfil\break\hbox{\kern -\exdentamount{\rm#1}}\hfil\break}} % This defn is used inside nofill environments such as @example. \def\nofillexdent{\parsearg\nofillexdentyyy} \def\nofillexdentyyy #1{{\advance \leftskip by -\exdentamount \leftline{\hskip\leftskip{\rm#1}}}} %\hbox{{\rm#1}}\hfil\break}} % @include file insert text of that file as input. \def\include{\parsearg\includezzz} %Use \input\thisfile to avoid blank after \input, which may be an active %char (in which case the blank would become the \input argument). %The grouping keeps the value of \thisfile correct even when @include %is nested. \def\includezzz #1{\begingroup \def\thisfile{#1}\input\thisfile \endgroup} \def\thisfile{} % @center line outputs that line, centered \def\center{\parsearg\centerzzz} \def\centerzzz #1{{\advance\hsize by -\leftskip \advance\hsize by -\rightskip \centerline{#1}}} % @sp n outputs n lines of vertical space \def\sp{\parsearg\spxxx} \def\spxxx #1{\par \vskip #1\baselineskip} % @comment ...line which is ignored... % @c is the same as @comment % @ignore ... @end ignore is another way to write a comment \def\comment{\catcode 64=\other \catcode 123=\other \catcode 125=\other% \parsearg \commentxxx} \def\commentxxx #1{\catcode 64=0 \catcode 123=1 \catcode 125=2 } \let\c=\comment % Prevent errors for section commands. % Used in @ignore and in failing conditionals. \def\ignoresections{% \let\chapter=\relax \let\unnumbered=\relax \let\top=\relax \let\unnumberedsec=\relax \let\unnumberedsection=\relax \let\unnumberedsubsec=\relax \let\unnumberedsubsection=\relax \let\unnumberedsubsubsec=\relax \let\unnumberedsubsubsection=\relax \let\section=\relax \let\subsec=\relax \let\subsubsec=\relax \let\subsection=\relax \let\subsubsection=\relax \let\appendix=\relax \let\appendixsec=\relax \let\appendixsection=\relax \let\appendixsubsec=\relax \let\appendixsubsection=\relax \let\appendixsubsubsec=\relax \let\appendixsubsubsection=\relax \let\contents=\relax \let\smallbook=\relax \let\titlepage=\relax } % Used in nested conditionals, where we have to parse the Texinfo source % and so want to turn off most commands, in case they are used % incorrectly. % \def\ignoremorecommands{% \let\defcv = \relax \let\deffn = \relax \let\deffnx = \relax \let\defindex = \relax \let\defivar = \relax \let\defmac = \relax \let\defmethod = \relax \let\defop = \relax \let\defopt = \relax \let\defspec = \relax \let\deftp = \relax \let\deftypefn = \relax \let\deftypefun = \relax \let\deftypevar = \relax \let\deftypevr = \relax \let\defun = \relax \let\defvar = \relax \let\defvr = \relax \let\ref = \relax \let\xref = \relax \let\printindex = \relax \let\pxref = \relax \let\settitle = \relax \let\include = \relax \let\lowersections = \relax \let\down = \relax \let\raisesections = \relax \let\up = \relax \let\set = \relax \let\clear = \relax } % Ignore @ignore ... @end ignore. % \def\ignore{\doignore{ignore}} % Also ignore @ifinfo, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} % Ignore text until a line `@end #1'. % \def\doignore#1{\begingroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define a command to swallow text until we reach `@end #1'. \long\def\doignoretext##1\end #1{\enddoignore}% % % Make sure that spaces turn into tokens that match what \doignoretext wants. \catcode32 = 10 % % And now expand that command. \doignoretext } % What we do to finish off ignored text. % \def\enddoignore{\endgroup\ignorespaces}% \newif\ifwarnedobs\warnedobsfalse \def\obstexwarn{% \ifwarnedobs\relax\else % We need to warn folks that they may have trouble with TeX 3.0. % This uses \immediate\write16 rather than \message to get newlines. \immediate\write16{} \immediate\write16{***WARNING*** for users of Unix TeX 3.0!} \immediate\write16{This manual trips a bug in TeX version 3.0 (tex hangs).} \immediate\write16{If you are running another version of TeX, relax.} \immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.} \immediate\write16{ Then upgrade your TeX installation if you can.} \immediate\write16{If you are stuck with version 3.0, run the} \immediate\write16{ script ``tex3patch'' from the Texinfo distribution} \immediate\write16{ to use a workaround.} \immediate\write16{} \warnedobstrue \fi } % **In TeX 3.0, setting text in \nullfont hangs tex. For a % workaround (which requires the file ``dummy.tfm'' to be installed), % uncomment the following line: %%%%%\font\nullfont=dummy\let\obstexwarn=\relax % Ignore text, except that we keep track of conditional commands for % purposes of nesting, up to an `@end #1' command. % \def\nestedignore#1{% \obstexwarn % We must actually expand the ignored text to look for the @end % command, so that nested ignore constructs work. Thus, we put the % text into a \vbox and then do nothing with the result. To minimize % the change of memory overflow, we follow the approach outlined on % page 401 of the TeXbook: make the current font be a dummy font. % \setbox0 = \vbox\bgroup % Don't complain about control sequences we have declared \outer. \ignoresections % % Define `@end #1' to end the box, which will in turn undefine the % @end command again. \expandafter\def\csname E#1\endcsname{\egroup\ignorespaces}% % % We are going to be parsing Texinfo commands. Most cause no % trouble when they are used incorrectly, but some commands do % complicated argument parsing or otherwise get confused, so we % undefine them. % % We can't do anything about stray @-signs, unfortunately; % they'll produce `undefined control sequence' errors. \ignoremorecommands % % Set the current font to be \nullfont, a TeX primitive, and define % all the font commands to also use \nullfont. We don't use % dummy.tfm, as suggested in the TeXbook, because not all sites % might have that installed. Therefore, math mode will still % produce output, but that should be an extremely small amount of % stuff compared to the main input. % \nullfont \let\tenrm = \nullfont \let\tenit = \nullfont \let\tensl = \nullfont \let\tenbf = \nullfont \let\tentt = \nullfont \let\smallcaps = \nullfont \let\tensf = \nullfont % Similarly for index fonts (mostly for their use in % smallexample) \let\indrm = \nullfont \let\indit = \nullfont \let\indsl = \nullfont \let\indbf = \nullfont \let\indtt = \nullfont \let\indsc = \nullfont \let\indsf = \nullfont % % Don't complain when characters are missing from the fonts. \tracinglostchars = 0 % % Don't bother to do space factor calculations. \frenchspacing % % Don't report underfull hboxes. \hbadness = 10000 % % Do minimal line-breaking. \pretolerance = 10000 % % Do not execute instructions in @tex \def\tex{\doignore{tex}} } % @set VAR sets the variable VAR to an empty value. % @set VAR REST-OF-LINE sets VAR to the value REST-OF-LINE. % % Since we want to separate VAR from REST-OF-LINE (which might be % empty), we can't just use \parsearg; we have to insert a space of our % own to delimit the rest of the line, and then take it out again if we % didn't need it. % \def\set{\parsearg\setxxx} \def\setxxx#1{\setyyy#1 \endsetyyy} \def\setyyy#1 #2\endsetyyy{% \def\temp{#2}% \ifx\temp\empty \global\expandafter\let\csname SET#1\endcsname = \empty \else \setzzz{#1}#2\endsetzzz % Remove the trailing space \setxxx inserted. \fi } \def\setzzz#1#2 \endsetzzz{\expandafter\xdef\csname SET#1\endcsname{#2}} % @clear VAR clears (i.e., unsets) the variable VAR. % \def\clear{\parsearg\clearxxx} \def\clearxxx#1{\global\expandafter\let\csname SET#1\endcsname=\relax} % @value{foo} gets the text saved in variable foo. % \def\value#1{\expandafter \ifx\csname SET#1\endcsname\relax {\{No value for ``#1''\}} \else \csname SET#1\endcsname \fi} % @ifset VAR ... @end ifset reads the `...' iff VAR has been defined % with @set. % \def\ifset{\parsearg\ifsetxxx} \def\ifsetxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifsetfail \else \expandafter\ifsetsucceed \fi } \def\ifsetsucceed{\conditionalsucceed{ifset}} \def\ifsetfail{\nestedignore{ifset}} \defineunmatchedend{ifset} % @ifclear VAR ... @end ifclear reads the `...' iff VAR has never been % defined with @set, or has been undefined with @clear. % \def\ifclear{\parsearg\ifclearxxx} \def\ifclearxxx #1{% \expandafter\ifx\csname SET#1\endcsname\relax \expandafter\ifclearsucceed \else \expandafter\ifclearfail \fi } \def\ifclearsucceed{\conditionalsucceed{ifclear}} \def\ifclearfail{\nestedignore{ifclear}} \defineunmatchedend{ifclear} % @iftex always succeeds; we read the text following, through @end % iftex). But `@end iftex' should be valid only after an @iftex. % \def\iftex{\conditionalsucceed{iftex}} \defineunmatchedend{iftex} % We can't just want to start a group at @iftex (for example) and end it % at @end iftex, since then @set commands inside the conditional have no % effect (they'd get reverted at the end of the group). So we must % define \Eiftex to redefine itself to be its previous value. (We can't % just define it to fail again with an ``unmatched end'' error, since % the @ifset might be nested.) % \def\conditionalsucceed#1{% \edef\temp{% % Remember the current value of \E#1. \let\nece{prevE#1} = \nece{E#1}% % % At the `@end #1', redefine \E#1 to be its previous value. \def\nece{E#1}{\let\nece{E#1} = \nece{prevE#1}}% }% \temp } % We need to expand lots of \csname's, but we don't want to expand the % control sequences after we've constructed them. % \def\nece#1{\expandafter\noexpand\csname#1\endcsname} % @asis just yields its argument. Used with @table, for example. % \def\asis#1{#1} % @math means output in math mode. % We don't use $'s directly in the definition of \math because control % sequences like \math are expanded when the toc file is written. Then, % we read the toc file back, the $'s will be normal characters (as they % should be, according to the definition of Texinfo). So we must use a % control sequence to switch into and out of math mode. % % This isn't quite enough for @math to work properly in indices, but it % seems unlikely it will ever be needed there. % \let\implicitmath = $ \def\math#1{\implicitmath #1\implicitmath} % @bullet and @minus need the same treatment as @math, just above. \def\bullet{\implicitmath\ptexbullet\implicitmath} \def\minus{\implicitmath-\implicitmath} \def\node{\ENVcheck\parsearg\nodezzz} \def\nodezzz#1{\nodexxx [#1,]} \def\nodexxx[#1,#2]{\gdef\lastnode{#1}} \let\nwnode=\node \let\lastnode=\relax \def\donoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\setref{\lastnode}\fi \let\lastnode=\relax} \def\unnumbnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\unnumbsetref{\lastnode}\fi \let\lastnode=\relax} \def\appendixnoderef{\ifx\lastnode\relax\else \expandafter\expandafter\expandafter\appendixsetref{\lastnode}\fi \let\lastnode=\relax} \let\refill=\relax % @setfilename is done at the beginning of every texinfo file. % So open here the files we need to have open while reading the input. % This makes it possible to make a .fmt file for texinfo. \def\setfilename{% \readauxfile \opencontents \openindices \fixbackslash % Turn off hack to swallow `\input texinfo'. \global\let\setfilename=\comment % Ignore extra @setfilename cmds. \comment % Ignore the actual filename. } \outer\def\bye{\pagealignmacro\tracingstats=1\ptexend} \def\inforef #1{\inforefzzz #1,,,,**} \def\inforefzzz #1,#2,#3,#4**{See Info file \file{\ignorespaces #3{}}, node \samp{\ignorespaces#1{}}} \message{fonts,} % Font-change commands. % Texinfo supports the sans serif font style, which plain TeX does not. % So we set up a \sf analogous to plain's \rm, etc. \newfam\sffam \def\sf{\fam=\sffam \tensf} \let\li = \sf % Sometimes we call it \li, not \sf. %% Try out Computer Modern fonts at \magstephalf \let\mainmagstep=\magstephalf \ifx\bigger\relax \let\mainmagstep=\magstep1 \font\textrm=cmr12 \font\texttt=cmtt12 \else \font\textrm=cmr10 scaled \mainmagstep \font\texttt=cmtt10 scaled \mainmagstep \fi % Instead of cmb10, you many want to use cmbx10. % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. \font\textbf=cmb10 scaled \mainmagstep \font\textit=cmti10 scaled \mainmagstep \font\textsl=cmsl10 scaled \mainmagstep \font\textsf=cmss10 scaled \mainmagstep \font\textsc=cmcsc10 scaled \mainmagstep \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep % A few fonts for @defun, etc. \font\defbf=cmbx10 scaled \magstep1 %was 1314 \font\deftt=cmtt10 scaled \magstep1 \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} % Fonts for indices and small examples. % We actually use the slanted font rather than the italic, % because texinfo normally uses the slanted fonts for that. % Do not make many font distinctions in general in the index, since they % aren't very useful. \font\ninett=cmtt9 \font\indrm=cmr9 \font\indit=cmsl9 \let\indsl=\indit \let\indtt=\ninett \let\indsf=\indrm \let\indbf=\indrm \let\indsc=\indrm \font\indi=cmmi9 \font\indsy=cmsy9 % Fonts for headings \font\chaprm=cmbx12 scaled \magstep2 \font\chapit=cmti12 scaled \magstep2 \font\chapsl=cmsl12 scaled \magstep2 \font\chaptt=cmtt12 scaled \magstep2 \font\chapsf=cmss12 scaled \magstep2 \let\chapbf=\chaprm \font\chapsc=cmcsc10 scaled\magstep3 \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 \font\secrm=cmbx12 scaled \magstep1 \font\secit=cmti12 scaled \magstep1 \font\secsl=cmsl12 scaled \magstep1 \font\sectt=cmtt12 scaled \magstep1 \font\secsf=cmss12 scaled \magstep1 \font\secbf=cmbx12 scaled \magstep1 \font\secsc=cmcsc10 scaled\magstep2 \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 % \font\ssecrm=cmbx10 scaled \magstep1 % This size an font looked bad. % \font\ssecit=cmti10 scaled \magstep1 % The letters were too crowded. % \font\ssecsl=cmsl10 scaled \magstep1 % \font\ssectt=cmtt10 scaled \magstep1 % \font\ssecsf=cmss10 scaled \magstep1 %\font\ssecrm=cmb10 scaled 1315 % Note the use of cmb rather than cmbx. %\font\ssecit=cmti10 scaled 1315 % Also, the size is a little larger than %\font\ssecsl=cmsl10 scaled 1315 % being scaled magstep1. %\font\ssectt=cmtt10 scaled 1315 %\font\ssecsf=cmss10 scaled 1315 %\let\ssecbf=\ssecrm \font\ssecrm=cmbx12 scaled \magstephalf \font\ssecit=cmti12 scaled \magstephalf \font\ssecsl=cmsl12 scaled \magstephalf \font\ssectt=cmtt12 scaled \magstephalf \font\ssecsf=cmss12 scaled \magstephalf \font\ssecbf=cmbx12 scaled \magstephalf \font\ssecsc=cmcsc10 scaled \magstep1 \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled \magstep1 % The smallcaps and symbol fonts should actually be scaled \magstep1.5, % but that is not a standard magnification. % Fonts for title page: \font\titlerm = cmbx12 scaled \magstep3 \let\authorrm = \secrm % In order for the font changes to affect most math symbols and letters, % we have to define the \textfont of the standard families. Since % texinfo doesn't allow for producing subscripts and superscripts, we % don't bother to reset \scriptfont and \scriptscriptfont (which would % also require loading a lot more fonts). % \def\resetmathfonts{% \textfont0 = \tenrm \textfont1 = \teni \textfont2 = \tensy \textfont\itfam = \tenit \textfont\slfam = \tensl \textfont\bffam = \tenbf \textfont\ttfam = \tentt \textfont\sffam = \tensf } % The font-changing commands redefine the meanings of \tenSTYLE, instead % of just \STYLE. We do this so that font changes will continue to work % in math mode, where it is the current \fam that is relevant in most % cases, not the current. Plain TeX does, for example, % \def\bf{\fam=\bffam \tenbf} By redefining \tenbf, we obviate the need % to redefine \bf itself. \def\textfonts{% \let\tenrm=\textrm \let\tenit=\textit \let\tensl=\textsl \let\tenbf=\textbf \let\tentt=\texttt \let\smallcaps=\textsc \let\tensf=\textsf \let\teni=\texti \let\tensy=\textsy \resetmathfonts} \def\chapfonts{% \let\tenrm=\chaprm \let\tenit=\chapit \let\tensl=\chapsl \let\tenbf=\chapbf \let\tentt=\chaptt \let\smallcaps=\chapsc \let\tensf=\chapsf \let\teni=\chapi \let\tensy=\chapsy \resetmathfonts} \def\secfonts{% \let\tenrm=\secrm \let\tenit=\secit \let\tensl=\secsl \let\tenbf=\secbf \let\tentt=\sectt \let\smallcaps=\secsc \let\tensf=\secsf \let\teni=\seci \let\tensy=\secsy \resetmathfonts} \def\subsecfonts{% \let\tenrm=\ssecrm \let\tenit=\ssecit \let\tensl=\ssecsl \let\tenbf=\ssecbf \let\tentt=\ssectt \let\smallcaps=\ssecsc \let\tensf=\ssecsf \let\teni=\sseci \let\tensy=\ssecsy \resetmathfonts} \def\indexfonts{% \let\tenrm=\indrm \let\tenit=\indit \let\tensl=\indsl \let\tenbf=\indbf \let\tentt=\indtt \let\smallcaps=\indsc \let\tensf=\indsf \let\teni=\indi \let\tensy=\indsy \resetmathfonts} % Set up the default fonts, so we can use them for creating boxes. % \textfonts % Count depth in font-changes, for error checks \newcount\fontdepth \fontdepth=0 % Fonts for short table of contents. \font\shortcontrm=cmr12 \font\shortcontbf=cmbx12 \font\shortcontsl=cmsl12 %% Add scribe-like font environments, plus @l for inline lisp (usually sans %% serif) and @ii for TeX italic % \smartitalic{ARG} outputs arg in italics, followed by an italic correction % unless the following character is such as not to need one. \def\smartitalicx{\ifx\next,\else\ifx\next-\else\ifx\next.\else\/\fi\fi\fi} \def\smartitalic#1{{\sl #1}\futurelet\next\smartitalicx} \let\i=\smartitalic \let\var=\smartitalic \let\dfn=\smartitalic \let\emph=\smartitalic \let\cite=\smartitalic \def\b#1{{\bf #1}} \let\strong=\b % We can't just use \exhyphenpenalty, because that only has effect at % the end of a paragraph. Restore normal hyphenation at the end of the % group within which \nohyphenation is presumably called. % \def\nohyphenation{\hyphenchar\font = -1 \aftergroup\restorehyphenation} \def\restorehyphenation{\hyphenchar\font = `- } \def\t#1{% {\tt \nohyphenation \rawbackslash \frenchspacing #1}% \null } \let\ttfont = \t %\def\samp #1{`{\tt \rawbackslash \frenchspacing #1}'\null} \def\samp #1{`\tclose{#1}'\null} \def\key #1{{\tt \nohyphenation \uppercase{#1}}\null} \def\ctrl #1{{\tt \rawbackslash \hat}#1} \let\file=\samp % @code is a modification of @t, % which makes spaces the same size as normal in the surrounding text. \def\tclose#1{% {% % Change normal interword space to be same as for the current font. \spaceskip = \fontdimen2\font % % Switch to typewriter. \tt % % But `\ ' produces the large typewriter interword space. \def\ {{\spaceskip = 0pt{} }}% % % Turn off hyphenation. \nohyphenation % \rawbackslash \frenchspacing #1% }% \null } % We *must* turn on hyphenation at `-' and `_' in \code. % Otherwise, it is too hard to avoid overful hboxes % in the Emacs manual, the Library manual, etc. % Unfortunately, TeX uses one parameter (\hyphenchar) to control % both hyphenation at - and hyphenation within words. % We must therefore turn them both off (\tclose does that) % and arrange explicitly to hyphenate an a dash. % -- rms. { \catcode`\-=\active \catcode`\_=\active \global\def\code{\begingroup \catcode`\-=\active \let-\codedash \catcode`\_=\active \let_\codeunder \codex} % The following is used by \doprintindex to insure that long function names % wrap around. It is necessary for - and _ to be active before the index is % read from the file, as \entry parses the arguments long before \code is % ever called. -- mycroft \global\def\indexbreaks{\catcode`\-=\active \let-\realdash \catcode`\_=\active \let_\realunder} } \def\realdash{-} \def\realunder{_} \def\codedash{-\discretionary{}{}{}} \def\codeunder{\normalunderscore\discretionary{}{}{}} \def\codex #1{\tclose{#1}\endgroup} %\let\exp=\tclose %Was temporary % @kbd is like @code, except that if the argument is just one @key command, % then @kbd has no effect. \def\xkey{\key} \def\kbdfoo#1#2#3\par{\def\one{#1}\def\three{#3}\def\threex{??}% \ifx\one\xkey\ifx\threex\three \key{#2}% \else\tclose{\look}\fi \else\tclose{\look}\fi} % Typeset a dimension, e.g., `in' or `pt'. The only reason for the % argument is to make the input look right: @dmn{pt} instead of % @dmn{}pt. % \def\dmn#1{\thinspace #1} \def\kbd#1{\def\look{#1}\expandafter\kbdfoo\look??\par} \def\l#1{{\li #1}\null} % \def\r#1{{\rm #1}} % roman font % Use of \lowercase was suggested. \def\sc#1{{\smallcaps#1}} % smallcaps font \def\ii#1{{\it #1}} % italic font \message{page headings,} \newskip\titlepagetopglue \titlepagetopglue = 1.5in \newskip\titlepagebottomglue \titlepagebottomglue = 2pc % First the title page. Must do @settitle before @titlepage. \def\titlefont#1{{\titlerm #1}} \newif\ifseenauthor \newif\iffinishedtitlepage \def\shorttitlepage{\parsearg\shorttitlepagezzz} \def\shorttitlepagezzz #1{\begingroup\hbox{}\vskip 1.5in \chaprm \centerline{#1}% \endgroup\page\hbox{}\page} \def\titlepage{\begingroup \parindent=0pt \textfonts \let\subtitlerm=\tenrm % I deinstalled the following change because \cmr12 is undefined. % This change was not in the ChangeLog anyway. --rms. % \let\subtitlerm=\cmr12 \def\subtitlefont{\subtitlerm \normalbaselineskip = 13pt \normalbaselines}% % \def\authorfont{\authorrm \normalbaselineskip = 16pt \normalbaselines}% % % Leave some space at the very top of the page. \vglue\titlepagetopglue % % Now you can print the title using @title. \def\title{\parsearg\titlezzz}% \def\titlezzz##1{\leftline{\titlefont{##1}} % print a rule at the page bottom also. \finishedtitlepagefalse \vskip4pt \hrule height 4pt width \hsize \vskip4pt}% % No rule at page bottom unless we print one at the top with @title. \finishedtitlepagetrue % % Now you can put text using @subtitle. \def\subtitle{\parsearg\subtitlezzz}% \def\subtitlezzz##1{{\subtitlefont \rightline{##1}}}% % % @author should come last, but may come many times. \def\author{\parsearg\authorzzz}% \def\authorzzz##1{\ifseenauthor\else\vskip 0pt plus 1filll\seenauthortrue\fi {\authorfont \leftline{##1}}}% % % Most title ``pages'' are actually two pages long, with space % at the top of the second. We don't want the ragged left on the second. \let\oldpage = \page \def\page{% \iffinishedtitlepage\else \finishtitlepage \fi \oldpage \let\page = \oldpage \hbox{}}% % \def\page{\oldpage \hbox{}} } \def\Etitlepage{% \iffinishedtitlepage\else \finishtitlepage \fi % It is important to do the page break before ending the group, % because the headline and footline are only empty inside the group. % If we use the new definition of \page, we always get a blank page % after the title page, which we certainly don't want. \oldpage \endgroup \HEADINGSon } \def\finishtitlepage{% \vskip4pt \hrule height 2pt width \hsize \vskip\titlepagebottomglue \finishedtitlepagetrue } %%% Set up page headings and footings. \let\thispage=\folio \newtoks \evenheadline % Token sequence for heading line of even pages \newtoks \oddheadline % Token sequence for heading line of odd pages \newtoks \evenfootline % Token sequence for footing line of even pages \newtoks \oddfootline % Token sequence for footing line of odd pages % Now make Tex use those variables \headline={{\textfonts\rm \ifodd\pageno \the\oddheadline \else \the\evenheadline \fi}} \footline={{\textfonts\rm \ifodd\pageno \the\oddfootline \else \the\evenfootline \fi}\HEADINGShook} \let\HEADINGShook=\relax % Commands to set those variables. % For example, this is what @headings on does % @evenheading @thistitle|@thispage|@thischapter % @oddheading @thischapter|@thispage|@thistitle % @evenfooting @thisfile|| % @oddfooting ||@thisfile \def\evenheading{\parsearg\evenheadingxxx} \def\oddheading{\parsearg\oddheadingxxx} \def\everyheading{\parsearg\everyheadingxxx} \def\evenfooting{\parsearg\evenfootingxxx} \def\oddfooting{\parsearg\oddfootingxxx} \def\everyfooting{\parsearg\everyfootingxxx} {\catcode`\@=0 % \gdef\evenheadingxxx #1{\evenheadingyyy #1@|@|@|@|\finish} \gdef\evenheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddheadingxxx #1{\oddheadingyyy #1@|@|@|@|\finish} \gdef\oddheadingyyy #1@|#2@|#3@|#4\finish{% \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyheadingxxx #1{\everyheadingyyy #1@|@|@|@|\finish} \gdef\everyheadingyyy #1@|#2@|#3@|#4\finish{% \global\evenheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddheadline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\evenfootingxxx #1{\evenfootingyyy #1@|@|@|@|\finish} \gdef\evenfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\oddfootingxxx #1{\oddfootingyyy #1@|@|@|@|\finish} \gdef\oddfootingyyy #1@|#2@|#3@|#4\finish{% \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} \gdef\everyfootingxxx #1{\everyfootingyyy #1@|@|@|@|\finish} \gdef\everyfootingyyy #1@|#2@|#3@|#4\finish{% \global\evenfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}} \global\oddfootline={\rlap{\centerline{#2}}\line{#1\hfil#3}}} % }% unbind the catcode of @. % @headings double turns headings on for double-sided printing. % @headings single turns headings on for single-sided printing. % @headings off turns them off. % @headings on same as @headings double, retained for compatibility. % @headings after turns on double-sided headings after this page. % @headings doubleafter turns on double-sided headings after this page. % @headings singleafter turns on single-sided headings after this page. % By default, they are off. \def\headings #1 {\csname HEADINGS#1\endcsname} \def\HEADINGSoff{ \global\evenheadline={\hfil} \global\evenfootline={\hfil} \global\oddheadline={\hfil} \global\oddfootline={\hfil}} \HEADINGSoff % When we turn headings on, set the page number to 1. % For double-sided printing, put current file name in lower left corner, % chapter name on inside top of right hand pages, document % title on inside top of left hand pages, and page numbers on outside top % edge of all pages. \def\HEADINGSdouble{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % For single-sided printing, chapter title goes across top left of page, % page number on top right. \def\HEADINGSsingle{ %\pagealignmacro \global\pageno=1 \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSon{\HEADINGSdouble} \def\HEADINGSafter{\let\HEADINGShook=\HEADINGSdoublex} \let\HEADINGSdoubleafter=\HEADINGSafter \def\HEADINGSdoublex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\folio\hfil\thistitle}} \global\oddheadline={\line{\thischapter\hfil\folio}} } \def\HEADINGSsingleafter{\let\HEADINGShook=\HEADINGSsinglex} \def\HEADINGSsinglex{% \global\evenfootline={\hfil} \global\oddfootline={\hfil} \global\evenheadline={\line{\thischapter\hfil\folio}} \global\oddheadline={\line{\thischapter\hfil\folio}} } % Subroutines used in generating headings % Produces Day Month Year style of output. \def\today{\number\day\space \ifcase\month\or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi \space\number\year} % Use this if you want the Month Day, Year style of output. %\def\today{\ifcase\month\or %January\or February\or March\or April\or May\or June\or %July\or August\or September\or October\or November\or December\fi %\space\number\day, \number\year} % @settitle line... specifies the title of the document, for headings % It generates no output of its own \def\thistitle{No Title} \def\settitle{\parsearg\settitlezzz} \def\settitlezzz #1{\gdef\thistitle{#1}} \message{tables,} % @tabs -- simple alignment % These don't work. For one thing, \+ is defined as outer. % So these macros cannot even be defined. %\def\tabs{\parsearg\tabszzz} %\def\tabszzz #1{\settabs\+#1\cr} %\def\tabline{\parsearg\tablinezzz} %\def\tablinezzz #1{\+#1\cr} %\def\&{&} % Tables -- @table, @ftable, @vtable, @item(x), @kitem(x), @xitem(x). % default indentation of table text \newdimen\tableindent \tableindent=.8in % default indentation of @itemize and @enumerate text \newdimen\itemindent \itemindent=.3in % margin between end of table item and start of table text. \newdimen\itemmargin \itemmargin=.1in % used internally for \itemindent minus \itemmargin \newdimen\itemmax % Note @table, @vtable, and @vtable define @item, @itemx, etc., with % these defs. % They also define \itemindex % to index the item name in whatever manner is desired (perhaps none). \newif\ifitemxneedsnegativevskip \def\itemxpar{\par\ifitemxneedsnegativevskip\vskip-\parskip\nobreak\fi} \def\internalBitem{\smallbreak \parsearg\itemzzz} \def\internalBitemx{\itemxpar \parsearg\itemzzz} \def\internalBxitem "#1"{\def\xitemsubtopix{#1} \smallbreak \parsearg\xitemzzz} \def\internalBxitemx "#1"{\def\xitemsubtopix{#1} \itemxpar \parsearg\xitemzzz} \def\internalBkitem{\smallbreak \parsearg\kitemzzz} \def\internalBkitemx{\itemxpar \parsearg\kitemzzz} \def\kitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \lastfunction}}% \itemzzz {#1}} \def\xitemzzz #1{\dosubind {kw}{\code{#1}}{for {\bf \xitemsubtopic}}% \itemzzz {#1}} \def\itemzzz #1{\begingroup % \advance\hsize by -\rightskip \advance\hsize by -\tableindent \setbox0=\hbox{\itemfont{#1}}% \itemindex{#1}% \nobreak % This prevents a break before @itemx. % % Be sure we are not still in the middle of a paragraph. %{\parskip = 0in %\par %}% % % If the item text does not fit in the space we have, put it on a line % by itself, and do not allow a page break either before or after that % line. We do not start a paragraph here because then if the next % command is, e.g., @kindex, the whatsit would get put into the % horizontal list on a line by itself, resulting in extra blank space. \ifdim \wd0>\itemmax % % Make this a paragraph so we get the \parskip glue and wrapping, % but leave it ragged-right. \begingroup \advance\leftskip by-\tableindent \advance\hsize by\tableindent \advance\rightskip by0pt plus1fil \leavevmode\unhbox0\par \endgroup % % We're going to be starting a paragraph, but we don't want the % \parskip glue -- logically it's part of the @item we just started. \nobreak \vskip-\parskip % % Stop a page break at the \parskip glue coming up. Unfortunately % we can't prevent a possible page break at the following % \baselineskip glue. \nobreak \endgroup \itemxneedsnegativevskipfalse \else % The item text fits into the space. Start a paragraph, so that the % following text (if any) will end up on the same line. Since that % text will be indented by \tableindent, we make the item text be in % a zero-width box. \noindent \rlap{\hskip -\tableindent\box0}\ignorespaces% \endgroup% \itemxneedsnegativevskiptrue% \fi } \def\item{\errmessage{@item while not in a table}} \def\itemx{\errmessage{@itemx while not in a table}} \def\kitem{\errmessage{@kitem while not in a table}} \def\kitemx{\errmessage{@kitemx while not in a table}} \def\xitem{\errmessage{@xitem while not in a table}} \def\xitemx{\errmessage{@xitemx while not in a table}} %% Contains a kludge to get @end[description] to work \def\description{\tablez{\dontindex}{1}{}{}{}{}} \def\table{\begingroup\inENV\obeylines\obeyspaces\tablex} {\obeylines\obeyspaces% \gdef\tablex #1^^M{% \tabley\dontindex#1 \endtabley}} \def\ftable{\begingroup\inENV\obeylines\obeyspaces\ftablex} {\obeylines\obeyspaces% \gdef\ftablex #1^^M{% \tabley\fnitemindex#1 \endtabley \def\Eftable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\vtable{\begingroup\inENV\obeylines\obeyspaces\vtablex} {\obeylines\obeyspaces% \gdef\vtablex #1^^M{% \tabley\vritemindex#1 \endtabley \def\Evtable{\endgraf\afterenvbreak\endgroup}% \let\Etable=\relax}} \def\dontindex #1{} \def\fnitemindex #1{\doind {fn}{\code{#1}}}% \def\vritemindex #1{\doind {vr}{\code{#1}}}% {\obeyspaces % \gdef\tabley#1#2 #3 #4 #5 #6 #7\endtabley{\endgroup% \tablez{#1}{#2}{#3}{#4}{#5}{#6}}} \def\tablez #1#2#3#4#5#6{% \aboveenvbreak % \begingroup % \def\Edescription{\Etable}% Neccessary kludge. \let\itemindex=#1% \ifnum 0#3>0 \advance \leftskip by #3\mil \fi % \ifnum 0#4>0 \tableindent=#4\mil \fi % \ifnum 0#5>0 \advance \rightskip by #5\mil \fi % \def\itemfont{#2}% \itemmax=\tableindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \tableindent % \exdentamount=\tableindent \parindent = 0pt \parskip = \smallskipamount \ifdim \parskip=0pt \parskip=2pt \fi% \def\Etable{\endgraf\afterenvbreak\endgroup}% \let\item = \internalBitem % \let\itemx = \internalBitemx % \let\kitem = \internalBkitem % \let\kitemx = \internalBkitemx % \let\xitem = \internalBxitem % \let\xitemx = \internalBxitemx % } % This is the counter used by @enumerate, which is really @itemize \newcount \itemno \def\itemize{\parsearg\itemizezzz} \def\itemizezzz #1{% \begingroup % ended by the @end itemize \itemizey {#1}{\Eitemize} } \def\itemizey #1#2{% \aboveenvbreak % \itemmax=\itemindent % \advance \itemmax by -\itemmargin % \advance \leftskip by \itemindent % \exdentamount=\itemindent \parindent = 0pt % \parskip = \smallskipamount % \ifdim \parskip=0pt \parskip=2pt \fi% \def#2{\endgraf\afterenvbreak\endgroup}% \def\itemcontents{#1}% \let\item=\itemizeitem} % Set sfcode to normal for the chars that usually have another value. % These are `.?!:;,' \def\frenchspacing{\sfcode46=1000 \sfcode63=1000 \sfcode33=1000 \sfcode58=1000 \sfcode59=1000 \sfcode44=1000 } % \splitoff TOKENS\endmark defines \first to be the first token in % TOKENS, and \rest to be the remainder. % \def\splitoff#1#2\endmark{\def\first{#1}\def\rest{#2}}% % Allow an optional argument of an uppercase letter, lowercase letter, % or number, to specify the first label in the enumerated list. No % argument is the same as `1'. % \def\enumerate{\parsearg\enumeratezzz} \def\enumeratezzz #1{\enumeratey #1 \endenumeratey} \def\enumeratey #1 #2\endenumeratey{% \begingroup % ended by the @end enumerate % % If we were given no argument, pretend we were given `1'. \def\thearg{#1}% \ifx\thearg\empty \def\thearg{1}\fi % % Detect if the argument is a single token. If so, it might be a % letter. Otherwise, the only valid thing it can be is a number. % (We will always have one token, because of the test we just made. % This is a good thing, since \splitoff doesn't work given nothing at % all -- the first parameter is undelimited.) \expandafter\splitoff\thearg\endmark \ifx\rest\empty % Only one token in the argument. It could still be anything. % A ``lowercase letter'' is one whose \lccode is nonzero. % An ``uppercase letter'' is one whose \lccode is both nonzero, and % not equal to itself. % Otherwise, we assume it's a number. % % We need the \relax at the end of the \ifnum lines to stop TeX from % continuing to look for a . % \ifnum\lccode\expandafter`\thearg=0\relax \numericenumerate % a number (we hope) \else % It's a letter. \ifnum\lccode\expandafter`\thearg=\expandafter`\thearg\relax \lowercaseenumerate % lowercase letter \else \uppercaseenumerate % uppercase letter \fi \fi \else % Multiple tokens in the argument. We hope it's a number. \numericenumerate \fi } % An @enumerate whose labels are integers. The starting integer is % given in \thearg. % \def\numericenumerate{% \itemno = \thearg \startenumeration{\the\itemno}% } % The starting (lowercase) letter is in \thearg. \def\lowercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more lowercase letters in @enumerate; get a bigger alphabet}% \fi \char\lccode\itemno }% } % The starting (uppercase) letter is in \thearg. \def\uppercaseenumerate{% \itemno = \expandafter`\thearg \startenumeration{% % Be sure we're not beyond the end of the alphabet. \ifnum\itemno=0 \errmessage{No more uppercase letters in @enumerate; get a bigger alphabet} \fi \char\uccode\itemno }% } % Call itemizey, adding a period to the first argument and supplying the % common last two arguments. Also subtract one from the initial value in % \itemno, since @item increments \itemno. % \def\startenumeration#1{% \advance\itemno by -1 \itemizey{#1.}\Eenumerate\flushcr } % @alphaenumerate and @capsenumerate are abbreviations for giving an arg % to @enumerate. % \def\alphaenumerate{\enumerate{a}} \def\capsenumerate{\enumerate{A}} \def\Ealphaenumerate{\Eenumerate} \def\Ecapsenumerate{\Eenumerate} % Definition of @item while inside @itemize. \def\itemizeitem{% \advance\itemno by 1 {\let\par=\endgraf \smallbreak}% \ifhmode \errmessage{\in hmode at itemizeitem}\fi {\parskip=0in \hskip 0pt \hbox to 0pt{\hss \itemcontents\hskip \itemmargin}% \vadjust{\penalty 1200}}% \flushcr} \message{indexing,} % Index generation facilities % Define \newwrite to be identical to plain tex's \newwrite % except not \outer, so it can be used within \newindex. {\catcode`\@=11 \gdef\newwrite{\alloc@7\write\chardef\sixt@@n}} % \newindex {foo} defines an index named foo. % It automatically defines \fooindex such that % \fooindex ...rest of line... puts an entry in the index foo. % It also defines \fooindfile to be the number of the output channel for % the file that accumulates this index. The file's extension is foo. % The name of an index should be no more than 2 characters long % for the sake of vms. \def\newindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#1}} } % @defindex foo == \newindex{foo} \def\defindex{\parsearg\newindex} % Define @defcodeindex, like @defindex except put all entries in @code. \def\newcodeindex #1{ \expandafter\newwrite \csname#1indfile\endcsname% Define number for output file \openout \csname#1indfile\endcsname \jobname.#1 % Open the file \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#1}} } \def\defcodeindex{\parsearg\newcodeindex} % @synindex foo bar makes index foo feed into index bar. % Do this instead of @defindex foo if you don't want it as a separate index. \def\synindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\doindex {#2}}% } % @syncodeindex foo bar similar, but put all entries made for index foo % inside @code. \def\syncodeindex #1 #2 {% \expandafter\let\expandafter\synindexfoo\expandafter=\csname#2indfile\endcsname \expandafter\let\csname#1indfile\endcsname=\synindexfoo \expandafter\xdef\csname#1index\endcsname{% % Define \xxxindex \noexpand\docodeindex {#2}}% } % Define \doindex, the driver for all \fooindex macros. % Argument #1 is generated by the calling \fooindex macro, % and it is "foo", the name of the index. % \doindex just uses \parsearg; it calls \doind for the actual work. % This is because \doind is more useful to call from other macros. % There is also \dosubind {index}{topic}{subtopic} % which makes an entry in a two-level index such as the operation index. \def\doindex#1{\edef\indexname{#1}\parsearg\singleindexer} \def\singleindexer #1{\doind{\indexname}{#1}} % like the previous two, but they put @code around the argument. \def\docodeindex#1{\edef\indexname{#1}\parsearg\singlecodeindexer} \def\singlecodeindexer #1{\doind{\indexname}{\code{#1}}} \def\indexdummies{% \def\_{{\realbackslash _}}% \def\w{\realbackslash w }% \def\bf{\realbackslash bf }% \def\rm{\realbackslash rm }% \def\sl{\realbackslash sl }% \def\sf{\realbackslash sf}% \def\tt{\realbackslash tt}% \def\gtr{\realbackslash gtr}% \def\less{\realbackslash less}% \def\hat{\realbackslash hat}% \def\char{\realbackslash char}% \def\TeX{\realbackslash TeX}% \def\dots{\realbackslash dots }% \def\copyright{\realbackslash copyright }% \def\tclose##1{\realbackslash tclose {##1}}% \def\code##1{\realbackslash code {##1}}% \def\samp##1{\realbackslash samp {##1}}% \def\t##1{\realbackslash r {##1}}% \def\r##1{\realbackslash r {##1}}% \def\i##1{\realbackslash i {##1}}% \def\b##1{\realbackslash b {##1}}% \def\cite##1{\realbackslash cite {##1}}% \def\key##1{\realbackslash key {##1}}% \def\file##1{\realbackslash file {##1}}% \def\var##1{\realbackslash var {##1}}% \def\kbd##1{\realbackslash kbd {##1}}% \def\dfn##1{\realbackslash dfn {##1}}% \def\emph##1{\realbackslash emph {##1}}% } % \indexnofonts no-ops all font-change commands. % This is used when outputting the strings to sort the index by. \def\indexdummyfont#1{#1} \def\indexdummytex{TeX} \def\indexdummydots{...} \def\indexnofonts{% \let\w=\indexdummyfont \let\t=\indexdummyfont \let\r=\indexdummyfont \let\i=\indexdummyfont \let\b=\indexdummyfont \let\emph=\indexdummyfont \let\strong=\indexdummyfont \let\cite=\indexdummyfont \let\sc=\indexdummyfont %Don't no-op \tt, since it isn't a user-level command % and is used in the definitions of the active chars like <, >, |... %\let\tt=\indexdummyfont \let\tclose=\indexdummyfont \let\code=\indexdummyfont \let\file=\indexdummyfont \let\samp=\indexdummyfont \let\kbd=\indexdummyfont \let\key=\indexdummyfont \let\var=\indexdummyfont \let\TeX=\indexdummytex \let\dots=\indexdummydots } % To define \realbackslash, we must make \ not be an escape. % We must first make another character (@) an escape % so we do not become unable to do a definition. {\catcode`\@=0 \catcode`\\=\other @gdef@realbackslash{\}} \let\indexbackslash=0 %overridden during \printindex. \def\doind #1#2{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% Expand all macros now EXCEPT \folio \def\rawbackslashxx{\indexbackslash}% \indexbackslash isn't defined now % so it will be output as is; and it will print as backslash in the indx. % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}}}% \temp }% }\penalty\count10}} \def\dosubind #1#2#3{% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage \escapechar=`\\% {\let\folio=0% \def\rawbackslashxx{\indexbackslash}% % % Now process the index-string once, with all font commands turned off, % to get the string to sort the index by. {\indexnofonts \xdef\temp1{#2 #3}% }% % Now produce the complete index entry. We process the index-string again, % this time with font commands expanded, to get what to print in the index. \edef\temp{% \write \csname#1indfile\endcsname{% \realbackslash entry {\temp1}{\folio}{#2}{#3}}}% \temp }% }\penalty\count10}} % The index entry written in the file actually looks like % \entry {sortstring}{page}{topic} % or % \entry {sortstring}{page}{topic}{subtopic} % The texindex program reads in these files and writes files % containing these kinds of lines: % \initial {c} % before the first topic whose initial is c % \entry {topic}{pagelist} % for a topic that is used without subtopics % \primary {topic} % for the beginning of a topic that is used with subtopics % \secondary {subtopic}{pagelist} % for each subtopic. % Define the user-accessible indexing commands % @findex, @vindex, @kindex, @cindex. \def\findex {\fnindex} \def\kindex {\kyindex} \def\cindex {\cpindex} \def\vindex {\vrindex} \def\tindex {\tpindex} \def\pindex {\pgindex} \def\cindexsub {\begingroup\obeylines\cindexsub} {\obeylines % \gdef\cindexsub "#1" #2^^M{\endgroup % \dosubind{cp}{#2}{#1}}} % Define the macros used in formatting output of the sorted index material. % This is what you call to cause a particular index to get printed. % Write % @unnumbered Function Index % @printindex fn \def\printindex{\parsearg\doprintindex} \def\doprintindex#1{% \tex \dobreak \chapheadingskip {10000} \catcode`\%=\other\catcode`\&=\other\catcode`\#=\other \catcode`\$=\other \catcode`\~=\other \indexbreaks % % The following don't help, since the chars were translated % when the raw index was written, and their fonts were discarded % due to \indexnofonts. %\catcode`\"=\active %\catcode`\^=\active %\catcode`\_=\active %\catcode`\|=\active %\catcode`\<=\active %\catcode`\>=\active % % \def\indexbackslash{\rawbackslashxx} \indexfonts\rm \tolerance=9500 \advance\baselineskip -1pt \begindoublecolumns % % See if the index file exists and is nonempty. \openin 1 \jobname.#1s \ifeof 1 % \enddoublecolumns gets confused if there is no text in the index, % and it loses the chapter title and the aux file entries for the % index. The easiest way to prevent this problem is to make sure % there is some text. (Index is nonexistent) \else % % If the index file exists but is empty, then \openin leaves \ifeof % false. We have to make TeX try to read something from the file, so % it can discover if there is anything in it. \read 1 to \temp \ifeof 1 (Index is empty) \else \input \jobname.#1s \fi \fi \closein 1 \enddoublecolumns \Etex } % These macros are used by the sorted index file itself. % Change them to control the appearance of the index. % Same as \bigskipamount except no shrink. % \balancecolumns gets confused if there is any shrink. \newskip\initialskipamount \initialskipamount 12pt plus4pt \def\initial #1{% {\let\tentt=\sectt \let\tt=\sectt \let\sf=\sectt \ifdim\lastskip<\initialskipamount \removelastskip \penalty-200 \vskip \initialskipamount\fi \line{\secbf#1\hfill}\kern 2pt\penalty10000}} % This typesets a paragraph consisting of #1, dot leaders, and then #2 % flush to the right margin. It is used for index and table of contents % entries. The paragraph is indented by \leftskip. % \def\entry #1#2{\begingroup % % Start a new paragraph if necessary, so our assignments below can't % affect previous text. \par % % Do not fill out the last line with white space. \parfillskip = 0in % % No extra space above this paragraph. \parskip = 0in % % Do not prefer a separate line ending with a hyphen to fewer lines. \finalhyphendemerits = 0 % % \hangindent is only relevant when the entry text and page number % don't both fit on one line. In that case, bob suggests starting the % dots pretty far over on the line. Unfortunately, a large % indentation looks wrong when the entry text itself is broken across % lines. So we use a small indentation and put up with long leaders. % % \hangafter is reset to 1 (which is the value we want) at the start % of each paragraph, so we need not do anything with that. \hangindent=2em % % When the entry text needs to be broken, just fill out the first line % with blank space. \rightskip = 0pt plus1fil % % Start a ``paragraph'' for the index entry so the line breaking % parameters we've set above will have an effect. \noindent % % Insert the text of the index entry. TeX will do line-breaking on it. #1% % The following is kluged to not output a line of dots in the index if % there are no page numbers. The next person who breaks this will be % cursed by a Unix daemon. \def\tempa{{\rm }}% \def\tempb{#2}% \edef\tempc{\tempa}% \edef\tempd{\tempb}% \ifx\tempc\tempd\ \else% % % If we must, put the page number on a line of its own, and fill out % this line with blank space. (The \hfil is overwhelmed with the % fill leaders glue in \indexdotfill if the page number does fit.) \hfil\penalty50 \null\nobreak\indexdotfill % Have leaders before the page number. % % The `\ ' here is removed by the implicit \unskip that TeX does as % part of (the primitive) \par. Without it, a spurious underfull % \hbox ensues. \ #2% The page number ends the paragraph. \fi% \par \endgroup} % Like \dotfill except takes at least 1 em. \def\indexdotfill{\cleaders \hbox{$\mathsurround=0pt \mkern1.5mu ${\it .}$ \mkern1.5mu$}\hskip 1em plus 1fill} \def\primary #1{\line{#1\hfil}} \newskip\secondaryindent \secondaryindent=0.5cm \def\secondary #1#2{ {\parfillskip=0in \parskip=0in \hangindent =1in \hangafter=1 \noindent\hskip\secondaryindent\hbox{#1}\indexdotfill #2\par }} %% Define two-column mode, which is used in indexes. %% Adapted from the TeXbook, page 416. \catcode `\@=11 \newbox\partialpage \newdimen\doublecolumnhsize \def\begindoublecolumns{\begingroup % Grab any single-column material above us. \output = {\global\setbox\partialpage =\vbox{\unvbox255\kern -\topskip \kern \baselineskip}}% \eject % % Now switch to the double-column output routine. \output={\doublecolumnout}% % % Change the page size parameters. We could do this once outside this % routine, in each of @smallbook, @afourpaper, and the default 8.5x11 % format, but then we repeat the same computation. Repeating a couple % of assignments once per index is clearly meaningless for the % execution time, so we may as well do it once. % % First we halve the line length, less a little for the gutter between % the columns. We compute the gutter based on the line length, so it % changes automatically with the paper format. The magic constant % below is chosen so that the gutter has the same value (well, +- < % 1pt) as it did when we hard-coded it. % % We put the result in a separate register, \doublecolumhsize, so we % can restore it in \pagesofar, after \hsize itself has (potentially) % been clobbered. % \doublecolumnhsize = \hsize \advance\doublecolumnhsize by -.04154\hsize \divide\doublecolumnhsize by 2 \hsize = \doublecolumnhsize % % Double the \vsize as well. (We don't need a separate register here, % since nobody clobbers \vsize.) \vsize = 2\vsize \doublecolumnpagegoal } \def\enddoublecolumns{\eject \endgroup \pagegoal=\vsize \unvbox\partialpage} \def\doublecolumnsplit{\splittopskip=\topskip \splitmaxdepth=\maxdepth \global\dimen@=\pageheight \global\advance\dimen@ by-\ht\partialpage \global\setbox1=\vsplit255 to\dimen@ \global\setbox0=\vbox{\unvbox1} \global\setbox3=\vsplit255 to\dimen@ \global\setbox2=\vbox{\unvbox3} \ifdim\ht0>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi \ifdim\ht2>\dimen@ \setbox255=\vbox{\unvbox0\unvbox2} \global\setbox255=\copy5 \fi } \def\doublecolumnpagegoal{% \dimen@=\vsize \advance\dimen@ by-2\ht\partialpage \global\pagegoal=\dimen@ } \def\pagesofar{\unvbox\partialpage % \hsize=\doublecolumnhsize % have to restore this since output routine \wd0=\hsize \wd2=\hsize \hbox to\pagewidth{\box0\hfil\box2}} \def\doublecolumnout{% \setbox5=\copy255 {\vbadness=10000 \doublecolumnsplit} \ifvbox255 \setbox0=\vtop to\dimen@{\unvbox0} \setbox2=\vtop to\dimen@{\unvbox2} \onepageout\pagesofar \unvbox255 \penalty\outputpenalty \else \setbox0=\vbox{\unvbox5} \ifvbox0 \dimen@=\ht0 \advance\dimen@ by\topskip \advance\dimen@ by-\baselineskip \divide\dimen@ by2 \splittopskip=\topskip \splitmaxdepth=\maxdepth {\vbadness=10000 \loop \global\setbox5=\copy0 \setbox1=\vsplit5 to\dimen@ \setbox3=\vsplit5 to\dimen@ \ifvbox5 \global\advance\dimen@ by1pt \repeat \setbox0=\vbox to\dimen@{\unvbox1} \setbox2=\vbox to\dimen@{\unvbox3} \global\setbox\partialpage=\vbox{\pagesofar} \doublecolumnpagegoal } \fi \fi } \catcode `\@=\other \message{sectioning,} % Define chapters, sections, etc. \newcount \chapno \newcount \secno \secno=0 \newcount \subsecno \subsecno=0 \newcount \subsubsecno \subsubsecno=0 % This counter is funny since it counts through charcodes of letters A, B, ... \newcount \appendixno \appendixno = `\@ \def\appendixletter{\char\the\appendixno} \newwrite \contentsfile % This is called from \setfilename. \def\opencontents{\openout \contentsfile = \jobname.toc} % Each @chapter defines this as the name of the chapter. % page headings and footings can use it. @section does likewise \def\thischapter{} \def\thissection{} \def\seccheck#1{\if \pageno<0 % \errmessage{@#1 not allowed after generating table of contents}\fi % } \def\chapternofonts{% \let\rawbackslash=\relax% \let\frenchspacing=\relax% \def\result{\realbackslash result} \def\equiv{\realbackslash equiv} \def\expansion{\realbackslash expansion} \def\print{\realbackslash print} \def\TeX{\realbackslash TeX} \def\dots{\realbackslash dots} \def\copyright{\realbackslash copyright} \def\tt{\realbackslash tt} \def\bf{\realbackslash bf } \def\w{\realbackslash w} \def\less{\realbackslash less} \def\gtr{\realbackslash gtr} \def\hat{\realbackslash hat} \def\char{\realbackslash char} \def\tclose##1{\realbackslash tclose {##1}} \def\code##1{\realbackslash code {##1}} \def\samp##1{\realbackslash samp {##1}} \def\r##1{\realbackslash r {##1}} \def\b##1{\realbackslash b {##1}} \def\key##1{\realbackslash key {##1}} \def\file##1{\realbackslash file {##1}} \def\kbd##1{\realbackslash kbd {##1}} % These are redefined because @smartitalic wouldn't work inside xdef. \def\i##1{\realbackslash i {##1}} \def\cite##1{\realbackslash cite {##1}} \def\var##1{\realbackslash var {##1}} \def\emph##1{\realbackslash emph {##1}} \def\dfn##1{\realbackslash dfn {##1}} } \newcount\absseclevel % used to calculate proper heading level \newcount\secbase\secbase=0 % @raise/lowersections modify this count % @raisesections: treat @section as chapter, @subsection as section, etc. \def\raisesections{\global\advance\secbase by -1} \let\up=\raisesections % original BFox name % @lowersections: treat @chapter as section, @section as subsection, etc. \def\lowersections{\global\advance\secbase by 1} \let\down=\lowersections % original BFox name % Choose a numbered-heading macro % #1 is heading level if unmodified by @raisesections or @lowersections % #2 is text for heading \def\numhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \chapterzzz{#2} \or \seczzz{#2} \or \numberedsubseczzz{#2} \or \numberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \chapterzzz{#2} \else \numberedsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses appendix heading levels \def\apphead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \appendixzzz{#2} \or \appendixsectionzzz{#2} \or \appendixsubseczzz{#2} \or \appendixsubsubseczzz{#2} \else \ifnum \absseclevel<0 \appendixzzz{#2} \else \appendixsubsubseczzz{#2} \fi \fi } % like \numhead, but chooses numberless heading levels \def\unnmhead#1#2{\absseclevel=\secbase\advance\absseclevel by #1 \ifcase\absseclevel \unnumberedzzz{#2} \or \unnumberedseczzz{#2} \or \unnumberedsubseczzz{#2} \or \unnumberedsubsubseczzz{#2} \else \ifnum \absseclevel<0 \unnumberedzzz{#2} \else \unnumberedsubsubseczzz{#2} \fi \fi } \def\thischaptername{No Chapter Title} \outer\def\chapter{\parsearg\chapteryyy} \def\chapteryyy #1{\numhead0{#1}} % normally numhead0 calls chapterzzz \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \chapno by 1 \message{Chapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% % We don't substitute the actual chapter name into \thischapter % because we don't want its macros evaluated now. \xdef\thischapter{Chapter \the\chapno: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{\the\chapno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec }} \outer\def\appendix{\parsearg\appendixyyy} \def\appendixyyy #1{\apphead0{#1}} % normally apphead0 calls appendixzzz \def\appendixzzz #1{\seccheck{appendix}% \secno=0 \subsecno=0 \subsubsecno=0 \global\advance \appendixno by 1 \message{Appendix \appendixletter}% \chapmacro {#1}{Appendix \appendixletter}% \gdef\thissection{#1}% \gdef\thischaptername{#1}% \xdef\thischapter{Appendix \appendixletter: \noexpand\thischaptername}% {\chapternofonts% \edef\temp{{\realbackslash chapentry {#1}{Appendix \appendixletter}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \global\let\section = \appendixsec \global\let\subsection = \appendixsubsec \global\let\subsubsection = \appendixsubsubsec }} \outer\def\top{\parsearg\unnumberedyyy} \outer\def\unnumbered{\parsearg\unnumberedyyy} \def\unnumberedyyy #1{\unnmhead0{#1}} % normally unnmhead0 calls unnumberedzzz \def\unnumberedzzz #1{\seccheck{unnumbered}% \secno=0 \subsecno=0 \subsubsecno=0 % % This used to be simply \message{#1}, but TeX fully expands the % argument to \message. Therefore, if #1 contained @-commands, TeX % expanded them. For example, in `@unnumbered The @cite{Book}', TeX % expanded @cite (which turns out to cause errors because \cite is meant % to be executed, not expanded). % % Anyway, we don't want the fully-expanded definition of @cite to appear % as a result of the \message, we just want `@cite' itself. We use % \the to achieve this: TeX expands \the only once, % simply yielding the contents of the . \toks0 = {#1}\message{(\the\toks0)}% % \unnumbchapmacro {#1}% \gdef\thischapter{#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbchapentry {#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \global\let\section = \unnumberedsec \global\let\subsection = \unnumberedsubsec \global\let\subsubsection = \unnumberedsubsubsec }} \outer\def\numberedsec{\parsearg\secyyy} \def\secyyy #1{\numhead1{#1}} % normally calls seczzz \def\seczzz #1{\seccheck{section}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\the\chapno}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\the\chapno}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appenixsection{\parsearg\appendixsecyyy} \outer\def\appendixsec{\parsearg\appendixsecyyy} \def\appendixsecyyy #1{\apphead1{#1}} % normally calls appendixsectionzzz \def\appendixsectionzzz #1{\seccheck{appendixsection}% \subsecno=0 \subsubsecno=0 \global\advance \secno by 1 % \gdef\thissection{#1}\secheading {#1}{\appendixletter}{\the\secno}% {\chapternofonts% \edef\temp{{\realbackslash secentry % {#1}{\appendixletter}{\the\secno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsec{\parsearg\unnumberedsecyyy} \def\unnumberedsecyyy #1{\unnmhead1{#1}} % normally calls unnumberedseczzz \def\unnumberedseczzz #1{\seccheck{unnumberedsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsec{\parsearg\numberedsubsecyyy} \def\numberedsubsecyyy #1{\numhead2{#1}} % normally calls numberedsubseczzz \def\numberedsubseczzz #1{\seccheck{subsection}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\the\chapno}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\the\chapno}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsec{\parsearg\appendixsubsecyyy} \def\appendixsubsecyyy #1{\apphead2{#1}} % normally calls appendixsubseczzz \def\appendixsubseczzz #1{\seccheck{appendixsubsec}% \gdef\thissection{#1}\subsubsecno=0 \global\advance \subsecno by 1 % \subsecheading {#1}{\appendixletter}{\the\secno}{\the\subsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsecentry % {#1}{\appendixletter}{\the\secno}{\the\subsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsec{\parsearg\unnumberedsubsecyyy} \def\unnumberedsubsecyyy #1{\unnmhead2{#1}} %normally calls unnumberedsubseczzz \def\unnumberedsubseczzz #1{\seccheck{unnumberedsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} \outer\def\numberedsubsubsec{\parsearg\numberedsubsubsecyyy} \def\numberedsubsubsecyyy #1{\numhead3{#1}} % normally numberedsubsubseczzz \def\numberedsubsubseczzz #1{\seccheck{subsubsection}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry % {#1} {\the\chapno}{\the\secno}{\the\subsecno}{\the\subsubsecno} {\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \donoderef % \penalty 10000 % }} \outer\def\appendixsubsubsec{\parsearg\appendixsubsubsecyyy} \def\appendixsubsubsecyyy #1{\apphead3{#1}} % normally appendixsubsubseczzz \def\appendixsubsubseczzz #1{\seccheck{appendixsubsubsec}% \gdef\thissection{#1}\global\advance \subsubsecno by 1 % \subsubsecheading {#1} {\appendixletter}{\the\secno}{\the\subsecno}{\the\subsubsecno}% {\chapternofonts% \edef\temp{{\realbackslash subsubsecentry{#1}% {\appendixletter} {\the\secno}{\the\subsecno}{\the\subsubsecno}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \appendixnoderef % \penalty 10000 % }} \outer\def\unnumberedsubsubsec{\parsearg\unnumberedsubsubsecyyy} \def\unnumberedsubsubsecyyy #1{\unnmhead3{#1}} %normally unnumberedsubsubseczzz \def\unnumberedsubsubseczzz #1{\seccheck{unnumberedsubsubsec}% \plainsecheading {#1}\gdef\thissection{#1}% {\chapternofonts% \edef\temp{{\realbackslash unnumbsubsubsecentry{#1}{\noexpand\folio}}}% \escapechar=`\\% \write \contentsfile \temp % \unnumbnoderef % \penalty 10000 % }} % These are variants which are not "outer", so they can appear in @ifinfo. % Actually, they should now be obsolete; ordinary section commands should work. \def\infotop{\parsearg\unnumberedzzz} \def\infounnumbered{\parsearg\unnumberedzzz} \def\infounnumberedsec{\parsearg\unnumberedseczzz} \def\infounnumberedsubsec{\parsearg\unnumberedsubseczzz} \def\infounnumberedsubsubsec{\parsearg\unnumberedsubsubseczzz} \def\infoappendix{\parsearg\appendixzzz} \def\infoappendixsec{\parsearg\appendixseczzz} \def\infoappendixsubsec{\parsearg\appendixsubseczzz} \def\infoappendixsubsubsec{\parsearg\appendixsubsubseczzz} \def\infochapter{\parsearg\chapterzzz} \def\infosection{\parsearg\sectionzzz} \def\infosubsection{\parsearg\subsectionzzz} \def\infosubsubsection{\parsearg\subsubsectionzzz} % These macros control what the section commands do, according % to what kind of chapter we are in (ordinary, appendix, or unnumbered). % Define them by default for a numbered chapter. \global\let\section = \numberedsec \global\let\subsection = \numberedsubsec \global\let\subsubsection = \numberedsubsubsec % Define @majorheading, @heading and @subheading % NOTE on use of \vbox for chapter headings, section headings, and % such: % 1) We use \vbox rather than the earlier \line to permit % overlong headings to fold. % 2) \hyphenpenalty is set to 10000 because hyphenation in a % heading is obnoxious; this forbids it. % 3) Likewise, headings look best if no \parindent is used, and % if justification is not attempted. Hence \raggedright. \def\majorheading{\parsearg\majorheadingzzz} \def\majorheadingzzz #1{% {\advance\chapheadingskip by 10pt \chapbreak }% {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\chapheading{\parsearg\chapheadingzzz} \def\chapheadingzzz #1{\chapbreak % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 200} \def\heading{\parsearg\secheadingi} \def\subheading{\parsearg\subsecheadingi} \def\subsubheading{\parsearg\subsubsecheadingi} % These macros generate a chapter, section, etc. heading only % (including whitespace, linebreaking, etc. around it), % given all the information in convenient, parsed form. %%% Args are the skip and penalty (usually negative) \def\dobreak#1#2{\par\ifdim\lastskip<#1\removelastskip\penalty#2\vskip#1\fi} \def\setchapterstyle #1 {\csname CHAPF#1\endcsname} %%% Define plain chapter starts, and page on/off switching for it % Parameter controlling skip before chapter headings (if needed) \newskip \chapheadingskip \chapheadingskip = 30pt plus 8pt minus 4pt \def\chapbreak{\dobreak \chapheadingskip {-4000}} \def\chappager{\par\vfill\supereject} \def\chapoddpage{\chappager \ifodd\pageno \else \hbox to 0pt{} \chappager\fi} \def\setchapternewpage #1 {\csname CHAPPAG#1\endcsname} \def\CHAPPAGoff{ \global\let\pchapsepmacro=\chapbreak \global\let\pagealignmacro=\chappager} \def\CHAPPAGon{ \global\let\pchapsepmacro=\chappager \global\let\pagealignmacro=\chappager \global\def\HEADINGSon{\HEADINGSsingle}} \def\CHAPPAGodd{ \global\let\pchapsepmacro=\chapoddpage \global\let\pagealignmacro=\chapoddpage \global\def\HEADINGSon{\HEADINGSdouble}} \CHAPPAGon \def\CHAPFplain{ \global\let\chapmacro=\chfplain \global\let\unnumbchapmacro=\unnchfplain} \def\chfplain #1#2{% \pchapsepmacro {% \chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #2\enspace #1}% }% \bigskip \penalty5000 } \def\unnchfplain #1{% \pchapsepmacro % {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \CHAPFplain % The default \def\unnchfopen #1{% \chapoddpage {\chapfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}\bigskip \par\penalty 10000 % } \def\chfopen #1#2{\chapoddpage {\chapfonts \vbox to 3in{\vfil \hbox to\hsize{\hfil #2} \hbox to\hsize{\hfil #1} \vfil}}% \par\penalty 5000 % } \def\CHAPFopen{ \global\let\chapmacro=\chfopen \global\let\unnumbchapmacro=\unnchfopen} % Parameter controlling skip before section headings. \newskip \subsecheadingskip \subsecheadingskip = 17pt plus 8pt minus 4pt \def\subsecheadingbreak{\dobreak \subsecheadingskip {-500}} \newskip \secheadingskip \secheadingskip = 21pt plus 8pt minus 4pt \def\secheadingbreak{\dobreak \secheadingskip {-1000}} % @paragraphindent is defined for the Info formatting commands only. \let\paragraphindent=\comment % Section fonts are the base font at magstep2, which produces % a size a bit more than 14 points in the default situation. \def\secheading #1#2#3{\secheadingi {#2.#3\enspace #1}} \def\plainsecheading #1{\secheadingi {#1}} \def\secheadingi #1{{\advance \secheadingskip by \parskip % \secheadingbreak}% {\secfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } % Subsection fonts are the base font at magstep1, % which produces a size of 12 points. \def\subsecheading #1#2#3#4{\subsecheadingi {#2.#3.#4\enspace #1}} \def\subsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000 } \def\subsubsecfonts{\subsecfonts} % Maybe this should change: % Perhaps make sssec fonts scaled % magstep half \def\subsubsecheading #1#2#3#4#5{\subsubsecheadingi {#2.#3.#4.#5\enspace #1}} \def\subsubsecheadingi #1{{\advance \subsecheadingskip by \parskip % \subsecheadingbreak}% {\subsubsecfonts \vbox{\hyphenpenalty=10000\tolerance=5000 \parindent=0pt\raggedright \rm #1\hfill}}% \ifdim \parskip<10pt \kern 10pt\kern -\parskip\fi \penalty 10000} \message{toc printing,} % Finish up the main text and prepare to read what we've written % to \contentsfile. \newskip\contentsrightmargin \contentsrightmargin=1in \def\startcontents#1{% \pagealignmacro \immediate\closeout \contentsfile \ifnum \pageno>0 \pageno = -1 % Request roman numbered pages. \fi % Don't need to put `Contents' or `Short Contents' in the headline. % It is abundantly clear what they are. \unnumbchapmacro{#1}\def\thischapter{}% \begingroup % Set up to handle contents files properly. \catcode`\\=0 \catcode`\{=1 \catcode`\}=2 \catcode`\@=11 \raggedbottom % Worry more about breakpoints than the bottom. \advance\hsize by -\contentsrightmargin % Don't use the full line length. } % Normal (long) toc. \outer\def\contents{% \startcontents{Table of Contents}% \input \jobname.toc \endgroup \vfill \eject } % And just the chapters. \outer\def\summarycontents{% \startcontents{Short Contents}% % \let\chapentry = \shortchapentry \let\unnumbchapentry = \shortunnumberedentry % We want a true roman here for the page numbers. \secfonts \let\rm=\shortcontrm \let\bf=\shortcontbf \let\sl=\shortcontsl \rm \advance\baselineskip by 1pt % Open it up a little. \def\secentry ##1##2##3##4{} \def\unnumbsecentry ##1##2{} \def\subsecentry ##1##2##3##4##5{} \def\unnumbsubsecentry ##1##2{} \def\subsubsecentry ##1##2##3##4##5##6{} \def\unnumbsubsubsecentry ##1##2{} \input \jobname.toc \endgroup \vfill \eject } \let\shortcontents = \summarycontents % These macros generate individual entries in the table of contents. % The first argument is the chapter or section name. % The last argument is the page number. % The arguments in between are the chapter number, section number, ... % Chapter-level things, for both the long and short contents. \def\chapentry#1#2#3{\dochapentry{#2\labelspace#1}{#3}} % See comments in \dochapentry re vbox and related settings \def\shortchapentry#1#2#3{% \tocentry{\shortchaplabel{#2}\labelspace #1}{\doshortpageno{#3}}% } % Typeset the label for a chapter or appendix for the short contents. % The arg is, e.g. `Appendix A' for an appendix, or `3' for a chapter. % We could simplify the code here by writing out an \appendixentry % command in the toc file for appendices, instead of using \chapentry % for both, but it doesn't seem worth it. \setbox0 = \hbox{\shortcontrm Appendix } \newdimen\shortappendixwidth \shortappendixwidth = \wd0 \def\shortchaplabel#1{% % We typeset #1 in a box of constant width, regardless of the text of % #1, so the chapter titles will come out aligned. \setbox0 = \hbox{#1}% \dimen0 = \ifdim\wd0 > \shortappendixwidth \shortappendixwidth \else 0pt \fi % % This space should be plenty, since a single number is .5em, and the % widest letter (M) is 1em, at least in the Computer Modern fonts. % (This space doesn't include the extra space that gets added after % the label; that gets put in in \shortchapentry above.) \advance\dimen0 by 1.1em \hbox to \dimen0{#1\hfil}% } \def\unnumbchapentry#1#2{\dochapentry{#1}{#2}} \def\shortunnumberedentry#1#2{\tocentry{#1}{\doshortpageno{#2}}} % Sections. \def\secentry#1#2#3#4{\dosecentry{#2.#3\labelspace#1}{#4}} \def\unnumbsecentry#1#2{\dosecentry{#1}{#2}} % Subsections. \def\subsecentry#1#2#3#4#5{\dosubsecentry{#2.#3.#4\labelspace#1}{#5}} \def\unnumbsubsecentry#1#2{\dosubsecentry{#1}{#2}} % And subsubsections. \def\subsubsecentry#1#2#3#4#5#6{% \dosubsubsecentry{#2.#3.#4.#5\labelspace#1}{#6}} \def\unnumbsubsubsecentry#1#2{\dosubsubsecentry{#1}{#2}} % This parameter controls the indentation of the various levels. \newdimen\tocindent \tocindent = 3pc % Now for the actual typesetting. In all these, #1 is the text and #2 is the % page number. % % If the toc has to be broken over pages, we would want to be at chapters % if at all possible; hence the \penalty. \def\dochapentry#1#2{% \penalty-300 \vskip\baselineskip \begingroup \chapentryfonts \tocentry{#1}{\dopageno{#2}}% \endgroup \nobreak\vskip .25\baselineskip } \def\dosecentry#1#2{\begingroup \secentryfonts \leftskip=\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsecentry#1#2{\begingroup \subsecentryfonts \leftskip=2\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} \def\dosubsubsecentry#1#2{\begingroup \subsubsecentryfonts \leftskip=3\tocindent \tocentry{#1}{\dopageno{#2}}% \endgroup} % Final typesetting of a toc entry; we use the same \entry macro as for % the index entries, but we want to suppress hyphenation here. (We % can't do that in the \entry macro, since index entries might consist % of hyphenated-identifiers-that-do-not-fit-on-a-line-and-nothing-else.) % \def\tocentry#1#2{\begingroup \hyphenpenalty = 10000 \entry{#1}{#2}% \endgroup} % Space between chapter (or whatever) number and the title. \def\labelspace{\hskip1em \relax} \def\dopageno#1{{\rm #1}} \def\doshortpageno#1{{\rm #1}} \def\chapentryfonts{\secfonts \rm} \def\secentryfonts{\textfonts} \let\subsecentryfonts = \textfonts \let\subsubsecentryfonts = \textfonts \message{environments,} % Since these characters are used in examples, it should be an even number of % \tt widths. Each \tt character is 1en, so two makes it 1em. % Furthermore, these definitions must come after we define our fonts. \newbox\dblarrowbox \newbox\longdblarrowbox \newbox\pushcharbox \newbox\bullbox \newbox\equivbox \newbox\errorbox \let\ptexequiv = \equiv %{\tentt %\global\setbox\dblarrowbox = \hbox to 1em{\hfil$\Rightarrow$\hfil} %\global\setbox\longdblarrowbox = \hbox to 1em{\hfil$\mapsto$\hfil} %\global\setbox\pushcharbox = \hbox to 1em{\hfil$\dashv$\hfil} %\global\setbox\equivbox = \hbox to 1em{\hfil$\ptexequiv$\hfil} % Adapted from the manmac format (p.420 of TeXbook) %\global\setbox\bullbox = \hbox to 1em{\kern.15em\vrule height .75ex width .85ex % depth .1ex\hfil} %} \def\point{$\star$} \def\result{\leavevmode\raise.15ex\hbox to 1em{\hfil$\Rightarrow$\hfil}} \def\expansion{\leavevmode\raise.1ex\hbox to 1em{\hfil$\mapsto$\hfil}} \def\print{\leavevmode\lower.1ex\hbox to 1em{\hfil$\dashv$\hfil}} \def\equiv{\leavevmode\lower.1ex\hbox to 1em{\hfil$\ptexequiv$\hfil}} % Adapted from the TeXbook's \boxit. {\tentt \global\dimen0 = 3em}% Width of the box. \dimen2 = .55pt % Thickness of rules % The text. (`r' is open on the right, `e' somewhat less so on the left.) \setbox0 = \hbox{\kern-.75pt \tensf error\kern-1.5pt} \global\setbox\errorbox=\hbox to \dimen0{\hfil \hsize = \dimen0 \advance\hsize by -5.8pt % Space to left+right. \advance\hsize by -2\dimen2 % Rules. \vbox{ \hrule height\dimen2 \hbox{\vrule width\dimen2 \kern3pt % Space to left of text. \vtop{\kern2.4pt \box0 \kern2.4pt}% Space above/below. \kern3pt\vrule width\dimen2}% Space to right. \hrule height\dimen2} \hfil} % The @error{} command. \def\error{\leavevmode\lower.7ex\copy\errorbox} % @tex ... @end tex escapes into raw Tex temporarily. % One exception: @ is still an escape character, so that @end tex works. % But \@ or @@ will get a plain tex @ character. \def\tex{\begingroup \catcode `\\=0 \catcode `\{=1 \catcode `\}=2 \catcode `\$=3 \catcode `\&=4 \catcode `\#=6 \catcode `\^=7 \catcode `\_=8 \catcode `\~=13 \let~=\tie \catcode `\%=14 \catcode 43=12 \catcode`\"=12 \catcode`\==12 \catcode`\|=12 \catcode`\<=12 \catcode`\>=12 \escapechar=`\\ % \let\{=\ptexlbrace \let\}=\ptexrbrace \let\.=\ptexdot \let\*=\ptexstar \let\dots=\ptexdots \def\@{@}% \let\bullet=\ptexbullet \let\b=\ptexb \let\c=\ptexc \let\i=\ptexi \let\t=\ptext \let\l=\ptexl \let\L=\ptexL % \let\Etex=\endgroup} % Define @lisp ... @endlisp. % @lisp does a \begingroup so it can rebind things, % including the definition of @endlisp (which normally is erroneous). % Amount to narrow the margins by for @lisp. \newskip\lispnarrowing \lispnarrowing=0.4in % This is the definition that ^^M gets inside @lisp, @example, and other % such environments. \null is better than a space, since it doesn't % have any width. \def\lisppar{\null\endgraf} % Make each space character in the input produce a normal interword % space in the output. Don't allow a line break at this space, as this % is used only in environments like @example, where each line of input % should produce a line of output anyway. % {\obeyspaces % \gdef\sepspaces{\obeyspaces\let =\tie}} % Define \obeyedspace to be our active space, whatever it is. This is % for use in \parsearg. {\sepspaces% \global\let\obeyedspace= } % This space is always present above and below environments. \newskip\envskipamount \envskipamount = 0pt % Make spacing and below environment symmetrical. We use \parskip here % to help in doing that, since in @example-like environments \parskip % is reset to zero; thus the \afterenvbreak inserts no space -- but the % start of the next paragraph will insert \parskip % \def\aboveenvbreak{{\advance\envskipamount by \parskip \endgraf \ifdim\lastskip<\envskipamount \removelastskip \penalty-50 \vskip\envskipamount \fi}} \let\afterenvbreak = \aboveenvbreak % \nonarrowing is a flag. If "set", @lisp etc don't narrow margins. \let\nonarrowing=\relax %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % \cartouche: draw rectangle w/rounded corners around argument \font\circle=lcircle10 \newdimen\circthick \newdimen\cartouter\newdimen\cartinner \newskip\normbskip\newskip\normpskip\newskip\normlskip \circthick=\fontdimen8\circle % \def\ctl{{\circle\char'013\hskip -6pt}}% 6pt from pl file: 1/2charwidth \def\ctr{{\hskip 6pt\circle\char'010}} \def\cbl{{\circle\char'012\hskip -6pt}} \def\cbr{{\hskip 6pt\circle\char'011}} \def\carttop{\hbox to \cartouter{\hskip\lskip \ctl\leaders\hrule height\circthick\hfil\ctr \hskip\rskip}} \def\cartbot{\hbox to \cartouter{\hskip\lskip \cbl\leaders\hrule height\circthick\hfil\cbr \hskip\rskip}} % \newskip\lskip\newskip\rskip \long\def\cartouche{% \begingroup \lskip=\leftskip \rskip=\rightskip \leftskip=0pt\rightskip=0pt %we want these *outside*. \cartinner=\hsize \advance\cartinner by-\lskip \advance\cartinner by-\rskip \cartouter=\hsize \advance\cartouter by 18pt % allow for 3pt kerns on either % side, and for 6pt waste from % each corner char \normbskip=\baselineskip \normpskip=\parskip \normlskip=\lineskip % Flag to tell @lisp, etc., not to narrow margin. \let\nonarrowing=\comment \vbox\bgroup \baselineskip=0pt\parskip=0pt\lineskip=0pt \carttop \hbox\bgroup \hskip\lskip \vrule\kern3pt \vbox\bgroup \hsize=\cartinner \kern3pt \begingroup \baselineskip=\normbskip \lineskip=\normlskip \parskip=\normpskip \vskip -\parskip \def\Ecartouche{% \endgroup \kern3pt \egroup \kern3pt\vrule \hskip\rskip \egroup \cartbot \egroup \endgroup }} % This macro is called at the beginning of all the @example variants, % inside a group. \def\nonfillstart{% \aboveenvbreak \inENV % This group ends at the end of the body \hfuzz = 12pt % Don't be fussy \sepspaces % Make spaces be word-separators rather than space tokens. \singlespace \let\par = \lisppar % don't ignore blank lines \obeylines % each line of input is a line of output \parskip = 0pt \parindent = 0pt \emergencystretch = 0pt % don't try to avoid overfull boxes % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \exdentamount=\lispnarrowing \let\exdent=\nofillexdent \let\nonarrowing=\relax \fi } % To ending an @example-like environment, we first end the paragraph % (via \afterenvbreak's vertical glue), and then the group. That way we % keep the zero \parskip that the environments set -- \parskip glue % will be inserted at the beginning of the next paragraph in the % document, after the environment. % \def\nonfillfinish{\afterenvbreak\endgroup}% % This macro is \def\lisp{\begingroup \nonfillstart \let\Elisp = \nonfillfinish \tt \rawbackslash % have \ input char produce \ char from current font \gobble } % Define the \E... control sequence only if we are inside the % environment, so the error checking in \end will work. % % We must call \lisp last in the definition, since it reads the % return following the @example (or whatever) command. % \def\example{\begingroup \def\Eexample{\nonfillfinish\endgroup}\lisp} \def\smallexample{\begingroup \def\Esmallexample{\nonfillfinish\endgroup}\lisp} \def\smalllisp{\begingroup \def\Esmalllisp{\nonfillfinish\endgroup}\lisp} % @smallexample and @smalllisp. This is not used unless the @smallbook % command is given. Originally contributed by Pavel@xerox. % \def\smalllispx{\begingroup \nonfillstart \let\Esmalllisp = \nonfillfinish \let\Esmallexample = \nonfillfinish % % Smaller interline space and fonts for small examples. \baselineskip 10pt \indexfonts \tt \rawbackslash % output the \ character from the current font \gobble } % This is @display; same as @lisp except use roman font. % \def\display{\begingroup \nonfillstart \let\Edisplay = \nonfillfinish \gobble } % This is @format; same as @display except don't narrow margins. % \def\format{\begingroup \let\nonarrowing = t \nonfillstart \let\Eformat = \nonfillfinish \gobble } % @flushleft (same as @format) and @flushright. % \def\flushleft{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushleft = \nonfillfinish \gobble } \def\flushright{\begingroup \let\nonarrowing = t \nonfillstart \let\Eflushright = \nonfillfinish \advance\leftskip by 0pt plus 1fill \gobble} % @quotation does normal linebreaking and narrows the margins. % \def\quotation{% \begingroup\inENV %This group ends at the end of the @quotation body {\parskip=0pt % because we will skip by \parskip too, later \aboveenvbreak}% \singlespace \parindent=0pt \let\Equotation = \nonfillfinish % @cartouche defines \nonarrowing to inhibit narrowing % at next level down. \ifx\nonarrowing\relax \advance \leftskip by \lispnarrowing \advance \rightskip by \lispnarrowing \exdentamount=\lispnarrowing \let\nonarrowing=\relax \fi} \message{defuns,} % Define formatter for defuns % First, allow user to change definition object font (\df) internally \def\setdeffont #1 {\csname DEF#1\endcsname} \newskip\defbodyindent \defbodyindent=.4in \newskip\defargsindent \defargsindent=50pt \newskip\deftypemargin \deftypemargin=12pt \newskip\deflastargmargin \deflastargmargin=18pt \newcount\parencount % define \functionparens, which makes ( and ) and & do special things. % \functionparens affects the group it is contained in. \def\activeparens{% \catcode`\(=\active \catcode`\)=\active \catcode`\&=\active \catcode`\[=\active \catcode`\]=\active} % Make control sequences which act like normal parenthesis chars. \let\lparen = ( \let\rparen = ) {\activeparens % Now, smart parens don't turn on until &foo (see \amprm) % Be sure that we always have a definition for `(', etc. For example, % if the fn name has parens in it, \boldbrax will not be in effect yet, % so TeX would otherwise complain about undefined control sequence. \global\let(=\lparen \global\let)=\rparen \global\let[=\lbrack \global\let]=\rbrack \gdef\functionparens{\boldbrax\let&=\amprm\parencount=0 } \gdef\boldbrax{\let(=\opnr\let)=\clnr\let[=\lbrb\let]=\rbrb} % Definitions of (, ) and & used in args for functions. % This is the definition of ( outside of all parentheses. \gdef\oprm#1 {{\rm\char`\(}#1 \bf \let(=\opnested % \global\advance\parencount by 1 } % % This is the definition of ( when already inside a level of parens. \gdef\opnested{\char`\(\global\advance\parencount by 1 } % \gdef\clrm{% Print a paren in roman if it is taking us back to depth of 0. % also in that case restore the outer-level definition of (. \ifnum \parencount=1 {\rm \char `\)}\sl \let(=\oprm \else \char `\) \fi \global\advance \parencount by -1 } % If we encounter &foo, then turn on ()-hacking afterwards \gdef\amprm#1 {{\rm\}\let(=\oprm \let)=\clrm\ } % \gdef\normalparens{\boldbrax\let&=\ampnr} } % End of definition inside \activeparens %% These parens (in \boldbrax) actually are a little bolder than the %% contained text. This is especially needed for [ and ] \def\opnr{{\sf\char`\(}} \def\clnr{{\sf\char`\)}} \def\ampnr{\&} \def\lbrb{{\bf\char`\[}} \def\rbrb{{\bf\char`\]}} % First, defname, which formats the header line itself. % #1 should be the function name. % #2 should be the type of definition, such as "Function". \def\defname #1#2{% % Get the values of \leftskip and \rightskip as they were % outside the @def... \dimen2=\leftskip \advance\dimen2 by -\defbodyindent \dimen3=\rightskip \advance\dimen3 by -\defbodyindent \noindent % \setbox0=\hbox{\hskip \deflastargmargin{\rm #2}\hskip \deftypemargin}% \dimen0=\hsize \advance \dimen0 by -\wd0 % compute size for first line \dimen1=\hsize \advance \dimen1 by -\defargsindent %size for continuations \parshape 2 0in \dimen0 \defargsindent \dimen1 % % Now output arg 2 ("Function" or some such) % ending at \deftypemargin from the right margin, % but stuck inside a box of width 0 so it does not interfere with linebreaking {% Adjust \hsize to exclude the ambient margins, % so that \rightline will obey them. \advance \hsize by -\dimen2 \advance \hsize by -\dimen3 \rlap{\rightline{{\rm #2}\hskip \deftypemargin}}}% % Make all lines underfull and no complaints: \tolerance=10000 \hbadness=10000 \advance\leftskip by -\defbodyindent \exdentamount=\defbodyindent {\df #1}\enskip % Generate function name } % Actually process the body of a definition % #1 should be the terminating control sequence, such as \Edefun. % #2 should be the "another name" control sequence, such as \defunx. % #3 should be the control sequence that actually processes the header, % such as \defunheader. \def\defparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\activeparens\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % 61 is `=' \obeylines\activeparens\spacesplit#3} \def\defmethparsebody #1#2#3#4 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\activeparens\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#4}}} \def\defopparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\activeparens\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\activeparens\spacesplit{#3{#5}}} % These parsing functions are similar to the preceding ones % except that they do not make parens into active characters. % These are used for "variables" since they have no arguments. \def\defvarparsebody #1#2#3{\begingroup\inENV% Environment for definitionbody \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2{\begingroup\obeylines\spacesplit#3}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup % \catcode 61=\active % \obeylines\spacesplit#3} % This is used for \def{tp,vr}parsebody. It could probably be used for % some of the others, too, with some judicious conditionals. % \def\parsebodycommon#1#2#3{% \begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 {\begingroup\obeylines\spacesplit{#3{##1}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines } \def\defvrparsebody#1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{#3{#4}}% } % This loses on `@deftp {Data Type} {struct termios}' -- it thinks the % type is just `struct', because we lose the braces in `{struct % termios}' when \spacesplit reads its undelimited argument. Sigh. % \let\deftpparsebody=\defvrparsebody % % So, to get around this, we put \empty in with the type name. That % way, TeX won't find exactly `{...}' as an undelimited argument, and % won't strip off the braces. % \def\deftpparsebody #1#2#3#4 {% \parsebodycommon{#1}{#2}{#3}% \spacesplit{\parsetpheaderline{#3{#4}}}\empty } % Fine, but then we have to eventually remove the \empty *and* the % braces (if any). That's what this does, putting the result in \tptemp. % \def\removeemptybraces\empty#1\relax{\def\tptemp{#1}}% % After \spacesplit has done its work, this is called -- #1 is the final % thing to call, #2 the type name (which starts with \empty), and #3 % (which might be empty) the arguments. % \def\parsetpheaderline#1#2#3{% \removeemptybraces#2\relax #1{\tptemp}{#3}% }% \def\defopvarparsebody #1#2#3#4#5 {\begingroup\inENV % \medbreak % % Define the end token that this defining construct specifies % so that it will exit this group. \def#1{\endgraf\endgroup\medbreak}% \def#2##1 ##2 {\def#4{##1}% \begingroup\obeylines\spacesplit{#3{##2}}}% \parindent=0in \advance\leftskip by \defbodyindent \advance \rightskip by \defbodyindent \exdentamount=\defbodyindent \begingroup\obeylines\spacesplit{#3{#5}}} % Split up #2 at the first space token. % call #1 with two arguments: % the first is all of #2 before the space token, % the second is all of #2 after that space token. % If #2 contains no space token, all of it is passed as the first arg % and the second is passed as empty. {\obeylines \gdef\spacesplit#1#2^^M{\endgroup\spacesplitfoo{#1}#2 \relax\spacesplitfoo}% \long\gdef\spacesplitfoo#1#2 #3#4\spacesplitfoo{% \ifx\relax #3% #1{#2}{}\else #1{#2}{#3#4}\fi}} % So much for the things common to all kinds of definitions. % Define @defun. % First, define the processing that is wanted for arguments of \defun % Use this to expand the args and terminate the paragraph they make up \def\defunargs #1{\functionparens \sl % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \hyphenchar\tensl=0 #1% \hyphenchar\tensl=45 \ifnum\parencount=0 \else \errmessage{unbalanced parens in @def arguments}\fi% \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } \def\deftypefunargs #1{% % Expand, preventing hyphenation at `-' chars. % Note that groups don't affect changes in \hyphenchar. \functionparens \tclose{#1}% avoid \code because of side effects on active chars \interlinepenalty=10000 \advance\rightskip by 0pt plus 1fil \endgraf\penalty 10000\vskip -\parskip\penalty 10000% } % Do complete processing of one @defun or @defunx line already parsed. % @deffn Command forward-char nchars \def\deffn{\defmethparsebody\Edeffn\deffnx\deffnheader} \def\deffnheader #1#2#3{\doind {fn}{\code{#2}}% \begingroup\defname {#2}{#1}\defunargs{#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defun == @deffn Function \def\defun{\defparsebody\Edefun\defunx\defunheader} \def\defunheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Function}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefun int foobar (int @var{foo}, float @var{bar}) \def\deftypefun{\defparsebody\Edeftypefun\deftypefunx\deftypefunheader} % #1 is the data type. #2 is the name and args. \def\deftypefunheader #1#2{\deftypefunheaderx{#1}#2 \relax} % #1 is the data type, #2 the name, #3 the args. \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index \begingroup\defname {\code{#1} #2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @deftypefn {Library Function} int foobar (int @var{foo}, float @var{bar}) \def\deftypefn{\defmethparsebody\Edeftypefn\deftypefnx\deftypefnheader} % #1 is the classification. #2 is the data type. #3 is the name and args. \def\deftypefnheader #1#2#3{\deftypefnheaderx{#1}{#2}#3 \relax} % #1 is the classification, #2 the data type, #3 the name, #4 the args. \def\deftypefnheaderx #1#2#3 #4\relax{% \doind {fn}{\code{#3}}% Make entry in function index \begingroup \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working \defname {\code{#2} #3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defmac == @deffn Macro \def\defmac{\defparsebody\Edefmac\defmacx\defmacheader} \def\defmacheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Macro}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % @defspec == @deffn Special Form \def\defspec{\defparsebody\Edefspec\defspecx\defspecheader} \def\defspecheader #1#2{\doind {fn}{\code{#1}}% Make entry in function index \begingroup\defname {#1}{Special Form}% \defunargs {#2}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody } % This definition is run if you use @defunx % anywhere other than immediately after a @defun or @defunx. \def\deffnx #1 {\errmessage{@deffnx in invalid context}} \def\defunx #1 {\errmessage{@defunx in invalid context}} \def\defmacx #1 {\errmessage{@defmacx in invalid context}} \def\defspecx #1 {\errmessage{@defspecx in invalid context}} \def\deftypefnx #1 {\errmessage{@deftypefnx in invalid context}} \def\deftypeunx #1 {\errmessage{@deftypeunx in invalid context}} % @defmethod, and so on % @defop {Funny Method} foo-class frobnicate argument \def\defop #1 {\def\defoptype{#1}% \defopparsebody\Edefop\defopx\defopheader\defoptype} \def\defopheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% Make entry in function index \begingroup\defname {#2}{\defoptype{} on #1}% \defunargs {#3}\endgroup % } % @defmethod == @defop Method \def\defmethod{\defmethparsebody\Edefmethod\defmethodx\defmethodheader} \def\defmethodheader #1#2#3{% \dosubind {fn}{\code{#2}}{on #1}% entry in function index \begingroup\defname {#2}{Method on #1}% \defunargs {#3}\endgroup % } % @defcv {Class Option} foo-class foo-flag \def\defcv #1 {\def\defcvtype{#1}% \defopvarparsebody\Edefcv\defcvx\defcvarheader\defcvtype} \def\defcvarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{\defcvtype{} of #1}% \defvarargs {#3}\endgroup % } % @defivar == @defcv {Instance Variable} \def\defivar{\defvrparsebody\Edefivar\defivarx\defivarheader} \def\defivarheader #1#2#3{% \dosubind {vr}{\code{#2}}{of #1}% Make entry in var index \begingroup\defname {#2}{Instance Variable of #1}% \defvarargs {#3}\endgroup % } % These definitions are run if you use @defmethodx, etc., % anywhere other than immediately after a @defmethod, etc. \def\defopx #1 {\errmessage{@defopx in invalid context}} \def\defmethodx #1 {\errmessage{@defmethodx in invalid context}} \def\defcvx #1 {\errmessage{@defcvx in invalid context}} \def\defivarx #1 {\errmessage{@defivarx in invalid context}} % Now @defvar % First, define the processing that is wanted for arguments of @defvar. % This is actually simple: just print them in roman. % This must expand the args and terminate the paragraph they make up \def\defvarargs #1{\normalparens #1% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000} % @defvr Counter foo-count \def\defvr{\defvrparsebody\Edefvr\defvrx\defvrheader} \def\defvrheader #1#2#3{\doind {vr}{\code{#2}}% \begingroup\defname {#2}{#1}\defvarargs{#3}\endgroup} % @defvar == @defvr Variable \def\defvar{\defvarparsebody\Edefvar\defvarx\defvarheader} \def\defvarheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{Variable}% \defvarargs {#2}\endgroup % } % @defopt == @defvr {User Option} \def\defopt{\defvarparsebody\Edefopt\defoptx\defoptheader} \def\defoptheader #1#2{\doind {vr}{\code{#1}}% Make entry in var index \begingroup\defname {#1}{User Option}% \defvarargs {#2}\endgroup % } % @deftypevar int foobar \def\deftypevar{\defvarparsebody\Edeftypevar\deftypevarx\deftypevarheader} % #1 is the data type. #2 is the name. \def\deftypevarheader #1#2{% \doind {vr}{\code{#2}}% Make entry in variables index \begingroup\defname {\code{#1} #2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % @deftypevr {Global Flag} int enable \def\deftypevr{\defvrparsebody\Edeftypevr\deftypevrx\deftypevrheader} \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}% \begingroup\defname {\code{#2} #3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 \endgroup} % This definition is run if you use @defvarx % anywhere other than immediately after a @defvar or @defvarx. \def\defvrx #1 {\errmessage{@defvrx in invalid context}} \def\defvarx #1 {\errmessage{@defvarx in invalid context}} \def\defoptx #1 {\errmessage{@defoptx in invalid context}} \def\deftypevarx #1 {\errmessage{@deftypevarx in invalid context}} \def\deftypevrx #1 {\errmessage{@deftypevrx in invalid context}} % Now define @deftp % Args are printed in bold, a slight difference from @defvar. \def\deftpargs #1{\bf \defvarargs{#1}} % @deftp Class window height width ... \def\deftp{\deftpparsebody\Edeftp\deftpx\deftpheader} \def\deftpheader #1#2#3{\doind {tp}{\code{#2}}% \begingroup\defname {#2}{#1}\deftpargs{#3}\endgroup} % This definition is run if you use @deftpx, etc % anywhere other than immediately after a @deftp, etc. \def\deftpx #1 {\errmessage{@deftpx in invalid context}} \message{cross reference,} % Define cross-reference macros \newwrite \auxfile \newif\ifhavexrefs % True if xref values are known. \newif\ifwarnedxrefs % True if we warned once that they aren't known. % \setref{foo} defines a cross-reference point named foo. \def\setref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ysectionnumberandtype}} \def\unnumbsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Ynothing}} \def\appendixsetref#1{% \dosetq{#1-title}{Ytitle}% \dosetq{#1-pg}{Ypagenumber}% \dosetq{#1-snt}{Yappendixletterandtype}} % \xref, \pxref, and \ref generate cross-references to specified points. % For \xrefX, #1 is the node name, #2 the name of the Info % cross-reference, #3 the printed node name, #4 the name of the Info % file, #5 the name of the printed manual. All but the node name can be % omitted. % \def\pxref#1{see \xrefX[#1,,,,,,,]} \def\xref#1{See \xrefX[#1,,,,,,,]} \def\ref#1{\xrefX[#1,,,,,,,]} \def\xrefX[#1,#2,#3,#4,#5,#6]{\begingroup% \def\printedmanual{\ignorespaces #5}% \def\printednodename{\ignorespaces #3}% % \setbox1=\hbox{\printedmanual}% \setbox0=\hbox{\printednodename}% \ifdim \wd0=0pt% % No printed node name was explicitly given. \ifx SETxref-automatic-section-title % % This line should make the actual chapter or section title appear inside % the square brackets. Use the real section title if we have it. \ifdim \wd1>0pt% % It is in another manual, so we don't have it. \def\printednodename{\ignorespaces #1} \else% % We know the real title if we have the xref values. \ifhavexrefs \def\printednodename{\refx{#1-title}}% % Otherwise just copy the Info node name. \else \def\printednodename{\ignorespaces #1} \fi% \fi\def\printednodename{#1-title}% \else% This line just uses the node name. \def\printednodename{\ignorespaces #1}% \fi% ends \ifx SETxref-automatic-section-title \fi% ends \ifdim \wd0 % % % If we use \unhbox0 and \unhbox1 to print the node names, TeX does % not insert empty discretionaries after hyphens, which means that it % will not find a line break at a hyphen in a node names. Since some % manuals are best written with fairly long node names, containing % hyphens, this is a loss. Therefore, we simply give the text of % the node name again, so it is as if TeX is seeing it for the first % time. \ifdim \wd1>0pt section ``\printednodename'' in \cite{\printedmanual}% \else% \turnoffactive% \refx{#1-snt}{} [\printednodename], page\tie\refx{#1-pg}{}% \fi \endgroup} % \dosetq is the interface for calls from other macros % Use \turnoffactive so that punctuation chars such as underscore % work in node names. \def\dosetq #1#2{{\let\folio=0 \turnoffactive% \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} % \internalsetq {foo}{page} expands into % CHARACTERS 'xrdef {foo}{...expansion of \Ypage...} % When the aux file is read, ' is the escape character \def\internalsetq #1#2{'xrdef {#1}{\csname #2\endcsname}} % Things to be expanded by \internalsetq \def\Ypagenumber{\folio} \def\Ytitle{\thissection} \def\Ynothing{} \def\Ysectionnumberandtype{% \ifnum\secno=0 Chapter\xreftie\the\chapno % \else \ifnum \subsecno=0 Section\xreftie\the\chapno.\the\secno % \else \ifnum \subsubsecno=0 % Section\xreftie\the\chapno.\the\secno.\the\subsecno % \else % Section\xreftie\the\chapno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \def\Yappendixletterandtype{% \ifnum\secno=0 Appendix\xreftie'char\the\appendixno{}% \else \ifnum \subsecno=0 Section\xreftie'char\the\appendixno.\the\secno % \else \ifnum \subsubsecno=0 % Section\xreftie'char\the\appendixno.\the\secno.\the\subsecno % \else % Section\xreftie'char\the\appendixno.\the\secno.\the\subsecno.\the\subsubsecno % \fi \fi \fi } \gdef\xreftie{'tie} % Use TeX 3.0's \inputlineno to get the line number, for better error % messages, but if we're using an old version of TeX, don't do anything. % \ifx\inputlineno\thisisundefined \let\linenumber = \empty % Non-3.0. \else \def\linenumber{\the\inputlineno:\space} \fi % Define \refx{NAME}{SUFFIX} to reference a cross-reference string named NAME. % If its value is nonempty, SUFFIX is output afterward. \def\refx#1#2{% \expandafter\ifx\csname X#1\endcsname\relax % If not defined, say something at least. $\langle$un\-de\-fined$\rangle$% \ifhavexrefs \message{\linenumber Undefined cross reference `#1'.}% \else \ifwarnedxrefs\else \global\warnedxrefstrue \message{Cross reference values unknown; you must run TeX again.}% \fi \fi \else % It's defined, so just use it. \csname X#1\endcsname \fi #2% Output the suffix in any case. } % Read the last existing aux file, if any. No error if none exists. % This is the macro invoked by entries in the aux file. \def\xrdef #1#2{ {\catcode`\'=\other\expandafter \gdef \csname X#1\endcsname {#2}}} \def\readauxfile{% \begingroup \catcode `\^^@=\other \catcode `\=\other \catcode `\=\other \catcode `\^^C=\other \catcode `\^^D=\other \catcode `\^^E=\other \catcode `\^^F=\other \catcode `\^^G=\other \catcode `\^^H=\other \catcode `\ =\other \catcode `\^^L=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode `\=\other \catcode 26=\other \catcode `\^^[=\other \catcode `\^^\=\other \catcode `\^^]=\other \catcode `\^^^=\other \catcode `\^^_=\other \catcode `\@=\other \catcode `\^=\other \catcode `\~=\other \catcode `\[=\other \catcode `\]=\other \catcode`\"=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode `\$=\other \catcode `\#=\other \catcode `\&=\other % `\+ does not work, so use 43. \catcode 43=\other % the aux file uses ' as the escape. % Turn off \ as an escape so we do not lose on % entries which were dumped with control sequences in their names. % For example, 'xrdef {$\leq $-fun}{page ...} made by @defun ^^ % Reference to such entries still does not work the way one would wish, % but at least they do not bomb out when the aux file is read in. \catcode `\{=1 \catcode `\}=2 \catcode `\%=\other \catcode `\'=0 \catcode `\\=\other \openin 1 \jobname.aux \ifeof 1 \else \closein 1 \input \jobname.aux \global\havexrefstrue \global\warnedobstrue \fi % Open the new aux file. Tex will close it automatically at exit. \openout \auxfile=\jobname.aux \endgroup} % Footnotes. \newcount \footnoteno % The trailing space in the following definition for supereject is % vital for proper filling; pages come out unaligned when you do a % pagealignmacro call if that space before the closing brace is % removed. \def\supereject{\par\penalty -20000\footnoteno =0 } % @footnotestyle is meaningful for info output only.. \let\footnotestyle=\comment \let\ptexfootnote=\footnote {\catcode `\@=11 % % Auto-number footnotes. Otherwise like plain. \gdef\footnote{% \global\advance\footnoteno by \@ne \edef\thisfootno{$^{\the\footnoteno}$}% % % In case the footnote comes at the end of a sentence, preserve the % extra spacing after we do the footnote number. \let\@sf\empty \ifhmode\edef\@sf{\spacefactor\the\spacefactor}\/\fi % % Remove inadvertent blank space before typesetting the footnote number. \unskip \thisfootno\@sf \footnotezzz }% % Don't bother with the trickery in plain.tex to not require the % footnote text as a parameter. Our footnotes don't need to be so general. % \long\gdef\footnotezzz#1{\insert\footins{% % We want to typeset this text as a normal paragraph, even if the % footnote reference occurs in (for example) a display environment. % So reset some parameters. \interlinepenalty\interfootnotelinepenalty \splittopskip\ht\strutbox % top baseline for broken footnotes \splitmaxdepth\dp\strutbox \floatingpenalty\@MM \leftskip\z@skip \rightskip\z@skip \spaceskip\z@skip \xspaceskip\z@skip \parindent\defaultparindent % % Hang the footnote text off the number. \hang \textindent{\thisfootno}% % % Don't crash into the line above the footnote text. Since this % expands into a box, it must come within the paragraph, lest it % provide a place where TeX can split the footnote. \footstrut #1\strut}% } }%end \catcode `\@=11 % Set the baselineskip to #1, and the lineskip and strut size % correspondingly. There is no deep meaning behind these magic numbers % used as factors; they just match (closely enough) what Knuth defined. % \def\lineskipfactor{.08333} \def\strutheightpercent{.70833} \def\strutdepthpercent {.29167} % \def\setleading#1{% \normalbaselineskip = #1\relax \normallineskip = \lineskipfactor\normalbaselineskip \normalbaselines \setbox\strutbox =\hbox{% \vrule width0pt height\strutheightpercent\baselineskip depth \strutdepthpercent \baselineskip }% } % @| inserts a changebar to the left of the current line. It should % surround any changed text. This approach does *not* work if the % change spans more than two lines of output. To handle that, we would % have adopt a much more difficult approach (putting marks into the main % vertical list for the beginning and end of each change). % \def\|{% % \vadjust can only be used in horizontal mode. \leavevmode % % Append this vertical mode material after the current line in the output. \vadjust{% % We want to insert a rule with the height and depth of the current % leading; that is exactly what \strutbox is supposed to record. \vskip-\baselineskip % % \vadjust-items are inserted at the left edge of the type. So % the \llap here moves out into the left-hand margin. \llap{% % % For a thicker or thinner bar, change the `1pt'. \vrule height\baselineskip width1pt % % This is the space between the bar and the text. \hskip 12pt }% }% } % For a final copy, take out the rectangles % that mark overfull boxes (in case you have decided % that the text looks ok even though it passes the margin). % \def\finalout{\overfullrule=0pt} % End of control word definitions. \message{and turning on texinfo input format.} \def\openindices{% \newindex{cp}% \newcodeindex{fn}% \newcodeindex{vr}% \newcodeindex{tp}% \newcodeindex{ky}% \newcodeindex{pg}% } % Set some numeric style parameters, for 8.5 x 11 format. %\hsize = 6.5in \newdimen\defaultparindent \defaultparindent = 15pt \parindent = \defaultparindent \parskip 18pt plus 1pt \setleading{15pt} \advance\topskip by 1.2cm % Prevent underfull vbox error messages. \vbadness=10000 % Following George Bush, just get rid of widows and orphans. \widowpenalty=10000 \clubpenalty=10000 % Use TeX 3.0's \emergencystretch to help line breaking, but if we're % using an old version of TeX, don't do anything. We want the amount of % stretch added to depend on the line length, hence the dependence on % \hsize. This makes it come to about 9pt for the 8.5x11 format. % \ifx\emergencystretch\thisisundefined % Allow us to assign to \emergencystretch anyway. \def\emergencystretch{\dimen0}% \else \emergencystretch = \hsize \divide\emergencystretch by 45 \fi % Use @smallbook to reset parameters for 7x9.5 format (or else 7x9.25) \def\smallbook{ % These values for secheadingskip and subsecheadingskip are % experiments. RJC 7 Aug 1992 \global\secheadingskip = 17pt plus 6pt minus 3pt \global\subsecheadingskip = 14pt plus 6pt minus 3pt \global\lispnarrowing = 0.3in \setleading{12pt} \advance\topskip by -1cm \global\parskip 3pt plus 1pt \global\hsize = 5in \global\vsize=7.5in \global\tolerance=700 \global\hfuzz=1pt \global\contentsrightmargin=0pt \global\pagewidth=\hsize \global\pageheight=\vsize \global\let\smalllisp=\smalllispx \global\let\smallexample=\smalllispx \global\def\Esmallexample{\Esmalllisp} } % Use @afourpaper to print on European A4 paper. \def\afourpaper{ \global\tolerance=700 \global\hfuzz=1pt \setleading{12pt} \global\parskip 15pt plus 1pt \global\vsize= 53\baselineskip \advance\vsize by \topskip %\global\hsize= 5.85in % A4 wide 10pt \global\hsize= 6.5in \global\outerhsize=\hsize \global\advance\outerhsize by 0.5in \global\outervsize=\vsize \global\advance\outervsize by 0.6in \global\pagewidth=\hsize \global\pageheight=\vsize } % Define macros to output various characters with catcode for normal text. \catcode`\"=\other \catcode`\~=\other \catcode`\^=\other \catcode`\_=\other \catcode`\|=\other \catcode`\<=\other \catcode`\>=\other \catcode`\+=\other \def\normaldoublequote{"} \def\normaltilde{~} \def\normalcaret{^} \def\normalunderscore{_} \def\normalverticalbar{|} \def\normalless{<} \def\normalgreater{>} \def\normalplus{+} % This macro is used to make a character print one way in ttfont % where it can probably just be output, and another way in other fonts, % where something hairier probably needs to be done. % % #1 is what to print if we are indeed using \tt; #2 is what to print % otherwise. Since all the Computer Modern typewriter fonts have zero % interword stretch (and shrink), and it is reasonable to expect all % typewriter fonts to have this, we can check that font parameter. % \def\ifusingtt#1#2{\ifdim \fontdimen3\the\font=0pt #1\else #2\fi} % Turn off all special characters except @ % (and those which the user can use as if they were ordinary). % Most of these we simply print from the \tt font, but for some, we can % use math or other variants that look better in normal text. \catcode`\"=\active \def\activedoublequote{{\tt \char '042}} \let"=\activedoublequote \catcode`\~=\active \def~{{\tt \char '176}} \chardef\hat=`\^ \catcode`\^=\active \def^{{\tt \hat}} \catcode`\_=\active \def_{\ifusingtt\normalunderscore\_} % Subroutine for the previous macro. \def\_{\lvvmode \kern.06em \vbox{\hrule width.3em height.1ex}} % \lvvmode is equivalent in function to \leavevmode. % Using \leavevmode runs into trouble when written out to % an index file due to the expansion of \leavevmode into ``\unhbox % \voidb@x'' ---which looks to TeX like ``\unhbox \voidb\x'' due to our % magic tricks with @. \def\lvvmode{\vbox to 0pt{}} \catcode`\|=\active \def|{{\tt \char '174}} \chardef \less=`\< \catcode`\<=\active \def<{{\tt \less}} \chardef \gtr=`\> \catcode`\>=\active \def>{{\tt \gtr}} \catcode`\+=\active \def+{{\tt \char 43}} %\catcode 27=\active %\def^^[{$\diamondsuit$} % Used sometimes to turn off (effectively) the active characters % even after parsing them. \def\turnoffactive{\let"=\normaldoublequote \let~=\normaltilde \let^=\normalcaret \let_=\normalunderscore \let|=\normalverticalbar \let<=\normalless \let>=\normalgreater \let+=\normalplus} % Set up an active definition for =, but don't enable it most of the time. {\catcode`\==\active \global\def={{\tt \char 61}}} \catcode`\@=0 % \rawbackslashxx output one backslash character in current font \global\chardef\rawbackslashxx=`\\ %{\catcode`\\=\other %@gdef@rawbackslashxx{\}} % \rawbackslash redefines \ as input to do \rawbackslashxx. {\catcode`\\=\active @gdef@rawbackslash{@let\=@rawbackslashxx }} % \normalbackslash outputs one backslash in fixed width font. \def\normalbackslash{{\tt\rawbackslashxx}} % Say @foo, not \foo, in error messages. \escapechar=`\@ % \catcode 17=0 % Define control-q \catcode`\\=\active % If a .fmt file is being used, we don't want the `\input texinfo' to show up. % That is what \eatinput is for; after that, the `\' should revert to printing % a backslash. % @gdef@eatinput input texinfo{@fixbackslash} @global@let\ = @eatinput % On the other hand, perhaps the file did not have a `\input texinfo'. Then % the first `\{ in the file would cause an error. This macro tries to fix % that, assuming it is called before the first `\' could plausibly occur. % @gdef@fixbackslash{@ifx\@eatinput @let\ = @normalbackslash @fi} %% These look ok in all fonts, so just make them not special. The @rm below %% makes sure that the current font starts out as the newly loaded cmr10 @catcode`@$=@other @catcode`@%=@other @catcode`@&=@other @catcode`@#=@other @textfonts @rm @c Local variables: @c page-delimiter: "^\\\\message" @c End: make-3.70/TAGS 666 12241 13 27000 5512120706 6147 ./commands.c,170 set_file_variables 35,1048 chop_commands 192,4730 execute_file_commands 290,6980 fatal_error_signal 329,7907 delete_child_targets 403,9873 print_commands 443,10978 ./job.c,951 #define GET_NGROUPS_MAX 38,1273 #define NGROUPS_MAX 40,1347 #define WAIT_NOHANG(49,1477 #define WAIT_NOHANG(55,1630 #define WAIT_T 65,1853 #define WTERMSIG(68,1890 #define WCOREDUMP(71,1948 #define WEXITSTATUS(74,2009 #define WIFSIGNALED(77,2079 #define WIFEXITED(80,2147 #define WAIT_T 85,2229 #define WTERMSIG(87,2272 #define WCOREDUMP(90,2333 #define WEXITSTATUS(93,2398 #define WIFSIGNALED(96,2464 #define WIFEXITED(99,2531 #define getdtablesize(118,2888 #define NOFILE 121,3039 child_error 155,3892 child_handler 180,4602 reap_children 198,5154 free_child 455,11754 unblock_sigs 481,12279 start_job_command 493,12547 start_waiting_job 686,17448 new_job 742,18988 job_next_command 897,23520 load_too_high 919,24097 start_waiting_jobs 951,24801 child_execute_job 977,25506 search_path 1003,26074 exec_command 1095,27959 construct_command_argv_internal 1182,30039 construct_command_argv 1456,37133 dup2 1484,37752 ./dir.c,672 #define D_NAMLEN(24,928 #define D_NAMLEN(26,996 #define direct 29,1099 #define D_NAMLEN(30,1121 #define REAL_DIR_ENTRY(45,1520 #define REAL_DIR_ENTRY(47,1555 #define DIRECTORY_BUCKETS 53,1681 struct directory_contents56,1719 struct directory69,2123 #define MAX_OPEN_DIRECTORIES 87,2649 struct dirfile94,2773 #define DIRFILE_BUCKETS 102,2945 find_directory 110,3124 dir_contents_file_exists_p 203,5764 dir_file_exists_p 288,7826 file_exists_p 299,8074 file_impossible 325,8702 file_impossible_p 382,10343 dir_name 422,11307 print_dir_data_base 431,11430 struct dirstream499,13134 open_dirstream 512,13492 read_dirstream 537,14243 init_dir 560,14663 ./file.c,222 #define FILE_BUCKETS 29,951 lookup_file 44,1351 enter_file 81,2162 rename_file 130,3206 file_hash_enter 151,3618 remove_intermediates 288,7269 snap_deps 346,8416 print_file 389,9494 print_file_data_base 475,11693 ./getloadavg.c,1467 #define LDAV_CVT(101,3567 #define BSD106,3702 #define hpux127,4253 #define MORE_BSD131,4311 #define decstation135,4373 #define SUNOS_5139,4434 #define OSF_ALPHA143,4526 #define OSF_MIPS147,4616 #define tek4300 155,5018 #define LOAD_AVE_TYPE 163,5207 #define LOAD_AVE_TYPE 167,5253 #define LOAD_AVE_TYPE 171,5306 #define LOAD_AVE_TYPE 175,5358 #define LOAD_AVE_TYPE 179,5404 #define LOAD_AVE_TYPE 183,5451 #define LOAD_AVE_TYPE 187,5503 #define LOAD_AVE_TYPE 191,5553 #define LOAD_AVE_TYPE 195,5605 #define LOAD_AVE_TYPE 199,5680 #define LOAD_AVE_TYPE 203,5730 #define FSCALE 212,5943 #define FSCALE 221,6066 #define FSCALE 225,6154 #define FSCALE 232,6365 #define FSCALE 236,6435 #define FSCALE 240,6481 #define LDAV_CVT(246,6581 #define NLIST_STRUCT253,6753 #define NLIST_STRUCT257,6793 #define NLIST_STRUCT261,6840 #define NLIST_STRUCT265,6881 #define NLIST_STRUCT269,6955 #define NLIST_STRUCT273,6995 #define NLIST_STRUCT277,7036 #define NLIST_STRUCT281,7082 #define NLIST_STRUCT285,7128 #define NLIST_STRUCT289,7197 #define NLIST_STRUCT293,7241 #define NLIST_STRUCT297,7287 #define FIXUP_KERNEL_SYMBOL_ADDR(304,7407 #define KERNEL_FILE 309,7533 #define KERNEL_FILE 313,7615 #define KERNEL_FILE 317,7827 #define LDAV_SYMBOL 322,7912 #define LDAV_SYMBOL 326,8134 #define LOAD_AVE_TYPE 343,8503 #define KERNEL_FILE 361,8764 #define LDAV_SYMBOL 365,8840 #define LDAV_CVT(379,9066 getloadavg 469,11030 main 858,20773 ./misc.c,671 alpha_compare 27,943 collapse_continuations 40,1261 remove_comments 123,2980 print_spaces 161,3615 concat 173,3804 message 199,4375 fatal 215,4690 error 233,5085 makefile_error 246,5374 makefile_fatal 258,5652 strerror 272,5960 perror_with_name 290,6292 pfatal_with_name 299,6457 xmalloc 313,6671 xrealloc 324,6840 savestring 335,7036 sindex 351,7438 lindex 378,8089 end_of_token 392,8314 next_token 419,8732 find_next_token 433,8982 copy_dep_chain 453,9351 dep_name 482,9943 #define access_inited 504,10511 log_access 511,10669 init_access 528,11072 user_access 550,11561 make_access 610,13469 child_access 648,14278 get_path_max 681,14982 ./main.c,456 struct command_switch51,1542 struct stringlist83,2606 #define DESCRIPTION_COLUMN 304,9525 enter_command_line_file 345,10449 main 380,11294 static char options[sizeof 1123,30667 static struct option long_options[(sizeof 1124,30734 init_switches 1130,30955 decode_switches 1185,32158 decode_env_switches 1432,38155 define_makeflags 1491,39940 print_version 1693,45844 print_data_base 1723,46755 die 1744,47207 log_working_directory 1779,47841 ./read.c,446 struct linebuffer47,1423 #define initbuffer(56,1665 #define freebuffer(57,1739 struct conditionals68,2142 read_all_makefiles 112,3267 read_makefile 227,6158 do_define 756,20790 conditional_line 839,22950 uniquize_deps 1042,28131 record_files 1088,29362 find_semicolon 1381,37584 find_percent 1425,38604 parse_file_seq 1471,39935 readline 1640,44252 construct_include_path 1736,46707 tilde_expand 1810,48600 multi_glob 1887,50438 ./remake.c,269 update_goal_chain 51,1728 update_file 237,6805 update_file_1 278,7609 notice_finished_file 576,14984 check_dep 650,17207 #define TOUCH_ERROR(728,19121 touch_file 731,19207 remake_file 785,20427 f_mtime 835,21695 name_mtime 941,24230 library_search 958,24557 ./rule.c,258 count_implicit_rule_limits 67,1929 convert_suffix_rule 163,4307 convert_to_pattern 217,5749 new_pattern_rule 286,8014 install_pattern_rule 361,9772 freerule 413,11380 create_pattern_rule 462,13175 print_rule 512,14606 print_rule_data_base 538,15054 ./implicit.c,76 try_implicit_rule 33,1196 #define DEBUGP2(61,1976 pattern_search 82,2787 ./default.c,146 set_default_suffixes 308,8290 install_default_suffix_rules 330,8966 install_default_implicit_rules 355,9486 define_default_variables 370,9781 ./variable.c,630 #define VARIABLE_BUCKETS 28,985 #define PERFILE_VARIABLE_BUCKETS 31,1055 #define SMALL_SCOPE_VARIABLE_BUCKETS 34,1135 define_variable_in_set 53,1891 define_variable 117,3593 define_variable_for_file 131,3949 lookup_variable 149,4535 initialize_file_variables 183,5443 pop_variable_scope 214,6314 push_new_variable_scope 242,6929 merge_variable_sets 263,7603 merge_variable_set_lists 314,8715 define_automatic_variables 346,9425 target_environment 405,11559 try_variable_definition 565,16176 print_variable 691,19208 print_variable_set 762,20716 print_variable_data_base 804,21613 print_file_variables 815,21777 ./expand.c,285 variable_buffer_output 41,1642 initialize_variable_output 65,2307 recursively_expand 82,2683 warn_undefined 113,3315 reference_variable 134,3801 variable_expand 161,4545 expand_argument 403,10767 variable_expand_for_file 424,11201 allocated_variable_expand_for_file 450,11852 ./function.c,233 subst_expand 35,1378 patsubst_expand 94,3221 enum function200,6772 #define MAXFUNCTIONLEN 227,7322 pattern_matches 265,8446 #define BADARGS(298,9398 expand_function 307,9727 handle_function 1101,27805 string_glob 1174,29678 ./vpath.c,167 struct vpath25,890 build_vpath_lists 50,1681 construct_vpath_list 118,3899 vpath_search 272,7748 selective_vpath_search 304,8643 print_vpath_data_base 445,12754 ./version.c,0 ./remote-cstms.c,231 #define __STRICT_BSD__ 30,1102 #define EXPORT_COMMAND 38,1360 start_remote_job_p 49,1669 start_remote_job 110,3454 remote_status 239,7052 block_remote_children 250,7371 unblock_remote_children 259,7571 remote_kill 266,7689 ./ar.c,238 ar_name 39,1246 ar_parse_name 59,1749 ar_member_date 76,2128 ar_member_date_1 119,3189 ar_touch 134,3542 struct ar_glob_state188,4694 ar_glob_match 201,4955 ar_glob_alphacompare 227,5621 glob_pattern_p 236,5843 ar_glob 272,6361 ./arscan.c,213 #define PORTAR 44,1558 #define PORTAR 46,1581 #define AR_HDR_SIZE 54,1696 ar_scan 85,2595 ar_name_equal 381,9404 ar_member_pos 442,10670 ar_member_touch 464,11269 describe_member 522,12666 main 541,13160 ./signame.c,190 #define NSIG 36,1301 #define NSIG 38,1326 #define const43,1371 } num_abbrev;70,1983 init_sig 78,2199 signame_init 91,2462 sig_abbrev 231,6308 sig_number 249,6645 psignal 273,7193 ./signame.h,0 ./getopt.c,175 #define _NO_PROTO28,1087 #define const46,1568 #define my_index 175,6488 my_index 184,6638 exchange 231,7949 _getopt_internal 343,12136 getopt 677,20265 main 696,20647 ./getopt1.c,106 #define const36,1300 #define NULL 62,2091 getopt_long 66,2118 getopt_long_only 82,2621 main 100,2977 ./getopt.h,125 #define _GETOPT_H 19,801 #define no_argument 93,3203 #define required_argument 94,3226 #define optional_argument 95,3254 ./commands.h,124 struct commands21,872 #define COMMANDS_RECURSE 34,1385 #define COMMANDS_SILENT 35,1443 #define COMMANDS_NOERROR 36,1488 ./dep.h,217 struct dep24,975 struct nameseq35,1144 #define dep_name(50,1380 #define RM_NO_DEFAULT_GOAL 61,1749 #define RM_INCLUDED 62,1817 #define RM_DONTCARE 63,1883 #define RM_NO_TILDE 64,1950 #define RM_NOFLAG 65,2016 ./file.h,175 struct file23,918 #define file_mtime_1(88,3474 #define file_mtime(90,3574 #define file_mtime_no_search(91,3618 #define NEW_MTIME 102,4268 #define check_renamed(105,4310 ./job.h,80 struct child20,808 #define unblock_sigs(58,1896 #define unblock_sigs(60,1940 ./make.h,999 #define HAVE_CONFIG_H29,1139 #define signal 34,1272 #define _GNU_SOURCE37,1305 #define isblank(57,1797 #define POSIX63,1915 #define POSIX75,2231 #define sys_siglist 79,2316 #define HAVE_SYS_SIGLIST 80,2349 #define SYS_SIGLIST_DECLARED84,2510 #define NSIG 98,2750 #define NSIG 100,2775 #define RETSIGTYPE 105,2825 #define sigmask(109,2873 #define PATH_MAX 121,3055 #define MAXPATHLEN 125,3154 #define GET_PATH_MAX 129,3224 #define PATH_VAR(130,3254 #define NEED_GET_PATH_MAX132,3301 #define GET_PATH_MAX 134,3364 #define PATH_VAR(135,3403 #define S_ISREG(148,3627 #define S_ISDIR(151,3703 #define ANSI_STRING158,3863 #define ANSI_STRING163,3959 #define index(182,4242 #define rindex(185,4301 #define bcmp(189,4361 #define bzero(192,4431 #define bcopy(195,4493 #define alloca(216,4783 #define streq(228,5042 #define streq(233,5197 #define HASH(237,5317 #define ENUM_BITFIELD(241,5445 #define ENUM_BITFIELD(243,5485 #define getcwd(312,7378 #define DEBUGPR(338,8080 ./rule.h,40 struct rule20,806 struct pspec33,1292 ./variable.h,156 enum variable_origin20,908 struct variable36,1499 struct variable_set56,2181 struct variable_set_list64,2399 #define allocated_variable_expand(80,2861 ./alloca.c,584 #define ADDRESS_FUNCTION(58,1949 #define ADDRESS_FUNCTION(60,2012 typedef void *pointer;64,2070 typedef char *pointer;66,2099 #define NULL 69,2130 #define malloc 82,2594 #define STACK_DIRECTION 95,2993 #define STACK_DIR 100,3079 #define STACK_DIR 105,3250 find_stack_direction 108,3291 #define ALIGN_SIZE 139,4081 typedef union hdr142,4123 } header;150,4329 alloca 162,4780 #define CRAY_STACK222,6180 struct stack_control_header225,6273 struct stack_segment_linkage240,6894 struct stk_stat278,7992 struct stk_trailer307,9415 i00afunc 336,10073 i00afunc 410,12021 ./config.h.in,0 ./remote-cstms.c,231 #define __STRICT_BSD__ 30,1102 #define EXPORT_COMMAND 38,1360 start_remote_job_p 49,1669 start_remote_job 110,3454 remote_status 239,7052 block_remote_children 250,7371 unblock_remote_children 259,7571 remote_kill 266,7689 ./remote-stub.c,161 start_remote_job_p 28,900 start_remote_job 41,1362 remote_status 58,1932 block_remote_children 70,2269 unblock_remote_children 79,2469 remote_kill 86,2587 make-3.70/tags 666 12241 13 33236 5512120723 6356 ADDRESS_FUNCTION ./alloca.c /^#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&/ BADARGS ./function.c /^#define BADARGS(func) \\$/ DEBUGP2 ./implicit.c /^#define DEBUGP2(msg, a1, a2) \\$/ DEBUGPR ./make.h /^#define DEBUGPR(msg) \\$/ D_NAMLEN ./dir.c /^#define D_NAMLEN(d) strlen((d)->d_name)$/ ENUM_BITFIELD ./make.h /^#define ENUM_BITFIELD(bits) :bits$/ FIXUP_KERNEL_SYMBOL_ADDR ./getloadavg.c /^#define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_va/ HASH ./make.h /^#define HASH(var, c) \\$/ LDAV_CVT ./getloadavg.c /^#define LDAV_CVT(n) (LOAD_AVE_CVT (n) \/ 100.0)$/ Marscan ./arscan.c /^main (argc, argv)$/ Mgetloadavg ./getloadavg.c /^main (argc, argv)$/ Mgetopt ./getopt.c /^main (argc, argv)$/ Mgetopt1 ./getopt1.c /^main (argc, argv)$/ Mmain ./main.c /^main (argc, argv, envp)$/ PATH_VAR ./make.h /^#define PATH_VAR(var) char var[PATH_MAX]$/ REAL_DIR_ENTRY ./dir.c /^#define REAL_DIR_ENTRY(dp) 1$/ S_ISDIR ./make.h /^#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDI/ S_ISREG ./make.h /^#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFRE/ TOUCH_ERROR ./remake.c /^#define TOUCH_ERROR(call) return (perror_with_name/ WAIT_NOHANG ./job.c /^#define WAIT_NOHANG(status) waitpid (-1, (status),/ WCOREDUMP ./job.c /^#define WCOREDUMP(x) ((x) & 0x80)$/ WEXITSTATUS ./job.c /^#define WEXITSTATUS(x) (((x) >> 8) & 0xff)$/ WIFEXITED ./job.c /^#define WIFEXITED(x) (WTERMSIG (x) == 0)$/ WIFSIGNALED ./job.c /^#define WIFSIGNALED(x) (WTERMSIG (x) != 0)$/ WTERMSIG ./job.c /^#define WTERMSIG(x) ((x) & 0x7f)$/ _getopt_internal ./getopt.c /^_getopt_internal (argc, argv, optstring, longopts,/ alloca ./make.h /^#define alloca(n) __builtin_alloca (n)$/ allocated_variable_expand ./variable.h /^#define allocated_variable_expand(line) \\$/ allocated_variable_expand_for_file ./expand.c /^allocated_variable_expand_for_file (line, file)$/ alpha_compare ./misc.c /^alpha_compare (s1, s2)$/ ar_glob ./ar.c /^ar_glob (arname, member_pattern, size)$/ ar_glob_alphacompare ./ar.c /^ar_glob_alphacompare (a, b)$/ ar_glob_match ./ar.c /^ar_glob_match (desc, mem, truncated,$/ ar_member_date ./ar.c /^ar_member_date (name)$/ ar_member_date_1 ./ar.c /^ar_member_date_1 (desc, mem, truncated,$/ ar_member_pos ./arscan.c /^ar_member_pos (desc, mem, truncated,$/ ar_member_touch ./arscan.c /^ar_member_touch (arname, memname)$/ ar_name ./ar.c /^ar_name (name)$/ ar_name_equal ./arscan.c /^ar_name_equal (name, mem, truncated)$/ ar_parse_name ./ar.c /^ar_parse_name (name, arname_p, memname_p)$/ ar_scan ./arscan.c /^ar_scan (archive, function, arg)$/ ar_touch ./ar.c /^ar_touch (name)$/ bcmp ./make.h /^#define bcmp(s1, s2, n) memcmp ((s1), (s2), (n))$/ bcopy ./make.h /^#define bcopy(s, d, n) memcpy ((d), (s), (n))$/ block_remote_children ./remote-cstms.c /^block_remote_children ()$/ build_vpath_lists ./vpath.c /^build_vpath_lists ()$/ bzero ./make.h /^#define bzero(s, n) memset ((s), 0, (n))$/ check_dep ./remake.c /^check_dep (file, depth, this_mtime, must_make_ptr)/ check_renamed ./file.h /^#define check_renamed(file) \\$/ child_access ./misc.c /^child_access ()$/ child_error ./job.c /^child_error (target_name, exit_code, exit_sig, cor/ child_execute_job ./job.c /^child_execute_job (stdin_fd, stdout_fd, argv, envp/ child_handler ./job.c /^child_handler (sig)$/ chop_commands ./commands.c /^chop_commands (cmds)$/ collapse_continuations ./misc.c /^collapse_continuations (line)$/ concat ./misc.c /^concat (s1, s2, s3)$/ conditional_line ./read.c /^conditional_line (line, filename, lineno)$/ construct_command_argv ./job.c /^construct_command_argv (line, restp, file)$/ construct_command_argv_internal ./job.c /^construct_command_argv_internal (line, restp, shel/ construct_include_path ./read.c /^construct_include_path (arg_dirs)$/ construct_vpath_list ./vpath.c /^construct_vpath_list (pattern, dirpath)$/ convert_suffix_rule ./rule.c /^convert_suffix_rule (target, source, cmds)$/ convert_to_pattern ./rule.c /^convert_to_pattern ()$/ copy_dep_chain ./misc.c /^copy_dep_chain (d)$/ count_implicit_rule_limits ./rule.c /^count_implicit_rule_limits ()$/ create_pattern_rule ./rule.c /^create_pattern_rule (targets, target_percents,$/ decode_env_switches ./main.c /^decode_env_switches (envar, len)$/ decode_switches ./main.c /^decode_switches (argc, argv, env)$/ define_automatic_variables ./variable.c /^define_automatic_variables ()$/ define_default_variables ./default.c /^define_default_variables ()$/ define_makeflags ./main.c /^define_makeflags (all, makefile)$/ define_variable ./variable.c /^define_variable (name, length, value, origin, recu/ define_variable_for_file ./variable.c /^define_variable_for_file (name, length, value, ori/ define_variable_in_set ./variable.c /^define_variable_in_set (name, length, value, origi/ delete_child_targets ./commands.c /^delete_child_targets (child)$/ dep_name ./misc.c /^dep_name (dep)$/ describe_member ./arscan.c /^describe_member (desc, name, truncated,$/ die ./main.c /^die (status)$/ dir_contents_file_exists_p ./dir.c /^dir_contents_file_exists_p (dir, filename)$/ dir_file_exists_p ./dir.c /^dir_file_exists_p (dirname, filename)$/ dir_name ./dir.c /^dir_name (dir)$/ do_define ./read.c /^do_define (name, namelen, origin, lineno, infile, / dup2 ./job.c /^dup2 (old, new)$/ end_of_token ./misc.c /^end_of_token (s)$/ enter_command_line_file ./main.c /^enter_command_line_file (name)$/ enter_file ./file.c /^enter_file (name)$/ error ./misc.c /^error (s1, s2, s3, s4, s5, s6)$/ exchange ./getopt.c /^exchange (argv)$/ exec_command ./job.c /^exec_command (argv, envp)$/ execute_file_commands ./commands.c /^execute_file_commands (file)$/ expand_argument ./expand.c /^expand_argument (str, end)$/ expand_function ./function.c /^expand_function (o, function, text, end)$/ f_mtime ./remake.c /^f_mtime (file, search)$/ fatal ./misc.c /^fatal (s1, s2, s3, s4, s5, s6)$/ fatal_error_signal ./commands.c /^fatal_error_signal (sig)$/ file_exists_p ./dir.c /^file_exists_p (name)$/ file_hash_enter ./file.c /^file_hash_enter (file, name, oldhash, oldname)$/ file_impossible ./dir.c /^file_impossible (filename)$/ file_impossible_p ./dir.c /^file_impossible_p (filename)$/ file_mtime ./file.h /^#define file_mtime(f) file_mtime_1 ((f), 1)$/ file_mtime_1 ./file.h /^#define file_mtime_1(f, v) \\$/ file_mtime_no_search ./file.h /^#define file_mtime_no_search(f) file_mtime_1 ((f),/ find_directory ./dir.c /^find_directory (name)$/ find_next_token ./misc.c /^find_next_token (ptr, lengthptr)$/ find_percent ./read.c /^find_percent (pattern)$/ find_semicolon ./read.c /^find_semicolon (string)$/ find_stack_direction ./alloca.c /^find_stack_direction ()$/ free_child ./job.c /^free_child (child)$/ freebuffer ./read.c /^#define freebuffer(lb) free ((lb)->buffer)$/ freerule ./rule.c /^freerule (rule, lastrule)$/ get_path_max ./misc.c /^get_path_max ()$/ getcwd ./make.h /^#define getcwd(buf, len) getwd (buf)$/ getdtablesize ./job.c /^#define getdtablesize() NOFILE$/ getloadavg ./getloadavg.c /^getloadavg (loadavg, nelem)$/ getopt ./getopt.c /^getopt (argc, argv, optstring)$/ getopt_long ./getopt1.c /^getopt_long (argc, argv, options, long_options, op/ getopt_long_only ./getopt1.c /^getopt_long_only (argc, argv, options, long_option/ glob_pattern_p ./ar.c /^glob_pattern_p (pattern, quote)$/ handle_function ./function.c /^handle_function (op, stringp)$/ header ./alloca.c 150 i00afunc ./alloca.c /^i00afunc (long *address)$/ index ./make.h /^#define index(s, c) strchr((s), (c))$/ init_access ./misc.c /^init_access ()$/ init_dir ./dir.c /^init_dir ()$/ init_sig ./signame.c /^init_sig (number, abbrev, name)$/ init_switches ./main.c /^init_switches ()$/ initbuffer ./read.c /^#define initbuffer(lb) (lb)->buffer = (char *) xma/ initialize_file_variables ./variable.c /^initialize_file_variables (file)$/ initialize_variable_output ./expand.c /^initialize_variable_output ()$/ install_default_implicit_rules ./default.c /^install_default_implicit_rules ()$/ install_default_suffix_rules ./default.c /^install_default_suffix_rules ()$/ install_pattern_rule ./rule.c /^install_pattern_rule (p, terminal)$/ isblank ./make.h /^#define isblank(c) ((c) == ' ' || (c) == '\\t')$/ job_next_command ./job.c /^job_next_command (child)$/ library_search ./remake.c /^library_search (lib, mtime_ptr)$/ lindex ./misc.c /^lindex (s, limit, c)$/ load_too_high ./job.c /^load_too_high ()$/ log_access ./misc.c /^log_access (flavor)$/ log_working_directory ./main.c /^log_working_directory (entering)$/ lookup_file ./file.c /^lookup_file (name)$/ lookup_variable ./variable.c /^lookup_variable (name, length)$/ make_access ./misc.c /^make_access ()$/ makefile_error ./misc.c /^makefile_error (file, lineno, s1, s2, s3, s4, s5, / makefile_fatal ./misc.c /^makefile_fatal (file, lineno, s1, s2, s3, s4, s5, / merge_variable_set_lists ./variable.c /^merge_variable_set_lists (setlist0, setlist1)$/ merge_variable_sets ./variable.c /^merge_variable_sets (set0, set1)$/ message ./misc.c /^message (s1, s2, s3, s4, s5, s6)$/ multi_glob ./read.c /^multi_glob (chain, size)$/ my_index ./getopt.c /^my_index (str, chr)$/ name_mtime ./remake.c /^name_mtime (name)$/ new_job ./job.c /^new_job (file)$/ new_pattern_rule ./rule.c /^new_pattern_rule (rule, override)$/ next_token ./misc.c /^next_token (s)$/ notice_finished_file ./remake.c /^notice_finished_file (file)$/ num_abbrev ./signame.c 70 open_dirstream ./dir.c /^open_dirstream (directory)$/ parse_file_seq ./read.c /^parse_file_seq (stringp, stopchar, size, strip)$/ patsubst_expand ./function.c /^patsubst_expand (o, text, pattern, replace, patter/ pattern_matches ./function.c /^pattern_matches (pattern, percent, word)$/ pattern_search ./implicit.c /^pattern_search (file, archive, depth, recursions)$/ perror_with_name ./misc.c /^perror_with_name (str, name)$/ pfatal_with_name ./misc.c /^pfatal_with_name (name)$/ pointer ./alloca.c 64 pop_variable_scope ./variable.c /^pop_variable_scope ()$/ print_commands ./commands.c /^print_commands (cmds)$/ print_data_base ./main.c /^print_data_base ()$/ print_dir_data_base ./dir.c /^print_dir_data_base ()$/ print_file ./file.c /^print_file (f)$/ print_file_data_base ./file.c /^print_file_data_base ()$/ print_file_variables ./variable.c /^print_file_variables (file)$/ print_rule ./rule.c /^print_rule (r)$/ print_rule_data_base ./rule.c /^print_rule_data_base ()$/ print_spaces ./misc.c /^print_spaces (n)$/ print_variable ./variable.c /^print_variable (v, prefix)$/ print_variable_data_base ./variable.c /^print_variable_data_base ()$/ print_variable_set ./variable.c /^print_variable_set (set, prefix)$/ print_version ./main.c /^print_version ()$/ print_vpath_data_base ./vpath.c /^print_vpath_data_base ()$/ psignal ./signame.c /^psignal (signal, message)$/ push_new_variable_scope ./variable.c /^push_new_variable_scope ()$/ read_all_makefiles ./read.c /^read_all_makefiles (makefiles)$/ read_dirstream ./dir.c /^read_dirstream (stream)$/ read_makefile ./read.c /^read_makefile (filename, flags)$/ readline ./read.c /^readline (linebuffer, stream, filename, lineno)$/ reap_children ./job.c /^reap_children (block, err)$/ record_files ./read.c /^record_files (filenames, pattern, pattern_percent,/ recursively_expand ./expand.c /^recursively_expand (v)$/ reference_variable ./expand.c /^reference_variable (o, name, length)$/ remake_file ./remake.c /^remake_file (file)$/ remote_kill ./remote-cstms.c /^remote_kill (id, sig)$/ remote_status ./remote-cstms.c /^remote_status (exit_code_ptr, signal_ptr, coredump/ remove_comments ./misc.c /^remove_comments (line)$/ remove_intermediates ./file.c /^remove_intermediates (sig)$/ rename_file ./file.c /^rename_file (file, name)$/ rindex ./make.h /^#define rindex(s, c) strrchr((s), (c))$/ savestring ./misc.c /^savestring (str, length)$/ search_path ./job.c /^search_path (file, path, program)$/ selective_vpath_search ./vpath.c /^selective_vpath_search (path, file, mtime_ptr)$/ set_default_suffixes ./default.c /^set_default_suffixes ()$/ set_file_variables ./commands.c /^set_file_variables (file)$/ sig_abbrev ./signame.c /^sig_abbrev (number)$/ sig_number ./signame.c /^sig_number (abbrev)$/ sigmask ./make.h /^#define sigmask(sig) (1 << ((sig) - 1))$/ signame_init ./signame.c /^signame_init ()$/ sindex ./misc.c /^sindex (big, blen, small, slen)$/ sizeof ./main.c /^static char options[sizeof (switches) \/ sizeof (sw/ snap_deps ./file.c /^snap_deps ()$/ start_job_command ./job.c /^start_job_command (child)$/ start_remote_job ./remote-cstms.c /^start_remote_job (argv, envp, stdin_fd, is_remote,/ start_remote_job_p ./remote-cstms.c /^start_remote_job_p ()$/ start_waiting_job ./job.c /^start_waiting_job (c)$/ start_waiting_jobs ./job.c /^start_waiting_jobs ()$/ streq ./make.h /^#define streq(a, b) \\$/ strerror ./misc.c /^strerror (errnum)$/ string_glob ./function.c /^string_glob (line)$/ subst_expand ./function.c /^subst_expand (o, text, subst, replace, slen, rlen,/ target_environment ./variable.c /^target_environment (file)$/ tilde_expand ./read.c /^tilde_expand (name)$/ touch_file ./remake.c /^touch_file (file)$/ try_implicit_rule ./implicit.c /^try_implicit_rule (file, depth)$/ try_variable_definition ./variable.c /^try_variable_definition (filename, lineno, line, o/ unblock_remote_children ./remote-cstms.c /^unblock_remote_children ()$/ unblock_sigs ./job.c /^unblock_sigs ()$/ uniquize_deps ./read.c /^uniquize_deps (chain)$/ update_file ./remake.c /^update_file (file, depth)$/ update_file_1 ./remake.c /^update_file_1 (file, depth)$/ update_goal_chain ./remake.c /^update_goal_chain (goals, makefiles)$/ user_access ./misc.c /^user_access ()$/ variable_buffer_output ./expand.c /^variable_buffer_output (ptr, string, length)$/ variable_expand ./expand.c /^variable_expand (line)$/ variable_expand_for_file ./expand.c /^variable_expand_for_file (line, file)$/ vpath_search ./vpath.c /^vpath_search (file, mtime_ptr)$/ warn_undefined ./expand.c /^warn_undefined (name, length)$/ xmalloc ./misc.c /^xmalloc (size)$/ xrealloc ./misc.c /^xrealloc (ptr, size)$/ make-3.70/install.sh 777 12120 1 4212 5273135271 7433 #!/bin/sh # # install - install a program, script, or datafile # This comes from X11R5; it is not part of GNU. # # $XConsortium: install.sh,v 1.2 89/12/18 14:47:22 jim Exp $ # # This script is compatible with the BSD install script, but was written # from scratch. # # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" instcmd="$mvprog" chmodcmd="" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" while [ x"$1" != x ]; do case $1 in -c) instcmd="$cpprog" shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd="$stripprog" shift continue;; *) if [ x"$src" = x ] then src=$1 else dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "install: no input file specified" exit 1 fi if [ x"$dst" = x ] then echo "install: no destination specified" exit 1 fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d $dst ] then dst="$dst"/`basename $src` fi # Make a temp file name in the proper directory. dstdir=`dirname $dst` dsttmp=$dstdir/#inst.$$# # Move or copy the file name to the temp name $doit $instcmd $src $dsttmp # and set any options; do chmod last to preserve setuid bits if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; fi if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; fi if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; fi if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; fi # Now rename the file to the real destination. $doit $rmcmd $dst $doit $mvcmd $dsttmp $dst exit 0