Removed make and mkdepend source files, and removed them from the Jamfile. These are now available as OptionalPackages grouped in DevelopmentBase
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@38820 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Scott McCreary
@@ -242,10 +242,8 @@ SubInclude HAIKU_TOP src bin keymap ;
|
||||
SubInclude HAIKU_TOP src bin less ;
|
||||
SubInclude HAIKU_TOP src bin listdev ;
|
||||
SubInclude HAIKU_TOP src bin locale ;
|
||||
SubInclude HAIKU_TOP src bin make ;
|
||||
SubInclude HAIKU_TOP src bin makebootable ;
|
||||
#SubInclude HAIKU_TOP src bin makeudfimage ;
|
||||
SubInclude HAIKU_TOP src bin mkdepend ;
|
||||
SubInclude HAIKU_TOP src bin mkdos ;
|
||||
SubInclude HAIKU_TOP src bin mkfs ;
|
||||
SubInclude HAIKU_TOP src bin multiuser ;
|
||||
|
||||
@@ -1,340 +0,0 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
59 Temple Place - Suite 330, Boston, MA
|
||||
02111-1307, 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.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) 19yy <name of author>
|
||||
|
||||
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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.
|
||||
|
||||
<signature of Ty Coon>, 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.
|
||||
@@ -1,42 +0,0 @@
|
||||
SubDir HAIKU_TOP src bin make ;
|
||||
|
||||
SetSubDirSupportedPlatformsBeOSCompatible ;
|
||||
|
||||
# filter warnings we don't want here
|
||||
TARGET_WARNING_CCFLAGS = [ FFilter $(TARGET_WARNING_CCFLAGS)
|
||||
: -Wall -Wmissing-prototypes -Wsign-compare ] ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) glob ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
|
||||
|
||||
SubDirCcFlags -DHAVE_CONFIG_H ;
|
||||
|
||||
BinCommand make :
|
||||
ar.c
|
||||
arscan.c
|
||||
commands.c
|
||||
default.c
|
||||
dir.c
|
||||
expand.c
|
||||
file.c
|
||||
function.c
|
||||
getloadavg.c
|
||||
getopt.c
|
||||
getopt1.c
|
||||
hash.c
|
||||
implicit.c
|
||||
job.c
|
||||
main.c
|
||||
misc.c
|
||||
read.c
|
||||
remake.c
|
||||
remote-stub.c
|
||||
rule.c
|
||||
signame.c
|
||||
strcache.c
|
||||
variable.c
|
||||
version.c
|
||||
vpath.c
|
||||
: <make>libglob.a : make.rdef ;
|
||||
|
||||
SubInclude HAIKU_TOP src bin make glob ;
|
||||
@@ -1,189 +0,0 @@
|
||||
This directory contains the 3.81 release of GNU Make.
|
||||
|
||||
See the file NEWS for the user-visible changes from previous releases.
|
||||
In addition, there have been bugs fixed.
|
||||
|
||||
Please check the system-specific notes below for any caveats related to
|
||||
your operating system.
|
||||
|
||||
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.
|
||||
|
||||
Some systems' Make programs are broken and cannot process the Makefile for
|
||||
GNU Make. If you get errors from your system's Make when building GNU
|
||||
Make, try using `build.sh' instead.
|
||||
|
||||
|
||||
GNU Make is free software. See the file COPYING for copying conditions.
|
||||
|
||||
|
||||
Downloading
|
||||
-----------
|
||||
|
||||
GNU Make can be obtained in many different ways. See a description here:
|
||||
|
||||
http://www.gnu.org/software/software.html
|
||||
|
||||
|
||||
Documentation
|
||||
-------------
|
||||
|
||||
GNU make is fully documented in the GNU Make manual, which is contained
|
||||
in this distribution as the file make.texinfo. You can also find
|
||||
on-line and preformatted (PostScript and DVI) versions at the FSF's web
|
||||
site. There is information there about ordering hardcopy documentation.
|
||||
|
||||
http://www.gnu.org/
|
||||
http://www.gnu.org/doc/doc.html
|
||||
http://www.gnu.org/manual/manual.html
|
||||
|
||||
|
||||
Development
|
||||
-----------
|
||||
|
||||
GNU Make development is hosted by Savannah, the FSF's online development
|
||||
management tool. Savannah is here:
|
||||
|
||||
http://savannah.gnu.org
|
||||
|
||||
And the GNU Make development page is here:
|
||||
|
||||
http://savannah.gnu.org/projects/make/
|
||||
|
||||
You can find most information concerning the development of GNU Make at
|
||||
this site.
|
||||
|
||||
|
||||
Bug Reporting
|
||||
-------------
|
||||
|
||||
You can send GNU make bug reports to <[email protected]>. Please see the
|
||||
section of the GNU make manual entitled `Problems and Bugs' for
|
||||
information on submitting useful and complete bug reports.
|
||||
|
||||
You can also use the online bug tracking system in the Savannah GNU Make
|
||||
project to submit new problem reports or search for existing ones:
|
||||
|
||||
http://savannah.gnu.org/bugs/?group=make
|
||||
|
||||
If you need help using GNU make, try these forums:
|
||||
|
||||
[email protected]
|
||||
[email protected]
|
||||
news:gnu.utils.help
|
||||
news:gnu.utils.bug
|
||||
|
||||
http://savannah.gnu.org/support/?group=make
|
||||
|
||||
You may also find interesting patches to GNU Make available here:
|
||||
|
||||
http://savannah.gnu.org/patch/?group=make
|
||||
|
||||
Note these patches are provided by our users as a service and we make no
|
||||
statements regarding their correctness. Please contact the authors
|
||||
directly if you have a problem or suggestion for a patch available on
|
||||
this page.
|
||||
|
||||
|
||||
CVS Access
|
||||
----------
|
||||
|
||||
The GNU make source repository is available via anonymous CVS from the
|
||||
GNU Subversions CVS server; look here for details:
|
||||
|
||||
http://savannah.gnu.org/cvs/?group=make
|
||||
|
||||
Please note: you won't be able to build GNU make from CVS without
|
||||
installing appropriate maintainer's tools, such as GNU m4, automake,
|
||||
autoconf, Perl, GNU make, and GCC. See the README.cvs file for hints on
|
||||
how to build GNU make once these tools are available. We make no
|
||||
guarantees about the contents or quality of the latest code in the CVS
|
||||
repository: it is not unheard of for code that is known to be broken to
|
||||
be checked in. Use at your own risk.
|
||||
|
||||
|
||||
System-specific Notes
|
||||
---------------------
|
||||
|
||||
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.
|
||||
|
||||
The standard /bin/sh on SunOS 4.1.3_U1 and 4.1.4 is broken and cannot be
|
||||
used to configure GNU make. Please install a different shell such as
|
||||
bash or pdksh in order to run "configure". See this message for more
|
||||
information:
|
||||
http://mail.gnu.org/archive/html/bug-autoconf/2003-10/msg00190.html
|
||||
|
||||
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.)
|
||||
|
||||
Another potential source of porting problems is the support for large
|
||||
files (LFS) in configure for those operating systems that provide it.
|
||||
Please report any bugs that you find in this area. If you run into
|
||||
difficulties, then as a workaround you should be able to disable LFS by
|
||||
adding the `--disable-largefile' option to the `configure' script.
|
||||
|
||||
On systems that support micro- and nano-second timestamp values and
|
||||
where stat(2) provides this information, GNU make will use it when
|
||||
comparing timestamps to get the most accurate possible result. However,
|
||||
note that many current implementations of tools that *set* timestamps do
|
||||
not preserve micro- or nano-second granularity. This means that "cp -p"
|
||||
and other similar tools (tar, etc.) may not exactly duplicate timestamps
|
||||
with micro- and nano-second granularity on some systems. If your build
|
||||
system contains rules that depend on proper behavior of tools like "cp
|
||||
-p", you should consider using the .LOW_RESOLUTION_TIME pseudo-target to
|
||||
force make to treat them properly. See the manual for details.
|
||||
|
||||
|
||||
Ports
|
||||
-----
|
||||
|
||||
- See README.customs for details on integrating GNU make with the
|
||||
Customs distributed build environment from the Pmake distribution.
|
||||
|
||||
- See readme.vms for details about GNU Make on OpenVMS.
|
||||
|
||||
- See README.Amiga for details about GNU Make on AmigaDOS.
|
||||
|
||||
- See README.W32 for details about GNU Make on Windows NT, 95, or 98.
|
||||
|
||||
- See README.DOS for compilation instructions on MS-DOS and MS-Windows
|
||||
using DJGPP tools.
|
||||
|
||||
A precompiled binary of the MSDOS port of GNU Make is available as part
|
||||
of DJGPP; see the WWW page http://www.delorie.com/djgpp/ for more
|
||||
information.
|
||||
|
||||
Please note there are two _separate_ ports of GNU make for Microsoft
|
||||
systems: a native Windows tool built with (for example) MSVC or Cygwin,
|
||||
and a DOS-based tool built with DJGPP. Please be sure you are looking
|
||||
at the right README!
|
||||
|
||||
|
||||
-------------------------------------------------------------------------------
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
@@ -1,309 +0,0 @@
|
||||
/* Interface to `ar' archives for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
|
||||
#include "filedef.h"
|
||||
#include "dep.h"
|
||||
#include <fnmatch.h>
|
||||
|
||||
/* Defined in arscan.c. */
|
||||
extern long int ar_scan PARAMS ((char *archive, long int (*function) (), long int arg));
|
||||
extern int ar_name_equal PARAMS ((char *name, char *mem, int truncated));
|
||||
#ifndef VMS
|
||||
extern int ar_member_touch PARAMS ((char *arname, char *memname));
|
||||
#endif
|
||||
|
||||
/* 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 (char *name)
|
||||
{
|
||||
char *p = strchr (name, '(');
|
||||
char *end;
|
||||
|
||||
if (p == 0 || p == name)
|
||||
return 0;
|
||||
|
||||
end = p + strlen (p) - 1;
|
||||
if (*end != ')')
|
||||
return 0;
|
||||
|
||||
if (p[1] == '(' && end[-1] == ')')
|
||||
fatal (NILF, _("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 (char *name, char **arname_p, char **memname_p)
|
||||
{
|
||||
char *p = strchr (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 PARAMS ((int desc, char *mem, int truncated, long int hdrpos,
|
||||
long int datapos, long int size, long int date, int uid, int gid, int mode, char *name));
|
||||
|
||||
/* Return the modtime of NAME. */
|
||||
|
||||
time_t
|
||||
ar_member_date (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 (int desc UNUSED, char *mem, int truncated,
|
||||
long int hdrpos UNUSED, long int datapos UNUSED,
|
||||
long int size UNUSED, long int date,
|
||||
int uid UNUSED, int gid UNUSED, int mode UNUSED, char *name)
|
||||
{
|
||||
return ar_name_equal (name, mem, truncated) ? date : 0;
|
||||
}
|
||||
|
||||
/* Set the archive-member NAME's modtime to now. */
|
||||
|
||||
#ifdef VMS
|
||||
int
|
||||
ar_touch (char *name)
|
||||
{
|
||||
error (NILF, _("touch archive member is not available on VMS"));
|
||||
return -1;
|
||||
}
|
||||
#else
|
||||
int
|
||||
ar_touch (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 (NILF, _("touch: Archive `%s' does not exist"), arname);
|
||||
break;
|
||||
case -2:
|
||||
error (NILF, _("touch: `%s' is not a valid archive"), arname);
|
||||
break;
|
||||
case -3:
|
||||
perror_with_name ("touch: ", arname);
|
||||
break;
|
||||
case 1:
|
||||
error (NILF,
|
||||
_("touch: Member `%s' does not exist in `%s'"), memname, arname);
|
||||
break;
|
||||
case 0:
|
||||
val = 0;
|
||||
break;
|
||||
default:
|
||||
error (NILF,
|
||||
_("touch: Bad return code from ar_member_touch on `%s'"), name);
|
||||
}
|
||||
|
||||
if (!arname_used)
|
||||
free (arname);
|
||||
free (memname);
|
||||
|
||||
return val;
|
||||
}
|
||||
#endif /* !VMS */
|
||||
|
||||
/* 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 (int desc UNUSED, char *mem, int truncated UNUSED,
|
||||
long int hdrpos UNUSED, long int datapos UNUSED,
|
||||
long int size UNUSED, long int date UNUSED, int uid UNUSED,
|
||||
int gid UNUSED, int mode UNUSED, 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;
|
||||
}
|
||||
|
||||
/* Return nonzero if PATTERN contains any metacharacters.
|
||||
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
|
||||
static int
|
||||
glob_pattern_p (const char *pattern, int quote)
|
||||
{
|
||||
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 (char *arname, char *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), alpha_compare);
|
||||
|
||||
/* 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. */
|
||||
@@ -1,842 +0,0 @@
|
||||
/* Library function for scanning an archive file.
|
||||
Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
|
||||
#ifdef HAVE_FCNTL_H
|
||||
#include <fcntl.h>
|
||||
#else
|
||||
#include <sys/file.h>
|
||||
#endif
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
|
||||
#ifdef VMS
|
||||
#include <lbrdef.h>
|
||||
#include <mhddef.h>
|
||||
#include <credef.h>
|
||||
#include <descrip.h>
|
||||
#include <ctype.h>
|
||||
#if __DECC
|
||||
#include <unixlib.h>
|
||||
#include <lbr$routines.h>
|
||||
#endif
|
||||
|
||||
static void *VMS_lib_idx;
|
||||
|
||||
static char *VMS_saved_memname;
|
||||
|
||||
static time_t VMS_member_date;
|
||||
|
||||
static long int (*VMS_function) ();
|
||||
|
||||
static int
|
||||
VMS_get_member_info (struct dsc$descriptor_s *module, unsigned long *rfa)
|
||||
{
|
||||
int status, i;
|
||||
long int fnval;
|
||||
|
||||
time_t val;
|
||||
|
||||
static struct dsc$descriptor_s bufdesc =
|
||||
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
|
||||
|
||||
struct mhddef *mhd;
|
||||
char filename[128];
|
||||
|
||||
bufdesc.dsc$a_pointer = filename;
|
||||
bufdesc.dsc$w_length = sizeof (filename);
|
||||
|
||||
status = lbr$set_module (&VMS_lib_idx, rfa, &bufdesc,
|
||||
&bufdesc.dsc$w_length, 0);
|
||||
if (! (status & 1))
|
||||
{
|
||||
error (NILF, _("lbr$set_module failed to extract module info, status = %d"),
|
||||
status);
|
||||
|
||||
lbr$close (&VMS_lib_idx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
mhd = (struct mhddef *) filename;
|
||||
|
||||
#ifdef __DECC
|
||||
/* John Fowler <[email protected]> writes this is needed in his environment,
|
||||
* but that decc$fix_time() isn't documented to work this way. Let me
|
||||
* know if this causes problems in other VMS environments.
|
||||
*/
|
||||
val = decc$fix_time (&mhd->mhd$l_datim) + timezone - daylight*3600;
|
||||
#endif
|
||||
|
||||
for (i = 0; i < module->dsc$w_length; i++)
|
||||
filename[i] = _tolower ((unsigned char)module->dsc$a_pointer[i]);
|
||||
|
||||
filename[i] = '\0';
|
||||
|
||||
VMS_member_date = (time_t) -1;
|
||||
|
||||
fnval =
|
||||
(*VMS_function) (-1, filename, 0, 0, 0, 0, val, 0, 0, 0,
|
||||
VMS_saved_memname);
|
||||
|
||||
if (fnval)
|
||||
{
|
||||
VMS_member_date = fnval;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* 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.
|
||||
|
||||
NOTE: on VMS systems, only name, date, and arg are meaningful!
|
||||
|
||||
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 (char *archive, long int (*function) PARAMS ((void)), long int arg)
|
||||
{
|
||||
char *p;
|
||||
|
||||
static struct dsc$descriptor_s libdesc =
|
||||
{ 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
|
||||
|
||||
unsigned long func = LBR$C_READ;
|
||||
unsigned long type = LBR$C_TYP_UNK;
|
||||
unsigned long index = 1;
|
||||
|
||||
int status;
|
||||
|
||||
status = lbr$ini_control (&VMS_lib_idx, &func, &type, 0);
|
||||
|
||||
if (! (status & 1))
|
||||
{
|
||||
error (NILF, _("lbr$ini_control failed with status = %d"),status);
|
||||
return -2;
|
||||
}
|
||||
|
||||
libdesc.dsc$a_pointer = archive;
|
||||
libdesc.dsc$w_length = strlen (archive);
|
||||
|
||||
status = lbr$open (&VMS_lib_idx, &libdesc, 0, 0, 0, 0, 0);
|
||||
|
||||
if (! (status & 1))
|
||||
{
|
||||
error (NILF, _("unable to open library `%s' to lookup member `%s'"),
|
||||
archive, (char *)arg);
|
||||
return -1;
|
||||
}
|
||||
|
||||
VMS_saved_memname = (char *)arg;
|
||||
|
||||
/* For comparison, delete .obj from arg name. */
|
||||
|
||||
p = strrchr (VMS_saved_memname, '.');
|
||||
if (p)
|
||||
*p = '\0';
|
||||
|
||||
VMS_function = function;
|
||||
|
||||
VMS_member_date = (time_t) -1;
|
||||
lbr$get_index (&VMS_lib_idx, &index, VMS_get_member_info, 0);
|
||||
|
||||
/* Undo the damage. */
|
||||
if (p)
|
||||
*p = '.';
|
||||
|
||||
lbr$close (&VMS_lib_idx);
|
||||
|
||||
return VMS_member_date > 0 ? VMS_member_date : 0;
|
||||
}
|
||||
|
||||
#else /* !VMS */
|
||||
|
||||
/* 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 <[email protected]>, 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
|
||||
|
||||
/* On AIX, define these symbols to be sure to get both archive formats.
|
||||
AIX 4.3 introduced the "big" archive format to support 64-bit object
|
||||
files, so on AIX 4.3 systems we need to support both the "normal" and
|
||||
"big" archive formats. An archive's format is indicated in the
|
||||
"fl_magic" field of the "FL_HDR" structure. For a normal archive,
|
||||
this field will be the string defined by the AIAMAG symbol. For a
|
||||
"big" archive, it will be the string defined by the AIAMAGBIG symbol
|
||||
(at least on AIX it works this way).
|
||||
|
||||
Note: we'll define these symbols regardless of which AIX version
|
||||
we're compiling on, but this is okay since we'll use the new symbols
|
||||
only if they're present. */
|
||||
#ifdef _AIX
|
||||
# define __AR_SMALL__
|
||||
# define __AR_BIG__
|
||||
#endif
|
||||
|
||||
#ifndef WINDOWS32
|
||||
# if (!defined(__BEOS__) && !defined(__HAIKU__))
|
||||
# include <ar.h>
|
||||
# else
|
||||
/* BeOS 5 doesn't have <ar.h> but has archives in the same format
|
||||
* as many other Unices. This was taken from GNU binutils for BeOS.
|
||||
*/
|
||||
# define ARMAG "!<arch>\n" /* String that begins an archive file. */
|
||||
# define SARMAG 8 /* Size of that string. */
|
||||
# define ARFMAG "`\n" /* String in ar_fmag at end of each header. */
|
||||
struct ar_hdr
|
||||
{
|
||||
char ar_name[16]; /* Member file name, sometimes / terminated. */
|
||||
char ar_date[12]; /* File date, decimal seconds since Epoch. */
|
||||
char ar_uid[6], ar_gid[6]; /* User and group IDs, in ASCII decimal. */
|
||||
char ar_mode[8]; /* File mode, in ASCII octal. */
|
||||
char ar_size[10]; /* File size, in ASCII decimal. */
|
||||
char ar_fmag[2]; /* Always contains ARFMAG. */
|
||||
};
|
||||
# endif
|
||||
#else
|
||||
/* These should allow us to read Windows (VC++) libraries (according to Frank
|
||||
* Libbrecht <[email protected]>)
|
||||
*/
|
||||
# include <windows.h>
|
||||
# include <windef.h>
|
||||
# include <io.h>
|
||||
# define ARMAG IMAGE_ARCHIVE_START
|
||||
# define SARMAG IMAGE_ARCHIVE_START_SIZE
|
||||
# define ar_hdr _IMAGE_ARCHIVE_MEMBER_HEADER
|
||||
# define ar_name Name
|
||||
# define ar_mode Mode
|
||||
# define ar_size Size
|
||||
# define ar_date Date
|
||||
# define ar_uid UserID
|
||||
# define ar_gid GroupID
|
||||
#endif
|
||||
|
||||
/* Cray's <ar.h> 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 (char *archive, long int (*function)(), long int arg)
|
||||
{
|
||||
#ifdef AIAMAG
|
||||
FL_HDR fl_header;
|
||||
#ifdef AIAMAGBIG
|
||||
int big_archive = 0;
|
||||
FL_HDR_BIG fl_header_big;
|
||||
#endif
|
||||
#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)
|
||||
{
|
||||
(void) close (desc);
|
||||
return -2;
|
||||
}
|
||||
#ifdef AIAMAGBIG
|
||||
/* If this is a "big" archive, then set the flag and
|
||||
re-read the header into the "big" structure. */
|
||||
if (!bcmp (fl_header.fl_magic, AIAMAGBIG, SAIAMAG))
|
||||
{
|
||||
big_archive = 1;
|
||||
|
||||
/* seek back to beginning of archive */
|
||||
if (lseek (desc, 0, 0) < 0)
|
||||
{
|
||||
(void) close (desc);
|
||||
return -2;
|
||||
}
|
||||
|
||||
/* re-read the header into the "big" structure */
|
||||
nread = read (desc, (char *) &fl_header_big, FL_HSZ_BIG);
|
||||
if (nread != FL_HSZ_BIG)
|
||||
{
|
||||
(void) close (desc);
|
||||
return -2;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
/* Check to make sure this is a "normal" archive. */
|
||||
if (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;
|
||||
|
||||
#ifdef AIAMAGBIG
|
||||
if ( big_archive )
|
||||
{
|
||||
sscanf (fl_header_big.fl_fstmoff, "%20ld", &member_offset);
|
||||
sscanf (fl_header_big.fl_lstmoff, "%20ld", &last_member_offset);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset);
|
||||
sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset);
|
||||
}
|
||||
|
||||
if (member_offset == 0)
|
||||
{
|
||||
/* Empty archive. */
|
||||
close (desc);
|
||||
return 0;
|
||||
}
|
||||
#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 AIAMAGBIG
|
||||
struct ar_hdr_big member_header_big;
|
||||
#endif
|
||||
#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_SZ(x) (sizeof(x) - sizeof (x._ar_name))
|
||||
|
||||
#ifdef AIAMAGBIG
|
||||
if (big_archive)
|
||||
{
|
||||
nread = read (desc, (char *) &member_header_big,
|
||||
AR_MEMHDR_SZ(member_header_big) );
|
||||
|
||||
if (nread != AR_MEMHDR_SZ(member_header_big))
|
||||
{
|
||||
(void) close (desc);
|
||||
return -2;
|
||||
}
|
||||
|
||||
sscanf (member_header_big.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_big.ar_date, "%12ld", &dateval);
|
||||
sscanf (member_header_big.ar_uid, "%12d", &uidval);
|
||||
sscanf (member_header_big.ar_gid, "%12d", &gidval);
|
||||
sscanf (member_header_big.ar_mode, "%12o", &eltmode);
|
||||
sscanf (member_header_big.ar_size, "%20ld", &eltsize);
|
||||
|
||||
data_offset = (member_offset + AR_MEMHDR_SZ(member_header_big)
|
||||
+ name_len + 2);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
nread = read (desc, (char *) &member_header,
|
||||
AR_MEMHDR_SZ(member_header) );
|
||||
|
||||
if (nread != AR_MEMHDR_SZ(member_header))
|
||||
{
|
||||
(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);
|
||||
|
||||
data_offset = (member_offset + AR_MEMHDR_SZ(member_header)
|
||||
+ name_len + 2);
|
||||
}
|
||||
data_offset += data_offset % 2;
|
||||
|
||||
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
|
||||
#if defined(ARFMAG) || defined(ARFZMAG)
|
||||
|| (
|
||||
# ifdef ARFMAG
|
||||
bcmp (member_header.ar_fmag, ARFMAG, 2)
|
||||
# else
|
||||
1
|
||||
# endif
|
||||
&&
|
||||
# ifdef ARFZMAG
|
||||
bcmp (member_header.ar_fmag, ARFZMAG, 2)
|
||||
# else
|
||||
1
|
||||
# endif
|
||||
)
|
||||
#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;
|
||||
|
||||
#ifdef AIAMAGBIG
|
||||
if (big_archive)
|
||||
sscanf (member_header_big.ar_nxtmem, "%20ld", &member_offset);
|
||||
else
|
||||
#endif
|
||||
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;
|
||||
}
|
||||
#endif /* !VMS */
|
||||
|
||||
/* 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 (char *name, char *mem, int truncated)
|
||||
{
|
||||
char *p;
|
||||
|
||||
p = strrchr (name, '/');
|
||||
if (p != 0)
|
||||
name = p + 1;
|
||||
|
||||
#ifndef VMS
|
||||
if (truncated)
|
||||
{
|
||||
#ifdef AIAMAG
|
||||
/* TRUNCATED should never be set on this system. */
|
||||
abort ();
|
||||
#else
|
||||
struct ar_hdr hdr;
|
||||
#if !defined (__hpux) && !defined (cray)
|
||||
return strneq (name, mem, sizeof(hdr.ar_name) - 1);
|
||||
#else
|
||||
return strneq (name, mem, sizeof(hdr.ar_name) - 2);
|
||||
#endif /* !__hpux && !cray */
|
||||
#endif /* !AIAMAG */
|
||||
}
|
||||
#endif /* !VMS */
|
||||
|
||||
return !strcmp (name, mem);
|
||||
}
|
||||
|
||||
#ifndef VMS
|
||||
/* ARGSUSED */
|
||||
static long int
|
||||
ar_member_pos (int desc UNUSED, char *mem, int truncated,
|
||||
long int hdrpos, long int datapos UNUSED, long int size UNUSED,
|
||||
long int date UNUSED, int uid UNUSED, int gid UNUSED,
|
||||
int mode UNUSED, 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 (char *arname, char *memname)
|
||||
{
|
||||
long int pos = ar_scan (arname, ar_member_pos, (long int) memname);
|
||||
int fd;
|
||||
struct ar_hdr ar_hdr;
|
||||
int i;
|
||||
unsigned int ui;
|
||||
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. */
|
||||
EINTRLOOP (i, fstat (fd, &statbuf));
|
||||
if (i < 0)
|
||||
goto lose;
|
||||
#if defined(ARFMAG) || defined(ARFZMAG) || defined(AIAMAG) || defined(WINDOWS32)
|
||||
/* Advance member's time to that time */
|
||||
for (ui = 0; ui < sizeof ar_hdr.ar_date; ui++)
|
||||
ar_hdr.ar_date[ui] = ' ';
|
||||
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;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef TEST
|
||||
|
||||
long int
|
||||
describe_member (int desc, char *name, int truncated,
|
||||
long int hdrpos, long int datapos, long int size,
|
||||
long int date, int uid, int gid, int 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;
|
||||
}
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
ar_scan (argv[1], describe_member);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* TEST. */
|
||||
#endif /* NO_ARCHIVES. */
|
||||
@@ -1,623 +0,0 @@
|
||||
/* Command processing for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "dep.h"
|
||||
#include "filedef.h"
|
||||
#include "variable.h"
|
||||
#include "job.h"
|
||||
#include "commands.h"
|
||||
#ifdef WINDOWS32
|
||||
#include <windows.h>
|
||||
#include "w32err.h"
|
||||
#endif
|
||||
|
||||
#if VMS
|
||||
# define FILE_LIST_SEPARATOR ','
|
||||
#else
|
||||
# define FILE_LIST_SEPARATOR ' '
|
||||
#endif
|
||||
|
||||
extern int remote_kill PARAMS ((int id, int sig));
|
||||
|
||||
#ifndef HAVE_UNISTD_H
|
||||
extern int getpid ();
|
||||
#endif
|
||||
|
||||
/* Set FILE's automatic variables up. */
|
||||
|
||||
void
|
||||
set_file_variables (struct file *file)
|
||||
{
|
||||
struct dep *d;
|
||||
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;
|
||||
char *p;
|
||||
|
||||
p = strchr (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 = strchr (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 && strneq (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 not order-only dependency. */
|
||||
less = "";
|
||||
for (d = file->deps; d != 0; d = d->next)
|
||||
if (!d->ignore_mtime)
|
||||
{
|
||||
less = dep_name (d);
|
||||
break;
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
/* Compute the values for $^, $+, $?, and $|. */
|
||||
|
||||
{
|
||||
static char *plus_value=0, *bar_value=0, *qmark_value=0;
|
||||
static unsigned int qmark_max=0, plus_max=0, bar_max=0;
|
||||
|
||||
unsigned int qmark_len, plus_len, bar_len;
|
||||
char *cp;
|
||||
char *caret_value;
|
||||
char *qp;
|
||||
char *bp;
|
||||
unsigned int len;
|
||||
|
||||
/* Compute first the value for $+, which is supposed to contain
|
||||
duplicate dependencies as they were listed in the makefile. */
|
||||
|
||||
plus_len = 0;
|
||||
for (d = file->deps; d != 0; d = d->next)
|
||||
if (! d->ignore_mtime)
|
||||
plus_len += strlen (dep_name (d)) + 1;
|
||||
if (plus_len == 0)
|
||||
plus_len++;
|
||||
|
||||
if (plus_len > plus_max)
|
||||
plus_value = xrealloc (plus_value, plus_max = plus_len);
|
||||
cp = plus_value;
|
||||
|
||||
qmark_len = plus_len + 1; /* Will be this or less. */
|
||||
for (d = file->deps; d != 0; d = d->next)
|
||||
if (! d->ignore_mtime)
|
||||
{
|
||||
char *c = dep_name (d);
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
if (ar_name (c))
|
||||
{
|
||||
c = strchr (c, '(') + 1;
|
||||
len = strlen (c) - 1;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
len = strlen (c);
|
||||
|
||||
bcopy (c, cp, len);
|
||||
cp += len;
|
||||
*cp++ = FILE_LIST_SEPARATOR;
|
||||
if (! d->changed)
|
||||
qmark_len -= len + 1; /* Don't space in $? for this one. */
|
||||
}
|
||||
|
||||
/* Kill the last space and define the variable. */
|
||||
|
||||
cp[cp > plus_value ? -1 : 0] = '\0';
|
||||
DEFINE_VARIABLE ("+", 1, plus_value);
|
||||
|
||||
/* 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);
|
||||
|
||||
bar_len = 0;
|
||||
for (d = file->deps; d != 0; d = d->next)
|
||||
if (d->ignore_mtime)
|
||||
bar_len += strlen (dep_name (d)) + 1;
|
||||
if (bar_len == 0)
|
||||
bar_len++;
|
||||
|
||||
/* Compute the values for $^, $?, and $|. */
|
||||
|
||||
cp = caret_value = plus_value; /* Reuse the buffer; it's big enough. */
|
||||
|
||||
if (qmark_len > qmark_max)
|
||||
qmark_value = xrealloc (qmark_value, qmark_max = qmark_len);
|
||||
qp = qmark_value;
|
||||
|
||||
if (bar_len > bar_max)
|
||||
bar_value = xrealloc (bar_value, bar_max = bar_len);
|
||||
bp = bar_value;
|
||||
|
||||
for (d = file->deps; d != 0; d = d->next)
|
||||
{
|
||||
char *c = dep_name (d);
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
if (ar_name (c))
|
||||
{
|
||||
c = strchr (c, '(') + 1;
|
||||
len = strlen (c) - 1;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
len = strlen (c);
|
||||
|
||||
if (d->ignore_mtime)
|
||||
{
|
||||
bcopy (c, bp, len);
|
||||
bp += len;
|
||||
*bp++ = FILE_LIST_SEPARATOR;
|
||||
}
|
||||
else
|
||||
{
|
||||
bcopy (c, cp, len);
|
||||
cp += len;
|
||||
*cp++ = FILE_LIST_SEPARATOR;
|
||||
if (d->changed)
|
||||
{
|
||||
bcopy (c, qp, len);
|
||||
qp += len;
|
||||
*qp++ = FILE_LIST_SEPARATOR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 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);
|
||||
|
||||
bp[bp > bar_value ? -1 : 0] = '\0';
|
||||
DEFINE_VARIABLE ("|", 1, bar_value);
|
||||
}
|
||||
|
||||
#undef DEFINE_VARIABLE
|
||||
}
|
||||
|
||||
/* Chop CMDS up into individual command lines if necessary.
|
||||
Also set the `lines_flags' and `any_recurse' members. */
|
||||
|
||||
void
|
||||
chop_commands (struct commands *cmds)
|
||||
{
|
||||
register char *p;
|
||||
unsigned int nlines, idx;
|
||||
char **lines;
|
||||
|
||||
/* If we don't have any commands,
|
||||
or we already parsed them, never mind. */
|
||||
|
||||
if (!cmds || cmds->command_lines != 0)
|
||||
return;
|
||||
|
||||
/* Chop CMDS->commands up into lines in CMDS->command_lines.
|
||||
Also set the corresponding CMDS->lines_flags elements,
|
||||
and the CMDS->any_recurse flag. */
|
||||
|
||||
nlines = 5;
|
||||
lines = (char **) xmalloc (5 * sizeof (char *));
|
||||
idx = 0;
|
||||
p = cmds->commands;
|
||||
while (*p != '\0')
|
||||
{
|
||||
char *end = p;
|
||||
find_end:;
|
||||
end = strchr (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 ((unsigned char)*p) || *p == '-' || *p == '@' || *p == '+';
|
||||
++p)
|
||||
switch (*p)
|
||||
{
|
||||
case '+':
|
||||
flags |= COMMANDS_RECURSE;
|
||||
break;
|
||||
case '@':
|
||||
flags |= COMMANDS_SILENT;
|
||||
break;
|
||||
case '-':
|
||||
flags |= COMMANDS_NOERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
/* If no explicit '+' was given, look for MAKE variable references. */
|
||||
if (!(flags & COMMANDS_RECURSE)
|
||||
&& (strstr (p, "$(MAKE)") != 0 || strstr (p, "${MAKE}") != 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 (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 ((unsigned char)*p) && *p != '-' && *p != '@')
|
||||
break;
|
||||
if (*p == '\0')
|
||||
{
|
||||
/* If there are no commands, assume everything worked. */
|
||||
set_command_state (file, cs_running);
|
||||
file->update_status = 0;
|
||||
notice_finished_file (file);
|
||||
return;
|
||||
}
|
||||
|
||||
/* First set the automatic variables according to this file. */
|
||||
|
||||
initialize_file_variables (file, 0);
|
||||
|
||||
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 (int sig)
|
||||
{
|
||||
#ifdef __MSDOS__
|
||||
extern int dos_status, dos_command_running;
|
||||
|
||||
if (dos_command_running)
|
||||
{
|
||||
/* That was the child who got the signal, not us. */
|
||||
dos_status |= (sig << 8);
|
||||
return;
|
||||
}
|
||||
remove_intermediates (1);
|
||||
exit (EXIT_FAILURE);
|
||||
#else /* not __MSDOS__ */
|
||||
#ifdef _AMIGA
|
||||
remove_intermediates (1);
|
||||
if (sig == SIGINT)
|
||||
fputs (_("*** Break.\n"), stderr);
|
||||
|
||||
exit (10);
|
||||
#else /* not Amiga */
|
||||
#ifdef WINDOWS32
|
||||
extern HANDLE main_thread;
|
||||
|
||||
/* Windows creates a sperate thread for handling Ctrl+C, so we need
|
||||
to suspend the main thread, or else we will have race conditions
|
||||
when both threads call reap_children. */
|
||||
if (main_thread)
|
||||
{
|
||||
DWORD susp_count = SuspendThread (main_thread);
|
||||
|
||||
if (susp_count != 0)
|
||||
fprintf (stderr, "SuspendThread: suspend count = %ld\n", susp_count);
|
||||
else if (susp_count == (DWORD)-1)
|
||||
{
|
||||
DWORD ierr = GetLastError ();
|
||||
|
||||
fprintf (stderr, "SuspendThread: error %ld: %s\n",
|
||||
ierr, map_windows32_error_to_string (ierr));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
handling_fatal_signal = 1;
|
||||
|
||||
/* Set the handling for this signal to the default.
|
||||
It is blocked now while we run this handler. */
|
||||
signal (sig, SIG_DFL);
|
||||
|
||||
/* 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
|
||||
#ifdef SIGHUP
|
||||
|| sig == SIGHUP
|
||||
#endif
|
||||
#ifdef SIGQUIT
|
||||
|| sig == SIGQUIT
|
||||
#endif
|
||||
)
|
||||
{
|
||||
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);
|
||||
|
||||
#ifdef SIGQUIT
|
||||
if (sig == SIGQUIT)
|
||||
/* We don't want to send ourselves SIGQUIT, because it will
|
||||
cause a core dump. Just exit instead. */
|
||||
exit (EXIT_FAILURE);
|
||||
#endif
|
||||
|
||||
#ifdef WINDOWS32
|
||||
if (main_thread)
|
||||
CloseHandle (main_thread);
|
||||
/* Cannot call W32_kill with a pid (it needs a handle). The exit
|
||||
status of 130 emulates what happens in Bash. */
|
||||
exit (130);
|
||||
#else
|
||||
/* Signal the same code; this time it will really be fatal. The signal
|
||||
will be unblocked when we return and arrive then to kill us. */
|
||||
if (kill (getpid (), sig) < 0)
|
||||
pfatal_with_name ("kill");
|
||||
#endif /* not WINDOWS32 */
|
||||
#endif /* not Amiga */
|
||||
#endif /* not __MSDOS__ */
|
||||
}
|
||||
|
||||
/* Delete FILE unless it's precious or not actually a file (phony),
|
||||
and it has changed on disk since we last stat'd it. */
|
||||
|
||||
static void
|
||||
delete_target (struct file *file, char *on_behalf_of)
|
||||
{
|
||||
struct stat st;
|
||||
int e;
|
||||
|
||||
if (file->precious || file->phony)
|
||||
return;
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
if (ar_name (file->name))
|
||||
{
|
||||
time_t file_date = (file->last_mtime == NONEXISTENT_MTIME
|
||||
? (time_t) -1
|
||||
: (time_t) FILE_TIMESTAMP_S (file->last_mtime));
|
||||
if (ar_member_date (file->name) != file_date)
|
||||
{
|
||||
if (on_behalf_of)
|
||||
error (NILF, _("*** [%s] Archive member `%s' may be bogus; not deleted"),
|
||||
on_behalf_of, file->name);
|
||||
else
|
||||
error (NILF, _("*** Archive member `%s' may be bogus; not deleted"),
|
||||
file->name);
|
||||
}
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
EINTRLOOP (e, stat (file->name, &st));
|
||||
if (e == 0
|
||||
&& S_ISREG (st.st_mode)
|
||||
&& FILE_TIMESTAMP_STAT_MODTIME (file->name, st) != file->last_mtime)
|
||||
{
|
||||
if (on_behalf_of)
|
||||
error (NILF, _("*** [%s] Deleting file `%s'"), on_behalf_of, file->name);
|
||||
else
|
||||
error (NILF, _("*** Deleting file `%s'"), file->name);
|
||||
if (unlink (file->name) < 0
|
||||
&& errno != ENOENT) /* It disappeared; so what. */
|
||||
perror_with_name ("unlink: ", file->name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* 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 (struct child *child)
|
||||
{
|
||||
struct dep *d;
|
||||
|
||||
if (child->deleted)
|
||||
return;
|
||||
|
||||
/* Delete the target file if it changed. */
|
||||
delete_target (child->file, (char *) 0);
|
||||
|
||||
/* Also remove any non-precious targets listed in the `also_make' member. */
|
||||
for (d = child->file->also_make; d != 0; d = d->next)
|
||||
delete_target (d->file, child->file->name);
|
||||
|
||||
child->deleted = 1;
|
||||
}
|
||||
|
||||
/* Print out the commands in CMDS. */
|
||||
|
||||
void
|
||||
print_commands (struct commands *cmds)
|
||||
{
|
||||
register char *s;
|
||||
|
||||
fputs (_("# commands to execute"), stdout);
|
||||
|
||||
if (cmds->fileinfo.filenm == 0)
|
||||
puts (_(" (built-in):"));
|
||||
else
|
||||
printf (_(" (from `%s', line %lu):\n"),
|
||||
cmds->fileinfo.filenm, cmds->fileinfo.lineno);
|
||||
|
||||
s = cmds->commands;
|
||||
while (*s != '\0')
|
||||
{
|
||||
char *end;
|
||||
|
||||
while (isspace ((unsigned char)*s))
|
||||
++s;
|
||||
|
||||
end = strchr (s, '\n');
|
||||
if (end == 0)
|
||||
end = s + strlen (s);
|
||||
|
||||
printf ("\t%.*s\n", (int) (end - s), s);
|
||||
|
||||
s = end;
|
||||
}
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
/* Definition of data structures describing shell commands for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
/* Structure that gives the commands to make a file
|
||||
and information about where these commands came from. */
|
||||
|
||||
struct commands
|
||||
{
|
||||
struct floc fileinfo; /* Where commands were defined. */
|
||||
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 PARAMS ((struct file *file));
|
||||
extern void print_commands PARAMS ((struct commands *cmds));
|
||||
extern void delete_child_targets PARAMS ((struct child *child));
|
||||
extern void chop_commands PARAMS ((struct commands *cmds));
|
||||
extern void set_file_variables PARAMS ((struct file *file));
|
||||
@@ -1,401 +0,0 @@
|
||||
/* Edited by Marcus Overhagen */
|
||||
/* config.h. Generated by configure. */
|
||||
/* config.h.in. Generated from configure.in by autoheader. */
|
||||
|
||||
#define LOCALEDIR "/etc/locale/"
|
||||
#define LIBDIR "/boot/develop/lib/"
|
||||
#define INCLUDEDIR "/boot/develop/headers/"
|
||||
|
||||
/* Define to 1 if the `closedir' function returns void instead of `int'. */
|
||||
/* #undef CLOSEDIR_VOID */
|
||||
|
||||
/* 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 to 1 if using `alloca.c'. */
|
||||
/* #undef C_ALLOCA */
|
||||
|
||||
/* Define to 1 if using `getloadavg.c'. */
|
||||
#define C_GETLOADAVG 1
|
||||
|
||||
/* Define to 1 for DGUX with <sys/dg_sys_info.h>. */
|
||||
/* #undef DGUX */
|
||||
|
||||
/* Define to 1 if translation of program messages to the user's native
|
||||
language is requested. */
|
||||
/* #undef ENABLE_NLS */
|
||||
|
||||
/* Use high resolution file timestamps if nonzero. */
|
||||
#define FILE_TIMESTAMP_HI_RES 0
|
||||
|
||||
/* Define to 1 if the `getloadavg' function needs to be run setuid or setgid.
|
||||
*/
|
||||
/* #undef GETLOADAVG_PRIVILEGED */
|
||||
|
||||
/* Define to 1 if you have `alloca', as a function or macro. */
|
||||
#define HAVE_ALLOCA 1
|
||||
|
||||
/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
|
||||
*/
|
||||
#define HAVE_ALLOCA_H 1
|
||||
|
||||
/* This system has SA_RESTART, but it doesn't work properly. */
|
||||
/* #undef HAVE_BROKEN_RESTART */
|
||||
|
||||
/* Define to 1 if you have the `bsd_signal' function. */
|
||||
/* #undef HAVE_BSD_SIGNAL */
|
||||
|
||||
/* Define if you have the clock_gettime function. */
|
||||
/* #undef HAVE_CLOCK_GETTIME */
|
||||
|
||||
/* Define if the GNU dcgettext() function is already present or preinstalled.
|
||||
*/
|
||||
/* #undef HAVE_DCGETTEXT */
|
||||
|
||||
/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
#define HAVE_DIRENT_H 1
|
||||
|
||||
/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
|
||||
/* #undef HAVE_DOPRNT */
|
||||
|
||||
/* Define to 1 if you have the `dup2' function. */
|
||||
#define HAVE_DUP2 1
|
||||
|
||||
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||
#define HAVE_FCNTL_H 1
|
||||
|
||||
/* Define to 1 if you have the `fdopen' function. */
|
||||
#define HAVE_FDOPEN 1
|
||||
|
||||
/* Define to 1 if you have the `fork' function. */
|
||||
#define HAVE_FORK 1
|
||||
|
||||
/* Define to 1 if you have the `getcwd' function. */
|
||||
#define HAVE_GETCWD 1
|
||||
|
||||
/* Define to 1 if you have the `getgroups' function. */
|
||||
#define HAVE_GETGROUPS 1
|
||||
|
||||
/* Define to 1 if you have the `gethostbyname' function. */
|
||||
/* #undef HAVE_GETHOSTBYNAME */
|
||||
|
||||
/* Define to 1 if you have the `gethostname' function. */
|
||||
/* #undef HAVE_GETHOSTNAME */
|
||||
|
||||
/* Define to 1 if you have the `getloadavg' function. */
|
||||
/* #undef HAVE_GETLOADAVG */
|
||||
|
||||
/* Define if the GNU gettext() function is already present or preinstalled. */
|
||||
/* #undef HAVE_GETTEXT */
|
||||
|
||||
/* Define if you have a standard gettimeofday function */
|
||||
#define HAVE_GETTIMEOFDAY 1
|
||||
|
||||
/* Define if you have the iconv() function. */
|
||||
/* #undef HAVE_ICONV */
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#define HAVE_INTTYPES_H 1
|
||||
|
||||
/* Define to 1 if you have the `dgc' library (-ldgc). */
|
||||
/* #undef HAVE_LIBDGC */
|
||||
|
||||
/* Define to 1 if you have the `kstat' library (-lkstat). */
|
||||
/* #undef HAVE_LIBKSTAT */
|
||||
|
||||
/* Define to 1 if you have the <limits.h> header file. */
|
||||
#define HAVE_LIMITS_H 1
|
||||
|
||||
/* Define to 1 if you have the <locale.h> header file. */
|
||||
#define HAVE_LOCALE_H 1
|
||||
|
||||
/* Define to 1 if you have the <mach/mach.h> header file. */
|
||||
/* #undef HAVE_MACH_MACH_H */
|
||||
|
||||
/* Define to 1 if you have the `memcpy' function. */
|
||||
#define HAVE_MEMCPY 1
|
||||
|
||||
/* Define to 1 if you have the `memmove' function. */
|
||||
#define HAVE_MEMMOVE 1
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#define HAVE_MEMORY_H 1
|
||||
|
||||
/* Define to 1 if you have the `mkstemp' function. */
|
||||
#define HAVE_MKSTEMP 1
|
||||
|
||||
/* Define to 1 if you have the `mktemp' function. */
|
||||
#define HAVE_MKTEMP 1
|
||||
|
||||
/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
|
||||
/* #undef HAVE_NDIR_H */
|
||||
|
||||
/* Define to 1 if you have the <nlist.h> header file. */
|
||||
/* #undef HAVE_NLIST_H */
|
||||
|
||||
/* Define to 1 if you have the `pipe' function. */
|
||||
#define HAVE_PIPE 1
|
||||
|
||||
/* Define to 1 if you have the `pstat_getdynamic' function. */
|
||||
/* #undef HAVE_PSTAT_GETDYNAMIC */
|
||||
|
||||
/* Define if <signal.h> defines the SA_RESTART constant. */
|
||||
/* #undef HAVE_SA_RESTART */
|
||||
#ifdef HAIKU_TARGET_PLATFORM_HAIKU
|
||||
# define HAVE_SA_RESTART 1
|
||||
#endif
|
||||
|
||||
/* Define to 1 if you have the `setegid' function. */
|
||||
/* #undef HAVE_SETEGID */
|
||||
|
||||
/* Define to 1 if you have the `seteuid' function. */
|
||||
/* #undef HAVE_SETEUID */
|
||||
|
||||
/* Define to 1 if you have the `setlinebuf' function. */
|
||||
#define HAVE_SETLINEBUF 1
|
||||
|
||||
/* Define to 1 if you have the `setlocale' function. */
|
||||
#define HAVE_SETLOCALE 1
|
||||
|
||||
/* Define to 1 if you have the `setregid' function. */
|
||||
/* #undef HAVE_SETREGID */
|
||||
|
||||
/* Define to 1 if you have the `setreuid' function. */
|
||||
/* #undef HAVE_SETREUID */
|
||||
|
||||
/* Define to 1 if you have the `setvbuf' function. */
|
||||
#define HAVE_SETVBUF 1
|
||||
|
||||
/* Define to 1 if you have the `sigaction' function. */
|
||||
#define HAVE_SIGACTION 1
|
||||
|
||||
/* Define to 1 if you have the `sigsetmask' function. */
|
||||
/* #undef HAVE_SIGSETMASK */
|
||||
|
||||
/* Define to 1 if you have the `socket' function. */
|
||||
/* #undef HAVE_SOCKET */
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
/* #undef HAVE_STDINT_H */
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#define HAVE_STDLIB_H 1
|
||||
|
||||
/* Define to 1 if you have the `strcasecmp' function. */
|
||||
/* #undef HAVE_STRCASECMP */
|
||||
#define HAVE_STRCASECMP 1
|
||||
|
||||
/* Define to 1 if you have the `strchr' function. */
|
||||
#define HAVE_STRCHR 1
|
||||
|
||||
/* Define to 1 if you have the `strcoll' function and it is properly defined.
|
||||
*/
|
||||
#define HAVE_STRCOLL 1
|
||||
|
||||
/* Define to 1 if you have the `strdup' function. */
|
||||
#define HAVE_STRDUP 1
|
||||
|
||||
/* Define to 1 if you have the `strerror' function. */
|
||||
#define HAVE_STRERROR 1
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#define HAVE_STRINGS_H 1
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#define HAVE_STRING_H 1
|
||||
|
||||
/* Define to 1 if you have the `strsignal' function. */
|
||||
#define HAVE_STRSIGNAL 1
|
||||
|
||||
/* Define to 1 if `n_un.n_name' is member of `struct nlist'. */
|
||||
/* #undef HAVE_STRUCT_NLIST_N_UN_N_NAME */
|
||||
|
||||
/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
/* #undef HAVE_SYS_DIR_H */
|
||||
|
||||
/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
|
||||
*/
|
||||
/* #undef HAVE_SYS_NDIR_H */
|
||||
|
||||
/* Define to 1 if you have the <sys/param.h> header file. */
|
||||
#define HAVE_SYS_PARAM_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#define HAVE_SYS_STAT_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/timeb.h> header file. */
|
||||
#define HAVE_SYS_TIMEB_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/time.h> header file. */
|
||||
#define HAVE_SYS_TIME_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#define HAVE_SYS_TYPES_H 1
|
||||
|
||||
/* Define to 1 if you have the <sys/wait.h> header file. */
|
||||
#define HAVE_SYS_WAIT_H 1
|
||||
|
||||
/* Define this if you have the `union wait' type in <sys/wait.h>. */
|
||||
/* #undef HAVE_UNION_WAIT */
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#define HAVE_UNISTD_H 1
|
||||
|
||||
/* Define to 1 if you have the `vfork' function. */
|
||||
/* #undef HAVE_VFORK */
|
||||
|
||||
/* Define to 1 if you have the <vfork.h> header file. */
|
||||
/* #undef HAVE_VFORK_H */
|
||||
|
||||
/* Define to 1 if you have the `vprintf' function. */
|
||||
#define HAVE_VPRINTF 1
|
||||
|
||||
/* Define to 1 if you have the `wait3' function. */
|
||||
/* #undef HAVE_WAIT3 */
|
||||
|
||||
/* Define to 1 if you have the `waitpid' function. */
|
||||
#define HAVE_WAITPID 1
|
||||
|
||||
/* Define to 1 if `fork' works. */
|
||||
#define HAVE_WORKING_FORK 1
|
||||
|
||||
/* Define to 1 if `vfork' works. */
|
||||
/* #undef HAVE_WORKING_VFORK */
|
||||
|
||||
/* Build host information. */
|
||||
#define MAKE_HOST "i586-pc-beos"
|
||||
|
||||
/* Define this to enable job server support in GNU make. */
|
||||
/* #undef MAKE_JOBSERVER */
|
||||
|
||||
/* Define to 1 if your `struct nlist' has an `n_un' member. Obsolete, depend
|
||||
on `HAVE_STRUCT_NLIST_N_UN_N_NAME */
|
||||
/* #undef NLIST_NAME_UNION */
|
||||
|
||||
/* Define if struct nlist.n_name is a pointer rather than an array. */
|
||||
/* #undef NLIST_STRUCT */
|
||||
|
||||
/* Define to 1 if your C compiler doesn't accept -c and -o together. */
|
||||
/* #undef NO_MINUS_C_MINUS_O */
|
||||
|
||||
/* Name of package */
|
||||
#define PACKAGE "make"
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#define PACKAGE_BUGREPORT "[email protected]"
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#define PACKAGE_NAME "GNU make"
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#define PACKAGE_STRING "GNU make 3.81"
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#define PACKAGE_TARNAME "make"
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#define PACKAGE_VERSION "3.81"
|
||||
|
||||
/* Define to 1 if the C compiler supports function prototypes. */
|
||||
#define PROTOTYPES 1
|
||||
|
||||
/* Define as the return type of signal handlers (`int' or `void'). */
|
||||
#define RETSIGTYPE void
|
||||
|
||||
/* Define to the name of the SCCS 'get' command. */
|
||||
#define SCCS_GET "get"
|
||||
|
||||
/* Define this if the SCCS 'get' command understands the '-G<file>' option. */
|
||||
/* #undef SCCS_GET_MINUS_G */
|
||||
|
||||
/* Define to 1 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 to 1 if the `S_IS*' macros in <sys/stat.h> do not work properly. */
|
||||
/* #undef STAT_MACROS_BROKEN */
|
||||
|
||||
/* Define to 1 if you have the ANSI C header files. */
|
||||
#define STDC_HEADERS 1
|
||||
|
||||
/* Define if 'struct stat' contains a nanoseconds field */
|
||||
/* #undef ST_MTIM_NSEC */
|
||||
|
||||
/* Define to 1 on System V Release 4. */
|
||||
/* #undef SVR4 */
|
||||
|
||||
/* Define to 1 if `sys_siglist' is declared by <signal.h> or <unistd.h>. */
|
||||
#define SYS_SIGLIST_DECLARED 1
|
||||
|
||||
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
|
||||
#define TIME_WITH_SYS_TIME 1
|
||||
|
||||
/* Define to 1 for Encore UMAX. */
|
||||
/* #undef UMAX */
|
||||
|
||||
/* Define to 1 for Encore UMAX 4.3 that has <inq_status/cpustats.h> instead of
|
||||
<sys/cpustats.h>. */
|
||||
/* #undef UMAX4_3 */
|
||||
|
||||
/* Version number of package */
|
||||
#define VERSION "3.81"
|
||||
|
||||
/* Define if using the dmalloc debugging malloc package */
|
||||
/* #undef WITH_DMALLOC */
|
||||
|
||||
/* Define to 1 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
|
||||
|
||||
/* Number of bits in a file offset, on hosts where this is settable. */
|
||||
/* #undef _FILE_OFFSET_BITS */
|
||||
|
||||
/* Define for large files, on AIX-style hosts. */
|
||||
/* #undef _LARGE_FILES */
|
||||
|
||||
/* Define to 1 if on MINIX. */
|
||||
/* #undef _MINIX */
|
||||
|
||||
/* Define to 2 if the system does not provide POSIX.1 features except with
|
||||
this defined. */
|
||||
/* #undef _POSIX_1_SOURCE */
|
||||
|
||||
/* Define to 1 if you need to in order for `stat' and other things to work. */
|
||||
/* #undef _POSIX_SOURCE */
|
||||
|
||||
/* Define like PROTOTYPES; this can be used by system headers. */
|
||||
#define __PROTOTYPES 1
|
||||
|
||||
/* Define to empty if `const' does not conform to ANSI C. */
|
||||
/* #undef const */
|
||||
|
||||
/* Define to `int' if <sys/types.h> doesn't define. */
|
||||
/* #undef gid_t */
|
||||
|
||||
/* Define to `int' if <sys/types.h> does not define. */
|
||||
/* #undef pid_t */
|
||||
|
||||
/* Define to `int' if <sys/types.h> doesn't define. */
|
||||
/* #undef uid_t */
|
||||
|
||||
/* Define uintmax_t if not defined in <stdint.h> or <inttypes.h>. */
|
||||
/* #undef uintmax_t */
|
||||
|
||||
/* Define as `fork' if `vfork' does not work. */
|
||||
#define vfork fork
|
||||
@@ -1,38 +0,0 @@
|
||||
/* Debugging macros and interface.
|
||||
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#define DB_NONE (0x000)
|
||||
#define DB_BASIC (0x001)
|
||||
#define DB_VERBOSE (0x002)
|
||||
#define DB_JOBS (0x004)
|
||||
#define DB_IMPLICIT (0x008)
|
||||
#define DB_MAKEFILES (0x100)
|
||||
|
||||
#define DB_ALL (0xfff)
|
||||
|
||||
extern int db_level;
|
||||
|
||||
#define ISDB(_l) ((_l)&db_level)
|
||||
|
||||
#define DBS(_l,_x) do{ if(ISDB(_l)) {print_spaces (depth); \
|
||||
printf _x; fflush (stdout);} }while(0)
|
||||
|
||||
#define DBF(_l,_x) do{ if(ISDB(_l)) {print_spaces (depth); \
|
||||
printf (_x, file->name); \
|
||||
fflush (stdout);} }while(0)
|
||||
|
||||
#define DB(_l,_x) do{ if(ISDB(_l)) {printf _x; fflush (stdout);} }while(0)
|
||||
@@ -1,594 +0,0 @@
|
||||
/* Data base of default implicit rules for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "filedef.h"
|
||||
#include "variable.h"
|
||||
#include "rule.h"
|
||||
#include "dep.h"
|
||||
#include "job.h"
|
||||
#include "commands.h"
|
||||
|
||||
/* Define GCC_IS_NATIVE if gcc is the native development environment on
|
||||
your system (gcc/bison/flex vs cc/yacc/lex). */
|
||||
#if defined(__MSDOS__) || defined(__EMX__)
|
||||
# define GCC_IS_NATIVE
|
||||
#endif
|
||||
|
||||
|
||||
/* 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[]
|
||||
#ifdef VMS
|
||||
= ".exe .olb .ln .obj .c .cxx .cc .pas .p .for .f .r .y .l .mar \
|
||||
.s .ss .i .ii .mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \
|
||||
.w .ch .cweb .web .com .sh .elc .el";
|
||||
#elif defined(__EMX__)
|
||||
= ".out .a .ln .o .c .cc .C .cpp .p .f .F .r .y .l .s .S \
|
||||
.mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \
|
||||
.w .ch .web .sh .elc .el .obj .exe .dll .lib";
|
||||
#else
|
||||
= ".out .a .ln .o .c .cc .C .cpp .p .f .F .r .y .l .s .S \
|
||||
.mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \
|
||||
.w .ch .web .sh .elc .el";
|
||||
#endif
|
||||
|
||||
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. */
|
||||
#ifdef VMS
|
||||
{ "%.exe", "%",
|
||||
"copy $< $@" },
|
||||
#else
|
||||
{ "%.out", "%",
|
||||
"@rm -f $@ \n cp $< $@" },
|
||||
#endif
|
||||
/* 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[] =
|
||||
{
|
||||
#ifdef VMS
|
||||
/* RCS. */
|
||||
{ "%", "%$$5lv", /* Multinet style */
|
||||
"if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
|
||||
{ "%", "[.$$rcs]%$$5lv", /* Multinet style */
|
||||
"if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
|
||||
{ "%", "%_v", /* Normal style */
|
||||
"if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
|
||||
{ "%", "[.rcs]%_v", /* Normal style */
|
||||
"if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
|
||||
|
||||
/* SCCS. */
|
||||
/* ain't no SCCS on vms */
|
||||
#else
|
||||
/* RCS. */
|
||||
{ "%", "%,v",
|
||||
"$(CHECKOUT,v)" },
|
||||
{ "%", "RCS/%,v",
|
||||
"$(CHECKOUT,v)" },
|
||||
{ "%", "RCS/%",
|
||||
"$(CHECKOUT,v)" },
|
||||
|
||||
/* SCCS. */
|
||||
{ "%", "s.%",
|
||||
"$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
|
||||
{ "%", "SCCS/s.%",
|
||||
"$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
|
||||
#endif /* !VMS */
|
||||
{ 0, 0, 0 }
|
||||
};
|
||||
|
||||
static char *default_suffix_rules[] =
|
||||
{
|
||||
#ifdef VMS
|
||||
".obj.exe",
|
||||
"$(LINK.obj) $^ $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
|
||||
".mar.exe",
|
||||
"$(COMPILE.mar) $^ \n $(LINK.obj) $(subst .mar,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
|
||||
".s.exe",
|
||||
"$(COMPILE.s) $^ \n $(LINK.obj) $(subst .s,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
|
||||
".c.exe",
|
||||
"$(COMPILE.c) $^ \n $(LINK.obj) $(subst .c,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
|
||||
".cc.exe",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"$(COMPILE.cc) $^ \n $(LINK.obj) $(CXXSTARTUP),sys$$disk:[]$(subst .cc,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@",
|
||||
#else
|
||||
"$(COMPILE.cc) $^ \n $(CXXLINK.obj) $(subst .cc,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@",
|
||||
".cxx.exe",
|
||||
"$(COMPILE.cxx) $^ \n $(CXXLINK.obj) $(subst .cxx,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@",
|
||||
#endif
|
||||
".for.exe",
|
||||
"$(COMPILE.for) $^ \n $(LINK.obj) $(subst .for,.obj,$^) $(LOADLIBES) $(LDLIBS) /exe=$@",
|
||||
".pas.exe",
|
||||
"$(COMPILE.pas) $^ \n $(LINK.obj) $(subst .pas,.obj,$^) $(LOADLIBES) $(LDLIBS) /exe=$@",
|
||||
|
||||
".com",
|
||||
"copy $< >$@",
|
||||
|
||||
".mar.obj",
|
||||
"$(COMPILE.mar) /obj=$@ $<",
|
||||
".s.obj",
|
||||
"$(COMPILE.s) /obj=$@ $<",
|
||||
".ss.obj",
|
||||
"$(COMPILE.s) /obj=$@ $<",
|
||||
".c.i",
|
||||
"$(COMPILE.c)/prep /list=$@ $<",
|
||||
".c.s",
|
||||
"$(COMPILE.c)/noobj/machine /list=$@ $<",
|
||||
".i.s",
|
||||
"$(COMPILE.c)/noprep/noobj/machine /list=$@ $<",
|
||||
".c.obj",
|
||||
"$(COMPILE.c) /obj=$@ $<",
|
||||
".cc.ii",
|
||||
"$(COMPILE.cc)/prep /list=$@ $<",
|
||||
".cc.ss",
|
||||
"$(COMPILE.cc)/noobj/machine /list=$@ $<",
|
||||
".ii.ss",
|
||||
"$(COMPILE.cc)/noprep/noobj/machine /list=$@ $<",
|
||||
".cc.obj",
|
||||
"$(COMPILE.cc) /obj=$@ $<",
|
||||
".cxx.obj",
|
||||
"$(COMPILE.cxx) /obj=$@ $<",
|
||||
".for.obj",
|
||||
"$(COMPILE.for) /obj=$@ $<",
|
||||
".pas.obj",
|
||||
"$(COMPILE.pas) /obj=$@ $<",
|
||||
|
||||
".y.c",
|
||||
"$(YACC.y) $< \n rename y_tab.c $@",
|
||||
".l.c",
|
||||
"$(LEX.l) $< \n rename lexyy.c $@",
|
||||
|
||||
".texinfo.info",
|
||||
"$(MAKEINFO) $<",
|
||||
|
||||
".tex.dvi",
|
||||
"$(TEX) $<",
|
||||
|
||||
#else /* ! VMS */
|
||||
|
||||
".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 $@",
|
||||
".cpp",
|
||||
"$(LINK.cpp) $^ $(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",
|
||||
"$(COMPILE.s) -o $@ $<",
|
||||
".S.o",
|
||||
"$(COMPILE.S) -o $@ $<",
|
||||
".c.o",
|
||||
"$(COMPILE.c) $(OUTPUT_OPTION) $<",
|
||||
".cc.o",
|
||||
"$(COMPILE.cc) $(OUTPUT_OPTION) $<",
|
||||
".C.o",
|
||||
"$(COMPILE.C) $(OUTPUT_OPTION) $<",
|
||||
".cpp.o",
|
||||
"$(COMPILE.cpp) $(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",
|
||||
#ifndef __MSDOS__
|
||||
"$(YACC.y) $< \n $(LINT.c) -C$* y.tab.c \n $(RM) y.tab.c",
|
||||
#else
|
||||
"$(YACC.y) $< \n $(LINT.c) -C$* y_tab.c \n $(RM) y_tab.c",
|
||||
#endif
|
||||
".l.ln",
|
||||
"@$(RM) $*.c\n $(LEX.l) $< > $*.c\n$(LINT.c) -i $*.c -o $@\n $(RM) $*.c",
|
||||
|
||||
".y.c",
|
||||
#ifndef __MSDOS__
|
||||
"$(YACC.y) $< \n mv -f y.tab.c $@",
|
||||
#else
|
||||
"$(YACC.y) $< \n mv -f y_tab.c $@",
|
||||
#endif
|
||||
".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) $(MAKEINFO_FLAGS) $< -o $@",
|
||||
|
||||
".texi.info",
|
||||
"$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@",
|
||||
|
||||
".txinfo.info",
|
||||
"$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@",
|
||||
|
||||
".tex.dvi",
|
||||
"$(TEX) $<",
|
||||
|
||||
".texinfo.dvi",
|
||||
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
|
||||
|
||||
".texi.dvi",
|
||||
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
|
||||
|
||||
".txinfo.dvi",
|
||||
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
|
||||
|
||||
".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) $<",
|
||||
|
||||
#endif /* !VMS */
|
||||
|
||||
0, 0,
|
||||
};
|
||||
|
||||
static char *default_variables[] =
|
||||
{
|
||||
#ifdef VMS
|
||||
#ifdef __ALPHA
|
||||
"ARCH", "ALPHA",
|
||||
#endif
|
||||
#ifdef __ia64
|
||||
"ARCH", "IA64",
|
||||
#endif
|
||||
#ifdef __VAX
|
||||
"ARCH", "VAX",
|
||||
#endif
|
||||
"AR", "library/obj",
|
||||
"ARFLAGS", "/replace",
|
||||
"AS", "macro",
|
||||
"MACRO", "macro",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"CC", "gcc",
|
||||
#else
|
||||
"CC", "cc",
|
||||
#endif
|
||||
"CD", "builtin_cd",
|
||||
"MAKE", "make",
|
||||
"ECHO", "write sys$$output \"",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"C++", "gcc/plus",
|
||||
"CXX", "gcc/plus",
|
||||
#else
|
||||
"C++", "cxx",
|
||||
"CXX", "cxx",
|
||||
"CXXLD", "cxxlink",
|
||||
#endif
|
||||
"CO", "co",
|
||||
"CPP", "$(CC) /preprocess_only",
|
||||
"FC", "fortran",
|
||||
/* 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)",
|
||||
"LD", "link",
|
||||
"LEX", "lex",
|
||||
"PC", "pascal",
|
||||
"YACC", "bison/yacc",
|
||||
"YFLAGS", "/Define/Verbose",
|
||||
"BISON", "bison",
|
||||
"MAKEINFO", "makeinfo",
|
||||
"TEX", "tex",
|
||||
"TEXINDEX", "texindex",
|
||||
|
||||
"RM", "delete/nolog",
|
||||
|
||||
"CSTARTUP", "",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"CRT0", ",sys$$library:vaxcrtl.olb/lib,gnu_cc_library:crt0.obj",
|
||||
"CXXSTARTUP", "gnu_cc_library:crtbegin.obj",
|
||||
"CXXRT0", ",sys$$library:vaxcrtl.olb/lib,gnu_cc_library:crtend.obj,gnu_cc_library:gxx_main.obj",
|
||||
"LXLIBS", ",gnu_cc_library:libstdcxx.olb/lib,gnu_cc_library:libgccplus.olb/lib",
|
||||
"LDLIBS", ",gnu_cc_library:libgcc.olb/lib",
|
||||
#else
|
||||
"CRT0", "",
|
||||
"CXXSTARTUP", "",
|
||||
"CXXRT0", "",
|
||||
"LXLIBS", "",
|
||||
"LDLIBS", "",
|
||||
#endif
|
||||
|
||||
"LINK.obj", "$(LD) $(LDFLAGS)",
|
||||
#ifndef GCC_IS_NATIVE
|
||||
"CXXLINK.obj", "$(CXXLD) $(LDFLAGS)",
|
||||
"COMPILE.cxx", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
|
||||
#endif
|
||||
"COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
|
||||
"COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
|
||||
"YACC.y", "$(YACC) $(YFLAGS)",
|
||||
"LEX.l", "$(LEX) $(LFLAGS)",
|
||||
"COMPILE.for", "$(FC) $(FFLAGS) $(TARGET_ARCH)",
|
||||
"COMPILE.pas", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
|
||||
"COMPILE.mar", "$(MACRO) $(MACROFLAGS)",
|
||||
"COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)",
|
||||
"LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
|
||||
|
||||
"MV", "rename/new_version",
|
||||
"CP", "copy",
|
||||
|
||||
#else /* !VMS */
|
||||
|
||||
"AR", "ar",
|
||||
"ARFLAGS", "rv",
|
||||
"AS", "as",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"CC", "gcc",
|
||||
# ifdef __MSDOS__
|
||||
"CXX", "gpp", /* g++ is an invalid name on MSDOS */
|
||||
# else
|
||||
"CXX", "gcc",
|
||||
# endif /* __MSDOS__ */
|
||||
#else
|
||||
"CC", "cc",
|
||||
"CXX", "g++",
|
||||
#endif
|
||||
|
||||
/* This expands to $(CO) $(COFLAGS) $< $@ if $@ does not exist,
|
||||
and to the empty string if $@ does exist. */
|
||||
"CHECKOUT,v", "+$(if $(wildcard $@),,$(CO) $(COFLAGS) $< $@)",
|
||||
"CO", "co",
|
||||
"COFLAGS", "",
|
||||
|
||||
"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",
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"LEX", "flex",
|
||||
#else
|
||||
"LEX", "lex",
|
||||
#endif
|
||||
"LINT", "lint",
|
||||
"M2C", "m2c",
|
||||
#ifdef pyr
|
||||
"PC", "pascal",
|
||||
#else
|
||||
#ifdef CRAY
|
||||
"PC", "PASCAL",
|
||||
"SEGLDR", "segldr",
|
||||
#else
|
||||
"PC", "pc",
|
||||
#endif /* CRAY. */
|
||||
#endif /* pyr. */
|
||||
#ifdef GCC_IS_NATIVE
|
||||
"YACC", "bison -y",
|
||||
#else
|
||||
"YACC", "yacc", /* Or "bison -y" */
|
||||
#endif
|
||||
"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)",
|
||||
"COMPILE.cpp", "$(COMPILE.cc)",
|
||||
"LINK.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
|
||||
"LINK.C", "$(LINK.cc)",
|
||||
"LINK.cpp", "$(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",
|
||||
"PREPROCESS.S", "$(CC) -E $(CPPFLAGS)",
|
||||
"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
|
||||
"OUTPUT_OPTION", "-o $@",
|
||||
#endif
|
||||
|
||||
#ifdef SCCS_GET_MINUS_G
|
||||
"SCCS_OUTPUT_OPTION", "-G$@",
|
||||
#endif
|
||||
|
||||
#ifdef _AMIGA
|
||||
".LIBPATTERNS", "%.lib",
|
||||
#else
|
||||
#ifdef __MSDOS__
|
||||
".LIBPATTERNS", "lib%.a $(DJDIR)/lib/lib%.a",
|
||||
#else
|
||||
".LIBPATTERNS", "lib%.so lib%.a",
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* !VMS */
|
||||
0, 0
|
||||
};
|
||||
|
||||
/* Set up the default .SUFFIXES list. */
|
||||
|
||||
void
|
||||
set_default_suffixes (void)
|
||||
{
|
||||
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 (void)
|
||||
{
|
||||
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->fileinfo.filenm = 0;
|
||||
f->cmds->commands = s[1];
|
||||
f->cmds->command_lines = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Install the default pattern rules. */
|
||||
|
||||
void
|
||||
install_default_implicit_rules (void)
|
||||
{
|
||||
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 (void)
|
||||
{
|
||||
register char **s;
|
||||
|
||||
if (no_builtin_variables_flag)
|
||||
return;
|
||||
|
||||
for (s = default_variables; *s != 0; s += 2)
|
||||
(void) define_variable (s[0], strlen (s[0]), s[1], o_default, 1);
|
||||
}
|
||||
@@ -1,85 +0,0 @@
|
||||
/* Definitions of dependency data structures for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
/* 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
|
||||
|
||||
/* Structure representing one dependency of a file.
|
||||
Each struct file's `deps' points to a chain of these,
|
||||
chained through the `next'. `stem' is the stem for this
|
||||
dep line of static pattern rule or NULL.
|
||||
|
||||
Note that the first two words of this match a struct nameseq. */
|
||||
|
||||
struct dep
|
||||
{
|
||||
struct dep *next;
|
||||
char *name;
|
||||
char *stem;
|
||||
struct file *file;
|
||||
unsigned int changed : 8;
|
||||
unsigned int ignore_mtime : 1;
|
||||
unsigned int staticpattern : 1;
|
||||
unsigned int need_2nd_expansion : 1;
|
||||
};
|
||||
|
||||
|
||||
/* Structure used in chains of names, for parsing and globbing. */
|
||||
|
||||
struct nameseq
|
||||
{
|
||||
struct nameseq *next;
|
||||
char *name;
|
||||
};
|
||||
|
||||
|
||||
extern struct nameseq *multi_glob PARAMS ((struct nameseq *chain, unsigned int size));
|
||||
#ifdef VMS
|
||||
extern struct nameseq *parse_file_seq ();
|
||||
#else
|
||||
extern struct nameseq *parse_file_seq PARAMS ((char **stringp, int stopchar, unsigned int size, int strip));
|
||||
#endif
|
||||
extern char *tilde_expand PARAMS ((char *name));
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
extern struct nameseq *ar_glob PARAMS ((char *arname, char *member_pattern, unsigned int size));
|
||||
#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 *alloc_dep PARAMS ((void));
|
||||
extern void free_dep PARAMS ((struct dep *d));
|
||||
extern struct dep *copy_dep_chain PARAMS ((const struct dep *d));
|
||||
extern void free_dep_chain PARAMS ((struct dep *d));
|
||||
extern void free_ns_chain PARAMS ((struct nameseq *n));
|
||||
extern struct dep *read_all_makefiles PARAMS ((char **makefiles));
|
||||
extern int eval_buffer PARAMS ((char *buffer));
|
||||
extern int update_goal_chain PARAMS ((struct dep *goals));
|
||||
extern void uniquize_deps PARAMS ((struct dep *));
|
||||
-1216
File diff suppressed because it is too large
Load Diff
@@ -1,584 +0,0 @@
|
||||
/* Variable expansion functions for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "filedef.h"
|
||||
#include "job.h"
|
||||
#include "commands.h"
|
||||
#include "variable.h"
|
||||
#include "rule.h"
|
||||
|
||||
/* Initially, any errors reported when expanding strings will be reported
|
||||
against the file where the error appears. */
|
||||
const struct floc **expanding_var = &reading_file;
|
||||
|
||||
/* 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.
|
||||
|
||||
For efficiency, it's guaranteed that the buffer will always have
|
||||
VARIABLE_BUFFER_ZONE extra bytes allocated. This allows you to add a few
|
||||
extra chars without having to call a function. Note you should never use
|
||||
these bytes unless you're _sure_ you have room (you know when the buffer
|
||||
length was last checked. */
|
||||
|
||||
#define VARIABLE_BUFFER_ZONE 5
|
||||
|
||||
static unsigned int variable_buffer_length;
|
||||
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 (char *ptr, char *string, unsigned int length)
|
||||
{
|
||||
register unsigned int newlen = length + (ptr - variable_buffer);
|
||||
|
||||
if ((newlen + VARIABLE_BUFFER_ZONE) > 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 (void)
|
||||
{
|
||||
/* 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. */
|
||||
|
||||
static char *allocated_variable_append PARAMS ((const struct variable *v));
|
||||
|
||||
char *
|
||||
recursively_expand_for_file (struct variable *v, struct file *file)
|
||||
{
|
||||
char *value;
|
||||
const struct floc *this_var;
|
||||
const struct floc **saved_varp;
|
||||
struct variable_set_list *save = 0;
|
||||
int set_reading = 0;
|
||||
|
||||
/* Don't install a new location if this location is empty.
|
||||
This can happen for command-line variables, builtin variables, etc. */
|
||||
saved_varp = expanding_var;
|
||||
if (v->fileinfo.filenm)
|
||||
{
|
||||
this_var = &v->fileinfo;
|
||||
expanding_var = &this_var;
|
||||
}
|
||||
|
||||
/* If we have no other file-reading context, use the variable's context. */
|
||||
if (!reading_file)
|
||||
{
|
||||
set_reading = 1;
|
||||
reading_file = &v->fileinfo;
|
||||
}
|
||||
|
||||
if (v->expanding)
|
||||
{
|
||||
if (!v->exp_count)
|
||||
/* Expanding V causes infinite recursion. Lose. */
|
||||
fatal (*expanding_var,
|
||||
_("Recursive variable `%s' references itself (eventually)"),
|
||||
v->name);
|
||||
--v->exp_count;
|
||||
}
|
||||
|
||||
if (file)
|
||||
{
|
||||
save = current_variable_set_list;
|
||||
current_variable_set_list = file->variables;
|
||||
}
|
||||
|
||||
v->expanding = 1;
|
||||
if (v->append)
|
||||
value = allocated_variable_append (v);
|
||||
else
|
||||
value = allocated_variable_expand (v->value);
|
||||
v->expanding = 0;
|
||||
|
||||
if (set_reading)
|
||||
reading_file = 0;
|
||||
|
||||
if (file)
|
||||
current_variable_set_list = save;
|
||||
|
||||
expanding_var = saved_varp;
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
/* Expand a simple reference to variable NAME, which is LENGTH chars long. */
|
||||
|
||||
#ifdef __GNUC__
|
||||
__inline
|
||||
#endif
|
||||
static char *
|
||||
reference_variable (char *o, char *name, unsigned int length)
|
||||
{
|
||||
register struct variable *v;
|
||||
char *value;
|
||||
|
||||
v = lookup_variable (name, length);
|
||||
|
||||
if (v == 0)
|
||||
warn_undefined (name, length);
|
||||
|
||||
/* If there's no variable by that name or it has no value, stop now. */
|
||||
if (v == 0 || (*v->value == '\0' && !v->append))
|
||||
return o;
|
||||
|
||||
value = (v->recursive ? recursively_expand (v) : v->value);
|
||||
|
||||
o = variable_buffer_output (o, value, strlen (value));
|
||||
|
||||
if (v->recursive)
|
||||
free (value);
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
/* Scan STRING for variable references and expansion-function calls. Only
|
||||
LENGTH bytes of STRING are actually scanned. If LENGTH is -1, scan until
|
||||
a null byte is found.
|
||||
|
||||
Write the results to LINE, which must point into `variable_buffer'. If
|
||||
LINE is NULL, start at the beginning of the buffer.
|
||||
Return a pointer to LINE, or to the beginning of the buffer if LINE is
|
||||
NULL. */
|
||||
|
||||
char *
|
||||
variable_expand_string (char *line, char *string, long length)
|
||||
{
|
||||
register struct variable *v;
|
||||
register char *p, *o, *p1;
|
||||
char save_char = '\0';
|
||||
unsigned int line_offset;
|
||||
|
||||
if (!line)
|
||||
line = initialize_variable_output();
|
||||
|
||||
p = string;
|
||||
o = line;
|
||||
line_offset = line - variable_buffer;
|
||||
|
||||
if (length >= 0)
|
||||
{
|
||||
save_char = string[length];
|
||||
string[length] = '\0';
|
||||
}
|
||||
|
||||
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 = strchr (p, '$');
|
||||
|
||||
o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(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;
|
||||
int free_beg = 0;
|
||||
char *op, *begp;
|
||||
char *end, *colon;
|
||||
|
||||
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. */
|
||||
|
||||
end = strchr (beg, closeparen);
|
||||
if (end == 0)
|
||||
/* Unterminated variable reference. */
|
||||
fatal (*expanding_var, _("unterminated variable reference"));
|
||||
p1 = lindex (beg, end, '$');
|
||||
if (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;
|
||||
}
|
||||
/* 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)
|
||||
{
|
||||
beg = expand_argument (beg, p); /* Expand the name. */
|
||||
free_beg = 1; /* Remember to free BEG when finished. */
|
||||
end = strchr (beg, '\0');
|
||||
}
|
||||
}
|
||||
else
|
||||
/* Advance P to the end of this reference. After we are
|
||||
finished expanding this one, P will be incremented to
|
||||
continue the scan. */
|
||||
p = end;
|
||||
|
||||
/* This is not a reference to a built-in function and
|
||||
any variable references inside are now expanded.
|
||||
Is the resultant text a substitution reference? */
|
||||
|
||||
colon = lindex (beg, end, ':');
|
||||
if (colon)
|
||||
{
|
||||
/* This looks like a substitution reference: $(FOO:A=B). */
|
||||
char *subst_beg, *subst_end, *replace_beg, *replace_end;
|
||||
|
||||
subst_beg = colon + 1;
|
||||
subst_end = lindex (subst_beg, end, '=');
|
||||
if (subst_end == 0)
|
||||
/* There is no = in sight. Punt on the substitution
|
||||
reference and treat this as a variable name containing
|
||||
a colon, in the code below. */
|
||||
colon = 0;
|
||||
else
|
||||
{
|
||||
replace_beg = subst_end + 1;
|
||||
replace_end = end;
|
||||
|
||||
/* Extract the variable name before the colon
|
||||
and look up that variable. */
|
||||
v = lookup_variable (beg, colon - beg);
|
||||
if (v == 0)
|
||||
warn_undefined (beg, colon - beg);
|
||||
|
||||
/* If the variable is not empty, perform the
|
||||
substitution. */
|
||||
if (v != 0 && *v->value != '\0')
|
||||
{
|
||||
char *pattern, *replace, *ppercent, *rpercent;
|
||||
char *value = (v->recursive
|
||||
? recursively_expand (v)
|
||||
: v->value);
|
||||
|
||||
/* Copy the pattern and the replacement. Add in an
|
||||
extra % at the beginning to use in case there
|
||||
isn't one in the pattern. */
|
||||
pattern = (char *) alloca (subst_end - subst_beg + 2);
|
||||
*(pattern++) = '%';
|
||||
bcopy (subst_beg, pattern, subst_end - subst_beg);
|
||||
pattern[subst_end - subst_beg] = '\0';
|
||||
|
||||
replace = (char *) alloca (replace_end
|
||||
- replace_beg + 2);
|
||||
*(replace++) = '%';
|
||||
bcopy (replace_beg, replace,
|
||||
replace_end - replace_beg);
|
||||
replace[replace_end - replace_beg] = '\0';
|
||||
|
||||
/* Look for %. Set the percent pointers properly
|
||||
based on whether we find one or not. */
|
||||
ppercent = find_percent (pattern);
|
||||
if (ppercent)
|
||||
{
|
||||
++ppercent;
|
||||
rpercent = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
ppercent = pattern;
|
||||
rpercent = replace;
|
||||
--pattern;
|
||||
--replace;
|
||||
}
|
||||
|
||||
o = patsubst_expand (o, value, pattern, replace,
|
||||
ppercent, rpercent);
|
||||
|
||||
if (v->recursive)
|
||||
free (value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (colon == 0)
|
||||
/* This is an ordinary variable reference.
|
||||
Look up the value of the variable. */
|
||||
o = reference_variable (o, beg, end - beg);
|
||||
|
||||
if (free_beg)
|
||||
free (beg);
|
||||
}
|
||||
break;
|
||||
|
||||
case '\0':
|
||||
break;
|
||||
|
||||
default:
|
||||
if (isblank ((unsigned char)p[-1]))
|
||||
break;
|
||||
|
||||
/* A $ followed by a random char is a variable reference:
|
||||
$a is equivalent to $(a). */
|
||||
o = reference_variable (o, p, 1);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (*p == '\0')
|
||||
break;
|
||||
else
|
||||
++p;
|
||||
}
|
||||
|
||||
if (save_char)
|
||||
string[length] = save_char;
|
||||
|
||||
(void)variable_buffer_output (o, "", 1);
|
||||
return (variable_buffer + line_offset);
|
||||
}
|
||||
|
||||
/* 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 (char *line)
|
||||
{
|
||||
return variable_expand_string(NULL, line, (long)-1);
|
||||
}
|
||||
|
||||
/* 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 (const char *str, const char *end)
|
||||
{
|
||||
char *tmp;
|
||||
|
||||
if (str == end)
|
||||
return xstrdup("");
|
||||
|
||||
if (!end || *end == '\0')
|
||||
return allocated_variable_expand ((char *)str);
|
||||
|
||||
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 (char *line, 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;
|
||||
if (file->cmds && file->cmds->fileinfo.filenm)
|
||||
reading_file = &file->cmds->fileinfo;
|
||||
else
|
||||
reading_file = 0;
|
||||
result = variable_expand (line);
|
||||
current_variable_set_list = save;
|
||||
reading_file = 0;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/* Like allocated_variable_expand, but for += target-specific variables.
|
||||
First recursively construct the variable value from its appended parts in
|
||||
any upper variable sets. Then expand the resulting value. */
|
||||
|
||||
static char *
|
||||
variable_append (const char *name, unsigned int length,
|
||||
const struct variable_set_list *set)
|
||||
{
|
||||
const struct variable *v;
|
||||
char *buf = 0;
|
||||
|
||||
/* If there's nothing left to check, return the empty buffer. */
|
||||
if (!set)
|
||||
return initialize_variable_output ();
|
||||
|
||||
/* Try to find the variable in this variable set. */
|
||||
v = lookup_variable_in_set (name, length, set->set);
|
||||
|
||||
/* If there isn't one, look to see if there's one in a set above us. */
|
||||
if (!v)
|
||||
return variable_append (name, length, set->next);
|
||||
|
||||
/* If this variable type is append, first get any upper values.
|
||||
If not, initialize the buffer. */
|
||||
if (v->append)
|
||||
buf = variable_append (name, length, set->next);
|
||||
else
|
||||
buf = initialize_variable_output ();
|
||||
|
||||
/* Append this value to the buffer, and return it.
|
||||
If we already have a value, first add a space. */
|
||||
if (buf > variable_buffer)
|
||||
buf = variable_buffer_output (buf, " ", 1);
|
||||
|
||||
/* Either expand it or copy it, depending. */
|
||||
if (! v->recursive)
|
||||
return variable_buffer_output (buf, v->value, strlen (v->value));
|
||||
|
||||
buf = variable_expand_string (buf, v->value, strlen (v->value));
|
||||
return (buf + strlen (buf));
|
||||
}
|
||||
|
||||
|
||||
static char *
|
||||
allocated_variable_append (const struct variable *v)
|
||||
{
|
||||
char *val;
|
||||
|
||||
/* Construct the appended variable value. */
|
||||
|
||||
char *obuf = variable_buffer;
|
||||
unsigned int olen = variable_buffer_length;
|
||||
|
||||
variable_buffer = 0;
|
||||
|
||||
val = variable_append (v->name, strlen (v->name), current_variable_set_list);
|
||||
variable_buffer_output (val, "", 1);
|
||||
val = variable_buffer;
|
||||
|
||||
variable_buffer = obuf;
|
||||
variable_buffer_length = olen;
|
||||
|
||||
return val;
|
||||
}
|
||||
|
||||
/* 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 (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;
|
||||
}
|
||||
|
||||
/* Install a new variable_buffer context, returning the current one for
|
||||
safe-keeping. */
|
||||
|
||||
void
|
||||
install_variable_buffer (char **bufp, unsigned int *lenp)
|
||||
{
|
||||
*bufp = variable_buffer;
|
||||
*lenp = variable_buffer_length;
|
||||
|
||||
variable_buffer = 0;
|
||||
initialize_variable_output ();
|
||||
}
|
||||
|
||||
/* Restore a previously-saved variable_buffer setting (free the current one).
|
||||
*/
|
||||
|
||||
void
|
||||
restore_variable_buffer (char *buf, unsigned int len)
|
||||
{
|
||||
free (variable_buffer);
|
||||
|
||||
variable_buffer = buf;
|
||||
variable_buffer_length = len;
|
||||
}
|
||||
-1051
File diff suppressed because it is too large
Load Diff
@@ -1,202 +0,0 @@
|
||||
/* Definition of target file data structures for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
|
||||
/* Structure that represents the info on one file
|
||||
that the makefile says how to make.
|
||||
All of these are chained together through `next'. */
|
||||
|
||||
#include "hash.h"
|
||||
|
||||
struct file
|
||||
{
|
||||
char *name;
|
||||
char *hname; /* Hashed filename */
|
||||
char *vpath; /* VPATH/vpath pathname */
|
||||
struct dep *deps; /* all dependencies, including duplicates */
|
||||
struct commands *cmds; /* Commands to execute for this target. */
|
||||
int command_flags; /* Flags OR'd in for cmds; see commands.h. */
|
||||
char *stem; /* Implicit stem, if an implicit
|
||||
rule has been used */
|
||||
struct dep *also_make; /* Targets that are made by making this. */
|
||||
FILE_TIMESTAMP last_mtime; /* File's modtime, if already known. */
|
||||
FILE_TIMESTAMP mtime_before_update; /* File's modtime before any updating
|
||||
has been performed. */
|
||||
struct file *prev; /* Previous entry for same file name;
|
||||
used when there are multiple double-colon
|
||||
entries for the same file. */
|
||||
struct file *last; /* Last entry for the same file name. */
|
||||
|
||||
/* 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;
|
||||
|
||||
/* Pattern-specific variable reference for this target, or null if there
|
||||
isn't one. Also see the pat_searched flag, below. */
|
||||
struct variable_set_list *pat_variables;
|
||||
|
||||
/* Immediate dependent that caused this target to be remade,
|
||||
or nil if there isn't one. */
|
||||
struct file *parent;
|
||||
|
||||
/* For a double-colon entry, this is the first double-colon entry for
|
||||
the same file. Otherwise this is null. */
|
||||
struct file *double_colon;
|
||||
|
||||
short int update_status; /* Status of the last attempt to update,
|
||||
or -1 if none has been made. */
|
||||
|
||||
enum cmd_state /* 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 precious:1; /* Non-0 means don't delete file on quit */
|
||||
unsigned int low_resolution_time:1; /* Nonzero if this file's time stamp
|
||||
has only one-second resolution. */
|
||||
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 prerequisite of .PHONY. */
|
||||
unsigned int intermediate:1;/* Nonzero if this is an intermediate file. */
|
||||
unsigned int secondary:1; /* Nonzero means remove_intermediates should
|
||||
not delete it. */
|
||||
unsigned int dontcare:1; /* Nonzero if no complaint is to be made if
|
||||
this target cannot be remade. */
|
||||
unsigned int ignore_vpath:1;/* Nonzero if we threw out VPATH name. */
|
||||
unsigned int pat_searched:1;/* Nonzero if we already searched for
|
||||
pattern-specific variables. */
|
||||
unsigned int considered:1; /* equal to 'considered' if file has been
|
||||
considered on current scan of goal chain */
|
||||
};
|
||||
|
||||
|
||||
extern struct file *default_goal_file, *suffix_file, *default_file;
|
||||
extern char **default_goal_name;
|
||||
|
||||
|
||||
extern struct file *lookup_file PARAMS ((char *name));
|
||||
extern struct file *enter_file PARAMS ((char *name));
|
||||
extern struct dep *parse_prereqs PARAMS ((char *prereqs));
|
||||
extern void remove_intermediates PARAMS ((int sig));
|
||||
extern void snap_deps PARAMS ((void));
|
||||
extern void rename_file PARAMS ((struct file *file, char *name));
|
||||
extern void rehash_file PARAMS ((struct file *file, char *name));
|
||||
extern void set_command_state PARAMS ((struct file *file, enum cmd_state state));
|
||||
extern void notice_finished_file PARAMS ((struct file *file));
|
||||
extern void init_hash_files PARAMS ((void));
|
||||
extern char *build_target_list PARAMS ((char *old_list));
|
||||
|
||||
#if FILE_TIMESTAMP_HI_RES
|
||||
# define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \
|
||||
file_timestamp_cons (fname, (st).st_mtime, (st).st_mtim.ST_MTIM_NSEC)
|
||||
#else
|
||||
# define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \
|
||||
file_timestamp_cons (fname, (st).st_mtime, 0)
|
||||
#endif
|
||||
|
||||
/* If FILE_TIMESTAMP is 64 bits (or more), use nanosecond resolution.
|
||||
(Multiply by 2**30 instead of by 10**9 to save time at the cost of
|
||||
slightly decreasing the number of available timestamps.) With
|
||||
64-bit FILE_TIMESTAMP, this stops working on 2514-05-30 01:53:04
|
||||
UTC, but by then uintmax_t should be larger than 64 bits. */
|
||||
#define FILE_TIMESTAMPS_PER_S (FILE_TIMESTAMP_HI_RES ? 1000000000 : 1)
|
||||
#define FILE_TIMESTAMP_LO_BITS (FILE_TIMESTAMP_HI_RES ? 30 : 0)
|
||||
|
||||
#define FILE_TIMESTAMP_S(ts) (((ts) - ORDINARY_MTIME_MIN) \
|
||||
>> FILE_TIMESTAMP_LO_BITS)
|
||||
#define FILE_TIMESTAMP_NS(ts) ((int) (((ts) - ORDINARY_MTIME_MIN) \
|
||||
& ((1 << FILE_TIMESTAMP_LO_BITS) - 1)))
|
||||
|
||||
/* Upper bound on length of string "YYYY-MM-DD HH:MM:SS.NNNNNNNNN"
|
||||
representing a file timestamp. The upper bound is not necessarily 19,
|
||||
since the year might be less than -999 or greater than 9999.
|
||||
|
||||
Subtract one for the sign bit if in case file timestamps can be negative;
|
||||
subtract FLOOR_LOG2_SECONDS_PER_YEAR to yield an upper bound on how many
|
||||
file timestamp bits might affect the year;
|
||||
302 / 1000 is log10 (2) rounded up;
|
||||
add one for integer division truncation;
|
||||
add one more for a minus sign if file timestamps can be negative;
|
||||
add 4 to allow for any 4-digit epoch year (e.g. 1970);
|
||||
add 25 to allow for "-MM-DD HH:MM:SS.NNNNNNNNN". */
|
||||
#define FLOOR_LOG2_SECONDS_PER_YEAR 24
|
||||
#define FILE_TIMESTAMP_PRINT_LEN_BOUND \
|
||||
(((sizeof (FILE_TIMESTAMP) * CHAR_BIT - 1 - FLOOR_LOG2_SECONDS_PER_YEAR) \
|
||||
* 302 / 1000) \
|
||||
+ 1 + 1 + 4 + 25)
|
||||
|
||||
extern FILE_TIMESTAMP file_timestamp_cons PARAMS ((char const *,
|
||||
time_t, int));
|
||||
extern FILE_TIMESTAMP file_timestamp_now PARAMS ((int *));
|
||||
extern void file_timestamp_sprintf PARAMS ((char *p, FILE_TIMESTAMP ts));
|
||||
|
||||
/* Return the mtime of file F (a struct file *), caching it.
|
||||
The value is NONEXISTENT_MTIME if the file does not exist. */
|
||||
#define file_mtime(f) file_mtime_1 ((f), 1)
|
||||
/* Return the mtime of file F (a struct file *), caching it.
|
||||
Don't search using vpath for the file--if it doesn't actually exist,
|
||||
we don't find it.
|
||||
The value is NONEXISTENT_MTIME if the file does not exist. */
|
||||
#define file_mtime_no_search(f) file_mtime_1 ((f), 0)
|
||||
extern FILE_TIMESTAMP f_mtime PARAMS ((struct file *file, int search));
|
||||
#define file_mtime_1(f, v) \
|
||||
((f)->last_mtime == UNKNOWN_MTIME ? f_mtime ((f), v) : (f)->last_mtime)
|
||||
|
||||
/* Special timestamp values. */
|
||||
|
||||
/* The file's timestamp is not yet known. */
|
||||
#define UNKNOWN_MTIME 0
|
||||
|
||||
/* The file does not exist. */
|
||||
#define NONEXISTENT_MTIME 1
|
||||
|
||||
/* The file does not exist, and we assume that it is older than any
|
||||
actual file. */
|
||||
#define OLD_MTIME 2
|
||||
|
||||
/* The smallest and largest ordinary timestamps. */
|
||||
#define ORDINARY_MTIME_MIN (OLD_MTIME + 1)
|
||||
#define ORDINARY_MTIME_MAX ((FILE_TIMESTAMP_S (NEW_MTIME) \
|
||||
<< FILE_TIMESTAMP_LO_BITS) \
|
||||
+ ORDINARY_MTIME_MIN + FILE_TIMESTAMPS_PER_S - 1)
|
||||
|
||||
/* 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. */
|
||||
#define NEW_MTIME INTEGER_TYPE_MAXIMUM (FILE_TIMESTAMP)
|
||||
|
||||
#define check_renamed(file) \
|
||||
while ((file)->renamed != 0) (file) = (file)->renamed /* No ; here. */
|
||||
|
||||
/* Have we snapped deps yet? */
|
||||
extern int snapped_deps;
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,133 +0,0 @@
|
||||
/* Declarations for getopt.
|
||||
Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
||||
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
|
||||
|
||||
NOTE: The canonical source of this file is maintained with the GNU C Library.
|
||||
Bugs can be reported to [email protected].
|
||||
|
||||
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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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 -1, 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 defined (__STDC__) && __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 defined (__STDC__) && __STDC__
|
||||
#ifdef __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 /* __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 /* __STDC__ */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* getopt.h */
|
||||
@@ -1,180 +0,0 @@
|
||||
/* getopt_long and getopt_long_only entry points for GNU getopt.
|
||||
Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
|
||||
Foundation, Inc.
|
||||
|
||||
NOTE: The canonical source of this file is maintained with the GNU C Library.
|
||||
Bugs can be reported to [email protected].
|
||||
|
||||
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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include "getopt.h"
|
||||
|
||||
#if !defined __STDC__ || !__STDC__
|
||||
/* This is a separate conditional since some stdc systems
|
||||
reject `defined (const)'. */
|
||||
#ifndef const
|
||||
#define const
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/* 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. */
|
||||
|
||||
#define GETOPT_INTERFACE_VERSION 2
|
||||
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
|
||||
#include <gnu-versions.h>
|
||||
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
|
||||
#define ELIDE_CODE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef ELIDE_CODE
|
||||
|
||||
|
||||
/* This needs to come after some library #include
|
||||
to get __GNU_LIBRARY__ defined. */
|
||||
#ifdef __GNU_LIBRARY__
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
#endif
|
||||
|
||||
int
|
||||
getopt_long (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 (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 /* Not ELIDE_CODE. */
|
||||
|
||||
#ifdef TEST
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int
|
||||
main (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 == -1)
|
||||
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 */
|
||||
@@ -1,58 +0,0 @@
|
||||
/* Convenience header for conditional use of GNU <libintl.h>.
|
||||
Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005,
|
||||
2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#ifndef _LIBGETTEXT_H
|
||||
#define _LIBGETTEXT_H 1
|
||||
|
||||
/* NLS can be disabled through the configure --disable-nls option. */
|
||||
#if ENABLE_NLS
|
||||
|
||||
/* Get declarations of GNU message catalog functions. */
|
||||
# include <libintl.h>
|
||||
|
||||
#else
|
||||
|
||||
/* Disabled NLS.
|
||||
The casts to 'const char *' serve the purpose of producing warnings
|
||||
for invalid uses of the value returned from these functions.
|
||||
On pre-ANSI systems without 'const', the config.h file is supposed to
|
||||
contain "#define const". */
|
||||
# define gettext(Msgid) ((const char *) (Msgid))
|
||||
# define dgettext(Domainname, Msgid) ((const char *) (Msgid))
|
||||
# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid))
|
||||
# define ngettext(Msgid1, Msgid2, N) \
|
||||
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
|
||||
# define dngettext(Domainname, Msgid1, Msgid2, N) \
|
||||
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
|
||||
# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
|
||||
((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
|
||||
# define textdomain(Domainname) ((const char *) (Domainname))
|
||||
# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname))
|
||||
# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset))
|
||||
|
||||
#endif
|
||||
|
||||
/* A pseudo function call that serves as a marker for the automated
|
||||
extraction of messages, but does not call gettext(). The run-time
|
||||
translation is done at a different place in the code.
|
||||
The argument, String, should be a literal string. Concatenated strings
|
||||
and other string expressions won't work.
|
||||
The macro's expansion is not parenthesized, so that it is suitable as
|
||||
initializer for static 'char[]' or 'const char[]' variables. */
|
||||
#define gettext_noop(String) String
|
||||
|
||||
#endif /* _LIBGETTEXT_H */
|
||||
@@ -1,481 +0,0 @@
|
||||
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.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
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.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
@@ -1,17 +0,0 @@
|
||||
SubDir HAIKU_TOP src bin make glob ;
|
||||
|
||||
SetSubDirSupportedPlatformsBeOSCompatible ;
|
||||
|
||||
# filter warnings we don't want here
|
||||
TARGET_WARNING_CCFLAGS = [ FFilter $(TARGET_WARNING_CCFLAGS)
|
||||
: -Wall -Wmissing-prototypes -Wsign-compare ] ;
|
||||
|
||||
SubDirCcFlags -DHAVE_CONFIG_H ;
|
||||
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) $(DOTDOT) ] ;
|
||||
SubDirSysHdrs [ FDirName $(SUBDIR) ] ;
|
||||
|
||||
StaticLibrary <make>libglob.a :
|
||||
fnmatch.c
|
||||
glob.c
|
||||
;
|
||||
@@ -1,488 +0,0 @@
|
||||
/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA. */
|
||||
|
||||
#if HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
/* Enable GNU extensions in fnmatch.h. */
|
||||
#ifndef _GNU_SOURCE
|
||||
# define _GNU_SOURCE 1
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
#include <fnmatch.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#if HAVE_STRING_H || defined _LIBC
|
||||
# include <string.h>
|
||||
#else
|
||||
# include <strings.h>
|
||||
#endif
|
||||
|
||||
#if defined STDC_HEADERS || defined _LIBC
|
||||
# include <stdlib.h>
|
||||
#endif
|
||||
|
||||
/* For platform which support the ISO C amendement 1 functionality we
|
||||
support user defined character classes. */
|
||||
#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
|
||||
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */
|
||||
# include <wchar.h>
|
||||
# include <wctype.h>
|
||||
#endif
|
||||
|
||||
/* 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 STDC_HEADERS || !defined isascii
|
||||
# define ISASCII(c) 1
|
||||
# else
|
||||
# define ISASCII(c) isascii(c)
|
||||
# endif
|
||||
|
||||
# ifdef isblank
|
||||
# define ISBLANK(c) (ISASCII (c) && isblank (c))
|
||||
# else
|
||||
# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
|
||||
# endif
|
||||
# ifdef isgraph
|
||||
# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
|
||||
# else
|
||||
# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
|
||||
# endif
|
||||
|
||||
# define ISPRINT(c) (ISASCII (c) && isprint (c))
|
||||
# define ISDIGIT(c) (ISASCII (c) && isdigit (c))
|
||||
# define ISALNUM(c) (ISASCII (c) && isalnum (c))
|
||||
# define ISALPHA(c) (ISASCII (c) && isalpha (c))
|
||||
# define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
|
||||
# define ISLOWER(c) (ISASCII (c) && islower (c))
|
||||
# define ISPUNCT(c) (ISASCII (c) && ispunct (c))
|
||||
# define ISSPACE(c) (ISASCII (c) && isspace (c))
|
||||
# define ISUPPER(c) (ISASCII (c) && isupper (c))
|
||||
# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
|
||||
|
||||
# define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
|
||||
|
||||
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
|
||||
/* The GNU C library provides support for user-defined character classes
|
||||
and the functions from ISO C amendement 1. */
|
||||
# ifdef CHARCLASS_NAME_MAX
|
||||
# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
|
||||
# else
|
||||
/* This shouldn't happen but some implementation might still have this
|
||||
problem. Use a reasonable default value. */
|
||||
# define CHAR_CLASS_MAX_LENGTH 256
|
||||
# endif
|
||||
|
||||
# ifdef _LIBC
|
||||
# define IS_CHAR_CLASS(string) __wctype (string)
|
||||
# else
|
||||
# define IS_CHAR_CLASS(string) wctype (string)
|
||||
# endif
|
||||
# else
|
||||
# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */
|
||||
|
||||
# define IS_CHAR_CLASS(string) \
|
||||
(STREQ (string, "alpha") || STREQ (string, "upper") \
|
||||
|| STREQ (string, "lower") || STREQ (string, "digit") \
|
||||
|| STREQ (string, "alnum") || STREQ (string, "xdigit") \
|
||||
|| STREQ (string, "space") || STREQ (string, "print") \
|
||||
|| STREQ (string, "punct") || STREQ (string, "graph") \
|
||||
|| STREQ (string, "cntrl") || STREQ (string, "blank"))
|
||||
# endif
|
||||
|
||||
/* Avoid depending on library functions or files
|
||||
whose names are inconsistent. */
|
||||
|
||||
# if !defined _LIBC && !defined getenv
|
||||
extern char *getenv ();
|
||||
# endif
|
||||
|
||||
# ifndef errno
|
||||
extern int errno;
|
||||
# endif
|
||||
|
||||
/* This function doesn't exist on most systems. */
|
||||
|
||||
# if !defined HAVE___STRCHRNUL && !defined _LIBC
|
||||
static char *
|
||||
__strchrnul (s, c)
|
||||
const char *s;
|
||||
int c;
|
||||
{
|
||||
char *result = strchr (s, c);
|
||||
if (result == NULL)
|
||||
result = strchr (s, '\0');
|
||||
return result;
|
||||
}
|
||||
# endif
|
||||
|
||||
# ifndef internal_function
|
||||
/* Inside GNU libc we mark some function in a special way. In other
|
||||
environments simply ignore the marking. */
|
||||
# define internal_function
|
||||
# endif
|
||||
|
||||
/* Match STRING against the filename pattern PATTERN, returning zero if
|
||||
it matches, nonzero if not. */
|
||||
static int internal_fnmatch __P ((const char *pattern, const char *string,
|
||||
int no_leading_period, int flags))
|
||||
internal_function;
|
||||
static int
|
||||
internal_function
|
||||
internal_fnmatch (pattern, string, no_leading_period, flags)
|
||||
const char *pattern;
|
||||
const char *string;
|
||||
int no_leading_period;
|
||||
int flags;
|
||||
{
|
||||
register const char *p = pattern, *n = string;
|
||||
register unsigned char c;
|
||||
|
||||
/* Note that this evaluates C many times. */
|
||||
# ifdef _LIBC
|
||||
# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
|
||||
# else
|
||||
# define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c))
|
||||
# endif
|
||||
|
||||
while ((c = *p++) != '\0')
|
||||
{
|
||||
c = FOLD (c);
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case '?':
|
||||
if (*n == '\0')
|
||||
return FNM_NOMATCH;
|
||||
else if (*n == '/' && (flags & FNM_FILE_NAME))
|
||||
return FNM_NOMATCH;
|
||||
else if (*n == '.' && no_leading_period
|
||||
&& (n == string
|
||||
|| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
|
||||
return FNM_NOMATCH;
|
||||
break;
|
||||
|
||||
case '\\':
|
||||
if (!(flags & FNM_NOESCAPE))
|
||||
{
|
||||
c = *p++;
|
||||
if (c == '\0')
|
||||
/* Trailing \ loses. */
|
||||
return FNM_NOMATCH;
|
||||
c = FOLD (c);
|
||||
}
|
||||
if (FOLD ((unsigned char) *n) != c)
|
||||
return FNM_NOMATCH;
|
||||
break;
|
||||
|
||||
case '*':
|
||||
if (*n == '.' && no_leading_period
|
||||
&& (n == string
|
||||
|| (n[-1] == '/' && (flags & FNM_FILE_NAME))))
|
||||
return FNM_NOMATCH;
|
||||
|
||||
for (c = *p++; c == '?' || c == '*'; c = *p++)
|
||||
{
|
||||
if (*n == '/' && (flags & FNM_FILE_NAME))
|
||||
/* A slash does not match a wildcard under FNM_FILE_NAME. */
|
||||
return FNM_NOMATCH;
|
||||
else if (c == '?')
|
||||
{
|
||||
/* A ? needs to match one character. */
|
||||
if (*n == '\0')
|
||||
/* There isn't another character; no match. */
|
||||
return FNM_NOMATCH;
|
||||
else
|
||||
/* One character of the string is consumed in matching
|
||||
this ? wildcard, so *??? won't match if there are
|
||||
less than three characters. */
|
||||
++n;
|
||||
}
|
||||
}
|
||||
|
||||
if (c == '\0')
|
||||
/* The wildcard(s) is/are the last element of the pattern.
|
||||
If the name is a file name and contains another slash
|
||||
this does mean it cannot match. */
|
||||
return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL
|
||||
? FNM_NOMATCH : 0);
|
||||
else
|
||||
{
|
||||
const char *endp;
|
||||
|
||||
endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0');
|
||||
|
||||
if (c == '[')
|
||||
{
|
||||
int flags2 = ((flags & FNM_FILE_NAME)
|
||||
? flags : (flags & ~FNM_PERIOD));
|
||||
|
||||
for (--p; n < endp; ++n)
|
||||
if (internal_fnmatch (p, n,
|
||||
(no_leading_period
|
||||
&& (n == string
|
||||
|| (n[-1] == '/'
|
||||
&& (flags
|
||||
& FNM_FILE_NAME)))),
|
||||
flags2)
|
||||
== 0)
|
||||
return 0;
|
||||
}
|
||||
else if (c == '/' && (flags & FNM_FILE_NAME))
|
||||
{
|
||||
while (*n != '\0' && *n != '/')
|
||||
++n;
|
||||
if (*n == '/'
|
||||
&& (internal_fnmatch (p, n + 1, flags & FNM_PERIOD,
|
||||
flags) == 0))
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
int flags2 = ((flags & FNM_FILE_NAME)
|
||||
? flags : (flags & ~FNM_PERIOD));
|
||||
|
||||
if (c == '\\' && !(flags & FNM_NOESCAPE))
|
||||
c = *p;
|
||||
c = FOLD (c);
|
||||
for (--p; n < endp; ++n)
|
||||
if (FOLD ((unsigned char) *n) == c
|
||||
&& (internal_fnmatch (p, n,
|
||||
(no_leading_period
|
||||
&& (n == string
|
||||
|| (n[-1] == '/'
|
||||
&& (flags
|
||||
& FNM_FILE_NAME)))),
|
||||
flags2) == 0))
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* If we come here no match is possible with the wildcard. */
|
||||
return FNM_NOMATCH;
|
||||
|
||||
case '[':
|
||||
{
|
||||
/* Nonzero if the sense of the character class is inverted. */
|
||||
static int posixly_correct;
|
||||
register int not;
|
||||
char cold;
|
||||
|
||||
if (posixly_correct == 0)
|
||||
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
|
||||
|
||||
if (*n == '\0')
|
||||
return FNM_NOMATCH;
|
||||
|
||||
if (*n == '.' && no_leading_period && (n == string
|
||||
|| (n[-1] == '/'
|
||||
&& (flags
|
||||
& FNM_FILE_NAME))))
|
||||
return FNM_NOMATCH;
|
||||
|
||||
if (*n == '/' && (flags & FNM_FILE_NAME))
|
||||
/* `/' cannot be matched. */
|
||||
return FNM_NOMATCH;
|
||||
|
||||
not = (*p == '!' || (posixly_correct < 0 && *p == '^'));
|
||||
if (not)
|
||||
++p;
|
||||
|
||||
c = *p++;
|
||||
for (;;)
|
||||
{
|
||||
unsigned char fn = FOLD ((unsigned char) *n);
|
||||
|
||||
if (!(flags & FNM_NOESCAPE) && c == '\\')
|
||||
{
|
||||
if (*p == '\0')
|
||||
return FNM_NOMATCH;
|
||||
c = FOLD ((unsigned char) *p);
|
||||
++p;
|
||||
|
||||
if (c == fn)
|
||||
goto matched;
|
||||
}
|
||||
else if (c == '[' && *p == ':')
|
||||
{
|
||||
/* Leave room for the null. */
|
||||
char str[CHAR_CLASS_MAX_LENGTH + 1];
|
||||
size_t c1 = 0;
|
||||
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
|
||||
wctype_t wt;
|
||||
# endif
|
||||
const char *startp = p;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (c1 == CHAR_CLASS_MAX_LENGTH)
|
||||
/* The name is too long and therefore the pattern
|
||||
is ill-formed. */
|
||||
return FNM_NOMATCH;
|
||||
|
||||
c = *++p;
|
||||
if (c == ':' && p[1] == ']')
|
||||
{
|
||||
p += 2;
|
||||
break;
|
||||
}
|
||||
if (c < 'a' || c >= 'z')
|
||||
{
|
||||
/* This cannot possibly be a character class name.
|
||||
Match it as a normal range. */
|
||||
p = startp;
|
||||
c = '[';
|
||||
goto normal_bracket;
|
||||
}
|
||||
str[c1++] = c;
|
||||
}
|
||||
str[c1] = '\0';
|
||||
|
||||
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
|
||||
wt = IS_CHAR_CLASS (str);
|
||||
if (wt == 0)
|
||||
/* Invalid character class name. */
|
||||
return FNM_NOMATCH;
|
||||
|
||||
if (__iswctype (__btowc ((unsigned char) *n), wt))
|
||||
goto matched;
|
||||
# else
|
||||
if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n))
|
||||
|| (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n))
|
||||
|| (STREQ (str, "blank") && ISBLANK ((unsigned char) *n))
|
||||
|| (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n))
|
||||
|| (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n))
|
||||
|| (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n))
|
||||
|| (STREQ (str, "lower") && ISLOWER ((unsigned char) *n))
|
||||
|| (STREQ (str, "print") && ISPRINT ((unsigned char) *n))
|
||||
|| (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n))
|
||||
|| (STREQ (str, "space") && ISSPACE ((unsigned char) *n))
|
||||
|| (STREQ (str, "upper") && ISUPPER ((unsigned char) *n))
|
||||
|| (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n)))
|
||||
goto matched;
|
||||
# endif
|
||||
}
|
||||
else if (c == '\0')
|
||||
/* [ (unterminated) loses. */
|
||||
return FNM_NOMATCH;
|
||||
else
|
||||
{
|
||||
normal_bracket:
|
||||
if (FOLD (c) == fn)
|
||||
goto matched;
|
||||
|
||||
cold = c;
|
||||
c = *p++;
|
||||
|
||||
if (c == '-' && *p != ']')
|
||||
{
|
||||
/* It is a range. */
|
||||
unsigned char cend = *p++;
|
||||
if (!(flags & FNM_NOESCAPE) && cend == '\\')
|
||||
cend = *p++;
|
||||
if (cend == '\0')
|
||||
return FNM_NOMATCH;
|
||||
|
||||
if (cold <= fn && fn <= FOLD (cend))
|
||||
goto matched;
|
||||
|
||||
c = *p++;
|
||||
}
|
||||
}
|
||||
|
||||
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 == '\\')
|
||||
{
|
||||
if (*p == '\0')
|
||||
return FNM_NOMATCH;
|
||||
/* XXX 1003.2d11 is unclear if this is right. */
|
||||
++p;
|
||||
}
|
||||
else if (c == '[' && *p == ':')
|
||||
{
|
||||
do
|
||||
if (*++p == '\0')
|
||||
return FNM_NOMATCH;
|
||||
while (*p != ':' || p[1] == ']');
|
||||
p += 2;
|
||||
c = *p;
|
||||
}
|
||||
}
|
||||
if (not)
|
||||
return FNM_NOMATCH;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
if (c != FOLD ((unsigned char) *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;
|
||||
|
||||
# undef FOLD
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
fnmatch (pattern, string, flags)
|
||||
const char *pattern;
|
||||
const char *string;
|
||||
int flags;
|
||||
{
|
||||
return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
|
||||
}
|
||||
|
||||
#endif /* _LIBC or not __GNU_LIBRARY__. */
|
||||
@@ -1,84 +0,0 @@
|
||||
/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C 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.
|
||||
|
||||
The GNU C 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA. */
|
||||
|
||||
#ifndef _FNMATCH_H
|
||||
#define _FNMATCH_H 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
|
||||
# if !defined __GLIBC__ || !defined __P
|
||||
# undef __P
|
||||
# define __P(protos) protos
|
||||
# endif
|
||||
#else /* Not C++ or ANSI C. */
|
||||
# undef __P
|
||||
# define __P(protos) ()
|
||||
/* 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. */
|
||||
|
||||
#ifndef const
|
||||
# if (defined __STDC__ && __STDC__) || defined __cplusplus || defined WINDOWS32
|
||||
# define __const const
|
||||
# else
|
||||
# define __const
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* We #undef these before defining them because some losing systems
|
||||
(HP-UX A.08.07 for example) define these in <unistd.h>. */
|
||||
#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
|
||||
|
||||
/* This value is returned if the implementation does not support
|
||||
`fnmatch'. Since this is not the case here it will never be
|
||||
returned but the conformance test suites still require the symbol
|
||||
to be defined. */
|
||||
#ifdef _XOPEN_SOURCE
|
||||
# define FNM_NOSYS (-1)
|
||||
#endif
|
||||
|
||||
/* Match NAME against the filename pattern PATTERN,
|
||||
returning zero if it matches, FNM_NOMATCH if not. */
|
||||
extern int fnmatch __P ((__const char *__pattern, __const char *__name,
|
||||
int __flags));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* fnmatch.h */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,209 +0,0 @@
|
||||
/* Copyright (C) 1991, 92, 95, 96, 97, 98 Free Software Foundation, Inc.
|
||||
|
||||
The GNU C 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.
|
||||
|
||||
The GNU C 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA. */
|
||||
|
||||
#ifndef _GLOB_H
|
||||
#define _GLOB_H 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#undef __ptr_t
|
||||
#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
|
||||
# if !defined __GLIBC__
|
||||
# undef __P
|
||||
# undef __PMT
|
||||
# define __P(protos) protos
|
||||
# define __PMT(protos) protos
|
||||
# if !defined __GNUC__ || __GNUC__ < 2
|
||||
# undef __const
|
||||
# define __const const
|
||||
# endif
|
||||
# endif
|
||||
# define __ptr_t void *
|
||||
#else /* Not C++ or ANSI C. */
|
||||
# undef __P
|
||||
# undef __PMT
|
||||
# define __P(protos) ()
|
||||
# define __PMT(protos) ()
|
||||
# undef __const
|
||||
# define __const
|
||||
# define __ptr_t char *
|
||||
#endif /* C++ or ANSI C. */
|
||||
|
||||
/* We need `size_t' for the following definitions. */
|
||||
#ifndef __size_t
|
||||
# if defined __FreeBSD__
|
||||
# define __size_t size_t
|
||||
# else
|
||||
# if defined __GNUC__ && __GNUC__ >= 2
|
||||
typedef __SIZE_TYPE__ __size_t;
|
||||
# else
|
||||
/* This is a guess. */
|
||||
/*hb
|
||||
* Conflicts with DECCs aready defined type __size_t.
|
||||
* Defining an own type with a name beginning with '__' is no good.
|
||||
* Anyway if DECC is used and __SIZE_T is defined then __size_t is
|
||||
* already defined (and I hope it's exactly the one we need here).
|
||||
*/
|
||||
# if !(defined __DECC && defined __SIZE_T)
|
||||
typedef unsigned long int __size_t;
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
/* The GNU CC stddef.h version defines __size_t as empty. We need a real
|
||||
definition. */
|
||||
# undef __size_t
|
||||
# define __size_t size_t
|
||||
#endif
|
||||
|
||||
/* 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. */
|
||||
|
||||
#if (!defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _BSD_SOURCE \
|
||||
|| defined _GNU_SOURCE)
|
||||
# define GLOB_MAGCHAR (1 << 8)/* Set in gl_flags if any metachars seen. */
|
||||
# define GLOB_ALTDIRFUNC (1 << 9)/* Use gl_opendir et al functions. */
|
||||
# define GLOB_BRACE (1 << 10)/* Expand "{a,b}" to "a" "b". */
|
||||
# define GLOB_NOMAGIC (1 << 11)/* If no magic chars, return the pattern. */
|
||||
# define GLOB_TILDE (1 << 12)/* Expand ~user and ~ to home directories. */
|
||||
# define GLOB_ONLYDIR (1 << 13)/* Match only directories. */
|
||||
# define GLOB_TILDE_CHECK (1 << 14)/* Like GLOB_TILDE but return an error
|
||||
if the user name is not available. */
|
||||
# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
|
||||
GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \
|
||||
GLOB_PERIOD|GLOB_ALTDIRFUNC|GLOB_BRACE| \
|
||||
GLOB_NOMAGIC|GLOB_TILDE|GLOB_ONLYDIR|GLOB_TILDE_CHECK)
|
||||
#else
|
||||
# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
|
||||
GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \
|
||||
GLOB_PERIOD)
|
||||
#endif
|
||||
|
||||
/* Error returns from `glob'. */
|
||||
#define GLOB_NOSPACE 1 /* Ran out of memory. */
|
||||
#define GLOB_ABORTED 2 /* Read error. */
|
||||
#define GLOB_NOMATCH 3 /* No matches found. */
|
||||
#define GLOB_NOSYS 4 /* Not implemented. */
|
||||
#ifdef _GNU_SOURCE
|
||||
/* Previous versions of this file defined GLOB_ABEND instead of
|
||||
GLOB_ABORTED. Provide a compatibility definition here. */
|
||||
# define GLOB_ABEND GLOB_ABORTED
|
||||
#endif
|
||||
|
||||
/* Structure describing a globbing run. */
|
||||
#if !defined _AMIGA && !defined VMS /* Buggy compiler. */
|
||||
struct stat;
|
||||
#endif
|
||||
typedef struct
|
||||
{
|
||||
__size_t gl_pathc; /* Count of paths matched by the pattern. */
|
||||
char **gl_pathv; /* List of matched pathnames. */
|
||||
__size_t gl_offs; /* Slots to reserve in `gl_pathv'. */
|
||||
int gl_flags; /* Set to FLAGS, maybe | GLOB_MAGCHAR. */
|
||||
|
||||
/* If the GLOB_ALTDIRFUNC flag is set, the following functions
|
||||
are used instead of the normal file access functions. */
|
||||
void (*gl_closedir) __PMT ((void *));
|
||||
struct dirent *(*gl_readdir) __PMT ((void *));
|
||||
__ptr_t (*gl_opendir) __PMT ((__const char *));
|
||||
int (*gl_lstat) __PMT ((__const char *, struct stat *));
|
||||
#if defined(VMS) && defined(__DECC) && !defined(_POSIX_C_SOURCE)
|
||||
int (*gl_stat) __PMT ((__const char *, struct stat *, ...));
|
||||
#else
|
||||
int (*gl_stat) __PMT ((__const char *, struct stat *));
|
||||
#endif
|
||||
} glob_t;
|
||||
|
||||
#ifdef _LARGEFILE64_SOURCE
|
||||
struct stat64;
|
||||
typedef struct
|
||||
{
|
||||
__size_t gl_pathc;
|
||||
char **gl_pathv;
|
||||
__size_t gl_offs;
|
||||
int gl_flags;
|
||||
|
||||
/* If the GLOB_ALTDIRFUNC flag is set, the following functions
|
||||
are used instead of the normal file access functions. */
|
||||
void (*gl_closedir) __PMT ((void *));
|
||||
struct dirent64 *(*gl_readdir) __PMT ((void *));
|
||||
__ptr_t (*gl_opendir) __PMT ((__const char *));
|
||||
int (*gl_lstat) __PMT ((__const char *, struct stat64 *));
|
||||
int (*gl_stat) __PMT ((__const char *, struct stat64 *));
|
||||
} glob64_t;
|
||||
#endif
|
||||
|
||||
#if _FILE_OFFSET_BITS == 64 && __GNUC__ < 2
|
||||
# define glob glob64
|
||||
# define globfree globfree64
|
||||
#else
|
||||
# ifdef _LARGEFILE64_SOURCE
|
||||
extern int glob64 __P ((__const char *__pattern, int __flags,
|
||||
int (*__errfunc) (__const char *, int),
|
||||
glob64_t *__pglob));
|
||||
|
||||
extern void globfree64 __P ((glob64_t *__pglob));
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* 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. */
|
||||
#if _FILE_OFFSET_BITS != 64 || __GNUC__ < 2
|
||||
extern int glob __P ((__const char *__pattern, int __flags,
|
||||
int (*__errfunc) (__const char *, int),
|
||||
glob_t *__pglob));
|
||||
|
||||
/* Free storage allocated in PGLOB by a previous `glob' call. */
|
||||
extern void globfree __P ((glob_t *__pglob));
|
||||
#else
|
||||
extern int glob __P ((__const char *__pattern, int __flags,
|
||||
int (*__errfunc) (__const char *, int),
|
||||
glob_t *__pglob)) __asm__ ("glob64");
|
||||
|
||||
extern void globfree __P ((glob_t *__pglob)) __asm__ ("globfree64");
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef _GNU_SOURCE
|
||||
/* Return nonzero if PATTERN contains any metacharacters.
|
||||
Metacharacters can be quoted with backslashes if QUOTE is nonzero.
|
||||
|
||||
This function is not part of the interface specified by POSIX.2
|
||||
but several programs want to use it. */
|
||||
extern int glob_pattern_p __P ((__const char *__pattern, int __quote));
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* glob.h */
|
||||
@@ -1,332 +0,0 @@
|
||||
/* hash.c -- hash table maintenance
|
||||
Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc.
|
||||
Written by Greg McGary <[email protected]> <[email protected]>
|
||||
|
||||
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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "hash.h"
|
||||
|
||||
#define CALLOC(t, n) ((t *) calloc (sizeof (t), (n)))
|
||||
#define MALLOC(t, n) ((t *) xmalloc (sizeof (t) * (n)))
|
||||
#define REALLOC(o, t, n) ((t *) xrealloc ((o), sizeof (t) * (n)))
|
||||
#define CLONE(o, t, n) ((t *) memcpy (MALLOC (t, (n)), (o), sizeof (t) * (n)))
|
||||
|
||||
static void hash_rehash __P((struct hash_table* ht));
|
||||
static unsigned long round_up_2 __P((unsigned long rough));
|
||||
|
||||
/* Implement double hashing with open addressing. The table size is
|
||||
always a power of two. The secondary (`increment') hash function
|
||||
is forced to return an odd-value, in order to be relatively prime
|
||||
to the table size. This guarantees that the increment can
|
||||
potentially hit every slot in the table during collision
|
||||
resolution. */
|
||||
|
||||
void *hash_deleted_item = &hash_deleted_item;
|
||||
|
||||
/* Force the table size to be a power of two, possibly rounding up the
|
||||
given size. */
|
||||
|
||||
void
|
||||
hash_init (struct hash_table *ht, unsigned long size,
|
||||
hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp)
|
||||
{
|
||||
ht->ht_size = round_up_2 (size);
|
||||
ht->ht_empty_slots = ht->ht_size;
|
||||
ht->ht_vec = (void**) CALLOC (struct token *, ht->ht_size);
|
||||
if (ht->ht_vec == 0)
|
||||
{
|
||||
fprintf (stderr, _("can't allocate %ld bytes for hash table: memory exhausted"),
|
||||
ht->ht_size * sizeof(struct token *));
|
||||
exit (1);
|
||||
}
|
||||
|
||||
ht->ht_capacity = ht->ht_size - (ht->ht_size / 16); /* 93.75% loading factor */
|
||||
ht->ht_fill = 0;
|
||||
ht->ht_collisions = 0;
|
||||
ht->ht_lookups = 0;
|
||||
ht->ht_rehashes = 0;
|
||||
ht->ht_hash_1 = hash_1;
|
||||
ht->ht_hash_2 = hash_2;
|
||||
ht->ht_compare = hash_cmp;
|
||||
}
|
||||
|
||||
/* Load an array of items into `ht'. */
|
||||
|
||||
void
|
||||
hash_load (struct hash_table *ht, void *item_table,
|
||||
unsigned long cardinality, unsigned long size)
|
||||
{
|
||||
char *items = (char *) item_table;
|
||||
while (cardinality--)
|
||||
{
|
||||
hash_insert (ht, items);
|
||||
items += size;
|
||||
}
|
||||
}
|
||||
|
||||
/* Returns the address of the table slot matching `key'. If `key' is
|
||||
not found, return the address of an empty slot suitable for
|
||||
inserting `key'. The caller is responsible for incrementing
|
||||
ht_fill on insertion. */
|
||||
|
||||
void **
|
||||
hash_find_slot (struct hash_table *ht, const void *key)
|
||||
{
|
||||
void **slot;
|
||||
void **deleted_slot = 0;
|
||||
unsigned int hash_2 = 0;
|
||||
unsigned int hash_1 = (*ht->ht_hash_1) (key);
|
||||
|
||||
ht->ht_lookups++;
|
||||
for (;;)
|
||||
{
|
||||
hash_1 &= (ht->ht_size - 1);
|
||||
slot = &ht->ht_vec[hash_1];
|
||||
|
||||
if (*slot == 0)
|
||||
return (deleted_slot ? deleted_slot : slot);
|
||||
if (*slot == hash_deleted_item)
|
||||
{
|
||||
if (deleted_slot == 0)
|
||||
deleted_slot = slot;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (key == *slot)
|
||||
return slot;
|
||||
if ((*ht->ht_compare) (key, *slot) == 0)
|
||||
return slot;
|
||||
ht->ht_collisions++;
|
||||
}
|
||||
if (!hash_2)
|
||||
hash_2 = (*ht->ht_hash_2) (key) | 1;
|
||||
hash_1 += hash_2;
|
||||
}
|
||||
}
|
||||
|
||||
void *
|
||||
hash_find_item (struct hash_table *ht, const void *key)
|
||||
{
|
||||
void **slot = hash_find_slot (ht, key);
|
||||
return ((HASH_VACANT (*slot)) ? 0 : *slot);
|
||||
}
|
||||
|
||||
void *
|
||||
hash_insert (struct hash_table *ht, const void *item)
|
||||
{
|
||||
void **slot = hash_find_slot (ht, item);
|
||||
const void *old_item = slot ? *slot : 0;
|
||||
hash_insert_at (ht, item, slot);
|
||||
return (void *)((HASH_VACANT (old_item)) ? 0 : old_item);
|
||||
}
|
||||
|
||||
void *
|
||||
hash_insert_at (struct hash_table *ht, const void *item, const void *slot)
|
||||
{
|
||||
const void *old_item = *(void **) slot;
|
||||
if (HASH_VACANT (old_item))
|
||||
{
|
||||
ht->ht_fill++;
|
||||
if (old_item == 0)
|
||||
ht->ht_empty_slots--;
|
||||
old_item = item;
|
||||
}
|
||||
*(void const **) slot = item;
|
||||
if (ht->ht_empty_slots < ht->ht_size - ht->ht_capacity)
|
||||
{
|
||||
hash_rehash (ht);
|
||||
return (void *) hash_find_slot (ht, item);
|
||||
}
|
||||
else
|
||||
return (void *) slot;
|
||||
}
|
||||
|
||||
void *
|
||||
hash_delete (struct hash_table *ht, const void *item)
|
||||
{
|
||||
void **slot = hash_find_slot (ht, item);
|
||||
return hash_delete_at (ht, slot);
|
||||
}
|
||||
|
||||
void *
|
||||
hash_delete_at (struct hash_table *ht, const void *slot)
|
||||
{
|
||||
void *item = *(void **) slot;
|
||||
if (!HASH_VACANT (item))
|
||||
{
|
||||
*(void const **) slot = hash_deleted_item;
|
||||
ht->ht_fill--;
|
||||
return item;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
hash_free_items (struct hash_table *ht)
|
||||
{
|
||||
void **vec = ht->ht_vec;
|
||||
void **end = &vec[ht->ht_size];
|
||||
for (; vec < end; vec++)
|
||||
{
|
||||
void *item = *vec;
|
||||
if (!HASH_VACANT (item))
|
||||
free (item);
|
||||
*vec = 0;
|
||||
}
|
||||
ht->ht_fill = 0;
|
||||
ht->ht_empty_slots = ht->ht_size;
|
||||
}
|
||||
|
||||
void
|
||||
hash_delete_items (struct hash_table *ht)
|
||||
{
|
||||
void **vec = ht->ht_vec;
|
||||
void **end = &vec[ht->ht_size];
|
||||
for (; vec < end; vec++)
|
||||
*vec = 0;
|
||||
ht->ht_fill = 0;
|
||||
ht->ht_collisions = 0;
|
||||
ht->ht_lookups = 0;
|
||||
ht->ht_rehashes = 0;
|
||||
ht->ht_empty_slots = ht->ht_size;
|
||||
}
|
||||
|
||||
void
|
||||
hash_free (struct hash_table *ht, int free_items)
|
||||
{
|
||||
if (free_items)
|
||||
hash_free_items (ht);
|
||||
else
|
||||
{
|
||||
ht->ht_fill = 0;
|
||||
ht->ht_empty_slots = ht->ht_size;
|
||||
}
|
||||
free (ht->ht_vec);
|
||||
ht->ht_vec = 0;
|
||||
ht->ht_capacity = 0;
|
||||
}
|
||||
|
||||
void
|
||||
hash_map (struct hash_table *ht, hash_map_func_t map)
|
||||
{
|
||||
void **slot;
|
||||
void **end = &ht->ht_vec[ht->ht_size];
|
||||
|
||||
for (slot = ht->ht_vec; slot < end; slot++)
|
||||
{
|
||||
if (!HASH_VACANT (*slot))
|
||||
(*map) (*slot);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
hash_map_arg (struct hash_table *ht, hash_map_arg_func_t map, void *arg)
|
||||
{
|
||||
void **slot;
|
||||
void **end = &ht->ht_vec[ht->ht_size];
|
||||
|
||||
for (slot = ht->ht_vec; slot < end; slot++)
|
||||
{
|
||||
if (!HASH_VACANT (*slot))
|
||||
(*map) (*slot, arg);
|
||||
}
|
||||
}
|
||||
|
||||
/* Double the size of the hash table in the event of overflow... */
|
||||
|
||||
static void
|
||||
hash_rehash (struct hash_table *ht)
|
||||
{
|
||||
unsigned long old_ht_size = ht->ht_size;
|
||||
void **old_vec = ht->ht_vec;
|
||||
void **ovp;
|
||||
|
||||
if (ht->ht_fill >= ht->ht_capacity)
|
||||
{
|
||||
ht->ht_size *= 2;
|
||||
ht->ht_capacity = ht->ht_size - (ht->ht_size >> 4);
|
||||
}
|
||||
ht->ht_rehashes++;
|
||||
ht->ht_vec = (void **) CALLOC (struct token *, ht->ht_size);
|
||||
|
||||
for (ovp = old_vec; ovp < &old_vec[old_ht_size]; ovp++)
|
||||
{
|
||||
if (! HASH_VACANT (*ovp))
|
||||
{
|
||||
void **slot = hash_find_slot (ht, *ovp);
|
||||
*slot = *ovp;
|
||||
}
|
||||
}
|
||||
ht->ht_empty_slots = ht->ht_size - ht->ht_fill;
|
||||
free (old_vec);
|
||||
}
|
||||
|
||||
void
|
||||
hash_print_stats (struct hash_table *ht, FILE *out_FILE)
|
||||
{
|
||||
/* GKM FIXME: honor NO_FLOAT */
|
||||
fprintf (out_FILE, _("Load=%ld/%ld=%.0f%%, "), ht->ht_fill, ht->ht_size,
|
||||
100.0 * (double) ht->ht_fill / (double) ht->ht_size);
|
||||
fprintf (out_FILE, _("Rehash=%d, "), ht->ht_rehashes);
|
||||
fprintf (out_FILE, _("Collisions=%ld/%ld=%.0f%%"), ht->ht_collisions, ht->ht_lookups,
|
||||
(ht->ht_lookups
|
||||
? (100.0 * (double) ht->ht_collisions / (double) ht->ht_lookups)
|
||||
: 0));
|
||||
}
|
||||
|
||||
/* Dump all items into a NULL-terminated vector. Use the
|
||||
user-supplied vector, or malloc one. */
|
||||
|
||||
void **
|
||||
hash_dump (struct hash_table *ht, void **vector_0, qsort_cmp_t compare)
|
||||
{
|
||||
void **vector;
|
||||
void **slot;
|
||||
void **end = &ht->ht_vec[ht->ht_size];
|
||||
|
||||
if (vector_0 == 0)
|
||||
vector_0 = MALLOC (void *, ht->ht_fill + 1);
|
||||
vector = vector_0;
|
||||
|
||||
for (slot = ht->ht_vec; slot < end; slot++)
|
||||
if (!HASH_VACANT (*slot))
|
||||
*vector++ = *slot;
|
||||
*vector = 0;
|
||||
|
||||
if (compare)
|
||||
qsort (vector_0, ht->ht_fill, sizeof (void *), compare);
|
||||
return vector_0;
|
||||
}
|
||||
|
||||
/* Round a given number up to the nearest power of 2. */
|
||||
|
||||
static unsigned long
|
||||
round_up_2 (unsigned long n)
|
||||
{
|
||||
n |= (n >> 1);
|
||||
n |= (n >> 2);
|
||||
n |= (n >> 4);
|
||||
n |= (n >> 8);
|
||||
n |= (n >> 16);
|
||||
|
||||
#if !defined(HAVE_LIMITS_H) || ULONG_MAX > 4294967295
|
||||
/* We only need this on systems where unsigned long is >32 bits. */
|
||||
n |= (n >> 32);
|
||||
#endif
|
||||
|
||||
return n + 1;
|
||||
}
|
||||
@@ -1,233 +0,0 @@
|
||||
/* hash.h -- decls for hash table
|
||||
Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc.
|
||||
Written by Greg McGary <[email protected]> <[email protected]>
|
||||
|
||||
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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#ifndef _hash_h_
|
||||
#define _hash_h_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
|
||||
# if !defined __GLIBC__ || !defined __P
|
||||
# undef __P
|
||||
# define __P(protos) protos
|
||||
# endif
|
||||
#else /* Not C++ or ANSI C. */
|
||||
# undef __P
|
||||
# define __P(protos) ()
|
||||
/* 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. */
|
||||
|
||||
typedef unsigned long (*hash_func_t) __P((void const *key));
|
||||
typedef int (*hash_cmp_func_t) __P((void const *x, void const *y));
|
||||
typedef void (*hash_map_func_t) __P((void const *item));
|
||||
typedef void (*hash_map_arg_func_t) __P((void const *item, void *arg));
|
||||
|
||||
struct hash_table
|
||||
{
|
||||
void **ht_vec;
|
||||
unsigned long ht_size; /* total number of slots (power of 2) */
|
||||
unsigned long ht_capacity; /* usable slots, limited by loading-factor */
|
||||
unsigned long ht_fill; /* items in table */
|
||||
unsigned long ht_empty_slots; /* empty slots not including deleted slots */
|
||||
unsigned long ht_collisions; /* # of failed calls to comparison function */
|
||||
unsigned long ht_lookups; /* # of queries */
|
||||
unsigned int ht_rehashes; /* # of times we've expanded table */
|
||||
hash_func_t ht_hash_1; /* primary hash function */
|
||||
hash_func_t ht_hash_2; /* secondary hash function */
|
||||
hash_cmp_func_t ht_compare; /* comparison function */
|
||||
};
|
||||
|
||||
typedef int (*qsort_cmp_t) __P((void const *, void const *));
|
||||
|
||||
void hash_init __P((struct hash_table *ht, unsigned long size,
|
||||
hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp));
|
||||
void hash_load __P((struct hash_table *ht, void *item_table,
|
||||
unsigned long cardinality, unsigned long size));
|
||||
void **hash_find_slot __P((struct hash_table *ht, void const *key));
|
||||
void *hash_find_item __P((struct hash_table *ht, void const *key));
|
||||
void *hash_insert __P((struct hash_table *ht, const void *item));
|
||||
void *hash_insert_at __P((struct hash_table *ht, const void *item, void const *slot));
|
||||
void *hash_delete __P((struct hash_table *ht, void const *item));
|
||||
void *hash_delete_at __P((struct hash_table *ht, void const *slot));
|
||||
void hash_delete_items __P((struct hash_table *ht));
|
||||
void hash_free_items __P((struct hash_table *ht));
|
||||
void hash_free __P((struct hash_table *ht, int free_items));
|
||||
void hash_map __P((struct hash_table *ht, hash_map_func_t map));
|
||||
void hash_map_arg __P((struct hash_table *ht, hash_map_arg_func_t map, void *arg));
|
||||
void hash_print_stats __P((struct hash_table *ht, FILE *out_FILE));
|
||||
void **hash_dump __P((struct hash_table *ht, void **vector_0, qsort_cmp_t compare));
|
||||
|
||||
extern void *hash_deleted_item;
|
||||
#define HASH_VACANT(item) ((item) == 0 || (void *) (item) == hash_deleted_item)
|
||||
|
||||
|
||||
/* hash and comparison macros for case-sensitive string keys. */
|
||||
|
||||
#define STRING_HASH_1(KEY, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
while (*++_key_) \
|
||||
(RESULT) += (*_key_ << (_key_[1] & 0xf)); \
|
||||
} while (0)
|
||||
#define return_STRING_HASH_1(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
STRING_HASH_1 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define STRING_HASH_2(KEY, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
while (*++_key_) \
|
||||
(RESULT) += (*_key_ << (_key_[1] & 0x7)); \
|
||||
} while (0)
|
||||
#define return_STRING_HASH_2(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
STRING_HASH_2 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define STRING_COMPARE(X, Y, RESULT) do { \
|
||||
RESULT = strcmp ((X), (Y)); \
|
||||
} while (0)
|
||||
#define return_STRING_COMPARE(X, Y) do { \
|
||||
return strcmp ((X), (Y)); \
|
||||
} while (0)
|
||||
|
||||
|
||||
#define STRING_N_HASH_1(KEY, N, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
int _n_ = (N); \
|
||||
if (_n_) \
|
||||
while (--_n_ && *++_key_) \
|
||||
(RESULT) += (*_key_ << (_key_[1] & 0xf)); \
|
||||
(RESULT) += *++_key_; \
|
||||
} while (0)
|
||||
#define return_STRING_N_HASH_1(KEY, N) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
STRING_N_HASH_1 ((KEY), (N), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define STRING_N_HASH_2(KEY, N, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
int _n_ = (N); \
|
||||
if (_n_) \
|
||||
while (--_n_ && *++_key_) \
|
||||
(RESULT) += (*_key_ << (_key_[1] & 0x7)); \
|
||||
(RESULT) += *++_key_; \
|
||||
} while (0)
|
||||
#define return_STRING_N_HASH_2(KEY, N) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
STRING_N_HASH_2 ((KEY), (N), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define STRING_N_COMPARE(X, Y, N, RESULT) do { \
|
||||
RESULT = strncmp ((X), (Y), (N)); \
|
||||
} while (0)
|
||||
#define return_STRING_N_COMPARE(X, Y, N) do { \
|
||||
return strncmp ((X), (Y), (N)); \
|
||||
} while (0)
|
||||
|
||||
#ifdef HAVE_CASE_INSENSITIVE_FS
|
||||
|
||||
/* hash and comparison macros for case-insensitive string _key_s. */
|
||||
|
||||
#define ISTRING_HASH_1(KEY, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
while (*++_key_) \
|
||||
(RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0xf)); \
|
||||
} while (0)
|
||||
#define return_ISTRING_HASH_1(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
ISTRING_HASH_1 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define ISTRING_HASH_2(KEY, RESULT) do { \
|
||||
unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
|
||||
while (*++_key_) \
|
||||
(RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0x7)); \
|
||||
} while (0)
|
||||
#define return_ISTRING_HASH_2(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
ISTRING_HASH_2 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define ISTRING_COMPARE(X, Y, RESULT) do { \
|
||||
RESULT = strcmpi ((X), (Y)); \
|
||||
} while (0)
|
||||
#define return_ISTRING_COMPARE(X, Y) do { \
|
||||
return strcmpi ((X), (Y)); \
|
||||
} while (0)
|
||||
|
||||
#else
|
||||
|
||||
#define ISTRING_HASH_1(KEY, RESULT) STRING_HASH_1 ((KEY), (RESULT))
|
||||
#define return_ISTRING_HASH_1(KEY) return_STRING_HASH_1 (KEY)
|
||||
|
||||
#define ISTRING_HASH_2(KEY, RESULT) STRING_HASH_2 ((KEY), (RESULT))
|
||||
#define return_ISTRING_HASH_2(KEY) return_STRING_HASH_2 (KEY)
|
||||
|
||||
#define ISTRING_COMPARE(X, Y, RESULT) STRING_COMPARE ((X), (Y), (RESULT))
|
||||
#define return_ISTRING_COMPARE(X, Y) return_STRING_COMPARE ((X), (Y))
|
||||
|
||||
#endif
|
||||
|
||||
/* hash and comparison macros for integer _key_s. */
|
||||
|
||||
#define INTEGER_HASH_1(KEY, RESULT) do { \
|
||||
(RESULT) += ((unsigned long)(KEY)); \
|
||||
} while (0)
|
||||
#define return_INTEGER_HASH_1(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
INTEGER_HASH_1 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define INTEGER_HASH_2(KEY, RESULT) do { \
|
||||
(RESULT) += ~((unsigned long)(KEY)); \
|
||||
} while (0)
|
||||
#define return_INTEGER_HASH_2(KEY) do { \
|
||||
unsigned long _result_ = 0; \
|
||||
INTEGER_HASH_2 ((KEY), _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
#define INTEGER_COMPARE(X, Y, RESULT) do { \
|
||||
(RESULT) = X - Y; \
|
||||
} while (0)
|
||||
#define return_INTEGER_COMPARE(X, Y) do { \
|
||||
int _result_; \
|
||||
INTEGER_COMPARE (X, Y, _result_); \
|
||||
return _result_; \
|
||||
} while (0)
|
||||
|
||||
/* hash and comparison macros for address keys. */
|
||||
|
||||
#define ADDRESS_HASH_1(KEY, RESULT) INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3, (RESULT))
|
||||
#define ADDRESS_HASH_2(KEY, RESULT) INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3, (RESULT))
|
||||
#define ADDRESS_COMPARE(X, Y, RESULT) INTEGER_COMPARE ((X), (Y), (RESULT))
|
||||
#define return_ADDRESS_HASH_1(KEY) return_INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3)
|
||||
#define return_ADDRESS_HASH_2(KEY) return_INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3)
|
||||
#define return_ADDRESS_COMPARE(X, Y) return_INTEGER_COMPARE ((X), (Y))
|
||||
|
||||
#endif /* not _hash_h_ */
|
||||
@@ -1,982 +0,0 @@
|
||||
/* Implicit rule searching for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "filedef.h"
|
||||
#include "rule.h"
|
||||
#include "dep.h"
|
||||
#include "debug.h"
|
||||
#include "variable.h"
|
||||
#include "job.h" /* struct child, used inside commands.h */
|
||||
#include "commands.h" /* set_file_variables */
|
||||
|
||||
static int
|
||||
pattern_search PARAMS ((struct file *file, int archive,
|
||||
unsigned int depth, unsigned int recursions));
|
||||
|
||||
/* 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 (struct file *file, unsigned int depth)
|
||||
{
|
||||
DBF (DB_IMPLICIT, _("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))
|
||||
{
|
||||
DBF (DB_IMPLICIT,
|
||||
_("Looking for archive-member implicit rule for `%s'.\n"));
|
||||
if (pattern_search (file, 1, depth, 0))
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Struct idep captures information about implicit prerequisites
|
||||
that come from implicit rules. */
|
||||
struct idep
|
||||
{
|
||||
struct idep *next; /* struct dep -compatible interface */
|
||||
char *name; /* name of the prerequisite */
|
||||
struct file *intermediate_file; /* intermediate file, 0 otherwise */
|
||||
char *intermediate_pattern; /* pattern for intermediate file */
|
||||
unsigned char had_stem; /* had % substituted with stem */
|
||||
unsigned char ignore_mtime; /* ignore_mtime flag */
|
||||
};
|
||||
|
||||
static void
|
||||
free_idep_chain (struct idep *p)
|
||||
{
|
||||
struct idep *n;
|
||||
|
||||
for (; p != 0; p = n)
|
||||
{
|
||||
n = p->next;
|
||||
|
||||
if (p->name)
|
||||
{
|
||||
struct file *f = p->intermediate_file;
|
||||
|
||||
if (f != 0
|
||||
&& (f->stem < f->name || f->stem > f->name + strlen (f->name)))
|
||||
free (f->stem);
|
||||
|
||||
free (p->name);
|
||||
}
|
||||
|
||||
free (p);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Scans the BUFFER for the next word with whitespace as a separator.
|
||||
Returns the pointer to the beginning of the word. LENGTH hold the
|
||||
length of the word. */
|
||||
|
||||
static char *
|
||||
get_next_word (char *buffer, unsigned int *length)
|
||||
{
|
||||
char *p = buffer, *beg;
|
||||
char c;
|
||||
|
||||
/* Skip any leading whitespace. */
|
||||
while (isblank ((unsigned char)*p))
|
||||
++p;
|
||||
|
||||
beg = p;
|
||||
c = *(p++);
|
||||
|
||||
if (c == '\0')
|
||||
return 0;
|
||||
|
||||
|
||||
/* We already found the first value of "c", above. */
|
||||
while (1)
|
||||
{
|
||||
char closeparen;
|
||||
int count;
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case '\0':
|
||||
case ' ':
|
||||
case '\t':
|
||||
goto done_word;
|
||||
|
||||
case '$':
|
||||
c = *(p++);
|
||||
if (c == '$')
|
||||
break;
|
||||
|
||||
/* This is a variable reference, so read it to the matching
|
||||
close paren. */
|
||||
|
||||
if (c == '(')
|
||||
closeparen = ')';
|
||||
else if (c == '{')
|
||||
closeparen = '}';
|
||||
else
|
||||
/* This is a single-letter variable reference. */
|
||||
break;
|
||||
|
||||
for (count = 0; *p != '\0'; ++p)
|
||||
{
|
||||
if (*p == c)
|
||||
++count;
|
||||
else if (*p == closeparen && --count < 0)
|
||||
{
|
||||
++p;
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case '|':
|
||||
goto done;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
c = *(p++);
|
||||
}
|
||||
done_word:
|
||||
--p;
|
||||
|
||||
done:
|
||||
if (length)
|
||||
*length = p - beg;
|
||||
|
||||
return beg;
|
||||
}
|
||||
|
||||
/* 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 (struct file *file, int archive,
|
||||
unsigned int depth, unsigned int recursions)
|
||||
{
|
||||
/* Filename we are searching for a rule for. */
|
||||
char *filename = archive ? strchr (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;
|
||||
|
||||
/* This linked list records all the prerequisites actually
|
||||
found for a rule along with some other useful information
|
||||
(see struct idep for details). */
|
||||
struct idep* deps = 0;
|
||||
|
||||
/* 1 if we need to remove explicit prerequisites, 0 otherwise. */
|
||||
unsigned int remove_explicit_deps = 0;
|
||||
|
||||
/* 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 = 0;
|
||||
register unsigned int stemlen = 0;
|
||||
register unsigned int fullstemlen = 0;
|
||||
|
||||
/* Buffer in which we store all the rules that are possibly applicable. */
|
||||
struct rule **tryrules
|
||||
= (struct rule **) xmalloc (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;
|
||||
|
||||
unsigned int i = 0; /* uninit checks OK */
|
||||
struct rule *rule;
|
||||
struct dep *dep, *expl_d;
|
||||
|
||||
char *p, *vname;
|
||||
|
||||
struct idep *d;
|
||||
struct idep **id_ptr;
|
||||
struct dep **d_ptr;
|
||||
|
||||
PATH_VAR (stem_str); /* @@ Need to get rid of stem, stemlen, etc. */
|
||||
|
||||
#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/.) */
|
||||
#ifdef VMS
|
||||
lastslash = strrchr (filename, ']');
|
||||
if (lastslash == 0)
|
||||
lastslash = strrchr (filename, ':');
|
||||
#else
|
||||
lastslash = strrchr (filename, '/');
|
||||
#ifdef HAVE_DOS_PATHS
|
||||
/* Handle backslashes (possibly mixed with forward slashes)
|
||||
and the case of "d:file". */
|
||||
{
|
||||
char *bslash = strrchr (filename, '\\');
|
||||
if (lastslash == 0 || bslash > lastslash)
|
||||
lastslash = bslash;
|
||||
if (lastslash == 0 && filename[0] && filename[1] == ':')
|
||||
lastslash = filename + 1;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
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)
|
||||
{
|
||||
DBS (DB_IMPLICIT, (_("Avoiding implicit rule recursion.\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 = 0;
|
||||
if (lastslash)
|
||||
{
|
||||
#ifdef VMS
|
||||
check_lastslash = (strchr (target, ']') == 0
|
||||
&& strchr (target, ':') == 0);
|
||||
#else
|
||||
check_lastslash = strchr (target, '/') == 0;
|
||||
#ifdef HAVE_DOS_PATHS
|
||||
/* Didn't find it yet: check for DOS-type directories. */
|
||||
if (check_lastslash)
|
||||
{
|
||||
char *b = strchr (target, '\\');
|
||||
check_lastslash = !(b || (target[0] && target[1] == ':'));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
if (check_lastslash)
|
||||
{
|
||||
/* If so, 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)
|
||||
&& !strneq (target, lastslash + 1, stem - lastslash - 1))
|
||||
continue;
|
||||
}
|
||||
else if (stem > filename
|
||||
&& !strneq (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 non-"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;
|
||||
}
|
||||
|
||||
/* We are going to do second expansion so initialize file variables
|
||||
for the rule. */
|
||||
initialize_file_variables (file, 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, expand its dependencies (as substituted)
|
||||
and chain them in DEPS. */
|
||||
|
||||
for (i = 0; i < nrules; i++)
|
||||
{
|
||||
struct file *f;
|
||||
unsigned int failed = 0;
|
||||
int check_lastslash;
|
||||
int file_variables_set = 0;
|
||||
|
||||
rule = tryrules[i];
|
||||
|
||||
remove_explicit_deps = 0;
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
DBS (DB_IMPLICIT, (_("Trying pattern rule with stem `%.*s'.\n"),
|
||||
(int) stemlen, stem));
|
||||
|
||||
strncpy (stem_str, stem, stemlen);
|
||||
stem_str[stemlen] = '\0';
|
||||
|
||||
/* Temporary assign STEM to file->stem (needed to set file
|
||||
variables below). */
|
||||
file->stem = stem_str;
|
||||
|
||||
/* Try each dependency; see if it "exists". */
|
||||
|
||||
for (dep = rule->deps; dep != 0; dep = dep->next)
|
||||
{
|
||||
unsigned int len;
|
||||
char *p2;
|
||||
unsigned int order_only = 0; /* Set if '|' was seen. */
|
||||
|
||||
/* In an ideal world we would take the dependency line,
|
||||
substitute the stem, re-expand the whole line and chop it
|
||||
into individual prerequisites. Unfortunately this won't work
|
||||
because of the "check_lastslash" twist. Instead, we will
|
||||
have to go word by word, taking $()'s into account, for each
|
||||
word we will substitute the stem, re-expand, chop it up, and,
|
||||
if check_lastslash != 0, add the directory part to each
|
||||
resulting prerequisite. */
|
||||
|
||||
p = get_next_word (dep->name, &len);
|
||||
|
||||
while (1)
|
||||
{
|
||||
int add_dir = 0;
|
||||
int had_stem = 0;
|
||||
|
||||
if (p == 0)
|
||||
break; /* No more words */
|
||||
|
||||
/* Is there a pattern in this prerequisite? */
|
||||
|
||||
for (p2 = p; p2 < p + len && *p2 != '%'; ++p2)
|
||||
;
|
||||
|
||||
if (dep->need_2nd_expansion)
|
||||
{
|
||||
/* If the dependency name has %, substitute the stem.
|
||||
|
||||
Watch out, we are going to do something tricky
|
||||
here. If we just replace % with the stem value,
|
||||
later, when we do the second expansion, we will
|
||||
re-expand this stem value once again. This is not
|
||||
good especially if you have certain characters in
|
||||
your stem (like $).
|
||||
|
||||
Instead, we will replace % with $* and allow the
|
||||
second expansion to take care of it for us. This way
|
||||
(since $* is a simple variable) there won't be
|
||||
additional re-expansion of the stem. */
|
||||
|
||||
if (p2 < p + len)
|
||||
{
|
||||
register unsigned int i = p2 - p;
|
||||
bcopy (p, depname, i);
|
||||
bcopy ("$*", depname + i, 2);
|
||||
bcopy (p2 + 1, depname + i + 2, len - i - 1);
|
||||
depname[len + 2 - 1] = '\0';
|
||||
|
||||
if (check_lastslash)
|
||||
add_dir = 1;
|
||||
|
||||
had_stem = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
bcopy (p, depname, len);
|
||||
depname[len] = '\0';
|
||||
}
|
||||
|
||||
/* Set file variables. Note that we cannot do it once
|
||||
at the beginning of the function because of the stem
|
||||
value. */
|
||||
if (!file_variables_set)
|
||||
{
|
||||
set_file_variables (file);
|
||||
file_variables_set = 1;
|
||||
}
|
||||
|
||||
p2 = variable_expand_for_file (depname, file);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (p2 < p + len)
|
||||
{
|
||||
register unsigned int i = p2 - p;
|
||||
bcopy (p, depname, i);
|
||||
bcopy (stem_str, depname + i, stemlen);
|
||||
bcopy (p2 + 1, depname + i + stemlen, len - i - 1);
|
||||
depname[len + stemlen - 1] = '\0';
|
||||
|
||||
if (check_lastslash)
|
||||
add_dir = 1;
|
||||
|
||||
had_stem = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
bcopy (p, depname, len);
|
||||
depname[len] = '\0';
|
||||
}
|
||||
|
||||
p2 = depname;
|
||||
}
|
||||
|
||||
/* Parse the dependencies. */
|
||||
|
||||
while (1)
|
||||
{
|
||||
id_ptr = &deps;
|
||||
|
||||
for (; *id_ptr; id_ptr = &(*id_ptr)->next)
|
||||
;
|
||||
|
||||
*id_ptr = (struct idep *)
|
||||
multi_glob (
|
||||
parse_file_seq (&p2,
|
||||
order_only ? '\0' : '|',
|
||||
sizeof (struct idep),
|
||||
1), sizeof (struct idep));
|
||||
|
||||
/* @@ It would be nice to teach parse_file_seq or
|
||||
multi_glob to add prefix. This would save us some
|
||||
reallocations. */
|
||||
|
||||
if (order_only || add_dir || had_stem)
|
||||
{
|
||||
unsigned long l = lastslash - filename + 1;
|
||||
|
||||
for (d = *id_ptr; d != 0; d = d->next)
|
||||
{
|
||||
if (order_only)
|
||||
d->ignore_mtime = 1;
|
||||
|
||||
if (add_dir)
|
||||
{
|
||||
char *p = d->name;
|
||||
|
||||
d->name = xmalloc (strlen (p) + l + 1);
|
||||
|
||||
bcopy (filename, d->name, l);
|
||||
bcopy (p, d->name + l, strlen (p) + 1);
|
||||
|
||||
free (p);
|
||||
}
|
||||
|
||||
if (had_stem)
|
||||
d->had_stem = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!order_only && *p2)
|
||||
{
|
||||
++p2;
|
||||
order_only = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
p += len;
|
||||
p = get_next_word (p, &len);
|
||||
}
|
||||
}
|
||||
|
||||
/* Reset the stem in FILE. */
|
||||
|
||||
file->stem = 0;
|
||||
|
||||
/* @@ This loop can be combined with the previous one. I do
|
||||
it separately for now for transparency.*/
|
||||
|
||||
for (d = deps; d != 0; d = d->next)
|
||||
{
|
||||
char *name = d->name;
|
||||
|
||||
if (file_impossible_p (name))
|
||||
{
|
||||
/* 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. */
|
||||
DBS (DB_IMPLICIT,
|
||||
(d->had_stem
|
||||
? _("Rejecting impossible implicit prerequisite `%s'.\n")
|
||||
: _("Rejecting impossible rule prerequisite `%s'.\n"),
|
||||
name));
|
||||
tryrules[i] = 0;
|
||||
|
||||
failed = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
DBS (DB_IMPLICIT,
|
||||
(d->had_stem
|
||||
? _("Trying implicit prerequisite `%s'.\n")
|
||||
: _("Trying rule prerequisite `%s'.\n"), name));
|
||||
|
||||
/* If this prerequisite also happened to be explicitly mentioned
|
||||
for FILE skip all the test below since it it has to be built
|
||||
anyway, no matter which implicit rule we choose. */
|
||||
|
||||
for (expl_d = file->deps; expl_d != 0; expl_d = expl_d->next)
|
||||
if (streq (dep_name (expl_d), name))
|
||||
break;
|
||||
if (expl_d != 0)
|
||||
continue;
|
||||
|
||||
/* 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. */
|
||||
|
||||
/* @@ dep->changed check is disabled. */
|
||||
if (((f = lookup_file (name)) != 0 && f->is_target)
|
||||
/*|| ((!dep->changed || check_lastslash) && */
|
||||
|| file_exists_p (name))
|
||||
continue;
|
||||
|
||||
/* This code, given FILENAME = "lib/foo.o", dependency name
|
||||
"lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */
|
||||
vname = name;
|
||||
if (vpath_search (&vname, (FILE_TIMESTAMP *) 0))
|
||||
{
|
||||
DBS (DB_IMPLICIT,
|
||||
(_("Found prerequisite `%s' as VPATH `%s'\n"),
|
||||
name,
|
||||
vname));
|
||||
|
||||
free (vname);
|
||||
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));
|
||||
|
||||
DBS (DB_IMPLICIT,
|
||||
(_("Looking for a rule with intermediate file `%s'.\n"),
|
||||
name));
|
||||
|
||||
bzero ((char *) intermediate_file, sizeof (struct file));
|
||||
intermediate_file->name = name;
|
||||
if (pattern_search (intermediate_file,
|
||||
0,
|
||||
depth + 1,
|
||||
recursions + 1))
|
||||
{
|
||||
d->intermediate_file = intermediate_file;
|
||||
d->intermediate_pattern = intermediate_file->name;
|
||||
|
||||
intermediate_file->name = xstrdup (name);
|
||||
intermediate_file = 0;
|
||||
|
||||
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. */
|
||||
if (intermediate_file->variables)
|
||||
free_variable_set (intermediate_file->variables);
|
||||
file_impossible (name);
|
||||
}
|
||||
|
||||
/* A dependency of this rule does not exist. Therefore,
|
||||
this rule fails. */
|
||||
failed = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* This rule is no longer `in use' for recursive searches. */
|
||||
rule->in_use = 0;
|
||||
|
||||
if (failed)
|
||||
{
|
||||
/* This pattern rule does not apply. If some of its
|
||||
dependencies succeeded, free the data structure
|
||||
describing them. */
|
||||
free_idep_chain (deps);
|
||||
deps = 0;
|
||||
}
|
||||
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)
|
||||
goto done;
|
||||
|
||||
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. */
|
||||
|
||||
if (remove_explicit_deps)
|
||||
{
|
||||
/* Remove all the dependencies that didn't come from
|
||||
this implicit rule. */
|
||||
|
||||
dep = file->deps;
|
||||
while (dep != 0)
|
||||
{
|
||||
struct dep *next = dep->next;
|
||||
free_dep (dep);
|
||||
dep = next;
|
||||
}
|
||||
file->deps = 0;
|
||||
}
|
||||
|
||||
expl_d = file->deps; /* We will add them at the end. */
|
||||
d_ptr = &file->deps;
|
||||
|
||||
for (d = deps; d != 0; d = d->next)
|
||||
{
|
||||
register char *s;
|
||||
|
||||
if (d->intermediate_file != 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 = d->intermediate_file;
|
||||
register struct file *f = lookup_file (imf->name);
|
||||
|
||||
/* We don't want to delete an intermediate file that happened
|
||||
to be a prerequisite of some (other) target. Mark it as
|
||||
precious. */
|
||||
if (f != 0)
|
||||
f->precious = 1;
|
||||
else
|
||||
f = enter_file (imf->name);
|
||||
|
||||
f->deps = imf->deps;
|
||||
f->cmds = imf->cmds;
|
||||
f->stem = imf->stem;
|
||||
f->also_make = imf->also_make;
|
||||
f->is_target = 1;
|
||||
|
||||
if (!f->precious)
|
||||
{
|
||||
imf = lookup_file (d->intermediate_pattern);
|
||||
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);
|
||||
/* enter_file uses dep->name _if_ we created a new file. */
|
||||
if (dep->name != dep->file->name)
|
||||
free (dep->name);
|
||||
dep->name = 0;
|
||||
dep->file->tried_implicit |= dep->changed;
|
||||
}
|
||||
}
|
||||
|
||||
dep = alloc_dep ();
|
||||
dep->ignore_mtime = d->ignore_mtime;
|
||||
s = d->name; /* Hijacking the name. */
|
||||
d->name = 0;
|
||||
if (recursions == 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;
|
||||
}
|
||||
|
||||
if (d->intermediate_file == 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;
|
||||
}
|
||||
|
||||
*d_ptr = dep;
|
||||
d_ptr = &dep->next;
|
||||
}
|
||||
|
||||
*d_ptr = expl_d;
|
||||
|
||||
if (!checked_lastslash[foundrule])
|
||||
{
|
||||
/* Always allocate new storage, since STEM might be
|
||||
on the stack for an intermediate file. */
|
||||
file->stem = savestring (stem, stemlen);
|
||||
fullstemlen = stemlen;
|
||||
}
|
||||
else
|
||||
{
|
||||
int dirlen = (lastslash + 1) - filename;
|
||||
|
||||
/* We want to prepend the directory from
|
||||
the original FILENAME onto the stem. */
|
||||
fullstemlen = dirlen + stemlen;
|
||||
file->stem = (char *) xmalloc (fullstemlen + 1);
|
||||
bcopy (filename, file->stem, dirlen);
|
||||
bcopy (stem, file->stem + dirlen, stemlen);
|
||||
file->stem[fullstemlen] = '\0';
|
||||
}
|
||||
|
||||
file->cmds = rule->cmds;
|
||||
file->is_target = 1;
|
||||
|
||||
/* Set precious flag. */
|
||||
{
|
||||
struct file *f = lookup_file (rule->targets[matches[foundrule]]);
|
||||
if (f && f->precious)
|
||||
file->precious = 1;
|
||||
}
|
||||
|
||||
/* If this rule builds other targets, too, put the others into FILE's
|
||||
`also_make' member. */
|
||||
|
||||
if (rule->targets[1] != 0)
|
||||
for (i = 0; rule->targets[i] != 0; ++i)
|
||||
if (i != matches[foundrule])
|
||||
{
|
||||
struct file *f;
|
||||
struct dep *new = alloc_dep ();
|
||||
|
||||
/* GKM FIMXE: handle '|' here too */
|
||||
new->name = p = (char *) xmalloc (rule->lens[i] + fullstemlen + 1);
|
||||
bcopy (rule->targets[i], p,
|
||||
rule->suffixes[i] - rule->targets[i] - 1);
|
||||
p += rule->suffixes[i] - rule->targets[i] - 1;
|
||||
bcopy (file->stem, p, fullstemlen);
|
||||
p += fullstemlen;
|
||||
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;
|
||||
|
||||
/* Set precious flag. */
|
||||
f = lookup_file (rule->targets[i]);
|
||||
if (f && f->precious)
|
||||
new->file->precious = 1;
|
||||
|
||||
/* Set the is_target flag so that this file is not treated
|
||||
as intermediate by the pattern rule search algorithm and
|
||||
file_exists_p cannot pick it up yet. */
|
||||
new->file->is_target = 1;
|
||||
|
||||
file->also_make = new;
|
||||
}
|
||||
|
||||
done:
|
||||
free_idep_chain (deps);
|
||||
free (tryrules);
|
||||
|
||||
return rule != 0;
|
||||
}
|
||||
-3070
File diff suppressed because it is too large
Load Diff
@@ -1,105 +0,0 @@
|
||||
/* Definitions for managing subprocesses in GNU Make.
|
||||
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
|
||||
2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#ifndef SEEN_JOB_H
|
||||
#define SEEN_JOB_H
|
||||
|
||||
#ifdef HAVE_FCNTL_H
|
||||
# include <fcntl.h>
|
||||
#else
|
||||
# include <sys/file.h>
|
||||
#endif
|
||||
|
||||
/* How to set close-on-exec for a file descriptor. */
|
||||
|
||||
#if !defined F_SETFD
|
||||
# define CLOSE_ON_EXEC(_d)
|
||||
#else
|
||||
# ifndef FD_CLOEXEC
|
||||
# define FD_CLOEXEC 1
|
||||
# endif
|
||||
# define CLOSE_ON_EXEC(_d) (void) fcntl ((_d), F_SETFD, FD_CLOEXEC)
|
||||
#endif
|
||||
|
||||
/* 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. */
|
||||
#ifdef VMS
|
||||
int efn; /* Completion event flag number */
|
||||
int cstatus; /* Completion status */
|
||||
#endif
|
||||
char *sh_batch_file; /* Script file for shell commands */
|
||||
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. */
|
||||
unsigned int dontcare:1; /* Saved dontcare flag. */
|
||||
};
|
||||
|
||||
extern struct child *children;
|
||||
|
||||
extern void new_job PARAMS ((struct file *file));
|
||||
extern void reap_children PARAMS ((int block, int err));
|
||||
extern void start_waiting_jobs PARAMS ((void));
|
||||
|
||||
extern char **construct_command_argv PARAMS ((char *line, char **restp, struct file *file, char** batch_file));
|
||||
#ifdef VMS
|
||||
extern int child_execute_job PARAMS ((char *argv, struct child *child));
|
||||
#elif defined(__EMX__)
|
||||
extern int child_execute_job PARAMS ((int stdin_fd, int stdout_fd, char **argv, char **envp));
|
||||
#else
|
||||
extern void child_execute_job PARAMS ((int stdin_fd, int stdout_fd, char **argv, char **envp));
|
||||
#endif
|
||||
#ifdef _AMIGA
|
||||
extern void exec_command PARAMS ((char **argv));
|
||||
#elif defined(__EMX__)
|
||||
extern int exec_command PARAMS ((char **argv, char **envp));
|
||||
#else
|
||||
extern void exec_command PARAMS ((char **argv, char **envp));
|
||||
#endif
|
||||
|
||||
extern unsigned int job_slots_used;
|
||||
|
||||
extern void block_sigs PARAMS ((void));
|
||||
#ifdef POSIX
|
||||
extern void unblock_sigs PARAMS ((void));
|
||||
#else
|
||||
#ifdef HAVE_SIGSETMASK
|
||||
extern int fatal_signal_mask;
|
||||
#define unblock_sigs() sigsetmask (0)
|
||||
#else
|
||||
#define unblock_sigs()
|
||||
#endif
|
||||
#endif
|
||||
|
||||
extern unsigned int jobserver_tokens;
|
||||
|
||||
#endif /* SEEN_JOB_H */
|
||||
-3129
File diff suppressed because it is too large
Load Diff
@@ -1,611 +0,0 @@
|
||||
/* Miscellaneous global declarations and portability cruft for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
/* We use <config.h> 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 <config.h>
|
||||
#undef HAVE_CONFIG_H
|
||||
#define HAVE_CONFIG_H 1
|
||||
|
||||
/* AIX requires this to be the first thing in the file. */
|
||||
#ifndef __GNUC__
|
||||
# if HAVE_ALLOCA_H
|
||||
# include <alloca.h>
|
||||
# else
|
||||
# ifdef _AIX
|
||||
#pragma alloca
|
||||
# else
|
||||
# ifndef alloca /* predefined by HP cc +Olibcalls */
|
||||
char *alloca ();
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
/* Use prototypes if available. */
|
||||
#if defined (__cplusplus) || defined (__STDC__)
|
||||
# undef PARAMS
|
||||
# define PARAMS(protos) protos
|
||||
#else /* Not C++ or ANSI C. */
|
||||
# undef PARAMS
|
||||
# define PARAMS(protos) ()
|
||||
#endif /* C++ or ANSI C. */
|
||||
|
||||
/* Specify we want GNU source code. This must be defined before any
|
||||
system headers are included. */
|
||||
|
||||
#define _GNU_SOURCE 1
|
||||
|
||||
|
||||
#ifdef CRAY
|
||||
/* This must happen before #include <signal.h> so
|
||||
that the declaration therein is changed. */
|
||||
# define signal bsdsignal
|
||||
#endif
|
||||
|
||||
/* If we're compiling for the dmalloc debugger, turn off string inlining. */
|
||||
#if defined(HAVE_DMALLOC_H) && defined(__GNUC__)
|
||||
# define __NO_STRING_INLINES
|
||||
#endif
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <signal.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#ifdef HAVE_SYS_TIMEB_H
|
||||
/* SCO 3.2 "devsys 4.2" has a prototype for `ftime' in <time.h> that bombs
|
||||
unless <sys/timeb.h> has been included first. Does every system have a
|
||||
<sys/timeb.h>? If any does not, configure should check for it. */
|
||||
# include <sys/timeb.h>
|
||||
#endif
|
||||
|
||||
#if TIME_WITH_SYS_TIME
|
||||
# include <sys/time.h>
|
||||
# include <time.h>
|
||||
#else
|
||||
# if HAVE_SYS_TIME_H
|
||||
# include <sys/time.h>
|
||||
# else
|
||||
# include <time.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
#ifndef errno
|
||||
extern int errno;
|
||||
#endif
|
||||
|
||||
#ifndef isblank
|
||||
# define isblank(c) ((c) == ' ' || (c) == '\t')
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_UNISTD_H
|
||||
# include <unistd.h>
|
||||
/* Ultrix's unistd.h always defines _POSIX_VERSION, but you only get
|
||||
POSIX.1 behavior with `cc -YPOSIX', which predefines POSIX itself! */
|
||||
# if defined (_POSIX_VERSION) && !defined (ultrix) && !defined (VMS)
|
||||
# define POSIX 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/* Some systems define _POSIX_VERSION but are not really POSIX.1. */
|
||||
#if (defined (butterfly) || defined (__arm) || (defined (__mips) && defined (_SYSTYPE_SVR3)) || (defined (sequent) && defined (i386)))
|
||||
# undef POSIX
|
||||
#endif
|
||||
|
||||
#if !defined (POSIX) && defined (_AIX) && defined (_POSIX_SOURCE)
|
||||
# define POSIX 1
|
||||
#endif
|
||||
|
||||
#ifndef RETSIGTYPE
|
||||
# define RETSIGTYPE void
|
||||
#endif
|
||||
|
||||
#ifndef sigmask
|
||||
# define sigmask(sig) (1 << ((sig) - 1))
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_SA_RESTART
|
||||
# define SA_RESTART 0
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_LIMITS_H
|
||||
# include <limits.h>
|
||||
#endif
|
||||
#ifdef HAVE_SYS_PARAM_H
|
||||
# include <sys/param.h>
|
||||
#endif
|
||||
|
||||
#ifndef PATH_MAX
|
||||
# ifndef POSIX
|
||||
# define PATH_MAX MAXPATHLEN
|
||||
# endif
|
||||
#endif
|
||||
#ifndef MAXPATHLEN
|
||||
# define MAXPATHLEN 1024
|
||||
#endif
|
||||
|
||||
#ifdef PATH_MAX
|
||||
# define GET_PATH_MAX PATH_MAX
|
||||
# define PATH_VAR(var) char var[PATH_MAX]
|
||||
#else
|
||||
# define NEED_GET_PATH_MAX 1
|
||||
# define GET_PATH_MAX (get_path_max ())
|
||||
# define PATH_VAR(var) char *var = (char *) alloca (GET_PATH_MAX)
|
||||
extern unsigned int get_path_max PARAMS ((void));
|
||||
#endif
|
||||
|
||||
#ifndef CHAR_BIT
|
||||
# define CHAR_BIT 8
|
||||
#endif
|
||||
|
||||
/* Nonzero if the integer type T is signed. */
|
||||
#define INTEGER_TYPE_SIGNED(t) ((t) -1 < 0)
|
||||
|
||||
/* The minimum and maximum values for the integer type T.
|
||||
Use ~ (t) 0, not -1, for portability to 1's complement hosts. */
|
||||
#define INTEGER_TYPE_MINIMUM(t) \
|
||||
(! INTEGER_TYPE_SIGNED (t) ? (t) 0 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))
|
||||
#define INTEGER_TYPE_MAXIMUM(t) (~ (t) 0 - INTEGER_TYPE_MINIMUM (t))
|
||||
|
||||
#ifndef CHAR_MAX
|
||||
# define CHAR_MAX INTEGER_TYPE_MAXIMUM (char)
|
||||
#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
|
||||
|
||||
#ifdef VMS
|
||||
# include <types.h>
|
||||
# include <unixlib.h>
|
||||
# include <unixio.h>
|
||||
# include <perror.h>
|
||||
/* Needed to use alloca on VMS. */
|
||||
# include <builtins.h>
|
||||
#endif
|
||||
|
||||
#ifndef __attribute__
|
||||
/* This feature is available in gcc versions 2.5 and later. */
|
||||
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
|
||||
# define __attribute__(x)
|
||||
# endif
|
||||
/* The __-protected variants of `format' and `printf' attributes
|
||||
are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */
|
||||
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
|
||||
# define __format__ format
|
||||
# define __printf__ printf
|
||||
# endif
|
||||
#endif
|
||||
#define UNUSED __attribute__ ((unused))
|
||||
|
||||
#if defined (STDC_HEADERS) || defined (__GNU_LIBRARY__)
|
||||
# include <stdlib.h>
|
||||
# include <string.h>
|
||||
# define ANSI_STRING 1
|
||||
#else /* No standard headers. */
|
||||
# ifdef HAVE_STRING_H
|
||||
# include <string.h>
|
||||
# define ANSI_STRING 1
|
||||
# else
|
||||
# include <strings.h>
|
||||
# endif
|
||||
# ifdef HAVE_MEMORY_H
|
||||
# include <memory.h>
|
||||
# endif
|
||||
# ifdef HAVE_STDLIB_H
|
||||
# include <stdlib.h>
|
||||
# else
|
||||
extern char *malloc PARAMS ((int));
|
||||
extern char *realloc PARAMS ((char *, int));
|
||||
extern void free PARAMS ((char *));
|
||||
|
||||
extern void abort PARAMS ((void)) __attribute__ ((noreturn));
|
||||
extern void exit PARAMS ((int)) __attribute__ ((noreturn));
|
||||
# endif /* HAVE_STDLIB_H. */
|
||||
|
||||
#endif /* Standard headers. */
|
||||
|
||||
/* These should be in stdlib.h. Make sure we have them. */
|
||||
#ifndef EXIT_SUCCESS
|
||||
# define EXIT_SUCCESS 0
|
||||
#endif
|
||||
#ifndef EXIT_FAILURE
|
||||
# define EXIT_FAILURE 0
|
||||
#endif
|
||||
|
||||
#ifdef ANSI_STRING
|
||||
|
||||
# ifndef bcmp
|
||||
# define bcmp(s1, s2, n) memcmp ((s1), (s2), (n))
|
||||
# endif
|
||||
# ifndef bzero
|
||||
# define bzero(s, n) memset ((s), 0, (n))
|
||||
# endif
|
||||
# if defined(HAVE_MEMMOVE) && !defined(bcopy)
|
||||
# define bcopy(s, d, n) memmove ((d), (s), (n))
|
||||
# endif
|
||||
|
||||
#else /* Not ANSI_STRING. */
|
||||
|
||||
# ifndef HAVE_STRCHR
|
||||
# define strchr(s, c) index((s), (c))
|
||||
# define strrchr(s, c) rindex((s), (c))
|
||||
# endif
|
||||
|
||||
# ifndef bcmp
|
||||
extern int bcmp PARAMS ((const char *, const char *, int));
|
||||
# endif
|
||||
# ifndef bzero
|
||||
extern void bzero PARAMS ((char *, int));
|
||||
#endif
|
||||
# ifndef bcopy
|
||||
extern void bcopy PARAMS ((const char *b1, char *b2, int));
|
||||
# endif
|
||||
|
||||
/* SCO Xenix has a buggy macro definition in <string.h>. */
|
||||
#undef strerror
|
||||
#if !defined(__DECC)
|
||||
extern char *strerror PARAMS ((int errnum));
|
||||
#endif
|
||||
|
||||
#endif /* !ANSI_STRING. */
|
||||
#undef ANSI_STRING
|
||||
|
||||
#if HAVE_INTTYPES_H
|
||||
# include <inttypes.h>
|
||||
#endif
|
||||
#define FILE_TIMESTAMP uintmax_t
|
||||
|
||||
#if !defined(HAVE_STRSIGNAL)
|
||||
extern char *strsignal PARAMS ((int signum));
|
||||
#endif
|
||||
|
||||
/* ISDIGIT offers the following features:
|
||||
- Its arg may be any int or unsigned int; it need not be an unsigned char.
|
||||
- It's guaranteed to evaluate its argument exactly once.
|
||||
NOTE! Make relies on this behavior, don't change it!
|
||||
- It's typically faster.
|
||||
POSIX 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that
|
||||
only '0' through '9' are digits. Prefer ISDIGIT to isdigit() unless
|
||||
it's important to use the locale's definition of `digit' even when the
|
||||
host does not conform to POSIX. */
|
||||
#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
|
||||
|
||||
#ifndef iAPX286
|
||||
# define streq(a, b) \
|
||||
((a) == (b) || \
|
||||
(*(a) == *(b) && (*(a) == '\0' || !strcmp ((a) + 1, (b) + 1))))
|
||||
# ifdef HAVE_CASE_INSENSITIVE_FS
|
||||
/* This is only used on Windows/DOS platforms, so we assume strcmpi(). */
|
||||
# define strieq(a, b) \
|
||||
((a) == (b) \
|
||||
|| (tolower((unsigned char)*(a)) == tolower((unsigned char)*(b)) \
|
||||
&& (*(a) == '\0' || !strcmpi ((a) + 1, (b) + 1))))
|
||||
# else
|
||||
# define strieq(a, b) streq(a, b)
|
||||
# endif
|
||||
#else
|
||||
/* Buggy compiler can't handle this. */
|
||||
# define streq(a, b) (strcmp ((a), (b)) == 0)
|
||||
# define strieq(a, b) (strcmp ((a), (b)) == 0)
|
||||
#endif
|
||||
#define strneq(a, b, l) (strncmp ((a), (b), (l)) == 0)
|
||||
#ifdef VMS
|
||||
extern int strcmpi (const char *,const char *);
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) || defined(ENUM_BITFIELDS)
|
||||
# define ENUM_BITFIELD(bits) :bits
|
||||
#else
|
||||
# define ENUM_BITFIELD(bits)
|
||||
#endif
|
||||
|
||||
/* Handle gettext and locales. */
|
||||
|
||||
#if HAVE_LOCALE_H
|
||||
# include <locale.h>
|
||||
#else
|
||||
# define setlocale(category, locale)
|
||||
#endif
|
||||
|
||||
#include <gettext.h>
|
||||
|
||||
#define _(msgid) gettext (msgid)
|
||||
#define N_(msgid) gettext_noop (msgid)
|
||||
#define S_(msg1,msg2,num) ngettext (msg1,msg2,num)
|
||||
|
||||
/* Handle other OSs. */
|
||||
#if defined(HAVE_DOS_PATHS)
|
||||
# define PATH_SEPARATOR_CHAR ';'
|
||||
#elif defined(VMS)
|
||||
# define PATH_SEPARATOR_CHAR ','
|
||||
#else
|
||||
# define PATH_SEPARATOR_CHAR ':'
|
||||
#endif
|
||||
|
||||
/* This is needed for getcwd() and chdir(). */
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
# include <direct.h>
|
||||
#endif
|
||||
|
||||
#ifdef WINDOWS32
|
||||
# include <fcntl.h>
|
||||
# include <malloc.h>
|
||||
# define pipe(p) _pipe(p, 512, O_BINARY)
|
||||
# define kill(pid,sig) w32_kill(pid,sig)
|
||||
|
||||
extern void sync_Path_environment(void);
|
||||
extern int kill(int pid, int sig);
|
||||
extern char *end_of_token_w32(char *s, char stopchar);
|
||||
extern int find_and_set_default_shell(char *token);
|
||||
|
||||
/* indicates whether or not we have Bourne shell */
|
||||
extern int no_default_sh_exe;
|
||||
|
||||
/* is default_shell unixy? */
|
||||
extern int unixy_shell;
|
||||
#endif /* WINDOWS32 */
|
||||
|
||||
struct floc
|
||||
{
|
||||
const char *filenm;
|
||||
unsigned long lineno;
|
||||
};
|
||||
#define NILF ((struct floc *)0)
|
||||
|
||||
#define STRING_SIZE_TUPLE(_s) (_s), (sizeof (_s)-1)
|
||||
|
||||
|
||||
/* We have to have stdarg.h or varargs.h AND v*printf or doprnt to use
|
||||
variadic versions of these functions. */
|
||||
|
||||
#if HAVE_STDARG_H || HAVE_VARARGS_H
|
||||
# if HAVE_VPRINTF || HAVE_DOPRNT
|
||||
# define USE_VARIADIC 1
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
|
||||
extern void message (int prefix, const char *fmt, ...)
|
||||
__attribute__ ((__format__ (__printf__, 2, 3)));
|
||||
extern void error (const struct floc *flocp, const char *fmt, ...)
|
||||
__attribute__ ((__format__ (__printf__, 2, 3)));
|
||||
extern void fatal (const struct floc *flocp, const char *fmt, ...)
|
||||
__attribute__ ((noreturn, __format__ (__printf__, 2, 3)));
|
||||
#else
|
||||
extern void message ();
|
||||
extern void error ();
|
||||
extern void fatal ();
|
||||
#endif
|
||||
|
||||
extern void die PARAMS ((int)) __attribute__ ((noreturn));
|
||||
extern void log_working_directory PARAMS ((int));
|
||||
extern void pfatal_with_name PARAMS ((const char *)) __attribute__ ((noreturn));
|
||||
extern void perror_with_name PARAMS ((const char *, const char *));
|
||||
extern char *savestring PARAMS ((const char *, unsigned int));
|
||||
extern char *concat PARAMS ((const char *, const char *, const char *));
|
||||
extern char *xmalloc PARAMS ((unsigned int));
|
||||
extern char *xrealloc PARAMS ((char *, unsigned int));
|
||||
extern char *xstrdup PARAMS ((const char *));
|
||||
extern char *find_next_token PARAMS ((char **, unsigned int *));
|
||||
extern char *next_token PARAMS ((const char *));
|
||||
extern char *end_of_token PARAMS ((const char *));
|
||||
extern void collapse_continuations PARAMS ((char *));
|
||||
extern char *lindex PARAMS ((const char *, const char *, int));
|
||||
extern int alpha_compare PARAMS ((const void *, const void *));
|
||||
extern void print_spaces PARAMS ((unsigned int));
|
||||
extern char *find_percent PARAMS ((char *));
|
||||
extern FILE *open_tmpfile PARAMS ((char **, const char *));
|
||||
|
||||
#ifndef NO_ARCHIVES
|
||||
extern int ar_name PARAMS ((char *));
|
||||
extern void ar_parse_name PARAMS ((char *, char **, char **));
|
||||
extern int ar_touch PARAMS ((char *));
|
||||
extern time_t ar_member_date PARAMS ((char *));
|
||||
#endif
|
||||
|
||||
extern int dir_file_exists_p PARAMS ((char *, char *));
|
||||
extern int file_exists_p PARAMS ((char *));
|
||||
extern int file_impossible_p PARAMS ((char *));
|
||||
extern void file_impossible PARAMS ((char *));
|
||||
extern char *dir_name PARAMS ((char *));
|
||||
extern void hash_init_directories PARAMS ((void));
|
||||
|
||||
extern void define_default_variables PARAMS ((void));
|
||||
extern void set_default_suffixes PARAMS ((void));
|
||||
extern void install_default_suffix_rules PARAMS ((void));
|
||||
extern void install_default_implicit_rules PARAMS ((void));
|
||||
|
||||
extern void build_vpath_lists PARAMS ((void));
|
||||
extern void construct_vpath_list PARAMS ((char *pattern, char *dirpath));
|
||||
extern int vpath_search PARAMS ((char **file, FILE_TIMESTAMP *mtime_ptr));
|
||||
extern int gpath_search PARAMS ((char *file, unsigned int len));
|
||||
|
||||
extern void construct_include_path PARAMS ((char **arg_dirs));
|
||||
|
||||
extern void user_access PARAMS ((void));
|
||||
extern void make_access PARAMS ((void));
|
||||
extern void child_access PARAMS ((void));
|
||||
|
||||
extern void close_stdout PARAMS ((void));
|
||||
|
||||
extern char *strip_whitespace PARAMS ((const char **begpp, const char **endpp));
|
||||
|
||||
/* String caching */
|
||||
extern void strcache_init PARAMS ((void));
|
||||
extern void strcache_print_stats PARAMS ((const char *prefix));
|
||||
extern int strcache_iscached PARAMS ((const char *str));
|
||||
extern const char *strcache_add PARAMS ((const char *str));
|
||||
extern const char *strcache_add_len PARAMS ((const char *str, int len));
|
||||
extern int strcache_setbufsize PARAMS ((int size));
|
||||
|
||||
#ifdef HAVE_VFORK_H
|
||||
# include <vfork.h>
|
||||
#endif
|
||||
|
||||
/* We omit these declarations on non-POSIX systems which define _POSIX_VERSION,
|
||||
because such systems often declare them in header files anyway. */
|
||||
|
||||
#if !defined (__GNU_LIBRARY__) && !defined (POSIX) && !defined (_POSIX_VERSION) && !defined(WINDOWS32)
|
||||
|
||||
extern long int atol ();
|
||||
# ifndef VMS
|
||||
extern long int lseek ();
|
||||
# endif
|
||||
|
||||
#endif /* Not GNU C library or POSIX. */
|
||||
|
||||
#ifdef HAVE_GETCWD
|
||||
# if !defined(VMS) && !defined(__DECC)
|
||||
extern char *getcwd ();
|
||||
# endif
|
||||
#else
|
||||
extern char *getwd ();
|
||||
# define getcwd(buf, len) getwd (buf)
|
||||
#endif
|
||||
|
||||
extern const struct floc *reading_file;
|
||||
extern const struct floc **expanding_var;
|
||||
|
||||
extern char **environ;
|
||||
|
||||
extern int just_print_flag, silent_flag, ignore_errors_flag, keep_going_flag;
|
||||
extern int print_data_base_flag, question_flag, touch_flag, always_make_flag;
|
||||
extern int env_overrides, no_builtin_rules_flag, no_builtin_variables_flag;
|
||||
extern int print_version_flag, print_directory_flag, check_symlink_flag;
|
||||
extern int warn_undefined_variables_flag, posix_pedantic, not_parallel;
|
||||
extern int second_expansion, clock_skew_detected, rebuilding_makefiles;
|
||||
|
||||
/* can we run commands via 'sh -c xxx' or must we use batch files? */
|
||||
extern int batch_mode_shell;
|
||||
|
||||
extern unsigned int job_slots;
|
||||
extern int job_fds[2];
|
||||
extern int job_rfd;
|
||||
#ifndef NO_FLOAT
|
||||
extern double max_load_average;
|
||||
#else
|
||||
extern int max_load_average;
|
||||
#endif
|
||||
|
||||
extern char *program;
|
||||
extern char *starting_directory;
|
||||
extern unsigned int makelevel;
|
||||
extern char *version_string, *remote_description, *make_host;
|
||||
|
||||
extern unsigned int commands_started;
|
||||
|
||||
extern int handling_fatal_signal;
|
||||
|
||||
|
||||
#ifndef MIN
|
||||
#define MIN(_a,_b) ((_a)<(_b)?(_a):(_b))
|
||||
#endif
|
||||
#ifndef MAX
|
||||
#define MAX(_a,_b) ((_a)>(_b)?(_a):(_b))
|
||||
#endif
|
||||
|
||||
#ifdef VMS
|
||||
# define MAKE_SUCCESS 1
|
||||
# define MAKE_TROUBLE 2
|
||||
# define MAKE_FAILURE 3
|
||||
#else
|
||||
# define MAKE_SUCCESS 0
|
||||
# define MAKE_TROUBLE 1
|
||||
# define MAKE_FAILURE 2
|
||||
#endif
|
||||
|
||||
/* Set up heap debugging library dmalloc. */
|
||||
|
||||
#ifdef HAVE_DMALLOC_H
|
||||
#include <dmalloc.h>
|
||||
#endif
|
||||
|
||||
#ifndef initialize_main
|
||||
# ifdef __EMX__
|
||||
# define initialize_main(pargc, pargv) \
|
||||
{ _wildcard(pargc, pargv); _response(pargc, pargv); }
|
||||
# else
|
||||
# define initialize_main(pargc, pargv)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __EMX__
|
||||
# if !HAVE_STRCASECMP
|
||||
# define strcasecmp stricmp
|
||||
# endif
|
||||
|
||||
# if !defined chdir
|
||||
# define chdir _chdir2
|
||||
# endif
|
||||
# if !defined getcwd
|
||||
# define getcwd _getcwd2
|
||||
# endif
|
||||
|
||||
/* NO_CHDIR2 causes make not to use _chdir2() and _getcwd2() instead of
|
||||
chdir() and getcwd(). This avoids some error messages for the
|
||||
make testsuite but restricts the drive letter support. */
|
||||
# ifdef NO_CHDIR2
|
||||
# warning NO_CHDIR2: usage of drive letters restricted
|
||||
# undef chdir
|
||||
# undef getcwd
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef initialize_main
|
||||
# define initialize_main(pargc, pargv)
|
||||
#endif
|
||||
|
||||
|
||||
/* Some systems (like Solaris, PTX, etc.) do not support the SA_RESTART flag
|
||||
properly according to POSIX. So, we try to wrap common system calls with
|
||||
checks for EINTR. Note that there are still plenty of system calls that
|
||||
can fail with EINTR but this, reportedly, gets the vast majority of
|
||||
failure cases. If you still experience failures you'll need to either get
|
||||
a system where SA_RESTART works, or you need to avoid -j. */
|
||||
|
||||
#define EINTRLOOP(_v,_c) while (((_v)=_c)==-1 && errno==EINTR)
|
||||
|
||||
/* While system calls that return integers are pretty consistent about
|
||||
returning -1 on failure and setting errno in that case, functions that
|
||||
return pointers are not always so well behaved. Sometimes they return
|
||||
NULL for expected behavior: one good example is readdir() which returns
|
||||
NULL at the end of the directory--and _doesn't_ reset errno. So, we have
|
||||
to do it ourselves here. */
|
||||
|
||||
#define ENULLLOOP(_v,_c) do{ errno = 0; \
|
||||
while (((_v)=_c)==0 && errno==EINTR); }while(0)
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
resource app_version
|
||||
{
|
||||
major = 3,
|
||||
middle = 81,
|
||||
minor = 0,
|
||||
variety = 5,
|
||||
internal = 0,
|
||||
short_info = "3.81",
|
||||
long_info = "3.81 ©2006 The Free Software Foundation, Inc."
|
||||
};
|
||||
|
||||
@@ -1,897 +0,0 @@
|
||||
/* Miscellaneous generic support functions for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "dep.h"
|
||||
#include "debug.h"
|
||||
|
||||
/* Variadic functions. We go through contortions to allow proper function
|
||||
prototypes for both ANSI and pre-ANSI C compilers, and also for those
|
||||
which support stdarg.h vs. varargs.h, and finally those which have
|
||||
vfprintf(), etc. and those who have _doprnt... or nothing.
|
||||
|
||||
This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and
|
||||
VA_END macros used here since we have multiple print functions. */
|
||||
|
||||
#if USE_VARIADIC
|
||||
# if HAVE_STDARG_H
|
||||
# include <stdarg.h>
|
||||
# define VA_START(args, lastarg) va_start(args, lastarg)
|
||||
# else
|
||||
# include <varargs.h>
|
||||
# define VA_START(args, lastarg) va_start(args)
|
||||
# endif
|
||||
# if HAVE_VPRINTF
|
||||
# define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args))
|
||||
# else
|
||||
# define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp))
|
||||
# endif
|
||||
# define VA_END(args) va_end(args)
|
||||
#else
|
||||
/* We can't use any variadic interface! */
|
||||
# define va_alist a1, a2, a3, a4, a5, a6, a7, a8
|
||||
# define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
|
||||
# define VA_START(args, lastarg)
|
||||
# define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist)
|
||||
# define VA_END(args)
|
||||
#endif
|
||||
|
||||
|
||||
/* 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 (const void *v1, const void *v2)
|
||||
{
|
||||
const char *s1 = *((char **)v1);
|
||||
const char *s2 = *((char **)v2);
|
||||
|
||||
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 (char *line)
|
||||
{
|
||||
register char *in, *out, *p;
|
||||
register int backslash;
|
||||
register unsigned int bs_write;
|
||||
|
||||
in = strchr (line, '\n');
|
||||
if (in == 0)
|
||||
return;
|
||||
|
||||
out = in;
|
||||
while (out > line && 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 ((unsigned char)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';
|
||||
}
|
||||
|
||||
/* Print N spaces (used in debug for target-depth). */
|
||||
|
||||
void
|
||||
print_spaces (unsigned int n)
|
||||
{
|
||||
while (n-- > 0)
|
||||
putchar (' ');
|
||||
}
|
||||
|
||||
|
||||
/* Return a newly-allocated string whose contents
|
||||
concatenate those of s1, s2, s3. */
|
||||
|
||||
char *
|
||||
concat (const char *s1, const char *s2, const char *s3)
|
||||
{
|
||||
unsigned int len1, len2, len3;
|
||||
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
|
||||
#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
|
||||
message (int prefix, const char *fmt, ...)
|
||||
#else
|
||||
message (prefix, fmt, va_alist)
|
||||
int prefix;
|
||||
const char *fmt;
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
#if USE_VARIADIC
|
||||
va_list args;
|
||||
#endif
|
||||
|
||||
log_working_directory (1);
|
||||
|
||||
if (fmt != 0)
|
||||
{
|
||||
if (prefix)
|
||||
{
|
||||
if (makelevel == 0)
|
||||
printf ("%s: ", program);
|
||||
else
|
||||
printf ("%s[%u]: ", program, makelevel);
|
||||
}
|
||||
VA_START (args, fmt);
|
||||
VA_PRINTF (stdout, fmt, args);
|
||||
VA_END (args);
|
||||
putchar ('\n');
|
||||
}
|
||||
|
||||
fflush (stdout);
|
||||
}
|
||||
|
||||
/* Print an error message. */
|
||||
|
||||
void
|
||||
#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
|
||||
error (const struct floc *flocp, const char *fmt, ...)
|
||||
#else
|
||||
error (flocp, fmt, va_alist)
|
||||
const struct floc *flocp;
|
||||
const char *fmt;
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
#if USE_VARIADIC
|
||||
va_list args;
|
||||
#endif
|
||||
|
||||
log_working_directory (1);
|
||||
|
||||
if (flocp && flocp->filenm)
|
||||
fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno);
|
||||
else if (makelevel == 0)
|
||||
fprintf (stderr, "%s: ", program);
|
||||
else
|
||||
fprintf (stderr, "%s[%u]: ", program, makelevel);
|
||||
|
||||
VA_START(args, fmt);
|
||||
VA_PRINTF (stderr, fmt, args);
|
||||
VA_END (args);
|
||||
|
||||
putc ('\n', stderr);
|
||||
fflush (stderr);
|
||||
}
|
||||
|
||||
/* Print an error message and exit. */
|
||||
|
||||
void
|
||||
#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
|
||||
fatal (const struct floc *flocp, const char *fmt, ...)
|
||||
#else
|
||||
fatal (flocp, fmt, va_alist)
|
||||
const struct floc *flocp;
|
||||
const char *fmt;
|
||||
va_dcl
|
||||
#endif
|
||||
{
|
||||
#if USE_VARIADIC
|
||||
va_list args;
|
||||
#endif
|
||||
|
||||
log_working_directory (1);
|
||||
|
||||
if (flocp && flocp->filenm)
|
||||
fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno);
|
||||
else if (makelevel == 0)
|
||||
fprintf (stderr, "%s: *** ", program);
|
||||
else
|
||||
fprintf (stderr, "%s[%u]: *** ", program, makelevel);
|
||||
|
||||
VA_START(args, fmt);
|
||||
VA_PRINTF (stderr, fmt, args);
|
||||
VA_END (args);
|
||||
|
||||
fputs (_(". Stop.\n"), stderr);
|
||||
|
||||
die (2);
|
||||
}
|
||||
|
||||
#ifndef HAVE_STRERROR
|
||||
|
||||
#undef strerror
|
||||
|
||||
char *
|
||||
strerror (int errnum)
|
||||
{
|
||||
extern int errno, sys_nerr;
|
||||
#ifndef __DECC
|
||||
extern char *sys_errlist[];
|
||||
#endif
|
||||
static char buf[] = "Unknown error 12345678901234567890";
|
||||
|
||||
if (errno < sys_nerr)
|
||||
return sys_errlist[errnum];
|
||||
|
||||
sprintf (buf, _("Unknown error %d"), errnum);
|
||||
return buf;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Print an error message from errno. */
|
||||
|
||||
void
|
||||
perror_with_name (const char *str, const char *name)
|
||||
{
|
||||
error (NILF, _("%s%s: %s"), str, name, strerror (errno));
|
||||
}
|
||||
|
||||
/* Print an error message from errno and exit. */
|
||||
|
||||
void
|
||||
pfatal_with_name (const char *name)
|
||||
{
|
||||
fatal (NILF, _("%s: %s"), name, strerror (errno));
|
||||
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
||||
/* Like malloc but get fatal error if memory is exhausted. */
|
||||
/* Don't bother if we're using dmalloc; it provides these for us. */
|
||||
|
||||
#ifndef HAVE_DMALLOC_H
|
||||
|
||||
#undef xmalloc
|
||||
#undef xrealloc
|
||||
#undef xstrdup
|
||||
|
||||
char *
|
||||
xmalloc (unsigned int size)
|
||||
{
|
||||
/* Make sure we don't allocate 0, for pre-ANSI libraries. */
|
||||
char *result = (char *) malloc (size ? size : 1);
|
||||
if (result == 0)
|
||||
fatal (NILF, _("virtual memory exhausted"));
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
char *
|
||||
xrealloc (char *ptr, unsigned int size)
|
||||
{
|
||||
char *result;
|
||||
|
||||
/* Some older implementations of realloc() don't conform to ANSI. */
|
||||
if (! size)
|
||||
size = 1;
|
||||
result = ptr ? realloc (ptr, size) : malloc (size);
|
||||
if (result == 0)
|
||||
fatal (NILF, _("virtual memory exhausted"));
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
char *
|
||||
xstrdup (const char *ptr)
|
||||
{
|
||||
char *result;
|
||||
|
||||
#ifdef HAVE_STRDUP
|
||||
result = strdup (ptr);
|
||||
#else
|
||||
result = (char *) malloc (strlen (ptr) + 1);
|
||||
#endif
|
||||
|
||||
if (result == 0)
|
||||
fatal (NILF, _("virtual memory exhausted"));
|
||||
|
||||
#ifdef HAVE_STRDUP
|
||||
return result;
|
||||
#else
|
||||
return strcpy(result, ptr);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* HAVE_DMALLOC_H */
|
||||
|
||||
char *
|
||||
savestring (const char *str, unsigned int length)
|
||||
{
|
||||
register char *out = (char *) xmalloc (length + 1);
|
||||
if (length > 0)
|
||||
bcopy (str, out, length);
|
||||
out[length] = '\0';
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
/* 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 (const char *s, const char *limit, int c)
|
||||
{
|
||||
while (s < limit)
|
||||
if (*s++ == c)
|
||||
return (char *)(s - 1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Return the address of the first whitespace or null in the string S. */
|
||||
|
||||
char *
|
||||
end_of_token (const char *s)
|
||||
{
|
||||
while (*s != '\0' && !isblank ((unsigned char)*s))
|
||||
++s;
|
||||
return (char *)s;
|
||||
}
|
||||
|
||||
#ifdef WINDOWS32
|
||||
/*
|
||||
* Same as end_of_token, but take into account a stop character
|
||||
*/
|
||||
char *
|
||||
end_of_token_w32 (char *s, char stopchar)
|
||||
{
|
||||
register char *p = s;
|
||||
register int backslash = 0;
|
||||
|
||||
while (*p != '\0' && *p != stopchar
|
||||
&& (backslash || !isblank ((unsigned char)*p)))
|
||||
{
|
||||
if (*p++ == '\\')
|
||||
{
|
||||
backslash = !backslash;
|
||||
while (*p == '\\')
|
||||
{
|
||||
backslash = !backslash;
|
||||
++p;
|
||||
}
|
||||
}
|
||||
else
|
||||
backslash = 0;
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Return the address of the first nonwhitespace or null in the string S. */
|
||||
|
||||
char *
|
||||
next_token (const char *s)
|
||||
{
|
||||
while (isblank ((unsigned char)*s))
|
||||
++s;
|
||||
return (char *)s;
|
||||
}
|
||||
|
||||
/* 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 (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;
|
||||
}
|
||||
|
||||
|
||||
/* Allocate a new `struct dep' with all fields initialized to 0. */
|
||||
|
||||
struct dep *
|
||||
alloc_dep ()
|
||||
{
|
||||
struct dep *d = (struct dep *) xmalloc (sizeof (struct dep));
|
||||
bzero ((char *) d, sizeof (struct dep));
|
||||
return d;
|
||||
}
|
||||
|
||||
|
||||
/* Free `struct dep' along with `name' and `stem'. */
|
||||
|
||||
void
|
||||
free_dep (struct dep *d)
|
||||
{
|
||||
if (d->name != 0)
|
||||
free (d->name);
|
||||
|
||||
if (d->stem != 0)
|
||||
free (d->stem);
|
||||
|
||||
free ((char *)d);
|
||||
}
|
||||
|
||||
/* Copy a chain of `struct dep', making a new chain
|
||||
with the same contents as the old one. */
|
||||
|
||||
struct dep *
|
||||
copy_dep_chain (const struct dep *d)
|
||||
{
|
||||
register struct dep *c;
|
||||
struct dep *firstnew = 0;
|
||||
struct dep *lastnew = 0;
|
||||
|
||||
while (d != 0)
|
||||
{
|
||||
c = (struct dep *) xmalloc (sizeof (struct dep));
|
||||
bcopy ((char *) d, (char *) c, sizeof (struct dep));
|
||||
|
||||
if (c->name != 0)
|
||||
c->name = xstrdup (c->name);
|
||||
if (c->stem != 0)
|
||||
c->stem = xstrdup (c->stem);
|
||||
|
||||
c->next = 0;
|
||||
if (firstnew == 0)
|
||||
firstnew = lastnew = c;
|
||||
else
|
||||
lastnew = lastnew->next = c;
|
||||
|
||||
d = d->next;
|
||||
}
|
||||
|
||||
return firstnew;
|
||||
}
|
||||
|
||||
/* Free a chain of 'struct dep'. */
|
||||
|
||||
void
|
||||
free_dep_chain (struct dep *d)
|
||||
{
|
||||
while (d != 0)
|
||||
{
|
||||
struct dep *df = d;
|
||||
d = d->next;
|
||||
free_dep (df);
|
||||
}
|
||||
}
|
||||
|
||||
/* Free a chain of `struct nameseq'. Each nameseq->name is freed
|
||||
as well. For `struct dep' chains use free_dep_chain. */
|
||||
|
||||
void
|
||||
free_ns_chain (struct nameseq *n)
|
||||
{
|
||||
register struct nameseq *tmp;
|
||||
|
||||
while (n != 0)
|
||||
{
|
||||
if (n->name != 0)
|
||||
free (n->name);
|
||||
|
||||
tmp = n;
|
||||
|
||||
n = n->next;
|
||||
|
||||
free (tmp);
|
||||
}
|
||||
|
||||
}
|
||||
#ifdef iAPX286
|
||||
/* The losing compiler on this machine can't handle this macro. */
|
||||
|
||||
char *
|
||||
dep_name (struct dep *dep)
|
||||
{
|
||||
return dep->name == 0 ? dep->file->name : dep->name;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef GETLOADAVG_PRIVILEGED
|
||||
|
||||
#ifdef POSIX
|
||||
|
||||
/* Hopefully if a system says it's POSIX.1 and has the setuid and setgid
|
||||
functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2,
|
||||
for example) which claim to be POSIX.1 also have the BSD setreuid and
|
||||
setregid functions, but they don't work as in BSD and only the POSIX.1
|
||||
way works. */
|
||||
|
||||
#undef HAVE_SETREUID
|
||||
#undef HAVE_SETREGID
|
||||
|
||||
#else /* Not POSIX. */
|
||||
|
||||
/* Some POSIX.1 systems have the seteuid and setegid functions. In a
|
||||
POSIX-like system, they are the best thing to use. However, some
|
||||
non-POSIX systems have them too but they do not work in the POSIX style
|
||||
and we must use setreuid and setregid instead. */
|
||||
|
||||
#undef HAVE_SETEUID
|
||||
#undef HAVE_SETEGID
|
||||
|
||||
#endif /* POSIX. */
|
||||
|
||||
#ifndef HAVE_UNISTD_H
|
||||
extern int getuid (), getgid (), geteuid (), getegid ();
|
||||
extern int setuid (), setgid ();
|
||||
#ifdef HAVE_SETEUID
|
||||
extern int seteuid ();
|
||||
#else
|
||||
#ifdef HAVE_SETREUID
|
||||
extern int setreuid ();
|
||||
#endif /* Have setreuid. */
|
||||
#endif /* Have seteuid. */
|
||||
#ifdef HAVE_SETEGID
|
||||
extern int setegid ();
|
||||
#else
|
||||
#ifdef HAVE_SETREGID
|
||||
extern int setregid ();
|
||||
#endif /* Have setregid. */
|
||||
#endif /* Have setegid. */
|
||||
#endif /* No <unistd.h>. */
|
||||
|
||||
/* 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 (const char *flavor)
|
||||
{
|
||||
if (! ISDB (DB_JOBS))
|
||||
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: user %lu (real %lu), group %lu (real %lu)\n"),
|
||||
flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
|
||||
(unsigned long) getegid (), (unsigned long) getgid ());
|
||||
fflush (stderr);
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
init_access (void)
|
||||
{
|
||||
#ifndef VMS
|
||||
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 access"));
|
||||
|
||||
current_access = make;
|
||||
#endif
|
||||
}
|
||||
|
||||
#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 (void)
|
||||
{
|
||||
#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. */
|
||||
|
||||
#ifdef HAVE_SETEUID
|
||||
|
||||
/* Modern systems have the seteuid/setegid calls which set only the
|
||||
effective IDs, which is ideal. */
|
||||
|
||||
if (seteuid (user_uid) < 0)
|
||||
pfatal_with_name ("user_access: seteuid");
|
||||
|
||||
#else /* Not HAVE_SETEUID. */
|
||||
|
||||
#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 /* HAVE_SETREUID. */
|
||||
|
||||
/* 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 /* Not HAVE_SETREUID. */
|
||||
#endif /* HAVE_SETEUID. */
|
||||
|
||||
#ifdef HAVE_SETEGID
|
||||
if (setegid (user_gid) < 0)
|
||||
pfatal_with_name ("user_access: setegid");
|
||||
#else
|
||||
#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
|
||||
#endif
|
||||
|
||||
current_access = user;
|
||||
|
||||
log_access (_("User access"));
|
||||
|
||||
#endif /* GETLOADAVG_PRIVILEGED */
|
||||
}
|
||||
|
||||
/* Give the process appropriate permissions for access to
|
||||
make data (i.e., the load average). */
|
||||
void
|
||||
make_access (void)
|
||||
{
|
||||
#ifdef GETLOADAVG_PRIVILEGED
|
||||
|
||||
if (!access_inited)
|
||||
init_access ();
|
||||
|
||||
if (current_access == make)
|
||||
return;
|
||||
|
||||
/* See comments in user_access, above. */
|
||||
|
||||
#ifdef HAVE_SETEUID
|
||||
if (seteuid (make_uid) < 0)
|
||||
pfatal_with_name ("make_access: seteuid");
|
||||
#else
|
||||
#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
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_SETEGID
|
||||
if (setegid (make_gid) < 0)
|
||||
pfatal_with_name ("make_access: setegid");
|
||||
#else
|
||||
#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
|
||||
#endif
|
||||
|
||||
current_access = make;
|
||||
|
||||
log_access (_("Make access"));
|
||||
|
||||
#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 (void)
|
||||
{
|
||||
#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 access"));
|
||||
|
||||
#endif /* GETLOADAVG_PRIVILEGED */
|
||||
}
|
||||
|
||||
#ifdef NEED_GET_PATH_MAX
|
||||
unsigned int
|
||||
get_path_max (void)
|
||||
{
|
||||
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
|
||||
|
||||
|
||||
/* This code is stolen from gnulib.
|
||||
If/when we abandon the requirement to work with K&R compilers, we can
|
||||
remove this (and perhaps other parts of GNU make!) and migrate to using
|
||||
gnulib directly.
|
||||
|
||||
This is called only through atexit(), which means die() has already been
|
||||
invoked. So, call exit() here directly. Apparently that works...?
|
||||
*/
|
||||
|
||||
/* Close standard output, exiting with status 'exit_failure' on failure.
|
||||
If a program writes *anything* to stdout, that program should close
|
||||
stdout and make sure that it succeeds before exiting. Otherwise,
|
||||
suppose that you go to the extreme of checking the return status
|
||||
of every function that does an explicit write to stdout. The last
|
||||
printf can succeed in writing to the internal stream buffer, and yet
|
||||
the fclose(stdout) could still fail (due e.g., to a disk full error)
|
||||
when it tries to write out that buffered data. Thus, you would be
|
||||
left with an incomplete output file and the offending program would
|
||||
exit successfully. Even calling fflush is not always sufficient,
|
||||
since some file systems (NFS and CODA) buffer written/flushed data
|
||||
until an actual close call.
|
||||
|
||||
Besides, it's wasteful to check the return value from every call
|
||||
that writes to stdout -- just let the internal stream state record
|
||||
the failure. That's what the ferror test is checking below.
|
||||
|
||||
It's important to detect such failures and exit nonzero because many
|
||||
tools (most notably `make' and other build-management systems) depend
|
||||
on being able to detect failure in other tools via their exit status. */
|
||||
|
||||
void
|
||||
close_stdout (void)
|
||||
{
|
||||
int prev_fail = ferror (stdout);
|
||||
int fclose_fail = fclose (stdout);
|
||||
|
||||
if (prev_fail || fclose_fail)
|
||||
{
|
||||
if (fclose_fail)
|
||||
error (NILF, _("write error: %s"), strerror (errno));
|
||||
else
|
||||
error (NILF, _("write error"));
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
-3138
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,101 +0,0 @@
|
||||
/* Template for the remote job exportation interface to GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "filedef.h"
|
||||
#include "job.h"
|
||||
#include "commands.h"
|
||||
|
||||
|
||||
char *remote_description = 0;
|
||||
|
||||
/* Call once at startup even if no commands are run. */
|
||||
|
||||
void
|
||||
remote_setup (void)
|
||||
{
|
||||
}
|
||||
|
||||
/* Called before exit. */
|
||||
|
||||
void
|
||||
remote_cleanup (void)
|
||||
{
|
||||
}
|
||||
|
||||
/* Return nonzero if the next job should be done remotely. */
|
||||
|
||||
int
|
||||
start_remote_job_p (int first_p UNUSED)
|
||||
{
|
||||
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 (char **argv UNUSED, char **envp UNUSED, int stdin_fd UNUSED,
|
||||
int *is_remote UNUSED, int *id_ptr UNUSED,
|
||||
int *used_stdin UNUSED)
|
||||
{
|
||||
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 (int *exit_code_ptr UNUSED, int *signal_ptr UNUSED,
|
||||
int *coredump_ptr UNUSED, int block UNUSED)
|
||||
{
|
||||
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 (void)
|
||||
{
|
||||
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 (void)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* Send signal SIG to child ID. Return 0 if successful, -1 if not. */
|
||||
int
|
||||
remote_kill (int id UNUSED, int sig UNUSED)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
@@ -1,586 +0,0 @@
|
||||
/* Pattern and suffix rule internals for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "dep.h"
|
||||
#include "filedef.h"
|
||||
#include "job.h"
|
||||
#include "commands.h"
|
||||
#include "variable.h"
|
||||
#include "rule.h"
|
||||
|
||||
static void freerule PARAMS ((struct rule *rule, struct rule *lastrule));
|
||||
|
||||
/* 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 (void)
|
||||
{
|
||||
char *name;
|
||||
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);
|
||||
|
||||
#ifdef VMS
|
||||
char *p = strrchr (dep->name, ']');
|
||||
char *p2;
|
||||
if (p == 0)
|
||||
p = strrchr (dep->name, ':');
|
||||
p2 = p != 0 ? strchr (dep->name, '%') : 0;
|
||||
#else
|
||||
char *p = strrchr (dep->name, '/');
|
||||
char *p2 = p != 0 ? strchr (dep->name, '%') : 0;
|
||||
#endif
|
||||
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, "");
|
||||
}
|
||||
else
|
||||
/* This dependency does not reside in a subdirectory. */
|
||||
dep->changed = 0;
|
||||
}
|
||||
|
||||
if (ndeps > max_pattern_deps)
|
||||
max_pattern_deps = ndeps;
|
||||
|
||||
lastrule = rule;
|
||||
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 (char *target, char *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)'. */
|
||||
{
|
||||
#ifdef VMS
|
||||
targname = savestring ("(%.obj)", 7);
|
||||
#else
|
||||
targname = savestring ("(%.o)", 5);
|
||||
#endif
|
||||
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 = alloc_dep ();
|
||||
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 (void)
|
||||
{
|
||||
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 (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 (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->fileinfo.filenm = 0;
|
||||
r->cmds->fileinfo.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 = xstrdup (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 (struct rule *rule, struct rule *lastrule)
|
||||
{
|
||||
struct rule *next = rule->next;
|
||||
register unsigned int i;
|
||||
register struct dep *dep;
|
||||
|
||||
for (i = 0; rule->targets[i] != 0; ++i)
|
||||
free (rule->targets[i]);
|
||||
|
||||
dep = rule->deps;
|
||||
while (dep)
|
||||
{
|
||||
struct dep *t;
|
||||
|
||||
t = dep->next;
|
||||
/* We might leak dep->name here, but I'm not sure how to fix this: I
|
||||
think that pointer might be shared (e.g., in the file hash?) */
|
||||
dep->name = 0; /* Make sure free_dep does not free name. */
|
||||
free_dep (dep);
|
||||
dep = t;
|
||||
}
|
||||
|
||||
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 (char **targets, char **target_percents,
|
||||
int terminal, struct dep *deps,
|
||||
struct commands *commands, int override)
|
||||
{
|
||||
unsigned int max_targets, i;
|
||||
struct rule *r = (struct rule *) xmalloc (sizeof (struct rule));
|
||||
|
||||
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 (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 (void)
|
||||
{
|
||||
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);
|
||||
#else
|
||||
{
|
||||
int f = (terminal * 1000 + 5) / rules;
|
||||
printf (" (%d.%d%%)", f/10, f%10);
|
||||
}
|
||||
#endif
|
||||
puts (_(" terminal."));
|
||||
}
|
||||
|
||||
if (num_pattern_rules != rules)
|
||||
{
|
||||
/* This can happen if a fatal error was detected while reading the
|
||||
makefiles and thus count_implicit_rule_limits wasn't called yet. */
|
||||
if (num_pattern_rules != 0)
|
||||
fatal (NILF, _("BUG: num_pattern_rules wrong! %u != %u"),
|
||||
num_pattern_rules, rules);
|
||||
}
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
/* Definitions for using pattern rules in GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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 PARAMS ((struct pspec *p, int terminal));
|
||||
extern int new_pattern_rule PARAMS ((struct rule *rule, int override));
|
||||
extern void count_implicit_rule_limits PARAMS ((void));
|
||||
extern void convert_to_pattern PARAMS ((void));
|
||||
extern void create_pattern_rule PARAMS ((char **targets,
|
||||
char **target_percents, int terminal,
|
||||
struct dep *deps,
|
||||
struct commands *commands,
|
||||
int override));
|
||||
@@ -1,255 +0,0 @@
|
||||
/* Convert between signal names and numbers.
|
||||
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
||||
2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
|
||||
/* If the system provides strsignal, we don't need it. */
|
||||
|
||||
#if !HAVE_STRSIGNAL
|
||||
|
||||
/* If the system provides sys_siglist, we'll use that.
|
||||
Otherwise create our own.
|
||||
*/
|
||||
|
||||
#if !HAVE_DECL_SYS_SIGLIST
|
||||
|
||||
/* Some systems do not define NSIG in <signal.h>. */
|
||||
#ifndef NSIG
|
||||
#ifdef _NSIG
|
||||
#define NSIG _NSIG
|
||||
#else
|
||||
#define NSIG 32
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* There is too much variation in Sys V signal numbers and names, so
|
||||
we must initialize them at runtime. */
|
||||
|
||||
static const char *undoc;
|
||||
|
||||
static const char *sys_siglist[NSIG];
|
||||
|
||||
/* Table of abbreviations for signals. Note: A given number can
|
||||
appear more than once with different abbreviations. */
|
||||
#define SIG_TABLE_SIZE (NSIG*2)
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int number;
|
||||
const char *abbrev;
|
||||
} num_abbrev;
|
||||
|
||||
static num_abbrev sig_table[SIG_TABLE_SIZE];
|
||||
|
||||
/* 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 (int number, const char *abbrev, const char *name)
|
||||
{
|
||||
/* If this value is ever greater than NSIG it seems like it'd be a bug in
|
||||
the system headers, but... better safe than sorry. We know, for
|
||||
example, that this isn't always true on VMS. */
|
||||
|
||||
if (number >= 0 && number < NSIG)
|
||||
sys_siglist[number] = name;
|
||||
|
||||
if (sig_table_nelts < SIG_TABLE_SIZE)
|
||||
{
|
||||
sig_table[sig_table_nelts].number = number;
|
||||
sig_table[sig_table_nelts++].abbrev = abbrev;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
signame_init (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
undoc = xstrdup (_("unknown signal"));
|
||||
|
||||
/* Initialize signal names. */
|
||||
for (i = 0; i < NSIG; i++)
|
||||
sys_siglist[i] = undoc;
|
||||
|
||||
/* 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
|
||||
#if defined (SIGINFO)
|
||||
init_sig (SIGINFO, "INFO", _("Information request"));
|
||||
#endif
|
||||
#if defined (SIGNOFP)
|
||||
init_sig (SIGNOFP, "NOFP", _("Floating point co-processor not available"));
|
||||
#endif
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
#endif /* HAVE_DECL_SYS_SIGLIST */
|
||||
|
||||
|
||||
char *
|
||||
strsignal (int signal)
|
||||
{
|
||||
static char buf[] = "Signal 12345678901234567890";
|
||||
|
||||
#if ! HAVE_DECL_SYS_SIGLIST
|
||||
# if HAVE_DECL__SYS_SIGLIST
|
||||
# define sys_siglist _sys_siglist
|
||||
# elif HAVE_DECL___SYS_SIGLIST
|
||||
# define sys_siglist __sys_siglist
|
||||
# else
|
||||
static char sig_initted = 0;
|
||||
|
||||
if (!sig_initted)
|
||||
sig_initted = signame_init ();
|
||||
# endif
|
||||
#endif
|
||||
|
||||
if (signal > 0 || signal < NSIG)
|
||||
return (char *) sys_siglist[signal];
|
||||
|
||||
sprintf (buf, "Signal %d", signal);
|
||||
return buf;
|
||||
}
|
||||
|
||||
#endif /* HAVE_STRSIGNAL */
|
||||
@@ -1,216 +0,0 @@
|
||||
/* Constant string caching for GNU Make.
|
||||
Copyright (C) 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
#include "hash.h"
|
||||
|
||||
/* The size (in bytes) of each cache buffer. */
|
||||
#define CACHE_BUFFER_SIZE (4096)
|
||||
|
||||
|
||||
/* A string cached here will never be freed, so we don't need to worry about
|
||||
reference counting. We just store the string, and then remember it in a
|
||||
hash so it can be looked up again. */
|
||||
|
||||
struct strcache {
|
||||
struct strcache *next; /* The next block of strings. */
|
||||
char *end; /* Pointer to the beginning of the free space. */
|
||||
int count; /* # of strings in this buffer (for stats). */
|
||||
int bytesfree; /* The amount of the buffer that is free. */
|
||||
char buffer[1]; /* The buffer comes after this. */
|
||||
};
|
||||
|
||||
static int bufsize = CACHE_BUFFER_SIZE;
|
||||
static struct strcache *strcache = NULL;
|
||||
|
||||
static struct strcache *
|
||||
new_cache()
|
||||
{
|
||||
struct strcache *new;
|
||||
new = (struct strcache *) xmalloc (sizeof (*new) + bufsize);
|
||||
new->end = new->buffer;
|
||||
new->count = 0;
|
||||
new->bytesfree = bufsize;
|
||||
|
||||
new->next = strcache;
|
||||
strcache = new;
|
||||
|
||||
return new;
|
||||
}
|
||||
|
||||
static const char *
|
||||
add_string(const char *str, int len)
|
||||
{
|
||||
struct strcache *best = NULL;
|
||||
struct strcache *sp;
|
||||
const char *res;
|
||||
|
||||
/* If the string we want is too large to fit into a single buffer, then we're
|
||||
screwed; nothing will ever fit! Change the maximum size of the cache to
|
||||
be big enough. */
|
||||
if (len > bufsize)
|
||||
bufsize = len * 2;
|
||||
|
||||
/* First, find a cache with enough free space. We always look through all
|
||||
the blocks and choose the one with the best fit (the one that leaves the
|
||||
least amount of space free). */
|
||||
for (sp = strcache; sp != NULL; sp = sp->next)
|
||||
if (sp->bytesfree > len && (!best || best->bytesfree > sp->bytesfree))
|
||||
best = sp;
|
||||
|
||||
/* If nothing is big enough, make a new cache. */
|
||||
if (!best)
|
||||
best = new_cache();
|
||||
|
||||
assert (best->bytesfree > len);
|
||||
|
||||
/* Add the string to the best cache. */
|
||||
res = best->end;
|
||||
memcpy (best->end, str, len);
|
||||
best->end += len;
|
||||
*(best->end++) = '\0';
|
||||
best->bytesfree -= len + 1;
|
||||
++best->count;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/* Hash table of strings in the cache. */
|
||||
|
||||
static unsigned long
|
||||
str_hash_1 (const void *key)
|
||||
{
|
||||
return_ISTRING_HASH_1 ((const char *) key);
|
||||
}
|
||||
|
||||
static unsigned long
|
||||
str_hash_2 (const void *key)
|
||||
{
|
||||
return_ISTRING_HASH_2 ((const char *) key);
|
||||
}
|
||||
|
||||
static int
|
||||
str_hash_cmp (const void *x, const void *y)
|
||||
{
|
||||
return_ISTRING_COMPARE ((const char *) x, (const char *) y);
|
||||
}
|
||||
|
||||
static struct hash_table strings;
|
||||
|
||||
static const char *
|
||||
add_hash (const char *str, int len)
|
||||
{
|
||||
/* Look up the string in the hash. If it's there, return it. */
|
||||
char **slot = (char **) hash_find_slot (&strings, str);
|
||||
const char *key = *slot;
|
||||
|
||||
if (!HASH_VACANT (key))
|
||||
return key;
|
||||
|
||||
/* Not there yet so add it to a buffer, then into the hash table. */
|
||||
key = add_string (str, len);
|
||||
hash_insert_at (&strings, key, slot);
|
||||
return key;
|
||||
}
|
||||
|
||||
/* Returns true if the string is in the cache; false if not. */
|
||||
int
|
||||
strcache_iscached (const char *str)
|
||||
{
|
||||
struct strcache *sp;
|
||||
|
||||
for (sp = strcache; sp != 0; sp = sp->next)
|
||||
if (str >= sp->buffer && str < sp->end)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* If the string is already in the cache, return a pointer to the cached
|
||||
version. If not, add it then return a pointer to the cached version.
|
||||
Note we do NOT take control of the string passed in. */
|
||||
const char *
|
||||
strcache_add (const char *str)
|
||||
{
|
||||
return add_hash (str, strlen (str));
|
||||
}
|
||||
|
||||
const char *
|
||||
strcache_add_len (const char *str, int len)
|
||||
{
|
||||
char *key = alloca (len + 1);
|
||||
memcpy (key, str, len);
|
||||
key[len] = '\0';
|
||||
|
||||
return add_hash (key, len);
|
||||
}
|
||||
|
||||
int
|
||||
strcache_setbufsize(int size)
|
||||
{
|
||||
if (size > bufsize)
|
||||
bufsize = size;
|
||||
return bufsize;
|
||||
}
|
||||
|
||||
void
|
||||
strcache_init (void)
|
||||
{
|
||||
hash_init (&strings, 1000, str_hash_1, str_hash_2, str_hash_cmp);
|
||||
}
|
||||
|
||||
|
||||
/* Generate some stats output. */
|
||||
|
||||
void
|
||||
strcache_print_stats (const char *prefix)
|
||||
{
|
||||
int numbuffs = 0, numstrs = 0;
|
||||
int totsize = 0, avgsize, maxsize = 0, minsize = bufsize;
|
||||
int totfree = 0, avgfree, maxfree = 0, minfree = bufsize;
|
||||
const struct strcache *sp;
|
||||
|
||||
for (sp = strcache; sp != NULL; sp = sp->next)
|
||||
{
|
||||
int bf = sp->bytesfree;
|
||||
int sz = (sp->end - sp->buffer) + bf;
|
||||
|
||||
++numbuffs;
|
||||
numstrs += sp->count;
|
||||
|
||||
totsize += sz;
|
||||
maxsize = (sz > maxsize ? sz : maxsize);
|
||||
minsize = (sz < minsize ? sz : minsize);
|
||||
|
||||
totfree += bf;
|
||||
maxfree = (bf > maxfree ? bf : maxfree);
|
||||
minfree = (bf < minfree ? bf : minfree);
|
||||
}
|
||||
|
||||
avgsize = numbuffs ? (int)(totsize / numbuffs) : 0;
|
||||
avgfree = numbuffs ? (int)(totfree / numbuffs) : 0;
|
||||
|
||||
printf (_("\n%s # of strings in strcache: %d\n"), prefix, numstrs);
|
||||
printf (_("%s # of strcache buffers: %d\n"), prefix, numbuffs);
|
||||
printf (_("%s strcache size: total = %d / max = %d / min = %d / avg = %d\n"),
|
||||
prefix, totsize, maxsize, minsize, avgsize);
|
||||
printf (_("%s strcache free: total = %d / max = %d / min = %d / avg = %d\n"),
|
||||
prefix, totfree, maxfree, minfree, avgfree);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,200 +0,0 @@
|
||||
/* Definitions for using variables in GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "hash.h"
|
||||
|
||||
/* 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. */
|
||||
};
|
||||
|
||||
enum variable_flavor
|
||||
{
|
||||
f_bogus, /* Bogus (error) */
|
||||
f_simple, /* Simple definition (:=) */
|
||||
f_recursive, /* Recursive definition (=) */
|
||||
f_append, /* Appending definition (+=) */
|
||||
f_conditional /* Conditional definition (?=) */
|
||||
};
|
||||
|
||||
/* Structure that represents one variable definition.
|
||||
Each bucket of the hash table is a chain of these,
|
||||
chained through `next'. */
|
||||
|
||||
#define EXP_COUNT_BITS 15 /* This gets all the bitfields into 32 bits */
|
||||
#define EXP_COUNT_MAX ((1<<EXP_COUNT_BITS)-1)
|
||||
|
||||
struct variable
|
||||
{
|
||||
char *name; /* Variable name. */
|
||||
int length; /* strlen (name) */
|
||||
char *value; /* Variable value. */
|
||||
struct floc fileinfo; /* Where the variable was defined. */
|
||||
unsigned int recursive:1; /* Gets recursively re-evaluated. */
|
||||
unsigned int append:1; /* Nonzero if an appending target-specific
|
||||
variable. */
|
||||
unsigned int conditional:1; /* Nonzero if set with a ?=. */
|
||||
unsigned int per_target:1; /* Nonzero if a target-specific variable. */
|
||||
unsigned int special:1; /* Nonzero if this is a special variable. */
|
||||
unsigned int exportable:1; /* Nonzero if the variable _could_ be
|
||||
exported. */
|
||||
unsigned int expanding:1; /* Nonzero if currently being expanded. */
|
||||
unsigned int exp_count:EXP_COUNT_BITS;
|
||||
/* If >1, allow this many self-referential
|
||||
expansions. */
|
||||
enum variable_flavor
|
||||
flavor ENUM_BITFIELD (3); /* Variable flavor. */
|
||||
enum variable_origin
|
||||
origin ENUM_BITFIELD (3); /* Variable origin. */
|
||||
enum variable_export
|
||||
{
|
||||
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 hash_table table; /* Hash table of variables. */
|
||||
};
|
||||
|
||||
/* 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. */
|
||||
};
|
||||
|
||||
/* Structure used for pattern-specific variables. */
|
||||
|
||||
struct pattern_var
|
||||
{
|
||||
struct pattern_var *next;
|
||||
char *target;
|
||||
unsigned int len;
|
||||
char *suffix;
|
||||
struct variable variable;
|
||||
};
|
||||
|
||||
extern char *variable_buffer;
|
||||
extern struct variable_set_list *current_variable_set_list;
|
||||
|
||||
/* expand.c */
|
||||
extern char *variable_buffer_output PARAMS ((char *ptr, char *string, unsigned int length));
|
||||
extern char *variable_expand PARAMS ((char *line));
|
||||
extern char *variable_expand_for_file PARAMS ((char *line, struct file *file));
|
||||
extern char *allocated_variable_expand_for_file PARAMS ((char *line, struct file *file));
|
||||
#define allocated_variable_expand(line) \
|
||||
allocated_variable_expand_for_file (line, (struct file *) 0)
|
||||
extern char *expand_argument PARAMS ((const char *str, const char *end));
|
||||
extern char *variable_expand_string PARAMS ((char *line, char *string,
|
||||
long length));
|
||||
extern void install_variable_buffer PARAMS ((char **bufp, unsigned int *lenp));
|
||||
extern void restore_variable_buffer PARAMS ((char *buf, unsigned int len));
|
||||
|
||||
/* function.c */
|
||||
extern int handle_function PARAMS ((char **op, char **stringp));
|
||||
extern int pattern_matches PARAMS ((char *pattern, char *percent, char *str));
|
||||
extern char *subst_expand PARAMS ((char *o, char *text, char *subst, char *replace,
|
||||
unsigned int slen, unsigned int rlen, int by_word));
|
||||
extern char *patsubst_expand PARAMS ((char *o, char *text, char *pattern, char *replace,
|
||||
char *pattern_percent, char *replace_percent));
|
||||
|
||||
/* expand.c */
|
||||
extern char *recursively_expand_for_file PARAMS ((struct variable *v,
|
||||
struct file *file));
|
||||
#define recursively_expand(v) recursively_expand_for_file (v, NULL)
|
||||
|
||||
/* variable.c */
|
||||
extern struct variable_set_list *create_new_variable_set PARAMS ((void));
|
||||
extern void free_variable_set PARAMS ((struct variable_set_list *));
|
||||
extern struct variable_set_list *push_new_variable_scope PARAMS ((void));
|
||||
extern void pop_variable_scope PARAMS ((void));
|
||||
extern void define_automatic_variables PARAMS ((void));
|
||||
extern void initialize_file_variables PARAMS ((struct file *file, int read));
|
||||
extern void print_file_variables PARAMS ((struct file *file));
|
||||
extern void print_variable_set PARAMS ((struct variable_set *set, char *prefix));
|
||||
extern void merge_variable_set_lists PARAMS ((struct variable_set_list **to_list, struct variable_set_list *from_list));
|
||||
extern struct variable *do_variable_definition PARAMS ((const struct floc *flocp, const char *name, char *value, enum variable_origin origin, enum variable_flavor flavor, int target_var));
|
||||
extern struct variable *parse_variable_definition PARAMS ((struct variable *v, char *line));
|
||||
extern struct variable *try_variable_definition PARAMS ((const struct floc *flocp, char *line, enum variable_origin origin, int target_var));
|
||||
extern void init_hash_global_variable_set PARAMS ((void));
|
||||
extern void hash_init_function_table PARAMS ((void));
|
||||
extern struct variable *lookup_variable PARAMS ((const char *name, unsigned int length));
|
||||
extern struct variable *lookup_variable_in_set PARAMS ((const char *name,
|
||||
unsigned int length,
|
||||
const struct variable_set *set));
|
||||
|
||||
extern struct variable *define_variable_in_set
|
||||
PARAMS ((const char *name, unsigned int length, char *value,
|
||||
enum variable_origin origin, int recursive,
|
||||
struct variable_set *set, const struct floc *flocp));
|
||||
|
||||
/* Define a variable in the current variable set. */
|
||||
|
||||
#define define_variable(n,l,v,o,r) \
|
||||
define_variable_in_set((n),(l),(v),(o),(r),\
|
||||
current_variable_set_list->set,NILF)
|
||||
|
||||
/* Define a variable with a location in the current variable set. */
|
||||
|
||||
#define define_variable_loc(n,l,v,o,r,f) \
|
||||
define_variable_in_set((n),(l),(v),(o),(r),\
|
||||
current_variable_set_list->set,(f))
|
||||
|
||||
/* Define a variable with a location in the global variable set. */
|
||||
|
||||
#define define_variable_global(n,l,v,o,r,f) \
|
||||
define_variable_in_set((n),(l),(v),(o),(r),NULL,(f))
|
||||
|
||||
/* Define a variable in FILE's variable set. */
|
||||
|
||||
#define define_variable_for_file(n,l,v,o,r,f) \
|
||||
define_variable_in_set((n),(l),(v),(o),(r),(f)->variables->set,NILF)
|
||||
|
||||
/* Warn that NAME is an undefined variable. */
|
||||
|
||||
#define warn_undefined(n,l) do{\
|
||||
if (warn_undefined_variables_flag) \
|
||||
error (reading_file, \
|
||||
_("warning: undefined variable `%.*s'"), \
|
||||
(int)(l), (n)); \
|
||||
}while(0)
|
||||
|
||||
extern char **target_environment PARAMS ((struct file *file));
|
||||
|
||||
extern struct pattern_var *create_pattern_var PARAMS ((char *target, char *suffix));
|
||||
|
||||
extern int export_all_variables;
|
||||
|
||||
#define MAKELEVEL_NAME "MAKELEVEL"
|
||||
#define MAKELEVEL_LENGTH (sizeof (MAKELEVEL_NAME) - 1)
|
||||
@@ -1,35 +0,0 @@
|
||||
/* Record version and build host architecture for GNU make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
/* We use <config.h> 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 <config.h>
|
||||
|
||||
#ifndef MAKE_HOST
|
||||
# define MAKE_HOST "unknown"
|
||||
#endif
|
||||
|
||||
char *version_string = VERSION;
|
||||
char *make_host = MAKE_HOST;
|
||||
|
||||
/*
|
||||
Local variables:
|
||||
version-control: never
|
||||
End:
|
||||
*/
|
||||
@@ -1,605 +0,0 @@
|
||||
/* Implementation of pattern-matching file search paths for GNU Make.
|
||||
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
|
||||
1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
|
||||
|
||||
#include "make.h"
|
||||
#include "filedef.h"
|
||||
#include "variable.h"
|
||||
#ifdef WINDOWS32
|
||||
#include "pathstuff.h"
|
||||
#endif
|
||||
|
||||
|
||||
/* 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;
|
||||
|
||||
/* Structure for GPATH given in the variable. */
|
||||
|
||||
static struct vpath *gpaths;
|
||||
|
||||
static int selective_vpath_search PARAMS ((struct vpath *path, char **file, FILE_TIMESTAMP *mtime_ptr));
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
/* If there is a GPATH variable with a nonnull value, construct the
|
||||
GPATH 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 $(GPATH))");
|
||||
|
||||
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 GPATH,
|
||||
and restore the old list of vpaths. */
|
||||
gpaths = 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 the path element separator (defined in make.h) 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 (char *pattern, char *dirpath)
|
||||
{
|
||||
register unsigned int elem;
|
||||
register char *p;
|
||||
register char **vpath;
|
||||
register unsigned int maxvpath;
|
||||
unsigned int maxelem;
|
||||
char *percent = NULL;
|
||||
|
||||
if (pattern != 0)
|
||||
{
|
||||
pattern = xstrdup (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;
|
||||
}
|
||||
|
||||
#ifdef WINDOWS32
|
||||
convert_vpath_to_windows32(dirpath, ';');
|
||||
#endif
|
||||
|
||||
/* Figure out the maximum number of VPATH entries and put it in
|
||||
MAXELEM. We start with 2, one before the first separator and one
|
||||
nil (the list terminator) and increment our estimated number for
|
||||
each separator or blank we find. */
|
||||
maxelem = 2;
|
||||
p = dirpath;
|
||||
while (*p != '\0')
|
||||
if (*p++ == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
|
||||
++maxelem;
|
||||
|
||||
vpath = (char **) xmalloc (maxelem * sizeof (char *));
|
||||
maxvpath = 0;
|
||||
|
||||
/* Skip over any initial separators and blanks. */
|
||||
p = dirpath;
|
||||
while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
|
||||
++p;
|
||||
|
||||
elem = 0;
|
||||
while (*p != '\0')
|
||||
{
|
||||
char *v;
|
||||
unsigned int len;
|
||||
|
||||
/* Find the end of this entry. */
|
||||
v = p;
|
||||
while (*p != '\0' && *p != PATH_SEPARATOR_CHAR
|
||||
&& !isblank ((unsigned char)*p))
|
||||
++p;
|
||||
|
||||
len = p - v;
|
||||
/* Make sure there's no trailing slash,
|
||||
but still allow "/" as a directory. */
|
||||
#if defined(__MSDOS__) || defined(__EMX__)
|
||||
/* We need also to leave alone a trailing slash in "d:/". */
|
||||
if (len > 3 || (len > 1 && v[1] != ':'))
|
||||
#endif
|
||||
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 separators and blanks between entries. */
|
||||
while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*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 GPATH list for a pathname string that matches the one passed
|
||||
in. If it is found, return 1. Otherwise we return 0. */
|
||||
|
||||
int
|
||||
gpath_search (char *file, unsigned int len)
|
||||
{
|
||||
char **gp;
|
||||
|
||||
if (gpaths && (len <= gpaths->maxlen))
|
||||
for (gp = gpaths->searchpath; *gp != NULL; ++gp)
|
||||
if (strneq (*gp, file, len) && (*gp)[len] == '\0')
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 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 (char **file, FILE_TIMESTAMP *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 == '/'
|
||||
#ifdef HAVE_DOS_PATHS
|
||||
|| **file == '\\'
|
||||
|| (*file)[1] == ':'
|
||||
#endif
|
||||
|| (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 (struct vpath *path, char **file,
|
||||
FILE_TIMESTAMP *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 = strrchr (*file, '/');
|
||||
#ifdef HAVE_DOS_PATHS
|
||||
/* We need the rightmost slash or backslash. */
|
||||
{
|
||||
char *bslash = strrchr(*file, '\\');
|
||||
if (!n || bslash > n)
|
||||
n = bslash;
|
||||
}
|
||||
#endif
|
||||
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 *) xmalloc (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)
|
||||
{
|
||||
#ifndef VMS
|
||||
*n++ = '/';
|
||||
#endif
|
||||
bcopy (*file, n, name_dplen);
|
||||
n += name_dplen;
|
||||
}
|
||||
|
||||
#ifdef HAVE_DOS_PATHS
|
||||
/* Cause the next if to treat backslash and slash alike. */
|
||||
if (n != name && n[-1] == '\\' )
|
||||
n[-1] = '/';
|
||||
#endif
|
||||
/* Now add the name-within-directory at the end of NAME. */
|
||||
#ifndef VMS
|
||||
if (n != name && n[-1] != '/')
|
||||
{
|
||||
*n = '/';
|
||||
bcopy (filename, n + 1, flen + 1);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
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 this restriction to allow a file
|
||||
to be chosen if it is mentioned as a target in a makefile. This
|
||||
seem logical.
|
||||
|
||||
Special handling for -W / -o: make sure we preserve the special
|
||||
values here. Actually this whole thing is a little bogus: I think
|
||||
we should ditch the name/hname thing and look into the renamed
|
||||
capability that already exists for files: that is, have a new struct
|
||||
file* entry for the VPATH-found file, and set the renamed field if
|
||||
we use it.
|
||||
*/
|
||||
{
|
||||
struct file *f = lookup_file (name);
|
||||
if (f != 0)
|
||||
{
|
||||
exists = not_target || f->is_target;
|
||||
if (exists && mtime_ptr
|
||||
&& (f->last_mtime == OLD_MTIME || f->last_mtime == NEW_MTIME))
|
||||
{
|
||||
*mtime_ptr = f->last_mtime;
|
||||
mtime_ptr = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!exists)
|
||||
{
|
||||
/* That file wasn't mentioned in the makefile.
|
||||
See if it actually exists. */
|
||||
|
||||
#ifdef VMS
|
||||
exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
|
||||
#else
|
||||
/* 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);
|
||||
#endif
|
||||
}
|
||||
|
||||
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;
|
||||
|
||||
#ifndef VMS
|
||||
/* Put the slash back in NAME. */
|
||||
*n = '/';
|
||||
#endif
|
||||
|
||||
if (exists_in_cache) /* Makefile-mentioned file need not exist. */
|
||||
{
|
||||
int e;
|
||||
|
||||
EINTRLOOP (e, stat (name, &st)); /* Does it really exist? */
|
||||
if (e != 0)
|
||||
{
|
||||
exists = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Store the modtime into *MTIME_PTR for the caller. */
|
||||
if (mtime_ptr != 0)
|
||||
{
|
||||
*mtime_ptr = FILE_TIMESTAMP_STAT_MODTIME (name, st);
|
||||
mtime_ptr = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* We have found a file.
|
||||
Store the name we found into *FILE for the caller. */
|
||||
|
||||
*file = savestring (name, (n + 1 - name) + flen);
|
||||
|
||||
/* If we get here and mtime_ptr hasn't been set, record
|
||||
UNKNOWN_MTIME to indicate this. */
|
||||
if (mtime_ptr != 0)
|
||||
*mtime_ptr = UNKNOWN_MTIME;
|
||||
|
||||
free (name);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
free (name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Print the data base of VPATH search paths. */
|
||||
|
||||
void
|
||||
print_vpath_data_base (void)
|
||||
{
|
||||
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' : PATH_SEPARATOR_CHAR);
|
||||
}
|
||||
|
||||
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' : PATH_SEPARATOR_CHAR);
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
** 14-Oct-2001, Lars Düning **
|
||||
- RELEASE 1.7
|
||||
- (main, args) New options '--no-warn-exit' to return a zero exitcode
|
||||
('success') when a warning was generated (for use in Makefiles).
|
||||
- (main, args) New options '--ignore-missing' to ignore missing include
|
||||
files (apart from printing a diagnostic).
|
||||
- (Makefile, libglob/Makefile) Added x86->PPC cross-compilation.
|
||||
|
||||
** 01-Mar-2000, Lars Düning **
|
||||
- RELEASE 1.6
|
||||
- (main, args, nodes) New option '--select' to narrow the dependency
|
||||
generation to a few selected files.
|
||||
- (Makefile, libglob/Makefile) Added crosscompilation PPC->x86.
|
||||
|
||||
** 03-Feb-1999, Lars Düning **
|
||||
- (main, args) When out of memory, the error message also contains a slightly
|
||||
cryptic hint where the program failed.
|
||||
- (Makefile) The 'archive' target also creates a checksum file for the
|
||||
archive, using the /bin/cksum command.
|
||||
The .dependencies are included only when no 'clean' or 'clobber' is
|
||||
requested (this solves the behavior Dianne noticed, that a 'make clean'
|
||||
first recreates .dependencies only to delete it again).
|
||||
|
||||
** 02-Feb-1999, Lars Düning **
|
||||
- (args.*) All information about an include directory is now combined
|
||||
in one structure.
|
||||
- (main.c, nodes.*) Rewrote the file identification and searching routines,
|
||||
the old code failed to discriminate files which are included from
|
||||
different directories.
|
||||
- (util.*) New.
|
||||
|
||||
- (getargs.c) A long option matched even when only the first characters
|
||||
were given. A test for the proper length corrected this.
|
||||
|
||||
** 25-Nov-1998, Lars Düning **
|
||||
- (getargs.c) A long option matched even when only the first characters
|
||||
were given. A test for the proper length corrected this.
|
||||
|
||||
** 01-Nov-1998, Lars Düning **
|
||||
- (getargs.c) If a value for an option was missing, the parser printed
|
||||
the wrong option name in the error message.
|
||||
|
||||
** 25-Oct-1998, Lars Düning **
|
||||
- RELEASE 1.4.5
|
||||
- (Makefile, libglob/Makefile) Adapted for R4 compilations.
|
||||
- (Makefile) Improved the dependency generation: dependencies are
|
||||
kept in the file .dependencies; and the rule is clever enough
|
||||
to fall back to the compiler facilities if mkdepend is not
|
||||
on the system.
|
||||
- (getargs) Separated the commandline parser into here.
|
||||
- (args) New options '--longhelp' to print a long help text, and
|
||||
'--version' to print the program version.
|
||||
'--include' distinguishes between normal and system include paths.
|
||||
- (main) Default file suffixes now also cover a whole range of
|
||||
C++ suffixes (.cc, .cpp, .cxx, .cc).
|
||||
Filenames with embedded spaces are written in quotes.
|
||||
- (nodes, reader, main) Added support for system includes.
|
||||
|
||||
** 15-Oct-1998, Lars Düning **
|
||||
- (main.c) The name for the makefile backup was allocated one character
|
||||
too short.
|
||||
|
||||
** 04-Jul-1998, Lars Düning **
|
||||
- RELEASE 1.4
|
||||
RCS-Name is 'Rel-1_4', State is 'Rel'.
|
||||
- Converted the program to BeOS. I decided to not keep the old Amiga
|
||||
code - it's available on Aminet and I won't further develop it anyway.
|
||||
New files: LICENSE.
|
||||
Changed files: Just about everything else.
|
||||
- Added libglob/ for filename globbing.
|
||||
|
||||
** 02-Mar-1996, Lars Düning **
|
||||
- RELEASE 1.3
|
||||
- Oops, when confronted with target/source relations, MkDepend put the
|
||||
source name into the dependency list as well. Though intentional, this
|
||||
had the potential to confuse implicit make rules. Now this behaviour
|
||||
is optional, triggered by specifying '+' with the object extension.
|
||||
(main.c, args.ch)
|
||||
- RCS tweaks to the Makefiles.
|
||||
|
||||
** 25-Feb-1996, Lars Düning **
|
||||
- RELEASE 1.2
|
||||
- main.c (output_tree, output): Added output of includers of a file.
|
||||
- main.c (readfiles): If a file can't be found, it's users known so far
|
||||
are printed in the warning notice.
|
||||
- nodes.c,h: Added .pUsers (List of includers of this file) to the Node
|
||||
structure, extended routines nodes_depend() and nodes_deplist()
|
||||
accordingly.
|
||||
- Put under RCS (the Makefiles still need tweaking for this, though).
|
||||
|
||||
** 04-Feb-1996, Lars Düning **
|
||||
- main.c (output, getargs, main): The program is now able to write the
|
||||
list of dependencies into a separate file as well.
|
||||
- main.c (output_tree): New to write the dependency tree into a file.
|
||||
- args.ch, main.c: Exported argument parsing into args.c.
|
||||
- reader.c (reader_openrw): Immediate writing if no file to read is
|
||||
opened is now possible.
|
||||
|
||||
** 13-Oct-1995, Lars Düning **
|
||||
- RELEASE 1.1
|
||||
- reader.c (reader_copymake2): Copies the remainder of the original
|
||||
Makefile starting with the second tagline.
|
||||
|
||||
** 12-Oct-1995, Lars Düning **
|
||||
- main.c (make_objname): %p pattern expanded to %[-][<][<number>]p.
|
||||
- Makefile, DMakefile: Making the 'archive' missed some files.
|
||||
|
||||
** 18-Sep-1995, Lars Düning **
|
||||
- RELEASE 1.0
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
SubDir HAIKU_TOP src bin mkdepend ;
|
||||
|
||||
SetSubDirSupportedPlatformsBeOSCompatible ;
|
||||
|
||||
SubDirHdrs [ FDirName $(SUBDIR) .. make glob ] ;
|
||||
|
||||
BinCommand mkdepend :
|
||||
args.c
|
||||
getargs.c
|
||||
main.c
|
||||
reader.c
|
||||
nodes.c
|
||||
util.c
|
||||
: <make>libglob.a : mkdepend.rdef ;
|
||||
@@ -1,28 +0,0 @@
|
||||
MkDepend License
|
||||
|
||||
Copyright (c) 1995-2000, Lars Düning.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
- Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
- Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
- Modifications of the original software, in parts or as a whole,
|
||||
must be clearly recognizable as such.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
$Id: LICENSE 1.2 Wed, 01 Mar 2000 21:15:40 -0700 lars $
|
||||
@@ -1,622 +0,0 @@
|
||||
$Id: MkDepend.doc 1.10 Wed, 01 Mar 2000 21:15:40 -0700 lars $
|
||||
|
||||
MkDepend 1.7
|
||||
|
||||
Copyright (c) 1995-2001 by Lars Düning
|
||||
All Rights Reserved.
|
||||
|
||||
|
||||
"Good information are hard to get. It is even more difficult to put
|
||||
it into use." -- Sherlock Holmes
|
||||
|
||||
|
||||
Introduction
|
||||
------------
|
||||
Makefiles are very useful in the development of larger program systems,
|
||||
as they notate the various dependencies and associated needed actions
|
||||
in a machine-useable notation. Unfortunately it's the most important
|
||||
dependency between C sources and their includes which have to be
|
||||
maintained by hand, a most boring and errorprone task.
|
||||
|
||||
MkDepend is one of those programs which attempt to automate this part
|
||||
of development by scanning source files for includes and repeating this
|
||||
step recursively until the complete transitive closure of included files
|
||||
is determined. The found dependencies are then written into an existing
|
||||
makefile, keeping it up to date, and/or into a separate file (the 'depfile')
|
||||
for use by the makefile or for documentary purposes.
|
||||
|
||||
The advantage of using MkDepend instead of the built-in dependency
|
||||
facilities of modern compilers is that (a) MkDepend is faster,
|
||||
(b) simplifies the maintenance of multiple and/or portable Makefiles,
|
||||
and (c) you can modify it for your special needs.
|
||||
|
||||
|
||||
Usage
|
||||
-----
|
||||
MkDepend is a shell-only program, compiled for R4.5
|
||||
|
||||
|
||||
mkdepend {-i|-I|--include <includepath>[::<symbol>]}
|
||||
{-x|--except <filepattern>}
|
||||
{-S|--select <filepattern>}
|
||||
{-s|--suffix <src_ext>{,<src_ext>}[+][:<obj_ext>] | [+]:<obj_ext>}
|
||||
{-p|--objpat <src_ext>{,<src_ext>}[+]:<obj_pattern>}
|
||||
[-f|--file <makefile>]
|
||||
[-d|--dep <depfile>]
|
||||
[-l|--flat]
|
||||
[-m|--ignore-missing]
|
||||
[-w|--no-warn-exit]
|
||||
[-v|--verbose]
|
||||
[-h|-?|--help|--longhelp]
|
||||
[-V|--version]
|
||||
{<filename>}
|
||||
|
||||
|
||||
All option keywords are case sensitive. The space between the short
|
||||
form of the keywords and their operands may be omitted. For example
|
||||
|
||||
mkdepend -I/include
|
||||
mkdepend -i /include
|
||||
mkdepend -I=/include
|
||||
mkdepend --include=/include
|
||||
mkdepend --include /include
|
||||
|
||||
are all equivalent. Several short options may be combined, but only
|
||||
one of them may take an argument, and it must be the last one. For
|
||||
example:
|
||||
|
||||
mkdepend -vl
|
||||
mkdepend -vf Makefile
|
||||
|
||||
are legal, but
|
||||
|
||||
mkdepend -fv Makefile
|
||||
|
||||
will be misunderstood as 'mkdepend -f=v Makefile'.
|
||||
|
||||
The option '--' is special in that it marks the end of all option
|
||||
recognition. All following arguments are considered filenames even
|
||||
if they start with '-' or '--'.
|
||||
|
||||
|
||||
General Operation
|
||||
-----------------
|
||||
|
||||
MkDepend is given a 'skeleton' of C source files and searches them for
|
||||
included files. The includes found are recursively searched for includes
|
||||
themselves, until the complete transitive closure has been determined.
|
||||
MkDepend searches the includes first in the current directory, then in
|
||||
the given paths (if any), imitating the C preprocessor's behaviour.
|
||||
The files are scanned for include statements of the form
|
||||
|
||||
#include "filename"
|
||||
#include <filename>
|
||||
|
||||
excluding those which are commented out using C-style /* */- or
|
||||
C++-style //-comments. Every other content of the files is ignored.
|
||||
|
||||
After all includes have been found, the dependencies are written into
|
||||
a makefile (creating it if necessary). The makefile is searched for
|
||||
a line
|
||||
|
||||
# --- DO NOT MODIFY THIS LINE -- AUTO-DEPENDS FOLLOW ---
|
||||
|
||||
after which MkDepend adds the dependencies, overwriting old ones, then
|
||||
terminating the dependencies with the line
|
||||
|
||||
# --- DO NOT MODIFY THIS LINE -- AUTO-DEPENDS PRECEDE ---
|
||||
|
||||
Text following the second tagline in the makefile is not modified.
|
||||
|
||||
If the first tagline is not found, the tagged dependencies are simply
|
||||
appended to the file. Existing makefiles are modified by renaming it
|
||||
to <origname>.bak and then re-creating the makefile by copying the
|
||||
data not to be modified.
|
||||
|
||||
The found dependencies for the 'skeleton' files are written as
|
||||
|
||||
<skeleton> : <included file 1> <included file 2>...
|
||||
|
||||
Lines are limited to 80 chars, longer entries are folded into several
|
||||
lines, ending each but the last line with a backslash (\). If a
|
||||
name contains spaces, it is written within double quotes.
|
||||
|
||||
MkDepend can be taught to know about source/object file relationships
|
||||
to be used in the entries written. E,g, the entry generated for a typical
|
||||
C source file would be of the form
|
||||
|
||||
<skeleton>.o : <include 1> <include 2> ...
|
||||
|
||||
Includes appear with that path in the list under which MkDepend found
|
||||
them. To support multi-platform development, replacement texts may
|
||||
be specified for the paths which are then used instead in the output.
|
||||
|
||||
|
||||
For documentary purposes MkDepend may additionally (or instead) write
|
||||
the dependencies into a separate file, either as flat lists or in
|
||||
tree form. Here it writes the 'a includes b' relationships in the
|
||||
form "a <- b" as well as the 'b is included by a' relationsships
|
||||
in the form "b -> a".
|
||||
|
||||
|
||||
Selected-File Operation
|
||||
-----------------------
|
||||
|
||||
MkDepend can be instructed just look for dependencies involving
|
||||
some selected include files. This mode is activated by the use
|
||||
of one or more '-S' arguments; and the output in this mode is
|
||||
restricted to just the skeleton and the selected file.
|
||||
|
||||
For example, where a normal MkDepend run would generate
|
||||
|
||||
foobar.o : foobar.h yacc.tab.h main.h
|
||||
|
||||
call MkDepend with the argument '-S yacc.tab.h' would reduce this output
|
||||
to
|
||||
|
||||
foobar.o : yacc.tab.h
|
||||
|
||||
In the Makefile, these selected dependencies are put between
|
||||
|
||||
# --- DO NOT MODIFY THIS LINE -- SELECTED AUTO-DEPENDS FOLLOW ---
|
||||
# --- DO NOT MODIFY THIS LINE -- SELECTED AUTO-DEPENDS PRECEDE ---
|
||||
|
||||
delimiter lines, so that both kinds of operations can be used on the
|
||||
same Makefile.
|
||||
|
||||
|
||||
In addition, the output of the other dependency files is modified in
|
||||
a similar way.
|
||||
|
||||
|
||||
Arguments
|
||||
---------
|
||||
|
||||
<filepattern>
|
||||
|
||||
Any command argument not recognizable as option is considered as
|
||||
specification of one of the 'skeleton' sources.
|
||||
Wildcards are recognized.
|
||||
|
||||
Default: *.c
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend *.c *.cc grammar.y
|
||||
|
||||
All files ending in ".c" or ".cc" and the file "grammar.y"
|
||||
are considered.
|
||||
|
||||
The expansion of the wildcards is done by the shell.
|
||||
|
||||
------
|
||||
|
||||
-x <filepattern>
|
||||
--except <filepattern>
|
||||
|
||||
Files which are not part of the 'skeleton', even if they are specified
|
||||
as such. The filepattern may contain the typical bash-wildcards, which
|
||||
are expanded by MkDepend.
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend *.c -x 'test*'
|
||||
|
||||
All files ending in ".c", except those whose name start with "test",
|
||||
are considered as sources. Note the quotes around "test*" to protect
|
||||
it from shell name expansion.
|
||||
|
||||
------
|
||||
|
||||
-S <filepattern>
|
||||
--select <filepattern>
|
||||
|
||||
The output of dependency information is restricted to just those
|
||||
'skeleton' source which include at least one of the <filepattern> files.
|
||||
Furthermore, only the named files are printed in the dependency lists.
|
||||
|
||||
The filepattern may contain the typical bash-wildcards, which are
|
||||
expanded by MkDepend _against the files existing at the time of
|
||||
program start_. The pattern has to match the full filename
|
||||
of the included file, including the directory part implicitely given
|
||||
by any -I argument.
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend *.c -S 'yacc.tab.h'
|
||||
|
||||
Only the files which include "yacc.tab.h" will be listed in the
|
||||
output.
|
||||
|
||||
------
|
||||
|
||||
-I <includedir>[::<symbol>]}
|
||||
--include <includedir>[::<symbol>]}
|
||||
|
||||
Specify a directory to be searched for include files. The paths are
|
||||
searched in the order given on the command line. Unless '-I-' was
|
||||
specified, the directory the including file is in is searched first.
|
||||
|
||||
If <symbol> is specified, it replaces the <includedir> when writing
|
||||
dependencies to a makefile.
|
||||
|
||||
Usually, the path, made up from all given <includedir>s, is searched
|
||||
fully for both ""- and <>-includes. This behaviour changes if the
|
||||
path is split using the special dirname '-' (like in '-I-').
|
||||
|
||||
If '-I-' is used, all directories given before the '-I-' are searched
|
||||
only for ""-includes. The directories given after the '-I-' are
|
||||
searched for both ""- and <>-includes again. Also the directories of
|
||||
the including files are no longer searched automatically.
|
||||
|
||||
If a ""-include is not found, MkDepend will print a warning, but
|
||||
still list the file in the generated dependencies. Missing <>-includes
|
||||
on the other hand are silently ignored.
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend -I /include -I- -I libglob
|
||||
|
||||
""-include files are searched in the current directory, in /include
|
||||
and in libglob. <>-include files are searched only in the
|
||||
current directory and libglob.
|
||||
|
||||
mkdepend -I '/include/pdlibs::$(PDLIBS)'
|
||||
|
||||
Include files are searched in the current directory and
|
||||
in /include/pdlibs. A file like "/include/pdlibs/tree.h" will be
|
||||
written as "$(PDLIBS)tree.h" into the makefile.
|
||||
Again note the use of quotes to keep the shell from expanding
|
||||
the text '$(PDLIBS)'.
|
||||
|
||||
Note that the syntax of this option is similar, but not identical to
|
||||
what most compilers expect. One example of an exception is the GNU
|
||||
C-Compiler which distinguishes between '-I' and '-i' in meaning. It is
|
||||
therefore advisable to only use the uppercase '-I' for both compiler
|
||||
and MkDepend.
|
||||
|
||||
------
|
||||
|
||||
-s <src_ext>{,<src_ext>}[+][:<obj_ext>] | [+]:<obj_ext>}
|
||||
--suffix <src_ext>{,<src_ext>}[+][:<obj_ext>] | [+]:<obj_ext>}
|
||||
|
||||
Specify a name relationship between source and object files.
|
||||
If a source name ends in one of the given <src_ext>s, an Makefile entry
|
||||
with the object name constructed using the associated <obj_ext>.
|
||||
The <obj_ext> given with no associated <src_ext> serves as default
|
||||
extension used for those <src_ext> which are given without own
|
||||
<obj_ext>.
|
||||
When constructing the dependency list for a defined source/object
|
||||
relation, the sourcefile itself is not included in the list, as
|
||||
usually implicit makerules take care of them. This can be overridden
|
||||
by specifying the '+' sign (which is associated with the given source
|
||||
extensions).
|
||||
|
||||
Default: -s :.o -s .c,.cc,.cpp,.cp,.cxx
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend -s :.o -s '.c,.cc'
|
||||
|
||||
Default <obj_ext> is ".obj", which is used for files with the
|
||||
extensions ".c" and ".cc".
|
||||
|
||||
------
|
||||
|
||||
-p <src_ext>{,<src_ext>}[+]:<obj_pattern>
|
||||
--objpat <src_ext>{,<src_ext>}[+]:<obj_pattern>
|
||||
|
||||
Similar to SUFFIX, but allows more complicated name relations.
|
||||
<obj_pattern> gives the object file name verbatim, using placeholders
|
||||
for the actual filenames:
|
||||
|
||||
%s: the full sourcename (w/o suffix)
|
||||
%p: the path part of the sourcename
|
||||
%[-][<][<number>]p: the path part of the sourcename
|
||||
<number>: skip the first <number> directories of the path,
|
||||
defaults to 0.
|
||||
< : count the directories from the end or the path part.
|
||||
- : use, don't skip the counted directories.
|
||||
%n: the base of the sourcename (w/o suffix)
|
||||
%%: the character '%'.
|
||||
%x: the character x for every other character.
|
||||
|
||||
Example:
|
||||
|
||||
mkdepend -p .c:obj/%n.o
|
||||
|
||||
For every sourcefile <name>.c, an entry for obj/<name>.o is
|
||||
created.
|
||||
|
||||
mkdepend -p .c:obj/%1p%n.o 'source/*.c'
|
||||
|
||||
For every sourcefile source/<name>.c, an entry for obj/<name>.o is
|
||||
created.
|
||||
|
||||
------
|
||||
|
||||
-f <makefile>
|
||||
--file <makefile>
|
||||
|
||||
Specify the makefile to modify. If none is specified and the --dep
|
||||
option is missing as well, MkDepend searches in order for "Makefile",
|
||||
"makefile", "Makefile.mk", "makefile.mk" and "GNUMakefile". If none
|
||||
of these exist, 'Makefile' is used and thus created.
|
||||
|
||||
------
|
||||
|
||||
-d <depfile>
|
||||
--dep <depfile>
|
||||
|
||||
Specify the depfile to write the dependencies into.
|
||||
The output hereinto notes just the plain dependencies between the
|
||||
skeleton and the included files, i.e. ignores any --objpat or --objpat
|
||||
setting. However, symbolic include paths are used here as well.
|
||||
MkDepend prints both the 'a is included by b' as well as the
|
||||
'b includes a' relationships. The former are tagged with '<-' in
|
||||
the output, the latter with '->'.
|
||||
|
||||
If --flat is not specified, the dependencies are written in tree
|
||||
form with indentation representating the nesting.
|
||||
If --flat is specified, a flat list like that in Makefiles will
|
||||
be written.
|
||||
|
||||
------
|
||||
|
||||
-l
|
||||
--flat
|
||||
|
||||
Print the plain dependency file (see option --dep) as flat list instead
|
||||
of tree form.
|
||||
|
||||
------
|
||||
|
||||
-m|--ignore-missing
|
||||
|
||||
If an include file is not found, it is NOT added to the dependencies.
|
||||
However, MkDepend will still print diagnostic.
|
||||
|
||||
------
|
||||
|
||||
-w|--no-warn-exit
|
||||
|
||||
If MkDepend generates a warning, it does not return a non-zero exit
|
||||
code to the caller (useful for use within makefiles).
|
||||
|
||||
------
|
||||
|
||||
-v
|
||||
--verbose
|
||||
|
||||
Print some output during operation, namely the program name and the
|
||||
file currently under examination.
|
||||
------
|
||||
|
||||
-h
|
||||
--help
|
||||
--longhelp
|
||||
|
||||
Print a (short) summary of the commandline arguments and exit the
|
||||
program.
|
||||
|
||||
------
|
||||
|
||||
-V
|
||||
--version
|
||||
|
||||
Print the program version and exit.
|
||||
|
||||
|
||||
Installation
|
||||
------------
|
||||
Copy the executable "mkdepend" into a suitable directory, profitably
|
||||
into one in your search path. The PPC executable is in the subdirectory
|
||||
obj.ppc/, the x86 executable in the subdirectory obj.x86/.
|
||||
|
||||
|
||||
Using MkDepend
|
||||
--------------
|
||||
The straightforward use of MkDepend is of course the call from the
|
||||
commandline a la 'mkdepend *.c', give or take a few command options. This
|
||||
would scan all C source files, compute the dependencies and update the
|
||||
Makefile in the same directory with these dependencies. Easy to use and
|
||||
as easy to forget to do after an important change (trust me, it happens!).
|
||||
Also, modifying the Makefile may not be what you want; after all, it adds
|
||||
quite a bunch of junk to the file which is of no direct interest to you.
|
||||
|
||||
Let's solve the second problem first: the solution is to instruct MkDepend
|
||||
to write all dependencies into an auxiliary file '.dependencies', which is
|
||||
done with the '-f' command option. The command now looks like this:
|
||||
'mkdepend -f .dependencies *.c'. To make use of this new file, the following
|
||||
statement must be added to the Makefile on a separate line:
|
||||
'-include .dependencies'. When make processes this line, it will read the
|
||||
contents of .dependencies and treat them as if they were written in the
|
||||
Makefile. The '-' in the command tells make to ignore the whole statement
|
||||
should .dependencies not exist.
|
||||
|
||||
The solution to the first problem (calling MkDepend automatically whenever
|
||||
a file changes) is to put the MkDepend call into the Makefile, too.
|
||||
Fortunately for us, Be's standard make allows a Makefile to change itself
|
||||
or any included file: if such a change is detected, make will simply
|
||||
re-read the affected files. Putting MkDepend into a Makefile requires the
|
||||
following changes/additions to be done (modified according to your special
|
||||
needs where necessary):
|
||||
|
||||
- the main build rule for $(TARGET) must be changed to include .dependencies
|
||||
as one of the requisites:
|
||||
|
||||
$(TARGET) : .dependencies $(OBJS) ...
|
||||
|
||||
- since MkDepend is not part of the BeOS distribution, the Makefile must
|
||||
be able to use the normal compiler as a standin for MkDepend. The variable
|
||||
DEP_FLAGS is set to the appropriate value to do so:
|
||||
|
||||
ifeq ($(CC), gcc)
|
||||
DEP_FLAGS = -M
|
||||
endif
|
||||
|
||||
ifeq ($(CC), mwcc$(CPU))
|
||||
DEP_FLAGS = -make
|
||||
endif
|
||||
|
||||
- the rule to generate the .dependencies file:
|
||||
|
||||
.dependencies: $(SRCS)
|
||||
$(SHELL) -ec '\
|
||||
if [ -n "`type -t mkdepend`" ]; then \
|
||||
mkdepend $(SRCS) $(INCLUDES) -p '\''.c:obj.$$(CPU)/%n.o'\'' -f$@; \
|
||||
else \
|
||||
$(CC) $(DEP_FLAGS) $(INCLUDES) $(SRCS) \
|
||||
| tr '\''\011'\'' '\''\040'\'' \
|
||||
| sed '\''s;^\([^ :][^ :]*\);$$(OBJ)/\1;g'\'' > $@; \
|
||||
fi'
|
||||
|
||||
- gmake automatically makes '.dependencies' when it is missing; however,
|
||||
if our intent is to 'clean' all auxiliary files, this behaviour is
|
||||
rather annoying. The solution is to include the .dependencies into
|
||||
the Makefile only when no cleaning action is requested:
|
||||
|
||||
ifneq (,$(filter clean clobber cleanall clobberall, $MAKECMDGOALS))
|
||||
-include .dependencies
|
||||
endif
|
||||
|
||||
- a rule to point out missing header files (this allows a smoother make
|
||||
process in case of outdated .dependencies):
|
||||
|
||||
%.h :
|
||||
@echo "Warning: Can't find $@."
|
||||
|
||||
And that's all.
|
||||
|
||||
The same changes apply if you chose to let mkdepend modify the Makefile
|
||||
directly, just replace every occurence of '.dependencies' with 'Makefile'
|
||||
(and of course do not '-include Makefile' in your Makefile).
|
||||
|
||||
For a real-life example take a look at MkDepend's own Makefile.
|
||||
|
||||
|
||||
Program Information
|
||||
-------------------
|
||||
MkDepend consists of these source files:
|
||||
|
||||
main.c,.h : Program control, data generation routines.
|
||||
args.c,.h : Argument parsing.
|
||||
getargs.c,.h : Generic commandline parser.
|
||||
reader.c,.h : Reading of source files and scanning for #include statements.
|
||||
Copying and writing of makefiles.
|
||||
nodes.c,.h : Management of the names and locations of the files analysed.
|
||||
It is implemented as a binary search tree with an additional
|
||||
linked list.
|
||||
util.c,.h : Some helpful functions - ok, right now just one function.
|
||||
version.h : The version number, automatically updated by PRCS.
|
||||
|
||||
Filename expansion is provided by the static library libglob, which comes
|
||||
under the GNU Library Public License in the subdirectory libglob/.
|
||||
|
||||
The provided Makefile takes care of all the necessary steps to compile and
|
||||
link both MkDepend and the libglob. See the head comment of the Makefile
|
||||
for further information about available targets and cross-compilation.
|
||||
|
||||
MkDepend was developed with Metrowerks C, Gnu C and GNU make; PRCS provides
|
||||
the source code version management.
|
||||
|
||||
|
||||
Bugs/TODO
|
||||
---------
|
||||
Maybe allow the modification of several makefiles with one call.
|
||||
Maybe omit from the depends list those files that could not be found.
|
||||
The Makefile should be more generic.
|
||||
|
||||
|
||||
History
|
||||
-------
|
||||
v 1.6 (01-Mar-2000)
|
||||
Added the possibility to select certain files for dependency generation.
|
||||
|
||||
v 1.5 (03-Feb-1999)
|
||||
Added the search for include files in the directory of the including
|
||||
file; older versions of MkDepend searched in the directory from where
|
||||
MkDepend was started.
|
||||
|
||||
v 1.4.5 (25-Oct-1998)
|
||||
R4 support (PPC and x86).
|
||||
The version number is now handled by PRCS.
|
||||
New command options '--longhelp' and '--version'.
|
||||
Default file suffixes now also cover a whole range of
|
||||
C++ suffixes (.cc, .cpp, .cxx, .cc).
|
||||
Systemincludes (<>-includes) are now handled; with the help of
|
||||
the new command option -i-.
|
||||
Filenames with embedded spaces are quoted when written to a Makefile.
|
||||
|
||||
v 1.4 (04-Jul-1998) :
|
||||
Moved to BeOS, Amiga support dropped.
|
||||
New option -?|-h|--help for online help.
|
||||
|
||||
v 1.3 (02-Mar-1996) :
|
||||
For source/object relations, the source is no longer included in
|
||||
dependency list, except when demanded by '+'-command option.
|
||||
|
||||
v 1.2 (25-Feb-1996) :
|
||||
New option -D=DEP/K for separate file with then plain source
|
||||
dependencies.
|
||||
New option -L=FLAT/S to write the plain dependencies as flat
|
||||
list instead of a tree.
|
||||
|
||||
v 1.1 (13-Oct-1995) :
|
||||
The dependencies may now be placed in midst of a makefile.
|
||||
Object file name pattern %p expanded to %[-][<][<number>]p .
|
||||
|
||||
v 1.0 (18-Sep-1995) :
|
||||
Initial release, at that time for Amiga OS.
|
||||
|
||||
|
||||
Authors
|
||||
-------
|
||||
Lars Düning, 10 Morningside Gardens, Edinburgh, EH10 5LA, United Kingdom
|
||||
EMail: [email protected], or [email protected] (deprecated)
|
||||
|
||||
The file reader was inspired by the input module of lcc by David Hanson
|
||||
and Christopher Fraser.
|
||||
|
||||
The elaborate %p pattern follows a suggestion by Michael A. Wiedmer
|
||||
(<[email protected]>).
|
||||
|
||||
The initial support for R4/x86 and a nice generic Makefile was provided
|
||||
by Stephen van Egmond (<[email protected]>).
|
||||
|
||||
Dianne Kyra Hackborn (<[email protected]>) and
|
||||
Stephen van Egmond provided valuable input.
|
||||
|
||||
|
||||
Legalese
|
||||
--------
|
||||
The following license is replicated in the file LICENSE. It applies to
|
||||
all files and derivates thereof which are part of the MkDepend package,
|
||||
except for those files which explicitely state otherwise.
|
||||
|
||||
|
||||
Copyright (c) 1995-1999, Lars Düning.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
- Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
- Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
- Modifications of the original software, of parts or of the whole,
|
||||
must be clearly recognizable as such.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
========================================================================
|
||||
File: mkdepend-17.zip
|
||||
Author: Lars Duening ([email protected])
|
||||
Release: 1.7 (14. Oct 2001)
|
||||
Compatibility: R5
|
||||
Location: contrib/development
|
||||
Description: Dependencygenerator for Makefiles
|
||||
Notes:
|
||||
|
||||
MkDepend scans C-source files recursively for includes and
|
||||
writes the found dependency trees into an existing makefile.
|
||||
Special features of MkDepend are:
|
||||
- generates the complete transitive closure of all included files;
|
||||
- searches the included files in several definable paths, and allows
|
||||
to represent these pathnames by symbols in the generated Makefile;
|
||||
- the source/object filename relationships may be flexibly defined;
|
||||
- quite fast file scanner :-).
|
||||
|
||||
The archive comes with full source and precompiled executables for
|
||||
both x86 and (cross-compiled) PPC.
|
||||
========================================================================
|
||||
@@ -1,670 +0,0 @@
|
||||
/* $Id: args.c 1.9 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Arguments parsing and variables.
|
||||
**
|
||||
** Copyright (c) 1996-2001 by Lars Düning. All Rights Reserved.
|
||||
** This file is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
** Parsed arguments:
|
||||
**
|
||||
** {-i|--include <includepath>[::<symbol>]}
|
||||
** [-i-]
|
||||
** {-x|--except <filepattern>}
|
||||
** {-S|--select <filepattern>}
|
||||
** {-s|--suffix <src_ext>{,<src_ext>}[+][:<obj_ext>] | [+]:<obj_ext>}
|
||||
** {-p|--objpat <src_ext>{,<src_ext>}[+]:<obj_pattern>
|
||||
** [-f|--file <makefile>]
|
||||
** [-d|--dep <depfile>]
|
||||
** [-l|--flat]
|
||||
** [-m|--ignore-missing]
|
||||
** [-w|--no-warn-exit]
|
||||
** [-v|--verbose]
|
||||
** [-h|-?|--help|--longhelp]
|
||||
** [-V|--version]
|
||||
** {<filename>}
|
||||
**
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "args.h"
|
||||
#include "getargs.h"
|
||||
#include "main.h"
|
||||
#include "glob.h"
|
||||
#include "version.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* Program arguments */
|
||||
|
||||
short bVerbose = FALSE; /* TRUE: Verbose action */
|
||||
SArray aFiles = { 0, 0, NULL }; /* Source files */
|
||||
SArray aAvoid = { 0, 0, NULL }; /* Source files to avoid */
|
||||
SArray aSelect = { 0, 0, NULL }; /* Selected include files to print */
|
||||
Include * aIncl = NULL; /* Include directories */
|
||||
int iInclSize = 0; /* Number of valid entries in aIncl */
|
||||
static int allocIncl = 0; /* Allcoated size of pIncl */
|
||||
short bSplitPath = FALSE; /* TRUE: distinguish between normal
|
||||
* and system include path. */
|
||||
SArray aSrcExt = { 0, 0, NULL }; /* Source file extensions */
|
||||
static int allocGiveSrc = 0, sizeGiveSrc = 0;
|
||||
/* Allocated/used size of *bGiveSrc */
|
||||
short * bGiveSrc = NULL; /* For each entry in aSrcExt:
|
||||
* TRUE if the source name shall appear
|
||||
* in the dependency list, too. */
|
||||
SArray aObjExt = { 0, 0, NULL }; /* Associated object file extensions */
|
||||
SArray aObjPat = { 0, 0, NULL }; /* Associated object file patterns */
|
||||
char * sObjExt = NULL; /* Default object file extension */
|
||||
short bDefGSrc = FALSE; /* For sObjExt: TRUE if the source
|
||||
* name shall appear in the depency
|
||||
* list, too */
|
||||
char * sMake = NULL; /* Name of the Makefile */
|
||||
char * sDepfile = NULL; /* Name of the dependency file */
|
||||
short bFlat = FALSE; /* TRUE: Depfile in flat format */
|
||||
short bNoWarnExit = FALSE; /* TRUE: Don't return RETURN_WARN
|
||||
* from program */
|
||||
short bIgnoreMiss = FALSE; /* TRUE: Ignore missing includes */
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* Every recognized option has a ordinal number */
|
||||
|
||||
typedef enum OptNumber {
|
||||
cUnknown = OPTION_UNKNOWN /* unknown option */
|
||||
, cArgument = OPTION_ARGUMENT /* normal argument (for us: filename) */
|
||||
, cInclude /* --include */
|
||||
, cExcept /* --except */
|
||||
, cSelect /* --select */
|
||||
, cSuffix /* --suffix */
|
||||
, cObjPat /* --objpat */
|
||||
, cFile /* --file */
|
||||
, cDep /* --dep */
|
||||
, cFlat /* --flat */
|
||||
, cNoWarn // --no-warn-exit
|
||||
, cIgnMiss // --ignore-missing
|
||||
, cHelp /* --help */
|
||||
, cLongHelp /* --longhelp */
|
||||
, cVerbose /* --verbose */
|
||||
, cVersion /* --version */
|
||||
} OptNumber;
|
||||
|
||||
/* Comprehensive lists of recognized options */
|
||||
|
||||
static OptionDesc aOptions[]
|
||||
= { { 'i', "include", cInclude, TRUE }
|
||||
, { 'I', NULL, cInclude, TRUE }
|
||||
, { 'x', "except", cExcept, TRUE }
|
||||
, { 'S', "select", cSelect, TRUE }
|
||||
, { 's', "suffix", cSuffix, TRUE }
|
||||
, { 'p', "objpat", cObjPat, TRUE }
|
||||
, { 'f', "file", cFile, TRUE }
|
||||
, { 'd', "dep", cDep, TRUE }
|
||||
, { 'l', "flat", cFlat, FALSE }
|
||||
, { 'm', "ignore-missing", cIgnMiss, FALSE }
|
||||
, { 'w', "no-warn-exit", cNoWarn, FALSE }
|
||||
, { 'h', "help", cHelp, FALSE }
|
||||
, { '?', NULL, cHelp, FALSE }
|
||||
, { '\0', "longhelp", cLongHelp, FALSE }
|
||||
, { 'v', "verbose", cVerbose, FALSE }
|
||||
, { 'V', "version", cVersion, FALSE }
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static void
|
||||
version (void)
|
||||
|
||||
/* Print the version of the program. */
|
||||
|
||||
{
|
||||
fputs("MkDepend " VERSION " - Makefile Dependency Generator\n"
|
||||
"\nReleased: " RELEASE_DATE
|
||||
"\nCompiled: " __DATE__
|
||||
#ifdef __TIME__
|
||||
" " __TIME__
|
||||
#endif
|
||||
"\n", stdout);
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static void
|
||||
shortusage (void)
|
||||
|
||||
/* Print the short help information to stdout. */
|
||||
|
||||
{
|
||||
version();
|
||||
printf("\nUsage: %s [options] <filename>...\n", aPgmName);
|
||||
fputs(
|
||||
"\nOptions are:\n"
|
||||
"\n"
|
||||
" -i|--include <includepath>[::<symbol>]\n"
|
||||
" -x|--except <filepattern>\n"
|
||||
" -S|--select <filepattern>\n"
|
||||
" -s|--suffix <src_ext>{,<src_ext>}[+][:<obj_ext>]\n"
|
||||
" -s|--suffix [+]:<obj_ext>\n"
|
||||
" -p|--objpat <src_ext>{,<src_ext>}[+]:<obj_pattern>\n"
|
||||
" -f|--file <makefile>\n"
|
||||
" -d|--dep <depfile>\n"
|
||||
" -l|--flat\n"
|
||||
" -m|--ignore-missing\n"
|
||||
" -w|--no-warn-exit\n"
|
||||
" -v|--verbose\n"
|
||||
" -h|-?|--help|--longhelp\n"
|
||||
" -V|--version\n"
|
||||
, stdout);
|
||||
|
||||
} /* shortusage() */
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static void
|
||||
usage (void)
|
||||
|
||||
/* Print the help information to stdout. */
|
||||
|
||||
{
|
||||
version();
|
||||
printf("\nUsage: %s [options] <filename>...\n", aPgmName);
|
||||
fputs(
|
||||
"\nOptions are:\n"
|
||||
"\n"
|
||||
" -i|--include <includepath>[::<symbol>]\n"
|
||||
" Add <includepath> to the list of searched directories. If given,\n"
|
||||
" <symbol> is used in the generated dependencies to denote\n"
|
||||
" the <includepath>.\n"
|
||||
" The special notation '-i-' is used to split the search path into\n"
|
||||
" a non-system and a common part.\n"
|
||||
"\n"
|
||||
" -x|--except <filepattern>\n"
|
||||
" Except all matching files from the root set.\n"
|
||||
"\n"
|
||||
" -S|--select <filepattern>\n"
|
||||
" Only the dependencies for files including <filepattern> are printed,\n"
|
||||
" and in those only the included files matching <filepattern> are listed.\n"
|
||||
" Except all matching files from the root set.\n"
|
||||
"\n"
|
||||
" -s|--suffix <src_ext>{,<src_ext>}[+][:<obj_ext>]\n"
|
||||
" Set the recognized source file suffixes (and optionally associated\n"
|
||||
" object file suffixes).\n"
|
||||
"\n"
|
||||
" -s|--suffix [+]:<obj_ext>\n"
|
||||
" Set the default object file suffix.\n"
|
||||
"\n"
|
||||
" -p|--objpat <src_ext>{,<src_ext>}[+]:<obj_pattern>\n"
|
||||
" Define a complex source/object file name relation.\n"
|
||||
" The <objpattern> recognizes as meta-symbols:\n"
|
||||
" %s: the full sourcename (w/o suffix)\n"
|
||||
" %[-][<][<number>]p: the path part of the sourcename\n"
|
||||
" <number>: skip first <number> directories of the path,\n"
|
||||
" defaults to 0.\n"
|
||||
" < : directories are counted from the end.\n"
|
||||
" - : use, don't skip the counted directories.\n"
|
||||
" %n: the base of the sourcename (w/o suffix)\n"
|
||||
" %%: the character %\n"
|
||||
" %x: the character 'x' for every other character.\n"
|
||||
"\n"
|
||||
" -f|--file <makefile>\n"
|
||||
" Update <makefile> with the found dependencies (default is 'Makefile').\n"
|
||||
"\n"
|
||||
" -d|--dep <depfile>\n"
|
||||
" Write the found dependencies into <depfile>.\n"
|
||||
"\n"
|
||||
" -l|--flat\n"
|
||||
" When generating a <depfile> write the dependencies in flat form.\n"
|
||||
"\n"
|
||||
" -m|--ignore-missing\n"
|
||||
" If an include file is not found, it is NOT added to the dependencies.\n"
|
||||
"\n"
|
||||
" -w|--no-warn-exit\n"
|
||||
" If MkDepend generates a warning, it does not return a non-zero exit\n"
|
||||
" code to the caller (useful for use within makefiles).\n"
|
||||
"\n"
|
||||
" -v|--verbose\n"
|
||||
" Verbose operation.\n"
|
||||
"\n"
|
||||
" -V|--version\n"
|
||||
" Display the version of the program and exit.\n"
|
||||
"\n"
|
||||
" --longhelp\n"
|
||||
" Display this help and exit.\n"
|
||||
"\n"
|
||||
" -h|-?|--help\n"
|
||||
" Display the short help text and exit.\n"
|
||||
"\n"
|
||||
, stdout);
|
||||
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int
|
||||
givesrc_addflag (short bFlag)
|
||||
|
||||
/* Add <bFlag> to *bGiveSrc.
|
||||
* Return 0 on success, non-0 on error.
|
||||
*/
|
||||
|
||||
{
|
||||
short * pFlags;
|
||||
assert(sizeGiveSrc <= allocGiveSrc);
|
||||
if (sizeGiveSrc+1 > allocGiveSrc)
|
||||
{
|
||||
pFlags = (short*)realloc(bGiveSrc, sizeof(short)*(allocGiveSrc+4));
|
||||
if (!pFlags)
|
||||
return 1;
|
||||
bGiveSrc = pFlags;
|
||||
allocGiveSrc += 4;
|
||||
}
|
||||
bGiveSrc[sizeGiveSrc] = bFlag;
|
||||
sizeGiveSrc++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int
|
||||
include_addinfo (char * pPath, char * pSymbol, int bSystem)
|
||||
|
||||
/* Add the given data to to *bIncl.
|
||||
* Return 0 on success, non-0 on error.
|
||||
*/
|
||||
|
||||
{
|
||||
Include * pNew;
|
||||
|
||||
assert(iInclSize <= allocIncl);
|
||||
if (iInclSize+1 > allocIncl)
|
||||
{
|
||||
pNew = realloc(aIncl, sizeof(Include)*(allocIncl+4));
|
||||
if (!pNew)
|
||||
return 1;
|
||||
aIncl = pNew;
|
||||
allocIncl += 4;
|
||||
}
|
||||
aIncl[iInclSize].pPath = pPath;
|
||||
aIncl[iInclSize].pSymbol = pSymbol;
|
||||
aIncl[iInclSize].bSysPath = bSystem;
|
||||
iInclSize++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
array_addfile (SArray *pArray, const char * pName)
|
||||
|
||||
/* Add a copy of <*pName> to the string array <pArray>.
|
||||
* Return 0 on success, non-0 on error.
|
||||
* If pName is NULL, the array is simply extended by a NULL pointer.
|
||||
*/
|
||||
|
||||
{
|
||||
char ** pStrs;
|
||||
assert(pArray->size <= pArray->alloc);
|
||||
if (pArray->size+1 > pArray->alloc)
|
||||
{
|
||||
pStrs = (char **)realloc(pArray->strs, sizeof(char *)*(pArray->alloc+4));
|
||||
if (!pStrs)
|
||||
return 1;
|
||||
pArray->strs = pStrs;
|
||||
pArray->alloc += 4;
|
||||
}
|
||||
else
|
||||
pStrs = pArray->strs;
|
||||
if (pName)
|
||||
{
|
||||
pStrs[pArray->size] = strdup(pName);
|
||||
if (!pStrs[pArray->size])
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
pStrs[pArray->size] = NULL;
|
||||
pArray->size++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
array_addlist (SArray *pArray, int count, const char ** pList)
|
||||
|
||||
/* Add the <count> strings from <pList> to string array <pArray>.
|
||||
* pList and contained strings may be freed after return.
|
||||
* Return 0 on success, non-0 else.
|
||||
*/
|
||||
|
||||
{
|
||||
char ** pStrs;
|
||||
int i;
|
||||
|
||||
assert(pList);
|
||||
if (!count)
|
||||
return 0;
|
||||
assert(pArray->size <= pArray->alloc);
|
||||
if (pArray->size+count > pArray->alloc)
|
||||
{
|
||||
pStrs = (char **)realloc(pArray->strs, sizeof(char *)*(pArray->alloc+count));
|
||||
if (!pStrs)
|
||||
return 1;
|
||||
pArray->strs = pStrs;
|
||||
pArray->alloc += count;
|
||||
}
|
||||
else
|
||||
pStrs = pArray->strs;
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
char * pString;
|
||||
|
||||
pString = strdup(pList[i]);
|
||||
if (!pString)
|
||||
return 1;
|
||||
pStrs[pArray->size++] = pString;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
add_expfile (SArray *pArray, const char * pName)
|
||||
|
||||
/* Glob filename <*pName> and add the filenames to string array <pArray>.
|
||||
* Return 0 on success, non-0 else.
|
||||
*/
|
||||
|
||||
{
|
||||
glob_t aGlob;
|
||||
int rc;
|
||||
|
||||
memset(&aGlob, 0, sizeof(aGlob));
|
||||
|
||||
switch (glob(pName, GLOB_NOSORT|GLOB_BRACE|GLOB_TILDE, NULL, &aGlob))
|
||||
{
|
||||
case GLOB_NOSPACE:
|
||||
globfree(&aGlob);
|
||||
exit_nomem(" (add_expfile: glob)");
|
||||
break;
|
||||
|
||||
case GLOB_ABORTED:
|
||||
printf("%s: Error expanding %s\n", aPgmName, pName);
|
||||
globfree(&aGlob);
|
||||
set_rc(RETURN_ERROR, TRUE);
|
||||
break;
|
||||
|
||||
case GLOB_NOMATCH:
|
||||
globfree(&aGlob);
|
||||
return 0;
|
||||
|
||||
case 0:
|
||||
/* No error */
|
||||
break;
|
||||
|
||||
default:
|
||||
globfree(&aGlob);
|
||||
exit_doserr(RETURN_ERROR);
|
||||
break;
|
||||
}
|
||||
|
||||
assert(aGlob.gl_pathc > 0);
|
||||
|
||||
rc = 0;
|
||||
if (aGlob.gl_pathc > 0)
|
||||
rc = array_addlist(pArray, aGlob.gl_pathc, (const char **)aGlob.gl_pathv);
|
||||
|
||||
globfree(&aGlob);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int
|
||||
handler (int eOption, const char * pValue)
|
||||
|
||||
/* Callback function for getargs(). It is called when option <eOption>
|
||||
* was recognized, possibly also passing an associated value in <pValue>.
|
||||
* Return 0 on success, non-zero else.
|
||||
*/
|
||||
|
||||
{
|
||||
int i; /* All purpose */
|
||||
|
||||
switch (eOption)
|
||||
{
|
||||
case cArgument:
|
||||
i = array_addfile(&aFiles, pValue);
|
||||
if (i)
|
||||
exit_nomem(" (args: add file)");
|
||||
break;
|
||||
|
||||
case cInclude:
|
||||
{
|
||||
char * pSym, * pMark;
|
||||
char * pVal;
|
||||
|
||||
/* Special case: check for the '-' marker */
|
||||
if (!strcmp(pValue, "-"))
|
||||
{
|
||||
bSplitPath = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Since we're going to hack into pValue, possibly extending it
|
||||
* by one character, we better make a copy of it. We need it
|
||||
* anyway to store the data in aIncl[].
|
||||
*/
|
||||
pVal = malloc(strlen(pValue)+2);
|
||||
if (!pVal)
|
||||
exit_nomem(" (args: dup include arg)");
|
||||
strcpy(pVal, pValue);
|
||||
|
||||
/* Allow for <path>::<symbol> notation */
|
||||
pSym = NULL;
|
||||
pMark = pVal+strlen(pVal);
|
||||
if (pMark != pVal)
|
||||
{
|
||||
pMark--;
|
||||
while (!pSym && pMark >= pVal+1)
|
||||
{
|
||||
if (':' != *pMark)
|
||||
{
|
||||
pMark--;
|
||||
continue;
|
||||
}
|
||||
if (':' != *(pMark-1))
|
||||
{
|
||||
pMark -= 2;
|
||||
continue;
|
||||
}
|
||||
pSym = pMark+1;
|
||||
*(pMark-1) = '\0';
|
||||
}
|
||||
}
|
||||
if (pSym && !strlen(pSym))
|
||||
pSym = NULL;
|
||||
else if (pSym)
|
||||
{
|
||||
pSym = strdup(pSym);
|
||||
if (!pSym)
|
||||
exit_nomem(" (args: dup include sym)");
|
||||
}
|
||||
|
||||
/* Make sure <path> ends in a ':' or '/' */
|
||||
pMark = pVal+strlen(pVal);
|
||||
if (pMark > pVal && ':' != *(pMark-1) && '/' != *(pMark-1))
|
||||
{
|
||||
*pMark = '/';
|
||||
*(pMark+1) = '\0';
|
||||
}
|
||||
i = include_addinfo(pVal, pSym, bSplitPath);
|
||||
if (i)
|
||||
exit_nomem(" (args: add include info)");
|
||||
}
|
||||
break;
|
||||
|
||||
case cExcept:
|
||||
i = add_expfile(&aAvoid, pValue);
|
||||
if (i)
|
||||
exit_nomem(" (args: add except)");
|
||||
break;
|
||||
|
||||
case cSelect:
|
||||
i = add_expfile(&aSelect, pValue);
|
||||
if (i)
|
||||
exit_nomem(" (args: add select)");
|
||||
break;
|
||||
|
||||
case cSuffix:
|
||||
case cObjPat:
|
||||
{
|
||||
char * pMark, *pOsfix;
|
||||
short bGotPlus;
|
||||
|
||||
/* Allow for <src_suffix>[+]:<obj_suffix> notation */
|
||||
bGotPlus = FALSE;
|
||||
pOsfix = NULL;
|
||||
pMark = (char *)pValue+strlen(pValue);
|
||||
if (pMark != pValue)
|
||||
{
|
||||
pMark--;
|
||||
while (!pOsfix && pMark >= pValue)
|
||||
{
|
||||
if (':' != *pMark)
|
||||
{
|
||||
pMark--;
|
||||
continue;
|
||||
}
|
||||
pOsfix = pMark+1;
|
||||
if (pMark != pValue && *(pMark-1) == '+')
|
||||
{
|
||||
bGotPlus = TRUE;
|
||||
pMark--;
|
||||
}
|
||||
*pMark = '\0';
|
||||
}
|
||||
}
|
||||
if (pOsfix && !strlen(pOsfix))
|
||||
pOsfix = NULL;
|
||||
|
||||
/* --objpat needs the [+]:<obj_pattern> part! */
|
||||
if (cObjPat == eOption && !pOsfix)
|
||||
{
|
||||
printf("%s: <obj_pattern> not specified.\n", aPgmName);
|
||||
set_rc(RETURN_ERROR, TRUE);
|
||||
}
|
||||
|
||||
/* [+]:<obj_suffix> alone defines default object suffix */
|
||||
if (pOsfix && !strlen(pValue))
|
||||
{
|
||||
if (sObjExt)
|
||||
free(sObjExt);
|
||||
sObjExt = strdup(pOsfix);
|
||||
if (!sObjExt)
|
||||
exit_nomem(" (args: dup obj suffix)");
|
||||
bDefGSrc = bGotPlus;
|
||||
}
|
||||
else
|
||||
{
|
||||
char * pSfix;
|
||||
|
||||
/* Allow for <sfix1>,<sfix2>,...,<sfixn> for source suffixes */
|
||||
for ( pSfix = (char *)pValue
|
||||
; NULL != (pMark = strchr(pSfix, ','))
|
||||
; pSfix = pMark+1
|
||||
)
|
||||
{
|
||||
*pMark = '\0';
|
||||
if (strlen(pSfix))
|
||||
{
|
||||
if ( array_addfile(&aSrcExt, pSfix)
|
||||
|| givesrc_addflag(bGotPlus)
|
||||
|| (cSuffix == eOption ? array_addfile(&aObjExt, pOsfix)
|
||||
: array_addfile(&aObjPat, pOsfix)
|
||||
)
|
||||
)
|
||||
exit_nomem(" (args: add obj suffix)");
|
||||
}
|
||||
}
|
||||
if (strlen(pSfix))
|
||||
{
|
||||
if ( array_addfile(&aSrcExt, pSfix)
|
||||
|| givesrc_addflag(bGotPlus)
|
||||
|| (cSuffix == eOption ? array_addfile(&aObjExt, pOsfix)
|
||||
: array_addfile(&aObjPat, pOsfix)
|
||||
)
|
||||
)
|
||||
exit_nomem(" (args: add last obj suffix)");
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case cFile:
|
||||
if (sMake)
|
||||
free(sMake);
|
||||
sMake = strdup(pValue);
|
||||
if (!sMake)
|
||||
exit_nomem(" (args: dup make)");
|
||||
break;
|
||||
|
||||
case cDep:
|
||||
if (sDepfile)
|
||||
free(sDepfile);
|
||||
sDepfile = strdup(pValue);
|
||||
if (!sDepfile)
|
||||
exit_nomem(" (args: dup dep)");
|
||||
break;
|
||||
|
||||
case cFlat:
|
||||
bFlat = TRUE;
|
||||
break;
|
||||
|
||||
case cIgnMiss:
|
||||
bIgnoreMiss = TRUE;
|
||||
break;
|
||||
|
||||
case cNoWarn:
|
||||
bNoWarnExit = TRUE;
|
||||
break;
|
||||
|
||||
case cVerbose:
|
||||
bVerbose = TRUE;
|
||||
break;
|
||||
|
||||
case cHelp:
|
||||
shortusage();
|
||||
set_rc(RETURN_WARN, TRUE);
|
||||
break;
|
||||
|
||||
case cLongHelp:
|
||||
usage();
|
||||
set_rc(RETURN_WARN, TRUE);
|
||||
break;
|
||||
|
||||
case cVersion:
|
||||
version();
|
||||
set_rc(RETURN_WARN, TRUE);
|
||||
break;
|
||||
|
||||
default:
|
||||
/* This shouldn't happen. */
|
||||
printf("%s: (getargs) Internal error, eOption is %d\n", aPgmName, eOption);
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
void
|
||||
parseargs (int argc, char ** argv)
|
||||
|
||||
/* Get the arguments from the commandline and fill in the exported variables.
|
||||
* In case of an error, the program is terminated.
|
||||
*/
|
||||
|
||||
{
|
||||
if (getargs(argc, argv, aOptions, handler))
|
||||
set_rc(RETURN_ERROR, TRUE);
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
@@ -1,61 +0,0 @@
|
||||
/* $Id: args.h 1.6 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Copyright (c) 1999-2001 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __ARGS_H__
|
||||
#define __ARGS_H__ 1
|
||||
|
||||
/* Dynamic string array */
|
||||
|
||||
typedef struct _sarray
|
||||
{
|
||||
int size; /* Number of used strings */
|
||||
int alloc; /* Number of allocated string pointers */
|
||||
char ** strs; /* Array of string pointers */
|
||||
} SArray;
|
||||
|
||||
/* Information about one include directory */
|
||||
|
||||
typedef struct _inclinfo {
|
||||
char * pPath; /* Pathname of the directory */
|
||||
char * pSymbol; /* Symbol to use in Makefiles, NULL if none */
|
||||
int bSysPath; /* TRUE for system directories */
|
||||
} Include;
|
||||
|
||||
/* Program arguments */
|
||||
|
||||
extern short bVerbose; /* TRUE: Verbose action */
|
||||
extern SArray aFiles; /* Source files */
|
||||
extern SArray aAvoid; /* Source files to avoid */
|
||||
extern SArray aSelect; /* Selected include files to print */
|
||||
extern Include * aIncl; /* Include directory information */
|
||||
extern int iInclSize; /* Number of valid entries in aIncl */
|
||||
extern short bSplitPath; /* Include path handling */
|
||||
extern SArray aSrcExt; /* Source file extensions */
|
||||
extern SArray aObjExt; /* Associated object file extensions */
|
||||
extern SArray aObjPat; /* Associated object file patterns */
|
||||
extern short * bGiveSrc; /* For each entry in aSrcExt: TRUE if the
|
||||
* source name shall appear in the
|
||||
* dependency list, too. */
|
||||
extern char * sObjExt; /* Default object file extension */
|
||||
extern short bDefGSrc; /* For sObjExt: TRUE if the source name
|
||||
* shall appear in the depency list, too
|
||||
*/
|
||||
extern char * sMake; /* Name of the Makefile */
|
||||
extern char * sDepfile; /* Name of the dependency file */
|
||||
extern short bFlat; /* TRUE: Depfile in flat format */
|
||||
extern short bNoWarnExit; /* TRUE: Don't return RETURN_WARN from program */
|
||||
extern short bIgnoreMiss; /* TRUE: Ignore missing includes */
|
||||
|
||||
/* Prototypes */
|
||||
|
||||
extern void parseargs (int argc, char ** argv);
|
||||
extern int array_addlist (SArray *, int, const char **);
|
||||
extern int array_addfile (SArray *, const char *);
|
||||
extern int add_expfile (SArray *, const char *);
|
||||
|
||||
#endif
|
||||
@@ -1,326 +0,0 @@
|
||||
/* $Id: getargs.c 1.5 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Commandline argument parser.
|
||||
*
|
||||
* Copyright (c) 1998-2000 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
* This code parses the arguments passed to the program in the count <argc>
|
||||
* and the array of strings <argv>. The parser distinguishes options, which
|
||||
* start with a '-', from normal arguments; options are further distinguished
|
||||
* by their name and may take an additional value. The parser neither
|
||||
* imposes nor expects any order of options and arguments.
|
||||
*
|
||||
* Options are recognized in two forms. In the short form the option must
|
||||
* be given as a single '-' followed by a single letter. In the long form,
|
||||
* options start with '--' followed by a string of arbitrary length.
|
||||
* Short options are case sensitive, long options aren't.
|
||||
* Examples are: '-r' and '--recursive'.
|
||||
*
|
||||
* If an option takes a value, it must follow the option immediately after
|
||||
* a separating space or '='. Additionally, the value for a short option
|
||||
* may follow the option without separator. Examples are: '-fMakefile',
|
||||
* '-f Makefile', '--file=Makefile' and '--file Makefile'.
|
||||
*
|
||||
* Short options may be collated into one argument, e.g. '-rtl', but
|
||||
* of these only the last may take a value.
|
||||
*
|
||||
* The option '--' marks the end of options. All following command arguments
|
||||
* are considered proper arguments even if they start with a '-' or '--'.
|
||||
*-------------------------------------------------------------------------
|
||||
* Internally every option recognized by the program is associated with
|
||||
* an id number, assigned by the user. The parser itself uses the two
|
||||
* id numbers 'OPTION_UNKNOWN' for unrecognized options, and
|
||||
* 'OPTION_ARGUMENT' for proper command arguments.
|
||||
*
|
||||
* Id numbers are associated with their option strings/letters by the
|
||||
* the array aOptions, which is passed to the parser function. Every element
|
||||
* in this array is a structure defining the option's name (string
|
||||
* or letter), the associated id number, and whether or not the option
|
||||
* takes a value. An element can hold just one type of option (short or
|
||||
* long) by setting the description the other option to \0 resp. NULL.
|
||||
* The order of the elements does not matter. The end of the array is
|
||||
* marked with an element using OPTION_UNKNOWN as assigned id number.
|
||||
*
|
||||
* The parsing is done by calling the function
|
||||
*
|
||||
* int getargs( int argc, char ** argv
|
||||
* , const OptionDesc aOptions[]
|
||||
* , OptionHandler handler)
|
||||
*
|
||||
* The function is passed the argument count <argc> and vector <argv> as
|
||||
* they were received from the main() function, the option description
|
||||
* array <aOptions> and a callback function* <handler>. getargs()
|
||||
* returns 0 if the parsing completed successfully, and non-zero else.
|
||||
*
|
||||
* The handler function is called for every successfully recognized option
|
||||
* and argument. Its prototype is
|
||||
*
|
||||
* int handler(int iOption, const char *pValue)
|
||||
*
|
||||
* Parameter <iOption> denotes the recognized option, and pValue points
|
||||
* to the beginning of the value string if the option takes a value.
|
||||
* Proper arguments are parsed with eOption==OPTION_ARGUMENT and pValue
|
||||
* pointing to the argument string. The handler has to return 0 if the
|
||||
* option/argument was processed correctly, and non-zero else.
|
||||
*
|
||||
* Additionally, getargs() puts the basename of the program (as determined
|
||||
* by argv[0]) into the exported variable
|
||||
*
|
||||
* const char *aPgmName
|
||||
*
|
||||
* when called the first time.
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "getargs.h"
|
||||
|
||||
const char *aPgmName = NULL;
|
||||
/* The exported program name. */
|
||||
|
||||
#define MY_TRUE 1
|
||||
#define MY_FALSE 0
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
getargs ( int argc, char ** argv
|
||||
, OptionDesc aOptions[]
|
||||
, OptionHandler opt_eval
|
||||
)
|
||||
|
||||
/* Get the arguments from the commandline and pass them
|
||||
* as (number, optional value) to the <opt_eval> callback.
|
||||
* The options are defined by the array <aOptions>, with an OPTION_UNKNOWN
|
||||
* element marking the last entry.
|
||||
*
|
||||
* If opt_eval() returns non-zero, argument scanning is terminated.
|
||||
* In that case, or if getargs() detects an error itself, getargs() returns
|
||||
* non-zero.
|
||||
* A zero return means 'success' in both cases.
|
||||
*
|
||||
* Additionally, on the first call getargs() sets aPgmName to the basename
|
||||
* of the program as derived from argv[0].
|
||||
*/
|
||||
|
||||
{
|
||||
int i; /* all purpose */
|
||||
int nOptions; /* Number of options */
|
||||
int iArg; /* Number of argument under inspection */
|
||||
int eOption; /* The current recognized option */
|
||||
int xOption; /* The index of the recog otion in aOptions */
|
||||
short bCont; /* True: find another option in the same argument */
|
||||
short bDone; /* True: all options parsed, only args left */
|
||||
short bShort; /* True: current argument is a short option */
|
||||
char * pArg; /* Next argument character to consider */
|
||||
|
||||
assert(aOptions != NULL);
|
||||
assert(opt_eval != NULL);
|
||||
|
||||
/* Determine the program's name */
|
||||
if (NULL == aPgmName)
|
||||
{
|
||||
char * newName;
|
||||
|
||||
newName = strdup(basename(argv[0]));
|
||||
if (NULL == newName)
|
||||
aPgmName = (const char *)argv[0];
|
||||
else
|
||||
aPgmName = (const char *)newName;
|
||||
}
|
||||
|
||||
/* Make the compiler happy */
|
||||
bShort = MY_FALSE;
|
||||
pArg = NULL;
|
||||
|
||||
/* Count the options */
|
||||
for (nOptions = 0; aOptions[nOptions].iNumber != OPTION_UNKNOWN; nOptions++)
|
||||
/* SKIP */ ;
|
||||
|
||||
/* Scan all arguments */
|
||||
bCont = MY_FALSE;
|
||||
bDone = MY_FALSE;
|
||||
for (iArg = 1; iArg < argc; !bCont ? iArg++ : iArg)
|
||||
{
|
||||
ssize_t iArglen; /* Length of remaining argument */
|
||||
char * pValue; /* First character of an option value, or NULL */
|
||||
int bTakesValue; /* This option takes a value */
|
||||
|
||||
/* Make the compiler happy */
|
||||
iArglen = 0;
|
||||
pValue = NULL;
|
||||
bTakesValue = MY_FALSE;
|
||||
|
||||
if (bDone)
|
||||
eOption = OPTION_ARGUMENT;
|
||||
else
|
||||
/* If this is not a continuation, reinitialise the inspection vars.
|
||||
* For --opt=val arguments, pValue is set to the first character of val.
|
||||
*/
|
||||
if (!bCont)
|
||||
{
|
||||
pArg = argv[iArg];
|
||||
if ('-' == pArg[0] && '-' == pArg[1]) /* Long option? */
|
||||
{
|
||||
eOption = OPTION_UNKNOWN;
|
||||
bShort = MY_FALSE;
|
||||
pArg += 2;
|
||||
/* Special case: if the argument is just '--', it marks the
|
||||
* end of all options.
|
||||
* We set a flag and continue with the next argument.
|
||||
*/
|
||||
if ('\0' == *pArg)
|
||||
{
|
||||
bDone = MY_TRUE;
|
||||
continue;
|
||||
}
|
||||
pValue = strchr(pArg, '=');
|
||||
if (pValue != NULL)
|
||||
{
|
||||
iArglen = pValue - pArg;
|
||||
pValue++;
|
||||
}
|
||||
else
|
||||
iArglen = (signed)strlen(pArg);
|
||||
}
|
||||
else if ('-' == pArg[0]) /* Short option? */
|
||||
{
|
||||
eOption = OPTION_UNKNOWN;
|
||||
bShort = MY_TRUE;
|
||||
pArg++;
|
||||
iArglen = (signed)strlen(pArg);
|
||||
pValue = NULL;
|
||||
}
|
||||
else /* No option */
|
||||
{
|
||||
eOption = OPTION_ARGUMENT;
|
||||
pValue = pArg;
|
||||
iArglen = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
eOption = OPTION_UNKNOWN;
|
||||
|
||||
/* If the option is not determined yet, do it.
|
||||
* Set pValue to the first character of the value if any.
|
||||
*/
|
||||
if (OPTION_UNKNOWN == eOption)
|
||||
{
|
||||
xOption = 0;
|
||||
if (bShort) /* search the short option */
|
||||
{
|
||||
for (i = 0; i < nOptions; i++)
|
||||
if ('\0' != aOptions[i].cOption && *pArg == aOptions[i].cOption)
|
||||
{
|
||||
xOption = i;
|
||||
eOption = aOptions[i].iNumber;
|
||||
bTakesValue = aOptions[i].bValue;
|
||||
pArg++; iArglen--; /* Consume this character */
|
||||
break;
|
||||
}
|
||||
|
||||
/* Consume a following '=' if appropriate */
|
||||
if (OPTION_UNKNOWN != eOption
|
||||
&& bTakesValue
|
||||
&& iArglen > 0 && '=' == *pArg)
|
||||
{
|
||||
pArg++; iArglen--;
|
||||
}
|
||||
|
||||
/* If there is a value following in the same argument, set pValue to
|
||||
* it and mark the remaining characters as 'consumed'
|
||||
*/
|
||||
if (OPTION_UNKNOWN != eOption && bTakesValue && iArglen > 0)
|
||||
{
|
||||
pValue = pArg;
|
||||
pArg += iArglen;
|
||||
iArglen = 0;
|
||||
}
|
||||
}
|
||||
else /* search the long option */
|
||||
{
|
||||
for (i = 0; i < nOptions; i++)
|
||||
if (NULL != aOptions[i].pOption
|
||||
&& (size_t)iArglen == strlen(aOptions[i].pOption)
|
||||
&& !strncasecmp(pArg, aOptions[i].pOption, (unsigned)iArglen))
|
||||
{
|
||||
xOption = i;
|
||||
eOption = aOptions[i].iNumber;
|
||||
bTakesValue = aOptions[i].bValue;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (OPTION_UNKNOWN == eOption)
|
||||
{
|
||||
fprintf(stderr, "%s: Unknown option '", aPgmName);
|
||||
if (bShort)
|
||||
fprintf(stderr, "-%c", *pArg);
|
||||
else
|
||||
fprintf(stderr, "--%*.*s", (int)iArglen, (int)iArglen, pArg);
|
||||
fputs("'.\n", stderr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* If at this point bTakesValue is true, but pValue is still NULL,
|
||||
* then the value is in the next argument. Get it if it's there.
|
||||
*/
|
||||
if (bTakesValue && pValue == NULL && iArg + 1 < argc)
|
||||
{
|
||||
iArg++;
|
||||
pValue = argv[iArg];
|
||||
}
|
||||
|
||||
/* Signal an error if pValue is still NULL or if it's empty. */
|
||||
if (bTakesValue && (pValue == NULL || !strlen(pValue)))
|
||||
{
|
||||
fprintf(stderr, "%s: Option '", aPgmName);
|
||||
if (bShort)
|
||||
putc(aOptions[xOption].cOption, stderr);
|
||||
else
|
||||
fputs(aOptions[xOption].pOption, stderr);
|
||||
fputs("' expects a value.\n", stderr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
} /* if (unknown option) */
|
||||
|
||||
/* Before evaluation of the parsed option, determine 'bCont' */
|
||||
bCont = bShort && (iArglen > 0) && !bTakesValue;
|
||||
|
||||
/* --- The option evaluation --- */
|
||||
|
||||
i = (*opt_eval)(eOption, pValue);
|
||||
if (i)
|
||||
return i;
|
||||
|
||||
} /* for (iArg) */
|
||||
|
||||
return 0;
|
||||
} /* getargs() */
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
char *
|
||||
basename (const char *pName)
|
||||
|
||||
/* Find the basename (filename) in a UNIX-style pathname and return
|
||||
* a pointer to its first character.
|
||||
* Example: basename("/boot/home/data/l.txt") returns a pointer to "l.txt".
|
||||
*/
|
||||
|
||||
{
|
||||
char * pBase, * cp;
|
||||
|
||||
pBase = (char *)pName;
|
||||
for (cp = (char *)pName; *cp; cp++)
|
||||
if ('/' == *cp)
|
||||
pBase = cp+1;
|
||||
return pBase;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
@@ -1,37 +0,0 @@
|
||||
/* $Id: getargs.h 1.2 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Copyright (c) 1995-1998 by Lars Düning. All Rights Reserved.
|
||||
** This file is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __GETARGS_H__
|
||||
#define __GETARGS_H__ 1
|
||||
|
||||
/* Description of an option */
|
||||
|
||||
typedef struct OptionDesc {
|
||||
unsigned char cOption; /* The option character (may be \0) */
|
||||
char * pOption; /* The option string (may be NULL) */
|
||||
int iNumber; /* The associated option number */
|
||||
short bValue; /* True: option takes a value */
|
||||
} OptionDesc;
|
||||
|
||||
/* Callback function type for option handling */
|
||||
|
||||
typedef int (*OptionHandler)(int iOption, const char * pValue);
|
||||
|
||||
/* Predefined values for OptionDesc.eNumber */
|
||||
|
||||
#define OPTION_UNKNOWN 0 /* Option unknown, or 'end of descriptor array' */
|
||||
#define OPTION_ARGUMENT 1 /* Not an option, but a real argument */
|
||||
|
||||
/* --- Prototypes --- */
|
||||
extern char * basename (const char *);
|
||||
extern int getargs(int, char **, OptionDesc[], OptionHandler);
|
||||
|
||||
/* --- Variables --- */
|
||||
extern const char * aPgmName;
|
||||
|
||||
#endif /* __GETARGS_H__ */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,37 +0,0 @@
|
||||
/* $Id: main.h 1.4 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Copyright (c) 1995-2000 by Lars Düning. All Rights Reserved.
|
||||
** This file is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __MAIN_H__
|
||||
#define __MAIN_H__ 1
|
||||
|
||||
/* Return codes */
|
||||
|
||||
#define RETURN_OK 0 /* Everything is ok */
|
||||
#define RETURN_WARN 1 /* A warning was issued */
|
||||
#define RETURN_ERROR 2 /* An error occured */
|
||||
#define RETURN_FAIL 3 /* A fatal error occured */
|
||||
|
||||
/* Boolean values */
|
||||
|
||||
#define FALSE 0
|
||||
#define TRUE 1
|
||||
|
||||
/* Macros */
|
||||
|
||||
#define IS_SELECT_MODE (aSelect.size != 0)
|
||||
/* The macro returns TRUE if only selected dependencies are to be
|
||||
* generated.
|
||||
*/
|
||||
|
||||
/* Prototypes */
|
||||
|
||||
extern void set_rc (int, int);
|
||||
extern void exit_doserr (int);
|
||||
extern void exit_nomem (char *);
|
||||
|
||||
#endif
|
||||
@@ -1,11 +0,0 @@
|
||||
resource app_version
|
||||
{
|
||||
major = 1,
|
||||
middle = 7,
|
||||
minor = 1,
|
||||
variety = 5,
|
||||
internal = 0,
|
||||
short_info = "1.7.1",
|
||||
long_info = "1.7.1 © 1995-2001 Lars Düning. All rights reserved."
|
||||
};
|
||||
|
||||
@@ -1,587 +0,0 @@
|
||||
/* $Id: nodes.c 1.6 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Management of the dependency tree and nodes.
|
||||
*
|
||||
* Copyright (c) 1995-2000 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
* Each file (source or include) is associated one node which is kept in
|
||||
* a binary search tree with the name as index. Glued to each node is
|
||||
* a list of that nodes which files the master nodes includes.
|
||||
* Each node contains an extra node pointer the module uses to implement
|
||||
* tree-independant lists, namely the TODO list of files still to read
|
||||
* and a virtual stack for inorder tree traversals.
|
||||
*
|
||||
* Adding and retrieving the files to analyse is done using the functions
|
||||
* nodes_addsource()
|
||||
* nodes_depend()
|
||||
* nodes_todo()
|
||||
* nodes_select_mark()
|
||||
*
|
||||
* The output of the dependency tree is done inorder using
|
||||
* nodes_initwalk()
|
||||
* nodes_inorder()
|
||||
*
|
||||
* The list of dependencies for one single node is managed using
|
||||
* nodes_deplist()
|
||||
* nodes_freelist()
|
||||
*
|
||||
* Tree traversal and creation must not be mixed!
|
||||
*---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "main.h"
|
||||
#include "nodes.h"
|
||||
#include "util.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/* Types for block allocation of Nodes and NodeRefs.
|
||||
* Note that Nodes are never freed.
|
||||
*/
|
||||
|
||||
#define NBLOCKSIZE 16
|
||||
|
||||
typedef struct nodeblock
|
||||
{
|
||||
struct nodeblock * pNext; /* Next nodeblock */
|
||||
int iFree; /* Number of first free node */
|
||||
Node aNodes[NBLOCKSIZE]; /* Block of nodes */
|
||||
}
|
||||
NodeBlock;
|
||||
|
||||
#define RBLOCKSIZE 16
|
||||
|
||||
typedef struct refblock
|
||||
{
|
||||
struct refblock * pNext; /* Next refblock */
|
||||
int iFree; /* Number of first free noderef */
|
||||
NodeRef aRefs[NBLOCKSIZE]; /* Block of noderefs */
|
||||
}
|
||||
RefBlock;
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static NodeBlock *pFreeNBlocks = NULL; /* Nodeblocks */
|
||||
static RefBlock *pFreeRBlocks = NULL; /* Refblocks */
|
||||
static NodeRef *pFreeRefs = NULL; /* List of free NodeRefs */
|
||||
static Node *pTree = NULL; /* Dependency tree */
|
||||
static Node *pList = NULL; /* List of (tree) nodes */
|
||||
/* The List is used as TODO list for the files to analyse as well as
|
||||
* stack simulation for the tree traversal.
|
||||
*/
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static Node *
|
||||
nodes_newnode (void)
|
||||
|
||||
/* Allocate a new Node.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the new Node, or NULL on error.
|
||||
*
|
||||
* The memory of the Node is cleared, except for .flags which is set
|
||||
* to NODE_NEW.
|
||||
*/
|
||||
|
||||
{
|
||||
Node * pNode;
|
||||
|
||||
if (!pFreeNBlocks || !pFreeNBlocks->iFree)
|
||||
{
|
||||
NodeBlock * pNewBlock;
|
||||
pNewBlock = (NodeBlock *)malloc(sizeof(*pNewBlock));
|
||||
if (!pNewBlock)
|
||||
return NULL;
|
||||
memset(pNewBlock, 0, sizeof(*pNewBlock));
|
||||
pNewBlock->iFree = NBLOCKSIZE;
|
||||
pNewBlock->pNext = pFreeNBlocks;
|
||||
pFreeNBlocks = pNewBlock;
|
||||
}
|
||||
pNode = &(pFreeNBlocks->aNodes[--pFreeNBlocks->iFree]);
|
||||
pNode->flags |= NODE_NEW;
|
||||
pNode->iInclude = -1;
|
||||
return pNode;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static NodeRef *
|
||||
nodes_newref (void)
|
||||
|
||||
/* Allocate a new NodeRef.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the new NodeRef, or NULL on error.
|
||||
*
|
||||
* The memory of the NodeRef is cleared.
|
||||
*/
|
||||
|
||||
{
|
||||
NodeRef * pRef;
|
||||
|
||||
if (pFreeRefs)
|
||||
{
|
||||
pRef = pFreeRefs;
|
||||
pFreeRefs = pRef->pNext;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!pFreeRBlocks || !pFreeRBlocks->iFree)
|
||||
{
|
||||
RefBlock * pNewBlock;
|
||||
pNewBlock = (RefBlock *)malloc(sizeof(*pNewBlock));
|
||||
if (!pNewBlock)
|
||||
return NULL;
|
||||
pNewBlock->iFree = NBLOCKSIZE;
|
||||
pNewBlock->pNext = pFreeRBlocks;
|
||||
pFreeRBlocks = pNewBlock;
|
||||
}
|
||||
pRef = &(pFreeRBlocks->aRefs[--pFreeRBlocks->iFree]);
|
||||
}
|
||||
memset(pRef, 0, sizeof(*pRef));
|
||||
return pRef;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
Node *
|
||||
nodes_findadd (const char *pName, int bAddToList)
|
||||
|
||||
/* Find the node associated with file *pName.
|
||||
* If necessary, add the node.
|
||||
*
|
||||
* pName: Pointer to the (minimalized) filename of the node.
|
||||
* bAddToList: If true, a newly allocated node is also added to
|
||||
* the TODO list.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the node associated with this filename, or NULL on error.
|
||||
*
|
||||
* If the node has been added by this call, NODE_NEW is set in its .flags,
|
||||
* but it is empty otherwise.
|
||||
*/
|
||||
|
||||
{
|
||||
Node * pThis, * pPrev;
|
||||
int i;
|
||||
|
||||
assert(pName);
|
||||
|
||||
if (!pTree)
|
||||
{
|
||||
pTree = nodes_newnode();
|
||||
if (bAddToList)
|
||||
{
|
||||
pTree->pNext = pList;
|
||||
pList = pTree;
|
||||
}
|
||||
return pTree;
|
||||
}
|
||||
|
||||
pPrev = NULL;
|
||||
pThis = pTree;
|
||||
while(pThis)
|
||||
{
|
||||
i = strcmp(pThis->pName, pName);
|
||||
if (!i)
|
||||
return pThis;
|
||||
pPrev = pThis;
|
||||
if (i > 0)
|
||||
pThis = pThis->pLeft;
|
||||
else
|
||||
pThis = pThis->pRight;
|
||||
}
|
||||
pThis = nodes_newnode();
|
||||
if (pThis)
|
||||
{
|
||||
if (i > 0)
|
||||
pPrev->pLeft = pThis;
|
||||
else
|
||||
pPrev->pRight = pThis;
|
||||
|
||||
if (bAddToList)
|
||||
{
|
||||
pThis->pNext = pList;
|
||||
pList = pThis;
|
||||
}
|
||||
}
|
||||
return pThis;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
Node *
|
||||
nodes_find (const char *pName)
|
||||
|
||||
/* Find the node associated with file *pName.
|
||||
*
|
||||
* pName: Pointer to the (minimalized) filename of the node.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the node associated with this filename, or NULL on error.
|
||||
*/
|
||||
|
||||
{
|
||||
Node * pThis, * pPrev;
|
||||
int i;
|
||||
|
||||
assert(pName);
|
||||
|
||||
if (!pTree)
|
||||
return NULL;
|
||||
|
||||
pPrev = NULL;
|
||||
pThis = pTree;
|
||||
while(pThis)
|
||||
{
|
||||
i = strcmp(pThis->pName, pName);
|
||||
if (!i)
|
||||
return pThis;
|
||||
pPrev = pThis;
|
||||
if (i > 0)
|
||||
pThis = pThis->pLeft;
|
||||
else
|
||||
pThis = pThis->pRight;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
nodes_addsource (char *pName, int bAvoid)
|
||||
|
||||
/* Add a source file to the dependency tree.
|
||||
*
|
||||
* pName : Name of the file to add (it will be duplicated).
|
||||
* bAvoid: TRUE if this is a file to be avoided.
|
||||
*
|
||||
* Result:
|
||||
* 0 on success, non-0 on error (out of memory).
|
||||
*
|
||||
* The file is also added to the internal TODO list of files if it is
|
||||
* a genuine source file.
|
||||
*/
|
||||
|
||||
{
|
||||
Node *pNode;
|
||||
char *pBasename;
|
||||
|
||||
assert(pName);
|
||||
|
||||
pName = util_getpath(pName, &pBasename);
|
||||
if (!pName)
|
||||
return 1;
|
||||
pNode = nodes_findadd(pName, !bAvoid);
|
||||
if (!pNode)
|
||||
return 1;
|
||||
if (pNode->flags & NODE_NEW)
|
||||
{
|
||||
pNode->flags = NODE_SOURCE;
|
||||
pNode->pName = pName;
|
||||
pNode->pBase = pBasename;
|
||||
pNode->pPath = util_getpath(pName, NULL);
|
||||
if (!pNode->pPath)
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
free(pName);
|
||||
|
||||
if (bAvoid)
|
||||
pNode->flags |= NODE_AVOID;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
nodes_depend (Node * pChild, Node * pParent)
|
||||
|
||||
/* Add node pChild to the list of dependees of pParent, vice versa add
|
||||
* pParent to the list of users of pName.
|
||||
*
|
||||
* pChild : Node of the file included by pParent.
|
||||
* pParent: Node which depends on pChild.
|
||||
*
|
||||
* Result:
|
||||
* 0 on success, non-0 on error (out of memory).
|
||||
*
|
||||
* The file is added to the dependee- and user-lists.
|
||||
*/
|
||||
|
||||
{
|
||||
NodeRef * pRef;
|
||||
|
||||
assert(pParent);
|
||||
assert(pChild);
|
||||
|
||||
/* Add pChild to pParent->pDeps if not already there */
|
||||
for ( pRef = pParent->pDeps
|
||||
; pRef && pRef->pNode != pChild
|
||||
; pRef = pRef->pNext
|
||||
) /* SKIP */;
|
||||
if (!pRef)
|
||||
{
|
||||
pRef = nodes_newref();
|
||||
if (!pRef)
|
||||
return 1;
|
||||
pRef->pNode = pChild;
|
||||
pRef->pNext = pParent->pDeps;
|
||||
pParent->pDeps = pRef;
|
||||
}
|
||||
|
||||
/* Add pParent to pChild->pUsers if not already there */
|
||||
for ( pRef = pChild->pUsers
|
||||
; pRef && pRef->pNode != pParent
|
||||
; pRef = pRef->pNext
|
||||
) /* SKIP */;
|
||||
if (!pRef)
|
||||
{
|
||||
pRef = nodes_newref();
|
||||
if (!pRef)
|
||||
return 1;
|
||||
pRef->pNode = pParent;
|
||||
pRef->pNext = pChild->pUsers;
|
||||
pChild->pUsers = pRef;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
Node *
|
||||
nodes_todo (void)
|
||||
|
||||
/* Return the tree node of the next file to analyse.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the node of the next file to analyse, or NULL if there is
|
||||
* none.
|
||||
*/
|
||||
|
||||
{
|
||||
Node * pNode;
|
||||
|
||||
/* NODE_DONE should not happen, but checking it is free */
|
||||
while (pList && (pList->flags & (NODE_AVOID|NODE_DONE)))
|
||||
pList = pList->pNext;
|
||||
if (pList)
|
||||
{
|
||||
pNode = pList;
|
||||
pList = pList->pNext;
|
||||
pNode->flags |= NODE_DONE;
|
||||
}
|
||||
else
|
||||
pNode = NULL;
|
||||
return pNode;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
nodes_mark_select (Node *pNode)
|
||||
|
||||
/* Check if this node, or one of its dependency nodes has been marked
|
||||
* as selected. If yes, mark pNode as well and return TRUE, otherwise
|
||||
* return FALSE.
|
||||
*
|
||||
* This is a recursive function. We avoid loops by temporarily marking
|
||||
* the node.
|
||||
*/
|
||||
|
||||
{
|
||||
int rc;
|
||||
NodeRef * pRef;
|
||||
|
||||
assert(pNode);
|
||||
|
||||
if (NODES_MARKED(pNode))
|
||||
return FALSE;
|
||||
|
||||
if (pNode->flags & NODE_ISELECT)
|
||||
return TRUE;
|
||||
|
||||
NODES_MARK(pNode);
|
||||
/* First, recurse into the dependency nodes */
|
||||
rc = FALSE;
|
||||
for (pRef = pNode->pDeps; pRef != NULL; pRef = pRef->pNext)
|
||||
{
|
||||
if (nodes_mark_select(pRef->pNode))
|
||||
rc = TRUE;
|
||||
}
|
||||
|
||||
if (rc && !(pNode->flags & NODE_SELECT))
|
||||
{
|
||||
pNode->flags |= NODE_ISELECT;
|
||||
}
|
||||
|
||||
NODES_UNMARK(pNode);
|
||||
|
||||
return rc || (pNode->flags & (NODE_SELECT|NODE_ISELECT));
|
||||
} /* nodes_mark_select() */
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
void
|
||||
nodes_initwalk (void)
|
||||
|
||||
/* Initialise a tree traversal.
|
||||
*/
|
||||
|
||||
{
|
||||
assert(!pList);
|
||||
pList = pTree;
|
||||
if (pList)
|
||||
{
|
||||
pList->iStage = 0;
|
||||
pList->pNext = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
Node *
|
||||
nodes_inorder (void)
|
||||
|
||||
/* Return the next Node of an inorder tree traversal.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the next node, or NULL if traversal is complete.
|
||||
*/
|
||||
|
||||
{
|
||||
Node *pNode = NULL;
|
||||
if (!pList)
|
||||
return NULL;
|
||||
while (pList)
|
||||
{
|
||||
switch (pList->iStage)
|
||||
{
|
||||
case 0:
|
||||
pList->iStage++;
|
||||
pNode = pList->pLeft;
|
||||
break;
|
||||
case 1:
|
||||
pList->iStage++;
|
||||
return pList;
|
||||
break;
|
||||
case 2:
|
||||
pList->iStage++;
|
||||
pNode = pList->pRight;
|
||||
break;
|
||||
case 3:
|
||||
pList = pList->pNext;
|
||||
pNode = NULL;
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
if (pNode)
|
||||
{
|
||||
pNode->pNext = pList;
|
||||
pList = pNode;
|
||||
pNode->iStage = 0;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
NodeRef *
|
||||
nodes_deplist (Node * pNode, int bUsers, int bSelect)
|
||||
|
||||
/* Gather the list of dependees or users of *pNode.
|
||||
*
|
||||
* pNode: the Node to get the list for.
|
||||
* bUsers: TRUE: gather the list of users instead of the dependees.
|
||||
* bSelect: TRUE: gather only files marked as NODE_SELECT.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the list of dependees/users, or NULL if an error occurs.
|
||||
* First entry in the list is pNode itself.
|
||||
*/
|
||||
|
||||
{
|
||||
NodeRef *pDList;
|
||||
NodeRef *pMark;
|
||||
NodeRef *pThis;
|
||||
NodeRef *pRover;
|
||||
Node *pDep;
|
||||
|
||||
assert(pNode);
|
||||
pDList = nodes_newref();
|
||||
if (!pDList)
|
||||
return NULL;
|
||||
|
||||
/* The list of dependencies is gathered in a wide search. */
|
||||
pDList->pNode = pNode;
|
||||
NODES_MARK(pNode);
|
||||
for ( pThis = pDList, pMark = pDList
|
||||
; pMark
|
||||
; pMark = pMark->pNext
|
||||
)
|
||||
{
|
||||
for ( pRover = (bUsers ? pMark->pNode->pUsers : pMark->pNode->pDeps)
|
||||
; pRover
|
||||
; pRover = pRover->pNext
|
||||
)
|
||||
{
|
||||
pDep = pRover->pNode;
|
||||
if (!NODES_MARKED(pDep))
|
||||
{
|
||||
pThis->pNext = nodes_newref();
|
||||
if (!pThis->pNext)
|
||||
return NULL;
|
||||
pThis = pThis->pNext;
|
||||
pThis->pNode = pDep;
|
||||
NODES_MARK(pDep);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* If bSelect is requested, remove all non-SELECT nodes from the list
|
||||
* (but always keep the first one).
|
||||
*/
|
||||
if (bSelect)
|
||||
{
|
||||
pThis = pDList;
|
||||
while (pThis->pNext != NULL)
|
||||
{
|
||||
pMark = pThis->pNext;
|
||||
if (!(pMark->pNode->flags & NODE_SELECT))
|
||||
{
|
||||
NODES_UNMARK(pMark->pNode);
|
||||
pThis->pNext = pMark->pNext;
|
||||
pMark->pNext = pFreeRefs;
|
||||
pFreeRefs = pMark;
|
||||
}
|
||||
else
|
||||
pThis = pMark;
|
||||
}
|
||||
}
|
||||
|
||||
return pDList;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
void
|
||||
nodes_freelist (NodeRef * pDList)
|
||||
|
||||
/* Free a dependency list produced earlier by nodes_deplist().
|
||||
*
|
||||
* pDList: Base of the list to free.
|
||||
*/
|
||||
|
||||
{
|
||||
NodeRef * pThis;
|
||||
|
||||
while (pDList)
|
||||
{
|
||||
NODES_UNMARK(pDList->pNode);
|
||||
pThis = pDList;
|
||||
pDList = pDList->pNext;
|
||||
pThis->pNext = pFreeRefs;
|
||||
pFreeRefs = pThis;
|
||||
}
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
@@ -1,95 +0,0 @@
|
||||
/* $Id: nodes.h 1.5 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Copyright (c) 1995-2000 by Lars Düning. All Rights Reserved.
|
||||
** This file is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __NODES_H__
|
||||
#define __NODES_H__ 1
|
||||
|
||||
struct noderef; /* forward */
|
||||
|
||||
/* Node structure to build the dependency tree
|
||||
*/
|
||||
typedef struct node
|
||||
{
|
||||
struct node * pLeft, * pRight; /* Tree pointers */
|
||||
struct node * pNext; /* List of Files to do; stack for traversals */
|
||||
|
||||
char * pName;
|
||||
/* Searchkey: Name of this file.
|
||||
* This is the minimal full pathname with which the file can be read.
|
||||
* For source files (and files to be avoided) it is identical with the name
|
||||
* given on the commandline.
|
||||
*/
|
||||
char * pBase;
|
||||
/* The filename part of the the file's pathname.
|
||||
* This is a pointer into pName.
|
||||
*/
|
||||
char * pPath;
|
||||
/* The directory part of the file's pathname.
|
||||
* Relative paths are interpreted depending on the type of the file:
|
||||
* source files are relative to the current working directory,
|
||||
* non-source files are relative to aIncl[.iInclude].
|
||||
*/
|
||||
int iInclude;
|
||||
/* Included non-sourcefiles: the index into aIncl[]/aSymbol[].
|
||||
* A negative index denotes an absolute filename, or one relative
|
||||
* to the cwd.
|
||||
*/
|
||||
short flags; /* misc flags */
|
||||
struct noderef * pDeps; /* What this file depends on */
|
||||
struct noderef * pUsers; /* Who depends on this file */
|
||||
short iStage; /* Stage counter for tree traversals */
|
||||
}
|
||||
Node;
|
||||
|
||||
/* Node.flags
|
||||
*/
|
||||
#define NODE_MARK (1<<0) /* Generic Node marker, used e.g. in tree walks */
|
||||
#define NODE_NEW (1<<1) /* Node is unused */
|
||||
#define NODE_SOURCE (1<<2) /* Node is a skeleton source */
|
||||
#define NODE_AVOID (1<<3) /* Node is not part of the skeleton sources */
|
||||
#define NODE_NOTFND (1<<4) /* Node describes a non-existant file */
|
||||
#define NODE_DONE (1<<5) /* Node has been evaluated */
|
||||
#define NODE_SYSTEM (1<<6) /* File is an <>-include */
|
||||
#define NODE_IGNORE (1<<7) /* Data for this node shall not be printed */
|
||||
#define NODE_SELECT (1<<8) /* Marks selected include files */
|
||||
#define NODE_ISELECT (1<<9) /* Marks nodes between source and selected
|
||||
* include files */
|
||||
|
||||
/* Node marking
|
||||
*/
|
||||
#define NODES_MARK(node) ((node)->flags |= NODE_MARK)
|
||||
#define NODES_UNMARK(node) ((node)->flags &= (short)(~NODE_MARK))
|
||||
#define NODES_MARKED(node) ((node)->flags & NODE_MARK)
|
||||
|
||||
/* Test if the _SYSTEM flag has a specific value
|
||||
*/
|
||||
#define NODES_SYSTEST(node,value) ( (node)->flags & NODE_SYSTEM ? (value) : !(value) )
|
||||
|
||||
/* Reference structure to treenodes
|
||||
*/
|
||||
typedef struct noderef
|
||||
{
|
||||
struct noderef * pNext; /* next NodeRef */
|
||||
Node * pNode; /* referenced Node */
|
||||
}
|
||||
NodeRef;
|
||||
|
||||
/* Prototypes */
|
||||
|
||||
extern Node * nodes_findadd (const char *, int);
|
||||
extern Node * nodes_find (const char *);
|
||||
extern int nodes_addsource (char *, int);
|
||||
extern int nodes_depend (Node *, Node *);
|
||||
extern int nodes_mark_select (Node *);
|
||||
extern Node * nodes_todo (void);
|
||||
extern void nodes_initwalk (void);
|
||||
extern Node * nodes_inorder (void);
|
||||
extern NodeRef * nodes_deplist (Node *, int, int);
|
||||
extern void nodes_freelist (NodeRef *);
|
||||
|
||||
#endif
|
||||
@@ -1,658 +0,0 @@
|
||||
/* $Id: reader.c 1.9 Wed, 01 Mar 2000 22:36:57 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Reading of C-Sources and filter for #include statements.
|
||||
** Also here are routines for the modification of Makefiles.
|
||||
**
|
||||
** Copyright (c) 1995-1998 by Lars Düning. All Rights Reserved.
|
||||
** This files is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
** Credits:
|
||||
** The buffering scheme was inspired by the input module of lcc (by
|
||||
** Chris Fraser & David Hanson).
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "reader.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
struct filestate
|
||||
{
|
||||
int len; /* Number of bytes buffered */
|
||||
char buf[1]; /* allocated to <len> bytes */
|
||||
};
|
||||
|
||||
#define BUFSIZE 10240 /* Size of the file buffer */
|
||||
static char aBuffer[BUFSIZE+1]; /* File buffer */
|
||||
static int fdFile; /* Filehandle */
|
||||
static int fdFile2; /* Filehandle Writer */
|
||||
static char * pLimit; /* Pointer to closing sentinel in buffer */
|
||||
static char * pch; /* Pointer to actual char in buffer */
|
||||
static char * pIName; /* Start of include filename */
|
||||
static struct filestate * pState; /* Saved state of the Makefile */
|
||||
|
||||
#define END_OF_BUF() (pch >= pLimit)
|
||||
#define END_OF_FILE() (pLimit == aBuffer)
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
void
|
||||
reader_init (void)
|
||||
|
||||
/* Initialize the reader.
|
||||
*/
|
||||
|
||||
{
|
||||
fdFile = -1;
|
||||
fdFile2 = -1;
|
||||
aBuffer[BUFSIZE] = '\n';
|
||||
pLimit = aBuffer+BUFSIZE;
|
||||
pch = pLimit;
|
||||
pIName = NULL;
|
||||
pState = NULL;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
static int
|
||||
fillbuffer (void)
|
||||
|
||||
/* Read in the next chunk from file such that incrementing pch will
|
||||
* access the newly read data.
|
||||
*
|
||||
* Result:
|
||||
* 0 on success, non-0 else (errno holds error code then).
|
||||
* pch is set to the start of the new data.
|
||||
*/
|
||||
|
||||
{
|
||||
int iRead;
|
||||
|
||||
if (END_OF_FILE())
|
||||
return 1;
|
||||
if (pIName)
|
||||
{
|
||||
if (pch > pLimit)
|
||||
pch = pLimit;
|
||||
memcpy(aBuffer, pIName, (unsigned)(pLimit-pIName));
|
||||
pch -= (pLimit-pIName);
|
||||
}
|
||||
else
|
||||
pch = aBuffer;
|
||||
iRead = read(fdFile, pch, (unsigned)(aBuffer+BUFSIZE-pch));
|
||||
if (iRead >= 0)
|
||||
{
|
||||
pLimit = pch+iRead;
|
||||
*pLimit = '\n';
|
||||
}
|
||||
return iRead < 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_open (const char *pName)
|
||||
|
||||
/* Open a file for reading.
|
||||
*
|
||||
* pName: Name of the file to read.
|
||||
*
|
||||
* Result:
|
||||
* 0 on success, non-0 else (errno contains error code then).
|
||||
*
|
||||
* The reader is initialized to read and filter the file name *pName.
|
||||
*/
|
||||
|
||||
{
|
||||
assert(pName);
|
||||
assert(fdFile < 0);
|
||||
reader_init();
|
||||
fdFile = open(pName, O_RDONLY);
|
||||
return fdFile >= 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_openrw (const char *pNameR, const char *pNameW)
|
||||
|
||||
/* Open two makefiles for modification.
|
||||
*
|
||||
* pNameR: Name of the file to read, may be NULL.
|
||||
* pNameW: Name of the file to read.
|
||||
*
|
||||
* Result:
|
||||
* 0 on success, non-0 else (errno contains error code then).
|
||||
*
|
||||
* The reader is initialized to read the old makefile *pNameR and writing
|
||||
* of new makefile *pNameW.
|
||||
* If no pNameR is given, the reader is immediately initialized to
|
||||
* write *pNameW.
|
||||
*/
|
||||
|
||||
{
|
||||
assert(pNameW);
|
||||
assert(fdFile < 0);
|
||||
assert(fdFile2 < 0);
|
||||
reader_init();
|
||||
fdFile2 = open(pNameW, O_WRONLY|O_CREAT|O_TRUNC, 0664);
|
||||
if (fdFile2 < 0)
|
||||
return 1;
|
||||
if (pNameR)
|
||||
{
|
||||
fdFile = open(pNameR, O_RDONLY);
|
||||
if (fdFile < 0)
|
||||
{
|
||||
close(fdFile2);
|
||||
fdFile2 = -1;
|
||||
}
|
||||
}
|
||||
else
|
||||
pch = aBuffer;
|
||||
return fdFile2 < 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_close (void)
|
||||
|
||||
/* Close the file currently read.
|
||||
* Result:
|
||||
* 0 on success, non-0 else.
|
||||
* errno set to error code in case.
|
||||
*/
|
||||
|
||||
{
|
||||
int i;
|
||||
|
||||
i = 0;
|
||||
if (fdFile >= 0)
|
||||
{
|
||||
i = close(fdFile);
|
||||
}
|
||||
fdFile = -1;
|
||||
if (fdFile2 >= 0)
|
||||
{
|
||||
i = close(fdFile2) || i;
|
||||
}
|
||||
fdFile2 = -1;
|
||||
if (pState)
|
||||
{
|
||||
free(pState);
|
||||
}
|
||||
pState = NULL;
|
||||
return i;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_eof (void)
|
||||
|
||||
/* Test if the file read is at its end.
|
||||
*
|
||||
* Result:
|
||||
* Non-0 on end of file.
|
||||
*/
|
||||
|
||||
{
|
||||
return END_OF_FILE();
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
const char *
|
||||
reader_get (int * pType)
|
||||
|
||||
/* Extract the next include statement from the file being read.
|
||||
*
|
||||
* Result:
|
||||
* Pointer to the filename extracted from the statement, or NULL on error
|
||||
* or end of file.
|
||||
* The memory is property of reader_get(), the pointer valid just until
|
||||
* the next call to reader_get().
|
||||
* <*pType> is set to 0 for an ""-include, and non-zero for an <>-include.
|
||||
* <errn>o set to an error code in case.
|
||||
*/
|
||||
|
||||
{
|
||||
enum { StartOfLine, InLine, FoundHash, SkipComment, SkipLComment, FoundInclude
|
||||
} eState;
|
||||
/* For debugging purposes:
|
||||
char *stab[]
|
||||
= {
|
||||
"Start "
|
||||
, "InLine"
|
||||
, "Found#"
|
||||
, "SkipC "
|
||||
, "SkipLC"
|
||||
, "FoundI"
|
||||
};
|
||||
*/
|
||||
char ch;
|
||||
int iFound; /* Number of chars found of "include" */
|
||||
int bDone; /* 0: still searching, 1: found include */
|
||||
int bType; /* 0: ""-include, 1: <>-include */
|
||||
|
||||
#define GETCHAR() \
|
||||
ch = *pch++; \
|
||||
if (ch == '\n' && pch >= pLimit) \
|
||||
{ \
|
||||
if (fillbuffer()) { \
|
||||
pIName = NULL; \
|
||||
return NULL; \
|
||||
} \
|
||||
ch = *pch++; \
|
||||
}
|
||||
|
||||
if (pIName)
|
||||
eState = InLine;
|
||||
else
|
||||
eState = StartOfLine;
|
||||
pIName = NULL;
|
||||
|
||||
iFound = 0;
|
||||
bType = 0;
|
||||
bDone = 0;
|
||||
while (!bDone)
|
||||
{
|
||||
/* Get the next interesting non-linefeed character */
|
||||
do {
|
||||
GETCHAR()
|
||||
if (ch == '\n' || ch == '\r' || ch == '\v' || ch == '\f')
|
||||
{
|
||||
eState = StartOfLine;
|
||||
pIName = NULL;
|
||||
}
|
||||
else
|
||||
break;
|
||||
} while (1);
|
||||
|
||||
switch(eState)
|
||||
{
|
||||
case StartOfLine:
|
||||
switch (ch)
|
||||
{
|
||||
case '#':
|
||||
eState = FoundHash;
|
||||
iFound = 0;
|
||||
break;
|
||||
case '/':
|
||||
GETCHAR()
|
||||
if (ch == '/')
|
||||
eState = SkipLComment;
|
||||
else if (ch == '*')
|
||||
eState = SkipComment;
|
||||
else
|
||||
eState = InLine;
|
||||
break;
|
||||
case ' ': case '\t':
|
||||
/* still: eState = StartOfLine; */
|
||||
break;
|
||||
default:
|
||||
eState = InLine;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case InLine:
|
||||
switch (ch)
|
||||
{
|
||||
case '/':
|
||||
GETCHAR()
|
||||
if (ch == '/')
|
||||
eState = SkipLComment;
|
||||
else if (ch == '*')
|
||||
eState = SkipComment;
|
||||
else
|
||||
eState = InLine;
|
||||
break;
|
||||
case '\\':
|
||||
GETCHAR()
|
||||
/* still: eState = InLine; */
|
||||
break;
|
||||
default:
|
||||
/* still: eState = InLine; */
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case FoundHash:
|
||||
switch(ch)
|
||||
{
|
||||
case ' ': case '\t':
|
||||
if (iFound)
|
||||
{
|
||||
eState = InLine;
|
||||
iFound = 0;
|
||||
}
|
||||
/* else still: eState = FoundHash */
|
||||
break;
|
||||
case 'i': case 'n': case 'c': case 'l':
|
||||
case 'u': case 'd': case 'e':
|
||||
if ("include"[iFound] != ch)
|
||||
{
|
||||
eState = InLine;
|
||||
iFound = 0;
|
||||
}
|
||||
else if (ch == 'e')
|
||||
{
|
||||
eState = FoundInclude;
|
||||
pIName = NULL;
|
||||
}
|
||||
else
|
||||
iFound++;
|
||||
break;
|
||||
default:
|
||||
eState = InLine;
|
||||
}
|
||||
break;
|
||||
|
||||
case FoundInclude:
|
||||
switch(ch)
|
||||
{
|
||||
case ' ': case '\t':
|
||||
/* still: eState = FoundInclude */
|
||||
break;
|
||||
case '<':
|
||||
if (!pIName)
|
||||
{
|
||||
pIName = pch;
|
||||
bType = 1;
|
||||
}
|
||||
else
|
||||
eState = InLine;
|
||||
break;
|
||||
case '>':
|
||||
if (!pIName)
|
||||
{
|
||||
eState = InLine;
|
||||
}
|
||||
else if (bType)
|
||||
{
|
||||
*(pch-1) = '\0';
|
||||
if (pch-1 == pIName)
|
||||
pIName = NULL;
|
||||
else
|
||||
bDone = 1;
|
||||
eState = InLine;
|
||||
}
|
||||
break;
|
||||
case '"':
|
||||
if (!pIName)
|
||||
{
|
||||
pIName = pch;
|
||||
bType = 0;
|
||||
}
|
||||
else if (!bType)
|
||||
{
|
||||
*(pch-1) = '\0';
|
||||
if (pch-1 == pIName)
|
||||
pIName = NULL;
|
||||
else
|
||||
bDone = 1;
|
||||
eState = InLine;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
if (!pIName)
|
||||
eState = InLine;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case SkipComment:
|
||||
case SkipLComment:
|
||||
break;
|
||||
} /* switch (eState) */
|
||||
|
||||
/* Skip comments immediately */
|
||||
if (eState == SkipComment)
|
||||
{
|
||||
while(1) {
|
||||
do {
|
||||
GETCHAR()
|
||||
} while (ch != '*');
|
||||
GETCHAR()
|
||||
if (ch == '/')
|
||||
break;
|
||||
}
|
||||
eState = StartOfLine;
|
||||
}
|
||||
else if (eState == SkipLComment)
|
||||
{
|
||||
do {
|
||||
GETCHAR()
|
||||
} while (ch != '\n' && ch != '\r' && ch != '\v' && ch != '\f');
|
||||
eState = StartOfLine;
|
||||
}
|
||||
} /* while(!bDone) */
|
||||
|
||||
*pType = bType;
|
||||
return pIName;
|
||||
|
||||
#undef GETCHAR
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_writeflush (void)
|
||||
|
||||
/* Write out the buffer to the written makefile.
|
||||
* Return 0 on success, non-0 else (errno holds the error code then).
|
||||
*/
|
||||
|
||||
{
|
||||
if (pch > aBuffer
|
||||
&& write(fdFile2, aBuffer, (unsigned)(pch-aBuffer)) != pch-aBuffer)
|
||||
return 1;
|
||||
pch = aBuffer;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_writen (const char *pText, size_t len)
|
||||
|
||||
/* Append the first <len> characters of <pText> to the written file.
|
||||
* Return 0 on success, non-0 else (errno holds the error code then)
|
||||
*/
|
||||
|
||||
{
|
||||
assert(pText);
|
||||
assert(fdFile2 >= 0);
|
||||
if (pLimit-pch < (signed)len && reader_writeflush())
|
||||
return 1;
|
||||
memcpy(pch, pText, len);
|
||||
pch += len;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_write (const char *pText)
|
||||
|
||||
/* Append <pText> to the written file.
|
||||
* Return 0 on success, non-0 else (errno holds the error code then)
|
||||
*/
|
||||
|
||||
{
|
||||
return reader_writen(pText, strlen(pText));
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_copymake (const char * pTagline)
|
||||
|
||||
/* Copy the file from fdFile to fdFile2 up to including the tagline.
|
||||
* If the tagline is not found, it is appended.
|
||||
* The tagline MUST end in a newline character!
|
||||
* Return 0 on success, non-0 on error (errno holds the error code then).
|
||||
*/
|
||||
|
||||
{
|
||||
size_t len;
|
||||
int count; /* Next charactor to compare in pTagline, or -1 if to skip
|
||||
* up to the next Newline */
|
||||
char ch;
|
||||
|
||||
|
||||
assert(pTagline);
|
||||
assert(fdFile2);
|
||||
len = strlen(pTagline);
|
||||
assert(len < 120);
|
||||
|
||||
/* Simplest case: no old makefile to copy */
|
||||
if (fdFile < 0)
|
||||
{
|
||||
strcpy(aBuffer, pTagline);
|
||||
pch = aBuffer+len;
|
||||
return 0;
|
||||
}
|
||||
if (fillbuffer())
|
||||
return 1;
|
||||
count = 0;
|
||||
|
||||
while (!END_OF_FILE() && count < (signed)len)
|
||||
{
|
||||
if (END_OF_BUF())
|
||||
{
|
||||
if (write(fdFile2, aBuffer, (unsigned)(pch-aBuffer)) != pch-aBuffer)
|
||||
return 1;
|
||||
if (fillbuffer())
|
||||
return 1;
|
||||
if (END_OF_FILE())
|
||||
break;
|
||||
}
|
||||
ch = *pch;
|
||||
if (count < 0)
|
||||
{
|
||||
if (ch == '\n')
|
||||
count = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ch == pTagline[count])
|
||||
count++;
|
||||
else if (ch == '\n')
|
||||
count = 0;
|
||||
else
|
||||
count = -1;
|
||||
}
|
||||
pch++;
|
||||
}
|
||||
|
||||
/* Remember the state of the Makefile read */
|
||||
if (!END_OF_FILE())
|
||||
{
|
||||
pState = (struct filestate *) malloc(sizeof(*pState)+(pLimit-pch));
|
||||
if (pState)
|
||||
{
|
||||
pState->len = pLimit-pch;
|
||||
memcpy(pState->buf, pch, (size_t)pState->len);
|
||||
}
|
||||
}
|
||||
|
||||
/* Switch to write mode */
|
||||
pLimit = aBuffer+BUFSIZE;
|
||||
|
||||
/* Append a newline if missing */
|
||||
if (count < 0 && reader_writen("\n", 1))
|
||||
return 1;
|
||||
|
||||
/* Put the Tagline into the buffer if necessary */
|
||||
if (count < (signed)len && reader_writen(pTagline, (size_t)len))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
int
|
||||
reader_copymake2 (const char * pTagline)
|
||||
|
||||
/* Copy the remainder from fdFile to fdFile2 starting with the tagline.
|
||||
* The tagline MUST end in a newline character!
|
||||
* Return 0 on success, non-0 on error (errno holds the error code then).
|
||||
*/
|
||||
|
||||
{
|
||||
size_t len;
|
||||
int count; /* Next charactor to compare in pTagline, or -1 if to skip
|
||||
* up to the next Newline */
|
||||
char ch;
|
||||
|
||||
|
||||
assert(pTagline);
|
||||
assert(fdFile);
|
||||
assert(fdFile2);
|
||||
len = strlen(pTagline);
|
||||
assert(len < 120);
|
||||
|
||||
/* Append the tagline to the file written */
|
||||
if (reader_write(pTagline) || reader_writeflush())
|
||||
return 1;
|
||||
|
||||
/* Easiest case: nothing to left copy */
|
||||
if (!pState)
|
||||
return 0;
|
||||
|
||||
/* Restore the aBuffer to the point where the reading stopped */
|
||||
pLimit = aBuffer+BUFSIZE;
|
||||
pch = pLimit-pState->len;
|
||||
memcpy(pch, pState->buf, (size_t)pState->len);
|
||||
free(pState);
|
||||
pState = NULL;
|
||||
pIName = NULL;
|
||||
|
||||
/* Fill up the buffer */
|
||||
if (END_OF_BUF() && fillbuffer())
|
||||
return 1;
|
||||
|
||||
/* Skip the Makefile read until the tagline has been found */
|
||||
count = 0;
|
||||
while (!END_OF_FILE() && count < (signed)len)
|
||||
{
|
||||
if (END_OF_BUF())
|
||||
{
|
||||
if (fillbuffer())
|
||||
return 1;
|
||||
if (END_OF_FILE())
|
||||
break;
|
||||
}
|
||||
ch = *pch;
|
||||
if (count < 0)
|
||||
{
|
||||
if (ch == '\n')
|
||||
count = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ch == pTagline[count])
|
||||
count++;
|
||||
else if (ch == '\n')
|
||||
count = 0;
|
||||
else
|
||||
count = -1;
|
||||
}
|
||||
pch++;
|
||||
}
|
||||
|
||||
/* Copy the remainder of the Makefile */
|
||||
do
|
||||
{
|
||||
if (!END_OF_BUF()
|
||||
&& write(fdFile2, pch, (unsigned)(pLimit-pch)) != pLimit-pch)
|
||||
return 1;
|
||||
if (!END_OF_FILE() && fillbuffer())
|
||||
return 1;
|
||||
}
|
||||
while (!END_OF_FILE());
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
@@ -1,24 +0,0 @@
|
||||
/* $Id: reader.h 1.4 Wed, 01 Mar 2000 21:15:40 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
** Copyright (c) 1995-1998 by Lars Düning. All Rights Reserved.
|
||||
** This file is free software. For terms of use see the file LICENSE.
|
||||
**---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __READER_H__
|
||||
#define __READER_H__ 1
|
||||
|
||||
extern void reader_init (void);
|
||||
extern int reader_open (const char *);
|
||||
extern int reader_openrw (const char *, const char *);
|
||||
extern int reader_close (void);
|
||||
extern int reader_eof (void);
|
||||
extern const char * reader_get (int *);
|
||||
extern int reader_writeflush (void);
|
||||
extern int reader_writen (const char *, size_t);
|
||||
extern int reader_write (const char *);
|
||||
extern int reader_copymake (const char *);
|
||||
extern int reader_copymake2 (const char *);
|
||||
|
||||
#endif
|
||||
@@ -1,146 +0,0 @@
|
||||
/* $Id: util.c 1.2 Wed, 01 Mar 2000 21:23:27 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Useful functions.
|
||||
*
|
||||
* Copyright (c) 1999 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "util.h"
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
char *
|
||||
util_getpath (const char * pDirtyName, char ** ppBasename)
|
||||
|
||||
/* Take the <pDirtyName> and eliminate as many '.' and '..' from it
|
||||
* as possible. Return a freshly allocated copy of the cleaned up path.
|
||||
* If ppBasename is NULL, the returned name will only contain the
|
||||
* directory parts, the filename will be dropped. If ppBasename is not
|
||||
* NULL, the returned name will contain the filename, and *ppBasename
|
||||
* will be set to point to its first character.
|
||||
*
|
||||
* Return NULL when out of memory.
|
||||
*/
|
||||
|
||||
{
|
||||
char * pPath; /* The newly created pathname */
|
||||
char * pStart; /* The first non-'/'-character of pPath */
|
||||
char * pSrc, * pDest; /* Working pointers */
|
||||
size_t oFilename; /* Offset of filename in pDirtyName */
|
||||
|
||||
assert(pDirtyName);
|
||||
|
||||
pPath = strdup(pDirtyName);
|
||||
if (!pPath)
|
||||
return NULL;
|
||||
|
||||
pStart = ('/' == *pPath) ? pPath+1 : pPath;
|
||||
|
||||
/* First scan: find the first character of the filename
|
||||
* and end the string there, leaving just the directory path.
|
||||
* But remember the offset of the filename.
|
||||
*/
|
||||
pDest = pStart; /* First character after last '/' found */
|
||||
pSrc = pStart; /* Rover */
|
||||
while ('\0' != *pSrc)
|
||||
{
|
||||
if ('/' == *pSrc++)
|
||||
pDest = pSrc;
|
||||
}
|
||||
*pDest = '\0';
|
||||
oFilename = (unsigned)(pDest - pPath);
|
||||
|
||||
/* pPath now ends in a '/', or *pStart is a '\0' */
|
||||
|
||||
/* Second scan: visit all directory parts and eliminate '.'
|
||||
* and '..' where possible.
|
||||
*/
|
||||
pDest = pStart; /* First character after last valid '/' */
|
||||
pSrc = pStart;
|
||||
|
||||
/* Skip initial '.' entries */
|
||||
while ('.' == *pSrc)
|
||||
{
|
||||
if ('/' == pSrc[1])
|
||||
{
|
||||
pSrc += 2;
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
while ('\0' != *pSrc)
|
||||
{
|
||||
char ch;
|
||||
|
||||
/* Copy forward until the next '/' */
|
||||
do
|
||||
{
|
||||
ch = *pSrc++;
|
||||
*pDest++ = ch;
|
||||
} while ('/' != ch);
|
||||
|
||||
/* If a '.' follows, it might be a '.' or '..' entry */
|
||||
while ('.' == *pSrc)
|
||||
{
|
||||
pSrc++;
|
||||
|
||||
if ('/' == *pSrc)
|
||||
{
|
||||
/* Simply skip the '.' entry */
|
||||
pSrc++;
|
||||
}
|
||||
else if ('.' == pSrc[0] && '/' == pSrc[1] && pDest != pStart)
|
||||
{
|
||||
/* For a '..' entry, move pDest back one directory unless
|
||||
* it is at the start of the string
|
||||
*/
|
||||
char * pLastDest;
|
||||
|
||||
for ( pLastDest = pDest-1
|
||||
; pLastDest != pStart && '/' != pLastDest[-1]
|
||||
; pLastDest--) /* SKIP */;
|
||||
|
||||
/* Special case: if the part just unrolled is '..' itself,
|
||||
* don't do the unrolling and instead break the loop.
|
||||
*/
|
||||
if (pLastDest + 3 == pDest && pLastDest[0] == '.' && pLastDest[1] == '.')
|
||||
{
|
||||
*pDest++ = '.';
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
pSrc += 2;
|
||||
pDest = pLastDest;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Its not a '.' or handleable '..' entry */
|
||||
*pDest++ = '.';
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
*pDest = '\0';
|
||||
|
||||
/* If the caller wants to have the filename too, append it to
|
||||
* the clean directory.
|
||||
*/
|
||||
if (ppBasename)
|
||||
{
|
||||
strcpy(pDest, pDirtyName+oFilename);
|
||||
*ppBasename = pDest;
|
||||
}
|
||||
|
||||
return pPath;
|
||||
}
|
||||
|
||||
/***************************************************************************/
|
||||
@@ -1,14 +0,0 @@
|
||||
/* $Id: util.h 1.1 Tue, 02 Feb 1999 17:57:55 -0700 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Copyright (c) 1999 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __UTIL_H__
|
||||
#define __UTIL_H__ 1
|
||||
|
||||
extern char * util_getpath(const char *, char **);
|
||||
|
||||
#endif
|
||||
@@ -1,38 +0,0 @@
|
||||
/* $Id: version.h 1.2 Sat, 24 Oct 1998 19:54:13 -0600 lars $ */
|
||||
|
||||
/*---------------------------------------------------------------------------
|
||||
* Version information for MkDepend.
|
||||
*
|
||||
* Copyright (c) 1998 by Lars Düning. All Rights Reserved.
|
||||
* This file is free software. For terms of use see the file LICENSE.
|
||||
*---------------------------------------------------------------------------
|
||||
* This macros are exported:
|
||||
*
|
||||
* VERSION: a string of the form "x.y" or "x.y.z", with z being >= 2.
|
||||
* RELEASEDATE: a string with date and time when the current version was
|
||||
* checked in.
|
||||
* PRCS_LEVEL: the internal minor version of MkDepend, used for <z>
|
||||
* in VERSION when the value is >= 2.
|
||||
*
|
||||
* The values are created by PRCS.
|
||||
*---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#ifndef __VERSION_H__
|
||||
#define __VERSION_H__
|
||||
|
||||
/* $Format: "#define RELEASE_DATE \"$ReleaseDate$\""$ */
|
||||
#define RELEASE_DATE "Thu, 19 Mar 2009 11:20:00 -0100"
|
||||
|
||||
/* $Format: "#define PRCS_LEVEL $ProjectMinorVersion$"$ */
|
||||
#define PRCS_LEVEL 1
|
||||
|
||||
#if PRCS_LEVEL > 1
|
||||
/* $Format: "#define VERSION \"$ReleaseVersion$.$ProjectMinorVersion$\""$ */
|
||||
#define VERSION "1.7.1"
|
||||
#else
|
||||
/* $Format: "#define VERSION \"$ReleaseVersion$\""$ */
|
||||
#define VERSION "1.7"
|
||||
#endif
|
||||
|
||||
#endif /* __VERSION_H__ */
|
||||
Reference in New Issue
Block a user