metaconfig-debian-perl-5.26.1/000077500000000000000000000000001316016665300161105ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/.gitignore000066400000000000000000000000641316016665300201000ustar00rootroot00000000000000U/all dist-git dist-svn dist-3.5-20 dist-3.5-20.txz metaconfig-debian-perl-5.26.1/.package000066400000000000000000000012341316016665300175040ustar00rootroot00000000000000: This file was created by running packinit on ma 28 syys 17.56.27 1998. : Do not hand edit -- run packinit again if changes are to be made. packver='3.036' : Basic variables package=perl5 baserev=5.0 patchbranch=0 copyright=' ' mydiff='gdiff -u' maintname='Perl Maintainers' maintloc='perlbug@perl.org' ftpsite='' orgname='Illuminati' newsgroups='' recipients='' ftpdir='' mailagent='false' changelog=' ' changercs=0 : File lookup extensions cext='.xs' shext='' : Mailing list variables list_users='false' list_name='' list_addr='' list_request='' list_manager='' list_sub='' list_unsub='' : Derivative variables -- do not change revbranch="$baserev.$patchbranch" metaconfig-debian-perl-5.26.1/Makefile.PL000066400000000000000000000006061316016665300200640ustar00rootroot00000000000000#!perl use strict; exists $ENV{AUTOMATED_TESTING} && $ENV{AUTOMATED_TESTING} and exit 0; print < ../lib/dist (a) You need to have dist installed so that you have metalint and metaconfig in your $PATH. As dist/meta binaries are now included in the git chackout, you do NOT need to install dist/meta itself. If you also want to play with or compare to the original meta/dit, you can checkout that too. The dist version used for perl is dist-3.5-20 in this directory, which is a slightly modified version of the original, which you can get at GITHUB repository https://github.com/rmanfredi/dist.git. If you'd like to keep up to date with changes in dist, you can use git to create your own clone. For git, that would be something like: $ git clone https://github.com/rmanfredi/dist.git dist-git Unsurprisingly 'dist' uses (its) Configure to generate itself: $ cd dist-3.5-20 # or dist-git $ chmod -R +w . # We have derived files in git :-( $ ./Configure $ make $ make install After make install, remove lib/U/d_debugging.U in your target lib, as perl uses its own way to set/define debugging (see INSTALL) the dist-3.5-20 installation as used by Merijn is available on his CPAN as perl-meta-3.5-20.tgz dist's 'Configure' is similar to perl's but perhaps not quite as polished. There are some perl specific "dist units" in the 'U' directory. The U directory also contains some patches to 'dist' which have already been applied to dist-3.5-20 directory. We have not yet arranged for metaconfig to use perl's versions of the 'units' by default so you need some housekeeping in the perl directory... (aa) If you plan to make changes to mconfig or mlint locally (and you probably want to, as both are written for perl4), consider installing mconfig and mlint from the cmon subdirectory into your $PATH too. These are the non-autoloading versions and can easily be changed. Here is what I added at the beginning of mconfig: --8<--- BEGIN { $ENV{LC_ALL} = "C"; } chdir "/pro/3gl/CPAN/perl"; { my @Cc = qw( Configure config_h.SH ); system "chown merijn @Cc"; chmod 0775, @Cc; #-d "merijn" or mkdir "merijn"; #system "cp -f Configure config_h.SH Porting/Glossary Porting/config.sh merijn/"; system "ls", "-l", @Cc; } -->8--- I also added the first two lines of that patch to mlint (b) You need to be in a/the Perl directory, i.e. either something from //depot/perl/... or one of its branches (e.g. Nick I-S is usually in //depot/perlio/...) and you need: 1) have a symlink to ../metaconfig/U called U 2) have a symlink to ../metaconfig/.package called .package 3) have a symlink to MANIFEST called MANIFEST.new 4) chmod +w Configure config_h.SH Porting/Glossary Porting/config* (c) Write the new unit as U/perl/d_bar.U ('perl' can also be 'modified', 'compline' or any other existing folder, except for 'all'). Choose the best appropriate subdir of U. See U/README for a description of the various subdirectories.) (d) Run metalint (or mlint) to see nits: as opposed to lint, the gripings of metalint are usually serious :-) and need fixing Exceptions are lots of Your private U/modified/issymlink.U overrides the public one. due to the perl special units an alias to something like $ metalint |& grep -v -e '^ Your private U/' will make the process silence up on that (of course you can add an option to mlint to disable that warning (which is already disabled by the undocumented and forgotten -s option, but that also suppresses other warnings) and "End.U": stale ?MAKE: dependency '$W'. which is apparently normal ... -- the next steps are in the perl folder (e) chmod +w Configure config_h.SH (f) mconfig -m -O to regenerate Configure and config_h.SH Make *sure* your mconfig is the correct one in your $PATH, as the mono-web package will install /usr/bin/mconfig which will do something completely different. (g) metaconfig does not deal with depends in config_h.SH, so some reorganization is needed. perl Porting/config_h.SH will fix the ordering (h) The messy not-yet-automated part is that the knowledge of the new symbol needs to be propagated to non-Configure lands like Win32, WinCE, Netware, VMS, VOS, EPOC, ... see previous Configure changes to see which are these heathen lands. Files to take care of are {win32,wince,NetWare}/config_[hH]*, (Win32, WinCE, NetWare), configure.com (VMS), VOS/config* (since 5.9 VOS uses Configure, though), epoc/config.sh (EPOC). Depending on the kind of patch djgpp/config* might also need adjusting (for example when adding/changing the list of extensions) For Win32 the process is semi-automated - if you have a Win32 machine to run dmake on ... (i) Edit U/mkglossary (right near the top) to point to where you keep dist's standard metaconfig units as well as your perl-specific ones. (j) Run U/mksample to freshen the Porting/config* and Porting/Glossary. Adjust the various compile-time options (e.g. 64bit, threads) as you see fit. You can skip this phase, it's not essential, just good housekeeping. (k) Run the perl build chain make veryclean sh ./Configure -des -Dusedevel The dependency for uconfig.h isn't carved in stone, so you might need to regenerate it perl regen/uconfig_h.pl Then make and make test or make test_harness (with TEST_JOBS=5) make all test_harness Before you start committing, make sure that the other developers are happy and run make test_porting -- the next steps are in the metaconfig folder again (l) git add U/perl/foo/bar.U when you are ready ... (m) git commit -m "Your commit description" (n) When all patches are applied, tested and committed, and you are happy, git push Merijn prefers to do steps (l) through (n) in git-gui metaconfig-debian-perl-5.26.1/README_U000066400000000000000000000121271316016665300172570ustar00rootroot00000000000000Line Description ======= ======================================================================= ?MAKE: The ?MAKE: line records dependencies ?MAKE:symbol list: dependency list [+optional] This is the first dependency line. The first "symbol list" should list all the symbols built by this unit (i.e. whose value is computed by the shell section of the unit). Symbols should be space separated. If a defined symbol is for internal use only and should not appear in the generated "config.sh" file, then it should be preceded by a '+' (not to be confused with optional dependencies defined hereafter). The second part of the list (after the middle ':') is the unit dependency. It should list all the needed special units, as well as all the symbols used by the shell implementation. If a symbol is nedded but its configuration value is not critical, it can be preceded by a '+', in which case it is called a conditional dependency: its corresponding unit will be loaded if, and only if, that symbol is otherwise really wanted; otherwise the default value will be used. ?MAKE: command There can be one or more command lines following the initial dependency lines. Those commands will be executed when the unit is wanted to load them into "Configure". Note that the leading character is required before the "command". ?INIT: Initializations printed verbatim ?LINT: Hints for metalint set Listed variables are set ?LINT:set d_getservprotos describe Listed shell variables are described ?LINT:describe awk ar bash bison byacc cat chgrp chmod chown create Listed created files in regular units ?LINT:create mips known Listed C variables are described ?LINT:known StGiFy change Shell variable ok to be changed ?LINT:change CONFIG_H extern Variables known to be externally defined ?LINT:extern CONFIG_H usefile Files marked as being used ?LINT:usefile foobar use Variables declared as used by unit ?LINT:use PERL_CONFIG_SH define Listed variables are defined ?LINT:define fieldn empty Empty unit file ?LINT:empty unclosed Unclosed here-documents ?LINT:unclosed EOT nothere Not a here-document name nocomment OK if leading unit ': comment' missing ?LINT:nocomment ?RCS: RCS comments are ignored To be used for RCS comments, at the top of the unit. ?C: C symbols Comments for #defines ?D: Default value for conditional symbols ?D:osname='' ?E: Example of usage ?F: Produced files Defines what files are created by this module Files produced in the UU directory and which are identified by the convention ./filename. Files !filename are not produced, i.e. they are temporary or externally provided. ?F:cppstdin !testcpp.out !testcpp.c ?H: Process the config.h lines Defines the part to be included in the generated config_h.SH To get #ifdefs in config_h.SH, you'll need strange constructs like ?H:?%<:@if USE_SITECUSTOMIZE ?H:?%<:#ifndef USE_SITECUSTOMIZE ?H:?%<:#$usesitecustomize USE_SITECUSTOMIZE /**/ ?H:?%<:#endif ?H:?%<:@end ?I: Added includes ?L: Added libraries ?M: Process the confmagic.h lines ?O: Unit obsolescence ?P: Location of PD implementation file ?S: Shell variables ?S:symbol_name (obsolete symbol list)]: Introduces a shell symbol. This first line names the symbol, optionally followed by a list enclosed between parenthesis and giving the obsolete equivalent. Those obsolete symbols will be remapped to the new "symbol_name" if the -o option is given to "metaconfig". ?S: any text, for "Porting/Glossary" Basically a comment describing the shell symbol, which will be extracted by "makegloss" into the Glossary file. ?S:. Closes the shell symbol comment. ?T: Shell temporaries used What variables are used as temporary variables ?V: Visible symbols like 'rp', 'dflt' ?V:fieldn ?W: Wanted value for interpreter ?X: User comment is ignored General purpose comments. May appear anywhere in the unit but must be left justfied. For RCS comments, please use the ?RCS: comment form. ?Y: User-defined layout preference Declare a layout directive for this unit. That directive may be one of the strings "top", "default" or "bottom" (case does not matter, recommended style is to spell them out uppercased). If omitted, "default" is assumed. This directive is only required if you wish to force a unit at the top or the bottom of the generated "Configure" script, as unit dependencies permit it. Important questions may thus be forced at the beginning. Within the same layout class, units are sorted alphabetically with two special cases for d_* and i_* units, forced respectively at the top and bottom of their classes (but these should belong to the default class). It you force at the top a unit whose dependencies require all the other unit to precede it, you achieve nothing interesting. Therefore, that directive should really be used to increase the priority of some interactive units that do not depend on many other user-visible symbols, like path-related questions. ?Y:TOP lines can be made conditional (see Config_sh.U) @if d_portable : : @end metaconfig-debian-perl-5.26.1/U.check/000077500000000000000000000000001316016665300173705ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U.check/.config/000077500000000000000000000000001316016665300207135ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U.check/.config/README000066400000000000000000000002201316016665300215650ustar00rootroot00000000000000This directory created by Configure to save information that should persist across sessions for u.check. You may safely delete it if you wish. metaconfig-debian-perl-5.26.1/U.check/.config/instruct000066400000000000000000000000241316016665300225050ustar00rootroot00000000000000doughera jhi merijn metaconfig-debian-perl-5.26.1/U.check/.package000066400000000000000000000014041316016665300207630ustar00rootroot00000000000000: This file was created by running packinit on Mon Jul 15 09:57:23 EDT 1996. : Do not hand edit; run packinit again if changes are to be made. packver='3.036' : Basic variables package=u.check baserev=1.1 patchbranch=1 copyright='COPYRIGHT' mydiff='gdiff -c' maintname='Andy Dougherty' maintloc='doughera@fractal.phys.lafayette.edu' ftpsite='' orgname='Dept. of Physics, Lafayette College' newsgroups='comp.sources.bugs' recipients='source-archives@mirror.TMC.COM' ftpdir='' mailagent='false' changelog='ChangeLog' changercs= : File lookup extensions cext='' shext='PL' : Mailing list variables list_users='false' list_name='' list_addr='' list_request='' list_manager='' list_sub='' list_unsub='' : Derivative variables -- do not change revbranch="$baserev.$patchbranch" metaconfig-debian-perl-5.26.1/U.check/MANIFEST000066400000000000000000000001161316016665300205170ustar00rootroot00000000000000MANIFEST This file. Makefile.SH README dummy.SH Configure config_h.SH main.c metaconfig-debian-perl-5.26.1/U.check/MANIFEST.new000066400000000000000000000001521316016665300213070ustar00rootroot00000000000000MANIFEST This file. Makefile.SH dummy.SH Configure main.c config_h.SH Produces config.h metaconfig-debian-perl-5.26.1/U.check/Makefile.SH000077500000000000000000000030661316016665300213510ustar00rootroot00000000000000case $CONFIG in '') if test -f config.sh; then TOP=.; elif test -f ../config.sh; then TOP=..; elif test -f ../../config.sh; then TOP=../..; elif test -f ../../../config.sh; then TOP=../../..; elif test -f ../../../../config.sh; then TOP=../../../..; else echo "Can't find config.sh."; exit 1 fi . $TOP/config.sh ;; esac : This forces SH files to create target in same directory as SH file. : This is so that make DEPEND always knows where to find SH derivatives. case "$0" in */*) cd `expr X$0 : 'X\(.*\)/'` ;; esac echo "Extracting Makefile (with variable substitutions)" : This section of the file will have variable substitutions done on it. : Move anything that needs config subs from !NO!SUBS! section to !GROK!THIS!. : Protect any dollar signs and backticks that you do not want interpreted : by putting a backslash in front. You may delete these comments. $spitshell >Makefile <>Makefile <<'!NO!SUBS!' all: dummy main ./dummy ./main main: try1.o try2.o main.o $(CC) -o main main.o try1.o try2.o test: ./main clean: rm -f dummy config.h core config.sh rm -f try try?.o main.o main core realclean: clean rm -f Wanted Obsolete check.extra check.wanted build.log rm -f Makefile try1.o: try1.c config.h try2.o: try2.c config.h main.o: main.c config.h DEPEND: $(MKDEP) $(CPPFLAGS) -- try1.c try2.c main.c !NO!SUBS! chmod 755 Makefile $eunicefix Makefile metaconfig-debian-perl-5.26.1/U.check/README000066400000000000000000000007521316016665300202540ustar00rootroot00000000000000Since metaconfig units are modular, you don't have to regenerate perl5's entire Configure every time you want to test just one unit. Instead, you can run metaconfig against a smaller project that tests just one (or a few) units. That's what this U.check directory is for. Just edit main.c and dummy.SH to use whatever metaconfig symbols you're trying to test. Then run metaconfig -m to regenerate Configure. You'll get a slimmed-down Configure that tests just what you want to test. metaconfig-debian-perl-5.26.1/U.check/U000077700000000000000000000000001316016665300200542../Uustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U.check/dummy000077500000000000000000000001041316016665300204440ustar00rootroot00000000000000#!/bin/sh cat <dummy <. Instructions: 1. Unpack the full perl5 sources. Execute the following command chmod +w Configure config_h.SH Porting/Glossary Porting/config* 2. Unpack the archive containing this file in the perl5 source directory. This will create a directory 'U' under the perl5 sources. That directory will contain the metaconfig units for perl5. This will also create two files in the perl5 source tree: MANIFEST.new and .package. 3. Apply any patches to perl in the perl_patches/ directory. (This may well be empty.) 4. Obtain and install dist-3.0pl70. 4. Apply any patches to dist under the dist_patches subdirectory. 5. From your main perl5 source directory, run packinit to regenerate the .package file. IMPORTANT: Change the name and address of the maintainer to your own name and address. I don't want bug reports intended for you coming to me. 6. From your main perl5 source directory, run metalint (or mlint) and repair every failure it reports. 7. From your main perl5 source directory, run metaconfig -m (or mconfig -m) 8. Edit U/mkglossary and/or U/mkgloss.pl to point to your dist-3.0pl70 location. (See comments at the top.) 9. Run the U/mksample script to update the contents of the Porting/ subdirectory, or run all parts by hand. (see README) 10. Let me know about any changes, corrections, or enhancements. Things to watch out for: 1. The Configure in 5.005 is a hand-patched version of that supplied with perl5.004_74 or so. Most of the patches had to do with supporting MPE/iX and EBCDIC systems. I have re-integrated most of the changes back into metaconfig, but I don't really undertand why MPE/iX needed some of the patches, so I may have missed something important. I did try to flag questionable changes in the individual units. The Configure as generated in the 5.9.x branch leading towards 5.10, is also used exactly as is without changes in the 5.8.x and 5.6.x branches, so do not remove support for features that are availabvle in those branches, but are removed from devel (e.g. perl5005threads). 2. Future support of better random number generators should probably start with the randfunc.U unit included here. It's currently broken, but well commented and probably a good place to start. Descriptions: The units and other related files have been broken up into the following directories: acl/ This is an old patch to begin to detect and use ACL (access control list) file protection schemes. compline/ These are similar to the standard units, but I have modified them to have a more uniform compile command line, usually using the new Compile.U unit. I have submitted these for inclusion into the regular dist distribution. (The ccflags.U unit is actually perl-specific since it mentions -DDEBUGGING and -DPOSIX_SOURCE, but that's the only place it is perl-specific.) dist_patches/ These are patches to dist that must be applied before it is built and installed. I have submitted these for inclusion in the regular dist distribution. modified/ These are modified versions of the standard units. Also included in this directory are new units that are clearly derived from existing units. I have submitted these for inclusion in the regular dist distribution. perl/ These are specific to perl. Some are heavily derived from original dist units, and are marked as such. Others are original. perl_patches/ These are patches to the perl source. This directory should ordinarily be empty, but there may have been drift between the standard version of perl and the one associated with these units. protos/ These are units modified to use the new Hasproto.U or Protochk.U units to check for prototypes. I have submitted these for inclusion into the regular dist distribution. target/ This is the very, very beginning of cross-compiler support. It doesn't work yet, and many standard units will need modification. typedefs/ These are standard units modified to use the modified Typedef.U unit to check for typedefs. (The modified Typdef.U includes a function to avoid unnecessary prompts if the typdef being searched for exists.) I have submitted these for inclusion into the regular dist distribution. threads/ These are specific to threading perl. Copyright Information: Unless otherwise indicated, the files contained in this distribution are: Copyright (c) 1996-1998, Andy Dougherty The following licensing terms apply to all files contained in this distribution: You may distribute the files contained in this distribution under the terms of either a) the "Artistic License" which comes with Perl, or b) the "Artistic License" which comes with dist, or c) the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version (see the file "Copying" that comes with the Perl distribution). Which one to use is your choice. The units in the "modified" directory have been derived from units associated with the metaconfig program of Raphael Manfredi's "dist" distribution. These units list Raphael Manfredi as the Copyright holder. dist is distributed under a modified version of the Perl Artistic License. Clause 7 of this modified license as contained in dist-3.0-pl60 provides: 7. You may reuse parts of this Package in your own programs, provided that you explicitly state where you got them from, in the source code (and, left to your courtesy, in the documentation), duplicating all the associated copyright notices and disclaimers. Besides your changes, if any, must be clearly marked as such. Parts reused that way will no longer fall under this license if, and only if, the name of your program(s) have no immediate connection with the name of the Package itself or its associated programs. You may then apply whatever restrictions you wish on the reused parts or choose to place them in the Public Domain--this will apply only within the context of your package. In accordance with this clause, the versions of these units contained here are made available under the same terms as the rest of the units. If you have any questions about the use of these units or about the differences between these units and the standard versions, please feel free to ask. Andy Dougherty doughera@lafayette.edu Dept. of Physics Lafayette College Easton, PA 18042-1782 metaconfig-debian-perl-5.26.1/U/a_dvisory/000077500000000000000000000000001316016665300203135ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/a_dvisory/intsize.U000066400000000000000000000065421316016665300221350ustar00rootroot00000000000000?RCS: $Id: intsize.U,v 3.0.1.2 1997/02/28 15:55:26 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: intsize.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:55:26 ram ?RCS: patch61: avoid prompting the user if the test runs ok ?RCS: patch61: moved code from longsize.U into there ?RCS: patch61: new tests for shortsize as well ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:21:06 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:52 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:intsize longsize shortsize: Compile Myread cat run i_stdlib rm_try ?MAKE: -pick add $@ %< ?S:intsize: ?S: This variable contains the value of the INTSIZE symbol, which ?S: indicates to the C program how many bytes there are in an int. ?S:. ?S:longsize: ?S: This variable contains the value of the LONGSIZE symbol, which ?S: indicates to the C program how many bytes there are in a long. ?S:. ?S:shortsize: ?S: This variable contains the value of the SHORTSIZE symbol which ?S: indicates to the C program how many bytes there are in a short. ?S:. ?C:INTSIZE: ?C: This symbol contains the value of sizeof(int) so that the C ?C: preprocessor can make decisions based on it. ?C:. ?C:LONGSIZE: ?C: This symbol contains the value of sizeof(long) so that the C ?C: preprocessor can make decisions based on it. ?C:. ?C:SHORTSIZE: ?C: This symbol contains the value of sizeof(short) so that the C ?C: preprocessor can make decisions based on it. ?C:. ?H:#define INTSIZE $intsize /**/ ?H:#define LONGSIZE $longsize /**/ ?H:#define SHORTSIZE $shortsize /**/ ?H:. ?F:!try : check for lengths of integral types echo " " case "$intsize" in '') echo "Checking to see how big your integers are..." >&4 $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { @if INTSIZE || intsize printf("intsize=%d;\n", (int)sizeof(int)); @end @if LONGSIZE || longsize printf("longsize=%d;\n", (int)sizeof(long)); @end @if SHORTSIZE || shortsize printf("shortsize=%d;\n", (int)sizeof(short)); @end exit(0); } EOCP set try if eval $compile_ok && $run ./try > /dev/null; then eval `$run ./try` @if INTSIZE || intsize echo "Your integers are $intsize bytes long." @end @if LONGSIZE || longsize echo "Your long integers are $longsize bytes long." @end @if SHORTSIZE || shortsize echo "Your short integers are $shortsize bytes long." @end else $cat >&4 <&4 ?X: We prefer quad types in order of int, long, long long, int64_t. case "$intsize" in 8) val=int set quadtype eval $setvar val='"unsigned int"' set uquadtype eval $setvar quadkind=1 ;; *) case "$longsize" in 8) val=long set quadtype eval $setvar val='"unsigned long"' set uquadtype eval $setvar quadkind=2 ;; *) case "$d_longlong:$longlongsize" in define:8) val='"long long"' set quadtype eval $setvar val='"unsigned long long"' set uquadtype eval $setvar quadkind=3 ;; *) case "$d_int64_t" in define) val=int64_t set quadtype eval $setvar val=uint64_t set uquadtype eval $setvar quadkind=4 ;; esac ;; esac ;; esac ;; esac case "$quadtype" in '') echo "Alas, no 64-bit integer types in sight." >&4 d_quad="$undef" ;; *) echo "We could use '$quadtype' for 64-bit integers." >&4 d_quad="$define" ;; esac metaconfig-debian-perl-5.26.1/U/acl/000077500000000000000000000000001316016665300170535ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/acl/d_accessx.U000066400000000000000000000012451316016665300211370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_accessx: Inlibc ?MAKE: -pick add $@ %< ?S:d_accessx: ?S: This variable conditionally defines the HAS_ACCESSX symbol, which ?S: indicates to the C program that the accessx() routine is available. ?S:. ?C:HAS_ACCESSX : ?C: This symbol, if defined, indicates that the accessx routine is ?C: available to do extended access checks. ?C:. ?H:#$d_accessx HAS_ACCESSX /**/ ?H:. ?LINT:set d_accessx : see if accessx exists set accessx d_accessx eval $inlibc metaconfig-debian-perl-5.26.1/U/acl/d_eaccess.U000066400000000000000000000012451316016665300211140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_eaccess: Inlibc ?MAKE: -pick add $@ %< ?S:d_eaccess: ?S: This variable conditionally defines the HAS_EACCESS symbol, which ?S: indicates to the C program that the eaccess() routine is available. ?S:. ?C:HAS_EACCESS : ?C: This symbol, if defined, indicates that the eaccess routine is ?C: available to do extended access checks. ?C:. ?H:#$d_eaccess HAS_EACCESS /**/ ?H:. ?LINT:set d_eaccess : see if eaccess exists set eaccess d_eaccess eval $inlibc metaconfig-debian-perl-5.26.1/U/acl/i_sysaccess.U000066400000000000000000000016041316016665300215120ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_sysaccess: Inhdr ?MAKE: -pick add $@ %< ?S:i_sysaccess: ?S: This variable conditionally defines the I_SYS_ACCESS symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_ACCESS: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_sysaccess I_SYS_ACCESS /**/ ?H:. ?LINT:set i_sysaccess : see if sys/access.h is available set sys/access.h i_sysaccess eval $inhdr metaconfig-debian-perl-5.26.1/U/acl/i_syssecrt.U000066400000000000000000000015761316016665300214010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_syssecrt: Inhdr ?MAKE: -pick add $@ %< ?S:i_syssecrt: ?S: This variable conditionally defines the I_SYS_SECURITY symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_SECURITY: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_syssecrt I_SYS_SECURITY /**/ ?H:. ?LINT:set i_syssecrt : see if sys/security.h is available set sys/security.h i_syssecrt eval $inhdr metaconfig-debian-perl-5.26.1/U/compline/000077500000000000000000000000001316016665300201225ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/compline/Compile.U000066400000000000000000000042061316016665300216420ustar00rootroot00000000000000?RCS: $Id: Compile.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: ?X: ?X: This unit is just a quick shorthand for the compile command ?X: to be used in all the other metaconfig units. ?X: ?MAKE:Compile: +cc +optimize +ccflags +ldflags +libs test ?MAKE: -pick add $@ %< ?LINT:extern usedevel ?LINT:define compile compile_ok ?V:compile compile_ok mc_file ?S:compile: ?S: This shell variable is used internally by Configure to provide ?S: a convenient shorthand for the typical compile command, namely ?S: $cc $optimize $ccflags $ldflags -o $1 $1.c $libs > /dev/null 2>&1 ?S: Note that the output filename does _not_ include the _exe ?S: extension. Instead we assume that the linker will be ?S: "helpful" and automatically appending the correct suffix. ?S: OS/2 users will apparently need to supply the -Zexe flag to ?S: get this behavior. ?S: ?S: To use this variable, say something like: ?S: echo 'int main() { exit(0); }' > try.c ?S: set try ?S: if eval $compile; then ?S: echo "success" # and do whatever . . . ?S: else ?S: echo "failure" # and do whatever . . . ?S: fi ?S: To add extra flags cc flags (e.g. -DWHATEVER) just put them ?S: in $*, e.g. ?S: set try -DTRY_THIS_FLAG ?S:. ?S:compile_ok: ?S: This shell variable is used internally by Configure to provide ?S: a convenient shorthand for the typical compile command that you ?S: expect to work ok. It is the same as $compile, except we ?S: deliberately let the user see any error messages. ?S:. : define a shorthand compile call compile=' mc_file=$1; shift; case "$usedevel" in $define|true|[yY]*) if $test ! -f "${mc_file}.c"; then echo "Internal Configure script bug - compiler test file ${mc_file}.c is missing. Please report this to perlbug@perl.org" >&4; exit 1; fi; esac; $cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs > /dev/null 2>&1;' : define a shorthand compile call for compilations that should be ok. compile_ok=' mc_file=$1; shift; $cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs;' metaconfig-debian-perl-5.26.1/U/compline/Csym.U000066400000000000000000000111711316016665300211640ustar00rootroot00000000000000?RCS: $Id: Csym.U,v 3.0.1.4 1995/07/25 13:36:29 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: Csym.U,v $ ?RCS: Revision 3.0.1.4 1995/07/25 13:36:29 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: patch56: added quotes for OS/2 support ?RCS: ?RCS: Revision 3.0.1.3 1995/05/12 12:00:33 ram ?RCS: patch54: fixed C test program to bypass gcc builtin type checks (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/10/31 09:34:13 ram ?RCS: patch44: added Options to the MAKE line since it's no longer in Init.U ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:00:05 ram ?RCS: patch6: added ldflags as a conditional dependency and to compile line ?RCS: patch6: a final double quote was missing in csym variable after eval ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:Csym mistrustnm extern_C: Options contains libc libs runnm test \ +cc +optimize +ccflags +ldflags run rm_try _exe d_cplusplus ?MAKE: -pick add $@ %< ?LINT:define csym ?LINT:use libc ?LINT:extern mistrustnm ?LINT:set mistrustnm ?S:csym: ?S: This shell variable is used internally by Configure to check ?S: whether a given C symbol is defined or not. A typical use is: ?S: set symbol result [-fva] [previous] ?S: eval $csym ?S: That will set result to 'true' if the function [-f], variable [-v] ?S: or array [-a] is defined, 'false' otherwise. If a previous value is ?S: given and the -r flag was provided on the command line, that value ?S: is reused without questioning. ?S:. ?S:extern_C: ?S: ANSI C requires 'extern' where C++ requires 'extern "C"'. This ?S: variable can be used in Configure to do the right thing. ?S:. ?S:mistrustnm: ?S: This variable can be used to establish a fallthrough for the cases ?S: where nm fails to find a symbol. If usenm is false or usenm is true ?S: and mistrustnm is false, this variable has no effect. If usenm is true ?S: and mistrustnm is "compile", a test program will be compiled to try to ?S: find any symbol that can't be located via nm lookup. If mistrustnm is ?S: "run", the test program will be run as well as being compiled. ?S:. ?V:csym ?T:tval tx tlook tf tdc ?F:!try : is a C symbol defined? csym='tlook=$1; case "$3" in -v) tf=libc.tmp; tdc="";; -a) tf=libc.tmp; tdc="[]";; *) tlook="^$1\$"; tf=libc.list; tdc="()";; esac; case "$d_cplusplus" in $define) extern_C="extern \"C\"" ;; *) extern_C="extern" ;; esac; tx=yes; case "$reuseval-$4" in true-) ;; true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;; esac; case "$tx" in yes) ?X: ?X: Put symbol inside a printf to fool optimizing compilers... ?X: ?X: We use 'short' instead of 'int' to try to circumvent overzealous ?X: optimizing compilers using built-in prototypes for commonly used ?X: routines to complain when seeing a different external declaration. For ?X: instance, gcc 2.6.3 fails if we use 'int' and we attempt a test against ?X: memcpy() on machines where sizeof(int) == sizeof(char *) (the usual return ?X: type), the compiler assuming it's a built-in declaration given that the ?X: returned size matches. At least with 'short' we are safe! -- RAM, for ADO ?X: ?X: Let's thank GNU cc for making our lives so easy! :-) ?X: (An alternative for the future would be to use our knowledge about gcc ?X: to force a -fno-builtin option in the compile test, in case the 'short' ?X: trick is obsoleted by future gcc releases). -- RAM ?X: tval=false; if $test "$runnm" = true; then if $contains $tlook $tf >/dev/null 2>&1; then tval=true; elif $test "$mistrustnm" = compile -o "$mistrustnm" = run; then echo "$extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main(int argc, char **argv) { if(p() && p() != (void *)argv[0]) return(0); else return(1); }"> try.c; $cc -o try $optimize $ccflags $ldflags try.c >/dev/null 2>&1 $libs && tval=true; $test "$mistrustnm" = run -a -x try && { $run ./try$_exe >/dev/null 2>&1 || tval=false; }; $rm_try; fi; else echo "$extern_C void *$1$tdc; void *(*(p()))$tdc { return &$1; } int main(int argc, char **argv) { if(p() && p() != (void *)argv[0]) return(0); else return(1); }"> try.c; $cc -o try $optimize $ccflags $ldflags try.c $libs >/dev/null 2>&1 && tval=true; $rm_try; fi; ;; *) case "$tval" in $define) tval=true;; *) tval=false;; esac; ;; esac; eval "$2=$tval"' metaconfig-debian-perl-5.26.1/U/compline/abortsig.U000066400000000000000000000041221316016665300220610ustar00rootroot00000000000000?RCS: $Id: abortsig.U,v 3.0.1.1 1994/10/29 16:02:19 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: abortsig.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:02:19 ram ?RCS: patch36: call ./usg explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:20 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:abortsig: Myread Oldconfig Guess cat Compile rm ?MAKE: -pick add $@ %< ?S:abortsig: ?S: This variable holds the name of the signal used by the abort() call. ?S:. ?C:ABORTSIG: ?C: This symbol holds the signal number (symbol) used by the abort() call. To ?C: actually define the signal symbol, should be included. ?C:. ?H:#define ABORTSIG $abortsig /**/ ?H:. ?T:signal : which signal is sent by abort ? echo " " case "$abortsig" in '') echo "Checking to see which signal is sent to the process by abort()..." >&4 echo "abort" > abort.sh chmod +x abort.sh ?X: SIGABRT should replace SIGIOT on USG machines in a near future (1991). for signal in SIGIOT SIGILL SIGABRT; do case "$abortsig" in '') $cat >abort.c < caught() { exit(0); } int main() { #ifdef $signal signal($signal, caught); #endif if (-1 == abort()) exit(1); exit(1); } EOP ?X: We have to use the abort.sh script otherwise sh behaves strangely on AIX. set abort if eval $compile; then (./abort.sh) >/dev/null 2>&1 case $? in 0) abortsig="$signal";; esac fi ;; esac done ;; esac case "$abortsig" in '') echo "(I wasn't able to compute the signal name--guessing)" if ./usg; then dflt="SIGIOT" else dflt="SIGILL" fi;; *) dflt="$abortsig" ;; esac rp="Which signal does abort() send to the process (signal name)?" . ./myread abortsig="$ans" $rm -f core abort.sh abort abort.c metaconfig-debian-perl-5.26.1/U/compline/alignbytes.U000066400000000000000000000047011316016665300224130ustar00rootroot00000000000000?RCS: $Id: alignbytes.U,v 3.0.1.2 1994/10/29 16:02:28 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: alignbytes.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 16:02:28 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:25:20 ram ?RCS: patch23: avoid ALIGNBYTES, since it conflicts on NetBSD ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:23 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:alignbytes: Myread Compile cat rm_try multiarch run test nvtype ?MAKE: -pick add $@ %< ?S:alignbytes: ?S: This variable holds the number of bytes required to align a ?S: double-- or a long double when applicable. Usual values are ?S: 2, 4 and 8. The default is eight, for safety. ?S:. ?X: This used to be called ALIGNBYTES, but that conflicts with ?X: in NetBSD. ?C:MEM_ALIGNBYTES (ALIGNBYTES): ?C: This symbol contains the number of bytes required to align a ?C: double, or a long double when applicable. Usual values are 2, ?C: 4 and 8. The default is eight, for safety. For cross-compiling ?C: or multiarch support, Configure will set a minimum of 8. ?C:. ?H:?%<:#define MEM_ALIGNBYTES $alignbytes ?H:. ?F:!try : check for alignment requirements echo " " case "$alignbytes" in '') echo "Checking alignment constraints..." >&4 $cat >try.c < struct foobar { char foo; $nvtype bar; } try_algn; int main() { printf("%d\n", (int)((char *)&try_algn.bar - (char *)&try_algn.foo)); return(0); } EOCP set try if eval $compile_ok; then dflt=`$run ./try` else dflt='8' echo "(I can't seem to compile the test program...)" fi case "$multiarch" in *$define*) : The usual safe value is 8, but Darwin with -Duselongdouble : needs 16. Hence, we will take 8 as a minimum, but allow : Configure to pick a larger value if needed. if $test "$dflt" -lt 8; then dflt='8' echo "Setting alignment to 8 for multiarch support.">&4 fi ;; esac ;; *) dflt="$alignbytes" ;; esac rp="Doubles must be aligned on a how-many-byte boundary?" . ./myread alignbytes="$ans" $rm_try metaconfig-debian-perl-5.26.1/U/compline/bitpbyte.U000066400000000000000000000035661316016665300221040ustar00rootroot00000000000000?RCS: $Id: bitpbyte.U,v 3.0.1.1 1994/10/29 16:02:54 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: bitpbyte.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:02:54 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:27 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:bitpbyte: cat rm Myread Compile run ?MAKE: -pick add $@ %< ?S:bitpbyte: ?S: This variable contains the value of the BITS_PER_BYTE symbol, which ?S: indicates to the C program how many bits there are in a byte. ?S:. ?C:BITS_PER_BYTE: ?C: This symbol contains the number of bits in a byte, so that the C ?C: preprocessor can make decisions based on it. ?C:. ?H:#define BITS_PER_BYTE $bitpbyte /**/ ?H:. ?F:!try : check for length of byte echo " " case "$bitpbyte" in '') echo "Checking to see how many bits there are in a byte..." >&4 $cat >try.c <<'EOCP' #include ?X: Standard C requires a macro CHAR_BIT in #ifdef __STDC__ #include #ifndef CHAR_BIT #define CHAR_BIT 8 #endif #ifndef BITSPERBYTE #define BITSPERBYTE CHAR_BIT #endif #else ?X: On non standard C, try with #include #ifndef BITSPERBYTE #define BITSPERBYTE 8 #endif #endif int main() { printf("%d\n", BITSPERBYTE); } EOCP set try if eval $compile_ok; then dflt=`$run ./try` else dflt='8' echo "(I can't seem to compile the test program. Guessing...)" fi ;; *) dflt="$bitpbyte" ;; esac rp="What is the length of a byte (in bits)?" . ./myread bitpbyte="$ans" $rm -f try.c try metaconfig-debian-perl-5.26.1/U/compline/byteorder.U000066400000000000000000000075151316016665300222570ustar00rootroot00000000000000?RCS: $Id: byteorder.U,v 3.0.1.2 1997/02/28 15:24:55 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: byteorder.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:24:55 ram ?RCS: patch61: no longer ask the user if the test runs ok ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:02:58 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:28 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:byteorder: cat Myread Oldconfig Loc Compile rm_try run \ multiarch uvtype uvsize i_stdlib ?MAKE: -pick add $@ %< ?S:byteorder: ?S: This variable holds the byte order in a UV. In the following, ?S: larger digits indicate more significance. The variable byteorder ?S: is either 4321 on a big-endian machine, or 1234 on a little-endian, ?S: or 87654321 on a Cray ... or 3412 with weird order ! ?S:. ?C:BYTEORDER: ?C: This symbol holds the hexadecimal constant defined in byteorder, ?C: in a UV, i.e. 0x1234 or 0x4321 or 0x12345678, etc... ?C: If the compiler supports cross-compiling or multiple-architecture ?C: binaries, use compiler-defined macros to ?C: determine the byte order. ?C:. ?H:?%<:#if defined(MULTIARCH) ?H:?%<:# ifdef __LITTLE_ENDIAN__ ?H:?%<:# if LONGSIZE == 4 ?H:?%<:# define BYTEORDER 0x1234 ?H:?%<:# else ?H:?%<:# if LONGSIZE == 8 ?H:?%<:# define BYTEORDER 0x12345678 ?H:?%<:# endif ?H:?%<:# endif ?H:?%<:# else ?H:?%<:# ifdef __BIG_ENDIAN__ ?H:?%<:# if LONGSIZE == 4 ?H:?%<:# define BYTEORDER 0x4321 ?H:?%<:# else ?H:?%<:# if LONGSIZE == 8 ?H:?%<:# define BYTEORDER 0x87654321 ?H:?%<:# endif ?H:?%<:# endif ?H:?%<:# endif ?H:?%<:# endif ?H:?%<:#else ?H:?%<:#define BYTEORDER 0x$byteorder /* large digits for MSB */ ?H:?%<:#endif ?H:. ?T:xxx_prompt ?F:!try : check for ordering of bytes in a UV echo " " case "$multiarch" in *$define*) $cat <try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include typedef $uvtype UV; int main() { int i; union { UV l; char c[$uvsize]; } u; if ($uvsize > 4) u.l = (((UV)0x08070605) << 32) | (UV)0x04030201; else u.l = (UV)0x04030201; for (i = 0; i < $uvsize; i++) printf("%c", u.c[i]+'0'); printf("\n"); exit(0); } EOCP xxx_prompt=y set try if eval $compile && $run ./try > /dev/null; then dflt=`$run ./try` case "$dflt" in [1-4][1-4][1-4][1-4]|12345678|87654321) echo "(The test program ran ok.)" echo "byteorder=$dflt" xxx_prompt=n ;; ????|????????) echo "(The test program ran ok.)" ;; *) echo "(The test program didn't run right for some reason.)" ;; esac else dflt='4321' cat <<'EOM' (I can't seem to compile the test program. Guessing big-endian...) EOM fi case "$xxx_prompt" in y) rp="What is the order of bytes in $uvtype?" . ./myread byteorder="$ans" ;; *) byteorder=$dflt ;; esac ;; esac $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/compline/ccflags.U000066400000000000000000000356501316016665300216630ustar00rootroot00000000000000?RCS: $Id: ccflags.U,v 3.0.1.9 1997/02/28 15:27:07 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: ccflags.U,v $ ?RCS: Revision 3.0.1.9 1997/02/28 15:27:07 ram ?RCS: patch61: removed support for NO_PROTOTYPE detection on SCO ?RCS: patch61: new locincpth variable ?RCS: patch61: added info on the "additional ld flags" question ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:48:54 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.7 1995/05/12 12:08:33 ram ?RCS: patch54: now checks for cc/ccflags/ldflags coherency ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 16:07:02 ram ?RCS: patch36: gcc versioning no longer relies on the C compiler's name ?RCS: patch36: simplified check for gcc version checking (ADO) ?RCS: ?RCS: Revision 3.0.1.5 1994/08/29 16:06:35 ram ?RCS: patch32: propagate -posix flag from ccflags to ldflags ?RCS: ?RCS: Revision 3.0.1.4 1994/05/06 14:28:45 ram ?RCS: patch23: -fpcc-struct-return only needed in gcc 1.x (ADO) ?RCS: patch23: cppflags now computed on an option-by-option basis ?RCS: patch23: magically added cc flags now only done the first time ?RCS: ?RCS: Revision 3.0.1.3 1993/09/13 15:58:29 ram ?RCS: patch10: explicitly mention -DDEBUG just in case they need it (WAD) ?RCS: patch10: removed all the "tans" variable usage (WAD) ?RCS: ?RCS: Revision 3.0.1.2 1993/08/27 14:39:38 ram ?RCS: patch7: added support for OSF/1 machines ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:00:24 ram ?RCS: patch6: added defaults for cppflags, ccflags and ldflags ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:31 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:ccflags ldflags lkflags cppflags optimize locincpth: test cat osname \ Myread Guess Options Oldconfig +gccversion mips_type +usrinc \ package contains rm +cc cppstdin cppminus cpprun cpplast libpth \ libs loclibpth hint usesocks sh run rm_try sysroot ?MAKE: -pick add $@ %< ?S:ccflags: ?S: This variable contains any additional C compiler flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:cppflags: ?S: This variable holds the flags that will be passed to the C pre- ?S: processor. It is up to the Makefile to use it. ?S:. ?S:optimize: ?S: This variable contains any optimizer/debugger flag that should be used. ?S: It is up to the Makefile to use it. ?S:. ?S:ldflags: ?S: This variable contains any additional C loader flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:lkflags: ?S: This variable contains any additional C partial linker flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:locincpth: ?S: This variable contains a list of additional directories to be ?S: searched by the compiler. The appropriate '-I' directives will ?S: be added to ccflags. This is intended to simplify setting ?S: local directories from the Configure command line. ?S: It's not much, but it parallels the loclibpth stuff in libpth.U. ?S:. ?T:inctest thisincl xxx inclwanted ftry previous thislibdir ?T:EBUGGING DEBUGGING ?T:check flag callback checkccflag ?F:!cpp.c !gcctest !try ?D:cppflags='' ?D:ccflags='' ?D:ldflags='' ?D:optimize='' ?LINT:extern _sysroot ?INIT:: Possible local include directories to search. ?INIT:: Set locincpth to "" in a hint file to defeat local include searches. ?INIT:locincpth="/usr/local/include /opt/local/include /usr/gnu/include" ?INIT:locincpth="$locincpth /opt/gnu/include /usr/GNU/include /opt/GNU/include" ?INIT:: ?INIT:: no include file wanted by default ?INIT:inclwanted='' ?INIT: ?INIT:: Enable -DEBUGGING and -DDEBUGGING from the command line ?INIT:EBUGGING='' ?INIT:DEBUGGING='' ?INIT: : determine optimization, if desired, or use for debug flag also ?X: Allow for Configure -Uoptimize -- it's not strictly sensible, but ?X: it has happened and we know what they mean. AD 2/16/98 case "$optimize" in ' '|$undef) dflt='none';; '') dflt='-O';; *) dflt="$optimize";; esac $cat </dev/null 2>&1 then # Interactive Systems (ISC) POSIX mode. dflt="$dflt -posix" fi ;; esac ?X: If the user has gcc-2.95 or greater, try adding -fno-strict-alias. ?X: Since the gcc "version" can be non-numeric, e.g. ?X: "2.95.1 19990809 (prerelease)" , we'll do the test on any version ?X: greater than 2.8. ?X: --Andy Dougherty 27 Aug 1999 case "$gccversion" in 1*) ;; 2.[0-8]*) ;; ?*) set strict-aliasing -fno-strict-aliasing eval $checkccflag ;; esac ?X: HMB 200405 ?X: -pipe has shown a compile time speedup of about 40% on Linux and HP-UX ?X: and also worked on cygwin-1.5.9 ?X: If a system fails, disable it in the hints. 99% of gcc uses binutils # For gcc, adding -pipe speeds up compilations for some, but apparently # some assemblers can't read from stdin. (It also slows down compilations # in other cases, but those are apparently rarer these days.) AD 5/2004. case "$gccversion" in ?*) set pipe -pipe eval $checkccflag ;; esac ?X: NWC 200712 # on x86_64 (at least) we require an extra library (libssp) in the # link command line. This library is not named, so I infer that it is # an implementation detail that may change. Hence the safest approach # is to add the flag to the flags passed to the compiler at link time, # as that way the compiler can do the right implementation dependant # thing. (NWC) case "$osname" in amigaos) ;; # -fstack-protector builds but doesn't work *) case "$gccversion" in ?*) set stack-protector-strong -fstack-protector-strong eval $checkccflag case "$dflt" in *-fstack-protector-strong*) ;; # It got added. *) # Try the plain/older -fstack-protector. set stack-protector -fstack-protector eval $checkccflag ;; esac ;; esac ;; esac ;; esac ?X: In USG mode, a MIPS system may need some BSD includes case "$mips_type" in *BSD*|'') inclwanted="$locincpth $usrinc";; *) inclwanted="$locincpth $inclwanted $usrinc/bsd";; esac for thisincl in $inclwanted; do if $test -d $thisincl; then if $test x$thisincl != x$usrinc; then case "$dflt" in *" -I$thisincl "*);; *) dflt="$dflt -I$thisincl ";; esac fi fi done ?X: Include test function (header, symbol) inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then xxx=true; elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then xxx=true; else xxx=false; fi; if $xxx; then case "$dflt" in *$2*);; *) dflt="$dflt -D$2";; esac; fi' set signal.h LANGUAGE_C; eval $inctest case "$usesocks" in $define) ccflags="$ccflags -DSOCKS" ;; esac case "$hint" in default|recommended) dflt="$ccflags $dflt" ;; *) dflt="$ccflags";; esac case "$dflt" in ''|' ') dflt=none;; esac $cat <&4 set X $cppflags shift cppflags='' $cat >cpp.c <<'EOM' #define BLURFL foo BLURFL xx LFRULB EOM ?X: ?X: For each cc flag, try it out with both cppstdin and cpprun, since the ?X: first is almost surely a cc wrapper. We have to try both in case ?X: of cc flags like '-Olimit 2900' that are actually two words... ?X: previous='' for flag in $* do case "$flag" in -*) ftry="$flag";; *) ftry="$previous $flag";; esac if $cppstdin -DLFRULB=bar $cppflags $ftry $cppminus cpp1.out 2>/dev/null && \ $cpprun -DLFRULB=bar $cppflags $ftry $cpplast cpp2.out 2>/dev/null && \ $contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \ $contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1 then cppflags="$cppflags $ftry" previous='' else previous="$flag" fi done set X $cppflags shift cppflags=${1+"$@"} case "$cppflags" in *-*) echo "They appear to be: $cppflags";; esac $rm -f cpp.c cpp?.out ;; esac : flags used in final linking phase case "$ldflags" in '') if ./venix; then dflt='-i -z' else dflt='' fi case "$ccflags" in *-posix*) dflt="$dflt -posix" ;; esac ;; *) dflt="$ldflags";; esac # See note above about -fstack-protector case "$ccflags" in *-fstack-protector-strong*) case "$dflt" in *-fstack-protector-strong*) ;; # Don't add it again *) dflt="$dflt -fstack-protector-strong" ;; esac ;; *-fstack-protector*) case "$dflt" in *-fstack-protector*) ;; # Don't add it again *) dflt="$dflt -fstack-protector" ;; esac ;; esac : Try to guess additional flags to pick up local libraries. for thislibdir in $libpth; do case " $loclibpth " in *" $thislibdir "*) case "$dflt " in *"-L$thislibdir "*) ;; *) dflt="$dflt -L$thislibdir" ;; esac ;; esac done case "$dflt" in '') dflt='none' ;; esac $cat <&4 $cat > try.c <<'EOF' #include int main() { printf("Ok\n"); return(0); } EOF ?X: Strip extra blanks in case some of the following variables are empty set X $cc -o try $optimize $ccflags $ldflags try.c $libs shift $cat >try.msg <<'EOM' I've tried to compile and run the following simple program: EOM $cat try.c >> try.msg $cat >> try.msg <>try.msg 2>&1; then if $sh -c "$run ./try " >>try.msg 2>&1; then xxx=`$run ./try` case "$xxx" in "Ok") dflt=n ;; *) echo 'The program compiled OK, but produced no output.' >> try.msg ;; esac else echo "The program compiled OK, but exited with status $?." >>try.msg rp="You have a problem. Shall I abort Configure" dflt=y fi else echo "I can't compile the test program." >>try.msg rp="You have a BIG problem. Shall I abort Configure" dflt=y fi case "$dflt" in y) $cat try.msg >&4 ?X: using -K will prevent default aborting--maybe they're cross compiling? case "$knowitall" in '') echo "(The supplied flags or libraries might be incorrect.)" ;; *) dflt=n;; esac echo " " . ./myread case "$ans" in n*|N*) ;; *) echo "Ok. Stopping Configure." >&4 exit 1 ;; esac ;; n) echo "OK, that should do.";; esac $rm_try gcctest gcctest.out metaconfig-debian-perl-5.26.1/U/compline/charorder.U000066400000000000000000000072361316016665300222310ustar00rootroot00000000000000?RCS: $Id: charorder.U,v 3.0.1.1 1994/10/29 16:07:08 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: charorder.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:07:08 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:33 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:chorder_int chorder_short chorder_long: Myread cat Compile rm ?MAKE: -pick add $@ %< ?S:chorder_short (d_cos d_bos): ?S: Holds the value describing the byte ordering of characters in a short. ?S: On a Big-Endian machine, that would be "c0c1". ?S:. ?S:chorder_int (charoder): ?S: Holds the value describing the byte ordering of characters in an int. ?S: For instance, on a Big-Endian machine, this would be: "c0c1c2c3". ?S:. ?S:chorder_long (d_col d_bol): ?S: Holds the value describing the byte ordering of characters in a long. ?S: On a 64 bits Big-Endian machine, that would yield: "c0c1c2c3c4c5c6c7". ?S:. ?C:CHAR_ORDER_SHORT: ?C: Holds the byte ordering of characters in a short. It's a string ?C: value like "c0c1" on a Big-Endian machine. ?C:. ?C:CHAR_ORDER_INT: ?C: Holds the byte ordering of characters in an int. It's a string ?C: value like "c0c1c2c3" on a Big-Endian machine. ?C:. ?C:CHAR_ORDER_LONG: ?C: Holds the byte ordering of characters in a long. It's a string ?C: value like "c0c1c2c3c4c5c6c7" on a 64 bits Big-Endian machine. ?C:. ?H:#define CHAR_ORDER_SHORT "$chorder_short" /* byte order in a short */ ?H:#define CHAR_ORDER_INT "$chorder_int" /* byte order in an int */ ?H:#define CHAR_ORDER_LONG "$chorder_long" /* byte order in a long */ ?H:. ?F:!byteorder : check for character ordering echo " " echo "Checking out byte order..." >&4 $cat >byteorder.c <<'EOCP' #include int main(argc, argv) int argc; char *argv[]; { int i; int max; union { short u_s; int u_i; long u_l; char u_c[sizeof(long)]; } u; switch (argv[1][0]) { case 'l': u.u_l = 0L; /* HMS: ASSERT: sizeof(long) < 10. */ for(i = 0; i < sizeof(long); ++i) { u.u_l *= 0x100L; u.u_l += (0xc0 + i); } max = sizeof(long); break; case 's': u.u_s = 0; /* HMS: ASSERT: sizeof(short) < 10. */ for(i = 0; i < sizeof(short); ++i) { u.u_s *= 0x100L; u.u_s += (0xc0 + i); } max = sizeof(short); break; case 'i': u.u_i = 0; /* RAM: ASSERT: sizeof(int) < 10. */ for(i = 0; i < sizeof(int); ++i) { u.u_l *= 0x100L; u.u_l += (0xc0 + i); } max = sizeof(int); break; default: max = 0; break; } for(i = 0; i < max; i++) { printf("%x", u.u_c[i] & 0x00FF); } printf("\n"); exit(0); } EOCP set byteorder if eval $compile_ok ; then : null statement @if chorder_short chorder_short=`./byteorder s` @end @if chorder_int chorder_int=`./byteorder i` @end @if chorder_long chorder_long=`./byteorder l` @end else $cat <&4 $cat >try.c < int main () { int n; unsigned char c; for (c = 1, n = 0; c; c <<= 1, n++) ; printf ("%d\n", n); return (0); } EOCP set try if eval $compile_ok; then dflt=`$run ./try` else dflt='8' echo "(I can't seem to compile the test program. Guessing...)" fi ;; *) dflt="$charbits" ;; esac rp="What is the length of a character (in bits)?" . ./myread charbits="$ans" $rm_try case "$charbits" in 8) ;; *) cat >&4 << EOM Your system has an unsigned character size of $charbits bits, which is rather unusual (normally it is 8 bits). Perl likely will not work correctly on your system, with subtle bugs in various places. EOM rp='Do you really want to continue?' dflt='n' . ./myread case "$ans" in [yY]) echo >&4 "Okay, continuing." ;; *) exit 1 ;; esac esac metaconfig-debian-perl-5.26.1/U/compline/d_NOFILE.U000066400000000000000000000115671316016665300215410ustar00rootroot00000000000000?RCS: $Id: d_NOFILE.U,v 3.0.1.1 1994/10/29 16:08:38 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_NOFILE.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:08:38 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:39 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:nofile d_gettblsz tablesize: Compile Myread Guess cat \ test rm Csym +cc +ccflags +optimize +ldflags +libs ?MAKE: -pick add $@ %< ?S:nofile: ?S: This variable contains the number of file descriptors available to the ?S: process. ?S:. ?S:d_gettblsz: ?S: This variable conditionally handles remapping of the getdtablesize() ?S: subroutine to ulimit(4,0), or the NOFILE manifest constant. ?S:. ?S:tablesize: ?S: This variable contains either the 'NOFILE' constant or 'ulimit(4, 0L)' ?S: and is used as the remapped value for the getdtablesize() macro. ?S:. ?C:getdtablesize: ?C: This catches use of the getdtablesize() subroutine, and remaps it ?C: to either ulimit(4,0) or NOFILE, if getdtablesize() isn't available. ?C:. ?C:VAL_NOFILE: ?C: This symbol contains the number of file descriptors available to the ?C: process, as determined at configuration time. Unless a static constant ?C: is needed, you should rely on getdtablesize() to obtain that number. ?C:. ?H:#$d_gettblsz getdtablesize() $tablesize /**/ ?H:#define VAL_NOFILE $nofile /* Number of file descriptors */ ?H:. ?F:!nofile ?T:d_ulimit4 val : see if getdtablesize exists echo " " ?X: Revert logical value (d_gettblsz is undef if getdtablesize is present) case "$d_gettblsz" in $define) d_gettblsz="$undef";; $undef) d_gettblsz="$define";; esac if set getdtablesize val -f d_gettblsz; eval $csym; $val; then echo 'getdtablesize() found.' >&4 d_gettblsz="$undef" tablesize='' @if VAL_NOFILE || nofile $cat >nofile.c <<'EOCP' #include int main() { printf("%d\n", getdtablesize()); } EOCP nofile='' set nofile if eval $compile_ok; then nofile=`./nofile 2>/dev/null` fi if $test "$nofile"; then echo "(You have $nofile file descriptors available per process.)" else nofile='20' if ./bsd; then nofile='64' fi echo "(Hmm... Let's say you have $nofile file descriptors available.)" fi @end else echo 'getdtablesize() NOT found...' >&4 if set ulimit val -f; eval $csym; $val; then echo 'Maybe ulimit(4,0) will work...' $cat >nofile.c <<'EOCP' #include #ifdef GETPARAM_H #include #endif int main() { printf("%d %d\n", #ifdef NOFILE NOFILE, #else 0, #endif ulimit(4,0)); exit(0); } EOCP if $cc $optimize $ccflags -DGETPARAM_H $ldflags -o nofile nofile.c $libs >/dev/null 2>&1 \ || $cc $optimize $ccflags $ldflags -o nofile nofile.c $libs >/dev/null 2>&1 ; then set `./nofile` d_gettblsz=$1 d_ulimit4=$2 if $test "$d_ulimit4" -lt 0; then echo "Your ulimit() call doesn't tell me what I want to know." echo "We'll just use NOFILE in this case." nofile=$d_gettblsz d_gettblsz="$define" tablesize='NOFILE' else if $test "$d_gettblsz" -gt 0; then echo "Your system defines NOFILE to be $d_gettblsz, and" >&4 else echo "I had trouble getting NOFILE from your system, but" >&4 fi echo "ulimit returns $d_ulimit4 as the number of available file descriptors." >&4 dflt='y'; echo " " rp='Should I use ulimit to get the number of available file descriptors?' . ./myread case "$ans" in y*) nofile=$d_ulimit4 d_gettblsz="$define" tablesize='ulimit(4, 0L)' echo "Using ulimit(4,0)." ;; *) nofile=$d_gettblsz d_gettblsz="$define" tablesize='NOFILE' echo "Using NOFILE." ;; esac fi else echo "Strange, I couldn't get my test program to compile." echo "We'll just use NOFILE in this case." d_gettblsz="$define" tablesize='NOFILE' nofile='' fi else echo 'Using NOFILE instead.' d_gettblsz="$define" tablesize='NOFILE' nofile='' fi fi @if VAL_NOFILE || nofile case "$nofile" in '') $cat >nofile.c <<'EOCP' #include #ifdef GETPARAM_H #include #endif int main() { printf("%d\n", #ifdef NOFILE NOFILE, #else 0, #endif ); exit(0); } EOCP if $cc $ccflags -DGETPARAM_H nofile.c -o nofile $libs >/dev/null 2>&1 \ || $cc $ccflags nofile.c -o nofile $libs >/dev/null 2>&1 ; then nofile=`./nofile 2>/dev/null` fi if $test "$nofile"; then echo "(You have $nofile file descriptors available per process.)" else nofile='20' if ./bsd; then nofile='64' fi echo "(Hmm... Let's say you have $nofile file descriptors available.)" fi ;; esac @end $rm -f nofile* metaconfig-debian-perl-5.26.1/U/compline/d_casti32.U000066400000000000000000000052051316016665300220250ustar00rootroot00000000000000?RCS: $Id: d_casti32.U,v 3.0.1.3 1995/05/12 12:10:45 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_casti32.U,v $ ?RCS: Revision 3.0.1.3 1995/05/12 12:10:45 ram ?RCS: patch54: made sure cc and ccflags are conditional dependencies ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:09:37 ram ?RCS: patch36: declare signal handler correctly (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:06 ram ?RCS: patch32: created by ADO ?RCS: ?X: ?X: Can the compiler cast large floats to 32-bit integers? ?X: ?MAKE:d_casti32: cat Compile rm_try intsize Setvar test signal_t run i_stdlib ?MAKE: -pick add $@ %< ?S:d_casti32: ?S: This variable conditionally defines CASTI32, which indicates ?S: whether the C compiler can cast large floats to 32-bit ints. ?S:. ?C:CASTI32: ?C: This symbol is defined if the C compiler can cast negative ?C: or large floating point numbers to 32-bit ints. ?C:. ?H:#$d_casti32 CASTI32 /**/ ?H:. ?T:xxx yyy ?F:!try ?LINT:set d_casti32 : check for ability to cast large floats to 32-bit ints. echo " " echo 'Checking whether your C compiler can cast large floats to int32.' >&4 if $test "$intsize" -ge 4; then xxx=int else xxx=long fi $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include #include $signal_t blech(int s) { exit(3); } int main() { $xxx i32; double f, g; int result = 0; char str[16]; signal(SIGFPE, blech); /* Don't let compiler optimize the test away. Store the number in a writable string for gcc to pass to sscanf under HP-UX. */ sprintf(str, "2147483647"); sscanf(str, "%lf", &f); /* f = (double) 0x7fffffff; */ g = 10 * f; i32 = ($xxx) g; /* x86 processors will probably give 0x8000 0000, which is a sign change. We don't want that. We want to mimic SPARC behavior here, which is to preserve the sign and give back 0x7fff ffff. */ if (i32 != ($xxx) f) result |= 1; exit(result); } EOCP set try if eval $compile_ok; then $run ./try 2>/dev/null yyy=$? else echo "(I can't seem to compile the test program--assuming it can't)" yyy=1 fi case "$yyy" in 0) val="$define" echo "Yup, it can." ;; *) val="$undef" echo "Nope, it can't." ;; esac set d_casti32 eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_castneg.U000066400000000000000000000110641316016665300222010ustar00rootroot00000000000000?RCS: $Id: d_castneg.U,v 3.0.1.2 1995/05/12 12:11:21 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_castneg.U,v $ ?RCS: Revision 3.0.1.2 1995/05/12 12:11:21 ram ?RCS: patch54: made sure cc and ccflags are conditional dependencies ?RCS: patch54: added improved test case for Interactive Unix ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:10:50 ram ?RCS: patch36: don't forget to tell user about compilation failures (ADO) ?RCS: patch36: declare signal handler correctly using 'signal_t' (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:47 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Can the compiler cast negative / odd floats to unsigned values. ?X: ?MAKE:d_castneg castflags: cat Compile rm_try Setvar signal_t run i_stdlib ?MAKE: -pick add $@ %< ?S:d_castneg: ?S: This variable conditionally defines CASTNEG, which indicates ?S: whether the C compiler can cast negative float to unsigned. ?S:. ?S:castflags: ?S: This variable contains a flag that precise difficulties the ?S: compiler has casting odd floating values to unsigned long: ?S: 0 = ok ?S: 1 = couldn't cast < 0 ?S: 2 = couldn't cast >= 0x80000000 ?S: 4 = couldn't cast in argument expression list ?S:. ?C:CASTNEGFLOAT: ?C: This symbol is defined if the C compiler can cast negative ?C: numbers to unsigned longs, ints and shorts. ?C:. ?C:CASTFLAGS: ?C: This symbol contains flags that say what difficulties the compiler ?C: has casting odd floating values to unsigned long: ?C: 0 = ok ?C: 1 = couldn't cast < 0 ?C: 2 = couldn't cast >= 0x80000000 ?C: 4 = couldn't cast in argument expression list ?C:. ?H:#$d_castneg CASTNEGFLOAT /**/ ?H:#define CASTFLAGS $castflags /**/ ?H:. ?F:!try ?LINT:set d_castneg : check for ability to cast negative floats to unsigned echo " " echo 'Checking whether your C compiler can cast negative float to unsigned.' >&4 $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include #include $signal_t blech(int s) { exit(7); } $signal_t blech_in_list(int s) { exit(4); } unsigned long dummy_long(unsigned long p) { return p; } unsigned int dummy_int(unsigned int p) { return p; } unsigned short dummy_short(unsigned short p) { return p; } int main() { double f; unsigned long along; unsigned int aint; unsigned short ashort; int result = 0; char str[16]; /* Frustrate gcc-2.7.2's optimizer which failed this test with a direct f = -123. assignment. gcc-2.8.0 reportedly optimized the whole file away */ /* Store the number in a writable string for gcc to pass to sscanf under HP-UX. */ sprintf(str, "-123"); sscanf(str, "%lf", &f); /* f = -123.; */ signal(SIGFPE, blech); along = (unsigned long)f; aint = (unsigned int)f; ashort = (unsigned short)f; if (along != (unsigned long)-123) result |= 1; if (aint != (unsigned int)-123) result |= 1; if (ashort != (unsigned short)-123) result |= 1; sprintf(str, "1073741824."); sscanf(str, "%lf", &f); /* f = (double)0x40000000; */ f = f + f; along = 0; along = (unsigned long)f; if (along != 0x80000000) result |= 2; f -= 1.; along = 0; along = (unsigned long)f; if (along != 0x7fffffff) result |= 1; f += 2.; along = 0; along = (unsigned long)f; if (along != 0x80000001) result |= 2; if (result) exit(result); ?X: ?X: The following is a test for Interactive Unix Version 4.1, which ?X: has an 'improved' compiler which can correctly cast negative ?X: floats in expression lists, but apparently not in argument lists. ?X: Contributed by Winfried Koenig ?X: signal(SIGFPE, blech_in_list); sprintf(str, "123."); sscanf(str, "%lf", &f); /* f = 123.; */ along = dummy_long((unsigned long)f); aint = dummy_int((unsigned int)f); ashort = dummy_short((unsigned short)f); if (along != (unsigned long)123) result |= 4; if (aint != (unsigned int)123) result |= 4; if (ashort != (unsigned short)123) result |= 4; exit(result); } EOCP set try if eval $compile_ok; then $run ./try 2>/dev/null castflags=$? else echo "(I can't seem to compile the test program--assuming it can't)" castflags=7 fi case "$castflags" in 0) val="$define" echo "Yup, it can." ;; *) val="$undef" echo "Nope, it can't." ;; esac set d_castneg eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_closedir.U000066400000000000000000000055451316016665300223700ustar00rootroot00000000000000?RCS: $Id: d_closedir.U,v 3.0.1.3 1997/02/28 15:31:26 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_closedir.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:31:26 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:11:18 ram ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:21 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_closedir d_void_closedir: Inlibc i_dirent i_sysdir i_sysndir \ i_systypes Compile Setvar rm_try run ?MAKE: -pick add $@ %< ?S:d_closedir: ?S: This variable conditionally defines HAS_CLOSEDIR if closedir() is ?S: available. ?S:. ?C:HAS_CLOSEDIR: ?C: This symbol, if defined, indicates that the closedir() routine is ?C: available. ?C:. ?H:#$d_closedir HAS_CLOSEDIR /**/ ?H:. ?S:d_void_closedir: ?S: This variable conditionally defines VOID_CLOSEDIR if closedir() ?S: does not return a value. ?S:. ?C:VOID_CLOSEDIR: ?C: This symbol, if defined, indicates that the closedir() routine ?C: does not return a value. ?C:. ?H:#$d_void_closedir VOID_CLOSEDIR /**/ ?H:. ?F:!try ?LINT:set d_closedir d_void_closedir : see if closedir exists set closedir d_closedir eval $inlibc @if VOID_CLOSEDIR || d_void_closedir ?X: The following contortions are designed so we can call closedir() ?X: and check whether it returns a value. The contortions are designed ?X: to portably pick up the correct directory header, for those ?X: systems that support various mutually incompatible directory functions. ?X: This is from perl5's perl.h case "$d_closedir" in "$define") echo " " echo "Checking whether closedir() returns a status..." >&4 cat > try.c < #endif #if defined(I_DIRENT) #include #else #ifdef I_SYS_NDIR #include #else #ifdef I_SYS_DIR #ifdef hp9000s500 #include /* may be wrong in the future */ #else #include #endif #endif #endif #endif int main() { return closedir(opendir(".")); } EOM set try if eval $compile_ok; then if $run ./try > /dev/null 2>&1 ; then echo "Yes, it does." val="$undef" else echo "No, it doesn't." val="$define" fi else echo "(I can't seem to compile the test program--assuming it doesn't)" val="$define" fi ;; *) val="$undef"; ;; esac set d_void_closedir eval $setvar $rm_try @end metaconfig-debian-perl-5.26.1/U/compline/d_eofpipe.U000066400000000000000000000046751316016665300222160ustar00rootroot00000000000000?RCS: $Id: d_eofpipe.U,v 3.0.1.1 1994/10/29 16:12:40 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_eofpipe.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:12:40 ram ?RCS: patch36: call ./bsd explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_eofpipe: Compile cat rm Oldconfig Guess echo n c ?MAKE: -pick add $@ %< ?S:d_eofpipe: ?S: This variable conditionally defines the EOFPIPE symbol, which ?S: indicates to the C program that select will correctly detect the EOF ?S: condition when pipe is closed from the other end. ?S:. ?C:EOFPIPE: ?C: This symbol, if defined, indicates that EOF condition will be detected ?C: by the reader of the pipe when it is closed by the writing process. ?C: That is, a select() call on that file descriptor will not block when ?C: only an EOF remains (typical behavior for BSD systems). ?C:. ?H:#$d_eofpipe EOFPIPE /**/ ?H:. ?F:!mpipe : see if pipe correctly gives the EOF condition echo " " case "$d_eofpipe" in '') echo "Let's see if your pipes return EOF to select() upon closing..." >&4 $cat >pipe.c <<'EOP' int main() { int pd[2]; int mask; pipe(pd); if (0 == fork()) { close(pd[0]); close(pd[1]); exit(0); } close(pd[1]); mask = 1 << pd[0]; alarm(2); select(32, &mask, (int *) 0, (int *) 0, (char *) 0); if (0 == read(pd[0], &mask, 1)) exit(0); exit(1); } EOP set pipe if eval $compile_ok; then ?X: Use a script to avoid the possible 'alarm call' message echo "./pipe || exit 1" > mpipe chmod +x mpipe ./mpipe >/dev/null 2>&1 case $? in 0) d_eofpipe="$define";; *) d_eofpipe="$undef";; esac else echo "(The test program did not compile correctly -- Guessing.)" if ./bsd; then d_eofpipe="$define" else d_eofpipe="$undef" fi fi case "$d_eofpipe" in "$define") echo "Yes, they do.";; *) echo "No, they don't! (sigh)";; esac ;; *) $echo $n "Your pipes $c" case "$d_eofpipe" in "$define") echo "allow select() to see EOF upon closing.";; *) echo "won't let select() see EOF on closing.";; esac ;; esac $rm -f *pipe* core metaconfig-debian-perl-5.26.1/U/compline/d_fd_set.U000066400000000000000000000102461316016665300220220ustar00rootroot00000000000000?RCS: $Id: d_fd_set.U,v 3.0.1.3 1997/02/28 15:33:16 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_fd_set.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:33:16 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.2 1994/06/20 06:57:23 ram ?RCS: patch30: extended scope for fd_set checks (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:06:27 ram ?RCS: patch16: comments for HAS_FD_* symbols were not consistent ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:02 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_fd_set d_fd_macros d_fds_bits: Compile cat rm_try Oldconfig \ d_socket i_systime i_sysselct i_stdlib run ?MAKE: -pick add $@ %< ?S:d_fd_set: ?S: This variable contains the eventual value of the HAS_FD_SET symbol, ?S: which indicates if your C compiler knows about the fd_set typedef. ?S:. ?S:d_fd_macros: ?S: This variable contains the eventual value of the HAS_FD_MACROS symbol, ?S: which indicates if your C compiler knows about the macros which ?S: manipulate an fd_set. ?S:. ?S:d_fds_bits: ?S: This variable contains the eventual value of the HAS_FDS_BITS symbol, ?S: which indicates if your fd_set typedef contains the fds_bits member. ?S: If you have an fd_set typedef, but the dweebs who installed it did ?S: a half-fast job and neglected to provide the macros to manipulate ?S: an fd_set, HAS_FDS_BITS will let us know how to fix the gaffe. ?S:. ?C:HAS_FD_SET: ?C: This symbol, when defined, indicates presence of the fd_set typedef ?C: in ?C:. ?C:HAS_FD_MACROS: ?C: This symbol, when defined, indicates presence of the macros used to ?C: manipulate an fd_set. ?C:. ?C:HAS_FDS_BITS: ?C: This symbol, when defined, indicates presence of the fds_bits member in ?C: fd_set. This knowledge is useful if fd_set is available but the macros ?C: aren't. ?C:. ?H:#$d_fd_set HAS_FD_SET /**/ ?H:#$d_fd_macros HAS_FD_MACROS /**/ ?H:#$d_fds_bits HAS_FDS_BITS /**/ ?H:. ?F:!try : check for fd_set items $cat <, which is included (perhaps) ?X: by . We won't force people to include ?X: because it might introduce other ?X: incompatibilities. $cat >try.c < #endif #$i_systime I_SYS_TIME #$i_sysselct I_SYS_SELECT #$d_socket HAS_SOCKET #include #ifdef HAS_SOCKET #include /* Might include */ #endif #ifdef I_SYS_TIME #include #endif #ifdef I_SYS_SELECT #include #endif int main() { fd_set fds; #ifdef TRYBITS if(fds.fds_bits); #endif #if defined(FD_SET) && defined(FD_CLR) && defined(FD_ISSET) && defined(FD_ZERO) exit(0); #else exit(1); #endif } EOCP set try -DTRYBITS if eval $compile; then d_fds_bits="$define" d_fd_set="$define" echo "Well, your system knows about the normal fd_set typedef..." >&4 if $run ./try; then echo "and you have the normal fd_set macros (just as I'd expect)." >&4 d_fd_macros="$define" else $cat >&4 <<'EOM' but not the normal fd_set macros! Gaaack! I'll have to cover for you. EOM d_fd_macros="$undef" fi else $cat <<'EOM' Hmm, your compiler has some difficulty with fd_set. Checking further... EOM set try if eval $compile; then d_fds_bits="$undef" d_fd_set="$define" echo "Well, your system has some sort of fd_set available..." >&4 if $run ./try; then echo "and you have the normal fd_set macros." >&4 d_fd_macros="$define" else $cat <<'EOM' but not the normal fd_set macros! Gross! More work for me... EOM d_fd_macros="$undef" fi else echo "Well, you got zip. That's OK, I can roll my own fd_set stuff." >&4 d_fd_set="$undef" d_fds_bits="$undef" d_fd_macros="$undef" fi fi $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_gconvert.U000066400000000000000000000227031316016665300224060ustar00rootroot00000000000000?RCS: $Id: d_gconvert.U,v 3.0.1.3 1997/02/28 15:33:38 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_gconvert.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:33:38 ram ?RCS: patch61: integrated new unit from perl5 ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 13:55:59 ram ?RCS: patch56: improved comments about the Gconvert macro (ADO) ?RCS: patch56: force compile-link test since it may exist but be unusable (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:12:51 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_Gconvert: \ Compile cat Inlibc rm _o rm_try i_stdlib i_string d_qgcvt run \ uselongdouble d_longdbl d_PRIgldbl sPRIgldbl ?MAKE: -pick add $@ %< ?S:d_Gconvert: ?S: This variable holds what Gconvert is defined as to convert ?S: floating point numbers into strings. By default, Configure ?S: sets this macro to use the first of gconvert, gcvt, or sprintf ?S: that pass sprintf-%g-like behavior tests. If perl is using ?S: long doubles, the macro uses the first of the following ?S: functions that pass Configure's tests: qgcvt, sprintf (if ?S: Configure knows how to make sprintf format long doubles--see ?S: sPRIgldbl), gconvert, gcvt, and sprintf (casting to double). ?S: The gconvert_preference and gconvert_ld_preference variables ?S: can be used to alter Configure's preferences, for doubles and ?S: long doubles, respectively. If present, they contain a ?S: space-separated list of one or more of the above function ?S: names in the order they should be tried. ?S: ?S: d_Gconvert may be set to override Configure with a platform- ?S: specific function. If this function expects a double, a ?S: different value may need to be set by the uselongdouble.cbu ?S: call-back unit so that long doubles can be formatted without ?S: loss of precision. ?S:. ?C:Gconvert: ?C: This preprocessor macro is defined to convert a floating point ?C: number to a string without a trailing decimal point. This ?C: emulates the behavior of sprintf("%g"), but is sometimes much more ?C: efficient. If gconvert() is not available, but gcvt() drops the ?C: trailing decimal point, then gcvt() is used. If all else fails, ?C: a macro using sprintf("%g") is used. Arguments for the Gconvert ?C: macro are: value, number of digits, whether trailing zeros should ?C: be retained, and the output buffer. ?C: The usual values are: ?C: d_Gconvert='gconvert((x),(n),(t),(b))' ?C: d_Gconvert='gcvt((x),(n),(b))' ?C: d_Gconvert='sprintf((b),"%.*g",(n),(x))' ?C: The last two assume trailing zeros should not be kept. ?C:. ?H:#define Gconvert(x,n,t,b) $d_Gconvert ?H:. ?T: xxx_list xxx_convert xxx_ld_list ?F:!try ?LINT:extern gconvert_preference ?LINT:extern gconvert_ld_preference : Check how to convert floats to strings. if test "X$d_Gconvert" = X; then echo " " echo "Checking for an efficient way to convert floats to strings." echo " " > try.c case "$uselongdouble" in "$define") echo "#define USE_LONG_DOUBLE" >>try.c ;; esac case "$d_longdbl" in "$define") echo "#define HAS_LONG_DOUBLE" >>try.c ;; esac case "$d_PRIgldbl" in "$define") echo "#define HAS_PRIgldbl" >>try.c ;; esac $cat >>try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_string I_STRING #ifdef I_STRING # include #else # include #endif int checkit(char *expect, char *got) { if (strcmp(expect, got)) { printf("%s oddity: Expected %s, got %s\n", myname, expect, got); exit(1); } } int main() { char buf[64]; buf[63] = '\0'; /* This must be 1st test on (which?) platform */ /* Alan Burlison */ Gconvert((DOUBLETYPE)0.1, 8, 0, buf); checkit("0.1", buf); Gconvert((DOUBLETYPE)0.01, 8, 0, buf); checkit("0.01", buf); Gconvert((DOUBLETYPE)0.001, 8, 0, buf); checkit("0.001", buf); Gconvert((DOUBLETYPE)0.0001, 8, 0, buf); checkit("0.0001", buf); Gconvert((DOUBLETYPE)0.00009, 8, 0, buf); if (strlen(buf) > 5) checkit("9e-005", buf); /* for Microsoft ?? */ else checkit("9e-05", buf); Gconvert((DOUBLETYPE)1.0, 8, 0, buf); checkit("1", buf); Gconvert((DOUBLETYPE)1.1, 8, 0, buf); checkit("1.1", buf); Gconvert((DOUBLETYPE)1.01, 8, 0, buf); checkit("1.01", buf); Gconvert((DOUBLETYPE)1.001, 8, 0, buf); checkit("1.001", buf); Gconvert((DOUBLETYPE)1.0001, 8, 0, buf); checkit("1.0001", buf); Gconvert((DOUBLETYPE)1.00001, 8, 0, buf); checkit("1.00001", buf); Gconvert((DOUBLETYPE)1.000001, 8, 0, buf); checkit("1.000001", buf); Gconvert((DOUBLETYPE)0.0, 8, 0, buf); checkit("0", buf); Gconvert((DOUBLETYPE)-1.0, 8, 0, buf); checkit("-1", buf); /* Some Linux gcvt's give 1.e+5 here. */ Gconvert((DOUBLETYPE)100000.0, 8, 0, buf); checkit("100000", buf); /* Some Linux gcvt's give -1.e+5 here. */ Gconvert((DOUBLETYPE)-100000.0, 8, 0, buf); checkit("-100000", buf); Gconvert((DOUBLETYPE)123.456, 8, 0, buf); checkit("123.456", buf); /* Testing of 1e+129 in bigintpm.t must not get extra '.' here. */ Gconvert((DOUBLETYPE)1e34, 8, 0, buf); /* 34 should be enough to scare even long double * places into using the e notation. */ if (strlen(buf) > 5) checkit("1e+034", buf); /* for Microsoft */ else checkit("1e+34", buf); /* For Perl, if you add additional tests here, also add them to * t/base/num.t for benefit of platforms not using Configure or * overriding d_Gconvert */ exit(0); } EOP ?X: List of order in which to search for functions. ?X: Usual order of efficiency is gconvert gcvt sprintf ?X: If a hint file sets a d_Gconvert="gconvert" or "gcvt" or "sprintf", ?X: then that is taken as a hint for which function to try first. ?X: (e.g. that function may be in a problematic /usr/ucblib library, and ?X: the user may or may not choose to use -lucb stuff.) ?X: Any other hint file (or previous config.sh) setting is left intact. : first add preferred functions to our list xxx_list="" for xxx_convert in $gconvert_preference; do case $xxx_convert in gcvt|gconvert|sprintf) xxx_list="$xxx_list $xxx_convert" ;; *) echo "Discarding unrecognized gconvert_preference $xxx_convert" >&4 ;; esac done : then add any others for xxx_convert in gconvert gcvt sprintf; do case "$xxx_list" in *$xxx_convert*) ;; *) xxx_list="$xxx_list $xxx_convert" ;; esac done case "$d_longdbl$uselongdouble" in "$define$define") : again, add preferred functions to our list first xxx_ld_list="" for xxx_convert in $gconvert_ld_preference; do case $xxx_convert in qgcvt|gcvt|gconvert|sprintf) xxx_ld_list="$xxx_ld_list $xxx_convert" ;; *) echo "Discarding unrecognized gconvert_ld_preference $xxx_convert" ;; esac done : then add qgcvt, sprintf--then, in xxx_list order, gconvert and gcvt for xxx_convert in qgcvt sprintf $xxx_list; do case "$xxx_ld_list" in $xxx_convert*|*" $xxx_convert"*) ;; *) xxx_ld_list="$xxx_ld_list $xxx_convert" ;; esac done : if sprintf cannot do long doubles, move it to the end if test "$d_PRIgldbl" != "$define"; then xxx_ld_list="`echo $xxx_ld_list|sed s/sprintf//` sprintf" fi : if no qgcvt, remove it if test "$d_qgcvt" != "$define"; then xxx_ld_list="`echo $xxx_ld_list|sed s/qgcvt//`" fi : use the ld_list xxx_list="$xxx_ld_list" ;; esac for xxx_convert in $xxx_list; do echo "Trying $xxx_convert..." ?X: Do NOT use $rm_try here, as we need to keep try.c $rm -f try try$_o core set try -DTRY_$xxx_convert if eval $compile; then echo "$xxx_convert() found." >&4 if $run ./try; then echo "I'll use $xxx_convert to convert floats into a string." >&4 break; else echo "...But $xxx_convert didn't work as I expected." xxx_convert='' fi else echo "$xxx_convert NOT found." >&4 fi done if test X$xxx_convert = X; then echo "*** WHOA THERE!!! ***" >&4 echo "None of ($xxx_list) seemed to work properly. I'll use sprintf." >&4 xxx_convert=sprintf fi case "$xxx_convert" in gconvert) d_Gconvert='gconvert((x),(n),(t),(b))' ;; gcvt) d_Gconvert='gcvt((x),(n),(b))' ;; qgcvt) d_Gconvert='qgcvt((x),(n),(b))' ;; *) case "$uselongdouble$d_longdbl$d_PRIgldbl" in "$define$define$define") d_Gconvert="sprintf((b),\"%.*\"$sPRIgldbl,(n),(x))" ;; "$define$define$undef") d_Gconvert='sprintf((b),"%.*g",(n),(double)(x))' ;; *) d_Gconvert='sprintf((b),"%.*g",(n),(x))' ;; esac ;; esac fi $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_getpagsz.U000066400000000000000000000023641316016665300224040ustar00rootroot00000000000000?RCS: $Id: d_getpagsz.U,v 3.0.1.1 1994/10/29 16:13:10 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_getpagsz.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:13:10 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:14 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpagsz: Compile Oldconfig Myread Inlibc Findhdr ?MAKE: -pick add $@ %< ?S:d_getpagsz: ?S: This variable conditionally defines HAS_GETPAGESIZE if getpagesize() ?S: is available to get the system page size. ?S:. ?C:HAS_GETPAGESIZE (GETPAGESIZE): ?C: This symbol, if defined, indicates that the getpagesize system call ?C: is available to get system page size, which is the granularity of ?C: many memory management calls. ?C:. ?H:#$d_getpagsz HAS_GETPAGESIZE /**/ ?H:. ?LINT:set d_getpagsz : see if getpagesize exists set getpagesize d_getpagsz eval $inlibc metaconfig-debian-perl-5.26.1/U/compline/d_gnulibc.U000066400000000000000000000064161316016665300222050ustar00rootroot00000000000000?RCS: $Id: d_gnulibc.U,v 3.0.1.1 1997/02/28 15:34:33 ram Exp $ ?RCS: ?RCS: Copyright (c) 1996,1998 Andy Dougherty ?RCS: Copyright (c) 1996, Sven Verdoolaege ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_gnulibc.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:34:33 ram ?RCS: patch61: created ?RCS: ?MAKE:d_gnulibc gnulibc_version: Myread Oldconfig Setvar rm_try \ cat Compile run ?MAKE: -pick add $@ %< ?S:d_gnulibc: ?S: Defined if we're dealing with the GNU C Library. ?S:. ?S:gnulibc_version: ?S: This variable contains the version number of the GNU C library. ?S: It is usually something like '2.2.5'. It is a plain '' if this ?S: is not the GNU C library, or if the version is unknown. ?S:. ?C:HAS_GNULIBC: ?C: This symbol, if defined, indicates to the C program that ?C: the GNU C library is being used. A better check is to use ?C: the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc. ?C:. ?H:#$d_gnulibc HAS_GNULIBC /**/ ?H:?%<:#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE) ?H:?%<:# define _GNU_SOURCE ?H:?%<:#endif ?H:. ?F:!glibc.ver !try ?LINT: set d_gnulibc ?X: gnulibc can be executed by calling __libc_main(). ?X: Ulrich Drepper doesn't think any other libc does that, ?X: but we check if it says 'GNU C Library' to be sure. ?X: ?X: Alas, as of 3/1998 glibc 2.0.7 reportedly isn't going to ?X: have __libc_main() anymore. :-(. Fortunately, all released ?X: versions of glibc 2.x.x _do_ have CPP variables. For 2.0.6, ?X: they are: ?X: #define __GLIBC__ 2 ?X: #define__GLIBC_MINOR__ 0. ?X: (The '6' isn't available :-(. ?X: glibc2.1 will also have ?X: extern const char * __gnu_get_libc_release(void); ?X: extern const char * __gnu_get_libc_version(void); ?X: functions. --thanks to Andreas Jaeger. --AD 6/1998. ?X: Although the exact format isn't documented, __gnu_get_libc_version() ?X: returns a simple string '2.1.3' in glibc 2.1.3. ?X: : Check if we are using the GNU C library echo " " echo "Checking for GNU C Library..." >&4 cat >try.c <<'EOCP' /* Find out version of GNU C library. __GLIBC__ and __GLIBC_MINOR__ alone are insufficient to distinguish different versions, such as 2.0.6 and 2.0.7. The function gnu_get_libc_version() appeared in libc version 2.1.0. A. Dougherty, June 3, 2002. */ #include int main(void) { #ifdef __GLIBC__ # ifdef __GLIBC_MINOR__ # if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 && !defined(__cplusplus) # include printf("%s\n", gnu_get_libc_version()); # else printf("%d.%d\n", __GLIBC__, __GLIBC_MINOR__); # endif # else printf("%d\n", __GLIBC__); # endif return 0; #else return 1; #endif } EOCP set try if eval $compile_ok && $run ./try > glibc.ver; then val="$define" gnulibc_version=`$cat glibc.ver` echo "You are using the GNU C Library version $gnulibc_version" else val="$undef" gnulibc_version='' echo "You are not using the GNU C Library" fi $rm_try glibc.ver set d_gnulibc eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_isascii.U000066400000000000000000000031211316016665300221740ustar00rootroot00000000000000?RCS: $Id: d_isascii.U,v 3.0.1.2 1994/10/29 16:13:39 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_isascii.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 16:13:39 ram ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:09:32 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_isascii: Compile cat rm Setvar i_stdlib ?MAKE: -pick add $@ %< ?S:d_isascii: ?S: This variable conditionally defines the HAS_ISASCII constant, ?S: which indicates to the C program that isascii() is available. ?S:. ?C:HAS_ISASCII: ?C: This manifest constant lets the C program know that isascii ?C: is available. ?C:. ?H:#$d_isascii HAS_ISASCII /**/ ?H:. ?LINT:set d_isascii ?X: Can't use Inlibc because isascii() might be a macro. : Look for isascii echo " " $cat >isascii.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { int c = 'A'; if (isascii(c)) exit(0); else exit(1); } EOCP set isascii if eval $compile; then echo "isascii() found." >&4 val="$define" else echo "isascii() NOT found." >&4 val="$undef" fi set d_isascii eval $setvar $rm -f isascii* metaconfig-debian-perl-5.26.1/U/compline/d_keepsig.U000066400000000000000000000044531316016665300222100ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_keepsig.U,v $ ?RCS: Revision 3.0.1.4 1995/07/25 13:57:56 ram ?RCS: patch56: made cc and ccflags optional dependencies ?RCS: ?RCS: Revision 3.0.1.3 1995/01/11 15:26:25 ram ?RCS: patch45: protected "sh -c" within backquotes for Linux and SGI ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:13:59 ram ?RCS: patch36: call ./bsd explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0.1.1 1993/10/16 13:48:47 ram ?RCS: patch12: comment for SIGNALS_KEPT was the other way round ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:26 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_keepsig: cat Compile rm Guess contains echo n c Setvar run ?MAKE: -pick add $@ %< ?S:d_keepsig: ?S: This variable contains the eventual value of the SIGNALS_KEPT symbol, ?S: which indicates to the C program if signal handlers need not reinstated ?S: after receipt of a signal. ?S:. ?C:SIGNALS_KEPT (PERSISTENT_SIGNAL): ?C: This symbol is defined if signal handlers needn't be reinstated after ?C: receipt of a signal. ?C:. ?H:#$d_keepsig SIGNALS_KEPT /**/ ?H:. ?F:!try !try.out ?LINT:set d_keepsig : see if signals are kept val="$undef"; echo " " echo "Checking to see if signal handlers stick around..." >&4 $cat >try.c <<'EOCP' foo() {} int main() { signal(2, foo); kill(getpid(), 2); kill(getpid(), 2); printf("abc\n"); } EOCP set try if eval $compile_ok; then ?X: On AIX a single ./try will not work (with ksh) ?X: Backquotes required on Linux and SGI (prevents "ambiguous output redirect") ?X: (reported by Xavier LeVourch ) `sh -c $run ./try >try.out 2>/dev/null` if $contains abc try.out >/dev/null 2>&1; then echo "Yes, they do." val="$define"; else echo "No, they don't." fi else $echo $n "(I can't seem to compile the test program. Assuming $c" if ./bsd; then echo "they do.)" val="$define" else echo "they don't.)" fi fi set d_keepsig eval $setvar $rm -f try* metaconfig-debian-perl-5.26.1/U/compline/d_lchown.U000066400000000000000000000057621316016665300220570ustar00rootroot00000000000000?RCS: $Id: d_lchown.U,v 3.0.1.1 1994/08/29 16:07:14 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_lchown.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:14 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_lchown: Compile Setvar cat echo ?MAKE: -pick add $@ %< ?S:d_lchown: ?S: This variable conditionally defines the HAS_LCHOWN symbol, which ?S: indicates to the C program that the lchown() routine is available ?S: to operate on a symbolic link (instead of following the link). ?S:. ?C:HAS_LCHOWN : ?C: This symbol, if defined, indicates that the lchown routine is ?C: available to operate on a symbolic link (instead of following the ?C: link). ?C:. ?H:#$d_lchown HAS_LCHOWN /**/ ?H:. ?LINT:set d_lchown : see if lchown exists echo " " ?X: Some functions (such as lchown()) are present in libc, but are ?X: unimplemented. That is, they always fail and set errno=ENOSYS. ?X: ?X: Thomas Bushnell provided the following sample code and the explanation ?X: that follows. ?X: ?X: The choice of is essentially arbitrary. The GNU libc ?X: macros are found in . You can include that file instead ?X: of (which itself includes ) if you test for ?X: its existence first. is assumed to exist on every system, ?X: which is why it's used here. Any GNU libc header file will include ?X: the stubs macros. If either __stub_NAME or __stub___NAME is defined, ?X: then the function doesn't actually exist. Tests using work ?X: on every system around. ?X: ?X: The declaration of FOO is there to override builtin prototypes for ?X: ANSI C functions. ?X: ?X: I really ought to enhance the inlibc test to check for this, but ?X: I don't have time now. --A.D. 5/1998 ?X: $cat > try.c <<'EOCP' /* System header to define __stub macros and hopefully few prototypes, which can conflict with char lchown(); below. */ #include /* Override any gcc2 internal prototype to avoid an error. */ /* We use char because int might match the return type of a gcc2 builtin and then its argument prototype would still apply. */ char lchown(); int main() { /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined (__stub_lchown) || defined (__stub___lchown) choke me #else lchown(); #endif ; return 0; } EOCP set try if eval $compile; then $echo "lchown() found." >&4 val="$define" else $echo "lchown() NOT found." >&4 val="$undef" fi set d_lchown eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_open3.U000066400000000000000000000051541316016665300216040ustar00rootroot00000000000000?RCS: $Id: d_open3.U,v 3.0.1.2 1997/02/28 15:37:12 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_open3.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:37:12 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1995/07/25 13:58:26 ram ?RCS: patch56: added knowledge of the O_NONBLOCK symbol ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:44 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_open3: Compile test cat h_fcntl h_sysfile rm_try Setvar Findhdr run i_stdlib ?MAKE: -pick add $@ %< ?X: It would be easy to separate the h_O_stuff from this. ?X: Is there a reason to do so? -- HMS ?S:d_open3: ?S: This variable conditionally defines the HAS_OPEN3 manifest constant, ?S: which indicates to the C program that the 3 argument version of ?S: the open(2) function is available. ?S:. ?C:HAS_OPEN3 (OPEN3): ?C: This manifest constant lets the C program know that the three ?C: argument form of open(2) is available. ?C:. ?H:#$d_open3 HAS_OPEN3 /**/ ?H:. ?W:%<:O_RDONLY O_WRONLY O_RDWR O_NDELAY O_APPEND O_SYNC O_CREAT O_TRUNC ?W:%<:O_EXCL O_NONBLOCK ?F:!try ?LINT:set d_open3 ?LINT:change h_fcntl h_sysfile : Locate the flags for 'open()' echo " " $cat >try.c < #ifdef I_FCNTL #include #endif #ifdef I_SYS_FILE #include #endif #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { if(O_RDONLY); #ifdef O_TRUNC exit(0); #else exit(1); #endif } EOCP : check sys/file.h first to get FREAD on Sun if $test `./findhdr sys/file.h` && \ set try -DI_SYS_FILE && eval $compile; then h_sysfile=true; echo " defines the O_* constants..." >&4 if $run ./try; then echo "and you have the 3 argument form of open()." >&4 val="$define" else echo "but not the 3 argument form of open(). Oh, well." >&4 val="$undef" fi elif $test `./findhdr fcntl.h` && \ set try -DI_FCNTL && eval $compile; then h_fcntl=true; echo " defines the O_* constants..." >&4 if $run ./try; then echo "and you have the 3 argument form of open()." >&4 val="$define" else echo "but not the 3 argument form of open(). Oh, well." >&4 val="$undef" fi else val="$undef" echo "I can't find the O_* constant definitions! You got problems." >&4 fi set d_open3 eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_safebcpy.U000066400000000000000000000063431316016665300223550ustar00rootroot00000000000000?RCS: $Id: d_safebcpy.U,v 3.0.1.4 1997/02/28 15:40:58 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_safebcpy.U,v $ ?RCS: Revision 3.0.1.4 1997/02/28 15:40:58 ram ?RCS: patch61: improved overlapping copy check ?RCS: patch61: comfort them if they have memmove ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.3 1995/07/25 13:58:40 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.2 1995/01/11 15:29:23 ram ?RCS: patch45: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:49:03 ram ?RCS: patch23: ensure string is not optimized in read-only memory (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_safebcpy: cat d_bcopy Compile rm_try run \ d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_safebcpy: ?S: This variable conditionally defines the HAS_SAFE_BCOPY symbol if ?S: the bcopy() routine can do overlapping copies. Normally, you ?S: should probably use memmove(). ?S:. ?C:HAS_SAFE_BCOPY (SAFE_BCOPY): ?C: This symbol, if defined, indicates that the bcopy routine is available ?C: to copy potentially overlapping memory blocks. Normally, you should ?C: probably use memmove() or memcpy(). If neither is defined, roll your ?C: own version. ?C:. ?H:#$d_safebcpy HAS_SAFE_BCOPY /**/ ?H:. ?F:!try ?LINT: set d_safebcpy : can bcopy handle overlapping blocks? echo " " ?X: assume the worst. val="$undef" case "$d_memmove" in "$define") echo "I'll use memmove() instead of bcopy() for overlapping copies." ;; *) case "$d_bcopy" in "$define") echo "Checking to see if bcopy() can do overlapping copies..." >&4 $cat >try.c <>try.c <<'EOCP' #include #ifdef I_MEMORY # include #endif #ifdef I_STDLIB # include #endif #ifdef I_STRING # include #else # include #endif #ifdef I_UNISTD # include /* Needed for NetBSD */ #endif int main() { char buf[128], abc[128]; char *b; int len; int off; int align; /* Copy "abcde..." string to char abc[] so that gcc doesn't try to store the string in read-only memory. */ bcopy("abcdefghijklmnopqrstuvwxyz0123456789", abc, 36); for (align = 7; align >= 0; align--) { for (len = 36; len; len--) { b = buf+align; bcopy(abc, b, len); for (off = 1; off <= len; off++) { bcopy(b, b+off, len); bcopy(b+off, b, len); if (bcmp(b, abc, len)) exit(1); } } } exit(0); } EOCP set try if eval $compile_ok; then if $run ./try 2>/dev/null; then echo "Yes, it can." val="$define" else echo "It can't, sorry." fi else echo "(I can't compile the test program, so we'll assume not...)" fi ;; esac $rm_try ;; esac set d_safebcpy eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_safemcpy.U000066400000000000000000000066111316016665300223660ustar00rootroot00000000000000?RCS: $Id: d_safemcpy.U,v 3.0.1.5 1997/02/28 15:41:12 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_safemcpy.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 15:41:12 ram ?RCS: patch61: improved overlapping copy check ?RCS: patch61: comfort them if they have memmove ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.4 1995/07/25 13:58:46 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.3 1995/03/21 08:47:26 ram ?RCS: patch52: swapped two first arguments of memcpy() calls ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:15:10 ram ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:53:12 ram ?RCS: patch23: ensure string is not optimized in read-only memory (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_safemcpy: Compile cat d_memcpy rm_try run \ d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_safemcpy: ?S: This variable conditionally defines the HAS_SAFE_MEMCPY symbol if ?S: the memcpy() routine can do overlapping copies. ?S: For overlapping copies, memmove() should be used, if available. ?S:. ?C:HAS_SAFE_MEMCPY (SAFE_MEMCPY): ?C: This symbol, if defined, indicates that the memcpy routine is available ?C: to copy potentially overlapping memory blocks. If you need to ?C: copy overlapping memory blocks, you should check HAS_MEMMOVE and ?C: use memmove() instead, if available. ?C:. ?H:#$d_safemcpy HAS_SAFE_MEMCPY /**/ ?H:. ?F:!try ?LINT: set d_safemcpy : can memcpy handle overlapping blocks? echo " " ?X: assume the worst val="$undef" case "$d_memmove" in "$define") echo "I'll use memmove() instead of memcpy() for overlapping copies." ;; *) case "$d_memcpy" in "$define") echo "Checking to see if memcpy() can do overlapping copies..." >&4 $cat >try.c <>try.c <<'EOCP' #include #ifdef I_MEMORY # include #endif #ifdef I_STDLIB # include #endif #ifdef I_STRING # include #else # include #endif #ifdef I_UNISTD # include /* Needed for NetBSD */ #endif int main() { char buf[128], abc[128]; char *b; int len; int off; int align; /* Copy "abcde..." string to char abc[] so that gcc doesn't try to store the string in read-only memory. */ memcpy(abc, "abcdefghijklmnopqrstuvwxyz0123456789", 36); for (align = 7; align >= 0; align--) { for (len = 36; len; len--) { b = buf+align; memcpy(b, abc, len); for (off = 1; off <= len; off++) { memcpy(b+off, b, len); memcpy(b, b+off, len); if (memcmp(b, abc, len)) exit(1); } } } exit(0); } EOCP set try if eval $compile_ok; then if $run ./try 2>/dev/null; then echo "Yes, it can." val="$define" else echo "It can't, sorry." fi else echo "(I can't compile the test program, so we'll assume not...)" fi ;; esac $rm_try ;; esac set d_safemcpy eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_sanemcmp.U000066400000000000000000000042351316016665300223620ustar00rootroot00000000000000?RCS: $Id: d_sanemcmp.U,v 3.0.1.1 1997/02/28 15:41:19 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_sanemcmp.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:41:19 ram ?RCS: patch61: created ?RCS: ?RCS: ?MAKE:d_sanemcmp: Compile cat d_memcmp rm_try run \ i_memory i_stdlib i_string i_unistd Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_sanemcmp: ?S: This variable conditionally defines the HAS_SANE_MEMCMP symbol if ?S: the memcpy() routine is available and can be used to compare relative ?S: magnitudes of chars with their high bits set. ?S:. ?C:HAS_SANE_MEMCMP: ?C: This symbol, if defined, indicates that the memcmp routine is available ?C: and can be used to compare relative magnitudes of chars with their high ?C: bits set. If it is not defined, roll your own version. ?C:. ?H:#$d_sanemcmp HAS_SANE_MEMCMP /**/ ?H:. ?F:!try ?LINT: set d_sanemcmp : can memcmp be trusted to compare relative magnitude? ?X: assume the worst val="$undef" case "$d_memcmp" in "$define") echo " " echo "Checking if your memcmp() can compare relative magnitude..." >&4 $cat >try.c <>try.c <<'EOCP' #include #ifdef I_MEMORY # include #endif #ifdef I_STDLIB # include #endif #ifdef I_STRING # include #else # include #endif #ifdef I_UNISTD # include /* Needed for NetBSD */ #endif int main() { char a = -1; char b = 0; if ((a < b) && memcmp(&a, &b, 1) < 0) exit(1); exit(0); } EOCP set try if eval $compile_ok; then if $run ./try 2>/dev/null; then echo "Yes, it can." val="$define" else echo "No, it can't (it uses signed chars)." fi else echo "(I can't compile the test program, so we'll assume not...)" fi ;; esac $rm_try set d_sanemcmp eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_scannl.U000066400000000000000000000040701316016665300220320ustar00rootroot00000000000000?RCS: $Id: d_scannl.U,v 3.0.1.2 1997/02/28 15:41:27 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_scannl.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:41:27 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1995/07/25 13:59:12 ram ?RCS: patch56: made cc and ccflags optional dependencies ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:00 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Does the scanf routine read "\n" correctly ? This is was not ?X: the case on AIX... ?X: ?MAKE:d_scannl: cat rm Setvar Compile run ?MAKE: -pick add $@ %< ?S:d_scannl: ?S: This variable conditionally defines SCAN_NL, which indicates ?S: whether the C library routines scanf() and friends can deal with ?S: a '\n' in the input correctly. They do most of the time. ?S:. ?C:SCAN_NL: ?C: This symbol is defined if the C library routines scanf() and friends ?C: can deal with a '\n' in the input correctly, so that you can say ?C: scanf("%d\n"); instead of scanf("%d"); getc(c); to handle the '\n'. ?C:. ?H:#$d_scannl SCAN_NL /* scanf("%d\n") works */ ?H:. ?F:!try ?LINT:set d_scannl : does scanf handle "\n" correctly ? echo " " val="$define" ?X: I really want to say "\n" instead of '\n', because I am referring ?X: to the string given as argument to scanf(). echo 'Let'"'"'s see if scanf() handles "\\n" correctly...' >&4 $cat >try.c <<'EOCP' int main() { int i = 0, j = 0; scanf("%d\n%d", &i, &j); if (j != 3) exit(1); exit(0); } EOCP set try if eval $compile_ok; then if $run ./try <<'EOD' 2 3 EOD then echo "Yes, it does." else echo "No, it doesn't." val="$undef" fi else echo "(I can't seem to compile the test program. Assuming it does.)" fi set d_scannl eval $setvar $rm -f try.* try metaconfig-debian-perl-5.26.1/U/compline/d_sgndchr.U000066400000000000000000000033031316016665300222020ustar00rootroot00000000000000?RCS: $Id: d_sgndchr.U,v 3.0.1.2 1997/02/28 15:44:25 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_sgndchr.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:44:25 ram ?RCS: patch61: added a ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1995/07/25 14:00:24 ram ?RCS: patch56: made cc and ccflags optional dependencies ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:16 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_sgndchr: cat rm Compile Setvar run ?MAKE: -pick add $@ %< ?S:d_sgndchr: ?S: This variable conditionally defines the SIGNEDCHAR symbol, which ?S: indicates to the C program that signed characters are available. ?S:. ?C:SIGNEDCHAR: ?C: This symbol, if defined, indicates that characters are a signed type. ?C: If not defined, things declared as signed characters (and that make ?C: use of negative values) should probably be declared as shorts instead. ?C:. ?H:#$d_sgndchr SIGNEDCHAR /**/ ?H:. ?F:!try ?LINT:set d_sgndchr : check for signed chars echo " " echo "Checking to see if your C compiler can do signed chars..." >&4 $cat >try.c <<'EOCP' int main() { char c = 0; c--; exit(c >= 0); } EOCP set try if eval $compile && $run ./try; then if $run ./try; then val="$define" echo "It certainly can." else val="$undef" echo "It can't. I'll have to make some things type short." fi set d_sgndchr eval $setvar $rm -f try* metaconfig-debian-perl-5.26.1/U/compline/d_sigaction.U000066400000000000000000000035471316016665300225440ustar00rootroot00000000000000?RCS: $Id: d_sigaction.U,v 3.0.1.1 1997/02/28 15:44:29 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_sigaction.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:44:29 ram ?RCS: patch61: created ?RCS: ?RCS: ?MAKE:d_sigaction: Csym Compile Setvar cat rm_try i_stdlib ?MAKE: -pick add $@ %< ?S:d_sigaction: ?S: This variable conditionally defines the HAS_SIGACTION symbol, which ?S: indicates that the Vr4 sigaction() routine is available. ?S:. ?C:HAS_SIGACTION: ?C: This symbol, if defined, indicates that Vr4's sigaction() routine ?C: is available. ?C:. ?H:#$d_sigaction HAS_SIGACTION /**/ ?H:. ?T:val ?LINT:set d_sigaction : see if we have sigaction echo " " if set sigaction val -f d_sigaction; eval $csym; $val; then echo 'sigaction() found.' >&4 ?X: ?X: Solaris 2.5_x86 with SunWorks Pro C 3.0.1 doesn't have a complete ?X: sigaction structure if compiled with cc -Xc. This compile test ?X: will fail then. ?X: $cat > try.c < #include #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { struct sigaction act, oact; act.sa_flags = 0; oact.sa_handler = 0; /* so that act and oact are used */ exit(act.sa_flags == 0 && oact.sa_handler == 0); } EOP set try if eval $compile_ok; then val="$define" else echo "But you don't seem to have a usable struct sigaction." >&4 val="$undef" fi else echo 'sigaction NOT found.' >&4 val="$undef" fi set d_sigaction; eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_siginfo_si.U000066400000000000000000000107231316016665300227070ustar00rootroot00000000000000?RCS: Copyright (c) 2016 Dagfinn Ilmari Mannsåker & H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_siginfo_si_errno d_siginfo_si_pid d_siginfo_si_uid d_siginfo_si_addr d_siginfo_si_status d_siginfo_si_band d_siginfo_si_value d_siginfo_si_fd: d_sigaction pidtype uidtype Hasfield_t ?MAKE: -pick add $@ %< ?S:d_siginfo_si_errno: ?S: This variable conditionally defines the HAS_SIGINFO_SI_ERRNO symbol, ?S: which indicates that the siginfo_t struct has the si_errno member. ?S:. ?S:d_siginfo_si_pid: ?S: This variable conditionally defines the HAS_SIGINFO_SI_PID symbol, ?S: which indicates that the siginfo_t struct has the si_pid member. ?S:. ?S:d_siginfo_si_uid: ?S: This variable conditionally defines the HAS_SIGINFO_SI_UID symbol, ?S: which indicates that the siginfo_t struct has the si_uid member. ?S:. ?S:d_siginfo_si_addr: ?S: This variable conditionally defines the HAS_SIGINFO_SI_ADDR symbol, ?S: which indicates that the siginfo_t struct has the si_addr member. ?S:. ?S:d_siginfo_si_status: ?S: This variable conditionally defines the HAS_SIGINFO_SI_STATUS symbol, ?S: which indicates that the siginfo_t struct has the si_status member. ?S:. ?S:d_siginfo_si_band: ?S: This variable conditionally defines the HAS_SIGINFO_SI_BAND symbol, ?S: which indicates that the siginfo_t struct has the si_band member. ?S:. ?S:d_siginfo_si_value: ?S: This variable conditionally defines the HAS_SIGINFO_SI_VALUE symbol, ?S: which indicates that the siginfo_t struct has the si_value member. ?S:. ?S:d_siginfo_si_fd: ?S: This variable conditionally defines the HAS_SIGINFO_SI_FD symbol, ?S: which indicates that the siginfo_t struct has the si_fd member. ?S:. ?C:HAS_SIGINFO_SI_ERRNO: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_errno member ?C:. ?C:HAS_SIGINFO_SI_PID: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_pid member ?C:. ?C:HAS_SIGINFO_SI_UID: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_uid member ?C:. ?C:HAS_SIGINFO_SI_ADDR: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_addr member ?C:. ?C:HAS_SIGINFO_SI_STATUS: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_status member ?C:. ?C:HAS_SIGINFO_SI_BAND: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_band member ?C:. ?C:HAS_SIGINFO_SI_VALUE: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_value member ?C:. ?C:HAS_SIGINFO_SI_FD: ?C: This symbol, if defined, indicates that siginfo_t has the ?C: si_fd member ?C:. ?H:#$d_siginfo_si_errno HAS_SIGINFO_SI_ERRNO /**/ ?H:#$d_siginfo_si_pid HAS_SIGINFO_SI_PID /**/ ?H:#$d_siginfo_si_uid HAS_SIGINFO_SI_UID /**/ ?H:#$d_siginfo_si_addr HAS_SIGINFO_SI_ADDR /**/ ?H:#$d_siginfo_si_status HAS_SIGINFO_SI_STATUS /**/ ?H:#$d_siginfo_si_band HAS_SIGINFO_SI_BAND /**/ ?H:#$d_siginfo_si_value HAS_SIGINFO_SI_VALUE /**/ ?H:#$d_siginfo_si_fd HAS_SIGINFO_SI_FD /**/ ?H:. : see what siginfo fields we have case "$d_sigaction" in "$define") echo "Checking if your siginfo_t has si_errno field...">&4 set d_siginfo_si_errno siginfo_t int si_errno $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_pid field...">&4 set d_siginfo_si_pid siginfo_t $pidtype si_pid $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_uid field...">&4 set d_siginfo_si_uid siginfo_t $uidtype si_uid $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_addr field...">&4 set d_siginfo_si_addr siginfo_t "void *" si_addr $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_status field...">&4 set d_siginfo_si_status siginfo_t int si_status $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_band field...">&4 set d_siginfo_si_band siginfo_t long si_band $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_value field...">&4 set d_siginfo_si_value siginfo_t "union sigval" si_value $d_sigaction signal.h eval $hasfield_t; echo "Checking if your siginfo_t has si_fd field...">&4 set d_siginfo_si_fd siginfo_t int si_fd $d_sigaction signal.h eval $hasfield_t; ;; *) d_siginfo_si_errno="$undef" d_siginfo_si_pid="$undef" d_siginfo_si_uid="$undef" d_siginfo_si_addr="$undef" d_siginfo_si_status="$undef" d_siginfo_si_band="$undef" d_siginfo_si_value="$undef" d_siginfo_si_fd="$undef" ;; esac metaconfig-debian-perl-5.26.1/U/compline/d_sigsetjmp.U000066400000000000000000000062301316016665300225610ustar00rootroot00000000000000?RCS: $Id: d_sigsetjmp.U,v 3.0.1.1 1997/02/28 15:44:33 ram Exp $ ?RCS: ?RCS: Copyright (c) 1996,1998 Andy Dougherty ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_sigsetjmp.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:44:33 ram ?RCS: patch61: created ?RCS: ?MAKE:d_sigsetjmp: Compile Setvar cat rm_try run i_stdlib ?MAKE: -pick add $@ %< ?S:d_sigsetjmp: ?S: This variable conditionally defines the HAS_SIGSETJMP symbol, ?S: which indicates that the sigsetjmp() routine is available to ?S: call setjmp() and optionally save the process's signal mask. ?S:. ?C:HAS_SIGSETJMP: ?C: This variable indicates to the C program that the sigsetjmp() ?C: routine is available to save the calling process's registers ?C: and stack environment for later use by siglongjmp(), and ?C: to optionally save the process's signal mask. See ?C: Sigjmp_buf, Sigsetjmp, and Siglongjmp. ?C:. ?C:Sigjmp_buf: ?C: This is the buffer type to be used with Sigsetjmp and Siglongjmp. ?C:. ?C:Sigsetjmp: ?C: This macro is used in the same way as sigsetjmp(), but will invoke ?C: traditional setjmp() if sigsetjmp isn't available. ?C: See HAS_SIGSETJMP. ?C:. ?C:Siglongjmp: ?C: This macro is used in the same way as siglongjmp(), but will invoke ?C: traditional longjmp() if siglongjmp isn't available. ?C: See HAS_SIGSETJMP. ?C:. ?H:?%<:#$d_sigsetjmp HAS_SIGSETJMP /**/ ?H:?%<:#ifdef HAS_SIGSETJMP ?H:?%<:#define Sigjmp_buf sigjmp_buf ?H:?%<:#define Sigsetjmp(buf,save_mask) sigsetjmp((buf),(save_mask)) ?H:?%<:#define Siglongjmp(buf,retval) siglongjmp((buf),(retval)) ?H:?%<:#else ?H:?%<:#define Sigjmp_buf jmp_buf ?H:?%<:#define Sigsetjmp(buf,save_mask) setjmp((buf)) ?H:?%<:#define Siglongjmp(buf,retval) longjmp((buf),(retval)) ?H:?%<:#endif ?H:. ?W:%<:Sigjmp_buf Sigsetjmp Siglongjmp ?F:!try ?LINT:set d_sigsetjmp : see if sigsetjmp exists ?X: We can't check for these symbols with Inlibc because sigsetjmp ?X: is (sometimes? always?) a macro under GCC echo " " case "$d_sigsetjmp" in '') $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif sigjmp_buf env; int set = 1; int main() { if (sigsetjmp(env,1)) exit(set); set = 0; siglongjmp(env, 1); exit(1); } EOP set try if eval $compile; then if $run ./try >/dev/null 2>&1; then echo "POSIX sigsetjmp found." >&4 val="$define" else $cat >&4 <&4 val="$undef" fi ;; *) val="$d_sigsetjmp" case "$d_sigsetjmp" in $define) echo "POSIX sigsetjmp found." >&4;; $undef) echo "sigsetjmp not found." >&4;; esac ;; esac set d_sigsetjmp eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_static_inline.U000066400000000000000000000112071316016665300234010ustar00rootroot00000000000000?RCS: $Id: d_static_inline.U,v $ ?RCS: ?RCS: Copyright (c) 2010 Andrew Dougherty ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?MAKE:d_static_inline perl_static_inline: Compile Setvar gccversion \ cat echo run hint rm rm_try ?MAKE: -pick add $@ %< ?S:d_static_inline: ?S: This variable conditionally defines the HAS_STATIC_INLINE symbol, ?S: which indicates that the C compiler supports C99-style static ?S: inline. That is, the function can't be called from another ?S: translation unit. ?S:. ?S:perl_static_inline: ?S: This variable defines the PERL_STATIC_INLINE symbol to ?S: the best-guess incantation to use for static inline functions. ?S: Possibilities include ?S: static inline (c99) ?S: static __inline__ (gcc -ansi) ?S: static __inline (MSVC) ?S: static _inline (older MSVC) ?S: static (c89 compilers) ?S:. ?C:HAS_STATIC_INLINE : ?C: This symbol, if defined, indicates that the C compiler supports ?C: C99-style static inline. That is, the function can't be called ?C: from another translation unit. ?C:. ?C:PERL_STATIC_INLINE: ?C: This symbol gives the best-guess incantation to use for static ?C: inline functions. If HAS_STATIC_INLINE is defined, this will ?C: give C99-style inline. If HAS_STATIC_INLINE is not defined, ?C: this will give a plain 'static'. It will always be defined ?C: to something that gives static linkage. ?C: Possibilities include ?C: static inline (c99) ?C: static __inline__ (gcc -ansi) ?C: static __inline (MSVC) ?C: static _inline (older MSVC) ?C: static (c89 compilers) ?C:. ?H:#$d_static_inline HAS_STATIC_INLINE /**/ ?H:#define PERL_STATIC_INLINE $perl_static_inline /**/ ?H:. ?LINT:set d_static_inline ?T:inline xxx ?F:!try : see what flavor, if any, of static inline is supported echo " " echo "Checking to see if your system supports static inline..." ?X: Build two programs. The first uses static inline in file a.c and ?X: should work. The second also includes b.c which tries to link against ?X: the static function in a.c. This should fail. ?X:. $cat > try.c <<'EOCP' #include extern int f_via_a(int x); extern int f_via_b(int x); int main(int argc, char **argv) { int y; y = f_via_a(0); #ifdef USE_B y = f_via_b(0); #endif if (y == 42) { return EXIT_SUCCESS; } else { return EXIT_FAILURE; } } EOCP $cat > a.c <<'EOCP' static INLINE int f(int x) { int y; y = x + 42; return y; } int f_via_a(int x) { return f(x); } EOCP $cat > b.c <<'EOCP' extern int f(int x); int f_via_b(int x) { return f(x); } EOCP # Respect a hint (or previous) value for perl_static_inline, if there is one. case "$perl_static_inline" in '') # Check the various possibilities, and break out on success. # For gcc, prefer __inline__, which will still permit # cflags.SH to add in -ansi. case "$gccversion" in '') xxx="inline __inline__ __inline _inline";; *) xxx="__inline__ inline __inline _inline";; esac for inline in $xxx; do set try -DINLINE=$inline a.c if eval $compile && $run ./try; then # Now make sure there is no external linkage of static # functions set try -DINLINE=$inline -DUSE_B a.c b.c if eval $compile && $run ./try; then $echo "Your compiler supports static $inline, " >&4 $echo "but it also creates an external definition," >&4 $echo "so I won't use it." >&4 val=$undef else $echo "Your compiler supports static $inline." >&4 val=$define perl_static_inline="static $inline"; break; fi else $echo "Your compiler does NOT support static $inline." >&4 val="$undef" fi done ;; *inline*) # Some variant of inline exists. echo "Keeping your $hint value of $perl_static_inline." val=$define ;; static) # No inline capabilities echo "Keeping your $hint value of $perl_static_inline." val=$undef ;; *) # Unrecognized previous value -- blindly trust the supplied # value and hope it makes sense. Use old value for # d_static_inline, if there is one. echo "Keeping your $hint value of $perl_static_inline." case "$d_static_inline" in '') val=$define ;; *) val=$d_static_inline ;; esac ;; esac # Fallback to plain 'static' if nothing worked. case "$perl_static_inline" in '') perl_static_inline="static" val=$undef ;; esac set d_static_inline eval $setvar $rm -f a.[co] b.[co] $rm_try metaconfig-debian-perl-5.26.1/U/compline/d_stdstdio.U000066400000000000000000000344431316016665300224200ustar00rootroot00000000000000?RCS: $Id: d_stdstdio.U,v 3.0.1.3 1997/02/28 15:46:32 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Tye McQueen ?RCS: ?RCS: $Log: d_stdstdio.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:46:32 ram ?RCS: patch61: merged with perl5's unit ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 14:06:54 ram ?RCS: patch56: typo fix on ?C: line for FILE_bufsiz ?RCS: patch56: fixed unbalanced parenthesis (ADO) ?RCS: patch56: check whether FILE_cnt and FILE_ptr can be assigned to (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1995/05/12 12:12:11 ram ?RCS: patch54: complete rewrite by Tye McQueen to fit modern systems ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:31 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_stdstdio d_stdiobase stdio_ptr stdio_cnt \ d_stdio_ptr_lval_sets_cnt d_stdio_ptr_lval_nochange_cnt stdio_base \ stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf: cat \ Compile contains rm_try d_gnulibc gnulibc_version i_stdlib \ Setvar Findhdr Oldconfig run to ?MAKE: -pick weed $@ %< ?S:d_stdstdio: ?S: This variable conditionally defines USE_STDIO_PTR if this system ?S: has a FILE structure declaring usable _ptr and _cnt fields (or ?S: equivalent) in stdio.h. ?S:. ?S:stdio_ptr: ?S: This variable defines how, given a FILE pointer, fp, to access the ?S: _ptr field (or equivalent) of stdio.h's FILE structure. This will ?S: be used to define the macro FILE_ptr(fp). ?S:. ?S:d_stdio_ptr_lval: ?S: This variable conditionally defines STDIO_PTR_LVALUE if the ?S: FILE_ptr macro can be used as an lvalue. ?S:. ?S:stdio_cnt: ?S: This variable defines how, given a FILE pointer, fp, to access the ?S: _cnt field (or equivalent) of stdio.h's FILE structure. This will ?S: be used to define the macro FILE_cnt(fp). ?S:. ?S:d_stdio_cnt_lval: ?S: This variable conditionally defines STDIO_CNT_LVALUE if the ?S: FILE_cnt macro can be used as an lvalue. ?S:. ?S:d_stdio_ptr_lval_sets_cnt: ?S: This symbol is defined if using the FILE_ptr macro as an lvalue ?S: to increase the pointer by n has the side effect of decreasing the ?S: value of File_cnt(fp) by n. ?S:. ?S:d_stdio_ptr_lval_nochange_cnt: ?S: This symbol is defined if using the FILE_ptr macro as an lvalue ?S: to increase the pointer by n leaves File_cnt(fp) unchanged. ?S:. ?S:stdio_filbuf: ?S: This variable defines how, given a FILE pointer, fp, to tell ?S: stdio to refill its internal buffers (?). This will ?S: be used to define the macro FILE_filbuf(fp). ?S:. ?S:d_stdiobase: ?S: This variable conditionally defines USE_STDIO_BASE if this system ?S: has a FILE structure declaring a usable _base field (or equivalent) ?S: in stdio.h. ?S:. ?S:stdio_base: ?S: This variable defines how, given a FILE pointer, fp, to access the ?S: _base field (or equivalent) of stdio.h's FILE structure. This will ?S: be used to define the macro FILE_base(fp). ?S:. ?S:stdio_bufsiz: ?S: This variable defines how, given a FILE pointer, fp, to determine ?S: the number of bytes store in the I/O buffer pointer to by the ?S: _base field (or equivalent) of stdio.h's FILE structure. This will ?S: be used to define the macro FILE_bufsiz(fp). ?S:. ?C:USE_STDIO_PTR ~ d_stdstdio (USE_STD_STDIO STDSTDIO): ?C: This symbol is defined if the _ptr and _cnt fields (or similar) ?C: of the stdio FILE structure can be used to access the stdio buffer ?C: for a file handle. If this is defined, then the FILE_ptr(fp) ?C: and FILE_cnt(fp) macros will also be defined and should be used ?C: to access these fields. ?C:. ?C:FILE_ptr: ?C: This macro is used to access the _ptr field (or equivalent) of the ?C: FILE structure pointed to by its argument. This macro will always be ?C: defined if USE_STDIO_PTR is defined. ?C:. ?C:STDIO_PTR_LVALUE: ?C: This symbol is defined if the FILE_ptr macro can be used as an ?C: lvalue. ?C:. ?C:FILE_cnt: ?C: This macro is used to access the _cnt field (or equivalent) of the ?C: FILE structure pointed to by its argument. This macro will always be ?C: defined if USE_STDIO_PTR is defined. ?C:. ?C:STDIO_CNT_LVALUE: ?C: This symbol is defined if the FILE_cnt macro can be used as an ?C: lvalue. ?C:. ?C:STDIO_PTR_LVAL_SETS_CNT: ?C: This symbol is defined if using the FILE_ptr macro as an lvalue ?C: to increase the pointer by n has the side effect of decreasing the ?C: value of File_cnt(fp) by n. ?C:. ?C:STDIO_PTR_LVAL_NOCHANGE_CNT: ?C: This symbol is defined if using the FILE_ptr macro as an lvalue ?C: to increase the pointer by n leaves File_cnt(fp) unchanged. ?C:. ?C:FILE_filbuf: ?C: This macro is used to access the internal stdio _filbuf function ?C: (or equivalent), if STDIO_CNT_LVALUE and STDIO_PTR_LVALUE ?C: are defined. It is typically either _filbuf or __filbuf. ?C: This macro will only be defined if both STDIO_CNT_LVALUE and ?C: STDIO_PTR_LVALUE are defined. ?C:. ?H:?d_stdstdio:#$d_stdstdio USE_STDIO_PTR /**/ ?H:?d_stdstdio:#ifdef USE_STDIO_PTR ?H:#define FILE_ptr(fp) $stdio_ptr ?H:#$d_stdio_ptr_lval STDIO_PTR_LVALUE /**/ ?H:#define FILE_cnt(fp) $stdio_cnt ?H:#$d_stdio_cnt_lval STDIO_CNT_LVALUE /**/ ?H:#$d_stdio_ptr_lval_sets_cnt STDIO_PTR_LVAL_SETS_CNT /**/ ?H:#$d_stdio_ptr_lval_nochange_cnt STDIO_PTR_LVAL_NOCHANGE_CNT /**/ ?H:?FILE_filbuf:#if defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE) ?H:?FILE_filbuf:#define FILE_filbuf(fp) $stdio_filbuf /**/ ?H:?FILE_filbuf:#endif ?H:?d_stdstdio:#endif ?H:. ?W:d_stdstdio:FILE_ptr FILE_cnt FILE_filbuf ?C:USE_STDIO_BASE ~ d_stdiobase: ?C: This symbol is defined if the _base field (or similar) of the ?C: stdio FILE structure can be used to access the stdio buffer for ?C: a file handle. If this is defined, then the FILE_base(fp) macro ?C: will also be defined and should be used to access this field. ?C: Also, the FILE_bufsiz(fp) macro will be defined and should be used ?C: to determine the number of bytes in the buffer. USE_STDIO_BASE ?C: will never be defined unless USE_STDIO_PTR is. ?C:. ?C:FILE_base: ?C: This macro is used to access the _base field (or equivalent) of the ?C: FILE structure pointed to by its argument. This macro will always be ?C: defined if USE_STDIO_BASE is defined. ?C:. ?C:FILE_bufsiz: ?C: This macro is used to determine the number of bytes in the I/O ?C: buffer pointed to by _base field (or equivalent) of the FILE ?C: structure pointed to its argument. This macro will always be defined ?C: if USE_STDIO_BASE is defined. ?C:. ?H:?d_stdiobase:#$d_stdiobase USE_STDIO_BASE /**/ ?H:?d_stdiobase:#ifdef USE_STDIO_BASE ?H:#define FILE_base(fp) $stdio_base ?H:#define FILE_bufsiz(fp) $stdio_bufsiz ?H:?d_stdiobase:#endif ?H:. ?W:d_stdiobase:FILE_base FILE_bufsiz ?T:ptr_lval cnt_lval filbuf xxx ?F:!try ?LINT:set d_stdstdio d_stdiobase : see if _ptr and _cnt from stdio act std echo " " if $contains '_lbfsize' `./findhdr stdio.h` >/dev/null 2>&1 ; then echo "(Looks like you have stdio.h from BSD.)" case "$stdio_ptr" in '') stdio_ptr='((fp)->_p)' ptr_lval=$define ;; *) ptr_lval=$d_stdio_ptr_lval;; esac case "$stdio_cnt" in '') stdio_cnt='((fp)->_r)' cnt_lval=$define ;; *) cnt_lval=$d_stdio_cnt_lval;; esac case "$stdio_base" in '') stdio_base='((fp)->_ub._base ? (fp)->_ub._base : (fp)->_bf._base)';; esac case "$stdio_bufsiz" in '') stdio_bufsiz='((fp)->_ub._base ? (fp)->_ub._size : (fp)->_bf._size)';; esac elif $contains '_IO_fpos_t' `./findhdr stdio.h` `./findhdr libio.h` >/dev/null 2>&1 ; then echo "(Looks like you have stdio.h from Linux.)" case "$stdio_ptr" in '') stdio_ptr='((fp)->_IO_read_ptr)' ptr_lval=$define ;; *) ptr_lval=$d_stdio_ptr_lval;; esac case "$stdio_cnt" in '') stdio_cnt='((fp)->_IO_read_end - (fp)->_IO_read_ptr)' cnt_lval=$undef ;; *) cnt_lval=$d_stdio_cnt_lval;; esac case "$stdio_base" in '') stdio_base='((fp)->_IO_read_base)';; esac case "$stdio_bufsiz" in '') stdio_bufsiz='((fp)->_IO_read_end - (fp)->_IO_read_base)';; esac else case "$stdio_ptr" in '') stdio_ptr='((fp)->_ptr)' ptr_lval=$define ;; *) ptr_lval=$d_stdio_ptr_lval;; esac case "$stdio_cnt" in '') stdio_cnt='((fp)->_cnt)' cnt_lval=$define ;; *) cnt_lval=$d_stdio_cnt_lval;; esac case "$stdio_base" in '') stdio_base='((fp)->_base)';; esac case "$stdio_bufsiz" in '') stdio_bufsiz='((fp)->_cnt + (fp)->_ptr - (fp)->_base)';; esac fi : test whether _ptr and _cnt really work echo "Checking how std your stdio is..." >&4 $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #define FILE_ptr(fp) $stdio_ptr #define FILE_cnt(fp) $stdio_cnt int main() { FILE *fp = fopen("try.c", "r"); char c = getc(fp); if ( 18 <= FILE_cnt(fp) && strncmp(FILE_ptr(fp), "include \n", 18) == 0 ) exit(0); exit(1); } EOP val="$undef" set try if eval $compile && $to try.c; then if $run ./try; then echo "Your stdio acts pretty std." val="$define" else echo "Your stdio isn't very std." fi else echo "Your stdio doesn't appear very std." fi $rm_try # glibc 2.2.90 and above apparently change stdio streams so Perl's # direct buffer manipulation no longer works. The Configure tests # should be changed to correctly detect this, but until then, # the following check should at least let perl compile and run. # (This quick fix should be updated before 5.8.1.) # To be defensive, reject all unknown versions, and all versions > 2.2.9. # A. Dougherty, June 3, 2002. case "$d_gnulibc" in $define) case "$gnulibc_version" in 2.[01]*) ;; 2.2) ;; 2.2.[0-9]) ;; *) echo "But I will not snoop inside glibc $gnulibc_version stdio buffers." val="$undef" ;; esac ;; esac set d_stdstdio eval $setvar @if STDIO_PTR_LVALUE || d_stdio_ptr_lval : Can _ptr be used as an lvalue? ?X: Only makes sense if we have a known stdio implementation. case "$d_stdstdio$ptr_lval" in $define$define) val=$define ;; *) val=$undef ;; esac set d_stdio_ptr_lval eval $setvar @end @if STDIO_CNT_LVALUE || d_stdio_cnt_lval : Can _cnt be used as an lvalue? ?X: Only makes sense if we have a known stdio implementation. case "$d_stdstdio$cnt_lval" in $define$define) val=$define ;; *) val=$undef ;; esac set d_stdio_cnt_lval eval $setvar @end @if FILE_filbuf : How to access the stdio _filbuf or __filbuf function. : If this fails, check how the getc macro in stdio.h works. case "${d_stdio_ptr_lval}${d_stdio_cnt_lval}" in ${define}${define}) : Try $hint value, if any, then _filbuf, __filbuf, _fill, then punt. : _fill is for os/2. xxx='notok' for filbuf in $stdio_filbuf '_filbuf(fp)' '__filbuf(fp) ' '_fill(fp)' ; do $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #define FILE_ptr(fp) $stdio_ptr #define FILE_cnt(fp) $stdio_cnt #define FILE_filbuf(fp) $filbuf int main() { FILE *fp = fopen("try.c", "r"); int c; c = getc(fp); c = FILE_filbuf(fp); /* Just looking for linker errors.*/ exit(0); } EOP set try if eval $compile && $to try.c && $run ./try; then echo "Your stdio appears to use $filbuf" stdio_filbuf="$filbuf" xxx='ok' break else echo "Hmm. $filbuf doesn't seem to work." fi $rm_try done case "$xxx" in notok) echo "I can't figure out how to access _filbuf" echo "I'll just have to work around it." d_stdio_ptr_lval="$undef" d_stdio_cnt_lval="$undef" ;; esac ;; esac @end @if STDIO_PTR_LVALUE : test whether setting _ptr sets _cnt as a side effect d_stdio_ptr_lval_sets_cnt="$undef" d_stdio_ptr_lval_nochange_cnt="$undef" case "$d_stdio_ptr_lval$d_stdstdio" in $define$define) echo "Checking to see what happens if we set the stdio ptr..." >&4 $cat >try.c < /* Can we scream? */ /* Eat dust sed :-) */ /* In the buffer space, no one can hear you scream. */ #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #define FILE_ptr(fp) $stdio_ptr #define FILE_cnt(fp) $stdio_cnt #include int main() { FILE *fp = fopen("try.c", "r"); int c; char *ptr; size_t cnt; if (!fp) { puts("Fail even to read"); exit(1); } c = getc(fp); /* Read away the first # */ if (c == EOF) { puts("Fail even to read"); exit(1); } if (!( 18 <= FILE_cnt(fp) && strncmp(FILE_ptr(fp), "include \n", 18) == 0 )) { puts("Fail even to read"); exit (1); } ptr = (char*) FILE_ptr(fp); cnt = (size_t)FILE_cnt(fp); FILE_ptr(fp) += 42; if ((char*)FILE_ptr(fp) != (ptr + 42)) { printf("Fail ptr check %p != %p", FILE_ptr(fp), (ptr + 42)); exit (1); } if (FILE_cnt(fp) <= 20) { printf ("Fail (<20 chars to test)"); exit (1); } if (strncmp(FILE_ptr(fp), "Eat dust sed :-) */\n", 20) != 0) { puts("Fail compare"); exit (1); } if (cnt == FILE_cnt(fp)) { puts("Pass_unchanged"); exit (0); } if (FILE_cnt(fp) == (cnt - 42)) { puts("Pass_changed"); exit (0); } printf("Fail count was %d now %d\n", cnt, FILE_cnt(fp)); return 1; } EOP set try if eval $compile && $to try.c; then case `$run ./try` in Pass_changed) echo "Increasing ptr in your stdio decreases cnt by the same amount. Good." >&4 d_stdio_ptr_lval_sets_cnt="$define" ;; Pass_unchanged) echo "Increasing ptr in your stdio leaves cnt unchanged. Good." >&4 d_stdio_ptr_lval_nochange_cnt="$define" ;; Fail*) echo "Increasing ptr in your stdio didn't do exactly what I expected. We'll not be doing that then." >&4 ;; *) echo "It appears attempting to set ptr in your stdio is a bad plan." >&4 ;; esac else echo "It seems we can't set ptr in your stdio. Nevermind." >&4 fi $rm_try ;; esac @end @if d_stdiobase || USE_STDIO_BASE || FILE_base || FILE_bufsiz : see if _base is also standard val="$undef" case "$d_stdstdio" in $define) $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #define FILE_base(fp) $stdio_base #define FILE_bufsiz(fp) $stdio_bufsiz int main() { FILE *fp = fopen("try.c", "r"); char c = getc(fp); if ( 19 <= FILE_bufsiz(fp) && strncmp(FILE_base(fp), "#include \n", 19) == 0 ) exit(0); exit(1); } EOP set try if eval $compile && $to try.c; then if $run ./try; then echo "And its _base field acts std." val="$define" else echo "But its _base field isn't std." fi else echo "However, it seems to be lacking the _base field." fi $rm_try ;; esac set d_stdiobase eval $setvar @end metaconfig-debian-perl-5.26.1/U/compline/d_vprintf.U000066400000000000000000000062471316016665300222540ustar00rootroot00000000000000?RCS: $Id: d_vprintf.U,v 3.0 1993/08/18 12:07:59 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_vprintf.U,v $ ?RCS: Revision 3.0 1993/08/18 12:07:59 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_vprintf d_charvspr: Compile Guess cat Csym Setvar run rm_try \ i_stdlib i_unistd i_stdarg i_varargs ?MAKE: -pick add $@ %< ?S:d_vprintf: ?S: This variable conditionally defines the HAS_VPRINTF symbol, which ?S: indicates to the C program that the vprintf() routine is available ?S: to printf with a pointer to an argument list. ?S:. ?S:d_charvspr: ?S: This variable conditionally defines CHARVSPRINTF if this system ?S: has vsprintf returning type (char*). The trend seems to be to ?S: declare it as "int vsprintf()". ?S:. ?C:HAS_VPRINTF (VPRINTF): ?C: This symbol, if defined, indicates that the vprintf routine is available ?C: to printf with a pointer to an argument list. If unavailable, you ?C: may need to write your own, probably in terms of _doprnt(). ?C:. ?C:USE_CHAR_VSPRINTF (CHARVSPRINTF): ?C: This symbol is defined if this system has vsprintf() returning type ?C: (char*). The trend seems to be to declare it as "int vsprintf()". It ?C: is up to the package author to declare vsprintf correctly based on the ?C: symbol. ?C:. ?H:#$d_vprintf HAS_VPRINTF /**/ ?H:#$d_charvspr USE_CHAR_VSPRINTF /**/ ?H:. ?T:val2 ?F:!try ?LINT:set d_vprintf d_charvspr : see if vprintf exists echo " " if set vprintf val -f d_vprintf; eval $csym; $val; then echo 'vprintf() found.' >&4 val="$define" $cat >try.c < #else /* I_VARARGS */ # include #endif #ifdef I_UNISTD # include #endif #ifdef I_STDLIB # include #endif #include /* vsprintf prototype */ #ifdef I_STDARG void xxx(int n, ...) { va_list args; char buf[10]; va_start(args, n); exit((unsigned long)vsprintf(buf,"%s",args) > 10L); } int main() { xxx(1, "foo"); } #else /* I_VARARGS */ xxx(va_alist) va_dcl { va_list args; char buf[10]; va_start(args); exit((unsigned long)vsprintf(buf,"%s",args) > 10L); } int main() { xxx("foo"); } #endif EOF set try if eval $compile_ok; then if $run ./try; then echo "Your vsprintf() returns (int)." >&4 val2="$undef" else echo "Your vsprintf() returns (char*)." >&4 val2="$define" fi else echo 'I am unable to compile the vsprintf() test program.' >&4 # We shouldn't get here. If we do, assume the standard signature, # not the old BSD one. echo 'Guessing that vsprintf() returns (int).' >&4 val2="$undef" fi else echo 'vprintf() NOT found.' >&4 val="$undef" val2="$undef" fi $rm_try set d_vprintf eval $setvar val=$val2 set d_charvspr eval $setvar metaconfig-debian-perl-5.26.1/U/compline/d_wifstat.U000066400000000000000000000052361316016665300222420ustar00rootroot00000000000000?RCS: $Id: d_wifstat.U,v 3.0.1.3 1997/02/28 15:47:43 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_wifstat.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:47:43 ram ?RCS: patch61: added a ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 14:09:10 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.1 1995/03/21 08:47:46 ram ?RCS: patch52: created ?RCS: ?MAKE:d_wifstat: Compile d_uwait Oldconfig cat rm ?MAKE: -pick add $@ %< ?S:d_wifstat: ?S: This symbol conditionally defines USE_WIFSTAT if the C program can ?S: safely use the WIFxxx macros with the kind of wait() parameter ?S: declared in the program (see UNION_WAIT), or if it can't. Should ?S: only matter on HP-UX, where the macros are incorrectly written and ?S: therefore cause programs using them with an 'union wait' variable ?S: to not compile properly. ?S:. ?C:USE_WIFSTAT: ?C: This symbol, if defined, indicates to the C program that the argument ?C: for the WIFxxx set of macros such as WIFSIGNALED or WIFEXITED can ?C: be of the same kind as the one used to hold the wait() status. Should ?C: only matter on HP-UX, where the macros are incorrectly written and ?C: therefore cause programs using them with an 'union wait' variable ?C: to not compile properly. See also UNION_WAIT. ?C:. ?H:#$d_wifstat USE_WIFSTAT /**/ ?H:. ?T:type ?F:!foo : see if we can use WIFxxx macros echo " " case "$d_wifstat" in "$define") echo "As before, you can safely use WIFEXITED and friends!" >&4;; "$undef") echo "You still can't use WIFEXITED and friends!" >&4;; *) echo "Let's see whether you can use the WIFEXITED(status) macro and its" case "$d_uwait" in "$define") type='union wait';; *) type='int';; esac echo "friends with status declared as '$type status'..." $cat >foo.c < #include int main() { $type status; int e = 0; #ifdef WIFEXITED if (WIFEXITED(status)) printf("\n"); exit(0); #else exit(2); #endif } EOCP d_wifstat="$undef" set foo if eval $compile; then if ./foo >/dev/null; then echo "Great! Looks like we can use the WIFxxx macros." >&4 d_wifstat="$define" else echo "You don't seem to have WIFxxx macros, but that's ok." >&4 fi else echo "Apparently you can't use WIFxxx macros properly." >&4 fi $rm -f foo.* foo core ;; esac metaconfig-debian-perl-5.26.1/U/compline/doublesize.U000066400000000000000000000033231316016665300224160ustar00rootroot00000000000000?RCS: $Id: doublesize.U,v 3.0.1.1 1994/10/29 16:17:06 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: doublesize.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:17:06 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:06 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:doublesize: cat rm_try Myread Compile run i_stdlib ?MAKE: -pick add $@ %< ?S:doublesize: ?S: This variable contains the value of the DOUBLESIZE symbol, which ?S: indicates to the C program how many bytes there are in a double. ?S:. ?C:DOUBLESIZE: ?C: This symbol contains the size of a double, so that the C preprocessor ?C: can make decisions based on it. ?C:. ?H:#define DOUBLESIZE $doublesize /**/ ?H:. ?F:!try : check for length of double echo " " case "$doublesize" in '') echo "Checking to see how big your double precision numbers are..." >&4 $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof(double)); exit(0); } EOCP set try if eval $compile_ok; then doublesize=`$run ./try` echo "Your double is $doublesize bytes long." else dflt='8' echo "(I can't seem to compile the test program. Guessing...)" rp="What is the size of a double precision number (in bytes)?" . ./myread doublesize="$ans" fi ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/compline/errnolist.U000066400000000000000000000057561316016665300223060ustar00rootroot00000000000000?RCS: $Id: errnolist.U,v 3.0.1.2 1997/02/28 15:48:01 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: errnolist.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:48:01 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: patch61: likewise for .o replaced by $_o ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:10:54 ram ?RCS: patch16: created ?RCS: ?MAKE:errnolist errnolist_SH errnolist_a errnolist_c errnolist_o: cat \ Compile +d_sysernlst _a _o ?MAKE: -pick add $@ %< ?S:errnolist: ?S: This variable holds the base name of a file containing the ?S: definition of the sys_errnolist array, if the C library ?S: doesn't provide it already. Otherwise, its value is empty. ?S: The following lines should be included in your Makefile.SH: ?S: ?S: case "$errnolist" in ?S: '') ;; ?S: *) ?S: $spitshell >>Makefile <errnolist.c <<'EOCP' extern char *sys_errnolist[]; int main() { char *p0 = sys_errnolist[0]; char *p1 = sys_errnolist[1]; return (p0 == p1); /* Make sure they're not optimized away */ } EOCP set errnolist if eval $compile; then echo "It does." errnolist='' errnolist_SH='' errnolist_a='' errnolist_c='' errnolist_o='' else echo "I'll make sure your Makefile provides sys_errnolist in $errnolist.c" errnolist_SH=$errnolist.SH errnolist_a=$errnolist$_a errnolist_c=$errnolist.c errnolist_o=$errnolist$_o fi @end metaconfig-debian-perl-5.26.1/U/compline/floatsize.U000066400000000000000000000031171316016665300222520ustar00rootroot00000000000000?RCS: $Id: floatsize.U,v 3.0.1.1 1994/10/29 16:17:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: floatsize.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:17:09 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:floatsize: cat rm Myread Compile run ?MAKE: -pick add $@ %< ?S:floatsize: ?S: This variable contains the value of the FLOATSIZE symbol, which ?S: indicates to the C program how many bytes there are in a float. ?S:. ?C:FLOATSIZE: ?C: This symbol contains the size of a float, so that the C preprocessor ?C: can make decisions based on it. ?C:. ?H:#define FLOATSIZE $floatsize /**/ ?H:. ?F:!try : check for length of float echo " " case "$floatsize" in '') echo "Checking to see how big your floating point numbers are..." >&4 $cat >try.c <<'EOCP' #include int main() { printf("%d\n", (int)sizeof(float)); exit(0); } EOCP set try if eval $compile_ok; then floatsize=`$run ./try` else dflt='4' echo "(I can't seem to compile the test program. Guessing...)" rp="What is the size of a floating point number (in bytes)?" . ./myread floatsize="$ans" fi ;; esac $rm -f try.c try metaconfig-debian-perl-5.26.1/U/compline/i_time.U000066400000000000000000000142521316016665300215220ustar00rootroot00000000000000?RCS: $Id: i_time.U,v 3.0 1993/08/18 12:08:45 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: i_time.U,v $ ?RCS: Revision 3.0 1993/08/18 12:08:45 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit finds which "time" include to use. If 'timezone' is used by the ?X: program, we also try to find which header should be included. Eventually, ?X: we look for if I_SYSSELECT is used, to get struct timeval. ?X: ?MAKE:i_time i_systime i_systimek timeincl d_tm_tm_zone d_tm_tm_gmtoff: \ Compile cat \ contains rm_try echo n c +i_sysselct Findhdr Hasfield i_stdlib ?MAKE: -pick add $@ %< ?S:i_time: ?S: This variable conditionally defines I_TIME, which indicates ?S: to the C program that it should include . ?S:. ?S:i_systime: ?S: This variable conditionally defines I_SYS_TIME, which indicates ?S: to the C program that it should include . ?S:. ?S:i_systimek: ?S: This variable conditionally defines I_SYS_TIME_KERNEL, which ?S: indicates to the C program that it should include ?S: with KERNEL defined. ?S:. ?S:timeincl: ?S: This variable holds the full path of the included time header(s). ?S:. ?S:d_tm_tm_zone: ?S: This variable conditionally defines HAS_TM_TM_ZONE, which indicates ?S: indicates to the C program that the struct tm has the tm_zone field. ?S:. ?S:d_tm_tm_gmtoff: ?S: This variable conditionally defines HAS_TM_TM_GMTOFF, which indicates ?S: indicates to the C program that the struct tm has the tm_gmtoff field. ?S:. ?C:I_TIME (USE_TIME_H): ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?C:I_SYS_TIME (I_SYSTIME USE_SYS_TIME_H NO_TIME_WITH_SYS_TIME): ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?C:I_SYS_TIME_KERNEL (I_SYSTIMEKERNEL): ?C: This symbol, if defined, indicates to the C program that it should ?C: include with KERNEL defined. ?C:. ?C:HAS_TM_TM_ZONE: ?C: This symbol, if defined, indicates to the C program that ?C: the struct tm has a tm_zone field. ?C:. ?C:HAS_TM_TM_GMTOFF: ?C: This symbol, if defined, indicates to the C program that ?C: the struct tm has a tm_gmtoff field. ?C:. ?H:#$i_time I_TIME /**/ ?H:#$i_systime I_SYS_TIME /**/ ?H:#$i_systimek I_SYS_TIME_KERNEL /**/ ?H:#$d_tm_tm_zone HAS_TM_TM_ZONE /**/ ?H:#$d_tm_tm_gmtoff HAS_TM_TM_GMTOFF /**/ ?H:. ?W::timezone ?T:xselect flags sysselect s_timeval s_timezone ?LINT:change i_sysselct ?LINT:set d_tm_tm_zone ?LINT:set d_tm_tm_gmtoff : see if we should include time.h, sys/time.h, or both echo " " if test "X$timeincl" = X; then echo "Testing to see if we should include , or both." >&4 $echo $n "I'm now running the test program...$c" $cat >try.c < #ifdef I_TIME #include #endif #ifdef I_SYSTIME #ifdef SYSTIMEKERNEL #define KERNEL #endif #include #endif #ifdef I_SYSSELECT #include #endif #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { struct tm foo; #ifdef S_TIMEVAL struct timeval bar; #endif #ifdef S_TIMEZONE struct timezone tzp; #endif if (foo.tm_sec == foo.tm_sec) exit(0); #ifdef S_TIMEVAL if (bar.tv_sec == bar.tv_sec) exit(0); #endif exit(1); } EOCP flags='' @if I_SYSSELECT if $contains 'timeval.*{' `./findhdr sys/select.h` >/dev/null 2>&1; then xselect='-DI_SYSSELECT' else xselect='' fi @end @if timezone for s_timezone in '-DS_TIMEZONE' ''; do @else s_timezone='' @end ?X: Every package is given a try with 'struct timeval' @if I_SYSSELECT for sysselect in $xselect ''; do @else sysselect='' @end for s_timeval in '-DS_TIMEVAL' ''; do for i_systimek in '' '-DSYSTIMEKERNEL'; do for i_time in '' '-DI_TIME'; do for i_systime in '-DI_SYSTIME' ''; do case "$flags" in '') $echo $n ".$c" set try $i_time $i_systime $i_systimek $sysselect $s_timeval $s_timezone if eval $compile; then set X $i_time $i_systime $i_systimek $sysselect $s_timeval shift flags="$*" echo " " $echo $n "Succeeded with $flags$c" fi ;; esac done done done done @if I_SYSSELECT done @end @if timezone done @end timeincl='' echo " " case "$flags" in *SYSTIMEKERNEL*) i_systimek="$define" timeincl=`./findhdr sys/time.h` echo "We'll include with KERNEL defined." >&4;; *) i_systimek="$undef";; esac case "$flags" in *I_TIME*) i_time="$define" timeincl=`./findhdr time.h`" $timeincl" echo "We'll include ." >&4;; *) i_time="$undef";; esac case "$flags" in *I_SYSTIME*) i_systime="$define" timeincl=`./findhdr sys/time.h`" $timeincl" echo "We'll include ." >&4;; *) i_systime="$undef";; esac @if I_SYSSELECT case "$flags" in *I_SYSSELECT*) i_sysselct="$define" timeincl=`./findhdr sys/select.h`" $timeincl" echo "We'll also include to get struct timeval." >&4;; *) case "$i_sysselct" in '') i_sysselct="$undef";; esac esac @end $rm_try fi : see if struct tm knows about tm_zone case "$i_systime$i_time" in *$define*) echo " " echo "Checking to see if your struct tm has tm_zone field..." >&4 set d_tm_tm_zone tm tm_zone $i_systime sys/time.h $i_time time.h eval $hasfield ;; *) val="$undef" set d_tm_tm_zone eval $setvar ;; esac case "$d_tm_tm_zone" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac : see if struct tm knows about tm_gmtoff case "$i_systime$i_time" in *$define*) echo " " echo "Checking to see if your struct tm has tm_gmtoff field..." >&4 set d_tm_tm_gmtoff tm tm_gmtoff $i_systime sys/time.h $i_time time.h eval $hasfield ;; *) val="$undef" set d_tm_tm_gmtoff eval $setvar ;; esac case "$d_tm_tm_gmtoff" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/compline/nblock_io.U000066400000000000000000000213511316016665300222110ustar00rootroot00000000000000?RCS: $Id: nblock_io.U,v 3.0.1.2 1997/02/28 16:17:14 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: nblock_io.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 16:17:14 ram ?RCS: patch61: simplify here document for shells that can't handle them well ?RCS: patch61: force use of "startsh" at the head of the generated script ?RCS: patch61: added new files to the ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1995/07/25 14:13:22 ram ?RCS: patch56: created ?RCS: ?X: ?X: Simplify here document for shells that can't handle them well. ?X: (Problem reported on FreeBSD; it's unclear if this helps.) --AD ?X: ?MAKE:o_nonblock eagain rd_nodata d_eofnblk: cat rm_try Compile run \ d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar \ startsh i_unistd i_string i_fcntl i_stdlib d_fork d_pipe d_alarm ?MAKE: -pick add $@ %< ?S:o_nonblock: ?S: This variable bears the symbol value to be used during open() or fcntl() ?S: to turn on non-blocking I/O for a file descriptor. If you wish to switch ?S: between blocking and non-blocking, you may try ioctl(FIOSNBIO) instead, ?S: but that is only supported by some devices. ?S:. ?S:eagain: ?S: This variable bears the symbolic errno code set by read() when no ?S: data is present on the file and non-blocking I/O was enabled (otherwise, ?S: read() blocks naturally). ?S:. ?S:rd_nodata: ?S: This variable holds the return code from read() when no data is ?S: present. It should be -1, but some systems return 0 when O_NDELAY is ?S: used, which is a shame because you cannot make the difference between ?S: no data and an EOF.. Sigh! ?S:. ?S:d_eofnblk: ?S: This variable conditionally defines EOF_NONBLOCK if EOF can be seen ?S: when reading from a non-blocking I/O source. ?S:. ?C:VAL_O_NONBLOCK: ?C: This symbol is to be used during open() or fcntl(F_SETFL) to turn on ?C: non-blocking I/O for the file descriptor. Note that there is no way ?C: back, i.e. you cannot turn it blocking again this way. If you wish to ?C: alternatively switch between blocking and non-blocking, use the ?C: ioctl(FIOSNBIO) call instead, but that is not supported by all devices. ?C:. ?C:VAL_EAGAIN: ?C: This symbol holds the errno error code set by read() when no data was ?C: present on the non-blocking file descriptor. ?C:. ?C:RD_NODATA: ?C: This symbol holds the return code from read() when no data is present ?C: on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is ?C: not defined, then you can't distinguish between no data and EOF by ?C: issuing a read(). You'll have to find another way to tell for sure! ?C:. ?C:EOF_NONBLOCK: ?C: This symbol, if defined, indicates to the C program that a read() on ?C: a non-blocking file descriptor will return 0 on EOF, and not the value ?C: held in RD_NODATA (-1 usually, in that case!). ?C:. ?H:#define VAL_O_NONBLOCK $o_nonblock ?H:#define VAL_EAGAIN $eagain ?H:#define RD_NODATA $rd_nodata ?H:#$d_eofnblk EOF_NONBLOCK ?H:. ?T:status ?F:!try.out !try.ret !try.err !try !mtry ?LINT:use d_open3 : check for non-blocking I/O stuff case "$h_sysfile" in true) echo "#include " > head.c;; *) case "$h_fcntl" in true) echo "#include " > head.c;; *) echo "#include " > head.c;; esac ;; esac echo " " echo "Figuring out the flag used by open() for non-blocking I/O..." >&4 case "$o_nonblock" in '') $cat head.c > try.c $cat >>try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_fcntl I_FCNTL #ifdef I_FCNTL #include #endif int main() { #ifdef O_NONBLOCK printf("O_NONBLOCK\n"); exit(0); #endif #ifdef O_NDELAY printf("O_NDELAY\n"); exit(0); #endif ?X: Stevens "Advanced Programming in the UNIX Environment" page 364 mentions ?X: the FNDELAY symbol, used in 4.3BSD (source: Paul Marquess). #ifdef FNDELAY printf("FNDELAY\n"); exit(0); #endif exit(0); } EOCP set try if eval $compile_ok; then o_nonblock=`$run ./try` case "$o_nonblock" in '') echo "I can't figure it out, assuming O_NONBLOCK will do.";; *) echo "Seems like we can use $o_nonblock.";; esac else echo "(I can't compile the test program; pray O_NONBLOCK is right!)" fi ;; *) echo "Using $hint value $o_nonblock.";; esac $rm_try echo " " echo "Let's see what value errno gets from read() on a $o_nonblock file..." >&4 case "$eagain" in '') case "$d_fork:$d_pipe:$d_alarm" in define:define:define) $cat head.c > try.c $cat >>try.c < #include #include #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_fcntl I_FCNTL #ifdef I_FCNTL #include #endif #define MY_O_NONBLOCK $o_nonblock #ifndef errno /* XXX need better Configure test */ extern int errno; #endif #$i_unistd I_UNISTD #ifdef I_UNISTD #include #endif #$i_string I_STRING #ifdef I_STRING #include #else #include #endif $signal_t blech(int x) { exit(3); } EOCP $cat >> try.c <<'EOCP' int main() { int pd[2]; int pu[2]; char buf[1]; char string[100]; int ret; ret = pipe(pd); /* Down: child -> parent */ if (ret != 0) exit(3); ret = pipe(pu); /* Up: parent -> child */ if (ret != 0) exit(3); if (0 != fork()) { close(pd[1]); /* Parent reads from pd[0] */ close(pu[0]); /* Parent writes (blocking) to pu[1] */ #ifdef F_SETFL if (-1 == fcntl(pd[0], F_SETFL, MY_O_NONBLOCK)) exit(1); #else exit(4); #endif signal(SIGALRM, blech); alarm(5); if ((ret = read(pd[0], buf, 1)) > 0) /* Nothing to read! */ exit(2); sprintf(string, "%d\n", ret); ret = write(2, string, strlen(string)); if (ret != strlen(string)) exit(3); alarm(0); #ifdef EAGAIN if (errno == EAGAIN) { printf("EAGAIN\n"); goto ok; } #endif #ifdef EWOULDBLOCK if (errno == EWOULDBLOCK) printf("EWOULDBLOCK\n"); #endif ok: ret = write(pu[1], buf, 1); /* Unblocks child, tell it to close our pipe */ if (ret != 1) exit(3); sleep(2); /* Give it time to close our pipe */ alarm(5); ret = read(pd[0], buf, 1); /* Should read EOF */ alarm(0); sprintf(string, "%d\n", ret); ret = write(4, string, strlen(string)); if (ret != strlen(string)) exit(3); exit(0); } close(pd[0]); /* We write to pd[1] */ close(pu[1]); /* We read from pu[0] */ ret = read(pu[0], buf, 1); /* Wait for parent to signal us we may continue */ if (ret != 1) exit(3); close(pd[1]); /* Pipe pd is now fully closed! */ exit(0); /* Bye bye, thank you for playing! */ } EOCP set try if eval $compile_ok; then ?X: Use script to avoid the possible 'alarm call' message echo "$startsh" >mtry echo "$run ./try >try.out 2>try.ret 4>try.err || exit 4" >>mtry chmod +x mtry $run ./mtry >/dev/null 2>&1 case $? in 0) eagain=`$cat try.out`;; 1) echo "Could not perform non-blocking setting!";; 2) echo "I did a successful read() for something that was not there!";; 3) echo "Hmm... non-blocking I/O does not seem to be working!";; 4) echo "Could not find F_SETFL!";; *) echo "Something terribly wrong happened during testing.";; esac rd_nodata=`$cat try.ret` echo "A read() system call with no data present returns $rd_nodata." case "$rd_nodata" in 0|-1) ;; *) echo "(That's peculiar, fixing that to be -1.)" rd_nodata=-1 ;; esac case "$eagain" in '') echo "Forcing errno EAGAIN on read() with no data available." eagain=EAGAIN ;; *) echo "Your read() sets errno to $eagain when no data is available." ;; esac status=`$cat try.err` case "$status" in 0) echo "And it correctly returns 0 to signal EOF.";; -1) echo "But it also returns -1 to signal EOF, so be careful!";; *) echo "However, your read() returns '$status' on EOF??";; esac val="$define" if test "$status" = "$rd_nodata"; then echo "WARNING: you can't distinguish between EOF and no data!" val="$undef" fi else echo "I can't compile the test program--assuming errno EAGAIN will do." eagain=EAGAIN fi ;; *) echo "Can't figure out how to test this--assuming errno EAGAIN will do." eagain=EAGAIN val="$define" ;; esac set d_eofnblk eval $setvar ;; *) echo "Using $hint value $eagain." echo "Your read() returns $rd_nodata when no data is present." case "$d_eofnblk" in "$define") echo "And you can see EOF because read() returns 0.";; "$undef") echo "But you can't see EOF status from read() returned value.";; *) ?X: Should not happen, but if it does, assume the worst! echo "(Assuming you can't see EOF status from read anyway.)" d_eofnblk=$undef ;; esac ;; esac $rm_try head.c mtry metaconfig-debian-perl-5.26.1/U/compline/orderlib.U000066400000000000000000000101351316016665300220520ustar00rootroot00000000000000?RCS: $Id: orderlib.U,v 3.0.1.4 1997/02/28 16:18:18 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: orderlib.U,v $ ?RCS: Revision 3.0.1.4 1997/02/28 16:18:18 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: patch61: likewise for .o replaced by $_o ?RCS: patch61: now uses the ar located by Loc.U ?RCS: ?RCS: Revision 3.0.1.3 1995/01/11 15:33:04 ram ?RCS: patch45: allows hint files to specify their own value for 'ranlib' ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:26:48 ram ?RCS: patch36: now performs a real small compile for accurate checks (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:31:17 ram ?RCS: patch32: use cc variable instead of hardwired 'cc' in 1st compile ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:26 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:orderlib ranlib: Loc ar cat test rm +cc +ccflags +ldflags +libs i_stdlib _a _o run ?MAKE: -pick add $@ %< ?S:orderlib: ?S: This variable is "true" if the components of libraries must be ordered ?S: (with `lorder $* | tsort`) before placing them in an archive. Set to ?S: "false" if ranlib or ar can generate random libraries. ?S:. ?S:ranlib: ?S: This variable is set to the pathname of the ranlib program, if it is ?S: needed to generate random libraries. Set to ":" if ar can generate ?S: random libraries or if random libraries are not supported ?S:. ?F:!foobar : see if ar generates random libraries by itself echo " " echo "Checking how to generate random libraries on your machine..." >&4 ?X: Some systems (like MIPS) complain when running ar... Others like Ultrix ?X: need an explicit 'ar ts' to add the table of contents. ?X: Still others like Linux run ar ts successfully, but still need ranlib. ?X: This set of tests seems the minimum necessary to check out Linux. ?X: We need to explicitly put the entries in out-of-order so that Sun's ld ?X: will fail. (Otherwise it complains, but gives an exit status of 0.) echo 'int bar1() { return bar2(); }' > bar1.c echo 'int bar2() { return 2; }' > bar2.c $cat > foo.c < #endif int main() { printf("%d\n", bar1()); exit(0); } EOP $cc $ccflags -c bar1.c >/dev/null 2>&1 $cc $ccflags -c bar2.c >/dev/null 2>&1 $cc $ccflags -c foo.c >/dev/null 2>&1 $ar rc bar$_a bar2$_o bar1$_o >/dev/null 2>&1 if $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && $run ./foobar >/dev/null 2>&1; then echo "$ar appears to generate random libraries itself." orderlib=false if [ "X$ranlib" = "X" ]; then ranlib=":" fi elif $ar s bar$_a >/dev/null 2>&1 && $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && $run ./foobar >/dev/null 2>&1; then echo "a table of contents needs to be added with '$ar s'." orderlib=false ranlib="$ar s" elif $ar ts bar$_a >/dev/null 2>&1 && $cc -o foobar $ccflags $ldflags foo$_o bar$_a $libs > /dev/null 2>&1 && $run ./foobar >/dev/null 2>&1; then echo "a table of contents needs to be added with '$ar ts'." orderlib=false ranlib="$ar ts" else ?X: Allow hints to specify their own ranlib "script". For instance, on ?X: some NeXT machines, the timestamp put by ranlib is not correct, and this ?X: may raise tedious recompiles for nothing. Therefore, NeXT may add the ?X: ranlib='sleep 5; /bin/ranlib' line in their hints to "fix" that. ?X: (reported by Andreas Koenig ) case "$ranlib" in :) ranlib='';; '') ranlib=`./loc ranlib X /usr/bin /bin /usr/local/bin` $test -f $ranlib || ranlib='' ;; esac if $test -n "$ranlib"; then echo "your system has '$ranlib'; we'll use that." orderlib=false else echo "your system doesn't seem to support random libraries" echo "so we'll use lorder and tsort to order the libraries." orderlib=true ranlib=":" fi fi $rm -f foo* bar* metaconfig-debian-perl-5.26.1/U/compline/ptrsize.U000066400000000000000000000043551316016665300217570ustar00rootroot00000000000000?RCS: $Id: ptrsize.U,v 3.0.1.1 1994/10/29 16:28:19 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: ptrsize.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:28:19 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:37 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:ptrsize: cat rm_try Myread Compile run use64bitall i_stdlib d_quad ?MAKE: -pick add $@ %< ?S:ptrsize: ?S: This variable contains the value of the PTRSIZE symbol, which ?S: indicates to the C program how many bytes there are in a pointer. ?S:. ?C:PTRSIZE: ?C: This symbol contains the size of a pointer, so that the C preprocessor ?C: can make decisions based on it. It will be sizeof(void *) if ?C: the compiler supports (void *); otherwise it will be ?C: sizeof(char *). ?C:. ?H:#define PTRSIZE $ptrsize /**/ ?H:. ?F:!try ?LINT:extern use64bitint : check for length of pointer echo " " case "$ptrsize" in '') echo "Checking to see how big your pointers are..." >&4 $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof(void *)); exit(0); } EOCP set try if eval $compile_ok; then ptrsize=`$run ./try` echo "Your pointers are $ptrsize bytes long." else dflt='4' echo "(I can't seem to compile the test program. Guessing...)" >&4 rp="What is the size of a pointer (in bytes)?" . ./myread ptrsize="$ans" fi ;; esac $rm_try case "$use64bitall" in "$define"|true|[yY]*) case "$ptrsize" in 4) cat <&4 *** You have chosen a maximally 64-bit build, *** but your pointers are only 4 bytes wide. *** Please rerun Configure without -Duse64bitall. EOM case "$d_quad" in define) cat <&4 *** Since you have quads, you could possibly try with -Duse64bitint. EOM ;; esac cat <&4 *** Cannot continue, aborting. EOM exit 1 ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/compline/randbits.U000066400000000000000000000007231316016665300220600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?X: ?X: Useless unit dropped. Use randfunc instead. ?X: ?LINT:empty metaconfig-debian-perl-5.26.1/U/compline/randfunc.U000066400000000000000000000070101316016665300220460ustar00rootroot00000000000000?RCS: $Id: randfunc.U,v 3.0 1993/08/18 12:09:39 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: randfunc.U,v $ ?RCS: Revision 3.0 1993/08/18 12:09:39 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This is the new unit that should be used when random ?X: functions are to be used. It thus makes randbits.U obsolete. ?X: ?X: This unit gives a simple #define for Drand01, which produces ?X: doubles in the range [0,1) using the "best" random number ?X: generator available. The source should just call Drand01 ?X: and not worry about the underlying implementation. ?X: Andy Dougherty July 1998 ?X: ?MAKE:randfunc drand01 seedfunc randbits randseedtype: \ Compile Myread Csym ccflags ?MAKE: -pick add $@ %< ?S:randfunc: ?S: Indicates the name of the random number function to use. ?S: Values include drand48, random, and rand. In C programs, ?S: the 'Drand01' macro is defined to generate uniformly distributed ?S: random numbers over the range [0., 1.[ (see drand01 and nrand). ?S:. ?S:drand01: ?S: Indicates the macro to be used to generate normalized ?S: random numbers. Uses randfunc, often divided by ?S: (double) (((unsigned long) 1 << randbits)) in order to ?S: normalize the result. ?S: In C programs, the macro 'Drand01' is mapped to drand01. ?S:. ?S:randseedtype: ?S: Indicates the type of the argument of the seedfunc. ?S:. ?S:seedfunc: ?S: Indicates the random number generating seed function. ?S: Values include srand48, srandom, and srand. ?S:. ?S:randbits: ?S: Indicates how many bits are produced by the function used to ?S: generate normalized random numbers. ?S:. ?C:RANDFUNC: ?C: This symbol defines the random function used to define Drand01(). ?C:. ?C:Drand01: ?C: This macro is to be used to generate uniformly distributed ?C: random numbers over the range [0., 1.[. You may have to supply ?C: an 'extern double drand48();' in your program since SunOS 4.1.3 ?C: doesn't provide you with anything relevant in its headers. ?C: See HAS_DRAND48_PROTO. ?C:. ?C:Rand_seed_t: ?C: This symbol defines the type of the argument of the ?C: random seed function. ?C:. ?C:seedDrand01: ?C: This symbol defines the macro to be used in seeding the ?C: random number generator (see Drand01). ?C:. ?C:RANDBITS: ?C: This symbol indicates how many bits are produced by the ?C: function used to generate normalized random numbers. ?C: Values include 15, 16, 31, and 48. ?C:. ?H:#define RANDFUNC $randfunc /**/ ?H:#define Drand01() $drand01 /**/ ?H:#define Rand_seed_t $randseedtype /**/ ?H:#define seedDrand01(x) $seedfunc((Rand_seed_t)x) /**/ ?H:#define RANDBITS $randbits /**/ ?H:. ?LINT:change ccflags ?LINT:unclosed $randbits))" : How can we generate normalized random numbers ? echo " " echo "Using our internal random number implementation..." >&4 case "$ccflags" in *-Dmy_rand=*|*-Dmy_srand=*) echo "Removing obsolete -Dmy_rand, -Dmy_srand, and -Drandbits from ccflags." >&4 ccflags="`echo $ccflags | sed -e 's/-Dmy_rand=random/ /'`" ccflags="`echo $ccflags | sed -e 's/-Dmy_srand=srandom/ /'`" ccflags="`echo $ccflags | sed -e 's/-Drandbits=[0-9][0-9]*/ /'`" ;; esac randfunc=Perl_drand48 drand01="Perl_drand48()" seedfunc="Perl_drand48_init" randbits=48 randseedtype=U32 metaconfig-debian-perl-5.26.1/U/compline/sbrksmart.U000066400000000000000000000050711316016665300222630ustar00rootroot00000000000000?RCS: $Id: sbrksmart.U,v 3.0.1.2 1995/01/11 15:35:41 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: sbrksmart.U,v $ ?RCS: Revision 3.0.1.2 1995/01/11 15:35:41 ram ?RCS: patch45: now sets sbrksmart to undef explicitly when lacking sbrk() ?RCS: patch45: forgot a cast when using return value from sbrk() ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:16:45 ram ?RCS: patch16: created ?RCS: ?MAKE:sbrksmart: cat d_sbrk Compile rm ?MAKE: -pick add $@ %< ?S:sbrksmart: ?S: This variable conditionally defines HAS_SMART_SBRK if the sbrk() ?S: routine honors a negative argument to lower the break value. ?S:. ?C:HAS_SMART_SBRK: ?C: This symbol is defined when the sbrk() system call may be used with ?C: a negative argument to lower the break value, therefore releasing ?C: core to the system. If not, you'd probably be better off using the ?C: mmap() system call. ?C:. ?H:#$sbrksmart HAS_SMART_SBRK /**/ ?H:. ?T:dumb ?F:!sbrk : see if sbrk can release core to the kernel echo " " case "$d_sbrk" in "$define") echo "Let's see if your sbrk() is smart enough to release core..." >&4 $cat > sbrk.c <<'EOC' #define INC 256 /* Small enough to be less than a page size */ int main() { char *obrk = (char *) sbrk(0); char *nbrk; nbrk = (char *) sbrk(INC); if (nbrk == (char *) -1) exit(1); /* Not enough memory */ if (nbrk != obrk) exit(2); /* Unreliable sbrk() */ nbrk = (char *) sbrk(-INC); if (nbrk == (char *) -1) exit(3); /* May have understood negative arg as huge positive */ if (obrk != (char *) sbrk(0)) exit(4); /* Not smart, definitely */ exit(0); /* Ok */ } EOC sbrksmart="$undef" dumb='-- assuming dumb sbrk().' set sbrk if eval $compile_ok; then ./sbrk >/dev/null 2>&1 case $? in 0) sbrksmart="$define" echo "Yes, it can be used with negative values." ;; 1) echo "Sorry, not enough memory $dumb" ;; 2) echo "No it's not, and besides it seems to be buggy..." ;; 3) echo "No, it fails with negative values." ;; 4) echo "Nope, your sbrk() is too dumb." ;; *) echo "Err... Unexpected result $dumb" ;; esac else echo "(Could not compile test program $dumb)" fi ;; *) echo "Since you don't have sbrk(), let's forget about the smart test!" sbrksmart="$undef" ;; esac $rm -f sbrk sbrk.* core metaconfig-debian-perl-5.26.1/U/compline/sockopt.U000066400000000000000000000047701316016665300217420ustar00rootroot00000000000000?RCS: $Id: sockopt.U,v 3.0.1.1 1995/07/25 14:16:14 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: sockopt.U,v $ ?RCS: Revision 3.0.1.1 1995/07/25 14:16:14 ram ?RCS: patch56: obsoleted KEEPALIVE in favor of CAN_KEEPALIVE for consistency ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:48 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_keepalive: cat rm contains +cc +ccflags +ldflags socketlib sockethdr \ d_oldsock libs Oldconfig Setvar Findhdr ?MAKE: -pick add $@ %< ?S:d_keepalive: ?S: This symbol conditionally defines CAN_KEEPALIVE which indicates to the C ?S: program that setsockopt SO_KEEPALIVE will work properly. ?S:. ?C:CAN_KEEPALIVE (KEEPALIVE): ?C: This symbol if defined indicates to the C program that the SO_KEEPALIVE ?C: option of setsockopt() will work as advertised in the manual. ?C:. ?H:#$d_keepalive CAN_KEEPALIVE /**/ ?H:. ?F:!socket ?LINT:set d_keepalive : see if setsockopt with SO_KEEPALIVE works as advertised echo " " case "$d_oldsock" in "$undef") if $contains SO_KEEPALIVE `./findhdr sys/socket.h` \ /dev/null >/dev/null 2>&1 then echo "OK, let's see if SO_KEEPALIVE works as advertised..." >&4 $cat > socket.c < #include #include #include int main() { int s = socket(AF_INET, SOCK_STREAM, 0); if (s == -1) exit(1); if (-1 == setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, 0, 0)) exit(2); exit(0); } EOP if $cc $ccflags $sockethdr $ldflags -o socket socket.c $libs \ $socketlib >/dev/null 2>&1; then ./socket >/dev/null 2>&1 case $? in 0) echo "Yes, it does!" val="$define";; 1) $cat < ?RCS: ?RCS: $Log: ssizetype.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 16:24:21 ram ?RCS: patch61: integrated perl5 concerns for mis-configured sfio ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:30:28 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:33:06 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:ssizetype: Myread Typedef sizetype cat rm_try Compile run i_stdlib ?MAKE: -pick add $@ %< ?S:ssizetype: ?S: This variable defines ssizetype to be something like ssize_t, ?S: long or int. It is used by functions that return a count ?S: of bytes or an error condition. It must be a signed type. ?S: We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). ?S:. ?C:SSize_t: ?C: This symbol holds the type used by functions that return ?C: a count of bytes or an error condition. It must be a signed type. ?C: It is usually ssize_t, but may be long or int, etc. ?C: It may be necessary to include or ?C: to get any typedef'ed information. ?C: We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). ?C:. ?H:#define SSize_t $ssizetype /* signed count of bytes */ ?H:. ?F:!try : see what type is used for signed size_t set ssize_t ssizetype int stdio.h sys/types.h eval $typedef dflt="$ssizetype" ?X: Now check out whether sizeof(SSize_t) == sizeof(Size_t) $cat > try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include #define Size_t $sizetype #define SSize_t $dflt int main() { if (sizeof(Size_t) == sizeof(SSize_t)) printf("$dflt\n"); else if (sizeof(Size_t) == sizeof(int)) printf("int\n"); else printf("long\n"); exit(0); } EOM echo " " set try if eval $compile_ok && $run ./try > /dev/null; then ssizetype=`$run ./try` echo "I'll be using $ssizetype for functions returning a byte count." >&4 else $cat >&4 <&4 $cat >scanf.c <<'EOCP' int main() { float value; sscanf("4.5","%g",&value); printf("%d\n", value == 4.5); } EOCP set scanf if eval $compile_ok; then if $test `./scanf` = 0; then echo "Hmm.. seems you are not running the USG flavor.." val="$undef" else echo "Uh... you are running the USG flavor of scanf." val="$define" fi else echo "(I can't seem to compile the test program... Guessing)" val="$undef" fi set sunscanf eval $setvar $rm -f scanf* metaconfig-debian-perl-5.26.1/U/ebcdic/000077500000000000000000000000001316016665300175255ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/ebcdic/ebcdic.U000066400000000000000000000023551316016665300210710ustar00rootroot00000000000000?RCS: $Id: ebcdic.U,v 3.0.1.3 1994/05/06 15:11:49 doughera Exp $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original author Jarkko Hietaniemi ?RCS: Merged into dist by Andy Dougherty July 13, 1998 ?RCS: ?MAKE:ebcdic: Compile Setvar cat rm_try run ?MAKE: -pick add $@ %< ?S:ebcdic: ?S: This variable conditionally defines EBCDIC if this ?S: system uses EBCDIC encoding. ?S:. ?C:EBCDIC: ?C: This symbol, if defined, indicates that this system uses ?C: EBCDIC encoding. ?C:. ?H:#$ebcdic EBCDIC /**/ ?H:. ?F:!try ?LINT:set ebcdic : Determine if this is an EBCDIC system echo " " echo "Determining whether or not we are on an EBCDIC system..." >&4 $cat >try.c <<'EOM' int main() { if ('M'==0xd4) return 0; return 1; } EOM val=$undef set try if eval $compile_ok; then if $run ./try; then echo "You seem to speak EBCDIC." >&4 val="$define" else echo "Nope, no EBCDIC, probably ASCII or some ISO Latin. Or UTF-8." >&4 fi else echo "I'm unable to compile the test program." >&4 echo "I'll assume ASCII or some ISO Latin. Or UTF8." >&4 fi $rm_try set ebcdic eval $setvar metaconfig-debian-perl-5.26.1/U/installdirs/000077500000000000000000000000001316016665300206445ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/installdirs/Notes000066400000000000000000000022671316016665300216660ustar00rootroot00000000000000These units are intended to eventually live up to the INSTALL-1.58 specifications. Right now, they are woefully incomplete, but I am about to fall off the end of the e-world for quite a while, so I'm sending you what I have now in the hopes that someone will be able to pick up on it and complete it. I think this is the best I'll be able to do prior to the perl conference. If the squirrel hadn't climbed into the campus power transformer and taken us down for most of Monday and Tuesday, and if I hadn't spent 10 hours yesterday at the car repair shop (and another 4 hours on the road) I might have gotten further. Sorry about that :-(. I'll be unsubscribing from p5p, so if you have questions, please contact me directly. I will still check my mail about once a week, but probably not more often for a while. The vendor* stuff is only vaguely sketched out. Since it all defaults to being unused, you may delete it if implementing it is taking too long. I've tried to mark with XXX some known problem spots, but I know I've missed many. Good luck and have the appropriate amount of fun :-). Andy Dougherty doughera@lafayette.edu Dept. of Physics Lafayette College, Easton PA 18042 metaconfig-debian-perl-5.26.1/U/installdirs/Setprefixvar.U000066400000000000000000000032611316016665300234560ustar00rootroot00000000000000?RCS: $Id: Setprefixvar.U,v 3.0 2006/04/01 17:25:29 hmbrand $ ?RCS: ?RCS: Copyright (c) 2006-2006, H.Merijn Brand & Nicholas Clark ?RCS: ?RCS: This file is included with or a derivative work of a file included ?RCS: with the metaconfig program of Raphael Manfredi's "dist" distribution. ?RCS: In accordance with clause 7 of dist's modified Artistic License: ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: ?X: This unit sets up the scripts installprefix and setprefixvar, so code ?X: in other parts can be more simple and maintainable ?X: ?MAKE:Setprefixvar: Myread Getfile startsh eunicefix test \ prefix prefixexp installprefix installprefixexp ?MAKE: -pick add $@ %< ?LINT:extern prefixvar ?X: metalint still sees "`\$${prefixvar}exp`" as variable :( ?T:prefixvarexp ?F:./setprefixvar ?F:./installprefix : Perform the prefixexp/installprefixexp correction if necessary cat <installprefix $startsh EOS cat <<'EOSC' >>installprefix : Change installation prefix, if necessary. if $test X"$prefix" != X"$installprefix"; then eval "install${prefixvar}=\`echo \$${prefixvar}exp | sed \"s#^\$prefixexp#\$installprefixexp#\"\`" else eval "install${prefixvar}=\"\$${prefixvar}exp\"" fi EOSC chmod +x installprefix $eunicefix installprefix : Set variables such as privlib and privlibexp from the output of ./getfile : performing the prefixexp/installprefixexp correction if necessary. cat <setprefixvar $startsh EOS cat <<'EOSC' >>setprefixvar eval "${prefixvar}=\"\$ans\"" eval "${prefixvar}exp=\"\$ansexp\"" . ./installprefix EOSC chmod +x setprefixvar $eunicefix setprefixvar metaconfig-debian-perl-5.26.1/U/installdirs/Todo000066400000000000000000000006051316016665300214750ustar00rootroot00000000000000prefix.U installprefix.U installstyle.U bin.U scriptdir.U privlib.U archlib.U man1dir.U man3dir.U html1dir.U html3dir.U siteprefix.U sitebin.U sitescriptdir.U sitelib.U sitearch.U siteman1dir.U siteman3dir.U sitehtml1dir.U sitehtml3dir.U vendorprefix.U vendorbin.U vendorscriptdir.U vendorlib.U vendorarch.U vendorman1dir.U vendorman3dir.U vendorhtml1dir.U vendorhtml3dir.U otherlibdirs.U metaconfig-debian-perl-5.26.1/U/installdirs/archlib.U000066400000000000000000000077501316016665300224070ustar00rootroot00000000000000?RCS: $Id: archlib.U,v 3.1 1999/07/08 18:32:29 doughera Exp doughera $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: This file is included with or a derivative work of a file included ?RCS: with the metaconfig program of Raphael Manfredi's "dist" distribution. ?RCS: In accordance with clause 7 of dist's modified Artistic License: ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: archlib.U,v $ ?RCS: Revision 3.1 1999/07/08 18:32:29 doughera ?RCS: Updated for perl5.005_5x ?RCS: ?RCS: ?RCS: Revision 3.0.1.4 1995/09/25 09:15:18 ram ?RCS: patch59: unit is now forced to the top of Configure, if possible ?RCS: ?RCS: Revision 3.0.1.3 1995/02/15 14:14:14 ram ?RCS: patch51: architecture name is now computed by a separate unit ?RCS: ?RCS: Revision 3.0.1.2 1995/01/30 14:32:22 ram ?RCS: patch49: archname is now systematically recomputed ?RCS: patch49: can now handle installation prefix changes (from WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:02:36 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_archlib archlib archlibexp installarchlib: \ cat Getfile Setprefixvar Loc Oldconfig archname spackage \ privlib sed test Prefixit Prefixup binexp ?MAKE: -pick add $@ %< ?Y:TOP ?S:d_archlib: ?S: This variable conditionally defines ARCHLIB to hold the pathname ?S: of architecture-dependent library files for $package. If ?S: $archlib is the same as $privlib, then this is set to undef. ?S:. ?D:archlib='' ?S:archlib: ?S: This variable holds the name of the directory in which the user wants ?S: to put architecture-dependent public library files for $package. ?S: It is most often a local directory such as /usr/local/lib. ?S: Programs using this variable must be prepared to deal ?S: with filename expansion. ?S:. ?D:archlibexp='' ?S:archlibexp: ?S: This variable is the same as the archlib variable, but is ?S: filename expanded at configuration time, for convenient use. ?S:. ?D:installarchlib='' ?S:installarchlib: ?S: This variable is really the same as archlibexp but may differ on ?S: those systems using AFS. For extra portability, only this variable ?S: should be used in makefiles. ?S:. ?C:ARCHLIB: ?C: This variable, if defined, holds the name of the directory in ?C: which the user wants to put architecture-dependent public ?C: library files for $package. It is most often a local directory ?C: such as /usr/local/lib. Programs using this variable must be ?C: prepared to deal with filename expansion. If ARCHLIB is the ?C: same as PRIVLIB, it is not defined, since presumably the ?C: program already searches PRIVLIB. ?C:. ?C:ARCHLIB_EXP: ?C: This symbol contains the ~name expanded version of ARCHLIB, to be used ?C: in programs that are not prepared to deal with ~ expansion at run-time. ?C:. ?H:#$d_archlib ARCHLIB "$archlib" /**/ ?H:#$d_archlib ARCHLIB_EXP "$archlibexp" /**/ ?H:. ?T: tdflt ?LINT:change prefixvar ?LINT:set archlib ?LINT:set archlibexp ?LINT:set installarchlib : determine where public architecture dependent libraries go set archlib archlib eval $prefixit : privlib default is /usr/local/lib/$package/$version : archlib default is /usr/local/lib/$package/$version/$archname : privlib may have an optional trailing /share. tdflt=`echo $privlib | $sed 's,/share$,,'` tdflt=$tdflt/$archname case "$archlib" in '') dflt=$tdflt ;; *) dflt="$archlib" ;; esac $cat < getverlist <> getverlist <<'EOPL' # The list found is store twice for each entry: the original name, and # the binary broken down version as pack "sss", so sorting is easy and # unambiguous. This will work for all versions that have a maximum of # three digit groups, separate by '.'s or '_'s. Names are extended with # ".0.0" to ensure at least three elements for the pack. # -- H.Merijn Brand (m)'06 23-10-2006 # Can't have leading @ because metaconfig interprets it as a command! ;@inc_version_list=(); # XXX Redo to do opendir/readdir? if (-d $stem) { chdir($stem); ;@candidates = map { [ $_, pack "sss", split m/[._]/, "$_.0.0" ] } glob("5.*"); ;@candidates = sort { $a->[1] cmp $b->[1]} @candidates; } else { ;@candidates = (); } ($pversion, $aversion, $vsn5005) = map { pack "sss", split m/[._]/, "$_.0.0" } $version, $api_versionstring, "5.005"; foreach $d (@candidates) { if ($d->[1] lt $pversion) { if ($d->[1] ge $aversion) { unshift(@inc_version_list, grep { -d } $d->[0]."/$archname", $d->[0]); } elsif ($d->[1] ge $vsn5005) { unshift(@inc_version_list, grep { -d } $d->[0]); } } else { # Skip newer version. I.e. don't look in # 5.7.0 if we're installing 5.6.1. } } if (@inc_version_list) { print join(' ', @inc_version_list); } else { # Blank space to preserve value for next Configure run. print " "; } EOPL chmod +x getverlist case "$inc_version_list" in '') if test -x "$perl5$exe_ext"; then dflt=`$perl5 getverlist` else dflt='none' fi ;; $undef) dflt='none' ;; ?X: Configure -Dinc_version_list='5.6.0/$archname 5.6.0' ... *) eval dflt=\"$inc_version_list\" ;; esac case "$dflt" in ''|' ') dflt=none ;; esac case "$dflt" in 5.005) dflt=none ;; esac $cat < ?RCS: ?RCS: $Log: installprefix.U,v $ ?RCS: Revision 1.1 1999/07/08 18:32:57 doughera ?RCS: Initial revision ?RCS: ?RCS: ?MAKE:installprefix installprefixexp: Getfile Loc \ Oldconfig afs cat package prefix ?MAKE: -pick add $@ %< ?S:installprefix: ?S: This variable holds the name of the directory below which ?S: "make install" will install the package. For most users, this ?S: is the same as prefix. However, it is useful for ?S: installing the software into a different (usually temporary) ?S: location after which it can be bundled up and moved somehow ?S: to the final location specified by prefix. ?S:. ?S:installprefixexp: ?S: This variable holds the full absolute path of installprefix ?S: with all ~-expansion done. ?S:. : determine installation prefix for where package is to be installed. if $afs; then $cat <&4 WARNING: Previous versions of perl installed man3 pages into $privlib/man/man3. This version will suggest a new default of $dflt. EOM tdflt=$dflt dflt='n' rp='Do you wish to preserve the old behavior?(y/n)' . ./myread case "$ans" in y*) dflt="$privlib/man/man3" ;; *) dflt=$tdflt ;; esac fi ;; *) dflt="$man3dir" ;; esac case "$dflt" in ' ') dflt=none ;; esac echo " " fn=dn+~ rp="Where do the $package library man pages (source) go?" . ./getfile prefixvar=man3dir . ./setprefixvar case "$man3dir" in '') man3dir=' ' installman3dir='';; esac : What suffix to use on installed man pages case "$man3dir" in ' ') man3ext='0' ;; *) rp="What suffix should be used for the $package library man pages?" case "$man3ext" in '') case "$man3dir" in *3) dflt=3 ;; *3p) dflt=3p ;; *3pm) dflt=3pm ;; *l) dflt=l;; *n) dflt=n;; *o) dflt=o;; *p) dflt=p;; *C) dflt=C;; *L) dflt=L;; *L3) dflt=L3;; *) dflt=3;; esac ;; *) dflt="$man3ext";; esac . ./myread man3ext="$ans" ;; esac metaconfig-debian-perl-5.26.1/U/installdirs/otherlibdirs.U000066400000000000000000000053231316016665300234670ustar00rootroot00000000000000?RCS: $Id: otherlibdirs.U,v 1.1 1999/07/08 18:32:57 doughera Exp doughera $ ?RCS: ?RCS: Copyright (c) 1999-2000, Andy Dougherty ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: otherlibdirs.U,v $ ?RCS: Revision 1.1 1999/07/08 18:32:57 doughera ?RCS: Initial revision ?RCS: ?RCS: Revision 1.1 1999/07/08 18:20:26 doughera ?RCS: Initial revision ?RCS: ?RCS: ?MAKE:otherlibdirs d_perl_otherlibdirs: Myread cat sitelib sitearch \ vendorarch vendorlib Setvar ?MAKE: -pick add $@ %< ?Y:TOP ?S:otherlibdirs: ?S: This variable contains a colon-separated set of paths for the perl ?S: binary to search for additional library files or modules. ?S: These directories will be tacked to the end of @INC. ?S: Perl will automatically search below each path for version- ?S: and architecture-specific directories. See inc_version_list ?S: for more details. ?S: A value of ' ' means 'none' and is used to preserve this value ?S: for the next run through Configure. ?S:. ?S:d_perl_otherlibdirs: ?S: This variable conditionally defines PERL_OTHERLIBDIRS, which ?S: contains a colon-separated set of paths for the perl binary to ?S: include in @INC. See also otherlibdirs. ?S:. ?C:PERL_OTHERLIBDIRS: ?C: This variable contains a colon-separated set of paths for the perl ?C: binary to search for additional library files or modules. ?C: These directories will be tacked to the end of @INC. ?C: Perl will automatically search below each path for version- ?C: and architecture-specific directories. See PERL_INC_VERSION_LIST ?C: for more details. ?C:. ?H:#$d_perl_otherlibdirs PERL_OTHERLIBDIRS "$otherlibdirs" /**/ ?H:. ?LINT: set d_perl_otherlibdirs : Final catch-all directories to search $cat </dev/null 2>&1; then perl5=$tdir/perl break; elif $test -x $tdir/perl5$exe_ext && $tdir/perl5 -Mless -e 'use 5.005;' >/dev/null 2>&1; then perl5=$tdir/perl5 break; fi done ;; *) perl5="$perl5" ;; esac case "$perl5" in '') echo "None found. That's ok.";; *) echo "Using $perl5." ;; esac metaconfig-debian-perl-5.26.1/U/installdirs/prefix.U000066400000000000000000000053631316016665300222760ustar00rootroot00000000000000?RCS: $Id: prefix.U,v 3.1 1999/07/08 18:27:51 doughera Exp doughera $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: prefix.U,v $ ?RCS: Revision 3.1 1999/07/08 18:27:51 doughera ?RCS: 5.005_5x version -- Andy Dougherty ?RCS: ?RCS: Revision 3.0.1.2 1995/01/30 14:44:05 ram ?RCS: patch49: new prefixexp variable holding a fully expanded prefix ?RCS: patch49: save off previous prefix value in oldprefix if changed (WED) ?RCS: patch49: added the INSTALLPREFIX define for C programs to use (WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:31:34 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:prefix prefixexp +oldprefix: Getfile Loc Oldconfig cat package ?MAKE: -pick add $@ %< ?S:prefix: ?S: This variable holds the name of the directory below which the ?S: user will install the package. Usually, this is /usr/local, and ?S: executables go in /usr/local/bin, library stuff in /usr/local/lib, ?S: man pages in /usr/local/man, etc. It is only used to set defaults ?S: for things in bin.U, mansrc.U, privlib.U, or scriptdir.U. ?S:. ?S:prefixexp: ?S: This variable holds the full absolute path of the directory below ?S: which the user will install the package. Derived from prefix. ?S:. ?S:oldprefix: ?S: This variable is set non-null if the prefix was previously defined ?S: and gets set to a new value. Used internally by Configure only. ?S:. ?C:INSTALLPREFIX: ?C: This symbol contains the name of the install prefix for this package. ?C:. ?H:#define INSTALLPREFIX "$prefix" /**/ ?H:. : determine root of directory hierarchy where package will be installed. case "$prefix" in '') dflt=`./loc . /usr/local /usr/local /local /opt /usr` ;; *?/) dflt=`echo "$prefix" | sed 's/.$//'` ;; *) dflt="$prefix" ;; esac $cat <; for (@safe) { unlink $_; copy "$perl/$_", $_; } @ARGV = ("/pro/3gl/CPAN/bin/mconfig -v -m -O 2>&1 |"); while (<>) { s{^\s+$perl/U}{} or next; chomp; (my $f = $_) =~ s{.*/}{}; (my $l = "../$_") =~ s{//+}{/}g; symlink $l, $f; } for (qw( Configure config_h.SH )) { unlink "$perl/$_"; move $_, "$perl/$_"; } __END__ The list of files that were linked before I started this script: U/all/abortsig.U U/all/alignbytes.U U/all/ansi2knr.U U/all/archlib.U U/all/archname.U U/all/atolf.U U/all/atoll.U U/all/bincompat3.U U/all/bincompat5005.U U/all/bin.U U/all/bitpbyte.U U/all/byteorder.U U/all/ccflags.U U/all/cc.U U/all/cf_email.U U/all/cf_who.U U/all/charorder.U U/all/charsize.U U/all/Checkcc.U U/all/Compile.U U/all/Config_h.U U/all/Config_sh.U U/all/cppstdin.U U/all/cpp_stuff.U U/all/Cppsym.U U/all/Csym.U U/all/d_access.U U/all/d_accessx.U U/all/d_asctime_r.U U/all/d_attribut.U U/all/dbm64.U U/all/d_builtin.U U/all/d_casti32.U U/all/d_castneg.U U/all/d_class.U U/all/d_clearenv.U U/all/d_clock_getres.U U/all/d_clock_gettime.U U/all/d_clock_settime.U U/all/d_closedir.U U/all/d_cmsghdr_s.U U/all/d_crypt_r.U U/all/d_csh.U U/all/d_ctime_r.U U/all/d_dirfd.U U/all/d_dirname_r.U U/all/d_dlsymun.U U/all/d_drand48proto.U U/all/d_drand48_r.U U/all/d_eaccess.U U/all/d_endgrent_r.U U/all/d_endgrent.U U/all/d_endhent.U U/all/d_endnent.U U/all/d_endpent.U U/all/d_endpwent_r.U U/all/d_endpwent.U U/all/d_endsent.U U/all/d_endspent.U U/all/d_eofpipe.U U/all/Devel.U U/all/devtype.U U/all/d_fchdir.U U/all/d_fcntl_can_lock.U U/all/d_fd_set.U U/all/d_finitel.U U/all/d_finite.U U/all/d_flexfnam.U U/all/d_fpclassify.U U/all/d_fp_class_l.U U/all/d_fp_classl.U U/all/d_fp_class.U U/all/d_fpclass.U U/all/d_fpos64_t.U U/all/d_frexpl.U U/all/d_fs_data_s.U U/all/d_fseeko.U U/all/d_fstatfs.U U/all/d_fsync.U U/all/d_ftello.U U/all/d_futimes.U U/all/d__fwalk.U U/all/d_gconvert.U U/all/d_getcwd.U U/all/d_getespwnam.U U/all/d_getfsstat.U U/all/d_getgrent_r.U U/all/d_getgrent.U U/all/d_getgrgid_r.U U/all/d_getgrnam_r.U U/all/d_gethbyad.U U/all/d_gethbynm.U U/all/d_gethent.U U/all/d_gethname.U U/all/d_gethostprotos.U U/all/d_getitimer.U U/all/d_getlogin_r.U U/all/d_getmntent_r.U U/all/d_getmntent.U U/all/d_getmntinfo_r.U U/all/d_getmnt.U U/all/d_getnbyad.U U/all/d_getnbynm.U U/all/d_getnent.U U/all/d_getnetprotos.U U/all/d_getpagsz.U U/all/d_getpent.U U/all/d_getpgrp.U U/all/d_getprotby.U U/all/d_getprotoprotos.U U/all/d_getprpwnam.U U/all/d_getpwent_r.U U/all/d_getpwent.U U/all/d_getpwnam_r.U U/all/d_getpwuid_r.U U/all/d_getrlimit.U U/all/d_getsent.U U/all/d_getservprotos.U U/all/d_getspent_r.U U/all/d_getspent.U U/all/d_getspnam_r.U U/all/d_getspnam.U U/all/d_getsrvby.U U/all/d_gmtime_r.U U/all/d_gnulibc.U U/all/d_hasmntopt.U U/all/d_htonl.U U/all/d_iconv.U U/all/d_int64_t.U U/all/d_iovec_s.U U/all/d_isascii.U U/all/d_isfinite.U U/all/d_isinf.U U/all/d_isnanl.U U/all/d_isnan.U U/all/d_keepsig.U U/all/d_lchmod.U U/all/d_lchown.U U/all/d_ldbl_dig.U U/all/dlext.U U/all/d_libm_lib_version.U U/all/d_llseek.U U/all/d_localtime_r.U U/all/d_longdbl.U U/all/d_longlong.U U/all/d_lseekproto.U U/all/dlsrc.U U/all/d_lutimes.U U/all/d_madvise.U U/all/d_malloc_size.U U/all/d_memchr.U U/all/d_mkdtemp.U U/all/d_mknod.U U/all/d_mkstemps.U U/all/d_mkstemp.U U/all/d_mmap.U U/all/d_modfl.U U/all/d_mprotect.U U/all/d_mq_close.U U/all/d_mq_getattr.U U/all/d_mq_notify.U U/all/d_mq_open.U U/all/d_mq_receive.U U/all/d_mq_send.U U/all/d_mq_setattr.U U/all/d_mq_unlink.U U/all/d_msghdr_s.U U/all/d_msg.U U/all/d_nanosleep.U U/all/d_NOFILE.U U/all/d_off64_t.U U/all/d_open3.U U/all/doublesize.U U/all/d_portable.U U/all/d_posix_clock.U U/all/d_posix_mq.U U/all/d_posix_sched.U U/all/d_posix_sem.U U/all/d_posix_shm.U U/all/d_posix_timer.U U/all/d_printfed.U U/all/d_pthrattrj.U U/all/d_pthreadj.U U/all/d_pthread_y.U U/all/d_qgcvt.U U/all/d_random_r.U U/all/d_rand_r.U U/all/d_readdir_r.U U/all/d_readv.U U/all/d_recvmsg.U U/all/d_safebcpy.U U/all/d_safemcpy.U U/all/d_sanemcmp.U U/all/d_sbrkproto.U U/all/d_scannl.U U/all/d_sched_getparam.U U/all/d_sched_getscheduler.U U/all/d_sched_gpmax.U U/all/d_sched_gpmin.U U/all/d_sched_rrgi.U U/all/d_sched_setparam.U U/all/d_sched_setscheduler.U U/all/d_sem_close.U U/all/d_sem_destroy.U U/all/d_sem_getvalue.U U/all/d_sem_init.U U/all/d_sem_open.U U/all/d_sem_post.U U/all/d_sem_trywait.U U/all/d_sem.U U/all/d_sem_unlink.U U/all/d_sem_wait.U U/all/d_sendmsg.U U/all/d_setgrent_r.U U/all/d_setgrent.U U/all/d_setgrps.U U/all/d_sethent.U U/all/d_setitimer.U U/all/d_setnent.U U/all/d_setpent.U U/all/d_setpgrp.U U/all/d_setproctitle.U U/all/d_setpwent_r.U U/all/d_setpwent.U U/all/d_setrlimit.U U/all/d_setsent.U U/all/d_setspent.U U/all/d_setvbuf.U U/all/d_sfio.U U/all/d_sgndchr.U U/all/d_shm_open.U U/all/d_shm.U U/all/d_shm_unlink.U U/all/d_sigaction.U U/all/d_sigqueue.U U/all/d_sigsetjmp.U U/all/d_sigtimedwait.U U/all/d_sigwaitinfo.U U/all/d_sigwait.U U/all/d_sitecustomize.U U/all/d_snprintf.U U/all/d_socket.U U/all/d_socklen_t.U U/all/d_socks5_init.U U/all/d_sprintf_len.U U/all/d_sqrtl.U U/all/d_srand48_r.U U/all/d_srandom_r.U U/all/d_statblks.U U/all/d_statfs3.U U/all/d_statfs4.U U/all/d_statfs_f_flags.U U/all/d_statfs_s.U U/all/d_statfs.U U/all/d_statvfs.U U/all/d_stdstdio.U U/all/d_strerror_r.U U/all/d_strerror.U U/all/d_strtold.U U/all/d_strtoll.U U/all/d_strtoq.U U/all/d_strtoull.U U/all/d_strtoul.U U/all/d_strtouq.U U/all/d_telldirproto.U U/all/d_timer_create.U U/all/d_timer_delete.U U/all/d_timer_getoverrun.U U/all/d_timer_gettime.U U/all/d_timer_settime.U U/all/d_times.U U/all/d_time.U U/all/d_tmpnam_r.U U/all/d_ualarm.U U/all/d_union_semun.U U/all/d_unorderedl.U U/all/d_unordered.U U/all/d_unsetenv.U U/all/d_ustat.U U/all/d_utimes.U U/all/d_vfork.U U/all/d_voidsig.U U/all/d_vprintf.U U/all/d_wifstat.U U/all/d_writev.U U/all/ebcdic.U U/all/End.U U/all/errnolist.U U/all/Extensions.U U/all/Extractall.U U/all/Extract.U U/all/fflushall.U U/all/Findhdr.U U/all/Finish.U U/all/floatsize.U U/all/fpossize.U U/all/fpostype.U U/all/fpu.U U/all/gccvers.U U/all/Getfile.U U/all/gidf.U U/all/gidsign.U U/all/gidsize.U U/all/gidtype.U U/all/groupstype.U U/all/Guess.U U/all/Hasfield.U U/all/Hasproto.U U/all/Hasstruct.U U/all/Head.U U/all/html1dir.U U/all/html3dir.U U/all/i_db.U U/all/i_fp_class.U U/all/i_grp.U U/all/i_iconv.U U/all/i_ieeefp.U U/all/i_inttypes.U U/all/i_libutil.U U/all/i_machcthr.U U/all/i_malloc.U U/all/i_mntent.U U/all/i_mqueue.U U/all/inc_version_list.U U/all/i_netdb.U U/all/i_netinettcp.U U/all/Inhdr.U U/all/i_nlist.U U/all/inotype.U U/all/installprefix.U U/all/installstyle.U U/all/Instruct.U U/all/instubperl.U U/all/intsize.U U/all/i_poll.U U/all/i_prot.U U/all/i_pthread.U U/all/i_pwd.U U/all/i_sched.U U/all/i_semaphore.U U/all/i_shadow.U U/all/i_socks.U U/all/issymlink.U U/all/i_sunmath.U U/all/i_sysaccess.U U/all/i_syslog.U U/all/i_sysmman.U U/all/i_sysmode.U U/all/i_sysmount.U U/all/i_sysrusage.U U/all/i_syssecrt.U U/all/i_sysstatfs.U U/all/i_sysstatvfs.U U/all/i_sysuio.U U/all/i_sysutsname.U U/all/i_sysvfs.U U/all/i_time.U U/all/i_ulimit.U U/all/i_ustat.U U/all/libc.U U/all/libnlist.U U/all/libperl.U U/all/libpth.U U/all/libs.U U/all/lib.U U/all/lns.U U/all/localarch.U U/all/locallib.U U/all/Loc_ar.U U/all/Loc.U U/all/longdblfio.U U/all/lseektype.U U/all/mad.U U/all/mallocsrc.U U/all/man1dir.U U/all/man3dir.U U/all/mandirstyle.U U/all/mandirs.U U/all/Mksymlinks.U U/all/models.U U/all/modetype.U U/all/multiarch.U U/all/myhostname.U U/all/Myinit.U U/all/Myread.U U/all/nblock_io.U U/all/need_va_copy.U U/all/netdbtype.U U/all/nis.U U/all/oldarchlib.U U/all/Oldconfig.U U/all/Oldsym.U U/all/Options.U U/all/orderlib.U U/all/otherlibdirs.U U/all/pager.U U/all/patchlevel.U U/all/perl5.U U/all/perladmin.U U/all/perlpath.U U/all/perlxvf.U U/all/perlxv.U U/all/pidsign.U U/all/pidsize.U U/all/pidtype.U U/all/prefix.U U/all/privlib.U U/all/Protochk.U U/all/ptrsize.U U/all/quadfio.U U/all/quadtype.U U/all/randbits.U U/all/randfunc.U U/all/sbrksmart.U U/all/scriptdir.U U/all/selectminbits.U U/all/selecttype.U U/all/Setprefixvar.U U/all/Signal.U U/all/sig_name.U U/all/sitearch.U U/all/sitebin.U U/all/sitehtml1dir.U U/all/sitehtml1.U U/all/sitehtml3dir.U U/all/sitehtml3.U U/all/sitelib.U U/all/siteman1dir.U U/all/siteman1.U U/all/siteman3dir.U U/all/siteman3.U U/all/siteprefix.U U/all/sitescriptdir.U U/all/sitescript.U U/all/sizesize.U U/all/sizetype.U U/all/sockopt.U U/all/socksizetype.U U/all/so.U U/all/spitshell.U U/all/src.U U/all/ssizesize.U U/all/ssizetype.U U/all/startperl.U U/all/stdchar.U U/all/stdio64.U U/all/stdio_streams.U U/all/sunscanf.U U/all/trnl.U U/all/Tr.U U/all/Typedef.U U/all/uidf.U U/all/uidsign.U U/all/uidsize.U U/all/uidtype.U U/all/Unix.U U/all/use64bits.U U/all/uselfs.U U/all/uselongdbl.U U/all/uselonglong.U U/all/usemorebits.U U/all/usemultiplicity.U U/all/usenm.U U/all/useperlio.U U/all/usesocks.U U/all/usethreads.U U/all/usrinc.U U/all/vendorarch.U U/all/vendorbin.U U/all/vendorhtml1dir.U U/all/vendorhtml1.U U/all/vendorhtml3dir.U U/all/vendorhtml3.U U/all/vendorlib.U U/all/vendorman1dir.U U/all/vendorman1.U U/all/vendorman3dir.U U/all/vendorman3.U U/all/vendorprefix.U U/all/vendorscript.U U/all/versiononly.U U/all/voidflags.U U/all/xs_apiversion.U metaconfig-debian-perl-5.26.1/U/mkgloss.pl000077500000000000000000000025171316016665300203400ustar00rootroot00000000000000#!/pro/bin/perl # (c)'11 H.Merijn Brand [ 26 Aug 2011 ] # This script combines the output of mkglossary, with the suggested # patches (see README), and sorts the list use strict; use warnings; my $Pcsh = "Porting/config.sh"; @ARGV = "config.sh"; my @config = <> or die "mkgloss uses $Pcsh.sh. You didn't run Configure (yet)\n". "so I cannot make a temporary version of it to generate a reliable\n". "Glossary!\n"; { my $drop = 0; for (@config) { s{\bh.m.brand\@\w+\.nl\b}{hmbrand\@cpan.org}; s{\b\.xs4all.nl\b}{.cpan.org}; m/^# Variables propagated from previous config/ and $drop++; $drop and $_ = ''; } unlink $Pcsh; open my $config, ">", $Pcsh or die "$Pcsh: $!\n"; print $config @config; close $config; } @ARGV = ("U/mkglossary |"); $/ = undef; my @g = split m{(?<=\n\n)(?=\S)}, <>, -1; print splice @g, 0, 2; for (sort { lc $a cmp lc $b } @g) { if (m/^make_set_make /) { s/Configure -D option/Configure '-D' option/; } if (m/^n /) { s/contains the -n flag/contains the '-n' flag/; } if (m/^sh /) { s/set sh with a -D$/set sh with a '-D'/m; s{with -O -Dsh=/bin/whatever -Dstartsh=whatever} {with '-O -Dsh=/bin/whatever -Dstartsh=whatever'}; } if (m/^spitshell /) { s/cat or a grep -v for # comments/cat or a grep '-v' for # comments/; } s/[ \t]+\n/\n/g; print; } metaconfig-debian-perl-5.26.1/U/mkglossary000077500000000000000000000144331316016665300204420ustar00rootroot00000000000000#!/usr/bin/perl use strict; use warnings; use File::Basename; # WARNING: This is site-specific. Change to the location # where you have installed dist-3.0PL70. my @std_units = glob ("/pro/3gl/CPAN/lib/dist/U/*.U"); my $PWD = "/pro/3gl/CPAN/perl"; -d "U" and chdir "U"; my @perl_units = glob ("$PWD/U/*/*.U"); push (@perl_units, @std_units); # Get the list of config.sh symbols. Be sure this is up to date! # (I run the U/mksample script first to be sure.) open my $wanted, "< $PWD/Porting/config.sh" or die "$0: open $PWD/Wanted: $!\n"; my @WANTED = map { $_->[0] } sort { $a->[1] cmp $b->[1] } map { [ $_, lc $_ ] } <$wanted>; close $wanted; print <<'EOM'; !!!!!!! DO NOT EDIT THIS FILE !!!!!!! This file is built by metaconfig. This file contains a description of all the shell variables whose value is determined by the Configure script. Variables intended for use in C programs (e.g. I_UNISTD) are already described in config_h.SH. [`configpm' generates pod documentation for Config.pm from this file--please try to keep the formatting regular.] EOM my ($Loc, %expl, %file, %predef); foreach my $file (@perl_units) { open my $fh, "< $file" or die "$0: open $file: $!"; my $base = basename ($file); $Loc = $file, next if $base eq "Loc.U" and not defined $Loc; my @var; while (<$fh>) { if (m/^\?S:\w+[ \t:]/ .. m/^\?S:\.$/) { s/[ \t]+$//; if (m/^\?S:.$/) { my ($var) = ((shift @var) =~ /^(\w+)/); unless (exists $expl{$var}) { $expl{$var} = [ @var, "\n" ]; $file{$var} = $base; } @var = (); } else { s/^\?S://; # Remove leading ?S: markers. s/^\s+(?=.)/\t/; # Ensure all lines begin with tabs. push @var, $_; } } } close $fh or die "$0: close $file: $!"; } defined $Loc or die "$0: Couldn't locate Loc.U: $!"; open my $fh, "< $Loc" or die "$0: open $Loc: $!"; while (<$fh>) { m/^\?(\w+):\1$/ and ($expl{$1}, $file{$1}) = (1, "Loc.U"); } close $fh or die "$0: close $Loc: $!"; { local $/ = "\n\n"; for () { m/^(\w+)/; $predef{$1} = $_; } } for (@WANTED) { chomp; m/^#/ and next; # Skip comments m/^:/ and next; # Skip comments m/^$/ and next; # Skip empty sections my ($var, $val) = split /=/, $_, 2; if (exists $expl{$var}) { if ($file{$var} eq "Loc.U") { print "$var (Loc.U):\n"; if ($val eq "''") { # If we didn't have d_portable, this info might be # useful, but it still won't help with non-standard # stuff if perl is built on one system but installed # on others (this is common with Linux distributions, # for example). print <Policy.sh <<'EOP' libswanted="cl pthread $libswanted" EOP sh ./Configure -Dprefix=/opt/perl \ -Dcf_by='merijn' \ -Dcf_email='yourname@yourhost.yourplace.com' \ -Dperladmin='yourname@yourhost.yourplace.com' \ -Dmydomain='.yourplace.com' \ -Dmyhostname='yourhost' \ -Duse64bitint \ -Dusedevel \ -dE test $? = 0 || exit 1 chmod u+w Porting Porting/Glossary Porting/config* cp config.sh Porting/config.sh sh config_h.SH cat <<'EOCP' > Porting/config_H /* This file (config_H) is a sample config.h file. If you are unable to successfully run Configure, copy this file to config.h and edit it to suit your system. */ EOCP cat config.h >> Porting/config_H rm config.sh config.h if newer Configure Porting/Glossary; then pwd=`pwd` U/mkgloss.pl >Porting/Glossary # cd Porting # rm -f Glossary.rej # # The standard 'dist' units contain some strings that upset # # pod2man. This patch silences pod2man's warnings. # patch < $pwd/U/Glossary.patch # if test -f Glossary.rej; then # echo 'Check possible failed patch to Porting/Glossary!' # exit 2 # fi # cd $pwd fi # Remove detritus. #if test -f makeaperl -a -f pod/Makefile; then # rm -f cflags config.h cppstdin makeaperl makedepend makedir Makefile myconfig pod/Makefile Policy.sh writemain x2p/cflags x2p/Makefile Obsolete Wanted # fi metaconfig-debian-perl-5.26.1/U/modified/000077500000000000000000000000001316016665300200745ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/modified/Config_h.U000066400000000000000000000100711316016665300217350ustar00rootroot00000000000000?RCS: $Id: Config_h.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Config_h.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 14:57:43 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.4 1995/09/25 09:10:49 ram ?RCS: patch59: commented the purpose of the #un-def directive ?RCS: ?RCS: Revision 3.0.1.3 1995/01/30 14:25:39 ram ?RCS: patch49: typo fixes in leading config.h comment (WED) ?RCS: ?RCS: Revision 3.0.1.2 1993/08/24 12:13:20 ram ?RCS: patch3: added TOP as a local shell temporary variable ?RCS: ?RCS: Revision 3.0.1.1 1993/08/19 06:42:20 ram ?RCS: patch1: leading config.sh searching was not aborting properly ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:47 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This file ends up producing the config_h.SH script, which is run to produce ?X: the config.h file. The file ./.Config_h below contains all the ?H: lines ?X: extracted out of all the units. Metaconfig itself adds the !GROK!THIS!. ?X: Note that this code isn't included into Configure, but must be shipped with. ?X: ?X: For those who wish to know why the file is config_h.SH instead of the more ?X: natural config.h.SH, well... it is to support systems like MS-DOG. Only one ?X: 'dot' is allowed within the file name, as it is part of the "extension" of ?X: the file. MS-DOG will not let you have two 'dots' because that would mean ?X: two "extensions". ?X: ?MAKE:Config_h: Id End Config_sh Obsol_h myuname cf_time cf_by package src ?MAKE: -pick c_h_weed $@ %< ?MAKE: -pick c_h_weed $@ ./Config_h ?MAKE: -pick c_h_weed $@ ./Obsol_h ?T:PERL_CONFIG_SH TOP ?LINT:unclosed !GROK!THIS! ?LINT:extern CONFIG_H CONFIG_SH ?LINT:change CONFIG_H CONFIG_SH ?X:?LINT:nocomment : Set up for generating config_h.SH case "$CONFIG_SH" in '') CONFIG_SH=config.sh;; esac case "$CONFIG_H" in '') CONFIG_H=config.h;; esac case $PERL_CONFIG_SH in '') if test -f $CONFIG_SH; then TOP=.; elif test -f ../$CONFIG_SH; then TOP=..; elif test -f ../../$CONFIG_SH; then TOP=../..; elif test -f ../../../$CONFIG_SH; then TOP=../../..; elif test -f ../../../../$CONFIG_SH; then TOP=../../../..; else echo "Can't find $CONFIG_SH."; exit 1 fi . $TOP/$CONFIG_SH ;; esac ?X: Make sure we are in the directory where the .SH file is located. case "$0" in */*) cd `expr X$0 : 'X\(.*\)/'` ;; esac echo "Extracting $CONFIG_H (with variable substitutions)" ?X: ?X: Since we unconditionally translate leading #undef into /*#define, we're ?X: stuck when we really want to have a #undef in $CONFIG_H. That's why there ?X: is provision here for #un-def, which is translated back into #undef after ?X: all original #undef have been processed. ?X: ?X: Previously, we changed all ?X: #undef FOO /**/ ?X: into ?X: /*#define FOO /**/ ?X: The xlc compiler (available on IBM's AIX) complains that this is ?X: an illegal attempt to write a nested comment, and warns against it. ?X: There's apparently no way to shut the compiler up, either. ?X: This sed command from Hallvard B Furuseth ?X: changes it to ?X: /*#define FOO / **/ sed <$CONFIG_H -e 's!^#undef\(.*/\)\*!/\*#define\1 \*!' -e 's!^#un-def!#undef!' /* This file was produced by running the config_h.SH script, which * gets its values from $CONFIG_SH, which is generally produced by * running Configure. * * Feel free to modify any of this as the need arises. Note, however, * that running config_h.SH again will wipe out any changes you've made. * For a more permanent change edit $CONFIG_SH and rerun config_h.SH. */ /* Package name : $package * Source directory : $src * Configuration time: $cf_time * Configured by : $cf_by * Target system : $myuname */ #ifndef _config_h_ #define _config_h_ metaconfig-debian-perl-5.26.1/U/modified/Config_sh.U000066400000000000000000000103561316016665300221260ustar00rootroot00000000000000?RCS: $Id: Config_sh.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Config_sh.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 14:57:53 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.2 1995/01/11 14:53:31 ram ?RCS: patch45: moved path stripping from d_portable.U to end of Configure ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:50:37 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:48 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit ends up producing the config.sh script, which contains all the ?X: definitions figured out by Configure. The add.Config_sh command knows ?X: which variables need to be remembered. It also adds the EOT (ends the ?X: here document redirection with variable substitution). ?X: ?MAKE:Config_sh: cf_time cf_by test spitshell startsh myuname Myread \ End Obsol_sh Loc +d_portable package src cat ?MAKE: -pick add.Config_sh $@ %< ?MAKE: -pick add $@ ./Obsol_sh ?MAKE: -pick close.Config_sh $@ %< ?F:!config.over !config.arch ?T:file temp ?LINT:unclosed EOT : back to where it started if test -d ../UU; then cd .. fi : configuration may be unconditionally patched via a 'config.arch' file if $test -f config.arch; then echo "I see a config.arch file, loading it." >&4 . ./config.arch fi : configuration may be patched via a 'config.over' file if $test -f config.over; then echo " " dflt=y rp='I see a config.over file. Do you wish to load it?' . UU/myread case "$ans" in n*) echo "OK, I'll ignore it.";; *) . ./config.over echo "Configuration override changes have been loaded." ;; esac fi @if d_portable : in case they want portability, strip down executable paths ?X: ?X: Strip down paths in located executables. For each file, e.g. vi, there ?X: is a $vi variable whose value is for instance '/usr/bin/vi'. By resetting ?X: $vi to 'vi', we rely on the PATH variable to locate the executable... ?X: case "$d_portable" in "$define") echo " " echo "Stripping down executable paths..." >&4 ?X: ?X: Previously, we used to do eval $file="\$file" but in order ?X: to handle things like sh Configure -Dmake=gmake, we can't do ?X: that. What we *really* want is to strip away the absolute path ?X: and rely on the end user's $PATH to correctly find the executable. ?X: This method assumes there is a "basename" command available. If ?X: not, replace it with the following expr-based command: ?X: expr $temp : '.*/\(.*\)' \| $temp ?X: Since this preserves the actual command name, we can now drop the ?X: OS/2 specific code. ?X: --Andy Dougherty August 1999 ?X: ?X: On OS/2, a special $ar command not even named 'ar' is required, ?X: so we don't strip that name. ?X: Also, on DOS-ish systems, there might not be a ln command, but we ?X: might have ln='cp'. ?X: However, we can't set d_portable=undef on such systems since ?X: Unix-ish tools don't have standard locations there. Thus we ?X: MUST rely on the user's $PATH. ?X: --Andy Dougherty 4/1998 ?X: for file in $loclist $trylist; do eval temp=\$$file eval $file=`basename $temp` done ;; esac @end : create config.sh file echo " " echo "Creating config.sh..." >&4 $spitshell <config.sh $startsh # # This file was produced by running the Configure script. It holds all the # definitions figured out by Configure. Should you modify one of these values, # do not forget to propagate your changes by running "Configure -der". You may # instead choose to run each of the .SH files by yourself, or "Configure -S". # # Package name : $package # Source directory : $src # Configuration time: $cf_time # Configured by : $cf_by # Target system : $myuname EOT ?X: Command line options are saved by the Options.U unit in the ?X: temporary file UU/cmdline.opt : Add in command line options if available $test -f UU/cmdline.opt && $cat UU/cmdline.opt >> config.sh $spitshell <>config.sh metaconfig-debian-perl-5.26.1/U/modified/Cppsym.U000066400000000000000000000305371316016665300215050ustar00rootroot00000000000000?RCS: $Id: Cppsym.U,v 3.0.1.5 1995/05/12 11:59:11 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: Cppsym.U,v $ ?RCS: Revision 3.0.1.5 1995/05/12 11:59:11 ram ?RCS: patch54: split awk command onto two lines for older awk's (ADO) ?RCS: ?RCS: Revision 3.0.1.4 1995/01/11 14:55:57 ram ?RCS: patch45: new cc vs. cpp symbol checking suggested by JHI ?RCS: patch45: added more cpp symbols (JHI) ?RCS: ?RCS: Revision 3.0.1.3 1994/10/29 15:51:32 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: new symbols ardent and titan (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/06/20 06:53:32 ram ?RCS: patch30: extended cpp symbol lookup list (JHI) ?RCS: patch30: renamed attrlist symbol into al for brevity ?RCS: ?RCS: Revision 3.0.1.1 1993/12/15 08:14:14 ram ?RCS: patch15: added new cpp symbols __bsdi__ and BSD_NET2 ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: This unit produces a shell script called Cppsym, which can be used to ?X: determine whether any in a list of symbols is defined by the C compilation ?X: chain (C preprocessor symbols plus C compiler native ones). ?X: It can determine the status of any symbol, though the symbols in $al ?X: are more easily determined. If you want to add to $al you can do ?X: it in Myinit.U. ?MAKE:Cppsym ccsymbols cppsymbols cppccsymbols: run \ eunicefix Guess awk cat tr sed sort rm rm_try startsh osname \ +cc +gccversion test comm uniq echo Options trnl \ optimize ccflags ldflags libs cpp_stuff cpp ?MAKE: -pick add $@ %< ?T:also symbols i postprocess_cc_v tHdrH ?X: ?X: The symbol list is in alpha order for ease of maintenance... ?X: ?X: Lots of new symbols (mostly rummaged from gcc), courtesy of ?X: Jarkko Hietaniemi -- RAM, 06/06/94 ?X: ?S:ccsymbols: ?S: The variable contains the symbols defined by the C compiler alone. ?S: The symbols defined by cpp or by cc when it calls cpp are not in ?S: this list, see cppsymbols and cppccsymbols. ?S: The list is a space-separated list of symbol=value tokens. ?S:. ?S:cppsymbols: ?S: The variable contains the symbols defined by the C preprocessor ?S: alone. The symbols defined by cc or by cc when it calls cpp are ?S: not in this list, see ccsymbols and cppccsymbols. ?S: The list is a space-separated list of symbol=value tokens. ?S:. ?S:cppccsymbols: ?S: The variable contains the symbols defined by the C compiler ?S: when it calls cpp. The symbols defined by the cc alone or cpp ?S: alone are not in this list, see ccsymbols and cppsymbols. ?S: The list is a space-separated list of symbol=value tokens. ?S:. ?F:./Cppsym ?F:./Cppsym.know ?F:!Cppsym.true ?F:!ccsym.com ?F:!ccsym.cpp ?F:!ccsym.own ?X: fake LINT hints ?LINT:change ccflags ?LINT:extern s ?LINT:extern s__ : Preprocessor symbols echo " " $echo "Guessing which symbols your C compiler and preprocessor define..." >&4 ?X: If your symbol is mixed case, just add it as-is. ?X: All symbols will be transformed to both all-lower and all-upper. ?X: Also drop any leading/trailing underscores, the scan will try all those. $cat <<'EOSH' > Cppsym.know a29k aarch64 ABI64 aegis AES_SOURCE AIX AIX32 AIX370 AIX41 AIX42 AIX43 aixpc AIX_SOURCE alliant ALL_SOURCE alpha AM29000 am29000 AMD64 amd64 amiga AMIGAOS AMIX ansi ANSI_C_SOURCE apollo arch_ppc arch_pwr ardent ARM ARM32 atarist att386 att3b BeOS BIG_ENDIAN BIT_MSF BSD bsd bsd43 bsd4_2 BSD4_3 bsd4_3 bsd4_4 BSDCOMPAT bsdi BSD_4_3 BSD_4_4 BSD_NET2 BSD_TIME BSD_TYPES bull byteorder byte_order c cadmus clang clipper CMU COFF COMPILER_VERSION concurrent convex cpu CRAY cray CRAYMPP ctix CX_UX CYGWIN DECC DGUX DGUX_SOURCE DJGPP dmert DOLPHIN DPX2 DSO Dynix DynixPTX ELF encore EPI EXTENSIONS FAVOR_BSD FILE_OFFSET_BITS FORTIFY_SOURCE FreeBSD GCC_NEW_VARARGS gcos gcx gimpel GLIBC GLIBC_MINOR GNUC GNUC_MINOR GNU_LIBRARY GNU_SOURCE GO32 gould GOULD_PN H3050R H3050RX hbullx20 hcx host_mips hp200 hp300 HP700 hp700 hp800 hp9000 hp9000s200 hp9000s300 hp9000s400 hp9000s500 hp9000s700 hp9000s800 hp9k8 hppa hpux HPUX_SOURCE hp_osf i186 i286 i386 i486 i586 i686 i8086 i80960 i860 I960 IA32 IA64 iAPX286 ibm ibm032 ibmesa IBMR2 ibmrt ILP32 ILP64 INLINE_INTRINSICS INT64 INTEL interdata INTRINSICS is68k itanium ksr1 LANGUAGE_C LARGEFILE64_SOURCE LARGEFILE_SOURCE LARGE_FILE_API LFS64_LARGEFILE LFS_LARGEFILE LIBCATAMOUNT Linux LITTLE_ENDIAN LONG64 LONGDOUBLE LONGLONG LONG_DOUBLE LONG_LONG LP64 luna luna88k Lynx M68000 m68k m88100 m88k M88KBCS_TARGET MACH machine MachTen MATH_HAS_NO_SIDE_EFFECTS mc300 mc500 mc68000 mc68010 mc68020 mc68030 mc68040 mc68060 mc68k mc68k32 mc700 mc88000 mc88100 merlin mert MiNT mips MIPSEB MIPSEL MIPS_FPSET MIPS_ISA MIPS_SIM MIPS_SZINT MIPS_SZLONG MIPS_SZPTR MODERN_C motorola mpeix MSDOS MTXINU MULTIMAX MVS mvs M_AMD64 M_ARM M_ARMT M_COFF M_I186 M_I286 M_I386 M_I8086 M_I86 M_I86SM M_IA64 M_IX86 M_PPC M_SYS3 M_SYS5 M_SYSIII M_SYSV M_UNIX M_X86 M_XENIX n16 ncl_el ncl_mr NetBSD news1500 news1700 news1800 news1900 news3700 news700 news800 news900 NeXT NLS nonstopux ns16000 ns32000 ns32016 ns32332 ns32k nsc32000 OCS88 OEMVS OpenBSD os OS2 OS390 osf OSF1 OSF_SOURCE PARAGON parisc pa_risc PA_RISC1_1 PA_RISC2_0 pc532 pdp11 PGC PIC plexus PORTAR posix POSIX1B_SOURCE POSIX2_SOURCE POSIX4_SOURCE POSIX_C_SOURCE POSIX_SOURCE POWER powerpc ppc PROTOTYPES PWB pyr QK_USER QNX R3000 REENTRANT RES Rhapsody RISC6000 riscix riscos RT S390 S390x SA110 SCO scs sequent sgi SGI_SOURCE SH SH3 sinix SIZE_INT SIZE_LONG SIZE_PTR SOCKETS_SOURCE SOCKET_SOURCE sony sonyrisc sony_news sparc sparclite sparcv8 sparcv9 spectrum stardent stdc STDC_EXT stratos sun sun3 sun386 Sun386i svr3 svr4 SVR4_2 SVR4_SOURCE svr5 SX system SYSTYPE_BSD SYSTYPE_BSD43 SYSTYPE_BSD44 SYSTYPE_SVR4 SYSTYPE_SVR5 SYSTYPE_SYSV SYSV SYSV3 SYSV4 SYSV5 sysV68 sysV88 Tek4132 Tek4300 thumb thw_370 thw_intel thw_rs6000 titan TM3200 TM5400 TM5600 tower tower32 tower32_200 tower32_600 tower32_700 tower32_800 tower32_850 tss u370 u3b u3b2 u3b20 u3b200 u3b20d u3b5 ultrix UMAXV UnicomPBB UnicomPBD UNICOS UNICOSMK unix UNIX95 UNIX99 unixpc unos USE_BSD USE_FILE_OFFSET64 USE_GNU USE_ISOC9X USE_LARGEFILE USE_LARGEFILE64 USE_MISC USE_POSIX USE_POSIX199309 USE_POSIX199506 USE_POSIX2 USE_REENTRANT USE_SVID USE_UNIX98 USE_XOPEN USE_XOPEN_EXTENDED USGr4 USGr4_2 UTek Utek UTS UWIN uxpm uxps vax venix VMESA vms x86_64 xenix Xenix286 XOPEN_SOURCE XOPEN_SOURCE_EXTENDED XPG2 XPG2_EXTENDED XPG3 XPG3_EXTENDED XPG4 XPG4_EXTENDED z8000 zarch EOSH # Maybe put other stuff here too. ?X:Some OS's will have a dash in their $osname ?X:e.g. Android is known as linux-android ?X:The preprocessor will interpret the dash as a minus ./tr '-' '_' <>Cppsym.know $osname EOSH ./tr '[a-z]' '[A-Z]' < Cppsym.know > Cppsym.a ./tr '[A-Z]' '[a-z]' < Cppsym.know > Cppsym.b $cat Cppsym.know > Cppsym.c $cat Cppsym.a Cppsym.b Cppsym.c | $tr ' ' $trnl | $sort | $uniq > Cppsym.know $rm -f Cppsym.a Cppsym.b Cppsym.c cat < Cppsym $startsh if $test \$# -gt 0; then echo \$* | $tr " " "$trnl" | ./Cppsym.try > Cppsym.got if $test -s Cppsym.got; then $rm -f Cppsym.got exit 0 fi $rm -f Cppsym.got exit 1 else $tr " " "$trnl" | ./Cppsym.try exit 0 fi EOSH chmod +x Cppsym $eunicefix Cppsym ?X: The below awk script will die a horrible death if ?X: some of the tested symbols are not long ints. ?X: Also, we do not make difference between just defined and defined zero. cat < Cppsym.try $startsh cat <<'EOCP' > try.c #include #if cpp_stuff == 1 #define STRINGIFY(a) "a" #endif #if cpp_stuff == 42 #define StGiFy(a) #a #define STRINGIFY(a) StGiFy(a) #endif #if $cpp_stuff != 1 && $cpp_stuff != 42 # include "Bletch: How does this C preprocessor stringify macros?" #endif int main() { EOCP ?X: The length($1) command guards against possible empty entries. ?X: The awk snippet is know to give heartburn to UNICOS/mk awk. $awk \\ EOSH cat <<'EOSH' >> Cppsym.try 'length($1) > 0 { printf "#ifdef %s\nprintf(\"%s=%%s\\n\", STRINGIFY(%s));\n#endif\n", $1, $1, $1 printf "#ifdef _%s\nprintf(\"_%s=%%s\\n\", STRINGIFY(_%s));\n#endif\n", $1, $1, $1 printf "#ifdef __%s\nprintf(\"__%s=%%s\\n\", STRINGIFY(__%s));\n#endif\n", $1, $1, $1 printf "#ifdef __%s__\nprintf(\"__%s__=%%s\\n\", STRINGIFY(__%s__));\n#endif\n", $1, $1, $1 }' >> try.c echo 'return 0;}' >> try.c EOSH cat <> Cppsym.try ccflags="$ccflags" case "$osname-$gccversion" in irix-) ccflags="\$ccflags -woff 1178" ;; os2-*) ccflags="\$ccflags -Zlinker /PM:VIO" ;; esac $cc -o try -Dcpp_stuff=$cpp_stuff $optimize \$ccflags $ldflags try.c $libs 2>/dev/null && $run ./try | $sed 's/ /\\\\ /g' EOSH chmod +x Cppsym.try $eunicefix Cppsym.try ./Cppsym < Cppsym.know | $sort | $uniq > Cppsym.true : Add in any Linux cpp "predefined macros": case "$osname::$gccversion" in *linux*::*.*|*gnukfreebsd*::*.*|gnu::*.*) tHdrH=_tmpHdr rm -f $tHdrH'.h' $tHdrH touch $tHdrH'.h' # Filter out macro arguments, such as Linux's __INT8_C(c) if $cpp -dM $tHdrH'.h' > $tHdrH'_cppsym.h' && [ -s $tHdrH'_cppsym.h' ]; then sed -e 's/#define[\ \ ]*//;s/[\ \ ].*$//' -e 's/(.*//' <$tHdrH'_cppsym.h' >$tHdrH'_cppsym.real' if [ -s $tHdrH'_cppsym.real' ]; then cat $tHdrH'_cppsym.real' Cppsym.know | sort | uniq | ./Cppsym | sort | uniq > Cppsym.true fi fi rm -f $tHdrH'.h' $tHdrH'_cppsym.h' $tHdrH'_cppsym.real' ;; esac : now check the C compiler for additional symbols ?X: suggested by Jarkko Hietaniemi , thanks! postprocess_cc_v='' case "$osname" in aix) postprocess_cc_v="|$tr , ' '" ;; esac $cat >ccsym <tmp.c <&1 $postprocess_cc_v\` do case "\$i" in -D*) echo "\$i" | $sed 's/^-D//';; -A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A//' | $sed 's/\(.*\)(\(.*\))/\1=\2/';; esac done $rm_try EOS postprocess_cc_v='' chmod +x ccsym $eunicefix ccsym ./ccsym > ccsym1.raw ?X: AIX complains if $uniq is passed an empty file. ($sort apparently ?X: doesn't care.) --AD 14 July 1998 if $test -s ccsym1.raw; then $sort ccsym1.raw | $uniq >ccsym.raw else mv ccsym1.raw ccsym.raw fi ?X: canonicalize symbols for easier sort/uniq/comm usage: append =1 if no = sign ?X: the awk script must be on two lines for older awk programs, sigh! -- ADO $awk '/\=/ { print $0; next } { print $0"=1" }' ccsym.raw >ccsym.list $comm -13 Cppsym.true ccsym.list >ccsym.own $comm -12 Cppsym.true ccsym.list >ccsym.com $comm -23 Cppsym.true ccsym.list >ccsym.cpp also='' if $test -z ccsym.raw; then echo "Your C compiler doesn't seem to define any symbols!" >&4 echo " " echo "However, your C preprocessor defines the following symbols:" $cat Cppsym.true ccsymbols='' cppsymbols=`$cat Cppsym.true` cppsymbols=`echo $cppsymbols` cppccsymbols="$cppsymbols" else if $test -s ccsym.com; then echo "Your C compiler and pre-processor define these symbols:" $sed -e 's/\(..*\)=.*/\1/' ccsym.com also='also ' symbols='ones' cppccsymbols=`$cat ccsym.com` cppccsymbols=`echo $cppccsymbols` $test "$silent" || sleep 1 fi if $test -s ccsym.cpp; then $test "$also" && echo " " echo "Your C pre-processor ${also}defines the following symbols:" $sed -e 's/\(..*\)=.*/\1/' ccsym.cpp also='further ' cppsymbols=`$cat ccsym.cpp` cppsymbols=`echo $cppsymbols` $test "$silent" || sleep 1 fi if $test -s ccsym.own; then $test "$also" && echo " " echo "Your C compiler ${also}defines the following cpp symbols:" $sed -e 's/\(..*\)=1/\1/' ccsym.own $sed -e 's/\(..*\)=.*/\1/' ccsym.own | $uniq >>Cppsym.true ccsymbols=`$cat ccsym.own` ccsymbols=`echo $ccsymbols` $test "$silent" || sleep 1 fi fi : add -D_FORTIFY_SOURCE if feasible and not already there case "$gccversion" in [4567].*) case "$optimize$ccflags" in *-O*) case "$ccflags$cppsymbols" in *_FORTIFY_SOURCE=*) # Don't add it again. echo "You seem to have -D_FORTIFY_SOURCE already, not adding it." >&4 ;; *) echo "Adding -D_FORTIFY_SOURCE=2 to ccflags..." >&4 ccflags="$ccflags -D_FORTIFY_SOURCE=2" ;; esac ;; *) echo "You have gcc 4.* or later but not optimizing, not adding -D_FORTIFY_SOURCE." >&4 ;; esac ;; *) echo "You seem not to have gcc 4.* or later, not adding -D_FORTIFY_SOURCE." >&4 ;; esac metaconfig-debian-perl-5.26.1/U/modified/Extract.U000066400000000000000000000065531316016665300216450ustar00rootroot00000000000000?RCS: $Id: Extract.U,v 3.0.1.2 1997/02/28 14:58:52 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: Extract.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 14:58:52 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:51:46 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:52 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script which can be doted in order to extract ?X: .SH files with variable substitutions. ?X: ?X: When running Configure from a remote directory ($src is not '.'), ?X: then the files will be created in that directory, so beware! ?X: ?MAKE:Extract: src ?MAKE: -pick add $@ %< ?F:./extract ?T:PERL_CONFIG_SH dir file name create mkdir_p : script used to extract .SH files with variable substitutions cat >extract <<'EOS' PERL_CONFIG_SH=true echo "Doing variable substitutions on .SH files..." if test -f MANIFEST; then set x `awk '{print $1}' < MANIFEST | grep '\.SH$'` else echo "(Looking for .SH files under the source directory.)" set x `(cd "$src"; find . -name "*.SH" -print)` fi shift case $# in 0) set x `(cd "$src"; echo *.SH)`; shift;; esac if test ! -f "$src/$1"; then shift fi ?X: script to emulate mkdir -p mkdir_p=' name=$1; create=""; while test $name; do if test ! -d "$name"; then create="$name $create"; name=`echo $name | sed -e "s|^[^/]*$||"`; name=`echo $name | sed -e "s|\(.*\)/.*|\1|"`; else name=""; fi; done; for file in $create; do mkdir $file; done ' for file in $*; do case "$src" in ".") case "$file" in */*) dir=`expr X$file : 'X\(.*\)/'` file=`expr X$file : 'X.*/\(.*\)'` (cd "$dir" && . ./$file) ;; *) . ./$file ;; esac ;; *) ?X: ?X: When running Configure remotely ($src is not '.'), we cannot source ?X: the files directly, since that would wrongly cause the extraction ?X: where the source lie instead of withing the current directory. Therefore, ?X: we need to 'sh src -> Options -> Extract ?X: The Begin.U unit now requires us before beginning to do anything ?X: interesting, to ensure proper semantics. -- RAM, 15/03/96 ?X: ?MAKE:Extractall: Extract Options ?MAKE: -pick wipe $@ %< : extract files and exit if asked to do so case "$extractsh" in true) ?X: Undo the forced silent=true when -S was supplied, by probing realsilent ?X: which was set iff -s was also given. See Options.U for details. case "$realsilent" in true) ;; *) exec 1>&4;; esac case "$config_sh" in '') config_sh='config.sh';; esac echo " " echo "Fetching answers from $config_sh..." cd .. . $config_sh ?X: extract has to be run from the top directory, not within UU. . UU/optdef.sh echo " " ?X: extract has to be run from the top directory, not within UU. . UU/extract rm -rf UU echo "Extraction done." exit 0 ;; esac metaconfig-debian-perl-5.26.1/U/modified/Findhdr.U000066400000000000000000000073211316016665300216030ustar00rootroot00000000000000?RCS: $Id: Findhdr.U,v 3.0.1.2 1994/10/29 15:53:08 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Thomas Neumann ?RCS: ?RCS: $Log: Findhdr.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 15:53:08 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:03:56 ram ?RCS: patch23: cppminus must be after other cppflags, not before ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:54 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a findhdr script which is used to locate the header ?X: files in $usrinc or other stranger places using cpp capabilities. The ?X: script is given an include file base name, like 'stdio.h' or 'sys/file.h' ?X: and it returns the full path of the include file and a zero status or an ?X: empty string with an error status if the file could not be located. ?X: ?MAKE:Findhdr: grep test tr rm incpth awk cat startsh \ cppstdin cppminus +cppflags osname ?MAKE: -pick add $@ %< ?LINT:extern cppfilter ?LINT:define fieldn ?S:fieldn: ?S: This variable is used internally by Configure. It contains the position ?S: of the included file name in cpp output. That is to say, when cpp ?S: pre-processes a #include line, it replaces it by a # line which ?S: contains the original position in the input file and the full name of ?S: included file, between "quotes". ?S:. ?V:fieldn ?F:./findhdr !fieldn ?T:cline pos wanted name awkprg usrincdir status testaccess : determine filename position in cpp output echo " " echo "Computing filename position in cpp output for #include directives..." >&4 case "$osname" in amigaos) fieldn=3 ;; # Workaround for a bug in abc (pdksh). esac case "$fieldn" in '') case "$osname" in vos) testaccess=-e ;; *) testaccess=-r ;; esac echo '#include ' > foo.c $cat >fieldn </dev/null | \ $grep '^[ ]*#.*stdio\.h' | \ while read cline; do pos=1 set \$cline while $test \$# -gt 0; do if $test $testaccess \`echo \$1 | $tr -d '"'\`; then echo "\$pos" exit 0 fi shift pos=\`expr \$pos + 1\` done done EOF chmod +x fieldn fieldn=`./fieldn` $rm -f foo.c fieldn ;; esac case $fieldn in '') pos='???';; 1) pos=first;; 2) pos=second;; 3) pos=third;; *) pos="${fieldn}th";; esac echo "Your cpp writes the filename in the $pos field of the line." ?X: To locate a header file, we cannot simply check for $usrinc/file.h, since ?X: some machine have the headers in weird places and our only hope is that ?X: the C pre-processor will know how to find those headers. Thank you NexT! : locate header file $cat >findhdr <" > foo\$\$.c $cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \ $cppfilter $grep "^[ ]*#.*\$wanted" | \ while read cline; do name=\`echo \$cline | $awk "\$awkprg" | $tr -d '"'\` case "\$name" in *[/\\\\]\$wanted) echo "\$name"; exit 1;; *[\\\\/]\$wanted) echo "\$name"; exit 1;; *) exit 2;; esac; done; # # status = 0: grep returned 0 lines, case statement not executed # status = 1: headerfile found # status = 2: while loop executed, no headerfile found # status=\$? $rm -f foo\$\$.c; if test \$status -eq 1; then exit 0; fi exit 1 EOF chmod +x findhdr metaconfig-debian-perl-5.26.1/U/modified/Guess.U000066400000000000000000000133601316016665300213130ustar00rootroot00000000000000?RCS: $Id: Guess.U,v 3.0.1.5 1995/07/25 13:37:14 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: Guess.U,v $ ?RCS: Revision 3.0.1.5 1995/07/25 13:37:14 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.4 1994/10/29 15:53:55 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: call ./xenix explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0.1.3 1993/12/15 08:14:35 ram ?RCS: patch15: variable d_bsd was not always set properly ?RCS: ?RCS: Revision 3.0.1.2 1993/08/30 08:57:14 ram ?RCS: patch8: fixed comment which wrongly attributed the usrinc symbol ?RCS: patch8: no more ugly messages when no /usr/include/ctype.h ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:37:37 ram ?RCS: patch7: added support for OSF/1 machines ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit hazards some guesses as to what the general nature of the system ?X: is. The information it collects here is used primarily to establish default ?X: answers to other questions. ?X: ?MAKE:Guess d_eunice d_xenix d_bsd: cat test echo n c contains \ rm Loc eunicefix tr sysroot ?MAKE: -pick add $@ %< ?S:d_eunice: ?S: This variable conditionally defines the symbols EUNICE and VAX, which ?S: alerts the C program that it must deal with idiosyncrasies of VMS. ?S:. ?S:d_xenix: ?S: This variable conditionally defines the symbol XENIX, which alerts ?S: the C program that it runs under Xenix. ?S:. ?S:d_bsd: ?S: This symbol conditionally defines the symbol BSD when running on a ?S: BSD system. ?S:. ?C:EUNICE: ?C: This symbol, if defined, indicates that the program is being compiled ?C: under the EUNICE package under VMS. The program will need to handle ?C: things like files that don't go away the first time you unlink them, ?C: due to version numbering. It will also need to compensate for lack ?C: of a respectable link() command. ?C:. ?X: Should we define VMS here? Is Eunice actually used anymore? ?X:?C:VMS: ?X:?C: This symbol, if defined, indicates that the program is running under ?X:?C: VMS. It is currently only set in conjunction with the EUNICE symbol. ?X:?C:. ?C:XENIX: ?C: This symbol, if defined, indicates that the program is running under ?C: Xenix (at least 3.0 ?). ?C:. ?X: We don't use BSD in the perl source. It's too vague, and already ?X: defined in some header files anyway (e.g. NetBSD). This just gives ?X: us a spurious redefinition error upon compilation. ?X: --Andy Dougherty Feb 11, 1998 ?X: ?C:BSD: ?X: ?C: This symbol, if defined, indicates that the program is running under ?X: ?C: a BSD system. ?X: ?C:. ?H:#$d_eunice EUNICE /**/ ?X:?H:#$d_eunice VMS /**/ ?H:#$d_xenix XENIX /**/ ?X: ?H:#$d_bsd BSD /**/ ?H:. ?F:./bsd ./usg ./v7 ./osf1 ./eunice ./xenix ./venix ./os2 ?T:xxx : make some quick guesses about what we are up against echo " " $echo $n "Hmm... $c" echo exit 1 >bsd echo exit 1 >usg echo exit 1 >v7 echo exit 1 >osf1 echo exit 1 >eunice echo exit 1 >xenix echo exit 1 >venix echo exit 1 >os2 d_bsd="$undef" ?X: ?X: Do not use 'usrinc', or we get a circular dependency. because ?X: usrinc is defined in usrinc.U, which relies on us... ?X: $cat $sysroot/usr/include/signal.h $sysroot/usr/include/sys/signal.h >foo 2>/dev/null if test -f /osf_boot || $contains 'OSF/1' $sysroot/usr/include/ctype.h >/dev/null 2>&1 then echo "Looks kind of like an OSF/1 system, but we'll see..." echo exit 0 >osf1 elif test `echo abc | $tr a-z A-Z` = Abc ; then xxx=`./loc addbib blurfl $pth` if $test -f $xxx; then echo "Looks kind of like a USG system with BSD features, but we'll see..." echo exit 0 >bsd echo exit 0 >usg else if $contains SIGTSTP foo >/dev/null 2>&1 ; then echo "Looks kind of like an extended USG system, but we'll see..." else echo "Looks kind of like a USG system, but we'll see..." fi echo exit 0 >usg fi elif $contains SIGTSTP foo >/dev/null 2>&1 ; then echo "Looks kind of like a BSD system, but we'll see..." d_bsd="$define" echo exit 0 >bsd else echo "Looks kind of like a Version 7 system, but we'll see..." echo exit 0 >v7 fi case "$eunicefix" in *unixtovms*) $cat <<'EOI' There is, however, a strange, musty smell in the air that reminds me of something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit. EOI echo exit 0 >eunice d_eunice="$define" : it so happens the Eunice I know will not run shell scripts in Unix format ;; *) echo " " echo "Congratulations. You aren't running Eunice." d_eunice="$undef" ;; esac : Detect OS2. The p_ variable is set above in the Head.U unit. : Note that this also -- wrongly -- detects e.g. dos-djgpp, which also uses : semicolon as a patch separator case "$p_" in :) ;; *) $cat <<'EOI' I have the feeling something is not exactly right, however...don't tell me... lemme think...does HAL ring a bell?...no, of course, you're only running OS/2! (Or you may be running DOS with DJGPP.) EOI echo exit 0 >os2 ;; esac if test -f /xenix; then echo "Actually, this looks more like a XENIX system..." echo exit 0 >xenix d_xenix="$define" else echo " " echo "It's not Xenix..." d_xenix="$undef" fi chmod +x xenix $eunicefix xenix if test -f /venix; then echo "Actually, this looks more like a VENIX system..." echo exit 0 >venix else echo " " if ./xenix; then : null else echo "Nor is it Venix..." fi fi chmod +x bsd usg v7 osf1 eunice xenix venix os2 $eunicefix bsd usg v7 osf1 eunice xenix venix os2 $rm -f foo metaconfig-debian-perl-5.26.1/U/modified/Head.U000066400000000000000000000272561316016665300210770ustar00rootroot00000000000000?RCS: $Id: Head.U 6 2006-08-25 22:21:46Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Head.U,v $ ?RCS: Revision 3.0.1.9 1997/02/28 15:02:09 ram ?RCS: patch61: make sure we unset CDPATH for shells that support this ?RCS: patch61: improved Korn shell detection and handling ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:40:02 ram ?RCS: patch56: added SVR4-ish /opt directories to path list (ADO) ?RCS: patch56: OS/2 platforms are using another path separator ?RCS: ?RCS: Revision 3.0.1.7 1995/03/21 08:46:15 ram ?RCS: patch52: definition of paths wrongly added spurious ':' chars ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 15:54:19 ram ?RCS: patch36: make sure ENV is unset before calling /bin/ksh ?RCS: ?RCS: Revision 3.0.1.5 1994/08/29 16:03:44 ram ?RCS: patch32: now sets PATH only using existing directories ?RCS: ?RCS: Revision 3.0.1.4 1994/06/20 06:54:28 ram ?RCS: patch30: now computes its invocation name into 'me' ?RCS: patch30: symbol me is made visible to all units read-only ?RCS: ?RCS: Revision 3.0.1.3 1993/12/15 08:15:07 ram ?RCS: patch15: added /sbin:/usr/sbin:/usr/libexec in PATH for BSD/386 ?RCS: ?RCS: Revision 3.0.1.2 1993/11/10 17:32:35 ram ?RCS: patch14: ensure PATH is reset to '.' before testing for alias ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:38:07 ram ?RCS: patch7: not all 'test' programs support the -x option ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This is the very first unit in the Configure script. It is mostly just ?X: things to keep people from getting into a tizzy right off the bat. ?X: ?MAKE:Head: ?MAKE: -pick wipe $@ %< ?V:PATH p_ _exe me newsh ?T:argv p paths OS2_SHELL DJGPP ?T:inksh needksh avoidksh newsh changesh reason ?F:!* ?LINT:extern ENV CDPATH SHELL MACHTYPE _exe is_os2 ?LINT:change ENV CDPATH is_os2 ?LINT:nocomment #! /bin/sh # # If these # comments don't work, trim them. Don't worry about any other # shell scripts, Configure will trim # comments from them for you. # # (If you are trying to port this package to a machine without sh, # I would suggest you have a look at the prototypical config_h.SH file # and edit it to reflect your system. Some packages may include samples # of config.h for certain machines, so you might look for one of those.) # ?X: ?X: NOTE THAT A CONFIGURE SCRIPT IS IN THE PUBLIC DOMAIN (whether or not ?X: the software which uses it is in the public domain). ?X: # Yes, you may rip this off to use in other distribution packages. This # script belongs to the public domain and cannot be copyrighted. # ?X: ?X: WE ASK YOU NOT TO REMOVE OR ALTER THE FOLLOWING PARAGRAPH, PLEASE: ?X: # Note: this Configure script was generated automatically by the tool # called "metaconfig". Rather than working with this copy of Configure, # you may wish to get metaconfig. Perl uses a modified version of this # tool, available in the "dist" folder in the checkout of the git repo # $ git clone git://perl5.git.perl.org/metaconfig.git metaconfig # The original dist package (including metaconfig) is available via SVN: # $ svn co https://svn.code.sf.net/p/dist/code/trunk/dist # ?X: OK, I'll not alter, but I'll add to it then ... # Though this script was generated by metaconfig from metaunits, it is # OK to send patches against Configure itself. It's up to the Configure # pumpkin to backport the patch to the metaunits if it is accepted. # For more information on patching Configure, see pod/perlhack.pod # # The metaunits are also available from the public git repository: # http://perl5.git.perl.org/metaconfig.git/ or # $ git clone git://perl5.git.perl.org/metaconfig.git metaconfig # # See Porting/pumpkin.pod for more information on metaconfig. ?X: ?X: NOTA BENE: ?X: If you develop you own version of metaconfig based on this work, ?X: you have to add some comments telling that the script was generated ?X: by your version, not mine: It credits your work. ?X: # Generated using [metaconfig PL] # (with additional metaconfig patches by ) cat >c1$$ <c2$$ </dev/null` test "$me" || me=$0 ;; esac ?X: ?X: To be able to run under OS/2, we must detect that early enough to use ?X: the proper path separator, stored in $p_. It is : on UNIX and ; on ?X: DOS-ish systems such as OS/2. ?X: : Proper separator for the PATH environment variable p_=: : On OS/2 this directory should exist if this is not floppy only system ":-]" if test -d c:/. || ( uname -a | grep -i 'os\(/\|\)2' 2>&1 ) 2>&1 >/dev/null ; then if test -n "$OS2_SHELL"; then p_=\; PATH=`cmd /c "echo %PATH%" | tr '\\\\' / ` ?X: That's a bug in ksh5.22 OS2_SHELL=`cmd /c "echo %OS2_SHELL%" | tr '\\\\' / | tr '[A-Z]' '[a-z]'` is_os2=yes elif test -n "$DJGPP"; then case "X${MACHTYPE:-nonesuchmach}" in *cygwin|*msys) ;; *) p_=\; ;; esac fi fi ?X: ?X: There are two schools of thoughts here. Some people correctly argue that ?X: the user has a better chance than we do of setting a reasonable PATH and ?X: others argue that Configure is the best place there is to set up a suitable ?X: PATH. Well, here we try to compromise by keeping the user's PATH and ?X: appending some directories which are known to work on some machine or the ?X: other. The rationale behind this being that a novice user might not have a ?X: proper environment variable set, and some directories like /etc (where ?X: chown is located on some BSD systems) may be missing--RAM. ?X: ?X: SVR4 adds an /opt directory for optional packages. Some sites use ?X: various permutations on /opt as opposed to /usr or /usr/local.-- ADO ?X: ?X: We only add directories that are not already in the PATH of the ?X: user and the directories must exist also. ?X: ?X: 20040627, Merijn, HP-UX's ANSI compiler is in /opt/ansic/bin if present ?X: and should be before /usr/ccs/bin, where the braindead bundled compiler ?X: can be found. The /usr/ccs/bin compiler cannot be used to build perl. ?X: : Proper PATH setting paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin' paths="$paths /opt/bin /opt/local/bin /opt/local /opt/lbin" paths="$paths /usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin" paths="$paths /opt/gnu/bin /opt/new /opt/new/bin /opt/nbin" paths="$paths /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb" paths="$paths /bsd4.3/usr/bin /usr/bsd /bsd43/bin /opt/ansic/bin /usr/ccs/bin" paths="$paths /etc /usr/lib /usr/ucblib /lib /usr/ccs/lib" paths="$paths /sbin /usr/sbin /usr/libexec" paths="$paths /system/gnu_library/bin" for p in $paths do case "$p_$PATH$p_" in *$p_$p$p_*) ;; *) test -d $p && PATH=$PATH$p_$p ;; esac done PATH=.$p_$PATH export PATH : shall we be using ksh? inksh='' needksh='' avoidksh='' newsh=/bin/ksh changesh='' ?X: Use (alias -x) and not (alias) since zsh and bash recognize the alias ?X: builtin but not the -x option which is typically ksh... ?X: We need to set up PATH before calling the "alias" built-in since some ?X: systems like HP-UX have a binary called /bin/alias. if (PATH=.; alias -x) >/dev/null 2>&1; then inksh=true fi ?X: On HP-UX, large Configure scripts may exercise a bug in /bin/sh, use ksh if test -f /hp-ux -a -f /bin/ksh; then needksh='to avoid sh bug in "here document" expansion' fi ?X: On AIX4, /bin/sh is really ksh and it causes problems, use sh if test -d /usr/lpp -a -f /usr/bin/bsh -a -f /usr/bin/uname; then if test X`/usr/bin/uname -v` = X4; then avoidksh="to avoid AIX 4's /bin/sh" newsh=/usr/bin/bsh fi fi ?X: On Digital UNIX, /bin/sh may start up buggy /bin/ksh, use sh if test -f /osf_boot -a -f /usr/sbin/setld; then if test X`/usr/bin/uname -s` = XOSF1; then avoidksh="to avoid Digital UNIX' ksh" newsh=/bin/sh ?X: if BIN_SH is set to 'xpg4', sh will start up ksh unset BIN_SH fi fi ?X: If we are not in ksh and need it, then feed us back to it case "$inksh/$needksh" in /[a-z]*) ?X: Clear ENV to avoid any ~/.kshrc that could alias cd or whatever... ?X: Don't use "unset ENV", that is not portable enough ENV='' changesh=true reason="$needksh" ;; esac ?X: If we are in ksh and must avoid it, then feed us back to a new shell case "$inksh/$avoidksh" in true/[a-z]*) changesh=true reason="$avoidksh" ;; esac ?X: Warn them if they use ksh on other systems, which are those where ?X: we don't need ksh nor want to avoid it explicitly, yet are using it. case "$inksh/$needksh-$avoidksh-" in true/--) cat </dev/null` case "$user" in '') user=`whoami 2>&1`;; esac if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then firsttime=false echo " " rp='Would you like to see the instructions?' dflt=n . ./myread case "$ans" in [yY]*) ;; *) needman=false;; esac fi if $needman; then cat < package should be installed. If you get stuck on a question, you may use a ! shell escape to start a subshell or execute a command. Many of the questions will have default answers in square brackets; typing carriage return will give you the default. On some of the questions which ask for file or directory names you are allowed to use the ~name construct to specify the login directory belonging to "name", even if you don't have a shell which knows about that. Questions where this is allowed will be marked "(~name ok)". EOH rp='' dflt='Type carriage return to continue' . ./myread cat <<'EOH' The prompter used in this script allows you to use shell variables and backticks in your answers. You may use $1, $2, etc... to refer to the words in the default answer, as if the default line was a set of arguments given to a script shell. This means you may also use $* to repeat the whole default line, so you do not have to re-type everything to add something to the default. Every time there is a substitution, you will have to confirm. If there is an error (e.g. an unmatched backtick), the default answer will remain unchanged and you will be prompted again. If you are in a hurry, you may run 'Configure -d'. This will bypass nearly all the questions and use the computed defaults (or the previous answers if there was already a config.sh file). Type 'Configure -h' for a list of options. You may also start interactively and then answer '& -d' at any prompt to turn on the non-interactive behaviour for the remainder of the execution. EOH . ./myread cat <) know how I blew it. This installation script affects things in two ways: 1) it may do direct variable substitutions on some of the files included in this kit. 2) it builds a config.h file for inclusion in C programs. You may edit any of these files as the need arises after running this script. If you make a mistake on a question, there is no easy way to back up to it currently. The easiest thing to do is to edit config.sh and rerun all the SH files. Configure will offer to let you do this before it runs the SH files. EOH ?X: In case they played with the prompter... dflt='Type carriage return to continue' . ./myread case "$firsttime" in true) echo $user >>../.config/instruct;; esac fi metaconfig-debian-perl-5.26.1/U/modified/Loc.U000066400000000000000000000243441316016665300207460ustar00rootroot00000000000000?RCS: $Id: Loc.U 14 2006-08-28 16:51:14Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Loc.U,v $ ?RCS: Revision 3.0.1.10 1997/02/28 15:04:16 ram ?RCS: patch61: allow users to specify paths on the command line ?RCS: patch61: will now substitute cp for ln if not supported ?RCS: ?RCS: Revision 3.0.1.9 1995/09/25 09:11:24 ram ?RCS: patch59: commented the purpose of the #un-def directive ?RCS: patch59: abort Configure run when mandatory command is missing ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:40:40 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.7 1995/01/11 15:13:37 ram ?RCS: patch45: protected "sh -c" within backquotes for Linux and SGI ?RCS: patch45: added path lookup for the 'comm' program ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 15:56:14 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: be careful and guard against wildcard searching (ADO) ?RCS: ?RCS: Revision 3.0.1.5 1994/06/20 06:54:55 ram ?RCS: patch30: now locates find ?RCS: ?RCS: Revision 3.0.1.4 1994/05/13 15:18:15 ram ?RCS: patch27: added byacc to the trylist (ADO) ?RCS: patch27: lint lines reformatted (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/01/24 14:01:44 ram ?RCS: patch16: added metalint hint on changed PATH variable ?RCS: ?RCS: Revision 3.0.1.2 1993/12/15 08:16:52 ram ?RCS: patch15: now set _test variable when test is built-in ?RCS: patch15: fixed rare cases where echo is not needed ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:47:13 ram ?RCS: patch10: test program not always in /bin/test (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:05 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script "loc" which can be used to find out ?X: where in a list of directories something is. It then uses loc to ?X: determine the location of commonly used programs. It leaves loc sitting ?X: around for other Configure units to use, but arranges for its demise ?X: at the end of Configure. ?X: ?X: To add a new program to find, add it both to the ?MAKE: line and to either ?X: the loclist or trylist variable. ?X: ?X: I put startsh at the end of the dependency list, in order to avoid the ?X: loading of the spitshell unit before the instructions. ?X: ?MAKE:Loc awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo egrep emacs expr find flex \ gmake gzip grep inews ksh less line lint ln lp lpr ls mail mailx \ make mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee test touch tr troff \ uname uniq uuname vi zcat zip: eunicefix n c startsh Instruct sysroot ?MAKE: -pick weed $@ %< ?LINT:describe awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo egrep emacs expr find flex \ gmake gzip grep inews ksh less line lint ln lp lpr ls mail mailx \ make mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee test touch tr troff \ uname uniq uuname vi zcat zip ?V::pth loclist trylist ?F:./loc test_h ?T:thisthing thing xxx dir file say _test DJGPP ?LINT:change PATH _egrep _ln _make _less ?LINT:extern _exe : find out where common programs are echo " " echo "Locating common programs..." >&4 cat <loc $startsh case \$# in 0) exit 1;; esac thing=\$1 shift dflt=\$1 shift for dir in \$*; do case "\$thing" in .) if test -d \$dir/\$thing; then echo \$dir exit 0 fi ;; *) ?X: Be careful in case thing includes wildcards that might expand to multiple ?X: files. Choose the last one. This happens when searching for shared ?X: libraries with version numbers. How to choose which one we want is ?X: probably an insoluble problem, in general. ?X: Some folks leave things like libc.so.orig around w/o read ?X: permission. A -r test would handle that, but since ./loc is ?X: also used to find executables (which are installed w/o read ?X: permission on SCO ODT 3.0, we can't include the -r test. ?X: If you need to use an _exe that is different from .exe ?X: you need to set it in Head.U. for thisthing in \$dir/\$thing; do : just loop through to pick last item done if test -f \$thisthing; then echo \$thisthing exit 0 elif test "X$_exe" != X -a -f \$thisthing$_exe; then echo \$thisthing exit 0 elif test -f \$dir/\$thing.exe; then if test -n "$DJGPP"; then echo \$dir/\$thing.exe elif test "$eunicefix" != ":"; then : on Eunice apparently echo \$dir/\$thing fi exit 0 fi ;; esac done echo \$dflt exit 1 EOSC chmod +x loc $eunicefix loc loclist=" ?awk:awk ?cat:cat ?chgrp:chgrp ?chmod:chmod ?chown:chown ?comm:comm ?cp:cp ?echo:echo ?expr:expr ?find:find ?grep:grep ?ls:ls ?mkdir:mkdir ?mv:mv ?rm:rm ?sed:sed ?sleep:sleep ?sort:sort ?tail:tail ?touch:touch ?tr:tr ?uniq:uniq " trylist=" ?Mcc:Mcc ?ar:ar ?bash:bash ?bison:bison ?byacc:byacc ?compress:compress ?cpio:cpio ?cpp:cpp ?csh:csh ?date:date ?egrep:egrep ?emacs:emacs ?flex:flex ?gmake:gmake ?gzip:gzip ?inews:inews ?ksh:ksh ?less:less ?line:line ?lint:lint ?ln:ln ?lp:lp ?lpr:lpr ?mail:mail ?mailx:mailx ?make:make ?more:more ?nm:nm ?nroff:nroff ?perl:perl ?pg:pg ?pmake:pmake ?pr:pr ?rmail:rmail ?sendmail:sendmail ?shar:shar ?smail:smail ?submit:submit ?tar:tar ?tbl:tbl ?tee:tee ?test:test ?troff:troff ?uname:uname ?uuname:uuname ?vi:vi ?zcat:zcat ?zip:zip " ?LINT:set awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo emacs expr find flex \ gmake gzip grep inews ksh line lint lp lpr ls mail mailx \ mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee touch tr troff \ uname uniq uuname vi zcat zip pth=`echo $PATH | sed -e "s/$p_/ /g"` pth="$pth $sysroot/lib $sysroot/usr/lib" for file in $loclist; do ?X: ?X: Allow them to -Dmake=pmake on the command line for instance... ?X: If the file is not fully qualified, as in -Dmake=pmake, then we ?X: look the for the specified command (pmake here). If they say ?X: -Dmake=/sbin/make for instance, then we make sure the file ?X: exists, or we die... ?X: eval xxx=\$$file case "$xxx" in /*|?:[\\/]*) if test -f "$xxx"; then : ok else echo "WARNING: no $xxx -- ignoring your setting for $file." >&4 xxx=`./loc $file $file $pth` fi ;; '') xxx=`./loc $file $file $pth`;; *) xxx=`./loc $xxx $xxx $pth`;; esac eval $file=$xxx$_exe eval _$file=$xxx case "$xxx" in /*) echo $file is in $xxx. ;; ?X: Under OS/2, we have PC-like paths ?:[\\/]*) echo $file is in $xxx. ;; *) echo "I don't know where '$file' is, and my life depends on it." >&4 echo "Go find a public domain implementation or fix your PATH setting!" >&4 exit 1 ;; esac done echo " " echo "Don't worry if any of the following aren't found..." say=offhand for file in $trylist; do ?X: Allow them to -Dmake=pmake on the command line for instance (see above) eval xxx=\$$file case "$xxx" in /*|?:[\\/]*) if test -f "$xxx"; then : ok else echo "WARNING: no $xxx -- ignoring your setting for $file." >&4 xxx=`./loc $file $file $pth` fi ;; '') xxx=`./loc $file $file $pth`;; *) xxx=`./loc $xxx $xxx $pth`;; esac eval $file=$xxx$_exe eval _$file=$xxx case "$xxx" in /*) echo $file is in $xxx. ;; ?X: Under OS/2, we have PC-like paths ?:[\\/]*) echo $file is in $xxx. ;; *) echo "I don't see $file out there, $say." say=either ;; esac done case "$egrep" in egrep) echo "Substituting grep for egrep." egrep=$grep _egrep=$grep ;; esac @if less case "$less" in '') ;; *) if $less -R /dev/null 2>&1; then echo "Substituting less -R for less." less="$less -R" _less=$less fi ;; esac @end @if ln case "$ln" in ln) echo "Substituting cp for ln." ln=$cp _ln=$cp ;; esac @end @if make || gmake case "$make" in make) case "$gmake" in gmake) echo "I can't find make or gmake, and my life depends on it." >&4 echo "Go find a public domain implementation or fix your PATH setting!" >&4 exit 1 ;; esac ;; esac case "$gmake" in gmake) ;; *) # We can't have osname yet. if test -f "/system/gnu_library/bin/ar.pm"; then # Stratus VOS # Assume that gmake, if found, is definitely GNU make # and prefer it over the system make. echo "Substituting gmake for make." make=$gmake _make=$gmake fi ;; esac @end case "$test" in test) echo "Hopefully test is built into your sh." ;; *) if `sh -c "PATH= test true" >/dev/null 2>&1`; then echo "Using the test built into your sh." ?X: ?X: We need to set both test and _test, since Oldconfig.U will use the _test ?X: value to systematically restore computed paths, which may be wrong if ?X: we choose to load an old config.sh generated on another platform. ?X: test=test _test=test fi ;; esac ?LINT:change n c case "$echo" in echo) echo "Hopefully echo is built into your sh." ;; ?X: For those rare cases where we don't need $echo... '') ;; *) echo " " echo "Checking compatibility between $echo and builtin echo (if any)..." >&4 $echo $n "hi there$c" >foo1 echo $n "hi there$c" >foo2 if cmp foo1 foo2 >/dev/null 2>&1; then echo "They are compatible. In fact, they may be identical." else case "$n" in '-n') n='' c='\c';; *) n='-n' c='';; esac cat <$c" $echo "*" fi $rm -f foo1 foo2 ;; esac ?X: The next part is irrelevant to the real process # This question was auctioned at YAPC::Europe-2007 in Vienna # I never promised you could answer it. I only auctioned the question. cat </dev/null` $test -z "$myuname" && myuname=`hostname 2>/dev/null` # Downcase everything to avoid ambiguity. # Remove slashes and single quotes so we can use parts of this in # directory and file names. # Remove newlines so myuname is sane to use elsewhere. # tr '[A-Z]' '[a-z]' would not work in EBCDIC # because the A-Z/a-z are not consecutive. myuname=`echo $myuname | $sed -e "s,['/],,g" | \ ./tr '[A-Z]' '[a-z]' | $tr $trnl ' '` ?X: Save the value we just computed to reset myuname after we get done here. newmyuname="$myuname" dflt=n case "$knowitall" in '') if test -f ../config.sh; then if $contains myuname= ../config.sh >/dev/null 2>&1; then eval "`grep myuname= ../config.sh`" fi if test "X$myuname" = "X$newmyuname"; then dflt=y fi fi ;; *) dflt=y;; esac @if {test -d ../hints} : Get old answers from old config file if Configure was run on the : same system, otherwise use the hints. hint=default cd .. ?X: Since we are now at the root of the source tree, we must use $src ?X: to access the sources and not $rsrc. See src.U for details... if test -f config.sh; then echo " " rp="I see a config.sh file. Shall I use it to set the defaults?" . UU/myread case "$ans" in n*|N*) echo "OK, I'll ignore it." mv config.sh config.sh.old myuname="$newmyuname" ;; *) echo "Fetching default answers from your old config.sh file..." >&4 tmp_n="$n" tmp_c="$c" tmp_sh="$sh" . ./config.sh cp config.sh UU n="$tmp_n" c="$tmp_c" : Older versions did not always set $sh. Catch re-use of such : an old config.sh. case "$sh" in '') sh="$tmp_sh" ;; esac hint=previous ;; esac fi . ./UU/checkcc if test ! -f config.sh; then $cat <&4 dflt='' : Half the following guesses are probably wrong... If you have better : tests or hints, please send them to : The metaconfig authors would also appreciate a copy... $test -f /irix && osname=irix $test -f /xenix && osname=sco_xenix $test -f /dynix && osname=dynix $test -f /dnix && osname=dnix $test -f /lynx.os && osname=lynxos $test -f /unicos && osname=unicos && osvers=`$uname -r` $test -f /unicosmk && osname=unicosmk && osvers=`$uname -r` $test -f /unicosmk.ar && osname=unicosmk && osvers=`$uname -r` $test -f /bin/mips && /bin/mips && osname=mips $test -d /usr/apollo/bin && osname=apollo $test -f /etc/saf/_sactab && osname=svr4 $test -d /usr/include/minix && osname=minix && osvers=`$uname -r` $test -f /system/gnu_library/bin/ar.pm && osname=vos $test -f /sys/utilities/MultiView && osname=amigaos if $test -d /MachTen -o -d /MachTen_Folder; then ?X: MachTen uname -a output looks like ?X: xxx 4 0.0 Macintosh ?X: MachTen /sbin/version output looks like ?X: MachTen 4.0 Mon Aug 28 10:18:00 1995 ?X: MachTen 3.x had the 'version' command in /usr/etc/version. osname=machten if $test -x /sbin/version; then osvers=`/sbin/version | $awk '{print $2}' | $sed -e 's/[A-Za-z]$//'` elif $test -x /usr/etc/version; then osvers=`/usr/etc/version | $awk '{print $2}' | $sed -e 's/[A-Za-z]$//'` else osvers="$2.$3" fi fi $test -f /sys/posix.dll && $test -f /usr/bin/what && set X `/usr/bin/what /sys/posix.dll` && $test "$3" = UWIN && osname=uwin && osvers="$5" ?X: If we have uname, we already computed a suitable uname -a output, ?X: and it lies in $myuname. if $test -f $uname; then set X $myuname shift case "$5" in fps*) osname=fps ;; mips*) case "$4" in umips) osname=umips ;; *) osname=mips ;; esac;; [23]100) osname=mips ;; ?X: Interactive Unix. i386*) tmp=`/bin/uname -X 2>/dev/null|awk '/3\.2v[45]/{ print $(NF) }'` if $test "$tmp" != "" -a "$3" = "3.2" -a -f '/etc/systemid'; then osname='sco' osvers=$tmp elif $test -f /etc/kconfig; then osname=isc if test "$lns" = "$ln -s"; then osvers=4 elif $contains _SYSV3 /usr/include/stdio.h > /dev/null 2>&1 ; then osvers=3 elif $contains _POSIX_SOURCE /usr/include/stdio.h > /dev/null 2>&1 ; then osvers=2 fi fi tmp='' ;; ?X: MS-DOS djgpp uname -a output looks like: ?X: ms-dos xxx 6 22 pc ?X: $1 is the "dos flavor" (need not be "ms-dos"). ?X: $2 is the node name ?X: $3 and $4 are version/subversion ?X: $5 is always "pc", but that might not be unique to DJGPP. ?X: (e.g. Solaris_x86 has $5 = i86pc, which doesn't actually conflict, ?X: but it's close enough that I can easily imagine other vendors also ?X: using variants of pc* in $5.) ?X: The "DJGPP" environment variable is always set when djgpp is active. pc*) if test -n "$DJGPP"; then osname=dos osvers=djgpp fi ;; esac case "$1" in aix) osname=aix ?X: aix 4.1 uname -a output looks like ?X: AIX foo 1 4 000123456789 ?X: where $4 is the major release number and $3 is the (minor) version. ?X: More detail on the version is available with the oslevel command. ?X: in 3.2.x, it output a string (see case statements below). In 4.1, ?X: it puts out something like 4.1.1.0 tmp=`( (oslevel) 2>/dev/null || echo "not found") 2>&1` case "$tmp" in # oslevel can fail with: # oslevel: Unable to acquire lock. *not\ found) osvers="$4"."$3" ;; '<3240'|'<>3240') osvers=3.2.0 ;; '=3240'|'>3240'|'<3250'|'<>3250') osvers=3.2.4 ;; '=3250'|'>3250') osvers=3.2.5 ;; *) osvers=$tmp;; esac ;; bitrig) osname=bitrig osvers="$3" ;; bsd386) osname=bsd386 osvers=`$uname -r` ;; cygwin*) osname=cygwin osvers="$3" ;; *dc.osx) osname=dcosx osvers="$3" ;; dnix) osname=dnix osvers="$3" ;; domainos) osname=apollo osvers="$3" ;; dgux) osname=dgux osvers="$3" ;; dragonfly) osname=dragonfly osvers="$3" ;; ?X: uname -a returns ?X: DYNIX/ptx xxx 4.0 V4.1.2 i386 dynixptx*) osname=dynixptx osvers=`echo "$4"|sed 's/^v//'` ;; freebsd) osname=freebsd osvers="$3" ;; genix) osname=genix ;; ?X: GNU/Hurd uname -a gives something like: ?X: GNU foo 0.3 GNU-Mach 1.4/Hurd-0.3 i386-AT386 GNU ?X: GNU gnu 0.3 GNUmach-1.2/Hurd-0.3 i386-AT386 GNU ?X: Note the hostname on the second one, which will fool Configure ?X: into using the SysV case! gnu) osname=gnu osvers="$3" ;; ?X: HP-UX uname -a gives something like ?X: HP-UX foobar B.10.20 A 9000/735 2016483812 two-user license ?X: Preserve the full 10.20 string instead of the previous plain '10'. ?X: Thanks to Graham Barr. --AD 6/30/1998 hp*) osname=hpux osvers=`echo "$3" | $sed 's,.*\.\([0-9]*\.[0-9]*\),\1,'` ;; irix*) osname=irix case "$3" in 4*) osvers=4 ;; 5*) osvers=5 ;; *) osvers="$3" ;; esac ;; linux) osname=linux case "$3" in *) osvers="$3" ;; esac $test -f /system/lib/libandroid.so && osname=linux-android ;; MiNT) osname=mint ;; netbsd*) osname=netbsd osvers="$3" ;; news-os) osvers="$3" case "$3" in 4*) osname=newsos4 ;; *) osname=newsos ;; esac ;; nonstop-ux) osname=nonstopux ;; openbsd) osname=openbsd osvers="$3" ;; os2) osname=os2 osvers="$4" ;; POSIX-BC | posix-bc ) osname=posix-bc osvers="$3" ;; powerux | power_ux | powermax_os | powermaxos | \ powerunix | power_unix) osname=powerux osvers="$3" ;; qnx) osname=qnx osvers="$4" ;; solaris) osname=solaris case "$3" in 5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;; *) osvers="$3" ;; esac ;; sunos) osname=sunos case "$3" in 5*) osname=solaris osvers=`echo $3 | $sed 's/^5/2/g'` ;; *) osvers="$3" ;; esac ;; titanos) osname=titanos case "$3" in 1*) osvers=1 ;; 2*) osvers=2 ;; 3*) osvers=3 ;; 4*) osvers=4 ;; *) osvers="$3" ;; esac ;; ultrix) osname=ultrix osvers="$3" ;; osf1|mls+) case "$5" in alpha) ?X: DEC OSF/1 myuname -a output looks like: osf1 xxxx t3.2 123.4 alpha ?X: where the version number can be something like [xvt]n.n osname=dec_osf ?X: sizer knows the minor minor version: the letter osvers=`sizer -v | awk -FUNIX '{print $2}' | awk '{print $1}' | tr '[A-Z]' '[a-z]' | sed 's/^[xvt]//'` case "$osvers" in [1-9].[0-9]*) ;; *) osvers=`echo "$3" | sed 's/^[xvt]//'` ;; esac ;; hp*) osname=hp_osf1 ;; mips) osname=mips_osf1 ;; ?X: hp and mips were unsupported Technology Releases -- ADO, 24/10/94 esac ;; # UnixWare 7.1.2 is known as Open UNIX 8 openunix|unixware) osname=svr5 osvers="$4" ;; uts) osname=uts osvers="$3" ;; vos) osvers="$3" ;; $2) case "$osname" in *isc*) ;; *freebsd*) ;; svr*) : svr4.x or possibly later case "svr$3" in ${osname}*) osname=svr$3 osvers=$4 ;; esac case "$osname" in svr4.0) : Check for ESIX if test -f /stand/boot ; then eval `grep '^INITPROG=[a-z/0-9]*$' /stand/boot` if test -n "$INITPROG" -a -f "$INITPROG"; then isesix=`strings -a $INITPROG|grep 'ESIX SYSTEM V/386 Release 4.0'` if test -n "$isesix"; then osname=esix4 fi fi fi ;; esac ;; *) if test -f /etc/systemid; then osname=sco set `echo $3 | $sed 's/\./ /g'` $4 if $test -f $src/hints/sco_$1_$2_$3.sh; then osvers=$1.$2.$3 elif $test -f $src/hints/sco_$1_$2.sh; then osvers=$1.$2 elif $test -f $src/hints/sco_$1.sh; then osvers=$1 fi else case "$osname" in '') : Still unknown. Probably a generic Sys V. osname="sysv" osvers="$3" ;; esac fi ;; esac ;; *) case "$osname" in '') : Still unknown. Probably a generic BSD. osname="$1" osvers="$3" ;; esac ;; esac else ?X: Try to identify sony's NEWS-OS (BSD unix) if test -f /vmunix -a -f $src/hints/news_os.sh; then (what /vmunix | UU/tr '[A-Z]' '[a-z]') > UU/kernel.what 2>&1 if $contains news-os UU/kernel.what >/dev/null 2>&1; then osname=news_os fi $rm -f UU/kernel.what ?X: Maybe it's OS/2 or DOS or something similar elif test -d c:/. -o -n "$is_os2" ; then set X $myuname osname=os2 osvers="$5" fi fi case "$targetarch" in '') ;; *) hostarch=$osname case "$targetarch" in nto*|*-nto-*) # Will load qnx.sh, which should change osname to nto osname=qnx osvers='' ;; *linux-android*) # Catch arm-linux-androideabi, mipsel-linux-android, # and i686-linux-android osname=linux-android osvers='' ;; *linux*) # Something like arm-linux-gnueabihf is really just # plain linux. osname=linux osvers='' ;; *solaris*|*sunos*) osname=solaris # XXX perhaps we should just assume # osvers to be 2, or maybe take the value # from targetarch. Using $run before the # hints are run is somewhat icky. set X `$run $uname -a 2>/dev/null` shift case "$3" in 5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;; *) osvers="$3" ;; esac ;; *) osname=`echo $targetarch|sed 's,^[^-]*-,,'` osvers='' ;; esac ;; esac : Now look for a hint file osname_osvers, unless one has been : specified already. case "$hintfile" in ''|' ') file=`echo "${osname}_${osvers}" | $sed -e 's%\.%_%g' -e 's%_$%%'` : Also try without trailing minor version numbers. xfile=`echo $file | $sed -e 's%_[^_]*$%%'` xxfile=`echo $xfile | $sed -e 's%_[^_]*$%%'` xxxfile=`echo $xxfile | $sed -e 's%_[^_]*$%%'` xxxxfile=`echo $xxxfile | $sed -e 's%_[^_]*$%%'` case "$file" in '') dflt=none ;; *) case "$osvers" in '') dflt=$file ;; *) if $test -f $src/hints/$file.sh ; then dflt=$file elif $test -f $src/hints/$xfile.sh ; then dflt=$xfile elif $test -f $src/hints/$xxfile.sh ; then dflt=$xxfile elif $test -f $src/hints/$xxxfile.sh ; then dflt=$xxxfile elif $test -f $src/hints/$xxxxfile.sh ; then dflt=$xxxxfile elif $test -f "$src/hints/${osname}.sh" ; then dflt="${osname}" else dflt=none fi ;; esac ;; esac if $test -f Policy.sh ; then case "$dflt" in *Policy*) ;; none) dflt="Policy" ;; *) dflt="Policy $dflt" ;; esac fi ;; *) dflt=`echo $hintfile | $sed 's/\.sh$//'` ;; esac if $test -f Policy.sh ; then $cat <> UU/config.sh elif $test -f $src/hints/$file.sh; then . $src/hints/$file.sh $cat $src/hints/$file.sh >> UU/config.sh elif $test X"$tans" = X -o X"$tans" = Xnone ; then : nothing else : Give one chance to correct a possible typo. echo "$file.sh does not exist" dflt=$file rp="hint to use instead?" . UU/myread for file in $ans; do if $test -f "$src/hints/$file.sh"; then . $src/hints/$file.sh $cat $src/hints/$file.sh >> UU/config.sh elif $test X$ans = X -o X$ans = Xnone ; then : nothing else echo "$file.sh does not exist -- ignored." fi done fi done hint=recommended : Remember our hint file for later. if $test -f "$src/hints/$file.sh" ; then hintfile="$file" else hintfile='' fi fi cd UU ?X: From here on, we must use $rsrc instead of $src @else : Get old answers, if there is a config file out there hint=default hintfile='' if test -f ../config.sh; then echo " " rp="I see a config.sh file. Shall I use it to set the defaults?" . ./myread case "$ans" in n*|N*) echo "OK, I'll ignore it.";; *) echo "Fetching default answers from your old config.sh file..." >&4 tmp_n="$n" tmp_c="$c" . ../config.sh cp ../config.sh . n="$tmp_n" c="$tmp_c" hint=previous ;; esac fi @end ?X: remember, indentation is wrong--RAM ;; *) echo " " echo "Fetching default answers from $config_sh..." >&4 tmp_n="$n" tmp_c="$c" cd .. ?X: preserve symbolic links, if any cp $config_sh config.sh 2>/dev/null chmod +w config.sh . ./config.sh cd UU cp ../config.sh . n="$tmp_n" c="$tmp_c" hint=previous ;; esac . ./optdef.sh : Restore computed paths for file in $loclist $trylist; do eval $file="\$_$file" done @if osname || osvers cat << EOM Configure uses the operating system name and version to set some defaults. The default value is probably right if the name rings a bell. Otherwise, since spelling matters for me, either accept the default or answer "none" to leave it blank. EOM @end @if osname case "$osname" in ''|' ') case "$hintfile" in ''|' '|none) dflt=none ;; *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/_.*$//'` ;; esac ;; *) dflt="$osname" ;; esac rp="Operating system name?" . ./myread case "$ans" in none) osname='' ;; *) osname=`echo "$ans" | $sed -e 's/[ ][ ]*/_/g' | ./tr '[A-Z]' '[a-z]'`;; esac @end @if osvers @if osname echo " " @end case "$osvers" in ''|' ') case "$hintfile" in ''|' '|none) dflt=none ;; *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/^[^_]*//'` dflt=`echo $dflt | $sed -e 's/^_//' -e 's/_/./g'` case "$dflt" in ''|' ') dflt=none ;; esac ;; esac ;; *) dflt="$osvers" ;; esac rp="Operating system version?" . ./myread case "$ans" in none) osvers='' ;; *) osvers="$ans" ;; esac @end . ./posthint.sh metaconfig-debian-perl-5.26.1/U/modified/Oldsym.U000066400000000000000000000045731316016665300215020ustar00rootroot00000000000000?RCS: $Id: Oldsym.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Oldsym.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:06:58 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:13 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit follows the creation of the config.sh file. It adds some ?X: special symbols: defines from patchlevel.h file if any and PERL_CONFIG_SH, ?X: which is set to true. Then, we try to keep all the new symbols that ?X: may come from a hint file or a previous config.sh file. ?X: ?MAKE:Oldsym: Config_sh cat test hint src sed sort uniq perl_patchlevel ?MAKE: -pick add $@ %< ?T:PERL_CONFIG_SH PERL_PATCHLEVEL sym tmp ?F:!UU : add special variables $test -f $src/patchlevel.h && \ awk '/^#define[ ]+PERL_/ {printf "%s=%s\n",$2,$3}' $src/patchlevel.h >>config.sh echo "PERL_PATCHLEVEL='$perl_patchlevel'" >>config.sh echo "PERL_CONFIG_SH=true" >>config.sh : propagate old symbols if $test -f UU/config.sh; then ?X: Make sure each symbol is unique in oldconfig.sh UU/oldconfig.sh ?X: ?X: All the symbols that appear twice come only from config.sh (hence the ?X: two config.sh in the command line). These symbols will be removed by ?X: the uniq -u command. The oldsyms file thus contains all the symbols ?X: that did not appear in the produced config.sh (Larry Wall). ?X: ?X: Do not touch the -u flag of uniq. This means you too, Jarkko. ?X: $sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' \ config.sh config.sh UU/oldconfig.sh |\ $sort | $uniq -u >UU/oldsyms set X `$cat UU/oldsyms` shift case $# in 0) ;; *) $cat <>config.sh for sym in `$cat UU/oldsyms`; do echo " Propagating $hint variable "'$'"$sym..." eval 'tmp="$'"${sym}"'"' echo "$tmp" | \ sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh done ;; esac fi metaconfig-debian-perl-5.26.1/U/modified/Options.U000066400000000000000000000275031316016665300216640ustar00rootroot00000000000000?RCS: $Id: Options.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Options.U,v $ ?RCS: Revision 3.0.1.7 1997/02/28 15:08:15 ram ?RCS: patch61: optdef.sh now starts with a "startsh" ?RCS: patch61: moved some code from Head.U ?RCS: ?RCS: Revision 3.0.1.6 1995/09/25 09:14:46 ram ?RCS: patch59: protected option parsing code against 'echo -*' option failure ?RCS: ?RCS: Revision 3.0.1.5 1995/05/12 12:04:52 ram ?RCS: patch54: added -K option for experts ?RCS: ?RCS: Revision 3.0.1.4 1995/01/30 14:27:52 ram ?RCS: patch49: this unit now exports file optdef.sh, not a variable ?RCS: ?RCS: Revision 3.0.1.3 1995/01/11 15:19:00 ram ?RCS: patch45: new -O option allowing -D and -U to override config.sh settings ?RCS: patch45: file optdef.sh is no longer removed after sourcing ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 15:58:06 ram ?RCS: patch36: ensure option definition file is removed before appending ?RCS: patch36: protect variable definitions with spaces in them ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 06:55:44 ram ?RCS: patch30: now uses new me symbol to tag error messages ?RCS: patch30: new -D and -U options to define/undef symbols (JHI) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:14 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Command line parsing. It is really important that the variables used here ?X: be not listed in the MAKE line, or they will be saved in config.sh and ?X: loading this file to fetch default answers would clobber the values set ?X: herein. ?X: ?MAKE:Options: startsh ?MAKE: -pick wipe $@ %< ?V:reuseval alldone error realsilent silent extractsh fastread \ knowitall: config_sh ?T:arg argn symbol config_arg0 config_args config_argc xxx yyy zzz uuu ?T:args_exp args_sep arg_exp ccflags ?F:!Configure ?F:./optdef.sh ./cmdline.opt ./posthint.sh ./cmdl.opt : Save command line options in file UU/cmdline.opt for later use in : generating config.sh. ?X: This temporary file will be read by Oldsym.U. I used a temporary ?X: file to preserve all sorts of potential command line quotes and ?X: also because we don't know in advance how many variables we'll ?X: need, so I can't actually declare them on the MAKE line. ?X: The config_args variable won't be quite correct if Configure is ?X: fed something like ./Configure -Dcc="gcc -B/usr/ccs/bin/" ?X: since the quotes are gone by the time we see them. You'd have to ?X: reconstruct the command line from the config_arg? lines, but since ?X: I don't imagine anyone actually having to do that, I'm not going ?X: to worry too much. cat > cmdline.opt <>cmdline.opt < cmdl.opt $arg EOC arg_exp=`cat cmdl.opt` args_exp="$args_exp$args_sep'$arg_exp'" argn=`expr $argn + 1` args_sep=' ' done ?X: args_exp is good for restarting self: eval "set X $args_exp"; shift; $0 "$@" ?X: used by hints/os2.sh in Perl, for instance rm -f cmdl.opt : produce awk script to parse command line options cat >options.awk <<'EOF' BEGIN { optstr = "A:dD:eEf:hKOrsSU:V"; # getopt-style specification len = length(optstr); for (i = 1; i <= len; i++) { c = substr(optstr, i, 1); ?X: some older awk's do not have the C ?: construct if (i < len) a = substr(optstr, i + 1, 1); else a = ""; if (a == ":") { arg[c] = 1; i++; } opt[c] = 1; } } { expect = 0; str = $0; if (substr(str, 1, 1) != "-") { printf("'%s'\n", str); next; } len = length($0); for (i = 2; i <= len; i++) { c = substr(str, i, 1); if (!opt[c]) { printf("-%s\n", substr(str, i)); next; } printf("-%s\n", c); if (arg[c]) { if (i < len) printf("'%s'\n", substr(str, i + 1)); else expect = 1; next; } } } END { if (expect) print "?"; } EOF : process the command line options ?X: Use "$@" to keep arguments with spaces in them from being split apart. ?X: For the same reason, awk will output quoted arguments and the final eval ?X: removes them and sets a proper $* array. An 'X' is prepended to each ?X: argument before being fed to echo to guard against 'echo -x', where -x ?X: would be understood as an echo option! It is removed before feeding awk. set X `for arg in "$@"; do echo "X$arg"; done | sed -e s/X// | awk -f options.awk` eval "set $*" shift rm -f options.awk : set up default values fastread='' reuseval=false config_sh='' alldone='' error='' silent='' extractsh='' knowitall='' rm -f optdef.sh posthint.sh cat >optdef.sh <&4 redirection based on the value of the ?X: realsilent variable... -- RAM, 18/93/96 ?X: : option parsing while test $# -gt 0; do case "$1" in -d) shift; fastread=yes;; -e) shift; alldone=cont;; -f) shift cd .. if test -r "$1"; then config_sh="$1" else echo "$me: cannot read config file $1." >&2 error=true fi cd UU shift;; --help|\ -h) shift; error=true;; -r) shift; reuseval=true;; -s) shift; silent=true; realsilent=true;; -E) shift; alldone=exit;; -K) shift; knowitall=true;; -O) shift;; -S) shift; silent=true; extractsh=true;; -D) shift case "$1" in *=) echo "$me: use '-U symbol=', not '-D symbol='." >&2 echo "$me: ignoring -D $1" >&2 ;; *=*) echo "$1" | \ sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;; *) echo "$1='define'" >> optdef.sh;; esac shift ;; -U) shift case "$1" in *=) echo "$1" >> optdef.sh;; *=*) echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2 echo "$me: ignoring -U $1" >&2 ;; *) echo "$1='undef'" >> optdef.sh;; esac shift ;; -A) shift xxx='' yyy="$1" zzz='' uuu=undef case "$yyy" in *=*) zzz=`echo "$yyy"|sed 's!=.*!!'` case "$zzz" in *:*) zzz='' ;; *) xxx=append zzz=" "`echo "$yyy"|sed 's!^[^=]*=!!'` yyy=`echo "$yyy"|sed 's!=.*!!'` ;; esac ;; esac case "$xxx" in '') case "$yyy" in *:*) xxx=`echo "$yyy"|sed 's!:.*!!'` yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` zzz=`echo "$yyy"|sed 's!^[^=]*=!!'` yyy=`echo "$yyy"|sed 's!=.*!!'` ;; *) xxx=`echo "$yyy"|sed 's!:.*!!'` yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` ;; esac ;; esac case "$xxx" in append) echo "$yyy=\"\${$yyy}$zzz\"" >> posthint.sh ;; clear) echo "$yyy=''" >> posthint.sh ;; define) case "$zzz" in '') zzz=define ;; esac echo "$yyy='$zzz'" >> posthint.sh ;; eval) echo "eval \"$yyy=$zzz\"" >> posthint.sh ;; prepend) echo "$yyy=\"$zzz\${$yyy}\"" >> posthint.sh ;; undef) case "$zzz" in '') zzz="$uuu" ;; esac echo "$yyy=$zzz" >> posthint.sh ;; *) echo "$me: unknown -A command '$xxx', ignoring -A $1" >&2 ;; esac shift ;; -V) echo "$me generated by metaconfig PL." >&2 exit 0;; --) break;; -*) echo "$me: unknown option $1" >&2; shift; error=true;; *) break;; esac done case "$error" in true) cat >&2 <&1 case "$silent" in true) exec 1>/dev/null;; esac : run the defines and the undefines, if any, but leave the file out there... touch optdef.sh ?X: -q is POSIX ?X: It does not work in SysV (solaris) or old BSD greps. grep '\\' optdef.sh >/dev/null 2>&1 if test $? = 0; then echo "Configure does not support \\ in -D arguments" exit 1 fi . ./optdef.sh : create the posthint manipulation script and leave the file out there... ?X: this file will be perused by Oldconfig.U touch posthint.sh metaconfig-debian-perl-5.26.1/U/modified/Signal.U000066400000000000000000000165531316016665300214510ustar00rootroot00000000000000?RCS: $Id: Signal.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Signal.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:20:01 ram ?RCS: patch61: created ?RCS: ?X: ?X: This unit produces three files: ?X: 1- A signal.c file, which, when compiled and run, produces an output like: ?X: ?X: HUP 1 ?X: INT 2 ?X: QUIT 3 ?X: etc... ?X: ?X: 2- A signal.awk script to parse the output of signal.c, fill ?X: in gaps (up to NSIG) and move duplicates to the end. ?X: 3- A signal_cmd script to compile signal.c and run it ?X: through sort -n -k 2 | uniq | awk -f signal.awk. ?X: (we try also sort -n +1 since some old hosts don't grok sort -k) ?X: (This is called signal_cmd to avoid OS/2 confusion with ?X: signal.cmd vs. signal. ?X: The signal_cmd script also falls back on checking signals one at a ?X: time in case the signal.c program fails. On at least one version of ?X: Linux 2.1.x, the header file #define'd SIGRTMAX to a symbol that ?X: is not defined by the compiler/linker. :-(. Further, on that same ?X: version of Linux, the user had a defective C-shell that gave an ?X: incorrect list for kill -l, so the fall-back didn't work. ?X: ?X: This unit is then used by sig_name.U. ?X: ?MAKE:Signal: test tr rm awk cat grep startsh eunicefix sed sort uniq \ Findhdr cppstdin +cppflags cppminus Compile _o _exe trnl run i_stdlib \ sysroot ?MAKE: -pick add $@ %< ?X:all files declared as "public" since they're used from other units ?F:signal.c signal_cmd signal.lst signal signal.awk ?T: xx xxx xxxfiles ?LINT:use rm run _o _exe ?LINT:extern sig_num_init : Trace out the files included by signal.h, then look for SIGxxx names. ?X: Remove SIGARRAYSIZE used by HPUX. ?X: Remove SIGSTKSIZE used by Linux. ?X: Remove SIGSTKSZ used by POSIX. ?X: Remove SIGTYP void lines used by OS2. ?X: Some cpps, like os390, do not give the file name anywhere case "$sig_num_init" in '') if [ "X$fieldn" = X ]; then : Just make some guesses. We check them later. xxx="$sysroot/usr/include/signal.h $sysroot/usr/include/sys/signal.h" else xxx=`echo '#include ' | $cppstdin $cppminus $cppflags 2>/dev/null | $grep '^[ ]*#.*include' | $awk "{print \\$$fieldn}" | $sed 's!"!!g' |\ $sed 's!\\\\\\\\!/!g' | $sort | $uniq` fi ?X: Check this list of files to be sure we have parsed the cpp output ok. ?X: This will also avoid potentially non-existent files, such ?X: as ../foo/bar.h xxxfiles='' ?X: Add /dev/null in case the $xxx list is empty. for xx in $xxx /dev/null ; do $test -f "$xx" && xxxfiles="$xxxfiles $xx" done ?X: If we have found no files, at least try signal.h case "$xxxfiles" in '') xxxfiles=`./findhdr signal.h` ;; esac xxx=`awk ' $1 ~ /^#define$/ && $2 ~ /^SIG[A-Z0-9]*$/ && $2 !~ /SIGARRAYSIZE/ && $2 !~ /SIGSTKSIZE/ && $2 !~ /SIGSTKSZ/ && $3 !~ /void/ { print substr($2, 4, 20) } $1 == "#" && $2 ~ /^define$/ && $3 ~ /^SIG[A-Z0-9]*$/ && $3 !~ /SIGARRAYSIZE/ && $4 !~ /void/ { print substr($3, 4, 20) }' $xxxfiles` : Append some common names just in case the awk scan failed. xxx="$xxx ABRT ALRM BUS CANCEL CHLD CLD CONT DIL EMT FPE" xxx="$xxx FREEZE HUP ILL INT IO IOT KILL LOST LWP PHONE" xxx="$xxx PIPE POLL PROF PWR QUIT RTMAX RTMIN SEGV STKFLT STOP" xxx="$xxx SYS TERM THAW TRAP TSTP TTIN TTOU URG USR1 USR2" xxx="$xxx USR3 USR4 VTALRM WAITING WINCH WIND WINDOW XCPU XFSZ" : generate a few handy files for later $cat > signal.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include int main() { /* Strange style to avoid deeply-nested #if/#else/#endif */ #ifndef NSIG # ifdef _NSIG # define NSIG (_NSIG) # endif #endif #ifndef NSIG # ifdef SIGMAX # define NSIG (SIGMAX+1) # endif #endif #ifndef NSIG # ifdef SIG_MAX # define NSIG (SIG_MAX+1) # endif #endif #ifndef NSIG # ifdef _SIG_MAX # define NSIG (_SIG_MAX+1) # endif #endif #ifndef NSIG # ifdef MAXSIG # define NSIG (MAXSIG+1) # endif #endif #ifndef NSIG # ifdef MAX_SIG # define NSIG (MAX_SIG+1) # endif #endif #ifndef NSIG # ifdef SIGARRAYSIZE # define NSIG SIGARRAYSIZE /* Assume ary[SIGARRAYSIZE] */ # endif #endif #ifndef NSIG # ifdef _sys_nsig # define NSIG (_sys_nsig) /* Solaris 2.5 */ # endif #endif /* Default to some arbitrary number that's big enough to get most of the common signals. */ #ifndef NSIG # define NSIG 50 #endif printf("NSIG %d\n", NSIG); #ifndef JUST_NSIG EOCP echo $xxx | $tr ' ' $trnl | $sort | $uniq | $awk ' { printf "#ifdef SIG"; printf $1; printf "\n" printf "printf(\""; printf $1; printf " %%d\\n\",SIG"; printf $1; printf ");\n" printf "#endif\n" } END { printf "#endif /* JUST_NSIG */\n"; printf "exit(0);\n}\n"; } ' >>signal.c $cat >signal.awk <<'EOP' BEGIN { ndups = 0 } $1 ~ /^NSIG$/ { nsig = $2 } ($1 !~ /^NSIG$/) && (NF == 2) && ($2 ~ /^[0-9][0-9]*$/) { if ($2 > maxsig) { maxsig = $2 } if (sig_name[$2]) { dup_name[ndups] = $1 dup_num[ndups] = $2 ndups++ } else { sig_name[$2] = $1 sig_num[$2] = $2 } } END { if (nsig == 0) { nsig = maxsig + 1 } printf("NSIG %d\n", nsig); for (n = 1; n < nsig; n++) { if (sig_name[n]) { printf("%s %d\n", sig_name[n], sig_num[n]) } else { printf("NUM%d %d\n", n, n) } } for (n = 0; n < ndups; n++) { printf("%s %d\n", dup_name[n], dup_num[n]) } } EOP $cat >signal_cmd <>signal_cmd <<'EOS' set signal if eval $compile_ok; then $run ./signal$_exe | ($sort -n -k 2 2>/dev/null || $sort -n +1) |\ $uniq | $awk -f signal.awk >signal.lst else echo "(I can't seem be able to compile the whole test program)" >&4 echo "(I'll try it in little pieces.)" >&4 set signal -DJUST_NSIG if eval $compile_ok; then $run ./signal$_exe > signal.nsg $cat signal.nsg else echo "I can't seem to figure out how many signals you have." >&4 echo "Guessing 50." >&4 echo 'NSIG 50' > signal.nsg fi : Now look at all the signal names, one at a time. for xx in `echo $xxx | $tr ' ' $trnl | $sort | $uniq`; do $cat > signal.c < #include #include int main() { printf("$xx %d\n", SIG${xx}); return 0; } EOCP set signal if eval $compile; then echo "SIG${xx} found." $run ./signal$_exe >> signal.ls1 else echo "SIG${xx} NOT found." fi done if $test -s signal.ls1; then $cat signal.nsg signal.ls1 | $sort -n | $uniq | $awk -f signal.awk >signal.lst fi fi if $test -s signal.lst; then : else echo "(AAK! I can't compile the test programs -- Guessing)" >&4 echo 'kill -l' >signal set X `csh -f signal.lst fi $rm -f signal.c signal$_exe signal$_o signal.nsg signal.ls1 EOS chmod a+x signal_cmd $eunicefix signal_cmd ;; esac metaconfig-debian-perl-5.26.1/U/modified/Tr.U000066400000000000000000000061451316016665300206150ustar00rootroot00000000000000?RCS: $Id: Tr.U,v 3.0.1.2 1994/10/29 18:00:54 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: Tr.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 18:00:54 ram ?RCS: patch43: forgot to quote $@ to protect against "evil" characters ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:58:35 ram ?RCS: patch36: created ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in in order ?X: to do a character translation. It catches translations to uppercase or ?X: to lowercase, and then invokes the real tr to perform the job. ?X: ?X: This unit is necessary on HP machines (HP strikes again!) with non-ascii ?X: ROMAN8-charset, where normal letters are not arranged in a row, so a-z ?X: covers not the whole alphabet but lots of special chars. This was reported ?X: by Andreas Sahlbach . ?X: ?X: Units performing a tr '[A-Z]' '[a-z]' or the other way round should include ?X: us in their dependency and use ./tr instead. ?X: ?MAKE:Tr: startsh tr eunicefix ?MAKE: -pick add $@ %< ?F:./tr ?T:up low : see whether [:lower:] and [:upper:] are supported character classes echo " " case "`echo AbyZ | $tr '[:lower:]' '[:upper:]' 2>/dev/null`"-"`echo AbyZ | $tr '[:upper:]' '[:lower:]' 2>/dev/null`" in ABYZ-abyz) echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4 up='[:upper:]' low='[:lower:]' ;; *) # There is a discontinuity in EBCDIC between 'R' and 'S' # (0xd9 and 0xe2), therefore that is a nice testing point. if test "X$up" = X -o "X$low" = X; then case "`echo RS | $tr '[R-S]' '[r-s]' 2>/dev/null`" in rs) up='[A-Z]' low='[a-z]' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo RS | $tr R-S r-s 2>/dev/null`" in rs) up='A-Z' low='a-z' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo RS | od -x 2>/dev/null`" in *D9E2*|*d9e2*) echo "Hey, this might be EBCDIC." >&4 if test "X$up" = X -o "X$low" = X; then case "`echo RS | $tr '[A-IJ-RS-Z]' '[a-ij-rs-z]' 2>/dev/null`" in rs) up='[A-IJ-RS-Z]' low='[a-ij-rs-z]' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo RS | $tr A-IJ-RS-Z a-ij-rs-z 2>/dev/null`" in rs) up='A-IJ-RS-Z' low='a-ij-rs-z' ;; esac fi ;; esac fi esac case "`echo RS | $tr \"$up\" \"$low\" 2>/dev/null`" in rs) echo "Using $up and $low to convert case." >&4 ;; *) echo "I don't know how to translate letters from upper to lower case." >&4 echo "Your tr is not acting any way I know of." >&4 exit 1 ;; esac : set up the translation script tr, must be called with ./tr of course cat >tr <whoa $startsh EOS cat <<'EOSC' >>whoa dflt=y case "$hint" in recommended) case "$hintfile" in '') echo "The $hint value for \$$var on this machine was \"$was\"!" >&4 ;; *) echo "Hmm. Based on the hints in hints/$hintfile.sh, " >&4 echo "the $hint value for \$$var on this machine was \"$was\"!" >&4 ;; esac ;; *) echo " " echo "*** WHOA THERE!!! ***" >&4 echo " The $hint value for \$$var on this machine was \"$was\"!" >&4 ;; esac rp=" Keep the $hint value?" . ./myread case "$ans" in y) td=$was; tu=$was;; esac EOSC metaconfig-debian-perl-5.26.1/U/modified/cf_who.U000066400000000000000000000045721316016665300214770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cf_who.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:28:50 ram ?RCS: patch61: new computation method avoiding use of temporary file ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:42:34 ram ?RCS: patch23: login name now computed the hard way ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:32 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Oldconfig dependency is there to ensure computation occurs after old values ?X: from config.sh have been loaded, so that we can supersede them. ?X: ?MAKE:cf_time cf_by: date Oldconfig ?MAKE: -pick add $@ %< ?S:cf_time: ?S: Holds the output of the "date" command when the configuration file was ?S: produced. This is used to tag both config.sh and config_h.SH. ?S:. ?S:cf_by: ?S: Login name of the person who ran the Configure script and answered the ?S: questions. This is used to tag both config.sh and config_h.SH. ?S:. ?LINT:change LC_ALL LANGUAGE : who configured the system ?X: Ensure English date -- Jarkko Hietaniemi cf_time=`LC_ALL=C; LANGUAGE=C; export LC_ALL; export LANGUAGE; $date 2>&1` ?X: ?X: Leave a white space between first two '(' for ksh. The sub-shell is needed ?X: on some machines to avoid the error message when logname is not found; e.g. ?X: on SUN-OS 3.2, (logname || whoami) would not execute whoami if logname was ?X: not found. Sigh! ?X: ?X: Convex had a broken logname executable which returned a non-zero status, ?X: and that broke the previous: ?X: cf_by=`( (logname) 2>/dev/null || whoami) 2>&1` ?X: Switch to emergency mode... -- RAM, 19/04/94 ?X: ?X: Parentheses needed to avoid error message if the program does not exist. ?X: Uses case instead of $test so it can be put before $test is defined. ?X: Don't redirect to a file because on Ultrix (under script?) logname ?X: outputs a blank line first. This method will apparently work. case "$cf_by" in "") cf_by=`(logname) 2>/dev/null` case "$cf_by" in "") cf_by=`(whoami) 2>/dev/null` case "$cf_by" in "") cf_by=unknown ;; esac ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/modified/cpp_stuff.U000066400000000000000000000121451316016665300222160ustar00rootroot00000000000000?RCS: $Id: cpp_stuff.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cpp_stuff.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:08:24 ram ?RCS: patch36: now uses cppstdin instead of plain cpp for consistency (ADO) ?RCS: patch36: remove temporary files when done ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:36 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:cpp_stuff: cat contains cppstdin cppflags cppminus rm ?MAKE: -pick add $@ %< ?S:cpp_stuff: ?S: This variable contains an identification of the concatenation mechanism ?S: used by the C preprocessor. ?S:. ?C:CAT2: ?C: This macro concatenates 2 tokens together. ?C:. ?C:CAT3: ?C: This macro concatenates 3 tokens together. ?C:. ?C:CAT4: ?C: This macro concatenates 4 tokens together. ?C:. ?C:CAT5: ?C: This macro concatenates 5 tokens together. ?C:. ?C:STRINGIFY: ?C: This macro surrounds its token with double quotes. ?C:. ?C:SCAT2: ?C: This macro concatenates 2 tokens together and stringifies the result. ?C: It might not exist, so #ifdef it in your code! ?C:. ?C:SCAT3: ?C: This macro concatenates 3 tokens together and stringifies the result. ?C: It might not exist, so #ifdef it in your code! ?C:. ?C:SCAT4: ?C: This macro concatenates 4 tokens together and stringifies the result. ?C: It might not exist, so #ifdef it in your code! ?C:. ?C:SCAT5: ?C: This macro concatenates 5 tokens together and stringifies the result. ?C: It might not exist, so #ifdef it in your code! ?C:. ?X: Dist pl70 included the following, but AIX's xlc compiler ?X: (which is ANSI-ish and has cpp_stuff == 42)) rejects ?X: The SQuoTe/EQuoTe stuff because the string literals are on ?X: separate lines. Sigh. ?X: Andy Dougherty 24 Feb 1998 ?X: ?H:?%<:#if $cpp_stuff == 1 ?X: ?H:?CAT2:#define CAT2(a,b)a/**/b ?X: ?H:?CAT3:#define CAT3(a,b,c)a/**/b/**/c ?X: ?H:?CAT4:#define CAT4(a,b,c,d)a/**/b/**/c/**/d ?X: ?H:?CAT5:#define CAT5(a,b,c,d,e)a/**/b/**/c/**/d/**/e ?X: ?H:?STRINGIFY:#define STRINGIFY(a)"a" ?X: ?H:?%<:#define SQuoTe(a)"a ?X: ?H:?%<:#define EQuoTe(a)a" ?X: ?H:?SCAT2:#define SCAT2(a,b)EQuoTe(SQuoTe(a)b) ?X: ?H:?SCAT3:#define SCAT3(a,b,c)EQuoTe(SQuoTe(a)b/**/c) ?X: ?H:?SCAT4:#define SCAT4(a,b,c,d)EQuoTe(SQuoTe(a)b/**/c/**/d) ?X: ?H:?SCAT5:#define SCAT5(a,b,c,d,e)EQuoTe(SQuoTe(a)b/**/c/**/d/**/e) ?X: ?H:?%<:#endif ?H:?%<:#if $cpp_stuff == 1 ?H:?CAT2:#define CAT2(a,b) a/**/b ?H:?CAT3:#define CAT3(a,b,c) a/**/b/**/c ?H:?CAT4:#define CAT4(a,b,c,d) a/**/b/**/c/**/d ?H:?CAT5:#define CAT5(a,b,c,d,e) a/**/b/**/c/**/d/**/e ?H:?STRINGIFY:#define STRINGIFY(a) "a" ?X: If you can get stringification with catify, tell me how! ?H:?%<:#endif ?H:?%<:#if $cpp_stuff == 42 ?H:?%<:#define PeRl_CaTiFy(a, b) a ## b ?H:?%<:#define PeRl_StGiFy(a) #a ?X: The additional level of indirection enables these macros to be ?X: used as arguments to other macros. See K&R 2nd ed., page 231. ?H:?CAT2:#define CAT2(a,b) PeRl_CaTiFy(a,b) ?H:?CAT3:#define CAT3(a,b,c) CAT2(PeRl_CaTiFy(a,b),c) ?H:?CAT4:#define CAT4(a,b,c,d) CAT2(CAT3(a,b,c),d) ?H:?CAT5:#define CAT5(a,b,c,d,e) CAT2(CAT4(a,b,c,d),e) ?H:?%<:#define StGiFy(a) PeRl_StGiFy(a) ?H:?STRINGIFY:#define STRINGIFY(a) PeRl_StGiFy(a) ?H:?SCAT2:#define SCAT2(a,b) PeRl_StGiFy(a) PeRl_StGiFy(b) ?H:?SCAT3:#define SCAT3(a,b,c) PeRl_StGiFy(a) PeRl_StGiFy(b) PeRl_StGiFy(c) ?H:?SCAT4:#define SCAT4(a,b,c,d) PeRl_StGiFy(a) PeRl_StGiFy(b) PeRl_StGiFy(c) PeRl_StGiFy(d) ?H:?SCAT5:#define SCAT5(a,b,c,d,e) PeRl_StGiFy(a) PeRl_StGiFy(b) PeRl_StGiFy(c) PeRl_StGiFy(d) PeRl_StGiFy(e) ?H:?%<:#endif ?H:?%<:#if $cpp_stuff != 1 && $cpp_stuff != 42 ?H:?%<:#include "Bletch: How does this C preprocessor concatenate tokens?" ?H:?%<:#endif ?H:. ?W:%<:CAT2 CAT3 CAT4 CAT5 STRINGIFY SCAT2 SCAT3 SCAT4 SCAT5 ?F:!cpp_stuff.c ?LINT:known StGiFy ?LINT:known PeRl_CaTiFy ?LINT:known PeRl_StGiFy : how do we concatenate cpp tokens here? echo " " echo "Checking to see how your cpp does stuff like concatenate tokens..." >&4 $cat >cpp_stuff.c <<'EOCP' #define RCAT(a,b)a/**/b #define ACAT(a,b)a ## b RCAT(Rei,ser) ACAT(Cir,cus) EOCP $cppstdin $cppflags $cppminus cpp_stuff.out 2>&1 if $contains 'Circus' cpp_stuff.out >/dev/null 2>&1; then echo "Oh! Smells like ANSI's been here." >&4 echo "We can catify or stringify, separately or together!" cpp_stuff=42 elif $contains 'Reiser' cpp_stuff.out >/dev/null 2>&1; then echo "Ah, yes! The good old days!" >&4 echo "However, in the good old days we don't know how to stringify and" echo "catify at the same time." cpp_stuff=1 else $cat >&4 <&4 cat <<'EOT' >testcpp.c #define ABC abc #define XYZ xyz ABC.XYZ EOT cd .. if test ! -f cppstdin; then if test "X$osname" = "Xaix" -a "X$gccversion" = X; then # AIX cc -E doesn't show the absolute headerfile # locations but we'll cheat by using the -M flag. echo 'cat >.$$.c; rm -f .$$.u; '"$cc"' ${1+"$@"} -M -c .$$.c 2>/dev/null; test -s .$$.u && awk '"'"'$2 ~ /\.h$/ { print "# 0 \""$2"\"" }'"'"' .$$.u; rm -f .$$.o .$$.u; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' > cppstdin else echo 'cat >.$$.c; '"$cc $cppflags"' -E ${1+"$@"} .$$.c; rm .$$.c' >cppstdin fi else echo "Keeping your $hint cppstdin wrapper." fi chmod 755 cppstdin wrapper=`pwd`/cppstdin ok='false' cd UU ?X: ?X: We'll run the cpp tests again if we don't have any valid C preprocessor ?X: yet or don't know how to proceed without a wrapper (in which case cpprun ?X: is empty and that's really annoying...) ?X: if $test "X$cppstdin" != "X" && \ $cppstdin $cppminus testcpp.out 2>&1 && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "You used to use $cppstdin $cppminus so we'll use that again." case "$cpprun" in '') echo "But let's see if we can live without a wrapper..." ;; *) if $cpprun $cpplast testcpp.out 2>&1 && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "(And we'll use $cpprun $cpplast to preprocess directly.)" ok='true' else echo "(However, $cpprun $cpplast does not work, let's see...)" fi ;; esac else case "$cppstdin" in '') ;; *) echo "Good old $cppstdin $cppminus does not seem to be of any help..." ;; esac fi if $ok; then : nothing elif echo 'Maybe "'"$cc"' -E" will work...'; \ $cc -E testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yup, it does." x_cpp="$cc $cppflags -E" x_minus=''; elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \ $cc -E - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yup, it does." x_cpp="$cc $cppflags -E" x_minus='-'; elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \ $cc -P testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yipee, that works!" x_cpp="$cc $cppflags -P" x_minus=''; elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \ $cc -P - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "At long last!" x_cpp="$cc $cppflags -P" x_minus='-'; elif echo 'No such luck, maybe "'$cpp'" will work...'; \ $cpp testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "It works!" x_cpp="$cpp $cppflags" x_minus=''; elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \ $cpp - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Hooray, it works! I was beginning to wonder." x_cpp="$cpp $cppflags" x_minus='-'; elif echo 'Uh-uh. Time to get fancy. Trying a wrapper...'; \ $wrapper testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then x_cpp="$wrapper" x_minus='' echo "Eureka!" else dflt='' rp="No dice. I can't find a C preprocessor. Name one:" . ./myread x_cpp="$ans" x_minus='' $x_cpp testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "OK, that will do." >&4 else echo "Sorry, I can't get that to work. Go find one and rerun Configure." >&4 exit 1 fi fi case "$ok" in false) cppstdin="$x_cpp" cppminus="$x_minus" cpprun="$x_cpp" cpplast="$x_minus" ?X: ?X: If /lib/cpp is used, try using a wrapper to increase our chances to have ?X: the C compiler and our $cppstdin agree on the same symbols... However, ?X: since cpprun is guaranteed not to be a wrapper, we must clear it if the ?X: only preprocessor we found was a wrapper, with all our luck... ?X: set X $x_cpp shift case "$1" in "$cpp") echo "Perhaps can we force $cc -E using a wrapper..." if $wrapper testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "Yup, we can." cppstdin="$wrapper" cppminus=''; else echo "Nope, we'll have to live without it..." fi ;; esac case "$cpprun" in "$wrapper") cpprun='' cpplast='' ;; esac ;; esac case "$cppstdin" in "$wrapper"|'cppstdin') ;; *) $rm -f $wrapper;; esac $rm -f testcpp.c testcpp.out metaconfig-debian-perl-5.26.1/U/modified/d_access.U000066400000000000000000000043601316016665300217710ustar00rootroot00000000000000?RCS: $Id: d_access.U,v 3.0 1993/08/18 12:05:42 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_access.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:42 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_access: test +cc cat +cppflags h_fcntl h_sysfile i_stdlib rm Inlibc Findhdr ?MAKE: -pick add $@ %< ?S:d_access: ?S: This variable conditionally defines HAS_ACCESS if the access() system ?S: call is available to check for access permissions using real IDs. ?S:. ?C:HAS_ACCESS: ?C: This manifest constant lets the C program know that the access() ?C: system call is available to check for accessibility using real UID/GID. ?C: (always present on UNIX.) ?C:. ?H:#$d_access HAS_ACCESS /**/ ?H:. ?W:%<:R_OK W_OK X_OK F_OK ?LINT:set d_access ?LINT:change h_fcntl h_sysfile : access call always available on UNIX set access d_access eval $inlibc : locate the flags for 'access()' case "$d_access" in "$define") echo " " $cat >access.c < #ifdef I_FCNTL #include #endif #ifdef I_SYS_FILE #include #endif #ifdef I_UNISTD #include #endif #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { exit(R_OK); } EOCP : check sys/file.h first, no particular reason here if $test `./findhdr sys/file.h` && \ $cc -o access $cppflags -DI_SYS_FILE access.c >/dev/null 2>&1 ; then h_sysfile=true; echo " defines the *_OK access constants." >&4 elif $test `./findhdr fcntl.h` && \ $cc -o access $cppflags -DI_FCNTL access.c >/dev/null 2>&1 ; then h_fcntl=true; echo " defines the *_OK access constants." >&4 @if I_UNISTD elif $test `./findhdr unistd.h` && \ $cc -o access $cppflags -DI_UNISTD access.c >/dev/null 2>&1 ; then echo " defines the *_OK access constants." >&4 @end else echo "I can't find the four *_OK access constants--I'll use mine." >&4 fi ;; esac $rm -f access* metaconfig-debian-perl-5.26.1/U/modified/d_attribut.U000066400000000000000000000275421316016665300223750ustar00rootroot00000000000000?RCS: $Id: d_attribut.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_attribut.U,v $ ?RCS: Revision 3.0.1.3 1995/01/30 14:33:45 ram ?RCS: patch49: test C program now includes (WED) ?RCS: ?RCS: Revision 3.0.1.2 1995/01/11 15:25:47 ram ?RCS: patch45: fixed typo in the d_attribut variable (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:08:55 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_attribute_deprecated d_attribute_format d_attribute_malloc \ d_attribute_nonnull d_attribute_noreturn d_attribute_pure \ d_attribute_unused d_attribute_warn_unused_result \ d_printf_format_null: \ Myread Oldconfig cat cc ccflags rm Setvar contains i_stdlib run ?MAKE: -pick add $@ %< ?S:d_attribute_format: ?S: This variable conditionally defines HASATTRIBUTE_FORMAT, which ?S: indicates the C compiler can check for printf-like formats. ?S:. ?S:d_attribute_deprecated: ?S: This variable conditionally defines HASATTRIBUTE_DEPRECATED, which ?S: indicates that GCC can handle the attribute for marking deprecated ?S: APIs ?S:. ?S:d_printf_format_null: ?S: This variable conditionally defines PRINTF_FORMAT_NULL_OK, which ?S: indicates the C compiler allows printf-like formats to be null. ?S:. ?S:d_attribute_malloc: ?S: This variable conditionally defines HASATTRIBUTE_MALLOC, which ?S: indicates the C compiler can understand functions as having ?S: malloc-like semantics. ?S:. ?S:d_attribute_nonnull: ?S: This variable conditionally defines HASATTRIBUTE_NONNULL, which ?S: indicates that the C compiler can know that certain arguments ?S: must not be NULL, and will check accordingly at compile time. ?S:. ?S:d_attribute_noreturn: ?S: This variable conditionally defines HASATTRIBUTE_NORETURN, which ?S: indicates that the C compiler can know that certain functions ?S: are guaranteed never to return. ?S:. ?S:d_attribute_pure: ?S: This variable conditionally defines HASATTRIBUTE_PURE, which ?S: indicates that the C compiler can know that certain functions ?S: are "pure" functions, meaning that they have no side effects, and ?S: only rely on function input and/or global data for their results. ?S:. ?S:d_attribute_unused: ?S: This variable conditionally defines HASATTRIBUTE_UNUSED, which ?S: indicates that the C compiler can know that certain variables ?S: and arguments may not always be used, and to not throw warnings ?S: if they don't get used. ?S:. ?S:d_attribute_warn_unused_result: ?S: This variable conditionally defines ?S: HASATTRIBUTE_WARN_UNUSED_RESULT, which indicates that the C ?S: compiler can know that certain functions have a return values ?S: that must not be ignored, such as malloc() or open(). ?S:. ?C:HASATTRIBUTE_FORMAT ~ %< (GNUC_ATTRIBUTE_CHECK): ?C: Can we handle GCC attribute for checking printf-style formats ?C:. ?C:PRINTF_FORMAT_NULL_OK: ?C: Allows __printf__ format to be null when checking printf-style ?C:. ?C:HASATTRIBUTE_MALLOC: ?C: Can we handle GCC attribute for malloc-style functions. ?C:. ?C:HASATTRIBUTE_NONNULL: ?C: Can we handle GCC attribute for nonnull function parms. ?C:. ?C:HASATTRIBUTE_NORETURN: ?C: Can we handle GCC attribute for functions that do not return ?C:. ?C:HASATTRIBUTE_PURE: ?C: Can we handle GCC attribute for pure functions ?C:. ?C:HASATTRIBUTE_UNUSED: ?C: Can we handle GCC attribute for unused variables and arguments ?C:. ?C:HASATTRIBUTE_DEPRECATED: ?C: Can we handle GCC attribute for marking deprecated APIs ?C:. ?C:HASATTRIBUTE_WARN_UNUSED_RESULT ~ %< (HASATTRIBUTE): ?C: Can we handle GCC attribute for warning on unused results ?C:. ?H:?%<:#$d_attribute_deprecated HASATTRIBUTE_DEPRECATED /**/ ?H:?%<:#$d_attribute_format HASATTRIBUTE_FORMAT /**/ ?H:?%<:#$d_printf_format_null PRINTF_FORMAT_NULL_OK /**/ ?H:?%<:#$d_attribute_noreturn HASATTRIBUTE_NORETURN /**/ ?H:?%<:#$d_attribute_malloc HASATTRIBUTE_MALLOC /**/ ?H:?%<:#$d_attribute_nonnull HASATTRIBUTE_NONNULL /**/ ?H:?%<:#$d_attribute_pure HASATTRIBUTE_PURE /**/ ?H:?%<:#$d_attribute_unused HASATTRIBUTE_UNUSED /**/ ?H:?%<:#$d_attribute_warn_unused_result HASATTRIBUTE_WARN_UNUSED_RESULT /**/ ?H:. ?F:!attrib !attrib.out !attrib.c ?LINT:set d_attribute_deprecated ?LINT:set d_attribute_format ?LINT:set d_printf_format_null ?LINT:set d_attribute_malloc ?LINT:set d_attribute_nonnull ?LINT:set d_attribute_noreturn ?LINT:set d_attribute_pure ?LINT:set d_attribute_unused ?LINT:set d_attribute_warn_unused_result : Look for GCC-style attribute format case "$d_attribute_format" in '') echo " " echo "Checking whether your compiler can handle __attribute__((format)) ..." >&4 $cat >attrib.c <<'EOCP' #include void my_special_printf(char* pat,...) __attribute__((__format__(__printf__,1,2))); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((format))." val="$undef" else echo "Your C compiler supports __attribute__((format))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_format" ;; esac set d_attribute_format eval $setvar $rm -f attrib* : Look for GCC-style attribute format with null format allowed case "$d_printf_format_null" in '') case "$d_attribute_format" in $define) echo " " echo "Checking whether your compiler allows __printf__ format to be null ..." >&4 $cat >attrib.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int null_printf (char* pat,...) __attribute__((__format__(__printf__,1,2))); int null_printf (char* pat,...) { return (int)pat; } int main () { exit(null_printf(NULL)); } EOCP if $cc $ccflags -o attrib attrib.c >attrib.out 2>&1 ; then : run the executable in case it produces a run-time warning if $run ./attrib >>attrib.out 2>&1; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't allow __printf__ format to be null." val="$undef" else echo "Your C compiler allows __printf__ format to be null." val="$define" fi else echo "Your C compiler executable failed with __printf__ format null." val="$undef" fi else echo "Your C compiler fails with __printf__ format null." val="$undef" fi ;; *) val="$undef" ;; esac ;; *) val="$d_printf_format_null" ;; esac set d_printf_format_null eval $setvar $rm -f attrib* : Look for GCC-style attribute malloc case "$d_attribute_malloc" in '') echo " " echo "Checking whether your compiler can handle __attribute__((malloc)) ..." >&4 $cat >attrib.c <<'EOCP' #include char *go_get_some_memory( int how_many_bytes ) __attribute__((malloc)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((malloc))." val="$undef" else echo "Your C compiler supports __attribute__((malloc))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_malloc" ;; esac set d_attribute_malloc eval $setvar $rm -f attrib* : Look for GCC-style attribute nonnull case "$d_attribute_nonnull" in '') echo " " echo "Checking whether your compiler can handle __attribute__((nonnull(1))) ..." >&4 $cat >attrib.c <<'EOCP' #include void do_something (char *some_pointer,...) __attribute__((nonnull(1))); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((nonnull))." val="$undef" else echo "Your C compiler supports __attribute__((nonnull))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_nonnull" ;; esac set d_attribute_nonnull eval $setvar $rm -f attrib* : Look for GCC-style attribute noreturn case "$d_attribute_noreturn" in '') echo " " echo "Checking whether your compiler can handle __attribute__((noreturn)) ..." >&4 $cat >attrib.c <<'EOCP' #include void fall_over_dead( void ) __attribute__((noreturn)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((noreturn))." val="$undef" else echo "Your C compiler supports __attribute__((noreturn))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_noreturn" ;; esac set d_attribute_noreturn eval $setvar $rm -f attrib* : Look for GCC-style attribute pure case "$d_attribute_pure" in '') echo " " echo "Checking whether your compiler can handle __attribute__((pure)) ..." >&4 $cat >attrib.c <<'EOCP' #include int square( int n ) __attribute__((pure)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((pure))." val="$undef" else echo "Your C compiler supports __attribute__((pure))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_pure" ;; esac set d_attribute_pure eval $setvar $rm -f attrib* : Look for GCC-style attribute unused case "$d_attribute_unused" in '') echo " " echo "Checking whether your compiler can handle __attribute__((unused)) ..." >&4 $cat >attrib.c <<'EOCP' #include int do_something( int dummy __attribute__((unused)), int n ); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((unused))." val="$undef" else echo "Your C compiler supports __attribute__((unused))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_unused" ;; esac set d_attribute_unused eval $setvar $rm -f attrib* : Look for GCC-style attribute deprecated case "$d_attribute_deprecated" in '') echo " " echo "Checking whether your compiler can handle __attribute__((deprecated)) ..." >&4 $cat >attrib.c <<'EOCP' #include int I_am_deprecated(void) __attribute__((deprecated)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((deprecated))." val="$undef" else echo "Your C compiler supports __attribute__((deprecated))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_deprecated" ;; esac set d_attribute_deprecated eval $setvar $rm -f attrib* : Look for GCC-style attribute warn_unused_result case "$d_attribute_warn_unused_result" in '') echo " " echo "Checking whether your compiler can handle __attribute__((warn_unused_result)) ..." >&4 $cat >attrib.c <<'EOCP' #include int I_will_not_be_ignored(void) __attribute__((warn_unused_result)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't support __attribute__((warn_unused_result))." val="$undef" else echo "Your C compiler supports __attribute__((warn_unused_result))." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi ;; *) val="$d_attribute_warn_unused_result" ;; esac set d_attribute_warn_unused_result eval $setvar $rm -f attrib* metaconfig-debian-perl-5.26.1/U/modified/d_backtrace.U000066400000000000000000000017541316016665300224530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2014, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_backtrace.U,v $ ?RCS: ?MAKE:d_backtrace: Inlibc ?MAKE: -pick add $@ %< ?S:d_backtrace: ?S: This variable conditionally defines the HAS_BACKTRACE symbol, which ?S: indicates to the C program that the backtrace() routine is available ?S: to get a stack trace. ?S:. ?C:HAS_BACKTRACE: ?C: This symbol, if defined, indicates that the backtrace() routine is ?C: available to get a stack trace. The header must be ?C: included to use this routine. ?C:. ?H:#$d_backtrace HAS_BACKTRACE /**/ ?H:. ?LINT:set d_backtrace : see if backtrace exists set backtrace d_backtrace eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_const.U000066400000000000000000000037741316016665300216660ustar00rootroot00000000000000?RCS: $Id: d_const.U,v 3.0.1.1 1993/11/10 17:33:41 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_const.U,v $ ?RCS: Revision 3.0.1.1 1993/11/10 17:33:41 ram ?RCS: patch14: stronger const check with added typedef for MIPS cc ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:51 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_const: cat cc ccflags Setvar ?MAKE: -pick add $@ %< ?S:d_const: ?S: This variable conditionally defines the HASCONST symbol, which ?S: indicates to the C program that this C compiler knows about the ?S: const type. ?S:. ?C:HASCONST ~ %<: ?C: This symbol, if defined, indicates that this C compiler knows about ?C: the const type. There is no need to actually test for that symbol ?C: within your programs. The mere use of the "const" keyword will ?C: trigger the necessary tests. ?C:. ?H:?%<:#$d_const HASCONST /**/ ?H:?%<:#ifndef HASCONST ?H:?%<:#define const ?H:?%<:#endif ?H:. ?W:%<:const ?LINT:set d_const ?LINT:known const : check for const keyword echo " " echo 'Checking to see if your C compiler knows about "const"...' >&4 $cat >const.c <<'EOCP' ?X: mmcg@bruce.cs.monash.edu.au reports that: ?X: The MIPS cc compiler (V2.10) on a dec 5000 running Ultrix 4.2A ?X: pretends to understand `const' but doesn't - it'll also fail to ?X: handle typedefs properly if they're declared const. To guard ?X: against this, boost up the test by using an explicit typedef... typedef struct spug { int drokk; } spug; int main() { const char *foo; const spug y = { 0 }; } EOCP if $cc -c $ccflags const.c >/dev/null 2>&1 ; then val="$define" echo "Yup, it does." else val="$undef" echo "Nope, it doesn't." fi set d_const eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_csh.U000066400000000000000000000043571316016665300213130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_csh.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:32:18 ram ?RCS: patch61: added full_csh to preserve the full path even when portable ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:53 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_csh full_csh: csh Setvar ?MAKE: -pick add $@ %< ?S:d_csh: ?S: This variable conditionally defines the CSH symbol, which ?S: indicates to the C program that the C-shell exists. ?S:. ?S:full_csh: ?S: This variable contains the full pathname to 'csh', whether or ?S: not the user has specified 'portability'. This is only used ?S: in the compiled C program, and we assume that all systems which ?S: can share this executable will have the same full pathname to ?S: 'csh.' ?S:. ?X: Yes, I know about the C symbol PORTABLE, but I think csh ?X: is unlikely to move, and I'm too lazy to add all the ?X: #ifdef PORTABLE sections to the perl source. ?X: ?C:HAS_CSH: ?C: This symbol, if defined, indicates that the C-shell exists. ?C:. ?C:CSH: ?C: This symbol, if defined, contains the full pathname of csh. ?C:. ?X: Previously, I just did $d_csh CSH "$full_csh", but that caused ?X: problems on VMS where the config.sh extraction program changes ?X: $undef to a real cpp undef, and they then had #undef CSH "" ?X: which the compiler didn't like. It's easy to work around this, ?X: so I did. --AD 3/1998. ?X: And we don't want to define CSH if !HAS_CSH, but we don't want ?X: those lines in config.h if they don't need CSH, so protect with ?CSH ?X: and not ?%<. --RAM, 15/02/2004 ?H:?%<:#$d_csh HAS_CSH /**/ ?H:?CSH:#ifdef HAS_CSH ?H:?CSH:#define CSH "$full_csh" /**/ ?H:?CSH:#endif ?H:. ?LINT:set d_csh : get csh whereabouts case "$csh" in 'csh') val="$undef" ;; *) val="$define" ;; esac set d_csh eval $setvar : Respect a hint or command line value for full_csh. case "$full_csh" in '') full_csh=$csh ;; esac metaconfig-debian-perl-5.26.1/U/modified/d_dladdr.U000066400000000000000000000017371316016665300217670ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2014, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_dladdr.U,v $ ?RCS: ?MAKE:d_dladdr: Inlibc ?MAKE: -pick add $@ %< ?S:d_dladdr: ?S: This variable conditionally defines the HAS_DLADDR symbol, which ?S: indicates to the C program that the dladdr() routine is available ?S: to get a stack trace. ?S:. ?C:HAS_DLADDR: ?C: This symbol, if defined, indicates that the dladdr() routine is ?C: available to query dynamic linker information for an address. ?C: The header must be included to use this routine. ?C:. ?H:#$d_dladdr HAS_DLADDR /**/ ?H:. ?LINT:set d_dladdr : see if dladdr exists set dladdr d_dladdr eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_dlopen.U000066400000000000000000000035201316016665300220060ustar00rootroot00000000000000?RCS: $Id: d_dlopen.U,v 3.0.1.2 1995/07/25 13:52:56 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_dlopen.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 13:52:56 ram ?RCS: patch56: force compile-link test since symbol might lie in crt0.o (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:34 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_dlopen: Inlibc runnm d_cplusplus ccflags gccversion ?MAKE: -pick add $@ %< ?S:d_dlopen: ?S: This variable conditionally defines the HAS_DLOPEN symbol, which ?S: indicates to the C program that the dlopen() routine is available. ?S:. ?C:HAS_DLOPEN : ?C: This symbol, if defined, indicates that the dlopen routine is ?C: available. ?C:. ?H:#$d_dlopen HAS_DLOPEN /**/ ?H:. ?T: xxx_runnm ?T: xxx_ccflags ?LINT:set d_dlopen ?X: We don't permanently change runnm and ccflags, but we do temporarily. ?LINT: change runnm ?LINT: change ccflags : see if dlopen exists ?X: On NetBSD and FreeBSD, dlopen is available, but it is in ?X: /usr/lib/crt0.o, not in any of the libraries. Therefore, do not ?X: use the nm extraction, but use a real compile and link test instead. xxx_runnm="$runnm" xxx_ccflags="$ccflags" runnm=false : with g++ one needs -shared to get is-in-libc to work for dlopen case "$gccversion" in '') ;; *Clang*) ;; *) case "$d_cplusplus" in "$define") ccflags="$ccflags -shared" ;; esac ;; esac set dlopen d_dlopen eval $inlibc runnm="$xxx_runnm" ccflags="$xxx_ccflags" metaconfig-debian-perl-5.26.1/U/modified/d_dosuid.U000066400000000000000000000126611316016665300220220ustar00rootroot00000000000000?RCS: $Id: d_dosuid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Tye McQueen added safe setuid script checks. ?RCS: ?RCS: $Log: d_dosuid.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:33:03 ram ?RCS: patch61: moved unit to TOP via a ?Y: layout directive ?RCS: patch61: tell them /dev/fd is not about floppy disks ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:12:08 ram ?RCS: patch36: added checks for secure setuid scripts (Tye McQueen) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:55 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_dosuid d_suidsafe: cat contains ls rm test Myread Setvar \ Oldconfig Guess package hint patchlevel ?MAKE: -pick add $@ %< ?S:d_suidsafe: ?S: This variable conditionally defines SETUID_SCRIPTS_ARE_SECURE_NOW ?S: if setuid scripts can be secure. This test looks in /dev/fd/. ?S:. ?S:d_dosuid: ?S: This variable conditionally defines the symbol DOSUID, which ?S: tells the C program that it should insert setuid emulation code ?S: on hosts which have setuid #! scripts disabled. ?S:. ?C:SETUID_SCRIPTS_ARE_SECURE_NOW: ?C: This symbol, if defined, indicates that the bug that prevents ?C: setuid scripts from being secure is not present in this kernel. ?C:. ?C:DOSUID: ?C: This symbol, if defined, indicates that the C program should ?C: check the script that it is executing for setuid/setgid bits, and ?C: attempt to emulate setuid/setgid on systems that have disabled ?C: setuid #! scripts because the kernel can't do it securely. ?C: It is up to the package designer to make sure that this emulation ?C: is done securely. Among other things, it should do an fstat on ?C: the script it just opened to make sure it really is a setuid/setgid ?C: script, it should make sure the arguments passed correspond exactly ?C: to the argument on the #! line, and it should not trust any ?C: subprocesses to which it must pass the filename rather than the ?C: file descriptor of the script to be executed. ?C:. ?H:#$d_suidsafe SETUID_SCRIPTS_ARE_SECURE_NOW /**/ ?H:#$d_dosuid DOSUID /**/ ?H:. ?Y:TOP ?F:!reflect ?LINT: set d_suidsafe : see if setuid scripts can be secure $cat <reflect chmod +x,u+s reflect ./reflect >flect 2>&1 if $contains "/dev/fd" flect >/dev/null; then echo "Congratulations, your kernel has secure setuid scripts!" >&4 val="$define" else $cat <&4 dflt=n;; "$undef") echo "Well, the $hint value is *not* secure." >&4 dflt=n;; *) echo "Well, the $hint value *is* secure." >&4 dflt=y;; esac ;; *) $rm -f reflect flect echo "#!$ls" >reflect chmod +x,u+s reflect echo >flect chmod a+w flect echo '"su" will (probably) prompt you for '"$ans's password." su $ans -c './reflect >flect' if $contains "/dev/fd" flect >/dev/null; then echo "Okay, it looks like setuid scripts are secure." >&4 dflt=y else echo "I don't think setuid scripts are secure." >&4 dflt=n fi ;; esac rp='Does your kernel have *secure* setuid scripts?' . ./myread case "$ans" in [yY]*) val="$define";; *) val="$undef";; esac fi else echo "I don't think setuid scripts are secure (no /dev/fd directory)." >&4 echo "(That's for file descriptors, not floppy disks.)" val="$undef" fi set d_suidsafe eval $setvar $rm -f reflect flect : now see if they want to do setuid emulation if $test $patchlevel -lt 11; then echo " " val="$undef" case "$d_suidsafe" in "$define") val="$undef" echo "No need to emulate SUID scripts since they are secure here." >&4 ;; *) $cat <&4 <$first) 2>/dev/null; then if $test -f 123456789abcde; then echo 'You cannot have filenames longer than 14 characters. Sigh.' >&4 val="$undef" else echo 'You can have filenames longer than 14 characters.'>&4 val="$define" fi else $cat <<'EOM' You can't have filenames longer than 14 chars. You can't even think about them! EOM val="$undef" fi set d_flexfnam eval $setvar $rm -rf 123456789abcde* metaconfig-debian-perl-5.26.1/U/modified/d_getgrent.U000066400000000000000000000014401316016665300223430ustar00rootroot00000000000000?RCS: $Id: d_getgrent.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_getgrent.U,v $ ?RCS: ?MAKE:d_getgrent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getgrent: ?S: This variable conditionally defines the HAS_GETGRENT symbol, which ?S: indicates to the C program that the getgrent() routine is available ?S: for sequential access of the group database. ?S:. ?C:HAS_GETGRENT: ?C: This symbol, if defined, indicates that the getgrent routine is ?C: available for sequential access of the group database. ?C:. ?H:#$d_getgrent HAS_GETGRENT /**/ ?H:. ?LINT:set d_getgrent : see if getgrent exists set getgrent d_getgrent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_gethbyad.U000066400000000000000000000014421316016665300223150ustar00rootroot00000000000000?RCS: $Id: d_gethbyad.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_gethbyaddr: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethbyaddr: ?S: This variable conditionally defines the HAS_GETHOSTBYADDR symbol, which ?S: indicates to the C program that the gethostbyaddr() routine is available ?S: to look up hosts by their IP addresses. ?S:. ?C:HAS_GETHOSTBYADDR: ?C: This symbol, if defined, indicates that the gethostbyaddr() routine is ?C: available to look up hosts by their IP addresses. ?C:. ?H:#$d_gethbyaddr HAS_GETHOSTBYADDR /**/ ?H:. ?LINT:set d_gethbyaddr : see if gethostbyaddr exists set gethostbyaddr d_gethbyaddr eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_gethbynm.U000066400000000000000000000023101316016665300223360ustar00rootroot00000000000000?RCS: $Id: d_gethbynm.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethbynm.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:08 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethbyname: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethbyname (d_gethbynm d_gethhstby): ?S: This variable conditionally defines the HAS_GETHOSTBYNAME symbol, which ?S: indicates to the C program that the gethostbyname() routine is available ?S: to look up host names in some data base or other. ?S:. ?C:HAS_GETHOSTBYNAME (GETHOSTBYNAME): ?C: This symbol, if defined, indicates that the gethostbyname() routine is ?C: available to look up host names in some data base or other. ?C:. ?H:#$d_gethbyname HAS_GETHOSTBYNAME /**/ ?H:. ?LINT:set d_gethbyname : see if gethostbyname exists set gethostbyname d_gethbyname eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_gethent.U000066400000000000000000000020761316016665300221700ustar00rootroot00000000000000?RCS: $Id: d_gethent.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethent: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethent: ?S: This variable conditionally defines HAS_GETHOSTENT if gethostent() is ?S: available to look up host names in some data base or another. ?S:. ?C:HAS_GETHOSTENT: ?C: This symbol, if defined, indicates that the gethostent() routine is ?C: available to look up host names in some data base or another. ?C:. ?H:#$d_gethent HAS_GETHOSTENT /**/ ?H:. ?LINT:set d_gethent : see if gethostent exists set gethostent d_gethent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_gethname.U000066400000000000000000000170351316016665300223230ustar00rootroot00000000000000?RCS: $Id: d_gethname.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethname.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:13:00 ram ?RCS: patch36: call ./xenix explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:11 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethname d_uname d_phostname aphostname: phostname cat \ myhostname package d_portable Loc echo n c +i_whoami +usrinc \ Myread Guess Oldconfig Csym ?MAKE: -pick add $@ %< ?S:d_gethname: ?S: This variable conditionally defines the HAS_GETHOSTNAME symbol, which ?S: indicates to the C program that the gethostname() routine may be ?S: used to derive the host name. ?S:. ?S:d_uname: ?S: This variable conditionally defines the HAS_UNAME symbol, which ?S: indicates to the C program that the uname() routine may be ?S: used to derive the host name. ?S:. ?S:d_phostname: ?S: This variable conditionally defines the HAS_PHOSTNAME symbol, which ?S: contains the shell command which, when fed to popen(), may be ?S: used to derive the host name. ?S:. ?S:aphostname: ?S: This variable contains the command which can be used to compute the ?S: host name. The command is fully qualified by its absolute path, to make ?S: it safe when used by a process with super-user privileges. ?S:. ?C:HAS_GETHOSTNAME (GETHOSTNAME): ?C: This symbol, if defined, indicates that the C program may use the ?C: gethostname() routine to derive the host name. See also HAS_UNAME ?C: and PHOSTNAME. ?C:. ?C:HAS_UNAME (UNAME): ?C: This symbol, if defined, indicates that the C program may use the ?C: uname() routine to derive the host name. See also HAS_GETHOSTNAME ?C: and PHOSTNAME. ?C:. ?C:PHOSTNAME: ?C: This symbol, if defined, indicates the command to feed to the ?C: popen() routine to derive the host name. See also HAS_GETHOSTNAME ?C: and HAS_UNAME. Note that the command uses a fully qualified path, ?C: so that it is safe even if used by a process with super-user ?C: privileges. ?C:. ?C:HAS_PHOSTNAME: ?C: This symbol, if defined, indicates that the C program may use the ?C: contents of PHOSTNAME as a command to feed to the popen() routine ?C: to derive the host name. ?C:. ?H:?%<:#$d_gethname HAS_GETHOSTNAME /**/ ?H:?%<:#$d_uname HAS_UNAME /**/ ?H:?%<:#$d_phostname HAS_PHOSTNAME /**/ ?H:?%<:#ifdef HAS_PHOSTNAME ?H:?%<:#define PHOSTNAME "$aphostname" /* How to get the host name */ ?H:?%<:#endif ?H:. ?T:file val call ?LINT:change i_whoami : see how we will look up host name echo " " call='' @if HAS_GETHOSTNAME if set gethostname val -f d_gethname; eval $csym; $val; then echo 'gethostname() found.' >&4 d_gethname="$define" call=gethostname fi @end @if HAS_UNAME if set uname val -f d_uname; eval $csym; $val; then if ./xenix; then $cat <<'EOM' uname() was found, but you're running xenix, and older versions of xenix have a broken uname(). If you don't really know whether your xenix is old enough to have a broken system call, use the default answer. EOM dflt=y case "$d_uname" in "$define") dflt=n;; esac rp='Is your uname() broken?' . ./myread case "$ans" in n*) d_uname="$define"; call=uname;; esac else echo 'uname() found.' >&4 d_uname="$define" case "$call" in '') call=uname ;; esac fi fi @end case "$d_gethname" in '') d_gethname="$undef";; esac case "$d_uname" in '') d_uname="$undef";; esac @if PHOSTNAME || MYHOSTNAME case "$d_uname$d_gethname" in *define*) dflt=n cat <&4;; @ end esac;; esac @elsif PHOSTNAME case "$d_uname$d_gethname" in *define*) ;; *) case "$phostname" in '') @ if WHOAMI case "$i_whoami" in "$define") $cat <&4;; esac;; @ else echo "There will be no way for $package to get your hostname." >&4;; @ end *) echo "I'll use 'popen("'"'$aphostname'", "r")'"' to get your hostname." >&4 ;; esac;; esac @elsif MYHOSTNAME case "$d_uname$d_gethname" in *define*) ;; *) @ if WHOAMI case "$i_whoami" in "$define") dflt=y $cat <&4;; esac;; @ else echo 'Hardwiring "'$myhostname'".' >&4;; @ end esac @end case "$d_phostname" in '') d_phostname="$undef";; esac metaconfig-debian-perl-5.26.1/U/modified/d_getnbyad.U000066400000000000000000000014411316016665300223220ustar00rootroot00000000000000?RCS: $Id: d_getnbyad.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getnbyaddr: Inlibc ?MAKE: -pick add $@ %< ?S:d_getnbyaddr: ?S: This variable conditionally defines the HAS_GETNETBYADDR symbol, which ?S: indicates to the C program that the getnetbyaddr() routine is available ?S: to look up networks by their IP addresses. ?S:. ?C:HAS_GETNETBYADDR: ?C: This symbol, if defined, indicates that the getnetbyaddr() routine is ?C: available to look up networks by their IP addresses. ?C:. ?H:#$d_getnbyaddr HAS_GETNETBYADDR /**/ ?H:. ?LINT:set d_getnbyaddr : see if getnetbyaddr exists set getnetbyaddr d_getnbyaddr eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getnbynm.U000066400000000000000000000014231316016665300223500ustar00rootroot00000000000000?RCS: $Id: d_getnbyad.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getnbyname: Inlibc ?MAKE: -pick add $@ %< ?S:d_getnbyname: ?S: This variable conditionally defines the HAS_GETNETBYNAME symbol, which ?S: indicates to the C program that the getnetbyname() routine is available ?S: to look up networks by their names. ?S:. ?C:HAS_GETNETBYNAME: ?C: This symbol, if defined, indicates that the getnetbyname() routine is ?C: available to look up networks by their names. ?C:. ?H:#$d_getnbyname HAS_GETNETBYNAME /**/ ?H:. ?LINT:set d_getnbyname : see if getnetbyname exists set getnetbyname d_getnbyname eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getnent.U000066400000000000000000000020631316016665300221720ustar00rootroot00000000000000?RCS: $Id: d_getnent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_getnent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getnent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getnent: ?S: This variable conditionally defines HAS_GETNETENT if getnetent() is ?S: available to look up network names in some data base or another. ?S:. ?C:HAS_GETNETENT: ?C: This symbol, if defined, indicates that the getnetent() routine is ?C: available to look up network names in some data base or another. ?C:. ?H:#$d_getnent HAS_GETNETENT /**/ ?H:. ?LINT:set d_getnent : see if getnetent exists set getnetent d_getnent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getpent.U000066400000000000000000000020711316016665300221730ustar00rootroot00000000000000?RCS: $Id: d_getpent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_getpent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getpent: ?S: This variable conditionally defines HAS_GETPROTOENT if getprotoent() is ?S: available to look up protocols in some data base or another. ?S:. ?C:HAS_GETPROTOENT: ?C: This symbol, if defined, indicates that the getprotoent() routine is ?C: available to look up protocols in some data base or another. ?C:. ?H:#$d_getpent HAS_GETPROTOENT /**/ ?H:. ?LINT:set d_getpent : see if getprotoent exists set getprotoent d_getpent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getpgrp.U000066400000000000000000000056231316016665300222030ustar00rootroot00000000000000?RCS: $Id: d_getpgrp.U,v 3.0.1.1 1997/02/28 15:34:28 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_getpgrp.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:34:28 ram ?RCS: patch61: new USE_BSD_GETPGRP to detect the getpgrp() flavor ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:15 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpgrp d_bsdgetpgrp: Guess Inlibc Setvar cat rm_try \ +cc +ccflags +ldflags +libs i_unistd i_stdlib run ?MAKE: -pick add $@ %< ?S:d_getpgrp: ?S: This variable conditionally defines HAS_GETPGRP if getpgrp() is ?S: available to get the current process group. ?S:. ?S:d_bsdgetpgrp: ?S: This variable conditionally defines USE_BSD_GETPGRP if ?S: getpgrp needs one arguments whereas USG one needs none. ?S:. ?C:HAS_GETPGRP (GETPGRP): ?C: This symbol, if defined, indicates that the getpgrp routine is ?C: available to get the current process group. ?C:. ?C:USE_BSD_GETPGRP: ?C: This symbol, if defined, indicates that getpgrp needs one ?C: arguments whereas USG one needs none. ?C:. ?H:#$d_getpgrp HAS_GETPGRP /**/ ?H:#$d_bsdgetpgrp USE_BSD_GETPGRP /**/ ?H:. ?T:xxx ?F:!try ?LINT:set d_getpgrp d_bsdgetpgrp : see if getpgrp exists set getpgrp d_getpgrp eval $inlibc @if USE_BSD_GETPGRP || d_bsdgetpgrp case "$d_getpgrp" in "$define") echo " " echo "Checking to see which flavor of getpgrp is in use..." $cat >try.c < #ifdef I_UNISTD # include #endif #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { if (getuid() == 0) { printf("(I see you are running Configure as super-user...)\n"); setuid(1); } #ifdef TRY_BSD_PGRP if (getpgrp(1) == 0) exit(0); #else if (getpgrp() > 0) exit(0); #endif exit(1); } EOP if $cc -o try -DTRY_BSD_PGRP $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then echo "You have to use getpgrp(pid) instead of getpgrp()." >&4 val="$define" elif $cc -o try $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then echo "You have to use getpgrp() instead of getpgrp(pid)." >&4 val="$undef" else echo "I can't seem to compile and run the test program." if ./usg; then xxx="a USG one, i.e. you use getpgrp()." else # SVR4 systems can appear rather BSD-ish. case "$i_unistd" in $undef) xxx="a BSD one, i.e. you use getpgrp(pid)." val="$define" ;; $define) xxx="probably a USG one, i.e. you use getpgrp()." val="$undef" ;; esac fi echo "Assuming your getpgrp is $xxx" >&4 fi ;; *) val="$undef";; esac set d_bsdgetpgrp eval $setvar $rm_try @end metaconfig-debian-perl-5.26.1/U/modified/d_getprotby.U000066400000000000000000000027421316016665300225510ustar00rootroot00000000000000?RCS: $Id: d_getprotby.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getpbyname d_getpbynumber: Inlibc ?MAKE: -pick add $@ %< ?S:d_getpbyname: ?S: This variable conditionally defines the HAS_GETPROTOBYNAME ?S: symbol, which indicates to the C program that the ?S: getprotobyname() routine is available to look up protocols ?S: by their name. ?S:. ?S:d_getpbynumber: ?S: This variable conditionally defines the HAS_GETPROTOBYNUMBER ?S: symbol, which indicates to the C program that the ?S: getprotobynumber() routine is available to look up protocols ?S: by their number. ?S:. ?C:HAS_GETPROTOBYNAME: ?C: This symbol, if defined, indicates that the getprotobyname() ?C: routine is available to look up protocols by their name. ?C:. ?C:HAS_GETPROTOBYNUMBER: ?C: This symbol, if defined, indicates that the getprotobynumber() ?C: routine is available to look up protocols by their number. ?C:. ?H:#$d_getpbyname HAS_GETPROTOBYNAME /**/ ?H:#$d_getpbynumber HAS_GETPROTOBYNUMBER /**/ ?H:. ?LINT:set d_getpbyname d_getpbynumber : Optional checks for getprotobyname and getprotobynumber @if d_getpbyname || HAS_GETPROTOBYNAME : see if getprotobyname exists set getprotobyname d_getpbyname eval $inlibc @end @if d_getpbynumber || HAS_GETPROTOBYNUMBER : see if getprotobynumber exists set getprotobynumber d_getpbynumber eval $inlibc @end metaconfig-debian-perl-5.26.1/U/modified/d_getpwent.U000066400000000000000000000015551316016665300223700ustar00rootroot00000000000000?RCS: $Id: d_getpwent.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_getpwent.U,v $ ?RCS: ?MAKE:d_getpwent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getpwent: ?S: This variable conditionally defines the HAS_GETPWENT symbol, which ?S: indicates to the C program that the getpwent() routine is available ?S: for sequential access of the passwd database. ?S:. ?C:HAS_GETPWENT: ?C: This symbol, if defined, indicates that the getpwent routine is ?C: available for sequential access of the passwd database. ?C: If this is not available, the older getpw() function may be available. ?C:. ?H:#$d_getpwent HAS_GETPWENT /**/ ?H:. ?LINT:set d_getpwent : see if getpwent exists set getpwent d_getpwent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getsent.U000066400000000000000000000021001316016665300221670ustar00rootroot00000000000000?RCS: $Id: d_getsent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_getsent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getsent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getsent: ?S: This variable conditionally defines HAS_GETSERVENT if getservent() is ?S: available to look up network services in some data base or another. ?S:. ?C:HAS_GETSERVENT: ?C: This symbol, if defined, indicates that the getservent() routine is ?C: available to look up network services in some data base or another. ?C:. ?H:#$d_getsent HAS_GETSERVENT /**/ ?H:. ?LINT:set d_getsent : see if getservent exists set getservent d_getsent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_getsrvby.U000066400000000000000000000026431316016665300223770ustar00rootroot00000000000000?RCS: $Id: d_getsrvby.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getsbyname d_getsbyport: Inlibc ?MAKE: -pick add $@ %< ?S:d_getsbyname: ?S: This variable conditionally defines the HAS_GETSERVBYNAME ?S: symbol, which indicates to the C program that the ?S: getservbyname() routine is available to look up services ?S: by their name. ?S:. ?S:d_getsbyport: ?S: This variable conditionally defines the HAS_GETSERVBYPORT ?S: symbol, which indicates to the C program that the ?S: getservbyport() routine is available to look up services ?S: by their port. ?S:. ?C:HAS_GETSERVBYNAME: ?C: This symbol, if defined, indicates that the getservbyname() ?C: routine is available to look up services by their name. ?C:. ?C:HAS_GETSERVBYPORT: ?C: This symbol, if defined, indicates that the getservbyport() ?C: routine is available to look up services by their port. ?C:. ?H:#$d_getsbyname HAS_GETSERVBYNAME /**/ ?H:#$d_getsbyport HAS_GETSERVBYPORT /**/ ?H:. ?LINT:set d_getsbyname d_getsbyport : Optional checks for getsbyname and getsbyport @if d_getsbyname || HAS_GETSERVBYNAME : see if getservbyname exists set getservbyname d_getsbyname eval $inlibc @end @if d_getsbyport || HAS_GETSERVBYPORT : see if getservbyport exists set getservbyport d_getsbyport eval $inlibc @end metaconfig-debian-perl-5.26.1/U/modified/d_htonl.U000066400000000000000000000052031316016665300216510ustar00rootroot00000000000000?RCS: $Id: d_htonl.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_htonl.U,v $ ?RCS: Revision 3.0.1.2 1994/08/29 16:09:25 ram ?RCS: patch32: now properly handles htonl() and friends when macros (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:45:00 ram ?RCS: patch23: now also check for htonl() macro (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:22 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_htonl: Inlibc Setvar i_niin i_sysin i_arpainet cat rm contains \ cppstdin cppflags cppminus ?MAKE: -pick add $@ %< ?S:d_htonl: ?S: This variable conditionally defines HAS_HTONL if htonl() and its ?S: friends are available to do network order byte swapping. ?S:. ?C:HAS_HTONL (HTONL): ?C: This symbol, if defined, indicates that the htonl() routine (and ?C: friends htons() ntohl() ntohs()) are available to do network ?C: order byte swapping. ?C:. ?C:HAS_HTONS (HTONS): ?C: This symbol, if defined, indicates that the htons() routine (and ?C: friends htonl() ntohl() ntohs()) are available to do network ?C: order byte swapping. ?C:. ?C:HAS_NTOHL (NTOHL): ?C: This symbol, if defined, indicates that the ntohl() routine (and ?C: friends htonl() htons() ntohs()) are available to do network ?C: order byte swapping. ?C:. ?C:HAS_NTOHS (NTOHS): ?C: This symbol, if defined, indicates that the ntohs() routine (and ?C: friends htonl() htons() ntohl()) are available to do network ?C: order byte swapping. ?C:. ?H:#$d_htonl HAS_HTONL /**/ ?H:#$d_htonl HAS_HTONS /**/ ?H:#$d_htonl HAS_NTOHL /**/ ?H:#$d_htonl HAS_NTOHS /**/ ?H:. ?F:!htonl.c ?LINT:set d_htonl : see if htonl --and friends-- exists val='' set htonl val eval $inlibc : Maybe they are macros. case "$val" in $undef) $cat >htonl.c < #include #$i_niin I_NETINET_IN #$i_sysin I_SYS_IN #$i_arpainet I_ARPA_INET #ifdef I_NETINET_IN #include #endif #ifdef I_SYS_IN #include #endif #ifdef I_ARPA_INET #include #endif #ifdef htonl printf("Defined as a macro."); #endif EOM $cppstdin $cppflags $cppminus < htonl.c >htonl.E 2>/dev/null if $contains 'Defined as a macro' htonl.E >/dev/null 2>&1; then val="$define" echo "But it seems to be defined as a macro." >&4 fi $rm -f htonl.? ;; esac set d_htonl eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_longdbl.U000066400000000000000000000324021316016665300221470ustar00rootroot00000000000000?RCS: $Id: d_longdbl.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_longdbl.U,v $ ?RCS: ?MAKE:d_longdbl longdblsize d_ldexpl longdblkind \ d_long_double_style_ieee d_long_double_style_ieee_doubledouble \ d_long_double_style_ieee_extended d_long_double_style_ieee_std \ d_long_double_style_vax: Compile Setvar Myread \ Inlibc run echo cat rm_try test doublesize i_stdlib i_float ?MAKE: -pick add $@ %< ?S:d_longdbl: ?S: This variable conditionally defines HAS_LONG_DOUBLE if ?S: the long double type is supported. ?S:. ?S:d_ldexpl: ?S: This variable conditionally defines the HAS_LDEXPL symbol, which ?S: indicates to the C program that the ldexpl() routine is available. ?S:. ?S:longdblsize: ?S: This variable contains the value of the LONG_DOUBLESIZE symbol, which ?S: indicates to the C program how many bytes there are in a long double, ?S: if this system supports long doubles. Note that this is ?S: sizeof(long double), which may include unused bytes. ?S:. ?S:longdblkind: ?S: This variable, if defined, encodes the type of a long double: ?S: 0 = double, ?S: 1 = IEEE 754 128-bit little endian, ?S: 2 = IEEE 754 128-bit big endian, ?S: 3 = x86 80-bit little endian, ?S: 4 = x86 80-bit big endian, ?S: 5 = double-double 128-bit little endian, ?S: 6 = double-double 128-bit big endian, ?S: 7 = 128-bit mixed-endian double-double (64-bit LEs in BE), ?S: 8 = 128-bit mixed-endian double-double (64-bit BEs in LE), ?S: 9 = 128-bit PDP-style mixed-endian long doubles, ?S: -1 = unknown format. ?S:. ?S:d_long_double_style_ieee: ?S: This variable conditionally defines LONG_DOUBLE_STYLE_IEEE ?S: if the long double is any of the IEEE 754 style long doubles: ?S: LONG_DOUBLE_STYLE_IEEE_STD, LONG_DOUBLE_STYLE_IEEE_EXTENDED, ?S: LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE. ?S:. ?S:d_long_double_style_ieee_doubledouble: ?S: This variable conditionally defines LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE ?S: if the long double is the 128-bit IEEE 754 double-double. ?S:. ?S:d_long_double_style_ieee_extended: ?S: This variable conditionally defines LONG_DOUBLE_STYLE_IEEE_EXTENDED ?S: if the long double is the 80-bit IEEE 754 extended precision. ?S: Note that despite the 'extended' this is less than the 'std', ?S: since thisis an extension of the double precision. ?S:. ?S:d_long_double_style_ieee_std: ?S: This variable conditionally defines LONG_DOUBLE_STYLE_IEEE_STD ?S: if the long double is the 128-bit IEEE 754. ?S:. ?S:d_long_double_style_vax: ?S: This variable conditionally defines LONG_DOUBLE_STYLE_VAX ?S: if the long double is the 128-bit VAX format H. ?S:. ?C:HAS_LONG_DOUBLE: ?C: This symbol will be defined if the C compiler supports long ?C: doubles. ?C:. ?C:LONG_DOUBLESIZE: ?C: This symbol contains the size of a long double, so that the ?C: C preprocessor can make decisions based on it. It is only ?C: defined if the system supports long doubles. Note that this ?C: is sizeof(long double), which may include unused bytes. ?C:. ?C:HAS_LDEXPL: ?C: This symbol, if defined, indicates that the ldexpl routine is ?C: available to shift a long double floating-point number ?C: by an integral power of 2. ?C:. ?C:LONG_DOUBLEKIND: ?C: LONG_DOUBLEKIND will be one of ?C: LONG_DOUBLE_IS_DOUBLE ?C: LONG_DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN ?C: LONG_DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN ?C: LONG_DOUBLE_IS_X86_80_BIT_LITTLE_ENDIAN ?C: LONG_DOUBLE_IS_X86_80_BIT_BIG_ENDIAN ?C: LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_LE ?C: LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_BE ?C: LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_BE ?C: LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_LE ?C: LONG_DOUBLE_IS_VAX_H_FLOAT ?C: LONG_DOUBLE_IS_UNKNOWN_FORMAT ?C: It is only defined if the system supports long doubles. ?C:. ?C:LONG_DOUBLE_STYLE_IEEE: ?C: This symbol, if defined, indicates that the long double ?C: is any of the IEEE 754 style long doubles: ?C: LONG_DOUBLE_STYLE_IEEE_STD, LONG_DOUBLE_STYLE_IEEE_EXTENDED, ?C: LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE. ?C:. ?C:LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE: ?C: This symbol, if defined, indicates that the long double is ?C: the 128-bit double-double. ?C:. ?C:LONG_DOUBLE_STYLE_IEEE_EXTENDED: ?C: This symbol, if defined, indicates that the long double is ?C: the 80-bit IEEE 754. Note that despite the 'extended' this ?C: is less than the 'std', since this is an extension of ?C: the double precision. ?C:. ?C:LONG_DOUBLE_STYLE_IEEE_STD: ?C: This symbol, if defined, indicates that the long double is ?C: the 128-bit IEEE 754. ?C:. ?C:LONG_DOUBLE_STYLE_VAX: ?C: This symbol, if defined, indicates that the long double is ?C: the 128-bit VAX format H. ?C:. ?H:#$d_ldexpl HAS_LDEXPL /**/ ?H:#$d_longdbl HAS_LONG_DOUBLE /**/ ?H:?LONG_DOUBLESIZE:#ifdef HAS_LONG_DOUBLE ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLESIZE $longdblsize /**/ ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLEKIND $longdblkind /**/ ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLE 0 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN 1 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN 2 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_X86_80_BIT_LITTLE_ENDIAN 3 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_X86_80_BIT_BIG_ENDIAN 4 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_LE 5 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_BE 6 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_BE 7 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_LE 8 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_VAX_H_FLOAT 9 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_UNKNOWN_FORMAT -1 ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LITTLE_ENDIAN LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_LE /* back-compat */ ?H:?LONG_DOUBLESIZE:#define LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BIG_ENDIAN LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_BE /* back-compat */ ?H:?LONG_DOUBLESIZE:#$d_long_double_style_ieee LONG_DOUBLE_STYLE_IEEE ?H:?LONG_DOUBLESIZE:#$d_long_double_style_ieee_doubledouble LONG_DOUBLE_STYLE_IEEE_DOUBLEDOUBLE ?H:?LONG_DOUBLESIZE:#$d_long_double_style_ieee_extended LONG_DOUBLE_STYLE_IEEE_EXTENDED ?H:?LONG_DOUBLESIZE:#$d_long_double_style_ieee_std LONG_DOUBLE_STYLE_IEEE_STD ?H:?LONG_DOUBLESIZE:#$d_long_double_style_vax LONG_DOUBLE_STYLE_VAX ?H:?LONG_DOUBLESIZE:#endif ?H:. ?F:!try ?LINT:known LONG_DOUBLE_IS_DOUBLE LONG_DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN ?LINT:known LONG_DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN LONG_DOUBLE_IS_X86_80_BIT_LITTLE_ENDIAN ?LINT:known LONG_DOUBLE_IS_X86_80_BIT_BIG_ENDIAN LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LITTLE_ENDIAN ?LINT:known LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BIG_ENDIAN LONG_DOUBLE_IS_UNKNOWN_FORMAT ?LINT:known LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_LE ?LINT:known LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_BE ?LINT:known LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_LE_BE ?LINT:known LONG_DOUBLE_IS_DOUBLEDOUBLE_128_BIT_BE_LE ?LINT:known LONG_DOUBLE_IS_VAX_H_FLOAT ?LINT:set d_longdbl ?LINT:set d_ldexpl : check for long doubles echo " " echo "Checking to see if you have long double..." >&4 echo 'int main() { long double x = 7.0; }' > try.c set try if eval $compile; then val="$define" echo "You have long double." else val="$undef" echo "You do not have long double." fi $rm_try set d_longdbl eval $setvar : see if ldexpl exists set ldexpl d_ldexpl eval $inlibc @if LONG_DOUBLESIZE || longdblsize : check for length of long double ?X: Check only if d_longdbl and if longdblsize is not already set. case "${d_longdbl}${longdblsize}" in $define) echo " " echo "Checking to see how big your long doubles are..." >&4 $cat >try.c <<'EOCP' #include int main() { printf("%d\n", sizeof(long double)); } EOCP set try ?X: Don't use compile_ok because some compilers warn you that they have ?X: 'long double' as just 'double'. set try if eval $compile; then longdblsize=`$run ./try` echo "Your long doubles are $longdblsize bytes long." else dflt='8' echo " " echo "(I can't seem to compile the test program. Guessing...)" >&4 rp="What is the size of a long double (in bytes)?" . ./myread longdblsize="$ans" fi if $test "X$doublesize" = "X$longdblsize"; then echo "That isn't any different from an ordinary double." echo "I'll keep your setting anyway, but you may see some" echo "harmless compilation warnings." fi ;; esac $rm_try @end $echo "Checking the kind of long doubles you have..." >&4 case "$d_longdbl" in define) $cat <try.c #$i_float I_FLOAT #$i_stdlib I_STDLIB #define LONGDBLSIZE $longdblsize #define DOUBLESIZE $doublesize #ifdef I_FLOAT #include #endif #ifdef I_STDLIB #include #endif #include static const long double d = -0.1L; int main() { unsigned const char* b = (unsigned const char*)(&d); #if DOUBLESIZE == LONGDBLSIZE printf("0\n"); /* if it floats like double */ exit(0); #endif #if (LDBL_MANT_DIG == 113 || FLT128_MANT_DIG == 113) && LONGDBLSIZE == 16 if (b[0] == 0x9A && b[1] == 0x99 && b[15] == 0xBF) { /* IEEE 754 128-bit little-endian */ printf("1\n"); exit(0); } if (b[0] == 0xBF && b[14] == 0x99 && b[15] == 0x9A) { /* IEEE 128-bit big-endian, e.g. solaris sparc */ printf("2\n"); exit(0); } #endif /* For alignment 32-bit platforms have the 80 bits in 12 bytes, * while 64-bits platforms have it in 16 bytes. The trailing bytes * cannot be trusted. */ #if LDBL_MANT_DIG == 64 && (LONGDBLSIZE == 16 || LONGDBLSIZE == 12) if (b[0] == 0xCD && b[9] == 0xBF) { /* x86 80-bit little-endian, sizeof 12 (ILP32, Solaris x86) * or 16 (LP64, Linux and OS X), 4 or 6 bytes of padding. * Also known as "extended precision". */ printf("3\n"); exit(0); } if (b[0] == 0xBF && b[9] == 0xCD) { /* Is there ever big-endian 80-bit, really? * * The Motorola 68881 had another "extended precision" format: * sign:1 exp:15 zero:16 integer:1 mantissa:63 * for total of 96 bits of bytes. The zero bits were unused. * See "M68000 FAMILY PROGRAMMER’S REFERENCE MANUAL" for more details. * If it ever becomes relevant, this format should be allocated * a new doublekind code since it's quite different from the Intel x87. */ printf("4\n"); exit(0); } #endif #if (LDBL_MANT_DIG == 106 || LDBL_MANT_DIG == 107) && LONGDBLSIZE == 16 /* software "double double", the 106 is 53+53. * but irix thinks it is 107. */ if (b[0] == 0x9A && b[7] == 0x3C && b[8] == 0x9A && b[15] == 0xBF) { /* double double 128-bit fully little-endian, * little-endian doubles in little-endian order, * 9a 99 99 99 99 99 59 3c 9a 99 99 99 99 99 b9 bf */ printf("5\n"); exit(0); } if (b[0] == 0xBF && b[7] == 0x9A && b[8] == 0x3C && b[15] == 0x9A) { /* double double 128-bit fully big-endian, * big-endian doubles in big-endian order, * e.g. PPC/Power and MIPS: * bf b9 99 99 99 99 99 9a 3c 59 99 99 99 99 99 9a */ printf("6\n"); exit(0); } if (b[0] == 0x9A && b[7] == 0xBF && b[8] == 0x9A && b[15] == 0x3C) { /* double double 128-bit mixed endian. * little-endian doubles in big-endian order, * e.g. ppc64el, * 9a 99 99 99 99 99 b9 bf 9a 99 99 99 99 99 59 3c */ printf("7\n"); exit(0); } if (b[0] == 0x3C && b[7] == 0x9A && b[8] == 0xBF && b[15] == 0x9A) { /* double double 128-bit mixed endian, * big-endian doubles in little-endian order, * 3c 59 99 99 99 99 99 9a bf b9 99 99 99 99 99 9a */ printf("8\n"); exit(0); } #endif /* We are largely making this up because it may well be * that the VAX format H was never made available to C, * only to Fortran. */ #if LONGDBLSIZE == 16 && defined(__vax__) if (b[0] == 0xFD && b[15] == 0x99) { /* VAX format H, PDP-11 mixed endian. */ printf("9\n"); exit(0); } #endif printf("-1\n"); /* unknown */ exit(0); } EOP set try if eval $compile; then longdblkind=`$run ./try` else longdblkind=-1 fi ;; *) longdblkind=0 ;; esac case "$longdblkind" in 0) echo "Your long doubles are doubles." >&4 ;; 1) echo "You have IEEE 754 128-bit little endian long doubles." >&4 ;; 2) echo "You have IEEE 754 128-bit big endian long doubles." >&4 ;; 3) echo "You have x86 80-bit little endian long doubles." >& 4 ;; 4) echo "You have x86 80-bit big endian long doubles." >& 4 ;; 5) echo "You have 128-bit fully little-endian double-double long doubles (64-bit LEs in LE)." >& 4 ;; 6) echo "You have 128-bit fully big-endian double-double long doubles (64-bit BEs in BE)." >& 4 ;; 7) echo "You have 128-bit mixed-endian double-double long doubles (64-bit LEs in BE)." >& 4 ;; 8) echo "You have 128-bit mixed-endian double-double long doubles (64-bit BEs in LE)." >& 4 ;; 9) echo "You have 128-bit PDP-style mixed-endian long doubles (VAX format H)." >& 4 ;; *) echo "Cannot figure out your long double." >&4 ;; esac d_long_double_style_ieee=$undef d_long_double_style_ieee_std=$undef d_long_double_style_ieee_extended=$undef d_long_double_style_ieee_doubledouble=$undef d_long_double_style_vax=$undef case "$longdblkind" in 1|2|3|4|5|6|7|8) d_long_double_style_ieee=$define ;; esac case "$longdblkind" in 1|2) d_long_double_style_ieee_std=$define ;; esac case "$longdblkind" in 3|4) d_long_double_style_ieee_extended=$define ;; esac case "$longdblkind" in 5|6|7|8) d_long_double_style_ieee_doubledouble=$define ;; esac case "$longdblkind" in 9) d_long_double_style_vax=$define ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/modified/d_longlong.U000066400000000000000000000043561316016665300223540ustar00rootroot00000000000000?RCS: $Id: d_longlong.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_longlong.U,v $ ?RCS: ?MAKE:d_longlong longlongsize: Compile Setvar Myread run \ cat rm_try test longsize ?MAKE: -pick add $@ %< ?S:d_longlong: ?S: This variable conditionally defines HAS_LONG_LONG if ?S: the long long type is supported. ?S:. ?S:longlongsize: ?S: This variable contains the value of the LONGLONGSIZE symbol, which ?S: indicates to the C program how many bytes there are in a long long, ?S: if this system supports long long. ?S:. ?C:HAS_LONG_LONG: ?C: This symbol will be defined if the C compiler supports long long. ?C:. ?C:LONGLONGSIZE: ?C: This symbol contains the size of a long long, so that the ?C: C preprocessor can make decisions based on it. It is only ?C: defined if the system supports long long. ?C:. ?H:#$d_longlong HAS_LONG_LONG /**/ ?H:?LONGLONGSIZE:#ifdef HAS_LONG_LONG ?H:?LONGLONGSIZE:#define LONGLONGSIZE $longlongsize /**/ ?H:?LONGLONGSIZE:#endif ?H:. ?F:!try ?LINT:set d_longlong : check for long long echo " " echo "Checking to see if you have long long..." >&4 echo 'int main() { long long x = 7; return 0; }' > try.c set try if eval $compile; then val="$define" echo "You have long long." else val="$undef" echo "You do not have long long." fi $rm_try set d_longlong eval $setvar @if LONGLONGSIZE || longlongsize : check for length of long long ?X: Check only if d_longlong and if longlongsize is not already set. case "${d_longlong}${longlongsize}" in $define) echo " " echo "Checking to see how big your long longs are..." >&4 $cat >try.c <<'EOCP' #include int main() { printf("%d\n", (int)sizeof(long long)); return(0); } EOCP set try if eval $compile_ok; then longlongsize=`$run ./try` echo "Your long longs are $longlongsize bytes long." else dflt='8' echo " " echo "(I can't seem to compile the test program. Guessing...)" rp="What is the size of a long long (in bytes)?" . ./myread longlongsize="$ans" fi if $test "X$longsize" = "X$longlongsize"; then echo "(That isn't any different from an ordinary long.)" fi ;; esac $rm_try @end metaconfig-debian-perl-5.26.1/U/modified/d_memchr.U000066400000000000000000000015731316016665300220060ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_memchr: Inlibc ?MAKE: -pick add $@ %< ?S:d_memchr: ?S: This variable conditionally defines the HAS_MEMCHR symbol, which ?S: indicates to the C program that the memchr() routine is available ?S: to locate characters within a C string. ?S:. ?C:HAS_MEMCHR: ?C: This symbol, if defined, indicates that the memchr routine is available ?C: to locate characters within a C string. ?C:. ?H:#$d_memchr HAS_MEMCHR /**/ ?H:. ?LINT:set d_memchr : see if memchr exists set memchr d_memchr eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_mknod.U000066400000000000000000000015751316016665300216450ustar00rootroot00000000000000?RCS: $Id: d_mknod.U,v 3.0.1.1 1994/10/29 16:14:17 ram Exp $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_mknod.U,v $ ?RCS: ?MAKE:d_mknod: Inlibc ?MAKE: -pick add $@ %< ?S:d_mknod: ?S: This variable conditionally defines the HAS_MKNOD symbol, which ?S: indicates to the C program that the mknod() routine is available. ?S:. ?C:HAS_MKNOD : ?C: This symbol, if defined, indicates that the mknod routine is ?C: available. If you just want to create FIFOs, you should try ?C: to use mkfifo instead. mknod might require super-user privileges. ?C:. ?H:#$d_mknod HAS_MKNOD /**/ ?H:. ?LINT:set d_mknod : see if mknod exists set mknod d_mknod eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_mkstemp.U000066400000000000000000000016551316016665300222140ustar00rootroot00000000000000?RCS: $Id: d_mkstemp.U,v 3.0.1.1 1994/08/29 16:11:57 ram Exp $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_mkstemp.U,v $ ?RCS: ?MAKE:d_mkstemp: Inlibc ?MAKE: -pick add $@ %< ?S:d_mkstemp: ?S: This variable conditionally defines the HAS_MKSTEMP symbol, which ?S: indicates to the C program that the mkstemp() routine is available ?S: to exclusively create and open a uniquely named temporary file. ?S:. ?C:HAS_MKSTEMP : ?C: This symbol, if defined, indicates that the mkstemp routine is ?C: available to exclusively create and open a uniquely named ?C: temporary file. ?C:. ?H:#$d_mkstemp HAS_MKSTEMP /**/ ?H:. ?LINT:set d_mkstemp : see if mkstemp exists set mkstemp d_mkstemp eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_mmap.U000066400000000000000000000030161316016665300214570ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mmap mmaptype: Inlibc i_sysmman cat cc ccflags ?MAKE: -pick add $@ %< ?S:d_mmap: ?S: This variable conditionally defines HAS_MMAP if mmap() is ?S: available to map a file into memory. ?S:. ?S:mmaptype: ?S: This symbol contains the type of pointer returned by mmap() ?S: (and simultaneously the type of the first argument). ?S: It can be 'void *' or 'caddr_t'. ?S:. ?C:HAS_MMAP: ?C: This symbol, if defined, indicates that the mmap system call is ?C: available to map a file into memory. ?C:. ?C:Mmap_t: ?C: This symbol holds the return type of the mmap() system call ?C: (and simultaneously the type of the first argument). ?C: Usually set to 'void *' or 'caddr_t'. ?C:. ?H:#$d_mmap HAS_MMAP /**/ ?H:#define Mmap_t $mmaptype /**/ ?H:. ?LINT:set d_mmap : see if mmap exists set mmap d_mmap eval $inlibc : see what shmat returns : default to something harmless mmaptype='void *' case "$i_sysmman$d_mmap" in "$define$define") $cat >mmap.c <<'END' #include void *mmap(); END if $cc $ccflags -c mmap.c >/dev/null 2>&1; then mmaptype='void *' else mmaptype='caddr_t' fi echo "and it returns ($mmaptype)." >&4 ;; esac metaconfig-debian-perl-5.26.1/U/modified/d_msg.U000066400000000000000000000033031316016665300213120ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_msg.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:37 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_msg: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr osname ?MAKE: -pick add $@ %< ?S:d_msg: ?S: This variable conditionally defines the HAS_MSG symbol, which ?S: indicates that the entire msg*(2) library is present. ?S:. ?C:HAS_MSG: ?C: This symbol, if defined, indicates that the entire msg*(2) library is ?C: supported (IPC mechanism based on message queues). ?C:. ?H:#$d_msg HAS_MSG /**/ ?H:. ?T:h_msg ?LINT:set d_msg : see how much of the 'msg*(2)' library is present. h_msg=true echo " " case "$d_msgctl$d_msgget$d_msgsnd$d_msgrcv" in *"$undef"*) h_msg=false;; esac case "$osname" in freebsd) case "`ipcs 2>&1`" in "SVID messages"*"not configured"*) echo "Your $osname does not have the msg*(2) configured." >&4 h_msg=false val="$undef" set msgctl d_msgctl eval $setvar set msgget d_msgget eval $setvar set msgsnd d_msgsnd eval $setvar set msgrcv d_msgrcv eval $setvar ;; esac ;; esac : we could also check for sys/ipc.h ... if $h_msg && $test `./findhdr sys/msg.h`; then echo "You have the full msg*(2) library." >&4 val="$define" else echo "You don't have the full msg*(2) library." >&4 val="$undef" fi set d_msg eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_sem.U000066400000000000000000000031421316016665300213110ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_sem.U,v $ ?RCS: Revision 3.0 1993/08/18 12:07:03 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_sem: test d_semctl d_semget d_semop Setvar Findhdr osname ?MAKE: -pick add $@ %< ?S:d_sem: ?S: This variable conditionally defines the HAS_SEM symbol, which ?S: indicates that the entire sem*(2) library is present. ?S:. ?C:HAS_SEM: ?C: This symbol, if defined, indicates that the entire sem*(2) library is ?C: supported. ?C:. ?H:#$d_sem HAS_SEM /**/ ?H:. ?T:h_sem ?LINT:set d_sem : see how much of the 'sem*(2)' library is present. h_sem=true echo " " case "$d_semctl$d_semget$d_semop" in *"$undef"*) h_sem=false;; esac case "$osname" in freebsd) case "`ipcs 2>&1`" in "SVID messages"*"not configured"*) echo "Your $osname does not have the sem*(2) configured." >&4 h_sem=false val="$undef" set semctl d_semctl eval $setvar set semget d_semget eval $setvar set semop d_semop eval $setvar ;; esac ;; esac : we could also check for sys/ipc.h ... if $h_sem && $test `./findhdr sys/sem.h`; then echo "You have the full sem*(2) library." >&4 val="$define" else echo "You don't have the full sem*(2) library." >&4 val="$undef" fi set d_sem eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_setgrent.U000066400000000000000000000014721316016665300223640ustar00rootroot00000000000000?RCS: $Id: d_setgrent.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_setgrent.U,v $ ?RCS: ?MAKE:d_setgrent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setgrent: ?S: This variable conditionally defines the HAS_SETGRENT symbol, which ?S: indicates to the C program that the setgrent() routine is available ?S: for initializing sequential access to the group database. ?S:. ?C:HAS_SETGRENT: ?C: This symbol, if defined, indicates that the setgrent routine is ?C: available for initializing sequential access of the group database. ?C:. ?H:#$d_setgrent HAS_SETGRENT /**/ ?H:. ?LINT:set d_setgrent : see if setgrent exists set setgrent d_setgrent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_sethent.U000066400000000000000000000017161316016665300222040ustar00rootroot00000000000000?RCS: $Id: d_sethent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_sethent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_sethent: Inlibc ?MAKE: -pick add $@ %< ?S:d_sethent: ?S: This variable conditionally defines HAS_SETHOSTENT if sethostent() is ?S: available. ?S:. ?C:HAS_SETHOSTENT: ?C: This symbol, if defined, indicates that the sethostent() routine is ?C: available. ?C:. ?H:#$d_sethent HAS_SETHOSTENT /**/ ?H:. ?LINT:set d_sethent : see if sethostent exists set sethostent d_sethent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_setnent.U000066400000000000000000000017071316016665300222120ustar00rootroot00000000000000?RCS: $Id: d_setnent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_setnent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_setnent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setnent: ?S: This variable conditionally defines HAS_SETNETENT if setnetent() is ?S: available. ?S:. ?C:HAS_SETNETENT: ?C: This symbol, if defined, indicates that the setnetent() routine is ?C: available. ?C:. ?H:#$d_setnent HAS_SETNETENT /**/ ?H:. ?LINT:set d_setnent : see if setnetent exists set setnetent d_setnent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_setpent.U000066400000000000000000000017251316016665300222140ustar00rootroot00000000000000?RCS: $Id: d_setpent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_setpent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_setpent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setpent: ?S: This variable conditionally defines HAS_SETPROTOENT if setprotoent() is ?S: available. ?S:. ?C:HAS_SETPROTOENT: ?C: This symbol, if defined, indicates that the setprotoent() routine is ?C: available. ?C:. ?H:#$d_setpent HAS_SETPROTOENT /**/ ?H:. ?LINT:set d_setpent : see if setprotoent exists set setprotoent d_setpent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_setpgrp.U000066400000000000000000000067321316016665300222210ustar00rootroot00000000000000?RCS: $Id: d_setpgrp.U,v 3.0.1.3 1997/02/28 15:44:16 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_setpgrp.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:44:16 ram ?RCS: patch61: obsoleted USE_BSDGRP in favor of USE_BSD_SETPGRP ?RCS: patch61: another unit now also defines a USE_BSD_GETPGRP ?RCS: patch61: fallback for test program failure improved ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 13:59:30 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:15:37 ram ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: patch36: call ./usg explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_setpgrp d_bsdsetpgrp: cat rm_try +cc +libs +ccflags \ +ldflags Inlibc Guess Setvar i_unistd i_stdlib run ?MAKE: -pick add $@ %< ?S:d_setpgrp: ?S: This variable conditionally defines HAS_SETPGRP if setpgrp() is ?S: available to set the current process group. ?S:. ?S:d_bsdsetpgrp (d_bsdpgrp): ?S: This variable conditionally defines USE_BSD_SETPGRP if ?S: setpgrp needs two arguments whereas USG one needs none. ?S: See also d_setpgid for a POSIX interface. ?S:. ?C:HAS_SETPGRP (SETPGRP): ?C: This symbol, if defined, indicates that the setpgrp routine is ?C: available to set the current process group. ?C:. ?C:USE_BSD_SETPGRP (USE_BSDPGRP BSDPGRP): ?C: This symbol, if defined, indicates that setpgrp needs two ?C: arguments whereas USG one needs none. See also HAS_SETPGID ?C: for a POSIX interface. ?C:. ?H:#$d_setpgrp HAS_SETPGRP /**/ ?H:#$d_bsdsetpgrp USE_BSD_SETPGRP /**/ ?H:. ?T:xxx ?F:!try ?LINT:set d_setpgrp d_bsdsetpgrp : see if setpgrp exists set setpgrp d_setpgrp eval $inlibc @if USE_BSD_SETPGRP || d_bsdsetpgrp case "$d_setpgrp" in "$define") echo " " echo "Checking to see which flavor of setpgrp is in use..." $cat >try.c < #ifdef I_UNISTD # include #endif #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { if (getuid() == 0) { printf("(I see you are running Configure as super-user...)\n"); setuid(1); } #ifdef TRY_BSD_PGRP if (-1 == setpgrp(1, 1)) exit(0); #else if (setpgrp() != -1) exit(0); #endif exit(1); } EOP if $cc -o try -DTRY_BSD_PGRP $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then echo 'You have to use setpgrp(pid,pgrp) instead of setpgrp().' >&4 val="$define" elif $cc -o try $ccflags $ldflags try.c $libs >/dev/null 2>&1 && $run ./try; then echo 'You have to use setpgrp() instead of setpgrp(pid,pgrp).' >&4 val="$undef" else echo "(I can't seem to compile and run the test program.)" if ./usg; then xxx="a USG one, i.e. you use setpgrp()." else # SVR4 systems can appear rather BSD-ish. case "$i_unistd" in $undef) xxx="a BSD one, i.e. you use setpgrp(pid,pgrp)." val="$define" ;; $define) xxx="probably a USG one, i.e. you use setpgrp()." val="$undef" ;; esac fi echo "Assuming your setpgrp is $xxx" >&4 fi ;; *) val="$undef";; esac set d_bsdsetpgrp eval $setvar $rm_try @end metaconfig-debian-perl-5.26.1/U/modified/d_setpwent.U000066400000000000000000000014741316016665300224040ustar00rootroot00000000000000?RCS: $Id: d_setpwent.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_setpwent.U,v $ ?RCS: ?MAKE:d_setpwent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setpwent: ?S: This variable conditionally defines the HAS_SETPWENT symbol, which ?S: indicates to the C program that the setpwent() routine is available ?S: for initializing sequential access to the passwd database. ?S:. ?C:HAS_SETPWENT: ?C: This symbol, if defined, indicates that the setpwent routine is ?C: available for initializing sequential access of the passwd database. ?C:. ?H:#$d_setpwent HAS_SETPWENT /**/ ?H:. ?LINT:set d_setpwent : see if setpwent exists set setpwent d_setpwent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_setsent.U000066400000000000000000000017161316016665300222170ustar00rootroot00000000000000?RCS: $Id: d_setsent.U,v 3.0 1993/08/18 12:06:09 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_setsent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_setsent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setsent: ?S: This variable conditionally defines HAS_SETSERVENT if setservent() is ?S: available. ?S:. ?C:HAS_SETSERVENT: ?C: This symbol, if defined, indicates that the setservent() routine is ?C: available. ?C:. ?H:#$d_setsent HAS_SETSERVENT /**/ ?H:. ?LINT:set d_setsent : see if setservent exists set setservent d_setsent eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_setvbuf.U000066400000000000000000000016401316016665300222040ustar00rootroot00000000000000?RCS: $Id: d_setvbuf.U,v 3.0.1.1 1994/08/29 16:11:57 ram Exp $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_setvbuf.U,v $ ?RCS: ?MAKE:d_setvbuf: Inlibc ?MAKE: -pick add $@ %< ?S:d_setvbuf: ?S: This variable conditionally defines the HAS_SETVBUF symbol, which ?S: indicates to the C program that the setvbuf() routine is available ?S: to change buffering on an open stdio stream. ?S:. ?C:HAS_SETVBUF : ?C: This symbol, if defined, indicates that the setvbuf routine is ?C: available to change buffering on an open stdio stream. ?C: to a line-buffered mode. ?C:. ?H:#$d_setvbuf HAS_SETVBUF /**/ ?H:. ?LINT:set d_setvbuf : see if setvbuf exists set setvbuf d_setvbuf eval $inlibc metaconfig-debian-perl-5.26.1/U/modified/d_shm.U000066400000000000000000000032711316016665300213170ustar00rootroot00000000000000?RCS: $Id: d_shm.U,v 3.0 1993/08/18 12:07:17 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_shm.U,v $ ?RCS: Revision 3.0 1993/08/18 12:07:17 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_shm: test d_shmctl d_shmget d_shmat d_shmdt Setvar Findhdr osname ?MAKE: -pick add $@ %< ?S:d_shm: ?S: This variable conditionally defines the HAS_SHM symbol, which ?S: indicates that the entire shm*(2) library is present. ?S:. ?C:HAS_SHM: ?C: This symbol, if defined, indicates that the entire shm*(2) library is ?C: supported. ?C:. ?H:#$d_shm HAS_SHM /**/ ?H:. ?T:h_shm ?LINT:set d_shm : see how much of the 'shm*(2)' library is present. h_shm=true echo " " case "$d_shmctl$d_shmget$d_shmat$d_shmdt" in *"$undef"*) h_shm=false;; esac case "$osname" in freebsd) case "`ipcs 2>&1`" in "SVID shared memory"*"not configured"*) echo "Your $osname does not have the shm*(2) configured." >&4 h_shm=false val="$undef" set shmctl d_shmctl eval $setvar set shmget d_shmget eval $setvar set shmat d_shmat eval $setvar set shmdt d_shmdt eval $setvar ;; esac ;; esac : we could also check for sys/ipc.h ... if $h_shm && $test `./findhdr sys/shm.h`; then echo "You have the full shm*(2) library." >&4 val="$define" else echo "You don't have the full shm*(2) library." >&4 val="$undef" fi set d_shm eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_shmat.U000066400000000000000000000056321316016665300216470ustar00rootroot00000000000000?RCS: $Id: d_shmat.U,v 3.0.1.3 1995/07/25 14:04:23 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_shmat.U,v $ ?RCS: Revision 3.0.1.3 1995/07/25 14:04:23 ram ?RCS: patch56: use findhdr to find , to get the right one (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/05/13 15:18:56 ram ?RCS: patch27: added new symbol HAS_SHMAT_PROTOTYPE (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:54:18 ram ?RCS: patch23: new Shmat_t symbol to declare return type of shmat() ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:18 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_shmat shmattype d_shmatprototype: Inlibc cat +cc +ccflags \ rm cppstdin cppflags cppminus Findhdr Setvar contains ?MAKE: -pick add $@ %< ?S:d_shmat: ?S: This variable conditionally defines the HAS_SHMAT symbol, which ?S: indicates to the C program that the shmat() routine is available. ?S:. ?S:shmattype: ?S: This symbol contains the type of pointer returned by shmat(). ?S: It can be 'void *' or 'char *'. ?S:. ?S:d_shmatprototype: ?S: This variable conditionally defines the HAS_SHMAT_PROTOTYPE ?S: symbol, which indicates that sys/shm.h has a prototype for ?S: shmat. ?S:. ?C:HAS_SHMAT: ?C: This symbol, if defined, indicates that the shmat() routine is ?C: available to attach a shared memory segment to the process space. ?C:. ?C:Shmat_t: ?C: This symbol holds the return type of the shmat() system call. ?C: Usually set to 'void *' or 'char *'. ?C:. ?C:HAS_SHMAT_PROTOTYPE: ?C: This symbol, if defined, indicates that the sys/shm.h includes ?C: a prototype for shmat(). Otherwise, it is up to the program to ?C: guess one. Shmat_t shmat(int, Shmat_t, int) is a good guess, ?C: but not always right so it should be emitted by the program only ?C: when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs. ?C:. ?H:#$d_shmat HAS_SHMAT /**/ ?H:#define Shmat_t $shmattype /**/ ?H:#$d_shmatprototype HAS_SHMAT_PROTOTYPE /**/ ?H:. ?LINT:set d_shmat d_shmatprototype ?T:xxx : see if shmat exists set shmat d_shmat eval $inlibc : see what shmat returns case "$d_shmat" in "$define") $cat >shmat.c <<'END' #include void *shmat(); END if $cc $ccflags -c shmat.c >/dev/null 2>&1; then shmattype='void *' else shmattype='char *' fi echo "and it returns ($shmattype)." >&4 : see if a prototype for shmat is available xxx=`./findhdr sys/shm.h` $cppstdin $cppflags $cppminus < $xxx > shmat.c 2>/dev/null if $contains 'shmat.*(' shmat.c >/dev/null 2>&1; then val="$define" else val="$undef" fi $rm -f shmat.[co] ;; *) val="$undef" ;; esac set d_shmatprototype eval $setvar metaconfig-debian-perl-5.26.1/U/modified/d_socket.U000066400000000000000000000312531316016665300220210ustar00rootroot00000000000000?RCS: $Id: d_socket.U,v 3.0.1.2 1997/02/28 15:46:00 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_socket.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:46:00 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:08:04 ram ?RCS: patch16: can now safely declare private nm_extract in dependencies ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:26 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_socket d_oldsock d_sockpair socketlib sockethdr \ d_msg_ctrunc d_msg_dontroute d_msg_oob d_msg_peek d_msg_proxy \ d_scm_rights d_sockaddr_sa_len d_sockaddr_in6 d_sin6_scope_id \ d_ip_mreq d_ip_mreq_source d_ipv6_mreq d_ipv6_mreq_source: \ contains echo n c ar nm nm_opt nm_extract Inlibc Csym _a \ Compile cat rm_try Setvar Hasfield sysroot ?MAKE: -pick add $@ %< ?S:d_socket: ?S: This variable conditionally defines HAS_SOCKET, which indicates ?S: that the BSD socket interface is supported. ?S:. ?S:d_sockpair: ?S: This variable conditionally defines the HAS_SOCKETPAIR symbol, which ?S: indicates that the BSD socketpair() is supported. ?S:. ?S:d_oldsock: ?S: This variable conditionally defines the OLDSOCKET symbol, which ?S: indicates that the BSD socket interface is based on 4.1c and not 4.2. ?S:. ?S:d_msg_ctrunc: ?S: This variable conditionally defines the HAS_MSG_CTRUNC symbol, ?S: which indicates that the MSG_CTRUNC is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_msg_dontroute: ?S: This variable conditionally defines the HAS_MSG_DONTROUTE symbol, ?S: which indicates that the MSG_DONTROUTE is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_msg_oob: ?S: This variable conditionally defines the HAS_MSG_OOB symbol, ?S: which indicates that the MSG_OOB is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_msg_peek: ?S: This variable conditionally defines the HAS_MSG_PEEK symbol, ?S: which indicates that the MSG_PEEK is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_msg_proxy: ?S: This variable conditionally defines the HAS_MSG_PROXY symbol, ?S: which indicates that the MSG_PROXY is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_scm_rights: ?S: This variable conditionally defines the HAS_SCM_RIGHTS symbol, ?S: which indicates that the SCM_RIGHTS is available. #ifdef is ?S: not enough because it may be an enum, glibc has been known to do this. ?S:. ?S:d_sockaddr_sa_len: ?S: This variable conditionally defines the HAS_SOCKADDR_SA_LEN symbol, ?S: which indicates that a struct sockaddr structure has the sa_len ?S: member. ?S:. ?S:d_sockaddr_in6: ?S: This variable conditionally defines the HAS_SOCKADDR_IN6 symbol, which ?S: indicates the availability of a struct sockaddr_in6. ?S:. ?S:d_sin6_scope_id: ?S: This variable conditionally defines the HAS_SIN6_SCOPE_ID symbol, which ?S: indicates that a struct sockaddr_in6 structure has the sin6_scope_id ?S: member. ?S:. ?S:d_ip_mreq: ?S: This variable conditionally defines the HAS_IP_MREQ symbol, which ?S: indicates the availability of a struct ip_mreq. ?S:. ?S:d_ip_mreq_source: ?S: This variable conditionally defines the HAS_IP_MREQ_SOURCE symbol, ?S: which indicates the availability of a struct ip_mreq_source. ?S:. ?S:d_ipv6_mreq: ?S: This variable conditionally defines the HAS_IPV6_MREQ symbol, which ?S: indicates the availability of a struct ipv6_mreq. ?S:. ?S:d_ipv6_mreq_source: ?S: This variable conditionally defines the HAS_IPV6_MREQ_SOURCE symbol, ?S: which indicates the availability of a struct ipv6_mreq_source. ?S:. ?S:socketlib: ?S: This variable has the names of any libraries needed for socket support. ?S:. ?S:sockethdr: ?S: This variable has any cpp '-I' flags needed for socket support. ?S:. ?C:HAS_SOCKET (SOCKET): ?C: This symbol, if defined, indicates that the BSD socket interface is ?C: supported. ?C:. ?C:HAS_SOCKETPAIR (SOCKETPAIR): ?C: This symbol, if defined, indicates that the BSD socketpair() call is ?C: supported. ?C:. ?C:USE_OLDSOCKET (OLDSOCKET): ?C: This symbol, if defined, indicates that the 4.1c BSD socket interface ?C: is supported instead of the 4.2/4.3 BSD socket interface. For instance, ?C: there is no setsockopt() call. ?C:. ?C:HAS_MSG_CTRUNC: ?C: This symbol, if defined, indicates that the MSG_CTRUNC is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_MSG_DONTROUTE: ?C: This symbol, if defined, indicates that the MSG_DONTROUTE is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_MSG_OOB: ?C: This symbol, if defined, indicates that the MSG_OOB is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_MSG_PEEK: ?C: This symbol, if defined, indicates that the MSG_PEEK is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_MSG_PROXY: ?C: This symbol, if defined, indicates that the MSG_PROXY is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_SCM_RIGHTS: ?C: This symbol, if defined, indicates that the SCM_RIGHTS is supported. ?C: Checking just with #ifdef might not be enough because this symbol ?C: has been known to be an enum. ?C:. ?C:HAS_SOCKADDR_SA_LEN: ?C: This symbol, if defined, indicates that the struct sockaddr ?C: structure has a member called sa_len, indicating the length of ?C: the structure. ?C:. ?C:HAS_SOCKADDR_IN6: ?C: This symbol, if defined, indicates the availability of ?C: struct sockaddr_in6; ?C:. ?C:HAS_SIN6_SCOPE_ID: ?C: This symbol, if defined, indicates that the struct sockaddr_in6 ?C: structure has a member called sin6_scope_id. ?C:. ?C:HAS_IP_MREQ: ?C: This symbol, if defined, indicates the availability of ?C: struct ip_mreq; ?C:. ?C:HAS_IP_MREQ_SOURCE: ?C: This symbol, if defined, indicates the availability of ?C: struct ip_mreq_source; ?C:. ?C:HAS_IPV6_MREQ: ?C: This symbol, if defined, indicates the availability of ?C: struct ipv6_mreq; ?C:. ?C:HAS_IPV6_MREQ_SOURCE: ?C: This symbol, if defined, indicates the availability of ?C: struct ipv6_mreq_source; ?C:. ?H:#$d_socket HAS_SOCKET /**/ ?H:#$d_sockpair HAS_SOCKETPAIR /**/ ?H:#$d_sockaddr_sa_len HAS_SOCKADDR_SA_LEN /**/ ?H:#$d_oldsock USE_OLDSOCKET /**/ ?H:#$d_msg_ctrunc HAS_MSG_CTRUNC /**/ ?H:#$d_msg_dontroute HAS_MSG_DONTROUTE /**/ ?H:#$d_msg_oob HAS_MSG_OOB /**/ ?H:#$d_msg_peek HAS_MSG_PEEK /**/ ?H:#$d_msg_proxy HAS_MSG_PROXY /**/ ?H:#$d_scm_rights HAS_SCM_RIGHTS /**/ ?H:#$d_sockaddr_in6 HAS_SOCKADDR_IN6 /**/ ?H:#$d_sin6_scope_id HAS_SIN6_SCOPE_ID /**/ ?H:#$d_ip_mreq HAS_IP_MREQ /**/ ?H:#$d_ip_mreq_source HAS_IP_MREQ_SOURCE /**/ ?H:#$d_ipv6_mreq HAS_IPV6_MREQ /**/ ?H:#$d_ipv6_mreq_source HAS_IPV6_MREQ_SOURCE /**/ ?H:. ?T:val net ENUM enum ?LINT:set d_sockpair d_sockaddr_sa_len ?LINT:set d_msg_ctrunc d_msg_dontroute d_msg_oob d_msg_peek d_msg_proxy ?LINT:set d_scm_rights d_sockaddr_in6 d_sin6_scope_id d_ip_mreq ?LINT:set d_ip_mreq_source d_ipv6_mreq d_ipv6_mreq_source : see whether socket exists socketlib='' sockethdr='' echo " " $echo $n "Hmm... $c" >&4 if set socket val -f d_socket; eval $csym; $val; then echo "Looks like you have Berkeley networking support." >&4 d_socket="$define" ?X: now check for advanced features if set setsockopt val -f; eval $csym; $val; then d_oldsock="$undef" else echo "...but it uses the old BSD 4.1c interface, rather than 4.2." >&4 d_oldsock="$define" fi else ?X: HP-UX, for one, puts all the socket stuff in socklib.o. Note that if we ?X: come here on HP-UX, then we must have used nm to get symbols, or we really ?X: don't have sockets anyway... if $contains socklib libc.list >/dev/null 2>&1; then echo "Looks like you have Berkeley networking support." >&4 d_socket="$define" : we will have to assume that it supports the 4.2 BSD interface d_oldsock="$undef" else echo "You don't have Berkeley networking in libc$_a..." >&4 ?X: look for optional networking libraries if test "X$d_socket" = "X$define"; then echo "...but you seem to believe that you have sockets." >&4 else for net in net socket do if test -f $sysroot/usr/lib/lib$net$_a; then ?X: space between two '(' needed for ksh ( ($nm $nm_opt $sysroot/usr/lib/lib$net$_a | eval $nm_extract) || \ $ar t $sysroot/usr/lib/lib$net$_a) 2>/dev/null >> libc.list if $contains socket libc.list >/dev/null 2>&1; then d_socket="$define" socketlib="-l$net" case "$net" in net) echo "...but the Wollongong group seems to have hacked it in." >&4 sockethdr="-I$sysroot/usr/netinclude" ;; esac echo "Found Berkeley sockets interface in lib$net." >&4 ?X: now check for advanced features if $contains setsockopt libc.list >/dev/null 2>&1; then d_oldsock="$undef" else echo "...using the old BSD 4.1c interface, rather than 4.2." >&4 d_oldsock="$define" fi break fi fi done if test "X$d_socket" != "X$define"; then echo "or anywhere else I see." >&4 d_socket="$undef" d_oldsock="$undef" fi fi fi fi @if HAS_SOCKETPAIR || d_sockpair : see if socketpair exists set socketpair d_sockpair eval $inlibc @end echo " " ?X: ... echo "Checking the availability sa_len in the sock struct ..." >&4 $cat >try.c < #include int main() { struct sockaddr sa; return (sa.sa_len); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_sockaddr_sa_len; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability struct sockaddr_in6 ..." >&4 $cat >try.c < #include #include int main() { struct sockaddr_in6 sin6; return (sin6.sin6_family); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_sockaddr_in6; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability sin6_scope_id in struct sockaddr_in6 ..." >&4 $cat >try.c < #include #include int main() { struct sockaddr_in6 sin6; return (sin6.sin6_scope_id); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_sin6_scope_id; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability struct ip_mreq ..." >&4 $cat >try.c < #include #include int main() { struct ip_mreq mreq; return (mreq.imr_multiaddr.s_addr); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_ip_mreq; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability struct ip_mreq_source ..." >&4 $cat >try.c < #include #include int main() { struct ip_mreq_source mreq; return (mreq.imr_multiaddr.s_addr); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_ip_mreq_source; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability struct ipv6_mreq ..." >&4 $cat >try.c < #include #include int main() { struct ipv6_mreq mreq; return (mreq.ipv6mr_interface); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_ipv6_mreq; eval $setvar $rm_try echo " " ?X: ... echo "Checking the availability struct ipv6_mreq_source ..." >&4 $cat >try.c < #include #include int main() { struct ipv6_mreq_source mreq; return (mreq.imr_multiaddr.s_addr); } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_ipv6_mreq_source; eval $setvar $rm_try echo " " ?X: these constants are known to be troublesomely defined as enums ?X: so that ifdef will not work for detecting their presence. echo "Checking the availability of certain socket constants..." >&4 for ENUM in MSG_CTRUNC MSG_DONTROUTE MSG_OOB MSG_PEEK MSG_PROXY SCM_RIGHTS; do enum=`$echo $ENUM|./tr '[A-Z]' '[a-z]'` $cat >try.c < #include int main() { int i = $ENUM; } EOF val="$undef" set try; if eval $compile; then val="$define" fi set d_${enum}; eval $setvar $rm_try done metaconfig-debian-perl-5.26.1/U/modified/d_statblks.U000066400000000000000000000023261316016665300223570ustar00rootroot00000000000000?RCS: $Id: d_statblks.U,v 3.0 1993/08/18 12:07:29 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_statblks.U,v $ ?RCS: Revision 3.0 1993/08/18 12:07:29 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_statblks: Hasfield i_sysstat ?MAKE: -pick add $@ %< ?S:d_statblks: ?S: This variable conditionally defines USE_STAT_BLOCKS ?S: if this system has a stat structure declaring ?S: st_blksize and st_blocks. ?S:. ?C:USE_STAT_BLOCKS (STATBLOCKS): ?C: This symbol is defined if this system has a stat structure declaring ?C: st_blksize and st_blocks. ?C:. ?H:?%<:#ifndef USE_STAT_BLOCKS ?H:?%<:#$d_statblks USE_STAT_BLOCKS /**/ ?H:?%<:#endif ?H:. ?LINT:set d_statblks : see if stat knows about block sizes echo " " echo "Checking to see if your struct stat has st_blocks field..." >&4 set d_statblks stat st_blocks $i_sysstat sys/stat.h eval $hasfield metaconfig-debian-perl-5.26.1/U/modified/d_strerror.U000066400000000000000000000115651316016665300224170ustar00rootroot00000000000000?RCS: $Id: d_strerror.U,v 3.0.1.3 1994/05/13 15:20:27 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_strerror.U,v $ ?RCS: Revision 3.0.1.3 1994/05/13 15:20:27 ram ?RCS: patch27: now uses new macro support for cleaner Strerror def ?RCS: ?RCS: Revision 3.0.1.2 1994/05/06 14:58:26 ram ?RCS: patch23: renamed strerror into Strerror to protect name space (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:08:56 ram ?RCS: patch16: protected code looking for sys_errnolist[] with @if ?RCS: patch16: added default value for d_sysernlst ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:35 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_strerror d_syserrlst d_sysernlst d_strerrm: contains Csym Findhdr ?MAKE: -pick add $@ %< ?S:d_strerror: ?S: This variable conditionally defines HAS_STRERROR if strerror() is ?S: available to translate error numbers to strings. ?S:. ?S:d_syserrlst: ?S: This variable conditionally defines HAS_SYS_ERRLIST if sys_errlist[] is ?S: available to translate error numbers to strings. ?S:. ?S:d_sysernlst: ?S: This variable conditionally defines HAS_SYS_ERRNOLIST if sys_errnolist[] ?S: is available to translate error numbers to the symbolic name. ?S:. ?S:d_strerrm: ?S: This variable holds what Strerror is defined as to translate an error ?S: code condition into an error message string. It could be 'strerror' ?S: or a more complex macro emulating strerror with sys_errlist[], or the ?S: "unknown" string when both strerror and sys_errlist are missing. ?S:. ?C:HAS_STRERROR (STRERROR): ?C: This symbol, if defined, indicates that the strerror routine is ?C: available to translate error numbers to strings. See the writeup ?C: of Strerror() in this file before you try to define your own. ?C:. ?C:HAS_SYS_ERRLIST (SYSERRLIST): ?C: This symbol, if defined, indicates that the sys_errlist array is ?C: available to translate error numbers to strings. The extern int ?C: sys_nerr gives the size of that table. ?C:. ?C:HAS_SYS_ERRNOLIST (SYSERRNOLIST): ?C: This symbol, if defined, indicates that the sys_errnolist array is ?C: available to translate an errno code into its symbolic name (e.g. ?C: ENOENT). The extern int sys_nerrno gives the size of that table. ?C:. ?C:Strerror: ?C: This preprocessor symbol is defined as a macro if strerror() is ?C: not available to translate error numbers to strings but sys_errlist[] ?C: array is there. ?C:. ?H:#$d_strerror HAS_STRERROR /**/ ?H:#$d_syserrlst HAS_SYS_ERRLIST /**/ ?H:#$d_sysernlst HAS_SYS_ERRNOLIST /**/ ?H:#define Strerror(e) $d_strerrm ?H:. ?D:d_sysernlst='' ?T:xxx val : see if strerror and/or sys_errlist[] exist echo " " ?X: MPE/iX needs this protection of hint values. ?X: Background: strerror exists in kernel but not in libc. ?X: Scanning the kernel for symbols would be a bad idea, however, ?X: because many symbols that look unix-ish exist in the kernel. ?X: The stress is on the 'look'. ?X: --jhi 9/1998 if test "X$d_strerror" = X -o "X$d_syserrlst" = X; then if set strerror val -f d_strerror; eval $csym; $val; then echo 'strerror() found.' >&4 d_strerror="$define" d_strerrm='strerror(e)' if set sys_errlist val -a d_syserrlst; eval $csym; $val; then echo "(You also have sys_errlist[], so we could roll our own strerror.)" d_syserrlst="$define" else echo "(Since you don't have sys_errlist[], strerror() is welcome.)" d_syserrlst="$undef" fi elif xxx=`./findhdr string.h`; test "$xxx" || xxx=`./findhdr strings.h`; \ $contains '#[ ]*define.*strerror' "$xxx" >/dev/null 2>&1; then echo 'strerror() found in string header.' >&4 d_strerror="$define" d_strerrm='strerror(e)' if set sys_errlist val -a d_syserrlst; eval $csym; $val; then echo "(Most probably, strerror() uses sys_errlist[] for descriptions.)" d_syserrlst="$define" else echo "(You don't appear to have any sys_errlist[], how can this be?)" d_syserrlst="$undef" fi elif set sys_errlist val -a d_syserrlst; eval $csym; $val; then echo "strerror() not found, but you have sys_errlist[] so we'll use that." >&4 d_strerror="$undef" d_syserrlst="$define" d_strerrm='((e)<0||(e)>=sys_nerr?"unknown":sys_errlist[e])' else echo 'strerror() and sys_errlist[] NOT found.' >&4 d_strerror="$undef" d_syserrlst="$undef" d_strerrm='"unknown"' fi fi @if d_sysernlst || HAS_SYS_ERRNOLIST if set sys_errnolist val -a d_sysernlst; eval $csym; $val; then echo "(Symbolic error codes can be fetched via the sys_errnolist[] array.)" d_sysernlst="$define" else echo "(However, I can't extract the symbolic error code out of errno.)" d_sysernlst="$undef" fi @end metaconfig-debian-perl-5.26.1/U/modified/d_strtoul.U000066400000000000000000000057451316016665300222540ustar00rootroot00000000000000?RCS: $Id: d_strtoul.U,v 3.0.1.1 1997/02/28 15:46:43 ram Exp $ ?RCS: ?RCS: Copyright (c) 1996, Andy Dougherty ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_strtoul.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:46:43 ram ?RCS: patch61: created ?RCS: ?RCS: ?MAKE:d_strtoul: Inlibc cat longsize Compile run ?MAKE: -pick add $@ %< ?S:d_strtoul: ?S: This variable conditionally defines the HAS_STRTOUL symbol, which ?S: indicates to the C program that the strtoul() routine is available ?S: to provide conversion of strings to unsigned long. ?S:. ?C:HAS_STRTOUL (STRTOUL): ?C: This symbol, if defined, indicates that the strtoul routine is ?C: available to provide conversion of strings to unsigned long. ?C:. ?H:#$d_strtoul HAS_STRTOUL /**/ ?H:. ?F:!try : see if strtoul exists set strtoul d_strtoul eval $inlibc case "$d_strtoul" in "$define") $cat <try.c <<'EOCP' #include #include extern unsigned long int strtoul(char *s, char **, int); static int bad = 0; void check(char *s, unsigned long eul, int een) { unsigned long gul; errno = 0; gul = strtoul(s, 0, 10); if (!((gul == eul) && (errno == een))) bad++; } int main() { check(" 1", 1L, 0); check(" 0", 0L, 0); EOCP case "$longsize" in 8) $cat >>try.c <<'EOCP' check("18446744073709551615", 18446744073709551615UL, 0); check("18446744073709551616", 18446744073709551615UL, ERANGE); #if 0 /* strtoul() for /^-/ strings is undefined. */ check("-1", 18446744073709551615UL, 0); check("-18446744073709551614", 2, 0); check("-18446744073709551615", 1, 0); check("-18446744073709551616", 18446744073709551615UL, ERANGE); check("-18446744073709551617", 18446744073709551615UL, ERANGE); #endif EOCP ;; 4) $cat >>try.c <<'EOCP' check("4294967295", 4294967295UL, 0); check("4294967296", 4294967295UL, ERANGE); #if 0 /* strtoul() for /^-/ strings is undefined. */ check("-1", 4294967295UL, 0); check("-4294967294", 2, 0); check("-4294967295", 1, 0); check("-4294967296", 4294967295UL, ERANGE); check("-4294967297", 4294967295UL, ERANGE); #endif EOCP ;; *) : Should we write these tests to be more portable by sprintf-ing : ~0 and then manipulating that char string as input for strtol? ;; esac $cat >>try.c <<'EOCP' if (!bad) printf("ok\n"); return 0; } EOCP set try if eval $compile; then case "`$run ./try`" in ok) echo "Your strtoul() seems to be working okay." ;; *) cat <&4 Your strtoul() doesn't seem to be working okay. EOM d_strtoul="$undef" ;; esac else echo "(I can't seem to compile the test program--assuming it doesn't)" d_strtoul="$undef" fi ;; esac metaconfig-debian-perl-5.26.1/U/modified/d_union_semun.U000066400000000000000000000136571316016665300231000ustar00rootroot00000000000000?RCS: $Id: d_union_semun.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_union_semun.U,v $ ?RCS: ?MAKE:d_union_semun d_semctl_semun d_semctl_semid_ds: Compile Setvar Myread run \ cat rm_try d_sem ?MAKE: -pick add $@ %< ?S:d_union_semun: ?S: This variable conditionally defines HAS_UNION_SEMUN if the ?S: union semun is defined by including . ?S:. ?S:d_semctl_semun: ?S: This variable conditionally defines USE_SEMCTL_SEMUN, which ?S: indicates that union semun is to be used for semctl IPC_STAT. ?S:. ?S:d_semctl_semid_ds: ?S: This variable conditionally defines USE_SEMCTL_SEMID_DS, which ?S: indicates that struct semid_ds * is to be used for semctl IPC_STAT. ?S:. ?C:HAS_UNION_SEMUN: ?C: This symbol, if defined, indicates that the union semun is ?C: defined by including . If not, the user code ?C: probably needs to define it as: ?C: union semun { ?C: int val; ?C: struct semid_ds *buf; ?C: unsigned short *array; ?C: } ?C:. ?C:USE_SEMCTL_SEMUN: ?C: This symbol, if defined, indicates that union semun is ?C: used for semctl IPC_STAT. ?C:. ?C:USE_SEMCTL_SEMID_DS: ?C: This symbol, if defined, indicates that struct semid_ds * is ?C: used for semctl IPC_STAT. ?C:. ?H:#$d_union_semun HAS_UNION_SEMUN /**/ ?H:#$d_semctl_semun USE_SEMCTL_SEMUN /**/ ?H:#$d_semctl_semid_ds USE_SEMCTL_SEMID_DS /**/ ?H:. ?T:xxx also ?F:!try ?LINT: set d_union_semun d_semctl_semun d_semctl_semid_ds : see whether sys/sem.h defines union semun echo " " $cat > try.c <<'END' #include #include #include int main () { union semun semun; semun.buf = 0; } END set try if eval $compile; then echo "You have union semun in ." >&4 val="$define" else echo "You do not have union semun in ." >&4 val="$undef" fi $rm_try set d_union_semun eval $setvar : see how to do semctl IPC_STAT case "$d_sem" in $define) echo " " ?X: use tryh.h instead of try.h because $rm_try cleans up try.* $cat > tryh.h <>3) # define S_IWGRP (S_IWUSR>>3) # define S_IXGRP (S_IXUSR>>3) # define S_IROTH (S_IRUSR>>6) # define S_IWOTH (S_IWUSR>>6) # define S_IXOTH (S_IXUSR>>6) #endif #ifndef S_IRWXU # define S_IRWXU (S_IRUSR|S_IWUSR|S_IXUSR) # define S_IRWXG (S_IRGRP|S_IWGRP|S_IXGRP) # define S_IRWXO (S_IROTH|S_IWOTH|S_IXOTH) #endif END : see whether semctl IPC_STAT can use union semun case "$d_semctl_semun" in '') val="$undef" $cat > try.c < #include #include #include #include #include #include "tryh.h" #ifndef errno extern int errno; #endif #$d_union_semun HAS_UNION_SEMUN int main() { union semun #ifndef HAS_UNION_SEMUN { int val; struct semid_ds *buf; unsigned short *array; } #endif arg; int sem, st; #if defined(IPC_PRIVATE) && defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO) && defined(IPC_CREAT) sem = semget(IPC_PRIVATE, 1, S_IRWXU|S_IRWXG|S_IRWXO|IPC_CREAT); if (sem > -1) { struct semid_ds argbuf; arg.buf = &argbuf; # ifdef IPC_STAT st = semctl(sem, 0, IPC_STAT, arg); if (st == 0) printf("semun\n"); else # endif /* IPC_STAT */ printf("semctl IPC_STAT failed: errno = %d\n", errno); # ifdef IPC_RMID if (semctl(sem, 0, IPC_RMID, arg) != 0) # endif /* IPC_RMID */ printf("semctl IPC_RMID failed: errno = %d\n", errno); } else #endif /* IPC_PRIVATE && ... */ printf("semget failed: errno = %d\n", errno); return 0; } END set try if eval $compile; then xxx=`$run ./try` case "$xxx" in semun) val="$define" ;; esac fi $rm_try set d_semctl_semun eval $setvar ;; esac case "$d_semctl_semun" in $define) echo "You can use union semun for semctl IPC_STAT." >&4 also='also' ;; *) echo "You cannot use union semun for semctl IPC_STAT." >&4 also='' ;; esac : see whether semctl IPC_STAT can use struct semid_ds pointer case "$d_semctl_semid_ds" in '') val="$undef" $cat > try.c <<'END' #include #include #include #include #include "tryh.h" #include #include #ifndef errno extern int errno; #endif int main() { struct semid_ds arg; int sem, st; #if defined(IPC_PRIVATE) && defined(S_IRWXU) && defined(S_IRWXG) && defined(S_IRWXO) && defined(IPC_CREAT) sem = semget(IPC_PRIVATE, 1, S_IRWXU|S_IRWXG|S_IRWXO|IPC_CREAT); if (sem > -1) { # ifdef IPC_STAT st = semctl(sem, 0, IPC_STAT, &arg); if (st == 0) printf("semid_ds\n"); else # endif /* IPC_STAT */ printf("semctl IPC_STAT failed: errno = %d\n", errno); # ifdef IPC_RMID if (semctl(sem, 0, IPC_RMID, &arg) != 0) # endif /* IPC_RMID */ printf("semctl IPC_RMID failed: errno = %d\n", errno); } else #endif /* IPC_PRIVATE && ... */ printf("semget failed: errno = %d\n", errno); return 0; } END set try if eval $compile; then xxx=`$run ./try` case "$xxx" in semid_ds) val="$define" ;; esac fi $rm_try set d_semctl_semid_ds eval $setvar ;; esac case "$d_semctl_semid_ds" in $define) echo "You can $also use struct semid_ds* for semctl IPC_STAT." >&4 ;; *) echo "You cannot use struct semid_ds* for semctl IPC_STAT." >&4 ;; esac ;; *) val="$undef" # We do not have the full sem*(2) library, so assume we can not # use either. set d_semctl_semun eval $setvar set d_semctl_semid_ds eval $setvar ;; esac $rm_try tryh.h metaconfig-debian-perl-5.26.1/U/modified/d_vfork.U000066400000000000000000000065271316016665300216660ustar00rootroot00000000000000?RCS: $Id: d_vfork.U,v 3.0.1.6 1994/08/29 16:18:21 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_vfork.U,v $ ?RCS: Revision 3.0.1.6 1994/08/29 16:18:21 ram ?RCS: patch32: set default to 'y' the first time ?RCS: ?RCS: Revision 3.0.1.5 1994/06/20 06:59:14 ram ?RCS: patch30: usevfork was not always properly set ?RCS: ?RCS: Revision 3.0.1.4 1994/05/13 15:20:56 ram ?RCS: patch27: modified to avoid spurious Whoa warnings (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/05/06 14:59:09 ram ?RCS: patch23: now explicitly ask whether vfork() should be used (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1993/10/16 13:49:39 ram ?RCS: patch12: added magic for vfork() ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 16:06:57 ram ?RCS: patch10: removed automatic remapping of vfork on fork (WAD) ?RCS: patch10: added compatibility code for older config.sh (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:55 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_vfork usevfork d_pseudofork: Inlibc Myread Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_vfork: ?S: This variable conditionally defines the HAS_VFORK symbol, which ?S: indicates the vfork() routine is available. ?S:. ?S:usevfork: ?S: This variable is set to true when the user accepts to use vfork. ?S: It is set to false when no vfork is available or when the user ?S: explicitly requests not to use vfork. ?S:. ?S:d_pseudofork: ?S: This variable conditionally defines the HAS_PSEUDOFORK symbol, ?S: which indicates that an emulation of the fork routine is available. ?S:. ?C:HAS_VFORK (VFORK): ?C: This symbol, if defined, indicates that vfork() exists. ?C:. ?H:#$d_vfork HAS_VFORK /**/ ?H:. ?C:HAS_PSEUDOFORK: ?C: This symbol, if defined, indicates that an emulation of the ?C: fork routine is available. ?C:. ?H:#$d_pseudofork HAS_PSEUDOFORK /**/ ?H:. ?M:vfork: HAS_VFORK ?M:#ifndef HAS_VFORK ?M:#define vfork fork ?M:#endif ?M:. ?T:d_hvfork : backward compatibility for d_hvfork if test X$d_hvfork != X; then d_vfork="$d_hvfork" d_hvfork='' fi ?X:========================== : see if there is a vfork val='' set vfork val eval $inlibc d_pseudofork=$undef : Ok, but do we want to use it. vfork is reportedly unreliable in : perl on Solaris 2.x, and probably elsewhere. case "$val" in $define) echo " " case "$usevfork" in false) dflt='n';; *) dflt='y';; esac cat <<'EOM' Perl can only use a vfork() that doesn't suffer from strict restrictions on calling functions or modifying global data in the child. For example, glibc-2.1 contains such a vfork() that is unsuitable. If your system provides a proper fork() call, chances are that you do NOT want perl to use vfork(). EOM rp="Do you still want to use vfork()?" . ./myread case "$ans" in y|Y) ;; *) echo "Ok, we won't use vfork()." val="$undef" ;; esac ;; esac ?X: ?X: Only set it when final value is known to avoid spurious Whoa's ?X: Then set usevfork accordingly to the current value, for next run ?X: set d_vfork eval $setvar case "$d_vfork" in $define) usevfork='true';; *) usevfork='false';; esac metaconfig-debian-perl-5.26.1/U/modified/d_voidsig.U000066400000000000000000000067261316016665300222040ustar00rootroot00000000000000?RCS: $Id: d_voidsig.U,v 3.0.1.3 1995/05/12 12:12:46 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_voidsig.U,v $ ?RCS: Revision 3.0.1.3 1995/05/12 12:12:46 ram ?RCS: patch54: made cppflags dependency optional ?RCS: ?RCS: Revision 3.0.1.2 1994/08/29 16:20:35 ram ?RCS: patch32: now sets signal_t only once d_voidsig is known (WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 06:59:54 ram ?RCS: patch30: now properly sets signal_t when re-using previous value ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:56 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_voidsig signal_t: rm contains cppstdin cppminus +cppflags test Myread \ Oldconfig Setvar Findhdr ?MAKE: -pick add $@ %< ?S:d_voidsig: ?S: This variable conditionally defines VOIDSIG if this system ?S: declares "void (*signal(...))()" in signal.h. The old way was to ?S: declare it as "int (*signal(...))()". ?S:. ?S:signal_t: ?S: This variable holds the type of the signal handler (void or int). ?S:. ?C:VOIDSIG: ?C: This symbol is defined if this system declares "void (*signal(...))()" in ?C: signal.h. The old way was to declare it as "int (*signal(...))()". It ?C: is up to the package author to declare things correctly based on the ?C: symbol. ?C:. ?C:Signal_t (SIGNAL_T): ?C: This symbol's value is either "void" or "int", corresponding to the ?C: appropriate return type of a signal handler. Thus, you can declare ?C: a signal handler using "Signal_t (*handler)()", and define the ?C: handler using "Signal_t handler(sig)". ?C:. ?H:#$d_voidsig VOIDSIG /**/ ?H:#define Signal_t $signal_t /* Signal handler's return type */ ?H:. ?T:xxx ?LINT:set d_voidsig : see if signal is declared as pointer to function returning int or void echo " " xxx=`./findhdr signal.h` $test "$xxx" && $cppstdin $cppminus $cppflags < $xxx >$$.tmp 2>/dev/null if $contains 'int.*\*[ ]*signal' $$.tmp >/dev/null 2>&1 ; then echo "You have int (*signal())() instead of void." >&4 val="$undef" elif $contains 'void.*\*[ ]*signal' $$.tmp >/dev/null 2>&1 ; then echo "You have void (*signal())()." >&4 val="$define" elif $contains 'extern[ ]*[(\*]*signal' $$.tmp >/dev/null 2>&1 ; then echo "You have int (*signal())() instead of void." >&4 val="$undef" ?X: This next test is kind of sloppy, but it catches Linux ?X: which has a ?X: typedef void (*__sighandler_t) (int) ; ?X: A better fix would be to compile a C program with the proper ?X: prototype, but since nearly everyone uses void, we'll just go with ?X: this. elif $contains 'void.*\*.*sig' $$.tmp >/dev/null 2>&1 ; then echo "You have void (*signal())()." >&4 val="$define" else case "$d_voidsig" in '') echo "I can't determine whether signal handler returns void or int..." >&4 dflt=void rp="What type does your signal handler return?" . ./myread case "$ans" in v*) val="$define";; *) val="$undef";; esac;; "$define") echo "As you already told me, signal handler returns void." >&4 val="$define" ;; *) echo "As you already told me, signal handler returns int." >&4 val="$undef" ;; esac fi set d_voidsig eval $setvar case "$d_voidsig" in "$define") signal_t="void";; *) signal_t="int";; esac $rm -f $$.tmp metaconfig-debian-perl-5.26.1/U/modified/d_volatile.U000066400000000000000000000040751316016665300223520ustar00rootroot00000000000000?RCS: $Id: d_volatile.U,v 3.0.1.2 1995/07/25 14:08:49 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_volatile.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 14:08:49 ram ?RCS: patch56: made cc and ccflags optional dependencies ?RCS: ?RCS: Revision 3.0.1.1 1993/09/09 11:49:51 ram ?RCS: patch9: volatile definition was swapped over with undef ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_volatile: cat +cc +ccflags rm_try Setvar ?MAKE: -pick add $@ %< ?S:d_volatile: ?S: This variable conditionally defines the HASVOLATILE symbol, which ?S: indicates to the C program that this C compiler knows about the ?S: volatile declaration. ?S:. ?C:HASVOLATILE ~ %<: ?C: This symbol, if defined, indicates that this C compiler knows about ?C: the volatile declaration. ?C:. ?H:?%<:#$d_volatile HASVOLATILE /**/ ?H:?%<:#ifndef HASVOLATILE ?H:?%<:#define volatile ?H:?%<:#endif ?H:. ?W:%<:volatile ?LINT:set d_volatile ?LINT:known volatile : check for volatile keyword echo " " echo 'Checking to see if your C compiler knows about "volatile"...' >&4 $cat >try.c <<'EOCP' int main() { ?X: ?X: The following seven lines added by Bill Campbell ?X: detect that MIPS compilers do not handle volatile in all situations. ?X: typedef struct _goo_struct goo_struct; goo_struct * volatile goo = ((goo_struct *)0); struct _goo_struct { long long_int; int reg_int; char char_var; }; typedef unsigned short foo_t; char *volatile foo; volatile int bar; volatile foo_t blech; foo = foo; } EOCP if $cc -c $ccflags try.c >/dev/null 2>&1 ; then val="$define" echo "Yup, it does." else val="$undef" echo "Nope, it doesn't." fi set d_volatile eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/modified/i_dirent.U000066400000000000000000000110611316016665300220160ustar00rootroot00000000000000?RCS: $Id: i_dirent.U,v 3.0.1.4 1994/10/29 16:20:01 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: i_dirent.U,v $ ?RCS: Revision 3.0.1.4 1994/10/29 16:20:01 ram ?RCS: patch36: failed scanning for 'd_namlen' with missing (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/06/20 07:01:25 ram ?RCS: patch30: added direntrytype for hints, merely for NeXT (ADO) ?RCS: patch30: now checks for both struct dirent and direct (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/05/13 15:22:37 ram ?RCS: patch27: new variable direntrytype for proper type setting (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:11:15 ram ?RCS: patch16: added new Direntry_t pseudo-type for directory entries ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:17 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit looks whether there is a dirent system or not ?X: ?MAKE:i_dirent d_dirnamlen direntrytype: test contains Setvar \ Myread Findhdr cppstdin cppflags cppminus rm_try ?MAKE: -pick add $@ %< ?S:i_dirent: ?S: This variable conditionally defines I_DIRENT, which indicates ?S: to the C program that it should include . ?S:. ?S:d_dirnamlen: ?S: This variable conditionally defines DIRNAMLEN, which indicates ?S: to the C program that the length of directory entry names is ?S: provided by a d_namelen field. ?S:. ?S:direntrytype: ?S: This symbol is set to 'struct direct' or 'struct dirent' depending on ?S: whether dirent is available or not. You should use this pseudo type to ?S: portably declare your directory entries. ?S:. ?C:I_DIRENT: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . Using this symbol also triggers the definition ?C: of the Direntry_t define which ends up being 'struct dirent' or ?C: 'struct direct' depending on the availability of . ?C:. ?C:DIRNAMLEN: ?C: This symbol, if defined, indicates to the C program that the length ?C: of directory entry names is provided by a d_namlen field. Otherwise ?C: you need to do strlen() on the d_name field. ?C:. ?C:Direntry_t: ?C: This symbol is set to 'struct direct' or 'struct dirent' depending on ?C: whether dirent is available or not. You should use this pseudo type to ?C: portably declare your directory entries. ?C:. ?H:#$i_dirent I_DIRENT /**/ ?H:#$d_dirnamlen DIRNAMLEN /**/ ?H:?%<:@if I_DIRENT && Direntry_t ?H:?%<:#define Direntry_t $direntrytype ?H:?%<:@end ?H:. ?T:xinc guess1 guess2 ?LINT:set i_dirent d_dirnamlen : see if this is a dirent system echo " " if xinc=`./findhdr dirent.h`; $test "$xinc"; then val="$define" echo " found." >&4 else val="$undef" if xinc=`./findhdr sys/dir.h`; $test "$xinc"; then echo " found." >&4 echo " " else xinc=`./findhdr sys/ndir.h` fi echo " NOT found." >&4 fi set i_dirent eval $setvar ?X: Use struct dirent or struct direct? If we're using dirent.h, ?X: it's probably struct dirent, but apparently not always. ?X: Assume $xinc still contains the name of the header file we're using. @if direntrytype || Direntry_t : Look for type of directory structure. echo " " $cppstdin $cppflags $cppminus < "$xinc" > try.c case "$direntrytype" in ''|' ') case "$i_dirent" in $define) guess1='struct dirent' ;; *) guess1='struct direct' ;; esac ;; *) guess1="$direntrytype" ;; esac case "$guess1" in 'struct dirent') guess2='struct direct' ;; *) guess2='struct dirent' ;; esac if $contains "$guess1" try.c >/dev/null 2>&1; then direntrytype="$guess1" echo "Your directory entries are $direntrytype." >&4 elif $contains "$guess2" try.c >/dev/null 2>&1; then direntrytype="$guess2" echo "Your directory entries seem to be $direntrytype." >&4 else echo "I don't recognize your system's directory entries." >&4 rp="What type is used for directory entries on this system?" dflt="$guess1" . ./myread direntrytype="$ans" fi $rm_try @end @if d_dirnamlen || DIRNAMLEN : see if the directory entry stores field length echo " " $cppstdin $cppflags $cppminus < "$xinc" > try.c if $contains 'd_namlen' try.c >/dev/null 2>&1; then echo "Good, your directory entry keeps length information in d_namlen." >&4 val="$define" else echo "Your directory entry does not know about the d_namlen field." >&4 val="$undef" fi set d_dirnamlen eval $setvar $rm_try @end metaconfig-debian-perl-5.26.1/U/modified/i_execinfo.U000066400000000000000000000016641316016665300223410ustar00rootroot00000000000000?RCS: $Id: i_execinfo.U 34 2010-11-27 11:55:39Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 2011, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?MAKE:i_execinfo: Inhdr ?MAKE: -pick add $@ %< ?S:i_execinfo: ?S: This variable conditionally defines the I_EXECINFO symbol, and indicates ?S: whether a C program may include , for backtrace() support. ?S:. ?C:I_EXECINFO: ?C: This symbol, if defined, indicates to the C program that it should ?C: include for backtrace() support. ?C:. ?H:#$i_execinfo I_EXECINFO /**/ ?H:. ?LINT:set i_execinfo : see if this is an execinfo.h system set execinfo.h i_execinfo eval $inhdr metaconfig-debian-perl-5.26.1/U/modified/i_grp.U000066400000000000000000000032551316016665300213270ustar00rootroot00000000000000?RCS: $Id: i_grp.U,v 3.0 1993/08/18 12:08:20 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: GRPASSWD detection added by Andy Dougherty July 14, 1998. ?RCS: ?RCS: $Log: i_grp.U,v $ ?RCS: Revision 3.0 1993/08/18 12:08:20 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:i_grp d_grpasswd: \ contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar ?MAKE: -pick add $@ %< ?S:i_grp: ?S: This variable conditionally defines the I_GRP symbol, and indicates ?S: whether a C program should include . ?S:. ?S:d_grpasswd: ?S: This variable conditionally defines GRPASSWD, which indicates ?S: that struct group in contains gr_passwd. ?S:. ?C:I_GRP: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?C:GRPASSWD: ?C: This symbol, if defined, indicates to the C program that struct group ?C: in contains gr_passwd. ?C:. ?H:#$i_grp I_GRP /**/ ?H:#$d_grpasswd GRPASSWD /**/ ?H:. ?LINT:set i_grp d_grpasswd ?T: xxx : see if this is an grp system set grp.h i_grp eval $inhdr case "$i_grp" in $define) xxx=`./findhdr grp.h` $cppstdin $cppflags $cppminus < $xxx >$$.h if $contains 'gr_passwd' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_grpasswd eval $setvar $rm -f $$.h ;; *) val="$undef"; set d_grpasswd; eval $setvar ;; esac metaconfig-debian-perl-5.26.1/U/modified/i_malloc.U000066400000000000000000000031651316016665300220060ustar00rootroot00000000000000?RCS: $Id: i_malloc.U,v 3.1 2003/01/21 18:51:51 merijn Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: i_malloc.U,v $ ?RCS: Revision 3.1 2003/01/21 18:51:51 merijn ?RCS: Moved to modified: Ihdr replaced with Compile ?RCS: ?RCS: $Log: i_malloc.U,v $ ?RCS: Revision 3.0 1993/08/18 12:08:21 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:i_malloc: cat rm_try Compile Setvar i_mallocmalloc ?MAKE: -pick add $@ %< ?S:i_malloc: ?S: This variable conditionally defines the I_MALLOC symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_MALLOC: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_malloc I_MALLOC /**/ ?H:. ?LINT:set i_malloc : see if this is a malloc.h system : we want a real compile instead of Inhdr because some systems have a : malloc.h that just gives a compile error saying to use stdlib.h instead echo " " $cat >try.c < #include #$i_mallocmalloc I_MALLOCMALLOC #ifdef I_MALLOCMALLOC # include #endif int main () { return 0; } EOCP set try if eval $compile; then echo " found." >&4 val="$define" else echo " NOT found." >&4 val="$undef" fi $rm_try set i_malloc eval $setvar metaconfig-debian-perl-5.26.1/U/modified/i_ndbm.U000066400000000000000000000154161316016665300214610ustar00rootroot00000000000000?RCS: $Id: i_ndbm.U,v 3.0.1.1 1995/05/12 12:16:53 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: i_ndbm.U,v $ ?RCS: Revision 3.0.1.1 1995/05/12 12:16:53 ram ?RCS: patch54: made more robust by checking both header and lib (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:23 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:i_ndbm i_gdbmndbm i_gdbm_ndbm d_ndbm d_ndbm_h_uses_prototypes \ d_gdbmndbm_h_uses_prototypes d_gdbm_ndbm_h_uses_prototypes: \ Inhdr Inlibc Setvar test d_cplusplus extern_C echo Protochk ?MAKE: -pick add $@ %< ?S:i_ndbm: ?S: This variable conditionally defines the I_NDBM symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?C:I_NDBM: ?C: This symbol, if defined, indicates that exists and should ?C: be included. ?C:. ?S:i_gdbmndbm: ?S: This variable conditionally defines the I_GDBMNDBM symbol, which ?S: indicates to the C program that exists and should ?S: be included. This was the location of the ndbm.h compatibility file ?S: in RedHat 7.1. ?S:. ?C:I_GDBMNDBM: ?C: This symbol, if defined, indicates that exists and should ?C: be included. This was the location of the ndbm.h compatibility file ?C: in RedHat 7.1. ?C:. ?S:i_gdbm_ndbm: ?S: This variable conditionally defines the I_GDBM_NDBM symbol, which ?S: indicates to the C program that exists and should ?S: be included. This is the location of the ndbm.h compatibility file ?S: in Debian 4.0. ?S:. ?C:I_GDBM_NDBM: ?C: This symbol, if defined, indicates that exists and should ?C: be included. This is the location of the ndbm.h compatibility file ?C: in Debian 4.0. ?C:. ?S:d_ndbm: ?S: This variable conditionally defines the HAS_NDBM symbol, which ?S: indicates that both the ndbm.h include file and an appropriate ndbm ?S: library exist. Consult the different i_*ndbm variables ?S: to find out the actual include location. Sometimes, a system has the ?S: header file but not the library. This variable will only be set if ?S: the system has both. ?S:. ?C:HAS_NDBM: ?C: This symbol, if defined, indicates that some form of ndbm.h or compatibility ?C: include exists, along with the appropriate library. ?C:. ?S:d_ndbm_h_uses_prototypes: ?S: This variable conditionally defines the NDBM_H_USES_PROTOTYPES symbol, ?S: which indicates that the ndbm.h include file uses real ANSI C ?S: prototypes instead of K&R style function declarations. K&R style ?S: declarations are unsupported in C++, so the include file requires ?S: special handling when using a C++ compiler and this variable is ?S: undefined. Consult the different d_*ndbm_h_uses_prototypes variables ?S: to get the same information for alternative ndbm.h include files. ?S:. ?C:NDBM_H_USES_PROTOTYPES: ?C: This symbol, if defined, indicates that uses real ANSI C ?C: prototypes instead of K&R style function declarations without any ?C: parameter information. While ANSI C prototypes are supported in C++, ?C: K&R style function declarations will yield errors. ?C:. ?S:d_gdbmndbm_h_uses_prototypes: ?S: This variable conditionally defines the NDBM_H_USES_PROTOTYPES symbol, ?S: which indicates that the gdbm/ndbm.h include file uses real ANSI C ?S: prototypes instead of K&R style function declarations. K&R style ?S: declarations are unsupported in C++, so the include file requires ?S: special handling when using a C++ compiler and this variable is ?S: undefined. Consult the different d_*ndbm_h_uses_prototypes variables ?S: to get the same information for alternative ndbm.h include files. ?S:. ?C:GDBMNDBM_H_USES_PROTOTYPES: ?C: This symbol, if defined, indicates that uses real ANSI C ?C: prototypes instead of K&R style function declarations without any ?C: parameter information. While ANSI C prototypes are supported in C++, ?C: K&R style function declarations will yield errors. ?C:. ?S:d_gdbm_ndbm_h_uses_prototypes: ?S: This variable conditionally defines the NDBM_H_USES_PROTOTYPES symbol, ?S: which indicates that the gdbm-ndbm.h include file uses real ANSI C ?S: prototypes instead of K&R style function declarations. K&R style ?S: declarations are unsupported in C++, so the include file requires ?S: special handling when using a C++ compiler and this variable is ?S: undefined. Consult the different d_*ndbm_h_uses_prototypes variables ?S: to get the same information for alternative ndbm.h include files. ?S:. ?C:GDBM_NDBM_H_USES_PROTOTYPES: ?C: This symbol, if defined, indicates that uses real ANSI C ?C: prototypes instead of K&R style function declarations without any ?C: parameter information. While ANSI C prototypes are supported in C++, ?C: K&R style function declarations will yield errors. ?C:. ?H:#$i_ndbm I_NDBM /**/ ?H:#$i_gdbmndbm I_GDBMNDBM /**/ ?H:#$i_gdbm_ndbm I_GDBM_NDBM /**/ ?H:#$d_ndbm HAS_NDBM /**/ ?H:#$d_ndbm_h_uses_prototypes NDBM_H_USES_PROTOTYPES /**/ ?H:#$d_gdbmndbm_h_uses_prototypes GDBMNDBM_H_USES_PROTOTYPES /**/ ?H:#$d_gdbm_ndbm_h_uses_prototypes GDBM_NDBM_H_USES_PROTOTYPES /**/ ?H:. ?T:d_dbm_open name hdr ihdr ndbm_hdr_protochk ?LINT:set d_ndbm d_gdbmndbm_h_uses_prototypes d_gdbm_ndbm_h_uses_prototypes d_ndbm_h_uses_prototypes : see if ndbm.h is available set ndbm.h i_ndbm eval $inhdr : Compatibility location for RedHat 7.1 set gdbm/ndbm.h i_gdbmndbm eval $inhdr : Compatibility location for Debian 4.0 set gdbm-ndbm.h i_gdbm_ndbm eval $inhdr val="$undef" if $test "$i_ndbm" = "$define" -o "$i_gdbmndbm" = "$define" -o "$i_gdbm_ndbm" = "$define"; then : see if dbm_open exists set dbm_open d_dbm_open eval $inlibc case "$d_dbm_open" in $undef) i_ndbm="$undef" i_gdbmndbm="$undef" i_gdbm_ndbm="$undef" echo "We won't be including " val="$undef" ;; *) val="$define" ;; esac fi set d_ndbm eval $setvar ndbm_hdr_protochk='name=$1; hdr=$2; eval "ihdr=\$""i_$name"; val="$undef"; if $test "$ihdr" = "$define"; then $echo "Checking if your <$hdr> uses prototypes..." >&4; case "$d_cplusplus" in $define) ./protochk "$extern_C void dbm_close(DBM *);" literal "extern \"C\" {" $ihdr $hdr literal "}" && val="$define" ;; *) ./protochk "$extern_C void dbm_close(int, int);" $ihdr $hdr || val="$define" ;; esac; case "$val" in $define) $echo "Your <$hdr> seems to have prototypes";; *) $echo "Your <$hdr> does not seem to have prototypes";; esac; fi; set "d_${name}_h_uses_prototypes"; eval $setvar' set ndbm ndbm.h eval $ndbm_hdr_protochk set gdbmndbm gdbm/ndbm.h eval $ndbm_hdr_protochk set gdbm_ndbm gdbm-ndbm.h eval $ndbm_hdr_protochk metaconfig-debian-perl-5.26.1/U/modified/i_netdb.U000066400000000000000000000011751316016665300216320ustar00rootroot00000000000000?RCS: $Id: i_netdb.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_netdb: Inhdr ?MAKE: -pick add $@ %< ?S:i_netdb: ?S: This variable conditionally defines the I_NETDB symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_NETDB: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_netdb I_NETDB /**/ ?H:. ?LINT:set i_netdb : see if this is a netdb.h system set netdb.h i_netdb eval $inhdr metaconfig-debian-perl-5.26.1/U/modified/i_neterrno.U000066400000000000000000000033711316016665300223720ustar00rootroot00000000000000?RCS: $Id: i_neterrno.U,v 3.0.1.3 1994/10/29 16:20:29 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: i_neterrno.U,v $ ?RCS: Revision 3.0.1.3 1994/10/29 16:20:29 ram ?RCS: patch36: forgot to initialize 'val' to an empty value (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/08/29 16:22:10 ram ?RCS: patch32: removed spurious echo ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 07:02:05 ram ?RCS: patch30: created by ADO ?RCS: ?MAKE:i_neterrno: Inhdr +cc +ccflags rm_try Setvar ?MAKE: -pick add $@ %< ?S:i_neterrno: ?S: This variable conditionally defines the I_NET_ERRNO symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?C:I_NET_ERRNO: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_neterrno I_NET_ERRNO /**/ ?H:. ?LINT:set i_neterrno : see if net/errno.h is available val='' set net/errno.h val eval $inhdr : Unfortunately, it causes problems on some systems. Arrgh. case "$val" in $define) cat > try.c <<'EOM' #include #include #include int func() { return ENOTSOCK; } EOM if $cc $ccflags -c try.c >/dev/null 2>&1; then echo "We'll be including ." >&4 else echo "We won't be including ." >&4 val="$undef" fi $rm_try ;; esac set i_neterrno eval $setvar metaconfig-debian-perl-5.26.1/U/modified/i_pwd.U000066400000000000000000000117041316016665300213270ustar00rootroot00000000000000?RCS: $Id: i_pwd.U,v 3.0.1.2 1995/07/25 14:10:57 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: i_pwd.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 14:10:57 ram ?RCS: patch56: use setvar so hint file values can override our guesses (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:03:27 ram ?RCS: patch23: had forgotten cppminus in cppstdin test (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:25 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit checks whether there is a pwd system or not ?X: ?MAKE:i_pwd d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire \ d_pwgecos d_pwpasswd d_pwcomment: \ contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar ?MAKE: -pick add $@ %< ?S:i_pwd: ?S: This variable conditionally defines I_PWD, which indicates ?S: to the C program that it should include . ?S:. ?S:d_pwquota: ?S: This variable conditionally defines PWQUOTA, which indicates ?S: that struct passwd contains pw_quota. ?S:. ?S:d_pwage: ?S: This variable conditionally defines PWAGE, which indicates ?S: that struct passwd contains pw_age. ?S:. ?S:d_pwchange: ?S: This variable conditionally defines PWCHANGE, which indicates ?S: that struct passwd contains pw_change. ?S:. ?S:d_pwclass: ?S: This variable conditionally defines PWCLASS, which indicates ?S: that struct passwd contains pw_class. ?S:. ?S:d_pwexpire: ?S: This variable conditionally defines PWEXPIRE, which indicates ?S: that struct passwd contains pw_expire. ?S:. ?S:d_pwcomment: ?S: This variable conditionally defines PWCOMMENT, which indicates ?S: that struct passwd contains pw_comment. ?S:. ?S:d_pwgecos: ?S: This variable conditionally defines PWGECOS, which indicates ?S: that struct passwd contains pw_gecos. ?S:. ?S:d_pwpasswd: ?S: This variable conditionally defines PWPASSWD, which indicates ?S: that struct passwd contains pw_passwd. ?S:. ?C:I_PWD: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?C:PWQUOTA: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_quota. ?C:. ?C:PWAGE: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_age. ?C:. ?C:PWCHANGE: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_change. ?C:. ?C:PWCLASS: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_class. ?C:. ?C:PWEXPIRE: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_expire. ?C:. ?C:PWCOMMENT: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_comment. ?C:. ?C:PWGECOS: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_gecos. ?C:. ?C:PWPASSWD: ?C: This symbol, if defined, indicates to the C program that struct passwd ?C: contains pw_passwd. ?C:. ?H:#$i_pwd I_PWD /**/ ?H:#$d_pwquota PWQUOTA /**/ ?H:#$d_pwage PWAGE /**/ ?H:#$d_pwchange PWCHANGE /**/ ?H:#$d_pwclass PWCLASS /**/ ?H:#$d_pwexpire PWEXPIRE /**/ ?H:#$d_pwcomment PWCOMMENT /**/ ?H:#$d_pwgecos PWGECOS /**/ ?H:#$d_pwpasswd PWPASSWD /**/ ?H:. ?LINT: set i_pwd d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment ?LINT: set d_pwgecos d_pwpasswd ?T:xxx : see if this is a pwd.h system set pwd.h i_pwd eval $inhdr case "$i_pwd" in $define) xxx=`./findhdr pwd.h` $cppstdin $cppflags $cppminus < $xxx >$$.h if $contains 'pw_quota' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwquota eval $setvar if $contains 'pw_age' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwage eval $setvar if $contains 'pw_change' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwchange eval $setvar if $contains 'pw_class' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwclass eval $setvar if $contains 'pw_expire' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwexpire eval $setvar if $contains 'pw_comment' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwcomment eval $setvar if $contains 'pw_gecos' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwgecos eval $setvar if $contains 'pw_passwd' $$.h >/dev/null 2>&1; then val="$define" else val="$undef" fi set d_pwpasswd eval $setvar $rm -f $$.h ;; *) val="$undef"; set d_pwquota; eval $setvar set d_pwage; eval $setvar set d_pwchange; eval $setvar set d_pwclass; eval $setvar set d_pwexpire; eval $setvar set d_pwcomment; eval $setvar set d_pwgecos; eval $setvar set d_pwpasswd; eval $setvar ;; esac metaconfig-debian-perl-5.26.1/U/modified/i_sysuio.U000066400000000000000000000012211316016665300220610ustar00rootroot00000000000000?RCS: $Id: i_sysuio.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysuio: Inhdr ?MAKE: -pick add $@ %< ?S:i_sysuio: ?S: This variable conditionally defines the I_SYSUIO symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SYSUIO: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysuio I_SYSUIO /**/ ?H:. ?LINT:set i_sysuio : see if this is a sys/uio.h system set sys/uio.h i_sysuio eval $inhdr metaconfig-debian-perl-5.26.1/U/modified/i_termio.U000066400000000000000000000101021316016665300220230ustar00rootroot00000000000000?RCS: $Id: i_termio.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: i_termio.U,v $ ?RCS: Revision 3.0.1.4 1994/10/29 16:20:54 ram ?RCS: patch36: call ./usg and ./Cppsym explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0.1.3 1994/08/29 16:26:38 ram ?RCS: patch32: don't include all threee I_* symbols in config.h ?RCS: patch32: (had forgotten to undo this part last time) ?RCS: ?RCS: Revision 3.0.1.2 1994/05/13 15:25:03 ram ?RCS: patch27: undone ADO's fix in previous patch since it was useless ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:05:23 ram ?RCS: patch23: now include all three defines in config.h (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:44 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:i_termio i_sgtty i_termios: test Inlibc Cppsym Guess Setvar Findhdr Warn run ?MAKE: -pick add $@ %< ?S:i_termio: ?S: This variable conditionally defines the I_TERMIO symbol, which ?S: indicates to the C program that it should include rather ?S: than . ?S:. ?S:i_termios: ?S: This variable conditionally defines the I_TERMIOS symbol, which ?S: indicates to the C program that the POSIX file is ?S: to be included. ?S:. ?S:i_sgtty: ?S: This variable conditionally defines the I_SGTTY symbol, which ?S: indicates to the C program that it should include rather ?S: than . ?S:. ?C:I_TERMIO: ?C: This symbol, if defined, indicates that the program should include ?C: rather than . There are also differences in ?C: the ioctl() calls that depend on the value of this symbol. ?C:. ?C:I_TERMIOS: ?C: This symbol, if defined, indicates that the program should include ?C: the POSIX termios.h rather than sgtty.h or termio.h. ?C: There are also differences in the ioctl() calls that depend on the ?C: value of this symbol. ?C:. ?C:I_SGTTY: ?C: This symbol, if defined, indicates that the program should include ?C: rather than . There are also differences in ?C: the ioctl() calls that depend on the value of this symbol. ?C:. ?H:#$i_termio I_TERMIO /**/ ?H:#$i_termios I_TERMIOS /**/ ?H:#$i_sgtty I_SGTTY /**/ ?H:. ?T:val2 val3 ?LINT:set i_termio i_sgtty i_termios : see if this is a termio system val="$undef" val2="$undef" val3="$undef" ?X: Prefer POSIX-approved termios.h over all else if $test `./findhdr termios.h`; then set tcsetattr i_termios eval $inlibc val3="$i_termios" fi echo " " case "$val3" in "$define") echo "You have POSIX termios.h... good!" >&4;; *) if ./Cppsym pyr; then case "`$run /bin/universe`" in ucb) if $test `./findhdr sgtty.h`; then val2="$define" echo " found." >&4 else echo "System is pyramid with BSD universe." ./warn " not found--you could have problems." fi;; *) if $test `./findhdr termio.h`; then val="$define" echo " found." >&4 else echo "System is pyramid with USG universe." ./warn " not found--you could have problems." fi;; esac ?X: Start with USG to avoid problems if both usg/bsd was guessed elif ./usg; then if $test `./findhdr termio.h`; then echo " found." >&4 val="$define" elif $test `./findhdr sgtty.h`; then echo " found." >&4 val2="$define" else ./warn "Neither nor found--cross fingers!" fi else if $test `./findhdr sgtty.h`; then echo " found." >&4 val2="$define" elif $test `./findhdr termio.h`; then echo " found." >&4 val="$define" else ./warn "Neither nor found--cross fingers!" fi fi;; esac set i_termio; eval $setvar val=$val2; set i_sgtty; eval $setvar val=$val3; set i_termios; eval $setvar metaconfig-debian-perl-5.26.1/U/modified/i_varhdr.U000066400000000000000000000104671316016665300220300ustar00rootroot00000000000000?RCS: $Id: i_varhdr.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: i_varhdr.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:54:42 ram ?RCS: patch61: varargs script now starts with leading "startsh" ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:21:02 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/13 15:26:05 ram ?RCS: patch27: this unit now supersedes old i_stdarg.U and i_varargs.U ?RCS: patch27: modified to avoid spurious Whoa warnings (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:49 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:i_stdarg i_varargs i_varhdr: cat +cc +ccflags rm test Setvar \ Findhdr startsh _o ?MAKE: -pick add $@ %< ?S:i_stdarg: ?S: This variable conditionally defines the I_STDARG symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?S:i_varargs: ?S: This variable conditionally defines I_VARARGS, which indicates ?S: to the C program that it should include . ?S:. ?S:i_varhdr: ?S: Contains the name of the header to be included to get va_dcl definition. ?S: Typically one of varargs.h or stdarg.h. ?S:. ?C:I_STDARG: ?C: This symbol, if defined, indicates that exists and should ?C: be included. ?C:. ?C:I_VARARGS: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_stdarg I_STDARG /**/ ?H:#$i_varargs I_VARARGS /**/ ?H:. ?W:%<:va_dcl ?F:!varargs ?T:valstd ?LINT:set i_stdarg i_varargs ?X: ?X: Don't use setvar because the varargs test below might override these. ?X: Actually, the messages here are just informative. We don't wish to set ?X: i_varargs or i_stdarg to their final value before knowing which of the ?X: two we'll include. ?X: : see if stdarg is available echo " " if $test `./findhdr stdarg.h`; then echo " found." >&4 valstd="$define" else echo " NOT found." >&4 valstd="$undef" fi : see if varargs is available echo " " if $test `./findhdr varargs.h`; then echo " found." >&4 else echo " NOT found, but that's ok (I hope)." >&4 fi ?X: ?X: if you have stdarg.h, you need to support prototypes to actually use it; ?X: but if stdarg.h exists and the compiler doesn't support prototypes (for some ?X: bizarre reason), we'll fall back to varargs.h anyway so it's not so bad. ?X: : set up the varargs testing programs $cat > varargs.c < #endif #ifdef I_VARARGS #include #endif #ifdef I_STDARG int f(char *p, ...) #else int f(va_alist) va_dcl #endif { va_list ap; #ifndef I_STDARG char *p; #endif #ifdef I_STDARG va_start(ap,p); #else va_start(ap); p = va_arg(ap, char *); #endif va_end(ap); return 0; } EOP $cat > varargs </dev/null 2>&1; then echo "true" else echo "false" fi $rm -f varargs$_o EOP chmod +x varargs : now check which varargs header should be included echo " " i_varhdr='' val='' case "$valstd" in "$define") if `./varargs I_STDARG`; then val='stdarg.h' elif `./varargs I_VARARGS`; then val='varargs.h' fi ;; *) if `./varargs I_VARARGS`; then val='varargs.h' fi ;; esac case "$val" in '') echo " " echo "*** WHOA THERE!!! ***" >&4 echo " Your C compiler \"$cc\" doesn't seem to support stdarg or varargs!" >&4 case "$knowitall" in '') echo " I'm giving up; maybe you can try again with a different compiler?" >&4 exit 1 ;; esac echo "I could not find the definition for va_dcl... You have problems..." >&4 val="$undef"; set i_stdarg; eval $setvar val="$undef"; set i_varargs; eval $setvar ;; *) set i_varhdr eval $setvar case "$i_varhdr" in stdarg.h) val="$define"; set i_stdarg; eval $setvar val="$undef"; set i_varargs; eval $setvar ;; varargs.h) val="$undef"; set i_stdarg; eval $setvar val="$define"; set i_varargs; eval $setvar ;; esac echo "We'll include <$i_varhdr> to get va_dcl definition." >&4;; esac $rm -f varargs* metaconfig-debian-perl-5.26.1/U/modified/libc.U000066400000000000000000000323471316016665300211440ustar00rootroot00000000000000?RCS: $Id: libc.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: libc.U,v $ ?RCS: Revision 3.0.1.10 1997/02/28 15:56:48 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: patch61: added support for HPUX-10 nm output ?RCS: ?RCS: Revision 3.0.1.9 1995/07/25 14:11:56 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.8 1995/05/12 12:20:47 ram ?RCS: patch54: made sure only most recent version of shared lib is picked ?RCS: patch54: final "nm -p" check now uses xscan and xrun like everybody ?RCS: patch54: can now grok Linux nm output with lead __IO (ADO) ?RCS: patch54: added support for Linux ELF output, using 'W' for alias (ADO) ?RCS: ?RCS: Revision 3.0.1.7 1994/10/29 16:23:40 ram ?RCS: patch36: now looks for shared libraries before anything else (ADO) ?RCS: patch36: added new nm output format (ADO) ?RCS: ?RCS: Revision 3.0.1.6 1994/08/29 16:28:10 ram ?RCS: patch32: added I-type symbols for nm output parsing on Linux ?RCS: ?RCS: Revision 3.0.1.5 1994/06/20 07:03:24 ram ?RCS: patch30: checks are now presented by succession of if/elif ?RCS: patch30: uniformized checks for shared objects with new so symbol ?RCS: ?RCS: Revision 3.0.1.4 1994/05/06 15:06:33 ram ?RCS: patch23: added shared library knowledge (ADO and WED) ?RCS: ?RCS: Revision 3.0.1.3 1994/01/24 14:12:17 ram ?RCS: patch16: can now export nm_extract as an internal-use only variable ?RCS: ?RCS: Revision 3.0.1.2 1993/09/13 16:09:03 ram ?RCS: patch10: added special handling for Apollo systems (WAD) ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:40:03 ram ?RCS: patch7: added entry for /usr/shlib/libc.so (OSF/1 machines) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:libc +nm_extract: echo n c rm test grep Getfile Myread Oldconfig Loc \ sed libs incpath libpth ar runnm nm nm_opt nm_so_opt contains xlibpth \ so _a _o osname trnl tr sort uniq sysroot ?MAKE: -pick add $@ %< ?S:libc: ?S: This variable contains the location of the C library. ?S:. ?S:nm_extract: ?S: This variable holds the name of the extraction command used to process ?S: the output of nm and yield the list of defined symbols. It is used ?S: internally by Configure. ?S:. ?T:thislib try libnames xxx xscan xrun thisname com tans file ?F:!libnames !libc.tmp !tmp.imp ?LINT:extern PASE ?LINT:extern libnames ?LINT:change nm_opt ?INIT:libnames='' : Figure out where the libc is located case "$runnm" in true) ?X: indentation is wrong on purpose--RAM : get list of predefined functions in a handy place echo " " case "$libc" in '') libc=unknown case "$libs" in *-lc_s*) libc=`./loc libc_s$_a $libc $libpth` esac ;; esac case "$libs" in '') ;; *) for thislib in $libs; do case "$thislib" in -lc|-lc_s) : Handle C library specially below. ;; -l*) thislib=`echo $thislib | $sed -e 's/^-l//'` if try=`./loc lib$thislib.$so.'*' X $libpth`; $test -f "$try"; then : elif try=`./loc lib$thislib.$so X $libpth`; $test -f "$try"; then : elif try=`./loc lib$thislib$_a X $libpth`; $test -f "$try"; then : elif try=`./loc $thislib$_a X $libpth`; $test -f "$try"; then : elif try=`./loc lib$thislib X $libpth`; $test -f "$try"; then : elif try=`./loc $thislib X $libpth`; $test -f "$try"; then : elif try=`./loc Slib$thislib$_a X $xlibpth`; $test -f "$try"; then : else try='' fi libnames="$libnames $try" ;; *) libnames="$libnames $thislib" ;; esac done ;; esac ?X: ?X: Some systems (e.g. DG/UX) use "environmental" links, which make the test ?X: -f fail. Ditto for symbolic links. So in order to reliably check the ?X: existence of a file, we use test -r. It will still fail with DG/UX links ?X: though, but at least it will detect symbolic links. At some strategic ?X: points, we make use of (test -h), using a sub-shell in case builtin test ?X: does not implement the -h check for symbolic links. This makes it ?X: possible to preset libc in a hint file for instance and have it show up ?X: as-is in the question. ?X: xxx=normal case "$libc" in unknown) ?X: ?X: The sed below transforms .so.9 .so.12 into something like .so.0009 .so.0012, ?X: then sorts on it to allow keeping .so.12 instead of .so.9 as the latest ?X: up-to-date library. The initial filename (before sed munging, saved in hold ?X: space via 'h') is appended via 'G' before sorting, then the leading munged ?X: part is removed after sorting. Nice efficient work from Tye McQueen. ?X: The initial blurfl is here to prevent the trailing pipe from producing an ?X: empty string, causing Configure to output all its set variables! ?X: set /lib/libc.$so for xxx in $libpth; do $test -r $1 || set $xxx/libc.$so : The messy sed command sorts on library version numbers. $test -r $1 || \ set `echo blurfl; echo $xxx/libc.$so.[0-9]* | \ tr ' ' $trnl | egrep -v '\.[A-Za-z]*$' | $sed -e ' h s/[0-9][0-9]*/0000&/g s/0*\([0-9][0-9][0-9][0-9][0-9]\)/\1/g G s/\n/ /' | \ $sort | $sed -e 's/^.* //'` eval set \$$# done $test -r $1 || set $sysroot/usr/ccs/lib/libc.$so $test -r $1 || set $sysroot/lib/libsys_s$_a ;; *) ?X: ensure the test below for the (shared) C library will fail set blurfl ;; esac if $test -r "$1"; then echo "Your (shared) C library seems to be in $1." libc="$1" elif $test -r /lib/libc && $test -r /lib/clib; then ?X: ?X: Apollo has its C library in /lib/clib AND /lib/libc ?X: not to mention its math library in /lib/syslib... ?X: echo "Your C library seems to be in both /lib/clib and /lib/libc." xxx=apollo libc='/lib/clib /lib/libc' if $test -r /lib/syslib; then echo "(Your math library is in /lib/syslib.)" ?X: Put syslib in libc -- not quite right, but won't hurt libc="$libc /lib/syslib" fi elif $test -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then echo "Your C library seems to be in $libc, as you said before." ?X: For mips, and... elif $test -r $incpath/usr/lib/libc$_a; then libc=$incpath/usr/lib/libc$_a; echo "Your C library seems to be in $libc. That's fine." elif $test -r /lib/libc$_a; then libc=/lib/libc$_a; echo "Your C library seems to be in $libc. You're normal." else if tans=`./loc libc$_a blurfl/dyick $libpth`; $test -r "$tans"; then : elif tans=`./loc libc blurfl/dyick $libpth`; $test -r "$tans"; then libnames="$libnames "`./loc clib blurfl/dyick $libpth` elif tans=`./loc clib blurfl/dyick $libpth`; $test -r "$tans"; then : elif tans=`./loc Slibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then : elif tans=`./loc Mlibc$_a blurfl/dyick $xlibpth`; $test -r "$tans"; then : else tans=`./loc Llibc$_a blurfl/dyick $xlibpth` fi if $test -r "$tans"; then echo "Your C library seems to be in $tans, of all places." libc=$tans else libc='blurfl' fi fi if $test $xxx = apollo -o -r "$libc" || (test -h "$libc") >/dev/null 2>&1; then dflt="$libc" cat < libpath cat >&4 < libnames set X `cat libnames` shift xxx=files case $# in 1) xxx=file; esac echo "Extracting names from the following $xxx for later perusal:" >&4 echo " " $sed 's/^/ /' libnames >&4 echo " " $echo $n "This may take a while...$c" >&4 ?X: ?X: Linux may need the special Dynamic option to nm for shared libraries. ?X: In general, this is stored in the nm_so_opt variable. ?X: Unfortunately, that option may be fatal on non-shared libraries. ?X: for file in $*; do case $file in *$so*) $nm $nm_so_opt $nm_opt $file 2>/dev/null;; *) $nm $nm_opt $file 2>/dev/null;; esac done >libc.tmp $echo $n ".$c" ?X: ?X: To accelerate processing, we look at the correct 'sed' command ?X: by using a small subset of libc.tmp, i.e. fprintf function. ?X: When we know which sed command to use, do the name extraction ?X: $grep fprintf libc.tmp > libc.ptf ?X: ?X: In order to enhance readability and save some space, we define ?X: some variables that will be "eval"ed. ?X: xscan='eval "libc.list"; $echo $n ".$c" >&4' xrun='eval "libc.list"; echo "done." >&4' ?X: BSD-like output, I and W types added for Linux ?X: Some versions of Linux include a leading __IO in the symbol name. ?X: HP-UX 10 reportedly has trailing spaces, though I'm surprised it has ?X: BSD-like output. (AD). ?X: GNU extension: i is "indirect function" xxx='[ADTSIWi]' if com="$sed -n -e 's/__IO//' -e 's/^.* $xxx *//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun ?X: SYSV-like output elif com="$sed -n -e 's/^__*//' -e 's/^\([a-zA-Z_0-9$]*\).*xtern.*/\1/p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e '/|UNDEF/d' -e '/FUNC..GL/s/^.*|__*//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/^.* D __*//p' -e 's/^.* D //p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/^_//' -e 's/^\([a-zA-Z_0-9]*\).*xtern.*text.*/\1/p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$grep '|' | $sed -n -e '/|COMMON/d' -e '/|DATA/d' \ -e '/ file/d' -e 's/^\([^ ]*\).*/\1/p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/^.*|FUNC |GLOB .*|//p' -e 's/^.*|FUNC |WEAK .*|//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun ?X: mips nm output (sysV) elif com="$sed -n -e 's/^__//' -e '/|Undef/d' -e '/|Proc/s/ .*//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/^.*|Proc .*|Text *| *//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e '/Def. Text/s/.* \([^ ]*\)\$/\1/p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun ?X: OS/2 nm output elif com="$sed -n -e 's/^[-0-9a-f ]*_\(.*\)=.*/\1/p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun elif com="$sed -n -e 's/.*\.text n\ \ \ \.//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun ?X: AIX nm output elif com="sed -n -e 's/^__.*//' -e 's/[ ]*D[ ]*[0-9]*.*//p'";\ eval $xscan;\ $contains '^fprintf$' libc.list >/dev/null 2>&1; then eval $xrun else $nm -p $* 2>/dev/null >libc.tmp $grep fprintf libc.tmp > libc.ptf if com="$sed -n -e 's/^.* [ADTSIW] *_[_.]*//p' -e 's/^.* [ADTSIW] //p'";\ eval $xscan; $contains '^fprintf$' libc.list >/dev/null 2>&1 then nm_opt='-p' eval $xrun else echo " " echo "$nm didn't seem to work right. Trying $ar instead..." >&4 com='' if $ar t $libc > libc.tmp && \ $contains '^fprintf$' libc.tmp >/dev/null 2>&1 then for thisname in $libnames $libc; do $ar t $thisname >>libc.tmp done $sed -e "s/\\$_o\$//" < libc.tmp > libc.list echo "Ok." >&4 elif test "X$osname" = "Xos2" && $ar tv $libc > libc.tmp; then ?X: Repeat libc to extract forwarders to DLL entries too for thisname in $libnames $libc; do $ar tv $thisname >>libc.tmp ?X: Revision 50 of EMX has bug in ar: it will not extract forwarders ?X: to DLL entries. Use emximp which will extract exactly them. emximp -o tmp.imp $thisname \ 2>/dev/null && \ $sed -e 's/^\([_a-zA-Z0-9]*\) .*$/\1/p' \ < tmp.imp >>libc.tmp $rm -f tmp.imp done $sed -e "s/\\$_o\$//" -e 's/^ \+//' < libc.tmp > libc.list echo "Ok." >&4 else echo "$ar didn't seem to work right." >&4 echo "Maybe this is a Cray...trying bld instead..." >&4 if bld t $libc | \ $sed -e 's/.*\///' -e "s/\\$_o:.*\$//" > libc.list && $test -s libc.list then for thisname in $libnames; do bld t $libnames | \ $sed -e 's/.*\///' -e "s/\\$_o:.*\$//" >>libc.list $ar t $thisname >>libc.tmp done echo "Ok." >&4 else echo "That didn't work either. Giving up." >&4 exit 1 fi fi fi fi nm_extract="$com" case "$PASE" in define) echo " " echo "Since you are compiling for PASE, extracting more symbols from libc.a ...">&4 dump -Tv /lib/libc.a | awk '$7 == "/unix" {print $5 " " $8}' | grep "^SV" | awk '{print $2}' >> libc.list ;; *) if $test -f /lib/syscalls.exp; then echo " " echo "Also extracting names from /lib/syscalls.exp for good ole AIX..." >&4 $sed -n 's/^\([^ ]*\)[ ]*syscall[0-9]*[ ]*$/\1/p' \ /lib/syscalls.exp >>libc.list fi ;; esac ;; esac $rm -f libnames libpath metaconfig-debian-perl-5.26.1/U/modified/libpth.U000066400000000000000000000156071316016665300215150ustar00rootroot00000000000000?RCS: $Id: libpth.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: libpth.U,v $ ?RCS: Revision 3.0.1.6 1997/02/28 16:08:49 ram ?RCS: patch61: new loclibpth variable ?RCS: ?RCS: Revision 3.0.1.5 1995/01/11 15:31:30 ram ?RCS: patch45: call ./mips instead of just mips (WED) ?RCS: ?RCS: Revision 3.0.1.4 1994/08/29 16:29:15 ram ?RCS: patch32: added /lib/pa1.1 for HP-UX specially tuned PA-RISC libs (ADO) ?RCS: patch32: fixed information message, making it clearer (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/06/20 07:03:54 ram ?RCS: patch30: added /usr/shlib to glibpth for shared-only libraries ?RCS: ?RCS: Revision 3.0.1.2 1994/05/13 15:26:57 ram ?RCS: patch27: fixed a typo (libpth -> glibpth) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:07:53 ram ?RCS: patch23: now asks for library directories to be searched (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:02 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit initializes the path for C library lookup. ?X: ?MAKE:libpth glibpth xlibpth plibpth loclibpth incpth: \ usrinc incpath test cat Myread Oldconfig sysroot osname \ ccname echo cppstdin awk grep sed rm usecrosscompile ?MAKE: -pick add $@ %< ?S:libpth: ?S: This variable holds the general path (space-separated) used to find ?S: libraries. It is intended to be used by other units. ?S:. ?S:glibpth: ?S: This variable holds the general path (space-separated) used to ?S: find libraries. It may contain directories that do not exist on ?S: this platform, libpth is the cleaned-up version. ?S:. ?S:xlibpth: ?S: This variable holds extra path (space-separated) used to find ?S: libraries on this platform, for example CPU-specific libraries ?S: (on multi-CPU platforms) may be listed here. ?S:. ?S:loclibpth: ?S: This variable holds the paths (space-separated) used to find local ?S: libraries. It is prepended to libpth, and is intended to be easily ?S: set from the command line. ?S:. ?S:plibpth: ?S: Holds the private path used by Configure to find out the libraries. ?S: Its value is prepend to libpth. This variable takes care of special ?S: machines, like the mips. Usually, it should be empty. ?S:. ?S:incpth: ?S: This variable must precede the normal include path to get the ?S: right one, as in "$incpath/usr/include" or "$incpath/usr/lib". ?S: Value can be "" or "/bsd43" on mips. ?S:. ?T: xxx dlist i j croak ?LINT:extern incpth ?LINT:change usrinc ?INIT:: change the next line if compiling for Xenix/286 on Xenix/386 ?INIT:xlibpth='/usr/lib/386 /lib/386' ?INIT:: Possible local library directories to search. ?INIT:loclibpth="/usr/local/lib /opt/local/lib /usr/gnu/lib" ?INIT:loclibpth="$loclibpth /opt/gnu/lib /usr/GNU/lib /opt/GNU/lib" ?INIT: ?INIT:: general looking path for locating libraries ?INIT:glibpth="/lib /usr/lib $xlibpth" ?INIT:glibpth="$glibpth /usr/ccs/lib /usr/ucblib /usr/local/lib" ?X: /shlib is for Digital Unix 4.0 ?X: /usr/shlib is for OSF/1 systems. ?INIT:test -f /usr/shlib/libc.so && glibpth="/usr/shlib $glibpth" ?INIT:test -f /shlib/libc.so && glibpth="/shlib $glibpth" ?INIT:test -d /usr/lib64 && glibpth="$glibpth /lib64 /usr/lib64 /usr/local/lib64" ?INIT: ?INIT:: Private path used by Configure to find libraries. Its value ?INIT:: is prepended to libpth. This variable takes care of special ?INIT:: machines, like the mips. Usually, it should be empty. ?INIT:plibpth='' ?INIT: ?X:cppfilter is later used in Findhdr.U, but we not want to expose it to config.h ?T:cppfilter : Adjust cppfilter for path component separator case "$osname" in vos) cppfilter="tr '\\\\>' '/' |" ;; # path component separator is > os2) cppfilter="sed -e 's|\\\\\\\\|/|g' |" ;; # path component separator is \ *) cppfilter='' ;; esac : Use gcc to determine libpth and incpth # If using gcc or clang, we can get better values for libpth, incpth # and usrinc directly from the compiler. # Note that ccname for clang is also gcc. case "$ccname" in gcc) $echo 'extern int foo;' > try.c set X `$cppstdin -v try.c 2>&1 | $awk '/^#include &4; croak=y ;; *) echo "Using incpth '$incpth'." >&4 ;; esac case "$libpth" in '') echo "Libpth not defined." >&4; croak=y ;; *) echo "Using libpth '$libpth'." >&4 ;; esac case "$usrinc" in '') echo "Usrinc not defined." >&4; croak=y ;; *) echo "Using usrinc $usrinc." >&4 ;; esac case "$croak" in y) if test "X$sysroot" = X; then echo "Cannot continue, aborting." >&4; exit 1 else echo "Cross-compiling using sysroot $sysroot, failing to guess inc/lib paths is not fatal" >&4 fi ;; esac ;; esac ;; esac : Default value for incpth is just usrinc case "$incpth" in '') incpth="$usrinc";; esac : Set private lib path case "$plibpth" in '') if ./mips; then ?X: on mips, we DO NOT want /lib, and we want $incpath/usr/lib plibpth="$incpath/usr/lib $sysroot/usr/local/lib $sysroot/usr/ccs/lib" fi;; esac case "$libpth" in ' ') dlist='';; '') dlist="$loclibpth $plibpth $glibpth";; *) dlist="$libpth";; esac : Now check and see which directories actually exist, avoiding duplicates for xxx in $dlist do if $test -d $xxx; then case " $libpth " in *" $xxx "*) ;; *) libpth="$libpth $xxx";; esac fi done $cat <<'EOM' Some systems have incompatible or broken versions of libraries. Among the directories listed in the question below, please remove any you know not to be holding relevant libraries, and add any that are needed. Say "none" for none. EOM if test "X$sysroot" != X; then $cat <&4 case "$libs" in ' '|'') dflt='';; *) dflt="$libs";; esac case "$libswanted" in '') libswanted='c_s';; esac ?X: libsocks has nasty naming scheme. ?X: This does not work if somebody wants SOCKS 4. case "$usesocks" in "$define") libswanted="$libswanted socks5 socks5_sh" ;; esac case "$usecbacktrace" in "$define") libswanted="$libswanted bfd" ;; esac case "$usequadmath" in "$define") libswanted="$libswanted quadmath" ;; esac libsfound='' libsfiles='' libsdirs='' libspath='' for thisdir in $libpth $xlibpth; do test -d $thisdir && libspath="$libspath $thisdir" done for thislib in $libswanted; do for thisdir in $libspath; do xxx='' if $test ! -f "$xxx" -a "X$ignore_versioned_solibs" = "X"; then xxx=`ls $thisdir/lib$thislib.$so.[0-9] 2>/dev/null|sed -n '$p'` $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=shared xxx=`ls $thisdir/lib$thislib.[0-9].$so 2>/dev/null|sed -n '$p'` $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=shared fi if test ! -f "$xxx"; then xxx=$thisdir/lib$thislib.$so $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=shared fi if test ! -f "$xxx"; then xxx=$thisdir/lib$thislib$_a $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=static fi if test ! -f "$xxx"; then xxx=$thisdir/$thislib$_a $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=static fi if test ! -f "$xxx"; then xxx=$thisdir/lib${thislib}_s$_a $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=static $test -f "$xxx" && thislib=${thislib}_s fi if test ! -f "$xxx"; then xxx=$thisdir/Slib$thislib$_a $test -f "$xxx" && eval $libscheck $test -f "$xxx" && libstyle=static fi if $test -f "$xxx"; then case "$libstyle" in shared) echo "Found -l$thislib (shared)." ;; static) echo "Found -l$thislib." ;; *) echo "Found -l$thislib ($libstyle)." ;; esac case " $dflt " in *"-l$thislib "*);; *) dflt="$dflt -l$thislib" libsfound="$libsfound $xxx" yyy=`basename $xxx` libsfiles="$libsfiles $yyy" yyy=`echo $xxx|$sed -e "s%/$yyy\\$%%"` case " $libsdirs " in *" $yyy "*) ;; *) libsdirs="$libsdirs $yyy" ;; esac ;; esac break fi done if $test ! -f "$xxx"; then echo "No -l$thislib." fi done set X $dflt shift dflt="$*" case "$libs" in '') dflt="$dflt";; *) dflt="$libs";; esac case "$dflt" in ' '|'') dflt='none';; esac $cat < ?RCS: ?RCS: $Log: lns.U,v $ ?RCS: Revision 3.0.1.1 1994/06/20 07:05:52 ram ?RCS: patch30: created by ADO ?RCS: ?X: ?X: This unit checks whether symbolic links are really supported. ?X: We can't rely on d_symlink because that may be listed in the ?X: C library but unimplemented. ?X: ?MAKE:lns: ln rm touch ?MAKE: -pick add $@ %< ?S:lns: ?S: This variable holds the name of the command to make ?S: symbolic links (if they are supported). It can be used ?S: in the Makefile. It is either 'ln -s' or 'ln' ?S:. : determine whether symbolic links are supported echo " " $touch blurfl if $ln -s blurfl sym > /dev/null 2>&1 ; then echo "Symbolic links are supported." >&4 lns="$ln -s" else echo "Symbolic links are NOT supported." >&4 lns="$ln" fi $rm -f blurfl sym metaconfig-debian-perl-5.26.1/U/modified/mallocsrc.U000066400000000000000000000131431316016665300222030ustar00rootroot00000000000000?RCS: $Id: mallocsrc.U,v 3.0.1.2 1997/02/28 16:10:26 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: mallocsrc.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 16:10:26 ram ?RCS: patch61: added support for Free_t, the type of free() ?RCS: patch61: replaced .o with $_o all over the place ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:10:46 ram ?RCS: patch23: added support for MYMALLOC, mainly for perl5 (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:12 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:mallocsrc mallocobj usemallocwrap usemymalloc malloctype d_mymalloc \ freetype: Myread \ Oldconfig package Guess Setvar rm cat +cc +ccflags Findhdr \ i_malloc i_stdlib sed libs _o ptrsize useithreads ?MAKE: -pick add $@ %< ?X: Put near top so that other tests don't erroneously include ?X: -lmalloc. --AD 22 June 1998 ?Y:TOP ?S:usemymalloc: ?S: This variable contains y if the malloc that comes with this package ?S: is desired over the system's version of malloc. People often include ?S: special versions of malloc for efficiency, but such versions are often ?S: less portable. See also mallocsrc and mallocobj. ?S: If this is 'y', then -lmalloc is removed from $libs. ?S:. ?S:usemallocwrap: ?S: This variable contains y if we are wrapping malloc to prevent ?S: integer overflow during size calculations. ?S:. ?S:mallocsrc: ?S: This variable contains the name of the malloc.c that comes with ?S: the package, if that malloc.c is preferred over the system malloc. ?S: Otherwise the value is null. This variable is intended for generating ?S: Makefiles. ?S:. ?S:d_mymalloc: ?S: This variable conditionally defines MYMALLOC in case other parts ?S: of the source want to take special action if MYMALLOC is used. ?S: This may include different sorts of profiling or error detection. ?S:. ?S:mallocobj: ?S: This variable contains the name of the malloc.o that this package ?S: generates, if that malloc.o is preferred over the system malloc. ?S: Otherwise the value is null. This variable is intended for generating ?S: Makefiles. See mallocsrc. ?S:. ?S:freetype: ?S: This variable contains the return type of free(). It is usually ?S: void, but occasionally int. ?S:. ?S:malloctype: ?S: This variable contains the kind of ptr returned by malloc and realloc. ?S:. ?C:Free_t: ?C: This variable contains the return type of free(). It is usually ?C: void, but occasionally int. ?C:. ?C:Malloc_t (MALLOCPTRTYPE): ?C: This symbol is the type of pointer returned by malloc and realloc. ?C:. ?H:#define Malloc_t $malloctype /**/ ?H:#define Free_t $freetype /**/ ?H:. ?C:PERL_MALLOC_WRAP: ?C: This symbol, if defined, indicates that we'd like malloc wrap checks. ?C:. ?H:#$usemallocwrap PERL_MALLOC_WRAP /**/ ?H:. ?C:MYMALLOC: ?C: This symbol, if defined, indicates that we're using our own malloc. ?C:. ?H:#$d_mymalloc MYMALLOC /**/ ?H:. ?LINT:extern usedevel ?LINT:change libs ?X: Cannot test for mallocsrc; it is the unit's name and there is a bug in ?X: the interpreter which defines all the names, even though they are not used. @if mallocobj : determine whether to use malloc wrapping echo " " case "$usemallocwrap" in [yY]*|true|$define) dflt='y' ;; [nN]*|false|$undef) dflt='n' ;; *) case "$usedevel" in [yY]*|true|$define) dflt='y' ;; *) dflt='n' ;; esac ;; esac rp="Do you wish to wrap malloc calls to protect against potential overflows?" . ./myread usemallocwrap="$ans" case "$ans" in y*|true) usemallocwrap="$define" ;; *) usemallocwrap="$undef" ;; esac : determine which malloc to compile in echo " " case "$usemymalloc" in [yY]*|true|$define) dflt='y' ;; [nN]*|false|$undef) dflt='n' ;; *) case "$ptrsize" in 4) dflt='y' ;; *) dflt='n' ;; esac if test "$useithreads" = "$define"; then dflt='n'; fi ;; esac rp="Do you wish to attempt to use the malloc that comes with $package?" . ./myread usemymalloc="$ans" case "$ans" in y*|true) usemymalloc='y' mallocsrc='malloc.c' mallocobj="malloc$_o" d_mymalloc="$define" ?X: Maybe libs.U should be dependent on mallocsrc.U, but then ?X: most packages that use dist probably don't supply their own ?X: malloc, so this is probably an o.k. compromise case "$libs" in *-lmalloc*) : Remove malloc from list of libraries to use echo "Removing unneeded -lmalloc from library list" >&4 set `echo X $libs | $sed -e 's/-lmalloc / /' -e 's/-lmalloc$//'` shift libs="$*" echo "libs = $libs" >&4 ;; esac ;; *) usemymalloc='n' mallocsrc='' mallocobj='' d_mymalloc="$undef" ;; esac @end @if MALLOCPTRTYPE || Malloc_t || Free_t : compute the return types of malloc and free echo " " $cat >malloc.c < #include #ifdef I_MALLOC #include #endif #ifdef I_STDLIB #include #endif #ifdef TRY_MALLOC void *malloc(); #endif #ifdef TRY_FREE void free(); #endif END @if MALLOCPTRTYPE || Malloc_t case "$malloctype" in '') if $cc $ccflags -c -DTRY_MALLOC malloc.c >/dev/null 2>&1; then malloctype='void *' else malloctype='char *' fi ;; esac echo "Your system wants malloc to return '$malloctype', it would seem." >&4 @end @if Free_t case "$freetype" in '') if $cc $ccflags -c -DTRY_FREE malloc.c >/dev/null 2>&1; then freetype='void' else freetype='int' fi ;; esac echo "Your system uses $freetype free(), it would seem." >&4 @end $rm -f malloc.[co] @end metaconfig-debian-perl-5.26.1/U/modified/models.U000066400000000000000000000132121316016665300215040ustar00rootroot00000000000000?RCS: $Id: models.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: models.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 16:13:17 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:02:39 ram ?RCS: patch6: added default for large ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:17 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:models split small medium large huge: test cat Myread sysman Oldconfig \ Loc contains rm ?MAKE: -pick add $@ %< ?S:models: ?S: This variable contains the list of memory models supported by this ?S: system. Possible component values are none, split, unsplit, small, ?S: medium, large, and huge. The component values are space separated. ?S:. ?S:split: ?S: This variable contains a flag which will tell the C compiler and loader ?S: to produce a program that will run in separate I and D space, for those ?S: machines that support separation of instruction and data space. It is ?S: up to the Makefile to use this. ?S:. ?S:small: ?S: This variable contains a flag which will tell the C compiler and loader ?S: to produce a program running with a small memory model. It is up to ?S: the Makefile to use this. ?S:. ?S:medium: ?S: This variable contains a flag which will tell the C compiler and loader ?S: to produce a program running with a medium memory model. If the ?S: medium model is not supported, contains the flag to produce large ?S: model programs. It is up to the Makefile to use this. ?S:. ?S:large: ?S: This variable contains a flag which will tell the C compiler and loader ?S: to produce a program running with a large memory model. It is up to ?S: the Makefile to use this. ?S:. ?S:huge: ?S: This variable contains a flag which will tell the C compiler and loader ?S: to produce a program running with a huge memory model. If the ?S: huge model is not supported, contains the flag to produce large ?S: model programs. It is up to the Makefile to use this. ?S:. ?T:unsplit tans modelcc ?F:!pdp11 ?D:large='' ?LINT:extern cc : see what memory models we can support case "$models" in '') ?X: We may not use Cppsym or we get a circular dependency through cc. ?X: But this should work regardless of which cc we eventually use. $cat >pdp11.c <<'EOP' int main() { #ifdef pdp11 exit(0); #else exit(1); #endif } EOP ?X: Run cc in a subshell in case they don't have a 'cc' command. ?X: Presumably they do have gcc or something. case "$cc" in '') modelcc="$cc" ;; *) modelcc="cc" ;; esac ( $modelcc -o pdp11 pdp11.c ) >/dev/null 2>&1 if $test -f pdp11 && ./pdp11 2>/dev/null; then dflt='unsplit split' else tans=`./loc . X /lib/small /lib/large /usr/lib/small /usr/lib/large /lib/medium /usr/lib/medium /lib/huge` case "$tans" in X) dflt='none';; *) if $test -d /lib/small || $test -d /usr/lib/small; then dflt='small' else dflt='' fi if $test -d /lib/medium || $test -d /usr/lib/medium; then dflt="$dflt medium" fi if $test -d /lib/large || $test -d /usr/lib/large; then dflt="$dflt large" fi if $test -d /lib/huge || $test -d /usr/lib/huge; then dflt="$dflt huge" fi esac fi;; *) dflt="$models";; esac $cat </dev/null 2>&1 || \ $contains '\-i' $sysman/cc.1 >/dev/null 2>&1; then dflt='-i' else dflt='none' fi;; *) dflt="$split";; esac rp="What flag indicates separate I and D space?" . ./myread tans="$ans" case "$tans" in none) tans='';; esac split="$tans" unsplit='';; *large*|*small*|*medium*|*huge*) case "$models" in *large*) case "$large" in '') dflt='-Ml';; *) dflt="$large";; esac rp="What flag indicates large model?" . ./myread tans="$ans" case "$tans" in none) tans=''; esac large="$tans";; *) large='';; esac case "$models" in *huge*) case "$huge" in '') dflt='-Mh';; *) dflt="$huge";; esac rp="What flag indicates huge model?" . ./myread tans="$ans" case "$tans" in none) tans=''; esac huge="$tans";; *) huge="$large";; esac case "$models" in *medium*) case "$medium" in '') dflt='-Mm';; *) dflt="$medium";; esac rp="What flag indicates medium model?" . ./myread tans="$ans" case "$tans" in none) tans=''; esac medium="$tans";; *) medium="$large";; esac case "$models" in *small*) case "$small" in '') dflt='none';; *) dflt="$small";; esac rp="What flag indicates small model?" . ./myread tans="$ans" case "$tans" in none) tans=''; esac small="$tans";; *) small='';; esac ;; *) echo "Unrecognized memory models--you may have to edit Makefile.SH" >&4 ;; esac $rm -f pdp11.* pdp11 metaconfig-debian-perl-5.26.1/U/modified/myhostname.U000066400000000000000000000207241316016665300224130ustar00rootroot00000000000000?RCS: $Id: myhostname.U,v 3.0.1.3 1997/02/28 16:15:55 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: myhostname.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 16:15:55 ram ?RCS: patch61: improved hostname lookup by using ypmatch when NIS is used ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:25:43 ram ?RCS: patch36: call ./xenix explicitly instead of relying on PATH ?RCS: patch36: now uses new Tr unit to convert to/from lowercase ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 07:06:20 ram ?RCS: patch30: now a little more clever for domain name guessing ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:18 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:myhostname phostname mydomain: contains sed test Myread Oldconfig \ Guess Loc awk echo sort uniq +usrinc rm hostcat Tr ?MAKE: -pick add $@ %< ?S:myhostname (hostname): ?S: This variable contains the eventual value of the MYHOSTNAME symbol, ?S: which is the name of the host the program is going to run on. ?S: The domain is not kept with hostname, but must be gotten from mydomain. ?S: The dot comes with mydomain, and need not be supplied by the program. ?S:. ?S:mydomain: ?S: This variable contains the eventual value of the MYDOMAIN symbol, ?S: which is the domain of the host the program is going to run on. ?S: The domain must be appended to myhostname to form a complete host name. ?S: The dot comes with mydomain, and need not be supplied by the program. ?S:. ?S:phostname: ?S: This variable contains the eventual value of the PHOSTNAME symbol, ?S: which is a command that can be fed to popen() to get the host name. ?S: The program should probably not presume that the domain is or isn't ?S: there already. ?S:. ?C:MYHOSTNAME (HOSTNAME): ?C: This symbol contains name of the host the program is going to run on. ?C: The domain is not kept with hostname, but must be gotten from MYDOMAIN. ?C: The dot comes with MYDOMAIN, and need not be supplied by the program. ?C: If gethostname() or uname() exist, MYHOSTNAME may be ignored. If MYDOMAIN ?C: is not used, MYHOSTNAME will hold the name derived from PHOSTNAME. ?C:. ?C:MYDOMAIN: ?C: This symbol contains the domain of the host the program is going to ?C: run on. The domain must be appended to HOSTNAME to form a complete ?C: host name. The dot comes with MYDOMAIN, and need not be supplied by ?C: the program. If the host name is derived from PHOSTNAME, the domain ?C: may or may not already be there, and the program should check. ?C:. ?H:#define MYHOSTNAME "$myhostname" /**/ ?H:#define MYDOMAIN "$mydomain" /**/ ?H:. ?LINT:extern osname ?T:cont i tans tmp_re : now get the host name echo " " echo "Figuring out host name..." >&4 case "$myhostname" in '') cont=true echo 'Maybe "hostname" will work...' if tans=`sh -c hostname 2>&1` ; then myhostname=$tans phostname=hostname cont='' fi ;; *) cont='';; esac if $test "$cont"; then if ./xenix; then echo 'Oh, dear. Maybe "/etc/systemid" is the key...' if tans=`cat /etc/systemid 2>&1` ; then myhostname=$tans phostname='cat /etc/systemid' echo "Whadyaknow. Xenix always was a bit strange..." cont='' fi elif $test -r /etc/systemid; then echo "(What is a non-Xenix system doing with /etc/systemid?)" fi fi if $test "$cont"; then echo 'No, maybe "uuname -l" will work...' if tans=`sh -c 'uuname -l' 2>&1` ; then myhostname=$tans phostname='uuname -l' else echo 'Strange. Maybe "uname -n" will work...' if tans=`sh -c 'uname -n' 2>&1` ; then myhostname=$tans phostname='uname -n' else echo 'Oh well, maybe I can mine it out of whoami.h...' if tans=`sh -c $contains' sysname $usrinc/whoami.h' 2>&1` ; then myhostname=`echo "$tans" | $sed 's/^.*"\(.*\)"/\1/'` phostname="sed -n -e '"'/sysname/s/^.*\"\\(.*\\)\"/\1/{'"' -e p -e q -e '}' <$usrinc/whoami.h" else case "$myhostname" in '') echo "Does this machine have an identity crisis or something?" phostname='';; *) echo "Well, you said $myhostname before..." phostname='echo $myhostname';; esac fi fi fi fi case "$myhostname" in '') myhostname=noname ;; esac : you do not want to know about this set $myhostname myhostname=$1 : verify guess if $test "$myhostname" ; then dflt=y rp='Your host name appears to be "'$myhostname'".'" Right?" . ./myread case "$ans" in y*) ;; *) myhostname='';; esac fi : bad guess or no guess while $test "X$myhostname" = X ; do dflt='' rp="Please type the (one word) name of your host:" . ./myread myhostname="$ans" done : translate upper to lower if necessary case "$myhostname" in *[A-Z]*) echo "(Normalizing case in your host name)" myhostname=`echo $myhostname | ./tr '[A-Z]' '[a-z]'` ;; esac ?X: Do not ask for domain name if this is not used later on. In that ?X: case, the hostname may keep its domain name, but it doesn't matter. @if MYDOMAIN || mydomain case "$myhostname" in *.*) dflt=`expr "X$myhostname" : "X[^.]*\(\..*\)"` myhostname=`expr "X$myhostname" : "X\([^.]*\)\."` echo "(Trimming domain name from host name--host name is now $myhostname)" ;; *) case "$mydomain" in '') ?X: ?X: There is currently no way to say we do not want hostcat if mydomain is not ?X: used. One way to achieve that would be to put that code in a mydomain.U ?X: unit. However, we want to stick the sanity checks right after the domain ?X: name computation, or if none is done, right after the hostname computation. ?X: { ?X: If we use NIS, try ypmatch. test "X$hostcat" = "Xypcat hosts" && ypmatch "$myhostname" hosts 2>/dev/null |\ $sed -e 's/[ ]*#.*//; s/$/ /' > hosts && \ $test -s hosts } || { ?X: Extract only the relevant hosts, reducing file size, ?X: remove comments, insert trailing space for later use. ?X: Test to be sure we *have* a hostcat command. os390 doesn't. test "X$hostcat" != "X" && $hostcat | $sed -n -e "s/[ ]*#.*//; s/\$/ / /[ ]$myhostname[ . ]/p" > hosts } tmp_re="[ . ]" if $test -f hosts; then $test x`$awk "/[0-9].*[ ]$myhostname$tmp_re/ { sum++ } END { print sum }" hosts` = x1 || tmp_re="[ ]" dflt=.`$awk "/[0-9].*[ ]$myhostname$tmp_re/ {for(i=2; i<=NF;i++) print \\\$i}" \ hosts | $sort | $uniq | \ $sed -n -e "s/$myhostname\.\([-a-zA-Z0-9_.]\)/\1/p"` case `$echo X$dflt` in X*\ *) echo "(Several hosts in the database matched hostname)" dflt=. ;; X.) echo "(You do not have fully-qualified names in the hosts database)" ;; esac else echo "(I cannot locate a hosts database anywhere)" dflt=. fi case "$dflt" in .) tans=`./loc resolv.conf X /etc /usr/etc` if $test -f "$tans"; then echo "(Attempting domain name extraction from $tans)" ?X: Look for either a search or a domain directive. dflt=.`$sed -n -e 's/ / /g' \ -e 's/^search *\([^ ]*\).*/\1/p' $tans \ -e 1q 2>/dev/null` case "$dflt" in .) dflt=.`$sed -n -e 's/ / /g' \ -e 's/^domain *\([^ ]*\).*/\1/p' $tans \ -e 1q 2>/dev/null` ;; esac fi ;; esac case "$dflt" in .) echo "(No help from resolv.conf either -- attempting clever guess)" dflt=.`sh -c domainname 2>/dev/null` case "$dflt" in '') dflt='.';; .nis.*|.yp.*|.main.*) dflt=`echo $dflt | $sed -e 's/^\.[^.]*//'`;; esac ;; esac case "$dflt$osname" in .os390) echo "(Attempting domain name extraction from //'SYS1.TCPPARMS(TCPDATA)')" dflt=.`awk '/^DOMAINORIGIN/ {print $2}' "//'SYS1.TCPPARMS(TCPDATA)'" 2>/dev/null` ;; esac case "$dflt" in .) echo "(Lost all hope -- silly guess then)" dflt='.nonet' ;; esac $rm -f hosts ;; *) dflt="$mydomain";; esac;; esac echo " " rp="What is your domain name?" . ./myread tans="$ans" case "$ans" in '') ;; .*) ;; *) tans=".$tans";; esac mydomain="$tans" : translate upper to lower if necessary case "$mydomain" in *[A-Z]*) echo "(Normalizing case in your domain name)" mydomain=`echo $mydomain | ./tr '[A-Z]' '[a-z]'` ;; esac @end : a little sanity check here case "$phostname" in '') ;; *) case `$phostname | ./tr '[A-Z]' '[a-z]'` in $myhostname$mydomain|$myhostname) ;; *) case "$phostname" in sed*) echo "(That doesn't agree with your whoami.h file, by the way.)" ;; *) echo "(That doesn't agree with your $phostname command, by the way.)" ;; esac ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/modified/nis.U000066400000000000000000000067401316016665300210220ustar00rootroot00000000000000?RCS: $Id: nis.U,v 3.0.1.3 1997/02/28 16:17:38 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: nis.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 16:17:38 ram ?RCS: patch61: ensure suitable defaults for hostcat and friends ?RCS: ?RCS: Revision 3.0.1.2 1995/03/21 08:48:34 ram ?RCS: patch52: continued fix for NeXT NIS/NetInfo handling ?RCS: ?RCS: Revision 3.0.1.1 1995/02/15 14:16:23 ram ?RCS: patch51: now correctly handles NeXT using NIS rather than NetInfo ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:24 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:passcat groupcat hostcat: Myread Oldconfig test contains ?MAKE: -pick add $@ %< ?S:passcat: ?S: This variable contains a command that produces the text of the ?S: /etc/passwd file. This is normally "cat /etc/passwd", but can be ?S: "ypcat passwd" when NIS is used. ?S: On some systems, such as os390, there may be no equivalent ?S: command, in which case this variable is unset. ?S:. ?S:groupcat: ?S: This variable contains a command that produces the text of the ?S: /etc/group file. This is normally "cat /etc/group", but can be ?S: "ypcat group" when NIS is used. ?S: On some systems, such as os390, there may be no equivalent ?S: command, in which case this variable is unset. ?S:. ?S:hostcat: ?S: This variable contains a command that produces the text of the ?S: /etc/hosts file. This is normally "cat /etc/hosts", but can be ?S: "ypcat hosts" when NIS is used. ?S: On some systems, such as os390, there may be no equivalent ?S: command, in which case this variable is unset. ?S:. : see if we have to deal with yellow pages, now NIS. ?X: NeXT gives us some fun here, as always, by having both NIS (former YP) ?X: and NetInfo. But since it has both, it's ok to put the test inside the if. ?X: Contributed by Thomas Neumann . if $test -d /usr/etc/yp || $test -d /etc/yp || $test -d /usr/lib/yp; then @if passcat || groupcat case "$passcat" in nidump*) ;; *) case "$passcat" in *ypcat*) dflt=y;; '') if $contains '^\+' /etc/passwd >/dev/null 2>&1; then dflt=y else dflt=n fi;; *) dflt=n;; esac echo " " rp='Are you getting the passwd file via yellow pages?' . ./myread case "$ans" in y*) passcat='ypcat passwd' @if groupcat echo "(Assuming /etc/group is also distributed.)" groupcat='ypcat group' @end ;; *) passcat='cat /etc/passwd' @if groupcat echo "(Assuming /etc/group is also local.)" groupcat='cat /etc/group' @end ;; esac ;; esac @end @if hostcat case "$hostcat" in nidump*) ;; *) case "$hostcat" in *ypcat*) dflt=y;; '') if $contains '^\+' /etc/passwd >/dev/null 2>&1; then dflt=y else dflt=n fi;; *) dflt=n;; esac echo " " rp='Are you getting the hosts file via yellow pages?' . ./myread case "$ans" in y*) hostcat='ypcat hosts';; *) hostcat='cat /etc/hosts';; esac ;; esac @end fi ?X: Ensure suitable default -- Manoj Srivastava case "$hostcat" in '') test -f /etc/hosts && hostcat='cat /etc/hosts';; esac case "$groupcat" in '') test -f /etc/group && groupcat='cat /etc/group';; esac case "$passcat" in '') test -f /etc/passwd && passcat='cat /etc/passwd';; esac metaconfig-debian-perl-5.26.1/U/modified/package.U000066400000000000000000000040451316016665300216200ustar00rootroot00000000000000?RCS: $Id: package.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: package.U,v $ ?RCS: Revision 3.0.1.3 1994/10/29 16:27:21 ram ?RCS: patch36: beware of non-ascii character sets when translating case ?RCS: ?RCS: Revision 3.0.1.2 1993/11/10 17:37:02 ram ?RCS: patch14: skip definition of spackage if not otherwise used ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 16:11:10 ram ?RCS: patch10: added spackage, suitable for starting sentences ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:28 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:package spackage: Nothing ?MAKE: -pick wipe $@ %< ?S:package: ?S: This variable contains the name of the package being constructed. ?S: It is primarily intended for the use of later Configure units. ?S:. ?S:spackage: ?S: This variable contains the name of the package being constructed, ?S: with the first letter uppercased, i.e. suitable for starting ?S: sentences. ?S:. ?X: dist-4 has defined PACKAGE: here, which clashes with perly.h ?X: as package is a reserved keyword in perl ?T:first last : set package name package='' @if spackage first=`echo $package | sed -e 's/^\(.\).*/\1/'` last=`echo $package | sed -e 's/^.\(.*\)/\1/'` ?X: ?X: So early in the Configure script, we don't have ./tr set up and can't ?X: include Tr in our dependency or that would create a cycle. Therefore, ?X: we have to somehow duplicate the work done in Tr. That's life. ?X: case "`echo AbyZ | tr '[:lower:]' '[:upper:]' 2>/dev/null`"-"`echo AbyZ | tr '[:upper:]' '[:lower:]' 2>/dev/null`" in ABYZ-abyz) spackage=`echo $first | tr '[:lower:]' '[:upper:]'`$last;; *) spackage=`echo $first | tr '[a-z]' '[A-Z]'`$last;; esac @end metaconfig-debian-perl-5.26.1/U/modified/prototype.U000066400000000000000000000105051316016665300222700ustar00rootroot00000000000000?RCS: $Id: prototype.U,v 3.0.1.3 1994/05/06 15:11:49 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: prototype.U,v $ ?RCS: Revision 3.0.1.3 1994/05/06 15:11:49 ram ?RCS: patch23: ensure cc flags used when looking for prototype support ?RCS: ?RCS: Revision 3.0.1.2 1994/01/24 14:15:36 ram ?RCS: patch16: prototype handling macros now appear only when needed ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:03:12 ram ?RCS: patch6: defines were referring to non-existent VOID symbol ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:36 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:prototype: Myread Oldconfig cat +cc +ccflags rm Setvar i_stdlib ?MAKE: -pick add $@ %< ?S:prototype: ?S: This variable holds the eventual value of CAN_PROTOTYPE, which ?S: indicates the C compiler can handle function prototypes. ?S:. ?C:CAN_PROTOTYPE ~ %<: ?C: If defined, this macro indicates that the C compiler can handle ?C: function prototypes. ?C:. ?C:DOTS: ?C: This macro is used to specify the ... in function prototypes which ?C: have arbitrary additional arguments. ?C:. ?C:NXT_ARG: ?C: This macro is used to separate arguments in the declared argument list. ?C:. ?C:P_FUNC: ?C: This macro is used to declare "private" (static) functions. ?C: It takes three arguments: the function type and name, a parenthesized ?C: traditional (comma separated) argument list, and the declared argument ?C: list (in which arguments are separated with NXT_ARG, and additional ?C: arbitrary arguments are specified with DOTS). For example: ?C: ?C: P_FUNC(int foo, (bar, baz), int bar NXT_ARG char *baz[]) ?C:. ?C:P_FUNC_VOID: ?C: This macro is used to declare "private" (static) functions that have ?C: no arguments. The macro takes one argument: the function type and name. ?C: For example: ?C: ?C: P_FUNC_VOID(int subr) ?C:. ?C:V_FUNC: ?C: This macro is used to declare "public" (non-static) functions. ?C: It takes three arguments: the function type and name, a parenthesized ?C: traditional (comma separated) argument list, and the declared argument ?C: list (in which arguments are separated with NXT_ARG, and additional ?C: arbitrary arguments are specified with DOTS). For example: ?C: ?C: V_FUNC(int main, (argc, argv), int argc NXT_ARG char *argv[]) ?C:. ?C:V_FUNC_VOID: ?C: This macro is used to declare "public" (non-static) functions that have ?C: no arguments. The macro takes one argument: the function type and name. ?C: For example: ?C: ?C: V_FUNC_VOID(int fork) ?C:. ?C:_ (P): ?C: This macro is used to declare function parameters for folks who want ?C: to make declarations with prototypes using a different style than ?C: the above macros. Use double parentheses. For example: ?C: ?C: int main _((int argc, char *argv[])); ?C:. ?H:?%<:#$prototype CAN_PROTOTYPE /**/ ?H:?_:#ifdef CAN_PROTOTYPE ?H:?NXT_ARG:#define NXT_ARG , ?H:?DOTS:#define DOTS , ... ?H:?V_FUNC:#define V_FUNC(name, arglist, args)name(args) ?H:?P_FUNC:#define P_FUNC(name, arglist, args)static name(args) ?H:?V_FUNC_VOID:#define V_FUNC_VOID(name)name(void) ?H:?P_FUNC_VOID:#define P_FUNC_VOID(name)static name(void) ?H:?_:#define _(args) args ?H:?_:#else ?H:?NXT_ARG:#define NXT_ARG ; ?H:?DOTS:#define DOTS ?H:?V_FUNC:#define V_FUNC(name, arglist, args)name arglist args; ?H:?P_FUNC:#define P_FUNC(name, arglist, args)static name arglist args; ?H:?V_FUNC_VOID:#define V_FUNC_VOID(name)name() ?H:?P_FUNC_VOID:#define P_FUNC_VOID(name)static name() ?H:?_:#define _(args) () ?H:?_:#endif ?H:. ?W:%<:NXT_ARG DOTS V_FUNC P_FUNC V_FUNC_VOID P_FUNC_VOID _ ?LINT:set prototype : Cruising for prototypes echo " " echo "Checking out function prototypes..." >&4 $cat >prototype.c < #endif int main(int argc, char *argv[]) { exit(0);} EOCP if $cc $ccflags -c prototype.c >prototype.out 2>&1 ; then echo "Your C compiler appears to support function prototypes." val="$define" else echo "Your C compiler doesn't seem to understand function prototypes." val="$undef" fi set prototype eval $setvar $rm -f prototype* metaconfig-debian-perl-5.26.1/U/modified/sh.U000066400000000000000000000060631316016665300206410ustar00rootroot00000000000000?RCS: $Id: sh.U,v 3.0.1.1 1997/02/28 16:20:13 ram Exp $ ?RCS: ?RCS: Copyright (c) 1997, Chip Salzenberg ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: sh.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 16:20:13 ram ?RCS: patch61: created ?RCS: ?MAKE:sh targetsh: Head ?MAKE: -pick wipe $@ %< ?S:sh: ?S: This variable contains the full pathname of the shell used ?S: on this system to execute Bourne shell scripts. Usually, this will be ?S: /bin/sh, though it's possible that some systems will have /bin/ksh, ?S: /bin/pdksh, /bin/ash, /bin/bash, or even something such as ?S: D:/bin/sh.exe. ?S: This unit comes before Options.U, so you can't set sh with a -D ?S: option, though you can override this (and startsh) ?S: with -O -Dsh=/bin/whatever -Dstartsh=whatever ?S:. ?S:targetsh: ?S: If cross-compiling, this variable contains the location of sh on the ?S: target system. ?S: If not, this will be the same as $sh. ?S:. ?C:SH_PATH: ?C: This symbol contains the full pathname to the shell used on this ?C: on this system to execute Bourne shell scripts. Usually, this will be ?C: /bin/sh, though it's possible that some systems will have /bin/ksh, ?C: /bin/pdksh, /bin/ash, /bin/bash, or even something such as ?C: D:/bin/sh.exe. ?C:. ?H:#define SH_PATH "$targetsh" /**/ ?H:. ?T:xxx try pth p SYSTYPE ?LINT:extern maintloc maintname _exe ?X: ?X: Be quiet unless something unusual happens because this gets ?X: loaded up even before options are processed. ?X: Can't use ./loc because that depends on startsh, which, in turn ?X: depends on this unit. ?X: : Find the basic shell for Bourne shell scripts case "$sh" in '') ?X: SYSTYPE is for some older MIPS systems. ?X: I do not know if it is still needed. case "$SYSTYPE" in *bsd*|sys5*) xxx="/$SYSTYPE/bin/sh";; *) xxx='/bin/sh';; esac if test -f "$xxx"; then sh="$xxx" else : Build up a list and do a single loop so we can 'break' out. pth=`echo $PATH | sed -e "s/$p_/ /g"` for xxx in sh bash ksh pdksh ash; do for p in $pth; do try="$try ${p}/${xxx}" done done for xxx in $try; do if test -f "$xxx"; then sh="$xxx"; break elif test "X$_exe" != X -a -f "$xxx$_exe"; then sh="$xxx"; break elif test -f "$xxx.exe"; then sh="$xxx"; break fi done fi ;; esac ?X: fd 4 isn't open yet... case "$sh" in '') cat >&2 <) at <$maintloc> and we'll try to straighten this all out. EOM exit 1 ;; esac : When cross-compiling we need to separate the sh-to-run-Configure-with from the sh-to-use-in-Perl : default both to the same thing, cross-compilers can then set targetsh differently if they like targetsh=$sh metaconfig-debian-perl-5.26.1/U/modified/sig_name.U000066400000000000000000000141031316016665300220030ustar00rootroot00000000000000?RCS: $Id: sig_name.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: sig_name.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 16:21:25 ram ?RCS: patch61: brand new algorithm for sig_name and (new!) sig_num ?RCS: ?RCS: Revision 3.0.1.4 1995/07/25 14:14:54 ram ?RCS: patch56: added lookup for Linux ?RCS: ?RCS: Revision 3.0.1.3 1995/05/12 12:24:11 ram ?RCS: patch54: now looks for too (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/06/20 07:06:57 ram ?RCS: patch30: final echo was missing to close awk-printed string ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:17:55 ram ?RCS: patch23: signal list now formatted to avoid scroll-ups (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:47 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:sig_name sig_name_init sig_num sig_num_init sig_count sig_size: \ awk Signal Oldconfig rm ?MAKE: -pick add $@ %< ?S:sig_name: ?S: This variable holds the signal names, space separated. The leading ?S: SIG in signal name is removed. A ZERO is prepended to the list. ?S: This is currently not used, sig_name_init is used instead. ?S:. ?S:sig_name_init: ?S: This variable holds the signal names, enclosed in double quotes and ?S: separated by commas, suitable for use in the SIG_NAME definition ?S: below. A "ZERO" is prepended to the list, and the list is ?S: terminated with a plain 0. The leading SIG in signal names ?S: is removed. See sig_num. ?S:. ?S:sig_num: ?S: This variable holds the signal numbers, space separated. A ZERO is ?S: prepended to the list (corresponding to the fake SIGZERO). ?S: Those numbers correspond to the value of the signal listed ?S: in the same place within the sig_name list. ?S: This is currently not used, sig_num_init is used instead. ?S:. ?S:sig_num_init: ?S: This variable holds the signal numbers, enclosed in double quotes and ?S: separated by commas, suitable for use in the SIG_NUM definition ?S: below. A "ZERO" is prepended to the list, and the list is ?S: terminated with a plain 0. ?S:. ?S:sig_count (sig_name.U): ?S: This variable holds a number larger than the largest valid ?S: signal number. This is usually the same as the NSIG macro. ?S:. ?S:sig_size: ?S: This variable contains the number of elements of the sig_name ?S: and sig_num arrays. ?S:. ?C:SIG_NAME: ?C: This symbol contains a list of signal names in order of ?C: signal number. This is intended ?C: to be used as a static array initialization, like this: ?C: char *sig_name[] = { SIG_NAME }; ?C: The signals in the list are separated with commas, and each signal ?C: is surrounded by double quotes. There is no leading SIG in the signal ?C: name, i.e. SIGQUIT is known as "QUIT". ?C: Gaps in the signal numbers (up to NSIG) are filled in with NUMnn, ?C: etc., where nn is the actual signal number (e.g. NUM37). ?C: The signal number for sig_name[i] is stored in sig_num[i]. ?C: The last element is 0 to terminate the list with a NULL. This ?C: corresponds to the 0 at the end of the sig_name_init list. ?C: Note that this variable is initialized from the sig_name_init, ?C: not from sig_name (which is unused). ?C:. ?C:SIG_NUM: ?C: This symbol contains a list of signal numbers, in the same order as the ?C: SIG_NAME list. It is suitable for static array initialization, as in: ?C: int sig_num[] = { SIG_NUM }; ?C: The signals in the list are separated with commas, and the indices ?C: within that list and the SIG_NAME list match, so it's easy to compute ?C: the signal name from a number or vice versa at the price of a small ?C: dynamic linear lookup. ?C: Duplicates are allowed, but are moved to the end of the list. ?C: The signal number corresponding to sig_name[i] is sig_number[i]. ?C: if (i < NSIG) then sig_number[i] == i. ?C: The last element is 0, corresponding to the 0 at the end of ?C: the sig_name_init list. ?C: Note that this variable is initialized from the sig_num_init, ?C: not from sig_num (which is unused). ?C:. ?C:SIG_COUNT: ?C: This variable contains a number larger than the largest ?C: signal number. This is usually the same as the NSIG macro. ?C:. ?C:SIG_SIZE: ?C: This variable contains the number of elements of the SIG_NAME ?C: and SIG_NUM arrays, excluding the final NULL entry. ?C:. ?H:#define SIG_NAME $sig_name_init /**/ ?H:#define SIG_NUM $sig_num_init /**/ ?H:#define SIG_COUNT $sig_count /**/ ?H:#define SIG_SIZE $sig_size /**/ ?H:. ?T:i doinit ?F:!= !signal_cmd ?X: signal.cmd creates a file signal.lst which has two columns: ?X: NAME number, e.g. ?X: HUP 1 ?X: The list is sorted on signal number, with duplicates moved to ?X: the end.. : generate list of signal names case "$sig_num_init" in '') echo " " case "$sig_name_init" in '') doinit=yes ;; *) case "$sig_num_init" in ''|*,*) doinit=yes ;; esac ;; esac case "$doinit" in yes) echo "Generating a list of signal names and numbers..." >&4 . ./signal_cmd sig_count=`$awk '/^NSIG/ { printf "%d", $2 }' signal.lst` sig_name=`$awk 'BEGIN { printf "ZERO " } !/^NSIG/ { printf "%s ", $1 }' signal.lst` sig_num=`$awk 'BEGIN { printf "0 " } !/^NSIG/ { printf "%d ", $2 }' signal.lst` sig_name_init=`$awk 'BEGIN { printf "\"ZERO\", " } !/^NSIG/ { printf "\"%s\", ", $1 } END { printf "0\n" }' signal.lst` sig_num_init=`$awk 'BEGIN { printf "0, " } !/^NSIG/ { printf "%d, ", $2} END { printf "0\n"}' signal.lst` ;; esac echo "The following $sig_count signals are available:" echo " " echo $sig_name | $awk \ 'BEGIN { linelen = 0 } { for (i = 1; i <= NF; i++) { name = "SIG" $i " " linelen = linelen + length(name) if (linelen > 70) { printf "\n" linelen = length(name) } printf "%s", name } printf "\n" }' sig_size=`echo $sig_name | awk '{print NF}'` $rm -f signal signal.c signal.awk signal.lst signal_cmd ;; esac metaconfig-debian-perl-5.26.1/U/modified/so.U000066400000000000000000000043041316016665300206440ustar00rootroot00000000000000?RCS: $Id: so.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: so.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 16:30:04 ram ?RCS: patch36: now tells user how he can suppress shared lib lookup (ADO) ?RCS: patch36: removed echo at the top, since it's now in the here-doc (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 07:07:02 ram ?RCS: patch30: created ?RCS: ?X: ?X: This unit computes the shared-object / shared-lib extension ?X: ?MAKE:so d_libname_unique: test libpth Loc Myread Oldconfig cat Setvar ?MAKE: -pick add $@ %< ?S:so: ?S: This variable holds the extension used to identify shared libraries ?S: (also known as shared objects) on the system. Usually set to 'so'. ?S:. ?S:d_libname_unique: ?S: This variable is defined if the target system insists on unique ?S: basenames for shared library files. This is currently true on Android, ?S: false everywhere else we know of. ?S: Defaults to 'undef'. ?S:. ?LINT:set d_libname_unique ?T: xxx : compute shared library extension case "$so" in '') if xxx=`./loc libc.sl X $libpth`; $test -f "$xxx"; then dflt='sl' else dflt='so' fi ;; *) dflt="$so";; esac $cat <&4 else echo "Could not find manual pages in source form." >&4 fi metaconfig-debian-perl-5.26.1/U/modified/usenm.U000066400000000000000000000100411316016665300213450ustar00rootroot00000000000000?RCS: $Id: usenm.U,v 3.0.1.1 1997/02/28 16:26:40 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: usenm.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 16:26:40 ram ?RCS: patch61: don't use nm with the GNU C library ?RCS: patch61: added support for Linux shared libs ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:usenm runnm nm_opt nm_so_opt: cat test Myread Oldconfig myuname grep \ nm d_gnulibc osname egrep rsrc ?MAKE: -pick add $@ %< ?S:usenm: ?S: This variable contains 'true' or 'false' depending whether the ?S: nm extraction is wanted or not. ?S:. ?S:runnm: ?S: This variable contains 'true' or 'false' depending whether the ?S: nm extraction should be performed or not, according to the value ?S: of usenm and the flags on the Configure command line. ?S:. ?S:nm_opt: ?S: This variable holds the options that may be necessary for nm. ?S:. ?S:nm_so_opt: ?S: This variable holds the options that may be necessary for nm ?S: to work on a shared library but that can not be used on an ?S: archive library. Currently, this is only used by Linux, where ?S: nm --dynamic is *required* to get symbols from an ELF library which ?S: has been stripped, but nm --dynamic is *fatal* on an archive library. ?S: Maybe Linux should just always set usenm=false. ?S:. : see if nm is to be used to determine whether a symbol is defined or not ?X: If there is enough inquiries, it might be worth to wait for the nm ?X: extraction. Otherwise, the C compilations might be a better deal. ?X: ?X: Don't bother if we're using GNU libc -- skimo ?LINT:extern PASE case "$usenm" in '') dflt='' case "$d_gnulibc" in "$define") echo " " echo "nm probably won't work on the GNU C Library." >&4 dflt=n ;; esac case "$dflt" in '') if $test "$osname" = aix -a "X$PASE" != "Xdefine" -a ! -f /lib/syscalls.exp; then echo " " echo "Whoops! This is an AIX system without /lib/syscalls.exp!" >&4 echo "'nm' won't be sufficient on this system." >&4 dflt=n fi ;; esac case "$dflt" in '') dflt=`$egrep 'inlibc|csym' $rsrc/Configure | wc -l 2>/dev/null` if $test $dflt -gt 20; then dflt=y else dflt=n fi ;; esac ;; *) case "$usenm" in true|$define) dflt=y;; *) dflt=n;; esac ;; esac $cat < /dev/null 2>&1; then nm_so_opt='--dynamic' fi ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/modified/usrinc.U000066400000000000000000000054021316016665300215260ustar00rootroot00000000000000?RCS: $Id: usrinc.U,v 1.1 2000/06/27 00:20:28 jhi Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: usrinc.U,v $ ?RCS: Revision 1.1 2000/06/27 00:20:28 jhi ?RCS: Initial revision ?RCS: ?RCS: Revision 3.0.1.3 1997/02/28 16:27:12 ram ?RCS: patch61: don't ask for the include path unless they are on a MIPS ?RCS: ?RCS: Revision 3.0.1.2 1995/05/12 12:24:36 ram ?RCS: patch54: ensure that ./mips always exists (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:18:31 ram ?RCS: patch23: ensure usrinc value is preserved across sessions (WED) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:usrinc incpath mips_type: test cat echo n c Getfile Guess \ Oldconfig eunicefix contains rm sysroot cc ?MAKE: -pick add $@ %< ?S:usrinc: ?S: This variable holds the path of the include files, which is ?S: usually /usr/include. It is mainly used by other Configure units. ?S:. ?S:incpath: ?S: This variable must precede the normal include path to get the ?S: right one, as in "$incpath/usr/include" or "$incpath/usr/lib". ?S: Value can be "" or "/bsd43" on mips. ?S:. ?S:mips_type: ?S: This variable holds the environment type for the mips system. ?S: Possible values are "BSD 4.3" and "System V". ?S:. ?D:usrinc='/usr/include' ?LINT:extern cppflags ?LINT:create mips ?T:xxx_prompt ?F:./mips : What should the include directory be ? : Use sysroot if set, so findhdr looks in the right place. echo " " $echo $n "Hmm... $c" dflt="$sysroot/usr/include" incpath='' ?X: mips_type is used later, to add -DSYSTYPE_BSD43 to cppflags if needed. mips_type='' ?X: ?X: Cannot put the following in Guess, or we get a circular dependency. ?X: if $test -f /bin/mips && /bin/mips; then echo "Looks like a MIPS system..." $cat >usr.c <<'EOCP' #ifdef SYSTYPE_BSD43 /bsd43 #endif EOCP if $cc $cppflags -E usr.c > usr.out && $contains / usr.out >/dev/null 2>&1; then dflt='/bsd43/usr/include' incpath='/bsd43' mips_type='BSD 4.3' else mips_type='System V' fi $rm -f usr.c usr.out echo "and you're compiling with the $mips_type compiler and libraries." xxx_prompt=y echo "exit 0" >mips else echo "Doesn't look like a MIPS system." xxx_prompt=n echo "exit 1" >mips fi chmod +x mips $eunicefix mips case "$usrinc" in '') ;; *) dflt="$usrinc";; esac case "$xxx_prompt" in y) fn=d/ echo " " rp='Where are the include files you want to use?' . ./getfile usrinc="$ans" ;; *) usrinc="$dflt" ;; esac metaconfig-debian-perl-5.26.1/U/modified/voidflags.U000066400000000000000000000117501316016665300222040ustar00rootroot00000000000000?RCS: $Id: voidflags.U,v 3.0.1.2 1997/02/28 16:27:58 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: voidflags.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 16:27:58 ram ?RCS: patch61: don't prompt them if the void support is high enough for us ?RCS: ?RCS: Revision 3.0.1.1 1995/01/11 15:37:44 ram ?RCS: patch45: cosmetic change to avoid spurious blank lines when using -s ?RCS: ?RCS: Revision 3.0 1993/08/18 12:10:01 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:voidflags defvoidused: cat rm_try contains +cc +ccflags package \ Oldconfig Myread i_stdlib ?MAKE: -pick add $@ %< ?S:voidflags: ?S: This variable contains the eventual value of the VOIDFLAGS symbol, ?S: which indicates how much support of the void type is given by this ?S: compiler. See VOIDFLAGS for more info. ?S:. ?S:defvoidused: ?S: This variable contains the default value of the VOIDUSED symbol (15). ?S:. ?X: Exceptionally, we have to explicitly alias the symbol name for ?X: config_h.SH, otherwise the comment would not appear. ?C:VOIDFLAGS ~ %<: ?C: This symbol indicates how much support of the void type is given by this ?C: compiler. What various bits mean: ?C: ?C: 1 = supports declaration of void ?C: 2 = supports arrays of pointers to functions returning void ?C: 4 = supports comparisons between pointers to void functions and ?C: addresses of void functions ?C: 8 = supports declaration of generic void pointers ?C: ?C: The package designer should define VOIDUSED to indicate the requirements ?C: of the package. This can be done either by #defining VOIDUSED before ?C: including config.h, or by defining defvoidused in Myinit.U. If the ?C: latter approach is taken, only those flags will be tested. If the ?C: level of void support necessary is not present, defines void to int. ?C:. ?H:?%<:#ifndef VOIDUSED ?H:?%<:#define VOIDUSED $defvoidused ?H:?%<:#endif ?H:?%<:#define VOIDFLAGS $voidflags ?H:?%<:#if (VOIDFLAGS & VOIDUSED) != VOIDUSED ?H:?%<:#define void int /* is void to be avoided? */ ?H:?%<:#define M_VOID /* Xenix strikes again */ ?H:?%<:#endif ?H:. ?INIT:: full support for void wanted by default ?INIT:defvoidused=15 ?INIT: ?LINT:known void M_VOID VOIDUSED : check for void type echo " " echo "Checking to see how well your C compiler groks the void type..." >&4 case "$voidflags" in '') $cat >try.c < #endif #if TRY & 1 void sub() { #else sub() { #endif extern void moo(); /* function returning void */ void (*goo)(); /* ptr to func returning void */ #if TRY & 8 void *hue; /* generic ptr */ #endif #if TRY & 2 void (*foo[10])(); #endif #if TRY & 4 if(goo == moo) { exit(0); } #endif exit(0); } int main() { sub(); } EOCP ?X: This unit used to use cc -S in those tests to try to speed up things, but ?X: unfortunately, AIX 3.2 does not support this option. if $cc $ccflags -c -DTRY=$defvoidused try.c >.out 2>&1 ; then voidflags=$defvoidused echo "Good. It appears to support void to the level $package wants.">&4 if $contains warning .out >/dev/null 2>&1; then echo "However, you might get some warnings that look like this:" $cat .out fi else echo "Hmm, your compiler has some difficulty with void. Checking further..." >&4 if $cc $ccflags -c -DTRY=1 try.c >/dev/null 2>&1; then echo "It supports 1..." if $cc $ccflags -c -DTRY=3 try.c >/dev/null 2>&1; then echo "It also supports 2..." if $cc $ccflags -c -DTRY=7 try.c >/dev/null 2>&1; then voidflags=7 echo "And it supports 4 but not 8 definitely." else echo "It doesn't support 4..." if $cc $ccflags -c -DTRY=11 try.c >/dev/null 2>&1; then voidflags=11 echo "But it supports 8." else voidflags=3 echo "Neither does it support 8." fi fi else echo "It does not support 2..." if $cc $ccflags -c -DTRY=13 try.c >/dev/null 2>&1; then voidflags=13 echo "But it supports 4 and 8." else if $cc $ccflags -c -DTRY=5 try.c >/dev/null 2>&1; then voidflags=5 echo "And it supports 4 but has not heard about 8." else echo "However it supports 8 but not 4." fi fi fi else echo "There is no support at all for void." voidflags=0 fi fi esac ?X: Only prompt user if support does not match the level we want case "$voidflags" in "$defvoidused") ;; *) $cat >&4 <<'EOM' Support flag bits are: 1: basic void declarations. 2: arrays of pointers to functions returning void. 4: operations between pointers to and addresses of void functions. 8: generic void pointers. EOM dflt="$voidflags"; rp="Your void support flags add up to what?" . ./myread voidflags="$ans" ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/modified/yacc.U000066400000000000000000000041501316016665300211410ustar00rootroot00000000000000?RCS: $Id: yacc.U,v 3.0.1.1 1994/05/13 15:28:48 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: yacc.U,v $ ?RCS: Revision 3.0.1.1 1994/05/13 15:28:48 ram ?RCS: patch27: added byacc as another alternative (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:10:03 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:yacc yaccflags: Guess Myread Oldconfig byacc bison cat test _exe ?MAKE: -pick add $@ %< ?S:yacc: ?S: This variable holds the name of the compiler compiler we ?S: want to use in the Makefile. It can be yacc, byacc, or bison -y. ?S:. ?S:yaccflags: ?S: This variable contains any additional yacc flags desired by the ?S: user. It is up to the Makefile to use this. ?S:. ?T:comp : determine compiler compiler case "$yacc" in '') dflt=yacc;; *) dflt="$yacc";; esac echo " " comp='yacc' if $test -f "$byacc$_exe"; then dflt="$byacc" comp="byacc or $comp" fi if $test -f "$bison$_exe"; then comp="$comp or bison -y" fi rp="Which compiler compiler ($comp) shall I use?" . ./myread yacc="$ans" case "$yacc" in *bis*) case "$yacc" in *-y*) ;; *) yacc="$yacc -y" echo "(Adding -y option to bison to get yacc-compatible behavior.)" ;; esac ;; esac @if yaccflags : see if we need extra yacc flags dflt="$yaccflags" case "$dflt" in '') dflt=none;; esac $cat <fpa.c << GOOP ?X: main(){return(1);} ?X:GOOP ?X: $cc -ffpa -o fpa fpa.c ?X: fpa > fpa.out 2>&1 ?X: if $test ! -s fpa.out; then ?X: dflt='y' ?X: $cat <<'EOM' ?X: ?X:You seem to have a sun fpa... I can compile the code to use the fpa but it will ?X:mean that the code can ONLY run on a machine with a fpa... ?X: ?X:EOM ?X: rp="Should I compile for fpa?" ?X: . ./myread ?X: if $test $ans = "n"; then ?X: fpu='' ?X: else ?X: fpu='-ffpa' ?X: fi ?X: else ?X: $cat <<'EOM' ?X: ?X:You have the fpa device but I can't seem to use it. Maybe you should talk to ?X:your sysadmin about this. For now, I am not going to compile it in. ?X: ?X:EOM ?X: fi ?X:fi ?X:if $test "$fpu" = ''; then ?X: if $test -r /usr/etc/mc68881version; then ?X: dflt='y' ?X: $cat <<'EOM' ?X: ?X:There also seems to be the pieces for a 68881. If I compile this in, it will ?X:work on almost all Sun 3's except for a few Sun-3/50s without a 68881... ?X: ?X:EOM ?X: rp="Should I compile for a 68881?" ?X: . ./myread ?X: if $test $ans = "y"; then ?X: fpu='-f68881' ?X: fi ?X: fi ?X:fi ?X: metaconfig-debian-perl-5.26.1/U/nullified/lib.U000066400000000000000000000035621316016665300211710ustar00rootroot00000000000000?RCS: $Id: lib.U,v 3.0.1.3 1995/09/25 09:16:47 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: lib.U,v $ ?RCS: Revision 3.0.1.3 1995/09/25 09:16:47 ram ?RCS: patch59: unit is now forced to the top of Configure, if possible ?RCS: ?RCS: Revision 3.0.1.2 1995/01/30 14:38:08 ram ?RCS: patch49: can now handle installation prefix changes (from WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:27:40 ram ?RCS: patch32: now uses installation prefix to set the default ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:56 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?LINT: empty ?X:?MAKE:lib libexp: Getfile Loc Oldconfig Prefixit Prefixup prefixexp ?X:?MAKE: -pick add $@ %< ?X:?Y:TOP ?X:?S:lib: ?X:?S: This variable holds the name of the directory in which the user wants ?X:?S: to put public library files for the package in question. It is most ?X:?S: often a local directory such as /usr/local/lib. Programs using this ?X:?S: variable must be prepared to deal with filename expansion. ?X:?S:. ?X:?S:libexp: ?X:?S: This variable is the same as the lib variable, but is filename expanded ?X:?S: at configuration time, for convenient use in your makefiles. ?X:?S:. ?X:: determine where public libraries go ?X:set lib lib ?X:eval $prefixit ?X:case "$lib" in ?X:'') ?X: dflt=`./loc . "." $prefixexp/lib /usr/local/lib /usr/lib /lib` ?X: set dflt ?X: eval $prefixup ?X: ;; ?X:*) dflt="$lib";; ?X:esac ?X:echo " " ?X:fn=d~ ?X:rp='Where do you want to put the public libraries?' ?X:. ./getfile ?X:lib="$ans" ?X:libexp="$ansexp" metaconfig-debian-perl-5.26.1/U/perl/000077500000000000000000000000001316016665300172565ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/perl/Checkcc.U000066400000000000000000000073341316016665300207360ustar00rootroot00000000000000?RCS: ?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in order ?X: to make quick check on whether the current C compiler is working. ?X: ?MAKE:Checkcc ccname ccversion: rm cat test Myread startsh ?MAKE: -pick add $@ %< ?S:ccname: ?S: This can set either by hints files or by Configure. If using ?S: gcc, this is gcc, and if not, usually equal to cc, unimpressive, no? ?S: Some platforms, however, make good use of this by storing the ?S: flavor of the C compiler being used here. For example if using ?S: the Sun WorkShop suite, ccname will be 'workshop'. ?S:. ?S:ccversion: ?S: This can set either by hints files or by Configure. If using ?S: a (non-gcc) vendor cc, this variable may contain a version for ?S: the compiler. ?S:. ?T: trygcc despair ?F:./checkcc ?F:./trygcc ?INIT:ccname='' ?INIT:ccversion='' ?LINT:extern cc ?LINT:change cc ?LINT:extern ccflags ?LINT:change ccflags ?LINT:extern ccflags ?LINT:extern ldflags : Check what type of C compiler we use cat <trygcc $startsh EOS cat <<'EOSC' >>trygcc case "$cc" in '') ;; *) $rm -f try try.* $cat >try.c <&4 despair=yes trygcc=yes case "$cc" in *gcc*) trygcc=no ;; esac # Skip this test because it gives a false match on output like: # ./trygcc: line 23: cc: command not found # case "`$cc -v -c try.c 2>&1`" in # *gcc*) trygcc=no ;; # esac if $test X"$trygcc" = Xyes; then if gcc -o try -c try.c; then echo " " echo "You seem to have a working gcc, though." >&4 # Switching compilers may undo the work of hints files. # The most common problem is -D_REENTRANT for threads. # This heuristic catches that case, but gets false positives # if -Dusethreads was not actually specified. Better to # bail out here with a useful message than fail # mysteriously later. Should we perhaps just try to # re-invoke Configure -Dcc=gcc config_args ? if $test -f usethreads.cbu; then $cat >&4 <&2 exit 1 fi fi case "$ans" in [yY]*) cc=gcc; ccname=gcc; ccflags=''; despair=no; esac fi fi fi $rm -f try try.* ;; esac EOSC cat <checkcc $startsh EOS cat <<'EOSC' >>checkcc case "$cc" in '') ;; *) $rm -f try try.* $cat >try.c <&4 fi $cat >&4 < arm-linux-androideabi # x86_64-w64-mingw32-gcc.exe -> x86_64-w64-mingw32 targetarch=`$echo $cc|$sed 's/-g[c\+][c\+].*$//'` ar=`$echo $cc|$sed 's/-g[c\+][c\+]/-ar/'` # leave out ld, choosing it is more complex nm=`$echo $cc|$sed 's/-g[c\+][c\+]/-nm/'` ranlib=`$echo $cc|$sed 's/-g[c\+][c\+]/-ranlib/'` # We are in a weird spot. Just before us, some values # were 'saved', to be restored after the hints are # run. This means that the changes we made to ar, # nm and ranlib will get reverted. # To avoid that, we hijack the saving mechanism and # have it save our new values. for file in ar nm ranlib; do eval xxx=\$$file eval $file=$xxx$_exe eval _$file=$xxx done ;; esac case "$targetarch" in '') echo "Targetarch not defined." >&4; croak=y ;; *) echo "Using targetarch $targetarch." >&4 ;; esac case "$targethost" in '') echo "Targethost not defined." >&4; croak=n ;; *) echo "Using targethost $targethost." >&4 esac locincpth=' ' loclibpth=' ' case "$croak" in y) echo "Cannot continue, aborting." >&4; exit 1 ;; esac : compile a host miniperl and generate_uudmap, unless we got passed them if $test "X$hostperl" = X; then echo "Building host miniperl and generate_uudmap binaries" >&4 before_host=`pwd` cd .. cd $src src=`pwd` rm -rf $src/host mkdir $src/host cd $src/host $src/Configure -des -Dusedevel -Dmksymlinks $make miniperl case "$hostgenerate" in '') $make generate_uudmap hostgenerate=$src/host/generate_uudmap ;; "$undef") hostgenerate='' ;; esac hostperl=$src/host/miniperl cd $before_host fi hostosname=`$hostperl -le 'print $^O'` ;; *) usecrosscompile="$undef" ;; esac : Define -Dtargethost=somecomputer to run compiled tests on another machine case "$targethost" in '') echo "Checking for cross-compile" >&4 case "$usecrosscompile$multiarch" in *$define*) echo "Skipping the try tests in the rest of Configure as no targethost was defined when cross-compiling" >&4 if [ -f Makefile ]; then echo " " echo "Now you must ensure config.sh, config.h and the generated headers exist and run a $make." else echo "Configure done." fi exit 0 ;; *) echo "No targethost for running compiler tests against defined, running locally" >&4 run='' to=: from=: ;; esac ;; *) echo "Using targethost $targethost." >&4 case "$src" in /*) run=$src/Cross/run targetmkdir=$src/Cross/mkdir to=$src/Cross/to from=$src/Cross/from ;; *) pwd=`$test -f ../Configure & cd ..; pwd` run=$pwd/Cross/run targetmkdir=$pwd/Cross/mkdir to=$pwd/Cross/to from=$pwd/Cross/from ;; esac case "$targetrun" in '') targetrun=ssh ;; esac case "$targetto" in '') targetto=scp ;; esac case "$targetfrom" in '') targetfrom=scp ;; esac run=$run-$targetrun to=$to-$targetto from=$from-$targetfrom case "$targetdir" in '') targetdir=/tmp echo "Guessing targetdir $targetdir." >&4 ;; esac case "$targetuser" in '') targetuser=root echo "Guessing targetuser $targetuser." >&4 ;; esac case "$targetport" in '') targetport=22 echo "Guessing targetport $targetport." >&4 ;; esac case "$targetfrom" in scp) q=-q ;; *) q='' ;; esac case "$targetrun" in ssh|rsh) cat >$run <&4 exit 1 ;; esac case "$targetmkdir" in */Cross/mkdir) cat >$targetmkdir <&4 exit 1 ;; esac case "$targetto" in scp|rcp) cat >$to </dev/null || exit 1 ;; *) $targetmkdir $targetdir/\`dirname \$f\` $targetto -P $targetport -r $q \$f $targetuser@$targethost:$targetdir/\$f 2>/dev/null || exit 1 ;; esac done exit 0 EOF ;; cp) cat >$to <&4 exit 1 ;; esac case "$targetfrom" in scp|rcp) cat >$from <$from <&4 exit 1 ;; esac if $test ! -f $run; then echo "Target 'run' script '$run' not found." >&4 else $chmod a+rx $run fi if $test ! -f $to; then echo "Target 'to' script '$to' not found." >&4 else $chmod a+rx $to fi if $test ! -f $from; then echo "Target 'from' script '$from' not found." >&4 else $chmod a+rx $from fi if $test ! -f $run -o ! -f $to -o ! -f $from; then exit 1 fi cat >&4 <&4 <&4 "Okay, continuing." usedevel="$define" ;; *) echo >&4 "Okay, bye." exit 1 ;; esac ;; esac usedevel="$undef" ;; esac case "$usedevel" in $define|true|[yY]*) case "$versiononly" in '') versiononly="$define" ;; esac case "$installusrbinperl" in '') installusrbinperl="$undef" ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/perl/End.U000066400000000000000000000046571316016665300201260ustar00rootroot00000000000000?RCS: $Id: End.U,v 3.0 1993/08/18 12:04:51 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: End.U,v $ ?RCS: Revision 3.0 1993/08/18 12:04:51 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit serves as the goal which forces make to choose all the units that ?X: ask questions. The $W on the ?MAKE: line is the list of all symbols wanted. ?X: To force any unit to be included, copy this unit to your private U directory ?X: and add the name of the unit desired to the ?MAKE: dependency line. ?X: ?MAKE:End perllibs: $W cppstdin gzip zip libs usedl osname osvers ?MAKE: -pick add $@ %< ?S:perllibs: ?S: The list of libraries needed by Perl only (any libraries needed ?S: by extensions only will by dropped, if using dynamic loading). ?S:. ?INIT:perllibs='' ?LINT:use $W ?LINT:use gzip zip ?LINT:change cppstdin : Remove libraries needed only for extensions : The appropriate ext/Foo/Makefile.PL will add them back in, if necessary. : The exception is SunOS 4.x, which needs them. case "${osname}X${osvers}" in sunos*X4*) perllibs="$libs" ;; *) case "$usedl" in $define|true|[yY]*) set X `echo " $libs " | sed -e 's@ -lndbm @ @' -e 's@ -lgdbm @ @' -e 's@ -lgdbm_compat @ @' -e 's@ -ldbm @ @' -e 's@ -ldb @ @'` shift perllibs="$*" ;; *) perllibs="$libs" ;; esac ;; esac ?X: If the user has the cppstdin wrapper, perl.c will try to call ?X: CPPSTDIN, but that will point to a location in the build ?X: directory, not the installed version!. Here, we'll just strip the ?X: name down to 'cppstdin', and rely on the fact that perl.c will ?X: then call SCRIPTDIR/cppstdin, but local things like 'make depend' ?X: will continue to work. : Remove build directory name from cppstdin so it can be used from : either the present location or the final installed location. echo " " : Get out of the UU directory to get correct path name. cd .. case "$cppstdin" in `pwd`/cppstdin) echo "Stripping down cppstdin path name" cppstdin=cppstdin ;; esac cd UU : end of configuration questions echo " " echo "End of configuration questions." echo " " metaconfig-debian-perl-5.26.1/U/perl/Extensions.U000066400000000000000000000323611316016665300215500ustar00rootroot00000000000000?RCS: $Id: Extensions.U,v$ ?RCS: ?RCS: Copyright (c) 1996-1998, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: Extensions.U,v $ ?RCS: ?MAKE:known_extensions extensions dynamic_ext static_ext nonxs_ext \ useposix useopcode : \ Myread hint usedl d_sem d_socket i_db i_dbm i_rpcsvcdbm i_gdbm \ d_ndbm usethreads use5005threads package test cat rsrc \ d_msg d_shm osname use64bitint i_langinfo d_nl_langinfo \ libs d_cplusplus sed ls rm contains trnl sort ?MAKE: -pick add $@ %< ?Y:BOTTOM ?S:known_extensions: ?S: This variable holds a list of all extensions (both XS and non-xs) ?S: included in the package source distribution. This information is ?S: only really of use during the Perl build, as the list makes no ?S: distinction between extensions which were build and installed, and ?S: those which where not. See "extensions" for the list of extensions ?S: actually built and available. ?S:. ?S:dynamic_ext: ?S: This variable holds a list of XS extension files we want to ?S: link dynamically into the package. It is used by Makefile. ?S:. ?S:static_ext: ?S: This variable holds a list of XS extension files we want to ?S: link statically into the package. It is used by Makefile. ?S:. ?S:nonxs_ext: ?S: This variable holds a list of all non-xs extensions built and ?S: installed by the package. By default, all non-xs extensions ?S: distributed will be built, with the exception of platform-specific ?S: extensions (currently only one VMS specific extension). ?S:. ?S:extensions: ?S: This variable holds a list of all extension files (both XS and ?S: non-xs) installed with the package. It is propagated to Config.pm ?S: and is typically used to test whether a particular extension ?S: is available. ?S:. ?S:useposix: ?S: This variable holds either 'true' or 'false' to indicate ?S: whether the POSIX extension should be used. The sole ?S: use for this currently is to allow an easy mechanism ?S: for hints files to indicate that POSIX will not compile ?S: on a particular system. ?S:. ?S:useopcode: ?S: This variable holds either 'true' or 'false' to indicate ?S: whether the Opcode extension should be used. The sole ?S: use for this currently is to allow an easy mechanism ?S: for users to skip the Opcode extension from the Configure ?S: command line. ?S:. ?T:xxx avail_ext this_ext tdir xs_extensions nonxs_extensions find_extensions ?INIT:: set useposix=false in your hint file to disable the POSIX extension. ?INIT:useposix=true ?INIT:: set useopcode=false in your hint file to disable the Opcode extension. ?INIT:useopcode=true ?LINT:extern noextensions ?LINT:extern onlyextensions ?T:keepextensions i : Check extensions echo " " echo "Looking for extensions..." >&4 : If we are using the old config.sh, nonxs_extensions and xs_extensions may : contain old or inaccurate or duplicate values. nonxs_extensions='' xs_extensions='' : We do not use find because it might not be available. : We do not just use MANIFEST because the user may have dropped : some additional extensions into the source tree and expect them : to be built. : Function to recursively find available extensions, ignoring DynaLoader : NOTE: recursion limit of 10 to prevent runaway in case of symlink madness : In 5.10.1 and later, extensions are stored in directories : like File-Glob instead of the older File/Glob/. find_extensions=' for xxx in *; do case "$xxx" in DynaLoader|dynaload) ;; *) this_ext=`echo "$xxx" | $sed -e s/-/\\\//g`; case "$this_ext" in Scalar/List/Utils) this_ext="List/Util" ;; PathTools) this_ext="Cwd" ;; esac; echo " $xs_extensions $nonxs_extensions" > "$tdir/$$.tmp"; if $contains " $this_ext " "$tdir/$$.tmp"; then echo >&4; echo "Duplicate directories detected for extension $xxx" >&4; echo "Configure cannot correctly recover from this - shall I abort?" >&4; case "$knowitall" in "") dflt=y;; *) dflt=n;; esac; . ../UU/myread; case "$ans" in n*|N*) ;; *) echo >&4; echo "Ok. Stopping Configure." >&4; echo "Please remove the duplicate directory (e.g. using git clean) and then re-run Configure" >&4; exit 1;; esac; echo "Ok. You will need to correct config.sh before running make." >&4; fi; $ls -1 "$xxx" > "$tdir/$$.tmp"; if $contains "\.xs$" "$tdir/$$.tmp" > /dev/null 2>&1; then xs_extensions="$xs_extensions $this_ext"; elif $contains "\.c$" "$tdir/$$.tmp" > /dev/null 2>&1; then xs_extensions="$xs_extensions $this_ext"; elif $test -d "$xxx"; then nonxs_extensions="$nonxs_extensions $this_ext"; fi; $rm -f "$tdir/$$.tmp"; ;; esac; done' tdir=`pwd` cd "$rsrc/cpan" set X shift eval $find_extensions cd "$rsrc/dist" set X shift eval $find_extensions cd "$rsrc/ext" set X shift eval $find_extensions set X $xs_extensions shift xs_extensions=`echo "$*" | tr ' ' $trnl | $sort | tr $trnl ' '` set X $nonxs_extensions shift nonxs_extensions=`echo "$*" | tr ' ' $trnl | $sort | tr $trnl ' '` cd "$tdir" known_extensions=`echo $nonxs_extensions $xs_extensions | tr ' ' $trnl | $sort | tr $trnl ' '` : Now see which are supported on this system. ?X: avail_ext lists available XS extensions. avail_ext='' for xxx in $xs_extensions ; do case "$xxx" in ?X: Handle possible DOS 8.3 filename and case alterations Amiga*) case "$osname" in amigaos) avail_ext="$avail_ext $xxx" ;; esac ;; DB_File|db_file) case "$i_db" in $define) avail_ext="$avail_ext $xxx" ;; esac ;; GDBM_File|gdbm_fil) case "$i_gdbm" in $define) avail_ext="$avail_ext $xxx" ;; esac ;; I18N/Langinfo|i18n_lan) case "$i_langinfo$d_nl_langinfo" in $define$define) avail_ext="$avail_ext $xxx" ;; esac ;; IPC/SysV|ipc/sysv) : XXX Do we need a useipcsysv variable here case "${d_msg}${d_sem}${d_shm}" in *"${define}"*) avail_ext="$avail_ext $xxx" ;; esac ;; NDBM_File|ndbm_fil) case "$d_ndbm" in $define) case "$osname-$use64bitint" in hpux-define) case "$libs" in *-lndbm*) avail_ext="$avail_ext $xxx" ;; esac ;; *) avail_ext="$avail_ext $xxx" ;; esac ;; esac ;; ODBM_File|odbm_fil) case "${i_dbm}${i_rpcsvcdbm}" in *"${define}"*) case "$d_cplusplus" in define) ;; # delete as a function name will not work *) case "$osname-$use64bitint" in hpux-define) case "$libs" in *-ldbm*) avail_ext="$avail_ext $xxx" ;; esac ;; *) avail_ext="$avail_ext $xxx" ;; esac ;; esac ;; esac ;; Opcode|opcode) case "$useopcode" in true|define|y) avail_ext="$avail_ext $xxx" ;; esac ;; POSIX|posix) case "$useposix" in true|define|y) avail_ext="$avail_ext $xxx" ;; esac ;; Socket|socket) case "$d_socket" in true|$define|y) avail_ext="$avail_ext $xxx" ;; esac ;; Sys/Syslog|sys/syslog) case $osname in amigaos) ;; # not really very useful on AmigaOS *) : XXX syslog requires socket case "$d_socket" in true|$define|y) avail_ext="$avail_ext $xxx" ;; esac ;; esac ;; Thread|thread) case "$usethreads" in true|$define|y) case "$use5005threads" in $define|true|[yY]*) avail_ext="$avail_ext $xxx" ;; esac esac ;; threads|threads/shared) # threads and threads::shared are special cases. # To stop people from asking "Perl 5.8.0 was supposed # to have this new fancy threads implementation but my # perl doesn't have it" and from people trying to # (re)install the threads module using CPAN.pm and # CPAN.pm then offering to reinstall Perl 5.8.0, # the threads.pm and threads/shared.pm will always be # there, croaking informatively ("you need to rebuild # all of Perl with threads, sorry") when threads haven't # been compiled in. # --jhi avail_ext="$avail_ext $xxx" ;; VMS*) ;; Win32*) case "$osname" in cygwin) avail_ext="$avail_ext $xxx" ;; esac ;; XS/APItest|xs/apitest) # This is just for testing. Skip it unless we have dynamic loading. case "$usedl" in $define) avail_ext="$avail_ext $xxx" ;; esac ;; XS/Typemap|xs/typemap) # This is just for testing. Skip it unless we have dynamic loading. case "$usedl" in $define) avail_ext="$avail_ext $xxx" ;; esac ;; *) avail_ext="$avail_ext $xxx" ;; esac done set X $avail_ext shift avail_ext="$*" case "$onlyextensions" in '') ;; *) keepextensions='' echo "You have requested that only certain extensions be included..." >&4 for i in $onlyextensions; do case " $avail_ext " in *" $i "*) echo "Keeping extension $i." keepextensions="$keepextensions $i" ;; *) echo "Ignoring extension $i." ;; esac done avail_ext="$keepextensions" ;; esac case "$noextensions" in '') ;; *) keepextensions='' echo "You have requested that certain extensions be ignored..." >&4 for i in $avail_ext; do case " $noextensions " in *" $i "*) echo "Ignoring extension $i." ;; *) echo "Keeping extension $i."; keepextensions="$keepextensions $i" ;; esac done avail_ext="$keepextensions" ;; esac : Now see which nonxs extensions are supported on this system. : For now assume all are. nonxs_ext='' for xxx in $nonxs_extensions ; do case "$xxx" in VMS*) ;; *) nonxs_ext="$nonxs_ext $xxx" ;; esac done set X $nonxs_ext shift nonxs_ext="$*" case $usedl in $define) $cat <&4 echo "WARNING: The Perl you are building will be quite crippled." >& 4 ;; esac metaconfig-debian-perl-5.26.1/U/perl/Extras.U000066400000000000000000000035251316016665300206570ustar00rootroot00000000000000?RCS: $Id: Extras.U,v$ ?RCS: ?RCS: Copyright (c) 2001, Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:extras: Myread Oldconfig Setvar rm ?MAKE: -pick add $@ %< ?Y:TOP ?S:extras: ?S: This variable holds a list of extra modules to install. ?S:. : See if we want extra modules installed echo " " case "$extras" in '') dflt='n';; *) dflt='y';; esac cat < ../extras.lst val="'$extras'" ;; esac set extras eval $setvar echo " " metaconfig-debian-perl-5.26.1/U/perl/Hasfield_t.U000066400000000000000000000022511316016665300214460ustar00rootroot00000000000000?RCS: Copyright (c) 2016 Dagfinn Ilmari Mannsåker & H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: ?X: This unit produces a variable that is intended to be eval'ed in ?X: order to define/undefine a symbol. A consistency check is made ?X: regarding any previous value and a warning is issued if there ?X: is any discrepancy. ?X: ?X: To use it, say: ?X: set d_siginfo_si_errno siginfo_t int si_errno $d_sigaction signal.h ?X: eval $hasfield_t; ?X: ?MAKE:Hasfield_t: test Compile rm_try Setvar ?MAKE: -pick add $@ %< ?LINT:define hasfield_t ?S:hasfield_t: ?S: Internal macro for Configure ?S:. ?V:hasfield_t: ?T:varname struct type field : Define hasfield_t macro for Configure internal use hasfield_t='varname=$1; struct=$2; type=$3; field=$4; shift; shift; shift; shift; while $test $# -ge 2; do case "$1" in $define) echo "#include <$2>";; esac ; shift 2; done > try.c; echo "int main () { $struct foo; $type bar = foo.$field; }" >> try.c; set try; if eval $compile; then val="$define"; else val="$undef"; fi; set $varname; eval $setvar; $rm_try' metaconfig-debian-perl-5.26.1/U/perl/IncClean.U000066400000000000000000000005551316016665300210650ustar00rootroot00000000000000?RCS: ?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in order ?X: to make quick check on whether the current C compiler is working. ?X: ?MAKE:IncClean: ccflags cppflags ?MAKE: -pick add $@ %< ?LINT:extern ccflags ?LINT:change ccflags ?LINT:extern cppflags ?LINT:change cppflags metaconfig-debian-perl-5.26.1/U/perl/Loc_ar.U000066400000000000000000000014151316016665300206040ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:full_ar: ar ?MAKE: -pick add $@ %< ?S:full_ar: ?S: This variable contains the full pathname to 'ar', whether or ?S: not the user has specified 'portability'. This is only used ?S: in the Makefile.SH. ?S:. : Store the full pathname to the ar program for use in the C program : Respect a hint or command line value for full_ar. case "$full_ar" in '') full_ar=$ar ;; esac metaconfig-debian-perl-5.26.1/U/perl/Mksymlinks.U000066400000000000000000000030721316016665300215470ustar00rootroot00000000000000?RCS: ?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?X: ?X: This unit tries to create a symlink tree on a -Dmksymlinks request ?X: to Configure ?X: ?MAKE:Mksymlinks: lns issymlink src ?MAKE: -pick add $@ %< ?T:dir source file ?LINT:extern mksymlinks : Make symlinks util case "$mksymlinks" in $define|true|[yY]*) case "$src" in ''|'.') echo "Cannot create symlinks in the original directory." >&4 exit 1 ;; *) case "$lns:$issymlink" in *"ln"*" -s:"*"test -"?) echo "Creating the symbolic links..." >&4 cd .. awk '{print $1}' $src/MANIFEST | sed -e 's:/\([^/]*\)$: \1:' | awk 'NF == 1 { dir="."; file=$1 ""; } NF == 2 { dir=$1 ""; file=$2 ""; } { print "# dir = ", dir, "file = ", file mf[dir] = mf[dir]" "source"/"dir"/"file; } END { for (d in mf) { if (d != ".") { print("mkdir -p "d) } print("ln -sf "mf[d]" "d); } }' source="$src" > UU/mksymlinks.$$ sh UU/mksymlinks.$$ rm UU/mksymlinks.$$ # Sanity check 1. if test ! -d t/base; then echo "Failed to create the subdirectories. Aborting." >&4 exit 1 fi # Sanity check 2. if test ! -f t/base/lex.t; then echo "Failed to create the symlinks (t/base/lex.t missing). Aborting." >&4 exit 1 fi if test ! -f win32/win32.c; then echo "Failed to create the symlinks (win32/win32.c missing). Aborting." >&4 exit 1 fi cd UU ;; *) echo "(I cannot figure out how to do symbolic links, ignoring mksymlinks)." >&4 ;; esac ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/perl/Sysroot.U000066400000000000000000000035421316016665300210720ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:sysroot: Head ?MAKE: -pick add $@ %< ?S:sysroot: ?S: This variable is empty unless supplied by the Configure user. ?S: It can contain a path to an alternative root directory, under which ?S: headers and libraries for the compilation target can be found. This ?S: is generally used when cross-compiling using a gcc-like compiler. ?S:. ?LINT:extern cc ?LINT:extern cppflags ?LINT:change cppflags ?LINT:extern ccflags ?LINT:change ccflags ?LINT:extern ldflags ?LINT:change ldflags ?LINT:extern cccdlflags ?X: _sysroot is later used in ccflags, but we do not want it in config.sh ?T:var xxx path _sysroot : Set 'sysroot' to change the logical root directory to your headers and libraries see man gcc : This is primarily meant for cross-compile environments, and may fail to be useful in other cases if test "X$sysroot" = X; then sysroot="" else case "$cc" in *gcc*|*g++*) echo "Using $sysroot to find your headers and libraries, adding to ccflags" # _sysroot is used in places where we need --sysroot=foo # but using the rest of the flags could cause issues. _sysroot="--sysroot=$sysroot"; case "$ccflags" in *sysroot*) ;; 'undef'|*) ccflags="$ccflags $_sysroot" esac case "$ldflags" in *sysroot*) ;; 'undef'|*) ldflags="$ldflags $_sysroot" esac case "$cppflags" in *sysroot*) ;; 'undef'|*) cppflags="$cppflags $_sysroot" esac # lddlflags updated below in lddlflags section; # same with cccdlflags ;; esac # Adjust some defaults to also use $sysroot for var in xlibpth loclibpth locincpth glibpth; do eval xxx=\$$var eval $var='' for path in $xxx; do eval $var=\"\$$var $sysroot$path\" done done fi metaconfig-debian-perl-5.26.1/U/perl/ansi2knr.U000066400000000000000000000020701316016665300211320ustar00rootroot00000000000000?RCS: $Id: ansi2knr.U,v 3.0.1.3 1994/05/06 15:11:49 ram Exp $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:ansi2knr: prototype +cc +ccflags package ?MAKE: -pick add $@ %< ?S:ansi2knr: ?S: This variable is set if the user needs to run ansi2knr. ?S: Currently, this is not supported, so we just abort. ?S:. ?Y:TOP : Check if ansi2knr is required case "$prototype" in "$define") ;; *) ansi2knr='ansi2knr' echo " " cat <&4 $me: FATAL ERROR: This version of $package can only be compiled by a compiler that understands function prototypes. Unfortunately, your C compiler $cc $ccflags doesn't seem to understand them. Sorry about that. If GNU cc is available for your system, perhaps you could try that instead. Eventually, we hope to support building Perl with pre-ANSI compilers. If you would like to help in that effort, please contact . Aborting Configure now. EOM exit 2 ;; esac metaconfig-debian-perl-5.26.1/U/perl/atolf.U000066400000000000000000000012241316016665300205100ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_atolf: Inlibc ?MAKE: -pick add $@ %< ?S:d_atolf: ?S: This variable conditionally defines the HAS_ATOLF symbol, which ?S: indicates to the C program that the atolf() routine is available. ?S:. ?C:HAS_ATOLF: ?C: This symbol, if defined, indicates that the atolf routine is ?C: available to convert strings into long doubles. ?C:. ?H:#$d_atolf HAS_ATOLF /**/ ?H:. ?LINT:set d_atolf : see if atolf exists set atolf d_atolf eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/atoll.U000066400000000000000000000012221316016665300205140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_atoll: Inlibc ?MAKE: -pick add $@ %< ?S:d_atoll: ?S: This variable conditionally defines the HAS_ATOLL symbol, which ?S: indicates to the C program that the atoll() routine is available. ?S:. ?C:HAS_ATOLL: ?C: This symbol, if defined, indicates that the atoll routine is ?C: available to convert strings into long longs. ?C:. ?H:#$d_atoll HAS_ATOLL /**/ ?H:. ?LINT:set d_atoll : see if atoll exists set atoll d_atoll eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/bincompat3.U000066400000000000000000000034241316016665300214460ustar00rootroot00000000000000?RCS: Copyright (c) 1996, Chip Salzenberg ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:bincompat3 d_bincompat3: Oldconfig Myread Setvar cat \ patchlevel subversion ?MAKE: -pick add $@ %< ?Y:TOP ?S:bincompat3: ?S: This variable contains y if Perl 5.004 should be binary-compatible ?S: with Perl 5.003. ?S:. ?S:d_bincompat3: ?S: This variable conditionally defines BINCOMPAT3 so that embed.h ?S: can take special action if Perl 5.004 should be binary-compatible ?S: with Perl 5.003. This is impossible for 5.004_50 and later, so ?S: it is always $undef for those versions. ?S:. ?C:BINCOMPAT3: ?C: This symbol, if defined, indicates that Perl 5.004 should be ?C: binary-compatible with Perl 5.003. This is impossible for ?C: 5.004_50 and later, so it is always undefined for those versions. ?C:. ?H:#$d_bincompat3 BINCOMPAT3 /**/ ?H:. : Binary compatibility with 5.003 is not possible with 5.004_50 and later. if test $patchlevel -gt 4 -o $subversion -ge 50; then d_bincompat3=$undef else $cat <&4 $cat >try.c <<'EOCP' #include #include #include #define SYRINX(x) __builtin_choose_expr( x, (1056*2), (103*50) ) int main(void) { assert( SYRINX(1) == 2112 ); assert( SYRINX(1) != 5150 ); assert( SYRINX(0) == 5150 ); assert( SYRINX(0) != 2112 ); puts( "All good!" ); exit(0); } EOCP set try if eval $compile && $run ./try; then echo "Your C compiler supports __builtin_choose_expr." val="$define" else echo "Your C compiler doesn't seem to understand __builtin_choose_expr." val="$undef" fi ;; *) val="$d_builtin_choose_expr" ;; esac set d_builtin_choose_expr eval $setvar $rm_try : Look for GCC-style __builtin_expect case "$d_builtin_expect" in '') echo " " echo "Checking whether your compiler can handle __builtin_expect ..." >&4 $cat >try.c <<'EOCP' int main(void) { int n = 50; if ( __builtin_expect(n, 0) ) n = 1; /* Remember shell exit code truth is 0, C truth is non-zero */ return !(n == 1); } EOCP set try if eval $compile && $run ./try; then echo "Your C compiler supports __builtin_expect." val="$define" else echo "Your C compiler doesn't seem to understand __builtin_expect." val="$undef" fi ;; *) val="$d_builtin_expect" ;; esac set d_builtin_expect eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_c99_variadic.U000066400000000000000000000036321316016665300221610ustar00rootroot00000000000000?RCS: Copyright (c) 2006-2007, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_c99_variadic_macros: Compile Setvar cat rm_try run i_stdarg i_stdlib ?MAKE: -pick add $@ %< ?S:d_c99_variadic_macros: ?S: This variable conditionally defines the HAS_C99_VARIADIC_MACROS ?S: symbol, which indicates to the C program that C99 variadic macros ?S: are available. ?S:. ?C:HAS_C99_VARIADIC_MACROS: ?C: If defined, the compiler supports C99 variadic macros. ?C:. ?H:#$d_c99_variadic_macros HAS_C99_VARIADIC_MACROS /**/ ?H:. ?F:!try : see if the Compiler supports C99 variadic macros case "$i_stdarg$i_stdlib" in "$define$define") echo "You have and , so checking for C99 variadic macros." >&4 $cat >try.c < #include #define foo(buffer, format, ...) sprintf(buffer, format, __VA_ARGS__) int main() { char buf[20]; foo(buf, "%d %g %.*s", 123, 456.0, (int)3, "789fail"); puts(buf); return 0; } EOCP set try if eval $compile && $run ./try 2>&1 >/dev/null; then case "`$run ./try`" in "123 456 789") echo "You have C99 variadic macros." >&4 d_c99_variadic_macros="$define" ;; *) echo "You don't have functional C99 variadic macros." >&4 d_c99_variadic_macros="$undef" ;; esac else echo "I couldn't compile and run the test program, so I assume that you don't have functional C99 variadic macros." >&4 d_c99_variadic_macros="$undef" fi $rm_try ;; *) echo "You don't have and , so not checking for C99 variadic macros." >&4 d_c99_variadic_macros="$undef" ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_class.U000066400000000000000000000021141316016665300210120ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_class: Inlibc ?MAKE: -pick add $@ %< ?S:d_class: ?S: This variable conditionally defines the HAS_CLASS symbol, which ?S: indicates to the C program that the class() routine is available. ?S:. ?C:HAS_CLASS: ?C: This symbol, if defined, indicates that the class routine is ?C: available to classify doubles. Available for example in AIX. ?C: The returned values are defined in and are: ?C: ?C: FP_PLUS_NORM Positive normalized, nonzero ?C: FP_MINUS_NORM Negative normalized, nonzero ?C: FP_PLUS_DENORM Positive denormalized, nonzero ?C: FP_MINUS_DENORM Negative denormalized, nonzero ?C: FP_PLUS_ZERO +0.0 ?C: FP_MINUS_ZERO -0.0 ?C: FP_PLUS_INF +INF ?C: FP_MINUS_INF -INF ?C: FP_NANS Signaling Not a Number (NaNS) ?C: FP_NANQ Quiet Not a Number (NaNQ) ?C:. ?H:#$d_class HAS_CLASS /**/ ?H:. ?LINT:set d_class : see if class exists set class d_class eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_clearenv.U000066400000000000000000000012341316016665300215060ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2005 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_clearenv: Inlibc ?MAKE: -pick add $@ %< ?S:d_clearenv: ?S: This variable conditionally defines the HAS_CLEARENV symbol, which ?S: indicates to the C program that the clearenv () routine is available. ?S:. ?C:HAS_CLEARENV: ?C: This symbol, if defined, indicates that the clearenv () routine is ?C: available for use. ?C:. ?H:#$d_clearenv HAS_CLEARENV /**/ ?H:. ?LINT:set d_clearenv : see if clearenv exists set clearenv d_clearenv eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_clock_getres.U000066400000000000000000000016241316016665300223560ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_clock_getres: Inlibc ?MAKE: -pick add $@ %< ?S:d_clock_getres: ?S: This variable conditionally defines HAS_CLOCK_GETRES ?S: if clock_getres() is available to get the resolution of a POSIX clock. ?S:. ?C:HAS_CLOCK_GETRES: ?C: This symbol, if defined, indicates that the clock_getres ?C: system call is available to get the resolution of a POSIX clock. ?C:. ?H:#$d_clock_getres HAS_CLOCK_GETRES /**/ ?H:. ?LINT:set d_clock_getres : see if clock_getres exists set clock_getres d_clock_getres eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_clock_gettime.U000066400000000000000000000016241316016665300225230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_clock_gettime: Inlibc ?MAKE: -pick add $@ %< ?S:d_clock_gettime: ?S: This variable conditionally defines HAS_CLOCK_GETTIME ?S: if clock_gettime() is available to get the time of a POSIX clock. ?S:. ?C:HAS_CLOCK_GETTIME: ?C: This symbol, if defined, indicates that the clock_gettime ?C: system call is available to get the time of a POSIX clock. ?C:. ?H:#$d_clock_gettime HAS_CLOCK_GETTIME /**/ ?H:. ?LINT:set d_clock_gettime : see if clock_gettime exists set clock_gettime d_clock_gettime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_clock_settime.U000066400000000000000000000016241316016665300225370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_clock_settime: Inlibc ?MAKE: -pick add $@ %< ?S:d_clock_settime: ?S: This variable conditionally defines HAS_CLOCK_SETTIME ?S: if clock_settime() is available to set the time of a POSIX clock. ?S:. ?C:HAS_CLOCK_SETTIME: ?C: This symbol, if defined, indicates that the clock_settime ?C: system call is available to set the time of a POSIX clock. ?C:. ?H:#$d_clock_settime HAS_CLOCK_SETTIME /**/ ?H:. ?LINT:set d_clock_settime : see if clock_settime exists set clock_settime d_clock_settime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_cmsghdr_s.U000066400000000000000000000017001316016665300216560ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_cmsghdr_s: Hasstruct i_systypes d_socket i_sysuio Setvar ?MAKE: -pick add $@ %< ?S:d_cmsghdr_s: ?S: This variable conditionally defines the HAS_STRUCT_CMSGHDR symbol, ?S: which indicates that the struct cmsghdr is supported. ?S:. ?C:HAS_STRUCT_CMSGHDR: ?C: This symbol, if defined, indicates that the struct cmsghdr ?C: is supported. ?C:. ?H:#$d_cmsghdr_s HAS_STRUCT_CMSGHDR /**/ ?H:. ?LINT:set d_cmsghdr_s : Check for cmsghdr support echo " " echo "Checking to see if your system supports struct cmsghdr..." >&4 set d_cmsghdr_s cmsghdr $i_systypes sys/types.h $d_socket sys/socket.h $i_sysuio sys/uio.h eval $hasstruct case "$d_cmsghdr_s" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_copysign.U000066400000000000000000000013001316016665300215340ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2014 Jarkko Hietaniemi & H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_copysign: Inlibc ?MAKE: -pick add $@ %< ?S:d_copysign: ?S: This variable conditionally defines the HAS_COPYSIGN symbol, which ?S: indicates to the C program that the copysign() routine is available. ?S:. ?C:HAS_COPYSIGN: ?C: This symbol, if defined, indicates that the copysign routine is ?C: available to do the copysign function. ?C:. ?H:#$d_copysign HAS_COPYSIGN /**/ ?H:. ?LINT:set d_copysign : see if copysign exists set copysign d_copysign eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_copysignl.U000066400000000000000000000014021316016665300217130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_copysignl: Inlibc ?MAKE: -pick add $@ %< ?S:d_copysignl: ?S: This variable conditionally defines the HAS_COPYSIGNL symbol, which ?S: indicates to the C program that the copysignl() routine is available. ?S: If aintl is also present we can emulate modfl. ?S:. ?C:HAS_COPYSIGNL: ?C: This symbol, if defined, indicates that the copysignl routine is ?C: available. If aintl is also present we can emulate modfl. ?C:. ?H:#$d_copysignl HAS_COPYSIGNL /**/ ?H:. ?LINT:set d_copysignl : see if copysignl exists set copysignl d_copysignl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_cplusplus.U000066400000000000000000000021371316016665300217440ustar00rootroot00000000000000?RCS: Copyright (c) 2005-2007 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_cplusplus: Compile Setvar run cat rm_try ?MAKE: -pick add $@ %< ?S:d_cplusplus (d_cplusplus.U): ?S: This variable conditionally defines the USE_CPLUSPLUS symbol, which ?S: indicates that a C++ compiler was used to compiled Perl and will be ?S: used to compile extensions. ?S:. ?C:USE_CPLUSPLUS: ?C: This symbol, if defined, indicates that a C++ compiler was ?C: used to compiled Perl and will be used to compile extensions. ?C:. ?H:#$d_cplusplus USE_CPLUSPLUS /**/ ?H:. ?F:!try ?LINT:set d_cplusplus : Check if we are using C++ echo " " echo "Checking for C++..." >&4 $cat >try.c <<'EOCP' #include int main(void) { #ifdef __cplusplus return 0; #else return 1; #endif } EOCP set try if eval $compile_ok && $run ./try; then val="$define" echo "You are using a C++ compiler." else val="$undef" echo "You are not using a C++ compiler." fi $rm_try cplusplus$$ set d_cplusplus eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_dbminitproto.U000066400000000000000000000021641316016665300224240ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_dbminitproto: Hasproto i_dbm ?MAKE: -pick add $@ %< ?S:d_dbminitproto: ?S: This variable conditionally defines the HAS_DBMINIT_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the dbminit() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_DBMINIT_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the dbminit() function. Otherwise, it is up ?C: to the program to supply one. A good guess is ?C: extern int dbminit(char *); ?C:. ?H:#$d_dbminitproto HAS_DBMINIT_PROTO /**/ ?H:. ?LINT:set d_dbminitproto : see if prototype for dbminit is available echo " " set d_dbminitproto dbminit $i_dbm dbm.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_dir_dd_fd.U000066400000000000000000000027411316016665300216110ustar00rootroot00000000000000?RCS: Copyright (c) 2006-2007, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: ?MAKE:d_dir_dd_fd: Compile cat rm_try Setvar i_dirent i_stdlib ?MAKE: -pick add $@ %< ?S:d_dir_dd_fd (d_dir_dd_fd.U): ?S: This variable conditionally defines the HAS_DIR_DD_FD symbol, which ?S: indicates that the DIR directory stream type contains a member ?S: variable called dd_fd. ?S:. ?C:HAS_DIR_DD_FD: ?C: This symbol, if defined, indicates that the the DIR* dirstream ?C: structure contains a member variable named dd_fd. ?C:. ?H:#$d_dir_dd_fd HAS_DIR_DD_FD /**/ ?H:. ?LINT:set d_dir_dd_fd : Look for DIR.dd_fd case "$i_dirent" in "$define") echo "Checking to see if DIR has a dd_fd member variable" >&4 $cat >try.c < #endif #include int main() { DIR dir; dir.dd_fd = 1; return 0; } EOCP val=$undef set try if eval $compile; then echo "Yes, it does." val="$define" else echo "No, it does not." val="$undef" fi ;; *) echo "You don't have a , so not checking for dd_fd." >&4 val="$undef" ;; esac set d_dir_dd_fd eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_dirfd.U000066400000000000000000000033251316016665300210020ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: ?MAKE:d_dirfd: Compile cat rm Setvar i_dirent i_sysdir i_sysndir i_systypes i_stdlib ?MAKE: -pick add $@ %< ?S:d_dirfd: ?S: This variable conditionally defines the HAS_DIRFD constant, ?S: which indicates to the C program that dirfd() is available ?S: to return the file descriptor of a directory stream. ?S:. ?C:HAS_DIRFD: ?C: This manifest constant lets the C program know that dirfd ?C: is available. ?C:. ?H:#$d_dirfd HAS_DIRFD /**/ ?H:. ?LINT:set d_dirfd ?X: Can't use Inlibc because dirfd() might be a macro. : Look for dirfd echo " " $cat >dirfd.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_dirent I_DIRENT /**/ #$i_sysdir I_SYS_DIR /**/ #$i_sysndir I_SYS_NDIR /**/ #$i_systypes I_SYS_TYPES /**/ #if defined(I_SYS_TYPES) #include #endif #if defined(I_DIRENT) #include #else #ifdef I_SYS_NDIR #include #else #ifdef I_SYS_DIR #ifdef hp9000s500 #include /* may be wrong in the future */ #else #include #endif #endif #endif #endif int main() { DIR *dirp = opendir("."); if (dirfd(dirp) >= 0) exit(0); else exit(1); } EOM val=$undef set dirfd if eval $compile; then val="$define" fi case "$val" in $define) echo "dirfd() found." >&4 ;; *) echo "dirfd() NOT found." >&4 ;; esac set d_dirfd eval $setvar $rm -f dirfd* metaconfig-debian-perl-5.26.1/U/perl/d_dlsymun.U000066400000000000000000000057751316016665300214200ustar00rootroot00000000000000?RCS: $Id: d_dlsymun.U,v $ ?RCS: ?RCS: Copyright (c) 1996-1998, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_dlsymun.U,v $ ?RCS: ?RCS: ?MAKE:d_dlsymun: cat cc ccflags ldflags ld rm Setvar dlsrc i_dlfcn i_stdlib \ cccdlflags ccdlflags lddlflags libs dlext _o run to ?MAKE: -pick add $@ %< ?X: This is specific to perl5. ?S:d_dlsymun: ?S: This variable conditionally defines DLSYM_NEEDS_UNDERSCORE, which ?S: indicates that we need to prepend an underscore to the symbol ?S: name before calling dlsym(). ?S:. ?C:DLSYM_NEEDS_UNDERSCORE: ?C: This symbol, if defined, indicates that we need to prepend an ?C: underscore to the symbol name before calling dlsym(). This only ?C: makes sense if you *have* dlsym, which we will presume is the ?C: case if you're using dl_dlopen.xs. ?C:. ?H:#$d_dlsymun DLSYM_NEEDS_UNDERSCORE /**/ ?H:. ?LINT:set d_dlsymun ?T: xxx ?F:!fred : Check if dlsym need a leading underscore echo " " val="$undef" case "$dlsrc" in dl_dlopen.xs) echo "Checking whether your dlsym() needs a leading underscore ..." >&4 $cat >dyna.c <<'EOM' fred () { } EOM $cat >fred.c< #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_dlfcn I_DLFCN #ifdef I_DLFCN #include /* the dynamic linker include file for SunOS/Solaris */ #else #include #include #include #endif extern int fred() ; int main() { void * handle ; void * symbol ; #ifndef RTLD_LAZY int mode = 1 ; #else int mode = RTLD_LAZY ; #endif handle = dlopen("./dyna.$dlext", mode) ; if (handle == NULL) { printf ("1\n") ; fflush (stdout) ; exit(0); } symbol = dlsym(handle, "fred") ; if (symbol == NULL) { /* try putting a leading underscore */ symbol = dlsym(handle, "_fred") ; if (symbol == NULL) { printf ("2\n") ; fflush (stdout) ; exit(0); } printf ("3\n") ; } else printf ("4\n") ; fflush (stdout) ; exit(0); } EOM : Call the object file tmp-dyna.o in case dlext=o. if $cc $ccflags $cccdlflags -c dyna.c > /dev/null 2>&1 && mv dyna${_o} tmp-dyna${_o} > /dev/null 2>&1 && $ld -o dyna.$dlext $ldflags $lddlflags tmp-dyna${_o} > /dev/null 2>&1 && $cc -o fred $ccflags $ldflags $cccdlflags $ccdlflags fred.c $libs > /dev/null 2>&1 && $to dyna.$dlext; then xxx=`$run ./fred` case $xxx in 1) echo "Test program failed using dlopen." >&4 echo "Perhaps you should not use dynamic loading." >&4;; 2) echo "Test program failed using dlsym." >&4 echo "Perhaps you should not use dynamic loading." >&4;; 3) echo "dlsym needs a leading underscore" >&4 val="$define" ;; 4) echo "dlsym doesn't need a leading underscore." >&4;; esac else echo "I can't compile and run the test program." >&4 echo "I'm guessing that dlsym doesn't need a leading underscore." >&4 fi ;; esac $rm -f fred fred.* dyna.$dlext dyna.* tmp-dyna.* set d_dlsymun eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_endspent.U000066400000000000000000000015771316016665300215410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_endspent: Inlibc ?MAKE: -pick add $@ %< ?S:d_endspent: ?S: This variable conditionally defines HAS_ENDSPENT if endspent() is ?S: available to finalize the scan of SysV shadow password entries. ?S:. ?C:HAS_ENDSPENT: ?C: This symbol, if defined, indicates that the endspent system call is ?C: available to finalize the scan of SysV shadow password entries. ?C:. ?H:#$d_endspent HAS_ENDSPENT /**/ ?H:. ?LINT:set d_endspent : see if endspent exists set endspent d_endspent eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_erf.U000066400000000000000000000010561316016665300204650ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_erf: Inlibc ?MAKE: -pick add $@ %< ?S:d_erf: ?S: This variable conditionally defines the HAS_ERF symbol, which ?S: indicates to the C program that the erf() routine is available. ?S:. ?C:HAS_ERF: ?C: This symbol, if defined, indicates that the erf routine is ?C: available to do the error function. ?C:. ?H:#$d_erf HAS_ERF /**/ ?H:. ?LINT:set d_erf : see if erf exists set erf d_erf eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_erfc.U000066400000000000000000000011101316016665300206170ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_erfc: Inlibc ?MAKE: -pick add $@ %< ?S:d_erfc: ?S: This variable conditionally defines the HAS_ERFC symbol, which ?S: indicates to the C program that the erfc() routine is available. ?S:. ?C:HAS_ERFC: ?C: This symbol, if defined, indicates that the erfc routine is ?C: available to do the complementary error function. ?C:. ?H:#$d_erfc HAS_ERFC /**/ ?H:. ?LINT:set d_erfc : see if erfc exists set erfc d_erfc eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_exp2.U000066400000000000000000000010711316016665300205640ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_exp2: Inlibc ?MAKE: -pick add $@ %< ?S:d_exp2: ?S: This variable conditionally defines the HAS_EXP2 symbol, which ?S: indicates to the C program that the exp2() routine is available. ?S:. ?C:HAS_EXP2: ?C: This symbol, if defined, indicates that the exp2 routine is ?C: available to do the 2**x function. ?C:. ?H:#$d_exp2 HAS_EXP2 /**/ ?H:. ?LINT:set d_exp2 : see if exp2 exists set exp2 d_exp2 eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_expm1.U000066400000000000000000000011341316016665300207400ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_expm1: Inlibc ?MAKE: -pick add $@ %< ?S:d_expm1: ?S: This variable conditionally defines the HAS_EXPM1 symbol, which ?S: indicates to the C program that the expm1() routine is available. ?S:. ?C:HAS_EXPM1: ?C: This symbol, if defined, indicates that the expm1 routine is ?C: available to do the exp(x) - 1 when x is near 1 function. ?C:. ?H:#$d_expm1 HAS_EXPM1 /**/ ?H:. ?LINT:set d_expm1 : see if expm1 exists set expm1 d_expm1 eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_faststdio.U000066400000000000000000000020641316016665300217110ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_faststdio: Setvar \ d_stdstdio d_stdio_ptr_lval d_stdio_cnt_lval d_stdio_ptr_lval_sets_cnt ?MAKE: -pick add $@ %< ?S:d_faststdio: ?S: This variable conditionally defines the HAS_FAST_STDIO symbol, ?S: which indicates to the C program that the "fast stdio" is available ?S: to manipulate the stdio buffers directly. ?S:. ?C:HAS_FAST_STDIO: ?C: This symbol, if defined, indicates that the "fast stdio" ?C: is available to manipulate the stdio buffers directly. ?C:. ?H:#$d_faststdio HAS_FAST_STDIO /**/ ?H:. ?LINT:set d_faststdio : see if fast_stdio exists val="$undef" case "$d_stdstdio:$d_stdio_ptr_lval" in "$define:$define") case "$d_stdio_cnt_lval$d_stdio_ptr_lval_sets_cnt" in *$define*) echo "You seem to have 'fast stdio' to directly manipulate the stdio buffers." >& 4 val="$define" ;; esac ;; esac set d_faststdio eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_fchdir.U000066400000000000000000000012471316016665300211520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fchdir: Inlibc ?MAKE: -pick add $@ %< ?S:d_fchdir: ?S: This variable conditionally defines the HAS_FCHDIR symbol, which ?S: indicates to the C program that the fchdir() routine is available. ?S:. ?C:HAS_FCHDIR: ?C: This symbol, if defined, indicates that the fchdir routine is ?C: available to change directory using a file descriptor. ?C:. ?H:#$d_fchdir HAS_FCHDIR /**/ ?H:. ?LINT:set d_fchdir : see if fchdir exists set fchdir d_fchdir eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fcntl_can_lock.U000066400000000000000000000045411316016665300226520ustar00rootroot00000000000000?RCS: $Id: d_fcntl_can_lock.U,v$ ?RCS: ?RCS: Copyright (c) 2000, Andrew Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_fcntl_can_lock.U,v $ ?RCS: ?MAKE:d_fcntl_can_lock: d_fcntl Compile Setvar cat rm_try run signal_t i_stdlib ?MAKE: -pick add $@ %< ?S:d_fcntl_can_lock: ?S: This variable conditionally defines the FCNTL_CAN_LOCK symbol ?S: and indicates whether file locking with fcntl() works. ?S:. ?C:FCNTL_CAN_LOCK: ?C: This symbol, if defined, indicates that fcntl() can be used ?C: for file locking. Normally on Unix systems this is defined. ?C: It may be undefined on VMS. ?C:. ?H:#$d_fcntl_can_lock FCNTL_CAN_LOCK /**/ ?H:. ?F:!try ?LINT: set d_fcntl_can_lock ?X: fcntl may not be fully functional. As of November 2000, on VMS and ?X: DOS/DJGPP, fctnl-based locking doesn't work. ?X: Thanks to Craig A. Berry for this test. : See if fcntl-based locking works. echo " " $cat >try.c < #endif #include #include #include $signal_t blech(int x) { exit(3); } int main() { #if defined(F_SETLK) && defined(F_SETLKW) struct flock flock; int retval, fd; fd = open("try.c", O_RDONLY); flock.l_type = F_RDLCK; flock.l_whence = SEEK_SET; flock.l_start = flock.l_len = 0; signal(SIGALRM, blech); alarm(10); retval = fcntl(fd, F_SETLK, &flock); close(fd); (retval < 0 ? exit(2) : exit(0)); #else exit(2); #endif } EOCP echo "Checking if fcntl-based file locking works... " case "$d_fcntl" in "$define") set try if eval $compile_ok; then if $run ./try; then echo "Yes, it seems to work." val="$define" else echo "Nope, it didn't work." val="$undef" case "$?" in 3) $cat >&4 < and are: ?C: ?C: FP_SNAN Signaling NaN (Not-a-Number) ?C: FP_QNAN Quiet NaN (Not-a-Number) ?C: FP_POS_INF +infinity ?C: FP_NEG_INF -infinity ?C: FP_POS_NORM Positive normalized ?C: FP_NEG_NORM Negative normalized ?C: FP_POS_DENORM Positive denormalized ?C: FP_NEG_DENORM Negative denormalized ?C: FP_POS_ZERO +0.0 (positive zero) ?C: FP_NEG_ZERO -0.0 (negative zero) ?C:. ?H:#$d_fp_class HAS_FP_CLASS /**/ ?H:. ?LINT:set d_fp_class : see if fp_class exists set fp_class d_fp_class eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fp_class_l.U000066400000000000000000000023111316016665300220110ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fp_class_l: Inlibc ?MAKE: -pick add $@ %< ?S:d_fp_class_l: ?S: This variable conditionally defines the HAS_FP_CLASS_L symbol, which ?S: indicates to the C program that the fp_class_l() routine is available. ?S:. ?C:HAS_FP_CLASS_L: ?C: This symbol, if defined, indicates that the fp_class_l routine is ?C: available to classify long doubles. Available for example in IRIX. ?C: The returned values are defined in and are: ?C: ?C: FP_SNAN Signaling NaN (Not-a-Number) ?C: FP_QNAN Quiet NaN (Not-a-Number) ?C: FP_POS_INF +infinity ?C: FP_NEG_INF -infinity ?C: FP_POS_NORM Positive normalized ?C: FP_NEG_NORM Negative normalized ?C: FP_POS_DENORM Positive denormalized ?C: FP_NEG_DENORM Negative denormalized ?C: FP_POS_ZERO +0.0 (positive zero) ?C: FP_NEG_ZERO -0.0 (negative zero) ?C:. ?H:#$d_fp_class_l HAS_FP_CLASS_L /**/ ?H:. ?LINT:set d_fp_class_l : see if fp_class_l exists set fp_class_l d_fp_class_l eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fp_classl.U000066400000000000000000000014131316016665300216540ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fp_classl: Inlibc ?MAKE: -pick add $@ %< ?S:d_fp_classl: ?S: This variable conditionally defines the HAS_FP_CLASSL symbol, which ?S: indicates to the C program that the fp_classl() routine is available. ?S:. ?C:HAS_FP_CLASSL: ?C: This symbol, if defined, indicates that the fp_classl routine is ?C: available to classify long doubles. Available for example in ?C: Digital UNIX. See for possible values HAS_FP_CLASS. ?C:. ?H:#$d_fp_classl HAS_FP_CLASSL /**/ ?H:. ?LINT:set d_fp_classl : see if fp_classl exists set fp_classl d_fp_classl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fpclass.U000066400000000000000000000021301316016665300213360ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fpclass: Inlibc ?MAKE: -pick add $@ %< ?S:d_fpclass: ?S: This variable conditionally defines the HAS_FPCLASS symbol, which ?S: indicates to the C program that the fpclass() routine is available. ?S:. ?C:HAS_FPCLASS: ?C: This symbol, if defined, indicates that the fpclass routine is ?C: available to classify doubles. Available for example in Solaris/SVR4. ?C: The returned values are defined in and are: ?C: ?C: FP_SNAN signaling NaN ?C: FP_QNAN quiet NaN ?C: FP_NINF negative infinity ?C: FP_PINF positive infinity ?C: FP_NDENORM negative denormalized non-zero ?C: FP_PDENORM positive denormalized non-zero ?C: FP_NZERO negative zero ?C: FP_PZERO positive zero ?C: FP_NNORM negative normalized non-zero ?C: FP_PNORM positive normalized non-zero ?C:. ?H:#$d_fpclass HAS_FPCLASS /**/ ?H:. ?LINT:set d_fpclass : see if fpclass exists set fpclass d_fpclass eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fpclassify.U000066400000000000000000000051241316016665300220540ustar00rootroot00000000000000?RCS: Copyright (c) 2000,2014 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fpclassify d_fp_classify: Inlibc cat i_math Compile rm_try Setvar ?MAKE: -pick add $@ %< ?X:the short story is that C99 says use fpclassify. But the story is confused ?X:by systems "partially C99" (or fully "pre C99") which either user fpclassify ?X:but with different return values, or they use fp_classify (with the expected) ?X:return values, or they use some other spelling of *fp*class* (sometimes even ?X:without the *fp* part), with yet another set(s) of return values ... ?S:d_fpclassify: ?S: This variable conditionally defines the HAS_FPCLASSIFY symbol, which ?S: indicates to the C program that the fpclassify() routine is available. ?S:. ?S:d_fp_classify: ?S: This variable conditionally defines the HAS_FP_CLASSIFY symbol, which ?S: indicates to the C program that the fp_classify() routine is available. ?S:. ?C:HAS_FPCLASSIFY: ?C: This symbol, if defined, indicates that the fpclassify routine is ?C: available to classify doubles. Available for example in HP-UX. ?C: The returned values are defined in and are ?C: ?C: FP_NORMAL Normalized ?C: FP_ZERO Zero ?C: FP_INFINITE Infinity ?C: FP_SUBNORMAL Denormalized ?C: FP_NAN NaN ?C: ?C:. ?C:HAS_FP_CLASSIFY: ?C: This symbol, if defined, indicates that the fp_classify routine is ?C: available to classify doubles. The values are defined in ?C: ?C: FP_NORMAL Normalized ?C: FP_ZERO Zero ?C: FP_INFINITE Infinity ?C: FP_SUBNORMAL Denormalized ?C: FP_NAN NaN ?C: ?C:. ?H:#$d_fpclassify HAS_FPCLASSIFY /**/ ?H:#$d_fp_classify HAS_FP_CLASSIFY /**/ ?H:. ?LINT:set d_fpclassify ?LINT:set d_fp_classify : check for fpclassify ?X:classified (Comment by jhi) ?X:fpclassify i_math ?X:fp_classify i_math ?X:fpclass i_math i_ieeefp i_fp ?X:fp_class i_math i_fp_class ?X: No i_fp_class yet. But the systems that have ?X: this (Tru64 and IRIX) both had ?X:class i_math echo "Checking to see if you have fpclassify..." >&4 $cat >try.c < #endif int main() { return fpclassify(1.0) == FP_NORMAL ? 0 : 1; } EOCP set try if eval $compile; then val="$define" echo "You have fpclassify." else val="$undef" echo "You do not have fpclassify." fi $rm_try set d_fpclassify eval $setvar : see if fp_classify exists set fp_classify d_fp_classify eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fpclassl.U000066400000000000000000000021411316016665300215140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fpclassl: Inlibc ?MAKE: -pick add $@ %< ?S:d_fpclassl: ?S: This variable conditionally defines the HAS_FPCLASSL symbol, which ?S: indicates to the C program that the fpclassl() routine is available. ?S:. ?C:HAS_FPCLASSL: ?C: This symbol, if defined, indicates that the fpclassl routine is ?C: available to classify long doubles. Available for example in IRIX. ?C: The returned values are defined in and are: ?C: ?C: FP_SNAN signaling NaN ?C: FP_QNAN quiet NaN ?C: FP_NINF negative infinity ?C: FP_PINF positive infinity ?C: FP_NDENORM negative denormalized non-zero ?C: FP_PDENORM positive denormalized non-zero ?C: FP_NZERO negative zero ?C: FP_PZERO positive zero ?C: FP_NNORM negative normalized non-zero ?C: FP_PNORM positive normalized non-zero ?C:. ?H:#$d_fpclassl HAS_FPCLASSL /**/ ?H:. ?LINT:set d_fpclassl : see if fpclassl exists set fpclassl d_fpclassl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fpgetround.U000066400000000000000000000011761316016665300220710ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fpgetround: Inlibc ?MAKE: -pick add $@ %< ?S:d_fpgetround: ?S: This variable conditionally defines HAS_FPGETROUND if fpgetround() ?S: is available to get the floating point rounding mode. ?S:. ?C:HAS_FPGETROUND: ?C: This symbol, if defined, indicates that the fpgetround routine is ?C: available to get the floating point rounding mode. ?C:. ?H:#$d_fpgetround HAS_FPGETROUND /**/ ?H:. ?LINT:set d_fpgetround : see if fpgetround exists set fpgetround d_fpgetround eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fpos64_t.U000066400000000000000000000016771316016665300213660ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fpos64_t: \ Inlibc Setvar Compile rm_try cat fpossize ?MAKE: -pick add $@ %< ?S:d_fpos64_t: ?S: This symbol will be defined if the C compiler supports fpos64_t. ?S:. ?C:HAS_FPOS64_T: ?C: This symbol will be defined if the C compiler supports fpos64_t. ?C:. ?H:#$d_fpos64_t HAS_FPOS64_T /**/ ?H:. ?LINT:set d_fpos64_t : check for fpos64_t echo " " echo "Checking to see if you have fpos64_t..." >&4 $cat >try.c < int main() { fpos64_t x = 7; } EOCP set try if eval $compile; then val="$define" echo "You have fpos64_t." else val="$undef" echo "You do not have fpos64_t." case "$fpossize" in 8) echo "(Your fpos_t is 64 bits, so you could use that.)" ;; esac fi $rm_try set d_fpos64_t eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_frexpl.U000066400000000000000000000013421316016665300212070ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_frexpl: Inlibc ?MAKE: -pick add $@ %< ?S:d_frexpl: ?S: This variable conditionally defines the HAS_FREXPL symbol, which ?S: indicates to the C program that the frexpl() routine is available. ?S:. ?C:HAS_FREXPL: ?C: This symbol, if defined, indicates that the frexpl routine is ?C: available to break a long double floating-point number into ?C: a normalized fraction and an integral power of 2. ?C:. ?H:#$d_frexpl HAS_FREXPL /**/ ?H:. ?LINT:set d_frexpl : see if frexpl exists set frexpl d_frexpl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fs_data_s.U000066400000000000000000000017211316016665300216330ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fs_data_s: Hasstruct i_sysparam i_sysmount i_systypes Setvar ?MAKE: -pick add $@ %< ?S:d_fs_data_s: ?S: This variable conditionally defines the HAS_STRUCT_FS_DATA symbol, ?S: which indicates that the struct fs_data is supported. ?S:. ?C:HAS_STRUCT_FS_DATA: ?C: This symbol, if defined, indicates that the struct fs_data ?C: to do statfs() is supported. ?C:. ?H:#$d_fs_data_s HAS_STRUCT_FS_DATA /**/ ?H:. ?LINT:set d_fs_data_s : Check for fs_data_s echo " " echo "Checking to see if your system supports struct fs_data..." >&4 set d_fs_data_s fs_data $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h eval $hasstruct case "$d_fs_data_s" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_fseeko.U000066400000000000000000000014131316016665300211620ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fseeko: Inlibc longsize ?MAKE: -pick add $@ %< ?S:d_fseeko: ?S: This variable conditionally defines the HAS_FSEEKO symbol, which ?S: indicates to the C program that the fseeko() routine is available. ?S:. ?C:HAS_FSEEKO: ?C: This symbol, if defined, indicates that the fseeko routine is ?C: available to fseek beyond 32 bits (useful for ILP32 hosts). ?C:. ?H:#$d_fseeko HAS_FSEEKO /**/ ?H:. ?LINT:set d_fseeko : see if fseeko exists set fseeko d_fseeko eval $inlibc case "$longsize" in 8) echo "(Your long is 64 bits, so you could use fseek.)" ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_fstatfs.U000066400000000000000000000012601316016665300213600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fstatfs : Inlibc ?MAKE: -pick add $@ %< ?S:d_fstatfs: ?S: This variable conditionally defines the HAS_FSTATFS symbol, which ?S: indicates to the C program that the fstatfs() routine is available. ?S:. ?C:HAS_FSTATFS: ?C: This symbol, if defined, indicates that the fstatfs routine is ?C: available to stat filesystems by file descriptors. ?C:. ?H:#$d_fstatfs HAS_FSTATFS /**/ ?H:. ?LINT:set d_fstatfs : see if fstatfs exists set fstatfs d_fstatfs eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_fsync.U000066400000000000000000000012671316016665300210370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_fsync: Inlibc ?MAKE: -pick add $@ %< ?S:d_fsync: ?S: This variable conditionally defines the HAS_FSYNC symbol, which ?S: indicates to the C program that the fsync() routine is available. ?S:. ?C:HAS_FSYNC: ?C: This symbol, if defined, indicates that the fsync routine is ?C: available to write a file's modified data and attributes to ?C: permanent storage. ?C:. ?H:#$d_fsync HAS_FSYNC /**/ ?H:. ?LINT:set d_fsync : see if fsync exists set fsync d_fsync eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_ftello.U000066400000000000000000000014131316016665300211730ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_ftello: Inlibc longsize ?MAKE: -pick add $@ %< ?S:d_ftello: ?S: This variable conditionally defines the HAS_FTELLO symbol, which ?S: indicates to the C program that the ftello() routine is available. ?S:. ?C:HAS_FTELLO: ?C: This symbol, if defined, indicates that the ftello routine is ?C: available to ftell beyond 32 bits (useful for ILP32 hosts). ?C:. ?H:#$d_ftello HAS_FTELLO /**/ ?H:. ?LINT:set d_ftello : see if ftello exists set ftello d_ftello eval $inlibc case "$longsize" in 8) echo "(Your long is 64 bits, so you could use ftell.)" ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_futimes.U000066400000000000000000000024661316016665300213730ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_futimes: Compile cat rm_try run ?MAKE: -pick add $@ %< ?S:d_futimes: ?S: This variable conditionally defines the HAS_FUTIMES symbol, which ?S: indicates to the C program that the futimes() routine is available. ?S:. ?C:HAS_FUTIMES: ?C: This symbol, if defined, indicates that the futimes routine is ?C: available to change file descriptor time stamps with struct timevals. ?C:. ?H:#$d_futimes HAS_FUTIMES /**/ ?H:. ?T:rc ?F:!try : check for a working futimes d_futimes="$undef" echo " " echo "Checking if you have a working futimes()" >&4 $cat >try.c < #include #include #include int main () { int fd, rv; fd = open ("try.c", O_RDWR); if (-1 == fd) exit (1); rv = futimes (fd, NULL); exit (rv == -1 ? errno : 0); } EOCP set try if eval $compile; then `$run ./try` rc=$? case "$rc" in 0) echo "Yes, you have" >&4 d_futimes="$define" ;; *) echo "No, you have futimes, but it isn't working ($rc) (probably harmless)" >&4 ;; esac else echo "No, it does not (probably harmless)" >&4 fi $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_gai_strerror.U000066400000000000000000000030331316016665300224100ustar00rootroot00000000000000?RCS: Copyright (c) 2016-2016, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_gai_strerror: Compile cat rm_try run Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_gai_strerror: ?S: This variable conditionally defines the HAS_GAI_STRERROR symbol ?S: if the gai_strerror() routine is available and can be used to ?S: translate error codes returned by getaddrinfo() into human ?S: readable strings. ?S:. ?C:HAS_GAI_STRERROR: ?C: This symbol, if defined, indicates that the gai_strerror routine ?C: is available to translate error codes returned by getaddrinfo() ?C: into human readable strings. ?C:. ?H:#$d_gai_strerror HAS_GAI_STRERROR /**/ ?H:. ?F:!try ?LINT: set d_gai_strerror : look for gai_strerror echo " " $cat >try.c <<'EOCP' #include #include #include int main () { return (gai_strerror (0) ? 0 : 1); } EOCP set try ?X: if $cc $ccflags $ldflags -o try try.c $libs >/dev/null 2>&1 ; then val="$undef" if eval $compile; then `$run ./try` case "$?" in 0) echo "A working gai_strerror() found." >&4 val="$define" ;; *) echo "gai_strerror() found, but it doesn't work" >&4 ;; esac else echo "gai_strerror() NOT found." >&4 fi set d_gai_strerror eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_getaddrinfo.U000066400000000000000000000013041316016665300221730ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2009 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getaddrinfo: Inlibc ?MAKE: -pick add $@ %< ?S:d_getaddrinfo: ?S: This variable conditionally defines the HAS_GETADDRINFO symbol, ?S: which indicates to the C program that the getaddrinfo() function ?S: is available. ?S:. ?C:HAS_GETADDRINFO: ?C: This symbol, if defined, indicates that the getaddrinfo() function ?C: is available for use. ?C:. ?H:#$d_getaddrinfo HAS_GETADDRINFO /**/ ?H:. ?LINT:set d_getaddrinfo : see if getaddrinfo exists set getaddrinfo d_getaddrinfo eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getcwd.U000066400000000000000000000013121316016665300211610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getcwd: Inlibc ?MAKE: -pick add $@ %< ?S:d_getcwd: ?S: This variable conditionally defines the HAS_GETCWD symbol, which ?S: indicates to the C program that the getcwd() routine is available ?S: to get the current working directory. ?S:. ?C:HAS_GETCWD : ?C: This symbol, if defined, indicates that the getcwd routine is ?C: available to get the current working directory. ?C:. ?H:#$d_getcwd HAS_GETCWD /**/ ?H:. ?LINT:set d_getcwd : see if getcwd exists set getcwd d_getcwd eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getespwnam.U000066400000000000000000000016331316016665300220640ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getespwnam: Inlibc ?MAKE: -pick add $@ %< ?S:d_getespwnam: ?S: This variable conditionally defines HAS_GETESPWNAM if getespwnam() is ?S: available to retrieve enhanced (shadow) password entries by name. ?S:. ?C:HAS_GETESPWNAM: ?C: This symbol, if defined, indicates that the getespwnam system call is ?C: available to retrieve enhanced (shadow) password entries by name. ?C:. ?H:#$d_getespwnam HAS_GETESPWNAM /**/ ?H:. ?LINT:set d_getespwnam : see if getespwnam exists set getespwnam d_getespwnam eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getfsstat.U000066400000000000000000000012741316016665300217170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getfsstat : Inlibc ?MAKE: -pick add $@ %< ?S:d_getfsstat: ?S: This variable conditionally defines the HAS_GETFSSTAT symbol, which ?S: indicates to the C program that the getfsstat() routine is available. ?S:. ?C:HAS_GETFSSTAT: ?C: This symbol, if defined, indicates that the getfsstat routine is ?C: available to stat filesystems in bulk. ?C:. ?H:#$d_getfsstat HAS_GETFSSTAT /**/ ?H:. ?LINT:set d_getfsstat : see if getfsstat exists set getfsstat d_getfsstat eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getitimer.U000066400000000000000000000012711316016665300217010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getitimer: Inlibc ?MAKE: -pick add $@ %< ?S:d_getitimer: ?S: This variable conditionally defines the HAS_GETITIMER symbol, which ?S: indicates to the C program that the getitimer() routine is available. ?S:. ?C:HAS_GETITIMER: ?C: This symbol, if defined, indicates that the getitimer routine is ?C: available to return interval timers. ?C:. ?H:#$d_getitimer HAS_GETITIMER /**/ ?H:. ?LINT:set d_getitimer : see if getitimer exists set getitimer d_getitimer eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getmnt.U000066400000000000000000000013361316016665300212100ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getmnt: Inlibc ?MAKE: -pick add $@ %< ?S:d_getmnt: ?S: This variable conditionally defines the HAS_GETMNT symbol, which ?S: indicates to the C program that the getmnt() routine is available ?S: to retrieve one or more mount info blocks by filename. ?S:. ?C:HAS_GETMNT: ?C: This symbol, if defined, indicates that the getmnt routine is ?C: available to get filesystem mount info by filename. ?C:. ?H:#$d_getmnt HAS_GETMNT /**/ ?H:. ?LINT:set d_getmnt : see if getmnt exists set getmnt d_getmnt eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getmntent.U000066400000000000000000000014261316016665300217170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getmntent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getmntent: ?S: This variable conditionally defines the HAS_GETMNTENT symbol, which ?S: indicates to the C program that the getmntent() routine is available ?S: to iterate through mounted files to get their mount info. ?S:. ?C:HAS_GETMNTENT: ?C: This symbol, if defined, indicates that the getmntent routine is ?C: available to iterate through mounted file systems to get their info. ?C:. ?H:#$d_getmntent HAS_GETMNTENT /**/ ?H:. ?LINT:set d_getmntent : see if getmntent exists set getmntent d_getmntent eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getnameinfo.U000066400000000000000000000013041316016665300222010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2009 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getnameinfo: Inlibc ?MAKE: -pick add $@ %< ?S:d_getnameinfo: ?S: This variable conditionally defines the HAS_GETNAMEINFO symbol, ?S: which indicates to the C program that the getnameinfo() function ?S: is available. ?S:. ?C:HAS_GETNAMEINFO: ?C: This symbol, if defined, indicates that the getnameinfo() function ?C: is available for use. ?C:. ?H:#$d_getnameinfo HAS_GETNAMEINFO /**/ ?H:. ?LINT:set d_getnameinfo : see if getnameinfo exists set getnameinfo d_getnameinfo eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getprpwnam.U000066400000000000000000000016351316016665300221000ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getprpwnam: Inlibc ?MAKE: -pick add $@ %< ?S:d_getprpwnam: ?S: This variable conditionally defines HAS_GETPRPWNAM if getprpwnam() is ?S: available to retrieve protected (shadow) password entries by name. ?S:. ?C:HAS_GETPRPWNAM: ?C: This symbol, if defined, indicates that the getprpwnam system call is ?C: available to retrieve protected (shadow) password entries by name. ?C:. ?H:#$d_getprpwnam HAS_GETPRPWNAM /**/ ?H:. ?LINT:set d_getprpwnam : see if getprpwnam exists set getprpwnam d_getprpwnam eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getrlimit.U000066400000000000000000000012761316016665300217150ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getrlimit: Inlibc ?MAKE: -pick add $@ %< ?S:d_getrlimit: ?S: This variable conditionally defines the HAS_GETRLIMIT symbol, which ?S: indicates to the C program that the getrlimit() routine is available. ?S:. ?C:HAS_GETRLIMIT: ?C: This symbol, if defined, indicates that the getrlimit routine is ?C: available to get process resource limits. ?C:. ?H:#$d_getrlimit HAS_GETRLIMIT /**/ ?H:. ?LINT:set d_getrlimit : see if getrlimit exists set getrlimit d_getrlimit eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getspent.U000066400000000000000000000016011316016665300215360ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getspent: Inlibc ?MAKE: -pick add $@ %< ?S:d_getspent: ?S: This variable conditionally defines HAS_GETSPENT if getspent() is ?S: available to retrieve SysV shadow password entries sequentially. ?S:. ?C:HAS_GETSPENT: ?C: This symbol, if defined, indicates that the getspent system call is ?C: available to retrieve SysV shadow password entries sequentially. ?C:. ?H:#$d_getspent HAS_GETSPENT /**/ ?H:. ?LINT:set d_getspent : see if getspent exists set getspent d_getspent eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_getspnam.U000066400000000000000000000015671316016665300215360ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getspnam: Inlibc ?MAKE: -pick add $@ %< ?S:d_getspnam: ?S: This variable conditionally defines HAS_GETSPNAM if getspnam() is ?S: available to retrieve SysV shadow password entries by name. ?S:. ?C:HAS_GETSPNAM: ?C: This symbol, if defined, indicates that the getspnam system call is ?C: available to retrieve SysV shadow password entries by name. ?C:. ?H:#$d_getspnam HAS_GETSPNAM /**/ ?H:. ?LINT:set d_getspnam : see if getspnam exists set getspnam d_getspnam eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_hasmntopt.U000066400000000000000000000013711316016665300217260ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_hasmntopt: Inlibc ?MAKE: -pick add $@ %< ?S:d_hasmntopt: ?S: This variable conditionally defines the HAS_HASMNTOPT symbol, which ?S: indicates to the C program that the hasmntopt() routine is available ?S: to query the mount options of file systems. ?S:. ?C:HAS_HASMNTOPT: ?C: This symbol, if defined, indicates that the hasmntopt routine is ?C: available to query the mount options of file systems. ?C:. ?H:#$d_hasmntopt HAS_HASMNTOPT /**/ ?H:. ?LINT:set d_hasmntopt : see if hasmntopt exists set hasmntopt d_hasmntopt eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_hypot.U000066400000000000000000000010711316016665300210510ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_hypot: Inlibc ?MAKE: -pick add $@ %< ?S:d_hypot: ?S: This variable conditionally defines HAS_HYPOT if hypot is available ?S: for numerically stable hypotenuse function. ?S:. ?C:HAS_HYPOT: ?C: This symbol, if defined, indicates that the hypot routine is ?C: available to do the hypotenuse function. ?C:. ?H:#$d_hypot HAS_HYPOT /**/ ?H:. ?LINT:set d_hypot : see if hypot exists set hypot d_hypot eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_iconv.U000066400000000000000000000012171316016665300210260ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_iconv: Inlibc ?MAKE: -pick add $@ %< ?S:d_iconv: ?S: This variable conditionally defines the HAS_ICONV symbol, which ?S: indicates to the C program that the iconv() routine is available. ?S:. ?C:HAS_ICONV: ?C: This symbol, if defined, indicates that the iconv routine is ?C: available to do character set conversions. ?C:. ?H:#$d_iconv HAS_ICONV /**/ ?H:. ?LINT:set d_iconv : see if iconv exists set iconv d_iconv eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_ilogb.U000066400000000000000000000012371316016665300210060ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_ilogb: Inlibc ?MAKE: -pick add $@ %< ?S:d_ilogb: ?S: This variable conditionally defines the HAS_ILOGB symbol, which ?S: indicates to the C program that the ilogb() routine is available ?S: for extracting the exponent of double x as a signed integer. ?S:. ?C:HAS_ILOGB: ?C: This symbol, if defined, indicates that the ilogb routine is ?C: available to get integer exponent of a floating-point value. ?C:. ?H:#$d_ilogb HAS_ILOGB /**/ ?H:. ?LINT:set d_ilogb : see if ilogb exists set ilogb d_ilogb eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_ilogbl.U000066400000000000000000000014511316016665300211600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_ilogbl: Inlibc ?MAKE: -pick add $@ %< ?S:d_ilogbl: ?S: This variable conditionally defines the HAS_ILOGBL symbol, which ?S: indicates to the C program that the ilogbl() routine is available ?S: for extracting the exponent of long double x as a signed integer. ?S: If scalbnl is also present we can emulate frexpl. ?S:. ?C:HAS_ILOGBL: ?C: This symbol, if defined, indicates that the ilogbl routine is ?C: available. If scalbnl is also present we can emulate frexpl. ?C:. ?H:#$d_ilogbl HAS_ILOGBL /**/ ?H:. ?LINT:set d_ilogbl : see if ilogbl exists set ilogbl d_ilogbl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_inetntop.U000066400000000000000000000012731316016665300215520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2009 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_inetntop: Inlibc ?MAKE: -pick add $@ %< ?S:d_inetntop: ?S: This variable conditionally defines the HAS_INETNTOP symbol, ?S: which indicates to the C program that the inet_ntop() function ?S: is available. ?S:. ?C:HAS_INETNTOP: ?C: This symbol, if defined, indicates that the inet_ntop() function ?C: is available to parse IPv4 and IPv6 strings. ?C:. ?H:#$d_inetntop HAS_INETNTOP /**/ ?H:. ?LINT:set d_inetntop : see if inet_ntop exists set inet_ntop d_inetntop eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_inetpton.U000066400000000000000000000012731316016665300215520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2009 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_inetpton: Inlibc ?MAKE: -pick add $@ %< ?S:d_inetpton: ?S: This variable conditionally defines the HAS_INETPTON symbol, ?S: which indicates to the C program that the inet_pton() function ?S: is available. ?S:. ?C:HAS_INETPTON: ?C: This symbol, if defined, indicates that the inet_pton() function ?C: is available to parse IPv4 and IPv6 strings. ?C:. ?H:#$d_inetpton HAS_INETPTON /**/ ?H:. ?LINT:set d_inetpton : see if inet_pton exists set inet_pton d_inetpton eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_int64_t.U000066400000000000000000000023171316016665300212010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_int64_t: Inhdr cat rm_try Setvar Compile i_inttypes ?MAKE: -pick add $@ %< ?S:d_int64_t: ?S: This symbol will be defined if the C compiler supports int64_t. ?S:. ?C:HAS_INT64_T: ?C: This symbol will defined if the C compiler supports int64_t. ?C: Usually the needs to be included, but sometimes ?C: is enough. ?C:. ?H:#$d_int64_t HAS_INT64_T /**/ ?H:. ?LINT:set d_int64_t : check for int64_t echo " " echo "Checking to see if you have int64_t..." >&4 $cat >try.c < #$i_inttypes I_INTTYPES #ifdef I_INTTYPES #include #endif int main() { int64_t x = 7; } EOCP set try if eval $compile; then val="$define" echo "You have int64_t." else val="$undef" echo "You do not have int64_t." fi $rm_try set d_int64_t eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_iovec_s.U000066400000000000000000000015701316016665300213410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_iovec_s: i_sysuio Hasfield ?MAKE: -pick add $@ %< ?S:d_iovec_s: ?S: This variable conditionally defines the HAS_STRUCT_IOVEC symbol, ?S: which indicates that the struct iovec is supported. ?S:. ?C:HAS_STRUCT_IOVEC: ?C: This symbol, if defined, indicates that the struct iovec ?C: to do scatter writes/gather reads is supported. ?C:. ?H:#$d_iovec_s HAS_STRUCT_IOVEC /**/ ?H:. ?LINT:set d_iovec_s : Check for iovec_s echo "Checking to see if your system supports struct iovec..." >&4 set d_iovec_s iovec iov_base $i_sysuio sys/uio.h eval $hasfield case "$d_iovec_s" in "$define") echo "Yup, it does." ;; *) echo "Nope, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_isblank.U000066400000000000000000000023701316016665300213340ustar00rootroot00000000000000?RCS: Copyright (c) 2012-2012, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: H.Merijn Brand ?RCS: ?MAKE:d_isblank: cc cat ccflags ldflags rm libs Setvar ?MAKE: -pick add $@ %< ?S:d_isblank: ?S: This variable conditionally defines the HAS_ISBLANK constant, ?S: which indicates to the C program that isblank() is available. ?S:. ?C:HAS_ISBLANK: ?C: This manifest constant lets the C program know that isblank ?C: is available. ?C:. ?H:#$d_isblank HAS_ISBLANK /**/ ?H:. ?LINT:set d_isblank ?X: Can't use Inlibc because isblank() might be a macro. : Look for isblank echo " " $cat >isblank.c <<'EOCP' #include #include int main() { int c = ' '; if (isblank(c)) return 0 ; else return 1 ; } EOCP if $cc $ccflags $ldflags -o isblank isblank.c $libs >/dev/null 2>&1 ; then echo "isblank() found." >&4 val="$define" else echo "isblank() NOT found." >&4 val="$undef" fi set d_isblank eval $setvar $rm -f isblank* metaconfig-debian-perl-5.26.1/U/perl/d_isfinite.U000066400000000000000000000020221316016665300215150ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isfinite: Inlibc cat i_math Compile rm_try Setvar ?MAKE: -pick add $@ %< ?S:d_isfinite: ?S: This variable conditionally defines the HAS_ISFINITE symbol, which ?S: indicates to the C program that the isfinite() routine is available. ?S:. ?C:HAS_ISFINITE: ?C: This symbol, if defined, indicates that the isfinite routine is ?C: available to check whether a double is finite (non-infinity non-NaN). ?C:. ?LINT:set d_isfinite ?H:#$d_isfinite HAS_ISFINITE /**/ ?H:. : check for isfinite echo "Checking to see if you have isfinite..." >&4 $cat >try.c < #endif int main() { return isfinite(0.0); } EOCP set try if eval $compile; then val="$define" echo "You have isfinite." else val="$undef" echo "You do not have isfinite." fi $rm_try set d_isfinite eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_isfinitel.U000066400000000000000000000013441316016665300216770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isfinitel: Inlibc ?MAKE: -pick add $@ %< ?S:d_isfinitel: ?S: This variable conditionally defines the HAS_ISFINITEL symbol, which ?S: indicates to the C program that the isfinitel() routine is available. ?S:. ?C:HAS_ISFINITEL: ?C: This symbol, if defined, indicates that the isfinitel routine is ?C: available to check whether a long double is finite. ?C: (non-infinity non-NaN). ?C:. ?H:#$d_isfinitel HAS_ISFINITEL /**/ ?H:. ?LINT:set d_isfinitel : see if isfinitel exists set isfinitel d_isfinitel eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_isinf.U000066400000000000000000000017231316016665300210220ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isinf: Inlibc cat i_math Compile rm_try Setvar ?MAKE: -pick add $@ %< ?S:d_isinf: ?S: This variable conditionally defines the HAS_ISINF symbol, which ?S: indicates to the C program that the isinf() routine is available. ?S:. ?C:HAS_ISINF: ?C: This symbol, if defined, indicates that the isinf routine is ?C: available to check whether a double is an infinity. ?C:. ?H:#$d_isinf HAS_ISINF /**/ ?H:. ?LINT:set d_isinf : check for isinf echo "Checking to see if you have isinf..." >&4 $cat >try.c < #endif int main() { return isinf(0.0); } EOCP set try if eval $compile; then val="$define" echo "You have isinf." else val="$undef" echo "You do not have isinf." fi $rm_try set d_isinf eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_isinfl.U000066400000000000000000000012511316016665300211720ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isinfl: Inlibc ?MAKE: -pick add $@ %< ?S:d_isinfl: ?S: This variable conditionally defines the HAS_ISINFL symbol, which ?S: indicates to the C program that the isinfl() routine is available. ?S:. ?C:HAS_ISINFL: ?C: This symbol, if defined, indicates that the isinfl routine is ?C: available to check whether a long double is an infinity. ?C:. ?H:#$d_isinfl HAS_ISINFL /**/ ?H:. ?LINT:set d_isinfl : see if isinfl exists set isinfl d_isinfl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_isless.U000066400000000000000000000016121316016665300212110ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isless: cat i_math Compile rm_try Setvar ?MAKE: -pick add $@ %< ?S:d_isless: ?S: This variable conditionally defines the HAS_ISLESS symbol, which ?S: indicates to the C program that the isless() routine is available. ?S:. ?C:HAS_ISLESS: ?C: This symbol, if defined, indicates that the isless routine is ?C: available to do the isless function. ?C:. ?H:#$d_isless HAS_ISLESS /**/ ?H:. ?LINT:set d_isless : check for isless echo "Checking to see if you have isless..." >&4 $cat >try.c < #endif int main() { return isless(0.0); } EOCP set try if eval $compile; then val="$define" echo "You have isless." else val="$undef" echo "You do not have isless." fi $rm_try set d_isless eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_isnan.U000066400000000000000000000017151316016665300210230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isnan: Inlibc cat i_math Compile rm_try Setvar ?MAKE: -pick add $@ %< ?S:d_isnan: ?S: This variable conditionally defines the HAS_ISNAN symbol, which ?S: indicates to the C program that the isnan() routine is available. ?S:. ?C:HAS_ISNAN: ?C: This symbol, if defined, indicates that the isnan routine is ?C: available to check whether a double is a NaN. ?C:. ?H:#$d_isnan HAS_ISNAN /**/ ?H:. ?LINT:set d_isnan : check for isnan echo "Checking to see if you have isnan..." >&4 $cat >try.c < #endif int main() { return isnan(0.0); } EOCP set try if eval $compile; then val="$define" echo "You have isnan." else val="$undef" echo "You do not have isnan." fi $rm_try set d_isnan eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_isnanl.U000066400000000000000000000012431316016665300211730ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isnanl: Inlibc ?MAKE: -pick add $@ %< ?S:d_isnanl: ?S: This variable conditionally defines the HAS_ISNANL symbol, which ?S: indicates to the C program that the isnanl() routine is available. ?S:. ?C:HAS_ISNANL: ?C: This symbol, if defined, indicates that the isnanl routine is ?C: available to check whether a long double is a NaN. ?C:. ?H:#$d_isnanl HAS_ISNANL /**/ ?H:. ?LINT:set d_isnanl : see if isnanl exists set isnanl d_isnanl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_isnormal.U000066400000000000000000000017101316016665300215320ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_isnormal: cat i_math Compile Setvar rm_try ?MAKE: -pick add $@ %< ?S:d_isnormal: ?S: This variable conditionally defines the HAS_ISNORMAL symbol, which ?S: indicates to the C program that the isnormal() routine is available. ?S:. ?C:HAS_ISNORMAL: ?C: This symbol, if defined, indicates that the isnormal routine is ?C: available to check whether a double is normal (non-zero normalized). ?C:. ?H:#$d_isnormal HAS_ISNORMAL /**/ ?H:. ?LINT:set d_isnormal : check for isnormal echo "Checking to see if you have isnormal..." >&4 $cat >try.c < #endif int main() { return isnormal(0.0); } EOCP set try if eval $compile; then val="$define" echo "You have isnormal." else val="$undef" echo "You do not have isnormal." fi $rm_try set d_isnormal eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_j0.U000066400000000000000000000020351316016665300202200ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_j0 d_j0l: Inlibc ?MAKE: -pick add $@ %< ?S:d_j0: ?S: This variable conditionally defines the HAS_J0 symbol, which ?S: indicates to the C program that the j0() routine is available. ?S:. ?S:d_j0l: ?S: This variable conditionally defines the HAS_J0L symbol, which ?S: indicates to the C program that the j0l() routine is available. ?S:. ?C:HAS_J0: ?C: This symbol, if defined, indicates to the C program that the ?C: j0() function is available for Bessel functions of the first ?C: kind of the order zero, for doubles. ?C:. ?C:HAS_J0L: ?C: This symbol, if defined, indicates to the C program that the ?C: j0l() function is available for Bessel functions of the first ?C: kind of the order zero, for long doubles. ?C:. ?H:#$d_j0 HAS_J0 /**/ ?H:#$d_j0l HAS_J0L /**/ ?H:. ?LINT:set d_j0 ?LINT:set d_j0l : see if j0 exists set j0 d_j0 eval $inlibc : see if j0l exists set j0l d_j0l eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lc_monetary_2008.U000066400000000000000000000022631316016665300226770ustar00rootroot00000000000000?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_lc_monetary_2008: cat Compile rm_try d_locconv ?MAKE: -pick add $@ %< ?S:d_lc_monetary_2008: ?S: This variable conditionally defines HAS_LC_MONETARY_2008 if libc ?S: has the international currency locale rules from POSIX ?S: 1003.1-2008. ?S:. ?C:HAS_LC_MONETARY_2008: ?C: This symbol, if defined, indicates that the localeconv routine is ?C: available and has the additional members added in POSIX 1003.1-2008. ?C:. ?H:#$d_lc_monetary_2008 HAS_LC_MONETARY_2008 /**/ ?H:. : see if libc has the POSIX.1-2008 currency locale rules case "$d_locconv:$d_lc_monetary_2008" in $define:) $cat >try.c < int main() { struct lconv *lc = localeconv(); char int_p_cs_precedes = lc->int_p_cs_precedes; return 0; } EOCP set try if eval $compile; then d_lc_monetary_2008="$define" else d_lc_monetary_2008="$undef" fi; $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_lchmod.U000066400000000000000000000012311316016665300211520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lchmod: Inlibc ?MAKE: -pick add $@ %< ?S:d_lchmod: ?S: This variable conditionally defines the HAS_LCHMOD symbol, which ?S: indicates to the C program that the lchmod() routine is available. ?S:. ?C:HAS_LCHMOD: ?C: This symbol, if defined, indicates that the lchmod routine is ?C: available to change symbolic link modes. ?C:. ?H:#$d_lchmod HAS_LCHMOD /**/ ?H:. ?LINT:set d_lchmod : see if lchmod exists set lchmod d_lchmod eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_ldbl_dig.U000066400000000000000000000031661316016665300214550ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_ldbl_dig: Myread contains cat rm Setvar i_limits i_float \ cppstdin cppflags cppminus ?MAKE: -pick add $@ %< ?S:d_ldbl_dig: ?S: This variable conditionally defines d_ldbl_dig if this system's ?S: header files provide LDBL_DIG, which is the number of significant ?S: digits in a long double precision number. ?S:. ?C:HAS_LDBL_DIG: ?C: This symbol, if defined, indicates that this system's ?C: or defines the symbol LDBL_DIG, which is the number ?C: of significant digits in a long double precision number. Unlike ?C: for DBL_DIG, there's no good guess for LDBL_DIG if it is undefined. ?C:. ?H:#$d_ldbl_dig HAS_LDBL_DIG /* */ ?H:. ?F:!ldbl_dig.c ?LINT:set d_ldbl_dig : See if number of significant digits in a double precision number is known echo " " $cat >ldbl_dig.c < #endif #ifdef I_FLOAT #include #endif #ifdef LDBL_DIG printf("Contains LDBL_DIG"); #endif EOM $cppstdin $cppflags $cppminus < ldbl_dig.c >ldbl_dig.E 2>/dev/null if $contains 'LDBL_DIG' ldbl_dig.E >/dev/null 2>&1; then echo "LDBL_DIG found." >&4 val="$define" else echo "LDBL_DIG NOT found." >&4 val="$undef" fi $rm -f ldbl_dig.? set d_ldbl_dig eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_lgamma.U000066400000000000000000000013031316016665300211420ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lgamma: Inlibc ?MAKE: -pick add $@ %< ?S:d_lgamma: ?S: This variable conditionally defines the HAS_LGAMMA symbol, which ?S: indicates to the C program that the lgamma() routine is available ?S: for the log gamma function. See also d_tgamma and d_lgamma_r. ?S:. ?C:HAS_LGAMMA: ?C: This symbol, if defined, indicates that the lgamma routine is ?C: available to do the log gamma function. See also HAS_TGAMMA and ?C: HAS_LGAMMA_R. ?C:. ?H:#$d_lgamma HAS_LGAMMA /**/ ?H:. ?LINT:set d_lgamma : see if lgamma exists set lgamma d_lgamma eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lgamma_r.U000066400000000000000000000013461316016665300214720ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lgamma_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_lgamma_r: ?S: This variable conditionally defines the HAS_LGAMMA_R symbol, which ?S: indicates to the C program that the lgamma_r() routine is available ?S: for the log gamma function, without using the global signgam variable. ?S:. ?C:HAS_LGAMMA_R: ?C: This symbol, if defined, indicates that the lgamma_r routine is ?C: available to do the log gamma function without using the global ?C: signgam variable. ?C:. ?H:#$d_lgamma_r HAS_LGAMMA_R /**/ ?H:. ?LINT:set d_lgamma_r : see if lgamma_r exists set lgamma_r d_lgamma_r eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_libm_lib_version.U000066400000000000000000000023501316016665300232250ustar00rootroot00000000000000?RCS: Copyright (c) 2005-2007 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_libm_lib_version: Compile cat run rm_try i_math ?MAKE: -pick add $@ %< ?S:d_libm_lib_version: ?S: This variable conditionally defines the LIBM_LIB_VERSION symbol, ?S: which indicates to the C program that math.h defines _LIB_VERSION ?S: being available in libm ?S:. ?C:LIBM_LIB_VERSION: ?C: This symbol, if defined, indicates that libm exports _LIB_VERSION ?C: and that math.h defines the enum to manipulate it. ?C:. ?H:#$d_libm_lib_version LIBM_LIB_VERSION /**/ ?H:. ?T:foo ?F:!try : check to see if math.h defines _LIB_VERSION d_libm_lib_version="$undef" case $i_math in $define) echo " " echo "Checking to see if your libm supports _LIB_VERSION..." >&4 $cat >try.c < #include int main (int argc, char *argv[]) { printf ("%d\n", _LIB_VERSION); return (0); } /* main */ EOCP set try if eval $compile; then foo=`$run ./try` echo "Yes, it does ($foo)" >&4 d_libm_lib_version="$define" else echo "No, it does not (probably harmless)" >&4 fi $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_llrint.U000066400000000000000000000013731316016665300212170ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_llrint: Inlibc ?MAKE: -pick add $@ %< ?S:d_llrint: ?S: This variable conditionally defines the HAS_LLRINT symbol, which ?S: indicates to the C program that the llrint() routine is available ?S: to return the long long value closest to a double (according ?S: to the current rounding mode). ?S:. ?C:HAS_LLRINT: ?C: This symbol, if defined, indicates that the llrint routine is ?C: available to return the long long value closest to a double ?C: (according to the current rounding mode). ?C:. ?H:#$d_llrint HAS_LLRINT /**/ ?H:. ?LINT:set d_llrint : see if llrint exists set llrint d_llrint eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_llrintl.U000066400000000000000000000014211316016665300213650ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_llrintl: Inlibc ?MAKE: -pick add $@ %< ?S:d_llrintl: ?S: This variable conditionally defines the HAS_LLRINTL symbol, which ?S: indicates to the C program that the llrintl() routine is available ?S: to return the long long value closest to a long double (according ?S: to the current rounding mode). ?S:. ?C:HAS_LLRINTL: ?C: This symbol, if defined, indicates that the llrintl routine is ?C: available to return the long long value closest to a long double ?C: (according to the current rounding mode). ?C:. ?H:#$d_llrintl HAS_LLRINTL /**/ ?H:. ?LINT:set d_llrintl : see if llrintl exists set llrintl d_llrintl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_llround.U000066400000000000000000000012321316016665300213640ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_llround: Inlibc ?MAKE: -pick add $@ %< ?S:d_llround: ?S: This variable conditionally defines the HAS_LLROUND symbol, which ?S: indicates to the C program that the llround() routine is available ?S: to return the long long value nearest to x. ?S:. ?C:HAS_LLROUND: ?C: This symbol, if defined, indicates that the llround routine is ?C: available to return the nearest long long value. ?C:. ?H:#$d_llround HAS_LLROUND /**/ ?H:. ?LINT:set d_llround : see if llround exists set llround d_llround eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_llroundl.U000066400000000000000000000013521316016665300215430ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_llroundl: Inlibc ?MAKE: -pick add $@ %< ?S:d_llroundl: ?S: This variable conditionally defines the HAS_LLROUNDL symbol, which ?S: indicates to the C program that the llroundl() routine is available ?S: to return the long long value nearest to x away from zero. ?S:. ?C:HAS_LLROUNDL: ?C: This symbol, if defined, indicates that the llroundl routine is ?C: available to return the nearest long long value away from zero of ?C: the long double argument value. ?C:. ?H:#$d_llroundl HAS_LLROUNDL /**/ ?H:. ?LINT:set d_llroundl : see if llroundl exists set llroundl d_llroundl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_llseek.U000066400000000000000000000012411316016665300211640ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_llseek: Inlibc ?MAKE: -pick add $@ %< ?S:d_llseek: ?S: This variable conditionally defines the HAS_LLSEEK symbol, which ?S: indicates to the C program that the llseek() routine is available. ?S:. ?C:HAS_LLSEEK: ?C: This symbol, if defined, indicates that the llseek routine is ?C: available to seek files larger than 2 gigabytes. ?C:. ?H:#$d_llseek HAS_LLSEEK /**/ ?H:. ?LINT:set d_llseek : see if llseek exists set llseek d_llseek eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_log1p.U000066400000000000000000000012251316016665300207310ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_log1p: Inlibc ?MAKE: -pick add $@ %< ?S:d_log1p: ?S: This variable conditionally defines the HAS_LOG1P symbol, which ?S: indicates to the C program that the logp1() routine is available ?S: to compute log(1 + x) for values of x close to zero. ?S:. ?C:HAS_LOG1P: ?C: This symbol, if defined, indicates that the log1p routine is ?C: available to do the logarithm of 1 plus argument function. ?C:. ?H:#$d_log1p HAS_LOG1P /**/ ?H:. ?LINT:set d_log1p : see if log1p exists set log1p d_log1p eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_log2.U000066400000000000000000000011251316016665300205510ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_log2: Inlibc ?MAKE: -pick add $@ %< ?S:d_log2: ?S: This variable conditionally defines the HAS_LOG2 symbol, which ?S: indicates to the C program that the log2() routine is available ?S: to compute log base two. ?S:. ?C:HAS_LOG2: ?C: This symbol, if defined, indicates that the log2 routine is ?C: available to do the log2 function. ?C:. ?H:#$d_log2 HAS_LOG2 /**/ ?H:. ?LINT:set d_log2 : see if log2 exists set log2 d_log2 eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_logb.U000066400000000000000000000011321316016665300206270ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_logb: Inlibc ?MAKE: -pick add $@ %< ?S:d_logb: ?S: This variable conditionally defines the HAS_LOGB symbol, which ?S: indicates to the C program that the logb() routine is available ?S: to extract the exponent of x. ?S:. ?C:HAS_LOGB: ?C: This symbol, if defined, indicates that the logb routine is ?C: available to do the logb function. ?C:. ?H:#$d_logb HAS_LOGB /**/ ?H:. ?LINT:set d_logb : see if logb exists set logb d_logb eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lrint.U000066400000000000000000000013551316016665300210430ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lrint: Inlibc ?MAKE: -pick add $@ %< ?S:d_lrint: ?S: This variable conditionally defines the HAS_LRINT symbol, which ?S: indicates to the C program that the lrint() routine is available ?S: to return the integral value closest to a double (according ?S: to the current rounding mode). ?S:. ?C:HAS_LRINT: ?C: This symbol, if defined, indicates that the lrint routine is ?C: available to return the integral value closest to a double ?C: (according to the current rounding mode). ?C:. ?H:#$d_lrint HAS_LRINT /**/ ?H:. ?LINT:set d_lrint : see if lrint exists set lrint d_lrint eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lrintl.U000066400000000000000000000014031316016665300212110ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lrintl: Inlibc ?MAKE: -pick add $@ %< ?S:d_lrintl: ?S: This variable conditionally defines the HAS_LRINTL symbol, which ?S: indicates to the C program that the lrintl() routine is available ?S: to return the integral value closest to a long double (according ?S: to the current rounding mode). ?S:. ?C:HAS_LRINTL: ?C: This symbol, if defined, indicates that the lrintl routine is ?C: available to return the integral value closest to a long double ?C: (according to the current rounding mode). ?C:. ?H:#$d_lrintl HAS_LRINTL /**/ ?H:. ?LINT:set d_lrintl : see if lrintl exists set lrintl d_lrintl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lround.U000066400000000000000000000012141316016665300212100ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lround: Inlibc ?MAKE: -pick add $@ %< ?S:d_lround: ?S: This variable conditionally defines the HAS_LROUND symbol, which ?S: indicates to the C program that the lround() routine is available ?S: to return the integral value nearest to x. ?S:. ?C:HAS_LROUND: ?C: This symbol, if defined, indicates that the lround routine is ?C: available to return the nearest integral value. ?C:. ?H:#$d_lround HAS_LROUND /**/ ?H:. ?LINT:set d_lround : see if lround exists set lround d_lround eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lroundl.U000066400000000000000000000013341316016665300213670ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lroundl: Inlibc ?MAKE: -pick add $@ %< ?S:d_lroundl: ?S: This variable conditionally defines the HAS_LROUNDL symbol, which ?S: indicates to the C program that the lroundl() routine is available ?S: to return the integral value nearest to x away from zero. ?S:. ?C:HAS_LROUNDL: ?C: This symbol, if defined, indicates that the lroundl routine is ?C: available to return the nearest integral value away from zero of ?C: the long double argument value. ?C:. ?H:#$d_lroundl HAS_LROUNDL /**/ ?H:. ?LINT:set d_lroundl : see if lroundl exists set lroundl d_lroundl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_lutimes.U000066400000000000000000000012771316016665300214000ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_lutimes: Inlibc ?MAKE: -pick add $@ %< ?S:d_lutimes: ?S: This variable conditionally defines the HAS_LUTIMES symbol, which ?S: indicates to the C program that the lutimes() routine is available. ?S:. ?C:HAS_LUTIMES: ?C: This symbol, if defined, indicates that the lutimes routine is ?C: available to change symbolic link timestamps with struct timevals. ?C:. ?H:#$d_lutimes HAS_LUTIMES /**/ ?H:. ?LINT:set d_lutimes : see if lutimes exists set lutimes d_lutimes eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_madvise.U000066400000000000000000000014761316016665300213470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_madvise: Inlibc ?MAKE: -pick add $@ %< ?S:d_madvise: ?S: This variable conditionally defines HAS_MADVISE if madvise() is ?S: available to map a file into memory. ?S:. ?C:HAS_MADVISE: ?C: This symbol, if defined, indicates that the madvise system call is ?C: available to map a file into memory. ?C:. ?H:#$d_madvise HAS_MADVISE /**/ ?H:. ?LINT:set d_madvise : see if madvise exists set madvise d_madvise eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_malloc_size.U000066400000000000000000000023741316016665300222160ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2005, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_malloc_size d_malloc_good_size: Inlibc ?MAKE: -pick add $@ %< ?S:d_malloc_size: ?S: This symbol, if defined, indicates that the malloc_size ?S: routine is available for use. ?S:. ?S:d_malloc_good_size: ?S: This symbol, if defined, indicates that the malloc_good_size ?S: routine is available for use. ?S:. ?C:HAS_MALLOC_SIZE: ?C: This symbol, if defined, indicates that the malloc_size ?C: routine is available for use. ?C:. ?H:#$d_malloc_size HAS_MALLOC_SIZE /**/ ?H:. ?C:HAS_MALLOC_GOOD_SIZE: ?C: This symbol, if defined, indicates that the malloc_good_size ?C: routine is available for use. ?C:. ?H:#$d_malloc_good_size HAS_MALLOC_GOOD_SIZE /**/ ?H:. ?LINT:set d_malloc_size ?LINT:set d_malloc_good_size : see if malloc_size exists set malloc_size d_malloc_size eval $inlibc : see if malloc_size_good exists set malloc_good_size d_malloc_good_size eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_memmem.U000066400000000000000000000014431316016665300211660ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_memmem: Inlibc ?MAKE: -pick add $@ %< ?S:d_memmem: ?S: This variable conditionally defines the HAS_MEMMEM symbol, which ?S: indicates to the C program that the memmem() routine is available ?S: to return a pointer to the start of the first occurance of a ?S: substring in a memory area (or NULL if not found). ?S:. ?C:HAS_MEMMEM: ?C: This symbol, if defined, indicates that the memmem routine is ?C: available to return a pointer to the start of the first occurance ?C: of a substring in a memory area (or NULL if not found). ?C:. ?H:#$d_memmem HAS_MEMMEM /**/ ?H:. ?LINT:set d_memmem : see if memmem exists set memmem d_memmem eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mkdtemp.U000066400000000000000000000014021316016665300213450ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_mkdtemp: Inlibc ?MAKE: -pick add $@ %< ?S:d_mkdtemp: ?S: This variable conditionally defines the HAS_MKDTEMP symbol, which ?S: indicates to the C program that the mkdtemp() routine is available ?S: to exclusively create a uniquely named temporary directory. ?S:. ?C:HAS_MKDTEMP : ?C: This symbol, if defined, indicates that the mkdtemp routine is ?C: available to exclusively create a uniquely named temporary directory. ?C:. ?H:#$d_mkdtemp HAS_MKDTEMP /**/ ?H:. ?LINT:set d_mkdtemp : see if mkdtemp exists set mkdtemp d_mkdtemp eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mkstemps.U000066400000000000000000000014761316016665300215620ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_mkstemps: Inlibc ?MAKE: -pick add $@ %< ?S:d_mkstemps: ?S: This variable conditionally defines the HAS_MKSTEMPS symbol, which ?S: indicates to the C program that the mkstemps() routine is available ?S: to exclusively create and open a uniquely named (with a suffix) ?S: temporary file. ?S:. ?C:HAS_MKSTEMPS : ?C: This symbol, if defined, indicates that the mkstemps routine is ?C: available to exclusively create and open a uniquely named ?C: (with a suffix) temporary file. ?C:. ?H:#$d_mkstemps HAS_MKSTEMPS /**/ ?H:. ?LINT:set d_mkstemps : see if mkstemps exists set mkstemps d_mkstemps eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_modfl.U000066400000000000000000000051651316016665300210170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_modfl d_modflproto: Inlibc Compile Hasproto cat \ test ccflags uselongdouble i_math \ d_sqrtl d_aintl d_copysignl d_ilogbl d_scalbnl d_frexpl d_ldexpl \ d_truncl ?MAKE: -pick add $@ %< ?S:d_modfl: ?S: This variable conditionally defines the HAS_MODFL symbol, which ?S: indicates to the C program that the modfl() routine is available. ?S:. ?S:d_modflproto: ?S: This symbol, if defined, indicates that the system provides ?S: a prototype for the modfl() function. Otherwise, it is up ?S: to the program to supply one. C99 says it should be ?S: long double modfl(long double, long double *); ?S:. ?C:HAS_MODFL: ?C: This symbol, if defined, indicates that the modfl routine is ?C: available to split a long double x into a fractional part f and ?C: an integer part i such that |f| < 1.0 and (f + i) = x. ?C:. ?C:HAS_MODFL_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the modfl() function. Otherwise, it is up ?C: to the program to supply one. ?C:. ?H:#$d_modfl HAS_MODFL /**/ ?H:#$d_modflproto HAS_MODFL_PROTO /**/ ?H:. ?T:message ?LINT:set d_modfl ?LINT:set d_modflproto ?LINT:change ccflags : see if modfl exists set modfl d_modfl eval $inlibc : see if prototype for modfl is available echo " " set d_modflproto modfl $i_math math.h eval $hasproto if $test "$uselongdouble" = "$define"; then message="" if $test "$d_sqrtl" != "$define"; then message="$message sqrtl" fi if $test "$d_modfl" != "$define"; then if $test "$d_truncl:$d_copysignl" = "$define:$define"; then echo "You have both truncl and copysignl, so I can emulate modfl." else if $test "$d_aintl:$d_copysignl" = "$define:$define"; then echo "You have both aintl and copysignl, so I can emulate modfl." else message="$message modfl" fi fi fi if $test "$d_frexpl" != "$define"; then if $test "$d_ilogbl:$d_scalbnl" = "$define:$define"; then echo "You have both ilogbl and scalbnl, so I can emulate frexpl." else message="$message frexpl" fi fi if $test "$d_ldexpl" != "$define"; then message="$message ldexpl" fi if $test "$message" != ""; then $cat <&4 *** You requested the use of long doubles but you do not seem to have *** the following mathematical functions needed for long double support: *** $message *** Please rerun Configure without -Duselongdouble and/or -Dusemorebits. *** Cannot continue, aborting. EOM exit 1 fi fi metaconfig-debian-perl-5.26.1/U/perl/d_mprotect.U000066400000000000000000000016051316016665300215460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mprotect: Inlibc ?MAKE: -pick add $@ %< ?S:d_mprotect: ?S: This variable conditionally defines HAS_MPROTECT if mprotect() is ?S: available to modify the access protection of a memory mapped file. ?S:. ?C:HAS_MPROTECT: ?C: This symbol, if defined, indicates that the mprotect system call is ?C: available to modify the access protection of a memory mapped file. ?C:. ?H:#$d_mprotect HAS_MPROTECT /**/ ?H:. ?LINT:set d_mprotect : see if mprotect exists set mprotect d_mprotect eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_close.U000066400000000000000000000015241316016665300215130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_close: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_close: ?S: This variable conditionally defines HAS_MQ_CLOSE if mq_close() is ?S: available to close a POSIX message queue. ?S:. ?C:HAS_MQ_CLOSE: ?C: This symbol, if defined, indicates that the mq_close system call is ?C: available to close a POSIX message queue. ?C:. ?H:#$d_mq_close HAS_MQ_CLOSE /**/ ?H:. ?LINT:set d_mq_close : see if mq_close exists set mq_close d_mq_close eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_getattr.U000066400000000000000000000016421316016665300220610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_getattr: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_getattr: ?S: This variable conditionally defines HAS_MQ_GETATTR if mq_getattr() is ?S: available to get the attributes and status of a POSIX message queue. ?S:. ?C:HAS_MQ_GETATTR: ?C: This symbol, if defined, indicates that the mq_getattr system call is ?C: available to get the attributes and status of a POSIX message queue. ?C:. ?H:#$d_mq_getattr HAS_MQ_GETATTR /**/ ?H:. ?LINT:set d_mq_getattr : see if mq_getattr exists set mq_getattr d_mq_getattr eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_notify.U000066400000000000000000000016141316016665300217160ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_notify: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_notify: ?S: This variable conditionally defines HAS_MQ_NOTIFY if mq_notify() is ?S: available to ask for a notification from a POSIX message queue. ?S:. ?C:HAS_MQ_NOTIFY: ?C: This symbol, if defined, indicates that the mq_notify system call is ?C: available to ask for a notification from a POSIX message queue. ?C:. ?H:#$d_mq_notify HAS_MQ_NOTIFY /**/ ?H:. ?LINT:set d_mq_notify : see if mq_notify exists set mq_notify d_mq_notify eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_open.U000066400000000000000000000015061316016665300213470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_open: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_open: ?S: This variable conditionally defines HAS_MQ_OPEN if mq_open() is ?S: available to open a POSIX message queue. ?S:. ?C:HAS_MQ_OPEN: ?C: This symbol, if defined, indicates that the mq_open system call is ?C: available to open a POSIX message queue. ?C:. ?H:#$d_mq_open HAS_MQ_OPEN /**/ ?H:. ?LINT:set d_mq_open : see if mq_open exists set mq_open d_mq_open eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_receive.U000066400000000000000000000016161316016665300220320ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_receive: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_receive: ?S: This variable conditionally defines HAS_MQ_RECEIVE if mq_receive() is ?S: available to receive a message from a POSIX message queue. ?S:. ?C:HAS_MQ_RECEIVE: ?C: This symbol, if defined, indicates that the mq_receive system call is ?C: available to receive a message from a POSIX message queue. ?C:. ?H:#$d_mq_receive HAS_MQ_RECEIVE /**/ ?H:. ?LINT:set d_mq_receive : see if mq_receive exists set mq_receive d_mq_receive eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_send.U000066400000000000000000000015401316016665300213350ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_send: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_send: ?S: This variable conditionally defines HAS_MQ_SEND if mq_send() is ?S: available to send a message to a POSIX message queue. ?S:. ?C:HAS_MQ_SEND: ?C: This symbol, if defined, indicates that the mq_send system call is ?C: available to send a message to a POSIX message queue. ?C:. ?H:#$d_mq_send HAS_MQ_SEND /**/ ?H:. ?LINT:set d_mq_send : see if mq_send exists set mq_send d_mq_send eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_setattr.U000066400000000000000000000016141316016665300220740ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_setattr: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_setattr: ?S: This variable conditionally defines HAS_MQ_SETATTR if mq_setattr() is ?S: available to set the attributes of a POSIX message queue. ?S:. ?C:HAS_MQ_SETATTR: ?C: This symbol, if defined, indicates that the mq_setattr system call is ?C: available to set the attributes of a POSIX message queue. ?C:. ?H:#$d_mq_setattr HAS_MQ_SETATTR /**/ ?H:. ?LINT:set d_mq_setattr : see if mq_setattr exists set mq_setattr d_mq_setattr eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_mq_unlink.U000066400000000000000000000015421316016665300217060ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_mq_unlink: Inlibc ?MAKE: -pick add $@ %< ?S:d_mq_unlink: ?S: This variable conditionally defines HAS_MQ_UNLINK if mq_unlink() is ?S: available to unlink a POSIX message queue. ?S:. ?C:HAS_MQ_UNLINK: ?C: This symbol, if defined, indicates that the mq_unlink system call is ?C: available to unlink a POSIX message queue. ?C:. ?H:#$d_mq_unlink HAS_MQ_UNLINK /**/ ?H:. ?LINT:set d_mq_unlink : see if mq_unlink exists set mq_unlink d_mq_unlink eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_msghdr_s.U000066400000000000000000000016541316016665300215230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_msghdr_s: Hasstruct i_systypes d_socket i_sysuio Setvar ?MAKE: -pick add $@ %< ?S:d_msghdr_s: ?S: This variable conditionally defines the HAS_STRUCT_MSGHDR symbol, ?S: which indicates that the struct msghdr is supported. ?S:. ?C:HAS_STRUCT_MSGHDR: ?C: This symbol, if defined, indicates that the struct msghdr ?C: is supported. ?C:. ?H:#$d_msghdr_s HAS_STRUCT_MSGHDR /**/ ?H:. ?LINT:set d_msghdr_s : Check for msghdr_s echo " " echo "Checking to see if your system supports struct msghdr..." >&4 set d_msghdr_s msghdr $i_systypes sys/types.h $d_socket sys/socket.h $i_sysuio sys/uio.h eval $hasstruct case "$d_msghdr_s" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_nan.U000066400000000000000000000007721316016665300204710ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_nan: Inlibc ?MAKE: -pick add $@ %< ?S:d_nan: ?S: This variable conditionally defines HAS_NAN if nan() is ?S: available to generate NaN. ?S:. ?C:HAS_NAN: ?C: This symbol, if defined, indicates that the nan routine is ?C: available to generate NaN. ?C:. ?H:#$d_nan HAS_NAN /**/ ?H:. ?LINT:set d_nan : see if nan exists set nan d_nan eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_nanosleep.U000066400000000000000000000015421316016665300216750ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_nanosleep: Inlibc ?MAKE: -pick add $@ %< ?S:d_nanosleep: ?S: This variable conditionally defines HAS_NANOSLEEP ?S: if nanosleep() is available to sleep with 1E-9 sec accuracy. ?S:. ?C:HAS_NANOSLEEP: ?C: This symbol, if defined, indicates that the nanosleep ?C: system call is available to sleep with 1E-9 sec accuracy. ?C:. ?H:#$d_nanosleep HAS_NANOSLEEP /**/ ?H:. ?LINT:set d_nanosleep : see if nanosleep exists set nanosleep d_nanosleep eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_nearbyint.U000066400000000000000000000013261316016665300217040ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_nearbyint: Inlibc ?MAKE: -pick add $@ %< ?S:d_nearbyint: ?S: This variable conditionally defines HAS_NEARBYINT if nearbyint() ?S: is available to return the integral value closest to (according to ?S: the current rounding mode) to x. ?S:. ?C:HAS_NEARBYINT: ?C: This symbol, if defined, indicates that the nearbyint routine is ?C: available to return the integral value closest to (according to ?C: the current rounding mode) to x. ?C:. ?H:#$d_nearbyint HAS_NEARBYINT /**/ ?H:. ?LINT:set d_nearbyint : see if nearbyint exists set nearbyint d_nearbyint eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_newlocale.U000066400000000000000000000063111316016665300216610ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_newlocale d_freelocale d_uselocale d_duplocale d_querylocale i_xlocale: Inlibc Inhdr ?MAKE: -pick add $@ %< ?S:d_newlocale: ?S: This variable conditionally defines the HAS_NEWLOCALE symbol, which ?S: indicates to the C program that the newlocale() routine is available ?S: to return a new locale object or modify an existing locale object. ?S:. ?S:d_freelocale: ?S: This variable conditionally defines the HAS_FREELOCALE symbol, which ?S: indicates to the C program that the freelocale() routine is available ?S: to deallocates the resources associated with a locale object. ?S:. ?S:d_uselocale: ?S: This variable conditionally defines the HAS_USELOCALE symbol, which ?S: indicates to the C program that the uselocale() routine is available ?S: to set the current locale for the calling thread. ?S:. ?S:d_duplocale: ?S: This variable conditionally defines the HAS_DUPLOCALE symbol, which ?S: indicates to the C program that the duplocale() routine is available ?S: to duplicate a locale object. ?S:. ?S:d_querylocale: ?S: This variable conditionally defines the HAS_QUERYLOCALE symbol, which ?S: indicates to the C program that the querylocale() routine is available ?S: to return the name of the locale for a category mask. ?S:. ?S:i_xlocale: ?S: This symbol, if defined, indicates to the C program that it should ?S: include to get uselocale() and its friends ?S:. ?C:HAS_NEWLOCALE: ?C: This symbol, if defined, indicates that the newlocale routine is ?C: available to return a new locale object or modify an existing ?C: locale object. ?C:. ?C:HAS_FREELOCALE: ?C: This symbol, if defined, indicates that the freelocale routine is ?C: available to deallocates the resources associated with a locale object. ?C:. ?C:HAS_USELOCALE: ?C: This symbol, if defined, indicates that the uselocale routine is ?C: available to set the current locale for the calling thread. ?C:. ?C:HAS_DUPLOCALE: ?C: This symbol, if defined, indicates that the duplocale routine is ?C: available to duplicate a locale object. ?C:. ?C:HAS_QUERYLOCALE: ?C: This symbol, if defined, indicates that the querylocale routine is ?C: available to return the name of the locale for a category mask. ?C:. ?C:I_XLOCALE: ?C: This symbol, if defined, indicates to the C program that it should ?C: include to get uselocale() and its friends. ?C:. ?H:#$d_newlocale HAS_NEWLOCALE /**/ ?H:#$d_freelocale HAS_FREELOCALE /**/ ?H:#$d_uselocale HAS_USELOCALE /**/ ?H:#$d_duplocale HAS_DUPLOCALE /**/ ?H:#$d_querylocale HAS_QUERYLOCALE /**/ ?H:#$i_xlocale I_XLOCALE /**/ ?H:. ?LINT:set i_xlocale ?LINT:set d_newlocale ?LINT:set d_freelocale ?LINT:set d_uselocale ?LINT:set d_duplocale ?LINT:set d_querylocale : see if this is an xlocale.h system set xlocale.h i_xlocale eval $inhdr : see if newlocale exists set newlocale d_newlocale eval $inlibc : see if freelocale exists set freelocale d_freelocale eval $inlibc : see if uselocale exists set uselocale d_uselocale eval $inlibc : see if duplocale exists set duplocale d_duplocale eval $inlibc : see if querylocale exists set querylocale d_querylocale eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_nextafter.U000066400000000000000000000012661316016665300217140ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_nextafter: Inlibc ?MAKE: -pick add $@ %< ?S:d_nextafter: ?S: This variable conditionally defines HAS_NEXTAFTER if nextafter() ?S: is available to return the next machine representable double from ?S: x in direction y. ?S:. ?C:HAS_NEXTAFTER: ?C: This symbol, if defined, indicates that the nextafter routine is ?C: available to return the next machine representable double from ?C: x in direction y. ?C:. ?H:#$d_nextafter HAS_NEXTAFTER /**/ ?H:. ?LINT:set d_nextafter : see if nextafter exists set nextafter d_nextafter eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_nexttoward.U000066400000000000000000000013141316016665300221050ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_nexttoward: Inlibc ?MAKE: -pick add $@ %< ?S:d_nexttoward: ?S: This variable conditionally defines HAS_NEXTTOWARD if nexttoward() ?S: is available to return the next machine representable long double from ?S: x in direction y. ?S:. ?C:HAS_NEXTTOWARD: ?C: This symbol, if defined, indicates that the nexttoward routine is ?C: available to return the next machine representable long double from ?C: x in direction y. ?C:. ?H:#$d_nexttoward HAS_NEXTTOWARD /**/ ?H:. ?LINT:set d_nexttoward : see if nexttoward exists set nexttoward d_nexttoward eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_nl_langinfo.U000066400000000000000000000014531316016665300222000ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_nl_langinfo: Inlibc i_langinfo ?MAKE: -pick add $@ %< ?S:d_nl_langinfo: ?S: This variable conditionally defines the HAS_NL_LANGINFO symbol, which ?S: indicates to the C program that the nl_langinfo() routine is available. ?S:. ?C:HAS_NL_LANGINFO: ?C: This symbol, if defined, indicates that the nl_langinfo routine is ?C: available to return local data. You will also need ?C: and therefore I_LANGINFO. ?C:. ?H:#$d_nl_langinfo HAS_NL_LANGINFO /**/ ?H:. ?LINT:set d_nl_langinfo ?LINT:use i_langinfo : see if nl_langinfo exists set nl_langinfo d_nl_langinfo eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_off64_t.U000066400000000000000000000017131316016665300211600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_off64_t: \ Inlibc Setvar Compile rm_try cat lseeksize ?MAKE: -pick add $@ %< ?S:d_off64_t: ?S: This symbol will be defined if the C compiler supports off64_t. ?S:. ?C:HAS_OFF64_T: ?C: This symbol will be defined if the C compiler supports off64_t. ?C:. ?H:#$d_off64_t HAS_OFF64_T /**/ ?H:. ?LINT:set d_off64_t : check for off64_t echo " " echo "Checking to see if you have off64_t..." >&4 $cat >try.c < #include int main() { off64_t x = 7; } EOCP set try if eval $compile; then val="$define" echo "You have off64_t." else val="$undef" echo "You do not have off64_t." case "$lseeksize" in 8) echo "(Your off_t is 64 bits, so you could use that.)" ;; esac fi $rm_try set d_off64_t eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_portable.U000066400000000000000000000035461316016665300215270ustar00rootroot00000000000000?RCS: $Id: d_portable.U,v 3.0.1.2 1995/01/11 15:28:52 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: This file is included with or a derivative work of a file included ?RCS: with the metaconfig program of Raphael Manfredi's "dist" distribution. ?RCS: In accordance with clause 7 of dist's modified Artistic License: ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_portable.U,v $ ?RCS: Revision 3.0.1.2 1995/01/11 15:28:52 ram ?RCS: patch45: executable path stripping moved to the end in Config_sh.U ?RCS: ?RCS: Revision 3.0.1.1 1993/12/15 08:21:17 ram ?RCS: patch15: did not strip variables properly when needed ?RCS: patch15: now also strips down variables from trylist ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:48 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: This is the same as the dist version, except I don't bother ?X: prompting people since it makes no difference for perl5, ?X: and only confuses people. ?X: ?X: The Loc unit is wanted to get the definition of all the locating variables. ?X: ?MAKE:d_portable: Loc Oldconfig ?MAKE: -pick add $@ %< ?S:d_portable: ?S: This variable conditionally defines the PORTABLE symbol, which ?S: indicates to the C program that it should not assume that it is ?S: running on the machine it was compiled on. ?S:. ?C:PORTABLE: ?C: This symbol, if defined, indicates to the C program that it should ?C: not assume that it is running on the machine it was compiled on. ?C: The program should be prepared to look up the host name, translate ?C: generic filenames, use PATH, etc. ?C:. ?H:#$d_portable PORTABLE /**/ ?H:. ?D:d_portable='' : decide how portable to be. Allow command line overrides. case "$d_portable" in "$undef") ;; *) d_portable="$define" ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_posix_clock.U000066400000000000000000000023421316016665300222250ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_clock: Setvar d_clock_getres d_clock_gettime d_clock_settime i_time ?MAKE: -pick add $@ %< ?S:d_posix_clock: ?S: This variable conditionally defines the HAS_POSIX_CLOCK symbol, which ?S: indicates that the entire POSIX clock_*(2) library is present. ?S:. ?C:HAS_POSIX_CLOCK: ?C: This symbol, if defined, indicates that the entire POSIX clock_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_clock HAS_POSIX_CLOCK /**/ ?H:. ?LINT:set d_posix_clock : see how much of the 'POSIX clock_*(2)' library is present. echo " " case "$i_time$d_clock_getres$d_clock_gettime$d_clock_settime" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX clock_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX clock_*(2) library." >&4 ;; esac set d_posix_clock eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_posix_mq.U000066400000000000000000000024351316016665300215520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_mq: Setvar d_mq_open d_mq_unlink d_mq_close d_mq_send d_mq_receive d_mq_notify d_mq_setattr d_mq_getattr i_mqueue ?MAKE: -pick add $@ %< ?S:d_posix_mq: ?S: This variable conditionally defines the HAS_POSIX_MQ symbol, which ?S: indicates that the entire POSIX mq_*(2) library is present. ?S:. ?C:HAS_POSIX_MQ: ?C: This symbol, if defined, indicates that the entire POSIX mq_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_mq HAS_POSIX_MQ /**/ ?H:. ?LINT:set d_posix_mq : see how much of the 'POSIX mq_*(2)' library is present. echo " " case "$i_mqueue$d_mq_open$d_mq_close$d_mq_send$d_mq_receive$d_mq_notify$d_mq_setattr$d_mq_getattr$d_mq_unlink" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX mq_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX mq_*(2) library." >&4 ;; esac set d_posix_mq eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_posix_sched.U000066400000000000000000000026621316016665300222250ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_sched: Setvar d_sched_getparam d_sched_setparam d_sched_getscheduler d_sched_setscheduler d_sched_rr_get_interval d_sched_get_priority_min d_sched_get_priority_max i_sched ?MAKE: -pick add $@ %< ?S:d_posix_sched: ?S: This variable conditionally defines the HAS_POSIX_SCHED symbol, which ?S: indicates that the entire POSIX sched_*(2) library is present. ?S:. ?C:HAS_POSIX_SCHED: ?C: This symbol, if defined, indicates that the entire POSIX sched_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_sched HAS_POSIX_SCHED /**/ ?H:. ?LINT:set d_posix_sched : see how much of the 'POSIX sched_*(2)' library is present. echo " " case "$i_sched$d_sched_getparam$d_sched_getscheduler$d_sched_setscheduler$d_sched_rr_get_interval$d_sched_get_priority_min$d_sched_get_priority_max$d_sched_setparam" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX sched_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX sched_*(2) library." >&4 ;; esac set d_posix_sched eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_posix_sem.U000066400000000000000000000025151316016665300217200ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_sem: Setvar d_sem_open d_sem_unlink d_sem_close d_sem_destroy d_sem_getvalue d_sem_post d_sem_wait d_sem_init d_sem_trywait i_semaphore ?MAKE: -pick add $@ %< ?S:d_posix_sem: ?S: This variable conditionally defines the HAS_POSIX_SEM symbol, which ?S: indicates that the entire sem*(2) library is present. ?S:. ?C:HAS_POSIX_SEM: ?C: This symbol, if defined, indicates that the entire POSIX sem_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_sem HAS_POSIX_SEM /**/ ?H:. ?LINT:set d_posix_sem : see how much of the 'POSIX sem_*(2)' library is present. echo " " case "$i_semaphore$d_sem_open$d_sem_close$d_sem_destroy$d_sem_getvalue$d_sem_post$d_sem_wait$d_sem_trywait$d_sem_init$d_sem_unlink" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX sem_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX sem_*(2) library." >&4 ;; esac set d_posix_sem eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_posix_shm.U000066400000000000000000000022401316016665300217160ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_shm: Setvar d_shm_open d_shm_unlink i_sysmman ?MAKE: -pick add $@ %< ?S:d_posix_shm: ?S: This variable conditionally defines the HAS_POSIX_SHM symbol, which ?S: indicates that the entire POSIX shm_*(2) library is present. ?S:. ?C:HAS_POSIX_SHM: ?C: This symbol, if defined, indicates that the entire POSIX shm_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_shm HAS_POSIX_SHM /**/ ?H:. ?LINT:set d_posix_shm : see how much of the 'POSIX shm_*(2)' library is present. echo " " case "$i_sysmman$d_shm_open$d_shm_unlink" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX shm_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX shm_*(2) library." >&4 ;; esac set d_posix_shm eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_posix_timer.U000066400000000000000000000024461316016665300222570ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_posix_timer: Setvar d_timer_create d_timer_delete d_timer_gettime d_timer_settime d_timer_getoverrun i_time ?MAKE: -pick add $@ %< ?S:d_posix_timer: ?S: This variable conditionally defines the HAS_POSIX_TIMER symbol, which ?S: indicates that the entire POSIX timer_*(2) library is present. ?S:. ?C:HAS_POSIX_TIMER: ?C: This symbol, if defined, indicates that the entire POSIX timer_*(2) ?C: library is supported. ?C:. ?H:#$d_posix_timer HAS_POSIX_TIMER /**/ ?H:. ?LINT:set d_posix_timer : see how much of the 'POSIX timer_*(2)' library is present. echo " " case "$i_time$d_timer_create$d_timer_delete$d_timer_gettime$d_timer_settime$d_timer_getoverrun" in *"$undef"*) val="$undef" ;; *) val="$define" ;; esac case "$val" in "$define") echo "You have the full POSIX timer_*(2) library." >&4 ;; "$undef") echo "You don't have the full POSIX timer_*(2) library." >&4 ;; esac set d_posix_timer eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_prctl.U000066400000000000000000000033651316016665300210420ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2010 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_prctl d_prctl_set_name: Inlibc cat Compile run rm_try ?MAKE: -pick add $@ %< ?S:d_prctl: ?S: This variable conditionally defines the HAS_PRCTL symbol, which ?S: indicates to the C program that the prctl() routine is available. ?S: Note that there are at least two prctl variants: Linux and Irix. ?S: While they are somewhat similar, they are incompatible. ?S:. ?S:d_prctl_set_name: ?S: This variable conditionally defines the HAS_PRCTL_SET_NAME symbol, ?S: which indicates to the C program that the prctl() routine supports ?S: the PR_SET_NAME option. ?S:. ?C:HAS_PRCTL: ?C: This symbol, if defined, indicates that the prctl routine is ?C: available to set process title. ?C: Note that there are at least two prctl variants: Linux and Irix. ?C: While they are somewhat similar, they are incompatible. ?C:. ?C:HAS_PRCTL_SET_NAME: ?C: This symbol, if defined, indicates that the prctl routine is ?C: available to set process title and supports PR_SET_NAME. ?C:. ?H:#$d_prctl HAS_PRCTL /**/ ?H:#$d_prctl_set_name HAS_PRCTL_SET_NAME /**/ ?H:. ?F:!try ?LINT:set d_prctl : see if prctl exists set prctl d_prctl eval $inlibc : see if prctl supports PR_SET_NAME d_prctl_set_name=$undef case $d_prctl in $define) $cat >try.c < #endif #include int main (int argc, char *argv[]) { return (prctl (PR_SET_NAME, "Test")); } /* main */ EOM set try if eval $compile_ok && $run ./try; then echo "Your prctl (PR_SET_NAME, ...) works" d_prctl_set_name=$define fi $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_printfed.U000066400000000000000000000025621316016665300215270ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_printf_exp_digits: Compile cat rm run ?MAKE: -pick add $@ %< ?S:d_printf_exp_digits: ?S: This symbol's value is either 2 or 3, corresponding to the ?S: number of exponent digits produced by the system's sprintf %[FGfg] ?S: formats when the modulus of the exponent is 99 or less. ?S:. ?C:PRINTF_EXP_DIGITS: ?C: This symbol's value is either 2 or 3, corresponding to the ?C: number of exponent digits produced by the system's sprintf %[FGfg] ?C: formats when the modulus of the exponent is 99 or less. ?C:. ?H:#define PRINTF_EXP_DIGITS $d_printf_exp_digits ?H:. ?F:!try : Check sprintf exponent digits echo " " echo "Checking how many exponent digits your sprintf formats use..." $cat >try.c <<'EOSC' #include int main() { char b[10]; exit(sprintf(b, "%0.1e", 1.2) - 5); } EOSC set try if eval $compile; then $run ./try case "$?" in 2|3) d_printf_exp_digits=$? ;; esac fi case "$d_printf_exp_digits" in 2|3) echo "Your sprintf seems to use $d_printf_exp_digits exponent digits." ;; *) cat <&4 I do not understand what your sprintf is saying. I'm guessing it uses at least 2 exponent digits. EOM d_printf_exp_digits=2 ;; esac $rm -f try try.* metaconfig-debian-perl-5.26.1/U/perl/d_procselfexe.U000066400000000000000000000041161316016665300222300ustar00rootroot00000000000000?MAKE:d_procselfexe procselfexe: \ Oldconfig Setvar rm ls contains issymlink d_readlink test ?MAKE: -pick add $@ %< ?S:d_procselfexe: ?S: Defined if $procselfexe is symlink to the absolute ?S: pathname of the executing program. ?S:. ?S:procselfexe: ?S: If d_procselfexe is defined, $procselfexe is the filename ?S: of the symbolic link pointing to the absolute pathname of ?S: the executing program. ?S:. ?C:HAS_PROCSELFEXE: ?C: This symbol is defined if PROCSELFEXE_PATH is a symlink ?C: to the absolute pathname of the executing program. ?C:. ?C:PROCSELFEXE_PATH: ?C: If HAS_PROCSELFEXE is defined this symbol is the filename ?C: of the symbolic link pointing to the absolute pathname of ?C: the executing program. ?C:. ?H:#$d_procselfexe HAS_PROCSELFEXE /**/ ?H:?%<:#if defined(HAS_PROCSELFEXE) && !defined(PROCSELFEXE_PATH) ?H:?%<:#define PROCSELFEXE_PATH $procselfexe /**/ ?H:?%<:#endif ?H:. ?T:try type ?LINT: set d_procselfexe : Check if there is a /proc symlink to the abs path of : the executing program. We will honor hints of d_procselfexe=$undef : or procselfexe being non-empty, otherwise will try to determine both : if we have readlink. : AmigaOS will attempt to mount proc: aka /proc, if /proc/... is : referenced, and AmigaOS does not have a proc filesystem anyway. echo " " val="$undef" if $test "X$d_procselfexe" = Xundef; then procselfexe='' elif $test "X$procselfexe" != X -a "X$procselfexe" != 'X '; then val="$define" elif $test "X$d_readlink" = Xdefine; then : NetBSD first as /proc/self is a symlink to /proc/curproc, : and it feels more tidy to avoid an extra level of symlink set NetBSD /proc/curproc/exe Linux /proc/self/exe FreeBSD /proc/curproc/file Solaris /proc/self/path/a.out while test $# -gt 0; do type=$1; try=$2 shift; shift if $issymlink $try; then $ls -l $try > reflect if $contains /`basename $ls` reflect >/dev/null 2>&1; then echo "You have $type-like $try." procselfexe='"'$try'"' val="$define" : This will break out of the loop set X; shift fi fi done fi $rm -f reflect set d_procselfexe eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_pthread_attr_ss.U000066400000000000000000000021001316016665300230660ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2003, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_pthread_attr_setscope: Inlibc ?MAKE: -pick add $@ %< ?S:d_pthread_attr_setscope: ?S: This variable conditionally defines HAS_PTHREAD_ATTR_SETSCOPE if ?S: pthread_attr_setscope() is available to set the contention scope ?S: attribute of a thread attribute object. ?S:. ?C:HAS_PTHREAD_ATTR_SETSCOPE: ?C: This symbol, if defined, indicates that the pthread_attr_setscope ?C: system call is available to set the contention scope attribute of ?C: a thread attribute object. ?C:. ?H:#$d_pthread_attr_setscope HAS_PTHREAD_ATTR_SETSCOPE /**/ ?H:. ?LINT:set d_pthread_attr_setscope : see if pthread_attr_setscope exists set pthread_attr_setscope d_pthread_attr_setscope eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_ptrdiff_t.U000066400000000000000000000015461316016665300216760ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2014 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_ptrdiff_t: Inlibc Setvar Compile rm_try cat ?MAKE: -pick add $@ %< ?S:d_ptrdiff_t: ?S: This symbol will be defined if the C compiler supports ptrdiff_t. ?S:. ?C:HAS_PTRDIFF_T: ?C: This symbol will be defined if the C compiler supports ptrdiff_t. ?C:. ?H:#$d_ptrdiff_t HAS_PTRDIFF_T /**/ ?H:. ?LINT:set d_ptrdiff_t : check for ptrdiff_t echo " " echo "Checking to see if you have ptrdiff_t..." >&4 $cat >try.c < int main() { ptrdiff_t x = 7; } EOCP set try if eval $compile; then val="$define" echo "You have ptrdiff_t." else val="$undef" echo "You do not have ptrdiff_t." fi $rm_try set d_ptrdiff_t eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_qgcvt.U000066400000000000000000000013421316016665300210330ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_qgcvt: Inlibc ?MAKE: -pick add $@ %< ?S:d_qgcvt: ?S: This variable conditionally defines the HAS_QGCVT symbol, which ?S: indicates to the C program that the qgcvt() routine is available. ?S:. ?C:HAS_QGCVT: ?C: This symbol, if defined, indicates that the qgcvt routine is ?C: available to convert long doubles ("quad doubles") to strings. ?C: This is a low-level routine hopefully faster than sprintf. ?C:. ?H:#$d_qgcvt HAS_QGCVT /**/ ?H:. ?LINT:set d_qgcvt : see if qgcvt exists set qgcvt d_qgcvt eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_readv.U000066400000000000000000000012721316016665300210120ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_readv: Inlibc ?MAKE: -pick add $@ %< ?S:d_readv: ?S: This variable conditionally defines the HAS_READV symbol, which ?S: indicates to the C program that the readv() routine is available. ?S:. ?C:HAS_READV: ?C: This symbol, if defined, indicates that the readv routine is ?C: available to do gather reads. You will also need ?C: and there I_SYSUIO. ?C:. ?H:#$d_readv HAS_READV /**/ ?H:. ?LINT:set d_readv : see if readv exists set readv d_readv eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_realpath.U000066400000000000000000000012471316016665300215130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_realpath: Inlibc ?MAKE: -pick add $@ %< ?S:d_realpath: ?S: This variable conditionally defines the HAS_REALPATH symbol, which ?S: indicates to the C program that the realpath() routine is available. ?S:. ?C:HAS_REALPATH: ?C: This symbol, if defined, indicates that the realpath routine is ?C: available to do resolve paths. ?C:. ?H:#$d_realpath HAS_REALPATH /**/ ?H:. ?LINT:set d_realpath : see if realpath exists set realpath d_realpath eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_recvmsg.U000066400000000000000000000012521316016665300213550ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_recvmsg: Inlibc ?MAKE: -pick add $@ %< ?S:d_recvmsg: ?S: This variable conditionally defines the HAS_RECVMSG symbol, which ?S: indicates to the C program that the recvmsg() routine is available. ?S:. ?C:HAS_RECVMSG: ?C: This symbol, if defined, indicates that the recvmsg routine is ?C: available to send structured socket messages. ?C:. ?H:#$d_recvmsg HAS_RECVMSG /**/ ?H:. ?LINT:set d_recvmsg : see if recvmsg exists set recvmsg d_recvmsg eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_remainder.U000066400000000000000000000012041316016665300216520ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_remainder: Inlibc ?MAKE: -pick add $@ %< ?S:d_remainder: ?S: This variable conditionally defines the HAS_REMAINDER symbol, which ?S: indicates to the C program that the remainder() routine is available. ?S:. ?C:HAS_REMAINDER: ?C: This symbol, if defined, indicates that the remainder routine is ?C: available to return the floating-point remainder. ?C:. ?H:#$d_remainder HAS_REMAINDER /**/ ?H:. ?LINT:set d_remainder : see if remainder exists set remainder d_remainder eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_remquo.U000066400000000000000000000011461316016665300212210ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_remquo: Inlibc ?MAKE: -pick add $@ %< ?S:d_remquo: ?S: This variable conditionally defines the HAS_REMQUO symbol, which ?S: indicates to the C program that the remquo() routine is available. ?S:. ?C:HAS_REMQUO: ?C: This symbol, if defined, indicates that the remquo routine is ?C: available to return the remainder and part of quotient. ?C:. ?H:#$d_remquo HAS_REMQUO /**/ ?H:. ?LINT:set d_remquo : see if remquo exists set remquo d_remquo eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_rint.U000066400000000000000000000011711316016665300206630ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_rint: Inlibc ?MAKE: -pick add $@ %< ?S:d_rint: ?S: This variable conditionally defines the HAS_RINT symbol, which ?S: indicates to the C program that the rint() routine is available. ?S:. ?C:HAS_RINT: ?C: This symbol, if defined, indicates that the rint routine is ?C: available to return the nearest integral value to x as double ?C: using the current rounding mode. ?C:. ?H:#$d_rint HAS_RINT /**/ ?H:. ?LINT:set d_rint : see if rint exists set rint d_rint eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_round.U000066400000000000000000000011311316016665300210320ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_round: Inlibc ?MAKE: -pick add $@ %< ?S:d_round: ?S: This variable conditionally defines the HAS_ROUND symbol, which ?S: indicates to the C program that the round() routine is available. ?S:. ?C:HAS_ROUND: ?C: This symbol, if defined, indicates that the round routine is ?C: available to round to nearest integer, away from zero. ?C:. ?H:#$d_round HAS_ROUND /**/ ?H:. ?LINT:set d_round : see if round exists set round d_round eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sbrkproto.U000066400000000000000000000021661316016665300217410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sbrkproto: Hasproto i_unistd ?MAKE: -pick add $@ %< ?S:d_sbrkproto: ?S: This variable conditionally defines the HAS_SBRK_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the sbrk() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_SBRK_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the sbrk() function. Otherwise, it is up ?C: to the program to supply one. Good guesses are ?C: extern void* sbrk(int); ?C: extern void* sbrk(size_t); ?C:. ?H:#$d_sbrkproto HAS_SBRK_PROTO /**/ ?H:. ?LINT:set d_sbrkproto : see if prototype for sbrk is available echo " " set d_sbrkproto sbrk $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_scalbn.U000066400000000000000000000011721316016665300211520ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_scalbn: Inlibc ?MAKE: -pick add $@ %< ?S:d_scalbn: ?S: This variable conditionally defines the HAS_SCALBN symbol, which ?S: indicates to the C program that the scalbn() routine is available. ?S:. ?C:HAS_SCALBN: ?C: This symbol, if defined, indicates that the scalbn routine is ?C: available to multiply floating-point number by integral power ?C: of radix. ?C:. ?H:#$d_scalbn HAS_SCALBN /**/ ?H:. ?LINT:set d_scalbn : see if scalbn exists set scalbn d_scalbn eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_scalbnl.U000066400000000000000000000013561316016665300213320ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_scalbnl: Inlibc ?MAKE: -pick add $@ %< ?S:d_scalbnl: ?S: This variable conditionally defines the HAS_SCALBNL symbol, which ?S: indicates to the C program that the scalbnl() routine is available. ?S: If ilogbl is also present we can emulate frexpl. ?S:. ?C:HAS_SCALBNL: ?C: This symbol, if defined, indicates that the scalbnl routine is ?C: available. If ilogbl is also present we can emulate frexpl. ?C:. ?H:#$d_scalbnl HAS_SCALBNL /**/ ?H:. ?LINT:set d_scalbnl : see if scalbnl exists set scalbnl d_scalbnl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_getparam.U000066400000000000000000000016401316016665300226560ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_getparam: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_getparam: ?S: This variable conditionally defines HAS_SCHED_GETPARAM if ?S: sched_getparam() is available to get the scheduling parameters. ?S:. ?C:HAS_SCHED_GETPARAM: ?C: This symbol, if defined, indicates that the sched_getparam ?C: system call is available to get the scheduling parameters. ?C:. ?H:#$d_sched_getparam HAS_SCHED_GETPARAM /**/ ?H:. ?LINT:set d_sched_getparam : see if sched_getparam exists set sched_getparam d_sched_getparam eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_getscheduler.U000066400000000000000000000017101316016665300235320ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_getscheduler: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_getscheduler: ?S: This variable conditionally defines HAS_SCHED_GETSCHEDULER if ?S: sched_getscheduler() is available to get the scheduling policy. ?S:. ?C:HAS_SCHED_GETSCHEDULER: ?C: This symbol, if defined, indicates that the sched_getscheduler ?C: system call is available to get the scheduling policy. ?C:. ?H:#$d_sched_getscheduler HAS_SCHED_GETSCHEDULER /**/ ?H:. ?LINT:set d_sched_getscheduler : see if sched_getscheduler exists set sched_getscheduler d_sched_getscheduler eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_gpmax.U000066400000000000000000000020201316016665300221630ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_get_priority_max: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_get_priority_max: ?S: This variable conditionally defines HAS_SCHED_GET_PRIORITY_MAX if ?S: sched_get_priority_max() is available to get the maximum scheduling ?S: priority. ?S:. ?C:HAS_SCHED_GET_PRIORITY_MAX: ?C: This symbol, if defined, indicates that the sched_get_priority_max ?C: system call is available to get the maximum scheduling priority. ?C:. ?H:#$d_sched_get_priority_max HAS_SCHED_GET_PRIORITY_MAX /**/ ?H:. ?LINT:set d_sched_get_priority_max : see if sched_get_priority_max exists set sched_get_priority_max d_sched_get_priority_max eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_gpmin.U000066400000000000000000000020201316016665300221610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_get_priority_min: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_get_priority_min: ?S: This variable conditionally defines HAS_SCHED_GET_PRIORITY_MIN if ?S: sched_get_priority_min() is available to get the minimum scheduling ?S: priority. ?S:. ?C:HAS_SCHED_GET_PRIORITY_MIN: ?C: This symbol, if defined, indicates that the sched_get_priority_min ?C: system call is available to get the minimum scheduling priority. ?C:. ?H:#$d_sched_get_priority_min HAS_SCHED_GET_PRIORITY_MIN /**/ ?H:. ?LINT:set d_sched_get_priority_min : see if sched_get_priority_min exists set sched_get_priority_min d_sched_get_priority_min eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_rrgi.U000066400000000000000000000020461316016665300220220ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_rr_get_interval: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_rr_get_interval: ?S: This variable conditionally defines HAS_SCHED_RR_GET_INTERVAL if ?S: sched_rr_get_interval() is available to get the time quantum ?S: of the round robin scheduling. ?S:. ?C:HAS_SCHED_RR_GET_INTERVAL: ?C: This symbol, if defined, indicates that the sched_rr_get_interval ?C: system call is available to get the time quantum ?C: of the round robin scheduling. ?C:. ?H:#$d_sched_rr_get_interval HAS_SCHED_RR_GET_INTERVAL /**/ ?H:. ?LINT:set d_sched_rr_get_interval : see if sched_rr_get_interval exists set sched_rr_get_interval d_sched_rr_get_interval eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_setparam.U000066400000000000000000000016401316016665300226720ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_setparam: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_setparam: ?S: This variable conditionally defines HAS_SCHED_SETPARAM if ?S: sched_setparam() is available to set the scheduling parameters. ?S:. ?C:HAS_SCHED_SETPARAM: ?C: This symbol, if defined, indicates that the sched_setparam ?C: system call is available to set the scheduling parameters. ?C:. ?H:#$d_sched_setparam HAS_SCHED_SETPARAM /**/ ?H:. ?LINT:set d_sched_setparam : see if sched_setparam exists set sched_setparam d_sched_setparam eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sched_setscheduler.U000066400000000000000000000017101316016665300235460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sched_setscheduler: Inlibc ?MAKE: -pick add $@ %< ?S:d_sched_setscheduler: ?S: This variable conditionally defines HAS_SCHED_SETSCHEDULER if ?S: sched_setscheduler() is available to set the scheduling policy. ?S:. ?C:HAS_SCHED_SETSCHEDULER: ?C: This symbol, if defined, indicates that the sched_setscheduler ?C: system call is available to set the scheduling policy. ?C:. ?H:#$d_sched_setscheduler HAS_SCHED_SETSCHEDULER /**/ ?H:. ?LINT:set d_sched_setscheduler : see if sched_setscheduler exists set sched_setscheduler d_sched_setscheduler eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_close.U000066400000000000000000000015301316016665300216570ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_close: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_close: ?S: This variable conditionally defines HAS_SEM_CLOSE if sem_close() is ?S: available to close a POSIX semaphore. ?S:. ?C:HAS_SEM_CLOSE: ?C: This symbol, if defined, indicates that the sem_close system call is ?C: available to close a POSIX semaphore. ?C:. ?H:#$d_sem_close HAS_SEM_CLOSE /**/ ?H:. ?LINT:set d_sem_close : see if sem_close exists set sem_close d_sem_close eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_destroy.U000066400000000000000000000015641316016665300222520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_destroy: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_destroy: ?S: This variable conditionally defines HAS_SEM_DESTROY if sem_destroy() is ?S: available to destroy a POSIX semaphore. ?S:. ?C:HAS_SEM_DESTROY: ?C: This symbol, if defined, indicates that the sem_destroy system call is ?C: available to destroy a POSIX semaphore. ?C:. ?H:#$d_sem_destroy HAS_SEM_DESTROY /**/ ?H:. ?LINT:set d_sem_destroy : see if sem_destroy exists set sem_destroy d_sem_destroy eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_getvalue.U000066400000000000000000000016221316016665300223700ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_getvalue: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_getvalue: ?S: This variable conditionally defines HAS_SEM_GETVALUE if sem_getvalue() ?S: is available to get the value of a POSIX semaphore. ?S:. ?C:HAS_SEM_GETVALUE: ?C: This symbol, if defined, indicates that the sem_getvalue system call is ?C: available to get the value of a POSIX semaphore. ?C:. ?H:#$d_sem_getvalue HAS_SEM_GETVALUE /**/ ?H:. ?LINT:set d_sem_getvalue : see if sem_getvalue exists set sem_getvalue d_sem_getvalue eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_init.U000066400000000000000000000015261316016665300215220ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_init: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_init: ?S: This variable conditionally defines HAS_SEM_INIT if sem_init() is ?S: available to initialize a POSIX semaphore. ?S:. ?C:HAS_SEM_INIT: ?C: This symbol, if defined, indicates that the sem_init system call is ?C: available to initialize a POSIX semaphore. ?C:. ?H:#$d_sem_init HAS_SEM_INIT /**/ ?H:. ?LINT:set d_sem_init : see if sem_init exists set sem_init d_sem_init eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_open.U000066400000000000000000000015121316016665300215130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_open: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_open: ?S: This variable conditionally defines HAS_SEM_OPEN if sem_open() is ?S: available to open a POSIX semaphore. ?S:. ?C:HAS_SEM_OPEN: ?C: This symbol, if defined, indicates that the sem_open system call is ?C: available to open a POSIX semaphore. ?C:. ?H:#$d_sem_open HAS_SEM_OPEN /**/ ?H:. ?LINT:set d_sem_open : see if sem_open exists set sem_open d_sem_open eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_post.U000066400000000000000000000015561316016665300215470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_post: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_post: ?S: This variable conditionally defines HAS_SEM_POST if sem_post() is ?S: available to post (release, unlock) a POSIX semaphore. ?S:. ?C:HAS_SEM_POST: ?C: This symbol, if defined, indicates that the sem_post system call is ?C: available to post (release, unlock) a POSIX semaphore. ?C:. ?H:#$d_sem_post HAS_SEM_POST /**/ ?H:. ?LINT:set d_sem_post : see if sem_post exists set sem_post d_sem_post eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_trywait.U000066400000000000000000000016361316016665300222640ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_trywait: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_trywait: ?S: This variable conditionally defines HAS_SEM_TRYWAIT if sem_trywait() is ?S: available to attempt to wait (grab, lock) a POSIX semaphore. ?S:. ?C:HAS_SEM_TRYWAIT: ?C: This symbol, if defined, indicates that the sem_trywait system call is ?C: available to attempt to wait (grab, lock) a POSIX semaphore. ?C:. ?H:#$d_sem_trywait HAS_SEM_TRYWAIT /**/ ?H:. ?LINT:set d_sem_trywait : see if sem_trywait exists set sem_trywait d_sem_trywait eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_unlink.U000066400000000000000000000015461316016665300220610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_unlink: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_unlink: ?S: This variable conditionally defines HAS_SEM_UNLINK if sem_unlink() is ?S: available to unlink a POSIX semaphore. ?S:. ?C:HAS_SEM_UNLINK: ?C: This symbol, if defined, indicates that the sem_unlink system call is ?C: available to unlink a POSIX semaphore. ?C:. ?H:#$d_sem_unlink HAS_SEM_UNLINK /**/ ?H:. ?LINT:set d_sem_unlink : see if sem_unlink exists set sem_unlink d_sem_unlink eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sem_wait.U000066400000000000000000000015441316016665300215230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sem_wait: Inlibc ?MAKE: -pick add $@ %< ?S:d_sem_wait: ?S: This variable conditionally defines HAS_SEM_WAIT if sem_wait() is ?S: available to wait (grab, lock) a POSIX semaphore. ?S:. ?C:HAS_SEM_WAIT: ?C: This symbol, if defined, indicates that the sem_wait system call is ?C: available to wait (grab, lock) a POSIX semaphore. ?C:. ?H:#$d_sem_wait HAS_SEM_WAIT /**/ ?H:. ?LINT:set d_sem_wait : see if sem_wait exists set sem_wait d_sem_wait eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sendmsg.U000066400000000000000000000012521316016665300213470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_sendmsg: Inlibc ?MAKE: -pick add $@ %< ?S:d_sendmsg: ?S: This variable conditionally defines the HAS_SENDMSG symbol, which ?S: indicates to the C program that the sendmsg() routine is available. ?S:. ?C:HAS_SENDMSG: ?C: This symbol, if defined, indicates that the sendmsg routine is ?C: available to send structured socket messages. ?C:. ?H:#$d_sendmsg HAS_SENDMSG /**/ ?H:. ?LINT:set d_sendmsg : see if sendmsg exists set sendmsg d_sendmsg eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_setitimer.U000066400000000000000000000012661316016665300217210ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_setitimer: Inlibc ?MAKE: -pick add $@ %< ?S:d_setitimer: ?S: This variable conditionally defines the HAS_SETITIMER symbol, which ?S: indicates to the C program that the setitimer() routine is available. ?S:. ?C:HAS_SETITIMER: ?C: This symbol, if defined, indicates that the setitimer routine is ?C: available to set interval timers. ?C:. ?H:#$d_setitimer HAS_SETITIMER /**/ ?H:. ?LINT:set d_setitimer : see if setitimer exists set setitimer d_setitimer eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_setproctitle.U000066400000000000000000000013341316016665300224310ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_setproctitle: Inlibc ?MAKE: -pick add $@ %< ?S:d_setproctitle: ?S: This variable conditionally defines the HAS_SETPROCTITLE symbol, ?S: which indicates to the C program that the setproctitle() routine ?S: is available. ?S:. ?C:HAS_SETPROCTITLE: ?C: This symbol, if defined, indicates that the setproctitle routine is ?C: available to set process title. ?C:. ?H:#$d_setproctitle HAS_SETPROCTITLE /**/ ?H:. ?LINT:set d_setproctitle : see if setproctitle exists set setproctitle d_setproctitle eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_setrlimit.U000066400000000000000000000012761316016665300217310ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_setrlimit: Inlibc ?MAKE: -pick add $@ %< ?S:d_setrlimit: ?S: This variable conditionally defines the HAS_SETRLIMIT symbol, which ?S: indicates to the C program that the setrlimit() routine is available. ?S:. ?C:HAS_SETRLIMIT: ?C: This symbol, if defined, indicates that the setrlimit routine is ?C: available to set process resource limits. ?C:. ?H:#$d_setrlimit HAS_SETRLIMIT /**/ ?H:. ?LINT:set d_setrlimit : see if setrlimit exists set setrlimit d_setrlimit eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_setspent.U000066400000000000000000000016031316016665300215540ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_setspent: Inlibc ?MAKE: -pick add $@ %< ?S:d_setspent: ?S: This variable conditionally defines HAS_SETSPENT if setspent() is ?S: available to initialize the scan of SysV shadow password entries. ?S:. ?C:HAS_SETSPENT: ?C: This symbol, if defined, indicates that the setspent system call is ?C: available to initialize the scan of SysV shadow password entries. ?C:. ?H:#$d_setspent HAS_SETSPENT /**/ ?H:. ?LINT:set d_setspent : see if setspent exists set setspent d_setspent eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_shm_open.U000066400000000000000000000015401316016665300215170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_shm_open: Inlibc ?MAKE: -pick add $@ %< ?S:d_shm_open: ?S: This variable conditionally defines HAS_SHM_OPEN if shm_open() is ?S: available to open a POSIX shared memory object. ?S:. ?C:HAS_SHM_OPEN: ?C: This symbol, if defined, indicates that the shm_open system call is ?C: available to open a POSIX shared memory object. ?C:. ?H:#$d_shm_open HAS_SHM_OPEN /**/ ?H:. ?LINT:set d_shm_open : see if shm_open exists set shm_open d_shm_open eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_shm_unlink.U000066400000000000000000000015741316016665300220650ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_shm_unlink: Inlibc ?MAKE: -pick add $@ %< ?S:d_shm_unlink: ?S: This variable conditionally defines HAS_SHM_UNLINK if shm_unlink() is ?S: available to unlink a POSIX shared memory object. ?S:. ?C:HAS_SHM_UNLINK: ?C: This symbol, if defined, indicates that the shm_unlink system call is ?C: available to unlink a POSIX shared memory object. ?C:. ?H:#$d_shm_unlink HAS_SHM_UNLINK /**/ ?H:. ?LINT:set d_shm_unlink : see if shm_unlink exists set shm_unlink d_shm_unlink eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_signbit.U000066400000000000000000000034041316016665300213470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_signbit: nvtype Compile Setvar cat run rm_try echo n c i_math i_sunmath ?MAKE: -pick add $@ %< ?S:d_signbit: ?S: This variable conditionally defines the HAS_SIGNBIT symbol, which ?S: indicates to the C program that the signbit() routine is available ?S: and safe to use with perl's intern NV type. ?S:. ?C:HAS_SIGNBIT: ?C: This symbol, if defined, indicates that the signbit routine is ?C: available to check if the given number has the sign bit set. ?C: This should include correct testing of -0.0. This will only be set ?C: if the signbit() routine is safe to use with the NV type used internally ?C: in perl. Users should call Perl_signbit(), which will be #defined to ?C: the system's signbit() function or macro if this symbol is defined. ?C:. ?H:#$d_signbit HAS_SIGNBIT /**/ ?H:. ?F:!try ?LINT:set d_signbit : see if signbit exists $echo $n "Checking to see if you have signbit() available to work on $nvtype... $c" >&4 $cat >try.c < #endif #ifdef I_SUNMATH /* Solaris special math library */ # include #endif #define NV $nvtype int main(int argc, char **argv) { NV x = 0.0; NV y = -1.0; if ((signbit(x) == 0) && (signbit(y) != 0)) return 0; else return 1; } EOCP val="$undef" set try if eval $compile; then if $run ./try; then $echo "Yes." >&4 val="$define" else $echo "Signbit seems to be available, but doesn't work as I expected." $echo "I won't use it." >&4 val="$undef" fi else $echo "Nope." >&4 dflt="$undef" fi set d_signbit eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_sigprocmask.U000066400000000000000000000016721316016665300222370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sigprocmask: Inlibc ?MAKE: -pick add $@ %< ?S:d_sigprocmask: ?S: This variable conditionally defines HAS_SIGPROCMASK ?S: if sigprocmask() is available to examine or change the signal mask ?S: of the calling process. ?S:. ?C:HAS_SIGPROCMASK: ?C: This symbol, if defined, indicates that the sigprocmask ?C: system call is available to examine or change the signal mask ?C: of the calling process. ?C:. ?H:#$d_sigprocmask HAS_SIGPROCMASK /**/ ?H:. ?LINT:set d_sigprocmask : see if sigprocmask exists set sigprocmask d_sigprocmask eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sigqueue.U000066400000000000000000000015461316016665300215440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sigqueue: Inlibc ?MAKE: -pick add $@ %< ?S:d_sigqueue: ?S: This variable conditionally defines HAS_SIGQUEUE ?S: if sigqueue() is available to queue a signal and data to a process. ?S:. ?C:HAS_SIGQUEUE: ?C: This symbol, if defined, indicates that the sigqueue ?C: system call is available to queue a signal and data to a process. ?C:. ?H:#$d_sigqueue HAS_SIGQUEUE /**/ ?H:. ?LINT:set d_sigqueue : see if sigqueue exists set sigqueue d_sigqueue eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sigtimedwait.U000066400000000000000000000017061316016665300224050ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sigtimedwait: Inlibc ?MAKE: -pick add $@ %< ?S:d_sigtimedwait: ?S: This variable conditionally defines HAS_SIGTIMEDWAIT ?S: if sigtimedwait() is available to wait a signal and additional ?S: information, with a timeout. ?S:. ?C:HAS_SIGTIMEDWAIT: ?C: This symbol, if defined, indicates that the sigtimedwait ?C: system call is available to wait a signal and additional information, ?C: with a timeout. ?C:. ?H:#$d_sigtimedwait HAS_SIGTIMEDWAIT /**/ ?H:. ?LINT:set d_sigtimedwait : see if sigtimedwait exists set sigtimedwait d_sigtimedwait eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sigwait.U000066400000000000000000000014541316016665300213620ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sigwait: Inlibc ?MAKE: -pick add $@ %< ?S:d_sigwait: ?S: This variable conditionally defines HAS_SIGWAIT ?S: if sigwait() is available to wait a signal. ?S:. ?C:HAS_SIGWAIT: ?C: This symbol, if defined, indicates that the sigwait ?C: system call is available to wait a signal. ?C:. ?H:#$d_sigwait HAS_SIGWAIT /**/ ?H:. ?LINT:set d_sigwait : see if sigwait exists set sigwait d_sigwait eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sigwaitinfo.U000066400000000000000000000016261316016665300222370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sigwaitinfo: Inlibc ?MAKE: -pick add $@ %< ?S:d_sigwaitinfo: ?S: This variable conditionally defines HAS_SIGWAITINFO ?S: if sigwaitinfo() is available to wait a signal and additional ?S: information. ?S:. ?C:HAS_SIGWAITINFO: ?C: This symbol, if defined, indicates that the sigwaitinfo ?C: system call is available to wait a signal and additional information. ?C:. ?H:#$d_sigwaitinfo HAS_SIGWAITINFO /**/ ?H:. ?LINT:set d_sigwaitinfo : see if sigwaitinfo exists set sigwaitinfo d_sigwaitinfo eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sitecustomize.U000066400000000000000000000017751316016665300226300ustar00rootroot00000000000000?RCS: $Id: d_sitecustomize.U,v $ ?RCS: ?RCS: Copyright (c) 2005-2006 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_sitecustomize.U,v $ ?RCS: ?MAKE:usesitecustomize: Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:usesitecustomize: ?S: This variable is set to true when the user requires a mechanism that ?S: allows the sysadmin to add entries to @INC at runtime. This variable ?S: being set, makes perl run '$sitelib/sitecustomize.pl' at startup. ?S:. ?C:USE_SITECUSTOMIZE: ?C: This symbol, if defined, indicates that sitecustomize should ?C: be used. ?C:. ?H:?%<:@if USE_SITECUSTOMIZE ?H:?%<:#ifndef USE_SITECUSTOMIZE ?H:?%<:#$usesitecustomize USE_SITECUSTOMIZE /**/ ?H:?%<:#endif ?H:?%<:@end ?H:. : Check if site customization support was requested case "$usesitecustomize" in $define|true|[Yy]*) usesitecustomize="$define" ;; *) usesitecustomize="$undef" ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_snprintf.U000066400000000000000000000051221316016665300215520ustar00rootroot00000000000000?RCS: Copyright (c) 2006-2007, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_snprintf d_vsnprintf : Inlibc Compile cat run rm_try ?MAKE: -pick add $@ %< ?S:d_snprintf: ?S: This variable conditionally defines the HAS_SNPRINTF symbol, which ?S: indicates to the C program that the snprintf () library function ?S: is available. ?S:. ?S:d_vsnprintf: ?S: This variable conditionally defines the HAS_VSNPRINTF symbol, which ?S: indicates to the C program that the vsnprintf () library function ?S: is available. ?S:. ?C:HAS_SNPRINTF: ?C: This symbol, if defined, indicates that the snprintf () library ?C: function is available for use. ?C:. ?C:HAS_VSNPRINTF: ?C: This symbol, if defined, indicates that the vsnprintf () library ?C: function is available for use. ?C:. ?H:#$d_snprintf HAS_SNPRINTF /**/ ?H:#$d_vsnprintf HAS_VSNPRINTF /**/ ?H:. ?F:!try : see if snprintf exists set snprintf d_snprintf eval $inlibc : see if vsnprintf exists set vsnprintf d_vsnprintf eval $inlibc case "$d_snprintf-$d_vsnprintf" in "$define-$define") $cat <try.c <<'EOCP' /* v?snprintf testing logic courtesy of Russ Allbery. * According to C99: * - if the buffer is too short it still must be \0-terminated * - if the buffer is too short the potentially required length * must be returned and not -1 * - if the buffer is NULL the potentially required length * must be returned and not -1 or core dump */ #include #include char buf[2]; int test (char *format, ...) { va_list args; int count; va_start (args, format); count = vsnprintf (buf, sizeof buf, format, args); va_end (args); return count; } int main () { return ((test ("%s", "abcd") == 4 && buf[0] == 'a' && buf[1] == '\0' && snprintf (NULL, 0, "%s", "abcd") == 4) ? 0 : 1); } EOCP set try if eval $compile; then `$run ./try` case "$?" in 0) echo "Your snprintf() and vsnprintf() seem to be working okay." ;; *) cat <&4 Your snprintf() and snprintf() don't seem to be working okay. EOM d_snprintf="$undef" d_vsnprintf="$undef" ;; esac else echo "(I can't seem to compile the test program--assuming they don't)" d_snprintf="$undef" d_vsnprintf="$undef" fi $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_sockatmark.U000066400000000000000000000013371316016665300220520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_sockatmark: Inlibc ?MAKE: -pick add $@ %< ?S:d_sockatmark: ?S: This variable conditionally defines the HAS_SOCKATMARK symbol, which ?S: indicates to the C program that the sockatmark() routine is available. ?S:. ?C:HAS_SOCKATMARK: ?C: This symbol, if defined, indicates that the sockatmark routine is ?C: available to test whether a socket is at the out-of-band mark. ?C:. ?H:#$d_sockatmark HAS_SOCKATMARK /**/ ?H:. ?LINT:set d_sockatmark : see if sockatmark exists set sockatmark d_sockatmark eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sockatmarkproto.U000066400000000000000000000022451316016665300231350ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sockatmarkproto: Hasproto d_socket ?MAKE: -pick add $@ %< ?S:d_sockatmarkproto: ?S: This variable conditionally defines the HAS_SOCKATMARK_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the sockatmark() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_SOCKATMARK_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the sockatmark() function. Otherwise, it is up ?C: to the program to supply one. A good guess is ?C: extern int sockatmark(int); ?C:. ?H:#$d_sockatmarkproto HAS_SOCKATMARK_PROTO /**/ ?H:. ?LINT:set d_sockatmarkproto : see if prototype for sockatmark is available echo " " set d_sockatmarkproto sockatmark $d_socket sys/socket.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_socklen_t.U000066400000000000000000000025071316016665300216740ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_socklen_t: Inhdr cat rm_try Setvar Compile d_socket sizetype ?MAKE: -pick add $@ %< ?S:d_socklen_t: ?S: This symbol will be defined if the C compiler supports socklen_t. ?S:. ?C:HAS_SOCKLEN_T: ?C: This symbol will defined if the C compiler supports socklen_t. ?C: Usually the needs to be included. ?C:. ?H:#$d_socklen_t HAS_SOCKLEN_T /**/ ?H:. ?LINT:set d_socklen_t : check for socklen_t echo " " echo "Checking to see if you have socklen_t..." >&4 $cat >try.c < #$d_socket HAS_SOCKET #ifdef HAS_SOCKET #include #endif int main() { socklen_t x = 16; } EOCP set try if eval $compile; then val="$define" echo "You have socklen_t." else val="$undef" echo "You do not have socklen_t." case "$sizetype" in size_t) echo "(You do have size_t, that might work. Some people are happy with just an int.)" ;; esac fi $rm_try set d_socklen_t eval $setvar metaconfig-debian-perl-5.26.1/U/perl/d_socks5_init.U000066400000000000000000000013151316016665300221410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_socks5_init: Inlibc ?MAKE: -pick add $@ %< ?S:d_socks5_init: ?S: This variable conditionally defines the HAS_SOCKS5_INIT symbol, which ?S: indicates to the C program that the socks5_init() routine is available. ?S:. ?C:HAS_SOCKS5_INIT: ?C: This symbol, if defined, indicates that the socks5_init routine is ?C: available to initialize SOCKS 5. ?C:. ?H:#$d_socks5_init HAS_SOCKS5_INIT /**/ ?H:. ?LINT:set d_socks5_init : see if socks5_init exists set socks5_init d_socks5_init eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sprintf_len.U000066400000000000000000000044071316016665300222370ustar00rootroot00000000000000?RCS: Copyright (c) 2005-2008 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_sprintf_returns_strlen: Compile cat rm_try run i_stdlib i_string i_math echo ?MAKE: -pick add $@ %< ?S:d_sprintf_returns_strlen: ?S: This variable defines whether sprintf returns the length of the string ?S: (as per the ANSI spec). Some C libraries retain compatibility with ?S: pre-ANSI C and return a pointer to the passed in buffer; for these ?S: this variable will be undef. ?S:. ?C:SPRINTF_RETURNS_STRLEN: ?C: This variable defines whether sprintf returns the length of the string ?C: (as per the ANSI spec). Some C libraries retain compatibility with ?C: pre-ANSI C and return a pointer to the passed in buffer; for these ?C: this variable will be undef. ?C:. ?H:#$d_sprintf_returns_strlen SPRINTF_RETURNS_STRLEN /**/ ?H:. ?T:xxx ?F:!try : see if sprintf returns the length of the string in the buffer as per ANSI $echo "Checking whether sprintf returns the length of the string..." >&4 $cat <try.c #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_string I_STRING #ifdef I_STRING # include #else # include #endif #$i_math I_MATH #ifdef I_MATH #include #endif char buffer[256]; int check (size_t expect, int test) { size_t got = strlen(buffer); if (expect == got) return 0; printf("expected %ld, got %ld in test %d '%s'\n", (long) expect, (long) got, test, buffer); exit (test); } int main(int argc, char **argv) { int test = 0; check(sprintf(buffer, ""), ++test); check(sprintf(buffer, "%s %s", "perl", "rules"), ++test); check(sprintf(buffer, "I like %g", atan2(0,-1)), ++test); return 0; } EOP set try if eval $compile; then xxx="`$run ./try`" case "$?" in 0) cat >&4 <&4 <&4 d_sprintf_returns_strlen="$undef" fi $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_sqrtl.U000066400000000000000000000012161316016665300210540ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_sqrtl: Inlibc ?MAKE: -pick add $@ %< ?S:d_sqrtl: ?S: This variable conditionally defines the HAS_SQRTL symbol, which ?S: indicates to the C program that the sqrtl() routine is available. ?S:. ?C:HAS_SQRTL: ?C: This symbol, if defined, indicates that the sqrtl routine is ?C: available to do long double square roots. ?C:. ?H:#$d_sqrtl HAS_SQRTL /**/ ?H:. ?LINT:set d_sqrtl : see if sqrtl exists set sqrtl d_sqrtl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_sresgproto.U000066400000000000000000000022401316016665300221140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sresgproto: Hasproto i_unistd ?MAKE: -pick add $@ %< ?S:d_sresgproto: ?S: This variable conditionally defines the HAS_SETRESGID_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the setresgid() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_SETRESGID_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the setresgid() function. Otherwise, it is up ?C: to the program to supply one. Good guesses are ?C: extern int setresgid(uid_t ruid, uid_t euid, uid_t suid); ?C:. ?H:#$d_sresgproto HAS_SETRESGID_PROTO /**/ ?H:. ?LINT:set d_sresgproto : see if prototype for setresgid is available echo " " set d_sresgproto setresgid $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_sresuproto.U000066400000000000000000000022401316016665300221320ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_sresuproto: Hasproto i_unistd ?MAKE: -pick add $@ %< ?S:d_sresuproto: ?S: This variable conditionally defines the HAS_SETRESUID_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the setresuid() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_SETRESUID_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the setresuid() function. Otherwise, it is up ?C: to the program to supply one. Good guesses are ?C: extern int setresuid(uid_t ruid, uid_t euid, uid_t suid); ?C:. ?H:#$d_sresuproto HAS_SETRESUID_PROTO /**/ ?H:. ?LINT:set d_sresuproto : see if prototype for setresuid is available echo " " set d_sresuproto setresuid $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_statfs.U000066400000000000000000000012341316016665300212130ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_statfs: Inlibc ?MAKE: -pick add $@ %< ?S:d_statfs: ?S: This variable conditionally defines the HAS_STATFS symbol, which ?S: indicates to the C program that the statfs() routine is available. ?S:. ?C:HAS_STATFS: ?C: This symbol, if defined, indicates that the statfs routine is ?C: available to stat filesystems by filenames. ?C:. ?H:#$d_statfs HAS_STATFS /**/ ?H:. ?LINT:set d_statfs : see if statfs exists set statfs d_statfs eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_statfs3.U000066400000000000000000000031101316016665300212710ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_statfs3: \ d_statfs Compile rm_try cat i_sysparam i_sysmount i_systypes \ i_sysvfs i_sysstatfs Setvar ?MAKE: -pick add $@ %< ?S:d_statfs3: ?S: This variable conditionally defines the HAS_STATFS symbol, which ?S: indicates to the C program that the statfs() has four arguments. ?S:. ?C:HAS_STATFS3: ?C: This symbol, if defined, indicates that the statfs routine ?C: has four arguments, not two. ?C:. ?H:#$d_statfs3 HAS_STATFS3 /**/ ?H:. ?LINT:set d_statfs3 : Check for statfs3 case "$d_statfs" in define) $cat >try.h < #endif #ifdef HAS_SYS_PARAM # include #endif #ifdef HAS_SYS_MOUNT # include #endif #ifdef HAS_SYS_VFS # include #endif #ifdef HAS_SYS_STATFS # include #endif EOCP echo "Checking to see if your statfs can handle three arguments..." >&4 $cat >try.c <try.h < #endif #ifdef HAS_SYS_PARAM # include #endif #ifdef HAS_SYS_MOUNT # include #endif #ifdef HAS_SYS_VFS # include #endif #ifdef HAS_SYS_STATFS # include #endif EOCP echo "Checking to see if your statfs can handle four arguments..." >&4 $cat >try.c < (BSD 4.3), ?C: not from (SYSV). Older BSDs (like Ultrix) do not ?C: have statfs() and struct statfs, they have ustat() and getmnt() ?C: with struct ustat and struct fs_data. ?C:. ?H:#$d_statfs_f_flags HAS_STRUCT_STATFS_F_FLAGS /**/ ?H:. ?LINT:set d_statfs_f_flags : see if struct statfs knows about f_flags case "$d_statfs_s" in define) echo " " echo "Checking to see if your struct statfs has f_flags field..." >&4 set d_statfs_f_flags statfs f_flags $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h $i_sysvfs sys/vfs.h $i_sysstatfs sys/statfs.h eval $hasfield ;; *) val="$undef" set d_statfs_f_flags eval $setvar ;; esac case "$d_statfs_f_flags" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_statfs_s.U000066400000000000000000000020151316016665300215330ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_statfs_s: \ Hasstruct i_sysparam i_sysmount i_systypes \ i_sysvfs i_sysstatfs Setvar ?MAKE: -pick add $@ %< ?S:d_statfs_s: ?S: This variable conditionally defines the HAS_STRUCT_STATFS symbol, ?S: which indicates that the struct statfs is supported. ?S:. ?C:HAS_STRUCT_STATFS: ?C: This symbol, if defined, indicates that the struct statfs ?C: to do statfs() is supported. ?C:. ?H:#$d_statfs_s HAS_STRUCT_STATFS /**/ ?H:. ?LINT:set d_statfs_s : Check for statfs_s echo " " echo "Checking to see if your system supports struct statfs..." >&4 set d_statfs_s statfs $i_systypes sys/types.h $i_sysparam sys/param.h $i_sysmount sys/mount.h $i_sysvfs sys/vfs.h $i_sysstatfs sys/statfs.h eval $hasstruct case "$d_statfs_s" in "$define") echo "Yes, it does." ;; *) echo "No, it doesn't." ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_statvfs.U000066400000000000000000000021401316016665300213760ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_statvfs d_fstatvfs: Inlibc ?MAKE: -pick add $@ %< ?S:d_statvfs: ?S: This variable conditionally defines the HAS_STATVFS symbol, which ?S: indicates to the C program that the statvfs() routine is available. ?S:. ?S:d_fstatvfs: ?S: This variable conditionally defines the HAS_FSTATVFS symbol, which ?S: indicates to the C program that the fstatvfs() routine is available. ?S:. ?C:HAS_STATVFS: ?C: This symbol, if defined, indicates that the statvfs routine is ?C: available to stat filesystems by filenames. ?C:. ?C:HAS_FSTATVFS: ?C: This symbol, if defined, indicates that the fstatvfs routine is ?C: available to stat filesystems by file descriptors. ?C:. ?H:#$d_statvfs HAS_STATVFS /**/ ?H:#$d_fstatvfs HAS_FSTATVFS /**/ ?H:. ?LINT:set d_statvfs ?LINT:set d_fstatvfs : see if statvfs exists set statvfs d_statvfs eval $inlibc : see if fstatvfs exists set fstatvfs d_fstatvfs eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strerror_l.U000066400000000000000000000015171316016665300221100ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strerror_l: Inlibc ?MAKE: -pick add $@ %< ?S:d_strerror_l: ?S: This variable conditionally defines the HAS_STRERROR_L symbol, which ?S: indicates to the C program that the strerror_l() routine is available ?S: to return the error message for a given errno value in a particular ?S: locale (identified by a locale_t object). ?S:. ?C:HAS_STRERROR_L: ?C: This symbol, if defined, indicates that the strerror_l routine is ?C: available to return the error message for a given errno value in ?C: a particular locale (identified by a locale_t object). ?C:. ?H:#$d_strerror_l HAS_STRERROR_L /**/ ?H:. ?LINT:set d_strerror_l : see if strerror_l exists set strerror_l d_strerror_l eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strftime.U000066400000000000000000000012511316016665300215430ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strftime: Inlibc ?MAKE: -pick add $@ %< ?S:d_strftime: ?S: This variable conditionally defines the HAS_STRFTIME symbol, which ?S: indicates to the C program that the strftime() routine is available. ?S:. ?C:HAS_STRFTIME: ?C: This symbol, if defined, indicates that the strftime routine is ?C: available to do time formatting. ?C:. ?H:#$d_strftime HAS_STRFTIME /**/ ?H:. ?LINT:set d_strftime : see if strftime exists set strftime d_strftime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strlcat.U000066400000000000000000000012431316016665300213630ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2004 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strlcat: Inlibc ?MAKE: -pick add $@ %< ?S:d_strlcat: ?S: This variable conditionally defines the HAS_STRLCAT symbol, which ?S: indicates to the C program that the strlcat () routine is available. ?S:. ?C:HAS_STRLCAT: ?C: This symbol, if defined, indicates that the strlcat () routine is ?C: available to do string concatenation. ?C:. ?H:#$d_strlcat HAS_STRLCAT /**/ ?H:. ?LINT:set d_strlcat : see if strlcat exists set strlcat d_strlcat eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strlcpy.U000066400000000000000000000012351316016665300214100ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2004 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strlcpy: Inlibc ?MAKE: -pick add $@ %< ?S:d_strlcpy: ?S: This variable conditionally defines the HAS_STRLCPY symbol, which ?S: indicates to the C program that the strlcpy () routine is available. ?S:. ?C:HAS_STRLCPY: ?C: This symbol, if defined, indicates that the strlcpy () routine is ?C: available to do string copying. ?C:. ?H:#$d_strlcpy HAS_STRLCPY /**/ ?H:. ?LINT:set d_strlcpy : see if strlcpy exists set strlcpy d_strlcpy eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strptime.U000066400000000000000000000012241316016665300215550ustar00rootroot00000000000000?RCS: Copyright (c) 2012 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strptime: Inlibc ?MAKE: -pick add $@ %< ?S:d_strptime: ?S: This variable conditionally defines the HAS_STRPTIME symbol, which ?S: indicates to the C program that the strptime() routine is available. ?S:. ?C:HAS_STRPTIME: ?C: This symbol, if defined, indicates that the strptime routine is ?C: available to set process title. ?C:. ?H:#$d_strptime HAS_STRPTIME /**/ ?H:. ?LINT:set d_strptime : see if strptime exists set strptime d_strptime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strtold.U000066400000000000000000000012521316016665300214020ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strtold: Inlibc ?MAKE: -pick add $@ %< ?S:d_strtold: ?S: This variable conditionally defines the HAS_STRTOLD symbol, which ?S: indicates to the C program that the strtold() routine is available. ?S:. ?C:HAS_STRTOLD: ?C: This symbol, if defined, indicates that the strtold routine is ?C: available to convert strings to long doubles. ?C:. ?H:#$d_strtold HAS_STRTOLD /**/ ?H:. ?LINT:set d_strtold : see if strtold exists set strtold d_strtold eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strtoll.U000066400000000000000000000041251316016665300214140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strtoll: Inlibc d_longlong Compile cat run ?MAKE: -pick add $@ %< ?S:d_strtoll: ?S: This variable conditionally defines the HAS_STRTOLL symbol, which ?S: indicates to the C program that the strtoll() routine is available. ?S:. ?C:HAS_STRTOLL: ?C: This symbol, if defined, indicates that the strtoll routine is ?C: available to convert strings to long longs. ?C:. ?H:#$d_strtoll HAS_STRTOLL /**/ ?H:. ?T:yyy ?F:!try : see if strtoll exists set strtoll d_strtoll eval $inlibc case "$d_longlong-$d_strtoll" in "$define-$define") $cat <try.c <<'EOCP' #include #ifdef __hpux #define strtoll __strtoll #endif #ifdef __EMX__ #define strtoll _strtoll #endif #include extern long long int strtoll(char *s, char **, int); static int bad = 0; int check(char *s, long long ell, int een) { long long gll; errno = 0; gll = strtoll(s, 0, 10); if (!((gll == ell) && (errno == een))) bad++; } int main() { check(" 1", 1LL, 0); check(" 0", 0LL, 0); check("-1", -1LL, 0); check("-9223372036854775808", -9223372036854775808LL, 0); check("-9223372036854775808", -9223372036854775808LL, 0); check(" 9223372036854775807", 9223372036854775807LL, 0); check("-9223372036854775808", -9223372036854775808LL, 0); check(" 9223372036854775808", 9223372036854775807LL, ERANGE); check("-9223372036854775809", -9223372036854775808LL, ERANGE); if (!bad) printf("ok\n"); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in ok) echo "Your strtoll() seems to be working okay." ;; *) cat <&4 Your strtoll() doesn't seem to be working okay. EOM d_strtoll="$undef" ;; esac else echo "(I can't seem to compile the test program--assuming it doesn't)" d_strtoll="$undef" fi ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_strtoq.U000066400000000000000000000012441316016665300212440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strtoq: Inlibc ?MAKE: -pick add $@ %< ?S:d_strtoq: ?S: This variable conditionally defines the HAS_STRTOQ symbol, which ?S: indicates to the C program that the strtoq() routine is available. ?S:. ?C:HAS_STRTOQ: ?C: This symbol, if defined, indicates that the strtoq routine is ?C: available to convert strings to long longs (quads). ?C:. ?H:#$d_strtoq HAS_STRTOQ /**/ ?H:. ?LINT:set d_strtoq : see if strtoq exists set strtoq d_strtoq eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_strtoull.U000066400000000000000000000042331316016665300216010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strtoull: Inlibc d_longlong Compile cat run ?MAKE: -pick add $@ %< ?S:d_strtoull: ?S: This variable conditionally defines the HAS_STRTOULL symbol, which ?S: indicates to the C program that the strtoull() routine is available. ?S:. ?C:HAS_STRTOULL: ?C: This symbol, if defined, indicates that the strtoull routine is ?C: available to convert strings to unsigned long longs. ?C:. ?H:#$d_strtoull HAS_STRTOULL /**/ ?H:. ?F:!try : see if strtoull exists set strtoull d_strtoull eval $inlibc case "$d_longlong-$d_strtoull" in "$define-$define") $cat <try.c <<'EOCP' #include #ifdef __hpux #define strtoull __strtoull #endif #include extern unsigned long long int strtoull(char *s, char **, int); static int bad = 0; int check(char *s, long long eull, int een) { long long gull; errno = 0; gull = strtoull(s, 0, 10); if (!((gull == eull) && (errno == een))) bad++; } int main() { check(" 1", 1LL, 0); check(" 0", 0LL, 0); check("18446744073709551615", 18446744073709551615ULL, 0); check("18446744073709551616", 18446744073709551615ULL, ERANGE); #if 0 /* strtoull() for /^-/ strings is undefined. */ check("-1", 18446744073709551615ULL, 0); check("-18446744073709551614", 2LL, 0); check("-18446744073709551615", 1LL, 0); check("-18446744073709551616", 18446744073709551615ULL, ERANGE); check("-18446744073709551617", 18446744073709551615ULL, ERANGE); #endif if (!bad) printf("ok\n"); } EOCP set try if eval $compile; then case "`$run ./try`" in ok) echo "Your strtoull() seems to be working okay." ;; *) cat <&4 Your strtoull() doesn't seem to be working okay. EOM d_strtoull="$undef" ;; esac else echo "(I can't seem to compile the test program--assuming it doesn't)" d_strtoull="$undef" fi ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_strtouq.U000066400000000000000000000041351316016665300214330ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_strtouq: Inlibc cat Compile run ?MAKE: -pick add $@ %< ?S:d_strtouq: ?S: This variable conditionally defines the HAS_STRTOUQ symbol, which ?S: indicates to the C program that the strtouq() routine is available. ?S:. ?C:HAS_STRTOUQ: ?C: This symbol, if defined, indicates that the strtouq routine is ?C: available to convert strings to unsigned long longs (quads). ?C:. ?H:#$d_strtouq HAS_STRTOUQ /**/ ?H:. ?F:!try : see if strtouq exists set strtouq d_strtouq eval $inlibc case "$d_strtouq" in "$define") $cat <try.c <<'EOCP' #include #include extern unsigned long long int strtouq(char *s, char **, int); static int bad = 0; void check(char *s, unsigned long long eull, int een) { unsigned long long gull; errno = 0; gull = strtouq(s, 0, 10); if (!((gull == eull) && (errno == een))) bad++; } int main() { check(" 1", 1LL, 0); check(" 0", 0LL, 0); check("18446744073709551615", 18446744073709551615ULL, 0); check("18446744073709551616", 18446744073709551615ULL, ERANGE); #if 0 /* strtouq() for /^-/ strings is undefined. */ check("-1", 18446744073709551615ULL, 0); check("-18446744073709551614", 2LL, 0); check("-18446744073709551615", 1LL, 0); check("-18446744073709551616", 18446744073709551615ULL, ERANGE); check("-18446744073709551617", 18446744073709551615ULL, ERANGE); #endif if (!bad) printf("ok\n"); return 0; } EOCP set try if eval $compile; then case "`$run ./try`" in ok) echo "Your strtouq() seems to be working okay." ;; *) cat <&4 Your strtouq() doesn't seem to be working okay. EOM d_strtouq="$undef" ;; esac else echo "(I can't seem to compile the test program--assuming it doesn't)" d_strtouq="$undef" fi ;; esac metaconfig-debian-perl-5.26.1/U/perl/d_syscallproto.U000066400000000000000000000022451316016665300224500ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_syscallproto: Hasproto i_unistd ?MAKE: -pick add $@ %< ?S:d_syscallproto: ?S: This variable conditionally defines the HAS_SYSCALL_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the syscall() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_SYSCALL_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the syscall() function. Otherwise, it is up ?C: to the program to supply one. Good guesses are ?C: extern int syscall(int, ...); ?C: extern int syscall(long, ...); ?C:. ?H:#$d_syscallproto HAS_SYSCALL_PROTO /**/ ?H:. ?LINT:set d_syscallproto : see if prototype for syscall is available echo " " set d_syscallproto syscall $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_telldirproto.U000066400000000000000000000022371316016665300224360ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_telldirproto: Hasproto i_systypes i_dirent ?MAKE: -pick add $@ %< ?S:d_telldirproto: ?S: This variable conditionally defines the HAS_TELLDIR_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the telldir() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_TELLDIR_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the telldir() function. Otherwise, it is up ?C: to the program to supply one. A good guess is ?C: extern long telldir(DIR*); ?C:. ?H:#$d_telldirproto HAS_TELLDIR_PROTO /**/ ?H:. ?LINT:set d_telldirproto : see if prototype for telldir is available echo " " set d_telldirproto telldir $i_systypes sys/types.h $i_dirent dirent.h eval $hasproto metaconfig-debian-perl-5.26.1/U/perl/d_tgamma.U000066400000000000000000000012261316016665300211560ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_tgamma: Inlibc ?MAKE: -pick add $@ %< ?S:d_tgamma: ?S: This variable conditionally defines the HAS_TGAMMA symbol, which ?S: indicates to the C program that the tgamma() routine is available ?S: for the gamma function. See also d_lgamma. ?S:. ?C:HAS_TGAMMA: ?C: This symbol, if defined, indicates that the tgamma routine is ?C: available to do the gamma function. See also HAS_LGAMMA. ?C:. ?H:#$d_tgamma HAS_TGAMMA /**/ ?H:. ?LINT:set d_tgamma : see if tgamma exists set tgamma d_tgamma eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timefuncs64.U000066400000000000000000000053451316016665300220650ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2008 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_ctime64 d_localtime64 d_gmtime64 d_mktime64 d_difftime64 d_asctime64: Inlibc ?MAKE: -pick add $@ %< ?S:d_ctime64: ?S: This variable conditionally defines the HAS_CTIME64 symbol, which ?S: indicates to the C program that the ctime64 () routine is available. ?S:. ?S:d_localtime64: ?S: This variable conditionally defines the HAS_LOCALTIME64 symbol, which ?S: indicates to the C program that the localtime64 () routine is available. ?S:. ?S:d_gmtime64: ?S: This variable conditionally defines the HAS_GMTIME64 symbol, which ?S: indicates to the C program that the gmtime64 () routine is available. ?S:. ?S:d_mktime64: ?S: This variable conditionally defines the HAS_MKTIME64 symbol, which ?S: indicates to the C program that the mktime64 () routine is available. ?S:. ?S:d_difftime64: ?S: This variable conditionally defines the HAS_DIFFTIME64 symbol, which ?S: indicates to the C program that the difftime64 () routine is available. ?S:. ?S:d_asctime64: ?S: This variable conditionally defines the HAS_ASCTIME64 symbol, which ?S: indicates to the C program that the asctime64 () routine is available. ?S:. ?C:HAS_CTIME64: ?C: This symbol, if defined, indicates that the ctime64 () routine is ?C: available to do the 64bit variant of ctime () ?C:. ?C:HAS_LOCALTIME64: ?C: This symbol, if defined, indicates that the localtime64 () routine is ?C: available to do the 64bit variant of localtime () ?C:. ?C:HAS_GMTIME64: ?C: This symbol, if defined, indicates that the gmtime64 () routine is ?C: available to do the 64bit variant of gmtime () ?C:. ?C:HAS_MKTIME64: ?C: This symbol, if defined, indicates that the mktime64 () routine is ?C: available to do the 64bit variant of mktime () ?C:. ?C:HAS_DIFFTIME64: ?C: This symbol, if defined, indicates that the difftime64 () routine is ?C: available to do the 64bit variant of difftime () ?C:. ?C:HAS_ASCTIME64: ?C: This symbol, if defined, indicates that the asctime64 () routine is ?C: available to do the 64bit variant of asctime () ?C:. ?H:#$d_ctime64 HAS_CTIME64 /**/ ?H:#$d_localtime64 HAS_LOCALTIME64 /**/ ?H:#$d_gmtime64 HAS_GMTIME64 /**/ ?H:#$d_mktime64 HAS_MKTIME64 /**/ ?H:#$d_difftime64 HAS_DIFFTIME64 /**/ ?H:#$d_asctime64 HAS_ASCTIME64 /**/ ?H:. ?LINT:set d_ctime64 d_localtime64 d_gmtime64 d_mktime64 d_difftime64 d_asctime64 : see if 64bit time functions exists set ctime64 d_ctime64 eval $inlibc set localtime64 d_localtime64 eval $inlibc set gmtime64 d_gmtime64 eval $inlibc set mktime64 d_mktime64 eval $inlibc set difftime64 d_difftime64 eval $inlibc set asctime64 d_asctime64 eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timegm.U000066400000000000000000000012301316016665300211650ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2008 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_timegm: Inlibc ?MAKE: -pick add $@ %< ?S:d_timegm: ?S: This variable conditionally defines the HAS_TIMEGM symbol, which ?S: indicates to the C program that the timegm () routine is available. ?S:. ?C:HAS_TIMEGM: ?C: This symbol, if defined, indicates that the timegm routine is ?C: available to do the opposite of gmtime () ?C:. ?H:#$d_timegm HAS_TIMEGM /**/ ?H:. ?LINT:set d_timegm : see if timegm exists set timegm d_timegm eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timer_create.U000066400000000000000000000015661316016665300223620ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_timer_create: Inlibc ?MAKE: -pick add $@ %< ?S:d_timer_create: ?S: This variable conditionally defines HAS_TIMER_CREATE if timer_create() ?S: is available to create a POSIX timer. ?S:. ?C:HAS_TIMER_CREATE: ?C: This symbol, if defined, indicates that the timer_create system call is ?C: available to create a POSIX timer. ?C:. ?H:#$d_timer_create HAS_TIMER_CREATE /**/ ?H:. ?LINT:set d_timer_create : see if timer_create exists set timer_create d_timer_create eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timer_delete.U000066400000000000000000000015661316016665300223610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_timer_delete: Inlibc ?MAKE: -pick add $@ %< ?S:d_timer_delete: ?S: This variable conditionally defines HAS_TIMER_DELETE if timer_delete() ?S: is available to delete a POSIX timer. ?S:. ?C:HAS_TIMER_DELETE: ?C: This symbol, if defined, indicates that the timer_delete system call is ?C: available to delete a POSIX timer. ?C:. ?H:#$d_timer_delete HAS_TIMER_DELETE /**/ ?H:. ?LINT:set d_timer_delete : see if timer_delete exists set timer_delete d_timer_delete eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timer_getoverrun.U000066400000000000000000000017341316016665300233140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_timer_getoverrun: Inlibc ?MAKE: -pick add $@ %< ?S:d_timer_getoverrun: ?S: This variable conditionally defines HAS_TIMER_GETOVERRUN ?S: if timer_getoverrun() is available to get the number of ?S: overruns of a POSIX timer. ?S:. ?C:HAS_TIMER_GETOVERRUN: ?C: This symbol, if defined, indicates that the timer_getoverrun ?C: system call is available to get the number of overruns of ?C: a POSIX timer. ?C:. ?H:#$d_timer_getoverrun HAS_TIMER_GETOVERRUN /**/ ?H:. ?LINT:set d_timer_getoverrun : see if timer_getoverrun exists set timer_getoverrun d_timer_getoverrun eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timer_gettime.U000066400000000000000000000016241316016665300225500ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_timer_gettime: Inlibc ?MAKE: -pick add $@ %< ?S:d_timer_gettime: ?S: This variable conditionally defines HAS_TIMER_GETTIME ?S: if timer_gettime() is available to get the time of a POSIX timer. ?S:. ?C:HAS_TIMER_GETTIME: ?C: This symbol, if defined, indicates that the timer_gettime ?C: system call is available to get the time of a POSIX timer. ?C:. ?H:#$d_timer_gettime HAS_TIMER_GETTIME /**/ ?H:. ?LINT:set d_timer_gettime : see if timer_gettime exists set timer_gettime d_timer_gettime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_timer_settime.U000066400000000000000000000016241316016665300225640ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_timer_settime: Inlibc ?MAKE: -pick add $@ %< ?S:d_timer_settime: ?S: This variable conditionally defines HAS_TIMER_SETTIME ?S: if timer_settime() is available to set the time of a POSIX timer. ?S:. ?C:HAS_TIMER_SETTIME: ?C: This symbol, if defined, indicates that the timer_settime ?C: system call is available to set the time of a POSIX timer. ?C:. ?H:#$d_timer_settime HAS_TIMER_SETTIME /**/ ?H:. ?LINT:set d_timer_settime : see if timer_settime exists set timer_settime d_timer_settime eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_trunc.U000066400000000000000000000011551316016665300210440ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_trunc: Inlibc ?MAKE: -pick add $@ %< ?S:d_trunc: ?S: This variable conditionally defines the HAS_TRUNC symbol, which ?S: indicates to the C program that the trunc() routine is available ?S: to round doubles towards zero. ?S:. ?C:HAS_TRUNC: ?C: This symbol, if defined, indicates that the trunc routine is ?C: available to round doubles towards zero. ?C:. ?H:#$d_trunc HAS_TRUNC /**/ ?H:. ?LINT:set d_trunc : see if trunc exists set trunc d_trunc eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_truncl.U000066400000000000000000000013141316016665300212150ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_truncl: Inlibc ?MAKE: -pick add $@ %< ?S:d_truncl: ?S: This variable conditionally defines the HAS_TRUNCL symbol, which ?S: indicates to the C program that the truncl() routine is available ?S: to round long doubles towards zero. If copysignl is also present, ?S: we can emulate modfl. ?S:. ?C:HAS_TRUNCL : ?C: This symbol, if defined, indicates that the truncl routine is ?C: available. If copysignl is also present we can emulate modfl. ?C:. ?H:#$d_truncl HAS_TRUNCL /**/ ?H:. ?LINT:set d_truncl : see if truncl exists set truncl d_truncl eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/d_u32align.U000066400000000000000000000053411316016665300213360ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_u32align: Compile cat rm_try Oldconfig run i_stdlib \ byteorder u32type Myread Setvar u8type signal_t ?MAKE: -pick add $@ %< ?S:d_u32align: ?S: This variable tells whether you must access character data ?S: through U32-aligned pointers. ?S:. ?C:U32_ALIGNMENT_REQUIRED: ?C: This symbol, if defined, indicates that you must access ?C: character data through U32-aligned pointers. ?C:. ?H:?%<:#ifndef U32_ALIGNMENT_REQUIRED ?H:?%<:#$d_u32align U32_ALIGNMENT_REQUIRED /**/ ?H:?%<:#endif ?H:. ?F:!try : Checking 32bit alignedness $cat <try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #define U32 $u32type #define BYTEORDER 0x$byteorder #define U8 $u8type #include #ifdef SIGBUS $signal_t bletch(int s) { exit(4); } #endif int main() { #if BYTEORDER == 0x1234 || BYTEORDER == 0x4321 volatile U8 buf[8]; volatile U32 *up; int i; if (sizeof(U32) != 4) { printf("sizeof(U32) is not 4, but %d\n", sizeof(U32)); exit(1); } fflush(stdout); #ifdef SIGBUS signal(SIGBUS, bletch); #endif buf[0] = 0; buf[1] = 0; buf[2] = 0; buf[3] = 1; buf[4] = 0; buf[5] = 0; buf[6] = 0; buf[7] = 1; for (i = 0; i < 4; i++) { up = (U32*)(buf + i); if (! ((*up == 1 << (8*i)) || /* big-endian */ (*up == 1 << (8*(3-i))) /* little-endian */ ) ) { printf("read failed (%x)\n", *up); exit(2); } } /* write test */ for (i = 0; i < 4; i++) { up = (U32*)(buf + i); *up = 0xBeef; if (*up != 0xBeef) { printf("write failed (%x)\n", *up); exit(3); } } exit(0); #else printf("1\n"); exit(1); #endif return 0; } EOCP set try if eval $compile_ok; then echo "(Testing for character data alignment may crash the test. That's okay.)" >&4 $run ./try 2>&1 >/dev/null case "$?" in 0) cat >&4 <&4 <try.c <<'EOCP' #include #include int main () { wchar_t *s = L" "; return (wcscmp (s, s) ? 1 : 0); } EOCP set try ?X: if $cc $ccflags $ldflags -o try try.c $libs >/dev/null 2>&1 ; then val="$undef" if eval $compile; then `$run ./try` case "$?" in 0) echo "A working wcscmp() found." >&4 val="$define" ;; *) echo "wcscmp() found, but it doesn't work" >&4 ;; esac else echo "wcscmp() NOT found." >&4 fi set d_wcscmp eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_wcsxfrm.U000066400000000000000000000026751316016665300214120ustar00rootroot00000000000000?RCS: Copyright (c) 2014-2014, Karl Williamson & H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_wcsxfrm: Compile cat rm_try run Oldconfig Setvar ?MAKE: -pick add $@ %< ?S:d_wcsxfrm: ?S: This variable conditionally defines the HAS_WCSXFRM symbol if the ?S: wcsxfrm() routine is available and can be used to compare wide ?S: character strings. ?S:. ?C:HAS_WCSXFRM: ?C: This symbol, if defined, indicates that the wcsxfrm routine is ?C: available to tranform a wide character string for wcscmp(). ?C:. ?H:#$d_wcsxfrm HAS_WCSXFRM /**/ ?H:. ?F:!try ?LINT: set d_wcsxfrm : look for wcsxfrm echo " " $cat >try.c <<'EOCP' #include #include int main () { wchar_t dst[4], *src = L" "; errno = 0; return (wcsxfrm (dst, src, 1) ? errno ? errno : 0 : 1); } EOCP set try ?X: if $cc $ccflags $ldflags -o try try.c $libs >/dev/null 2>&1 ; then val="$undef" if eval $compile; then `$run ./try` case "$?" in 0) echo "A working wcsxfrm() found." >&4 val="$define" ;; *) echo "wcsxfrm() found, but it doesn't work" >&4 ;; esac else echo "wcsxfrm() NOT found." >&4 fi set d_wcsxfrm eval $setvar $rm_try metaconfig-debian-perl-5.26.1/U/perl/d_writev.U000066400000000000000000000012211316016665300212230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the WRITEME file. ?RCS: ?MAKE:d_writev: Inlibc ?MAKE: -pick add $@ %< ?S:d_writev: ?S: This variable conditionally defines the HAS_WRITEV symbol, which ?S: indicates to the C program that the writev() routine is available. ?S:. ?C:HAS_WRITEV: ?C: This symbol, if defined, indicates that the writev routine is ?C: available to do scatter writes. ?C:. ?H:#$d_writev HAS_WRITEV /**/ ?H:. ?LINT:set d_writev : see if writev exists set writev d_writev eval $inlibc metaconfig-debian-perl-5.26.1/U/perl/dbm64.U000066400000000000000000000072141316016665300203240ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_dbminit64 d_dbmclose64 d_fetch64 d_store64 d_delete64 \ d_firstkey64 d_nextkey64: Inlibc use64bitint Setvar test ?MAKE: -pick add $@ %< ?S:d_dbminit64: ?S: This variable conditionally defines the HAS_DBMINIT64 symbol, which ?S: indicates to the C program that the dbminit64() routine is available. ?S:. ?S:d_dbmclose64: ?S: This variable conditionally defines the HAS_DBMCLOSE64 symbol, which ?S: indicates to the C program that the dbmclose64() routine is available. ?S:. ?S:d_fetch64: ?S: This variable conditionally defines the HAS_FETCH64 symbol, which ?S: indicates to the C program that the fetch64() routine is available. ?S:. ?S:d_delete64: ?S: This variable conditionally defines the HAS_DELETE64 symbol, which ?S: indicates to the C program that the delete64() routine is available. ?S:. ?S:d_store64: ?S: This variable conditionally defines the HAS_STORE64 symbol, which ?S: indicates to the C program that the store64() routine is available. ?S:. ?S:d_firstkey64: ?S: This variable conditionally defines the HAS_FIRSTKEY64 symbol, which ?S: indicates to the C program that the firstkey64() routine is available. ?S:. ?S:d_nextkey64: ?S: This variable conditionally defines the HAS_NEXTKEY64 symbol, which ?S: indicates to the C program that the nextkey64() routine is available. ?S:. ?C:HAS_DBMINIT64: ?C: This symbol, if defined, indicates that the dbminit64 routine is ?C: available to open dbm files larger than 2 gigabytes. ?C:. ?C:HAS_DBMCLOSE64: ?C: This symbol, if defined, indicates that the dbmclose64 routine is ?C: available to close dbm files larger than 2 gigabytes. ?C:. ?C:HAS_FETCH64: ?C: This symbol, if defined, indicates that the fetch64 routine is ?C: available to fetch from dbm files larger than 2 gigabytes. ?C:. ?C:HAS_STORE64: ?C: This symbol, if defined, indicates that the store64 routine is ?C: available to store to dbm files larger than 2 gigabytes. ?C:. ?C:HAS_DELETE64: ?C: This symbol, if defined, indicates that the delete64 routine is ?C: available to delete from dbm files larger than 2 gigabytes. ?C:. ?C:HAS_FIRSTKEY64: ?C: This symbol, if defined, indicates that the firstkey64 routine is ?C: available to firstkey in dbm files larger than 2 gigabytes. ?C:. ?C:HAS_NEXTKEY64: ?C: This symbol, if defined, indicates that the nextkey64 routine is ?C: available to nextkey in dbm files larger than 2 gigabytes. ?C:. ?H:#$d_dbminit64 HAS_DBMINIT64 /**/ ?H:#$d_dbmclose64 HAS_DBMCLOSE64 /**/ ?H:#$d_fetch64 HAS_FETCH64 /**/ ?H:#$d_store64 HAS_STORE64 /**/ ?H:#$d_delete64 HAS_DELETE64 /**/ ?H:#$d_firstkey64 HAS_FIRSTKEY64 /**/ ?H:#$d_nextkey64 HAS_NEXTKEY64 /**/ ?H:. ?T:xxx ?LINT:set d_dbminit64 ?LINT:set d_dbmclose64 ?LINT:set d_fetch64 ?LINT:set d_store64 ?LINT:set d_delete64 ?LINT:set d_firstkey64 ?LINT:set d_nextkey64 : Check if DBM has 64bit functions if $test X"$use64bitint" = X"$define"; then : see if dbminit64 exists set dbminit64 d_dbminit64 eval $inlibc : see if dbmclose64 exists set dbmclose64 d_dbmclose64 eval $inlibc : see if fetch64 exists set fetch64 d_fetch64 eval $inlibc : see if store64 exists set store64 d_store64 eval $inlibc : see if delete64 exists set delete64 d_delete64 eval $inlibc : see if firstkey64 exists set firstkey64 d_firstkey64 eval $inlibc : see if nextkey64 exists set nextkey64 d_nextkey64 eval $inlibc else val="$undef" for xxx in d_dbminit64 d_dbmclose64 d_fetch64 d_store64 d_delete64 d_firstkey64 d_nextkey64 do set $xxx eval $setvar done fi metaconfig-debian-perl-5.26.1/U/perl/defaultincdot.U000066400000000000000000000025521316016665300222350ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2016 H.Merijn Brand & Todd Rinaldo ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:default_inc_excludes_dot: Myread cat ?MAKE: -pick add $@ %< ?S:default_inc_excludes_dot: ?S: When defined, remove the legacy '.' from @INC ?S:. ?C:DEFAULT_INC_EXCLUDES_DOT: ?C: This symbol, if defined, removes the legacy default behavior of ?C: including '.' at the end of @INC. ?C:. ?H:#$default_inc_excludes_dot DEFAULT_INC_EXCLUDES_DOT /**/ ?H:. : Include . in @INC $cat < ?X: ?X: To create a shared library, you must compile ALL source files in the ?X: library with +z (or possibly +Z if the library is whopping huge), ?X: then link the library with -b. Example: ?X: cc -c +z module_a.c ?X: cc -c +z module_b.c ?X: ld -b module_a.o module_b.o -o module.sl ?X: ?MAKE:dlext: \ Getfile Myread cat usedl so ?MAKE: -pick add $@ %< ?Y:BOTTOM ?S:dlext: ?S: This variable contains the extension that is to be used for the ?S: dynamically loaded modules that perl generates. ?S:. : Check what extension to use for shared libs case "$usedl" in $define|y|true) $cat << EOM On a few systems, the dynamically loaded modules that perl generates and uses will need a different extension than shared libs. The default will probably be appropriate. EOM case "$dlext" in '') dflt="$so" ;; *) dflt="$dlext" ;; esac rp='What is the extension of dynamically loaded modules' . ./myread dlext="$ans" ;; *) dlext="none" ;; esac metaconfig-debian-perl-5.26.1/U/perl/dlsrc.U000066400000000000000000000234311316016665300205160ustar00rootroot00000000000000?RCS: $Id: dlsrc.U,v$ ?RCS: ?RCS: Copyright (c) 1996-1998, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: dlsrc.U,v $ ?RCS: ?X: hpux support thanks to Jeff Okamoto ?X: ?X: To create a shared library, you must compile ALL source files in the ?X: library with +z (or possibly +Z if the library is whopping huge), ?X: then link the library with -b. Example: ?X: cc -c +z module_a.c ?X: cc -c +z module_b.c ?X: ld -b module_a.o module_b.o -o module.sl ?X: ?MAKE:usedl ld dlsrc cccdlflags lddlflags ccdlflags bin_ELF ld_can_script: \ rm_try Getfile Myread test osname sed d_dlopen Findhdr Setvar \ src run cc ccflags ldflags optimize ls gccversion cat rsrc i_stdlib \ i_unistd osvers sysroot ?MAKE: -pick add $@ %< ?Y:BOTTOM ?S:usedl: ?S: This variable indicates if the system supports dynamic ?S: loading of some sort. See also dlsrc and dlobj. ?S:. ?S:ld: ?S: This variable indicates the program to be used to link ?S: libraries for dynamic loading. On some systems, it is 'ld'. ?S: On ELF systems, it should be $cc. Mostly, we'll try to respect ?S: the hint file setting. ?S:. ?S:dlsrc: ?S: This variable contains the name of the dynamic loading file that ?S: will be used with the package. ?S:. ?S:cccdlflags: ?S: This variable contains any special flags that might need to be ?S: passed with 'cc -c' to compile modules to be used to create a shared ?S: library that will be used for dynamic loading. For hpux, this ?S: should be +z. It is up to the makefile to use it. ?S:. ?S:lddlflags: ?S: This variable contains any special flags that might need to be ?S: passed to $ld to create a shared library suitable for dynamic ?S: loading. It is up to the makefile to use it. For hpux, it ?S: should be '-b'. For sunos 4.1, it is empty. ?S:. ?S:ccdlflags: ?S: This variable contains any special flags that might need to be ?S: passed to cc to link with a shared library for dynamic loading. ?S: It is up to the makefile to use it. For sunos 4.1, it should ?S: be empty. ?S:. ?S:bin_ELF: ?S: This variable saves the result from configure if generated binaries ?S: are in ELF format. Only set to defined when the test has actually ?S: been performed, and the result was positive. ?S:. ?S:ld_can_script: ?S: This variable shows if the loader accepts scripts in the form of ?S: -Wl,--version-script=ld.script. This is currently only supported ?S: for GNU ld on ELF in dynamic loading builds. ?S:. ?C:USE_DYNAMIC_LOADING ~ %<: ?C: This symbol, if defined, indicates that dynamic loading of ?C: some sort is available. ?C:. ?H:?%<:#$usedl USE_DYNAMIC_LOADING /**/ ?H:. ?W:%<:dlopen ?T:dldir thisflag tdir ?F:!a.out : determine which dynamic loading, if any, to compile in echo " " dldir="ext/DynaLoader" case "$usedl" in $define|y|true) dflt='y' usedl="$define" ;; $undef|n|false) dflt='n' usedl="$undef" ;; *) dflt='n' case "$d_dlopen" in $define) dflt='y' ;; esac : Does a dl_xxx.xs file exist for this operating system $test -f $rsrc/$dldir/dl_${osname}.xs && dflt='y' ;; esac rp="Do you wish to use dynamic loading?" . ./myread usedl="$ans" bin_ELF="$undef" case "$ans" in y*) usedl="$define" case "$dlsrc" in '') if $test -f $rsrc/$dldir/dl_${osname}.xs ; then dflt="$dldir/dl_${osname}.xs" elif $test "$d_dlopen" = "$define" ; then dflt="$dldir/dl_dlopen.xs" else dflt='' fi ;; *) dflt="$dldir/$dlsrc" ;; esac echo "The following dynamic loading files are available:" : Can not go over to $dldir because getfile has path hard-coded in. tdir=`pwd`; cd "$rsrc"; $ls -C $dldir/dl*.xs; cd "$tdir" rp="Source file to use for dynamic loading" fn="fne" gfpth="$src" . ./getfile usedl="$define" : emulate basename dlsrc=`echo $ans | $sed -e 's%.*/\([^/]*\)$%\1%'` $cat << EOM Some systems may require passing special flags to $cc -c to compile modules that will be used to create a shared library. To use no flags, say "none". EOM case "$cccdlflags" in '') case "$gccversion" in '') case "$osname" in hpux) dflt='+z' ;; irix*) dflt='-KPIC' ;; svr4*|esix*|solaris|nonstopux) dflt='-KPIC' ;; sunos) dflt='-pic' ;; *) dflt='none' ;; esac ;; *) case "$osname" in darwin) dflt='none' ;; *linux*|svr4*|esix*|solaris|nonstopux) dflt='-fPIC' ;; *) dflt='-fpic' ;; esac ;; esac ;; ' ') dflt='none' ;; *) dflt="$cccdlflags" ;; esac case "$dflt" in none) dflt='' ;; esac # If -Dsysroot was specified, now's the time to add it # to cccdlflags if test "X$sysroot" != X; then case "$gccversion" in '') ;; *) case "$dflt" in *sysroot*) ;; 'undef'|*) dflt="$dflt --sysroot=$sysroot" ;; esac ;; esac fi case "$dflt" in '') dflt='none';; esac rp="Any special flags to pass to $cc -c to compile shared library modules?" . ./myread case "$ans" in ?X: Use ' ' so that a subsequent Configure run preserves the old state. none) cccdlflags=' ' ;; *) cccdlflags="$ans" ;; esac cat << EOM Some systems use ld to create libraries that can be dynamically loaded, while other systems (such as those using ELF) use $cc. EOM : Determine if this is ELF $cat >try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_unistd I_UNISTD #ifdef I_UNISTD #include #endif int main() { char b[4]; int i = open("a.out",O_RDONLY); if(i == -1) exit(1); /* fail */ if(read(i,b,4)==4 && b[0]==127 && b[1]=='E' && b[2]=='L' && b[3]=='F') exit(0); /* succeed (yes, it is ELF) */ exit(1); /* fail */ } EOM if $cc $ccflags $ldflags -o a.out try.c >/dev/null 2>&1 && $run ./a.out; then bin_ELF="$define" fi $rm_try case "$ld" in '') if $test $bin_ELF = "$define"; then cat <try.c <try.h </dev/null 2>&1 \ && $test -s a.out ; then echo "ld supports scripting" >&4 ld_can_script="$define" else echo "ld does not support scripting" >&4 fi $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/dtraceobject.U000066400000000000000000000040631316016665300220400ustar00rootroot00000000000000?RCS: Copyright (c) 2016 Tony Cook ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:dtraceobject dtracexnolibs: usedtrace dtrace cc ccflags optimize \ Compile cat rm_try ?MAKE: -pick add $@ %< ?S:dtraceobject: ?S: Whether we need to build an object file with the dtrace tool. ?S:. ?S:dtracexnolibs: ?S: Whether dtrace accepts -xnolibs. If available we call dtrace -h ?S: and dtrace -G with -xnolibs to allow dtrace to run in a jail on ?S: FreeBSD. ?S:. ?T:xnolibs : Probe whether dtrace builds an object, as newer Illumos requires an input : object file that uses at least one of the probes defined in the .d file case "$usedtrace" in $define) case "$dtracexnolibs" in $define|true|[yY]*) dtracexnolibs=$define $dtrace -h -xnolibs -s ../perldtrace.d -o perldtrace.h ;; ' '|'') if $dtrace -h -xnolibs -s ../perldtrace.d -o perldtrace.h 2>&1 ; then dtracexnolibs=$define echo "Your dtrace accepts -xnolibs" elif $dtrace -h -s ../perldtrace.d -o perldtrace.h 2>&1 ; then dtracexnolibs=$undef echo "Your dtrace doesn't accept -xnolibs" else echo "Your dtrace doesn't work at all, try building without dtrace support" >&4 exit 1 fi ;; *) dtracexnolibs=$undef $dtrace -h -s ../perldtrace.d -o perldtrace.h ;; esac case $dtracexnolibs in $define) xnolibs=-xnolibs ;; *) xnolibs= ;; esac case "$dtraceobject" in $define|true|[yY]*) dtraceobject=$define ;; ' '|'') $cat >try.c </dev/null 2>&1; then dtraceobject=$define echo "Your dtrace builds an object file" fi ;; *) dtraceobject=$undef ;; esac $rm_try perldtrace.o perldtrace.h esac metaconfig-debian-perl-5.26.1/U/perl/fflushall.U000066400000000000000000000202641316016665300213700ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:fflushNULL fflushall: Compile cat rm rm_try test osname run to from \ Oldconfig Myread Setvar echo targethost \ d_sysconf i_unistd d_stdio_stream_array stdio_stream_array i_stdlib ?MAKE: -pick add $@ %< ?S:fflushNULL: ?S: This symbol, if defined, tells that fflush(NULL) correctly ?S: flushes all pending stdio output without side effects. In ?S: particular, on some platforms calling fflush(NULL) *still* ?S: corrupts STDIN if it is a pipe. ?S:. ?S:fflushall: ?S: This symbol, if defined, tells that to flush ?S: all pending stdio output one must loop through all ?S: the stdio file handles stored in an array and fflush them. ?S: Note that if fflushNULL is defined, fflushall will not ?S: even be probed for and will be left undefined. ?S:. ?C:FFLUSH_NULL: ?C: This symbol, if defined, tells that fflush(NULL) correctly ?C: flushes all pending stdio output without side effects. In ?C: particular, on some platforms calling fflush(NULL) *still* ?C: corrupts STDIN if it is a pipe. ?C:. ?C:FFLUSH_ALL: ?C: This symbol, if defined, tells that to flush ?C: all pending stdio output one must loop through all ?C: the stdio file handles stored in an array and fflush them. ?C: Note that if fflushNULL is defined, fflushall will not ?C: even be probed for and will be left undefined. ?C:. ?H:#$fflushNULL FFLUSH_NULL /**/ ?H:#$fflushall FFLUSH_ALL /**/ ?H:. ?T:output code ?F:!try.out !try !tryp : Check how to flush echo " " $cat >&4 < try.c ;; esac $cat >>try.c < #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_unistd I_UNISTD #ifdef I_UNISTD # include #endif #$d_sysconf HAS_SYSCONF #$d_stdio_stream_array HAS_STDIO_STREAM_ARRAY #ifdef HAS_STDIO_STREAM_ARRAY # define STDIO_STREAM_ARRAY $stdio_stream_array #endif int main() { FILE* p; unlink("try.out"); p = fopen("try.out", "w"); #ifdef TRY_FPUTC fputc('x', p); #else # ifdef TRY_FPRINTF fprintf(p, "x"); # endif #endif #ifdef TRY_FFLUSH_NULL fflush(NULL); #endif #ifdef TRY_FFLUSH_ALL { long open_max = -1; # ifdef PERL_FFLUSH_ALL_FOPEN_MAX open_max = PERL_FFLUSH_ALL_FOPEN_MAX; # else # if defined(HAS_SYSCONF) && defined(_SC_OPEN_MAX) open_max = sysconf(_SC_OPEN_MAX); # else # ifdef FOPEN_MAX open_max = FOPEN_MAX; # else # ifdef OPEN_MAX open_max = OPEN_MAX; # else # ifdef _NFILE open_max = _NFILE; # endif # endif # endif # endif # endif # ifdef HAS_STDIO_STREAM_ARRAY if (open_max > 0) { long i; for (i = 0; i < open_max; i++) if (STDIO_STREAM_ARRAY[i]._file >= 0 && STDIO_STREAM_ARRAY[i]._file < open_max && STDIO_STREAM_ARRAY[i]._flag) fflush(&STDIO_STREAM_ARRAY[i]); } } # endif #endif _exit(42); } EOCP : first we have to find out how _not_ to flush $to try.c if $test "X$fflushNULL" = X -o "X$fflushall" = X; then output='' set try -DTRY_FPUTC if eval $compile; then $run ./try 2>/dev/null code="$?" $from try.out if $test ! -s try.out -a "X$code" = X42; then output=-DTRY_FPUTC fi fi case "$output" in '') set try -DTRY_FPRINTF if eval $compile; then $run ./try 2>/dev/null code="$?" $from try.out if $test ! -s try.out -a "X$code" = X42; then output=-DTRY_FPRINTF fi fi ;; esac fi : check for fflush NULL behavior case "$fflushNULL" in '') set try -DTRY_FFLUSH_NULL $output if eval $compile; then $run ./try 2>/dev/null code="$?" $from try.out if $test -s try.out -a "X$code" = X42; then fflushNULL="`$cat try.out`" else if $test "X$code" != X42; then $cat >&4 <&4 <tryp.c < int main(int argc, char **argv) { char buf[1024]; int i; char *bp = buf; while (1) { while ((i = getc(stdin)) != -1 && (*bp++ = i) != '\n' && bp < &buf[1024]) /* DO NOTHING */ ; *bp = '\0'; fprintf(stdout, "%s", buf); fflush(NULL); if (i == -1) return 0; bp = buf; } } EOCP fflushNULL="$define" set tryp if eval $compile; then $rm -f tryp.out # Copy the .c file to the remote host ($to is an ssh-alike if targethost is set) if $test "X$targethost" != X; then $to tryp.c $to tryp $run "cat tryp.c | ./tryp " 2>/dev/null > tryp.out else $cat tryp.c | $run ./tryp 2>/dev/null > tryp.out fi if cmp tryp.c tryp.out >/dev/null 2>&1; then $cat >&4 <&4 <&4 <&4 <tryp.c < int main(int argc, char **argv) { char buf[1024]; int i; char *bp = buf; while (1) { while ((i = getc(stdin)) != -1 && (*bp++ = i) != '\n' && bp < &buf[1024]) /* DO NOTHING */ ; *bp = '\0'; fprintf(stdout, "%s", buf); fflush(stdin); if (i == -1) return 0; bp = buf; } } EOCP set tryp if eval $compile; then $rm -f tryp.out if $test "X$targethost" != X; then $to tryp.c $to tryp $run "cat tryp.c | ./tryp " 2>/dev/null > tryp.out else $cat tryp.c | $run ./tryp 2>/dev/null > tryp.out fi if cmp tryp.c tryp.out >/dev/null 2>&1; then $cat >&4 <&4 </dev/null code=$? $from try.out if $test -s try.out -a "X$code" = X42; then fflushall="`$cat try.out`" fi fi $rm_try case "$fflushall" in x) $cat >&4 <&4 <&4 <&4 <&4 cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof($fpostype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') fpossize=4 echo "(I can't execute the test program--guessing $fpossize.)" >&4 ;; *) fpossize=$yyy echo "Your $zzz is $fpossize bytes long." ;; esac else dflt="$longsize" echo " " >&4 echo "(I can't compile the test program. Guessing...)" >&4 rp="What is the size of your file positions (in bytes)?" . ./myread fpossize="$ans" fi metaconfig-debian-perl-5.26.1/U/perl/gccvers.U000066400000000000000000000111241316016665300210370ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:gccversion gccosandvers gccansipedantic: cat cpp rm +cc \ Myread Guess Options Oldconfig Loc osname osvers run ?MAKE: -pick add $@ %< ?S:gccversion: ?S: If GNU cc (gcc) is used, this variable holds '1' or '2' to ?S: indicate whether the compiler is version 1 or 2. This is used in ?S: setting some of the default cflags. It is set to '' if not gcc. ?S:. ?S:gccosandvers: ?S: If GNU cc (gcc) is used, this variable holds the operating system ?S: and version used to compile gcc. It is set to '' if not gcc, ?S: or if nothing useful can be parsed as the os version. ?S:. ?S:gccansipedantic: ?S: If GNU cc (gcc) is used, this variable will enable (if set) the ?S: -ansi and -pedantic ccflags for building core files (through ?S: cflags script). (See Porting/pumpkin.pod for full description). ?S:. ?D:gccversion='' ?D:gccansipedantic='' ?T:gccshortvers ?T:incdir ?T:warn ?F:!try ?LINT:change cpp ?LINT:extern ccflags ?LINT:extern ldflags ?LINT:extern locincpth ?LINT:extern ccname ?LINT:change ccname ?LINT:change locincpth ?LINT:change ccflags ?LINT:set gccansipedantic ?X: Check if they have gcc in any guise. : Check if we are using GNU gcc and what its version is echo " " echo "Checking for GNU cc in disguise and/or its version number..." >&4 $cat >try.c < int main() { #if defined(__GNUC__) && !defined(__INTEL_COMPILER) #ifdef __VERSION__ printf("%s\n", __VERSION__); #else printf("%s\n", "1"); #endif #endif return(0); } EOM if $cc -o try $ccflags $ldflags try.c; then gccversion=`$run ./try` case "$gccversion" in '') echo "You are not using GNU cc." ;; *) echo "You are using GNU cc $gccversion." ccname=gcc ;; esac else echo " " echo "*** WHOA THERE!!! ***" >&4 echo " Your C compiler \"$cc\" doesn't seem to be working!" >&4 ?X: using -K will prevent aborting--maybe they're cross compiling? case "$knowitall" in '') echo " You'd better start hunting for one and let me know about it." >&4 exit 1 ;; esac fi $rm -f try try.* case "$gccversion" in 1*) cpp=`./loc gcc-cpp $cpp $pth` ;; esac case "$gccversion" in '') gccosandvers='' ;; *) gccshortvers=`echo "$gccversion"|sed 's/ .*//'` gccosandvers=`$cc -v 2>&1|grep '/specs$'|sed "s!.*/[^-/]*-[^-/]*-\([^-/]*\)/$gccshortvers/specs!\1!"` gccshortvers='' case "$gccosandvers" in $osname) gccosandvers='' ;; # linux gccs seem to have no linux osvers, grr $osname$osvers) ;; # looking good $osname*) cat <&4 *** WHOA THERE!!! *** Your gcc has not been compiled for the exact release of your operating system ($gccosandvers versus $osname$osvers). In general it is a good idea to keep gcc synchronized with the operating system because otherwise serious problems may ensue when trying to compile software, like Perl. I'm trying to be optimistic here, though, and will continue. If later during the configuration and build icky compilation problems appear (headerfile conflicts being the most common manifestation), I suggest reinstalling the gcc to match your operating system release. EOM ;; *) gccosandvers='' ;; # failed to parse, better be silent esac ;; esac case "$ccname" in '') ccname="$cc" ;; esac # gcc 3.* complain about adding -Idirectories that they already know about, # so we will take those off from locincpth. case "$gccversion" in 3*) echo "main(){}">try.c for incdir in $locincpth; do warn=`$cc $ccflags -I$incdir -c try.c 2>&1 | \ grep '^c[cp]p*[01]: warning: changing search order '` if test "X$warn" != X; then locincpth=`echo " $locincpth " | sed "s! $incdir ! !"` fi done $rm -f try try.* esac # gcc 4.9 by default does some optimizations that break perl. # see ticket 121505. # # The -fwrapv disables those optimizations (and probably others,) so # for gcc 4.9 (and later, since the optimizations probably won't go # away), add -fwrapv unless the user requests -fno-wrapv, which # disables -fwrapv, or if the user requests -fsanitize=undefined, # which turns the overflows -fwrapv ignores into runtime errors. case "$gccversion" in 4.[3-9].*|4.[1-9][0-9]*|[5-9].*|[1-9][0-9]*) case "$ccflags" in *-fno-wrapv*|*-fsanitize=undefined*|*-fwrapv*) ;; *) ccflags="$ccflags -fwrapv" ;; esac esac metaconfig-debian-perl-5.26.1/U/perl/i_assert.U000066400000000000000000000013231316016665300212140ustar00rootroot00000000000000?RCS: $Id: i_assert.U,v $ ?RCS: ?RCS: Copyright (c) 2007 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_assert: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_assert: ?S: This variable conditionally defines the I_ASSERT symbol, which ?S: indicates to the C program that exists and could be ?S: included. ?S:. ?C:I_ASSERT: ?C: This symbol, if defined, indicates that exists and ?C: could be included by the C program to get the assert() macro. ?C:. ?H:#$i_assert I_ASSERT /**/ ?H:. ?LINT:set i_assert : see if this is a assert.h system set assert.h i_assert eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_bfd.U000066400000000000000000000011461316016665300204510ustar00rootroot00000000000000?RCS: $Id: i_bfd.U,v $ ?RCS: ?RCS: Copyright (c) 2014 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_bfd: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_bfd: ?S: This variable conditionally defines the I_BFD symbol, and ?S: indicates whether a C program can include . ?S:. ?C:I_BFD: ?C: This symbol, if defined, indicates that exists and ?C: can be included. ?C:. ?H:#$i_bfd I_BFD /**/ ?H:. ?LINT:set i_bfd : see if this is a bfd.h system set bfd.h i_bfd eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_crypt.U000066400000000000000000000012111316016665300210500ustar00rootroot00000000000000?RCS: $Id: i_crypt.U,v $ ?RCS: ?RCS: Copyright (c) 2002 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_crypt: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_crypt: ?S: This variable conditionally defines the I_CRYPT symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_CRYPT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_crypt I_CRYPT /**/ ?H:. ?LINT:set i_crypt : see if this is a crypt.h system set crypt.h i_crypt eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_db.U000066400000000000000000000172041316016665300203050ustar00rootroot00000000000000?RCS: $Id: i_db.U,v 3.0.1.3 1995/07/25 14:10:22 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: i_db.U,v $ ?RCS: Revision 3.0.1.3 1995/07/25 14:10:22 ram ?RCS: patch56: conditionally use const in test programs (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1995/05/12 12:14:42 ram ?RCS: patch54: extended for more intimate DB probing (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:21:50 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:i_db db_hashtype db_prefixtype \ db_version_major db_version_minor db_version_patch : \ Inhdr +cc +ccflags rm_try contains cat \ Compile d_const libs sed run i_stdlib ?MAKE: -pick add $@ %< ?S:i_db: ?S: This variable conditionally defines the I_DB symbol, and indicates ?S: whether a C program may include Berkeley's DB include file . ?S:. ?S:db_hashtype: ?S: This variable contains the type of the hash structure element ?S: in the header file. In older versions of DB, it was ?S: int, while in newer ones it is u_int32_t. ?S:. ?S:db_prefixtype: ?S: This variable contains the type of the prefix structure element ?S: in the header file. In older versions of DB, it was ?S: int, while in newer ones it is size_t. ?S:. ?S:db_version_major: ?S: This variable contains the major version number of ?S: Berkeley DB found in the header file. ?S:. ?S:db_version_minor: ?S: This variable contains the minor version number of ?S: Berkeley DB found in the header file. ?S: For DB version 1 this is always 0. ?S:. ?S:db_version_patch: ?S: This variable contains the patch version number of ?S: Berkeley DB found in the header file. ?S: For DB version 1 this is always 0. ?S:. ?C:I_DB: ?C: This symbol, if defined, indicates to the C program that it should ?C: include Berkeley's DB include file . ?C:. ?C:DB_Prefix_t: ?C: This symbol contains the type of the prefix structure element ?C: in the header file. In older versions of DB, it was ?C: int, while in newer ones it is u_int32_t. ?C:. ?C:DB_Hash_t: ?C: This symbol contains the type of the prefix structure element ?C: in the header file. In older versions of DB, it was ?C: int, while in newer ones it is size_t. ?C:. ?C:DB_VERSION_MAJOR_CFG: ?C: This symbol, if defined, defines the major version number of ?C: Berkeley DB found in the header when Perl was configured. ?C:. ?C:DB_VERSION_MINOR_CFG: ?C: This symbol, if defined, defines the minor version number of ?C: Berkeley DB found in the header when Perl was configured. ?C: For DB version 1 this is always 0. ?C:. ?C:DB_VERSION_PATCH_CFG: ?C: This symbol, if defined, defines the patch version number of ?C: Berkeley DB found in the header when Perl was configured. ?C: For DB version 1 this is always 0. ?C:. ?H:#$i_db I_DB /**/ ?H:#define DB_Hash_t $db_hashtype /**/ ?H:#define DB_Prefix_t $db_prefixtype /**/ ?H:#define DB_VERSION_MAJOR_CFG $db_version_major /**/ ?H:#define DB_VERSION_MINOR_CFG $db_version_minor /**/ ?H:#define DB_VERSION_PATCH_CFG $db_version_patch /**/ ?H:. ?F:!try ?LINT:change libs : see if this is a db.h system set db.h i_db eval $inhdr case "$i_db" in $define) : Check db version. echo " " echo "Checking Berkeley DB version ..." >&4 $cat >try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include int main(int argc, char *argv[]) { #ifdef DB_VERSION_MAJOR /* DB version >= 2 */ int Major, Minor, Patch ; unsigned long Version ; (void)db_version(&Major, &Minor, &Patch) ; if (argc == 2) { printf("%d %d %d %d %d %d\n", DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH, Major, Minor, Patch); exit(0); } printf("You have Berkeley DB Version 2 or greater.\n"); printf("db.h is from Berkeley DB Version %d.%d.%d\n", DB_VERSION_MAJOR, DB_VERSION_MINOR, DB_VERSION_PATCH); printf("libdb is from Berkeley DB Version %d.%d.%d\n", Major, Minor, Patch) ; /* check that db.h & libdb are compatible */ if (DB_VERSION_MAJOR != Major || DB_VERSION_MINOR != Minor || DB_VERSION_PATCH != Patch) { printf("db.h and libdb are incompatible.\n") ; exit(3); } printf("db.h and libdb are compatible.\n") ; Version = DB_VERSION_MAJOR * 1000000 + DB_VERSION_MINOR * 1000 + DB_VERSION_PATCH ; /* needs to be >= 2.3.4 */ if (Version < 2003004) { /* if (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 0 && DB_VERSION_PATCH < 5) { */ printf("Perl needs Berkeley DB 2.3.4 or greater.\n") ; exit(2); } exit(0); #else #if defined(_DB_H_) && defined(BTREEMAGIC) && defined(HASHMAGIC) if (argc == 2) { printf("1 0 0\n"); exit(0); } printf("You have Berkeley DB Version 1.\n"); exit(0); /* DB version < 2: the coast is clear. */ #else exit(1); /* not Berkeley DB? */ #endif #endif } EOCP set try if eval $compile_ok && $run ./try; then echo 'Looks OK.' >&4 set `$run ./try 1` db_version_major=$1 db_version_minor=$2 db_version_patch=$3 else echo "I can't use Berkeley DB with your . I'll disable Berkeley DB." >&4 i_db=$undef case " $libs " in *"-ldb "*) : Remove db from list of libraries to use echo "Removing unusable -ldb from library list" >&4 set `echo X $libs | $sed -e 's/-ldb / /' -e 's/-ldb$//'` shift libs="$*" echo "libs = $libs" >&4 ;; esac fi $rm_try ;; esac @if DB_Hash_t case "$i_db" in define) : Check the return type needed for hash echo " " echo "Checking return type needed for hash for Berkeley DB ..." >&4 $cat >try.c < #include #ifndef DB_VERSION_MAJOR u_int32_t hash_cb (const void* ptr, size_t size) { } HASHINFO info; int main() { info.hash = hash_cb; } #endif EOCP if $cc $ccflags -c try.c >try.out 2>&1 ; then if $contains warning try.out >>/dev/null 2>&1 ; then db_hashtype='int' else db_hashtype='u_int32_t' fi else : XXX Maybe we should just give up here. db_hashtype=u_int32_t $cat try.out >&4 echo "Help: I can't seem to compile the db test program." >&4 echo "Something's wrong, but I'll assume you use $db_hashtype." >&4 fi $rm_try echo "Your version of Berkeley DB uses $db_hashtype for hash." ;; *) db_hashtype=u_int32_t ;; esac @end @if DB_Prefix_t case "$i_db" in define) : Check the return type needed for prefix echo " " echo "Checking return type needed for prefix for Berkeley DB ..." >&4 cat >try.c < #include #ifndef DB_VERSION_MAJOR size_t prefix_cb (const DBT *key1, const DBT *key2) { } BTREEINFO info; int main() { info.prefix = prefix_cb; } #endif EOCP if $cc $ccflags -c try.c >try.out 2>&1 ; then if $contains warning try.out >>/dev/null 2>&1 ; then db_prefixtype='int' else db_prefixtype='size_t' fi else db_prefixtype='size_t' : XXX Maybe we should just give up here. $cat try.out >&4 echo "Help: I can't seem to compile the db test program." >&4 echo "Something's wrong, but I'll assume you use $db_prefixtype." >&4 fi $rm_try echo "Your version of Berkeley DB uses $db_prefixtype for prefix." ;; *) db_prefixtype='size_t' ;; esac @end metaconfig-debian-perl-5.26.1/U/perl/i_features.U000066400000000000000000000012601316016665300215310ustar00rootroot00000000000000?RCS: $Id: i_features.U,v $ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_features: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_features: ?S: This variable conditionally defines the I_FEATURES symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_FEATURES: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_features I_FEATURES /**/ ?H:. ?LINT:set i_features : see if this is a features.h system set features.h i_features eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_fenv.U000066400000000000000000000011611316016665300206510ustar00rootroot00000000000000?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: ?MAKE:i_fenv: Inhdr ?MAKE: -pick add $@ %< ?S:i_fenv: ?S: This variable conditionally defines the I_FENV symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?C:I_FENV: ?C: This symbol, if defined, indicates to the C program that it should ?C: include to get the floating point environment definitions. ?C:. ?H:#$i_fenv I_FENV /**/ ?H:. ?LINT:set i_fenv : see if this is a fenv.h system set fenv.h i_fenv eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_fp.U000066400000000000000000000011311316016665300203150ustar00rootroot00000000000000?RCS: $Id: i_fp.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_fp: Inhdr ?MAKE: -pick add $@ %< ?S:i_fp: ?S: This variable conditionally defines the I_FP symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_FP: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_fp I_FP /**/ ?H:. ?LINT:set i_fp : see if this is a fp.h system set fp.h i_fp eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_fp_class.U000066400000000000000000000012601316016665300215050ustar00rootroot00000000000000?RCS: $Id: i_fp_class.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_fp_class: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_fp_class: ?S: This variable conditionally defines the I_FP_CLASS symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_FP_CLASS: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_fp_class I_FP_CLASS /**/ ?H:. ?LINT:set i_fp_class : see if this is a fp_class.h system set fp_class.h i_fp_class eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_iconv.U000066400000000000000000000012111316016665300210250ustar00rootroot00000000000000?RCS: $Id: i_iconv.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_iconv: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_iconv: ?S: This variable conditionally defines the I_ICONV symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_ICONV: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_iconv I_ICONV /**/ ?H:. ?LINT:set i_iconv : see if this is a iconv.h system set iconv.h i_iconv eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_ieeefp.U000066400000000000000000000013011316016665300211440ustar00rootroot00000000000000?RCS: $Id: i_ieeefp.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_ieeefp: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_ieeefp: ?S: This variable conditionally defines the I_IEEEFP symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_IEEEFP: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_ieeefp I_IEEEFP /**/ ?H:. ?LINT:set i_ieeefp : see if this is a ieeefp.h system case "$i_ieeefp" in '' ) set ieeefp.h i_ieeefp eval $inhdr ;; esac metaconfig-debian-perl-5.26.1/U/perl/i_inttypes.U000066400000000000000000000023631316016665300215770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_inttypes: Inhdr cat rm_try Setvar Compile ?MAKE: -pick add $@ %< ?S:i_inttypes: ?S: This variable conditionally defines the I_INTTYPES symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_INTTYPES: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_inttypes I_INTTYPES /**/ ?H:. ?LINT:set i_inttypes : see if inttypes.h is available : we want a real compile instead of Inhdr because some systems : have an inttypes.h which includes non-existent headers echo " " $cat >try.c < int main() { static int32_t foo32 = 0x12345678; } EOCP set try if eval $compile; then echo " found." >&4 val="$define" else echo " NOT found." >&4 val="$undef" fi $rm_try set i_inttypes eval $setvar metaconfig-debian-perl-5.26.1/U/perl/i_langinfo.U000066400000000000000000000012541316016665300215130ustar00rootroot00000000000000?RCS: $Id: i_poll.U,v $ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_langinfo: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_langinfo: ?S: This variable conditionally defines the I_LANGINFO symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_LANGINFO: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_langinfo I_LANGINFO /**/ ?H:. ?LINT:set i_langinfo : see if this is a langinfo.h system set langinfo.h i_langinfo eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_libutil.U000066400000000000000000000012431316016665300213600ustar00rootroot00000000000000?RCS: $Id: i_libutil.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_libutil: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_libutil: ?S: This variable conditionally defines the I_LIBUTIL symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_LIBUTIL: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_libutil I_LIBUTIL /**/ ?H:. ?LINT:set i_libutil : see if this is a libutil.h system set libutil.h i_libutil eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_mallocmalloc.U000066400000000000000000000016721316016665300223610ustar00rootroot00000000000000?RCS: $Id: i_malloc.U,v 3.5 2008/03/29 14:06:51 merijn Exp $ ?RCS: ?RCS: Copyright (c) 2008, H.Merijn Brand ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.5. ?RCS: ?MAKE:i_mallocmalloc: Inhdr ?MAKE: -pick add $@ %< ?S:i_mallocmalloc: ?S: This variable conditionally defines the I_MALLOCMALLOC symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_MALLOCMALLOC: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_mallocmalloc I_MALLOCMALLOC /**/ ?H:. ?LINT:set i_mallocmalloc : see if malloc/malloc.h has to be included set malloc/malloc.h i_mallocmalloc eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_mntent.U000066400000000000000000000012261316016665300212220ustar00rootroot00000000000000?RCS: $Id: i_mntent.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_mntent: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_mntent: ?S: This variable conditionally defines the I_MNTENT symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_MNTENT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_mntent I_MNTENT /**/ ?H:. ?LINT:set i_mntent : see if this is a mntent.h system set mntent.h i_mntent eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_mqueue.U000066400000000000000000000012261316016665300212160ustar00rootroot00000000000000?RCS: $Id: i_mqueue.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_mqueue: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_mqueue: ?S: This variable conditionally defines the I_MQUEUE symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_MQUEUE: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_mqueue I_MQUEUE /**/ ?H:. ?LINT:set i_mqueue : see if this is a mqueue.h system set mqueue.h i_mqueue eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_netinettcp.U000066400000000000000000000016201316016665300220700ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_netinettcp: Inhdr ?MAKE: -pick add $@ %< ?S:i_netinettcp: ?S: This variable conditionally defines the I_NETINET_TCP symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_NETINET_TCP: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_netinettcp I_NETINET_TCP /**/ ?H:. ?LINT:set i_netinettcp : see if netinet/tcp.h is available set netinet/tcp.h i_netinettcp eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_nlist.U000066400000000000000000000012111316016665300210400ustar00rootroot00000000000000?RCS: $Id: i_nlist.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_nlist: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_nlist: ?S: This variable conditionally defines the I_NLIST symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_NLIST: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_nlist I_NLIST /**/ ?H:. ?LINT:set i_nlist : see if this is a nlist.h system set nlist.h i_nlist eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_poll.U000066400000000000000000000012201316016665300206550ustar00rootroot00000000000000?RCS: $Id: i_poll.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_poll: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_poll: ?S: This variable conditionally defines the I_POLL symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_POLL: ?C: This symbol, if defined, indicates that exists and ?C: should be included. (see also HAS_POLL) ?C:. ?H:#$i_poll I_POLL /**/ ?H:. ?LINT:set i_poll : see if this is a poll.h system set poll.h i_poll eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_prot.U000066400000000000000000000011761316016665300207050ustar00rootroot00000000000000?RCS: $Id: i_shadow.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_prot: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_prot: ?S: This variable conditionally defines the I_PROT symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_PROT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_prot I_PROT /**/ ?H:. ?LINT:set i_prot : see if this is a prot.h system set prot.h i_prot eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_quadmath.U000066400000000000000000000011201316016665300215120ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_quadmath: Inhdr ?MAKE: -pick add $@ %< ?S:i_quadmath: ?S: This variable conditionally defines I_QUADMATH, which indicates ?S: to the C program that it should include . ?S:. ?C:I_QUADMATH: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_quadmath I_QUADMATH /**/ ?H:. ?LINT:set i_quadmath : see if this is a quadmath.h system set quadmath.h i_quadmath eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sched.U000066400000000000000000000012111316016665300207750ustar00rootroot00000000000000?RCS: $Id: i_sched.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sched: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sched: ?S: This variable conditionally defines the I_SCHED symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SCHED: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sched I_SCHED /**/ ?H:. ?LINT:set i_sched : see if this is a sched.h system set sched.h i_sched eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_semaphore.U000066400000000000000000000012751316016665300217040ustar00rootroot00000000000000?RCS: $Id: i_semaphore.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_semaphore: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_semaphore: ?S: This variable conditionally defines the I_SEMAPHORE symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SEMAPHORE: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_semaphore I_SEMAPHORE /**/ ?H:. ?LINT:set i_semaphore : see if this is a semaphore.h system set semaphore.h i_semaphore eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_shadow.U000066400000000000000000000012261316016665300212020ustar00rootroot00000000000000?RCS: $Id: i_shadow.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_shadow: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_shadow: ?S: This variable conditionally defines the I_SHADOW symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SHADOW: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_shadow I_SHADOW /**/ ?H:. ?LINT:set i_shadow : see if this is a shadow.h system set shadow.h i_shadow eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_socks.U000066400000000000000000000012111316016665300210310ustar00rootroot00000000000000?RCS: $Id: i_socks.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_socks: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_socks: ?S: This variable conditionally defines the I_SOCKS symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SOCKS: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_socks I_SOCKS /**/ ?H:. ?LINT:set i_socks : see if this is a socks.h system set socks.h i_socks eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_stdbool.U000066400000000000000000000022311316016665300213600ustar00rootroot00000000000000?RCS: $Id: i_stdbool.U,v $ ?RCS: ?RCS: Copyright (c) 2011 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_stdbool: cat Compile rm_try Setvar ?MAKE: -pick add $@ %< ?S:i_stdbool: ?S: This variable conditionally defines the I_STDBOOL symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?C:I_STDBOOL: ?C: This symbol, if defined, indicates that exists and ?C: can be included. ?C:. ?H:#$i_stdbool I_STDBOOL /**/ ?H:. ?LINT:set i_stdbool : see if stdbool is available : we want a real compile instead of Inhdr because some Solaris systems : have stdbool.h, but it can only be used if the compiler indicates it : is sufficiently c99-compliant. echo " " $cat >try.c < #include int func(bool x) { return x ? 1 : 0; } int main(int argc, char **argv) { return func(0); } EOCP set try if eval $compile; then echo " found." >&4 val="$define" else echo " NOT found." >&4 val="$undef" fi $rm_try set i_stdbool eval $setvar metaconfig-debian-perl-5.26.1/U/perl/i_stdint.U000066400000000000000000000011141316016665300212160ustar00rootroot00000000000000?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: ?MAKE:i_stdint: Inhdr ?MAKE: -pick add $@ %< ?S:i_stdint: ?S: This variable conditionally defines the I_STDINT symbol, which ?S: indicates to the C program that exists and should ?S: be included. ?S:. ?C:I_STDINT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_stdint I_STDINT /**/ ?H:. ?LINT:set i_stdint : see if stdint is available set stdint.h i_stdint eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sunmath.U000066400000000000000000000012431316016665300213730ustar00rootroot00000000000000?RCS: $Id: i_sunmath.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sunmath: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sunmath: ?S: This variable conditionally defines the I_SUNMATH symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_SUNMATH: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sunmath I_SUNMATH /**/ ?H:. ?LINT:set i_sunmath : see if this is a sunmath.h system set sunmath.h i_sunmath eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_syslog.U000066400000000000000000000012261316016665300212350ustar00rootroot00000000000000?RCS: $Id: i_syslog.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_syslog: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_syslog: ?S: This variable conditionally defines the I_SYSLOG symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYSLOG: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_syslog I_SYSLOG /**/ ?H:. ?LINT:set i_syslog : see if this is a syslog.h system set syslog.h i_syslog eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysmman.U000066400000000000000000000012521316016665300214030ustar00rootroot00000000000000?RCS: $Id: i_sysmman.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysmman: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysmman: ?S: This variable conditionally defines the I_SYS_MMAN symbol, and ?S: indicates whether a C program should include . ?S:. ?C:I_SYS_MMAN: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysmman I_SYS_MMAN /**/ ?H:. ?LINT:set i_sysmman : see if this is a sys/mman.h system set sys/mman.h i_sysmman eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysmode.U000066400000000000000000000012471316016665300214030ustar00rootroot00000000000000?RCS: $Id: i_sysmode.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysmode: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysmode: ?S: This variable conditionally defines the I_SYSMODE symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYSMODE: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysmode I_SYSMODE /**/ ?H:. ?LINT:set i_sysmode : see if this is a sys/mode.h system set sys/mode.h i_sysmode eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysmount.U000066400000000000000000000012661316016665300216220ustar00rootroot00000000000000?RCS: $Id: i_sysmount.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysmount: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysmount: ?S: This variable conditionally defines the I_SYSMOUNT symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_MOUNT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysmount I_SYS_MOUNT /**/ ?H:. ?LINT:set i_sysmount : see if this is a sys/mount.h system set sys/mount.h i_sysmount eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysrusage.U000066400000000000000000000013011316016665300217340ustar00rootroot00000000000000?RCS: $Id: i_sysrusage.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysrusage: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysrusage: ?S: This variable conditionally defines the I_SYSRUSAGE symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYSRUSAGE: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysrusage I_SYSRUSAGE /**/ ?H:. ?LINT:set i_sysrusage : see if this is a sys/rusage.h system set sys/rusage.h i_sysrusage eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysstatfs.U000066400000000000000000000012501316016665300217550ustar00rootroot00000000000000?RCS: $Id: i_sysstatfs.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysstatfs: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysstatfs: ?S: This variable conditionally defines the I_SYSSTATFS symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_STATFS: ?C: This symbol, if defined, indicates that exists. ?C:. ?H:#$i_sysstatfs I_SYS_STATFS /**/ ?H:. ?LINT:set i_sysstatfs : see if this is a sys/statfs.h system set sys/statfs.h i_sysstatfs eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysstatvfs.U000066400000000000000000000013201316016665300221410ustar00rootroot00000000000000?RCS: $Id: i_sysstatvfs.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysstatvfs: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysstatvfs: ?S: This variable conditionally defines the I_SYSSTATVFS symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_STATVFS: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysstatvfs I_SYS_STATVFS /**/ ?H:. ?LINT:set i_sysstatvfs : see if this is a sys/statvfs.h system set sys/statvfs.h i_sysstatvfs eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysutsname.U000066400000000000000000000013161316016665300221300ustar00rootroot00000000000000?RCS: $Id: i_sysutsname.U,v $ ?RCS: ?RCS: Copyright (c) 2000 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysutsname: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysutsname: ?S: This variable conditionally defines the I_SYSUTSNAME symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYSUTSNAME: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysutsname I_SYSUTSNAME /**/ ?H:. ?LINT:set i_sysutsname : see if this is a sys/utsname.h system set sys/utsname.h i_sysutsname eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_sysvfs.U000066400000000000000000000012341316016665300212510ustar00rootroot00000000000000?RCS: $Id: i_sysvfs.U,v $ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_sysvfs: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_sysvfs: ?S: This variable conditionally defines the I_SYSVFS symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_SYS_VFS: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_sysvfs I_SYS_VFS /**/ ?H:. ?LINT:set i_sysvfs : see if this is a sys/vfs.h system set sys/vfs.h i_sysvfs eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_ulimit.U000066400000000000000000000012261316016665300212200ustar00rootroot00000000000000?RCS: $Id: i_ulimit.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_ulimit: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_ulimit: ?S: This variable conditionally defines the I_ULIMIT symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_ULIMIT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_ulimit I_ULIMIT /**/ ?H:. ?LINT:set i_ulimit : see if this is a ulimit.h system set ulimit.h i_ulimit eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/i_ustat.U000066400000000000000000000012111316016665300210470ustar00rootroot00000000000000?RCS: $Id: i_ustat.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:i_ustat: Inhdr Hasfield ?MAKE: -pick add $@ %< ?S:i_ustat: ?S: This variable conditionally defines the I_USTAT symbol, and indicates ?S: whether a C program should include . ?S:. ?C:I_USTAT: ?C: This symbol, if defined, indicates that exists and ?C: should be included. ?C:. ?H:#$i_ustat I_USTAT /**/ ?H:. ?LINT:set i_ustat : see if this is a ustat.h system set ustat.h i_ustat eval $inhdr metaconfig-debian-perl-5.26.1/U/perl/infnan.U000066400000000000000000000233731316016665300206650ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2015 Jarkko Hietaniemi, H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:longdblinfbytes longdblnanbytes doubleinfbytes doublenanbytes: Inlibc \ cat i_math i_string Compile run rm_try Setvar echo d_longdbl \ doublekind doublesize longdblkind longdblsize ?MAKE: -pick add $@ %< ?S:longdblinfbytes: ?S: This variable contains comma-separated list of hexadecimal bytes ?S: for the long double precision infinity. ?S:. ?S:longdblnanbytes: ?S: This variable contains comma-separated list of hexadecimal bytes ?S: for the long double precision not-a-number. ?S:. ?S:doubleinfbytes: ?S: This variable contains comma-separated list of hexadecimal bytes ?S: for the double precision infinity. ?S:. ?S:doublenanbytes: ?S: This variable contains comma-separated list of hexadecimal bytes ?S: for the double precision not-a-number. ?S:. ?C:DOUBLEINFBYTES: ?C: This symbol, if defined, is a comma-separated list of ?C: hexadecimal bytes for the double precision infinity. ?C:. ?C:DOUBLENANBYTES: ?C: This symbol, if defined, is a comma-separated list of ?C: hexadecimal bytes (0xHH) for the double precision not-a-number. ?C:. ?C:LONGDBLINFBYTES: ?C: This symbol, if defined, is a comma-separated list of ?C: hexadecimal bytes for the long double precision infinity. ?C:. ?C:LONGDBLNANBYTES: ?C: This symbol, if defined, is a comma-separated list of ?C: hexadecimal bytes (0xHH) for the long double precision not-a-number. ?C:. ?H:#define DOUBLEINFBYTES $doubleinfbytes /**/ ?H:#define DOUBLENANBYTES $doublenanbytes /**/ ?H:#define LONGDBLINFBYTES $longdblinfbytes /**/ ?H:#define LONGDBLNANBYTES $longdblnanbytes /**/ ?H:. ?F:!try : Check what kind of inf/nan your system has $echo "Checking the kind of infinities and nans you have..." >&4 $echo "(The following tests may crash. That's okay.)" >&4 $cat >try.c < #endif #ifdef I_STRING # include #endif #include /* Note that whether the sign bit is on or off * for NaN depends on the CPU/FPU, and possibly * can be affected by the build toolchain. * * For example for older MIPS and HP-PA 2.0 the quiet NaN is: * 0x7f, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff * 0x7f, 0xf4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 * (respectively) as opposed to the more usual * 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 * * Pre-IEEE-754 floating point format do not even have inf/nan support * at all. They might have a "max" value (DBL_MAX), which may be deadly * to even mention, causing immediate SIGFPE or equivalent: this is * the case with VAX floating point, for example. */ static void bytes(void *v, unsigned int n) { unsigned char *p = (unsigned char *)v; int i; for (i = 0; i < n; i++) { printf("0x%02x%s", p[i], i < n - 1 ? ", " : "\n"); } } int main(int argc, char *argv[]) { /* We cannot use 1.0/0.0 and 0.0/0.0 (with L suffixes for long double) * because some compilers are 'smart' and not only warn but refuse to * compile such 'illegal' values. */ double dinf = exp(1e9); double dnan = sqrt(-1.0); #ifdef HAS_LONG_DOUBLE long double ldinf = (long double)exp(1e9); long double ldnan = (long double)sqrt(-1.0); # if LONG_DOUBLEKIND == 3 || LONG_DOUBLEKIND == 4 /* the 80-bit long doubles might have garbage in their excess bytes */ memset((char *)&ldinf + 10, '\0', LONG_DOUBLESIZE - 10); memset((char *)&ldnan + 10, '\0', LONG_DOUBLESIZE - 10); # endif if (argc == 2) { switch (argv[1][0]) { case '1': bytes(&dinf, sizeof(dinf)); break; case '2': bytes(&dnan, sizeof(dnan)); break; case '3': bytes(&ldinf, sizeof(ldinf)); break; case '4': bytes(&ldnan, sizeof(ldnan)); break; #endif } } return 0; } EOP set try if eval $compile; then doubleinfbytes=`$run ./try 1` doublenanbytes=`$run ./try 2` case "$d_longdbl" in $define) longdblinfbytes=`$run ./try 3` longdblnanbytes=`$run ./try 4` ;; esac else # Defaults in case the above test program failed. case "$doublekind" in 1) # IEEE 754 32-bit LE doubleinfbytes='0x00, 0x00, 0xf0, 0x7f' doublenanbytes='0x00, 0x00, 0xf8, 0x7f' ;; 2) # IEEE 754 32-bit BE doubleinfbytes='0x7f, 0xf0, 0x00, 0x00' doublenanbytes='0x7f, 0xf8, 0x00, 0x00' ;; 3) # IEEE 754 64-bit LE doubleinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f' doublenanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f' ;; 4) # IEEE 754 64-bit BE doubleinfbytes='0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' doublenanbytes='0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 5) # IEEE 754 128-bit LE doubleinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f' doublenanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f' ;; 6) # IEEE 754 128-bit BE doubleinfbytes='0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' doublenanbytes='0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 7) # IEEE 754 64-bit mixed: 32-bit LEs in BE doubleinfbytes='0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00' doublenanbytes='0x00, 0x00, 0xf8, 0x7f, 0x00, 0x00, 0x00, 0x00' ;; 8) # IEEE 754 64-bit mixed: 32-bit BEs in LE doubleinfbytes='0x00, 0x00, 0x00, 0x00, 0x7f, 0xf0, 0x00, 0x00' doublenanbytes='0x00, 0x00, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00' ;; 9|10|11|12|13|14) # VAX/Cray/IBM floating point formats, no inf/nan. doubleinfbytes=$undef doublenanbytes=$undef ;; *) # No idea. doubleinfbytes=$undef doublenanbytes=$undef ;; esac case "$longdblkind" in 1) # IEEE 754 128-bit LE longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x7f' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x7f' ;; 2) # IEEE 754 128-bit BE longdblinfbytes='0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x7f, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 3) # IEEE 754 80-bit LE, 12 or 16 bytes (x86) case "$longdblsize" in 12) # x86 32-bit (96 bits, or 4 x 32, or 12 x 8) longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x7f, 0x00, 0x00' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00' ;; 16) # x86_64 longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; *) # No idea. longdblinfbytes=$undef longdblnanbytes=$undef ;; esac ;; 4) # IEEE 754 80-bit BE, 12 or 16 bytes case "$longdblsize" in 12) # 32-bit system longdblinfbytes='0x7f, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x7f, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 16) # 64-bit system longdblinfbytes='0x7f, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x7f, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; *) # No idea. longdblinfbytes=$undef longdblnanbytes=$undef ;; esac ;; 5) # 128-bit LE-LE "double double" longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f' ;; 6) # 128-bit BE-BE "double double" longdblinfbytes='0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 7) # 128-bit LE-BE "double double" longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 8) # 128-bit BE-LE "double double" longdblinfbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' longdblnanbytes='0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00' ;; 9|10|11|12|13|14) # VAX/Cray/IBM floating point formats, no inf/nan. longdblinfbytes=$undef longdblnanbytes=$undef ;; *) # No idea. longdblinfbytes=$undef longdblnanbytes=$undef ;; esac fi # In case the program crashed the values are empty, turn them undef. case "$doubleinfbytes" in '') doubleinfbytes=$undef ;; esac case "$doublenanbytes" in '') doublenanbytes=$undef ;; esac case "$longdblinfbytes" in '') longdblinfbytes=$undef ;; esac case "$longdblnanbytes" in '') longdblnanbytes=$undef ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/perl/issymlink.U000066400000000000000000000043301316016665300214260ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: lns.U,v $ ?RCS: Revision 3.0.1.1 1994/06/20 07:05:52 ram ?RCS: patch30: created by ADO ?RCS: ?MAKE:issymlink: lns test rm ?MAKE: -pick add $@ %< ?S:issymlink: ?S: This variable holds the test command to test for a symbolic link ?S: (if they are supported). Typical values include 'test -h' and ?S: 'test -L'. ?S:. ?T:pth p ?LINT:change PATH test ?LINT:extern newsh : determine whether symbolic links are supported echo " " case "$lns" in *"ln"*" -s") echo "Checking how to test for symbolic links..." >&4 $lns blurfl sym if $test "X$issymlink" = X; then ?X: ?X: In some AIX 4 versions the (ksh) builtin test (-h) is broken. ?X: case "$newsh" in '') sh -c "PATH= test -h sym" >/dev/null 2>&1 ;; *) $newsh -c "PATH= test -h sym" >/dev/null 2>&1 ;; esac if test $? = 0; then issymlink="test -h" else echo "Your builtin 'test -h' may be broken." >&4 case "$test" in /*) ;; *) pth=`echo $PATH | sed -e "s/$p_/ /g"` for p in $pth do if test -f "$p/$test"; then test="$p/$test" break fi done ;; esac case "$test" in /*) echo "Trying external '$test -h'." >&4 issymlink="$test -h" if $test ! -h sym >/dev/null 2>&1; then echo "External '$test -h' is broken, too." >&4 issymlink='' fi ;; *) issymlink='' ;; esac fi fi if $test "X$issymlink" = X; then if $test -L sym 2>/dev/null; then issymlink="$test -L" echo "The builtin '$test -L' worked." >&4 fi fi if $test "X$issymlink" != X; then echo "You can test for symbolic links with '$issymlink'." >&4 else echo "I do not know how you can test for symbolic links." >&4 fi $rm -f blurfl sym ;; *) echo "No symbolic links, so not testing for their testing..." >&4 ;; esac metaconfig-debian-perl-5.26.1/U/perl/libperl.U000066400000000000000000000166241316016665300210460ustar00rootroot00000000000000?RCS: $Id: libperl.U,v $ ?RCS: ?RCS: Copyright (c) 1996-1998, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:libperl useshrplib shrpenv ldlibpthname: \ Myread Oldconfig archlibexp awk cat libc \ _a osname osvers so patchlevel subversion usedl ld \ ccdlflags installarchlib userelocatableinc ?MAKE: -pick wipe $@ %< ?S:libperl: ?S: The perl executable is obtained by linking perlmain.c with ?S: libperl, any static extensions (usually just DynaLoader), ?S: and any other libraries needed on this system. libperl ?S: is usually libperl.a, but can also be libperl.so.xxx if ?S: the user wishes to build a perl executable with a shared ?S: library. ?S:. ?S:useshrplib: ?S: This variable is set to 'true' if the user wishes ?S: to build a shared libperl, and 'false' otherwise. ?S:. ?S:shrpenv: ?S: If the user builds a shared libperl.so, then we need to tell the ?S: 'perl' executable where it will be able to find the installed libperl.so. ?S: One way to do this on some systems is to set the environment variable ?S: LD_RUN_PATH to the directory that will be the final location of the ?S: shared libperl.so. The makefile can use this with something like ?S: $shrpenv $(CC) -o perl perlmain.o $libperl $libs ?S: Typical values are ?S: shrpenv="env LD_RUN_PATH=$archlibexp/CORE" ?S: or ?S: shrpenv='' ?S: See the main perl Makefile.SH for actual working usage. ?S: Alternatively, we might be able to use a command line option such ?S: as -R $archlibexp/CORE (Solaris) or -Wl,-rpath ?S: $archlibexp/CORE (Linux). ?S:. ?S:ldlibpthname: ?S: This variable holds the name of the shared library ?S: search path, often LD_LIBRARY_PATH. To get an empty ?S: string, the hints file must set this to 'none'. ?S:. ?T:shrpdir majonly majmin also xxx tmp_shrpenv ?X: metalint gets confused and thinks we're actually setting LDOPTS ?X: and LD_RUN_PATH. ?LINT:extern LDOPTS ?LINT:change LDOPTS ?LINT:extern LD_RUN_PATH ?LINT:change LD_RUN_PATH ?LINT:change ccdlflags ?LINT:extern maintloc maintname ?Y:top : Do we want a shared libperl? also='' case "$usedl" in $undef) # No dynamic loading being used, so don't bother even to prompt. useshrplib='false' ;; *) case "$useshrplib" in '') case "$osname" in svr4*|nonstopux|dgux|dynixptx|esix|powerux|haiku|cygwin*) dflt=y also='Building a shared libperl is required for dynamic loading to work on your system.' ;; *) dflt=n ;; esac ;; $define|true|[Yy]*) dflt=y ;; *) dflt=n ;; esac $cat << EOM The perl executable is normally obtained by linking perlmain.c with libperl${_a}, any static extensions (usually just DynaLoader), and any other libraries needed on this system (such as -lm, etc.). Since your system supports dynamic loading, it is probably possible to build a shared libperl.$so. If you will have more than one executable linked to libperl.$so, this will significantly reduce the size of each executable, but it may have a noticeable effect on performance. The default is probably sensible for your system. $also EOM rp="Build a shared libperl.$so (y/n)" . ./myread case "$ans" in true|$define|[Yy]*) useshrplib='true' ;; *) useshrplib='false' ;; esac ;; esac case "$useshrplib" in true) case "$userelocatableinc" in true|define) echo "Cannot build with both -Duserelocatableinc and -Duseshrplib" >&4 echo "See INSTALL for an explanation why that won't work." >&4 exit 4 ;; esac case "$libperl" in '') # Figure out a good name for libperl.so. Since it gets stored in # a version-specific architecture-dependent library, the version # number isn't really that important, except for making cc/ld happy. # # A name such as libperl.so.10.1 majmin="libperl.$so.$patchlevel.$subversion" # A name such as libperl.so.100 majonly=`echo $patchlevel $subversion | $awk '{printf "%d%02d", $1, $2}'` majonly=libperl.$so.$majonly # I'd prefer to keep the os-specific stuff here to a minimum, and # rely on figuring it out from the naming of libc. case "${osname}${osvers}" in *linux*|gnu*) # ld won't link with a bare -lperl otherwise. dflt=libperl.$so ;; cygwin*) # ld links now against the dll directly majmin="cygperl5_${patchlevel}_${subversion}.${so}" majonly=`echo $patchlevel $subversion | $awk '{printf "%03d%03d", $1, $2}'` majonly=cygperl5.$majonly.$so dflt=$majmin ;; *) # Try to guess based on whether libc has major.minor. case "$libc" in *libc.$so.[0-9]*.[0-9]*) dflt=$majmin ;; *libc.$so.[0-9]*) dflt=$majonly ;; *) dflt=libperl.$so ;; esac ;; esac ;; *) dflt=$libperl ;; esac cat << EOM I need to select a good name for the shared libperl. If your system uses library names with major and minor numbers, then you might want something like $majmin. Alternatively, if your system uses a single version number for shared libraries, then you might want to use $majonly. Or, your system might be quite happy with a simple libperl.$so. Since the shared libperl will get installed into a version-specific architecture-dependent directory, the version number of the shared perl library probably isn't important, so the default should be o.k. EOM rp='What name do you want to give to the shared libperl?' . ./myread libperl=$ans echo "Ok, I'll use $libperl" ;; *) libperl="libperl${_a}" ;; esac # Detect old use of shrpdir via undocumented Configure -Dshrpdir case "$shrpdir" in '') ;; *) $cat >&4 <) know of any problems this may cause. EOM case "$shrpdir" in "$archlibexp/CORE") $cat >&4 <&4 <&4 Adding $xxx to the flags passed to $ld so that the perl executable will find the installed shared $libperl. EOM ;; esac ;; esac fi # Fix ccdlflags in AIX for building external extensions. # (For building Perl itself bare -bE:perl.exp is needed, # Makefile.SH takes care of this.) case "$osname" in aix) ccdlflags="$ccdlflags -bE:$installarchlib/CORE/perl.exp" ;; esac # Respect a hint or command-line value. case "$shrpenv" in '') shrpenv="$tmp_shrpenv" ;; esac case "$ldlibpthname" in '') ldlibpthname=LD_LIBRARY_PATH ;; none) ldlibpthname='' ;; esac metaconfig-debian-perl-5.26.1/U/perl/longdblfio.U000066400000000000000000000426301316016665300215300ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999-2016 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_PRIfldbl sPRIfldbl d_PRIgldbl d_PRIFUldbl sPRIGUldbl d_PRIEUldbl \ sPRIgldbl d_PRIeldbl sPRIeldbl sPRIFUldbl d_PRIGUldbl sPRIEUldbl \ d_SCNfldbl d_double_style_vax d_double_style_ieee \ d_double_style_ibm d_double_style_cray d_double_has_subnormals \ d_double_has_inf d_double_has_nan d_double_has_negative_zero \ sSCNfldbl doublekind: \ d_longdbl longdblsize doublesize uselongdouble test echo cat rm_try \ Setvar Compile run i_stdlib osname gccversion ccflags ?MAKE: -pick add $@ %< ?S:doublekind: ?S: This variable, if defined, encodes the type of a double: ?S: 1 = IEEE 754 32-bit little endian, ?S: 2 = IEEE 754 32-bit big endian, ?S: 3 = IEEE 754 64-bit little endian, ?S: 4 = IEEE 754 64-bit big endian, ?S: 5 = IEEE 754 128-bit little endian, ?S: 6 = IEEE 754 128-bit big endian, ?S: 7 = IEEE 754 64-bit mixed endian le-be, ?S: 8 = IEEE 754 64-bit mixed endian be-le, ?S: 9 = VAX 32bit little endian F float format ?S: 10 = VAX 64bit little endian D float format ?S: 11 = VAX 64bit little endian G float format ?S: 12 = IBM 32bit format ?S: 13 = IBM 64bit format ?S: 14 = Cray 64bit format ?S: -1 = unknown format. ?S:. ?S:d_PRIfldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S:. ?S:d_PRIgldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S:. ?S:d_PRIeldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S:. ?S:d_PRIFUldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S: The 'U' in the name is to separate this from d_PRIfldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:d_PRIGUldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S: The 'U' in the name is to separate this from d_PRIgldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:d_PRIEUldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to print long doubles. ?S: The 'U' in the name is to separate this from d_PRIeldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:d_SCNfldbl: ?S: This variable conditionally defines the PERL_PRIfldbl symbol, which ?S: indicates that stdio has a symbol to scan long doubles. ?S:. ?S:sPRIfldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'f') for output. ?S:. ?S:sPRIgldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'g') for output. ?S:. ?S:sPRIeldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'e') for output. ?S:. ?S:sPRIFUldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'F') for output. ?S: The 'U' in the name is to separate this from sPRIfldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:sPRIGUldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'G') for output. ?S: The 'U' in the name is to separate this from sPRIgldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:sPRIEUldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'E') for output. ?S: The 'U' in the name is to separate this from sPRIeldbl so that even ?S: case-blind systems can see the difference. ?S:. ?S:sSCNfldbl: ?S: This variable, if defined, contains the string used by stdio to ?S: format long doubles (format 'f') for input. ?S:. ?S:d_double_has_inf: ?S: This variable conditionally defines the symbol DOUBLE_HAS_INF ?S: which indicates that the double type has an infinity. ?S:. ?S:d_double_has_nan: ?S: This variable conditionally defines the symbol DOUBLE_HAS_INF ?S: which indicates that the double type has a not-a-number. ?S:. ?S:d_double_has_negative_zero: ?S: This variable conditionally defines the symbol DOUBLE_HAS_NEGATIVE_ZERO ?S: which indicates that the double type has a negative zero. ?S:. ?S:d_double_has_subnormals: ?S: This variable conditionally defines the symbol DOUBLE_HAS_SUBNORMALS ?S: which indicates that the double type has subnormals (denormals). ?S:. ?S:d_double_style_cray: ?S: This variable conditionally defines the symbol DOUBLE_STYLE_CRAY ?S: which indicates that the double is the 64-bit CRAY mainframe format. ?S:. ?S:d_double_style_ibm: ?S: This variable conditionally defines the symbol DOUBLE_STYLE_IBM, ?S: which indicates that the double is the 64-bit IBM mainframe format. ?S:. ?S:d_double_style_ieee: ?S: This variable conditionally defines the symbol DOUBLE_STYLE_IEEE, ?S: which indicates that the double is the 64-bit IEEE 754. ?S:. ?S:d_double_style_vax: ?S: This variable conditionally defines the symbol DOUBLE_STYLE_VAX, ?S: which indicates that the double is the 64-bit VAX format D or G. ?S:. ?C:PERL_PRIfldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'f') for output. ?C:. ?C:PERL_PRIgldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'g') for output. ?C:. ?C:PERL_PRIeldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'e') for output. ?C:. ?C:PERL_PRIFldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'f') for output. ?C:. ?C:PERL_PRIGldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'g') for output. ?C:. ?C:PERL_PRIEldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'e') for output. ?C:. ?C:PERL_SCNfldbl: ?C: This symbol, if defined, contains the string used by stdio to ?C: format long doubles (format 'f') for input. ?C:. ?C:DOUBLEKIND: ?C: DOUBLEKIND will be one of ?C: DOUBLE_IS_IEEE_754_32_BIT_LITTLE_ENDIAN ?C: DOUBLE_IS_IEEE_754_32_BIT_BIG_ENDIAN ?C: DOUBLE_IS_IEEE_754_64_BIT_LITTLE_ENDIAN ?C: DOUBLE_IS_IEEE_754_64_BIT_BIG_ENDIAN ?C: DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN ?C: DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN ?C: DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_LE_BE ?C: DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_BE_LE ?C: DOUBLE_IS_VAX_F_FLOAT ?C: DOUBLE_IS_VAX_D_FLOAT ?C: DOUBLE_IS_VAX_G_FLOAT ?C: DOUBLE_IS_IBM_SINGLE_32_BIT ?C: DOUBLE_IS_IBM_DOUBLE_64_BIT ?C: DOUBLE_IS_CRAY_SINGLE_64_BIT ?C: DOUBLE_IS_UNKNOWN_FORMAT ?C:. ?C:DOUBLE_HAS_INF: ?C: This symbol, if defined, indicates that the double has ?C: the infinity. ?C:. ?C:DOUBLE_HAS_NAN: ?C: This symbol, if defined, indicates that the double has ?C: the not-a-number. ?C:. ?C:DOUBLE_HAS_NEGATIVE_ZERO: ?C: This symbol, if defined, indicates that the double has ?C: the negative_zero. ?C:. ?C:DOUBLE_HAS_SUBNORMALS: ?C: This symbol, if defined, indicates that the double has ?C: the subnormals (denormals). ?C:. ?C:DOUBLE_STYLE_CRAY: ?C: This symbol, if defined, indicates that the double is ?C: the 64-bit CRAY mainframe format. ?C:. ?C:DOUBLE_STYLE_IBM: ?C: This symbol, if defined, indicates that the double is ?C: the 64-bit IBM mainframe format. ?C:. ?C:DOUBLE_STYLE_IEEE: ?C: This symbol, if defined, indicates that the double is ?C: the 64-bit IEEE 754. ?C:. ?C:DOUBLE_STYLE_VAX: ?C: This symbol, if defined, indicates that the double is ?C: the 64-bit VAX format D or G. ?C:. ?LINT:known DOUBLE_IS_IEEE_754_32_BIT_LITTLE_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_32_BIT_BIG_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_64_BIT_LITTLE_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_64_BIT_BIG_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN ?LINT:known DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_LE_BE ?LINT:known DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_BE_LE ?LINT:known DOUBLE_IS_VAX_F_FLOAT ?LINT:known DOUBLE_IS_VAX_D_FLOAT ?LINT:known DOUBLE_IS_VAX_G_FLOAT ?LINT:known DOUBLE_IS_IBM_SINGLE_32_BIT ?LINT:known DOUBLE_IS_IBM_DOUBLE_64_BIT ?LINT:known DOUBLE_IS_CRAY_SINGLE_64_BIT ?LINT:known DOUBLE_IS_UNKNOWN_FORMAT ?H:#define DOUBLEKIND $doublekind /**/ ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_32_BIT_LITTLE_ENDIAN 1 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_32_BIT_BIG_ENDIAN 2 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_64_BIT_LITTLE_ENDIAN 3 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_64_BIT_BIG_ENDIAN 4 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_128_BIT_LITTLE_ENDIAN 5 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_128_BIT_BIG_ENDIAN 6 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_LE_BE 7 ?H:?DOUBLEKIND:#define DOUBLE_IS_IEEE_754_64_BIT_MIXED_ENDIAN_BE_LE 8 ?H:?DOUBLEKIND:#define DOUBLE_IS_VAX_F_FLOAT 9 ?H:?DOUBLEKIND:#define DOUBLE_IS_VAX_D_FLOAT 10 ?H:?DOUBLEKIND:#define DOUBLE_IS_VAX_G_FLOAT 11 ?H:?DOUBLEKIND:#define DOUBLE_IS_IBM_SINGLE_32_BIT 12 ?H:?DOUBLEKIND:#define DOUBLE_IS_IBM_DOUBLE_64_BIT 13 ?H:?DOUBLEKIND:#define DOUBLE_IS_CRAY_SINGLE_64_BIT 14 ?H:?DOUBLEKIND:#define DOUBLE_IS_UNKNOWN_FORMAT -1 ?H:#$d_PRIfldbl PERL_PRIfldbl $sPRIfldbl /**/ ?H:#$d_PRIgldbl PERL_PRIgldbl $sPRIgldbl /**/ ?H:#$d_PRIeldbl PERL_PRIeldbl $sPRIeldbl /**/ ?H:#$d_PRIFUldbl PERL_PRIFldbl $sPRIFUldbl /**/ ?H:#$d_PRIGUldbl PERL_PRIGldbl $sPRIGUldbl /**/ ?H:#$d_PRIEUldbl PERL_PRIEldbl $sPRIEUldbl /**/ ?H:#$d_SCNfldbl PERL_SCNfldbl $sSCNfldbl /**/ ?H:#$d_double_has_inf DOUBLE_HAS_INF ?H:#$d_double_has_nan DOUBLE_HAS_NAN ?H:#$d_double_has_negative_zero DOUBLE_HAS_NEGATIVE_ZERO ?H:#$d_double_has_subnormals DOUBLE_HAS_SUBNORMALS ?H:#$d_double_style_cray DOUBLE_STYLE_CRAY ?H:#$d_double_style_ibm DOUBLE_STYLE_IBM ?H:#$d_double_style_ieee DOUBLE_STYLE_IEEE ?H:#$d_double_style_vax DOUBLE_STYLE_VAX ?H:. ?T:yyy message saveccflags ?F:!try ?LINT:change ccflags ?LINT:change uselongdouble : Check what kind of doubles your system has $echo "Checking the kind of doubles you have..." >&4 $cat >try.c < #endif #include static const double d = -0.1; int main() { unsigned const char* b = (unsigned const char*)(&d); #if DOUBLESIZE == 4 if (b[0] == 0xCD && b[3] == 0xBD) { /* IEEE 754 32-bit little-endian */ printf("1\n"); exit(0); } if (b[0] == 0xBD && b[3] == 0xCD) { /* IEEE 754 32-bit big-endian */ printf("2\n"); exit(0); } if (b[0] == 0xCC && b[3] == 0xCC) { /* VAX format F, 32-bit PDP-style mixed endian. */ printf("9\n"); exit(0); } if (b[0] == 0xC0 && b[3] == 0x9A) { /* IBM single 32-bit */ printf("12\n"); exit(0); } #endif #if DOUBLESIZE == 8 if (b[0] == 0x9A && b[7] == 0xBF) { /* IEEE 754 64-bit little-endian */ printf("3\n"); exit(0); } if (b[0] == 0xBF && b[7] == 0x9A) { /* IEEE 754 64-bit big-endian */ printf("4\n"); exit(0); } if (b[0] == 0x99 && b[3] == 0xBF && b[4] == 0x9A && b[7] == 0x99) { /* ARM mixed endian: two little-endian 32-bit floats, in big endian order: * 4 5 6 7 0 1 2 3 (MSB = 7, LSB = 0) * 99 99 b9 bf 9a 99 99 99 */ printf("7\n"); exit(0); } if (b[0] == 0x99 && b[3] == 0x9A && b[4] == 0xBF && b[7] == 0x99) { /* The opposite of case 7, mixed endian: two big-endian 32-bit floats, * in little endian order: 3 2 1 0 7 6 5 4 (MSB = 7, LSB = 0) * 99 99 99 9a bf b9 99 99 */ printf("8\n"); exit(0); } if (b[0] == 0xCC && b[7] == 0xCC) { /* VAX format D, 64-bit PDP-style mixed endian. */ printf("10\n"); exit(0); } if (b[0] == 0xD9 && b[7] == 0x99) { /* VAX format G, 64-bit PDP-style mixed endian. */ printf("11\n"); exit(0); } if (b[0] == 0xC0 && b[7] == 0x9A) { /* IBM double 64-bit */ printf("13\n"); exit(0); } if (b[0] == 0xBF && b[7] == 0xCD) { /* CRAY single 64-bit */ printf("14\n"); exit(0); } #endif #if DOUBLESIZE == 16 if (b[0] == 0x9A && b[15] == 0xBF) { /* IEEE 754 128-bit little-endian */ printf("5\n"); exit(0); } if (b[0] == 0xBF && b[15] == 0x9A) { /* IEEE 754 128-bit big-endian */ printf("6\n"); exit(0); } #endif /* Then there are old mainframe/miniframe formats like IBM and CRAY. * Whether those environments can still build Perl is debatable. */ printf("-1\n"); /* unknown */ exit(0); } EOP set try if eval $compile; then doublekind=`$run ./try` else doublekind=-1 fi case "$doublekind" in 1) echo "You have IEEE 754 32-bit little endian doubles." >&4 ;; 2) echo "You have IEEE 754 32-bit big endian doubles." >&4 ;; 3) echo "You have IEEE 754 64-bit little endian doubles." >&4 ;; 4) echo "You have IEEE 754 64-bit big endian doubles." >&4 ;; 5) echo "You have IEEE 754 128-bit little endian doubles." >&4 ;; 6) echo "You have IEEE 754 128-bit big endian doubles." >&4 ;; 7) echo "You have IEEE 754 64-bit mixed endian doubles (32-bit LEs in BE)." >&4 ;; 8) echo "You have IEEE 754 64-bit mixed endian doubles (32-bit BEs in LE)." >&4 ;; 9) echo "You have VAX format F 32-bit PDP-style mixed endian doubles." >&4 ;; 10) echo "You have VAX format D 64-bit PDP-style mixed endian doubles." >&4 ;; 11) echo "You have VAX format G 64-bit PDP-style mixed endian doubles." >&4 ;; 12) echo "You have IBM short 32-bit doubles." >&4 ;; 13) echo "You have IBM long 64-bit doubles." >&4 ;; 14) echo "You have Cray single 64-bit doubles." >&4 ;; *) echo "Cannot figure out your double. You Cyber, or something?" >&4 ;; esac d_double_style_ieee=$undef d_double_style_vax=$undef d_double_style_ibm=$undef d_double_style_cray=$undef case "$doublekind" in 1|2|3|4|5|6|7|8) d_double_style_ieee=$define ;; 9|10|11) d_double_style_vax=$define ;; 12|13) d_double_style_ibm=$define ;; 14) d_double_style_cray=$define ;; esac case "$d_double_style_ieee" in $define) d_double_has_inf=$define d_double_has_nan=$define d_double_has_negative_zero=$define d_double_has_subnormals=$define ;; *) d_double_has_inf=$undef d_double_has_nan=$undef d_double_has_negative_zero=$undef d_double_has_subnormals=$undef ;; esac $rm_try : Check print/scan long double stuff echo " " if $test X"$d_longdbl" = X"$define"; then echo "Checking how to print long doubles..." >&4 if $test X"$sPRIfldbl" = X -a X"$doublesize" = X"$longdblsize"; then $cat >try.c <<'EOCP' #include #include int main() { double d = 123.456; printf("%.3f\n", d); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 123.456) sPRIfldbl='"f"'; sPRIgldbl='"g"'; sPRIeldbl='"e"'; sPRIFUldbl='"F"'; sPRIGUldbl='"G"'; sPRIEUldbl='"E"'; echo "We will use %f." ;; esac fi fi if $test X"$sPRIfldbl" = X; then $cat >try.c <<'EOCP' #include #include int main() { long double d = 123.456; printf("%.3Lf\n", d); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 123.456) sPRIfldbl='"Lf"'; sPRIgldbl='"Lg"'; sPRIeldbl='"Le"'; sPRIFUldbl='"LF"'; sPRIGUldbl='"LG"'; sPRIEUldbl='"LE"'; echo "We will use %Lf." ;; esac fi fi if $test X"$sPRIfldbl" = X; then $cat >try.c <<'EOCP' #include #include int main() { long double d = 123.456; printf("%.3llf\n", d); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 123.456) sPRIfldbl='"llf"'; sPRIgldbl='"llg"'; sPRIeldbl='"lle"'; sPRIFUldbl='"llF"'; sPRIGUldbl='"llG"'; sPRIEUldbl='"llE"'; echo "We will use %llf." ;; esac fi fi if $test X"$sPRIfldbl" = X; then $cat >try.c <<'EOCP' #include #include int main() { long double d = 123.456; printf("%.3lf\n", d); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 123.456) sPRIfldbl='"lf"'; sPRIgldbl='"lg"'; sPRIeldbl='"le"'; sPRIFUldbl='"lF"'; sPRIGUldbl='"lG"'; sPRIEUldbl='"lE"'; echo "We will use %lf." ;; esac fi fi if $test X"$sPRIfldbl" = X; then echo "Cannot figure out how to print long doubles." >&4 else sSCNfldbl=$sPRIfldbl # expect consistency fi $rm_try fi # d_longdbl case "$sPRIfldbl" in '') d_PRIfldbl="$undef"; d_PRIgldbl="$undef"; d_PRIeldbl="$undef"; d_PRIFUldbl="$undef"; d_PRIGUldbl="$undef"; d_PRIEUldbl="$undef"; d_SCNfldbl="$undef"; ;; *) d_PRIfldbl="$define"; d_PRIgldbl="$define"; d_PRIeldbl="$define"; d_PRIFUldbl="$define"; d_PRIGUldbl="$define"; d_PRIEUldbl="$define"; d_SCNfldbl="$define"; ;; esac : Before committing on uselongdouble, see whether that looks sane. if $test "$uselongdouble" = "$define"; then message="" echo " " echo "Checking if your long double math functions work right..." >&4 $cat > try.c < #include int main() { printf("%"$sPRIgldbl"\n", sqrtl(logl(expl(cosl(sinl(0.0L))))+powl(2.0L, 3.0L))); } EOF case "$osname:$gccversion" in aix:) saveccflags="$ccflags" ccflags="$ccflags -qlongdouble" ;; # to avoid core dump esac set try if eval $compile_ok; then yyy=`$run ./try` fi case "$yyy" in 3) echo "Your long double math functions are working correctly." >&4 ;; *) echo "Your long double math functions are broken, not using long doubles." >&4 uselongdouble=$undef ;; esac $rm_try case "$osname:$gccversion" in aix:) ccflags="$saveccflags" ;; # restore esac fi metaconfig-debian-perl-5.26.1/U/perl/mandirs.U000066400000000000000000000077401316016665300210510ustar00rootroot00000000000000?RCS: $Id: mandirs.U,v $ ?RCS: ?RCS: Copyright (c) 2000, Andy Dougherty ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: mandirs.U,v $ ?RCS: ?MAKE: man1 man2 man3 man4 man5 man6 man7 man8 \ man2ext man4ext man5ext man6ext man7ext man8ext: \ mandirstyle man1dir man1ext man3dir prefix sed ?MAKE: -pick add $@ %< ?Y:TOP ?X: This unit just provides convenient definitions so that ?X: MakeMaker can sensibly assume that man5 pages go in ?X: $prefix/man/$man5 (or $siteprefix/man/$man5 as appropriate) ?X: and the BSD vs. SVR4 directory naming conventions will be ?X: handled automatically, as will older System V ?X: $prefix/man/u_man style directories. ?X: ?S:man1: ?S: Man 1 pages will normally be installed in $prefix/man/$man1. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man2: ?S: Man 2 pages will normally be installed in $prefix/man/$man2. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man2ext: ?S: Extension for man2 pages, typically just '2'. See mandirstyle. ?S:. ?S:man3: ?S: Man 3 pages will normally be installed in $prefix/man/$man3. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man4: ?S: Man 4 pages will normally be installed in $prefix/man/$man4. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man4ext: ?S: Extension for man4 pages, typically just '4'. See mandirstyle. ?S:. ?S:man5: ?S: Man 5 pages will normally be installed in $prefix/man/$man5. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man5ext: ?S: Extension for man5 pages, typically just '5'. See mandirstyle. ?S:. ?S:man6: ?S: Man 6 pages will normally be installed in $prefix/man/$man6. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man6ext: ?S: Extension for man6 pages, typically just '6'. See mandirstyle. ?S:. ?S:man7: ?S: Man 7 pages will normally be installed in $prefix/man/$man7. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man7ext: ?S: Extension for man7 pages, typically just '7'. See mandirstyle. ?S:. ?S:man8: ?S: Man 8 pages will normally be installed in $prefix/man/$man8. ?S: This variable handles SysV/SVR4/BSD conventions appropriately. ?S: See mandirstyle. ?S:. ?S:man8ext: ?S: Extension for man8 pages, typically just '8'. See mandirstyle. ?S:. ?LINT: set man2 man4 man5 man6 man7 man8 ?LINT: set man2ext man4ext ?LINT: set man5ext man6ext man7ext man8ext ?T: num s ts text ?X: eval fools metalint ?T: man : Determine locations for other man pages. For example, programs : should place man4 pages in $prefix/man/$man4 with an extension : of $man4ext. Use bsd naming conventions. See mandirstyle. : man1 and man3 are handled separately above. echo "Deducing locations for other man pages for future use." : Deduce man1 and man3 from existing variables. Keep them for completeness. : This approach preserves an existing SystemV-style : /usr/local/man/l_man/man1 hierarchy. man1=`echo $man1dir | $sed -e "s!$prefix/man/!!"` man3=`echo $man3dir | $sed -e "s!$prefix/man/!!"` for num in 2 4 5 6 7 8; do s=$num case "$mandirstyle" in sysv|svr4) case "$num" in 4) s='7' ;; 5) s='4' ;; 7) s='5' ;; 8) s='1M' ;; esac ;; esac eval "ts=\"\$man${num}\"" eval "text=\"\$man${num}ext\"" case "$ts" in '') ts=`echo $man1 | $sed -e "s/1/$s/g"` ;; none|$undef) ts=' ' ;; esac case "$text" in '') text=`echo $man1ext | $sed -e "s/1/$s/g"` ;; none|$undef) text=' ' ;; esac : Use extra quotes to preserve an empty ' ' value. eval "man${num}=\"$ts\"" eval "man${num}ext=\"$text\"" done metaconfig-debian-perl-5.26.1/U/perl/mandirstyle.U000066400000000000000000000037641316016665300217510ustar00rootroot00000000000000?RCS: $Id: mandirstyle.U,v 3.1 1999/07/08 20:52:19 doughera Exp doughera $ ?RCS: ?RCS: Copyright (c) 2000, Andy Dougherty ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: mandirstyle.U,v $ ?RCS: ?MAKE:mandirstyle: test ?MAKE: -pick add $@ %< ?S:mandirstyle: ?S: This variable indicates the style of man page directory layout ?S: used on this system. Current possible values are sysv, svr4, and ?S: bsd. This information is used for determining where to put various ?S: man pages. Configure uses the BSD convention internally (we've got ?S: to give *some* name to the variables). ?S: ?S: BSD SVR4 Description Example ?S: Number Number man page ?S: 1 1 Commands cat ?S: 2 2 system calls creat ?S: 3 3 library functions fread ?S: 4 7 special files fd ?S: 5 4 file formats magic ?S: 6 6 games and demos magic ?S: 7 5 miscellany eqnchar ?S: 8 1M Administrative commands mount ?S: ?S: The SysV style is almost the same as SVR4, but instead of ?S: /usr/man/man1, there is /usr/man/u_man/man1. ?S:. : determine style of existing man page installation if $test "$mandirstyle" = ""; then if $test -d /usr/man/u_man/man1; then mandirstyle=sysv elif $test -d /usr/man/man1m; then mandirstyle=svr4 elif $test -d /usr/share/man/man1m; then mandirstyle=svr4 elif $test -d /usr/share/man/sman1m; then mandirstyle=svr4 # Solaris 8 and beyond else # We could work a lot harder here, but there isn't # really much point. mandirstyle=bsd fi fi echo "You appear to have $mandirstyle style man page directories." metaconfig-debian-perl-5.26.1/U/perl/mantbits.U000066400000000000000000000110211316016665300212200ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2015 Jarkko Hietaniemi, H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:longdblmantbits doublemantbits nvmantbits: Inlibc cat Compile run \ rm_try Setvar echo i_float i_sunmath usequadmath \ d_longdbl longdblkind nvsize doublesize longdblsize ?MAKE: -pick add $@ %< ?S:doublemantbits: ?S: This symbol, if defined, tells how many mantissa bits ?S: there are in double precision floating point format. ?S: Note that this is usually DBL_MANT_DIG minus one, since ?S: with the standard IEEE 754 formats DBL_MANT_DIG includes ?S: the implicit bit which doesn't really exist. ?S:. ?S:longdblmantbits: ?S: This symbol, if defined, tells how many mantissa bits ?S: there are in long double precision floating point format. ?S: Note that this can be LDBL_MANT_DIG minus one, ?S: since LDBL_MANT_DIG can include the IEEE 754 implicit bit. ?S: The common x86-style 80-bit long double does not have ?S: an implicit bit. ?S:. ?S:nvmantbits: ?S: This variable tells how many bits the mantissa of a Perl NV has, ?S: not including the possible implicit bit. ?S:. ?C:DOUBLEMANTBITS: ?C: This symbol, if defined, tells how many mantissa bits ?C: there are in double precision floating point format. ?C: Note that this is usually DBL_MANT_DIG minus one, since ?C: with the standard IEEE 754 formats DBL_MANT_DIG includes ?C: the implicit bit, which doesn't really exist. ?C:. ?C:LONGDBLMANTBITS: ?C: This symbol, if defined, tells how many mantissa bits ?C: there are in long double precision floating point format. ?C: Note that this can be LDBL_MANT_DIG minus one, ?C: since LDBL_MANT_DIG can include the IEEE 754 implicit bit. ?C: The common x86-style 80-bit long double does not have ?C: an implicit bit. ?C:. ?C:NVMANTBITS: ?C: This symbol, if defined, tells how many mantissa bits ?C: (not including implicit bit) there are in a Perl NV. ?C: This depends on which floating point type was chosen. ?C:. ?H:#define DOUBLEMANTBITS $doublemantbits ?H:#define LONGDBLMANTBITS $longdblmantbits ?H:#define NVMANTBITS $nvmantbits ?H:. ?F:!try : Check the length of the double mantissa $echo "Checking how many mantissa bits your doubles have..." >&4 $cat >try.c < #endif #ifdef I_SUNMATH # include #endif #ifdef DBL_MANT_DIG # define BITS (DBL_MANT_DIG - 1) /* the implicit bit does not count */ #endif #include int main(int argc, char *argv[]) { #ifdef BITS printf("%d\n", BITS); #endif return 0; } EOP set try if eval $compile; then doublemantbits=`$run ./try` else doublemantbits="$undef" fi $rm_try : Check the length of the longdouble mantissa $echo "Checking how many mantissa bits your long doubles have..." >&4 $cat >try.c < #endif #ifdef I_SUNMATH # include #endif #$d_longdbl HAS_LONG_DOUBLE #if defined(HAS_LONG_DOUBLE) && defined(LDBL_MANT_DIG) # if ($longdblkind == 3) || ($longdblkind == 4) /* 80-bit extended precision */ /* This format has no implicit bit. Beware, however, that for * this format the bare LDBL_MANT_DIG is misleading for inf/nan: * the top three bits are used for inf (100) / qnan (11x) / snan (101), * and the top bit must have been one since 387, zero is plain invalid. * For normal fp values, the LDBL_MANT_DIG is fine, though. */ # define BITS LDBL_MANT_DIG # elif ($longdblkind == 5 || $longdblkind == 6 || $longdblkind == 7 || $longdblkind == 8) /* double double */ /* LDBL_MANT_DIG of 106 (twice 53) would be logical, but for some * reason e.g. Irix thinks 107. But in any case, we want only * the number of real bits, the implicit bits are of no interest. */ # define BITS 2 * (DBL_MANT_DIG - 1) # else # define BITS (LDBL_MANT_DIG - 1) /* the implicit bit does not count */ # endif #endif #include int main(int argc, char *argv[]) { #ifdef BITS printf("%d\n", BITS); #endif return 0; } EOP set try if eval $compile; then longdblmantbits=`$run ./try` else longdblmantbits="$undef" fi $rm_try : Check the length of the NV mantissa $echo "Checking how many mantissa bits your NVs have..." >&4 if test "X$usequadmath" = "X$define"; then nvmantbits=112 # 128-1-15 else if test "X$nvsize" = "X$doublesize"; then nvmantbits="$doublemantbits" else if test "X$nvsize" = "X$longdblsize"; then nvmantbits="$longdblmantbits" else nvmantbits="$undef" fi fi fi metaconfig-debian-perl-5.26.1/U/perl/need_va_copy.U000066400000000000000000000047401316016665300220440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:need_va_copy: rm_try cat Compile i_stdarg i_stdlib run ?MAKE: -pick add $@ %< ?S:need_va_copy: ?S: This symbol, if defined, indicates that the system stores ?S: the variable argument list datatype, va_list, in a format ?S: that cannot be copied by simple assignment, so that some ?S: other means must be used when copying is required. ?S: As such systems vary in their provision (or non-provision) ?S: of copying mechanisms, handy.h defines a platform- ?S: independent macro, Perl_va_copy(src, dst), to do the job. ?S:. ?C:NEED_VA_COPY: ?C: This symbol, if defined, indicates that the system stores ?C: the variable argument list datatype, va_list, in a format ?C: that cannot be copied by simple assignment, so that some ?C: other means must be used when copying is required. ?C: As such systems vary in their provision (or non-provision) ?C: of copying mechanisms, handy.h defines a platform- ?C: independent macro, Perl_va_copy(src, dst), to do the job. ?C:. ?H:#$need_va_copy NEED_VA_COPY /**/ ?H:. ?T:okay ?F:!try : see if we need va_copy echo " " case "$i_stdarg" in "$define") $cat >try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include int ivfprintf(FILE *f, const char *fmt, va_list *valp) { return vfprintf(f, fmt, *valp); } int myvfprintf(FILE *f, const char *fmt, va_list val) { return ivfprintf(f, fmt, &val); } int myprintf(char *fmt, ...) { va_list val; va_start(val, fmt); return myvfprintf(stdout, fmt, val); } int main(int ac, char **av) { signal(SIGSEGV, exit); myprintf("%s%cs all right, then\n", "that", '\''); exit(0); } EOCP set try if eval $compile && $run ./try 2>&1 >/dev/null; then case "`$run ./try`" in "that's all right, then") okay=yes ;; esac fi case "$okay" in yes) echo "It seems that you don't need va_copy()." >&4 need_va_copy="$undef" ;; *) echo "It seems that va_copy() or similar will be needed." >&4 need_va_copy="$define" ;; esac $rm_try ;; *) echo "You don't have , not checking for va_copy()." >&4 need_va_copy="$undef" ;; esac metaconfig-debian-perl-5.26.1/U/perl/oldarchlib.U000066400000000000000000000051231316016665300215100ustar00rootroot00000000000000?RCS: $Id: oldarchlib.U,v $ ?RCS: ?RCS: Copyright (c) 1996-1998, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_oldarchlib oldarchlib oldarchlibexp : archname privlib \ archlib sitearch Getfile test Setvar Prefixit ?MAKE: -pick add $@ %< ?Y:TOP ?S:d_oldarchlib: ?S: This variable conditionally defines OLDARCHLIB to hold the pathname ?S: of architecture-dependent library files for a previous ?S: version of $package. ?S:. ?S:oldarchlib: ?S: This variable holds the name of the directory in which perl5.000 ?S: and perl5.001 stored ?S: architecture-dependent public library files. ?S:. ?S:oldarchlibexp: ?S: This variable is the same as the oldarchlib variable, but is ?S: filename expanded at configuration time, for convenient use. ?S:. ?C:OLDARCHLIB: ?C: This variable, if defined, holds the name of the directory in ?C: which the user has perl5.000 or perl5.001 architecture-dependent ?C: public library files for $package. For the most part, these ?C: files will work with 5.002 (and later), but that is not ?C: guaranteed. ?C:. ?C:OLDARCHLIB_EXP: ?C: This symbol contains the ~name expanded version of OLDARCHLIB, to be ?C: used in programs that are not prepared to deal with ~ expansion at ?C: run-time. ?C:. ?H:#$d_oldarchlib OLDARCHLIB "$oldarchlib" /**/ ?H:#$d_oldarchlib OLDARCHLIB_EXP "$oldarchlibexp" /**/ ?H:. ?LINT:set d_oldarchlib : determine where old public architecture dependent libraries might be case "$oldarchlib" in '') case "$privlib" in '') ;; *) dflt="$privlib/$archname" ;; esac ;; *) dflt="$oldarchlib" ;; esac if $test ! -d "$dflt/auto"; then dflt=none fi cat <&4 if $test -r $rsrc/patchlevel.h;then revision=`awk '/define[ ]+PERL_REVISION/ {print $3}' $rsrc/patchlevel.h` patchlevel=`awk '/define[ ]+PERL_VERSION/ {print $3}' $rsrc/patchlevel.h` subversion=`awk '/define[ ]+PERL_SUBVERSION/ {print $3}' $rsrc/patchlevel.h` api_revision=`awk '/define[ ]+PERL_API_REVISION/ {print $3}' $rsrc/patchlevel.h` api_version=`awk '/define[ ]+PERL_API_VERSION/ {print $3}' $rsrc/patchlevel.h` api_subversion=`awk '/define[ ]+PERL_API_SUBVERSION/ {print $3}' $rsrc/patchlevel.h` perl_patchlevel=`egrep ',"(MAINT|SMOKE)[0-9][0-9]*"' $rsrc/patchlevel.h|tail -1|sed 's/[^0-9]//g'` else revision=0 patchlevel=0 subversion=0 api_revision=0 api_version=0 api_subversion=0 perl_patchlevel=0 $echo "(You do not have patchlevel.h. Eek.)" fi : Define a handy string here to avoid duplication in myconfig.SH and configpm. version_patchlevel_string="version $patchlevel subversion $subversion" case "$perl_patchlevel" in 0|'') ;; *) perl_patchlevel=`echo $perl_patchlevel | sed 's/.* //'` version_patchlevel_string="$version_patchlevel_string patch $perl_patchlevel" ;; esac $echo "(You have $package $version_patchlevel_string.)" case "$osname" in dos|vms) : XXX Should be a Configure test for double-dots in filenames. version=`echo $revision $patchlevel $subversion | \ $awk '{ printf "%d_%d_%d", $1, $2, $3 }'` api_versionstring=`echo $api_revision $api_version $api_subversion | \ $awk '{ printf "%d_%d_%d", $1, $2, $3 }'` ;; *) version=`echo $revision $patchlevel $subversion | \ $awk '{ printf "%d.%d.%d", $1, $2, $3 }'` api_versionstring=`echo $api_revision $api_version $api_subversion | \ $awk '{ printf "%d.%d.%d", $1, $2, $3 }'` ;; esac : Special case the 5.005_xx maintenance series, which used 5.005 : without any subversion label as a subdirectory in $sitelib if test "${api_revision}${api_version}${api_subversion}" = "550"; then api_versionstring='5.005' fi metaconfig-debian-perl-5.26.1/U/perl/perladmin.U000066400000000000000000000015231316016665300213600ustar00rootroot00000000000000?RCS: Copyright (c) 1996, Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:perladmin: cf_email Oldconfig Myread cat ?MAKE: -pick add $@ %< ?Y:TOP ?S:perladmin: ?S: Electronic mail address of the perl5 administrator. ?S:. : Ask e-mail of administrator $cat <&4 case "$use64bitint:$d_quad:$quadtype" in define:define:?*) ivtype="$quadtype" uvtype="$uquadtype" ivsize=8 uvsize=8 ;; *) ivtype="long" uvtype="unsigned long" ivsize=$longsize uvsize=$longsize ;; esac case "$uselongdouble:$d_longdbl" in define:define) nvtype="long double" nvsize=$longdblsize ;; *) nvtype=double nvsize=$doublesize ;; esac case "$usequadmath:$i_quadmath" in define:define) nvtype="__float128" nvsize=16 case "$libs" in *quadmath*) ;; *) $cat <&4 *** You requested the use of the quadmath library, but you *** do not seem to have the quadmath library installed. *** Cannot continue, aborting. EOM exit 1 ;; esac ;; define:*) $cat <&4 *** You requested the use of the quadmath library, but you *** do not seem to have the required header, . EOM case "$gccversion" in [23].*|4.[0-5]*) $cat <&4 *** Your gcc looks a bit old: *** $gccversion EOM ;; '') $cat <&4 *** You are not running a gcc. EOM ;; esac $cat <&4 *** For the quadmath library you need at least gcc 4.6. *** Cannot continue, aborting. EOM exit 1 ;; esac $echo "(IV will be "$ivtype", $ivsize bytes)" $echo "(UV will be "$uvtype", $uvsize bytes)" $echo "(NV will be "$nvtype", $nvsize bytes)" $cat >try.c < #endif #include int main() { #ifdef INT8 int8_t i = INT8_MAX; uint8_t u = UINT8_MAX; printf("int8_t\n"); #endif #ifdef INT16 int16_t i = INT16_MAX; uint16_t u = UINT16_MAX; printf("int16_t\n"); #endif #ifdef INT32 int32_t i = INT32_MAX; uint32_t u = UINT32_MAX; printf("int32_t\n"); #endif } EOCP i8type="signed char" u8type="unsigned char" i8size=1 u8size=1 case "$i16type" in '') case "$shortsize" in 2) i16type=short u16type="unsigned short" i16size=$shortsize u16size=$shortsize ;; esac ;; esac case "$i16type" in '') set try -DINT16 if eval $compile; then case "`$run ./try`" in int16_t) i16type=int16_t u16type=uint16_t i16size=2 u16size=2 ;; esac fi ;; esac case "$i16type" in '') if $test $shortsize -ge 2; then i16type=short u16type="unsigned short" i16size=$shortsize u16size=$shortsize fi ;; esac case "$i32type" in '') case "$longsize" in 4) i32type=long u32type="unsigned long" i32size=$longsize u32size=$longsize ;; *) case "$intsize" in 4) i32type=int u32type="unsigned int" i32size=$intsize u32size=$intsize ;; esac ;; esac ;; esac case "$i32type" in '') set try -DINT32 if eval $compile; then case "`$run ./try`" in int32_t) i32type=int32_t u32type=uint32_t i32size=4 u32size=4 ;; esac fi ;; esac case "$i32type" in '') if $test $intsize -ge 4; then i32type=int u32type="unsigned int" i32size=$intsize u32size=$intsize fi ;; esac case "$i64type" in '') case "$d_quad:$quadtype" in define:?*) i64type="$quadtype" u64type="$uquadtype" i64size=8 u64size=8 ;; esac ;; esac $echo "Checking how many bits of your UVs your NVs can preserve..." >&4 : volatile so that the compiler has to store it out to memory. if test X"$d_volatile" = X"$define"; then volatile=volatile fi $cat <try.c #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #include #include #ifdef SIGFPE $volatile int bletched = 0; $signal_t blech(int s) { bletched = 1; } #endif int main() { $uvtype u = 0; $nvtype d; int n = 8 * $uvsize; int i; #ifdef SIGFPE signal(SIGFPE, blech); #endif for (i = 0; i < n; i++) { u = u << 1 | ($uvtype)1; d = ($nvtype)u; if (($uvtype)d != u) break; if (d <= 0) break; d = ($nvtype)(u - 1); if (($uvtype)d != (u - 1)) break; #ifdef SIGFPE if (bletched) break; #endif } printf("%d\n", ((i == n) ? -n : i)); exit(0); } EOP set try d_nv_preserves_uv="$undef" if eval $compile; then nv_preserves_uv_bits="`$run ./try`" fi case "$nv_preserves_uv_bits" in \-[1-9]*) nv_preserves_uv_bits=`expr 0 - $nv_preserves_uv_bits` $echo "Your NVs can preserve all $nv_preserves_uv_bits bits of your UVs." 2>&1 d_nv_preserves_uv="$define" ;; [1-9]*) $echo "Your NVs can preserve only $nv_preserves_uv_bits bits of your UVs." 2>&1 d_nv_preserves_uv="$undef" ;; *) $echo "Can't figure out how many bits your NVs preserve." 2>&1 nv_preserves_uv_bits="0" ;; esac $rm_try $echo "Checking to find the largest integer value your NVs can hold..." >&4 : volatile so that the compiler has to store it out to memory. if test X"$d_volatile" = X"$define"; then volatile=volatile fi $cat <try.c #include typedef $nvtype NV; int main() { NV value = 2; int count = 1; while(count < 256) { $volatile NV up = value + 1.0; $volatile NV negated = -value; $volatile NV down = negated - 1.0; $volatile NV got_up = up - value; int up_good = got_up == 1.0; int got_down = down - negated; int down_good = got_down == -1.0; if (down_good != up_good) { fprintf(stderr, "Inconsistency - up %d %f; down %d %f; for 2**%d (%.20f)\n", up_good, (double) got_up, down_good, (double) got_down, count, (double) value); return 1; } if (!up_good) { while (1) { if (count > 8) { count -= 8; fputs("256.0", stdout); } else { count--; fputs("2.0", stdout); } if (!count) { puts(""); return 0; } fputs("*", stdout); } } value *= 2; ++count; } fprintf(stderr, "Cannot overflow integer range, even at 2**%d (%.20f)\n", count, (double) value); return 1; } EOP set try nv_overflows_integers_at='0' if eval $compile; then xxx="`$run ./try`" case "$?" in 0) case "$xxx" in 2*) cat >&4 <&4 <&4 <&4 : volatile so that the compiler has to store it out to memory. if test X"$d_volatile" = X"$define"; then volatile=volatile fi $cat <try.c #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif #$i_string I_STRING #ifdef I_STRING # include #else # include #endif #include #include #ifdef SIGFPE $volatile int bletched = 0; $signal_t blech(int s) { bletched = 1; } #endif int checkit($nvtype d, const char *where) { void *v = &d; unsigned char *p = (unsigned char *)v; unsigned char *end = p + sizeof(d); int fail = 0; while (p < end) fail += *p++; if (!fail) return 0; p = (unsigned char *)v; printf("No - %s: 0x", where); while (p < end) printf ("%02X", *p++); printf("\n"); return 1; } int main(int argc, char **argv) { $nvtype d = 0.0; int fail = 0; fail += checkit(d, "0.0"); /* The compiler shouldn't be assuming that bletched is 0 */ d = bletched; fail += checkit(d, "bleched"); #ifdef SIGFPE signal(SIGFPE, blech); #endif /* Paranoia - the compiler should have no way of knowing that ANSI says that argv[argc] will always be NULL. Actually, if it did assume this it would be buggy, as this is C and main() can be called from elsewhere in the program. */ d = argv[argc] ? 1 : 0; if (d) { printf("Odd argv[argc]=%p, d=%g\n", argv[argc], d); } fail += checkit(d, "ternary"); memset(&d, sizeof(d), argv[argc] ? 1 : 0); if (d != 0.0) { printf("No - memset doesn't give 0.0\n"); /* This might just blow up: */ printf("(gives %g)\n", d); return 1; } #ifdef SIGFPE if (bletched) { printf("No - something bleched\n"); return 1; } #endif if (fail) { printf("No - %d fail(s)\n", fail); return 1; } printf("Yes\n"); return 0; } EOP set try d_nv_zero_is_allbits_zero="$undef" if eval $compile; then xxx="`$run ./try`" case "$?" in 0) case "$xxx" in Yes) cat >&4 <&4 <&4 <&4 if $test X"$ivsize" = X8; then ivdformat="$sPRId64" uvuformat="$sPRIu64" uvoformat="$sPRIo64" uvxformat="$sPRIx64" uvXUformat="$sPRIXU64" else if $test X"$ivsize" = X"$longsize"; then ivdformat='"ld"' uvuformat='"lu"' uvoformat='"lo"' uvxformat='"lx"' uvXUformat='"lX"' else if $test X"$ivsize" = X"$intsize"; then ivdformat='"d"' uvuformat='"u"' uvoformat='"o"' uvxformat='"x"' uvXUformat='"X"' else : far out if $test X"$ivsize" = X"$shortsize"; then ivdformat='"hd"' uvuformat='"hu"' uvoformat='"ho"' uvxformat='"hx"' uvXUformat='"hX"' fi fi fi fi if $test X"$usequadmath" = X"$define"; then nveformat='"Qe"' nvfformat='"Qf"' nvgformat='"Qg"' nvEUformat='"QE"' nvFUformat='"QF"' nvGUformat='"QG"' else if $test X"$uselongdouble" = X"$define" -a X"$d_longdbl" = X"$define" -a X"$d_PRIgldbl" = X"$define"; then nveformat="$sPRIeldbl" nvfformat="$sPRIfldbl" nvgformat="$sPRIgldbl" nvEUformat="$sPRIEUldbl" nvFUformat="$sPRIFUldbl" nvGUformat="$sPRIGUldbl" else nveformat='"e"' nvfformat='"f"' nvgformat='"g"' nvEUformat='"E"' nvFUformat='"F"' nvGUformat='"G"' fi fi case "$ivdformat" in '') echo "$0: Fatal: failed to find format strings, cannot continue." >&4 exit 1 ;; esac metaconfig-debian-perl-5.26.1/U/perl/quadfio.U000066400000000000000000000153651316016665300210460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_PRId64 d_PRIi64 d_PRIu64 d_PRIo64 d_PRIx64 d_PRIXU64 \ sPRId64 sPRIi64 sPRIu64 sPRIo64 sPRIx64 sPRIXU64: \ quadtype i_inttypes test cat rm_try Setvar Compile run ?MAKE: -pick add $@ %< ?S:d_PRId64: ?S: This variable conditionally defines the PERL_PRId64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit decimal numbers. ?S:. ?S:d_PRIi64: ?S: This variable conditionally defines the PERL_PRIi64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit decimal numbers. ?S:. ?S:d_PRIu64: ?S: This variable conditionally defines the PERL_PRIu64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit unsigned decimal ?S: numbers. ?S:. ?S:d_PRIo64: ?S: This variable conditionally defines the PERL_PRIo64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit octal numbers. ?S:. ?S:d_PRIx64: ?S: This variable conditionally defines the PERL_PRIx64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit hexadecimal numbers. ?S:. ?S:d_PRIXU64: ?S: This variable conditionally defines the PERL_PRIXU64 symbol, which ?S: indicates that stdio has a symbol to print 64-bit hExADECimAl numbers. ?S: The 'U' in the name is to separate this from d_PRIx64 so that even ?S: case-blind systems can see the difference. ?S:. ?S:sPRId64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit decimal numbers (format 'd') for output. ?S:. ?S:sPRIi64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit decimal numbers (format 'i') for output. ?S:. ?S:sPRIu64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit unsigned decimal numbers (format 'u') for output. ?S:. ?S:sPRIo64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit octal numbers (format 'o') for output. ?S:. ?S:sPRIx64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit hexadecimal numbers (format 'x') for output. ?S:. ?S:sPRIXU64: ?S: This variable, if defined, contains the string used by stdio to ?S: format 64-bit hExADECimAl numbers (format 'X') for output. ?S: The 'U' in the name is to separate this from sPRIx64 so that even ?S: case-blind systems can see the difference. ?S:. ?C:PERL_PRId64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit decimal numbers (format 'd') for output. ?C:. ?C:PERL_PRIi64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit decimal numbers (format 'i') for output. ?C:. ?C:PERL_PRIu64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit unsigned decimal numbers (format 'u') for output. ?C:. ?C:PERL_PRIo64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit octal numbers (format 'o') for output. ?C:. ?C:PERL_PRIx64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit hexadecimal numbers (format 'x') for output. ?C:. ?C:PERL_PRIXU64: ?C: This symbol, if defined, contains the string used by stdio to ?C: format 64-bit hExADECimAl numbers (format 'X') for output. ?C:. ?H:#$d_PRId64 PERL_PRId64 $sPRId64 /**/ ?H:#$d_PRIi64 PERL_PRIi64 $sPRIi64 /**/ ?H:#$d_PRIu64 PERL_PRIu64 $sPRIu64 /**/ ?H:#$d_PRIo64 PERL_PRIo64 $sPRIo64 /**/ ?H:#$d_PRIx64 PERL_PRIx64 $sPRIx64 /**/ ?H:#$d_PRIx64 PERL_PRIXU64 $sPRIXU64 /**/ ?H:. ?T:yyy ?F:!try : Check 64bit sizes echo " " if $test X"$quadtype" != X; then echo "Checking how to print 64-bit integers..." >&4 if $test X"$sPRId64" = X -a X"$quadtype" = Xint; then $cat >try.c <<'EOCP' #include #include int main() { int q = 12345678901; printf("%ld\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64='"d"'; sPRIi64='"i"'; sPRIu64='"u"'; sPRIo64='"o"'; sPRIx64='"x"'; sPRIXU64='"X"'; echo "We will use %d." ;; esac fi fi if $test X"$sPRId64" = X -a X"$quadtype" = Xlong; then $cat >try.c <<'EOCP' #include #include int main() { long q = 12345678901; printf("%ld\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64='"ld"'; sPRIi64='"li"'; sPRIu64='"lu"'; sPRIo64='"lo"'; sPRIx64='"lx"'; sPRIXU64='"lX"'; echo "We will use %ld." ;; esac fi fi if $test X"$sPRId64" = X -a X"$i_inttypes" = X"$define" -a X"$quadtype" = Xint64_t; then $cat >try.c <<'EOCP' #include #include #include int main() { int64_t q = 12345678901; printf("%" PRId64 "\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64=PRId64; sPRIi64=PRIi64; sPRIu64=PRIu64; sPRIo64=PRIo64; sPRIx64=PRIx64; sPRIXU64=PRIXU64; echo "We will use the C9X style." ;; esac fi fi if $test X"$sPRId64" = X -a X"$quadtype" != X; then $cat >try.c < #include int main() { $quadtype q = 12345678901; printf("%Ld\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64='"Ld"'; sPRIi64='"Li"'; sPRIu64='"Lu"'; sPRIo64='"Lo"'; sPRIx64='"Lx"'; sPRIXU64='"LX"'; echo "We will use %Ld." ;; esac fi fi if $test X"$sPRId64" = X -a X"$quadtype" = X"long long"; then $cat >try.c <<'EOCP' #include #include int main() { long long q = 12345678901LL; /* AIX cc requires the LL suffix. */ printf("%lld\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64='"lld"'; sPRIi64='"lli"'; sPRIu64='"llu"'; sPRIo64='"llo"'; sPRIx64='"llx"'; sPRIXU64='"llX"'; echo "We will use the %lld style." ;; esac fi fi if $test X"$sPRId64" = X -a X"$quadtype" != X; then $cat >try.c < #include int main() { $quadtype q = 12345678901; printf("%qd\n", q); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in 12345678901) sPRId64='"qd"'; sPRIi64='"qi"'; sPRIu64='"qu"'; sPRIo64='"qo"'; sPRIx64='"qx"'; sPRIXU64='"qX"'; echo "We will use %qd." ;; esac fi fi if $test X"$sPRId64" = X; then echo "Cannot figure out how to print 64-bit integers." >&4 fi $rm_try fi case "$sPRId64" in '') d_PRId64="$undef"; d_PRIi64="$undef"; d_PRIu64="$undef"; d_PRIo64="$undef"; d_PRIx64="$undef"; d_PRIXU64="$undef"; ;; *) d_PRId64="$define"; d_PRIi64="$define"; d_PRIu64="$define"; d_PRIo64="$define"; d_PRIx64="$define"; d_PRIXU64="$define"; ;; esac metaconfig-debian-perl-5.26.1/U/perl/selectminbits.U000066400000000000000000000070651316016665300222610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:selectminbits: Compile cat rm_try Oldconfig d_select \ i_time i_systime i_systimek i_sysselct selecttype d_socket \ byteorder Myread Setvar run i_stdlib ptrsize ?MAKE: -pick add $@ %< ?S:selectminbits: ?S: This variable holds the minimum number of bits operated by select. ?S: That is, if you do select(n, ...), how many bits at least will be ?S: cleared in the masks if some activity is detected. Usually this ?S: is either n or 32*ceil(n/32), especially many little-endians do ?S: the latter. This is only useful if you have select(), naturally. ?S:. ?C:SELECT_MIN_BITS: ?C: This symbol holds the minimum number of bits operated by select. ?C: That is, if you do select(n, ...), how many bits at least will be ?C: cleared in the masks if some activity is detected. Usually this ?C: is either n or 32*ceil(n/32), especially many little-endians do ?C: the latter. This is only useful if you have select(), naturally. ?C:. ?H:#define SELECT_MIN_BITS $selectminbits /**/ ?H:. ?T:bits ?T:safebits ?F:!try : check for the select 'width' case "$selectminbits" in '') safebits=`expr $ptrsize \* 8` case "$d_select" in $define) $cat <try.c < #$i_time I_TIME #$i_systime I_SYS_TIME #$i_systimek I_SYS_TIME_KERNEL #ifdef I_TIME # include #endif #ifdef I_SYS_TIME # ifdef I_SYS_TIME_KERNEL # define KERNEL # endif # include # ifdef I_SYS_TIME_KERNEL # undef KERNEL # endif #endif #$i_sysselct I_SYS_SELECT #ifdef I_SYS_SELECT #include #endif #$d_socket HAS_SOCKET #ifdef HAS_SOCKET # include /* Might include */ #endif #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif $selecttype b; #define S sizeof(*(b)) #define MINBITS 64 #define NBYTES (S * 8 > MINBITS ? S : MINBITS/8) #define NBITS (NBYTES * 8) int main() { char *s = (char *)malloc(NBYTES); struct timeval t; int i; FILE* fp; int fd; if (!s) exit(1); fclose(stdin); fp = fopen("try.c", "r"); if (fp == 0) exit(2); fd = fileno(fp); if (fd < 0) exit(3); b = ($selecttype)s; for (i = 0; i < NBITS; i++) FD_SET(i, b); t.tv_sec = 0; t.tv_usec = 0; select(fd + 1, b, 0, 0, &t); for (i = NBITS - 1; i > fd && FD_ISSET(i, b); i--); free(s); printf("%d\n", i + 1); return 0; } EOCP set try if eval $compile_ok; then selectminbits=`$run ./try 2>/dev/null` case "$selectminbits" in '') cat >&4 <&4 else rp='What is the minimum number of bits your select() operates on?' case "$byteorder" in 12345678) dflt=64 ;; 1234) dflt=32 ;; *) dflt=1 ;; esac . ./myread val=$ans selectminbits="$val" fi $rm_try ;; *) : no select, so pick a harmless default selectminbits=$safebits ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/perl/st_ino_def.U000066400000000000000000000044731316016665300215250ustar00rootroot00000000000000?RCS: Copyright (c) 2011, H.Merijn Brand & Tony Cook ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:st_ino_size st_ino_sign: cat echo i_stdlib Setvar Compile run rm_try ?MAKE: -pick add $@ %< ?S:st_ino_sign: ?S: This variable contains the signedness of struct stat's st_ino. ?S: 1 for unsigned, -1 for signed. ?S:. ?S:st_ino_size: ?S: This variable contains the size of struct stat's st_ino in bytes. ?S:. ?C:ST_INO_SIZE: ?C: This variable contains the size of struct stat's st_ino in bytes. ?C:. ?C:ST_INO_SIGN: ?C: This symbol holds the signedness of struct stat's st_ino. ?C: 1 for unsigned, -1 for signed. ?C:. ?H:#define ST_INO_SIGN $st_ino_sign /* st_ino sign */ ?H:#define ST_INO_SIZE $st_ino_size /* st_ino size */ ?H:. ?F:!try : Check the size of st_ino $echo " " $echo "Checking the size of st_ino..." >&4 $cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { struct stat st; printf("%d\n", (int)sizeof(st.st_ino)); exit(0); } EOCP set try if eval $compile_ok; then val=`$run ./try` case "$val" in '') st_ino_size=4 $echo "(I can't execute the test program--guessing $st_ino_size.)" >&4 ;; *) st_ino_size=$val $echo "Your st_ino is $st_ino_size bytes long." ;; esac else st_ino_size=4 $echo "(I can't compile the test program--guessing $st_ino_size.)" >&4 fi $rm_try : Check if st_ino is signed $echo " " $echo "Checking the sign of st_ino..." >&4 $cat > try.c < #include int main() { struct stat foo; foo.st_ino = -1; if (foo.st_ino < 0) printf("-1\n"); else printf("1\n"); } EOCP set try if eval $compile; then val=`$run ./try` case "$val" in '') st_ino_sign=1 $echo "(I can't execute the test program--guessing unsigned.)" >&4 ;; *) st_ino_sign=$val case "$st_ino_sign" in 1) $echo "Your st_ino is unsigned." ;; -1) $echo "Your st_ino is signed." ;; esac ;; esac else st_ino_sign=1 $echo "(I can't compile the test program--guessing unsigned.)" >&4 fi $rm_try metaconfig-debian-perl-5.26.1/U/perl/startperl.U000066400000000000000000000057331316016665300214340ustar00rootroot00000000000000?RCS: $Id: startperl.U,v 3.0 1993/08/18 12:09:50 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: This file is included with or a derivative work of a file included ?RCS: with the metaconfig program of Raphael Manfredi's "dist" distribution. ?RCS: In accordance with clause 7 of dist's modified Artistic License: ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: startperl.U,v $ ?RCS: Perl5 version -- I always have d_portable=define. ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:startperl: cat Myread sharpbang initialinstalllocation test \ versiononly version ?MAKE: -pick add $@ %< ?Y:TOP ?X: This is different from dist's standard startperl.U unit because ?X: we can't directly test #!/usr/local/bin/perl (or whatever) because ?X: we haven't built and installed perl yet. ?S:startperl: ?S: This variable contains the string to put on the front of a perl ?S: script to make sure (hopefully) that it runs with perl and not some ?S: shell. Of course, that leading line must be followed by the classical ?S: perl idiom: ?S: eval 'exec perl -S $0 ${1+"$@"}' ?S: if $running_under_some_shell; ?S: to guarantee perl startup should the shell execute the script. Note ?S: that this magic incantation is not understood by csh. ?S:. ?C:STARTPERL: ?C: This variable contains the string to put in front of a perl ?C: script to make sure (one hopes) that it runs with perl and not ?C: some shell. ?C:. ?H:#define STARTPERL "$startperl" /**/ ?H:. : figure out how to guarantee perl startup : XXX Note that this currently takes advantage of the bug that binexp ignores : the Configure -Dinstallprefix setting, which in turn means that under : relocatable @INC, initialinstalllocation is what binexp started as. case "$startperl" in '') case "$sharpbang" in *!) $cat <&4 <&4 <try.c < int main() { if (&STDIO_STREAM_ARRAY[fileno(stdin)] == stdin) printf("yes\n"); } EOCP for s in _iob __iob __sF do set try -DSTDIO_STREAM_ARRAY=$s if eval $compile; then case "`$run ./try`" in yes) stdio_stream_array=$s; break ;; esac fi done $rm_try esac case "$stdio_stream_array" in '') $cat >&4 <&4 <try.c < #include #include $yyy int i; struct tm *tmp; time_t pt; void gm_check (time_t t, int min_year, int max_year) { tmp = gmtime (&t); if ( tmp == NULL || /* Check tm_year overflow */ tmp->tm_year < min_year || tmp->tm_year > max_year) tmp = NULL; else pt = t; } /* gm_check */ int check_max () { tmp = NULL; pt = 0; #ifdef MAXLONG gm_check (MAXLONG, 69, 0x7fffffff); #endif if (tmp == NULL || tmp->tm_year < 0) { for (i = 63; i >= 0; i--) { time_t x = pt | ((time_t)1 << i); if (x < 0 || x < pt) continue; gm_check (x, 69, 0x7fffffff); } } printf ("sGMTIME_max=%ld\n", pt); return (0); } /* check_max */ int check_min () { tmp = NULL; pt = 0; #ifdef MINLONG gm_check (MINLONG, -1900, 70); #endif if (tmp == NULL) { for (i = 36; i >= 0; i--) { time_t x = pt - ((time_t)1 << i); if (x > 0) continue; gm_check (x, -1900, 70); } } printf ("sGMTIME_min=%ld\n", pt); return (0); } /* check_min */ int main (int argc, char *argv[]) { /* fprintf (stderr, "Sizeof time_t = %ld\n", sizeof (time_t)); */ check_max (); check_min (); return (0); } /* main */ EOCP set try if eval $compile; then eval `$run ./try 2>/dev/null` else echo "Cannot determine sGMTIME_max and sGMTIME_min." >&4 fi $rm_try ;; esac echo "Checking max offsets that localtime () accepts" case "$sLOCALTIME_min/$sLOCALTIME_max" in 0/0|/) $cat >try.c < #include #include $yyy int i; struct tm *tmp; time_t pt; void local_check (time_t t, int min_year, int max_year) { if (sizeof (time_t) > 4 && t > 0x7ffffffffffff000LL) tmp = NULL; else tmp = localtime (&t); if ( tmp == NULL || /* Check tm_year overflow */ tmp->tm_year < min_year || tmp->tm_year > max_year) tmp = NULL; else pt = t; } /* local_check */ int check_max () { tmp = NULL; pt = 0; #ifdef MAXLONG local_check (MAXLONG, 69, 0x7fffffff); #endif if (tmp == NULL || tmp->tm_year < 0) { for (i = 63; i >= 0; i--) { time_t x = pt | ((time_t)1 << i); if (x < 0 || x < pt) continue; local_check (x, 69, 0x7fffffff); } } printf ("sLOCALTIME_max=%ld\n", pt); return (0); } /* check_max */ int check_min () { tmp = NULL; pt = 0; #ifdef MINLONG local_check (MINLONG, -1900, 70); #endif if (tmp == NULL) { for (i = 36; i >= 0; i--) { time_t x = pt - ((time_t)1 << i); if (x > 0) continue; local_check (x, -1900, 70); } } printf ("sLOCALTIME_min=%ld\n", pt); return (0); } /* check_min */ int main (int argc, char *argv[]) { check_max (); check_min (); return (0); } /* main */ EOCP set try if eval $compile; then eval `$run ./try 2>/dev/null` else echo "Cannot determine sLOCALTIME_max and sLOCALTIME_min." >&4 fi $rm_try ;; esac metaconfig-debian-perl-5.26.1/U/perl/use64bits.U000066400000000000000000000176421316016665300212460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:use64bitint use64bitall archname64: Myread Oldconfig Setvar test \ usemorebits longsize ccflags d_quad uquadtype Compile rm_try run ?MAKE: -pick add $@ %< ?Y:TOP ?S:use64bitint: ?S: This variable conditionally defines the USE_64_BIT_INT symbol, ?S: and indicates that 64-bit integer types should be used ?S: when available. The minimal possible 64-bitness ?S: is employed, just enough to get 64-bit integers into Perl. ?S: This may mean using for example "long longs", while your memory ?S: may still be limited to 2 gigabytes. ?S:. ?S:use64bitall: ?S: This variable conditionally defines the USE_64_BIT_ALL symbol, ?S: and indicates that 64-bit integer types should be used ?S: when available. The maximal possible ?S: 64-bitness is employed: LP64 or ILP64, meaning that you will ?S: be able to use more than 2 gigabytes of memory. This mode is ?S: even more binary incompatible than USE_64_BIT_INT. You may not ?S: be able to run the resulting executable in a 32-bit CPU at all or ?S: you may need at least to reboot your OS to 64-bit mode. ?S:. ?S:archname64: ?S: This variable is used for the 64-bitness part of $archname. ?S:. ?C:USE_64_BIT_INT: ?C: This symbol, if defined, indicates that 64-bit integers should ?C: be used when available. If not defined, the native integers ?C: will be employed (be they 32 or 64 bits). The minimal possible ?C: 64-bitness is used, just enough to get 64-bit integers into Perl. ?C: This may mean using for example "long longs", while your memory ?C: may still be limited to 2 gigabytes. ?C:. ?C:USE_64_BIT_ALL: ?C: This symbol, if defined, indicates that 64-bit integers should ?C: be used when available. If not defined, the native integers ?C: will be used (be they 32 or 64 bits). The maximal possible ?C: 64-bitness is employed: LP64 or ILP64, meaning that you will ?C: be able to use more than 2 gigabytes of memory. This mode is ?C: even more binary incompatible than USE_64_BIT_INT. You may not ?C: be able to run the resulting executable in a 32-bit CPU at all or ?C: you may need at least to reboot your OS to 64-bit mode. ?C:. ?H:?%<:#ifndef USE_64_BIT_INT ?H:?%<:#$use64bitint USE_64_BIT_INT /**/ ?H:?%<:#endif ?H:?%<:#ifndef USE_64_BIT_ALL ?H:?%<:#$use64bitall USE_64_BIT_ALL /**/ ?H:?%<:#endif ?H:. ?INIT:archname64='' ?LINT:extern ccflags ?LINT:use usemorebits ?LINT:extern use64bits ?LINT:extern uselonglong ?LINT:extern uselonglongs ?LINT:extern use64bitints ?LINT:extern use64bitsint ?LINT:extern use64bitsall ?T:libcquad ?F:!try ?F:!use64bitint.cbu ?F:!use64bitall.cbu : Do we want 64bit support case "$uselonglong" in "$define"|true|[yY]*) cat <&4 *** Configure -Duselonglong is deprecated, using -Duse64bitint instead. EOM use64bitint="$define" ;; esac case "$use64bits" in "$define"|true|[yY]*) cat <&4 *** Configure -Duse64bits is deprecated, using -Duse64bitint instead. EOM use64bitint="$define" ;; esac case "$use64bitints" in "$define"|true|[yY]*) cat <&4 *** There is no Configure -Duse64bitints, using -Duse64bitint instead. EOM use64bitint="$define" ;; esac case "$use64bitsint" in "$define"|true|[yY]*) cat <&4 *** There is no Configure -Duse64bitsint, using -Duse64bitint instead. EOM use64bitint="$define" ;; esac case "$uselonglongs" in "$define"|true|[yY]*) cat <&4 *** There is no Configure -Duselonglongs, using -Duse64bitint instead. EOM use64bitint="$define" ;; esac case "$use64bitsall" in "$define"|true|[yY]*) cat <&4 *** There is no Configure -Duse64bitsall, using -Duse64bitall instead. EOM use64bitall="$define" ;; esac case "$ccflags" in *-DUSE_LONG_LONG*|*-DUSE_64_BIT_INT*|*-DUSE_64_BIT_ALL*) use64bitint="$define";; esac case "$use64bitall" in "$define"|true|[yY]*) use64bitint="$define" ;; esac case "$longsize" in 8) cat <&4 cat >try.c < typedef $uquadtype myULL; int main (void) { struct { double d; myULL u; } *p, test[] = { {4294967303.15, 4294967303ULL}, {4294967294.2, 4294967294ULL}, {4294967295.7, 4294967295ULL}, {0.0, 0ULL} }; for (p = test; p->u; p++) { myULL x = (myULL)p->d; if (x != p->u) { printf("buggy\n"); return 0; } } printf("ok\n"); return 0; } EOCP set try if eval $compile_ok; then libcquad=`$run ./try` echo "Your C library's 64-bit functions are $libcquad." else echo "(I can't seem to compile the test program.)" echo "Assuming that your C library's 64-bit functions are ok." libcquad="ok" fi $rm_try case "$libcquad" in buggy*) cat >&4 <&4 <&4 usecbacktrace=$undef ;; esac ;; esac metaconfig-debian-perl-5.26.1/U/perl/usecjk.U000066400000000000000000000032461316016665300206750ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2002 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:usecjk: Myread Oldconfig Setvar ?MAKE: -pick add $@ %< ?Y:TOP ?S:usecjk: ?S: This variable conditionally defines the USE_CJK symbol, ?S: and indicates that Perl should be built to use CJK. ?S:. ?C:USE_CJK: ?C: This symbol, if defined, indicates that Perl should ?C: be built to use the CJK support of Encode. ?C:. ?H:?%<:#ifndef USE_CJK ?H:?%<:#$usecjk USE_CJK /**/ ?H:?%<:#endif ?H:. ?LINT:set usecjk ?INIT:: set usecjk on the Configure command line to enable cjk. ?X: We should really have some explanatory text here, and some ?X: automatic setting of sensible defaults. : Check for CJK support case "$usecjk" in ''|$define|true|[yY]*) dflt='y';; *) dflt='n';; esac cat </dev/null 2>&1 \ && rm -f perldtrace.tmp then echo " " echo "Good: your $dtrace knows about the -h flag." else cat >&2 <&2 <&4 $cat >try.c <<'EOM' /* Intentionally a long probe as I'd like to sanity check that the exact approach is going to work, as thinking it will work, but only having it part working at runtime is worse than not having it. */ #include #include #include #include #include #include #include int main(int argc, char **argv) { char *buffer; char *argv_leaf = strrchr(argv[0], '/'); char *buffer_leaf; size_t size = 0; int mib[4]; mib[0] = CTL_KERN; mib[1] = KERN_PROC; mib[2] = KERN_PROC_PATHNAME; mib[3] = -1; if (!argv_leaf) { fprintf(stderr, "Can't locate / in '%s'\n", argv[0]); return 1; } if (sysctl(mib, 4, NULL, &size, NULL, 0)) { perror("sysctl"); return 2; } if (size < strlen(argv_leaf) + 1) { fprintf(stderr, "size %lu is too short for a path\n", (unsigned long) size); return 3; } if (size > MAXPATHLEN * MAXPATHLEN) { fprintf(stderr, "size %lu is too long for a path\n", (unsigned long) size); return 4; } buffer = (char *)malloc(size); if (!buffer) { perror("malloc"); return 5; } if (sysctl(mib, 4, buffer, &size, NULL, 0)) { perror("sysctl"); return 6; } if (strlen(buffer) + 1 != size) { fprintf(stderr, "size != strlen(buffer) + 1 (%lu != %lu)\n", (unsigned long)size, (unsigned long)strlen(buffer) + 1); return 7; } if (*buffer != '/') { fprintf(stderr, "Not an absolute path: '%s'\n", buffer); return 8; } if (strstr(buffer, "/./")) { fprintf(stderr, "Contains /./: '%s'\n", buffer); return 9; } if (strstr(buffer, "/../")) { fprintf(stderr, "Contains /../: '%s'\n", buffer); return 10; } buffer_leaf = strrchr(buffer, '/'); if (strcmp(buffer_leaf, argv_leaf) != 0) { fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], buffer); return 11; } free(buffer); return 0; } EOM val=$undef set try if eval $compile; then if $run ./try; then echo "You can use sysctl with KERN_PROC_PATHNAME to find the executing program." >&4 val="$define" else echo "Nope, sysctl with KERN_PROC_PATHNAME doesn't work here." >&4 val="$undef" fi else echo "I'm unable to compile the test program." >&4 echo "I'll assume no sysctl with KERN_PROC_PATHNAME here." >&4 val="$undef" fi $rm_try set usekernprocpathname eval $setvar metaconfig-debian-perl-5.26.1/U/perl/uselfs.U000066400000000000000000000103311316016665300207030ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:uselargefiles \ ccflags_uselargefiles \ ldflags_uselargefiles \ libswanted_uselargefiles: \ Myread Oldconfig Setvar test lseeksize fpossize \ fpostype Compile echo n c cat lseektype rm_try run \ use64bitint use64bitall i_stdlib ?MAKE: -pick add $@ %< ?Y:TOP ?S:uselargefiles: ?S: This variable conditionally defines the USE_LARGE_FILES symbol, ?S: and indicates that large file interfaces should be used when ?S: available. ?S:. ?S:ccflags_uselargefiles: ?S: This variable contains the compiler flags needed by large file builds ?S: and added to ccflags by hints files. ?S:. ?S:ldflags_uselargefiles: ?S: This variable contains the loader flags needed by large file builds ?S: and added to ldflags by hints files. ?S:. ?S:libswanted_uselargefiles: ?S: This variable contains the libraries needed by large file builds ?S: and added to ldflags by hints files. It is a space separated list ?S: of the library names without the "lib" prefix or any suffix, just ?S: like libswanted.. ?S:. ?C:USE_LARGE_FILES: ?C: This symbol, if defined, indicates that large file support ?C: should be used when available. ?C:. ?H:?%<:#ifndef USE_LARGE_FILES ?H:?%<:#$uselargefiles USE_LARGE_FILES /**/ ?H:?%<:#endif ?H:. ?INIT:ccflags_uselargefiles='' ?INIT:ldflags_uselargefiles='' ?INIT:libswanted_uselargefiles='' ?T:yyy zzz ?F:!uselargefiles.cbu !try ?LINT:change lseeksize ?LINT:change fpossize ?LINT:extern uselfs ?LINT:use use64bitint ?LINT:use use64bitall : Check for large file support # Backward compatibility (uselfs is deprecated). case "$uselfs" in "$define"|true|[yY]*) cat <&4 *** Configure -Duselfs is deprecated, using -Duselargefiles instead. EOM uselargefiles="$define" ;; esac case "$lseeksize:$fpossize" in 8:8) cat <&4 $cat >try.c < #include int main() { printf("%d\n", (int)sizeof($lseektype)); return(0); } EOCP set try if eval $compile_ok; then lseeksize=`$run ./try` $echo "Your file offsets are now $lseeksize bytes long." else dflt="$lseeksize" echo " " echo "(I can't seem to compile the test program. Guessing...)" rp="What is the size of your file offsets (in bytes)?" . ./myread lseeksize="$ans" fi case "$fpostype" in *_t) zzz="$fpostype" ;; *) zzz="fpos_t" ;; esac $echo $n "Rechecking the size of $zzz...$c" >&4 $cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof($fpostype)); return(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` dflt="$lseeksize" case "$yyy" in '') echo " " echo "(I can't execute the test program--guessing $fpossize.)" >&4 ;; *) fpossize=$yyy echo " $fpossize bytes." >&4 ;; esac else dflt="$fpossize" echo " " echo "(I can't compile the test program. Guessing...)" >&4 rp="What is the size of your file positions (in bytes)?" . ./myread fpossize="$ans" fi $rm_try fi ;; esac metaconfig-debian-perl-5.26.1/U/perl/uselongdbl.U000066400000000000000000000034731316016665300215510ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:uselongdouble: Myread Oldconfig Setvar cat test usemorebits ?MAKE: -pick add $@ %< ?Y:TOP ?S:uselongdouble: ?S: This variable conditionally defines the USE_LONG_DOUBLE symbol, ?S: and indicates that long doubles should be used when available. ?S:. ?C:USE_LONG_DOUBLE: ?C: This symbol, if defined, indicates that long doubles should ?C: be used when available. ?C:. ?H:?%<:#ifndef USE_LONG_DOUBLE ?H:?%<:#$uselongdouble USE_LONG_DOUBLE /**/ ?H:?%<:#endif ?H:. ?LINT:extern ccflags ?LINT:use usemorebits ?F:!uselongdouble.cbu : Check for uselongdouble support case "$ccflags" in *-DUSE_LONG_DOUBLE*|*-DUSE_MORE_BITS*) uselongdouble="$define" ;; esac case "$uselongdouble" in $define|true|[yY]*) dflt='y';; *) dflt='n';; esac cat <&4 $cat >try.c <<'EOM' /* Intentionally a long probe as I'd like to sanity check that the exact approach is going to work, as thinking it will work, but only having it part working at runtime is worse than not having it. */ #include #include #include #include #include int main(int argc, char **argv) { char buf[1]; uint32_t size = sizeof(buf); int result; char *buffer; char *tidied; char *argv_leaf = strrchr(argv[0], '/'); char *tidied_leaf; if (!argv_leaf) { fprintf(stderr, "Can't locate / in '%s'\n", argv[0]); return 1; } _NSGetExecutablePath(buf, &size); if (size > MAXPATHLEN * MAXPATHLEN) { fprintf(stderr, "_NSGetExecutablePath size %u is too long for a path\n", (unsigned int) size); return 2; } buffer = (char *)malloc(size); if (!buffer) { perror("malloc"); return 3; } result = _NSGetExecutablePath(buffer, &size); if (result != 0) { fprintf(stderr, "_NSGetExecutablePath returned %i for a size of %u\n", result, (unsigned int) size); return 4; } tidied = realpath(buffer, NULL); if (!tidied) { perror("realpath"); return 5; } free(buffer); if (*tidied != '/') { fprintf(stderr, "Not an absolute path: '%s'\n", tidied); return 6; } if (strstr(tidied, "/./")) { fprintf(stderr, "Contains /./: '%s'\n", tidied); return 7; } if (strstr(tidied, "/../")) { fprintf(stderr, "Contains /../: '%s'\n", tidied); return 8; } tidied_leaf = strrchr(tidied, '/'); if (strcmp(tidied_leaf, argv_leaf) != 0) { fprintf(stderr, "Leafnames differ: '%s' vs '%s'\n", argv[0], tidied); return 9; } free(tidied); return 0; } EOM val=$undef set try if eval $compile; then if $run ./try; then echo "You can use _NSGetExecutablePath to find the executing program." >&4 val="$define" else echo "Nope, _NSGetExecutablePath doesn't work here." >&4 fi else echo "I'm unable to compile the test program." >&4 echo "I'll assume no _NSGetExecutablePath here." >&4 fi $rm_try set usensgetexecutablepath eval $setvar metaconfig-debian-perl-5.26.1/U/perl/useperlio.U000066400000000000000000000014641316016665300214200ustar00rootroot00000000000000?RCS: $Id: d_perlio.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: d_perlio.U,v $ ?RCS: ?MAKE:useperlio: Myread Oldconfig Setvar ?MAKE: -pick add $@ %< ?Y:TOP ?S:useperlio: ?S: This variable conditionally defines the USE_PERLIO symbol, ?S: and indicates that the PerlIO abstraction should be ?S: used throughout. ?S:. ?C:USE_PERLIO: ?C: This symbol, if defined, indicates that the PerlIO abstraction should ?C: be used throughout. If not defined, stdio should be ?C: used in a fully backward compatible manner. ?C:. ?H:?%<:#ifndef USE_PERLIO ?H:?%<:#$useperlio USE_PERLIO /**/ ?H:?%<:#endif ?H:. : Check if we want perlio useperlio="$define" metaconfig-debian-perl-5.26.1/U/perl/usequadmath.U000066400000000000000000000020231316016665300217220ustar00rootroot00000000000000?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:usequadmath: Setvar cat uselongdouble ?MAKE: -pick add $@ %< ?S:usequadmath: ?S: This variable conditionally defines the USE_QUADMATH symbol, ?S: and indicates that the quadmath library __float128 long doubles ?S: should be used when available. ?S:. ?C:USE_QUADMATH: ?C: This symbol, if defined, indicates that the quadmath library should ?C: be used when available. ?C:. ?H:?%<:#ifndef USE_QUADMATH ?H:?%<:#$usequadmath USE_QUADMATH /**/ ?H:?%<:#endif ?H:. : Check if quadmath is requested case "$usequadmath" in "$define"|true|[yY]*) usequadmath="$define" ;; *) usequadmath="$undef" ;; esac : Fail if both uselongdouble and usequadmath are requested case "$usequadmath:$uselongdouble" in define:define) $cat <&4 *** You requested the use of the quadmath library and use *** of long doubles. *** *** Please select one or the other. EOM exit 1 ;; esac metaconfig-debian-perl-5.26.1/U/perl/usesocks.U000066400000000000000000000024621316016665300212470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:usesocks: Myread Oldconfig Setvar ?MAKE: -pick add $@ %< ?Y:TOP ?S:usesocks: ?S: This variable conditionally defines the USE_SOCKS symbol, ?S: and indicates that Perl should be built to use SOCKS. ?S:. ?C:USE_SOCKS: ?C: This symbol, if defined, indicates that Perl should ?C: be built to use socks. ?C:. ?H:?%<:#ifndef USE_SOCKS ?H:?%<:#$usesocks USE_SOCKS /**/ ?H:?%<:#endif ?H:. ?LINT:set usesocks ?INIT:: set usesocks on the Configure command line to enable socks. : Check is we will use socks ?X: We should really have some explanatory text here, and some ?X: automatic setting of sensible defaults. case "$usesocks" in $define|true|[yY]*) dflt='y';; *) dflt='n';; esac cat </dev/null 2>&1 + if cmp -s y.tab.c perly.c; then + rm -f y.tab.c + else + echo "perly.y -> perly.c" >&2 + mv -f y.tab.c perly.c + chmod u+w perly.c + sed -e 's/fprintf *( *stderr *,/PerlIO_printf(Perl_debug_log,/g' \ + -e 's/y\.tab/perly/g' perly.c >perly.tmp && mv perly.tmp perly.c + xxx="$xxx perly.c" + fi + if cmp -s y.tab.h perly.h; then + rm -f y.tab.h + else + echo "perly.y -> perly.h" >&2 + mv -f y.tab.h perly.h + xxx="$xxx perly.h" + fi + echo "x2p/a2p.y" >&2 + cd x2p + rm -f y.tab.c y.tab.h + yacc -d a2p.y >/dev/null 2>&1 + if cmp -s y.tab.c a2p.c + then + rm -f y.tab.c + else + echo "a2p.y -> a2p.c" >&2 + mv -f y.tab.c a2p.c + chmod u+w a2p.c + sed -e 's/fprintf *( *stderr *,/PerlIO_printf(Perl_debug_log,/g' \ + -e 's/y\.tab/a2p/g' a2p.c >a2p.tmp && mv a2p.tmp a2p.c + xxx="$xxx a2p.c" + fi + if cmp -s y.tab.h a2p.h + then + rm -f y.tab.h + else + echo "a2p.h -> a2p.h" >&2 + mv -f y.tab.h a2p.h + xxx="$xxx a2p.h" + fi + cd .. + case "$xxx" in + '') echo "No parser files were regenerated. That's okay." >&2 ;; + esac + ;; +esac + metaconfig-debian-perl-5.26.1/U/protos/000077500000000000000000000000001316016665300176425ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/protos/Hasfield.U000066400000000000000000000024011316016665300215040ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: This unit generates a $hasfield string that is used internally ?X: by Configure to check if this system has a field for a ?X: particular struct (of if this system has a particular struct!) ?X: ?X: To use it, say something like: ?X: set d_statblocks stat st_blocks i_sysstat sys/stat.h ?X: eval $hasfield ?X: Or, for more complicated sets of headers, do something like ?X: hdrs="$define sys/foo.h ?X: $i_sysbar sys/bar.h ?X: $i_syszot sys/zot.h ?X: $i_zappa zappa.h" ?X: set d_statblocks stat st_blocks $hdrs ?X: eval $hasfield ?X: ?MAKE:Hasfield: Setvar rm_try test Compile ?MAKE: -pick add $@ %< ?T:varname struct field ?V:hasfield : Define hasfield macro for Configure internal use hasfield='varname=$1; struct=$2; field=$3; shift; shift; shift; while $test $# -ge 2; do case "$1" in $define) echo "#include <$2>";; esac ; shift 2; done > try.c; echo "int main () { struct $struct foo; char* bar; bar = (char*)foo.$field; }" >> try.c; set try; if eval $compile; then val="$define"; else val="$undef"; fi; set $varname; eval $setvar; $rm_try' metaconfig-debian-perl-5.26.1/U/protos/Hasproto.U000066400000000000000000000025011316016665300215650ustar00rootroot00000000000000?RCS: $Id: Hasproto.U $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: This unit generates a $hasproto string that is used internally ?X: by Configure to check if this system has a prototype for a ?X: particular function ?X: ?X: To use it, say something like: ?X: set d_getnetent_proto getnetent $i_netdb netdb.h ?X: eval $hasproto ?X: Or, for more complicated sets of headers, do something like ?X: hdrs="$define sys/types.h ?X: $i_systime sys/time.h ?X: $i_sysselct sys/select.h ?X: $i_netdb netdb.h" ?X: set d_getnetent_proto getnetent $hdrs ?X: eval $hasproto ?X: ?MAKE:Hasproto: Setvar cppstdin cppflags cppminus contains rm_try test ?MAKE: -pick add $@ %< ?T:func varname ?F:!try.c ?V:hasproto : Define hasproto macro for Configure internal use hasproto='varname=$1; func=$2; shift; shift; while $test $# -ge 2; do case "$1" in $define) echo "#include <$2>";; esac ; shift 2; done > try.c; $cppstdin $cppflags $cppminus < try.c > tryout.c 2>/dev/null; if $contains "$func.*(" tryout.c >/dev/null 2>&1; then echo "$func() prototype found."; val="$define"; else echo "$func() prototype NOT found."; val="$undef"; fi; set $varname; eval $setvar; $rm_try tryout.c' metaconfig-debian-perl-5.26.1/U/protos/Hasstruct.U000066400000000000000000000022711316016665300217520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: This unit generates a $hasstruct string that is used internally ?X: by Configure to check if this system has a field for a ?X: particular struct (of if this system has a particular struct!) ?X: ?X: To use it, say something like: ?X: set d_statblocks stat i_sysstat sys/stat.h ?X: eval $hasstruct ?X: Or, for more complicated sets of headers, do something like ?X: hdrs="$define sys/foo.h ?X: $i_sysbar sys/bar.h ?X: $i_syszot sys/zot.h ?X: $i_zappa zappa.h" ?X: set d_statblocks stat $hdrs ?X: eval $hasstruct ?X: ?MAKE:Hasstruct: Setvar rm_try test Compile ?MAKE: -pick add $@ %< ?T:varname struct ?V:hasstruct : Define hasstruct macro for Configure internal use hasstruct='varname=$1; struct=$2; shift; shift; while $test $# -ge 2; do case "$1" in $define) echo "#include <$2>";; esac ; shift 2; done > try.c; echo "int main () { struct $struct foo; }" >> try.c; set try; if eval $compile; then val="$define"; else val="$undef"; fi; set $varname; eval $setvar; $rm_try' metaconfig-debian-perl-5.26.1/U/protos/Protochk.U000066400000000000000000000075271316016665300215740ustar00rootroot00000000000000?RCS: $Id: Protochk.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?X: This unit generates a ./protochk script that is used internally ?X: by Configure to check if this system will accept a particular ?X: prototype. ?X: ?X: To use it, say something like: ?X: hdrs="$define sys/types.h ?X: $i_systime sys/time.h ?X: $i_sysselct sys/select.h ?X: $d_socket sys/socket.h" ?X: $xxx='fd_set *' ?X: try='extern int select _((int, $xxx, $xxx, $xxx, struct timeval *'));' ?X: if ./protochk "$try" $hdrs; then ?X: echo "Your system accepts $xxx for the arguments to select." ?X: fi ?X: (Of course select is harder, since the first arg can be int, ?X: size_t, or unsigned long, and the last arg may or may not have a ?X: 'const' before the 'struct timeval' :-(. Also SunOS 4.1.3 doesn't ?X: provide a select prototype so the compiler accepts anything :-). ?X: ?X: The C compiler on QNX warns about invalid pointer types, but ?X: still exits with a 0 exit status, so it's not much help here. ?X: (It does correctly detect incorrect non-pointer arguments). ?X: Still, since QNX is a POSIX-ish system, just make your first ?X: a POSIX-ish one, and QNX will probably accept it. ?X: ?X: For determining argument types, your compiler must support ?X: prototypes, and the header files must use them. Determining ?X: return types, however, is easier. Just give an ridiculous ?X: return type, something like ?X: ./protochk 'extern int atof _((void));' $i_stdlib stdlib.h ?X: that should surely fail if atof() is defined in ?X: ?X: There is also an 'escape' hatch built in. If you have a pair ?X: of args 'literal 'stuff' then 'stuff' gets included literally ?X: into the test program. This could be useful for doing something ?X: like ?X: hdrs="$define stdio.h ?X: $define sys/types.h" ?X: ./protochk 'extern int fsetpos(FILE *, Fpos_t);' $args \ ?X: 'literal' '#define Fpos_t long long' ?X: but you have to be really careful about the spaces in "literal". ?X: ?X: Andy Dougherty Feb. 1998 ?MAKE:Protochk: cat rm_try startsh eunicefix +cc +optimize +ccflags \ prototype i_pthread usethreads ?MAKE: -pick add $@ %< ?F:./protochk ?X: Comfort metalint. All these are actually used in the protochk script. ?T:foo status pthread_h_done ?LINT: change cc optimize ccflags prototype define rm_try ?LINT: extern pthread_h_first ?LINT: change pthread_h_first ?LINT: change usethreads ?LINT: change i_pthread : define a function to check prototypes $cat > protochk <> protochk <<'EOSH' $rm_try foo="$1" shift while test $# -ge 2; do case "$1" in $define) echo "#include <$2>" >> try.c ;; literal) echo "$2" >> try.c ;; esac # Extra magic for the benefit of systems that need pthread.h # to be included early to correctly detect threadsafe functions. # Such functions must guarantee themselves, though, that the usethreads # and i_pthread have been defined, before calling protochk. if test "$usethreads" = "$define" -a "$i_pthread" = "$define" -a "$pthread_h_first" = "$define" -a "$pthread_h_done" = ""; then echo "#include " >> try.c pthread_h_done=yes fi shift 2 done test "$prototype" = "$define" && echo '#define CAN_PROTOTYPE' >> try.c cat >> try.c <<'EOCP' #ifdef CAN_PROTOTYPE #define _(args) args #else #define _(args) () #endif EOCP echo "$foo" >> try.c ?X: Just so we have something to compile. echo 'int no_real_function_has_this_name _((void)) { return 0; }' >> try.c $cc $optimize $ccflags -c try.c > /dev/null 2>&1 status=$? $rm_try exit $status EOSH chmod +x protochk $eunicefix protochk metaconfig-debian-perl-5.26.1/U/protos/d_drand48proto.U000066400000000000000000000022371316016665300226270ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_drand48proto: Hasproto i_stdlib i_unistd ?MAKE: -pick add $@ %< ?S:d_drand48proto: ?S: This variable conditionally defines the HAS_DRAND48_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the drand48() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_DRAND48_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the drand48() function. Otherwise, it is up ?C: to the program to supply one. A good guess is ?C: extern double drand48(void); ?C:. ?H:#$d_drand48proto HAS_DRAND48_PROTO /**/ ?H:. ?LINT:set d_drand48proto : see if prototype for drand48 is available echo " " set d_drand48proto drand48 $i_stdlib stdlib.h $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/d_gethostprotos.U000066400000000000000000000026651316016665300232300ustar00rootroot00000000000000?RCS: $Id: d_gethostprotos.U,v $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_gethostprotos : Hasproto i_netdb ?MAKE: -pick add $@ %< ?S:d_gethostprotos: ?S: This variable conditionally defines the HAS_GETHOST_PROTOS symbol, ?S: which indicates to the C program that supplies ?S: prototypes for the various gethost*() functions. ?S: See also netdbtype.U for probing for various netdb types. ?S:. ?C:HAS_GETHOST_PROTOS: ?C: This symbol, if defined, indicates that includes ?C: prototypes for gethostent(), gethostbyname(), and ?C: gethostbyaddr(). Otherwise, it is up to the program to guess ?C: them. See netdbtype.U for probing for various Netdb_xxx_t types. ?C:. ?H:#$d_gethostprotos HAS_GETHOST_PROTOS /**/ ?H:. ?LINT:set d_gethostprotos ?X: This test actually only checks for gethostent() and assumes the ?X: others follow suit. This test fails for ChorusOS, which has ?X: gethostbyname and gethostbyaddr, but not gethostent. : see if prototypes for various gethostxxx netdb.h functions are available echo " " set d_gethostprotos gethostent $i_netdb netdb.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/d_getnetprotos.U000066400000000000000000000023501316016665300230300ustar00rootroot00000000000000?RCS: $Id: d_getnetprotos.U,v $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getnetprotos : Hasproto i_netdb ?MAKE: -pick add $@ %< ?S:d_getnetprotos: ?S: This variable conditionally defines the HAS_GETNET_PROTOS symbol, ?S: which indicates to the C program that supplies ?S: prototypes for the various getnet*() functions. ?S: See also netdbtype.U for probing for various netdb types. ?S:. ?C:HAS_GETNET_PROTOS: ?C: This symbol, if defined, indicates that includes ?C: prototypes for getnetent(), getnetbyname(), and ?C: getnetbyaddr(). Otherwise, it is up to the program to guess ?C: them. See netdbtype.U for probing for various Netdb_xxx_t types. ?C:. ?H:#$d_getnetprotos HAS_GETNET_PROTOS /**/ ?H:. ?LINT:set d_getnetprotos : see if prototypes for various getnetxxx netdb.h functions are available echo " " set d_getnetprotos getnetent $i_netdb netdb.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/d_getprotoprotos.U000066400000000000000000000024061316016665300234070ustar00rootroot00000000000000?RCS: $Id: d_getprotoprotos.U,v $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getprotoprotos : Hasproto i_netdb ?MAKE: -pick add $@ %< ?S:d_getprotoprotos: ?S: This variable conditionally defines the HAS_GETPROTO_PROTOS symbol, ?S: which indicates to the C program that supplies ?S: prototypes for the various getproto*() functions. ?S: See also netdbtype.U for probing for various netdb types. ?S:. ?C:HAS_GETPROTO_PROTOS: ?C: This symbol, if defined, indicates that includes ?C: prototypes for getprotoent(), getprotobyname(), and ?C: getprotobyaddr(). Otherwise, it is up to the program to guess ?C: them. See netdbtype.U for probing for various Netdb_xxx_t types. ?C:. ?H:#$d_getprotoprotos HAS_GETPROTO_PROTOS /**/ ?H:. ?LINT:set d_getprotoprotos : see if prototypes for various getprotoxxx netdb.h functions are available echo " " set d_getprotoprotos getprotoent $i_netdb netdb.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/d_getservprotos.U000066400000000000000000000023671316016665300232310ustar00rootroot00000000000000?RCS: $Id: d_getservprotos.U,v $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_getservprotos : Hasproto i_netdb ?MAKE: -pick add $@ %< ?S:d_getservprotos: ?S: This variable conditionally defines the HAS_GETSERV_PROTOS symbol, ?S: which indicates to the C program that supplies ?S: prototypes for the various getserv*() functions. ?S: See also netdbtype.U for probing for various netdb types. ?S:. ?C:HAS_GETSERV_PROTOS: ?C: This symbol, if defined, indicates that includes ?C: prototypes for getservent(), getservbyname(), and ?C: getservbyaddr(). Otherwise, it is up to the program to guess ?C: them. See netdbtype.U for probing for various Netdb_xxx_t types. ?C:. ?H:#$d_getservprotos HAS_GETSERV_PROTOS /**/ ?H:. ?LINT:set d_getservprotos : see if prototypes for various getservxxx netdb.h functions are available echo " " set d_getservprotos getservent $i_netdb netdb.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/d_lseekproto.U000066400000000000000000000022221316016665300224600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:d_lseekproto: Hasproto i_systypes i_unistd ?MAKE: -pick add $@ %< ?S:d_lseekproto: ?S: This variable conditionally defines the HAS_LSEEK_PROTO symbol, ?S: which indicates to the C program that the system provides ?S: a prototype for the lseek() function. Otherwise, it is ?S: up to the program to supply one. ?S:. ?C:HAS_LSEEK_PROTO: ?C: This symbol, if defined, indicates that the system provides ?C: a prototype for the lseek() function. Otherwise, it is up ?C: to the program to supply one. A good guess is ?C: extern off_t lseek(int, off_t, int); ?C:. ?H:#$d_lseekproto HAS_LSEEK_PROTO /**/ ?H:. ?LINT:set d_lseekproto : see if prototype for lseek is available echo " " set d_lseekproto lseek $i_systypes sys/types.h $i_unistd unistd.h eval $hasproto metaconfig-debian-perl-5.26.1/U/protos/netdbtype.U000066400000000000000000000126561316016665300220000ustar00rootroot00000000000000?RCS: $Id: netdbtype.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: netdbtype.U,v $ ?RCS: ?MAKE:netdb_host_type netdb_hlen_type netdb_name_type netdb_net_type: \ Protochk Oldconfig Myread cat \ d_gethbyaddr d_gethbyname d_getnbyaddr \ i_niin i_netdb i_unistd d_socket sizetype extern_C ?MAKE: -pick add $@ %< ?S:netdb_host_type: ?S: This variable holds the type used for the 1st argument to ?S: gethostbyaddr(). Usually, this is char * or void *, possibly ?S: with or without a const prefix. ?S: This is only useful if you have gethostbyaddr(), naturally. ?S:. ?S:netdb_hlen_type: ?S: This variable holds the type used for the 2nd argument to ?S: gethostbyaddr(). Usually, this is int or size_t or unsigned. ?S: This is only useful if you have gethostbyaddr(), naturally. ?S:. ?S:netdb_name_type: ?S: This variable holds the type used for the argument to ?S: gethostbyname(). Usually, this is char * or const char *. ?S: This is only useful if you have gethostbyname(), naturally. ?S:. ?S:netdb_net_type: ?S: This variable holds the type used for the 1st argument to ?S: getnetbyaddr(). Usually, this is int or long. ?S: This is only useful if you have getnetbyaddr(), naturally. ?S:. ?C:Netdb_host_t: ?C: This symbol holds the type used for the 1st argument ?C: to gethostbyaddr(). ?C:. ?C:Netdb_hlen_t: ?C: This symbol holds the type used for the 2nd argument ?C: to gethostbyaddr(). ?C:. ?C:Netdb_name_t: ?C: This symbol holds the type used for the argument to ?C: gethostbyname(). ?C:. ?C:Netdb_net_t: ?C: This symbol holds the type used for the 1st argument to ?C: getnetbyaddr(). ?C:. ?H:#define Netdb_host_t $netdb_host_type /**/ ?H:#define Netdb_hlen_t $netdb_hlen_type /**/ ?H:#define Netdb_name_t $netdb_name_type /**/ ?H:#define Netdb_net_t $netdb_net_type /**/ ?H:. ?T:xxx yyy try hdrs @if netdb_host_type || Netdb_host_t || netdb_hlen_type || Netdb_hlen_t : check for type of arguments to gethostbyaddr. if test "X$netdb_host_type" = X -o "X$netdb_hlen_type" = X; then case "$d_gethbyaddr" in $define) $cat < ?RCS: ?RCS: $Log: selecttype.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 16:20:09 ram ?RCS: patch61: always include when available for test ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 14:14:06 ram ?RCS: patch56: removed harmful spaces in assignment ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 07:06:31 ram ?RCS: patch30: created by ADO ?RCS: ?MAKE:selecttype: Protochk Oldconfig Myread cat \ d_fd_set d_select d_socket i_systime i_sysselct extern_C ?MAKE: -pick add $@ %< ?S:selecttype: ?S: This variable holds the type used for the 2nd, 3rd, and 4th ?S: arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET ?S: is defined, and 'int *' otherwise. This is only useful if you ?S: have select(), naturally. ?S:. ?C:Select_fd_set_t: ?C: This symbol holds the type used for the 2nd, 3rd, and 4th ?C: arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET ?C: is defined, and 'int *' otherwise. This is only useful if you ?C: have select(), of course. ?C:. ?H:#define Select_fd_set_t $selecttype /**/ ?H:. ?T:xxx nfd tmo try hdrs val : check for type of arguments to select. case "$selecttype" in '') case "$d_select" in $define) echo " " $cat < { "gnu" => "GNU", # output of uname }, "perl/patchlevel.U" => { "subversion" => "Subversion", # perl's subversion, not svn }, ); my %skip = map { m/^(\S+)/; lc $1 => 1 } ; if (open my $fh, "<", "/pro/3gl/CPAN/perl-git/Porting/Glossary") { while (<$fh>) { m/^(\S+)\s+\(\S+\)\s*:\s*$/ and $skip{lc $1}++; } } if (open my $fh, "<", "/pro/3gl/CPAN/perl-git/config_h.SH") { while (<$fh>) { m{^/\* ([A-Z_]+):$} and $skip{lc $1}++; } } my $asp = Text::Aspell->new; foreach my $u (sort @u) { open my $fh, "<", $u; my ($m) = ($u =~ m{([^/]+)\.U$}); $skip{lc $m}++; my $n = 0; while (<$fh>) { my $loc = sprintf "%-27s %4d", $u, ++$n; m{^(?| \?RCS: \s+ (\w.*) | \?C: \s+ (\w.*) | \?S: \s+ (\w.*) | \?INIT:: \s+ (\w.*) | \?X: \s* (\w.*) | : \s+ (\w.*) )}x or m{echo \s+ (?| "([^"]+)" | '([^']+)' )}x or next; my $t = $1; $t =~ s/\b( [Ww]as | [Dd]id | [Ii]s | [Cc]ould | [Ss]hould | [Dd]oes | [Nn]eed | [Aa]re ) n't \b/$1 not/gx; $t =~ s{\b[fh]tt?ps?://\S+}{}g; # possible url $t =~ s{<\S+\@\S+>}{}g; # possible e-mail address $t =~ s{<\S+\.h>}{}g; # possibly header file reference $t =~ s{"\S+\.h"}{}g; # possibly header file reference my @w = split m([!-#'-,./:-?[-^`{-~\s]+) => $t; # CommonMistakes my ($err, %seen); $err = _check_case (\@w); if (ref $err eq "HASH" && keys %$err) { for (sort keys %$err) { exists $ignore{$u}{$_} and next; $seen{$_}++ and next;; printf "%s %-20s => %s\n", $loc, $_, $err->{$_}; } } $err = _check_common (\@w); if (ref $err eq "HASH" && keys %$err) { for (sort keys %$err) { exists $ignore{$u}{$_} and next; $seen{$_}++ and next;; printf "%s %-20s => %s\n", $loc, $_, $err->{$_}; } } # aspell for (grep { !m/[-0-9_\$@%~]/ } @w) { exists $ignore{$u}{$_} and next; exists $skip{lc $_} and next; $asp->check ($_) and next; my @s = $asp->suggest ($_); printf "%s %-20s => %s\n", $loc, $_, "(@s)"; } } } __END__ abcdef accessx aintl aix alignedness andreas ansic archlibs arg argc args argv arrgh asctime asm atof attrlist backquotes backslashitis backticks basename basenames baz bcopy bene bincompat bitness bourne braindead brand bsd bsdtypes buf buglet builtin calloc canonicalize castneg catify cbu ccs cd cdpath ceil cflags charvsprintf chorusos chown cjk clearenv clib closedir cmd cmdline cmsghdr cnt conf config configpm const copysignl cposix css csym ctermid cthreads ctime ctype cygwin datatype dbm dbminit dec denormalized dev dflt dg difftime dir dirent dirfd dirname dirnames dirstream djgpp dl dld dll dlobj dlopen dlsym doughera dougherty drepper dst dwhatever dynaloader dynix eaccess edu elif emx emximp endgrent endhostent endian endif endnetent endprotoent endpwent endservent endspent enoent enosys enum enums env eof eofpipe eom eot eqnchar errno errnolistc esac euid eval evals exe executables extern extliblist extutils fallthrough fastread faststdio fchdir fcntl fd fflush fi fielnames fifos filename filenames filesystem filesystems finitel fiosnbio firstkey fixme fn fndelay foo fp fpa fpclass fpclassify fpclassl fprintf fread freebsd frexpl fseek fseeko fsetpos fstat fstatfs fstatvfs fsync ftell ftello furuseth futimes fwrite gconvert gcvt gdbm getaddrinfo getc getcwd getdtablesize getespwnam getfile getfsstat getgid getgrent getgrgid getgrnam gethost gethostbyaddr gethostbyname gethostent gethostname gethostxxx getitimer getlogin getmnt getmntent getmntinfo getnameinfo getnet getnetbyaddr getnetbyname getnetent getnetxxx getpagesize getpgrp getpos getproto getprotobyaddr getprotobyname getprotobynumber getprotoent getprotoxxx getprpwnam getpw getpwent getpwnam getpwuid getrlimit getrusage getsbyname getsbyport getserv getservbyaddr getservbyname getservbyport getservent getservxxx getspent getspnam getuid getvar gid gids glibc gmtime gnu gnulibc grp hallvard hardwire hardwiring hasmntopt hdrs hexadecimal hietaniemi hmb hostname hpux html htonl htons hup hurd iconv ieeefp ifdef ifndef ihdr ilogbl incpth incpush indices inet inhdr init initprog inlibc inode inodes installdirs installlocalarch installlocallib installperl ints inttypes iovec ip ipc irix is isascii isblank isc isdone isfinite isinf isnan isnanl ivs ix jaeger jarkko jhi joinable keepalive koenig korn k&r lafayette langinfo lchmod lchown ldopts lex libexec libexp libm libso libsocks libutil llseek loc localarchexp locallibexp localtime loclist login logname longjmp longlong lookup lookups lorder lseek lst lutimes lvalue machten madvise makedist makefile makefiles makemaker malloc mandirstyle manfredi manoj mansrc memchr memcmp memcpy memmove merijn metaconfig metalint mips misconfigured mk mkdtemp mkfifo mknod mkstemp mkstemps mktime mman mmap mntent modfl monash morebits mpe mprotect mqueue msg msghdr msvc multiplatform myconfig myinit myread nan nanosleep nanq nans ndbm ndir netbsd netdb netdbtype netinet netinfo netwide neumann nevermind next nextkey nfs nis nlist nofile nonnull nonxs noreturn nota nrand nsig ntohl ntohs nvs nwc odbm ok okamoto oldconfig oldprefix oldsocket oldsyms opcode optdef os osf oslevel pagefull pase passwd pathname pathnames pc perldoc perlio perlmain perly pgrp pid pids popen posix posixized posthint prctl prefixvar prepend prepended preprocess preprocessor printf prot pthread pthreads ptr ptx pvs pwd qgcvt qnx readdir readv realloc realpath realsilent recompiles recvmsg redhat reentr resolv ret rp rsrc ruid runtime rusage sahlbach salzenberg sbin sbrk scalbnl scanf sched sco sdbm sem semctl semun sendmsg setgid setgrent sethostent setitimer setjmp setlocale setnetent setpgrp setpos setproctitle setprotoent setpwent setresgid setresuid setrgid setrlimit setservent setsockopt setspent setuid setvar setvbuf sfio sgi shlib shm shmat sig sigabrt sigaction sigarraysize sigiot siglongjmp signbit signedchar signedness sigprocmask sigqueue sigquit sigrtmax sigsetjmp sigstksize sigstksz sigtimedwait sigtyp sigwait sigwaitinfo sigxxx sigzero sitecustomize sitescriptdirexp sizeof skimo sl snprintf sockaddr sockatmark socketpair socklib solaris sony sprintf sqrtl srand srandom src srivastava statfs statvfs stdarg stdbool stderr stdin stdlib stdout strerror strftime stringification stringifies strlcat strlcpy strlen strptime strtold strtoll strtoq strtoul strtoull strtouq struct structs su subdirectories subdirectory subprocesses subr subshell subversions suid sunmath sunos sunworks superseed symlink symlinking symlinks sys syscall syscalls sysctl syslib syslog syspath systemid systype sysv targetdir targetfrom targethost targetmkdir targetrun targetto targetuser tcp telldir thatlib thislib timegm timestamp timestamps timeval timevals tm tmp tmpfile tmpnam tromey tryh trylist tsort ttyname tye typedef typedefs tzset ualarm ucb uid uids uint uio uis ulimit ulrich ultrix undef undefines undefining undetached unicos unistd unix unlink unordered unorderedl unsetenv unsplit uppercased usg ushort usleep usr ustat util utimes utsname uu uvs ux varargs variadic varval venix verdoolaege versa versioned versioning vfork vfs voidsig voidused vos vpath vprintf vsnprintf vsprintf whoami wifexited wifxxx wildcard wildcards winfried workshop writeup writev xenix xlc xrun xs xscan xvt yp ypmatch zsh metaconfig-debian-perl-5.26.1/U/threads/000077500000000000000000000000001316016665300177465ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/U/threads/archname.U000066400000000000000000000127711316016665300216620ustar00rootroot00000000000000?RCS: $Id: archname.U,v 3.0.1.3 1997/02/28 15:24:32 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: archname.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:24:32 ram ?RCS: patch61: changed the way the archname is mangled from uname ?RCS: ?RCS: Revision 3.0.1.2 1995/05/12 12:05:24 ram ?RCS: patch54: protect against spaces in "uname -m" output (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1995/02/15 14:14:21 ram ?RCS: patch51: created ?RCS: ?MAKE:archname myarchname useversionedarchname: sed Loc Myread Oldconfig \ osname test rm usethreads usemultiplicity use64bitint use64bitall \ archname64 uselongdouble longdblsize doublesize targetarch Setvar \ api_versionstring usequadmath ?MAKE: -pick add $@ %< ?S:archname: ?S: This variable is a short name to characterize the current ?S: architecture. It is used mainly to construct the default archlib. ?S:. ?S:myarchname: ?S: This variable holds the architecture name computed by Configure in ?S: a previous run. It is not intended to be perused by any user and ?S: should never be set in a hint file. ?S:. ?S:useversionedarchname: ?S: This variable indicates whether to include the $api_versionstring ?S: as a component of the $archname. ?S:. ?C:ARCHNAME: ?C: This symbol holds a string representing the architecture name. ?C: It may be used to construct an architecture-dependant pathname ?C: where library files may be held under a private library, for ?C: instance. ?C:. ?H:#define ARCHNAME "$archname" /**/ ?H:. ?T:xxx tarch ?F:!archname.cbu ?INIT:archname='' : determine the architecture name echo " " ?X: We always recompute archname in case osname changes. However, we need ?X: to be careful since, as ADO rightfully pointed out, some systems pick ?X: silly architecture names (0001307135000-aix on AIX or 9000/715-ux under ?X: HP-UX). Therefore, we allow hint files to superseed our guess and ask ?X: the user for confirmation. if xxx=`./loc arch blurfl $pth`; $test -f "$xxx"; then tarch=`arch`"-$osname" elif xxx=`./loc uname blurfl $pth`; $test -f "$xxx" ; then if uname -m > tmparch 2>&1 ; then tarch=`$sed -e 's/ *$//' -e 's/ /_/g' \ -e 's/$/'"-$osname/" tmparch` else tarch="$osname" fi $rm -f tmparch else tarch="$osname" fi case "$myarchname" in ''|"$tarch") ;; *) echo "(Your architecture name used to be $myarchname.)" archname='' ;; esac case "$targetarch" in '') ;; ?X: Very GCCian. *) archname=`echo $targetarch|sed 's,^[^-]*-,,'` ;; esac myarchname="$tarch" case "$archname" in '') dflt="$tarch";; *) dflt="$archname";; esac rp='What is your architecture name' . ./myread archname="$ans" : optionally add API version to the architecture for versioned archlibs case "$useversionedarchname" in $define|true|[yY]*) dflt='y';; *) dflt='n';; esac rp='Add the Perl API version to your archname?' . ./myread case "$ans" in y|Y) useversionedarchname="$define" ;; *) useversionedarchname="$undef" ;; esac case "$useversionedarchname" in $define) case "$archname" in *-$api_versionstring) echo "...and architecture name already has -$api_versionstring" >&4 ;; *) archname="$archname-$api_versionstring" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac @if usethreads case "$usethreads" in $define) echo "Threads selected." >&4 case "$archname" in *-thread*) echo "...and architecture name already has -thread." >&4 ;; *) archname="$archname-thread" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac @end @if usemultiplicity case "$usemultiplicity" in $define) echo "Multiplicity selected." >&4 case "$archname" in *-multi*) echo "...and architecture name already has -multi." >&4 ;; *) archname="$archname-multi" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac @end @if use64bitint case "$use64bitint$use64bitall" in *"$define"*) case "$archname64" in '') echo "This architecture is naturally 64-bit, not changing architecture name." >&4 ;; *) case "$use64bitint" in "$define") echo "64 bit integers selected." >&4 ;; esac case "$use64bitall" in "$define") echo "Maximal 64 bitness selected." >&4 ;; esac case "$archname" in *-$archname64*) echo "...and architecture name already has $archname64." >&4 ;; *) archname="$archname-$archname64" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac esac @end @if uselongdouble case "$uselongdouble" in $define) echo "Long doubles selected." >&4 case "$longdblsize" in $doublesize) echo "...but long doubles are equal to doubles, not changing architecture name." >&4 ;; *) case "$archname" in *-ld*) echo "...and architecture name already has -ld." >&4 ;; *) archname="$archname-ld" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac ;; esac @end @if usequadmath case "$usequadmath" in $define) echo "quadmath selected." >&4 case "$archname" in *-quadmath*) echo "...and architecture name already has -quadmath." >&4 ;; *) archname="$archname-quadmath" echo "...setting architecture name to $archname." >&4 ;; esac ;; esac @end if $test -f archname.cbu; then echo "Your platform has some specific hints for architecture name, using them..." . ./archname.cbu fi metaconfig-debian-perl-5.26.1/U/threads/d_asctime_r.U000066400000000000000000000053161316016665300223520ustar00rootroot00000000000000?RCS: $Id: d_asctime_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_asctime_r asctime_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_time i_systime extern_C ?MAKE: -pick add $@ %< ?S:d_asctime_r: ?S: This variable conditionally defines the HAS_ASCTIME_R symbol, ?S: which indicates to the C program that the asctime_r() ?S: routine is available. ?S:. ?S:asctime_r_proto: ?S: This variable encodes the prototype of asctime_r. ?S: It is zero if d_asctime_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r ?S: is defined. ?S:. ?C:HAS_ASCTIME_R: ?C: This symbol, if defined, indicates that the asctime_r routine ?C: is available to asctime re-entrantly. ?C:. ?C:ASCTIME_R_PROTO: ?C: This symbol encodes the prototype of asctime_r. ?C: It is zero if d_asctime_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_asctime_r ?C: is defined. ?C:. ?H:#$d_asctime_r HAS_ASCTIME_R /**/ ?H:#define ASCTIME_R_PROTO $asctime_r_proto /**/ ?H:. ?T:try hdrs d_asctime_r_proto : see if asctime_r exists set asctime_r d_asctime_r eval $inlibc case "$d_asctime_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" case "$d_asctime_r_proto:$usethreads" in ":define") d_asctime_r_proto=define set d_asctime_r_proto asctime_r $hdrs eval $hasproto ;; *) ;; esac case "$d_asctime_r_proto" in define) case "$asctime_r_proto" in ''|0) try='char* asctime_r(const struct tm*, char*);' ./protochk "$extern_C $try" $hdrs && asctime_r_proto=B_SB ;; esac case "$asctime_r_proto" in ''|0) try='char* asctime_r(const struct tm*, char*, int);' ./protochk "$extern_C $try" $hdrs && asctime_r_proto=B_SBI ;; esac case "$asctime_r_proto" in ''|0) try='int asctime_r(const struct tm*, char*);' ./protochk "$extern_C $try" $hdrs && asctime_r_proto=I_SB ;; esac case "$asctime_r_proto" in ''|0) try='int asctime_r(const struct tm*, char*, int);' ./protochk "$extern_C $try" $hdrs && asctime_r_proto=I_SBI ;; esac case "$asctime_r_proto" in ''|0) d_asctime_r=undef asctime_r_proto=0 echo "Disabling asctime_r, cannot determine prototype." >&4 ;; * ) case "$asctime_r_proto" in REENTRANT_PROTO*) ;; *) asctime_r_proto="REENTRANT_PROTO_$asctime_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "asctime_r has no prototype, not using it." >&4 ;; esac d_asctime_r=undef asctime_r_proto=0 ;; esac ;; *) asctime_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_crypt_r.U000066400000000000000000000044741316016665300220720ustar00rootroot00000000000000?RCS: $Id: d_crypt_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_crypt_r crypt_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_crypt extern_C ?MAKE: -pick add $@ %< ?S:d_crypt_r: ?S: This variable conditionally defines the HAS_CRYPT_R symbol, ?S: which indicates to the C program that the crypt_r() ?S: routine is available. ?S:. ?S:crypt_r_proto: ?S: This variable encodes the prototype of crypt_r. ?S: It is zero if d_crypt_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r ?S: is defined. ?S:. ?C:HAS_CRYPT_R: ?C: This symbol, if defined, indicates that the crypt_r routine ?C: is available to crypt re-entrantly. ?C:. ?C:CRYPT_R_PROTO: ?C: This symbol encodes the prototype of crypt_r. ?C: It is zero if d_crypt_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_crypt_r ?C: is defined. ?C:. ?H:#$d_crypt_r HAS_CRYPT_R /**/ ?H:#define CRYPT_R_PROTO $crypt_r_proto /**/ ?H:. ?T:try hdrs d_crypt_r_proto : see if crypt_r exists set crypt_r d_crypt_r eval $inlibc case "$d_crypt_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_crypt crypt.h" case "$d_crypt_r_proto:$usethreads" in ":define") d_crypt_r_proto=define set d_crypt_r_proto crypt_r $hdrs eval $hasproto ;; *) ;; esac case "$d_crypt_r_proto" in define) case "$crypt_r_proto" in ''|0) try='char* crypt_r(const char*, const char*, struct crypt_data*);' ./protochk "$extern_C $try" $hdrs && crypt_r_proto=B_CCS ;; esac case "$crypt_r_proto" in ''|0) try='char* crypt_r(const char*, const char*, CRYPTD*);' ./protochk "$extern_C $try" $hdrs && crypt_r_proto=B_CCD ;; esac case "$crypt_r_proto" in ''|0) d_crypt_r=undef crypt_r_proto=0 echo "Disabling crypt_r, cannot determine prototype." >&4 ;; * ) case "$crypt_r_proto" in REENTRANT_PROTO*) ;; *) crypt_r_proto="REENTRANT_PROTO_$crypt_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "crypt_r has no prototype, not using it." >&4 ;; esac d_crypt_r=undef crypt_r_proto=0 ;; esac ;; *) crypt_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_ctermid_r.U000066400000000000000000000042711316016665300223530ustar00rootroot00000000000000?RCS: $Id: d_ctermid_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_ctermid_r ctermid_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads extern_C ?MAKE: -pick add $@ %< ?S:d_ctermid_r: ?S: This variable conditionally defines the HAS_CTERMID_R symbol, ?S: which indicates to the C program that the ctermid_r() ?S: routine is available. ?S:. ?S:ctermid_r_proto: ?S: This variable encodes the prototype of ctermid_r. ?S: It is zero if d_ctermid_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r ?S: is defined. ?S:. ?C:HAS_CTERMID_R: ?C: This symbol, if defined, indicates that the ctermid_r routine ?C: is available to ctermid re-entrantly. ?C:. ?C:CTERMID_R_PROTO: ?C: This symbol encodes the prototype of ctermid_r. ?C: It is zero if d_ctermid_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctermid_r ?C: is defined. ?C:. ?H:#$d_ctermid_r HAS_CTERMID_R /**/ ?H:#define CTERMID_R_PROTO $ctermid_r_proto /**/ ?H:. ?T:try hdrs d_ctermid_r_proto : see if ctermid_r exists set ctermid_r d_ctermid_r eval $inlibc case "$d_ctermid_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h " case "$d_ctermid_r_proto:$usethreads" in ":define") d_ctermid_r_proto=define set d_ctermid_r_proto ctermid_r $hdrs eval $hasproto ;; *) ;; esac case "$d_ctermid_r_proto" in define) case "$ctermid_r_proto" in ''|0) try='char* ctermid_r(char*);' ./protochk "$extern_C $try" $hdrs && ctermid_r_proto=B_B ;; esac case "$ctermid_r_proto" in ''|0) d_ctermid_r=undef ctermid_r_proto=0 echo "Disabling ctermid_r, cannot determine prototype." >&4 ;; * ) case "$ctermid_r_proto" in REENTRANT_PROTO*) ;; *) ctermid_r_proto="REENTRANT_PROTO_$ctermid_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "ctermid_r has no prototype, not using it." >&4 ;; esac d_ctermid_r=undef ctermid_r_proto=0 ;; esac ;; *) ctermid_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_ctime_r.U000066400000000000000000000051261316016665300220250ustar00rootroot00000000000000?RCS: $Id: d_ctime_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_ctime_r ctime_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_time i_systime extern_C ?MAKE: -pick add $@ %< ?S:d_ctime_r: ?S: This variable conditionally defines the HAS_CTIME_R symbol, ?S: which indicates to the C program that the ctime_r() ?S: routine is available. ?S:. ?S:ctime_r_proto: ?S: This variable encodes the prototype of ctime_r. ?S: It is zero if d_ctime_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r ?S: is defined. ?S:. ?C:HAS_CTIME_R: ?C: This symbol, if defined, indicates that the ctime_r routine ?C: is available to ctime re-entrantly. ?C:. ?C:CTIME_R_PROTO: ?C: This symbol encodes the prototype of ctime_r. ?C: It is zero if d_ctime_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ctime_r ?C: is defined. ?C:. ?H:#$d_ctime_r HAS_CTIME_R /**/ ?H:#define CTIME_R_PROTO $ctime_r_proto /**/ ?H:. ?T:try hdrs d_ctime_r_proto : see if ctime_r exists set ctime_r d_ctime_r eval $inlibc case "$d_ctime_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" case "$d_ctime_r_proto:$usethreads" in ":define") d_ctime_r_proto=define set d_ctime_r_proto ctime_r $hdrs eval $hasproto ;; *) ;; esac case "$d_ctime_r_proto" in define) case "$ctime_r_proto" in ''|0) try='char* ctime_r(const time_t*, char*);' ./protochk "$extern_C $try" $hdrs && ctime_r_proto=B_SB ;; esac case "$ctime_r_proto" in ''|0) try='char* ctime_r(const time_t*, char*, int);' ./protochk "$extern_C $try" $hdrs && ctime_r_proto=B_SBI ;; esac case "$ctime_r_proto" in ''|0) try='int ctime_r(const time_t*, char*);' ./protochk "$extern_C $try" $hdrs && ctime_r_proto=I_SB ;; esac case "$ctime_r_proto" in ''|0) try='int ctime_r(const time_t*, char*, int);' ./protochk "$extern_C $try" $hdrs && ctime_r_proto=I_SBI ;; esac case "$ctime_r_proto" in ''|0) d_ctime_r=undef ctime_r_proto=0 echo "Disabling ctime_r, cannot determine prototype." >&4 ;; * ) case "$ctime_r_proto" in REENTRANT_PROTO*) ;; *) ctime_r_proto="REENTRANT_PROTO_$ctime_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "ctime_r has no prototype, not using it." >&4 ;; esac d_ctime_r=undef ctime_r_proto=0 ;; esac ;; *) ctime_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_dirname_r.U000066400000000000000000000012731316016665300223420ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_dirname_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_dirname_r: ?S: This variable conditionally defines the HAS_DIRNAME_R symbol, ?S: which indicates to the C program that the dirname_r() ?S: routine is available. ?S:. ?C:HAS_DIRNAME_R: ?C: This symbol, if defined, indicates that the dirname_r routine ?C: is available to dirname re-entrantly. ?C:. ?H:#$d_dirname_r HAS_DIRNAME_R /**/ ?H:. ?LINT:set d_dirname_r : see if dirname_r exists set dirname_r d_dirname_r eval $inlibc metaconfig-debian-perl-5.26.1/U/threads/d_drand48_r.U000066400000000000000000000043531316016665300221710ustar00rootroot00000000000000?RCS: $Id: d_drand48_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_drand48_r drand48_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_stdlib extern_C ?MAKE: -pick add $@ %< ?S:d_drand48_r: ?S: This variable conditionally defines the HAS_DRAND48_R symbol, ?S: which indicates to the C program that the drand48_r() ?S: routine is available. ?S:. ?S:drand48_r_proto: ?S: This variable encodes the prototype of drand48_r. ?S: It is zero if d_drand48_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r ?S: is defined. ?S:. ?C:HAS_DRAND48_R: ?C: This symbol, if defined, indicates that the drand48_r routine ?C: is available to drand48 re-entrantly. ?C:. ?C:DRAND48_R_PROTO: ?C: This symbol encodes the prototype of drand48_r. ?C: It is zero if d_drand48_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_drand48_r ?C: is defined. ?C:. ?H:#$d_drand48_r HAS_DRAND48_R /**/ ?H:#define DRAND48_R_PROTO $drand48_r_proto /**/ ?H:. ?T:try hdrs d_drand48_r_proto : see if drand48_r exists set drand48_r d_drand48_r eval $inlibc case "$d_drand48_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" case "$d_drand48_r_proto:$usethreads" in ":define") d_drand48_r_proto=define set d_drand48_r_proto drand48_r $hdrs eval $hasproto ;; *) ;; esac case "$d_drand48_r_proto" in define) case "$drand48_r_proto" in ''|0) try='int drand48_r(struct drand48_data*, double*);' ./protochk "$extern_C $try" $hdrs && drand48_r_proto=I_ST ;; esac case "$drand48_r_proto" in ''|0) d_drand48_r=undef drand48_r_proto=0 echo "Disabling drand48_r, cannot determine prototype." >&4 ;; * ) case "$drand48_r_proto" in REENTRANT_PROTO*) ;; *) drand48_r_proto="REENTRANT_PROTO_$drand48_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "drand48_r has no prototype, not using it." >&4 ;; esac d_drand48_r=undef drand48_r_proto=0 ;; esac ;; *) drand48_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endgrent_r.U000066400000000000000000000045761316016665300225420ustar00rootroot00000000000000?RCS: $Id: d_endgrent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endgrent_r endgrent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_grp extern_C ?MAKE: -pick add $@ %< ?S:d_endgrent_r: ?S: This variable conditionally defines the HAS_ENDGRENT_R symbol, ?S: which indicates to the C program that the endgrent_r() ?S: routine is available. ?S:. ?S:endgrent_r_proto: ?S: This variable encodes the prototype of endgrent_r. ?S: It is zero if d_endgrent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r ?S: is defined. ?S:. ?C:HAS_ENDGRENT_R: ?C: This symbol, if defined, indicates that the endgrent_r routine ?C: is available to endgrent re-entrantly. ?C:. ?C:ENDGRENT_R_PROTO: ?C: This symbol encodes the prototype of endgrent_r. ?C: It is zero if d_endgrent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endgrent_r ?C: is defined. ?C:. ?H:#$d_endgrent_r HAS_ENDGRENT_R /**/ ?H:#define ENDGRENT_R_PROTO $endgrent_r_proto /**/ ?H:. ?T:try hdrs d_endgrent_r_proto : see if endgrent_r exists set endgrent_r d_endgrent_r eval $inlibc case "$d_endgrent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" case "$d_endgrent_r_proto:$usethreads" in ":define") d_endgrent_r_proto=define set d_endgrent_r_proto endgrent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endgrent_r_proto" in define) case "$endgrent_r_proto" in ''|0) try='int endgrent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && endgrent_r_proto=I_H ;; esac case "$endgrent_r_proto" in ''|0) try='void endgrent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && endgrent_r_proto=V_H ;; esac case "$endgrent_r_proto" in ''|0) d_endgrent_r=undef endgrent_r_proto=0 echo "Disabling endgrent_r, cannot determine prototype." >&4 ;; * ) case "$endgrent_r_proto" in REENTRANT_PROTO*) ;; *) endgrent_r_proto="REENTRANT_PROTO_$endgrent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endgrent_r has no prototype, not using it." >&4 ;; esac d_endgrent_r=undef endgrent_r_proto=0 ;; esac ;; *) endgrent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endhostent_r.U000066400000000000000000000050001316016665300230660ustar00rootroot00000000000000?RCS: $Id: d_endhostent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endhostent_r endhostent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_endhostent_r: ?S: This variable conditionally defines the HAS_ENDHOSTENT_R symbol, ?S: which indicates to the C program that the endhostent_r() ?S: routine is available. ?S:. ?S:endhostent_r_proto: ?S: This variable encodes the prototype of endhostent_r. ?S: It is zero if d_endhostent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r ?S: is defined. ?S:. ?C:HAS_ENDHOSTENT_R: ?C: This symbol, if defined, indicates that the endhostent_r routine ?C: is available to endhostent re-entrantly. ?C:. ?C:ENDHOSTENT_R_PROTO: ?C: This symbol encodes the prototype of endhostent_r. ?C: It is zero if d_endhostent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endhostent_r ?C: is defined. ?C:. ?H:#$d_endhostent_r HAS_ENDHOSTENT_R /**/ ?H:#define ENDHOSTENT_R_PROTO $endhostent_r_proto /**/ ?H:. ?T:try hdrs d_endhostent_r_proto : see if endhostent_r exists set endhostent_r d_endhostent_r eval $inlibc case "$d_endhostent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_endhostent_r_proto:$usethreads" in ":define") d_endhostent_r_proto=define set d_endhostent_r_proto endhostent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endhostent_r_proto" in define) case "$endhostent_r_proto" in ''|0) try='int endhostent_r(struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && endhostent_r_proto=I_D ;; esac case "$endhostent_r_proto" in ''|0) try='void endhostent_r(struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && endhostent_r_proto=V_D ;; esac case "$endhostent_r_proto" in ''|0) d_endhostent_r=undef endhostent_r_proto=0 echo "Disabling endhostent_r, cannot determine prototype." >&4 ;; * ) case "$endhostent_r_proto" in REENTRANT_PROTO*) ;; *) endhostent_r_proto="REENTRANT_PROTO_$endhostent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endhostent_r has no prototype, not using it." >&4 ;; esac d_endhostent_r=undef endhostent_r_proto=0 ;; esac ;; *) endhostent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endnetent_r.U000066400000000000000000000047161316016665300227140ustar00rootroot00000000000000?RCS: $Id: d_endnetent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endnetent_r endnetent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_endnetent_r: ?S: This variable conditionally defines the HAS_ENDNETENT_R symbol, ?S: which indicates to the C program that the endnetent_r() ?S: routine is available. ?S:. ?S:endnetent_r_proto: ?S: This variable encodes the prototype of endnetent_r. ?S: It is zero if d_endnetent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r ?S: is defined. ?S:. ?C:HAS_ENDNETENT_R: ?C: This symbol, if defined, indicates that the endnetent_r routine ?C: is available to endnetent re-entrantly. ?C:. ?C:ENDNETENT_R_PROTO: ?C: This symbol encodes the prototype of endnetent_r. ?C: It is zero if d_endnetent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endnetent_r ?C: is defined. ?C:. ?H:#$d_endnetent_r HAS_ENDNETENT_R /**/ ?H:#define ENDNETENT_R_PROTO $endnetent_r_proto /**/ ?H:. ?T:try hdrs d_endnetent_r_proto : see if endnetent_r exists set endnetent_r d_endnetent_r eval $inlibc case "$d_endnetent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_endnetent_r_proto:$usethreads" in ":define") d_endnetent_r_proto=define set d_endnetent_r_proto endnetent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endnetent_r_proto" in define) case "$endnetent_r_proto" in ''|0) try='int endnetent_r(struct netent_data*);' ./protochk "$extern_C $try" $hdrs && endnetent_r_proto=I_D ;; esac case "$endnetent_r_proto" in ''|0) try='void endnetent_r(struct netent_data*);' ./protochk "$extern_C $try" $hdrs && endnetent_r_proto=V_D ;; esac case "$endnetent_r_proto" in ''|0) d_endnetent_r=undef endnetent_r_proto=0 echo "Disabling endnetent_r, cannot determine prototype." >&4 ;; * ) case "$endnetent_r_proto" in REENTRANT_PROTO*) ;; *) endnetent_r_proto="REENTRANT_PROTO_$endnetent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endnetent_r has no prototype, not using it." >&4 ;; esac d_endnetent_r=undef endnetent_r_proto=0 ;; esac ;; *) endnetent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endprotoent_r.U000066400000000000000000000050621316016665300232640ustar00rootroot00000000000000?RCS: $Id: d_endprotoent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endprotoent_r endprotoent_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_endprotoent_r: ?S: This variable conditionally defines the HAS_ENDPROTOENT_R symbol, ?S: which indicates to the C program that the endprotoent_r() ?S: routine is available. ?S:. ?S:endprotoent_r_proto: ?S: This variable encodes the prototype of endprotoent_r. ?S: It is zero if d_endprotoent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r ?S: is defined. ?S:. ?C:HAS_ENDPROTOENT_R: ?C: This symbol, if defined, indicates that the endprotoent_r routine ?C: is available to endprotoent re-entrantly. ?C:. ?C:ENDPROTOENT_R_PROTO: ?C: This symbol encodes the prototype of endprotoent_r. ?C: It is zero if d_endprotoent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endprotoent_r ?C: is defined. ?C:. ?H:#$d_endprotoent_r HAS_ENDPROTOENT_R /**/ ?H:#define ENDPROTOENT_R_PROTO $endprotoent_r_proto /**/ ?H:. ?T:try hdrs d_endprotoent_r_proto : see if endprotoent_r exists set endprotoent_r d_endprotoent_r eval $inlibc case "$d_endprotoent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_endprotoent_r_proto:$usethreads" in ":define") d_endprotoent_r_proto=define set d_endprotoent_r_proto endprotoent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endprotoent_r_proto" in define) case "$endprotoent_r_proto" in ''|0) try='int endprotoent_r(struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && endprotoent_r_proto=I_D ;; esac case "$endprotoent_r_proto" in ''|0) try='void endprotoent_r(struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && endprotoent_r_proto=V_D ;; esac case "$endprotoent_r_proto" in ''|0) d_endprotoent_r=undef endprotoent_r_proto=0 echo "Disabling endprotoent_r, cannot determine prototype." >&4 ;; * ) case "$endprotoent_r_proto" in REENTRANT_PROTO*) ;; *) endprotoent_r_proto="REENTRANT_PROTO_$endprotoent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endprotoent_r has no prototype, not using it." >&4 ;; esac d_endprotoent_r=undef endprotoent_r_proto=0 ;; esac ;; *) endprotoent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endpwent_r.U000066400000000000000000000045761316016665300225600ustar00rootroot00000000000000?RCS: $Id: d_endpwent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endpwent_r endpwent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_pwd extern_C ?MAKE: -pick add $@ %< ?S:d_endpwent_r: ?S: This variable conditionally defines the HAS_ENDPWENT_R symbol, ?S: which indicates to the C program that the endpwent_r() ?S: routine is available. ?S:. ?S:endpwent_r_proto: ?S: This variable encodes the prototype of endpwent_r. ?S: It is zero if d_endpwent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r ?S: is defined. ?S:. ?C:HAS_ENDPWENT_R: ?C: This symbol, if defined, indicates that the endpwent_r routine ?C: is available to endpwent re-entrantly. ?C:. ?C:ENDPWENT_R_PROTO: ?C: This symbol encodes the prototype of endpwent_r. ?C: It is zero if d_endpwent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endpwent_r ?C: is defined. ?C:. ?H:#$d_endpwent_r HAS_ENDPWENT_R /**/ ?H:#define ENDPWENT_R_PROTO $endpwent_r_proto /**/ ?H:. ?T:try hdrs d_endpwent_r_proto : see if endpwent_r exists set endpwent_r d_endpwent_r eval $inlibc case "$d_endpwent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" case "$d_endpwent_r_proto:$usethreads" in ":define") d_endpwent_r_proto=define set d_endpwent_r_proto endpwent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endpwent_r_proto" in define) case "$endpwent_r_proto" in ''|0) try='int endpwent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && endpwent_r_proto=I_H ;; esac case "$endpwent_r_proto" in ''|0) try='void endpwent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && endpwent_r_proto=V_H ;; esac case "$endpwent_r_proto" in ''|0) d_endpwent_r=undef endpwent_r_proto=0 echo "Disabling endpwent_r, cannot determine prototype." >&4 ;; * ) case "$endpwent_r_proto" in REENTRANT_PROTO*) ;; *) endpwent_r_proto="REENTRANT_PROTO_$endpwent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endpwent_r has no prototype, not using it." >&4 ;; esac d_endpwent_r=undef endpwent_r_proto=0 ;; esac ;; *) endpwent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_endservent_r.U000066400000000000000000000050001316016665300230700ustar00rootroot00000000000000?RCS: $Id: d_endservent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_endservent_r endservent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_endservent_r: ?S: This variable conditionally defines the HAS_ENDSERVENT_R symbol, ?S: which indicates to the C program that the endservent_r() ?S: routine is available. ?S:. ?S:endservent_r_proto: ?S: This variable encodes the prototype of endservent_r. ?S: It is zero if d_endservent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r ?S: is defined. ?S:. ?C:HAS_ENDSERVENT_R: ?C: This symbol, if defined, indicates that the endservent_r routine ?C: is available to endservent re-entrantly. ?C:. ?C:ENDSERVENT_R_PROTO: ?C: This symbol encodes the prototype of endservent_r. ?C: It is zero if d_endservent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_endservent_r ?C: is defined. ?C:. ?H:#$d_endservent_r HAS_ENDSERVENT_R /**/ ?H:#define ENDSERVENT_R_PROTO $endservent_r_proto /**/ ?H:. ?T:try hdrs d_endservent_r_proto : see if endservent_r exists set endservent_r d_endservent_r eval $inlibc case "$d_endservent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_endservent_r_proto:$usethreads" in ":define") d_endservent_r_proto=define set d_endservent_r_proto endservent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_endservent_r_proto" in define) case "$endservent_r_proto" in ''|0) try='int endservent_r(struct servent_data*);' ./protochk "$extern_C $try" $hdrs && endservent_r_proto=I_D ;; esac case "$endservent_r_proto" in ''|0) try='void endservent_r(struct servent_data*);' ./protochk "$extern_C $try" $hdrs && endservent_r_proto=V_D ;; esac case "$endservent_r_proto" in ''|0) d_endservent_r=undef endservent_r_proto=0 echo "Disabling endservent_r, cannot determine prototype." >&4 ;; * ) case "$endservent_r_proto" in REENTRANT_PROTO*) ;; *) endservent_r_proto="REENTRANT_PROTO_$endservent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "endservent_r has no prototype, not using it." >&4 ;; esac d_endservent_r=undef endservent_r_proto=0 ;; esac ;; *) endservent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getgrent_r.U000066400000000000000000000061301316016665300225370ustar00rootroot00000000000000?RCS: $Id: d_getgrent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getgrent_r getgrent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_grp extern_C ?MAKE: -pick add $@ %< ?S:d_getgrent_r: ?S: This variable conditionally defines the HAS_GETGRENT_R symbol, ?S: which indicates to the C program that the getgrent_r() ?S: routine is available. ?S:. ?S:getgrent_r_proto: ?S: This variable encodes the prototype of getgrent_r. ?S: It is zero if d_getgrent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r ?S: is defined. ?S:. ?C:HAS_GETGRENT_R: ?C: This symbol, if defined, indicates that the getgrent_r routine ?C: is available to getgrent re-entrantly. ?C:. ?C:GETGRENT_R_PROTO: ?C: This symbol encodes the prototype of getgrent_r. ?C: It is zero if d_getgrent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrent_r ?C: is defined. ?C:. ?H:#$d_getgrent_r HAS_GETGRENT_R /**/ ?H:#define GETGRENT_R_PROTO $getgrent_r_proto /**/ ?H:. ?T:try hdrs d_getgrent_r_proto : see if getgrent_r exists set getgrent_r d_getgrent_r eval $inlibc case "$d_getgrent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" case "$d_getgrent_r_proto:$usethreads" in ":define") d_getgrent_r_proto=define set d_getgrent_r_proto getgrent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getgrent_r_proto" in define) case "$getgrent_r_proto" in ''|0) try='int getgrent_r(struct group*, char*, size_t, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBWR ;; esac case "$getgrent_r_proto" in ''|0) try='int getgrent_r(struct group*, char*, int, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBIR ;; esac case "$getgrent_r_proto" in ''|0) try='struct group* getgrent_r(struct group*, char*, size_t);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=S_SBW ;; esac case "$getgrent_r_proto" in ''|0) try='struct group* getgrent_r(struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=S_SBI ;; esac case "$getgrent_r_proto" in ''|0) try='int getgrent_r(struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBI ;; esac case "$getgrent_r_proto" in ''|0) try='int getgrent_r(struct group*, char*, int, FILE**);' ./protochk "$extern_C $try" $hdrs && getgrent_r_proto=I_SBIH ;; esac case "$getgrent_r_proto" in ''|0) d_getgrent_r=undef getgrent_r_proto=0 echo "Disabling getgrent_r, cannot determine prototype." >&4 ;; * ) case "$getgrent_r_proto" in REENTRANT_PROTO*) ;; *) getgrent_r_proto="REENTRANT_PROTO_$getgrent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getgrent_r has no prototype, not using it." >&4 ;; esac d_getgrent_r=undef getgrent_r_proto=0 ;; esac ;; *) getgrent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getgrgid_r.U000066400000000000000000000054541316016665300225240ustar00rootroot00000000000000?RCS: $Id: d_getgrgid_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getgrgid_r getgrgid_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_grp extern_C ?MAKE: -pick add $@ %< ?S:d_getgrgid_r: ?S: This variable conditionally defines the HAS_GETGRGID_R symbol, ?S: which indicates to the C program that the getgrgid_r() ?S: routine is available. ?S:. ?S:getgrgid_r_proto: ?S: This variable encodes the prototype of getgrgid_r. ?S: It is zero if d_getgrgid_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r ?S: is defined. ?S:. ?C:HAS_GETGRGID_R: ?C: This symbol, if defined, indicates that the getgrgid_r routine ?C: is available to getgrgid re-entrantly. ?C:. ?C:GETGRGID_R_PROTO: ?C: This symbol encodes the prototype of getgrgid_r. ?C: It is zero if d_getgrgid_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrgid_r ?C: is defined. ?C:. ?H:#$d_getgrgid_r HAS_GETGRGID_R /**/ ?H:#define GETGRGID_R_PROTO $getgrgid_r_proto /**/ ?H:. ?T:try hdrs d_getgrgid_r_proto : see if getgrgid_r exists set getgrgid_r d_getgrgid_r eval $inlibc case "$d_getgrgid_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" case "$d_getgrgid_r_proto:$usethreads" in ":define") d_getgrgid_r_proto=define set d_getgrgid_r_proto getgrgid_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getgrgid_r_proto" in define) case "$getgrgid_r_proto" in ''|0) try='int getgrgid_r(gid_t, struct group*, char*, size_t, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBWR ;; esac case "$getgrgid_r_proto" in ''|0) try='int getgrgid_r(gid_t, struct group*, char*, int, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBIR ;; esac case "$getgrgid_r_proto" in ''|0) try='int getgrgid_r(gid_t, struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=I_TSBI ;; esac case "$getgrgid_r_proto" in ''|0) try='struct group* getgrgid_r(gid_t, struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrgid_r_proto=S_TSBI ;; esac case "$getgrgid_r_proto" in ''|0) d_getgrgid_r=undef getgrgid_r_proto=0 echo "Disabling getgrgid_r, cannot determine prototype." >&4 ;; * ) case "$getgrgid_r_proto" in REENTRANT_PROTO*) ;; *) getgrgid_r_proto="REENTRANT_PROTO_$getgrgid_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getgrgid_r has no prototype, not using it." >&4 ;; esac d_getgrgid_r=undef getgrgid_r_proto=0 ;; esac ;; *) getgrgid_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getgrnam_r.U000066400000000000000000000057501316016665300225330ustar00rootroot00000000000000?RCS: $Id: d_getgrnam_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getgrnam_r getgrnam_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_grp extern_C ?MAKE: -pick add $@ %< ?S:d_getgrnam_r: ?S: This variable conditionally defines the HAS_GETGRNAM_R symbol, ?S: which indicates to the C program that the getgrnam_r() ?S: routine is available. ?S:. ?S:getgrnam_r_proto: ?S: This variable encodes the prototype of getgrnam_r. ?S: It is zero if d_getgrnam_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r ?S: is defined. ?S:. ?C:HAS_GETGRNAM_R: ?C: This symbol, if defined, indicates that the getgrnam_r routine ?C: is available to getgrnam re-entrantly. ?C:. ?C:GETGRNAM_R_PROTO: ?C: This symbol encodes the prototype of getgrnam_r. ?C: It is zero if d_getgrnam_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getgrnam_r ?C: is defined. ?C:. ?H:#$d_getgrnam_r HAS_GETGRNAM_R /**/ ?H:#define GETGRNAM_R_PROTO $getgrnam_r_proto /**/ ?H:. ?T:try hdrs d_getgrnam_r_proto : see if getgrnam_r exists set getgrnam_r d_getgrnam_r eval $inlibc case "$d_getgrnam_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" case "$d_getgrnam_r_proto:$usethreads" in ":define") d_getgrnam_r_proto=define set d_getgrnam_r_proto getgrnam_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getgrnam_r_proto" in define) case "$getgrnam_r_proto" in ''|0) try='int getgrnam_r(const char*, struct group*, char*, size_t, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBWR ;; esac case "$getgrnam_r_proto" in ''|0) try='int getgrnam_r(const char*, struct group*, char*, int, struct group**);' ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBIR ;; esac case "$getgrnam_r_proto" in ''|0) try='struct group* getgrnam_r(const char*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=S_CBI ;; esac case "$getgrnam_r_proto" in ''|0) try='int getgrnam_r(const char*, struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=I_CSBI ;; esac case "$getgrnam_r_proto" in ''|0) try='struct group* getgrnam_r(const char*, struct group*, char*, int);' ./protochk "$extern_C $try" $hdrs && getgrnam_r_proto=S_CSBI ;; esac case "$getgrnam_r_proto" in ''|0) d_getgrnam_r=undef getgrnam_r_proto=0 echo "Disabling getgrnam_r, cannot determine prototype." >&4 ;; * ) case "$getgrnam_r_proto" in REENTRANT_PROTO*) ;; *) getgrnam_r_proto="REENTRANT_PROTO_$getgrnam_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getgrnam_r has no prototype, not using it." >&4 ;; esac d_getgrnam_r=undef getgrnam_r_proto=0 ;; esac ;; *) getgrnam_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_gethostbyaddr_r.U000066400000000000000000000111571316016665300235700ustar00rootroot00000000000000?RCS: $Id: d_gethostbyaddr_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_gethostbyaddr_r gethostbyaddr_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_gethostbyaddr_r: ?S: This variable conditionally defines the HAS_GETHOSTBYADDR_R symbol, ?S: which indicates to the C program that the gethostbyaddr_r() ?S: routine is available. ?S:. ?S:gethostbyaddr_r_proto: ?S: This variable encodes the prototype of gethostbyaddr_r. ?S: It is zero if d_gethostbyaddr_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r ?S: is defined. ?S:. ?C:HAS_GETHOSTBYADDR_R: ?C: This symbol, if defined, indicates that the gethostbyaddr_r routine ?C: is available to gethostbyaddr re-entrantly. ?C:. ?C:GETHOSTBYADDR_R_PROTO: ?C: This symbol encodes the prototype of gethostbyaddr_r. ?C: It is zero if d_gethostbyaddr_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyaddr_r ?C: is defined. ?C:. ?H:#$d_gethostbyaddr_r HAS_GETHOSTBYADDR_R /**/ ?H:#define GETHOSTBYADDR_R_PROTO $gethostbyaddr_r_proto /**/ ?H:. ?T:try hdrs d_gethostbyaddr_r_proto : see if gethostbyaddr_r exists set gethostbyaddr_r d_gethostbyaddr_r eval $inlibc case "$d_gethostbyaddr_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_gethostbyaddr_r_proto:$usethreads" in ":define") d_gethostbyaddr_r_proto=define set d_gethostbyaddr_r_proto gethostbyaddr_r $hdrs eval $hasproto ;; *) ;; esac case "$d_gethostbyaddr_r_proto" in define) case "$gethostbyaddr_r_proto" in ''|0) try='int gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, size_t, struct hostent**, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CWISBWRE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, size_t, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CWISBWIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const char*, size_t, int, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CWISBIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const void*, size_t, int, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_TWISBIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const char*, int, int, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CIISBIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const char*, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_CSBIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='struct hostent* gethostbyaddr_r(const void*, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=S_TSBIE ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='int gethostbyaddr_r(const char*, size_t, int, struct hostent*, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CWISD ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='int gethostbyaddr_r(const char*, int, int, struct hostent*, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CIISD ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='int gethostbyaddr_r(const char*, int, int);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_CII ;; esac case "$gethostbyaddr_r_proto" in ''|0) try='int gethostbyaddr_r(const void*, socklen_t, int, struct hostent*, char*, size_t, struct hostent**, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyaddr_r_proto=I_TsISBWRE ;; esac case "$gethostbyaddr_r_proto" in ''|0) d_gethostbyaddr_r=undef gethostbyaddr_r_proto=0 echo "Disabling gethostbyaddr_r, cannot determine prototype." >&4 ;; * ) case "$gethostbyaddr_r_proto" in REENTRANT_PROTO*) ;; *) gethostbyaddr_r_proto="REENTRANT_PROTO_$gethostbyaddr_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "gethostbyaddr_r has no prototype, not using it." >&4 ;; esac d_gethostbyaddr_r=undef gethostbyaddr_r_proto=0 ;; esac ;; *) gethostbyaddr_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_gethostbyname_r.U000066400000000000000000000056601316016665300236000ustar00rootroot00000000000000?RCS: $Id: d_gethostbyname_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_gethostbyname_r gethostbyname_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_gethostbyname_r: ?S: This variable conditionally defines the HAS_GETHOSTBYNAME_R symbol, ?S: which indicates to the C program that the gethostbyname_r() ?S: routine is available. ?S:. ?S:gethostbyname_r_proto: ?S: This variable encodes the prototype of gethostbyname_r. ?S: It is zero if d_gethostbyname_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r ?S: is defined. ?S:. ?C:HAS_GETHOSTBYNAME_R: ?C: This symbol, if defined, indicates that the gethostbyname_r routine ?C: is available to gethostbyname re-entrantly. ?C:. ?C:GETHOSTBYNAME_R_PROTO: ?C: This symbol encodes the prototype of gethostbyname_r. ?C: It is zero if d_gethostbyname_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostbyname_r ?C: is defined. ?C:. ?H:#$d_gethostbyname_r HAS_GETHOSTBYNAME_R /**/ ?H:#define GETHOSTBYNAME_R_PROTO $gethostbyname_r_proto /**/ ?H:. ?T:try hdrs d_gethostbyname_r_proto : see if gethostbyname_r exists set gethostbyname_r d_gethostbyname_r eval $inlibc case "$d_gethostbyname_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_gethostbyname_r_proto:$usethreads" in ":define") d_gethostbyname_r_proto=define set d_gethostbyname_r_proto gethostbyname_r $hdrs eval $hasproto ;; *) ;; esac case "$d_gethostbyname_r_proto" in define) case "$gethostbyname_r_proto" in ''|0) try='int gethostbyname_r(const char*, struct hostent*, char*, size_t, struct hostent**, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=I_CSBWRE ;; esac case "$gethostbyname_r_proto" in ''|0) try='struct hostent* gethostbyname_r(const char*, struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=S_CSBIE ;; esac case "$gethostbyname_r_proto" in ''|0) try='int gethostbyname_r(const char*, struct hostent*, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && gethostbyname_r_proto=I_CSD ;; esac case "$gethostbyname_r_proto" in ''|0) d_gethostbyname_r=undef gethostbyname_r_proto=0 echo "Disabling gethostbyname_r, cannot determine prototype." >&4 ;; * ) case "$gethostbyname_r_proto" in REENTRANT_PROTO*) ;; *) gethostbyname_r_proto="REENTRANT_PROTO_$gethostbyname_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "gethostbyname_r has no prototype, not using it." >&4 ;; esac d_gethostbyname_r=undef gethostbyname_r_proto=0 ;; esac ;; *) gethostbyname_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_gethostent_r.U000066400000000000000000000063511316016665300231110ustar00rootroot00000000000000?RCS: $Id: d_gethostent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_gethostent_r gethostent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_gethostent_r: ?S: This variable conditionally defines the HAS_GETHOSTENT_R symbol, ?S: which indicates to the C program that the gethostent_r() ?S: routine is available. ?S:. ?S:gethostent_r_proto: ?S: This variable encodes the prototype of gethostent_r. ?S: It is zero if d_gethostent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r ?S: is defined. ?S:. ?C:HAS_GETHOSTENT_R: ?C: This symbol, if defined, indicates that the gethostent_r routine ?C: is available to gethostent re-entrantly. ?C:. ?C:GETHOSTENT_R_PROTO: ?C: This symbol encodes the prototype of gethostent_r. ?C: It is zero if d_gethostent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gethostent_r ?C: is defined. ?C:. ?H:#$d_gethostent_r HAS_GETHOSTENT_R /**/ ?H:#define GETHOSTENT_R_PROTO $gethostent_r_proto /**/ ?H:. ?T:try hdrs d_gethostent_r_proto : see if gethostent_r exists set gethostent_r d_gethostent_r eval $inlibc case "$d_gethostent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_gethostent_r_proto:$usethreads" in ":define") d_gethostent_r_proto=define set d_gethostent_r_proto gethostent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_gethostent_r_proto" in define) case "$gethostent_r_proto" in ''|0) try='int gethostent_r(struct hostent*, char*, size_t, struct hostent**, int*);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBWRE ;; esac case "$gethostent_r_proto" in ''|0) try='int gethostent_r(struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBIE ;; esac case "$gethostent_r_proto" in ''|0) try='struct hostent* gethostent_r(struct hostent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=S_SBIE ;; esac case "$gethostent_r_proto" in ''|0) try='struct hostent* gethostent_r(struct hostent*, char*, int);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=S_SBI ;; esac case "$gethostent_r_proto" in ''|0) try='int gethostent_r(struct hostent*, char*, int);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SBI ;; esac case "$gethostent_r_proto" in ''|0) try='int gethostent_r(struct hostent*, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && gethostent_r_proto=I_SD ;; esac case "$gethostent_r_proto" in ''|0) d_gethostent_r=undef gethostent_r_proto=0 echo "Disabling gethostent_r, cannot determine prototype." >&4 ;; * ) case "$gethostent_r_proto" in REENTRANT_PROTO*) ;; *) gethostent_r_proto="REENTRANT_PROTO_$gethostent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "gethostent_r has no prototype, not using it." >&4 ;; esac d_gethostent_r=undef gethostent_r_proto=0 ;; esac ;; *) gethostent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getlogin_r.U000066400000000000000000000052601316016665300225330ustar00rootroot00000000000000?RCS: $Id: d_getlogin_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getlogin_r getlogin_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_unistd extern_C ?MAKE: -pick add $@ %< ?S:d_getlogin_r: ?S: This variable conditionally defines the HAS_GETLOGIN_R symbol, ?S: which indicates to the C program that the getlogin_r() ?S: routine is available. ?S:. ?S:getlogin_r_proto: ?S: This variable encodes the prototype of getlogin_r. ?S: It is zero if d_getlogin_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r ?S: is defined. ?S:. ?C:HAS_GETLOGIN_R: ?C: This symbol, if defined, indicates that the getlogin_r routine ?C: is available to getlogin re-entrantly. ?C:. ?C:GETLOGIN_R_PROTO: ?C: This symbol encodes the prototype of getlogin_r. ?C: It is zero if d_getlogin_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getlogin_r ?C: is defined. ?C:. ?H:#$d_getlogin_r HAS_GETLOGIN_R /**/ ?H:#define GETLOGIN_R_PROTO $getlogin_r_proto /**/ ?H:. ?T:try hdrs d_getlogin_r_proto : see if getlogin_r exists set getlogin_r d_getlogin_r eval $inlibc case "$d_getlogin_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_unistd unistd.h" case "$d_getlogin_r_proto:$usethreads" in ":define") d_getlogin_r_proto=define set d_getlogin_r_proto getlogin_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getlogin_r_proto" in define) case "$getlogin_r_proto" in ''|0) try='int getlogin_r(char*, size_t);' ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=I_BW ;; esac case "$getlogin_r_proto" in ''|0) try='int getlogin_r(char*, int);' ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=I_BI ;; esac case "$getlogin_r_proto" in ''|0) try='char* getlogin_r(char*, size_t);' ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=B_BW ;; esac case "$getlogin_r_proto" in ''|0) try='char* getlogin_r(char*, int);' ./protochk "$extern_C $try" $hdrs && getlogin_r_proto=B_BI ;; esac case "$getlogin_r_proto" in ''|0) d_getlogin_r=undef getlogin_r_proto=0 echo "Disabling getlogin_r, cannot determine prototype." >&4 ;; * ) case "$getlogin_r_proto" in REENTRANT_PROTO*) ;; *) getlogin_r_proto="REENTRANT_PROTO_$getlogin_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getlogin_r has no prototype, not using it." >&4 ;; esac d_getlogin_r=undef getlogin_r_proto=0 ;; esac ;; *) getlogin_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getmntent_r.U000066400000000000000000000013251316016665300227260ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getmntent_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_getmntent_r: ?S: This variable conditionally defines the HAS_GETMNTENT_R symbol, ?S: which indicates to the C program that the getmntent_r() ?S: routine is available. ?S:. ?C:HAS_GETMNTENT_R: ?C: This symbol, if defined, indicates that the getmntent_r routine ?C: is available to getmntent re-entrantly. ?C:. ?H:#$d_getmntent_r HAS_GETMNTENT_R /**/ ?H:. ?LINT:set d_getmntent_r : see if getmntent_r exists set getmntent_r d_getmntent_r eval $inlibc metaconfig-debian-perl-5.26.1/U/threads/d_getmntinfo_r.U000066400000000000000000000013421316016665300230720ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getmntinfo_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_getmntinfo_r: ?S: This variable conditionally defines the HAS_GETMNTINFO_R symbol, ?S: which indicates to the C program that the getmntinfo_r() ?S: routine is available. ?S:. ?C:HAS_GETMNTINFO_R: ?C: This symbol, if defined, indicates that the getmntinfo_r routine ?C: is available to getmntinfo re-entrantly. ?C:. ?H:#$d_getmntinfo_r HAS_GETMNTINFO_R /**/ ?H:. ?LINT:set d_getmntinfo_r : see if getmntinfo_r exists set getmntinfo_r d_getmntinfo_r eval $inlibc metaconfig-debian-perl-5.26.1/U/threads/d_getnetbyaddr_r.U000066400000000000000000000075031316016665300234010ustar00rootroot00000000000000?RCS: $Id: d_getnetbyaddr_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getnetbyaddr_r getnetbyaddr_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getnetbyaddr_r: ?S: This variable conditionally defines the HAS_GETNETBYADDR_R symbol, ?S: which indicates to the C program that the getnetbyaddr_r() ?S: routine is available. ?S:. ?S:getnetbyaddr_r_proto: ?S: This variable encodes the prototype of getnetbyaddr_r. ?S: It is zero if d_getnetbyaddr_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r ?S: is defined. ?S:. ?C:HAS_GETNETBYADDR_R: ?C: This symbol, if defined, indicates that the getnetbyaddr_r routine ?C: is available to getnetbyaddr re-entrantly. ?C:. ?C:GETNETBYADDR_R_PROTO: ?C: This symbol encodes the prototype of getnetbyaddr_r. ?C: It is zero if d_getnetbyaddr_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyaddr_r ?C: is defined. ?C:. ?H:#$d_getnetbyaddr_r HAS_GETNETBYADDR_R /**/ ?H:#define GETNETBYADDR_R_PROTO $getnetbyaddr_r_proto /**/ ?H:. ?T:try hdrs d_getnetbyaddr_r_proto : see if getnetbyaddr_r exists set getnetbyaddr_r d_getnetbyaddr_r eval $inlibc case "$d_getnetbyaddr_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getnetbyaddr_r_proto:$usethreads" in ":define") d_getnetbyaddr_r_proto=define set d_getnetbyaddr_r_proto getnetbyaddr_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getnetbyaddr_r_proto" in define) case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(unsigned long, int, struct netent*, char*, size_t, struct netent**, int*);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_UISBWRE ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(long, int, struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_LISBI ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='struct netent* getnetbyaddr_r(in_addr_t, int, struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=S_TISBI ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='struct netent* getnetbyaddr_r(long, int, struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=S_LISBI ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(in_addr_t, int, struct netent*, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_TISD ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(long, int, struct netent*, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_LISD ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(int, int, struct netent*, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_IISD ;; esac case "$getnetbyaddr_r_proto" in ''|0) try='int getnetbyaddr_r(uint32_t, int, struct netent*, char*, size_t, struct netent**, int*);' ./protochk "$extern_C $try" $hdrs && getnetbyaddr_r_proto=I_uISBWRE ;; esac case "$getnetbyaddr_r_proto" in ''|0) d_getnetbyaddr_r=undef getnetbyaddr_r_proto=0 echo "Disabling getnetbyaddr_r, cannot determine prototype." >&4 ;; * ) case "$getnetbyaddr_r_proto" in REENTRANT_PROTO*) ;; *) getnetbyaddr_r_proto="REENTRANT_PROTO_$getnetbyaddr_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getnetbyaddr_r has no prototype, not using it." >&4 ;; esac d_getnetbyaddr_r=undef getnetbyaddr_r_proto=0 ;; esac ;; *) getnetbyaddr_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getnetbyname_r.U000066400000000000000000000060461316016665300234100ustar00rootroot00000000000000?RCS: $Id: d_getnetbyname_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getnetbyname_r getnetbyname_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getnetbyname_r: ?S: This variable conditionally defines the HAS_GETNETBYNAME_R symbol, ?S: which indicates to the C program that the getnetbyname_r() ?S: routine is available. ?S:. ?S:getnetbyname_r_proto: ?S: This variable encodes the prototype of getnetbyname_r. ?S: It is zero if d_getnetbyname_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r ?S: is defined. ?S:. ?C:HAS_GETNETBYNAME_R: ?C: This symbol, if defined, indicates that the getnetbyname_r routine ?C: is available to getnetbyname re-entrantly. ?C:. ?C:GETNETBYNAME_R_PROTO: ?C: This symbol encodes the prototype of getnetbyname_r. ?C: It is zero if d_getnetbyname_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetbyname_r ?C: is defined. ?C:. ?H:#$d_getnetbyname_r HAS_GETNETBYNAME_R /**/ ?H:#define GETNETBYNAME_R_PROTO $getnetbyname_r_proto /**/ ?H:. ?T:try hdrs d_getnetbyname_r_proto : see if getnetbyname_r exists set getnetbyname_r d_getnetbyname_r eval $inlibc case "$d_getnetbyname_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getnetbyname_r_proto:$usethreads" in ":define") d_getnetbyname_r_proto=define set d_getnetbyname_r_proto getnetbyname_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getnetbyname_r_proto" in define) case "$getnetbyname_r_proto" in ''|0) try='int getnetbyname_r(const char*, struct netent*, char*, size_t, struct netent**, int*);' ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSBWRE ;; esac case "$getnetbyname_r_proto" in ''|0) try='int getnetbyname_r(const char*, struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSBI ;; esac case "$getnetbyname_r_proto" in ''|0) try='struct netent* getnetbyname_r(const char*, struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=S_CSBI ;; esac case "$getnetbyname_r_proto" in ''|0) try='int getnetbyname_r(const char*, struct netent*, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && getnetbyname_r_proto=I_CSD ;; esac case "$getnetbyname_r_proto" in ''|0) d_getnetbyname_r=undef getnetbyname_r_proto=0 echo "Disabling getnetbyname_r, cannot determine prototype." >&4 ;; * ) case "$getnetbyname_r_proto" in REENTRANT_PROTO*) ;; *) getnetbyname_r_proto="REENTRANT_PROTO_$getnetbyname_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getnetbyname_r has no prototype, not using it." >&4 ;; esac d_getnetbyname_r=undef getnetbyname_r_proto=0 ;; esac ;; *) getnetbyname_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getnetent_r.U000066400000000000000000000062431316016665300227220ustar00rootroot00000000000000?RCS: $Id: d_getnetent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getnetent_r getnetent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getnetent_r: ?S: This variable conditionally defines the HAS_GETNETENT_R symbol, ?S: which indicates to the C program that the getnetent_r() ?S: routine is available. ?S:. ?S:getnetent_r_proto: ?S: This variable encodes the prototype of getnetent_r. ?S: It is zero if d_getnetent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r ?S: is defined. ?S:. ?C:HAS_GETNETENT_R: ?C: This symbol, if defined, indicates that the getnetent_r routine ?C: is available to getnetent re-entrantly. ?C:. ?C:GETNETENT_R_PROTO: ?C: This symbol encodes the prototype of getnetent_r. ?C: It is zero if d_getnetent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getnetent_r ?C: is defined. ?C:. ?H:#$d_getnetent_r HAS_GETNETENT_R /**/ ?H:#define GETNETENT_R_PROTO $getnetent_r_proto /**/ ?H:. ?T:try hdrs d_getnetent_r_proto : see if getnetent_r exists set getnetent_r d_getnetent_r eval $inlibc case "$d_getnetent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getnetent_r_proto:$usethreads" in ":define") d_getnetent_r_proto=define set d_getnetent_r_proto getnetent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getnetent_r_proto" in define) case "$getnetent_r_proto" in ''|0) try='int getnetent_r(struct netent*, char*, size_t, struct netent**, int*);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBWRE ;; esac case "$getnetent_r_proto" in ''|0) try='int getnetent_r(struct netent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBIE ;; esac case "$getnetent_r_proto" in ''|0) try='struct netent* getnetent_r(struct netent*, char*, int, int*);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=S_SBIE ;; esac case "$getnetent_r_proto" in ''|0) try='struct netent* getnetent_r(struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=S_SBI ;; esac case "$getnetent_r_proto" in ''|0) try='int getnetent_r(struct netent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SBI ;; esac case "$getnetent_r_proto" in ''|0) try='int getnetent_r(struct netent*, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && getnetent_r_proto=I_SD ;; esac case "$getnetent_r_proto" in ''|0) d_getnetent_r=undef getnetent_r_proto=0 echo "Disabling getnetent_r, cannot determine prototype." >&4 ;; * ) case "$getnetent_r_proto" in REENTRANT_PROTO*) ;; *) getnetent_r_proto="REENTRANT_PROTO_$getnetent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getnetent_r has no prototype, not using it." >&4 ;; esac d_getnetent_r=undef getnetent_r_proto=0 ;; esac ;; *) getnetent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getprotobyname_r.U000066400000000000000000000057331316016665300237670ustar00rootroot00000000000000?RCS: $Id: d_getprotobyname_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getprotobyname_r getprotobyname_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getprotobyname_r: ?S: This variable conditionally defines the HAS_GETPROTOBYNAME_R symbol, ?S: which indicates to the C program that the getprotobyname_r() ?S: routine is available. ?S:. ?S:getprotobyname_r_proto: ?S: This variable encodes the prototype of getprotobyname_r. ?S: It is zero if d_getprotobyname_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r ?S: is defined. ?S:. ?C:HAS_GETPROTOBYNAME_R: ?C: This symbol, if defined, indicates that the getprotobyname_r routine ?C: is available to getprotobyname re-entrantly. ?C:. ?C:GETPROTOBYNAME_R_PROTO: ?C: This symbol encodes the prototype of getprotobyname_r. ?C: It is zero if d_getprotobyname_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobyname_r ?C: is defined. ?C:. ?H:#$d_getprotobyname_r HAS_GETPROTOBYNAME_R /**/ ?H:#define GETPROTOBYNAME_R_PROTO $getprotobyname_r_proto /**/ ?H:. ?T:try hdrs d_getprotobyname_r_proto : see if getprotobyname_r exists set getprotobyname_r d_getprotobyname_r eval $inlibc case "$d_getprotobyname_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getprotobyname_r_proto:$usethreads" in ":define") d_getprotobyname_r_proto=define set d_getprotobyname_r_proto getprotobyname_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getprotobyname_r_proto" in define) case "$getprotobyname_r_proto" in ''|0) try='int getprotobyname_r(const char*, struct protoent*, char*, size_t, struct protoent**);' ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=I_CSBWR ;; esac case "$getprotobyname_r_proto" in ''|0) try='struct protoent* getprotobyname_r(const char*, struct protoent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=S_CSBI ;; esac case "$getprotobyname_r_proto" in ''|0) try='int getprotobyname_r(const char*, struct protoent*, struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && getprotobyname_r_proto=I_CSD ;; esac case "$getprotobyname_r_proto" in ''|0) d_getprotobyname_r=undef getprotobyname_r_proto=0 echo "Disabling getprotobyname_r, cannot determine prototype." >&4 ;; * ) case "$getprotobyname_r_proto" in REENTRANT_PROTO*) ;; *) getprotobyname_r_proto="REENTRANT_PROTO_$getprotobyname_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getprotobyname_r has no prototype, not using it." >&4 ;; esac d_getprotobyname_r=undef getprotobyname_r_proto=0 ;; esac ;; *) getprotobyname_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getprotobynumber_r.U000066400000000000000000000060511316016665300243310ustar00rootroot00000000000000?RCS: $Id: d_getprotobynumber_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getprotobynumber_r getprotobynumber_r_proto: Inlibc Protochk \ Hasproto i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getprotobynumber_r: ?S: This variable conditionally defines the HAS_GETPROTOBYNUMBER_R symbol, ?S: which indicates to the C program that the getprotobynumber_r() ?S: routine is available. ?S:. ?S:getprotobynumber_r_proto: ?S: This variable encodes the prototype of getprotobynumber_r. ?S: It is zero if d_getprotobynumber_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r ?S: is defined. ?S:. ?C:HAS_GETPROTOBYNUMBER_R: ?C: This symbol, if defined, indicates that the getprotobynumber_r routine ?C: is available to getprotobynumber re-entrantly. ?C:. ?C:GETPROTOBYNUMBER_R_PROTO: ?C: This symbol encodes the prototype of getprotobynumber_r. ?C: It is zero if d_getprotobynumber_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotobynumber_r ?C: is defined. ?C:. ?H:#$d_getprotobynumber_r HAS_GETPROTOBYNUMBER_R /**/ ?H:#define GETPROTOBYNUMBER_R_PROTO $getprotobynumber_r_proto /**/ ?H:. ?T:try hdrs d_getprotobynumber_r_proto : see if getprotobynumber_r exists set getprotobynumber_r d_getprotobynumber_r eval $inlibc case "$d_getprotobynumber_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getprotobynumber_r_proto:$usethreads" in ":define") d_getprotobynumber_r_proto=define set d_getprotobynumber_r_proto getprotobynumber_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getprotobynumber_r_proto" in define) case "$getprotobynumber_r_proto" in ''|0) try='int getprotobynumber_r(int, struct protoent*, char*, size_t, struct protoent**);' ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=I_ISBWR ;; esac case "$getprotobynumber_r_proto" in ''|0) try='struct protoent* getprotobynumber_r(int, struct protoent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=S_ISBI ;; esac case "$getprotobynumber_r_proto" in ''|0) try='int getprotobynumber_r(int, struct protoent*, struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && getprotobynumber_r_proto=I_ISD ;; esac case "$getprotobynumber_r_proto" in ''|0) d_getprotobynumber_r=undef getprotobynumber_r_proto=0 echo "Disabling getprotobynumber_r, cannot determine prototype." >&4 ;; * ) case "$getprotobynumber_r_proto" in REENTRANT_PROTO*) ;; *) getprotobynumber_r_proto="REENTRANT_PROTO_$getprotobynumber_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getprotobynumber_r has no prototype, not using it." >&4 ;; esac d_getprotobynumber_r=undef getprotobynumber_r_proto=0 ;; esac ;; *) getprotobynumber_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getprotoent_r.U000066400000000000000000000056771316016665300233110ustar00rootroot00000000000000?RCS: $Id: d_getprotoent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getprotoent_r getprotoent_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getprotoent_r: ?S: This variable conditionally defines the HAS_GETPROTOENT_R symbol, ?S: which indicates to the C program that the getprotoent_r() ?S: routine is available. ?S:. ?S:getprotoent_r_proto: ?S: This variable encodes the prototype of getprotoent_r. ?S: It is zero if d_getprotoent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r ?S: is defined. ?S:. ?C:HAS_GETPROTOENT_R: ?C: This symbol, if defined, indicates that the getprotoent_r routine ?C: is available to getprotoent re-entrantly. ?C:. ?C:GETPROTOENT_R_PROTO: ?C: This symbol encodes the prototype of getprotoent_r. ?C: It is zero if d_getprotoent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getprotoent_r ?C: is defined. ?C:. ?H:#$d_getprotoent_r HAS_GETPROTOENT_R /**/ ?H:#define GETPROTOENT_R_PROTO $getprotoent_r_proto /**/ ?H:. ?T:try hdrs d_getprotoent_r_proto : see if getprotoent_r exists set getprotoent_r d_getprotoent_r eval $inlibc case "$d_getprotoent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getprotoent_r_proto:$usethreads" in ":define") d_getprotoent_r_proto=define set d_getprotoent_r_proto getprotoent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getprotoent_r_proto" in define) case "$getprotoent_r_proto" in ''|0) try='int getprotoent_r(struct protoent*, char*, size_t, struct protoent**);' ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SBWR ;; esac case "$getprotoent_r_proto" in ''|0) try='int getprotoent_r(struct protoent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SBI ;; esac case "$getprotoent_r_proto" in ''|0) try='struct protoent* getprotoent_r(struct protoent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=S_SBI ;; esac case "$getprotoent_r_proto" in ''|0) try='int getprotoent_r(struct protoent*, struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && getprotoent_r_proto=I_SD ;; esac case "$getprotoent_r_proto" in ''|0) d_getprotoent_r=undef getprotoent_r_proto=0 echo "Disabling getprotoent_r, cannot determine prototype." >&4 ;; * ) case "$getprotoent_r_proto" in REENTRANT_PROTO*) ;; *) getprotoent_r_proto="REENTRANT_PROTO_$getprotoent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getprotoent_r has no prototype, not using it." >&4 ;; esac d_getprotoent_r=undef getprotoent_r_proto=0 ;; esac ;; *) getprotoent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getpwent_r.U000066400000000000000000000061421316016665300225600ustar00rootroot00000000000000?RCS: $Id: d_getpwent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getpwent_r getpwent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_pwd extern_C ?MAKE: -pick add $@ %< ?S:d_getpwent_r: ?S: This variable conditionally defines the HAS_GETPWENT_R symbol, ?S: which indicates to the C program that the getpwent_r() ?S: routine is available. ?S:. ?S:getpwent_r_proto: ?S: This variable encodes the prototype of getpwent_r. ?S: It is zero if d_getpwent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r ?S: is defined. ?S:. ?C:HAS_GETPWENT_R: ?C: This symbol, if defined, indicates that the getpwent_r routine ?C: is available to getpwent re-entrantly. ?C:. ?C:GETPWENT_R_PROTO: ?C: This symbol encodes the prototype of getpwent_r. ?C: It is zero if d_getpwent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwent_r ?C: is defined. ?C:. ?H:#$d_getpwent_r HAS_GETPWENT_R /**/ ?H:#define GETPWENT_R_PROTO $getpwent_r_proto /**/ ?H:. ?T:try hdrs d_getpwent_r_proto : see if getpwent_r exists set getpwent_r d_getpwent_r eval $inlibc case "$d_getpwent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" case "$d_getpwent_r_proto:$usethreads" in ":define") d_getpwent_r_proto=define set d_getpwent_r_proto getpwent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getpwent_r_proto" in define) case "$getpwent_r_proto" in ''|0) try='int getpwent_r(struct passwd*, char*, size_t, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBWR ;; esac case "$getpwent_r_proto" in ''|0) try='int getpwent_r(struct passwd*, char*, int, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBIR ;; esac case "$getpwent_r_proto" in ''|0) try='struct passwd* getpwent_r(struct passwd*, char*, size_t);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=S_SBW ;; esac case "$getpwent_r_proto" in ''|0) try='struct passwd* getpwent_r(struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=S_SBI ;; esac case "$getpwent_r_proto" in ''|0) try='int getpwent_r(struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBI ;; esac case "$getpwent_r_proto" in ''|0) try='int getpwent_r(struct passwd*, char*, int, FILE**);' ./protochk "$extern_C $try" $hdrs && getpwent_r_proto=I_SBIH ;; esac case "$getpwent_r_proto" in ''|0) d_getpwent_r=undef getpwent_r_proto=0 echo "Disabling getpwent_r, cannot determine prototype." >&4 ;; * ) case "$getpwent_r_proto" in REENTRANT_PROTO*) ;; *) getpwent_r_proto="REENTRANT_PROTO_$getpwent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getpwent_r has no prototype, not using it." >&4 ;; esac d_getpwent_r=undef getpwent_r_proto=0 ;; esac ;; *) getpwent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getpwnam_r.U000066400000000000000000000055131316016665300225460ustar00rootroot00000000000000?RCS: $Id: d_getpwnam_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getpwnam_r getpwnam_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_pwd extern_C ?MAKE: -pick add $@ %< ?S:d_getpwnam_r: ?S: This variable conditionally defines the HAS_GETPWNAM_R symbol, ?S: which indicates to the C program that the getpwnam_r() ?S: routine is available. ?S:. ?S:getpwnam_r_proto: ?S: This variable encodes the prototype of getpwnam_r. ?S: It is zero if d_getpwnam_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r ?S: is defined. ?S:. ?C:HAS_GETPWNAM_R: ?C: This symbol, if defined, indicates that the getpwnam_r routine ?C: is available to getpwnam re-entrantly. ?C:. ?C:GETPWNAM_R_PROTO: ?C: This symbol encodes the prototype of getpwnam_r. ?C: It is zero if d_getpwnam_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwnam_r ?C: is defined. ?C:. ?H:#$d_getpwnam_r HAS_GETPWNAM_R /**/ ?H:#define GETPWNAM_R_PROTO $getpwnam_r_proto /**/ ?H:. ?T:try hdrs d_getpwnam_r_proto : see if getpwnam_r exists set getpwnam_r d_getpwnam_r eval $inlibc case "$d_getpwnam_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" case "$d_getpwnam_r_proto:$usethreads" in ":define") d_getpwnam_r_proto=define set d_getpwnam_r_proto getpwnam_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getpwnam_r_proto" in define) case "$getpwnam_r_proto" in ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, size_t, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBWR ;; esac case "$getpwnam_r_proto" in ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, int, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBIR ;; esac case "$getpwnam_r_proto" in ''|0) try='struct passwd* getpwnam_r(const char*, struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=S_CSBI ;; esac case "$getpwnam_r_proto" in ''|0) try='int getpwnam_r(const char*, struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwnam_r_proto=I_CSBI ;; esac case "$getpwnam_r_proto" in ''|0) d_getpwnam_r=undef getpwnam_r_proto=0 echo "Disabling getpwnam_r, cannot determine prototype." >&4 ;; * ) case "$getpwnam_r_proto" in REENTRANT_PROTO*) ;; *) getpwnam_r_proto="REENTRANT_PROTO_$getpwnam_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getpwnam_r has no prototype, not using it." >&4 ;; esac d_getpwnam_r=undef getpwnam_r_proto=0 ;; esac ;; *) getpwnam_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getpwuid_r.U000066400000000000000000000054631316016665300225600ustar00rootroot00000000000000?RCS: $Id: d_getpwuid_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getpwuid_r getpwuid_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_pwd extern_C ?MAKE: -pick add $@ %< ?S:d_getpwuid_r: ?S: This variable conditionally defines the HAS_GETPWUID_R symbol, ?S: which indicates to the C program that the getpwuid_r() ?S: routine is available. ?S:. ?S:getpwuid_r_proto: ?S: This variable encodes the prototype of getpwuid_r. ?S: It is zero if d_getpwuid_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r ?S: is defined. ?S:. ?C:HAS_GETPWUID_R: ?C: This symbol, if defined, indicates that the getpwuid_r routine ?C: is available to getpwuid re-entrantly. ?C:. ?C:GETPWUID_R_PROTO: ?C: This symbol encodes the prototype of getpwuid_r. ?C: It is zero if d_getpwuid_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getpwuid_r ?C: is defined. ?C:. ?H:#$d_getpwuid_r HAS_GETPWUID_R /**/ ?H:#define GETPWUID_R_PROTO $getpwuid_r_proto /**/ ?H:. ?T:try hdrs d_getpwuid_r_proto : see if getpwuid_r exists set getpwuid_r d_getpwuid_r eval $inlibc case "$d_getpwuid_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" case "$d_getpwuid_r_proto:$usethreads" in ":define") d_getpwuid_r_proto=define set d_getpwuid_r_proto getpwuid_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getpwuid_r_proto" in define) case "$getpwuid_r_proto" in ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, size_t, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBWR ;; esac case "$getpwuid_r_proto" in ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, int, struct passwd**);' ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBIR ;; esac case "$getpwuid_r_proto" in ''|0) try='int getpwuid_r(uid_t, struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=I_TSBI ;; esac case "$getpwuid_r_proto" in ''|0) try='struct passwd* getpwuid_r(uid_t, struct passwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getpwuid_r_proto=S_TSBI ;; esac case "$getpwuid_r_proto" in ''|0) d_getpwuid_r=undef getpwuid_r_proto=0 echo "Disabling getpwuid_r, cannot determine prototype." >&4 ;; * ) case "$getpwuid_r_proto" in REENTRANT_PROTO*) ;; *) getpwuid_r_proto="REENTRANT_PROTO_$getpwuid_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getpwuid_r has no prototype, not using it." >&4 ;; esac d_getpwuid_r=undef getpwuid_r_proto=0 ;; esac ;; *) getpwuid_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getservbyname_r.U000066400000000000000000000057141316016665300236020ustar00rootroot00000000000000?RCS: $Id: d_getservbyname_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getservbyname_r getservbyname_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getservbyname_r: ?S: This variable conditionally defines the HAS_GETSERVBYNAME_R symbol, ?S: which indicates to the C program that the getservbyname_r() ?S: routine is available. ?S:. ?S:getservbyname_r_proto: ?S: This variable encodes the prototype of getservbyname_r. ?S: It is zero if d_getservbyname_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r ?S: is defined. ?S:. ?C:HAS_GETSERVBYNAME_R: ?C: This symbol, if defined, indicates that the getservbyname_r routine ?C: is available to getservbyname re-entrantly. ?C:. ?C:GETSERVBYNAME_R_PROTO: ?C: This symbol encodes the prototype of getservbyname_r. ?C: It is zero if d_getservbyname_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyname_r ?C: is defined. ?C:. ?H:#$d_getservbyname_r HAS_GETSERVBYNAME_R /**/ ?H:#define GETSERVBYNAME_R_PROTO $getservbyname_r_proto /**/ ?H:. ?T:try hdrs d_getservbyname_r_proto : see if getservbyname_r exists set getservbyname_r d_getservbyname_r eval $inlibc case "$d_getservbyname_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getservbyname_r_proto:$usethreads" in ":define") d_getservbyname_r_proto=define set d_getservbyname_r_proto getservbyname_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getservbyname_r_proto" in define) case "$getservbyname_r_proto" in ''|0) try='int getservbyname_r(const char*, const char*, struct servent*, char*, size_t, struct servent**);' ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=I_CCSBWR ;; esac case "$getservbyname_r_proto" in ''|0) try='struct servent* getservbyname_r(const char*, const char*, struct servent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=S_CCSBI ;; esac case "$getservbyname_r_proto" in ''|0) try='int getservbyname_r(const char*, const char*, struct servent*, struct servent_data*);' ./protochk "$extern_C $try" $hdrs && getservbyname_r_proto=I_CCSD ;; esac case "$getservbyname_r_proto" in ''|0) d_getservbyname_r=undef getservbyname_r_proto=0 echo "Disabling getservbyname_r, cannot determine prototype." >&4 ;; * ) case "$getservbyname_r_proto" in REENTRANT_PROTO*) ;; *) getservbyname_r_proto="REENTRANT_PROTO_$getservbyname_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getservbyname_r has no prototype, not using it." >&4 ;; esac d_getservbyname_r=undef getservbyname_r_proto=0 ;; esac ;; *) getservbyname_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getservbyport_r.U000066400000000000000000000056641316016665300236520ustar00rootroot00000000000000?RCS: $Id: d_getservbyport_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getservbyport_r getservbyport_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getservbyport_r: ?S: This variable conditionally defines the HAS_GETSERVBYPORT_R symbol, ?S: which indicates to the C program that the getservbyport_r() ?S: routine is available. ?S:. ?S:getservbyport_r_proto: ?S: This variable encodes the prototype of getservbyport_r. ?S: It is zero if d_getservbyport_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r ?S: is defined. ?S:. ?C:HAS_GETSERVBYPORT_R: ?C: This symbol, if defined, indicates that the getservbyport_r routine ?C: is available to getservbyport re-entrantly. ?C:. ?C:GETSERVBYPORT_R_PROTO: ?C: This symbol encodes the prototype of getservbyport_r. ?C: It is zero if d_getservbyport_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservbyport_r ?C: is defined. ?C:. ?H:#$d_getservbyport_r HAS_GETSERVBYPORT_R /**/ ?H:#define GETSERVBYPORT_R_PROTO $getservbyport_r_proto /**/ ?H:. ?T:try hdrs d_getservbyport_r_proto : see if getservbyport_r exists set getservbyport_r d_getservbyport_r eval $inlibc case "$d_getservbyport_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getservbyport_r_proto:$usethreads" in ":define") d_getservbyport_r_proto=define set d_getservbyport_r_proto getservbyport_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getservbyport_r_proto" in define) case "$getservbyport_r_proto" in ''|0) try='int getservbyport_r(int, const char*, struct servent*, char*, size_t, struct servent**);' ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=I_ICSBWR ;; esac case "$getservbyport_r_proto" in ''|0) try='struct servent* getservbyport_r(int, const char*, struct servent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=S_ICSBI ;; esac case "$getservbyport_r_proto" in ''|0) try='int getservbyport_r(int, const char*, struct servent*, struct servent_data*);' ./protochk "$extern_C $try" $hdrs && getservbyport_r_proto=I_ICSD ;; esac case "$getservbyport_r_proto" in ''|0) d_getservbyport_r=undef getservbyport_r_proto=0 echo "Disabling getservbyport_r, cannot determine prototype." >&4 ;; * ) case "$getservbyport_r_proto" in REENTRANT_PROTO*) ;; *) getservbyport_r_proto="REENTRANT_PROTO_$getservbyport_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getservbyport_r has no prototype, not using it." >&4 ;; esac d_getservbyport_r=undef getservbyport_r_proto=0 ;; esac ;; *) getservbyport_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getservent_r.U000066400000000000000000000056021316016665300231110ustar00rootroot00000000000000?RCS: $Id: d_getservent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getservent_r getservent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_getservent_r: ?S: This variable conditionally defines the HAS_GETSERVENT_R symbol, ?S: which indicates to the C program that the getservent_r() ?S: routine is available. ?S:. ?S:getservent_r_proto: ?S: This variable encodes the prototype of getservent_r. ?S: It is zero if d_getservent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r ?S: is defined. ?S:. ?C:HAS_GETSERVENT_R: ?C: This symbol, if defined, indicates that the getservent_r routine ?C: is available to getservent re-entrantly. ?C:. ?C:GETSERVENT_R_PROTO: ?C: This symbol encodes the prototype of getservent_r. ?C: It is zero if d_getservent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getservent_r ?C: is defined. ?C:. ?H:#$d_getservent_r HAS_GETSERVENT_R /**/ ?H:#define GETSERVENT_R_PROTO $getservent_r_proto /**/ ?H:. ?T:try hdrs d_getservent_r_proto : see if getservent_r exists set getservent_r d_getservent_r eval $inlibc case "$d_getservent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_getservent_r_proto:$usethreads" in ":define") d_getservent_r_proto=define set d_getservent_r_proto getservent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getservent_r_proto" in define) case "$getservent_r_proto" in ''|0) try='int getservent_r(struct servent*, char*, size_t, struct servent**);' ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SBWR ;; esac case "$getservent_r_proto" in ''|0) try='int getservent_r(struct servent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SBI ;; esac case "$getservent_r_proto" in ''|0) try='struct servent* getservent_r(struct servent*, char*, int);' ./protochk "$extern_C $try" $hdrs && getservent_r_proto=S_SBI ;; esac case "$getservent_r_proto" in ''|0) try='int getservent_r(struct servent*, struct servent_data*);' ./protochk "$extern_C $try" $hdrs && getservent_r_proto=I_SD ;; esac case "$getservent_r_proto" in ''|0) d_getservent_r=undef getservent_r_proto=0 echo "Disabling getservent_r, cannot determine prototype." >&4 ;; * ) case "$getservent_r_proto" in REENTRANT_PROTO*) ;; *) getservent_r_proto="REENTRANT_PROTO_$getservent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getservent_r has no prototype, not using it." >&4 ;; esac d_getservent_r=undef getservent_r_proto=0 ;; esac ;; *) getservent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_getspent_r.U000066400000000000000000000013101316016665300225440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_getspent_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_getspent_r: ?S: This variable conditionally defines the HAS_GETSPENT_R symbol, ?S: which indicates to the C prospam that the getspent_r() ?S: routine is available. ?S:. ?C:HAS_GETSPENT_R: ?C: This symbol, if defined, indicates that the getspent_r routine ?C: is available to getspent re-entrantly. ?C:. ?H:#$d_getspent_r HAS_GETSPENT_R /**/ ?H:. ?LINT:set d_getspent_r : see if getspent_r exists set getspent_r d_getspent_r eval $inlibc metaconfig-debian-perl-5.26.1/U/threads/d_getspnam_r.U000066400000000000000000000047461316016665300225510ustar00rootroot00000000000000?RCS: $Id: d_getspnam_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_getspnam_r getspnam_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_shadow extern_C ?MAKE: -pick add $@ %< ?S:d_getspnam_r: ?S: This variable conditionally defines the HAS_GETSPNAM_R symbol, ?S: which indicates to the C program that the getspnam_r() ?S: routine is available. ?S:. ?S:getspnam_r_proto: ?S: This variable encodes the prototype of getspnam_r. ?S: It is zero if d_getspnam_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r ?S: is defined. ?S:. ?C:HAS_GETSPNAM_R: ?C: This symbol, if defined, indicates that the getspnam_r routine ?C: is available to getspnam re-entrantly. ?C:. ?C:GETSPNAM_R_PROTO: ?C: This symbol encodes the prototype of getspnam_r. ?C: It is zero if d_getspnam_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_getspnam_r ?C: is defined. ?C:. ?H:#$d_getspnam_r HAS_GETSPNAM_R /**/ ?H:#define GETSPNAM_R_PROTO $getspnam_r_proto /**/ ?H:. ?T:try hdrs d_getspnam_r_proto : see if getspnam_r exists set getspnam_r d_getspnam_r eval $inlibc case "$d_getspnam_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_shadow shadow.h" case "$d_getspnam_r_proto:$usethreads" in ":define") d_getspnam_r_proto=define set d_getspnam_r_proto getspnam_r $hdrs eval $hasproto ;; *) ;; esac case "$d_getspnam_r_proto" in define) case "$getspnam_r_proto" in ''|0) try='int getspnam_r(const char*, struct spwd*, char*, size_t, struct spwd**);' ./protochk "$extern_C $try" $hdrs && getspnam_r_proto=I_CSBWR ;; esac case "$getspnam_r_proto" in ''|0) try='struct spwd* getspnam_r(const char*, struct spwd*, char*, int);' ./protochk "$extern_C $try" $hdrs && getspnam_r_proto=S_CSBI ;; esac case "$getspnam_r_proto" in ''|0) d_getspnam_r=undef getspnam_r_proto=0 echo "Disabling getspnam_r, cannot determine prototype." >&4 ;; * ) case "$getspnam_r_proto" in REENTRANT_PROTO*) ;; *) getspnam_r_proto="REENTRANT_PROTO_$getspnam_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "getspnam_r has no prototype, not using it." >&4 ;; esac d_getspnam_r=undef getspnam_r_proto=0 ;; esac ;; *) getspnam_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_gmtime_r.U000066400000000000000000000045571316016665300222150ustar00rootroot00000000000000?RCS: $Id: d_gmtime_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_gmtime_r gmtime_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_time i_systime extern_C ?MAKE: -pick add $@ %< ?S:d_gmtime_r: ?S: This variable conditionally defines the HAS_GMTIME_R symbol, ?S: which indicates to the C program that the gmtime_r() ?S: routine is available. ?S:. ?S:gmtime_r_proto: ?S: This variable encodes the prototype of gmtime_r. ?S: It is zero if d_gmtime_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r ?S: is defined. ?S:. ?C:HAS_GMTIME_R: ?C: This symbol, if defined, indicates that the gmtime_r routine ?C: is available to gmtime re-entrantly. ?C:. ?C:GMTIME_R_PROTO: ?C: This symbol encodes the prototype of gmtime_r. ?C: It is zero if d_gmtime_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_gmtime_r ?C: is defined. ?C:. ?H:#$d_gmtime_r HAS_GMTIME_R /**/ ?H:#define GMTIME_R_PROTO $gmtime_r_proto /**/ ?H:. ?T:try hdrs d_gmtime_r_proto : see if gmtime_r exists set gmtime_r d_gmtime_r eval $inlibc case "$d_gmtime_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" case "$d_gmtime_r_proto:$usethreads" in ":define") d_gmtime_r_proto=define set d_gmtime_r_proto gmtime_r $hdrs eval $hasproto ;; *) ;; esac case "$d_gmtime_r_proto" in define) case "$gmtime_r_proto" in ''|0) try='struct tm* gmtime_r(const time_t*, struct tm*);' ./protochk "$extern_C $try" $hdrs && gmtime_r_proto=S_TS ;; esac case "$gmtime_r_proto" in ''|0) try='int gmtime_r(const time_t*, struct tm*);' ./protochk "$extern_C $try" $hdrs && gmtime_r_proto=I_TS ;; esac case "$gmtime_r_proto" in ''|0) d_gmtime_r=undef gmtime_r_proto=0 echo "Disabling gmtime_r, cannot determine prototype." >&4 ;; * ) case "$gmtime_r_proto" in REENTRANT_PROTO*) ;; *) gmtime_r_proto="REENTRANT_PROTO_$gmtime_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "gmtime_r has no prototype, not using it." >&4 ;; esac d_gmtime_r=undef gmtime_r_proto=0 ;; esac ;; *) gmtime_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_localtime_r.U000066400000000000000000000112551316016665300226750ustar00rootroot00000000000000?RCS: $Id: d_localtime_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: Copyright (c) 2006,2007 H.Merijn Brand ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_localtime_r d_localtime_r_needs_tzset localtime_r_proto: Inlibc \ cat run Protochk Hasproto i_systypes usethreads i_time i_systime \ rm_try Compile extern_C i_stdlib i_unistd i_string i_malloc ?MAKE: -pick add $@ %< ?S:d_localtime_r: ?S: This variable conditionally defines the HAS_LOCALTIME_R symbol, ?S: which indicates to the C program that the localtime_r() ?S: routine is available. ?S:. ?S:d_localtime_r_needs_tzset: ?S: This variable conditionally defines the LOCALTIME_R_NEEDS_TZSET ?S: symbol, which makes us call tzset before localtime_r() ?S:. ?S:localtime_r_proto: ?S: This variable encodes the prototype of localtime_r. ?S: It is zero if d_localtime_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r ?S: is defined. ?S:. ?C:HAS_LOCALTIME_R: ?C: This symbol, if defined, indicates that the localtime_r routine ?C: is available to localtime re-entrantly. ?C:. ?C:LOCALTIME_R_NEEDS_TZSET: ?C: Many libc's localtime_r implementations do not call tzset, ?C: making them differ from localtime(), and making timezone ?C: changes using \$ENV{TZ} without explicitly calling tzset ?C: impossible. This symbol makes us call tzset before localtime_r ?C:. ?H:?%<:#$d_localtime_r_needs_tzset LOCALTIME_R_NEEDS_TZSET /**/ ?H:?%<:#ifdef LOCALTIME_R_NEEDS_TZSET ?H:?%<:#define L_R_TZSET tzset(), ?H:?%<:#else ?H:?%<:#define L_R_TZSET ?H:?%<:#endif ?H:. ?C:L_R_TZSET: ?C: If localtime_r() needs tzset, it is defined in this define ?C:. ?C:LOCALTIME_R_PROTO: ?C: This symbol encodes the prototype of localtime_r. ?C: It is zero if d_localtime_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_localtime_r ?C: is defined. ?C:. ?H:#$d_localtime_r HAS_LOCALTIME_R /**/ ?H:#define LOCALTIME_R_PROTO $localtime_r_proto /**/ ?H:. ?T:try hdrs d_localtime_r_proto ?F:!try : see if localtime_r exists set localtime_r d_localtime_r eval $inlibc case "$d_localtime_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_time time.h $i_systime sys/time.h" case "$d_localtime_r_proto:$usethreads" in ":define") d_localtime_r_proto=define set d_localtime_r_proto localtime_r $hdrs eval $hasproto ;; *) ;; esac case "$d_localtime_r_proto" in define) case "$localtime_r_proto" in ''|0) try='struct tm* localtime_r(const time_t*, struct tm*);' ./protochk "$extern_C $try" $hdrs && localtime_r_proto=S_TS ;; esac case "$localtime_r_proto" in ''|0) try='int localtime_r(const time_t*, struct tm*);' ./protochk "$extern_C $try" $hdrs && localtime_r_proto=I_TS ;; esac case "$localtime_r_proto" in ''|0) d_localtime_r=undef localtime_r_proto=0 echo "Disabling localtime_r, cannot determine prototype." >&4 ;; * ) case "$localtime_r_proto" in REENTRANT_PROTO*) ;; *) localtime_r_proto="REENTRANT_PROTO_$localtime_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "localtime_r has no prototype, not using it." >&4 ;; esac d_localtime_r=undef localtime_r_proto=0 ;; esac ;; *) localtime_r_proto=0 ;; esac : see if localtime_r calls tzset case "$localtime_r_proto" in REENTRANT_PROTO*) $cat >try.c < #endif #ifdef I_UNISTD # include #endif #ifdef I_TIME # include #endif #ifdef I_STDLIB #include #endif #ifdef I_STRING # include #else # include #endif #ifdef I_MALLOC # include #endif int main() { time_t t = time(0L); char w_tz[]="TZ" "=GMT+5", e_tz[]="TZ" "=GMT-5", *tz_e = (char*)malloc(16), *tz_w = (char*)malloc(16); struct tm tm_e, tm_w; memset(&tm_e,'\0',sizeof(struct tm)); memset(&tm_w,'\0',sizeof(struct tm)); strcpy(tz_e,e_tz); strcpy(tz_w,w_tz); putenv(tz_e); localtime_r(&t, &tm_e); putenv(tz_w); localtime_r(&t, &tm_w); if( memcmp(&tm_e, &tm_w, sizeof(struct tm)) == 0 ) return 1; return 0; } EOCP set try if eval $compile; then if $run ./try; then d_localtime_r_needs_tzset=undef; else d_localtime_r_needs_tzset=define; fi; else d_localtime_r_needs_tzset=undef; fi; ;; *) d_localtime_r_needs_tzset=undef; ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/threads/d_pthrattrj.U000066400000000000000000000051541316016665300224260ustar00rootroot00000000000000?RCS: $Id: d_pthrattrj.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_old_pthread_create_joinable old_pthread_create_joinable: \ cat Compile rm_try Setvar usethreads i_pthread ?MAKE: -pick add $@ %< ?S:d_old_pthread_create_joinable: ?S: This variable conditionally defines pthread_create_joinable. ?S: undef if pthread.h defines PTHREAD_CREATE_JOINABLE. ?S:. ?S:old_pthread_create_joinable: ?S: This variable defines the constant to use for creating joinable ?S: (aka undetached) pthreads. Unused if pthread.h defines ?S: PTHREAD_CREATE_JOINABLE. If used, possible values are ?S: PTHREAD_CREATE_UNDETACHED and __UNDETACHED. ?S:. ?C:OLD_PTHREAD_CREATE_JOINABLE: ?C: This symbol, if defined, indicates how to create pthread ?C: in joinable (aka undetached) state. NOTE: not defined ?C: if pthread.h already has defined PTHREAD_CREATE_JOINABLE ?C: (the new version of the constant). ?C: If defined, known values are PTHREAD_CREATE_UNDETACHED ?C: and __UNDETACHED. ?C:. ?H:#$d_old_pthread_create_joinable OLD_PTHREAD_CREATE_JOINABLE $old_pthread_create_joinable /**/ ?H:. : how to create joinable pthreads if test "X$usethreads" = "X$define" -a "X$i_pthread" = "X$define"; then echo " " echo "Checking what constant to use for creating joinable pthreads..." >&4 $cat >try.c <<'EOCP' #include int main() { int detachstate = JOINABLE; } EOCP set try -DJOINABLE=PTHREAD_CREATE_JOINABLE if eval $compile; then echo "You seem to use PTHREAD_CREATE_JOINABLE." >&4 val="$undef" # Yes, undef. set d_old_pthread_create_joinable eval $setvar val="" set old_pthread_create_joinable eval $setvar else set try -DJOINABLE=PTHREAD_CREATE_UNDETACHED if eval $compile; then echo "You seem to use PTHREAD_CREATE_UNDETACHED." >&4 val="$define" set d_old_pthread_create_joinable eval $setvar val=PTHREAD_CREATE_UNDETACHED set old_pthread_create_joinable eval $setvar else set try -DJOINABLE=__UNDETACHED if eval $compile; then echo "You seem to use __UNDETACHED." >&4 val="$define" set d_old_pthread_create_joinable eval $setvar val=__UNDETACHED set old_pthread_create_joinable eval $setvar else echo "Egads, nothing obvious found. Guessing that you use 0." >&4 val="$define" set d_old_pthread_create_joinable eval $setvar val=0 set old_pthread_create_joinable eval $setvar fi fi fi $rm_try else d_old_pthread_create_joinable="$undef" old_pthread_create_joinable="" fi metaconfig-debian-perl-5.26.1/U/threads/d_pthread_atfork.U000066400000000000000000000023341316016665300233760ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_pthread_atfork: Inlibc cat Compile usethreads Setvar ?MAKE: -pick add $@ %< ?S:d_pthread_atfork: ?S: This variable conditionally defines the HAS_PTHREAD_ATFORK symbol, ?S: which indicates to the C program that the pthread_atfork() ?S: routine is available. ?S:. ?C:HAS_PTHREAD_ATFORK: ?C: This symbol, if defined, indicates that the pthread_atfork routine ?C: is available to setup fork handlers. ?C:. ?H:#$d_pthread_atfork HAS_PTHREAD_ATFORK /**/ ?H:. ?LINT:set d_pthread_atfork : see whether the pthread_atfork exists $cat >try.c < #include int main() { #ifdef PTHREAD_ATFORK pthread_atfork(NULL,NULL,NULL); #endif } EOP : see if pthread_atfork exists set try -DPTHREAD_ATFORK if eval $compile; then val="$define" else val="$undef" fi case "$usethreads" in $define) case "$val" in $define) echo 'pthread_atfork found.' >&4 ;; *) echo 'pthread_atfork NOT found.' >&4 ;; esac esac set d_pthread_atfork eval $setvar metaconfig-debian-perl-5.26.1/U/threads/d_pthread_y.U000066400000000000000000000053641316016665300223660ustar00rootroot00000000000000?RCS: $Id: d_pthread_y.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_pthread_yield sched_yield d_sched_yield: \ Compile Setvar cat rm_try usethreads ?MAKE: -pick add $@ %< ?S:d_pthread_yield: ?S: This variable conditionally defines the HAS_PTHREAD_YIELD ?S: symbol if the pthread_yield routine is available to yield ?S: the execution of the current thread. ?S:. ?S:sched_yield: ?S: This variable defines the way to yield the execution ?S: of the current thread. ?S:. ?S:d_sched_yield: ?S: This variable conditionally defines the HAS_SCHED_YIELD ?S: symbol if the sched_yield routine is available to yield ?S: the execution of the current thread. ?S:. ?C:HAS_PTHREAD_YIELD: ?C: This symbol, if defined, indicates that the pthread_yield ?C: routine is available to yield the execution of the current ?C: thread. sched_yield is preferable to pthread_yield. ?C:. ?C:SCHED_YIELD: ?C: This symbol defines the way to yield the execution of ?C: the current thread. Known ways are sched_yield, ?C: pthread_yield, and pthread_yield with NULL. ?C:. ?C:HAS_SCHED_YIELD: ?C: This symbol, if defined, indicates that the sched_yield ?C: routine is available to yield the execution of the current ?C: thread. sched_yield is preferable to pthread_yield. ?C:. ?H:#$d_pthread_yield HAS_PTHREAD_YIELD /**/ ?H:#define SCHED_YIELD $sched_yield /**/ ?H:#$d_sched_yield HAS_SCHED_YIELD /**/ ?H:. ?LINT: set d_pthread_yield d_sched_yield : see whether the various POSIXish _yields exist $cat >try.c < #include int main() { #ifdef SCHED_YIELD sched_yield(); #else #ifdef PTHREAD_YIELD pthread_yield(); #else #ifdef PTHREAD_YIELD_NULL pthread_yield(NULL); #endif #endif #endif } EOP : see if sched_yield exists set try -DSCHED_YIELD if eval $compile; then val="$define" sched_yield='sched_yield()' else val="$undef" fi case "$usethreads" in $define) case "$val" in $define) echo 'sched_yield() found.' >&4 ;; *) echo 'sched_yield() NOT found.' >&4 ;; esac esac set d_sched_yield eval $setvar : see if pthread_yield exists set try -DPTHREAD_YIELD if eval $compile; then val="$define" case "$sched_yield" in '') sched_yield='pthread_yield()' ;; esac else set try -DPTHREAD_YIELD_NULL if eval $compile; then val="$define" case "$sched_yield" in '') sched_yield='pthread_yield(NULL)' ;; esac else val="$undef" fi fi case "$usethreads" in $define) case "$val" in $define) echo 'pthread_yield() found.' >&4 ;; *) echo 'pthread_yield() NOT found.' >&4 ;; esac ;; esac set d_pthread_yield eval $setvar case "$sched_yield" in '') sched_yield=undef ;; esac $rm_try metaconfig-debian-perl-5.26.1/U/threads/d_pthreadj.U000066400000000000000000000042561316016665300222070ustar00rootroot00000000000000?RCS: $Id: d_pthreadj.U,v $ ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_pthreads_created_joinable: cat Compile rm usethreads Setvar \ i_pthread run ?MAKE: -pick add $@ %< ?S:d_pthreads_created_joinable: ?S: This variable conditionally defines the PTHREADS_CREATED_JOINABLE ?S: symbol if pthreads are created in the joinable (aka undetached) ?S: state. ?S:. ?C:PTHREADS_CREATED_JOINABLE: ?C: This symbol, if defined, indicates that pthreads are created ?C: in the joinable (aka undetached) state. ?C:. ?H:#$d_pthreads_created_joinable PTHREADS_CREATED_JOINABLE /**/ ?H:. ?T:yyy ?F:!try : test whether pthreads are created in joinable -- aka undetached -- state if test "X$usethreads" = "X$define" -a "X$i_pthread" = "X$define"; then echo "Checking whether pthreads are created joinable..." >&4 $cat >try.c <<'EOCP' #include #ifdef PTHREAD_CREATE_UNDETACHED # define ATTR_JOINABLE PTHREAD_CREATE_UNDETACHED #else # ifdef __UNDETACHED # define ATTR_JOINABLE __UNDETACHED # endif #endif #include int main() { pthread_attr_t attr; int detachstate; printf("%s\n", pthread_attr_init(&attr) == 0 && #if PTHREAD_ATTR_GETDETACHSTATE_INT pthread_attr_getdetachstate(&attr) == ATTR_JOINABLE && #else pthread_attr_getdetachstate(&attr, &detachstate) == 0 && detachstate == PTHREAD_ATTR_JOINABLE #endif ? "detached" : "joinable"); exit(0); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in detached) echo "No, they aren't." ;; *) echo "Yes, they are." ;; esac else set try -DPTHREAD_ATTR_GETDETACHSTATE_INT if eval $compile; then yyy=`$run ./try` case "$yyy" in detached) echo "No, they aren't." ;; *) echo "Yes, they are." ;; esac else echo " " echo "(I can't execute the test program--assuming they are.)" >&4 yyy=joinable fi fi $rm -f try try.* case "$yyy" in detached) val="$undef" ;; *) val="$define" ;; esac set d_pthreads_created_joinable eval $setvar else d_pthreads_created_joinable="$undef" fi metaconfig-debian-perl-5.26.1/U/threads/d_rand_r.U000066400000000000000000000012241316016665300216430ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:d_rand_r: Inlibc ?MAKE: -pick add $@ %< ?S:d_rand_r: ?S: This variable conditionally defines the HAS_RAND_R symbol, ?S: which indicates to the C program that the rand_r() ?S: routine is available. ?S:. ?C:HAS_RAND_R: ?C: This symbol, if defined, indicates that the rand_r routine ?C: is available to rand re-entrantly. ?C:. ?H:#$d_rand_r HAS_RAND_R /**/ ?H:. ?LINT:set d_rand_r : see if rand_r exists set rand_r d_rand_r eval $inlibc metaconfig-debian-perl-5.26.1/U/threads/d_random_r.U000066400000000000000000000047471316016665300222140ustar00rootroot00000000000000?RCS: $Id: d_random_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_random_r random_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_stdlib extern_C ?MAKE: -pick add $@ %< ?S:d_random_r: ?S: This variable conditionally defines the HAS_RANDOM_R symbol, ?S: which indicates to the C program that the random_r() ?S: routine is available. ?S:. ?S:random_r_proto: ?S: This variable encodes the prototype of random_r. ?S: It is zero if d_random_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r ?S: is defined. ?S:. ?C:HAS_RANDOM_R: ?C: This symbol, if defined, indicates that the random_r routine ?C: is available to random re-entrantly. ?C:. ?C:RANDOM_R_PROTO: ?C: This symbol encodes the prototype of random_r. ?C: It is zero if d_random_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_random_r ?C: is defined. ?C:. ?H:#$d_random_r HAS_RANDOM_R /**/ ?H:#define RANDOM_R_PROTO $random_r_proto /**/ ?H:. ?T:try hdrs d_random_r_proto : see if random_r exists set random_r d_random_r eval $inlibc case "$d_random_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" case "$d_random_r_proto:$usethreads" in ":define") d_random_r_proto=define set d_random_r_proto random_r $hdrs eval $hasproto ;; *) ;; esac case "$d_random_r_proto" in define) case "$random_r_proto" in ''|0) try='int random_r(int*, struct random_data*);' ./protochk "$extern_C $try" $hdrs && random_r_proto=I_iS ;; esac case "$random_r_proto" in ''|0) try='int random_r(long*, struct random_data*);' ./protochk "$extern_C $try" $hdrs && random_r_proto=I_lS ;; esac case "$random_r_proto" in ''|0) try='int random_r(struct random_data*, int32_t*);' ./protochk "$extern_C $try" $hdrs && random_r_proto=I_St ;; esac case "$random_r_proto" in ''|0) d_random_r=undef random_r_proto=0 echo "Disabling random_r, cannot determine prototype." >&4 ;; * ) case "$random_r_proto" in REENTRANT_PROTO*) ;; *) random_r_proto="REENTRANT_PROTO_$random_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "random_r has no prototype, not using it." >&4 ;; esac d_random_r=undef random_r_proto=0 ;; esac ;; *) random_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_readdir64_r.U000066400000000000000000000047541316016665300225160ustar00rootroot00000000000000?RCS: $Id: d_readdir64_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_readdir64_r readdir64_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_dirent extern_C ?MAKE: -pick add $@ %< ?S:d_readdir64_r: ?S: This variable conditionally defines the HAS_READDIR64_R symbol, ?S: which indicates to the C program that the readdir64_r() ?S: routine is available. ?S:. ?S:readdir64_r_proto: ?S: This variable encodes the prototype of readdir64_r. ?S: It is zero if d_readdir64_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r ?S: is defined. ?S:. ?C:HAS_READDIR64_R: ?C: This symbol, if defined, indicates that the readdir64_r routine ?C: is available to readdir64 re-entrantly. ?C:. ?C:READDIR64_R_PROTO: ?C: This symbol encodes the prototype of readdir64_r. ?C: It is zero if d_readdir64_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir64_r ?C: is defined. ?C:. ?H:#$d_readdir64_r HAS_READDIR64_R /**/ ?H:#define READDIR64_R_PROTO $readdir64_r_proto /**/ ?H:. ?T:try hdrs d_readdir64_r_proto : see if readdir64_r exists set readdir64_r d_readdir64_r eval $inlibc case "$d_readdir64_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_dirent dirent.h" case "$d_readdir64_r_proto:$usethreads" in ":define") d_readdir64_r_proto=define set d_readdir64_r_proto readdir64_r $hdrs eval $hasproto ;; *) ;; esac case "$d_readdir64_r_proto" in define) case "$readdir64_r_proto" in ''|0) try='int readdir64_r(DIR*, struct dirent64*, struct dirent64**);' ./protochk "$extern_C $try" $hdrs && readdir64_r_proto=I_TSR ;; esac case "$readdir64_r_proto" in ''|0) try='int readdir64_r(DIR*, struct dirent64*);' ./protochk "$extern_C $try" $hdrs && readdir64_r_proto=I_TS ;; esac case "$readdir64_r_proto" in ''|0) d_readdir64_r=undef readdir64_r_proto=0 echo "Disabling readdir64_r, cannot determine prototype." >&4 ;; * ) case "$readdir64_r_proto" in REENTRANT_PROTO*) ;; *) readdir64_r_proto="REENTRANT_PROTO_$readdir64_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "readdir64_r has no prototype, not using it." >&4 ;; esac d_readdir64_r=undef readdir64_r_proto=0 ;; esac ;; *) readdir64_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_readdir_r.U000066400000000000000000000046061316016665300223400ustar00rootroot00000000000000?RCS: $Id: d_readdir_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_readdir_r readdir_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_dirent extern_C ?MAKE: -pick add $@ %< ?S:d_readdir_r: ?S: This variable conditionally defines the HAS_READDIR_R symbol, ?S: which indicates to the C program that the readdir_r() ?S: routine is available. ?S:. ?S:readdir_r_proto: ?S: This variable encodes the prototype of readdir_r. ?S: It is zero if d_readdir_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r ?S: is defined. ?S:. ?C:HAS_READDIR_R: ?C: This symbol, if defined, indicates that the readdir_r routine ?C: is available to readdir re-entrantly. ?C:. ?C:READDIR_R_PROTO: ?C: This symbol encodes the prototype of readdir_r. ?C: It is zero if d_readdir_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_readdir_r ?C: is defined. ?C:. ?H:#$d_readdir_r HAS_READDIR_R /**/ ?H:#define READDIR_R_PROTO $readdir_r_proto /**/ ?H:. ?T:try hdrs d_readdir_r_proto : see if readdir_r exists set readdir_r d_readdir_r eval $inlibc case "$d_readdir_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_dirent dirent.h" case "$d_readdir_r_proto:$usethreads" in ":define") d_readdir_r_proto=define set d_readdir_r_proto readdir_r $hdrs eval $hasproto ;; *) ;; esac case "$d_readdir_r_proto" in define) case "$readdir_r_proto" in ''|0) try='int readdir_r(DIR*, struct dirent*, struct dirent**);' ./protochk "$extern_C $try" $hdrs && readdir_r_proto=I_TSR ;; esac case "$readdir_r_proto" in ''|0) try='int readdir_r(DIR*, struct dirent*);' ./protochk "$extern_C $try" $hdrs && readdir_r_proto=I_TS ;; esac case "$readdir_r_proto" in ''|0) d_readdir_r=undef readdir_r_proto=0 echo "Disabling readdir_r, cannot determine prototype." >&4 ;; * ) case "$readdir_r_proto" in REENTRANT_PROTO*) ;; *) readdir_r_proto="REENTRANT_PROTO_$readdir_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "readdir_r has no prototype, not using it." >&4 ;; esac d_readdir_r=undef readdir_r_proto=0 ;; esac ;; *) readdir_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setgrent_r.U000066400000000000000000000045761316016665300225670ustar00rootroot00000000000000?RCS: $Id: d_setgrent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setgrent_r setgrent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_grp extern_C ?MAKE: -pick add $@ %< ?S:d_setgrent_r: ?S: This variable conditionally defines the HAS_SETGRENT_R symbol, ?S: which indicates to the C program that the setgrent_r() ?S: routine is available. ?S:. ?S:setgrent_r_proto: ?S: This variable encodes the prototype of setgrent_r. ?S: It is zero if d_setgrent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r ?S: is defined. ?S:. ?C:HAS_SETGRENT_R: ?C: This symbol, if defined, indicates that the setgrent_r routine ?C: is available to setgrent re-entrantly. ?C:. ?C:SETGRENT_R_PROTO: ?C: This symbol encodes the prototype of setgrent_r. ?C: It is zero if d_setgrent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setgrent_r ?C: is defined. ?C:. ?H:#$d_setgrent_r HAS_SETGRENT_R /**/ ?H:#define SETGRENT_R_PROTO $setgrent_r_proto /**/ ?H:. ?T:try hdrs d_setgrent_r_proto : see if setgrent_r exists set setgrent_r d_setgrent_r eval $inlibc case "$d_setgrent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_grp grp.h" case "$d_setgrent_r_proto:$usethreads" in ":define") d_setgrent_r_proto=define set d_setgrent_r_proto setgrent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setgrent_r_proto" in define) case "$setgrent_r_proto" in ''|0) try='int setgrent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && setgrent_r_proto=I_H ;; esac case "$setgrent_r_proto" in ''|0) try='void setgrent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && setgrent_r_proto=V_H ;; esac case "$setgrent_r_proto" in ''|0) d_setgrent_r=undef setgrent_r_proto=0 echo "Disabling setgrent_r, cannot determine prototype." >&4 ;; * ) case "$setgrent_r_proto" in REENTRANT_PROTO*) ;; *) setgrent_r_proto="REENTRANT_PROTO_$setgrent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setgrent_r has no prototype, not using it." >&4 ;; esac d_setgrent_r=undef setgrent_r_proto=0 ;; esac ;; *) setgrent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_sethostent_r.U000066400000000000000000000050141316016665300231200ustar00rootroot00000000000000?RCS: $Id: d_sethostent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_sethostent_r sethostent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_sethostent_r: ?S: This variable conditionally defines the HAS_SETHOSTENT_R symbol, ?S: which indicates to the C program that the sethostent_r() ?S: routine is available. ?S:. ?S:sethostent_r_proto: ?S: This variable encodes the prototype of sethostent_r. ?S: It is zero if d_sethostent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r ?S: is defined. ?S:. ?C:HAS_SETHOSTENT_R: ?C: This symbol, if defined, indicates that the sethostent_r routine ?C: is available to sethostent re-entrantly. ?C:. ?C:SETHOSTENT_R_PROTO: ?C: This symbol encodes the prototype of sethostent_r. ?C: It is zero if d_sethostent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_sethostent_r ?C: is defined. ?C:. ?H:#$d_sethostent_r HAS_SETHOSTENT_R /**/ ?H:#define SETHOSTENT_R_PROTO $sethostent_r_proto /**/ ?H:. ?T:try hdrs d_sethostent_r_proto : see if sethostent_r exists set sethostent_r d_sethostent_r eval $inlibc case "$d_sethostent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_sethostent_r_proto:$usethreads" in ":define") d_sethostent_r_proto=define set d_sethostent_r_proto sethostent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_sethostent_r_proto" in define) case "$sethostent_r_proto" in ''|0) try='int sethostent_r(int, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && sethostent_r_proto=I_ID ;; esac case "$sethostent_r_proto" in ''|0) try='void sethostent_r(int, struct hostent_data*);' ./protochk "$extern_C $try" $hdrs && sethostent_r_proto=V_ID ;; esac case "$sethostent_r_proto" in ''|0) d_sethostent_r=undef sethostent_r_proto=0 echo "Disabling sethostent_r, cannot determine prototype." >&4 ;; * ) case "$sethostent_r_proto" in REENTRANT_PROTO*) ;; *) sethostent_r_proto="REENTRANT_PROTO_$sethostent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "sethostent_r has no prototype, not using it." >&4 ;; esac d_sethostent_r=undef sethostent_r_proto=0 ;; esac ;; *) sethostent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setlocale_r.U000066400000000000000000000045061316016665300227000ustar00rootroot00000000000000?RCS: $Id: d_setlocale_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setlocale_r setlocale_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_locale extern_C ?MAKE: -pick add $@ %< ?S:d_setlocale_r: ?S: This variable conditionally defines the HAS_SETLOCALE_R symbol, ?S: which indicates to the C program that the setlocale_r() ?S: routine is available. ?S:. ?S:setlocale_r_proto: ?S: This variable encodes the prototype of setlocale_r. ?S: It is zero if d_setlocale_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r ?S: is defined. ?S:. ?C:HAS_SETLOCALE_R: ?C: This symbol, if defined, indicates that the setlocale_r routine ?C: is available to setlocale re-entrantly. ?C:. ?C:SETLOCALE_R_PROTO: ?C: This symbol encodes the prototype of setlocale_r. ?C: It is zero if d_setlocale_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setlocale_r ?C: is defined. ?C:. ?H:#$d_setlocale_r HAS_SETLOCALE_R /**/ ?H:#define SETLOCALE_R_PROTO $setlocale_r_proto /**/ ?H:. ?T:try hdrs d_setlocale_r_proto : see if setlocale_r exists set setlocale_r d_setlocale_r eval $inlibc case "$d_setlocale_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_locale locale.h" case "$d_setlocale_r_proto:$usethreads" in ":define") d_setlocale_r_proto=define set d_setlocale_r_proto setlocale_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setlocale_r_proto" in define) case "$setlocale_r_proto" in ''|0) try='int setlocale_r(int, const char*, char*, int);' ./protochk "$extern_C $try" $hdrs && setlocale_r_proto=I_ICBI ;; esac case "$setlocale_r_proto" in ''|0) d_setlocale_r=undef setlocale_r_proto=0 echo "Disabling setlocale_r, cannot determine prototype." >&4 ;; * ) case "$setlocale_r_proto" in REENTRANT_PROTO*) ;; *) setlocale_r_proto="REENTRANT_PROTO_$setlocale_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setlocale_r has no prototype, not using it." >&4 ;; esac d_setlocale_r=undef setlocale_r_proto=0 ;; esac ;; *) setlocale_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setnetent_r.U000066400000000000000000000047321316016665300227370ustar00rootroot00000000000000?RCS: $Id: d_setnetent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setnetent_r setnetent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_setnetent_r: ?S: This variable conditionally defines the HAS_SETNETENT_R symbol, ?S: which indicates to the C program that the setnetent_r() ?S: routine is available. ?S:. ?S:setnetent_r_proto: ?S: This variable encodes the prototype of setnetent_r. ?S: It is zero if d_setnetent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r ?S: is defined. ?S:. ?C:HAS_SETNETENT_R: ?C: This symbol, if defined, indicates that the setnetent_r routine ?C: is available to setnetent re-entrantly. ?C:. ?C:SETNETENT_R_PROTO: ?C: This symbol encodes the prototype of setnetent_r. ?C: It is zero if d_setnetent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setnetent_r ?C: is defined. ?C:. ?H:#$d_setnetent_r HAS_SETNETENT_R /**/ ?H:#define SETNETENT_R_PROTO $setnetent_r_proto /**/ ?H:. ?T:try hdrs d_setnetent_r_proto : see if setnetent_r exists set setnetent_r d_setnetent_r eval $inlibc case "$d_setnetent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_setnetent_r_proto:$usethreads" in ":define") d_setnetent_r_proto=define set d_setnetent_r_proto setnetent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setnetent_r_proto" in define) case "$setnetent_r_proto" in ''|0) try='int setnetent_r(int, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && setnetent_r_proto=I_ID ;; esac case "$setnetent_r_proto" in ''|0) try='void setnetent_r(int, struct netent_data*);' ./protochk "$extern_C $try" $hdrs && setnetent_r_proto=V_ID ;; esac case "$setnetent_r_proto" in ''|0) d_setnetent_r=undef setnetent_r_proto=0 echo "Disabling setnetent_r, cannot determine prototype." >&4 ;; * ) case "$setnetent_r_proto" in REENTRANT_PROTO*) ;; *) setnetent_r_proto="REENTRANT_PROTO_$setnetent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setnetent_r has no prototype, not using it." >&4 ;; esac d_setnetent_r=undef setnetent_r_proto=0 ;; esac ;; *) setnetent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setprotoent_r.U000066400000000000000000000050761316016665300233160ustar00rootroot00000000000000?RCS: $Id: d_setprotoent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setprotoent_r setprotoent_r_proto: Inlibc Protochk Hasproto \ i_systypes usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_setprotoent_r: ?S: This variable conditionally defines the HAS_SETPROTOENT_R symbol, ?S: which indicates to the C program that the setprotoent_r() ?S: routine is available. ?S:. ?S:setprotoent_r_proto: ?S: This variable encodes the prototype of setprotoent_r. ?S: It is zero if d_setprotoent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r ?S: is defined. ?S:. ?C:HAS_SETPROTOENT_R: ?C: This symbol, if defined, indicates that the setprotoent_r routine ?C: is available to setprotoent re-entrantly. ?C:. ?C:SETPROTOENT_R_PROTO: ?C: This symbol encodes the prototype of setprotoent_r. ?C: It is zero if d_setprotoent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setprotoent_r ?C: is defined. ?C:. ?H:#$d_setprotoent_r HAS_SETPROTOENT_R /**/ ?H:#define SETPROTOENT_R_PROTO $setprotoent_r_proto /**/ ?H:. ?T:try hdrs d_setprotoent_r_proto : see if setprotoent_r exists set setprotoent_r d_setprotoent_r eval $inlibc case "$d_setprotoent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_setprotoent_r_proto:$usethreads" in ":define") d_setprotoent_r_proto=define set d_setprotoent_r_proto setprotoent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setprotoent_r_proto" in define) case "$setprotoent_r_proto" in ''|0) try='int setprotoent_r(int, struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && setprotoent_r_proto=I_ID ;; esac case "$setprotoent_r_proto" in ''|0) try='void setprotoent_r(int, struct protoent_data*);' ./protochk "$extern_C $try" $hdrs && setprotoent_r_proto=V_ID ;; esac case "$setprotoent_r_proto" in ''|0) d_setprotoent_r=undef setprotoent_r_proto=0 echo "Disabling setprotoent_r, cannot determine prototype." >&4 ;; * ) case "$setprotoent_r_proto" in REENTRANT_PROTO*) ;; *) setprotoent_r_proto="REENTRANT_PROTO_$setprotoent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setprotoent_r has no prototype, not using it." >&4 ;; esac d_setprotoent_r=undef setprotoent_r_proto=0 ;; esac ;; *) setprotoent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setpwent_r.U000066400000000000000000000045761316016665300226050ustar00rootroot00000000000000?RCS: $Id: d_setpwent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setpwent_r setpwent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_pwd extern_C ?MAKE: -pick add $@ %< ?S:d_setpwent_r: ?S: This variable conditionally defines the HAS_SETPWENT_R symbol, ?S: which indicates to the C program that the setpwent_r() ?S: routine is available. ?S:. ?S:setpwent_r_proto: ?S: This variable encodes the prototype of setpwent_r. ?S: It is zero if d_setpwent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r ?S: is defined. ?S:. ?C:HAS_SETPWENT_R: ?C: This symbol, if defined, indicates that the setpwent_r routine ?C: is available to setpwent re-entrantly. ?C:. ?C:SETPWENT_R_PROTO: ?C: This symbol encodes the prototype of setpwent_r. ?C: It is zero if d_setpwent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setpwent_r ?C: is defined. ?C:. ?H:#$d_setpwent_r HAS_SETPWENT_R /**/ ?H:#define SETPWENT_R_PROTO $setpwent_r_proto /**/ ?H:. ?T:try hdrs d_setpwent_r_proto : see if setpwent_r exists set setpwent_r d_setpwent_r eval $inlibc case "$d_setpwent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_pwd pwd.h" case "$d_setpwent_r_proto:$usethreads" in ":define") d_setpwent_r_proto=define set d_setpwent_r_proto setpwent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setpwent_r_proto" in define) case "$setpwent_r_proto" in ''|0) try='int setpwent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && setpwent_r_proto=I_H ;; esac case "$setpwent_r_proto" in ''|0) try='void setpwent_r(FILE**);' ./protochk "$extern_C $try" $hdrs && setpwent_r_proto=V_H ;; esac case "$setpwent_r_proto" in ''|0) d_setpwent_r=undef setpwent_r_proto=0 echo "Disabling setpwent_r, cannot determine prototype." >&4 ;; * ) case "$setpwent_r_proto" in REENTRANT_PROTO*) ;; *) setpwent_r_proto="REENTRANT_PROTO_$setpwent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setpwent_r has no prototype, not using it." >&4 ;; esac d_setpwent_r=undef setpwent_r_proto=0 ;; esac ;; *) setpwent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_setservent_r.U000066400000000000000000000050141316016665300231220ustar00rootroot00000000000000?RCS: $Id: d_setservent_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_setservent_r setservent_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_netdb extern_C ?MAKE: -pick add $@ %< ?S:d_setservent_r: ?S: This variable conditionally defines the HAS_SETSERVENT_R symbol, ?S: which indicates to the C program that the setservent_r() ?S: routine is available. ?S:. ?S:setservent_r_proto: ?S: This variable encodes the prototype of setservent_r. ?S: It is zero if d_setservent_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r ?S: is defined. ?S:. ?C:HAS_SETSERVENT_R: ?C: This symbol, if defined, indicates that the setservent_r routine ?C: is available to setservent re-entrantly. ?C:. ?C:SETSERVENT_R_PROTO: ?C: This symbol encodes the prototype of setservent_r. ?C: It is zero if d_setservent_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_setservent_r ?C: is defined. ?C:. ?H:#$d_setservent_r HAS_SETSERVENT_R /**/ ?H:#define SETSERVENT_R_PROTO $setservent_r_proto /**/ ?H:. ?T:try hdrs d_setservent_r_proto : see if setservent_r exists set setservent_r d_setservent_r eval $inlibc case "$d_setservent_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_netdb netdb.h" case "$d_setservent_r_proto:$usethreads" in ":define") d_setservent_r_proto=define set d_setservent_r_proto setservent_r $hdrs eval $hasproto ;; *) ;; esac case "$d_setservent_r_proto" in define) case "$setservent_r_proto" in ''|0) try='int setservent_r(int, struct servent_data*);' ./protochk "$extern_C $try" $hdrs && setservent_r_proto=I_ID ;; esac case "$setservent_r_proto" in ''|0) try='void setservent_r(int, struct servent_data*);' ./protochk "$extern_C $try" $hdrs && setservent_r_proto=V_ID ;; esac case "$setservent_r_proto" in ''|0) d_setservent_r=undef setservent_r_proto=0 echo "Disabling setservent_r, cannot determine prototype." >&4 ;; * ) case "$setservent_r_proto" in REENTRANT_PROTO*) ;; *) setservent_r_proto="REENTRANT_PROTO_$setservent_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "setservent_r has no prototype, not using it." >&4 ;; esac d_setservent_r=undef setservent_r_proto=0 ;; esac ;; *) setservent_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_srand48_r.U000066400000000000000000000043501316016665300222050ustar00rootroot00000000000000?RCS: $Id: d_srand48_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_srand48_r srand48_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_stdlib extern_C ?MAKE: -pick add $@ %< ?S:d_srand48_r: ?S: This variable conditionally defines the HAS_SRAND48_R symbol, ?S: which indicates to the C program that the srand48_r() ?S: routine is available. ?S:. ?S:srand48_r_proto: ?S: This variable encodes the prototype of srand48_r. ?S: It is zero if d_srand48_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r ?S: is defined. ?S:. ?C:HAS_SRAND48_R: ?C: This symbol, if defined, indicates that the srand48_r routine ?C: is available to srand48 re-entrantly. ?C:. ?C:SRAND48_R_PROTO: ?C: This symbol encodes the prototype of srand48_r. ?C: It is zero if d_srand48_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_srand48_r ?C: is defined. ?C:. ?H:#$d_srand48_r HAS_SRAND48_R /**/ ?H:#define SRAND48_R_PROTO $srand48_r_proto /**/ ?H:. ?T:try hdrs d_srand48_r_proto : see if srand48_r exists set srand48_r d_srand48_r eval $inlibc case "$d_srand48_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" case "$d_srand48_r_proto:$usethreads" in ":define") d_srand48_r_proto=define set d_srand48_r_proto srand48_r $hdrs eval $hasproto ;; *) ;; esac case "$d_srand48_r_proto" in define) case "$srand48_r_proto" in ''|0) try='int srand48_r(long, struct drand48_data*);' ./protochk "$extern_C $try" $hdrs && srand48_r_proto=I_LS ;; esac case "$srand48_r_proto" in ''|0) d_srand48_r=undef srand48_r_proto=0 echo "Disabling srand48_r, cannot determine prototype." >&4 ;; * ) case "$srand48_r_proto" in REENTRANT_PROTO*) ;; *) srand48_r_proto="REENTRANT_PROTO_$srand48_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "srand48_r has no prototype, not using it." >&4 ;; esac d_srand48_r=undef srand48_r_proto=0 ;; esac ;; *) srand48_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_srandom_r.U000066400000000000000000000043571316016665300223740ustar00rootroot00000000000000?RCS: $Id: d_srandom_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_srandom_r srandom_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_stdlib extern_C ?MAKE: -pick add $@ %< ?S:d_srandom_r: ?S: This variable conditionally defines the HAS_SRANDOM_R symbol, ?S: which indicates to the C program that the srandom_r() ?S: routine is available. ?S:. ?S:srandom_r_proto: ?S: This variable encodes the prototype of srandom_r. ?S: It is zero if d_srandom_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r ?S: is defined. ?S:. ?C:HAS_SRANDOM_R: ?C: This symbol, if defined, indicates that the srandom_r routine ?C: is available to srandom re-entrantly. ?C:. ?C:SRANDOM_R_PROTO: ?C: This symbol encodes the prototype of srandom_r. ?C: It is zero if d_srandom_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_srandom_r ?C: is defined. ?C:. ?H:#$d_srandom_r HAS_SRANDOM_R /**/ ?H:#define SRANDOM_R_PROTO $srandom_r_proto /**/ ?H:. ?T:try hdrs d_srandom_r_proto : see if srandom_r exists set srandom_r d_srandom_r eval $inlibc case "$d_srandom_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_stdlib stdlib.h" case "$d_srandom_r_proto:$usethreads" in ":define") d_srandom_r_proto=define set d_srandom_r_proto srandom_r $hdrs eval $hasproto ;; *) ;; esac case "$d_srandom_r_proto" in define) case "$srandom_r_proto" in ''|0) try='int srandom_r(unsigned int, struct random_data*);' ./protochk "$extern_C $try" $hdrs && srandom_r_proto=I_TS ;; esac case "$srandom_r_proto" in ''|0) d_srandom_r=undef srandom_r_proto=0 echo "Disabling srandom_r, cannot determine prototype." >&4 ;; * ) case "$srandom_r_proto" in REENTRANT_PROTO*) ;; *) srandom_r_proto="REENTRANT_PROTO_$srandom_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "srandom_r has no prototype, not using it." >&4 ;; esac d_srandom_r=undef srandom_r_proto=0 ;; esac ;; *) srandom_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_strerror_r.U000066400000000000000000000050651316016665300226100ustar00rootroot00000000000000?RCS: $Id: d_strerror_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_strerror_r strerror_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_string extern_C ?MAKE: -pick add $@ %< ?S:d_strerror_r: ?S: This variable conditionally defines the HAS_STRERROR_R symbol, ?S: which indicates to the C program that the strerror_r() ?S: routine is available. ?S:. ?S:strerror_r_proto: ?S: This variable encodes the prototype of strerror_r. ?S: It is zero if d_strerror_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r ?S: is defined. ?S:. ?C:HAS_STRERROR_R: ?C: This symbol, if defined, indicates that the strerror_r routine ?C: is available to strerror re-entrantly. ?C:. ?C:STRERROR_R_PROTO: ?C: This symbol encodes the prototype of strerror_r. ?C: It is zero if d_strerror_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_strerror_r ?C: is defined. ?C:. ?H:#$d_strerror_r HAS_STRERROR_R /**/ ?H:#define STRERROR_R_PROTO $strerror_r_proto /**/ ?H:. ?T:try hdrs d_strerror_r_proto : see if strerror_r exists set strerror_r d_strerror_r eval $inlibc case "$d_strerror_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_string string.h" case "$d_strerror_r_proto:$usethreads" in ":define") d_strerror_r_proto=define set d_strerror_r_proto strerror_r $hdrs eval $hasproto ;; *) ;; esac case "$d_strerror_r_proto" in define) case "$strerror_r_proto" in ''|0) try='int strerror_r(int, char*, size_t);' ./protochk "$extern_C $try" $hdrs && strerror_r_proto=I_IBW ;; esac case "$strerror_r_proto" in ''|0) try='int strerror_r(int, char*, int);' ./protochk "$extern_C $try" $hdrs && strerror_r_proto=I_IBI ;; esac case "$strerror_r_proto" in ''|0) try='char* strerror_r(int, char*, size_t);' ./protochk "$extern_C $try" $hdrs && strerror_r_proto=B_IBW ;; esac case "$strerror_r_proto" in ''|0) d_strerror_r=undef strerror_r_proto=0 echo "Disabling strerror_r, cannot determine prototype." >&4 ;; * ) case "$strerror_r_proto" in REENTRANT_PROTO*) ;; *) strerror_r_proto="REENTRANT_PROTO_$strerror_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "strerror_r has no prototype, not using it." >&4 ;; esac d_strerror_r=undef strerror_r_proto=0 ;; esac ;; *) strerror_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_tmpnam_r.U000066400000000000000000000042141316016665300222150ustar00rootroot00000000000000?RCS: $Id: d_tmpnam_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_tmpnam_r tmpnam_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads extern_C ?MAKE: -pick add $@ %< ?S:d_tmpnam_r: ?S: This variable conditionally defines the HAS_TMPNAM_R symbol, ?S: which indicates to the C program that the tmpnam_r() ?S: routine is available. ?S:. ?S:tmpnam_r_proto: ?S: This variable encodes the prototype of tmpnam_r. ?S: It is zero if d_tmpnam_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r ?S: is defined. ?S:. ?C:HAS_TMPNAM_R: ?C: This symbol, if defined, indicates that the tmpnam_r routine ?C: is available to tmpnam re-entrantly. ?C:. ?C:TMPNAM_R_PROTO: ?C: This symbol encodes the prototype of tmpnam_r. ?C: It is zero if d_tmpnam_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_tmpnam_r ?C: is defined. ?C:. ?H:#$d_tmpnam_r HAS_TMPNAM_R /**/ ?H:#define TMPNAM_R_PROTO $tmpnam_r_proto /**/ ?H:. ?T:try hdrs d_tmpnam_r_proto : see if tmpnam_r exists set tmpnam_r d_tmpnam_r eval $inlibc case "$d_tmpnam_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h " case "$d_tmpnam_r_proto:$usethreads" in ":define") d_tmpnam_r_proto=define set d_tmpnam_r_proto tmpnam_r $hdrs eval $hasproto ;; *) ;; esac case "$d_tmpnam_r_proto" in define) case "$tmpnam_r_proto" in ''|0) try='char* tmpnam_r(char*);' ./protochk "$extern_C $try" $hdrs && tmpnam_r_proto=B_B ;; esac case "$tmpnam_r_proto" in ''|0) d_tmpnam_r=undef tmpnam_r_proto=0 echo "Disabling tmpnam_r, cannot determine prototype." >&4 ;; * ) case "$tmpnam_r_proto" in REENTRANT_PROTO*) ;; *) tmpnam_r_proto="REENTRANT_PROTO_$tmpnam_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "tmpnam_r has no prototype, not using it." >&4 ;; esac d_tmpnam_r=undef tmpnam_r_proto=0 ;; esac ;; *) tmpnam_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/d_ttyname_r.U000066400000000000000000000047771316016665300224200ustar00rootroot00000000000000?RCS: $Id: d_ttyname_r.U,v 0RCS: ?RCS: Copyright (c) 2002,2003 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: Generated by the reentr.pl from the Perl 5.8 distribution. ?RCS: ?MAKE:d_ttyname_r ttyname_r_proto: Inlibc Protochk Hasproto i_systypes \ usethreads i_unistd extern_C ?MAKE: -pick add $@ %< ?S:d_ttyname_r: ?S: This variable conditionally defines the HAS_TTYNAME_R symbol, ?S: which indicates to the C program that the ttyname_r() ?S: routine is available. ?S:. ?S:ttyname_r_proto: ?S: This variable encodes the prototype of ttyname_r. ?S: It is zero if d_ttyname_r is undef, and one of the ?S: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r ?S: is defined. ?S:. ?C:HAS_TTYNAME_R: ?C: This symbol, if defined, indicates that the ttyname_r routine ?C: is available to ttyname re-entrantly. ?C:. ?C:TTYNAME_R_PROTO: ?C: This symbol encodes the prototype of ttyname_r. ?C: It is zero if d_ttyname_r is undef, and one of the ?C: REENTRANT_PROTO_T_ABC macros of reentr.h if d_ttyname_r ?C: is defined. ?C:. ?H:#$d_ttyname_r HAS_TTYNAME_R /**/ ?H:#define TTYNAME_R_PROTO $ttyname_r_proto /**/ ?H:. ?T:try hdrs d_ttyname_r_proto : see if ttyname_r exists set ttyname_r d_ttyname_r eval $inlibc case "$d_ttyname_r" in "$define") hdrs="$i_systypes sys/types.h define stdio.h $i_unistd unistd.h" case "$d_ttyname_r_proto:$usethreads" in ":define") d_ttyname_r_proto=define set d_ttyname_r_proto ttyname_r $hdrs eval $hasproto ;; *) ;; esac case "$d_ttyname_r_proto" in define) case "$ttyname_r_proto" in ''|0) try='int ttyname_r(int, char*, size_t);' ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=I_IBW ;; esac case "$ttyname_r_proto" in ''|0) try='int ttyname_r(int, char*, int);' ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=I_IBI ;; esac case "$ttyname_r_proto" in ''|0) try='char* ttyname_r(int, char*, int);' ./protochk "$extern_C $try" $hdrs && ttyname_r_proto=B_IBI ;; esac case "$ttyname_r_proto" in ''|0) d_ttyname_r=undef ttyname_r_proto=0 echo "Disabling ttyname_r, cannot determine prototype." >&4 ;; * ) case "$ttyname_r_proto" in REENTRANT_PROTO*) ;; *) ttyname_r_proto="REENTRANT_PROTO_$ttyname_r_proto" ;; esac echo "Prototype: $try" ;; esac ;; *) case "$usethreads" in define) echo "ttyname_r has no prototype, not using it." >&4 ;; esac d_ttyname_r=undef ttyname_r_proto=0 ;; esac ;; *) ttyname_r_proto=0 ;; esac metaconfig-debian-perl-5.26.1/U/threads/i_machcthr.U000066400000000000000000000017031316016665300221760ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_machcthr: Inhdr usethreads ?MAKE: -pick add $@ %< ?S:i_machcthr: ?S: This variable conditionally defines the I_MACH_CTHREADS symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_MACH_CTHREADS: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_machcthr I_MACH_CTHREADS /**/ ?H:. : see if mach cthreads are available if test "X$usethreads" = "X$define"; then set mach/cthreads.h i_machcthr eval $inhdr else i_machcthr="$undef" fi metaconfig-debian-perl-5.26.1/U/threads/i_pthread.U000066400000000000000000000015331316016665300220350ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1998, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:i_pthread: Inhdr ?MAKE: -pick add $@ %< ?S:i_pthread: ?S: This variable conditionally defines the I_PTHREAD symbol, ?S: and indicates whether a C program should include . ?S:. ?C:I_PTHREAD: ?C: This symbol, if defined, indicates to the C program that it should ?C: include . ?C:. ?H:#$i_pthread I_PTHREAD /**/ ?H:. ?LINT:set i_pthread : see if POSIX threads are available set pthread.h i_pthread eval $inhdr metaconfig-debian-perl-5.26.1/U/threads/usethreads.U000066400000000000000000000146011316016665300222450ustar00rootroot00000000000000?RCS: $Id: usethreads.U,v $ ?RCS: ?RCS: Copyright (c) 1998-2000 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: $Log: usethreads.U,v $ ?RCS: ?MAKE:usethreads useithreads use5005threads d_oldpthreads usereentrant: \ Myread Oldconfig Setvar test cat patchlevel ?MAKE: -pick add $@ %< ?Y:TOP ?S:usethreads: ?S: This variable conditionally defines the USE_THREADS symbol, ?S: and indicates that Perl should be built to use threads. ?S:. ?S:useithreads: ?S: This variable conditionally defines the USE_ITHREADS symbol, ?S: and indicates that Perl should be built to use the interpreter-based ?S: threading implementation. ?S:. ?S:use5005threads: ?S: This variable conditionally defines the USE_5005THREADS symbol, ?S: and indicates that Perl should be built to use the 5.005-based ?S: threading implementation. Only valid up to 5.8.x. ?S:. ?X: I'm putting old_pthreads in this unit because it might eventually ?X: be part of an automatic determination to see if we can use threads ?X: at all. ?S:d_oldpthreads: ?S: This variable conditionally defines the OLD_PTHREADS_API symbol, ?S: and indicates that Perl should be built to use the old ?S: draft POSIX threads API. This is only potentially meaningful if ?S: usethreads is set. ?S:. ?S:usereentrant: ?S: This variable conditionally defines the USE_REENTRANT_API symbol, ?S: which indicates that the thread code may try to use the various ?S: _r versions of library functions. This is only potentially ?S: meaningful if usethreads is set and is very experimental, it is ?S: not even prompted for. ?S:. ?C:USE_ITHREADS: ?C: This symbol, if defined, indicates that Perl should be built to ?C: use the interpreter-based threading implementation. ?C:. ?C:USE_5005THREADS: ?C: This symbol, if defined, indicates that Perl should be built to ?C: use the 5.005-based threading implementation. ?C: Only valid up to 5.8.x. ?C:. ?C:USE_THREADS: ?C: This symbol, if defined, indicates that Perl should ?C: be built to use threads. At present, it is a synonym for ?C: USE_5005THREADS for perl older than 5.8 and USE_ITHREADS ?C: for 5.8.x and newer, but eventually the source ought to be ?C: changed to use this to mean _any_ threading implementation. ?C:. ?C:OLD_PTHREADS_API: ?C: This symbol, if defined, indicates that Perl should ?C: be built to use the old draft POSIX threads API. ?C:. ?C:USE_REENTRANT_API: ?C: This symbol, if defined, indicates that Perl should ?C: try to use the various _r versions of library functions. ?C: This is extremely experimental. ?C:. ?H:#$use5005threads USE_5005THREADS /**/ ?H:#$useithreads USE_ITHREADS /**/ ?H:?%<:#if defined(USE_5005THREADS) && !defined(USE_ITHREADS) ?H:?%<:#define USE_THREADS /* until src is revised*/ ?H:?%<:#endif ?H:#$d_oldpthreads OLD_PTHREADS_API /**/ ?H:#$usereentrant USE_REENTRANT_API /**/ ?H:. ?X: [hmb] Removed LINT for use5005threads, useithreads, and ?X: usereentrant, as LINT is only run on blead ?LINT:set usethreads d_oldpthreads ?INIT:: set usethreads on the Configure command line to enable threads. ?INIT:usereentrant='undef' ?F:!usethreads.cbu : Do we want threads support and if so, what type ?X: We should really have some explanatory text here, and some ?X: automatic setting of sensible defaults. case "$usethreads" in $define|true|[yY]*) dflt='y';; *) # Catch case where user specified ithreads or 5005threads but # forgot -Dusethreads (A.D. 4/2002) case "$useithreads$use5005threads" in *$define*) dflt='y';; *) dflt='n';; esac ;; esac cat <&4 <&4 <> temp.c; echo "printf(\"We have $type\");" >> temp.c; echo "#endif" >> temp.c; $cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null; if $contains $type temp.E >/dev/null 2>&1; then eval "$var=\$type"; else eval "$var=\$def"; fi; $rm -f temp.?;; *) eval "$var=\$varval";; esac' ?X: Originally, I eval'd $typedef and then checked the results against ?X: $type. Unfortunately, it then became complicated to check ?X: whether you are re-using an old config.sh value, and the logic got ?X: so convoluted it became easier to just copy the function above ?X: and alter it slightly. A.D. 3/1998 : define an is-a-typedef? function that prompts if the type is not available. typedef_ask='type=$1; var=$2; def=$3; shift; shift; shift; inclist=$@; case "$inclist" in "") inclist="sys/types.h";; esac; eval "varval=\$$var"; case "$varval" in "") $rm -f temp.c; for inc in $inclist; do echo "#include <$inc>" >>temp.c; done; ?X: Maybe it's a #define instead of a typedef. echo "#ifdef $type" >> temp.c; echo "printf(\"We have $type\");" >> temp.c; echo "#endif" >> temp.c; $cppstdin $cppflags $cppminus < temp.c >temp.E 2>/dev/null; echo " " ; echo "$rp" | $sed -e "s/What is/Looking for/" -e "s/?/./"; if $contains $type temp.E >/dev/null 2>&1; then echo "$type found." >&4; eval "$var=\$type"; else echo "$type NOT found." >&4; dflt="$def"; . ./myread ; eval "$var=\$ans"; fi; $rm -f temp.?;; *) eval "$var=\$varval";; esac' metaconfig-debian-perl-5.26.1/U/typedefs/d_time.U000066400000000000000000000043041316016665300215270ustar00rootroot00000000000000?RCS: $Id: d_time.U,v 3.0.1.2 1995/07/25 14:07:43 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_time.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 14:07:43 ram ?RCS: patch56: typo fix, sytem -> system ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:16:38 ram ?RCS: patch36: now uses new Typedef unit to compute type information (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:45 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: Maybe should be included? ?X:INC: i_systypes ?MAKE:d_time timetype: Csym Setvar Findhdr Myread Typedef ?MAKE: -pick add $@ %< ?S:d_time: ?S: This variable conditionally defines the HAS_TIME symbol, which indicates ?S: that the time() routine exists. The time() routine is normally ?S: provided on UNIX systems. ?S:. ?S:timetype: ?S: This variable holds the type returned by time(). It can be long, ?S: or time_t on BSD sites (in which case should be ?S: included). Anyway, the type Time_t should be used. ?S:. ?C:HAS_TIME (TIMER): ?C: This symbol, if defined, indicates that the time() routine exists. ?C:. ?C:Time_t (TIMETYPE): ?C: This symbol holds the type returned by time(). It can be long, ?C: or time_t on BSD sites (in which case should be ?C: included). ?C:. ?H:#$d_time HAS_TIME /**/ ?H:#define Time_t $timetype /* Time type */ ?H:. ?LINT:set d_time : see if time exists echo " " ?X: MPE/iX needs this protection of hint values. ?X: See d_sterror.U for more explanation. if test "X$d_time" = X -o X"$timetype" = X; then if set time val -f d_time; eval $csym; $val; then echo 'time() found.' >&4 val="$define" rp="What is the type returned by time() on this system?" set time_t timetype long stdio.h sys/types.h eval $typedef_ask else echo 'time() not found, hope that will do.' >&4 val="$undef" timetype='int'; fi set d_time eval $setvar fi metaconfig-debian-perl-5.26.1/U/typedefs/d_times.U000066400000000000000000000045331316016665300217160ustar00rootroot00000000000000?RCS: $Id: d_times.U,v 3.0.1.2 1995/07/25 14:07:50 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: d_times.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 14:07:50 ram ?RCS: patch56: typo fix, sytem -> system ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:14:00 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0 1993/08/18 12:07:46 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: What is the type returned by times() ? ?X: ?X: Force inclusion of ?X:INC: i_systypes ?MAKE:d_times clocktype: Csym Myread Typedef i_systimes ?MAKE: -pick add $@ %< ?S:d_times: ?S: This variable conditionally defines the HAS_TIMES symbol, which indicates ?S: that the times() routine exists. The times() routine is normally ?S: provided on UNIX systems. You may have to include . ?S:. ?S:clocktype: ?S: This variable holds the type returned by times(). It can be long, ?S: or clock_t on BSD sites (in which case should be ?S: included). ?S:. ?C:HAS_TIMES (TIMES): ?C: This symbol, if defined, indicates that the times() routine exists. ?C: Note that this became obsolete on some systems (SUNOS), which now ?C: use getrusage(). It may be necessary to include . ?C:. ?C:Clock_t (CLOCKTYPE): ?C: This symbol holds the type returned by times(). It can be long, ?C: or clock_t on BSD sites (in which case should be ?C: included). ?C:. ?H:#$d_times HAS_TIMES /**/ ?H:#define Clock_t $clocktype /* Clock time */ ?H:. ?T:val inc : see if times exists echo " " if set times val -f d_times; eval $csym; $val; then echo 'times() found.' >&4 d_times="$define" inc='' case "$i_systimes" in "$define") inc='sys/times.h';; esac rp="What is the type returned by times() on this system?" set clock_t clocktype long stdio.h sys/types.h $inc eval $typedef_ask else echo 'times() NOT found, hope that will do.' >&4 d_times="$undef" ?X: The following is needed for typedef (won't like an empty variable) clocktype='int' fi metaconfig-debian-perl-5.26.1/U/typedefs/devtype.U000066400000000000000000000027261316016665300217540ustar00rootroot00000000000000?RCS: $Id: devtype.U,v 3.0.1.1 1994/08/29 16:31:27 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: devtype.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:31:27 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:33 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:devtype: Myread Typedef ?MAKE: -pick add $@ %< ?S:devtype: ?S: This variable defines Dev_t to be something like dev_t, long, ?S: int, or whatever type is used to declare device numbers. ?S: This is usually the same as the type of the third argument ?S: to mknod(2). ?S:. ?C:Dev_t: ?C: This symbol holds the type used to declare device numbers. ?C: It can be int, long, dev_t, etc... This is usually the same ?C: as the type of the third argument to mknod(2). ?C: It may be necessary to include to get any ?C: typedef'ed information. ?C:. ?H:#define Dev_t $devtype /* type */ ?H:. ?LINT: set devtype : see what type is used for devices rp="What is the type used for device numbers on this system?" set dev_t devtype long stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/fpostype.U000066400000000000000000000025371316016665300221450ustar00rootroot00000000000000?RCS: $Id: fpostype.U,v 3.0.1.2 1994/08/29 16:20:52 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: fpostype.U,v $ ?RCS: Revision 3.0.1.2 1994/08/29 16:20:52 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 06:59:59 ram ?RCS: patch30: created ?RCS: ?MAKE:fpostype: Myread Typedef ?MAKE: -pick add $@ %< ?S:fpostype: ?S: This variable defines Fpos_t to be something like fpos_t, long, ?S: uint, or whatever type is used to declare file positions in libc. ?S:. ?C:Fpos_t: ?C: This symbol holds the type used to declare file positions in libc. ?C: It can be fpos_t, long, uint, etc... It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?H:#define Fpos_t $fpostype /* File position type */ ?H:. ?LINT:set fpostype : see what type file positions are declared as in the library rp="What is the type for file position used by fsetpos()?" set fpos_t fpostype long stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/gidf.U000066400000000000000000000024501316016665300211770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:gidformat: gidsize gidsign ivsize uvsize longsize intsize shortsize \ ivdformat uvuformat test echo ?MAKE: -pick add $@ %< ?S:gidformat: ?S: This variable contains the format string used for printing a Gid_t. ?S:. ?C:Gid_t_f: ?C: This symbol defines the format string used for printing a Gid_t. ?C:. ?H:#define Gid_t_f $gidformat /**/ ?H:. : Check format string for GID echo " " $echo "Checking the format string to be used for gids..." >&4 case "$gidsign" in -1) if $test X"$gidsize" = X"$ivsize"; then gidformat="$ivdformat" else if $test X"$gidsize" = X"$longsize"; then gidformat='"ld"' else if $test X"$gidsize" = X"$intsize"; then gidformat='"d"' else if $test X"$gidsize" = X"$shortsize"; then gidformat='"hd"' fi fi fi fi ;; *) if $test X"$gidsize" = X"$uvsize"; then gidformat="$uvuformat" else if $test X"$gidsize" = X"$longsize"; then gidformat='"lu"' else if $test X"$gidsize" = X"$intsize"; then gidformat='"u"' else if $test X"$gidsize" = X"$shortsize"; then gidformat='"hu"' fi fi fi fi ;; esac metaconfig-debian-perl-5.26.1/U/typedefs/gidsign.U000066400000000000000000000026141316016665300217140ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:gidsign: Myread Typedef gidtype Compile run ?MAKE: -pick add $@ %< ?S:gidsign: ?S: This variable contains the signedness of a gidtype. ?S: 1 for unsigned, -1 for signed. ?S:. ?C:Gid_t_sign: ?C: This symbol holds the signedness of a Gid_t. ?C: 1 for unsigned, -1 for signed. ?C:. ?H:#define Gid_t_sign $gidsign /* GID sign */ ?H:. ?T:yyy zzz ?F:!try : Check if GID is signed echo " " case "$gidtype" in *_t) zzz="$gidtype" ;; *) zzz="gid" ;; esac echo "Checking the sign of $zzz..." >&4 cat > try.c < #include int main() { $gidtype foo = -1; if (foo < 0) printf("-1\n"); else printf("1\n"); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in '') gidsign=1 echo "(I can't execute the test program--guessing unsigned.)" >&4 ;; *) gidsign=$yyy case "$gidsign" in 1) echo "Your $zzz is unsigned." ;; -1) echo "Your $zzz is signed." ;; esac ;; esac else gidsign=1 echo "(I can't compile the test program--guessing unsigned.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/gidsize.U000066400000000000000000000025041316016665300217240ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:gidsize: Myread Typedef gidtype Compile run i_stdlib ?MAKE: -pick add $@ %< ?S:gidsize: ?S: This variable contains the size of a gidtype in bytes. ?S:. ?C:Gid_t_size: ?C: This symbol holds the size of a Gid_t in bytes. ?C:. ?H:#define Gid_t_size $gidsize /* GID size */ ?H:. ?T:yyy zzz ?F:!try : Check the size of GID echo " " case "$gidtype" in *_t) zzz="$gidtype" ;; *) zzz="gid" ;; esac echo "Checking the size of $zzz..." >&4 cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof($gidtype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') gidsize=4 echo "(I can't execute the test program--guessing $gidsize.)" >&4 ;; *) gidsize=$yyy echo "Your $zzz is $gidsize bytes long." ;; esac else gidsize=4 echo "(I can't compile the test program--guessing $gidsize.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/gidtype.U000066400000000000000000000042671316016665300217430ustar00rootroot00000000000000?RCS: $Id: gidtype.U,v 3.0.1.3 1994/08/29 16:21:44 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: gidtype.U,v $ ?RCS: Revision 3.0.1.3 1994/08/29 16:21:44 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: patch32: removed useless usage of Setvar (for now) ?RCS: ?RCS: Revision 3.0.1.2 1994/05/13 15:21:07 ram ?RCS: patch27: added lint hint ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 15:01:51 ram ?RCS: patch23: protected gidtype setting via setvar (ADO) ?RCS: patch23: made Gid_t comment more explicit (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:08:11 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:gidtype: Myread Typedef Findhdr ?MAKE: -pick add $@ %< ?S:gidtype: ?S: This variable defines Gid_t to be something like gid_t, int, ?S: ushort, or whatever type is used to declare the return type ?S: of getgid(). Typically, it is the type of group ids in the kernel. ?S:. ?C:Gid_t (GIDTYPE): ?C: This symbol holds the return type of getgid() and the type of ?C: argument to setrgid() and related functions. Typically, ?C: it is the type of group ids in the kernel. It can be int, ushort, ?C: gid_t, etc... It may be necessary to include to get ?C: any typedef'ed information. ?C:. ?H:#define Gid_t $gidtype /* Type for getgid(), etc... */ ?H:. ?T:xxx : see what type gids are declared as in the kernel echo " " echo "Looking for the type for group ids returned by getgid()." set gid_t gidtype xxx stdio.h sys/types.h eval $typedef case "$gidtype" in xxx) xxx=`./findhdr sys/user.h` set `grep 'groups\[NGROUPS\];' "$xxx" 2>/dev/null` unsigned short case $1 in unsigned) dflt="$1 $2" ;; *) dflt="$1" ;; esac ;; *) dflt="$gidtype";; esac case "$gidtype" in gid_t) echo "gid_t found." ;; *) rp="What is the type for group ids returned by getgid()?" . ./myread gidtype="$ans" ;; esac metaconfig-debian-perl-5.26.1/U/typedefs/inotype.U000066400000000000000000000020071316016665300217530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:inotype: Myread Typedef ?MAKE: -pick add $@ %< ?S:inotype: ?S: This variable defines Ino_t to be something like ino_t, long, ?S: int, or whatever type is used to declare inode numbers. ?S:. ?C:Ino_t: ?C: This symbol holds the type used to declare inode numbers. ?C: It can be int, long, ino_t, etc... ?C: It may be necessary to include to get any ?C: typedef'ed information. ?C:. ?H:#define Ino_t $inotype /* type */ ?H:. ?LINT: set inotype : see what type is used for inodes rp="What is the type used for inode numbers on this system?" set ino_t inotype long stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/lseektype.U000066400000000000000000000047021316016665300222750ustar00rootroot00000000000000?RCS: $Id: lseektype.U,v 3.0.1.1 1994/08/29 16:30:10 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: lseektype.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:30:10 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:08 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:lseektype lseeksize: Myread Typedef cat Compile rm_try longsize run ?MAKE: -pick add $@ %< ?S:lseektype: ?S: This variable defines lseektype to be something like off_t, long, ?S: or whatever type is used to declare lseek offset's type in the ?S: kernel (which also appears to be lseek's return type). ?S:. ?S:lseeksize: ?S: This variable defines lseektype to be something like off_t, long, ?S: or whatever type is used to declare lseek offset's type in the ?S: kernel (which also appears to be lseek's return type). ?S:. ?C:Off_t (LSEEKTYPE): ?C: This symbol holds the type used to declare offsets in the kernel. ?C: It can be int, long, off_t, etc... It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?C:LSEEKSIZE: ?C: This symbol holds the number of bytes used by the Off_t. ?C:. ?C:Off_t_size: ?C: This symbol holds the number of bytes used by the Off_t. ?C:. ?H:#define Off_t $lseektype /* type */ ?H:#define LSEEKSIZE $lseeksize /* size */ ?H:#define Off_t_size $lseeksize /* size */ ?H:. ?F:!try ?LINT:set lseektype : see what type lseek is declared as in the kernel rp="What is the type used for lseek's offset on this system?" set off_t lseektype long stdio.h sys/types.h eval $typedef_ask echo " " echo "Checking to see how big your file offsets are..." >&4 $cat >try.c < #include int main() { printf("%d\n", (int)sizeof($lseektype)); return(0); } EOCP set try if eval $compile_ok; then lseeksize=`$run ./try` echo "Your file offsets are $lseeksize bytes long." else dflt=$longsize echo " " echo "(I can't seem to compile the test program. Guessing...)" rp="What is the size of your file offsets (in bytes)?" . ./myread lseeksize="$ans" fi $rm_try metaconfig-debian-perl-5.26.1/U/typedefs/modetype.U000066400000000000000000000025571316016665300221240ustar00rootroot00000000000000?RCS: $Id: modetype.U,v 3.0.1.1 1994/10/29 16:25:07 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: modetype.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:25:07 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:modetype: Myread Typedef ?MAKE: -pick add $@ %< ?S:modetype: ?S: This variable defines modetype to be something like mode_t, ?S: int, unsigned short, or whatever type is used to declare file ?S: modes for system calls. ?S:. ?C:Mode_t: ?C: This symbol holds the type used to declare file modes ?C: for systems calls. It is usually mode_t, but may be ?C: int or unsigned short. It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?H:#define Mode_t $modetype /* file mode parameter for system calls */ ?H:. ?LINT:set modetype : see what type is used for mode_t rp="What is the type used for file modes for system calls (e.g. fchmod())?" set mode_t modetype int stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/pidsign.U000066400000000000000000000026241316016665300217260ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:pidsign: Myread Typedef pidtype Compile run ?MAKE: -pick add $@ %< ?S:pidsign: ?S: This variable contains the signedness of a pidtype. ?S: 1 for unsigned, -1 for signed. ?S:. ?C:Pid_t_sign: ?C: This symbol holds the signedness of a Pid_t. ?C: 1 for unsigned, -1 for signed. ?C:. ?H:#define Pid_t_sign $pidsign /* PID sign */ ?H:. ?T:yyy zzz ?F:!try : Check if PID is signed echo " " case "$pidtype" in *_t) zzz="$pidtype" ;; *) zzz="pid" ;; esac echo "Checking the sign of $zzz..." >&4 cat > try.c < #include int main() { $pidtype foo = -1; if (foo < 0) printf("-1\n"); else printf("1\n"); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in '') pidsign=1 echo "(I can't execute the test program--guessing unsigned.)" >&4 ;; *) pidsign=$yyy case "$pidsign" in 1) echo "Your $pidtype is unsigned." ;; -1) echo "Your $pidtype is signed." ;; esac ;; esac else pidsign=1 echo "(I can't compile the test program--guessing unsigned.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/pidsize.U000066400000000000000000000023671316016665300217440ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:pidsize: Myread Typedef pidtype Compile run ?MAKE: -pick add $@ %< ?S:pidsize: ?S: This variable contains the size of a pidtype in bytes. ?S:. ?C:Pid_t_size: ?C: This symbol holds the size of a Pid_t in bytes. ?C:. ?H:#define Pid_t_size $pidsize /* PID size */ ?H:. ?T:yyy zzz ?F:!try : Check size of PID echo " " case "$pidtype" in *_t) zzz="$pidtype" ;; *) zzz="pid" ;; esac echo "Checking the size of $zzz..." >&4 cat > try.c < #include int main() { printf("%d\n", (int)sizeof($pidtype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') pidsize=4 echo "(I can't execute the test program--guessing $pidsize.)" >&4 ;; *) pidsize=$yyy echo "Your $zzz size is $pidsize bytes." ;; esac else pidsize=4 echo "(I can't compile the test program--guessing $pidsize.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/pidtype.U000066400000000000000000000025331316016665300217460ustar00rootroot00000000000000?RCS: $Id: pidtype.U,v 3.0.1.1 1994/08/29 16:31:27 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: pidtype.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:31:27 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:33 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:pidtype: Myread Typedef ?MAKE: -pick add $@ %< ?S:pidtype: ?S: This variable defines PIDTYPE to be something like pid_t, int, ?S: ushort, or whatever type is used to declare process ids in the kernel. ?S:. ?C:Pid_t (PIDTYPE): ?C: This symbol holds the type used to declare process ids in the kernel. ?C: It can be int, uint, pid_t, etc... It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?H:#define Pid_t $pidtype /* PID type */ ?H:. ?LINT: set pidtype : see what type pids are declared as in the kernel rp="What is the type of process ids on this system?" set pid_t pidtype int stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/sizesize.U000066400000000000000000000025141316016665300221340ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:sizesize: Myread Typedef sizetype Compile run i_stdlib ?MAKE: -pick add $@ %< ?S:sizesize: ?S: This variable contains the size of a sizetype in bytes. ?S:. ?C:Size_t_size: ?C: This symbol holds the size of a Size_t in bytes. ?C:. ?H:#define Size_t_size $sizesize /**/ ?H:. ?T:yyy zzz ?F:!try : Check size of size echo " " case "$sizetype" in *_t) zzz="$sizetype" ;; *) zzz="filesize" ;; esac echo "Checking the size of $zzz..." >&4 cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof($sizetype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') sizesize=4 echo "(I can't execute the test program--guessing $sizesize.)" >&4 ;; *) sizesize=$yyy echo "Your $zzz size is $sizesize bytes." ;; esac else sizesize=4 echo "(I can't compile the test program--guessing $sizesize.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/sizetype.U000066400000000000000000000026131316016665300221430ustar00rootroot00000000000000?RCS: $Id: sizetype.U,v 3.0.1.1 1994/08/29 16:32:10 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: sizetype.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:32:10 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:sizetype: Myread Typedef ?MAKE: -pick add $@ %< ?S:sizetype: ?S: This variable defines sizetype to be something like size_t, ?S: unsigned long, or whatever type is used to declare length ?S: parameters for string functions. ?S:. ?C:Size_t: ?C: This symbol holds the type used to declare length parameters ?C: for string functions. It is usually size_t, but may be ?C: unsigned long, int, etc. It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?H:#define Size_t $sizetype /* length parameter for string functions */ ?H:. ?LINT: set sizetype : see what type is used for size_t rp="What is the type used for the length parameter for string functions?" set size_t sizetype 'unsigned int' stdio.h sys/types.h eval $typedef_ask metaconfig-debian-perl-5.26.1/U/typedefs/ssizesize.U000066400000000000000000000024441316016665300223210ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:ssizesize: Myread Typedef ssizetype Compile run ?MAKE: -pick add $@ %< run ?S:ssizesize: ?S: This variable contains the size of a ssizetype in bytes. ?S:. ?C:Ssize_t_size: ?C: This symbol holds the size of a Ssize_t in bytes. ?C:. ?H:#define Ssize_t_size $ssizesize /**/ ?H:. ?T:yyy zzz ?F:!try : Check size of Ssize_t echo " " case "$ssizetype" in *_t) zzz="$ssizetype" ;; *) zzz="signed filesize" ;; esac echo "Checking the size of $zzz..." >&4 cat > try.c < #include int main() { printf("%d\n", (int)sizeof($ssizetype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') ssizesize=4 echo "(I can't execute the test program--guessing $ssizesize.)" >&4 ;; *) ssizesize=$yyy echo "Your $zzz size is $ssizesize bytes." ;; esac else ssizesize=4 echo "(I can't compile the test program--guessing $ssizesize.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/uidf.U000066400000000000000000000024471316016665300212230ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1999 Jarkko Hietaniemi ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?MAKE:uidformat: uidsize uidsign ivsize uvsize longsize intsize shortsize \ ivdformat uvuformat test echo ?MAKE: -pick add $@ %< ?S:uidformat: ?S: This variable contains the format string used for printing a Uid_t. ?S:. ?C:Uid_t_f: ?C: This symbol defines the format string used for printing a Uid_t. ?C:. ?H:#define Uid_t_f $uidformat /**/ ?H:. : Check format string for UID echo " " $echo "Checking the format string to be used for uids..." >&4 case "$uidsign" in -1) if $test X"$uidsize" = X"$ivsize"; then uidformat="$ivdformat" else if $test X"$uidsize" = X"$longsize"; then uidformat='"ld"' else if $test X"$uidsize" = X"$intsize"; then uidformat='"d"' else if $test X"$uidsize" = X"$shortsize"; then uidformat='"hd"' fi fi fi fi ;; *) if $test X"$uidsize" = X"$uvsize"; then uidformat="$uvuformat" else if $test X"$uidsize" = X"$longsize"; then uidformat='"lu"' else if $test X"$uidsize" = X"$intsize"; then uidformat='"u"' else if $test X"$uidsize" = X"$shortsize"; then uidformat='"hu"' fi fi fi fi ;; esac metaconfig-debian-perl-5.26.1/U/typedefs/uidsign.U000066400000000000000000000026141316016665300217320ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:uidsign: Myread Typedef uidtype Compile run ?MAKE: -pick add $@ %< ?S:uidsign: ?S: This variable contains the signedness of a uidtype. ?S: 1 for unsigned, -1 for signed. ?S:. ?C:Uid_t_sign: ?C: This symbol holds the signedness of a Uid_t. ?C: 1 for unsigned, -1 for signed. ?C:. ?H:#define Uid_t_sign $uidsign /* UID sign */ ?H:. ?T:yyy zzz ?F:!try : Check if UID is signed echo " " case "$uidtype" in *_t) zzz="$uidtype" ;; *) zzz="uid" ;; esac echo "Checking the sign of $zzz..." >&4 cat > try.c < #include int main() { $uidtype foo = -1; if (foo < 0) printf("-1\n"); else printf("1\n"); } EOCP set try if eval $compile; then yyy=`$run ./try` case "$yyy" in '') uidsign=1 echo "(I can't execute the test program--guessing unsigned.)" >&4 ;; *) uidsign=$yyy case "$uidsign" in 1) echo "Your $zzz is unsigned." ;; -1) echo "Your $zzz is signed." ;; esac ;; esac else uidsign=1 echo "(I can't compile the test program--guessing unsigned.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/uidsize.U000066400000000000000000000024771316016665300217530ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1999, Jarkko Hietaniemi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?MAKE:uidsize: Myread Typedef uidtype Compile run i_stdlib ?MAKE: -pick add $@ %< ?S:uidsize: ?S: This variable contains the size of a uidtype in bytes. ?S:. ?C:Uid_t_size: ?C: This symbol holds the size of a Uid_t in bytes. ?C:. ?H:#define Uid_t_size $uidsize /* UID size */ ?H:. ?T:yyy zzz ?F:!try : Check size of UID echo " " case "$uidtype" in *_t) zzz="$uidtype" ;; *) zzz="uid" ;; esac echo "Checking the size of $zzz..." >&4 cat > try.c < #include #$i_stdlib I_STDLIB #ifdef I_STDLIB #include #endif int main() { printf("%d\n", (int)sizeof($uidtype)); exit(0); } EOCP set try if eval $compile_ok; then yyy=`$run ./try` case "$yyy" in '') uidsize=4 echo "(I can't execute the test program--guessing $uidsize.)" >&4 ;; *) uidsize=$yyy echo "Your $zzz is $uidsize bytes long." ;; esac else uidsize=4 echo "(I can't compile the test program--guessing $uidsize.)" >&4 fi metaconfig-debian-perl-5.26.1/U/typedefs/uidtype.U000066400000000000000000000037401316016665300217540ustar00rootroot00000000000000?RCS: $Id: uidtype.U,v 3.0.1.3 1994/08/29 16:33:25 ram Exp $ ?RCS: ?RCS: Copyright (c) 1991-1993, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 3.0. ?RCS: ?RCS: $Log: uidtype.U,v $ ?RCS: Revision 3.0.1.3 1994/08/29 16:33:25 ram ?RCS: patch32: now uses new Typedef unit to compute type information ?RCS: ?RCS: Revision 3.0.1.2 1994/06/20 07:09:36 ram ?RCS: patch30: comment for uidtype referred to the obsoleted symbol ?RCS: ?RCS: Revision 3.0.1.1 1994/05/13 15:28:27 ram ?RCS: patch27: made conformant to its gidtype.U companion ?RCS: patch27: question now explicitly mentions getuid() ?RCS: ?RCS: Revision 3.0 1993/08/18 12:09:56 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:uidtype: Myread Typedef Findhdr ?MAKE: -pick add $@ %< ?S:uidtype: ?S: This variable defines Uid_t to be something like uid_t, int, ?S: ushort, or whatever type is used to declare user ids in the kernel. ?S:. ?C:Uid_t (UIDTYPE): ?C: This symbol holds the type used to declare user ids in the kernel. ?C: It can be int, ushort, uid_t, etc... It may be necessary to include ?C: to get any typedef'ed information. ?C:. ?H:#define Uid_t $uidtype /* UID type */ ?H:. ?T:xxx : see what type uids are declared as in the kernel echo " " echo "Looking for the type for user ids returned by getuid()." set uid_t uidtype xxx stdio.h sys/types.h eval $typedef case "$uidtype" in xxx) xxx=`./findhdr sys/user.h` set `grep '_ruid;' "$xxx" 2>/dev/null` unsigned short case $1 in unsigned) dflt="$1 $2" ;; *) dflt="$1" ;; esac ;; *) dflt="$uidtype";; esac case "$uidtype" in uid_t) echo "uid_t found." ;; *) rp="What is the type for user ids returned by getuid()?" . ./myread uidtype="$ans" ;; esac metaconfig-debian-perl-5.26.1/dist/000077500000000000000000000000001316016665300170535ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/dist/Glossary000066400000000000000000011050211316016665300206010ustar00rootroot00000000000000[This Glossary is automatically generated from the Unit files. Do not edit this file or your changes will be lost. Edit the appropriate Unit instead.] This file contains a listing of all the C preprocessor symbols and shell variables whose value can be determined by a Configure script. For the most part, any symbol in UPPERCASE is a C preprocessor symbol, and will be defined in config.h. Symbols in lowercase are shell variables, and are defined in config.sh. If you write your shell scripts and C programs in terms of these symbols, metaconfig can automatically build you a Configure script that will determine the value of those symbols. See the README file for a description of how to use metaconfig. In the following listing, the Unit: line indicates the name of the unit where this symbol is defined, and the Wants: line indicates what other symbols must be determined in order to figure out the value of this one. If there is an "(Also defines ...)" entry, it indicates what other symbols are defined by the Unit other than the one corresponding to the unit name. Variable of the form d_* either have the value "define" or "/*define", and control whether some C preprocessor symbol gets defined or not. ABORTSIG: Unit: abortsig Wants: Myread Oldconfig Guess cat ccflags rm Optional: cc This symbol holds the signal number (symbol) used by the abort() call. To actually define the signal symbol, should be included. ACTIVE: Unit: active (Also defines activeexp) Wants: newslib Oldconfig Getfile The name of the active file for the news system. This file contains the list of active newsgroups. The name may have ~ on the front. ACTIVE_EXP: Unit: active (Also defines activeexp) Wants: newslib Oldconfig Getfile This is the same as ACTIVE, but is filename expanded at configuration time, for programs that do not want to deal with it themselves. ALIGNBYTES: Obsoleted by MEM_ALIGNBYTES. ARCHLIB: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This variable, if defined, holds the name of the directory in which the user wants to put architecture-dependent public library files for $package. It is most often a local directory such as /usr/local/lib. Programs using this variable must be prepared to deal with filename expansion. If ARCHLIB is the same as PRIVLIB, it is not defined, since presumably the program already searches PRIVLIB. ARCHLIB_EXP: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This symbol contains the ~name expanded version of ARCHLIB, to be used in programs that are not prepared to deal with ~ expansion at run-time. ARCHNAME: Unit: archname (Also defines myarchname) Wants: sed Loc Myread Oldconfig osname test rm This symbol holds a string representing the architecture name. It may be used to construct an architecture-dependant pathname where library files may be held under a private library, for instance. BASICSHELL: Unit: basicshell Wants: Getfile Oldconfig bash csh ksh sh This symbol contains the full name of the basic script shell on this system. Usual values are /bin/sh, /bin/ksh, /bin/csh. BERKNAMES: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This symbol, if defined, indicates that full names are stored in the /etc/passwd file in Berkeley format (name first thing, everything up to first comma, with & replaced by capitalized login id, yuck). BIN: Unit: bin (Also defines binexp installbin) Wants: Prefixit Getfile Oldconfig afs cat test This symbol holds the path of the bin directory where the package will be installed. Program must be prepared to deal with ~name substitution. BIN_EXP: Unit: bin (Also defines binexp installbin) Wants: Prefixit Getfile Oldconfig afs cat test This symbol is the filename expanded version of the BIN symbol, for programs that do not want to deal with that at run-time. BITS_PER_BYTE: Unit: bitpbyte Wants: cat rm Myread Optional: cc ccflags This symbol contains the number of bits in a byte, so that the C preprocessor can make decisions based on it. BSDJMP: Obsoleted by USE_BSDJMP. BSDPGRP: Obsoleted by USE_BSD_SETPGRP. BSD_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under a BSD system. BYTEORDER: Unit: byteorder Wants: cat Myread Oldconfig Loc rm Optional: cc ccflags This symbol hold the hexadecimal constant defined in byteorder, i.e. 0x1234 or 0x4321, etc... CAN_KEEPALIVE: Unit: sockopt (Also defines d_keepalive) Wants: cat rm contains socketlib sockethdr d_oldsock libs Oldconfig Setvar Findhdr Optional: cc ccflags This symbol if defined indicates to the C program that the SO_KEEPALIVE option of setsockopt() will work as advertised in the manual. CAN_PROTOTYPE: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags If defined, this macro indicates that the C compiler can handle function prototypes. CAN_VAPROTO: Unit: vaproto Wants: prototype i_stdarg Setvar This variable is defined on systems supporting prototype declaration of functions with a variable number of arguments. CASTFLAGS: Unit: d_castneg (Also defines castflags) Wants: cat rm Setvar signal_t Optional: cc ccflags This symbol contains flags that say what difficulties the compiler has casting odd floating values to unsigned long: 0 = ok 1 = couldn't cast < 0 2 = couldn't cast >= 0x80000000 4 = couldn't cast in argument expression list CASTI32: Unit: d_casti32 Wants: cat rm intsize Setvar test signal_t Optional: cc ccflags This symbol is defined if the C compiler can cast negative or large floating point numbers to 32-bit ints. CASTNEGFLOAT: Unit: d_castneg (Also defines castflags) Wants: cat rm Setvar signal_t Optional: cc ccflags This symbol is defined if the C compiler can cast negative numbers to unsigned longs, ints and shorts. CAT2: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 2 tokens together. CAT3: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 3 tokens together. CAT4: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 4 tokens together. CAT5: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 5 tokens together. CBRT: Obsoleted by HAS_CBRT. CHARSIZE: Unit: charsize Wants: cat rm Myread Optional: cc ccflags This symbol contains the size of a char, so that the C preprocessor can make decisions based on it. CHARSPRINTF: Unit: d_charsprf Wants: cat rm Setvar Optional: cc This symbol is defined if this system declares "char *sprintf()" in stdio.h. The trend seems to be to declare it as "int sprintf()". It is up to the package author to declare sprintf correctly based on the symbol. CHARVSPRINTF: Obsoleted by USE_CHAR_VSPRINTF. CHAR_ORDER_INT: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the byte ordering of characters in an int. It's a string value like "c0c1c2c3" on a Big-Endian machine. CHAR_ORDER_LONG: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the byte ordering of characters in a long. It's a string value like "c0c1c2c3c4c5c6c7" on a 64 bits Big-Endian machine. CHAR_ORDER_SHORT: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the byte ordering of characters in a short. It's a string value like "c0c1" on a Big-Endian machine. CHSIZE: Obsoleted by HAS_CHSIZE. CITYDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the city. CLOCKTYPE: Obsoleted by Clock_t. CNTRYDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the country. CONTDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the continent. CPPCANSTDIN: Obsoleted by CPP_CAN_STDIN. CPPFILECOM: Obsoleted by CPP_FILE_COM. CPPIGNHDRS: Obsoleted by CPP_IGN_HDRS. CPPLAST: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This symbol is intended to be used along with CPPRUN in the same manner symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "". CPPMINUS: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This symbol contains the second part of the string which will invoke the C preprocessor on the standard input and produce to standard output. This symbol will have the value "-" if CPPSTDIN needs a minus to specify standard input, otherwise the value is "". CPPRUN: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This symbol contains the string which will invoke a C preprocessor on the standard input and produce to standard output. It needs to end with CPPLAST, after all other preprocessor flags have been specified. The main difference with CPPSTDIN is that this program will never be a pointer to a shell wrapper, i.e. it will be empty if no preprocessor is available directly to the user. Note that it may well be different from the preprocessor used to compile the C program. CPPSTDIN: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This symbol contains the first part of the string which will invoke the C preprocessor on the standard input and produce to standard output. Typical value of "cc -E" or "/lib/cpp", but it can also call a wrapper. See CPPRUN. CPPSTDINFLAGS: Obsoleted by CPP_STDIN_FLAGS. CPP_CAN_STDIN: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This symbol is defined if CPP_FILE_COM can read standard input directly. CPP_FILE_COM: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This symbol contains the first part of the string which will invoke the C preprocessor a file and produce to standard output, preserving comments. Typical value of "cc -E -C" or "/lib/cpp -C". CPP_IGN_HDRS: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This symbol is defined if CPP_FILE_COM ignores *.h files. CPP_STDIN_FLAGS: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This variable contains any flags necessary to get CPP_FILE_COM to read from the standard input. CROSS_TARGET_ARCH: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This symbol, if defined, indicates the target architecture the package has been cross-compiled to. Undefined if not a cross-compile. CRYPT: Obsoleted by HAS_CRYPT. CSH: Unit: d_csh (Also defines full_csh) Wants: csh Setvar This symbol, if defined, contains the full pathname of csh. CTERMID: Obsoleted by HAS_CTERMID. Caddr_t: Unit: sbrktype Wants: Myread Oldconfig Loc contains Findhdr This symbol holds the type of a core address. It is inteded to be used to safely declare the return type of system calls like sbrk(). It might be necessary to include as well. Clock_t: Unit: d_times (Also defines clocktype) Wants: Csym Myread Typedef i_systimes This symbol holds the type returned by times(). It can be long, or clock_t on BSD sites (in which case should be included). DB_Hash_t: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This symbol contains the type of the prefix structure element in the header file. In older versions of DB, it was int, while in newer ones it is size_t. DB_Prefix_t: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This symbol contains the type of the prefix structure element in the header file. In older versions of DB, it was int, while in newer ones it is u_int32_t. DEFEDITOR: Unit: defeditor Wants: Getfile Oldconfig Loc vi This symbol contains the full pathname of the default editor. DIRNAMLEN: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This symbol, if defined, indicates to the C program that the length of directory entry names is provided by a d_namlen field. Otherwise you need to do strlen() on the d_name field. DOSUID: Unit: d_dosuid (Also defines d_suidsafe) Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package hint This symbol, if defined, indicates that the C program should check the script that it is executing for setuid/setgid bits, and attempt to emulate setuid/setgid on systems that have disabled setuid #! scripts because the kernel can't do it securely. It is up to the package designer to make sure that this emulation is done securely. Among other things, it should do an fstat on the script it just opened to make sure it really is a setuid/setgid script, it should make sure the arguments passed correspond exactly to the argument on the #! line, and it should not trust any subprocesses to which it must pass the filename rather than the file descriptor of the script to be executed. DOS_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under DOS with DJGPP. DOTS: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to specify the ... in function prototypes which have arbitrary additional arguments. DOUBLESIZE: Unit: doublesize Wants: cat rm Myread Optional: cc ccflags This symbol contains the size of a double, so that the C preprocessor can make decisions based on it. DUP2: Obsoleted by HAS_DUP2. Direntry_t: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This symbol is set to 'struct direct' or 'struct dirent' depending on whether dirent is available or not. You should use this pseudo type to portably declare your directory entries. EBCDIC: Unit: ebcdic Wants: Compile Setvar cat rm run This symbol, if defined, indicates that this system uses EBCDIC encoding. EMULATE_NDIR: Unit: d_usendir (Also defines i_ndir ndirlib) Wants: test Setvar Findhdr d_readdir _a This symbol, if defined, indicates that the program should compile the ndir.c code provided with the package. EOFPIPE: Unit: d_eofpipe Wants: cat rm Oldconfig Guess echo n c Optional: cc ccflags libs This symbol, if defined, indicates that EOF condition will be detected by the reader of the pipe when it is closed by the writing process. That is, a select() call on that file descriptor will not block when only an EOF remains (typical behaviour for BSD systems). EOF_NONBLOCK: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This symbol, if defined, indicates to the C program that a read() on a non-blocking file descriptor will return 0 on EOF, and not the value held in RD_NODATA (-1 usually, in that case!). EUNICE: Obsoleted by EUNICE_SYSTEM. EUNICE_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is being compiled under the EUNICE package under VMS. The program will need to handle things like files that don't go away the first time you unlink them, due to version numbering. It will also need to compensate for lack of a respectable link() command. FCHMOD: Obsoleted by HAS_FCHMOD. FCHOWN: Obsoleted by HAS_FCHOWN. FCNTL: Obsoleted by I_FCNTL. FILE_base: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This macro is used to access the _base field (or equivalent) of the FILE structure pointed to by its argument. This macro will always be defined if USE_STDIO_BASE is defined. FILE_bufsiz: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This macro is used to determine the number of bytes in the I/O buffer pointed to by _base field (or equivalent) of the FILE structure pointed to its argument. This macro will always be defined if USE_STDIO_BASE is defined. FILE_cnt: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This macro is used to access the _cnt field (or equivalent) of the FILE structure pointed to by its argument. This macro will always be defined if USE_STDIO_PTR is defined. FILE_filbuf: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This macro is used to access the internal stdio _filbuf function (or equivalent), if STDIO_CNT_LVALUE and STDIO_PTR_LVALUE are defined. It is typically either _filbuf or __filbuf. This macro will only be defined if both STDIO_CNT_LVALUE and STDIO_PTR_LVALUE are defined. FILE_ptr: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This macro is used to access the _ptr field (or equivalent) of the FILE structure pointed to by its argument. This macro will always be defined if USE_STDIO_PTR is defined. FLEXFILENAMES: Unit: d_flexfnam Wants: cat rm test Setvar This symbol, if defined, indicates that the system supports filenames longer than 14 characters. FLOATSIZE: Unit: floatsize Wants: cat rm Myread Optional: cc ccflags This symbol contains the size of a float, so that the C preprocessor can make decisions based on it. FLOCK: Obsoleted by HAS_FLOCK. FPU: Unit: fpu Wants: test cat cc Myread String containing the flags for the local floating point unit. FPUNIT: Obsoleted by FPU. FTIMER: Obsoleted by HAS_FTIME. Fpos_t: Unit: fpostype Wants: Myread Typedef This symbol holds the type used to declare file positions in libc. It can be fpos_t, long, uint, etc... It may be necessary to include to get any typedef'ed information. Free_t: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This variable contains the return type of free(). It is usually void, but occasionally int. GETGROUPS: Obsoleted by HAS_GETGROUPS. GETHOSTBYNAME: Obsoleted by HAS_GETHOSTBYNAME. GETHOSTENT: Obsoleted by HAS_GETHOSTENT. GETHOSTID: Obsoleted by HAS_GETHOSTID. GETHOSTNAME: Obsoleted by HAS_GETHOSTNAME. GETOPT: Obsoleted by HAS_GETOPT. GETPAGESIZE: Obsoleted by HAS_GETPAGESIZE. GETPGRP: Obsoleted by HAS_GETPGRP. GETPGRP2: Obsoleted by HAS_GETPGRP2. GETPRIORITY: Obsoleted by HAS_GETPRIORITY. GETPWENT: Obsoleted by HAS_GETPWENT. GETRUSAGE: Obsoleted by HAS_GETRUSAGE. GETTIMEOFDAY: Obsoleted by HAS_GETTIMEOFDAY. GETWD: Obsoleted by HAS_GETWD. GIDTYPE: Obsoleted by Gid_t. GNUC_ATTRIBUTE_CHECK: Obsoleted by HASATTRIBUTE. GROUPSTYPE: Obsoleted by Groups_t. Gconvert: Unit: d_gconvert (Also defines d_Gconvert) Wants: cat cc ccflags ldflags libs Inlibc rm _o This preprocessor macro is defined to convert a floating point number to a string without a trailing decimal point. This emulates the behavior of sprintf("%g"), but is sometimes much more efficient. If gconvert() is not available, but gcvt() drops the trailing decimal point, then gcvt() is used. If all else fails, a macro using sprintf("%g") is used. Arguments for the Gconvert macro are: value, number of digits, whether trailing zeros should be retained, and the output buffer. Possible values are: d_Gconvert='gconvert((x),(n),(t),(b))' d_Gconvert='gcvt((x),(n),(b))' d_Gconvert='sprintf((b),"%.*g",(n),(x))' The last two assume trailing zeros should not be kept. Gid_t: Unit: gidtype Wants: Myread Typedef Findhdr This symbol holds the return type of getgid() and the type of argument to setrgid() and related functions. Typically, it is the type of group ids in the kernel. It can be int, ushort, uid_t, etc... It may be necessary to include to get any typedef'ed information. Groups_t: Unit: groupstype Wants: gidtype d_getgrps Myread Oldconfig Findhdr cat d_setgrps This symbol holds the type used for the second argument to getgroups() and setgroups(). Usually, this is the same as gidtype (gid_t) , but sometimes it isn't. It can be int, ushort, gid_t, etc... It may be necessary to include to get any typedef'ed information. This is only required if you have getgroups() or setgroups().. HASATTRIBUTE: Unit: d_attribut Wants: Myread Oldconfig cat cc ccflags rm Setvar contains This symbol indicates the C compiler can check for function attributes, such as printf formats. This is normally only supported by GNU cc. HASCONST: Unit: d_const Wants: cat rm cc ccflags Setvar This symbol, if defined, indicates that this C compiler knows about the const type. There is no need to actually test for that symbol within your programs. The mere use of the "const" keyword will trigger the necessary tests. HASVOLATILE: Unit: d_volatile Wants: cat rm Setvar Optional: cc ccflags This symbol, if defined, indicates that this C compiler knows about the volatile declaration. HAS_ACCESS: Unit: d_access Wants: test cat h_fcntl h_sysfile rm Inlibc Findhdr Optional: cc cppflags This manifest constant lets the C program know that the access() system call is available to check for accessibility using real UID/GID. (always present on UNIX.) HAS_ALARM: Unit: d_alarm Wants: Inlibc This symbol, if defined, indicates that the alarm routine is available. HAS_BCMP: Unit: d_bcmp Wants: Inlibc This symbol is defined if the bcmp() routine is available to compare blocks of memory. HAS_BCOPY: Unit: d_bcopy Wants: Inlibc This symbol is defined if the bcopy() routine is available to copy blocks of memory. HAS_BZERO: Unit: d_bzero Wants: Inlibc This symbol is defined if the bzero() routine is available to set a memory block to 0. HAS_CBRT: Unit: d_cbrt Wants: Inlibc This symbol, if defined, indicates that the cbrt() (cube root) function is available. HAS_CHOWN: Unit: d_chown Wants: Inlibc This symbol, if defined, indicates that the chown routine is available. HAS_CHROOT: Unit: d_chroot Wants: Inlibc This symbol, if defined, indicates that the chroot routine is available. HAS_CHSIZE: Unit: d_chsize Wants: Inlibc This symbol, if defined, indicates that the chsize routine is available to truncate files. You might need a -lx to get this routine. HAS_CLOSEDIR: Unit: d_closedir (Also defines d_void_closedir) Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs Setvar rm This symbol, if defined, indicates that the closedir() routine is available. HAS_CRYPT: Unit: d_crypt (Also defines cryptlib) Wants: Loc test xlibpth libpth Csym Setvar _a Inlibc This symbol, if defined, indicates that the crypt routine is available to encrypt passwords and the like. HAS_CSH: Unit: d_csh (Also defines full_csh) Wants: csh Setvar This symbol, if defined, indicates that the C-shell exists. HAS_CTERMID: Unit: d_ctermid Wants: Inlibc This symbol, if defined, indicates that the ctermid routine is available to generate filename for terminal. HAS_CURSES_KEYPAD: Unit: d_ckeypad Wants: cat cc termlib Setvar This symbol indicates the availability of the keypad() function of the curses library. HAS_CUSERID: Unit: d_cuserid Wants: Inlibc This symbol, if defined, indicates that the cuserid routine is available to get character login names. HAS_DBL_DIG: Unit: d_dbl_dig Wants: Myread contains cat rm Setvar i_limits i_float cppstdin cppflags cppminus This symbol, if defined, indicates that this system's or defines the symbol DBL_DIG, which is the number of significant digits in a double precision number. If this symbol is not defined, a guess of 15 is usually pretty good. HAS_DIFFTIME: Unit: d_difftime Wants: Inlibc This symbol, if defined, indicates that the difftime routine is available. HAS_DLERROR: Unit: d_dlerror Wants: Inlibc runnm This symbol, if defined, indicates that the dlerror routine is available to return a string describing the last error that occurred from a call to dlopen(), dlclose() or dlsym(). HAS_DLOPEN: Unit: d_dlopen Wants: Inlibc runnm This symbol, if defined, indicates that the dlopen routine is available. HAS_DREM: Unit: d_drem Wants: Inlibc This symbol, if defined, indicates that the drem routine is available. This routine is roughly the same as fmod, i.e. it computes the remainder r=x-n*y, where n=rint(x/y), whereas fmod uses n=trunc(x/y). HAS_DUP2: Unit: d_dup2 Wants: Inlibc This symbol, if defined, indicates that the dup2 routine is available to duplicate file descriptors. HAS_EUC2JIS: Unit: d_euc2jis Wants: Inlibc This symbol, if defined, indicates that the euc2jis routine is available to convert EUC to JIS. HAS_FCHMOD: Unit: d_fchmod Wants: Inlibc This symbol, if defined, indicates that the fchmod routine is available to change mode of opened files. If unavailable, use chmod(). HAS_FCHOWN: Unit: d_fchown Wants: Inlibc This symbol, if defined, indicates that the fchown routine is available to change ownership of opened files. If unavailable, use chown(). HAS_FCNTL: Unit: d_fcntl Wants: Inlibc This symbol, if defined, indicates to the C program that the fcntl() function exists. HAS_FDS_BITS: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This symbol, when defined, indicates presence of the fds_bits member in fd_set. This knowledge is useful if fd_set is available but the macros aren't. HAS_FD_MACROS: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This symbol, when defined, indicates presence of the macros used to manipulate an fd_set. HAS_FD_SET: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This symbol, when defined, indicates presence of the fd_set typedef in HAS_FFS: Unit: d_ffs Wants: Inlibc This symbol, if defined, indicates that the ffs routine is available to find the first bit set in its argument. If it's not available, roll your own. HAS_FGETPOS: Unit: d_fgetpos Wants: Inlibc This symbol, if defined, indicates that the fgetpos routine is available to get the file position indicator, similar to ftell(). HAS_FLOCK: Unit: d_flock Wants: Inlibc This symbol, if defined, indicates that the flock routine is available to do file locking. HAS_FMOD: Unit: d_fmod Wants: Inlibc This symbol, if defined, indicates that the fmod routine is available to compute the remainder r=x-n*y where n=trunc(x/y). HAS_FORK: Unit: d_fork Wants: Inlibc This symbol, if defined, indicates that the fork routine is available. HAS_FPATHCONF: Unit: d_pathconf (Also defines d_fpathconf) Wants: Inlibc This symbol, if defined, indicates that pathconf() is available to determine file-system related limits and options associated with a given open file descriptor. HAS_FSETPOS: Unit: d_fsetpos Wants: Inlibc This symbol, if defined, indicates that the fsetpos routine is available to set the file position indicator, similar to fseek(). HAS_FTIME: Unit: d_ftime (Also defines d_gettimeod) Wants: Inlibc Setvar This symbol, if defined, indicates that the ftime() routine exists. It is basically a sub-second accuracy clock, but is less accurate than gettimeofday(2) anyway. The type "Timeval" should be used to refer to "struct timeb". HAS_FTRUNCATE: Unit: d_ftrncate Wants: Inlibc This symbol, if defined, indicates that the ftruncate() subroutine exists. HAS_GDBM: Obsoleted by I_GDBM. HAS_GETGROUPS: Unit: d_getgrps Wants: Inlibc This symbol, if defined, indicates that the getgroups() routine is available to get the list of process groups. If unavailable, multiple groups are probably not supported. HAS_GETHOSTBYNAME: Unit: d_gethbynm Wants: Inlibc This symbol, if defined, indicates that the gethostbyname() routine is available to lookup host names in some data base or other. HAS_GETHOSTENT: Unit: d_gethent Wants: Inlibc This symbol, if defined, indicates that the gethostent routine is available to lookup host names in some data base or other. HAS_GETHOSTID: Unit: d_gethid Wants: Inlibc This symbol, if defined, indicates that the gethostid system call is available to get the host id. HAS_GETHOSTNAME: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This symbol, if defined, indicates that the C program may use the gethostname() routine to derive the host name. See also HAS_UNAME and PHOSTNAME. HAS_GETLOGIN: Unit: d_getlogin Wants: Inlibc This symbol, if defined, indicates that the getlogin routine is available to get the login name. HAS_GETOPT: Unit: d_getopt Wants: Inlibc This symbol, if defined, indicates that the getopt() routine exists. HAS_GETPAGESIZE: Unit: d_getpagsz (Also defines pagesize) Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr Optional: cc ccflags This symbol, if defined, indicates that the getpagesize system call is available to get system page size, which is the granularity of many memory management calls. HAS_GETPGID: Unit: d_getpgid Wants: Inlibc This symbol, if defined, indicates to the C program that the getpgid(pid) function is available to get the process group id. HAS_GETPGRP: Unit: d_getpgrp (Also defines d_bsdgetpgrp) Wants: Guess Inlibc Setvar cat rm i_unistd Optional: cc ccflags ldflags libs This symbol, if defined, indicates that the getpgrp routine is available to get the current process group. HAS_GETPGRP2: Unit: d_getpgrp2 Wants: Inlibc This symbol, if defined, indicates that the getpgrp2() (as in DG/UX) routine is available to get the current process group. HAS_GETPPID: Unit: d_getppid Wants: Inlibc This symbol, if defined, indicates that the getppid routine is available to get the parent process ID. HAS_GETPRIORITY: Unit: d_getprior Wants: Inlibc This symbol, if defined, indicates that the getpriority routine is available to get a process's priority. HAS_GETPWENT: Unit: d_getpwent Wants: Csym Setvar This symbol, if defined, indicates that the getpwent() routine should be used instead of the getpw() routine. HAS_GETRUSAGE: Unit: d_rusage Wants: Inlibc This symbol, if defined, indicates that the getrusage() routine is available to get process statistics with a sub-second accuracy. Inclusion of and may be necessary. HAS_GETTIMEOFDAY: Unit: d_ftime (Also defines d_gettimeod) Wants: Inlibc Setvar This symbol, if defined, indicates that the gettimeofday() system call is available for a sub-second accuracy clock. Usually, the file needs to be included (see I_SYS_RESOURCE). The type "Timeval" should be used to refer to "struct timeval". HAS_GETWD: Unit: d_getwd Wants: Csym Setvar This symbol, if defined, indicates that the getwd routine is available to get working directory. If not, you should probably use getcwd(). HAS_GNULIBC: Unit: d_gnulibc (Also defines gnulibc_version) Wants: Myread Oldconfig Setvar rm cat Compile run This symbol, if defined, indicates to the C program that the GNU C library is being used. A better check is to use the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc. HAS_HTONL: Unit: d_htonl Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags cppminus This symbol, if defined, indicates that the htonl() routine (and friends htons() ntohl() ntohs()) are available to do network order byte swapping. HAS_HTONS: Unit: d_htonl Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags cppminus This symbol, if defined, indicates that the htons() routine (and friends htonl() ntohl() ntohs()) are available to do network order byte swapping. HAS_INDEX: Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym This symbol is defined to indicate that the index()/rindex() functions are available for string searching. HAS_INET_ATON: Unit: d_inetaton Wants: Inlibc This symbol, if defined, indicates to the C program that the inet_aton() function is available to parse IP address "dotted-quad" strings. HAS_ISASCII: Unit: d_isascii Wants: cc cat ccflags ldflags rm libs Setvar This manifest constant lets the C program know that isascii is available. HAS_ITIMER: Unit: d_itimer Wants: Inlibc This symbol, if defined, indicates that the setitimer() routine exists. HAS_KILLPG: Unit: d_killpg Wants: Inlibc This symbol, if defined, indicates that the killpg routine is available to kill process groups. If unavailable, you probably should use kill with a negative process number. HAS_LINK: Unit: d_link Wants: Inlibc This symbol, if defined, indicates that the link routine is available to create hard links. HAS_LOCALECONV: Unit: d_locconv Wants: Inlibc This symbol, if defined, indicates that the localeconv routine is available for numeric and monetary formatting conventions. HAS_LOCKF: Unit: d_lockf Wants: Inlibc This symbol, if defined, indicates that the lockf routine is available to do file locking. HAS_LSTAT: Unit: d_lstat Wants: Inlibc This symbol, if defined, indicates that the lstat routine is available to do file stats on symbolic links. HAS_MBLEN: Unit: d_mblen Wants: Inlibc This symbol, if defined, indicates that the mblen routine is available to find the number of bytes in a multibye character. HAS_MBSTOWCS: Unit: d_mbstowcs Wants: Inlibc This symbol, if defined, indicates that the mbstowcs routine is available to covert a multibyte string into a wide character string. HAS_MBTOWC: Unit: d_mbtowc Wants: Inlibc This symbol, if defined, indicates that the mbtowc routine is available to covert a multibyte to a wide character. HAS_MEMALIGN: Unit: d_memalign Wants: Inlibc This symbol, if defined, indicates that the memalign routine is available to allocate aligned memory. HAS_MEMCCPY: Unit: d_memccpy Wants: Inlibc This symbol, if defined, indicates that the memccpy routine is available to copy a character into a block of memory. Otherwise you should roll your own. HAS_MEMCHR: Unit: d_memchr Wants: Inlibc This symbol, if defined, indicates that the memchr routine is available to scan a block of memory for a character. If undefined, roll your own. HAS_MEMCMP: Unit: d_memcmp Wants: Inlibc This symbol, if defined, indicates that the memcmp routine is available to compare blocks of memory. HAS_MEMCPY: Unit: d_memcpy Wants: Inlibc This symbol, if defined, indicates that the memcpy routine is available to copy blocks of memory. HAS_MEMMOVE: Unit: d_memmove Wants: Inlibc This symbol, if defined, indicates that the memmove routine is available to copy potentially overlapping blocks of memory. This should be used only when HAS_SAFE_BCOPY is not defined. If neither is there, roll your own version. HAS_MEMSET: Unit: d_memset Wants: Inlibc This symbol, if defined, indicates that the memset routine is available to set blocks of memory. HAS_MKDIR: Unit: d_mkdir Wants: Inlibc This symbol, if defined, indicates that the mkdir routine is available to create directories. Otherwise you should fork off a new process to exec /bin/mkdir. HAS_MKFIFO: Unit: d_mkfifo Wants: Inlibc This symbol, if defined, indicates that the mkfifo routine is available to create FIFOs. Otherwise, mknod should be able to do it for you. However, if mkfifo is there, mknod might require super-user privileges which mkfifo will not. HAS_MKTIME: Unit: d_mktime Wants: Inlibc This symbol, if defined, indicates that the mktime routine is available. HAS_MMAP: Unit: d_mmap Wants: Inlibc This symbol, if defined, indicates that the mmap system call is available to map a file into memory. HAS_MSEM_LOCK: Unit: d_msem_lck Wants: Inlibc This symbol, if defined, indicates that memory semaphores are available to protect mmap()'ed regions. HAS_MSG: Unit: d_msg Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr This symbol, if defined, indicates that the entire msg*(2) library is supported (IPC mechanism based on message queues). HAS_MSGCTL: Unit: d_msgctl Wants: Inlibc This symbol, if defined, indicates that the msgctl() routine is available to perform message control operations. HAS_MSGGET: Unit: d_msgget Wants: Inlibc This symbol, if defined, indicates that the msgget() routine is available to get a new message queue. HAS_MSGRCV: Unit: d_msgrcv Wants: Inlibc This symbol, if defined, indicates that the msgrcv() routine is available to extract a message from the message queue. HAS_MSGSND: Unit: d_msgsnd Wants: Inlibc This symbol, if defined, indicates that the msgsnd() routine is available to send a message into the message queue. HAS_MSYNC: Unit: d_msync Wants: Inlibc This symbol, if defined, indicates that the msync system call is available to synchronize a mapped file. HAS_MUNMAP: Unit: d_munmap Wants: Inlibc This symbol, if defined, indicates that the munmap system call is available to unmap a region, usually mapped by mmap(). HAS_NDBM: Obsoleted by I_NDBM. HAS_NEWS1_0: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile This symbol defined if running NeWS 1.0. HAS_NEWS1_1: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile This symbol defined if running NeWS 1.1. HAS_NICE: Unit: d_nice Wants: Inlibc This symbol, if defined, indicates that the nice routine is available. HAS_NTOHL: Unit: d_htonl Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags cppminus This symbol, if defined, indicates that the ntohl() routine (and friends htonl() htons() ntohs()) are available to do network order byte swapping. HAS_NTOHS: Unit: d_htonl Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags cppminus This symbol, if defined, indicates that the ntohs() routine (and friends htonl() htons() ntohl()) are available to do network order byte swapping. HAS_ODBM: Obsoleted by I_DBM. HAS_OPEN3: Unit: d_open3 Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr Warn Optional: cc cppflags This manifest constant lets the C program know that the three argument form of open(2) is available. HAS_PATHCONF: Unit: d_pathconf (Also defines d_fpathconf) Wants: Inlibc This symbol, if defined, indicates that pathconf() is available to determine file-system related limits and options associated with a given filename. HAS_PAUSE: Unit: d_pause Wants: Inlibc This symbol, if defined, indicates that the pause routine is available to suspend a process until a signal is received. HAS_PERROR: Unit: d_perror Wants: Inlibc This symbol, if defined, indicates that the perror() routine is available to print system error messages. If not defined, you should use your own diagnostic routine... HAS_PIPE: Unit: d_pipe Wants: Inlibc This symbol, if defined, indicates that the pipe routine is available to create an inter-process channel. HAS_POLL: Unit: d_poll Wants: Inlibc This symbol, if defined, indicates that the poll routine is available to poll active file descriptors. Please check I_POLL and I_SYS_POLL to know which header should be included as well. HAS_POPEN: Unit: d_popen Wants: Inlibc This symbol, if defined, indicates that the popen routine is available to open a pipe from a process. HAS_PREAD: Unit: d_pread Wants: Inlibc This symbol, if defined, indicates that the pread routine is available to perform reads on a file descriptor at a given offset. HAS_PREADV: Unit: d_preadv Wants: Inlibc This symbol, if defined, indicates that the preadv routine is available to perform vectored reads on a file descriptor at a given offset. HAS_PSIGNAL: Unit: d_psignal Wants: Inlibc This symbol, if defined, indicates that the psignal() routine exists. HAS_PWRITE: Unit: d_pwrite Wants: Inlibc This symbol, if defined, indicates that the pwrite routine is available to perform writes on a file descriptor at a given offset. HAS_PWRITEV: Unit: d_pwritev Wants: Inlibc This symbol, if defined, indicates that the pwritev routine is available to perform vectored writes on a file descriptor at a given offset. HAS_RDCHK: Unit: d_rdchk Wants: Inlibc This symbol, if defined, indicates that the rdchk routine is available to find out if there is input pending on an IO channel. Generally the routine is used only if FIONREAD and O_NDELAY aren't available. HAS_READDIR: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This symbol, if defined, indicates that the readdir routine is available to read directory entries. You may have to include . See I_DIRENT. HAS_READLINK: Unit: d_readlink Wants: Inlibc This symbol, if defined, indicates that the readlink routine is available to read the value of a symbolic link. HAS_RECOMP: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This symbol, if defined, indicates that the re_comp() routine is available to do some regular patern matching (usually on BSD). If so, it is likely that re_exec() be available. HAS_REGCMP: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This symbol, if defined, indicates that the regcmp() routine is available to do some regular patern matching (usually on System V). HAS_REGCOMP: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This symbol, if defined, indicates that the regcomp() routine is available to do some regular patern matching (usually on POSIX.2 conforming systems). HAS_RENAME: Unit: d_rename Wants: Inlibc This symbol, if defined, indicates that the rename routine is available to rename files. Otherwise you should do the unlink(), link(), unlink() trick. HAS_REWINDDIR: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This symbol, if defined, indicates that the rewinddir routine is available. You may have to include . See I_DIRENT. HAS_RMDIR: Unit: d_rmdir Wants: Inlibc This symbol, if defined, indicates that the rmdir routine is available to remove directories. Otherwise you should fork off a new process to exec /bin/rmdir. HAS_SAFE_BCOPY: Unit: d_safebcpy Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags ldflags libs This symbol, if defined, indicates that the bcopy routine is available to copy potentially overlapping memory blocks. Otherwise you should probably use memmove() or memcpy(). If neither is defined, roll your own version. HAS_SAFE_MEMCPY: Unit: d_safemcpy Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags libs ldflags This symbol, if defined, indicates that the memcpy routine is available to copy potentially overlapping memory blocks. Otherwise you should probably use memmove() or memcpy(). If neither is defined, roll your own version. HAS_SANE_MEMCMP: Unit: d_sanemcmp Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags libs ldflags This symbol, if defined, indicates that the memcmp routine is available and can be used to compare relative magnitudes of chars with their high bits set. If it is not defined, roll your own version. HAS_SBRK: Unit: d_sbrk Wants: Inlibc This symbol, if defined, indicates that the sbrk system call is available to add/relase core. Always true on Unix. HAS_SCANDIR: Unit: d_scandir Wants: Inlibc This symbol, if defined, indicates that the scandir routine is available to scan a directory. HAS_SEEKDIR: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This symbol, if defined, indicates that the seekdir routine is available. You may have to include . See I_DIRENT. HAS_SELECT: Unit: d_select Wants: Inlibc This symbol, if defined, indicates that the select routine is available to select active file descriptors. If the timeout field is used, may need to be included. HAS_SEM: Unit: d_sem Wants: test d_semctl d_semget d_semop Setvar Findhdr This symbol, if defined, indicates that the entire sem*(2) library is supported. HAS_SEMCTL: Unit: d_semctl Wants: Inlibc This symbol, if defined, indicates that the semctl() routine is available to perform semaphore control operations. HAS_SEMGET: Unit: d_semget Wants: Inlibc This symbol, if defined, indicates that the semget() routine is available to get a set of semaphores. HAS_SEMOP: Unit: d_semop Wants: Inlibc This symbol, if defined, indicates that the semop() routine is available to execute semaphore operations. HAS_SETEGID: Unit: d_setegid Wants: Inlibc This symbol, if defined, indicates that the setegid routine is available to change the effective gid of the current program. HAS_SETEUID: Unit: d_seteuid Wants: Inlibc This symbol, if defined, indicates that the seteuid routine is available to change the effective uid of the current program. HAS_SETGROUPS: Unit: d_setgrps Wants: Inlibc This symbol, if defined, indicates that the setgroups() routine is available to set the list of process groups. If unavailable, multiple groups are probably not supported. HAS_SETLINEBUF: Unit: d_setlnbuf (Also defines d_setlinebuf) Wants: Inlibc This symbol, if defined, indicates that the setlinebuf routine is available to change stderr or stdout from block-buffered or unbuffered to a line-buffered mode. HAS_SETLOCALE: Unit: d_setlocale Wants: Inlibc This symbol, if defined, indicates that the setlocale routine is available to handle locale-specific ctype implementations. HAS_SETPGID: Unit: d_setpgid Wants: Inlibc This symbol, if defined, indicates that the setpgid(pid, gpid) routine is available to set process group ID. HAS_SETPGRP: Unit: d_setpgrp (Also defines d_bsdsetpgrp) Wants: cat rm Inlibc Guess Setvar i_unistd Optional: cc libs ccflags ldflags This symbol, if defined, indicates that the setpgrp routine is available to set the current process group. HAS_SETPGRP2: Unit: d_setpgrp2 Wants: Inlibc This symbol, if defined, indicates that the setpgrp2() (as in DG/UX) routine is available to set the current process group. HAS_SETPRIORITY: Unit: d_setprior Wants: Inlibc This symbol, if defined, indicates that the setpriority routine is available to set a process's priority. HAS_SETREGID: Unit: d_setregid (Also defines d_setresgid) Wants: Inlibc This symbol, if defined, indicates that the setregid routine is available to change the real and effective gid of the current process. HAS_SETRESGID: Unit: d_setregid (Also defines d_setresgid) Wants: Inlibc This symbol, if defined, indicates that the setresgid routine is available to change the real, effective and saved gid of the current process. HAS_SETRESUID: Unit: d_setreuid (Also defines d_setresuid) Wants: Inlibc This symbol, if defined, indicates that the setresuid routine is available to change the real, effective and saved uid of the current process. HAS_SETREUID: Unit: d_setreuid (Also defines d_setresuid) Wants: Inlibc This symbol, if defined, indicates that the setreuid routine is available to change the real and effective uid of the current process. HAS_SETRGID: Unit: d_setrgid Wants: Inlibc This symbol, if defined, indicates that the setrgid routine is available to change the real gid of the current program. HAS_SETRUID: Unit: d_setruid Wants: Inlibc This symbol, if defined, indicates that the setruid routine is available to change the real uid of the current program. HAS_SETSID: Unit: d_setsid Wants: Inlibc This symbol, if defined, indicates that the setsid routine is available to set the process group ID. HAS_SHM: Unit: d_shm Wants: test d_shmctl d_shmget d_shmat d_shmdt Setvar Findhdr This symbol, if defined, indicates that the entire shm*(2) library is supported. HAS_SHMAT: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This symbol, if defined, indicates that the shmat() routine is available to attach a shared memory segment to the process space. HAS_SHMAT_PROTOTYPE: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This symbol, if defined, indicates that the sys/shm.h includes a prototype for shmat(). Otherwise, it is up to the program to guess one. Shmat_t shmat _((int, Shmat_t, int)) is a good guess, but not always right so it should be emitted by the program only when HAS_SHMAT_PROTOTYPE is not defined to avoid conflicting defs. HAS_SHMCTL: Unit: d_shmctl Wants: Inlibc This symbol, if defined, indicates that the shmctl() routine is available to perform shared memory control operations. HAS_SHMDT: Unit: d_shmdt Wants: Inlibc This symbol, if defined, indicates that the shmdt() routine is available to detach a shared memory segment from the process space. HAS_SHMGET: Unit: d_shmget Wants: Inlibc This symbol, if defined, indicates that the shmget() routine is available to request a shared memory segment from the kernel. HAS_SIGACTION: Unit: d_sigaction Wants: Csym Setvar cat cc ccflags ldflags libs rm _o This symbol, if defined, indicates that Vr4's sigaction() routine is available. HAS_SIGBLOCK: Unit: d_sigblock Wants: Inlibc This symbol, if defined, indicates that the sigblock routine is available to block signal reception. HAS_SIGHOLD: Unit: d_sighold Wants: Inlibc This symbol, if defined, indicates that the sighold routine is available to hold signals. HAS_SIGINTRP: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This symbol, if defined, indicates that the siginterrupt() routine is available. HAS_SIGSETJMP: Unit: d_sigsetjmp Wants: Setvar cat libs rm Optional: cc ccflags ldflags This variable indicates to the C program that the sigsetjmp() routine is available to save the calling process's registers and stack environment for later use by siglongjmp(), and to optionally save the process's signal mask. See Sigjmp_buf, Sigsetjmp, and Siglongjmp. HAS_SIGSETMASK: Unit: d_sigsetmk Wants: Csym Setvar This symbol, if defined, indicates that the sigsetmask() routine is available to set current signal mask. Otherwise, you should probably emulate this by using signal(), but fear race conditions... HAS_SIGVEC: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This symbol, if defined, indicates that BSD reliable signals are supported. HAS_SIGVECTOR: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This symbol, if defined, indicates that the sigvec() routine is called sigvector() instead, and that sigspace() is provided instead of sigstack(). This is probably only true for HP-UX. HAS_SJIS2JIS: Unit: d_sjis2jis Wants: Inlibc This symbol, if defined, indicates that the sjis2jis routine is available to convert SJIS to JIS. HAS_SMART_SBRK: Unit: sbrksmart Wants: cat d_sbrk rm Optional: cc ccflags libs This symbol is defined when the sbrk() system call may be used with a negative argument to lower the break value, therefore releasing core to the system. If not, you'd probably be better off using the mmap() system call. HAS_SOCKET: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This symbol, if defined, indicates that the BSD socket interface is supported. HAS_SOCKETPAIR: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This symbol, if defined, indicates that the BSD socketpair() call is supported. HAS_STAT: Unit: d_stat Wants: Inlibc This symbol, if defined, indicates that the stat routine is available to get file status. HAS_STRCASECMP: Unit: d_strccmp Wants: Inlibc This symbol, if defined, indicates that the strcasecmp() routine is available for case-insensitive string compares. HAS_STRCHR: Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym This symbol is defined to indicate that the strchr()/strrchr() functions are available for string searching. If not, try the index()/rindex() pair. HAS_STRCOLL: Unit: d_strcoll Wants: Inlibc This symbol, if defined, indicates that the strcoll routine is available to compare strings using collating information. HAS_STRCSPN: Unit: d_strcspn Wants: Inlibc This symbol, if defined, indicates that the strcspn routine is available to scan strings. HAS_STRDUP: Unit: d_strdup Wants: Inlibc This symbol, if defined, indicates that the strdup routine is available to duplicate strings in memory. Otherwise, roll up your own... HAS_STRERROR: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This symbol, if defined, indicates that the strerror routine is available to translate error numbers to strings. See the writeup of Strerror() in this file before you try to define your own. HAS_STRFTIME: Unit: d_strftime Wants: Inlibc This symbol, if defined, indicates that the strftime routine is available to format locale-specific times. HAS_STRSTR: Unit: d_strstr Wants: Inlibc This symbol, if defined, indicates that the strstr routine is available to find substrings. HAS_STRTOD: Unit: d_strtod Wants: Inlibc This symbol, if defined, indicates that the strtod routine is available to provide better numeric string conversion than atof(). HAS_STRTOK: Unit: d_strtok Wants: Inlibc This symbol, if defined, indicates that the strtok routine is available to scan strings for tokens. HAS_STRTOL: Unit: d_strtol Wants: Inlibc This symbol, if defined, indicates that the strtol routine is available to provide better numeric string conversion than atoi() and friends. HAS_STRTOUL: Unit: d_strtoul Wants: Inlibc This symbol, if defined, indicates that the strtoul routine is available to provide conversion of strings to unsigned long. HAS_STRXFRM: Unit: d_strxfrm Wants: Inlibc This symbol, if defined, indicates that the strxfrm() routine is available to transform strings. HAS_SYMLINK: Unit: d_symlink Wants: Inlibc This symbol, if defined, indicates that the symlink routine is available to create symbolic links. HAS_SYSCALL: Unit: d_syscall Wants: Inlibc This symbol, if defined, indicates that the syscall routine is available to call arbitrary system calls. If undefined, that's tough. HAS_SYSCONF: Unit: d_sysconf Wants: Inlibc This symbol, if defined, indicates that sysconf() is available to determine system related limits and options. HAS_SYSLOG: Unit: d_syslog Wants: test Csym Setvar Findhdr This symbol, if defined, indicates that the program can rely on the system providing syslog(). Otherwise, the syslog code provided by the package should be used. HAS_SYSTEM: Unit: d_system Wants: Inlibc This symbol, if defined, indicates that the system routine is available to issue a shell command. HAS_SYS_ERRLIST: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This symbol, if defined, indicates that the sys_errlist array is available to translate error numbers to strings. The extern int sys_nerr gives the size of that table. HAS_SYS_ERRNOLIST: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This symbol, if defined, indicates that the sys_errnolist array is available to translate an errno code into its symbolic name (e.g. ENOENT). The extern int sys_nerrno gives the size of that table. HAS_SYS_SIGLIST: Unit: d_siglist Wants: Csym Setvar This symbol, if defined, indicates that the sys_siglist array is available to translate signal numbers to strings. HAS_TABLE: Unit: d_table Wants: Inlibc This symbol, if defined, indicates that the OSF/1 table() system call is available to examine/update items from a system table. HAS_TCGETPGRP: Unit: d_tcgtpgrp (Also defines d_tcgetpgrp) Wants: Inlibc This symbol, if defined, indicates that the tcgetpgrp routine is available to get foreground process group ID. HAS_TCSETPGRP: Unit: d_tcstpgrp (Also defines d_tcsetpgrp) Wants: Inlibc This symbol, if defined, indicates that the tcsetpgrp routine is available to set foreground process group ID. HAS_TELLDIR: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This symbol, if defined, indicates that the telldir routine is available. You may have to include . See I_DIRENT. HAS_TERMLIB: Unit: d_havetlib (Also defines termlib) Wants: cat contains Myread Loc Filexp Oldconfig libpth test uname _a _o This symbol, when defined, indicates that termlib-style routines are available. There is nothing to include. HAS_TIME: Unit: d_time (Also defines timetype) Wants: Csym Setvar Findhdr Myread Typedef This symbol, if defined, indicates that the time() routine exists. HAS_TIMES: Unit: d_times (Also defines clocktype) Wants: Csym Myread Typedef i_systimes This symbol, if defined, indicates that the times() routine exists. Note that this became obsolete on some systems (SUNOS), which now use getrusage(). It may be necessary to include . HAS_TRUNCATE: Unit: d_truncate Wants: Inlibc This symbol, if defined, indicates that the truncate routine is available to truncate files. HAS_TZNAME: Unit: d_tzname Wants: Csym Setvar This symbol, if defined, indicates that the tzname[] array is available to access timezone names. HAS_ULIMIT: Unit: d_ulimit Wants: Inlibc This symbol, if defined, indicates that the ulimit system call is available to get the user limits. HAS_UMASK: Unit: d_umask Wants: Inlibc This symbol, if defined, indicates that the umask routine is available to set and get the value of the file creation mask. HAS_UNAME: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This symbol, if defined, indicates that the C program may use the uname() routine to derive the host name. See also HAS_GETHOSTNAME and PHOSTNAME. HAS_USLEEP: Unit: d_usleep Wants: Inlibc This symbol, if defined, indicates that the usleep routine is available to let the process sleep on a sub-second accuracy. HAS_VFORK: Unit: d_vfork (Also defines usevfork) Wants: Inlibc Myread Oldconfig Setvar This symbol, if defined, indicates that vfork() exists. HAS_VPRINTF: Unit: d_vprintf (Also defines d_charvspr) Wants: Guess cat Csym Setvar Optional: cc ccflags This symbol, if defined, indicates that the vprintf routine is available to printf with a pointer to an argument list. If unavailable, you may need to write your own, probably in terms of _doprnt(). HAS_WAIT3: Unit: d_wait3 Wants: Inlibc This symbol, if defined, indicates that the wait3() subroutine exists. HAS_WAIT4: Unit: d_wait4 Wants: Inlibc This symbol, if defined, indicates that wait4() exists. HAS_WAITPID: Unit: d_waitpid Wants: Inlibc This symbol, if defined, indicates that the waitpid routine is available to wait for child process. HAS_WCSTOMBS: Unit: d_wcstombs Wants: Inlibc This symbol, if defined, indicates that the wcstombs routine is available to convert wide character strings to multibyte strings. HAS_WCTOMB: Unit: d_wctomb Wants: Inlibc This symbol, if defined, indicates that the wctomb routine is available to covert a wide character to a multibyte. HAS_XDRS: Unit: d_xdrs Wants: cat Csym Setvar This symbol if defined indicates to the C program that the XDR serialization routines are available to transfer data accross various architectures. HAVETERMLIB: Obsoleted by HAS_TERMLIB. HDR_O_STUFF: Obsoleted by I_FCNTL. HIDDENNET: Obsoleted by HIDDEN_NET. HIDDEN_NET: Unit: d_hidnet (Also defines hiddennet) Wants: cat sed myhostname mydomain Myread Oldconfig This symbol, if defined, contains the host name that you want to advertise to the outside world. This name can be different from your actual host name, as long as the machine you specify knows how to forward mail to you. HOSTNAME: Obsoleted by MYHOSTNAME. HTONL: Obsoleted by HAS_HTONL. HTONS: Obsoleted by HAS_HTONS. INETD: Obsoleted by USE_INETD. INSTALLPREFIX: Unit: prefix (Also defines prefixexp) (With private oldprefix) Wants: Getfile Loc Oldconfig cat package This symbol contains the name of the install prefix for this package. INTERNET: Unit: d_internet Wants: Myread Oldconfig Setvar This symbol, if defined, indicates that there is a mailer available which supports internet-style addresses (user@site.domain). INTSIZE: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This symbol contains the value of sizeof(int) so that the C preprocessor can make decisions based on it. ITIMER: Obsoleted by HAS_ITIMER. I_ARPA_INET: Unit: i_arpainet Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get inet_addr and friends declarations. I_BSDIOCTL: Obsoleted by I_SYS_BSDIOCTL. I_DB: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This symbol, if defined, indicates to the C program that it should include Berkeley's DB include file . I_DBM: Unit: i_dbm (Also defines i_rpcsvcdbm) Wants: Inhdr Inlibc Setvar This symbol, if defined, indicates that exists and should be included. I_DIRENT: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This symbol, if defined, indicates to the C program that it should include . Using this symbol also triggers the definition of the Direntry_t define which ends up being 'struct dirent' or 'struct direct' depending on the availability of . I_DLD: Unit: i_dld Wants: Inhdr This symbol, if defined, indicates that exists and should be included before using GNU dynamic loading features. I_DLFCN: Unit: i_dlfcn Wants: Inhdr This symbol, if defined, indicates that exists and should be included. I_FCNTL: Unit: i_fcntl Wants: h_fcntl h_sysfile Inhdr Setvar Optional: i_sysfile This manifest constant tells the C program to include . I_FLOAT: Unit: i_float Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get definition of symbols like DBL_MAX or DBL_MIN, i.e. machine dependent floating point values. I_GDBM: Unit: i_gdbm Wants: Inhdr Inlibc Setvar This symbol, if defined, indicates that exists and should be included. I_GRP: Unit: i_grp Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_INTTYPES: Unit: i_inttypes Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get format conversions of integer types. I_LIMITS: Unit: i_limits Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get definition of symbols like WORD_BIT or LONG_MAX, i.e. machine dependant limitations. I_LOCALE: Unit: i_locale Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_MALLOC: Unit: i_malloc Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_MATH: Unit: i_math Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_MEMORY: Unit: i_memory Wants: Inhdr strings cppstdin cppflags cppminus contains rm Setvar This symbol, if defined, indicates to the C program that it should include . I_NDBM: Unit: i_ndbm Wants: Inhdr Inlibc Setvar This symbol, if defined, indicates that exists and should be included. I_NDIR: Unit: d_usendir (Also defines i_ndir ndirlib) Wants: test Setvar Findhdr d_readdir _a This symbol, if defined, indicates that the program should include the system's version of ndir.h, rather than the one with this package. I_NETINET_IN: Unit: i_niin (Also defines i_sysin) Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . Otherwise, you may try . I_NET_ERRNO: Unit: i_neterrno Wants: Inhdr rm Setvar Optional: cc ccflags This symbol, if defined, indicates that exists and should be included. I_POLL: Unit: i_poll Wants: Inhdr This symbol, if defined, indicates that the program may include . If there is no , then you may check I_SYS_POLL instead to see whether there is a to include. I_PWD: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that it should include . I_REGEX: Unit: i_regex Wants: Inhdr This symbol, if defined, indicates that exists and should be included. I_RPCSVC_DBM: Unit: i_dbm (Also defines i_rpcsvcdbm) Wants: Inhdr Inlibc Setvar This symbol, if defined, indicates that exists and should be included. I_SFIO: Unit: i_sfio Wants: Inhdr Setvar This symbol, if defined, indicates to the C program that it should include . I_SGTTY: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This symbol, if defined, indicates that the program should include rather than . There are also differences in the ioctl() calls that depend on the value of this symbol. I_STDARG: Unit: i_varhdr (Also defines i_stdarg i_varargs) Wants: cat rm test Setvar Findhdr Warn startsh _o Optional: cc ccflags This symbol, if defined, indicates that exists and should be included. I_STDDEF: Unit: i_stddef Wants: Inhdr This symbol, if defined, indicates that exists and should be included. I_STDLIB: Unit: i_stdlib Wants: Inhdr This symbol, if defined, indicates that exists and should be included. I_STRING: Unit: i_string (Also defines strings) Wants: test Setvar Findhdr Warn This symbol, if defined, indicates to the C program that it should include (USG systems) instead of (BSD systems). I_SYSDIR: Obsoleted by I_SYS_DIR. I_SYSFILE: Obsoleted by I_SYS_FILE. I_SYSIN: Obsoleted by I_SYS_IN. I_SYSIOCTL: Obsoleted by I_SYS_IOCTL. I_SYSNDIR: Obsoleted by I_SYS_NDIR. I_SYSRESOURCE: Obsoleted by I_SYS_RESOURCE. I_SYSSELECT: Obsoleted by I_SYS_SELECT. I_SYSSOCKIO: Obsoleted by I_SYS_SOCKIO. I_SYSSTAT: Obsoleted by I_SYS_STAT. I_SYSTIME: Obsoleted by I_SYS_TIME. I_SYSTIMEB: Obsoleted by I_SYS_TIMEB. I_SYSTIMEKERNEL: Obsoleted by I_SYS_TIME_KERNEL. I_SYSTIMES: Obsoleted by I_SYS_TIMES. I_SYSTYPES: Obsoleted by I_SYS_TYPES. I_SYSWAIT: Obsoleted by I_SYS_WAIT. I_SYS_BSDIOCTL: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This symbol, if defined, indicates that exists and should be included. Otherwise, try . This is primarly intended for definitions of sockets options, like SIOCATMARK. I_SYS_DIR: Unit: i_sysdir Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_FILE: Unit: i_sysfile Wants: h_sysfile Inhdr Setvar This symbol, if defined, indicates to the C program that it should include to get definition of R_OK and friends. I_SYS_FILIO: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This symbol, if defined, indicates that exists and should be included instead of . I_SYS_IN: Unit: i_niin (Also defines i_sysin) Wants: Inhdr This symbol, if defined, indicates to the C program that it should include instead of . I_SYS_IOCTL: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This symbol, if defined, indicates that exists and should be included. Otherwise, include or . I_SYS_MMAN: Unit: i_sysmman Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_NDIR: Unit: i_sysndir Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_PARAM: Unit: i_sysparam Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_POLL: Unit: i_syspoll Wants: Inhdr This symbol, if defined, indicates that the program may include . When I_POLL is also defined, it's probably safest to only include . I_SYS_RESOURCE: Unit: i_sysresrc Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_SELECT: Unit: i_sysselct Wants: Inhdr This symbol, if defined, indicates to the C program that it should include in order to get definition of struct timeval. I_SYS_SOCKET: Unit: i_syssock Wants: Inhdr This symbol, if defined, indicates to the C program that it should include before performing socket calls. I_SYS_SOCKIO: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This symbol, if defined, indicates the should be included to get socket ioctl options, like SIOCATMARK. I_SYS_STAT: Unit: i_sysstat Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_TABLE: Unit: i_systable Wants: Inhdr This symbol, if defined, indicates to the C program that it should include for the OSF/1 table() system call. I_SYS_TIME: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This symbol, if defined, indicates to the C program that it should include . I_SYS_TIMEB: Unit: i_systimeb Wants: test contains Loc Setvar Findhdr This symbol, if defined, indicates to the C program that it should include , in order to define struct timeb (some systems define this in ). This is useful when using ftime(). You should include if I_SYS_TIMEB is not defined, nor is I_SYS_TIME. I_SYS_TIMES: Unit: i_systimes Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_TIME_KERNEL: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This symbol, if defined, indicates to the C program that it should include with KERNEL defined. I_SYS_TWG_CF: Unit: i_systwgcf Wants: Inhdr This symbol, if defined, indicates to the C program that it should include sys/twg_config.h. I_SYS_TYPES: Unit: i_systypes Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_SYS_UN: Unit: i_sysun Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get UNIX domain socket definitions. I_SYS_WAIT: Unit: i_syswait Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_TERMIO: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This symbol, if defined, indicates that the program should include rather than . There are also differences in the ioctl() calls that depend on the value of this symbol. I_TERMIOS: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This symbol, if defined, indicates that the program should include the POSIX termios.h rather than sgtty.h or termio.h. There are also differences in the ioctl() calls that depend on the value of this symbol. I_TIME: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This symbol, if defined, indicates to the C program that it should include . I_UNISTD: Unit: i_unistd Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_UTIME: Unit: i_utime Wants: Inhdr This symbol, if defined, indicates to the C program that it should include . I_VALUES: Unit: i_values Wants: Inhdr This symbol, if defined, indicates to the C program that it should include to get definition of symbols like MINFLOAT or MAXLONG, i.e. machine dependant limitations. Probably, you should use instead, if it is available. I_VARARGS: Unit: i_varhdr (Also defines i_stdarg i_varargs) Wants: cat rm test Setvar Findhdr Warn startsh _o Optional: cc ccflags This symbol, if defined, indicates to the C program that it should include . I_VFORK: Unit: i_vfork Wants: Inhdr d_vfork This symbol, if defined, indicates to the C program that it should include vfork.h. I_WHOAMI: Unit: i_whoami Wants: Inhdr This symbol, if defined, indicates that the program may include . KEEPALIVE: Obsoleted by CAN_KEEPALIVE. KILLPG: Obsoleted by HAS_KILLPG. LIBNDIR: Obsoleted by I_NDIR. LIBSYSLOG: Obsoleted by HAS_SYSLOG. LINUX_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under a Linux system. LOCDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the local organization. LOCKF: Obsoleted by HAS_LOCKF. LOC_SED: Unit: Loc_sed (Also defines full_sed) Wants: sed This symbol holds the complete pathname to the sed program. LONGSIZE: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This symbol contains the value of sizeof(long) so that the C preprocessor can make decisions based on it. LSEEKTYPE: Obsoleted by Off_t. LSTAT: Obsoleted by HAS_LSTAT. MAILFILE: Unit: mailfile Wants: Myread Oldconfig Filexp Loc This symbol contains the interpretable name of the mail spool file for the current user. The program must be prepared to substitute the HOME directory for %~, and the login id for %L. MALLOCPTRTYPE: Obsoleted by Malloc_t. MBOXCHAR: Unit: mboxchar Wants: cat package shsharp Myread Oldconfig This symbol contains a character which will match the beginning of a mailbox file. MBSTOWCS: Obsoleted by HAS_MBSTOWCS. MBTOWC: Obsoleted by HAS_MBTOWC. MEMCCPY: Obsoleted by HAS_MEMCCPY. MEMCMP: Obsoleted by HAS_MEMCMP. MEMCPY: Obsoleted by HAS_MEMCPY. MEMSET: Obsoleted by HAS_MEMSET. MEM_ALIGNBYTES: Unit: alignbytes Wants: Myread cat cc ccflags rm This symbol contains the number of bytes required to align a double. Usual values are 2, 4 and 8. MKDIR: Obsoleted by HAS_MKDIR. MULTISTATEDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to a multi-state region. MYDOMAIN: Unit: myhostname (Also defines phostname mydomain) Wants: contains sed test Myread Oldconfig Guess Loc awk echo sort uniq rm hostcat Tr osname Optional: usrinc This symbol contains the domain of the host the program is going to run on. The domain must be appended to HOSTNAME to form a complete host name. The dot comes with MYDOMAIN, and need not be supplied by the program. If the host name is derived from PHOSTNAME, the domain may or may not already be there, and the program should check. MYHOSTNAME: Unit: myhostname (Also defines phostname mydomain) Wants: contains sed test Myread Oldconfig Guess Loc awk echo sort uniq rm hostcat Tr osname Optional: usrinc This symbol contains name of the host the program is going to run on. The domain is not kept with hostname, but must be gotten from MYDOMAIN. The dot comes with MYDOMAIN, and need not be supplied by the program. If gethostname() or uname() exist, MYHOSTNAME may be ignored. If MYDOMAIN is not used, MYHOSTNAME will hold the name derived from PHOSTNAME. MYMALLOC: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This symbol, if defined, indicates that we're using our own malloc. Malloc_t: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This symbol is the type of pointer returned by malloc and realloc. Mode_t: Unit: modetype Wants: Myread Typedef This symbol holds the type used to declare file modes for systems calls. It is usually mode_t, but may be int or unsigned short. It may be necessary to include to get any typedef'ed information. NDBM: Obsoleted by I_NDBM. NEWS1_0: Obsoleted by HAS_NEWS1_0. NEWS1_1: Obsoleted by HAS_NEWS1_1. NEWSADMIN: Obsoleted by NEWS_ADMIN. NEWSLEVEL: Unit: newslevel Wants: cat contains test activeexp newslib Myread Oldconfig The current revision level of the Usenet news system, encoded as 1000 * major rev + 10 * minor rev + sub rev. For instance, news 2.10.3 is encode as 2103, and 2.11 as 2110. NEWSLIB: Unit: newslib (Also defines newslibexp) Wants: test inews Oldconfig Getfile This symbol contains the name of the directory serving as the news library. The program must be prepared to do ~ expansion on it. NEWSLIB_EXP: Unit: newslib (Also defines newslibexp) Wants: test inews Oldconfig Getfile This symbol is the ~ expanded version of NEWSLIB, for programs that do not wish to deal with it at run-time. NEWSSPOOL: Unit: newsspool (Also defines newsspoolexp) Wants: Getfile Oldconfig This symbol contains the directory name where news articles are spooled. The program must be prepared to do ~ expansion on it. NEWSSPOOL_EXP: Unit: newsspool (Also defines newsspoolexp) Wants: Getfile Oldconfig This is the same as NEWSSPOOL, but is filename expanded at configuration time, for use in programs not willing to do so at run-time. NEWS_ADMIN: Unit: d_newsadm (Also defines newsadmin) Wants: cat contains Guess Setvar Myread Oldconfig This symbol, if defined, contains the login name of the news administrator. NLIST_FOUND: Unit: nlist_pfx (Also defines nlist_fnd) Wants: cat test Myread Oldconfig libnlist Optional: cc ccflags This manifest constant holds the member of the nlist structure which is nonzero if an nlist search succeeds. NLIST_PREFIX: Unit: nlist_pfx (Also defines nlist_fnd) Wants: cat test Myread Oldconfig libnlist Optional: cc ccflags This manifest constant holds the string of characters which should preceed the symbol name when doing an nlist search. NOLINEBUF: Unit: d_nolnbuf Wants: test cat rm Setvar Myread Optional: cc This symbol, if defined, indicates that stdout is not buffered, so that the program can call setbuf() or setlinebuf() for efficiency. NORMSIG: Unit: d_normsig (Also defines jobslib) Wants: test Setvar Guess _a This symbol, if defined, indicates that normal signal handling routines should be used, as opposed to the ones in 4.1bsd (sigset, etc.). NO_TIME_WITH_SYS_TIME: Obsoleted by I_SYS_TIME. NTOHL: Obsoleted by HAS_NTOHL. NTOHS: Obsoleted by HAS_NTOHS. NXT_ARG: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to separate arguments in the declared argument list. ODBM: Obsoleted by I_DBM. OLDSOCKET: Obsoleted by USE_OLDSOCKET. OPEN3: Obsoleted by HAS_OPEN3. ORGDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the organization. ORGNAME: Unit: orgname Wants: sed cat Myread Loc Oldconfig This symbol contains either the organizaton name or the full pathname of a file containing the organization name, which the program must be prepared to open and substitute the contents of. OS2_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under an OS/2 system. OSNAME: Unit: Oldconfig (Also defines hint myuname osname osvers) Wants: Instruct Myread Checkcc Mksymlinks Loc Options Tr src trnl ln uname sh awk sed test cat grep rm lns tr n c contains targetarch This symbol contains the name of the operating system, as determined by Configure. You shouldn't rely on it too much; the specific feature tests from Configure are generally more reliable. OSVERS: Unit: Oldconfig (Also defines hint myuname osname osvers) Wants: Instruct Myread Checkcc Mksymlinks Loc Options Tr src trnl ln uname sh awk sed test cat grep rm lns tr n c contains targetarch This symbol contains the version of the operating system, as determined by Configure. You shouldn't rely on it too much; the specific feature tests from Configure are generally more reliable. Off_t: Unit: lseektype Wants: Myread Typedef This symbol holds the type used to declare offsets in the kernel. It can be int, long, off_t, etc... It may be necessary to include to get any typedef'ed information. P: Obsoleted by _. PACKAGE: Unit: package (Also defines spackage) Wants: Nothing This variable contains the name of the package being built. PACKAGE_SOURCE_DIR: Unit: pkgsrc Wants: src rsrc Holds the directory name holding the package source. PAGESIZE_VALUE: Unit: d_getpagsz (Also defines pagesize) Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr Optional: cc ccflags This symbol holds the size in bytes of a system page (obtained via the getpagesize() system call at configuration time or asked to the user if the system call is not available). PAGSIZE: Obsoleted by PAGESIZE_VALUE. PASSNAMES: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This symbol, if defined, indicates that full names are stored in the /etc/passwd file. PERLPATH: Unit: perlpath Wants: Getfile Oldconfig Loc perl This symbol contains the absolute location of the perl interpeter. PERSISTENT_SIGNAL: Obsoleted by SIGNALS_KEPT. PHOSTNAME: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This symbol, if defined, indicates that the C program may use the contents of PHOSTNAME as a command to feed to the popen() routine to derive the host name. See also HAS_GETHOSTNAME and HAS_UNAME. Note that the command uses a fully qualified path, so that it is safe even if used by a process with super-user privileges. PIDCHECK: Unit: d_pidcheck Wants: cat rm _o Optional: cc This symbol, if defined, means that the kill(pid, 0) will check for an active pid (i.e. the kernel will run all the necessary pid checks, but no signal is actually sent). PIDTYPE: Obsoleted by Pid_t. POPEN: Obsoleted by HAS_POPEN. PORTABLE: Unit: d_portable Wants: cat Loc Myread Oldconfig This symbol, if defined, indicates to the C program that it should not assume that it is running on the machine it was compiled on. The program should be prepared to look up the host name, translate generic filenames, use PATH, etc. PORTAR: Unit: d_PORTAR Wants: cat rm Setvar Optional: cc This manifest constant must be defined to 1 for some implementations of ar.h to get the portable ar most everybody uses. PREFSHELL: Unit: prefshell Wants: cat package Getfile Oldconfig ksh csh bash This symbol contains the full name of the preferred user shell on this system. Usual values are /bin/csh, /bin/ksh, /bin/sh. PRIVLIB: Unit: privlib (Also defines privlibexp installprivlib) Wants: afs package cat Getfile Oldconfig Prefixit test This symbol contains the name of the private library for this package. The library is private in the sense that it needn't be in anyone's execution path, but it should be accessible by the world. The program should be prepared to do ~ expansion. PRIVLIB_EXP: Unit: privlib (Also defines privlibexp installprivlib) Wants: afs package cat Getfile Oldconfig Prefixit test This symbol contains the ~name expanded version of PRIVLIB, to be used in programs that are not prepared to deal with ~ expansion at run-time. PSIGNAL: Obsoleted by HAS_PSIGNAL. PTRSIZE: Unit: ptrsize Wants: cat rm Myread Optional: cc ccflags This symbol contains the size of a pointer, so that the C preprocessor can make decisions based on it. PWAGE: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_age. PWCHANGE: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_change. PWCLASS: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_class. PWCOMMENT: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_comment. PWEXPIRE: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_expire. PWQUOTA: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This symbol, if defined, indicates to the C program that struct passwd contains pw_quota. P_FUNC: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to declare "private" (static) functions. It takes three arguments: the function type and name, a parenthesized traditional (comma separated) argument list, and the declared argument list (in which arguments are separated with NXT_ARG, and additional arbitrary arguments are specified with DOTS). For example: P_FUNC(int foo, (bar, baz), int bar NXT_ARG char *baz[]) P_FUNC_VOID: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to declare "private" (static) functions that have no arguments. The macro takes one argument: the function type and name. For example: P_FUNC_VOID(int subr) Pid_t: Unit: pidtype Wants: Myread Typedef This symbol holds the type used to declare process ids in the kernel. It can be int, uint, pid_t, etc... It may be necessary to include to get any typedef'ed information. RANDBITS: Unit: randbits Wants: cat rm Myread cc i_unistd i_stdlib This symbol contains the number of bits of random number the rand() function produces. Usual values are 15, 16, and 31. RASTER_TEK: Unit: d_raster (Also defines rasterlib) Wants: cat test Setvar Myread Oldconfig Defined if this is a rastertech machine. RDCHK: Obsoleted by HAS_RDCHK. RD_NODATA: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This symbol holds the return code from read() when no data is present on the non-blocking file descriptor. Be careful! If EOF_NONBLOCK is not defined, then you can't distinguish between no data and EOF by issuing a read(). You'll have to find another way to tell for sure! READDIR: Obsoleted by HAS_READDIR. RECOMP: Obsoleted by HAS_RECOMP. REGCMP: Obsoleted by HAS_REGCMP. REGCOMP: Obsoleted by HAS_REGCOMP. RENAME: Obsoleted by HAS_RENAME. RMDIR: Obsoleted by HAS_RMDIR. ROOTID: Unit: rootid Wants: sed This symbol contains the uid of root, normally 0. ROOT_CHOWN: Obsoleted by SU_CHOWN. RUSAGE: Obsoleted by HAS_GETRUSAGE. SAFE_BCOPY: Obsoleted by HAS_SAFE_BCOPY. SAFE_MEMCPY: Obsoleted by HAS_SAFE_MEMCPY. SBRKTYPE: Obsoleted by Caddr_t. SCAN_NL: Unit: d_scannl Wants: cat rm Setvar Optional: cc ccflags This symbol is defined if the C library routines scanf() and friends can deal with a '\n' in the input correctly, so that you can say scanf("%d\n"); instead of scanf("%d"); getc(c); to handle the '\n'. SCAT2: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 2 tokens together and stringifies the result. SCAT3: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 3 tokens together and stringifies the result. SCAT4: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 4 tokens together and stringifies the result. SCAT5: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro catenates 5 tokens together and stringifies the result. SCOREFULL: Unit: d_scorfl Wants: cat Myread Oldconfig nametype Setvar This symbol, if defined, indicates that any scoreboard kept by the program should be kept on the basis of the user's full name as opposed to the user's login name. If the user can change his full name he can enter multiple scores if this is defined. SCRIPTDIR: Unit: scriptdir (Also defines scriptdirexp installscript) Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup Optional: bin This symbol holds the name of the directory in which the user wants to put publicly executable scripts for the package in question. It is often a directory that is mounted across diverse architectures. Programs must be prepared to deal with ~name expansion. SCRIPTDIR_EXP: Unit: scriptdir (Also defines scriptdirexp installscript) Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup Optional: bin This is the same as SCRIPTDIR, but is filename expanded at configuration time, for use in programs not prepared to do ~name substitutions at run-time. SERVE_INET_TCP: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to enable InterNet-domain TCP support for IPC. SERVE_INET_UDP: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to enable InterNet-domain UDP support for IPC. SERVE_MSG: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to use USG message queues for IPC. SERVE_SHM: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to use USG shared memory for IPC. SERVE_UNIX_TCP: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to enable Unix-domain TCP support for IPC. SERVE_UNIX_UDP: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem If defined, tells the C program to enable Unix-domain UDP support for IPC. SETEGID: Obsoleted by HAS_SETEGID. SETEUID: Obsoleted by HAS_SETEUID. SETPGRP: Obsoleted by HAS_SETPGRP. SETPGRP2: Obsoleted by HAS_SETPGRP2. SETPRIORITY: Obsoleted by HAS_SETPRIORITY. SETREGID: Obsoleted by HAS_SETREGID. SETRESGID: Obsoleted by HAS_SETRESGID. SETRESUID: Obsoleted by HAS_SETRESUID. SETREUID: Obsoleted by HAS_SETREUID. SETRGID: Obsoleted by HAS_SETRGID. SETRUID: Obsoleted by HAS_SETRUID. SETUID_SCRIPTS_ARE_SECURE_NOW: Unit: d_dosuid (Also defines d_suidsafe) Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package hint This symbol, if defined, indicates that the bug that prevents setuid scripts from being secure is not present in this kernel. SHMLBA_WANTS_IMMU: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags This value tells us to include because SHMLBA needs something from there, probably the stob() macro. (tower_600 only?) SHMLBA_WANTS_PARAM: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags This value tells us to include because SHMLBA needs something from there, probably the NBPC constant. SHMLBA_WANTS_SEG: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags This value tells us to include because SHMLBA needs something from there, probably the SNUMSHFT constant. SHMLBA_WANTS_SYSMACROS: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags This value tells us to include because SHMLBA needs something from there, probably the ctob() macro. SHORTSIZE: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This symbol contains the value of sizeof(short) so that the C preprocessor can make decisions based on it. SH_PATH: Unit: sh Wants: Head This symbol contains the full pathname to the shell used on this on this system to execute Bourne shell scripts. Usually, this will be /bin/sh, though it's possible that some systems will have /bin/ksh, /bin/pdksh, /bin/ash, /bin/bash, or even something such as D:/bin/sh.exe. SIGINTRP: Obsoleted by HAS_SIGINTRP. SIGNALS_KEPT: Unit: d_keepsig Wants: cat Compile rm Guess contains echo n c Setvar run This symbol is defined if signal handlers needn't be reinstated after receipt of a signal. SIGNAL_T: Obsoleted by Signal_t. SIGNEDCHAR: Unit: d_sgndchr Wants: cat rm Setvar Optional: cc ccflags This symbol, if defined, indicates that characters are a signed type. If not defined, things declared as signed characters (and that make use of negative values) should probably be declared as shorts instead. SIGSETMASK: Obsoleted by HAS_SIGSETMASK. SIGVEC: Obsoleted by HAS_SIGVEC. SIGVECTOR: Obsoleted by HAS_SIGVECTOR. SIG_COUNT: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable contains a number larger than the largest signal number. This is usually the same as the NSIG macro. SIG_NAME: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This symbol contains a list of signal names in order of signal number. This is intended to be used as a static array initialization, like this: char *sig_name[] = { SIG_NAME }; The signals in the list are separated with commas, and each signal is surrounded by double quotes. There is no leading SIG in the signal name, i.e. SIGQUIT is known as "QUIT". Gaps in the signal numbers (up to NSIG) are filled in with NUMnn, etc., where nn is the actual signal number (e.g. NUM37). The signal number for sig_name[i] is stored in sig_num[i]. The last element is 0 to terminate the list with a NULL. This corresponds to the 0 at the end of the sig_num list. SIG_NUM: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This symbol contains a list of signal numbers, in the same order as the SIG_NAME list. It is suitable for static array initialization, as in: int sig_num[] = { SIG_NUM }; The signals in the list are separated with commas, and the indices within that list and the SIG_NAME list match, so it's easy to compute the signal name from a number or vice versa at the price of a small dynamic linear lookup. Duplicates are allowed, but are moved to the end of the list. The signal number corresponding to sig_name[i] is sig_number[i]. if (i < NSIG) then sig_number[i] == i. The last element is 0, corresponding to the 0 at the end of the sig_name list. SIG_SIZE: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable contains the number of elements of the sig_name and sig_num arrays, excluding the final NULL entry. SITEARCH: Unit: sitearch (Also defines sitearchexp installsitearch) Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib This symbol contains the name of the private library for this package. The library is private in the sense that it needn't be in anyone's execution path, but it should be accessible by the world. The program should be prepared to do ~ expansion. The standard distribution will put nothing in this directory. Individual sites may place their own extensions and modules in this directory. SITEARCH_EXP: Unit: sitearch (Also defines sitearchexp installsitearch) Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib This symbol contains the ~name expanded version of SITEARCH, to be used in programs that are not prepared to deal with ~ expansion at run-time. SITELIB: Unit: sitelib (Also defines sitelibexp installsitelib) Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed This symbol contains the name of the private library for this package. The library is private in the sense that it needn't be in anyone's execution path, but it should be accessible by the world. The program should be prepared to do ~ expansion. The standard distribution will put nothing in this directory. Individual sites may place their own extensions and modules in this directory. SITELIB_EXP: Unit: sitelib (Also defines sitelibexp installsitelib) Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed This symbol contains the ~name expanded version of SITELIB, to be used in programs that are not prepared to deal with ~ expansion at run-time. SOCKET: Obsoleted by HAS_SOCKET. SOCKETPAIR: Obsoleted by HAS_SOCKETPAIR. SPEEDOVERMEM: Obsoleted by SPEED_OVER_MEM. SPEED_OVER_MEM: Unit: d_speedopt Wants: Myread Cppsym Oldconfig cat models Setvar This symbol, if defined, indicates that the program can use more memory in order to reduce CPU time. The symbol doesn't say whether we are more interested in saving text space or data space. SSize_t: Unit: ssizetype Wants: Myread Typedef sizetype cat rm _o Optional: cc optimize ccflags ldflags libs This symbol holds the type used by functions that return a count of bytes or an error condition. It must be a signed type. It is usually ssize_t, but may be long or int, etc. It may be necessary to include or to get any typedef'ed information. We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). STARTPERL: Unit: startperl Wants: cat rm sharpbang perlpath d_portable Myread This symbol is the string that should be put on the front of a perl script to make sure (hopefully) that it runs with perl and not under some shell. That line should be followed by the classical invocation magic: eval 'exec perl -S $0 ${1+"$@"}' if $running_under_some_shell; to guarantee perl startup should the shell execute the script at first. STAT: Obsoleted by HAS_STAT. STATBLOCKS: Obsoleted by USE_STAT_BLOCKS. STATEDIST: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This symbol contains the distribution name for the news system that restricts article distribution to the state or province. STAT_MACROS_BROKEN: Unit: d_brokstat Wants: cat contains cppstdin cppminus rm Setvar Optional: cppflags This symbol, if defined, indicates that the S_IS*() stat macros such as S_ISBLK() give false positive and are thus unusable. Your best bet is then to supply your own set. STDCHAR: Unit: stdchar Wants: contains Findhdr cppstdin cppminus rm This symbol is defined to be the type of char used in stdio.h. It has the values "unsigned char" or "char". STDIO_CNT_LVALUE: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This symbol is defined if the FILE_cnt macro can be used as an lvalue. STDIO_PTR_LVALUE: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This symbol is defined if the FILE_ptr macro can be used as an lvalue. STDSTDIO: Obsoleted by USE_STDIO_PTR. STRCSPN: Obsoleted by HAS_STRCSPN. STRERROR: Obsoleted by HAS_STRERROR. STRINGIFY: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This macro surrounds its token with double quotes. STRSTR: Obsoleted by HAS_STRSTR. STRTOD: Obsoleted by HAS_STRTOD. STRTOK: Obsoleted by HAS_STRTOK. STRTOL: Obsoleted by HAS_STRTOL. STRTOUL: Obsoleted by HAS_STRTOUL. STRUCTCOPY: Obsoleted by USE_STRUCT_COPY. SUNSCANF: Unit: sunscanf Wants: cat rm Myread test Setvar Optional: cc ccflags This variable is set if this system runs with the Sun version of scanf. SU_CHOWN: Unit: d_su_chown Wants: Csym Setvar This symbol, if defined, indicates that the system allows only root can change the owner of a file with chown(). SYMLINK: Obsoleted by HAS_SYMLINK. SYSCALL: Obsoleted by HAS_SYSCALL. SYSERRLIST: Obsoleted by HAS_SYS_ERRLIST. SYSERRNOLIST: Obsoleted by HAS_SYS_ERRNOLIST. SYSTEM: Obsoleted by HAS_SYSTEM. SYS_SIGLIST: Obsoleted by HAS_SYS_SIGLIST. S_SHM_ATT: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This symbol holds the default "place" to attach shared memory. Values are "HIGH", "ZERO", and "LOW". S_SHM_FOR: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This symbol identifies what we chose for the target system's default shared memory configuration parameters. S_SHM_LIM: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This symbol holds the default upper bound address limit if shared memory is attached HIGH. If zero, there is no upper limit. Select_fd_set_t: Unit: selecttype Wants: cat rm Oldconfig Myread d_fd_set d_select d_socket i_systime i_sysselct Optional: cc ccflags This symbol holds the type used for the 2nd, 3rd, and 4th arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET is defined, and 'int *' otherwise. This is only useful if you have select(), of course. Shmat_t: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This symbol holds the return type of the shmat() system call. Usually set to 'void *' or 'char *'. Sigjmp_buf: Unit: d_sigsetjmp Wants: Setvar cat libs rm Optional: cc ccflags ldflags This is the buffer type to be used with Sigsetjmp and Siglongjmp. Siglongjmp: Unit: d_sigsetjmp Wants: Setvar cat libs rm Optional: cc ccflags ldflags This macro is used in the same way as siglongjmp(), but will invoke traditional longjmp() if siglongjmp isn't available. See HAS_SIGSETJMP. Signal_t: Unit: d_voidsig (Also defines signal_t) Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar Findhdr Optional: cppflags This symbol's value is either "void" or "int", corresponding to the appropriate return type of a signal handler. Thus, you can declare a signal handler using "Signal_t (*handler)()", and define the handler using "Signal_t handler(sig)". Sigsetjmp: Unit: d_sigsetjmp Wants: Setvar cat libs rm Optional: cc ccflags ldflags This macro is used in the same way as sigsetjmp(), but will invoke traditional setjmp() if sigsetjmp isn't available. See HAS_SIGSETJMP. Size_t: Unit: sizetype Wants: Myread Typedef This symbol holds the type used to declare length parameters for string functions. It is usually size_t, but may be unsigned long, int, etc. It may be necessary to include to get any typedef'ed information. Strerror: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This preprocessor symbol is defined as a macro if strerror() is not available to translate error numbers to strings but sys_errlist[] array is there. TEXTCAN: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile Tells path to where the textcan.ps stuff is... TIMER: Obsoleted by HAS_TIME. TIMES: Obsoleted by HAS_TIMES. TIMETYPE: Obsoleted by Time_t. TMINSYS: Obsoleted by TM_IN_SYS. TM_IN_SYS: Unit: d_tminsys Wants: contains Setvar Findhdr This symbol is defined if this system declares "struct tm" in in rather than . We can't just say -I/usr/include/sys because some systems have both time files, and the -I trick gets the wrong one. TRUNCATE: Obsoleted by HAS_TRUNCATE. TZ_MINUTESWEST: Unit: d_tzmin Wants: contains cppstdin cppminus timeincl rm Setvar Guess This symbol is defined if this system uses tz_minuteswest in time header instead of timezone. If not defined, you may have to use struct timeb and ftime() rather than the new gettimeofday() system call. Time_t: Unit: d_time (Also defines timetype) Wants: Csym Setvar Findhdr Myread Typedef This symbol holds the type returned by time(). It can be long, or time_t on BSD sites (in which case should be included). UIDTYPE: Obsoleted by Uid_t. ULIMIT: Obsoleted by HAS_ULIMIT. UNAME: Obsoleted by HAS_UNAME. UNION_WAIT: Unit: d_uwait (Also defines d_uwait3) Wants: cat contains cppstdin cppminus rm Setvar Findhdr Optional: cppflags This symbol if defined indicates to the C program that the argument for the wait() system call should be declared as 'union wait status' instead of 'int status'. You probably need to include in the former case (see I_SYSWAIT). UNION_WAIT3: Unit: d_uwait (Also defines d_uwait3) Wants: cat contains cppstdin cppminus rm Setvar Findhdr Optional: cppflags This symbol if defined indicates to the C program that the first argument for the wait3() system call should be declared as 'union wait status' instead of 'int status'. You probably need to include in the former case (see I_SYSWAIT). It seems safe to assume that the same rule applies to the second parameter of wait4(). USENDIR: Obsoleted by EMULATE_NDIR. USE_BSDJMP: Unit: d_bsdjmp Wants: Guess Setvar cat libs rm Optional: cc This symbol, if defined, indicates that the BSD _setjmp and _longjmp routines are available to do non-local gotos wihtout saving or restoring the signal mask flag. USE_BSDPGRP: Obsoleted by USE_BSD_SETPGRP. USE_BSD_GETPGRP: Unit: d_getpgrp (Also defines d_bsdgetpgrp) Wants: Guess Inlibc Setvar cat rm i_unistd Optional: cc ccflags ldflags libs This symbol, if defined, indicates that getpgrp needs one arguments whereas USG one needs none. USE_BSD_SETPGRP: Unit: d_setpgrp (Also defines d_bsdsetpgrp) Wants: cat rm Inlibc Guess Setvar i_unistd Optional: cc libs ccflags ldflags This symbol, if defined, indicates that setpgrp needs two arguments whereas USG one needs none. See also HAS_SETPGID for a POSIX interface. USE_CHAR_VSPRINTF: Unit: d_vprintf (Also defines d_charvspr) Wants: Guess cat Csym Setvar Optional: cc ccflags This symbol is defined if this system has vsprintf() returning type (char*). The trend seems to be to declare it as "int vsprintf()". It is up to the package author to declare vsprintf correctly based on the symbol. USE_CROSS_COMPILE: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This symbol, if defined, indicates that the package is being cross-compiled. USE_INETD: Unit: d_inetd Wants: cat test package Myread Setvar This symbol if defined indicates to the C program that inetd will be in charge of the initial socket connection. The file descriptors 0 and 1 have been dup()ed from the original connected socket descriptor and are ready for send() and recv(). USE_LINUX_STDIO: Unit: d_linuxstd Wants: d_stdstdio cppstdin cppflags cppminus contains rm Setvar Findhdr This symbol is defined if this system has a FILE structure declaring _IO_read_base, _IO_read_ptr, and _IO_read_end in stdio.h. USE_OLDSOCKET: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This symbol, if defined, indicates that the 4.1c BSD socket interface is supported instead of the 4.2/4.3 BSD socket interface. For instance, there is no setsockopt() call. USE_SOCKS: Unit: usesocks Wants: Myread Oldconfig Setvar spackage package This symbol, if defined, indicates that Perl should be built to use socks. USE_STAT_BLOCKS: Unit: d_statblks Wants: contains Setvar Findhdr This symbol is defined if this system has a stat structure declaring st_blksize and st_blocks. USE_STDIO_BASE: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This symbol is defined if the _base field (or similar) of the stdio FILE structure can be used to access the stdio buffer for a file handle. If this is defined, then the FILE_base(fp) macro will also be defined and should be used to access this field. Also, the FILE_bufsiz(fp) macro will be defined and should be used to determine the number of bytes in the buffer. USE_STDIO_BASE will never be defined unless USE_STDIO_PTR is. USE_STDIO_PTR: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This symbol is defined if the _ptr and _cnt fields (or similar) of the stdio FILE structure can be used to access the stdio buffer for a file handle. If this is defined, then the FILE_ptr(fp) and FILE_cnt(fp) macros will also be defined and should be used to access these fields. USE_STD_STDIO: Obsoleted by USE_STDIO_PTR. USE_STRUCT_COPY: Unit: d_strctcpy Wants: cat rm cc Setvar This symbol, if defined, indicates that this C compiler knows how to copy structures. If undefined, you'll need to use a block copy routine of some sort instead. USE_SYS_TIME_H: Obsoleted by I_SYS_TIME. USE_TIME_H: Obsoleted by I_TIME. USE_TIOCNOTTY: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This symbol, if defined indicate to the C program that the ioctl() call with TIOCNOTTY should be used to void tty association. Otherwise (on USG probably), it is enough to close the standard file decriptors and do a setpgrp(). USE_WIFSTAT: Unit: d_wifstat Wants: d_uwait Oldconfig cat rm Optional: cc ccflags ldflags libs This symbol, if defined, indicates to the C program that the argument for the WIFxxx set of macros such as WIFSIGNALED or WIFEXITED can be of the same kind as the one used to hold the wait() status. Should only matter on HP-UX, where the macros are incorrectly written and therefore cause programs using them with an 'union wait' variable to not compile properly. See also UNION_WAIT. USGNAMES: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This symbol, if defined, indicates that full names are stored in the /etc/passwd file in USG format (everything after - and before ( is the name). USLEEP: Obsoleted by HAS_USLEEP. Uid_t: Unit: uidtype Wants: Myread Typedef Findhdr This symbol holds the type used to declare user ids in the kernel. It can be int, ushort, uid_t, etc... It may be necessary to include to get any typedef'ed information. VAL_EAGAIN: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This symbol holds the errno error code set by read() when no data was present on the non-blocking file descriptor. VAL_NOFILE: Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize) Wants: Myread Guess cat test rm Csym Optional: cc ccflags libs This symbol contains the number of file descriptors available to the process, as determined at configuration time. Unless a static constant is needed, you should rely on getdtablesize() to obtain that number. VAL_O_NONBLOCK: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This symbol is to be used during open() or fcntl(F_SETFL) to turn on non-blocking I/O for the file descriptor. Note that there is no way back, i.e. you cannot turn it blocking again this way. If you wish to alternatively switch between blocking and non-blocking, use the ioctl(FIOSNBIO) call instead, but that is not supported by all devices. VFORK: Obsoleted by HAS_VFORK. VMS: Obsoleted by VMS_SYSTEM. VMS_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under VMS. It is currently only set in conjunction with the EUNICE symbol. VOIDFLAGS: Unit: voidflags (Also defines defvoidused) Wants: cat sed rm contains package Oldconfig Myread Optional: cc ccflags This symbol indicates how much support of the void type is given by this compiler. What various bits mean: 1 = supports declaration of void 2 = supports arrays of pointers to functions returning void 4 = supports comparisons between pointers to void functions and addresses of void functions 8 = suports declaration of generic void pointers The package designer should define VOIDUSED to indicate the requirements of the package. This can be done either by #defining VOIDUSED before including config.h, or by defining defvoidused in Myinit.U. If the latter approach is taken, only those flags will be tested. If the level of void support necessary is not present, defines void to int. VOIDSIG: Unit: d_voidsig (Also defines signal_t) Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar Findhdr Optional: cppflags This symbol is defined if this system declares "void (*signal(...))()" in signal.h. The old way was to declare it as "int (*signal(...))()". It is up to the package author to declare things correctly based on the symbol. VOIDTTY: Obsoleted by USE_TIOCNOTTY. VOID_CLOSEDIR: Unit: d_closedir (Also defines d_void_closedir) Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs Setvar rm This symbol, if defined, indicates that the closedir() routine does not return a value. VPRINTF: Obsoleted by HAS_VPRINTF. V_FUNC: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to declare "public" (non-static) functions. It takes three arguments: the function type and name, a parenthesized traditional (comma separated) argument list, and the declared argument list (in which arguments are separated with NXT_ARG, and additional arbitrary arguments are specified with DOTS). For example: V_FUNC(int main, (argc, argv), int argc NXT_ARG char *argv[]) V_FUNC_VOID: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to declare "public" (non-static) functions that have no arguments. The macro takes one argument: the function type and name. For example: V_FUNC_VOID(int fork) WAIT4: Obsoleted by HAS_WAIT4. WAITPID: Obsoleted by HAS_WAITPID. WCTOMB: Obsoleted by HAS_WCTOMB. WHOAMI: Obsoleted by I_WHOAMI. XDRS: Obsoleted by HAS_XDRS. XENIX: Obsoleted by XENIX_SYSTEM. XENIX_SYSTEM: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol, if defined, indicates that the program is running under Xenix (at least 3.0 ?). _: Unit: prototype Wants: Myread Oldconfig cat rm Setvar Optional: cc ccflags This macro is used to declare function parameters for folks who want to make declarations with prototypes using a different style than the above macros. Use double parentheses. For example: int main _((int argc, char *argv[])); _V: Unit: vaproto Wants: prototype i_stdarg Setvar This macro is used to declare function parameters in prototypes for functions with a variable number of parameters. Use double parentheses. For example: int printf _V((char *fmt, ...)); Remember to use the plain simple _() macro when declaring a function with no variable number of arguments, since it might be possible to have a non-effect _V() macro and still get prototypes via _(). _a: Unit: Unix (Also defines _a _o firstmakefile archobjs) Wants: Oldconfig This variable defines the extension used for ordinary libraries. For unix, it is '.a'. The '.' is included. Other possible values include '.lib'. _exe: Unit: Init (Also defines eunicefix _exe) Wants: Null This variable defines the extension used for executable files. For unix it is empty. Other possible values include '.exe'. DJGPP, Cygwin and OS/2 use '.exe'. Stratus VOS uses '.pm'. On operating systems which do not require a specific extension for executable files, this variable is empty. _o: Unit: Unix (Also defines _a _o firstmakefile archobjs) Wants: Oldconfig This variable defines the extension used for object files. For unix, it is '.o'. The '.' is included. Other possible values include '.obj'. abortsig: Unit: abortsig Wants: Myread Oldconfig Guess cat ccflags rm Optional: cc This variable holds the name of the signal used by the abort() call. active: Unit: active (Also defines activeexp) Wants: newslib Oldconfig Getfile The name of the active file for the news system. This file contains the list of active newsgroups. The name may have ~ on the front. The variable myactive is the expanded form. activeexp: Unit: active (Also defines activeexp) Wants: newslib Oldconfig Getfile This is the same as the active variable, but is filename expanded so that later Configure units can look at the active file if desired. afs: Unit: afs (Also defines afsroot) Wants: test This variable is set to 'true' if AFS (Andrew File System) is used on the system, 'false' otherwise. It is possible to override this with a hint value or command line option, but you'd better know what you are doing. afsroot: Unit: afs (Also defines afsroot) Wants: test This variable is by default set to '/afs'. In the unlikely case this is not the correct root, it is possible to override this with a hint value or command line option. This will be used in subsequent tests for AFSness in the configure and test process. alignbytes: Unit: alignbytes Wants: Myread cat cc ccflags rm This variable holds the number of bytes required to align a double. Usual values are 2, 4 and 8. aphostname: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc Thie variable contains the command which can be used to compute the host name. The command is fully qualified by its absolute path, to make it safe when used by a process with super-user privileges. archlib: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This variable holds the name of the directory in which the user wants to put architecture-dependent public library files for $package. It is most often a local directory such as /usr/local/lib. Programs using this variable must be prepared to deal with filename expansion. archlibexp: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This variable is the same as the archlib variable, but is filename expanded at configuration time, for convenient use. archname: Unit: archname (Also defines myarchname) Wants: sed Loc Myread Oldconfig osname test rm This variable is a short name to characterize the current architecture. It is used mainly to construct the default archlib. archobjs: Unit: Unix (Also defines _a _o firstmakefile archobjs) Wants: Oldconfig This variable defines any additional objects that must be linked in with the program on this architecture. On unix, it is usually empty. It is typically used to include emulations of unix calls or other facilities. For perl on OS/2, for example, this would include os2/os2.obj. baserev: Unit: baserev Wants: Null The base revision level of this package, from the .package file. basicshell: Unit: basicshell Wants: Getfile Oldconfig bash csh ksh sh This variable contains the eventual value of the BASICSHELL symbol, which contains the full name of the basic script shell on this system. Usual values are /bin/sh, /bin/ksh, /bin/csh. bcmp: Magic symbol, needs: HAS_BCMP Unit: d_bcmp Wants: Inlibc #ifndef HAS_BCMP #ifndef bcmp #define bcmp(s,d,l) memcmp((s),(d),(l)) #endif #endif bcopy: Magic symbol, needs: HAS_BCOPY Unit: d_bcopy Wants: Inlibc #ifndef HAS_BCOPY #ifndef bcopy #define bcopy(s,d,l) memcpy((d),(s),(l)) #endif #endif bin: Unit: bin (Also defines binexp installbin) Wants: Prefixit Getfile Oldconfig afs cat test This variable holds the name of the directory in which the user wants to put publicly executable images for the package in question. It is most often a local directory such as /usr/local/bin. Programs using this variable must be prepared to deal with ~name substitution. binexp: Unit: bin (Also defines binexp installbin) Wants: Prefixit Getfile Oldconfig afs cat test This is the same as the bin variable, but is filename expanded at configuration time, for use in your makefiles. bitpbyte: Unit: bitpbyte Wants: cat rm Myread Optional: cc ccflags This variable contains the value of the BITS_PER_BYTE symbol, which indicates to the C program how many bits there are in a byte. byteorder: Unit: byteorder Wants: cat Myread Oldconfig Loc rm Optional: cc ccflags This variable holds the byte order. In the following, larger digits indicate more significance. The variable byteorder is either 4321 on a big-endian machine, or 1234 on a little-endian, or 87654321 on a Cray ... or 3412 with weird order ! bzero: Magic symbol, needs: HAS_BZERO Unit: d_bzero Wants: Inlibc #ifndef HAS_BZERO #ifndef bzero #define bzero(s,l) memset((s),0,(l)) #endif #endif c: Unit: n (Also defines c) Wants: contains This variable contains the \c string if that is what causes the echo command to suppress newline. Otherwise it is null. Correct usage is $echo $n "prompt for a question: $c". castflags: Unit: d_castneg (Also defines castflags) Wants: cat rm Setvar signal_t Optional: cc ccflags This variable contains a flag that precise difficulties the compiler has casting odd floating values to unsigned long: 0 = ok 1 = couldn't cast < 0 2 = couldn't cast >= 0x80000000 4 = couldn't cast in argument expression list cc: Unit: cc Wants: Myread Oldconfig Checkcc test This variable holds the name of a command to execute a C compiler which can resolve multiple global references that happen to have the same name. Usual values are 'cc' and 'gcc'. Fervent ANSI compilers may be called 'c89'. AIX has xlc. ccflags: Unit: ccflags (Also defines ldflags lkflags cppflags optimize locincpth) Wants: test cat Myread Guess Options Oldconfig gccversion mips_type package contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint Optional: usrinc cc This variable contains any additional C compiler flags desired by the user. It is up to the Makefile to use this. ccname: Unit: Checkcc (Also defines ccname ccversion) Wants: Myread Warn startsh cat contains test This can set either by hints files or by Configure. If using gcc, this is gcc, and if not, usually equal to cc, unimpressive, no? Some platforms, however, make good use of this by storing the flavor of the C compiler being used here. For example if using the Sun WorkShop suite, ccname will be 'workshop'. ccsymbols: Unit: Cppsym (Also defines ccsymbols cppsymbols cppccsymbols) Wants: run eunicefix Guess awk cat tr sed sort rm startsh osname gccversion test comm uniq echo Options trnl optimize ccflags ldflags libs Optional: cc The variable contains the symbols defined by the C compiler alone. The symbols defined by cpp or by cc when it calls cpp are not in this list, see cppsymbols and cppccsymbols. The list is a space-separated list of symbol=value tokens. ccversion: Unit: Checkcc (Also defines ccname ccversion) Wants: Myread Warn startsh cat contains test This can set either by hints files or by Configure. If using a (non-gcc) vendor cc, this variable may contain a version for the compiler. cf_by: Unit: cf_who (Also defines cf_time cf_by) Wants: date Oldconfig Login name of the person who ran the Configure script and answered the questions. This is used to tag both config.sh and config_h.SH. cf_email: Unit: cf_email Wants: cat cf_by myhostname mydomain Oldconfig Myread Electronic mail address of the person who ran Configure. This can be used by units that require the user's e-mail, like MailList.U. cf_name: Unit: cf_name (With private cf_name) Wants: cf_by passcat Filexp nametype cat test Full name of the person who ran the Configure script and answered the questions. This can be used by units that require the user's full name. This variable is for internal use only. cf_time: Unit: cf_who (Also defines cf_time cf_by) Wants: date Oldconfig Holds the output of the "date" command when the configuration file was produced. This is used to tag both config.sh and config_h.SH. charoder: Obsoleted by chorder_int. charsize: Unit: charsize Wants: cat rm Myread Optional: cc ccflags This variable contains the value of the CHARSIZE symbol, which indicates to the C program how many bytes there are in a character. chorder_int: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the value describing the byte ordering of characters in an int. For instance, on a Big-Endian machine, this would be: "c0c1c2c3". chorder_long: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the value describing the byte ordering of characters in a long. On a 64 bits Big-Endian machine, that would yield: "c0c1c2c3c4c5c6c7". chorder_short: Unit: charorder (Also defines chorder_int chorder_short chorder_long) Wants: Myread cat rm Optional: cc ccflags Holds the value describing the byte ordering of characters in a short. On a Big-Endian machine, that would be "c0c1". citydist: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This variable contains the eventual value of the CITYDIST symbol, which is the city's distribution name for news. clocktype: Unit: d_times (Also defines clocktype) Wants: Csym Myread Typedef i_systimes This variable holds the type returned by times(). It can be long, or clock_t on BSD sites (in which case should be included). cntrydist: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This variable contains the eventual value of the CNTRYDIST symbol, which is the country's distribution name for news. compile: Unit: Compile Optional: cc optimize ccflags ldflags libs This shell variable is used internally by Configure to provide a convenient shorthand for the typical compile command, namely $cc $optimize $ccflags $ldflags -o $1 $1.c $libs > /dev/null 2>&1 Note that the output filename does _not_ include the _exe extension. Instead we assume that the linker will be "helpful" and automatically appending the correct suffix. OS/2 users will apparently need to supply the -Zexe flag to get this behavior. To use this variable, say something like: echo 'int main() { exit(0); }' > try.c set try if eval $compile; then echo "success" # and do whatever . . . else echo "failure" # and do whatever . . . fi To add extra flags cc flags (e.g. -DWHATEVER) just put them in $*, e.g. set try -DTRY_THIS_FLAG compile_ok: Unit: Compile Optional: cc optimize ccflags ldflags libs This shell variable is used internally by Configure to provide a convenient shorthand for the typical compile command that you expect to work ok. It is the same as $compile, except we deliberately let the user see any error messages. contains: Unit: contains Wants: Nothing This variable holds the command to do a grep with a proper return status. On most sane systems it is simply "grep". On insane systems it is a grep followed by a cat followed by a test. This variable is primarily for the use of other Configure units. contdist: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This variable contains the eventual value of the CONTDIST symbol, which is the continent's distribution name for news. cpp_quote: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This variable is set to either '"' or '' depending on whether the pre-processor pre-dates ANSI or not. It is used in the production of the SQuoTe() and EQuoTe() macros, and was introduced to overcome a bug in gcc 3.x whereby the pre-processor complained loudly about the unterminated strings. cpp_stuff: Unit: cpp_stuff (Also defines cpp_quote) Wants: cat contains cppstdin cppflags cppminus rm Warn package This variable contains an identification of the catenation mechanism used by the C preprocessor. cpp_trad: Unit: cpp_trad Wants: cpp cat contains rm This variable contains the program to run to get traditional C preprocessor semantics and not ISO C semantics: we want something that knows as little about C as possible to use as a more general purpose preprocessor. cppccsymbols: Unit: Cppsym (Also defines ccsymbols cppsymbols cppccsymbols) Wants: run eunicefix Guess awk cat tr sed sort rm startsh osname gccversion test comm uniq echo Options trnl optimize ccflags ldflags libs Optional: cc The variable contains the symbols defined by the C compiler when it calls cpp. The symbols defined by the cc alone or cpp alone are not in this list, see ccsymbols and cppsymbols. The list is a space-separated list of symbol=value tokens. cppfilecom: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This variable contains the first part of the string which will invoke the C preprocessor a file and produce to standard output, preserving comments. Typical value of "cc -E -C" or "/lib/cpp -C". cppflags: Unit: ccflags (Also defines ldflags lkflags cppflags optimize locincpth) Wants: test cat Myread Guess Options Oldconfig gccversion mips_type package contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint Optional: usrinc cc This variable holds the flags that will be passed to the C pre- processor. It is up to the Makefile to use it. cpplast: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This variable has the same functionality as cppminus, only it applies to cpprun and not cppstdin. cppminus: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This variable contains the second part of the string which will invoke the C preprocessor on the standard input and produce to standard output. This variable will have the value "-" if cppstdin needs a minus to specify standard input, otherwise the value is "". cpprun: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This variable contains the command which will invoke a C preprocessor on standard input and put the output to stdout. It is guaranteed not to be a wrapper and may be a null string if no preprocessor can be made directly available. This preprocessor might be different from the one used by the C compiler. Don't forget to append cpplast after the preprocessor options. cppstdin: Unit: cppstdin (Also defines cppminus cpprun cpplast) Wants: contains test Myread Oldconfig Loc cpp rm hint osname gccversion startsh eunicefix Optional: cc This variable contains the command which will invoke the C preprocessor on standard input and put the output to stdout. It is primarily used by other Configure units that ask about preprocessor symbols. cppstdinflags: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This variable contains any flags necessary to get cppfilecom to read from the standard input. cppsymbols: Unit: Cppsym (Also defines ccsymbols cppsymbols cppccsymbols) Wants: run eunicefix Guess awk cat tr sed sort rm startsh osname gccversion test comm uniq echo Options trnl optimize ccflags ldflags libs Optional: cc The variable contains the symbols defined by the C preprocessor alone. The symbols defined by cc or by cc when it calls cpp are not in this list, see ccsymbols and cppccsymbols. The list is a space-separated list of symbol=value tokens. cryptlib: Unit: d_crypt (Also defines cryptlib) Wants: Loc test xlibpth libpth Csym Setvar _a Inlibc This variable holds -lcrypt or the path to a libcrypt.a archive if the crypt() function is not defined in the standard C library. It is up to the Makefile to use this. csym: Unit: Csym Wants: Options contains libc libs runnm rm Optional: cc ccflags ldflags This shell variable is used internally by Configure to check wether a given C symbol is defined or not. A typical use is: set symbol result [-fva] [previous] eval $csym That will set result to 'true' if the function [-f], variable [-v] or array [-a] is defined, 'false' otherwise. If a previous value is given and the -r flag was provided on the command line, that value is reused without questioning. d_Gconvert: Unit: d_gconvert (Also defines d_Gconvert) Wants: cat cc ccflags ldflags libs Inlibc rm _o This variable holds what Gconvert is defined as to convert floating point numbers into strings. It could be 'gconvert' or a more complex macro emulating gconvert with gcvt() or sprintf. d_PORTAR: Unit: d_PORTAR Wants: cat rm Setvar Optional: cc This variable conditionally handles definition of PORTAR, a creation of greater minds than I can imagine. d_SHM_IMMU: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags Sometimes, the SHMLBA manifest needs sys/immu.h, usually for the stob() macro. d_SHM_MAC: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags Sometimes, the SHMLBA manifest needs sys/sysmacros.h, usually for the ctob() macro. d_SHM_PRM: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags Sometimes, the SHMLBA manifest needs sys/param.h, usually for the NBPC constant. d_SHM_SEG: Unit: d_SHM_MAC (Also defines d_SHM_PRM d_SHM_SEG d_SHM_IMMU) Wants: cat d_shm test rm Optional: cc ccflags Sometimes, the SHMLBA manifest needs sys/seg.h, usually for the SNUMSHFT constant. d_access: Unit: d_access Wants: test cat h_fcntl h_sysfile rm Inlibc Findhdr Optional: cc cppflags This variable conditionally defines HAS_ACCESS if the access() system call is available to check for access permissions using real IDs. d_alarm: Unit: d_alarm Wants: Inlibc This variable conditionally defines the HAS_ALARM symbol, which indicates to the C program that the alarm() routine is available. d_archlib: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This variable conditionally defines ARCHLIB to hold the pathname of architecture-dependent library files for $package. If $archlib is the same as $privlib, then this is set to undef. d_attrib: Obsoleted by d_attribut. d_attribut: Unit: d_attribut Wants: Myread Oldconfig cat cc ccflags rm Setvar contains This variable conditionally defines HASATTRIBUTE, which indicates the C compiler can check for function attributes, such as printf formats. d_bcmp: Unit: d_bcmp Wants: Inlibc This variable conditionally defines the HAS_BCMP symbol if the bcmp() routine is available to compare strings. d_bcopy: Unit: d_bcopy Wants: Inlibc This variable conditionally defines the HAS_BCOPY symbol if the bcopy() routine is available to copy strings. d_berknames: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This variable conditionally defines the PASSNAMES symbol, which indicates to the C program that full names are stored in the /etc/passwd file in Berkeley format. d_bol: Obsoleted by chorder_long. d_bos: Obsoleted by chorder_short. d_brokstat: Unit: d_brokstat Wants: cat contains cppstdin cppminus rm Setvar Optional: cppflags This variable conditionally defines STAT_MACROS_BROKEN if some of the S_IS*() macros from give false positive on regular files. d_bsd: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol conditionally defines the symbol BSD_SYSTEM when running on a BSD system. d_bsdgetpgrp: Unit: d_getpgrp (Also defines d_bsdgetpgrp) Wants: Guess Inlibc Setvar cat rm i_unistd Optional: cc ccflags ldflags libs This variable conditionally defines USE_BSD_GETPGRP if getpgrp needs one arguments whereas USG one needs none. d_bsdjmp: Unit: d_bsdjmp Wants: Guess Setvar cat libs rm Optional: cc This variable conditionally defines USE_BSDJMP if BSD _setjmp and _longjmp routines are available to do non-local gotos without saving or restoring the signal mask flag. d_bsdpgrp: Obsoleted by d_bsdsetpgrp. d_bsdsetpgrp: Unit: d_setpgrp (Also defines d_bsdsetpgrp) Wants: cat rm Inlibc Guess Setvar i_unistd Optional: cc libs ccflags ldflags This variable conditionally defines USE_BSD_SETPGRP if setpgrp needs two arguments whereas USG one needs none. See also d_setpgid for a POSIX interface. d_byacc: Unit: d_byacc Wants: byacc Setvar This variable indicates whether byacc is available. If the user has specified 'portability', then Makefile.SH sees $byacc='byacc' whether or not the user actually has byacc. This variable allows us to determine in a makefile if we really have byacc. d_bzero: Unit: d_bzero Wants: Inlibc This variable conditionally defines the HAS_BZERO symbol if the bzero() routine is available to set memory to 0. d_casti32: Unit: d_casti32 Wants: cat rm intsize Setvar test signal_t Optional: cc ccflags This variable conditionally defines CASTI32, which indicates whether the C compiler can cast large floats to 32-bit ints. d_castneg: Unit: d_castneg (Also defines castflags) Wants: cat rm Setvar signal_t Optional: cc ccflags This variable conditionally defines CASTNEG, which indicates wether the C compiler can cast negative float to unsigned. d_cbrt: Unit: d_cbrt Wants: Inlibc This variable conditionally defines the CBRT symbol, which indicates to the C program that the cbrt() (cube root) function is available. d_charsprf: Unit: d_charsprf Wants: cat rm Setvar Optional: cc This variable conditionally defines CHARSPRINTF if this system declares "char *sprintf()" in stdio.h. The trend seems to be to declare it as "int sprintf()". d_charvspr: Unit: d_vprintf (Also defines d_charvspr) Wants: Guess cat Csym Setvar Optional: cc ccflags This variable conditionally defines CHARVSPRINTF if this system has vsprintf returning type (char*). The trend seems to be to declare it as "int vsprintf()". d_chown: Unit: d_chown Wants: Inlibc This variable conditionally defines the HAS_CHOWN symbol, which indicates to the C program that the chown() routine is available. d_chroot: Unit: d_chroot Wants: Inlibc This variable conditionally defines the HAS_CHROOT symbol, which indicates to the C program that the chroot() routine is available. d_chsize: Unit: d_chsize Wants: Inlibc This variable conditionally defines the CHSIZE symbol, which indicates to the C program that the chsize() routine is available to truncate files. You might need a -lx to get this routine. d_ckeypad: Unit: d_ckeypad Wants: cat cc termlib Setvar This variable controls the definition of HAS_CURSES_KEYPAD, which tells the application that the keypad() curses function is available. d_closedir: Unit: d_closedir (Also defines d_void_closedir) Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs Setvar rm This variable conditionally defines HAS_CLOSEDIR if closedir() is available. d_col: Obsoleted by chorder_long. d_const: Unit: d_const Wants: cat rm cc ccflags Setvar This variable conditionally defines the HASCONST symbol, which indicates to the C program that this C compiler knows about the const type. d_cos: Obsoleted by chorder_short. d_cppcanstdin: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This symbol conditionally defines CPP_CAN_STDIN if CPP_FILE_COM can read standard input directly. d_cppignhdrs: Unit: cppfilecom (Also defines cppstdinflags d_cppignhdrs d_cppcanstdin) Wants: contains package test Myread Oldconfig Loc Setvar cpp cc cat rm This symbol conditionally defines CPP_IGN_HDRS if CPP_FILE_COM ignores *.h files. d_crypt: Unit: d_crypt (Also defines cryptlib) Wants: Loc test xlibpth libpth Csym Setvar _a Inlibc This variable conditionally defines the CRYPT symbol, which indicates to the C program that the crypt() routine is available to encrypt passwords and the like. d_csh: Unit: d_csh (Also defines full_csh) Wants: csh Setvar This variable conditionally defines the CSH symbol, which indicates to the C program that the C-shell exists. d_ctermid: Unit: d_ctermid Wants: Inlibc This variable conditionally defines CTERMID if ctermid() is available to generate filename for terminal. d_cuserid: Unit: d_cuserid Wants: Inlibc This variable conditionally defines the HAS_CUSERID symbol, which indicates to the C program that the cuserid() routine is available to get character login names. d_dbl_dig: Unit: d_dbl_dig Wants: Myread contains cat rm Setvar i_limits i_float cppstdin cppflags cppminus This variable conditionally defines d_dbl_dig if this system's header files provide DBL_DIG, which is the number of significant digits in a double precision number. d_difftime: Unit: d_difftime Wants: Inlibc This variable conditionally defines the HAS_DIFFTIME symbol, which indicates to the C program that the difftime() routine is available. d_dirnamlen: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This variable conditionally defines DIRNAMLEN, which indicates to the C program that the length of directory entry names is provided by a d_namelen field. d_dlerror: Unit: d_dlerror Wants: Inlibc runnm This variable conditionally defines the HAS_DLERROR symbol, which indicates to the C program that the dlerror() routine is available. d_dlopen: Unit: d_dlopen Wants: Inlibc runnm This variable conditionally defines the HAS_DLOPEN symbol, which indicates to the C program that the dlopen() routine is available. d_dos: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol conditionally defines the symbol DOS_SYSTEM when running on DOS with DJGPP or Cygwin. d_dosuid: Unit: d_dosuid (Also defines d_suidsafe) Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package hint This variable conditionally defines the symbol DOSUID, which tells the C program that it should insert setuid emulation code on hosts which have setuid #! scripts disabled. d_drem: Unit: d_drem Wants: Inlibc This variable conditionally defines the HAS_DREM symbol, which indicates to the C program that the drem() routine is available. d_dup2: Unit: d_dup2 Wants: Inlibc This variable conditionally defines HAS_DUP2 if dup2() is available to duplicate file descriptors. d_eofnblk: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This variable conditionally defines EOF_NONBLOCK if EOF can be seen when reading from a non-blocking I/O source. d_eofpipe: Unit: d_eofpipe Wants: cat rm Oldconfig Guess echo n c Optional: cc ccflags libs This variable conditionally defines the EOFPIPE symbol, which indicates to the C program that select will correctly detect the EOF condition when pipe is closed from the other end. d_euc2jis: Unit: d_euc2jis Wants: Inlibc This variable conditionally defines the HAS_EUC2JIS symbol, which indicates to the C program that the euc2jis() routine is available to convert EUC to JIS. d_eunice: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This variable conditionally defines the symbols EUNICE_SYSTEM, which alerts the C program that it must deal with ideosyncracies of VMS. d_fchmod: Unit: d_fchmod Wants: Inlibc This variable conditionally defines the HAS_FCHMOD symbol, which indicates to the C program that the fchmod() routine is available to change mode of opened files. d_fchown: Unit: d_fchown Wants: Inlibc This variable conditionally defines the HAS_FCHOWN symbol, which indicates to the C program that the fchown() routine is available to change ownership of opened files. d_fcntl: Unit: d_fcntl Wants: Inlibc This variable conditionally defines the HAS_FCNTL symbol, and indicates whether the fcntl() function exists d_fd_macros: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This variable contains the eventual value of the HAS_FD_MACROS symbol, which indicates if your C compiler knows about the macros which manipulate an fd_set. d_fd_set: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This variable contains the eventual value of the HAS_FD_SET symbol, which indicates if your C compiler knows about the fd_set typedef. d_fds_bits: Unit: d_fd_set (Also defines d_fd_macros d_fds_bits) Wants: cat rm Oldconfig d_socket i_systime i_sysselct Optional: cc ccflags This variable contains the eventual value of the HAS_FDS_BITS symbol, which indicates if your fd_set typedef contains the fds_bits member. If you have an fd_set typedef, but the dweebs who installed it did a half-fast job and neglected to provide the macros to manipulate an fd_set, HAS_FDS_BITS will let us know how to fix the gaffe. d_ffs: Unit: d_ffs Wants: Inlibc This variable conditionally defines the HAS_FFS symbol, which indicates to the C program that the ffs() routine is available to find the first bit which is set in its integer argument. d_fgetpos: Unit: d_fgetpos Wants: Inlibc This variable conditionally defines HAS_FGETPOS if fgetpos() is available to get the file position indicator. d_flexfnam: Unit: d_flexfnam Wants: cat rm test Setvar This variable conditionally defines the FLEXFILENAMES symbol, which indicates that the system supports filenames longer than 14 characters. d_flock: Unit: d_flock Wants: Inlibc This variable conditionally defines HAS_FLOCK if flock() is available to do file locking. d_fmod: Unit: d_fmod Wants: Inlibc This variable conditionally defines the HAS_FMOD symbol, which indicates to the C program that the fmod() routine is available. See also d_drem for the drem() routine which does roughly the same. d_fork: Unit: d_fork Wants: Inlibc This variable conditionally defines the HAS_FORK symbol, which indicates to the C program that the fork() routine is available. d_fpathconf: Unit: d_pathconf (Also defines d_fpathconf) Wants: Inlibc This variable conditionally defines the HAS_FPATHCONF symbol, which indicates to the C program that the pathconf() routine is available to determine file-system related limits and options associated with a given open file descriptor. d_fsetpos: Unit: d_fsetpos Wants: Inlibc This variable conditionally defines HAS_FSETPOS if fsetpos() is available to set the file position indicator. d_ftime: Unit: d_ftime (Also defines d_gettimeod) Wants: Inlibc Setvar This variable conditionally defines the HAS_FTIME symbol, which indicates that the ftime() routine exists. The ftime() routine is basically a sub-second accuracy clock. d_ftrncate: Unit: d_ftrncate Wants: Inlibc This variable conditionally defines the HAS_FTRUNCATE symbol, which indicates to the C program that the ftruncate() subroutine exists. d_ftruncate: Obsoleted by d_ftrncate. d_gdbm: Obsoleted by i_gdbm. d_getgrps: Unit: d_getgrps Wants: Inlibc This variable conditionally defines the HAS_GETGROUPS symbol, which indicates to the C program that the getgroups() routine is available to get the list of process groups. d_gethbynm: Unit: d_gethbynm Wants: Inlibc This variable conditionally defines the HAS_GETHOSTBYNAME symbol, which indicates to the C program that the gethostbyname() routine is available to lookup host names in some data base or other. d_gethent: Unit: d_gethent Wants: Inlibc This variable conditionally defines HAS_GETHOSTENT if gethostent() is available to dup file descriptors. d_gethhstby: Obsoleted by d_gethbynm. d_gethid: Unit: d_gethid Wants: Inlibc This variable conditionally defines HAS_GETHOSTID if gethostid() is available to get the host id. d_gethname: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This variable conditionally defines the HAS_GETHOSTNAME symbol, which indicates to the C program that the gethostname() routine may be used to derive the host name. d_getlogin: Unit: d_getlogin Wants: Inlibc This variable conditionally defines the HAS_GETLOGIN symbol, which indicates to the C program that the getlogin() routine is available to get the login name. d_getopt: Unit: d_getopt Wants: Inlibc This variable conditionally defines the HAS_GETOPT symbol, which indicates that the getopt() routine exists. The getopt() routine parses command line options in a standard fashion. d_getpagsz: Unit: d_getpagsz (Also defines pagesize) Wants: Oldconfig Myread Inlibc cat contains libs rm Findhdr Optional: cc ccflags This variable conditionally defines HAS_GETPAGESIZE if getpagesize() is available to get the system page size. d_getpgid: Unit: d_getpgid Wants: Inlibc This variable conditionally defines the HAS_GETPGID symbol, which indicates to the C program that the getpgid(pid) function is available to get the process group id. d_getpgrp: Unit: d_getpgrp (Also defines d_bsdgetpgrp) Wants: Guess Inlibc Setvar cat rm i_unistd Optional: cc ccflags ldflags libs This variable conditionally defines HAS_GETPGRP if getpgrp() is available to get the current process group. d_getpgrp2: Unit: d_getpgrp2 Wants: Inlibc This variable conditionally defines the HAS_GETPGRP2 symbol, which indicates to the C program that the getpgrp2() (as in DG/UX) routine is available to get the current process group. d_getppid: Unit: d_getppid Wants: Inlibc This variable conditionally defines the HAS_GETPPID symbol, which indicates to the C program that the getppid() routine is available to get the parent process ID. d_getprior: Unit: d_getprior Wants: Inlibc This variable conditionally defines HAS_GETPRIORITY if getpriority() is available to get a process's priority. d_getpwent: Unit: d_getpwent Wants: Csym Setvar This variable conditionally defines the HAS_GETPWENT symbol, which indicates to the C program that it should use the getpwent() routine instead of the getpw() routine. d_getrusg: Obsoleted by d_rusage. d_gettblsz: Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize) Wants: Myread Guess cat test rm Csym Optional: cc ccflags libs This variable conditionally handles remapping of the getdtablesize() subroutine to ulimit(4,0), or the NOFILE manifest constant. d_gettimeod: Unit: d_ftime (Also defines d_gettimeod) Wants: Inlibc Setvar This variable conditionally defines the HAS_GETTIMEOFDAY symbol, which indicates that the gettimeofday() system call exists (to obtain a sub-second accuracy clock). You should probably include . d_getwd: Unit: d_getwd Wants: Csym Setvar This variable conditionally defines HAS_GETWD if getwd() is available to get working directory. If not, you should probably use getcwd(). d_gnulibc: Unit: d_gnulibc (Also defines gnulibc_version) Wants: Myread Oldconfig Setvar rm cat Compile run Defined if we're dealing with the GNU C Library. d_havetlib: Unit: d_havetlib (Also defines termlib) Wants: cat contains Myread Loc Filexp Oldconfig libpth test uname _a _o This variable conditionally defines the HAS_TERMLIB symbol, which indicates to the C program that termlib-style routines are available. d_hidnet: Unit: d_hidnet (Also defines hiddennet) Wants: cat sed myhostname mydomain Myread Oldconfig This variable conditionally defines the symbol HIDDEN_NET, which tells the C program that it should pretend it is on a different host for purposes of advertising a mailing address. d_htonl: Unit: d_htonl Wants: Inlibc Setvar i_niin i_sysin cat rm contains cppstdin cppflags cppminus This variable conditionally defines HAS_HTONL if htonl() and its friends are available to do network order byte swapping. d_index: Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym This variable conditionally defines HAS_INDEX if index() and rindex() are available for string searching. d_inetaton: Unit: d_inetaton Wants: Inlibc This variable conditionally defines the HAS_INET_ATON symbol, which indicates to the C program that the inet_aton() function is available to parse IP address "dotted-quad" strings. d_inetd: Unit: d_inetd Wants: cat test package Myread Setvar This symbol conditionally defines USE_INETD which indicates to the C program that the initial socket connection will be done via inetd. d_internet: Unit: d_internet Wants: Myread Oldconfig Setvar This variable conditionally defines the INTERNET symbol, which indicates to the C program that there is a mailer available which supports internet-style addresses (user@site.domain). d_isascii: Unit: d_isascii Wants: cc cat ccflags ldflags rm libs Setvar This variable conditionally defines the HAS_ISASCII constant, which indicates to the C program that isascii() is available. d_itimer: Unit: d_itimer Wants: Inlibc This variable conditionally defines the HAS_ITIMER symbol, which indicates that the setitimer() routine exists. The setitimer() routine supports sub-second accuracy for one real-time and two cpu clocks. d_keepalive: Unit: sockopt (Also defines d_keepalive) Wants: cat rm contains socketlib sockethdr d_oldsock libs Oldconfig Setvar Findhdr Optional: cc ccflags This symbol conditionally defines CAN_KEEPALIVE which indicates to the C program that setsockopt SO_KEEPALIVE will work properly. d_keepsig: Unit: d_keepsig Wants: cat Compile rm Guess contains echo n c Setvar run This variable contains the eventual value of the SIGNALS_KEPT symbol, which indicates to the C program if signal handlers need not reinstated after receipt of a signal. d_killpg: Unit: d_killpg Wants: Inlibc This variable conditionally defines the HAS_KILLPG symbol, which indicates to the C program that the killpg() routine is available to kill process groups. d_libndir: Obsoleted by i_ndir. d_link: Unit: d_link Wants: Inlibc This variable conditionally defines HAS_LINK if link() is available to create hard links. d_linux: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol conditionally defines the symbol LINUX_SYSTEM when running on a Linux system. d_linuxstd: Unit: d_linuxstd Wants: d_stdstdio cppstdin cppflags cppminus contains rm Setvar Findhdr This variable conditionally defines USE_LINUX_STDIO if this system has a FILE structure declaring _IO_read_base, _IO_read_ptr, and _IO_read_end in stdio.h. d_locconv: Unit: d_locconv Wants: Inlibc This variable conditionally defines HAS_LOCALECONV if localeconv() is available for numeric and monetary formatting conventions. d_lockf: Unit: d_lockf Wants: Inlibc This variable conditionally defines HAS_LOCKF if lockf() is available to do file locking. d_lstat: Unit: d_lstat Wants: Inlibc This variable conditionally defines HAS_LSTAT if lstat() is available to do file stats on symbolic links. d_mblen: Unit: d_mblen Wants: Inlibc This variable conditionally defines the HAS_MBLEN symbol, which indicates to the C program that the mblen() routine is available to find the number of bytes in a multibye character. d_mbstowcs: Unit: d_mbstowcs Wants: Inlibc This variable conditionally defines the HAS_MBSTOWCS symbol, which indicates to the C program that the mbstowcs() routine is available to convert a multibyte string into a wide character string. d_mbtowc: Unit: d_mbtowc Wants: Inlibc This variable conditionally defines the HAS_MBTOWC symbol, which indicates to the C program that the mbtowc() routine is available to convert multibyte to a wide character. d_memalign: Unit: d_memalign Wants: Inlibc This variable conditionally defines the HAS_MEMALIGN symbol, which indicates to the C program that the memalign() routine is available. d_memccpy: Unit: d_memccpy Wants: Inlibc This variable conditionally defines the HAS_MEMCCPY symbol, which indicates to the C program that the memccpy() routine is available to copy a character into a block of memory. d_memchr: Unit: d_memchr Wants: Inlibc This variable conditionally defines the HAS_MEMCHR symbol, which indicates to the C program that the memchr() routine is available to scan a block of memory for a character. d_memcmp: Unit: d_memcmp Wants: Inlibc This variable conditionally defines the HAS_MEMCMP symbol, which indicates to the C program that the memcmp() routine is available to compare blocks of memory. d_memcpy: Unit: d_memcpy Wants: Inlibc This variable conditionally defines the HAS_MEMCPY symbol, which indicates to the C program that the memcpy() routine is available to copy blocks of memory. d_memmove: Unit: d_memmove Wants: Inlibc This variable conditionally defines the HAS_MEMMOVE symbol, which indicates to the C program that the memmove() routine is available to copy potentatially overlapping blocks of memory. d_memset: Unit: d_memset Wants: Inlibc This variable conditionally defines the HAS_MEMSET symbol, which indicates to the C program that the memset() routine is available to set blocks of memory. d_mkdir: Unit: d_mkdir Wants: Inlibc This variable conditionally defines the HAS_MKDIR symbol, which indicates to the C program that the mkdir() routine is available to create directories.. d_mkfifo: Unit: d_mkfifo Wants: Inlibc This variable conditionally defines the HAS_MKFIFO symbol, which indicates to the C program that the mkfifo() routine is available. d_mktime: Unit: d_mktime Wants: Inlibc This variable conditionally defines the HAS_MKTIME symbol, which indicates to the C program that the mktime() routine is available. d_mmap: Unit: d_mmap Wants: Inlibc This variable conditionally defines HAS_MMAP if mmap() is available to map a file into memory. d_msem_lck: Unit: d_msem_lck Wants: Inlibc This variable conditionally defines HAS_MSEM_LOCK if msem_lock() is available, thereby indicating kernel support for memory semaphores. d_msg: Unit: d_msg Wants: test d_msgctl d_msgget d_msgsnd d_msgrcv Setvar Findhdr This variable conditionally defines the HAS_MSG symbol, which indicates that the entire msg*(2) library is present. d_msgctl: Unit: d_msgctl Wants: Inlibc This variable conditionally defines the HAS_MSGCTL symbol, which indicates to the C program that the msgctl() routine is available. d_msgget: Unit: d_msgget Wants: Inlibc This variable conditionally defines the HAS_MSGGET symbol, which indicates to the C program that the msgget() routine is available. d_msgrcv: Unit: d_msgrcv Wants: Inlibc This variable conditionally defines the HAS_MSGRCV symbol, which indicates to the C program that the msgrcv() routine is available. d_msgsnd: Unit: d_msgsnd Wants: Inlibc This variable conditionally defines the HAS_MSGSND symbol, which indicates to the C program that the msgsnd() routine is available. d_msync: Unit: d_msync Wants: Inlibc This variable conditionally defines HAS_MSYNC if msync() is available to synchronize a mapped file. d_munmap: Unit: d_munmap Wants: Inlibc This variable conditionally defines HAS_MUNMAP if munmap() is available to unmap a region mapped by mmap(). d_mymalloc: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This variable conditionally defines MYMALLOC in case other parts of the source want to take special action if MYMALLOC is used. This may include different sorts of profiling or error detection. d_ndbm: Obsoleted by i_ndbm. d_news: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile Set if running NeWS 1.1 d_news0: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile Set if running NeWS 1.0 d_newsadm: Unit: d_newsadm (Also defines newsadmin) Wants: cat contains Guess Setvar Myread Oldconfig This variable conditionally defines the NEWS_ADMIN symbol, which indicates to the C program that there is a user who is in charge of news administration. d_newshome: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile Path to the top directory of the NeWS structure. d_nice: Unit: d_nice Wants: Inlibc This variable conditionally defines the HAS_NICE symbol, which indicates to the C program that the nice() routine is available. d_nolnbuf: Unit: d_nolnbuf Wants: test cat rm Setvar Myread Optional: cc This variable conditionally defines the NOLINEBUF symbol, which indicates to the C program that stdout is not buffered, so that the program can call setbuf() or setlinebuf() for efficiency. d_normsig: Unit: d_normsig (Also defines jobslib) Wants: test Setvar Guess _a This variable conditionally defines the NORMSIG symbol, which indicates to the C program that the normal signal handling routines should be used, as opposed to the ones in 4.1bsd (sigset, etc.). d_odbm: Obsoleted by i_dbm. d_oldsock: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This variable conditionally defines the OLDSOCKET symbol, which indicates that the BSD socket interface is based on 4.1c and not 4.2. d_open3: Unit: d_open3 Wants: test cat h_fcntl h_sysfile rm Setvar Findhdr Warn Optional: cc cppflags This variable conditionally defines the HAS_OPEN3 manifest constant, which indicates to the C program that the 3 argument version of the open(2) function is available. d_os2: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This symbol conditionally defines the symbol OS2_SYSTEM when running on an OS/2 system. d_passnames: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This variable conditionally defines the PASSNAMES symbol, which indicates to the C program that full names are stored in the /etc/passwd file. d_pathconf: Unit: d_pathconf (Also defines d_fpathconf) Wants: Inlibc This variable conditionally defines the HAS_PATHCONF symbol, which indicates to the C program that the pathconf() routine is available to determine file-system related limits and options associated with a given filename. d_pause: Unit: d_pause Wants: Inlibc This variable conditionally defines the HAS_PAUSE symbol, which indicates to the C program that the pause() routine is available to suspend a process until a signal is received. d_perror: Unit: d_perror Wants: Inlibc This variable conditionally remaps perror to a null action and defines the symbol HAS_PERROR, which indicates to the C program that the perror() routine is not available to print system error messages. d_phostname: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This variable conditionally defines the PHOSTNAME symbol, which contains the shell command which, when fed to popen(), may be used to derive the host name. d_pidcheck: Unit: d_pidcheck Wants: cat rm _o Optional: cc This variable conditionally defines the variable PIDCHECK which indicates that kill(pid, 0) will check for an active pid. d_pipe: Unit: d_pipe Wants: Inlibc This variable conditionally defines the HAS_PIPE symbol, which indicates to the C program that the pipe() routine is available to create an inter-process channel. d_poll: Unit: d_poll Wants: Inlibc This variable conditionally defines the HAS_POLL symbol, which indicates to the C program that the poll() routine is available to poll active file descriptors. d_popen: Unit: d_popen Wants: Inlibc This variable conditionally defines HAS_POPEN if popen() is available to open a pipe from a process. d_portable: Unit: d_portable Wants: cat Loc Myread Oldconfig This variable conditionally defines the PORTABLE symbol, which indicates to the C program that it should not assume that it is running on the machine it was compiled on. d_pread: Unit: d_pread Wants: Inlibc This variable conditionally defines the HAS_PREAD symbol, which indicates to the C program that the pread() routine is available. d_preadv: Unit: d_preadv Wants: Inlibc This variable conditionally defines the HAS_PREADV symbol, which indicates to the C program that the preadv() routine is available. d_psignal: Unit: d_psignal Wants: Inlibc This variable conditionally defines the HAS_PSIGNAL symbol, which indicates that the psignal() routine exists. The psignal() routine prints a description of a signal on the standard error output. d_pwage: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWAGE, which indicates that struct passwd contains pw_age. d_pwchange: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWCHANGE, which indicates that struct passwd contains pw_change. d_pwclass: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWCLASS, which indicates that struct passwd contains pw_class. d_pwcomment: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWCOMMENT, which indicates that struct passwd contains pw_comment. d_pwexpire: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWEXPIRE, which indicates that struct passwd contains pw_expire. d_pwquota: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This varaible conditionally defines PWQUOTA, which indicates that struct passwd contains pw_quota. d_pwrite: Unit: d_pwrite Wants: Inlibc This variable conditionally defines the HAS_PWRITE symbol, which indicates to the C program that the pwrite() routine is available. d_pwritev: Unit: d_pwritev Wants: Inlibc This variable conditionally defines the HAS_PWRITEV symbol, which indicates to the C program that the pwritev() routine is available. d_raster: Unit: d_raster (Also defines rasterlib) Wants: cat test Setvar Myread Oldconfig Conditionally defines RASTER_TEK if this is a raster tech machine. d_rasterlib: Obsoleted by rasterlib. d_rdchk: Unit: d_rdchk Wants: Inlibc This variable conditionally defines the HAS_RDCHK symbol, which indicates to the C program that the rdchk() routine is available to find out if there is input pending on an IO channel. d_re_comp: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This variable conditionally defines the HAS_RECOMP symbol, which indicates to the C program that the re_comp() routine is available for regular patern matching (usally on BSD). If so, it is likely that re_exec() exists. d_readdir: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This variable conditionally defines HAS_READDIR if readdir() is available to read directory entries. d_readlink: Unit: d_readlink Wants: Inlibc This variable conditionally defines the HAS_READLINK symbol, which indicates to the C program that the readlink() routine is available to read the value of a symbolic link. d_regcmp: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This variable conditionally defines the HAS_REGCMP symbol, which indicates to the C program that the regcmp() routine is available for regular patern matching (usally on System V). d_regcomp: Unit: d_regcmp (Also defines d_re_comp d_regcomp) Wants: Csym cat This variable conditionally defines the HAS_REGCOMP symbol, which indicates to the C program that the regcomp() routine is available for regular patern matching (usally on POSIX.2 conforming systems). d_rename: Unit: d_rename Wants: Inlibc This variable conditionally defines the HAS_RENAME symbol, which indicates to the C program that the rename() routine is available to rename files. d_rewinddir: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This variable conditionally defines HAS_REWINDDIR if rewinddir() is available. d_rmdir: Unit: d_rmdir Wants: Inlibc This variable conditionally defines HAS_RMDIR if rmdir() is available to remove directories. d_rootchown: Obsoleted by d_su_chown. d_rusage: Unit: d_rusage Wants: Inlibc This variable conditionally defines the HAS_GETRUSAGE symbol, which indicates that the getrusage() routine exists. The getrusage() routine supports sub-second accuracy for process cpu accounting. You may need to include and . d_safebcpy: Unit: d_safebcpy Wants: cat d_bcopy rm d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags ldflags libs This variable conditionally defines the HAS_SAFE_BCOPY symbol if the bcopy() routine can do overlapping copies. d_safemcpy: Unit: d_safemcpy Wants: cat d_memcpy rm d_memmove i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags libs ldflags This variable conditionally defines the HAS_SAFE_MEMCPY symbol if the memcpy() routine can do overlapping copies. d_sanemcmp: Unit: d_sanemcmp Wants: cat d_memcmp rm i_memory i_stdlib i_string i_unistd Oldconfig Setvar Optional: cc optimize ccflags libs ldflags This variable conditionally defines the HAS_SANE_MEMCMP symbol if the memcpy() routine is available and can be used to compare relative magnitudes of chars with their high bits set. d_sbrk: Unit: d_sbrk Wants: Inlibc This variable conditionally defines HAS_SBRK if sbrk() is available to add more core to the process. d_scandir: Unit: d_scandir Wants: Inlibc This variable conditionally defines HAS_SCANDIR if scandir() is available to scan a directory. d_scannl: Unit: d_scannl Wants: cat rm Setvar Optional: cc ccflags This variable conditionally defines SCAN_NL, which indicates wether the C library routines scanf() and friends can deal with a '\n' in the input correctly. They do most of the time. d_scorfl: Unit: d_scorfl Wants: cat Myread Oldconfig nametype Setvar This variable conditionally defines the SCOREFULL symbol, which indicates to the C program that any scoreboard kept by the program should be kept on the basis of the user's full name as opposed to the user's login name. d_seekdir: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This variable conditionally defines HAS_SEEKDIR if seekdir() is available. d_select: Unit: d_select Wants: Inlibc This variable conditionally defines HAS_SELECT if select() is available to select active file descriptors. A inclusion may be necessary for the timeout field. d_sem: Unit: d_sem Wants: test d_semctl d_semget d_semop Setvar Findhdr This variable conditionally defines the HAS_SEM symbol, which indicates that the entire sem*(2) library is present. d_semctl: Unit: d_semctl Wants: Inlibc This variable conditionally defines the HAS_SEMCTL symbol, which indicates to the C program that the semctl() routine is available. d_semget: Unit: d_semget Wants: Inlibc This variable conditionally defines the HAS_SEMGET symbol, which indicates to the C program that the semget() routine is available. d_semop: Unit: d_semop Wants: Inlibc This variable conditionally defines the HAS_SEMOP symbol, which indicates to the C program that the semop() routine is available. d_setegid: Unit: d_setegid Wants: Inlibc This variable conditionally defines the HAS_SETEGID symbol, which indicates to the C program that the setegid() routine is available to change the effective gid of the current program. d_seteuid: Unit: d_seteuid Wants: Inlibc This variable conditionally defines the HAS_SETEUID symbol, which indicates to the C program that the seteuid() routine is available to change the effective uid of the current program. d_setgrps: Unit: d_setgrps Wants: Inlibc This variable conditionally defines the HAS_SETGROUPS symbol, which indicates to the C program that the setgroups() routine is available to set the list of process groups. d_setlinebuf: Unit: d_setlnbuf (Also defines d_setlinebuf) Wants: Inlibc This variable conditionally defines the HAS_SETLINEBUF symbol, which indicates to the C program that the setlinebuf() routine is available to change stderr or stdout from block-buffered or unbuffered to a line-buffered mode. d_setlocale: Unit: d_setlocale Wants: Inlibc This variable conditionally defines HAS_SETLOCALE if setlocale() is available to handle locale-specific ctype implementations. d_setpgid: Unit: d_setpgid Wants: Inlibc This variable conditionally defines the HAS_SETPGID symbol if the setpgid(pid, gpid) function is available to set process group ID. d_setpgrp: Unit: d_setpgrp (Also defines d_bsdsetpgrp) Wants: cat rm Inlibc Guess Setvar i_unistd Optional: cc libs ccflags ldflags This variable conditionally defines HAS_SETPGRP if setpgrp() is available to set the current process group. d_setpgrp2: Unit: d_setpgrp2 Wants: Inlibc This variable conditionally defines the HAS_SETPGRP2 symbol, which indicates to the C program that the setpgrp2() (as in DG/UX) routine is available to set the current process group. d_setprior: Unit: d_setprior Wants: Inlibc This variable conditionally defines HAS_SETPRIORITY if setpriority() is available to set a process's priority. d_setregid: Unit: d_setregid (Also defines d_setresgid) Wants: Inlibc This variable conditionally defines HAS_SETREGID if setregid() is available to change the real and effective gid of the current process. d_setresgid: Unit: d_setregid (Also defines d_setresgid) Wants: Inlibc This variable conditionally defines HAS_SETRESGID if setresgid() is available to change the real, effective and saved gid of the current process. d_setresuid: Unit: d_setreuid (Also defines d_setresuid) Wants: Inlibc This variable conditionally defines HAS_SETREUID if setresuid() is available to change the real, effective and saved uid of the current process. d_setreuid: Unit: d_setreuid (Also defines d_setresuid) Wants: Inlibc This variable conditionally defines HAS_SETREUID if setreuid() is available to change the real and effective uid of the current process. d_setrgid: Unit: d_setrgid Wants: Inlibc This variable conditionally defines the HAS_SETRGID symbol, which indicates to the C program that the setrgid() routine is available to change the real gid of the current program. d_setruid: Unit: d_setruid Wants: Inlibc This variable conditionally defines the HAS_SETRUID symbol, which indicates to the C program that the setruid() routine is available to change the real uid of the current program. d_setsid: Unit: d_setsid Wants: Inlibc This variable conditionally defines HAS_SETSID if setsid() is available to set the process group ID. d_sgndchr: Unit: d_sgndchr Wants: cat rm Setvar Optional: cc ccflags This variable conditionally defines the SIGNEDCHAR symbol, which indicates to the C program that signed characters are available. d_shm: Unit: d_shm Wants: test d_shmctl d_shmget d_shmat d_shmdt Setvar Findhdr This variable conditionally defines the HAS_SHM symbol, which indicates that the entire shm*(2) library is present. d_shmat: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This variable conditionally defines the HAS_SHMAT symbol, which indicates to the C program that the shmat() routine is available. d_shmatprototype: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This variable conditionally defines the HAS_SHMAT_PROTOTYPE symbol, which indicates that sys/shm.h has a prototype for shmat. d_shmctl: Unit: d_shmctl Wants: Inlibc This variable conditionally defines the HAS_SHMCTL symbol, which indicates to the C program that the shmctl() routine is available. d_shmdt: Unit: d_shmdt Wants: Inlibc This variable conditionally defines the HAS_SHMDT symbol, which indicates to the C program that the shmdt() routine is available. d_shmget: Unit: d_shmget Wants: Inlibc This variable conditionally defines the HAS_SHMGET symbol, which indicates to the C program that the shmget() routine is available. d_sigaction: Unit: d_sigaction Wants: Csym Setvar cat cc ccflags ldflags libs rm _o This variable conditionally defines the HAS_SIGACTION symbol, which indicates that the Vr4 sigaction() routine is available. d_sigblock: Unit: d_sigblock Wants: Inlibc This variable conditionally defines HAS_SIGBLOCK if sigblock() is available to block signal reception. d_sighold: Unit: d_sighold Wants: Inlibc This variable conditionally defines HAS_SIGHOLD if sighold() is available to hold signals. d_sigintrp: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This variable conditionally defines the HAS_SIGINTRP symbol, which indicates that the siginterrupt() routine is available. d_siglist: Unit: d_siglist Wants: Csym Setvar This variable conditionally defines HAS_SYS_SIGLIST if sys_siglist[] is available to translate signal numbers to strings. d_sigsetjmp: Unit: d_sigsetjmp Wants: Setvar cat libs rm Optional: cc ccflags ldflags This variable conditionally defines the HAS_SIGSETJMP symbol, which indicates that the sigsetjmp() routine is available to call setjmp() and optionally save the process's signal mask. d_sigsetmk: Unit: d_sigsetmk Wants: Csym Setvar This variable conditionally defines the HAS_SIGSETMASK symbol, which indicates to the C program that the sigsetmask() routine is available to set current signal mask. d_sigvec: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This variable conditionally defines the HAS_SIGVEC symbol, which indicates that BSD reliable signals are supported. d_sigvectr: Unit: d_sigvec (Also defines d_sigvectr d_sigintrp) Wants: Csym Inlibc Setvar This variable conditionally defines the HAS_SIGVECTOR symbol, which indicates that the sigvec() routine is called sigvector() instead, for reasons known only to Hewlett-Packard. d_sjis2jis: Unit: d_sjis2jis Wants: Inlibc This variable conditionally defines the HAS_SJIS2JIS symbol, which indicates to the C program that the sjis2jis() routine is available to convert SJIS to JIS. d_socket: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This variable conditionally defines HAS_SOCKET, which indicates that the BSD socket interface is supported. d_sockpair: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This variable conditionally defines the HAS_SOCKETPAIR symbol, which indicates that the BSD socketpair() is supported. d_speedopt: Unit: d_speedopt Wants: Myread Cppsym Oldconfig cat models Setvar This variable conditionally defines the SPEED_OVER_MEM symbol, which indicates to the C program that it can burn memory in order to save CPU time. d_stat: Unit: d_stat Wants: Inlibc This variable conditionally defines HAS_STAT if stat() is available to get file status. d_statblks: Unit: d_statblks Wants: contains Setvar Findhdr This variable conditionally defines USE_STAT_BLOCKS if this system has a stat structure declaring st_blksize and st_blocks. d_stdio_cnt_lval: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable conditionally defines STDIO_CNT_LVALUE if the FILE_cnt macro can be used as an lvalue. d_stdio_ptr_lval: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable conditionally defines STDIO_PTR_LVALUE if the FILE_ptr macro can be used as an lvalue. d_stdiobase: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable conditionally defines USE_STDIO_BASE if this system has a FILE structure declaring a usable _base field (or equivalent) in stdio.h. d_stdstdio: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable conditionally defines USE_STDIO_PTR if this system has a FILE structure declaring usable _ptr and _cnt fields (or equivalent) in stdio.h. d_strccmp: Unit: d_strccmp Wants: Inlibc This variable conditionally defines the HAS_STRCASECMP symbol, which indicates to the C program that the strcasecmp() routine is available for case-insensitive string compares. d_strchr: Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym This variable conditionally defines HAS_STRCHR if strchr() and strrchr() are available for string searching. d_strcoll: Unit: d_strcoll Wants: Inlibc This variable conditionally defines HAS_STRCOLL if strcoll() is available to compare strings using collating information. d_strcspn: Unit: d_strcspn Wants: Inlibc This variable conditionally defines the HAS_STRCSPN symbol, which indicates to the C program that the strcspn() routine is available to scan strings. d_strctcpy: Unit: d_strctcpy Wants: cat rm cc Setvar This variable conditionally defines the USE_STRUCT_COPY symbol, which indicates to the C program that this C compiler knows how to copy structures. d_strdup: Unit: d_strdup Wants: Inlibc This variable conditionally defines HAS_STRDUP if strdup() is available to duplicate strings in memory. d_strerrm: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This variable holds what Strerrr is defined as to translate an error code condition into an error message string. It could be 'strerror' or a more complex macro emulating strrror with sys_errlist[], or the "unknown" string when both strerror and sys_errlist are missing. d_strerror: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This variable conditionally defines HAS_STRERROR if strerror() is available to translate error numbers to strings. d_strftime: Unit: d_strftime Wants: Inlibc This variable conditionally defines HAS_STRFTIME if strftime() is available to format locale-specific times. d_strstr: Unit: d_strstr Wants: Inlibc This variable conditionally defines HAS_STRSTR if strstr() is available to find substrings. d_strtod: Unit: d_strtod Wants: Inlibc This variable conditionally defines the HAS_STRTOD symbol, which indicates to the C program that the strtod() routine is available to provide better numeric string conversion than atof(). d_strtok: Unit: d_strtok Wants: Inlibc This variable conditionally defines HAS_STRTOK if strtok() is available to scan strings for tokens. d_strtol: Unit: d_strtol Wants: Inlibc This variable conditionally defines the HAS_STRTOL symbol, which indicates to the C program that the strtol() routine is available to provide better numeric string conversion than atoi() and friends. d_strtoul: Unit: d_strtoul Wants: Inlibc This variable conditionally defines the HAS_STRTOUL symbol, which indicates to the C program that the strtoul() routine is available to provide conversion of strings to unsigned long. d_strxfrm: Unit: d_strxfrm Wants: Inlibc This variable conditionally defines HAS_STRXFRM if strxfrm() is available to transform strings. d_su_chown: Unit: d_su_chown Wants: Csym Setvar This variable conditionally defines the SU_CHOWN symbol, which indicates to the C program that only root can chown() the owner of a file. d_suidsafe: Unit: d_dosuid (Also defines d_suidsafe) Wants: cat contains ls rm test Myread Setvar Oldconfig Guess package hint This variable conditionally defines SETUID_SCRIPTS_ARE_SECURE_NOW if setuid scripts can be secure. This test looks in /dev/fd/. d_symlink: Unit: d_symlink Wants: Inlibc This variable conditionally defines the HAS_SYMLINK symbol, which indicates to the C program that the symlink() routine is available to create symbolic links. d_syscall: Unit: d_syscall Wants: Inlibc This variable conditionally defines HAS_SYSCALL if syscall() is available call arbitrary system calls. d_sysconf: Unit: d_sysconf Wants: Inlibc This variable conditionally defines the HAS_SYSCONF symbol, which indicates to the C program that the sysconf() routine is available to determine system related limits and options. d_sysernlst: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This variable conditionally defines HAS_SYS_ERRNOLIST if sys_errnolist[] is available to translate error numbers to the symbolic name. d_syserrlst: Unit: d_strerror (Also defines d_syserrlst d_sysernlst d_strerrm) Wants: contains Csym Findhdr This variable conditionally defines HAS_SYS_ERRLIST if sys_errlist[] is available to translate error numbers to strings. d_syslog: Unit: d_syslog Wants: test Csym Setvar Findhdr This variable conditionally defines the HAS_SYSLOG symbol, which indicates to the C program that syslog() exists on this system. d_system: Unit: d_system Wants: Inlibc This variable conditionally defines HAS_SYSTEM if system() is available to issue a shell command. d_table: Unit: d_table Wants: Inlibc This variable conditionally defines HAS_TABLE if table() is available to examine/update elements from a system table. d_tcgetpgrp: Unit: d_tcgtpgrp (Also defines d_tcgetpgrp) Wants: Inlibc This variable conditionally defines the HAS_TCGETPGRP symbol, which indicates to the C program that the tcgetpgrp() routine is available. to get foreground process group ID. d_tcsetpgrp: Unit: d_tcstpgrp (Also defines d_tcsetpgrp) Wants: Inlibc This variable conditionally defines the HAS_TCSETPGRP symbol, which indicates to the C program that the tcsetpgrp() routine is available to set foreground process group ID. d_telldir: Unit: d_readdir (Also defines d_seekdir d_telldir d_rewinddir) Wants: Inlibc This variable conditionally defines HAS_TELLDIR if telldir() is available. d_textcan: Unit: d_NeWS (Also defines d_news d_news0 d_newshome d_textcan) Wants: test rm Myread Getfile Path to where the textcan.ps stuff is... d_time: Unit: d_time (Also defines timetype) Wants: Csym Setvar Findhdr Myread Typedef This variable conditionally defines the HAS_TIME symbol, which indicates that the time() routine exists. The time() routine is normaly provided on UNIX systems. d_times: Unit: d_times (Also defines clocktype) Wants: Csym Myread Typedef i_systimes This variable conditionally defines the HAS_TIMES symbol, which indicates that the times() routine exists. The times() routine is normaly provided on UNIX systems. You may have to include . d_tminsys: Unit: d_tminsys Wants: contains Setvar Findhdr This variable conditionally defines TM_IN_SYS if this system declares "struct tm" in rather than . d_truncate: Unit: d_truncate Wants: Inlibc This variable conditionally defines HAS_TRUNCATE if truncate() is available to truncate files. d_tzmin: Unit: d_tzmin Wants: contains cppstdin cppminus timeincl rm Setvar Guess This symbol conditionally defines TZ_MINUTESWEST if the system uses tz_minuteswest in time header instead of timezone. d_tzname: Unit: d_tzname Wants: Csym Setvar This variable conditionally defines HAS_TZNAME if tzname[] is available to access timezone names. d_ulimit: Unit: d_ulimit Wants: Inlibc This variable conditionally defines HAS_ULIMIT if ulimit() is available to get the user limits. d_umask: Unit: d_umask Wants: Inlibc This variable conditionally defines the HAS_UMASK symbol, which indicates to the C program that the umask() routine is available. to set and get the value of the file creation mask. d_uname: Unit: d_gethname (Also defines d_uname d_phostname aphostname) Wants: phostname cat myhostname package d_portable Loc echo n c Myread Guess Oldconfig Csym Optional: i_whoami usrinc This variable conditionally defines the HAS_UNAME symbol, which indicates to the C program that the uname() routine may be used to derive the host name. d_usendir: Unit: d_usendir (Also defines i_ndir ndirlib) Wants: test Setvar Findhdr d_readdir _a This variable conditionally defines the EMULATE_NDIR symbol, which indicates to the C program that it should compile the ndir.c code provided with the package. d_usgnames: Unit: nametype (Also defines d_passnames d_berknames d_usgnames) Wants: Myread Guess Oldconfig cat This variable conditionally defines the PASSNAMES symbol, which indicates to the C program that full names are stored in the /etc/passwd file in USG format. d_usleep: Unit: d_usleep Wants: Inlibc This variable conditionally defines HAS_USLEEP if usleep() is available to do high granularity sleeps. d_uwait: Unit: d_uwait (Also defines d_uwait3) Wants: cat contains cppstdin cppminus rm Setvar Findhdr Optional: cppflags This symbol conditionally defines UNION_WAIT which indicates to the C program that argument for the wait() system call should be declared as 'union wait status' instead of 'int status'. d_uwait3: Unit: d_uwait (Also defines d_uwait3) Wants: cat contains cppstdin cppminus rm Setvar Findhdr Optional: cppflags This symbol conditionally defines UNION_WAIT3 which indicates to the C program that the first argument for the wait3() system call should be declared as 'union wait status' instead of 'int status'. d_vfork: Unit: d_vfork (Also defines usevfork) Wants: Inlibc Myread Oldconfig Setvar This variable conditionally defines the HAS_VFORK symbol, which indicates the vfork() routine is available. d_void_closedir: Unit: d_closedir (Also defines d_void_closedir) Wants: Inlibc i_dirent i_sysdir i_sysndir cc ccflags ldflags libs Setvar rm This variable conditionally defines VOID_CLOSEDIR if closedir() does not return a value. d_voidsig: Unit: d_voidsig (Also defines signal_t) Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar Findhdr Optional: cppflags This variable conditionally defines VOIDSIG if this system declares "void (*signal(...))()" in signal.h. The old way was to declare it as "int (*signal(...))()". d_voidtty: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This variable conditionally defines USE_IOCNOTTY to indicate that the ioctl() call with TIOCNOTTY should be used to void tty association. Otherwise (on USG probably), it is enough to close the standard file decriptors and do a setpgrp(). d_volatile: Unit: d_volatile Wants: cat rm Setvar Optional: cc ccflags This variable conditionally defines the HASVOLATILE symbol, which indicates to the C program that this C compiler knows about the volatile declaration. d_vprintf: Unit: d_vprintf (Also defines d_charvspr) Wants: Guess cat Csym Setvar Optional: cc ccflags This variable conditionally defines the HAS_VPRINTF symbol, which indicates to the C program that the vprintf() routine is available to printf with a pointer to an argument list. d_wait3: Unit: d_wait3 Wants: Inlibc This variable conditionally defines the HAS_WAIT3 symbol, which indicates to the C program that the wait3() subroutine exists. d_wait4: Unit: d_wait4 Wants: Inlibc This variable conditionally defines the HAS_WAIT4 symbol, which indicates the wait4() routine is available. d_waitpid: Unit: d_waitpid Wants: Inlibc This variable conditionally defines HAS_WAITPID if waitpid() is available to wait for child process. d_wcstombs: Unit: d_wcstombs Wants: Inlibc This variable conditionally defines the HAS_WCSTOMBS symbol, which indicates to the C program that the wcstombs() routine is available to convert wide character strings to multibyte strings. d_wctomb: Unit: d_wctomb Wants: Inlibc This variable conditionally defines the HAS_WCTOMB symbol, which indicates to the C program that the wctomb() routine is available to convert a wide character to a multibyte. d_whoami: Obsoleted by i_whoami. d_wifstat: Unit: d_wifstat Wants: d_uwait Oldconfig cat rm Optional: cc ccflags ldflags libs This symbol conditionally defines USE_WIFSTAT if the C program can safely use the WIFxxx macros with the kind of wait() parameter declared in the program (see UNION_WAIT), or if it can't. Should only matter on HP-UX, where the macros are incorrectly written and therefore cause programs using them with an 'union wait' variable to not compile properly. d_xdrs: Unit: d_xdrs Wants: cat Csym Setvar This symbol conditionally defines HAS_XDRS which indicates to the C program that XDR serialization routines are available. d_xenix: Unit: Guess (Also defines d_eunice d_xenix d_bsd d_linux d_dos d_os2) Wants: cat test echo n c contains rm tr Loc eunicefix This variable conditionally defines the symbol XENIX_SYSTEM, which alerts the C program that it runs under Xenix. db_hashtype: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This variable contains the type of the hash structure element in the header file. In older versions of DB, it was int, while in newer ones it is u_int32_t. db_prefixtype: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This variable contains the type of the prefix structure element in the header file. In older versions of DB, it was int, while in newer ones it is size_t. defeditor: Unit: defeditor Wants: Getfile Oldconfig Loc vi This variable contains the eventual value of the DEFEDITOR symbol, which contains the name of the default editor. defvoidused: Unit: voidflags (Also defines defvoidused) Wants: cat sed rm contains package Oldconfig Myread Optional: cc ccflags This variable contains the default value of the VOIDUSED symbol (15). direntrytype: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This symbol is set to 'struct direct' or 'struct dirent' depending on whether dirent is available or not. You should use this pseudo type to portably declare your directory entries. doublesize: Unit: doublesize Wants: cat rm Myread Optional: cc ccflags This variable contains the value of the DOUBLESIZE symbol, which indicates to the C program how many bytes there are in a double. eagain: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This variable bears the symbolic errno code set by read() when no data is present on the file and non-blocking I/O was enabled (otherwise, read() blocks naturally). ebcdic: Unit: ebcdic Wants: Compile Setvar cat rm run This variable conditionally defines EBCDIC if this system uses EBCDIC encoding. Among other things, this means that the character ranges are not contiguous. See trnl.U errnolist: Unit: errnolist (Also defines errnolist_SH errnolist_a errnolist_c errnolist_o) Wants: cat _a _o Optional: cc ccflags libs d_sysernlst This variable holds the base name of a file containing the definition of the sys_errnolist array, if the C library doesn't provide it already. Otherwise, its value is empty. The following lines should be included in your Makefile.SH: case "$errnolist" in '') ;; *) $spitshell >>Makefile < line, it replaces it by a # line which contains the original position in the input file and the full name of included file, between "quotes". filexp: Unit: filexp Wants: privlib This symbol contains the full pathname of the filexp script, in case we are saving the script for posterity. firstmakefile: Unit: Unix (Also defines _a _o firstmakefile archobjs) Wants: Oldconfig This variable defines the first file searched by make. On unix, it is makefile (then Makefile). On case-insensitive systems, it might be something else. This is only used to deal with convoluted make depend tricks. floatsize: Unit: floatsize Wants: cat rm Myread Optional: cc ccflags This variable contains the value of the FLOATSIZE symbol, which indicates to the C program how many bytes there are in a float. fpostype: Unit: fpostype Wants: Myread Typedef This variable defines Fpos_t to be something like fpost_t, long, uint, or whatever type is used to declare file positions in libc. fpu: Unit: fpu Wants: test cat cc Myread Set to be the compile flag for the local floating point unit. fpunit: Obsoleted by fpu. freetype: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This variable contains the return type of free(). It is usually void, but occasionally int. from: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This variable contains the command used by Configure to copy files from the target host. Useful and available only during the build. The string ':' if not cross-compiling. full_csh: Unit: d_csh (Also defines full_csh) Wants: csh Setvar This variable contains the full pathname to 'csh', whether or not the user has specified 'portability'. This is only used in the compiled C program, and we assume that all systems which can share this executable will have the same full pathname to 'csh.' full_sed: Unit: Loc_sed (Also defines full_sed) Wants: sed This variable contains the full pathname to 'sed', whether or not the user has specified 'portability'. This is only used in the compiled C program, and we assume that all systems which can share this executable will have the same full pathname to 'sed.' gccosandvers: Unit: gccvers (Also defines gccversion gccosandvers) Wants: cat cpp rm Myread Guess Options Oldconfig Loc osname osvers grep run ccname Optional: cc If GNU cc (gcc) is used, this variable the operating system and version used to compile the gcc. It is set to '' if not gcc, or if nothing useful can be parsed as the os version. gccversion: Unit: gccvers (Also defines gccversion gccosandvers) Wants: cat cpp rm Myread Guess Options Oldconfig Loc osname osvers grep run ccname Optional: cc If GNU cc (gcc) is used, this variable holds '1' or '3' (for instance) to indicate whether the compiler is version 1 or 3. This is used in setting some of the default cflags. It is set to '' if not gcc. getdtablesize: Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize) Wants: Myread Guess cat test rm Csym Optional: cc ccflags libs This catches use of the getdtablesize() subroutine, and remaps it to either ulimit(4,0) or NOFILE, if getdtablesize() isn't available. gidtype: Unit: gidtype Wants: Myread Typedef Findhdr This variable defines Gid_t to be something like gid_t, int, ushort, or whatever type is used to declare the return type of getgid(). Typically, it is the type of group ids in the kernel. glibpth: Unit: libpth (Also defines glibpth xlibpth plibpth loclibpth) Wants: usrinc incpath test cat Myread Oldconfig This variable holds the general path (space-separated) used to find libraries. It may contain directories that do not exist on this platform, libpth is the cleaned-up version. gnulibc_version: Unit: d_gnulibc (Also defines gnulibc_version) Wants: Myread Oldconfig Setvar rm cat Compile run This variable contains the version number of the GNU C library. It is usually something like '2.2.5'. It is a plain '' if this is not the GNU C library, or if the version is unknown. groupcat: Unit: nis (Also defines passcat groupcat hostcat) Wants: Myread Oldconfig test contains This variable contains a command that produces the text of the /etc/group file. This is normally "cat /etc/group", but can be "ypcat group" when NIS is used. groupstype: Unit: groupstype Wants: gidtype d_getgrps Myread Oldconfig Findhdr cat d_setgrps This variable defines Groups_t to be something like gid_t, int, ushort, or whatever type is used for the second argument to getgroups() and setgroups(). Usually, this is the same as gidtype (gid_t), but sometimes it isn't. h_fcntl: Unit: h_fcntl Wants: Nothing This is variable gets set in various places to tell i_fcntl that should be included. h_sysfile: Unit: h_sysfile Wants: Nothing This is variable gets set in various places to tell i_sys_file that should be included. hiddennet: Unit: d_hidnet (Also defines hiddennet) Wants: cat sed myhostname mydomain Myread Oldconfig This variable contains the value eventually given to the symbol HIDDEN_NET, if d_hidnet defines it. If defined, it's the name of the host which serves as the mail server for a network that is invisible to the outside world. hint: Unit: Oldconfig (Also defines hint myuname osname osvers) Wants: Instruct Myread Checkcc Mksymlinks Loc Options Tr src trnl ln uname sh awk sed test cat grep rm lns tr n c contains targetarch Gives the type of hints used for previous answers. May be one of "default", "recommended" or "previous". hostcat: Unit: nis (Also defines passcat groupcat hostcat) Wants: Myread Oldconfig test contains This variable contains a command that produces the text of the /etc/hosts file. This is normally "cat /etc/hosts", but can be "ypcat hosts" when NIS is used. hostname: Obsoleted by myhostname. huge: Unit: models (Also defines split small medium large huge) Wants: test cat Myread sysman Oldconfig Loc Warn contains rm This variable contains a flag which will tell the C compiler and loader to produce a program running with a huge memory model. If the huge model is not supported, contains the flag to produce large model programs. It is up to the Makefile to use this. i_arpainet: Unit: i_arpainet Wants: Inhdr This variable conditionally defines the I_ARPA_INET symbol, and indicates whether a C program should include . i_bsdioctl: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This variable conditionally defines the I_SYS_BSDIOCTL symbol, which indicates to the C program that exists and should be included. i_db: Unit: i_db (Also defines db_hashtype db_prefixtype) Wants: Inhdr rm contains cat d_const Optional: cc ccflags This variable conditionally defines the I_DB symbol, and indicates whether a C program may include Berkeley's DB include file . i_dbm: Unit: i_dbm (Also defines i_rpcsvcdbm) Wants: Inhdr Inlibc Setvar This variable conditionally defines the I_DBM symbol, which indicates to the C program that exists and should be included. i_dirent: Unit: i_dirent (Also defines d_dirnamlen direntrytype) Wants: test contains Setvar Myread Findhdr cppstdin cppflags cppminus rm This variable conditionally defines I_DIRENT, which indicates to the C program that it should include . i_dld: Unit: i_dld Wants: Inhdr This variable conditionally defines the I_DLD symbol, which indicates to the C program that (GNU dynamic loading) exists and should be included. i_dlfcn: Unit: i_dlfcn Wants: Inhdr This variable conditionally defines the I_DLFCN symbol, which indicates to the C program that exists and should be included. i_fcntl: Unit: i_fcntl Wants: h_fcntl h_sysfile Inhdr Setvar Optional: i_sysfile This variable controls the value of I_FCNTL (which tells the C program to include ). i_float: Unit: i_float Wants: Inhdr This variable conditionally defines the I_FLOAT symbol, and indicates whether a C program may include to get symbols like DBL_MAX or DBL_MIN, i.e. machine dependent floating point values. i_gdbm: Unit: i_gdbm Wants: Inhdr Inlibc Setvar This variable conditionally defines the I_GDBM symbol, which indicates to the C program that exists and should be included. i_grp: Unit: i_grp Wants: Inhdr This variable conditionally defines the I_GRP symbol, and indicates whether a C program should include . i_inttypes: Unit: i_inttypes Wants: Inhdr This variable conditionally defines I_INTTYPES, which indicates to the C program that it should include to get format conversions of integer types. i_limits: Unit: i_limits Wants: Inhdr This variable conditionally defines the I_LIMITS symbol, and indicates whether a C program may include to get symbols like WORD_BIT and friends. i_locale: Unit: i_locale Wants: Inhdr This variable conditionally defines the I_LOCALE symbol, and indicates whether a C program should include . i_malloc: Unit: i_malloc Wants: Inhdr This variable conditionally defines the I_MALLOC symbol, and indicates whether a C program should include . i_math: Unit: i_math Wants: Inhdr This variable conditionally defines the I_MATH symbol, and indicates whether a C program may include . i_memory: Unit: i_memory Wants: Inhdr strings cppstdin cppflags cppminus contains rm Setvar This variable conditionally defines the I_MEMORY symbol, and indicates whether a C program should include . i_ndbm: Unit: i_ndbm Wants: Inhdr Inlibc Setvar This variable conditionally defines the I_NDBM symbol, which indicates to the C program that exists and should be included. i_ndir: Unit: d_usendir (Also defines i_ndir ndirlib) Wants: test Setvar Findhdr d_readdir _a This variable conditionally defines the I_NDIR symbol, which indicates to the C program that it should include the system's version of ndir.h, rather than the one with this package. i_neterrno: Unit: i_neterrno Wants: Inhdr rm Setvar Optional: cc ccflags This variable conditionally defines the I_NET_ERRNO symbol, which indicates to the C program that exists and should be included. i_niin: Unit: i_niin (Also defines i_sysin) Wants: Inhdr This variable conditionally defines I_NETINET_IN, which indicates to the C program that it should include . Otherwise, you may try . i_poll: Unit: i_poll Wants: Inhdr This variable conditionally defines the I_POLL symbol, which indicates to the C program that it should include . i_pwd: Unit: i_pwd (Also defines d_pwquota d_pwage d_pwchange d_pwclass d_pwexpire d_pwcomment) Wants: contains rm cppstdin cppflags cppminus Inhdr Findhdr Setvar This variable conditionally defines I_PWD, which indicates to the C program that it should include . i_regex: Unit: i_regex Wants: Inhdr This variable conditionally defines the I_REGEX symbol, which indicates to the C program that exists and should be included. i_rpcsvcdbm: Unit: i_dbm (Also defines i_rpcsvcdbm) Wants: Inhdr Inlibc Setvar This variable conditionally defines the I_RPCSVC_DBM symbol, which indicates to the C program that exists and should be included. Some System V systems might need this instead of . i_sfio: Unit: i_sfio Wants: Inhdr Setvar This variable conditionally defines the I_SFIO symbol, and indicates whether a C program should include . i_sgtty: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This variable conditionally defines the I_SGTTY symbol, which indicates to the C program that it should include rather than . i_stdarg: Unit: i_varhdr (Also defines i_stdarg i_varargs) Wants: cat rm test Setvar Findhdr Warn startsh _o Optional: cc ccflags This variable conditionally defines the I_STDARG symbol, which indicates to the C program that exists and should be included. i_stddef: Unit: i_stddef Wants: Inhdr This variable conditionally defines the I_STDDEF symbol, which indicates to the C program that exists and should be included. i_stdlib: Unit: i_stdlib Wants: Inhdr This variable conditionally defines the I_STDLIB symbol, which indicates to the C program that exists and should be included. i_string: Unit: i_string (Also defines strings) Wants: test Setvar Findhdr Warn This variable conditionally defines the I_STRING symbol, which indicates that should be included rather than . i_sysdir: Unit: i_sysdir Wants: Inhdr This variable conditionally defines the I_SYS_DIR symbol, and indicates whether a C program should include . i_sysfile: Unit: i_sysfile Wants: h_sysfile Inhdr Setvar This variable conditionally defines the I_SYS_FILE symbol, and indicates whether a C program should include to get R_OK and friends. i_sysfilio: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This variable conditionally defines the I_SYS_FILIO symbol, which indicates to the C program that exists and should be included in preference to . i_sysin: Unit: i_niin (Also defines i_sysin) Wants: Inhdr This variable conditionally defines I_SYS_IN, which indicates to the C program that it should include instead of . i_sysioctl: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This variable conditionally defines the I_SYS_IOCTL symbol, which indicates to the C program that exists and should be included. i_sysmman: Unit: i_sysmman Wants: Inhdr This variable conditionally defines the I_SYS_MMAN symbol, and indicates whether a C program should include . i_sysndir: Unit: i_sysndir Wants: Inhdr This variable conditionally defines the I_SYS_NDIR symbol, and indicates whether a C program should include . i_sysparam: Unit: i_sysparam Wants: Inhdr This variable conditionally defines the I_SYS_PARAM symbol, and indicates whether a C program should include . i_syspoll: Unit: i_syspoll Wants: Inhdr This variable conditionally defines the I_SYS_POLL symbol, which indicates to the C program that it should include . i_sysresrc: Unit: i_sysresrc Wants: Inhdr This variable conditionally defines the I_SYS_RESOURCE symbol, and indicates whether a C program should include . i_sysselct: Unit: i_sysselct Wants: Inhdr This variable conditionally defines I_SYS_SELECT, which indicates to the C program that it should include in order to get the definition of struct timeval. i_syssock: Unit: i_syssock Wants: Inhdr This variable conditionally defines the I_SYS_SOCKET symbol, and indicates whether a C program should include before performing socket operations. i_syssockio: Unit: i_sysioctl (Also defines i_bsdioctl i_sysfilio i_syssockio d_voidtty) Wants: test contains cat i_termio i_termios i_sgtty Setvar Findhdr rm Inhdr Optional: cc This variable conditionally defines I_SYS_SOCKIO to indicate to the C program that socket ioctl codes may be found in instead of . i_sysstat: Unit: i_sysstat Wants: Inhdr This variable conditionally defines the I_SYS_STAT symbol, and indicates whether a C program should include . i_systable: Unit: i_systable Wants: Inhdr This variable conditionally defines the I_SYS_TABLE symbol, and indicates whether a C program should include . i_systime: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This variable conditionally defines I_SYS_TIME, which indicates to the C program that it should include . i_systimeb: Unit: i_systimeb Wants: test contains Loc Setvar Findhdr This variable conditionally defines I_SYS_TIMEB, which indicates to the C program that it should include . i_systimek: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This variable conditionally defines I_SYS_TIME_KERNEL, which indicates to the C program that it should include with KERNEL defined. i_systimes: Unit: i_systimes Wants: Inhdr This variable conditionally defines the I_SYS_TIMES symbol, and indicates whether a C program should include . i_systwgcf: Unit: i_systwgcf Wants: Inhdr This variable conditionally defines the I_SYS_TWG_CF symbol, and indicates whether a C program should include sys/twg_config.h. i_systypes: Unit: i_systypes Wants: Inhdr This variable conditionally defines the I_SYS_TYPES symbol, and indicates whether a C program should include . i_sysun: Unit: i_sysun Wants: Inhdr This variable conditionally defines I_SYS_UN, which indicates to the C program that it should include to get UNIX domain socket definitions. i_syswait: Unit: i_syswait Wants: Inhdr This variable conditionally defines I_SYS_WAIT, which indicates to the C program that it should include . i_termio: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This variable conditionally defines the I_TERMIO symbol, which indicates to the C program that it should include rather than . i_termios: Unit: i_termio (Also defines i_sgtty i_termios) Wants: test Inlibc Cppsym Guess Setvar Findhdr Warn This variable conditionally defines the I_TERMIOS symbol, which indicates to the C program that the POSIX file is to be included. i_time: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This variable conditionally defines I_TIME, which indicates to the C program that it should include . i_unistd: Unit: i_unistd Wants: Inhdr This variable conditionally defines the I_UNISTD symbol, and indicates whether a C program should include . i_utime: Unit: i_utime Wants: Inhdr This variable conditionally defines the I_UTIME symbol, and indicates whether a C program should include . i_values: Unit: i_values Wants: Inhdr This variable conditionally defines the I_VALUES symbol, and indicates whether a C program may include to get symbols like MAXLONG and friends. i_varargs: Unit: i_varhdr (Also defines i_stdarg i_varargs) Wants: cat rm test Setvar Findhdr Warn startsh _o Optional: cc ccflags This variable conditionally defines I_VARARGS, which indicates to the C program that it should include . i_varhdr: Unit: i_varhdr (Also defines i_stdarg i_varargs) Wants: cat rm test Setvar Findhdr Warn startsh _o Optional: cc ccflags Contains the name of the header to be included to get va_dcl definition. Typically one of varargs.h or stdarg.h. i_vfork: Unit: i_vfork Wants: Inhdr d_vfork This variable conditionally defines the I_VFORK symbol, and indicates whether a C program should include vfork.h. i_whoami: Unit: i_whoami Wants: Inhdr This variable conditionally defines the I_WHOAMI symbol, which indicates to the C program that it should include . inc: Unit: inc (Also defines incexp) Wants: Loc Oldconfig Getfile usrinc This variable holds the name of the directory in which the user wants to put public header files for the package in question. It is most often a local directory such as /usr/local/include. incexp: Unit: inc (Also defines incexp) Wants: Loc Oldconfig Getfile usrinc This is the same as the inc variable, but is filename expaned at configuration time for convenient use in your makefiles. incpath: Unit: usrinc (Also defines incpath mips_type) Wants: test cat echo n c Getfile Guess Oldconfig eunicefix contains rm This variable must preceed the normal include path to get hte right one, as in "$incpath/usr/include" or "$incpath/usr/lib". Value can be "" or "/bsd43" on mips. index: Magic symbol, needs: HAS_INDEX Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym #ifndef HAS_INDEX #ifndef index #define index strchr #endif #endif inhdr: Unit: Inhdr Wants: test Findhdr Whoa This shell variable is used internally by Configure to check wether a set of headers exist or not. A typical use is: set header i_header [ header2 i_header2 ... ] eval $inhdr That will print a message, saying wether header was found or not and set i_header* accordingly. If the first header is not found, we try the next one, until the list is empty or one is found. inlibc: Unit: Inlibc Wants: Csym Whoa Oldconfig This shell variable is used internally by Configure to check wether a given function is defined or not. A typical use is: set function d_func eval $inlibc That will print a message, saying wether function was found or not and set d_func accordingly. install: Unit: install (Also defines installdir) Wants: Loc Oldconfig Getfile cat test startsh rm eunicefix package contains mkdir echo n c Optional: cc This variable contains the name of an install program that can accept BSD-style arguments. It must correctly support -c, -s, and -m at least. It is a fully qualified pathname when found. If you have a local install.SH file at the root directory of your package, it is assumed to be the default script emulating a BSD install and the variable will be set to ./install. Otherwise, it is set to plain 'install', relying on the user's PATH to perform miracles. installarchlib: Unit: archlib (Also defines d_archlib archlibexp installarchlib) Wants: archname afs spackage cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup This variable is really the same as archlibexp but may differ on those systems using AFS. For extra portability, only this variable should be used in makefiles. installbin: Unit: bin (Also defines binexp installbin) Wants: Prefixit Getfile Oldconfig afs cat test This variable is the same as binexp unless AFS is running in which case the user is explicitely prompted for it. This variable should always be used in your makefiles for maximum portability. installdir: Unit: install (Also defines installdir) Wants: Loc Oldconfig Getfile cat test startsh rm eunicefix package contains mkdir echo n c Optional: cc This variable contains the name of a program that can install nested directories. Often set to 'mkdir -p', it can also be 'install -d' if you have such a beast and lack the former. If you have an install.SH file at the root directory of your package, it will be used in last resort, setting the variable to './install -d'. Otherwise, it is set to plain 'mkdir', and cross your fingers! installman1dir: Unit: man1dir (Also defines man1direxp man1ext installman1dir) Wants: afs cat nroff Loc Oldconfig spackage test Getfile Prefixit prefixexp Prefixup sysman Myread This variable is really the same as man1direxp, unless you are using AFS in which case it points to the read/write location whereas man1direxp only points to the read-only access location. For extra portability, you should only use this variable within your makefiles. installman3dir: Unit: man3dir (Also defines man3direxp man3ext installman3dir) Wants: afs cat nroff Loc Oldconfig sed man1dir spackage package Getfile prefix Prefixit Prefixup d_flexfnam privlib Myread This variable is really the same as man3direxp, unless you are using AFS in which case it points to the read/write location whereas man3direxp only points to the read-only access location. For extra portability, you should only use this variable within your makefiles. installmanfmt: Unit: manfmt (Also defines manfmtexp installmanfmt) Wants: Getfile Loc Oldconfig cat manext spackage Prefixit prefixexp Prefixup afs test This variable is really the same as manfmtexp, unless you are using AFS in which case it points to the read/write location whereas mansrcexp only points to the read-only access location. For extra portability, you should only use this variable within your makefiles. installmansrc: Unit: mansrc (Also defines mansrcexp manext installmansrc) Wants: afs cat nroff Loc Oldconfig sysman spackage test Getfile Prefixit prefixexp Prefixup This variable is really the same as mansrcexp, unless you are using AFS in which case it points to the read/write location whereas mansrcexp only points to the read-only access location. For extra portability, you should only use this variable within your makefiles. installprivlib: Unit: privlib (Also defines privlibexp installprivlib) Wants: afs package cat Getfile Oldconfig Prefixit test This variable is really the same as privlibexp but may differ on those systems using AFS. For extra portability, only this variable should be used in makefiles. installscript: Unit: scriptdir (Also defines scriptdirexp installscript) Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup Optional: bin This variable is usually the same as scriptdirexp, unless you are on a system running AFS, in which case they may differ slightly. You should always use this variable within your makefiles for portability. installsitearch: Unit: sitearch (Also defines sitearchexp installsitearch) Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib This variable is really the same as sitearchexp but may differ on those systems using AFS. For extra portability, only this variable should be used in makefiles. installsitelib: Unit: sitelib (Also defines sitelibexp installsitelib) Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed This variable is really the same as sitelibexp but may differ on those systems using AFS. For extra portability, only this variable should be used in makefiles. intsize: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This variable contains the value of the INTSIZE symbol, which indicates to the C program how many bytes there are in an int. ipc: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable holds the type of IPC service we'll be using. Values include "ip", "shm", "msg", "cms" and "os9". We don't worry about cms or os9 here, because Configure doesn't run in those places--HMS. issymlink: Unit: issymlink Wants: lns test rm This variable holds the test command to test for a symbolic link (if they are supported). Typical values include 'test -h' and 'test -L'. jobslib: Unit: d_normsig (Also defines jobslib) Wants: test Setvar Guess _a This variable holds the argument to be passed to the loader to include the strange signal handling routines from 4.1bsd. On systems that have NORMSIG defined this variable is null. kernel: Unit: kernel Wants: Getfile test This variable becomes the (fully rooted) path name of the kernel. large: Unit: models (Also defines split small medium large huge) Wants: test cat Myread sysman Oldconfig Loc Warn contains rm This variable contains a flag which will tell the C compiler and loader to produce a program running with a large memory model. It is up to the Makefile to use this. ldflags: Unit: ccflags (Also defines ldflags lkflags cppflags optimize locincpth) Wants: test cat Myread Guess Options Oldconfig gccversion mips_type package contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint Optional: usrinc cc This variable contains any additional C loader flags desired by the user. It is up to the Makefile to use this. lex: Unit: lex (Also defines lexflags) Wants: Guess Myread Oldconfig flex test This variable holds the name of the lexical analyser generator we want to use in the Makefile. It can be lex or flex. lexflags: Unit: lex (Also defines lexflags) Wants: Guess Myread Oldconfig flex test This variable holds any flags that should be passed to the lexical analyzer. It is up to the Makefile to use it. lib: Unit: lib (Also defines libexp) Wants: Getfile Loc Oldconfig Prefixit Prefixup prefixexp This variable holds the name of the directory in which the user wants to put public library files for the package in question. It is most often a local directory such as /usr/local/lib. Programs using this variable must be prepared to deal with filename expansion. lib_ext: Obsoleted by _a. libc: Unit: libc (Also defines libnames) (With private nm_extract) Wants: echo n c rm test grep Getfile Myread Oldconfig Loc sed libs incpath libpth ar runnm nm nm_opt nm_so_opt contains xlibpth so osname trnl tr sort uniq _o _a This variable contains the location of the C library. libdbm: Unit: libdbm Wants: test Loc libpth _a This variable contains the argument to pass to the loader in order to get the dbm library routines. If there is no dbm or ndbm library, it is null. libexp: Unit: lib (Also defines libexp) Wants: Getfile Loc Oldconfig Prefixit Prefixup prefixexp This variable is the same as the lib variable, but is filename expanded at configuration time, for convenient use in your makefiles. libflex: Unit: libflex Wants: Loc lex libpth _a This variable contains the argument to pass to the loader in order to get the flex/lex library routines. If there is no flex or flex library, it is null. libmld: Obsoleted by libnlist. libnames: Unit: libc (Also defines libnames) (With private nm_extract) Wants: echo n c rm test grep Getfile Myread Oldconfig Loc sed libs incpath libpth ar runnm nm nm_opt nm_so_opt contains xlibpth so osname trnl tr sort uniq _o _a The constructed list of library names. Normally empty, but hint files may set this for later perusal by Configure. libnlist: Unit: libnlist Wants: Loc libpth Guess usrinc _a This variable contains the name of the library required to get the definition of the nlist() function. On a MIPS RISC/OS box, it is -lmld. Under Sys Vr4, it is -lelf. Otherwise, its value is empty. libnm: Unit: libnm Wants: test Loc libpth _a This variable contains the argument to pass to the loader in order to get the new math library routines. If there is no new math library, it is null. libpth: Unit: libpth (Also defines glibpth xlibpth plibpth loclibpth) Wants: usrinc incpath test cat Myread Oldconfig This variable holds the general path (space-separated) used to find libraries. It is intended to be used by other units. libs: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable holds the additional libraries we want to use. It is up to the Makefile to deal with it. The list can be empty. libscheck: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable is intended to be set by hint files, if needed. It should contain shell code that will be eval'ed with $xxx holding some library file. It may change $xxx if needed. For instance, on an Irix platform, you may make sure the right library file is used depending on the cc command line, so that the correct library is used depending on the selected ABI (for 32 and 64-bit compilations). Here is an example of code that could be found in a hint file on Irix when the selected compiler was for 32-bit -- that code is put in the cc.cbu call-back unit to be invoked AFTER the C compiler and its flags have been chosen: libscheck='case "$xxx" in *.a) /bin/ar p $xxx `/bin/ar t $xxx | sed q` >$$.o; case "`/usr/bin/file $$.o`" in *N32*) rm -f $$.o ;; *) rm -f $$.o; xxx=/no/n32$xxx ;; esac ;; *) case "`/usr/bin/file $xxx`" in *N32*) ;; *) xxx=/no/n32$xxx ;; esac ;; esac' libsdirs: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable holds the directory names aka dirnames of the libraries we found and accepted, duplicates are removed. libsfiles: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable holds the filenames aka basenames of the libraries we found and accepted. libsfound: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable holds the full pathnames of the libraries we found and accepted. libspath: Unit: libs (Also defines libsfound libsfiles libsdirs libspath libscheck) Wants: test cat Myread Oldconfig Loc libpth package xlibpth so _a sed rm Optional: usesocks cc ccflags ldflags This variable holds the directory names probed for libraries. libyacc: Unit: libyacc Wants: Loc yacc libpth _a This variable contains the argument to pass to the loader in order to get the yacc library routines. If there is no yacc or yacc library, it is null. lintlib: Unit: lintlib (Also defines lintlibexp) Wants: Getfile Loc Oldconfig This variable holds the name of the directory in which the user wants to put public lint-library files for the package in question. It is most often a local directory such as /usr/local/lib/lint. Programs using this variable must be prepared to deal with ~name expansion. lintlibexp: Unit: lintlib (Also defines lintlibexp) Wants: Getfile Loc Oldconfig This variable is the same as the lintlib variable, but is filename expanded at configuration time, for convenient use in your makefiles. lkflags: Unit: ccflags (Also defines ldflags lkflags cppflags optimize locincpth) Wants: test cat Myread Guess Options Oldconfig gccversion mips_type package contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint Optional: usrinc cc This variable contains any additional C partial linker flags desired by the user. It is up to the Makefile to use this. lns: Unit: lns Wants: ln rm touch test This variable holds the name of the command to make symbolic links (if they are supported). It can be used in the Makefile. It is either 'ln -s' or 'ln' locdist: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This variable contains the eventual value of the LOCDIST symbol, which is the local organization's distribution name for news. locincpth: Unit: ccflags (Also defines ldflags lkflags cppflags optimize locincpth) Wants: test cat Myread Guess Options Oldconfig gccversion mips_type package contains rm cppstdin cppminus cpprun cpplast libpth loclibpth hint Optional: usrinc cc This variable contains a list of additional directories to be searched by the compiler. The appropriate -I directives will be added to ccflags. This is intended to simplify setting local directories from the Configure command line. It's not much, but it parallels the loclibpth stuff in libpth.U. loclibpth: Unit: libpth (Also defines glibpth xlibpth plibpth loclibpth) Wants: usrinc incpath test cat Myread Oldconfig This variable holds the paths (space-separated) used to find local libraries. It is prepended to libpth, and is intended to be easily set from the command line. longsize: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This variable contains the value of the LONGSIZE symbol, which indicates to the C program how many bytes there are in a long. lseektype: Unit: lseektype Wants: Myread Typedef This variable defines lseektype to be something like off_t, long, or whatever type is used to declare lseek offset's type in the kernel (which also appears to be lseek's return type). maildir: Unit: maildir (Also defines maildirexp) Wants: Getfile Loc Oldconfig This variable contains the name of the directory in which mail is spooled. Programs using this variable must be prepared to deal with ~name substitutions. maildirexp: Unit: maildir (Also defines maildirexp) Wants: Getfile Loc Oldconfig This is the same as the maildir variable, but is filename expanded at configuration time, for programs not willing to deal with it at run-time. mailer: Unit: mailer Wants: test cat rmail mail smail sendmail Getfile Oldconfig This variable contains the full pathname of a reasonable mailer. By reasonable, we mean some program which can understand internet addresses or at least forward them to some internet router. This mailer should be invoked as "mailer [options] recipients option, which can make Life Easier on those folks who like to run rcsdiff manually. rd_nodata: Unit: nblock_io (Also defines o_nonblock eagain rd_nodata d_eofnblk) Wants: cat rm d_open3 h_sysfile h_fcntl signal_t hint Oldconfig Setvar startsh Warn Optional: cc ccflags ldflags This variable holds the return code from read() when no data is present. It should be -1, but some systems return 0 when O_NDELAY is used, which is a shame because you cannot make the difference between no data and an EOF.. Sigh! reg1: Unit: registers (Also defines reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 reg9 reg10 reg11 reg12 reg13 reg14 reg15 reg16) Wants: awk rm Cppsym Myread Oldconfig This variable, along with reg2, reg3, etc. contains the eventual value for the symbols register1, register2, register3, etc. It has either the value "register" or is null. register1: Unit: registers (Also defines reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 reg9 reg10 reg11 reg12 reg13 reg14 reg15 reg16) Wants: awk rm Cppsym Myread Oldconfig This symbol, along with register2, register3, etc. is either the word "register" or null, depending on whether the C compiler pays attention to this many register declarations. The intent is that you don't have to order your register declarations in the order of importance, so you can freely declare register variables in sub-blocks of code and as function parameters. Do not use register more than once per routine. registers: Unit: registers (Also defines reg1 reg2 reg3 reg4 reg5 reg6 reg7 reg8 reg9 reg10 reg11 reg12 reg13 reg14 reg15 reg16) Wants: awk rm Cppsym Myread Oldconfig This variable contains the number of register declarations paid attention to by the C compiler. relsrcdir: Obsoleted by rsrc. rindex: Magic symbol, needs: HAS_INDEX Unit: d_strchr (Also defines d_index) Wants: contains strings Setvar Myread Oldconfig Csym #ifndef HAS_INDEX #ifndef rindex #define rindex strrchr #endif #endif rootid: Unit: rootid Wants: sed This variable contains the eventual value of the ROOTID symbol, which is the uid of root. rsrc: Unit: src (With private rsrc) Wants: Options package contains This variable holds a potentially relative path to the package source. The contents are correct for the configuration environment, i.e. there might be an extra .. prepended to get out of the UU dir. Configure units should use this, not the src variable. run: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This variable contains the command used by Configure to copy and execute a cross-compiled executable in the target host. Useful and available only during the build. Empty string '' if not cross-compiling. runnm: Unit: usenm (Also defines runnm nm_opt nm_so_opt) Wants: cat test Myread Oldconfig grep d_gnulibc nm egrep rsrc osname Guess This variable contains 'true' or 'false' depending whether the nm extraction should be performed or not, according to the value of usenm and the flags on the Configure command line. sbrksmart: Unit: sbrksmart Wants: cat d_sbrk rm Optional: cc ccflags libs This variable conditionally defines HAS_SMART_SBRK if the sbrk() routine honors a negative argument to lower the break value. sbrktype: Unit: sbrktype Wants: Myread Oldconfig Loc contains Findhdr This variable defines sbrktype to be something like caddr_t, char *, or whatever type is used to declare sbrk() in the kernel. scriptdir: Unit: scriptdir (Also defines scriptdirexp installscript) Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup Optional: bin This variable holds the name of the directory in which the user wants to put publicly scripts for the package in question. It is either the same directory as for binaries, or a special one that can be mounted across different architectures, like /usr/share. Programs must be prepared to deal with ~name expansion. scriptdirexp: Unit: scriptdir (Also defines scriptdirexp installscript) Wants: afs cat test Getfile Loc Oldconfig Prefixit prefixexp Prefixup Optional: bin This variable is the same as scriptdir, but is filename expanded at configuration time, for programs not wanting to bother with it. seedfunc: Unit: randfunc (Also defines mrand seedfunc nrandbits) Wants: cat rm test Myread Csym Optional: cc Indicates the random number generating seed function. Values include srand48, srandom, and srand. seednrand: Unit: randfunc (Also defines mrand seedfunc nrandbits) Wants: cat rm test Myread Csym Optional: cc This symbol defines the macro to be used in seeding the random number generator (see nrand). selecttype: Unit: selecttype Wants: cat rm Oldconfig Myread d_fd_set d_select d_socket i_systime i_sysselct Optional: cc ccflags This variable holds the type used for the 2nd, 3rd, and 4th arguments to select. Usually, this is 'fd_set *', if HAS_FD_SET is defined, and 'int *' otherwise. This is only useful if you have select(), naturally. serve_inet_tcp: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_INET_TCP, which tells the C program to enable InterNet-domain TCP support for IPC. serve_inet_udp: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_INET_UDP, which tells the C program to enable InterNet-domain UDP support for IPC. serve_msg: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_MSG, which tells the C program to use USG message queues for IPC. serve_shm: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_SHM, which tells the C program to use USG shared memory for IPC. serve_unix_tcp: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_UNIX_TCP, which tells the C program to enable Unix-domain TCP support for IPC. serve_unix_udp: Unit: ipc (Also defines serve_shm serve_msg serve_inet_udp serve_inet_tcp serve_unix_udp serve_unix_tcp) Wants: test Myread Oldconfig d_socket d_msg d_shm d_sem This variable controls the definition of SERVE_UNIX_UDP, which tells the C program to enable Unix-domain UDP support for IPC. setvar: Unit: Setvar Wants: Whoa This shell variable is used internally by Configure to set a value to a given symbol that is defined or not. A typical use is: val= set d_variable eval $setvar That will print a message in case the $val value is not the same as the previous value of $d_variable. sh: Unit: sh Wants: Head This variable contains the full pathname of the shell used on this system to execute Bourne shell scripts. Usually, this will be /bin/sh, though it's possible that some systems will have /bin/ksh, /bin/pdksh, /bin/ash, /bin/bash, or even something such as D:/bin/sh.exe. This unit comes before Options.U, so you can't set sh with a -D option, though you can override this (and startsh) with -O -Dsh=/bin/whatever -Dstartsh=whatever sharpbang: Unit: spitshell (Also defines shsharp sharpbang) Wants: eunicefix sh Head This variable contains the string #! if this system supports that construct. shm_att: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This variable tells us where a shared memory segment should be attached. Good values are HIGH, LOW, and ZERO. shm_for: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This variable tells us the type of machine we're expecting the shared memory code to run on. The value is available to C programs in the C_SHM_FOR manifest. shm_lim: Unit: shm_for (Also defines shm_att shm_lim) Wants: Cppsym Myread ipc uname This variable tells us if shared memory attached HIGH should have an upper limit. shmattype: Unit: d_shmat (Also defines shmattype d_shmatprototype) Wants: Inlibc cat rm cppstdin cppflags cppminus Findhdr Setvar contains Optional: cc ccflags This symbol contains the type of pointer returned by shmat(). It can be 'void *' or 'char *'. shortsize: Unit: intsize (Also defines longsize shortsize) Wants: Myread cat rm Optional: cc optimize ccflags ldflags libs This variable contains the value of the SHORTSIZE symbol which indicates to the C program how many bytes there are in a short. shsharp: Unit: spitshell (Also defines shsharp sharpbang) Wants: eunicefix sh Head This variable tells further Configure units whether your sh can handle # comments. sig_count: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable holds a number larger than the largest valid signal number. This is usually the same as the NSIG macro. sig_name: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable holds the signal names, space separated. The leading SIG in signal name is removed. A ZERO is prepended to the list. This is currently not used. sig_name.U: Obsoleted by sig_count. sig_name_init: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable holds the signal names, enclosed in double quotes and separated by commas, suitable for use in the SIG_NAME definition below. A "ZERO" is prepended to the list, and the list is terminated with a plain 0. The leading SIG in signal names is removed. See sig_num. sig_num: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable holds the signal numbers, space separated. A ZERO is prepended to the list (corresponding to the fake SIGZERO), and the list is terminated with a 0. Those numbers correspond to the value of the signal listed in the same place within the sig_name list. sig_num_init: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable holds the signal numbers, enclosed in double quotes and separated by commas, suitable for use in the SIG_NUM definition below. A "ZERO" is prepended to the list, and the list is terminated with a plain 0. sig_size: Unit: sig_name (Also defines sig_name_init sig_num sig_num_init sig_count sig_size) Wants: awk Signal Oldconfig rm This variable contains the number of elements of the sig_name and sig_num arrays, excluding the final NULL entry. signal_t: Unit: d_voidsig (Also defines signal_t) Wants: rm contains cppstdin cppminus test Myread Oldconfig Setvar Findhdr Optional: cppflags This variable holds the type of the signal handler (void or int). sitearch: Unit: sitearch (Also defines sitearchexp installsitearch) Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib This variable contains the eventual value of the SITEARCH symbol, which is the name of the private library for this package. It may have a ~ on the front. It is up to the makefile to eventually create this directory while performing installation (with ~ substitution). sitearchexp: Unit: sitearch (Also defines sitearchexp installsitearch) Wants: afs cat Getfile Oldconfig Prefixit prefix test archname sitelib This variable is the ~name expanded version of sitearch, so that you may use it directly in Makefiles or shell scripts. sitelib: Unit: sitelib (Also defines sitelibexp installsitelib) Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed This variable contains the eventual value of the SITELIB symbol, which is the name of the private library for this package. It may have a ~ on the front. It is up to the makefile to eventually create this directory while performing installation (with ~ substitution). sitelibexp: Unit: sitelib (Also defines sitelibexp installsitelib) Wants: afs cat Getfile Oldconfig Prefixit test privlib package sed This variable is the ~name expanded version of sitelib, so that you may use it directly in Makefiles or shell scripts. sizetype: Unit: sizetype Wants: Myread Typedef This variable defines sizetype to be something like size_t, unsigned long, or whatever type is used to declare length parameters for string functions. small: Unit: models (Also defines split small medium large huge) Wants: test cat Myread sysman Oldconfig Loc Warn contains rm This variable contains a flag which will tell the C compiler and loader to produce a program running with a small memory model. It is up to the Makefile to use this. so: Unit: so Wants: test libpth Loc Myread Oldconfig cat This variable holds the extension used to identify shared libraries (also known as shared objects) on the system. Usually set to 'so'. sockethdr: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This variable has any cpp -I flags needed for socket support. socketlib: Unit: d_socket (Also defines d_oldsock d_sockpair socketlib sockethdr) Wants: contains libc echo n c nm_opt nm_extract Inlibc Csym _a This variable has the names of any libraries needed for socket support. spackage: Unit: package (Also defines spackage) Wants: Nothing This variable contains the name of the package being constructed, with the first letter uppercased, i.e. suitable for starting sentences. spitshell: Unit: spitshell (Also defines shsharp sharpbang) Wants: eunicefix sh Head This variable contains the command necessary to spit out a runnable shell on this system. It is either cat or a grep -v for # comments. split: Unit: models (Also defines split small medium large huge) Wants: test cat Myread sysman Oldconfig Loc Warn contains rm This variable contains a flag which will tell the C compiler and loader to produce a program that will run in separate I and D space, for those machines that support separation of instruction and data space. It is up to the Makefile to use this. src: Unit: src (With private rsrc) Wants: Options package contains This variable holds the (possibly relative) path of the package source. It is up to the Makefile to use this variable and set VPATH accordingly to find the sources remotely. Use $pkgsrc to have an absolute path. srcdir: Obsoleted by src. ssizetype: Unit: ssizetype Wants: Myread Typedef sizetype cat rm _o Optional: cc optimize ccflags ldflags libs This variable defines ssizetype to be something like ssize_t, long or int. It is used by functions that return a count of bytes or an error condition. It must be a signed type. We will pick a type such that sizeof(SSize_t) == sizeof(Size_t). startperl: Unit: startperl Wants: cat rm sharpbang perlpath d_portable Myread This variable contains the string to put on the front of a perl script to make sure (hopefully) that it runs with perl and not some shell. Of course, that leading line must be followed by the classical perl idiom: eval 'exec perl -S $0 ${1+"$@"}' if $running_under_some_shell; to guarantee perl startup should the shell execute the script. Note that this magic incatation is not understood by csh. startsh: Unit: startsh Wants: sh sharpbang eunicefix This variable contains the string to put on the front of a shell script to make sure (hopefully) that it runs with sh and not some other shell. statedist: Unit: locdist (Also defines orgdist citydist statedist multistatedist cntrydist contdist) Wants: test newslibexp cat Myread Oldconfig This variable contains the eventual value of the STATEDIST symbol, which is the state's or province's distribution name for news. stdchar: Unit: stdchar Wants: contains Findhdr cppstdin cppminus rm This variable conditionally defines STDCHAR to be the type of char used in stdio.h. It has the values "unsigned char" or "char". stdio_base: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable defines how, given a FILE pointer, fp, to access the _base field (or equivalent) of stdio.h's FILE structure. This will be used to define the macro FILE_base(fp). stdio_bufsiz: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable defines how, given a FILE pointer, fp, to determine the number of bytes store in the I/O buffer pointer to by the _base field (or equivalent) of stdio.h's FILE structure. This will be used to define the macro FILE_bufsiz(fp). stdio_cnt: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable defines how, given a FILE pointer, fp, to access the _cnt field (or equivalent) of stdio.h's FILE structure. This will be used to define the macro FILE_cnt(fp). stdio_filbuf: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable defines how, given a FILE pointer, fp, to tell stdio to refill it's internal buffers (?). This will be used to define the macro FILE_filbuf(fp). stdio_ptr: Unit: d_stdstdio (Also defines d_stdiobase stdio_ptr stdio_cnt stdio_base stdio_bufsiz d_stdio_cnt_lval d_stdio_ptr_lval stdio_filbuf) Wants: cat contains rm Setvar Findhdr Oldconfig Optional: cc ccflags ldflags libs This variable defines how, given a FILE pointer, fp, to access the _ptr field (or equivalent) of stdio.h's FILE structure. This will be used to define the macro FILE_ptr(fp). strings: Unit: i_string (Also defines strings) Wants: test Setvar Findhdr Warn This variable holds the full path of the string header that will be used. Typically /usr/include/string.h or /usr/include/strings.h. sunscanf: Unit: sunscanf Wants: cat rm Myread test Setvar Optional: cc ccflags This variable is set if this system runs with the Sun version of scanf. sysman: Unit: sysman Wants: test Loc Oldconfig This variable holds the place where the manual is located on this system. It is not the place where the user wants to put his manual pages. Rather it is the place where Configure may look to find manual for unix commands (section 1 of the manual usually). See mansrc. tablesize: Unit: d_NOFILE (Also defines nofile d_gettblsz tablesize) Wants: Myread Guess cat test rm Csym Optional: cc ccflags libs This variable contains either the 'NOFILE' constant or 'ulimit(4, 0L)' and is used as the remapped value for the getdtablesize() macro. targetarch: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod If cross-compiling, this variable contains the target architecture. If not, this will be empty. termlib: Unit: d_havetlib (Also defines termlib) Wants: cat contains Myread Loc Filexp Oldconfig libpth test uname _a _o This variable contains the argument to pass to the loader to get termlib-style routines. It is up to the Makefile.SH to make sure the value gets to the right command. Note that on many systems the termlib routines are emulated by the curses or terminfo library. timeincl: Unit: i_time (Also defines i_systime i_systimek timeincl) Wants: cat cc ccflags contains rm echo n c Findhdr Optional: i_sysselct This variable holds the full path of the included time header(s). timetype: Unit: d_time (Also defines timetype) Wants: Csym Setvar Findhdr Myread Typedef This variable holds the type returned by time(). It can be long, or time_t on BSD sites (in which case should be included). Anyway, the type Time_t should be used. to: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This variable contains the command used by Configure to copy to from the target host. Useful and available only during the build. The string ':' if not cross-compiling. trnl: Unit: trnl Wants: Nothing This variable contains the value to be passed to the tr(1) command to transliterate a newline. Typical values are '\012' and '\n'. This is needed for EBCDIC systems where newline is not necessarily '\012'. typedef: Unit: Typedef Wants: cppstdin cppminus cppflags rm contains Oldconfig This shell variable is used internally by Configure to check wether a given typedef is defined or not. A typical use is: set typedef val_t default [includes] eval $typedef That will return val_t set to default if the typedef was not found, to typedef otherwise. If no includes are specified, look in sys/types.h. uidtype: Unit: uidtype Wants: Myread Typedef Findhdr This variable defines Uid_t to be something like uid_t, int, ushort, or whatever type is used to declare user ids in the kernel. usecrosscompile: Unit: Cross (Also defines run to from targetarch usecrosscompile) Wants: src awk cat grep test rm echo sed mkdir cp touch chmod This variable conditionally defines the USE_CROSS_COMPILE symbol, and indicates that our package has been cross-compiled. usemymalloc: Unit: mallocsrc (Also defines mallocobj usemymalloc malloctype d_mymalloc freetype) Wants: Myread Oldconfig package Guess Setvar rm cat Findhdr i_malloc i_stdlib sed libs _o ptrsize Optional: cc ccflags This variable contains y if the malloc that comes with this package is desired over the system's version of malloc. People often include special versions of malloc for effiency, but such versions are often less portable. See also mallocsrc and mallocobj. If this is 'y', then -lmalloc is removed from $libs. usenm: Unit: usenm (Also defines runnm nm_opt nm_so_opt) Wants: cat test Myread Oldconfig grep d_gnulibc nm egrep rsrc osname Guess This variable contains 'true' or 'false' depending whether the nm extraction is wanted or not. usermail: Unit: MailAuthor (Also defines mailpatches notifypatches usermail) Wants: test cat mailer package Myread patchlevel baserev rm rsrc Oldconfig Configdir This variable is used internally by Configure to keep track of the user e-mail address, where notifications or patches should be sent. A '-' value means the return address will be extracted by parsing the mail headers. usesocks: Unit: usesocks Wants: Myread Oldconfig Setvar spackage package This variable conditionally defines the USE_SOCKS symbol, and indicates that Perl should be built to use SOCKS. usevfork: Unit: d_vfork (Also defines usevfork) Wants: Inlibc Myread Oldconfig Setvar This variable is set to true when the user accepts to use vfork. It is set to false when no vfork is available or when the user explicitely requests not to use vfork. usrinc: Unit: usrinc (Also defines incpath mips_type) Wants: test cat echo n c Getfile Guess Oldconfig eunicefix contains rm This variable holds the path of the include files, which is usually /usr/include. It is mainly used by other Configure units. vaproto: Unit: vaproto Wants: prototype i_stdarg Setvar This variable conditionally defines CAN_VAPROTO on systems supporting prototype declaration of functions with a variable number of arguments. See also prototype. vfork: Magic symbol, needs: HAS_VFORK Unit: d_vfork (Also defines usevfork) Wants: Inlibc Myread Oldconfig Setvar #ifndef HAS_VFORK #define vfork fork #endif voidflags: Unit: voidflags (Also defines defvoidused) Wants: cat sed rm contains package Oldconfig Myread Optional: cc ccflags This variable contains the eventual value of the VOIDFLAGS symbol, which indicates how much support of the void type is given by this compiler. See VOIDFLAGS for more info. warnflags: Unit: warnflags Wants: cat cc contains Myread Guess Oldconfig Findhdr This variable contains any additional C compiler flags to generate warnings from the compiler. It is up to the Makefile to use this. xlibpth: Unit: libpth (Also defines glibpth xlibpth plibpth loclibpth) Wants: usrinc incpath test cat Myread Oldconfig This variable holds extra path (space-separated) used to find libraries on this platform, for example CPU-specific libraries (on multi-CPU platforms) may be listed here. yacc: Unit: yacc (Also defines yaccflags) Wants: Guess Myread Loc Oldconfig byacc bison cat test This variable holds the name of the compiler compiler we want to use in the Makefile. It can be yacc, byacc, or bison -y. yaccflags: Unit: yacc (Also defines yaccflags) Wants: Guess Myread Loc Oldconfig byacc bison cat test This variable contains any additional yacc flags desired by the user. It is up to the Makefile to use this. metaconfig-debian-perl-5.26.1/dist/Index000066400000000000000000001510231316016665300200470ustar00rootroot00000000000000[This Index is automatically generated from Jmake.rules file. Do not edit this file or your changes will be lost. Edit Jmake.rules instead.] This file contains a listing of all the macros that can be used in a Jmakefile. Only a few of these should be used in the Jmakefile (they are the top-level macros). However, some low-level ones may be useful, but it is up to you to make that decision. This explains why this file holds all the available macros for jmake. In the following listing, the macros are separated by a line of dashes. The signature of the macro is given, then a small comment of what it does precedes the actual definition. Lines preceded by '->' show the set of symbols defined when the macro is used. Initialization lines are shown as-is, i.e. have the form SYM = val while concatenation is shown by SYM += val (which means val is added to the value of SYM). Conditional lines are preceded by tests like (if SYM). This means the line is to be kept if and only if the symbol SYM is defined. Other internal requests are not formatted yet. ------------------------------------------------------------------------ AddSuffix(ext): Adds a sufix to the .SUFFIXES: list. .SUFFIXES: ext ------------------------------------------------------------------------ AddedByConfigure(files): Gives name of the files generated by Configure that can safely be removed when a "make clobber" is issued. Not that it is useless to name config.h or config.sh because these are already taken care of by jmake. local_clobber:: $(RM) files ------------------------------------------------------------------------ AliasedLibraryTarget(libname,alias): Generate rules to link one library to another. AllTarget(lib/**/alias.a) lib/**/alias.a: lib^^libname.a $(RM) $@ $(LN) lib/**/libname.a $@ ------------------------------------------------------------------------ AllTarget(depends): Generate rules to build necessary things during make all. all:: depends local_realclean:: $(RM) depends ------------------------------------------------------------------------ BuildMakefile(): Generate rules to build a Makefile from a Makefile.SH. Makefile: Makefile.SH /bin/sh Makefile.SH ------------------------------------------------------------------------ BuildMakefileSH(jmakeflags): Generate rules to build a Makefile.SH from an Jmakefile and any special jmake flags. This is generally done automatically by the template or by any special Jmakefiles. This function will simply touch Makefile.SH if no $(TOP)/.package exists, assuming the Jmakefile is not in a production environment. Makefile.SH: Jmakefile -@if test -f $(TOP)/.package; then \ if test -f Makefile.SH; then \ echo " $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~"; \ $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~; \ fi; \ echo " $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT)" jmakeflags; \ $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT) jmakeflags; \ else touch $@; fi ------------------------------------------------------------------------ CleanSubdirs(): Generate rules to recursively clean out garbage files. NamedDepthTargetSubdirs(clean,"Cleaning",/**/) NamedDepthTargetSubdirs(realclean,"Real cleaning",/**/) NamedDepthTargetSubdirs(clobber,"Clobbering",/**/) ------------------------------------------------------------------------ CleanTarget(): Generate rules to remove any garbage files. (if SUBDIRS) clean: sub_clean local_clean (not SUBDIRS) clean: local_clean (if SUBDIRS) realclean: sub_realclean local_realclean (not SUBDIRS) realclean: local_realclean (if SUBDIRS) clobber: sub_clobber local_clobber (not SUBDIRS) clobber: local_clobber local_clean:: if test -f core; then $(RM) core; fi $(RM) *~ *.o local_realclean:: local_clean (if TOP) $(RM) -r UU local_clobber:: local_realclean (not TOP) $(RM) Makefile config.sh (if TOP) $(RM) config.sh config.h (if TOP) $(RM) -r .config (if TOP) $(RM) Makefile ------------------------------------------------------------------------ CommonSubdirsRule(dirs): Rule for making $(TARGET) in every subdirectory, with $(VERB) as verbose message and $(FLAGS) as additional flags. subdirs: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in dirs ;\ do \ (cd $$i ; echo $(VERB) "in $(DIR)$$i..."; \ $(MAKE) $(MFLAGS) $(FLAGS) $(TARGET)) || exit 1; \ done ------------------------------------------------------------------------ ComplexProgramTarget(program): Generate rules for compiling and linking the program specified by $(OBJS) and $(SRCS), installing the program and its man page, and generating dependencies. It should only be used in Jmakefiles that describe a single program. OBJECTS += $(OBJS) SOURCES += $(SRCS) NormalObjectRule() AllTarget(program) program: $(OBJS) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) DependTarget() LintTarget() ------------------------------------------------------------------------ ComplexProgramTarget_1(program): Generate rules for compiling and linking the program specified by $(OBJS1) and $(SRCS1), installing the program and its man page, and generating dependencies for it and any programs described by $(SRCS2) and $(SRCS3). It should be used to build the primary program in Jmakefiles that describe multiple programs. OBJECTS += $(OBJS1) SOURCES += $(SRCS1) NormalObjectRule() AllTarget(program) program: $(OBJS1) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS1) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) DependTarget() LintTarget() ------------------------------------------------------------------------ ComplexProgramTarget_2(program): Generate rules for compiling and linking the program specified by $(OBJS2) and $(SRCS2) and installing the program and man page. It should be used to build the second program in Jmakefiles describing more than one program. OBJECTS += $(OBJS2) SOURCES += $(SRCS2) NormalObjectRule() AllTarget(program) program: $(OBJS2) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS2) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) ------------------------------------------------------------------------ ComplexProgramTarget_3(program): Generate rules for compiling and linking the program specified by $(OBJS3) and $(SRCS3) and installing the program and man page. It should be used to build the third program in Jmakefiles describing more than one program. OBJECTS += $(OBJS3) SOURCES += $(SRCS3) NormalObjectRule() AllTarget(program) program: $(OBJS3) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS3) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) ------------------------------------------------------------------------ ComplexShellManualTarget(manpages): Builds manual pages that are to be extracted from .SH files into .$manext files. MANPAGE += manpages |once _ShellManualRule_ .SH.$manext: /bin/sh $< -once AddSuffix(.SH) AddSuffix(.$manext) AllTarget(manpages) local_install.man:: _MakeInstallDirIgnore($(MANSRC)) \ for file in manpages; do \ (set -x; $(INSTALL) -c -m 444 $$file \ $(INSTALL_PREFIX)$(MANSRC)) || exit 1; \ done local_deinstall.man:: @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for file in manpages; do \ (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file); \ done ------------------------------------------------------------------------ ComplexYaccInclude(base,prefix): Declare that program will need an include file produced by the output of yacc on base.y, which typically produces a file named y.tab.h, which will be renamed as base.h. The difference with SimpleYaccInclude is the identifying process of the y.tab.h file where all 'yy' are renamed to prefix. The only problem is that the dependencies towards base.h have to be manually given in the Jmakefile. base.h: base.c @if test -f y.tab.h; then \ echo " $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h"; \ $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h; \ echo " $(RM) y.tab.h"; \ $(RM) y.tab.h; \ elif test -f base.h; then \ echo " $(CP) base.h base.ht"; \ $(CP) base.h base.ht; \ echo " $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h"; \ $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h; \ echo " $(RM) base.ht"; \ $(RM) base.ht; \ fi local_realclean:: $(RM) base.h ------------------------------------------------------------------------ ComplexYaccTarget(program,base,prefix): Declare a yacc base.y file to be used in the building of the specified target program. The source file must be given without its final .y extension. The name of the .c and .o will be derived from the source file basename provided. The difference with SimpleYaccTarget is the identifying process where all the 'yy' are replaced by the specified prefix. SOURCES += base.y OBJECTS += base.o program: base.c base.c: base.y $(YACC) $(JYFLAGS) base.y $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.c > base.c $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h $(RM) y.tab.c y.tab.h local_realclean:: $(RM) base.c ------------------------------------------------------------------------ CppScriptTarget(dst,src,defs,deplist): Generate rules to create a shell script by running the input through cpp. dst:: src deplist $(RM) $@ $(CPP) defs $@ chmod a+x $@ ------------------------------------------------------------------------ DebuggedAndProfiledLibraryObjectRule(): Generate make rules to build debuggable, profiled, and "normal" objects. all:: @if [ ! -d profiled ]; then mkdir profiled; fi @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ profiled/$@ debugger/$@ $(CC) -pg -c $(JCFLAGS) $*.c $(MV) $*.o profiled/$*.o $(CC) -g -c $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d profiled ]; then echo " $(RM) profiled/?*.o"; \ $(RM) profiled/?*.o; fi -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ DebuggedLibraryObjectRule(): Generate make rules to build both debuggable and "normal" objects. all:: @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ debugger/$@ $(CC) -g -c $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ DebuggedLibraryTarget(libname,srclist,objlist): Generate rules to create a debuggable library. SOURCES += srclist OBJECTS += objlist AllTarget(lib/**/libname^^_d.a) lib/**/libname^^_d.a: objlist $(RM) $@ cd debugger; $(AR) ../$@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ DebuggedRelocatableTarget(objname,objlist): Generate rules to produce a debuggable relocatable object file instead of a library. AllTarget(objname/**/_d.o) objname/**/_d.o: objlist $(RM) $@ $(LD) -X -r objlist -o $@ ------------------------------------------------------------------------ DeinstallMultipleDest(step,list,dest): Generate rules to deinstall multiple files at once during a particular step in the build. step:: @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for i in list; do \ (set -x; $(RM) $(INSTALL_PREFIX)/***/dest/$$i); \ done ------------------------------------------------------------------------ DependDependency(): Generate rules to build the makedepend program. depend:: TOPDIR/mkdep TOPDIR/mkdep: (if TOP) @echo "You have to run Configure first."; exit 1 (not TOP) @echo "You have to run Configure in $(TOP) first."; exit 1 ------------------------------------------------------------------------ DependDirs(dirs): Generate rules to recursively compute dependencies as part of the make depend step. NamedTargetSubdirsRule(dirs,depend,"Depending",/**/) ------------------------------------------------------------------------ DependSubdirs(): Generate rules to recursively compute dependencies as part of the make depend step. DependDirs($(SUBDIRS)) ------------------------------------------------------------------------ DependTarget(): Generate rules to compute dependencies for all files listed in $(SOURCES) (automatically generated macro). USRINC = $usrinc |once _DependTarget_ DependDependency() depend:: ($(SED) '/^# DO NOT DELETE/q' Makefile && \ $(MKDEP) $(SOURCES) | \ $(SED) -e 's:/usr/lib[^ ]*::g; s:$(USRINC)[^ ]*::g; ' \ -e '/: / b print' -e '$$ b print' -e 'H; d; n; : print' \ -e 'x; s/\\$$//; s/\\\n//g; s/ /**/ */ /g; s/ :/:/;' -e '/: *$$/d' \ ) > Makefile.new cp Makefile Makefile.bak cp Makefile.new Makefile $(RM) Makefile.new -once ------------------------------------------------------------------------ Expand(rule, pattern): This powerful macro expands the `rule' given a `pattern'. It relies on a built-in command in jmake. The expansion is documented in the short notes file that comes with jmake and gives some insights on the internal syntax. |expand pattern rule -expand ------------------------------------------------------------------------ ForceTarget(): The force target will force reconstruction of all the other targets which include .FORCE in their own dependencies. |once _force_ .FORCE: -once ------------------------------------------------------------------------ IdentifiedLexDependTarget(program,base,parser,prefix): Declare that program will need an include file produced by the output of lex on base.l, which typically produces a file named lex.yy.c which will be renamed as base.c. Besides, the lexical analyzer needs the file parser.h produced by running parser.y through yacc and renaming y.tab.h as parser.h. The lexical analyzer is identified with the supplied prefix, which replaces the regular 'yy' prefix in the symbol names. base.o: parser.h IdentifiedLexTarget(program,base,prefix) ------------------------------------------------------------------------ IdentifiedLexTarget(program,base,prefix): This declares a lex base.l file which is to be ran through lex to produce a base.c file. The prefix is used to replace the 'yy', so that the lexical analyzer may be identified. SOURCES += base.l OBJECTS += base.o program: base.c base.c: base.l $(LEX) $(JLFLAGS) base.l $(SED) -e 's/yy\(.\)/prefix\1/g' < lex.yy.c > base.c $(RM) lex.yy.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ IdentifiedParserTarget(program,lexic,parser,prefix): Specify that program is using the lex/yacc combination to produce a parser. The lexic and parser parameters are the base name of the .l and .y file, respectively. The parser produced is identified via its prefix, which replaces all the normally supplied 'yy' prefix, hence making it possible to have multiple parsers in a single executable. IdentifiedLexDependTarget(program,lexic,parser,prefix) IdentifiedYaccTarget(program,parser,prefix) ------------------------------------------------------------------------ IdentifiedYaccTarget(program,base,prefix): Declare a yacc base.y file which should produce a base.c and base.h file as derived from the output of yacc, to be used by the specified program. The specified prefix is used to remplace all the 'yy' in the generated file, for use when more than a single parser is needed in one executable. ComplexYaccTarget(program,base,prefix) ComplexYaccInclude(base,prefix) ------------------------------------------------------------------------ IncludesSubdirs(): Generate rules to recursively put include files in build NamedTargetSubdirs(includes,including,/**/) ------------------------------------------------------------------------ Initialize(symbol,value): Puts the line symbol = value in the initialization section of Makefile.SH (the one that is subject to parameter substitutions). symbol = value ------------------------------------------------------------------------ InstallLibrary(libname,dest): Generate rules to install the indicated library. local_install:: lib/**/libname.a _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 644 lib/**/libname.a $(INSTALL_PREFIX)/***/dest $(RANLIB) dest/lib/**/libname.a chmod 444 dest/lib/**/libnane.a local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.a ------------------------------------------------------------------------ InstallLibraryAlias(libname,alias,dest): Generate rules to create a link from one library name to another for the purposes of aliasing. local_install:: lib/**/libname.a $(RM) lib/**/alias.a -(cd dest; $(LN) lib/**/libname.a lib^^alias.a) local_deinstall:: $(RM) dest/lib/**/alias.a ------------------------------------------------------------------------ InstallLintLibrary(libname,dest): Generate rules to install the indicated lint library. install.ln:: llib-l/**/libname.ln _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 llib-l/**/libname.ln $(INSTALL_PREFIX)/***/dest deinstall.ln:: $(RM) $(INSTALL_PREFIX)/***/dest/llib-l/**/libname.ln ------------------------------------------------------------------------ InstallManPage(file,dest): Generate rules to install the indicated manual page. InstallManPageLong(file,dest,file) ------------------------------------------------------------------------ InstallManPageLong(file,destdir,dest): Generate rules to install the indicated manual page, giving it an alternate name. This is used for installing man pages whose base name without the .man suffix would normally be longer than 8 characters (the limit for using source code control systems on files systems with short file names). local_install.man:: file.man _MakeInstallDirIgnore(destdir) \ $(INSTALL) -c -m 444 file.man $(INSTALL_PREFIX)/***/destdir/dest.$(L) local_deinstall.man:: $(RM) $(INSTALL_PREFIX)/***/destdir/dest.$(L) ------------------------------------------------------------------------ InstallManScripts(): Generate rule to install/deinstall manual pages for scripts listed in the automatically generated $(SCRIPTS) macro. |once _InstallManScripts_ #ifndef NOMAN local_install.man:: _MakeInstallDirIgnore($(MANSRC)) \ for file in $(SCRIPTS); do \ if test -f $$file.man; then \ (set -x; \ $(INSTALL) -c -m 444 $$file.man \ $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)) || \ exit 1; \ fi; \ done local_deinstall.man:: case '${MFLAGS}' in *[i]*) set +e;; esac; \ for file in $(SCRIPTS); do \ (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)); \ done #endif -once ------------------------------------------------------------------------ InstallManSubdirs(): Generate rules to recursively install and deinstall manual pages. NamedSubTargetSubdirs(install.man,"Installing man pages",/**/) NamedDepthTargetSubdirs(deinstall.man,"Deinstalling man pages",/**/) ------------------------------------------------------------------------ InstallMultiple(list,dest): Generate rules to install multiple files at once during the install step of the build using any install flags set in $(INSTALLFLAGS) and deinstall them. InstallMultipleDestFlags(local_install,list,dest,$(INSTALLFLAGS)) DeinstallMultipleDest(local_deinstall,list,dest) ------------------------------------------------------------------------ InstallMultipleDestFlags(step,list,dest,flags): Generate rules to install multiple files at once during a particular step in the build using a specific set of install flags. step:: list _MakeInstallDirIgnore(dest) \ for i in list; do \ (set -x; $(INSTALL) -c flags \ $$i $(INSTALL_PREFIX)/***/dest) || exit 1;\ done ------------------------------------------------------------------------ InstallMultipleFlags(list,dest,flags): Generate rules to install multiple files at once during the install step of the build using the given install flags. InstallMultipleDestFlags(local_install,list,dest,flags) DeinstallMultipleDest(local_deinstall,list,dest) ------------------------------------------------------------------------ InstallMultipleMan(list,dest): Generate rules to install a variety of manual pages during the install.man step of the build. InstallMultipleDestFlags(local_install.man,list,dest,$(INSTALLFLAGS)) DeinstallMultipleDest(local_deinstall.man,list,dest) ------------------------------------------------------------------------ InstallNonExec(file,dest): Generate rules to install a data file using any special install flags. local_install:: file _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 file $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/file ------------------------------------------------------------------------ InstallProgram(program,dest): Generate rules to install an executable program using any special install flags set in $(INSTALLFLAGS). InstallProgramWithFlags(program,dest,/**/) ------------------------------------------------------------------------ InstallProgramNoStrip(program,dest): Generate rules to install an executable program using any special install flags set in $(INSTALLFLAGS), but without stripping the executable from debugging symbols. InstallProgramNoStripWithFlags(program,dest,/**/) ------------------------------------------------------------------------ InstallProgramNoStripWithFlags(program,dest,flags): Generate rules to install an executable program using given install flags. local_install:: program _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE) ------------------------------------------------------------------------ InstallProgramWithFlags(program,dest,flags): Generate rules to install an executable program using given install flags. local_install:: program _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -s -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE) ------------------------------------------------------------------------ InstallScript(script,dest): Generate rules to install an executable script using any special install flags set in $(INSTALLFLAGS). InstallScriptWithFlags(script,dest,/**/) ------------------------------------------------------------------------ InstallScriptWithFlags(script,dest,flags): Generate rules to install an executable script using given install flags. local_install:: script _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 555 flags script $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/script ------------------------------------------------------------------------ InstallScripts(): Generate rules to install all the scripts listed in the generated $(SCRIPTS) and $(LSCRIPTS) macros. |once _InstallScripts_ local_install:: $(SCRIPTS) $(LSCRIPTS) _MakeInstallDirIgnore($(SCRIPTDIR)) \ for file in $(SCRIPTS) $(LSCRIPTS); do \ (set -x; \ $(INSTALL) -c -m 555 $$file $(INSTALL_PREFIX)$(SCRIPTDIR)) || \ exit 1; \ done local_deinstall:: @for file in $(SCRIPTS) $(LSCRIPTS); do \ case '${MFLAGS}' in *[i]*) set +e;; esac; \ (set -x; $(RM) $(INSTALL_PREFIX)$(SCRIPTDIR)/$$file); \ done -once ------------------------------------------------------------------------ InstallSharedLibrary(libname,rev,dest): Generate rules to install the shared library. local_install:: lib/**/libname.so.rev _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 lib/**/libname.so.rev $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.so.rev ------------------------------------------------------------------------ InstallSharedLibraryData(libname,rev,dest): Generate rules to install the shared library data local_install:: lib/**/libname.sa.rev _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 lib/**/libname.sa.rev $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.sa.rev ------------------------------------------------------------------------ InstallSubdirs(): Generate rules to recursively install and deinstall programs and files. NamedSubTargetSubdirs(install,"Installing",/**/) NamedDepthTargetSubdirs(deinstall,"Deinstalling",/**/) ------------------------------------------------------------------------ InstallTarget(): Generate rules to recursively install files (if SUBDIRS) install:: local_install sub_install (not SUBDIRS) install:: local_install (if SUBDIRS) install.man:: maybe_install.man sub_install.man (not SUBDIRS) install.man:: maybe_install.man (if SUBDIRS) deinstall:: sub_deinstall local_deinstall (not SUBDIRS) deinstall:: local_deinstall (if SUBDIRS) deinstall.man:: sub_deinstall.man maybe_deinstall.man (not SUBDIRS) deinstall.man:: maybe_deinstall.man (if MANSRC) install.man-yes: local_install.man install.man-no: (if MANSRC) deinstall.man-yes: local_deinstall.man deinstall.man-no: ------------------------------------------------------------------------ LinkFileList(step,list,dir,sub): Link a list of list of files from one place to another step:: list @case '${MFLAGS}' in *[i]*) set +e;; esac; \ echo " cd" dir; cd dir; for i in list; do (set -x; $(LN) sub/$$i .); done ------------------------------------------------------------------------ LinkSourceFile(src,dir): Snag source file from some other directory src: dir/src $(RM) $@ $(LN) $? $@ ------------------------------------------------------------------------ LintDirs(dirs): Generate rules to recursively lint directories as part of the make lint step. MakeLintSubdirs(dirs,lint) ------------------------------------------------------------------------ LintLibraryTarget(libname,srclist): Generate rules to create a lint library. Note that the lint library is always forced to be newer than the library itself. lintlib:: llib-l/**/libname.ln llib-l/**/libname.ln: srclist $(RM) $@ $(LINT) $(LINTLIBFLAG)/**/libname $(LINTFLAGS) srclist ------------------------------------------------------------------------ LintSubdirs(): Generate rules to recursively lint directories as part of the make lint step. LintDirs($(SUBDIRS)) ------------------------------------------------------------------------ LintTarget(): Generate rules to lint $(SOURCES) (automatically generated) |once _LintTarget_ NormalLintTarget($(SOURCES)) -once ------------------------------------------------------------------------ MakeDirectories(step,dirs): Generate rules to create a hierarchy of directories. step:: MakeDirs(dirs) ------------------------------------------------------------------------ MakeDirs(dirs): Creates a set of directories, even if some directories in the path do not already exist. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ (set -x; test -d $$dir || $(INSTALLDIR) $$dir) || \ exit 1; \ done ------------------------------------------------------------------------ MakeInstallDirectories(dirs): Generate a rule to create a set of directories at installation time (removed by deinstall). local_install:: _MakeInstallDirs(dirs) local_deinstall:: _RmInstallDirs(dirs) ------------------------------------------------------------------------ MakeLintLibSubdirs(dirs): Generate rules to recursively create lint libraries. MakeLintSubdirs(dirs,lintlib) ------------------------------------------------------------------------ MakeLintSubdirs(dirs,target): Generate rules to recursively lint directories as part of the named step. NamedTargetSubdirsRule(dirs,target,"Linting",/**/) ------------------------------------------------------------------------ MakeMakeSubdirs(target): Generate rules to recursively recreate target as part of the specified step in the build. This assumes Makefile.SH has already been built (which is the case for a delivery), but does not rely on the existence of a Makefile. target:: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in $(SUBDIRS);\ do \ echo "Making "target" in $(DIR)$$i..."; \ (cd $$i || exit 1; \ if test ! -f Makefile; then /bin/sh Makefile.SH; fi; \ $(MAKE) $(MFLAGS) target) || exit 1;\ done ------------------------------------------------------------------------ MakeMakefilesSH(): Generate rules to recursively recreate target as part of the specified step in the build. If $(TOP) is set to an absolute path, don't prepend the ../ prefix. This makes running things outside of the source tree to be much easier. Makefiles.SH:: Makefile.SH @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in $(SUBDIRS);\ do \ case "$(DIR)$$i/" in \ /**/*^^/^^*^^/^^*^^/^^*^^/) newtop=../../../..;; \ /**/*^^/^^*^^/^^*^^/) newtop=../../..;; \ /**/*^^/^^*^^/) newtop=../..;; \ */**//) newtop=..;; \ esac; \ case "$(TOP)" in \ //**/*) newtop="$(TOP)" ;; \ esac; \ echo "Making Makefiles.SH in $(DIR)$$i..."; \ (cd $$i || exit 1; \ if test -f Jmakefile; then \ $(MAKE) $(MFLAGS) -f ../Makefile \ Makefile TOP=$$newtop CURRENT=$(DIR)$$i && \ $(MAKE) $(MFLAGS) Makefiles.SH; \ fi; \ ) || exit 1; \ done ------------------------------------------------------------------------ MakeScriptFromCpp(name,defs): Generate rules to create a script from a file with a .cpp suffix. CppScriptTarget(name,name.cpp,defs,/**/) ------------------------------------------------------------------------ MakeSubdirs(): Generate rules to do makes in the given subdirectories. NamedTargetSubdirs(all,"Making all",/**/) ------------------------------------------------------------------------ MakeSubincludesForBuild(step,dir,srclist): Make includes in sub directories. step:: dir srclist @-(list=`echo srclist | sed -e 's/[^ ]*\///g'`; \ set -x; cd dir; $(RM) $$list) @for i in srclist; do \ (set -x; cd dir; $(LN) ../$$i .) || exit 1; \ done MakeDirectories(dir,dir) local_realclean:: @-(if [ -d dir ]; then \ list=`echo srclist | sed -e 's/[^ ]*\///g'`; \ set -x; cd dir; $(RM) $$list; fi) ------------------------------------------------------------------------ MakefileSubdirs(): Generate rules to create Makefiles. MakeMakeSubdirs(Makefiles) MakeMakefilesSH() ------------------------------------------------------------------------ MakefileTarget(): Generate rules to build a normal Makefile. BuildMakefileSH(/**/) BuildMakefile() ------------------------------------------------------------------------ NamedDepthTargetSubdirs(name,verb,flags): Recursively make a series of steps. We first enter the subdirectories, then perform the local entries. The supplied "name" has "sub_" prefixed to it. sub_/***/name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags @echo "Back to $(CURRENT) for "name/**/... ------------------------------------------------------------------------ NamedSubTargetSubdirs(name,verb,flags): Recursively make a series of steps, like NamedTargetSubdirs. However, the supplied "name" has "sub_" prefixed to it. sub_/***/name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags ------------------------------------------------------------------------ NamedTargetSubdirs(name,verb,flags): Recursively make a series of steps. name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags ------------------------------------------------------------------------ NamedTargetSubdirsRule(dirs,name,verb,flags): Recursively make a series of steps in the specified directories. name:: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in dirs ;\ do \ (cd $$i ; echo verb "in $(DIR)$$i..."; \ $(MAKE) $(MFLAGS) flags name) || exit 1; \ done ------------------------------------------------------------------------ NoManPages(): Actually forces the definition of NOMAN, which tells the jmake program to not generate rules for installing manual pages. -> NOMAN. ------------------------------------------------------------------------ NormalLexDependTarget(program,base,parser): Declare that program will need an include file produced by the output of lex on base.l, which typically produces a file named lex.yy.c which will be renamed as base.c. Besides, the lexical analyzer needs the file parser.h produced by running parser.y through yacc and renaming y.tab.h as parser.h. base.o: parser.h SimpleLexTarget(program,base) ------------------------------------------------------------------------ NormalLibraryObjectRule(): Generate make rules to build "normal" objects. |once _ObjectRule_ .c.o: $(RM) $@ $(CC) -c $(JCFLAGS) $< -once ------------------------------------------------------------------------ NormalLibraryTarget(libname,srclist,objlist): Generate rules to create a library. The 'srclist' and 'objlist' parameters are added to SOURCES and OBJECTS macros. The 'srclist' is not otherwise used by this rule, but is necessary for make depend. OBJECTS += objlist SOURCES += srclist NormalLibraryObjectRule() AllTarget(lib/**/libname.a) lib/**/libname.a: objlist $(RM) $@ $(AR) $@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ NormalLibraryTarget2(libname,srclist,objlist1,objlist2): Generate rules to create a library in two steps. This is used to create libraries with large numbers of files. SOURCES += srclist OBJECTS += objlist1 OBJECTS += objlist2 NormalLibraryObjectRule() AllTarget(lib/**/libname.a) lib/**/libname.a: objlist1 objlist2 $(RM) $@ $(AR) $@ objlist1 $(AR) $@ objlist2 $(RANLIB) $@ ------------------------------------------------------------------------ NormalLintTarget(srclist): Generate rules to lint a set of sources. lint: $(LINT) $(LINTFLAGS) srclist $(LINTLIBS) ------------------------------------------------------------------------ NormalObjectRule(): Generate make rule to build usual object files. |once _ObjectRule_ .c.o: $(CC) -c $(JCFLAGS) $< -once ------------------------------------------------------------------------ NormalObjectTarget(file): Generate rules to produce a single object file.o from a file.c. SOURCES += file/**/.c AllTarget(file/**/.o) NormalObjectRule() ------------------------------------------------------------------------ NormalParserTarget(program,lexic,parser): Specify that program is using the lex/yacc combination to produce a parser. The lexic and parser parameters are the base name of the .l and .y file, respectively. NormalLexDependTarget(program,lexic,parser) NormalYaccTarget(program,parser) ------------------------------------------------------------------------ NormalProgramTarget(program,sources,objects): Generate rules to compile and link the indicated program; since it does not use any default object files, it may be used for multiple programs in the same Jmakefile. OBJECTS += objects SOURCES += sources NormalObjectRule() AllTarget(program) program: objects RemoveTargetProgram($@) $(CC) -o $@ objects $(JLDFLAGS) $(LIBS) ------------------------------------------------------------------------ NormalRelocatableTarget(objname,objlist): Generate rules to produce a relocatable object file instead of a library. AllTarget(objname.o) objname.o: objlist $(RM) $@ $(LD) $(JLDFLAGS) -r objlist -o $@ ------------------------------------------------------------------------ NormalSharedLibraryDataTarget(libname,rev,salist): Generate rules to create shlib data file; build it into a different name so that the we don't hose people by having the library gone for long periods. AllTarget(lib/**/libname.sa.rev) lib/**/libname.sa.rev: salist $(RM) $@ $(AR) $@ salist $(RANLIB) $@ ------------------------------------------------------------------------ NormalSharedLibraryTarget(libname,rev,solist): Generate rules to create a shared library; build it into a different name so that the we don't hose people by having the library gone for long periods. AllTarget(lib/**/libname.so.rev) lib/**/libname.so.rev: solist $(RM) $@~ (cd shared; $(LD) -o ../$@~ -assert pure-text solist) $(RM) $@ $(MV) $@~ $@ ------------------------------------------------------------------------ NormalYaccTarget(program,base): Declare a yacc base.y file which should produce a base.c and base.h file as derived from the output of yacc, to be used by the specified program. SimpleYaccTarget(program,base) SimpleYaccInclude(base) ------------------------------------------------------------------------ PrelinkedRelocatableTarget(objname,objlist,libs): Generate rules to produce a relocatable object file instead of a library. AllTarget(objname.o) objname.o: objlist $(RM) $@ $(LD) $(JLDFLAGS) -r objlist -o $@ libs ------------------------------------------------------------------------ ProfiledLibraryObjectRule(): Generate make rules to build both profiled and "normal" objects. all:: @if [ ! -d profiled ]; then mkdir profiled; fi .c.o: $(RM) $@ profiled/$@ $(CC) -pg -c $(JCFLAGS) $*.c $(MV) $*.o profiled/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d profiled ]; then echo " $(RM) profiled/?*.o"; \ $(RM) profiled/?*.o; fi ------------------------------------------------------------------------ ProfiledLibraryTarget(libname,srclist,objlist): Generate rules to create a profiled library. SOURCES += srclist OBJECTS += objlist AllTarget(lib/**/libname^^_p.a) lib/**/libname^^_p.a: objlist $(RM) $@ cd profiled; $(AR) ../$@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ ProfiledRelocatableTarget(objname,objlist): Generate rules to produce a profiled relocatable object file instead of a library. AllTarget(objname/**/_p.o) objname/**/_p.o: objlist $(RM) $@ $(LD) -X -r objlist -o $@ ------------------------------------------------------------------------ RemoteDependency(directory,dependency): Specify rules for making a remote dependency. ForceTarget() |once =directory//***/dependency= directory//***/dependency: .FORCE @echo "Checking "/***/dependency" in "/**/^directory"..." cd /***/directory; $(MAKE) /**/^dependency @echo "Continuing in $(CURRENT)..." -once ------------------------------------------------------------------------ RemoteTargetDependency(target,directory,dependency): A local target may rely on a remote dependency (e.g. a library) made in a separate directory. This rule explicits the dependency and forces a make of that dependency in the remote directory. RemoteDependency(directory,dependency) target: directory//***/dependency ------------------------------------------------------------------------ RemoveTargetProgram(program): This is used in some other macros in order to remove the target before starting its building (saves disk space). There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. $(RM) program if test -f program/***/$(_EXE); then \ $(MV) program/***/$(_EXE) program/**/~^^^$(_EXE); fi ------------------------------------------------------------------------ SetSubdirs(subdirs): Actually forces the definition of SUBDIRS, and lets the user specify what the sub-directories are. This will be added to the customization part. -> SUBDIRS. SUBDIRS = subdirs ------------------------------------------------------------------------ SharedAndDebuggedLibraryObjectRule(): Generate make rules to build shared, debuggable, and "normal" object files. all:: @if [ ! -d shared ]; then mkdir shared; fi @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ shared/$@ debugger/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o shared/$*.o $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c local_clean:: -@if [ -d shared ]; then echo " $(RM) shared/?*.o"; \ $(RM) shared/?*.o; fi -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ SharedLibraryObjectRule(): Generate make rules to build shared and "normal" object files. all:: @if [ ! -d shared ]; then mkdir shared; fi .c.o: $(RM) $@ shared/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o shared/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c local_clean:: -@if [ -d shared ]; then echo " $(RM) shared/?*.o"; \ $(RM) shared/?*.o; fi ------------------------------------------------------------------------ ShellScriptLongTarget(basename,scriptname): Generate rules to create a set of scripts from .SH files where the name of the generated file is different from the basename of the .SH file (when, for instance, the total length with the .SH extension would not leave enough space for RCS ,v extension). LSCRIPTS += scriptname AllTarget(scriptname) scriptname: basename/**/.SH /bin/sh basename/**/.SH InstallScripts() #ifndef NOMAN InstallManPageLong(basename,$(MANSRC),scriptname) #endif ------------------------------------------------------------------------ ShellScriptTarget(scripts): Generate rules to create and install a set of scripts from .SH files. Man pages derived from the name of the scripts are also installed unless NoManPages() is specified. ShellScriptTargetExt(scripts,.SH) ------------------------------------------------------------------------ ShellScriptTargetExt(scripts,ext): Generate rules to create and install a set of scripts from ext files (.sh and .SH are the most common examples). Man pages derived from the name of the scripts are also installed unless NoManPages() is specified. SCRIPTS += scripts SimpleShellScriptTargetExt(scripts,ext) InstallScripts() InstallManScripts() ------------------------------------------------------------------------ SimpleLexTarget(program,base): This declares a lex base.l file which is to be ran through lex to produce a base.c file. SOURCES += base.l OBJECTS += base.o |once _LexRule_ .l.c: $(LEX) $(JLFLAGS) $< $(MV) lex.yy.c $@ -once AddSuffix(.l) program: base.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ SimpleProgramTarget(program): Generate rules for compiling and linking programs that only have one C source file. It should only be used in Jmakefiles that describe a single program. NormalProgramTarget(program,program.c,program.o) ------------------------------------------------------------------------ SimpleShellScriptTarget(scripts): Generate rules to create a set of scripts from .SH files. SimpleShellScriptTargetExt(scripts,.SH) ------------------------------------------------------------------------ SimpleShellScriptTargetExt(scripts,ext): Generate rules to create a set of scripts from ext files where ext is usually something like .sh or .SH, or whatever file extension you like.. AllTarget(scripts) |expand s!scripts! !s: !s/**/ext /bin/sh !s/**/ext -expand ------------------------------------------------------------------------ SimpleYaccInclude(base): Declare that program will need an include file produced by the output of yacc on base.y, which typically produces a file named y.tab.h, which will be renamed as base.h. The only problem is that the dependencies towards base.h have to be manually given in the Jmakefile. base.h: base.c @if test -f y.tab.h; then \ echo " $(MV) y.tab.h $@"; \ $(MV) y.tab.h $@; \ fi local_realclean:: $(RM) base.h ------------------------------------------------------------------------ SimpleYaccTarget(program,base): Declare a yacc base.y file to be used in the building of the specified target program. The source file must be given without its final .y extension. The name of the .c and .o will be derived from the source file basename provided. SOURCES += base.y OBJECTS += base.o YaccRule() program: base.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ SingleProgramTarget(program,objects,libs): Obsolete version of NormalProgramTarget that doesn't have deplibs. NormalProgramTarget(program,objects,libs) ------------------------------------------------------------------------ SpecialDebuggedAndProfiledObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make debuggable and profiled versions. all:: @if [ ! -d profiled ]; then mkdir profiled; fi @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ profiled/$@ debugger/$@ $(CC) -pg -c $(JCFLAGS) options $*.c $(MV) $*.o profiled/$*.o $(CC) -g -c $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialDebuggedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make a debuggable version. all:: @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ debugger/$@ $(CC) -g -c $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialObjectRule(objs,depends,options): Generate rules to compile a file with special flags. objs: depends $(RM) $@ $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialProfiledObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make a profiled version. all:: @if [ ! -d profiled ]; then mkdir profiled; fi objs: depends $(RM) $@ profiled/$@ $(CC) -pg -c $(JCFLAGS) options $*.c $(MV) $*.o profiled/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialSharedAndDebuggedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make shared and debuggable versions. all:: @if [ ! -d shared ]; then mkdir shared; fi @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ shared/$@ debugger/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o shared/$*.o $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialSharedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make shared and debuggable versions. all:: @if [ ! -d shared ]; then mkdir shared; fi objs: depends $(RM) $@ shared/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o shared/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c ------------------------------------------------------------------------ TagSubdirs(dirs): Generate rules to recursively create tags files. NamedTargetSubdirsRule(dirs,tag,"Tagging",/**/) ------------------------------------------------------------------------ TagsTarget(): Generate rules to compute tags files for C source code. tags:: $(CTAGS) -w *.[ch] $(CTAGS) -xw *.[ch] > tags local_clobber:: $(RM) tags ------------------------------------------------------------------------ YaccRule(): This is the rule which is used to build a .c file from a .y file. AddSuffix(.y) |once _YaccRule_ .y.c: $(YACC) $(JYFLAGS) $< $(MV) y.tab.c $@ -once ------------------------------------------------------------------------ _MakeInstallDir(dir): Internal macro to create a missing install directory. (set -x; test -d $(INSTALL_PREFIX)/***/dir || \ $(INSTALLDIR) $(INSTALL_PREFIX)/***/dir); ------------------------------------------------------------------------ _MakeInstallDirIgnore(dir): Same as _MakeInstallDir but handles "make -i" as well. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ _MakeInstallDir(dir) ------------------------------------------------------------------------ _MakeInstallDirs(dirs): Creates a set of intall directories, even if some directories in the path do not already exist. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ _MakeInstallDir($$dir) \ done ------------------------------------------------------------------------ _RmInstallDirs(dirs): Removes a set of intall directories. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ (set -x; test -d $$dir && $(RM) -r $(INSTALL_PREFIX)$$dir); \ done ------------------------------------------------------------------------ metaconfig-debian-perl-5.26.1/dist/U/000077500000000000000000000000001316016665300172575ustar00rootroot00000000000000metaconfig-debian-perl-5.26.1/dist/U/AAAAA.U000066400000000000000000000036201316016665300201720ustar00rootroot00000000000000?RCS: $Id: AAAAA.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: AAAAA.U,v $ ?RCS: Revision 3.0.1.4 1994/06/20 06:50:26 ram ?RCS: patch30: changes from Jarkko Hietaniemi are tagged with JHI ?RCS: ?RCS: Revision 3.0.1.3 1994/05/06 14:01:39 ram ?RCS: patch23: initials for Wayne Davison are now WED ?RCS: patch23: added initials for new unit contributor Andy Dougherty ?RCS: ?RCS: Revision 3.0.1.2 1994/01/24 14:01:09 ram ?RCS: patch16: make metalint shut up on special unit definition for All target ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:43:57 ram ?RCS: patch10: documents initials used for Wayne Davison's contributions ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:44 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: The purpose of this file is to supply the head of the Makefile created ?X: by metaconfig. For this reason it must be first in alphabetical order. ?X: The leading '+' in front of the unit name is a hint for metalint, since ?X: the use of that special unit name as a "made" unit is legitimate here. ?X: ?MAKE:+All: Finish ?X: ?X: Throughout the units, the following initials are used to identify comments: ?X: ?X: HMS: Harlan Stenn ?X: RAM: Raphael Manfredi ?X: WED: Wayne Davison (was WAD by mistake--RAM) ?X: ADO: Andy Dougherty ?X: JHI: Jarkko Hietaniemi ?X: ?X: Agreed, this is a weird place to document it, but I couldn't find a better ?X: place to do so. I've bet on the curiosity of users, who would probably ?X: want to know what's in this strangely-named file--RAM. metaconfig-debian-perl-5.26.1/dist/U/Assert.U000066400000000000000000000016601316016665300206510ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 2012 Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?MAKE:Assert: cat ?MAKE: -pick add $@ %< ?F:./static_assert.h : static assertion checking include file ?X: ?X: C programs can include this file to perform STATIC_ASSERT() checks ?X: which are done at compile-time and cause the compilation to fail when ?X: the expression is false. ?X: ?X: It is sufficient to compile with: $cc -c $ccflags try.c ?X: There is no need to link the file to spot the assertion failure. ?X: $cat >static_assert.h <<'EOC' #define STATIC_ASSERT(expr) \ do { switch (0) { case ((expr) ? 1 : 0): case 0: break; } } while(0) EOC metaconfig-debian-perl-5.26.1/dist/U/Begin.U000066400000000000000000000031241316016665300204310ustar00rootroot00000000000000?RCS: $Id: Begin.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Begin.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 14:56:35 ram ?RCS: patch61: added Extractall dependency ?RCS: ?RCS: Revision 3.0.1.2 1995/01/30 14:25:08 ram ?RCS: patch49: avoid an empty rmlist: systems might choke on it (WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/31 09:32:20 ram ?RCS: patch44: created ?RCS: ?X: ?X: This file comes after option processing had been done and after all ?X: the default values have been set up. It marks the beginning of questions. ?X: It is important that Options be listed *after* Myinit to ensure that the ?X: default initializations performed by Init and Myinit will not clobber ?X: any setting done on the command line via -D or -U. ?X: ?MAKE:Begin: Myinit Options package Extractall ?MAKE: -pick add $@ %< : Eunice requires " " instead of "", can you believe it echo " " : Here we go... echo "Beginning of configuration questions for $package." ?X: Make sure the rm below is given a non-empty list for some systems. ?X: This is run only when within the UU directory, hence we can safely ?X: attempt to rm a non-existent 'X' file... trap 'echo " "; test -d ../UU && rm -rf X $rmlist; exit 1' 1 2 3 15 metaconfig-debian-perl-5.26.1/dist/U/Checkcc.U000066400000000000000000000075751316016665300207460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in order ?X: to make quick check on whether the current C compiler is working. ?X: ?MAKE:Checkcc ccname ccversion: Myread Warn startsh cat contains test ?MAKE: -pick add $@ %< ?S:ccname: ?S: This can set either by hints files or by Configure. If using ?S: gcc, this is gcc, and if not, usually equal to cc, unimpressive, no? ?S: Some platforms, however, make good use of this by storing the ?S: flavor of the C compiler being used here. For example if using ?S: the Sun WorkShop suite, ccname will be 'workshop'. ?S:. ?S:ccversion: ?S: This can set either by hints files or by Configure. If using ?S: a (non-gcc) vendor cc, this variable may contain a version for ?S: the compiler. ?S:. ?F:./checkcc ./trygcc !checktmp ?V:despair ?T:trygcc ?LINT:extern cc rm ccflags ldflags ?LINT:change cc ccflags ?LINT:usefile checktmp ?INIT:ccname='' ?INIT:ccversion='' : generate the trygcc script for later perusal cat <trygcc $startsh EOS cat <<'EOSC' >>trygcc case "$cc" in '') ;; *) $rm -f try try.* $cat >try.c <&4 despair=yes trygcc=yes case "$cc" in *gcc*) trygcc=no ;; esac case "`$cc -v -c try.c 2>&1`" in *gcc*) trygcc=no ;; esac if $test X"$trygcc" = Xyes; then if gcc -o try -c try.c; then echo " " echo "You seem to have a working gcc, though." >&4 rp="Would you like to use it?" dflt=y if $test -f myread; then . ./myread else if $test -f UU/myread; then . ./UU/myread else echo "Cannot find myread, sorry. Aborting." >&2 exit 1 fi fi case "$ans" in [yY]*) cc=gcc; ccname=gcc; ccflags=''; despair=no; ?X: Look whether we have 'call-back units' generated by hints that would ?X: seemingly affect the compiling environment. $cat *.cbu >checktmp 2>/dev/null if $contains ccflags checktmp >/dev/null; then ./warn <checkcc $startsh EOS cat <<'EOSC' >>checkcc case "$cc" in '') ;; *) $rm -f try try.* $cat >try.c <&4 fi $cat >&4 <&4 ?X: ?X: Files spelled uppercased and beginning with PACK are produced by the ?X: shell archive builder and may be removed by the user. Usually, they are ?X: not listed in the MANIFEST file, but you never know... ?X: ?X: "split -l" is the new way of running a split, but we also try the older way ?X: awk '$1 !~ /PACK[A-Z]+/ {print $1}' "$rsrc/MANIFEST" | \ (split -l 50 2>/dev/null || split -50) rm -f missing tmppwd=`pwd` for filelist in x??; do (cd "$rsrc"; ls `cat "$tmppwd/$filelist"` \ >/dev/null 2>>"$tmppwd/missing") done if test -s missing; then cat missing >&4 cat >&4 <<'EOM' THIS PACKAGE SEEMS TO BE INCOMPLETE. You have the option of continuing the configuration process, despite the distinct possibility that your kit is damaged, by typing 'y'es. If you do, don't blame me if something goes wrong. I advise you to type 'n'o and contact the author (). EOM ?X: Can't use $echo at this early stage echo $n "Continue? [n] $c" >&4 read ans case "$ans" in y*) echo "Continuing..." >&4 rm -f missing ;; *) ?X: ?X: Use kill and not exit, so that the trap gets executed to clean up ?X: echo "ABORTING..." >&4 kill $$ ;; esac else echo "Looks good..." fi else echo "There is no MANIFEST file. I hope your kit is complete !" fi rm -f missing x?? @end metaconfig-debian-perl-5.26.1/dist/U/Chk_whoami.U000066400000000000000000000015161316016665300214610ustar00rootroot00000000000000?RCS: $Id: Chk_whoami.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Chk_whoami.U,v $ ?RCS: Revision 3.0 1993/08/18 12:04:46 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit makes sure we don't try to include whoami.h if uname() exists. ?X: ?MAKE:Chk_whoami: d_uname i_whoami ?MAKE: -pick add $@ %< ?LINT:change i_whoami : weed out incompatibilities case "$d_uname" in "$define") i_whoami="$undef" ;; esac metaconfig-debian-perl-5.26.1/dist/U/Compile.U000066400000000000000000000044231316016665300210000ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Copyright (c) 1998 Andy Dougherty ?RCS: ?RCS: You may distribute under the terms of either the GNU General Public ?RCS: License or the Artistic License, as specified in the README file. ?RCS: ?RCS: ?X: ?X: This unit is just a quick shorthand for the compile command ?X: to be used in all the other metaconfig units. ?X: ?MAKE:Compile: +cc +optimize +ccflags +ldflags +libs ?MAKE: -pick add $@ %< ?LINT:define compile compile_ok ?V:compile compile_ok mc_file ?S:compile: ?S: This shell variable is used internally by Configure to provide ?S: a convenient shorthand for the typical compile command, namely ?S: $cc $optimize $ccflags $ldflags -o $1 $1.c $libs > /dev/null 2>&1 ?S: Note that the output filename does _not_ include the _exe ?S: extension. Instead we assume that the linker will be ?S: "helpful" and automatically appending the correct suffix. ?S: OS/2 users will apparently need to supply the -Zexe flag to ?S: get this behavior. ?S: ?S: To use this variable, say something like: ?S: echo 'int main() { exit(0); }' > try.c ?S: set try ?S: if eval $compile; then ?S: echo "success" # and do whatever . . . ?S: else ?S: echo "failure" # and do whatever . . . ?S: fi ?S: To add extra flags cc flags (e.g. -DWHATEVER) just put them ?S: in $*, e.g. ?S: set try -DTRY_THIS_FLAG ?S:. ?S:compile_ok: ?S: This shell variable is used internally by Configure to provide ?S: a convenient shorthand for the typical compile command that you ?S: expect to work ok. It is the same as $compile, except we ?S: deliberately let the user see any error messages. ?S:. : define a shorthand compile call compile=' mc_file=$1; shift; $cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs > /dev/null 2>&1;' : define a shorthand compile call for compilations that should be ok. compile_ok=' mc_file=$1; shift; $cc -o ${mc_file} $optimize $ccflags $ldflags $* ${mc_file}.c $libs;' metaconfig-debian-perl-5.26.1/dist/U/Config_h.U000066400000000000000000000100231316016665300211150ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Config_h.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 14:57:43 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.4 1995/09/25 09:10:49 ram ?RCS: patch59: commented the purpose of the #un-def directive ?RCS: ?RCS: Revision 3.0.1.3 1995/01/30 14:25:39 ram ?RCS: patch49: typo fixes in leading config.h comment (WED) ?RCS: ?RCS: Revision 3.0.1.2 1993/08/24 12:13:20 ram ?RCS: patch3: added TOP as a local shell temporary variable ?RCS: ?RCS: Revision 3.0.1.1 1993/08/19 06:42:20 ram ?RCS: patch1: leading config.sh searching was not aborting properly ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:47 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This file ends up producing the config_h.SH script, which is run to produce ?X: the config.h file. The file ./.Config_h below contains all the ?H: lines ?X: extracted out of all the units. Metaconfig itself adds the !GROK!THIS!. ?X: Note that this code isn't included into Configure, but must be shipped with. ?X: ?X: For those who wish to know why the file is config_h.SH instead of the more ?X: natural config.h.SH, well... it is to support systems like MS-DOG. Only one ?X: 'dot' is allowed within the file name, as it is part of the "extension" of ?X: the file. MS-DOG will not let you have two 'dots' because that would mean ?X: two "extensions". ?X: ?MAKE:Config_h: Id End Config_sh Obsol_h myuname cf_time cf_by package src ?MAKE: -pick c_h_weed $@ %< ?MAKE: -pick c_h_weed $@ ./Config_h ?MAKE: -pick c_h_weed $@ ./Obsol_h ?T:CONFIG TOP ?LINT:unclosed !GROK!THIS! ?LINT:extern CONFIG_H CONFIG_SH ?LINT:change CONFIG_H CONFIG_SH ?LINT:nocomment case "$CONFIG_SH" in '') CONFIG_SH=config.sh;; esac case "$CONFIG_H" in '') CONFIG_H=config.h;; esac case $CONFIG in '') if test -f $CONFIG_SH; then TOP=.; elif test -f ../$CONFIG_SH; then TOP=..; elif test -f ../../$CONFIG_SH; then TOP=../..; elif test -f ../../../$CONFIG_SH; then TOP=../../..; elif test -f ../../../../$CONFIG_SH; then TOP=../../../..; else echo "Can't find $CONFIG_SH."; exit 1 fi . $TOP/$CONFIG_SH ;; esac ?X: Make sure we are in the directory where the .SH file is located. case "$0" in */*) cd `expr X$0 : 'X\(.*\)/'` ;; esac echo "Extracting $CONFIG_H (with variable substitutions)" ?X: ?X: Since we unconditionally translate leading #undef into /*#define, we're ?X: stuck when we really want to have a #undef in config.h. That's why there ?X: is provision here for #un-def, which is translated back into #undef after ?X: all original #undef have been processed. ?X: ?X: Previously, we changed all ?X: #undef FOO /**/ ?X: into ?X: /*#define FOO /**/ ?X: The xlc compiler (available on IBM's AIX) complains that this is ?X: an illegal attempt to write a nested comment, and warns against it. ?X: There's apparently no way to shut the compiler up, either. ?X: This sed command from Hallvard B Furuseth ?X: changes it to ?X: /*#define FOO / **/ sed <$CONFIG_H -e 's!^#undef\(.*/\)\*!/\*#define\1 \*!' -e 's!^#un-def!#undef!' /* * This file was produced by running the config_h.SH script, which * gets its values from $CONFIG_SH, which is generally produced by * running Configure. * * Feel free to modify any of this as the need arises. Note, however, * that running config_h.SH again will wipe out any changes you've made. * For a more permanent change edit $CONFIG_SH and rerun config_h.SH. * * \$Id: Config_h.U 1 2006-08-24 12:32:52Z rmanfredi $ */ /* * Package name : $package * Source directory : $src * Configuration time: $cf_time * Configured by : $cf_by * Target system : $myuname */ #ifndef _config_h_ #define _config_h_ metaconfig-debian-perl-5.26.1/dist/U/Config_sh.U000066400000000000000000000067351316016665300213170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Config_sh.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 14:57:53 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.2 1995/01/11 14:53:31 ram ?RCS: patch45: moved path stripping from d_portable.U to end of Configure ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:50:37 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:48 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit ends up producing the config.sh script, which contains all the ?X: definitions figured out by Configure. The add.Config_sh command knows ?X: which variables need to be remembered. It also adds the EOT (ends the ?X: here document redirection with variable substitution). ?X: ?MAKE:Config_sh: cf_time cf_by test spitshell startsh myuname Myread \ End Obsol_sh Loc +d_portable package src cat sed ?MAKE: -pick add.Config_sh $@ %< ?MAKE: -pick add $@ ./Obsol_sh ?MAKE: -pick close.Config_sh $@ %< ?F:!config.over !config.arch ?T:file sfile xsed ?LINT:unclosed EOT : back to where it started if test -d ../UU; then cd .. fi : configuration may be unconditionally patched via a 'config.arch' file if $test -f config.arch; then echo "I see a config.arch file, loading it." >&4 . ./config.arch fi : configuration may be patched via a 'config.over' file if $test -f config.over; then echo " " dflt=y rp='I see a config.over file. Do you wish to load it?' . UU/myread case "$ans" in n*) echo "OK, I'll ignore it.";; *) . ./config.over echo "Configuration override changes have been loaded." ;; esac fi @if d_portable : in case they want portability, strip down executable paths ?X: ?X: Strip down paths in located executables. For each file, e.g. vi, there ?X: is a $vi variable whose value is for instance '/usr/bin/vi'. By resetting ?X: $vi to 'vi', we rely on the PATH variable to locate the executable... ?X: In order to allow vi='/usr/bin/nvi' which will strip down to vi='nvi', ?X: we can't just say 'eval $file="\$file"', we have to recourse to sed. ?X: We don't use basename since it is less portable than sed. ?X: case "$d_portable" in "$define") echo " " echo "Stripping down executable paths..." >&4 xsed=$sed for file in $loclist $trylist; do eval sfile="\$$file" sfile=`echo $sfile | $xsed -e 's,.*/\(.*\),\1,'` eval $file="$sfile" done ;; esac @end : create config.sh file echo " " echo "Creating config.sh..." >&4 $spitshell <config.sh $startsh # # This file was produced by running the Configure script. It holds all the # definitions figured out by Configure. Should you modify one of these values, # do not forget to propagate your changes by running "Configure -der". You may # instead choose to run each of the .SH files by yourself, or "Configure -S". # # Package name : $package # Source directory : $src # Configuration time: $cf_time # Configured by : $cf_by # Target system : $myuname EOT ?X: Command line options are saved by the Options.U unit in the ?X: temporary file UU/cmdline.opt $test -f UU/cmdline.opt && $cat UU/cmdline.opt >> config.sh $spitshell <>config.sh metaconfig-debian-perl-5.26.1/dist/U/Configdir.U000066400000000000000000000020141316016665300213060ustar00rootroot00000000000000?RCS: $Id: Configdir.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Configdir.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 14:58:36 ram ?RCS: patch61: have README explicitly mention the package name ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:49 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:Configdir: package ?MAKE: -pick add $@ %< : create .config dir to save info across Configure sessions test -d ../.config || mkdir ../.config cat >../.config/README <&4 ?X: ?X: The symbol list is in alpha order for ease of maintenance... ?X: ?X: Lots of new symbols (mostly rummaged from gcc), courtesy of ?X: Jarkko Hietaniemi -- RAM, 06/06/94 ?X: ?X: If your symbol is mixed case, just add it as-is. ?X: All symbols will be transformed to both all-lower and all-upper. ?X: Also drop any leading/trailing underscores, the scan will try all those. ?X: $cat <<'EOSH' > Cppsym.know a29k ABI64 aegis AES_SOURCE AIX AIX32 AIX370 AIX41 AIX42 AIX43 AIX_SOURCE aixpc ALL_SOURCE alliant alpha am29000 AM29000 AMD64 amiga AMIGAOS AMIX ansi ANSI_C_SOURCE apollo ardent ARM32 atarist att386 att3b BeOS BIG_ENDIAN BIT_MSF bsd BSD bsd43 bsd4_2 bsd4_3 BSD4_3 bsd4_4 BSD_4_3 BSD_4_4 BSD_NET2 BSD_TIME BSD_TYPES BSDCOMPAT bsdi bull c cadmus clipper CMU COFF COMPILER_VERSION concurrent convex cpu cray CRAY CRAYMPP ctix CX_UX CYGWIN DGUX DGUX_SOURCE DJGPP dmert DOLPHIN DPX2 DSO Dynix DynixPTX ELF encore EPI EXTENSIONS FAVOR_BSD FILE_OFFSET_BITS FreeBSD GCC_NEW_VARARGS gcos gcx gimpel GLIBC GLIBC_MINOR GNU_SOURCE GNUC GNUC_MINOR GNU_LIBRARY GO32 gould GOULD_PN H3050R H3050RX hbullx20 hcx host_mips hp200 hp300 hp700 HP700 hp800 hp9000 hp9000s200 hp9000s300 hp9000s400 hp9000s500 hp9000s700 hp9000s800 hp9k8 hp_osf hppa hpux HPUX_SOURCE i186 i286 i386 i486 i586 i686 i8086 i80960 i860 I960 IA64 iAPX286 ibm ibm032 ibmesa IBMR2 ibmrt ILP32 ILP64 INLINE_INTRINSICS INTRINSICS INT64 interdata is68k ksr1 LANGUAGE_C LARGE_FILE_API LARGEFILE64_SOURCE LARGEFILE_SOURCE LFS64_LARGEFILE LFS_LARGEFILE Linux LITTLE_ENDIAN LONG64 LONG_DOUBLE LONG_LONG LONGDOUBLE LONGLONG LP64 luna luna88k Lynx M68000 m68k m88100 m88k M88KBCS_TARGET M_COFF M_I186 M_I286 M_I386 M_I8086 M_I86 M_I86SM M_SYS3 M_SYS5 M_SYSIII M_SYSV M_UNIX M_XENIX MACH machine MachTen MATH_HAS_NO_SIDE_EFFECTS mc300 mc500 mc68000 mc68010 mc68020 mc68030 mc68040 mc68060 mc68k mc68k32 mc700 mc88000 mc88100 merlin mert MiNT mips MIPS_FPSET MIPS_ISA MIPS_SIM MIPS_SZINT MIPS_SZLONG MIPS_SZPTR MIPSEB MIPSEL MODERN_C motorola mpeix MSDOS MTXINU MULTIMAX mvs MVS n16 ncl_el ncl_mr NetBSD news1500 news1700 news1800 news1900 news3700 news700 news800 news900 NeXT NLS nonstopux ns16000 ns32000 ns32016 ns32332 ns32k nsc32000 OCS88 OEMVS OpenBSD os OS2 OS390 osf OSF1 OSF_SOURCE pa_risc PA_RISC1_1 PA_RISC2_0 PARAGON parisc pc532 pdp11 PGC PIC plexus PORTAR posix POSIX1B_SOURCE POSIX2_SOURCE POSIX4_SOURCE POSIX_C_SOURCE POSIX_SOURCE POWER PROTOTYPES PWB pyr QNX R3000 REENTRANT RES Rhapsody RISC6000 riscix riscos RT S390 SA110 scs SCO sequent sgi SGI_SOURCE SH3 sinix SIZE_INT SIZE_LONG SIZE_PTR SOCKET_SOURCE SOCKETS_SOURCE sony sony_news sonyrisc sparc sparclite spectrum stardent stdc STDC_EXT stratos sun sun3 sun386 Sun386i svr3 svr4 SVR4_2 SVR4_SOURCE svr5 SX system SYSTYPE_BSD SYSTYPE_BSD43 SYSTYPE_BSD44 SYSTYPE_SVR4 SYSTYPE_SVR5 SYSTYPE_SYSV SYSV SYSV3 SYSV4 SYSV5 sysV68 sysV88 Tek4132 Tek4300 titan TM3200 TM5400 TM5600 tower tower32 tower32_200 tower32_600 tower32_700 tower32_800 tower32_850 tss u370 u3b u3b2 u3b20 u3b200 u3b20d u3b5 ultrix UMAXV UnicomPBB UnicomPBD UNICOS UNICOSMK unix UNIX95 UNIX99 unixpc unos USE_BSD USE_FILE_OFFSET64 USE_GNU USE_ISOC9X USE_LARGEFILE USE_LARGEFILE64 USE_MISC USE_POSIX USE_POSIX199309 USE_POSIX199506 USE_POSIX2 USE_REENTRANT USE_SVID USE_UNIX98 USE_XOPEN USE_XOPEN_EXTENDED USGr4 USGr4_2 Utek UTek UTS UWIN uxpm uxps vax venix VMESA vms xenix Xenix286 XOPEN_SOURCE XOPEN_SOURCE_EXTENDED XPG2 XPG2_EXTENDED XPG3 XPG3_EXTENDED XPG4 XPG4_EXTENDED z8000 EOSH ?X: Maybe put other stuff here too. cat <>Cppsym.know $osname EOSH ./tr '[a-z]' '[A-Z]' < Cppsym.know > Cppsym.a ./tr '[A-Z]' '[a-z]' < Cppsym.know > Cppsym.b $cat Cppsym.know > Cppsym.c $cat Cppsym.a Cppsym.b Cppsym.c | $tr ' ' $trnl | $sort | $uniq > Cppsym.know $rm -f Cppsym.a Cppsym.b Cppsym.c cat < Cppsym $startsh if $test \$# -gt 0; then echo \$* | $tr " " "$trnl" | ./Cppsym.try > Cppsym.got if $test -s Cppsym.got; then $rm -f Cppsym.got exit 0 fi $rm -f Cppsym.got exit 1 else $tr " " "$trnl" | ./Cppsym.try exit 0 fi EOSH chmod +x Cppsym $eunicefix Cppsym ?X: The below awk script will die a horrible death if ?X: some of the tested symbols are not long ints. ?X: Also, we do not make difference between just defined and defined zero. cat < Cppsym.try $startsh cat <<'EOCP' > try.c #include int main() { EOCP ?X: The length($1) command guards against possible empty entries. ?X: The awk snippet is know to give heartburn to UNICOS/mk awk. $awk \\ EOSH cat <<'EOSH' >> Cppsym.try 'length($1) > 0 { printf "#ifdef %s\n#if %s+0\nprintf(\"%s=%%ld\\n\", (long)%s);\n#else\nprintf(\"%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 printf "#ifdef _%s\n#if _%s+0\nprintf(\"_%s=%%ld\\n\", (long)_%s);\n#else\nprintf(\"_%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 printf "#ifdef __%s\n#if __%s+0\nprintf(\"__%s=%%ld\\n\", (long)__%s);\n#else\nprintf(\"__%s\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 printf "#ifdef __%s__\n#if __%s__+0\nprintf(\"__%s__=%%ld\\n\", (long)__%s__);\n#else\nprintf(\"__%s__\\n\");\n#endif\n#endif\n", $1, $1, $1, $1, $1 }' >> try.c echo 'return 0;}' >> try.c EOSH cat <> Cppsym.try flags="$ccflags" case "$osname-$gccversion" in irix-) flags="\$flags -woff 1178" ;; os2-*) flags="\$flags -Zlinker /PM:VIO" ;; esac $cc -o try $optimize \$flags $ldflags try.c $libs && $run ./try EOSH chmod +x Cppsym.try $eunicefix Cppsym.try ./Cppsym < Cppsym.know > Cppsym.true : now check the C compiler for additional symbols ?X: suggested by Jarkko Hietaniemi , thanks! postprocess_cc_v='' case "$osname" in aix) postprocess_cc_v="|$tr , ' '" ;; esac $cat >ccsym <tmp.c <&1 $postprocess_cc_v\` do case "\$i" in -D*) echo "\$i" | $sed 's/^-D//';; -A*) $test "$gccversion" && echo "\$i" | $sed 's/^-A//' | $sed 's/\(.*\)(\(.*\))/\1=\2/';; esac done $rm -f try.c EOS postprocess_cc_v='' chmod +x ccsym $eunicefix ccsym ./ccsym > ccsym1.raw ?X: AIX complains if $uniq is passed an empty file. ($sort apparently ?X: doesn't care.) --AD 14 July 1998 if $test -s ccsym1.raw; then $sort ccsym1.raw | $uniq >ccsym.raw else mv ccsym1.raw ccsym.raw fi ?X: canonicalize symbols for easier sort/uniq/comm usage: append =1 if no = sign ?X: the awk script must be on two lines for older awk programs, sigh! -- ADO $awk '/\=/ { print $0; next } { print $0"=1" }' ccsym.raw >ccsym.list $awk '/\=/ { print $0; next } { print $0"=1" }' Cppsym.true >ccsym.true $comm -13 ccsym.true ccsym.list >ccsym.own $comm -12 ccsym.true ccsym.list >ccsym.com $comm -23 ccsym.true ccsym.list >ccsym.cpp also='' if $test -z ccsym.raw; then echo "Your C compiler doesn't seem to define any symbols!" >&4 echo " " echo "However, your C preprocessor defines the following symbols:" $cat Cppsym.true ccsymbols='' cppsymbols=`$cat Cppsym.true` cppsymbols=`echo $cppsymbols` cppccsymbols="$cppsymbols" else if $test -s ccsym.com; then echo "Your C compiler and pre-processor define these symbols:" $sed -e 's/\(..*\)=.*/\1/' ccsym.com also='also ' symbols='ones' cppccsymbols=`$cat ccsym.com` cppccsymbols=`echo $cppccsymbols` $test "$silent" || sleep 1 fi if $test -s ccsym.cpp; then $test "$also" && echo " " echo "Your C pre-processor ${also}defines the following symbols:" $sed -e 's/\(..*\)=.*/\1/' ccsym.cpp also='further ' cppsymbols=`$cat ccsym.cpp` cppsymbols=`echo $cppsymbols` $test "$silent" || sleep 1 fi if $test -s ccsym.own; then $test "$also" && echo " " echo "Your C compiler ${also}defines the following cpp symbols:" $sed -e 's/\(..*\)=1/\1/' ccsym.own $sed -e 's/\(..*\)=.*/\1/' ccsym.own | $uniq >>Cppsym.true ccsymbols=`$cat ccsym.own` ccsymbols=`echo $ccsymbols` $test "$silent" || sleep 1 fi fi $rm -f Cppsym.know Cppsym.true metaconfig-debian-perl-5.26.1/dist/U/Cross.U000066400000000000000000000177361316016665300205140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Copyright (c) 2001 Jarkko Hietaniemi ?RCS: ?MAKE:run to from targetarch usecrosscompile: src awk cat grep test rm \ echo sed mkdir cp touch chmod ?MAKE: -pick add $@ %< ?Y:TOP ?S:usecrosscompile: ?S: This variable conditionally defines the USE_CROSS_COMPILE symbol, ?S: and indicates that our package has been cross-compiled. ?S:. ?S:run: ?S: This variable contains the command used by Configure ?S: to copy and execute a cross-compiled executable in the ?S: target host. Useful and available only during the build. ?S: Empty string '' if not cross-compiling. ?S:. ?S:from: ?S: This variable contains the command used by Configure ?S: to copy files from the target host. Useful and available ?S: only during the build. ?S: The string ':' if not cross-compiling. ?S:. ?S:to: ?S: This variable contains the command used by Configure ?S: to copy to from the target host. Useful and available ?S: only during the build. ?S: The string ':' if not cross-compiling. ?S:. ?S:targetarch: ?S: If cross-compiling, this variable contains the target architecture. ?S: If not, this will be empty. ?S:. ?C:USE_CROSS_COMPILE: ?C: This symbol, if defined, indicates that the package is being ?C: cross-compiled. ?C:. ?C:CROSS_TARGET_ARCH: ?C: This symbol, if defined, indicates the target architecture ?C: the package has been cross-compiled to. ?C: Undefined if not a cross-compile. ?C:. ?H:?usecrosscompile:#ifndef USE_CROSS_COMPILE ?H:?usecrosscompile:#$usecrosscompile USE_CROSS_COMPILE /**/ ?H:?usecrosscompile:#define CROSS_TARGET_ARCH "$targetarch" /**/ ?H:?usecrosscompile:#endif ?H:. ?T:croak pwd exe f q i j cwd ?LINT:extern usecrosscompile ?LINT:extern cc ?LINT:extern usrinc ?LINT:change usrinc ?LINT:change ar ?LINT:change nm ?LINT:change ranlib ?LINT:extern targethost ?LINT:extern targetdir ?LINT:change targetdir ?LINT:extern targetuser ?LINT:change targetuser ?LINT:extern targetrun ?LINT:extern targetfrom ?LINT:extern targetto ?LINT:extern targetmkdir ?LINT:change targetrun ?LINT:change targetfrom ?LINT:change targetto ?LINT:change targetmkdir ?LINT:extern incpth ?LINT:extern libpth ?LINT:change incpth ?LINT:change libpth ?LINT:extern locincpth ?LINT:extern loclibpth ?LINT:change locincpth ?LINT:change loclibpth ?LINT:extern TMPDIR : setup for possible cross-compilation run='' to=: from=: usecrosscompile='undef' targetarch='' case "$usecrosscompile" in $define|true|[yY]*) @if { test -d ../Cross } ?X: ?X: Cross-compilation is enabled when there is a 'Cross' directory found ?X: at the root of the package. This directory must contain the following ?X: entries for defining the cross-compilation process: ?X: ?X: FIXME FIXME ?X: WE MUST DISTINGUISH BETWEEN LOCAL cross-compiling AND REMOTE ONE ?X: ACTUALLY, REMOTE COMPILATION SHOULD BE CONFIGURED INTERACTIVELY ?X: IT WILL COPY ALL THE FILES FROM THE MANIFEST DOWN TO THE REMOTE DIR... ?X: (and copy things like 'mkdep', etc...) ?X: $echo "Cross-compiling..." croak='' case "$cc" in *-*-gcc) ?X: A cross-compiling gcc, probably. targetarch=`$echo $cc|$sed 's/-gcc$//'` ar=$targetarch-ar ?X: leave out ld, choosing it is more complex nm=$targetarch-nm ranlib=$targetarch-ranlib $echo 'extern int foo;' > try.c set X `$cc -v -E try.c 2>&1 | \ $awk '/^#include &4 for i in $*; do j="`$echo $i|$sed 's,/include$,/lib,'`" if $test -d $j; then libpth="$libpth $j" fi done libpth="`$echo $libpth|$sed 's/^ //'`" echo "Guessing libpth '$libpth'." >&4 fi $rm -f try.c ;; esac case "$targetarch" in '') echo "Targetarch not defined." >&4; croak=y ;; *) echo "Using targetarch $targetarch." >&4 ;; esac case "$incpth" in '') echo "Incpth not defined." >&4; croak=y ;; *) echo "Using incpth '$incpth'." >&4 ;; esac case "$libpth" in '') echo "Libpth not defined." >&4; croak=y ;; *) echo "Using libpth '$libpth'." >&4 ;; esac case "$usrinc" in '') for i in $incpth; do if $test -f $i/errno.h -a -f $i/stdio.h -a -f $i/time.h; then usrinc=$i echo "Guessing usrinc $usrinc." >&4 break fi done case "$usrinc" in '') echo "Usrinc not defined." >&4; croak=y ;; esac ;; *) echo "Using usrinc $usrinc." >&4 ;; esac case "$targethost" in '') echo "Targethost not defined." >&4; croak=y ;; *) echo "Using targethost $targethost." >&4 esac locincpth=' ' loclibpth=' ' case "$croak" in y) echo "Cannot continue, aborting." >&4; exit 1 ;; esac case "$src" in /*) run=$src/Cross/run targetmkdir=$src/Cross/mkdir to=$src/Cross/to from=$src/Cross/from ;; *) pwd=`$test -f ../Configure & cd ..; pwd` run=$pwd/Cross/run targetmkdir=$pwd/Cross/mkdir to=$pwd/Cross/to from=$pwd/Cross/from ;; esac case "$targetrun" in '') targetrun=ssh ;; esac case "$targetto" in '') targetto=scp ;; esac case "$targetfrom" in '') targetfrom=scp ;; esac run=$run-$targetrun to=$to-$targetto from=$from-$targetfrom case "$targetdir" in '') targetdir="${TMPDIR:-/tmp}" echo "Guessing targetdir $targetdir." >&4 ;; esac case "$targetuser" in '') targetuser=root echo "Guessing targetuser $targetuser." >&4 ;; esac case "$targetfrom" in scp) q=-q ;; *) q='' ;; esac case "$targetrun" in ssh|rsh) $cat >$run <&4 exit 1 ;; esac case "$targetmkdir" in */Cross/mkdir) $cat >$targetmkdir <&4 exit 1 ;; esac case "$targetto" in scp|rcp) $cat >$to <$to <&4 exit 1 ;; esac case "$targetfrom" in scp|rcp) $cat >$from <$from <&4 exit 1 ;; esac if $test ! -f $run; then echo "Target 'run' script '$run' not found." >&4 else $chmod a+rx $run fi if $test ! -f $to; then echo "Target 'to' script '$to' not found." >&4 else $chmod a+rx $to fi if $test ! -f $from; then echo "Target 'from' script '$from' not found." >&4 else $chmod a+rx $from fi if $test ! -f $run -o ! -f $to -o ! -f $from; then exit 1 fi $cat >&4 <&4 exit 1 @end ;; esac metaconfig-debian-perl-5.26.1/dist/U/Csym.U000066400000000000000000000066111316016665300203240ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Csym.U,v $ ?RCS: Revision 3.0.1.4 1995/07/25 13:36:29 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: patch56: added quotes for OS/2 support ?RCS: ?RCS: Revision 3.0.1.3 1995/05/12 12:00:33 ram ?RCS: patch54: fixed C test program to bypass gcc builtin type checks (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/10/31 09:34:13 ram ?RCS: patch44: added Options to the MAKE line since it's no longer in Init.U ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:00:05 ram ?RCS: patch6: added ldflags as a conditional dependency and to compile line ?RCS: patch6: a final double quote was missing in csym variable after eval ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:Csym: Options contains libc libs runnm +cc +ccflags +ldflags rm ?MAKE: -pick add $@ %< ?LINT:define csym ?LINT:use libc ?S:csym: ?S: This shell variable is used internally by Configure to check ?S: wether a given C symbol is defined or not. A typical use is: ?S: set symbol result [-fva] [previous] ?S: eval $csym ?S: That will set result to 'true' if the function [-f], variable [-v] ?S: or array [-a] is defined, 'false' otherwise. If a previous value is ?S: given and the -r flag was provided on the command line, that value ?S: is reused without questioning. ?S:. ?V:csym ?T:tval tx tlook tf tdc tc : is a C symbol defined? csym='tlook=$1; case "$3" in -v) tf=libc.tmp; tc=""; tdc="";; -a) tf=libc.tmp; tc="[0]"; tdc="[]";; *) tlook="^$1\$"; tf=libc.list; tc=""; tdc="()";; esac; tx=yes; case "$reuseval-$4" in true-) ;; true-*) tx=no; eval "tval=\$$4"; case "$tval" in "") tx=yes;; esac;; esac; case "$tx" in yes) case "$runnm" in true) if $contains $tlook $tf >/dev/null 2>&1; then tval=true; else tval=false; fi;; *) ?X: ?X: We use 'char' instead of 'int' to try to circumvent overzealous ?X: optimizing compilers using built-in prototypes for commonly used ?X: routines to complain when seeing a different external declaration. For ?X: instance, gcc 2.6.3 fails if we use 'int' and we attempt a test against ?X: memcpy() on machines where sizeof(int) == sizeof(char *) (the usual return ?X: type), the compiler assuming it's a built-in declaration given that the ?X: returned size matches. At least with 'char' we are safe! -- RAM, for ADO ?X: ?X: Let's thank GNU cc for making our lifes so easy! :-) ?X: (An alternative for the future would be to use our knowledge about gcc ?X: to force a -fno-builtin option in the compile test, in case the 'char' ?X: trick is obsoleted by future gcc releases). -- RAM ?X: ?X: Lastly, gcc 3.4 otimizes &missing == 0 away, so we use + 2 instead now. ?X: The GNU folks like to do weird things, don't they? -- RAM, 2004-06-05 ?X: echo "extern char $1$tdc; int main() { return &$1$tc + 2; }" > t.c; if $cc $ccflags $ldflags -o t t.c $libs >/dev/null 2>&1; then tval=true; else tval=false; fi; $rm -f t t.c;; esac;; *) case "$tval" in $define) tval=true;; *) tval=false;; esac;; esac; eval "$2=$tval"' metaconfig-debian-perl-5.26.1/dist/U/End.U000066400000000000000000000017401316016665300201150ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: End.U,v $ ?RCS: Revision 3.0 1993/08/18 12:04:51 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit serves as the goal which forces make to choose all the units that ?X: ask questions. The $W on the ?MAKE: line is the list of all symbols wanted. ?X: To force any unit to be included, copy this unit to your private U directory ?X: and add the name of the unit desired to the ?MAKE: dependency line. ?X: ?MAKE:End: $W ?MAKE: -pick add $@ %< ?LINT:use $W : end of configuration questions echo " " echo "End of configuration questions." metaconfig-debian-perl-5.26.1/dist/U/Extract.U000066400000000000000000000060301316016665300210160ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Extract.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 14:58:52 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:51:46 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:52 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script which can be doted in order to extract ?X: .SH files with variable substitutions. ?X: ?X: When running Configure from a remote directory ($src is not '.'), ?X: then the files will be created in that directory, so beware! ?X: ?MAKE:Extract: Mkdirp src ?MAKE: -pick add $@ %< ?F:./extract ?T:CONFIG SRC dir file : script used to extract .SH files with variable substitutions cat >extract <>extract <<'EOS' echo "Doing variable substitutions on .SH files..." if test -f "$SRC/MANIFEST"; then set x `awk '{print $1}' <$SRC/MANIFEST | grep '\.SH'` else echo "(Looking for .SH files under the source directory.)" set x `(cd "$SRC"; find . -name "*.SH" -print)` fi shift case $# in 0) set x `(cd "$SRC"; echo *.SH)`; shift;; esac if test ! -f "$SRC/$1"; then shift fi for file in $*; do case "$SRC" in ".") case "$file" in */*) dir=`expr X$file : 'X\(.*\)/'` file=`expr X$file : 'X.*/\(.*\)'` (cd $dir && . ./$file) ;; *) . ./$file ;; esac ;; *) ?X: ?X: When running Configure remotely ($src is not '.'), we cannot source ?X: the files directly, since that would wrongly cause the extraction ?X: where the source lie instead of withing the current directory. Therefore, ?X: we need to 'sh src -> Options -> Extract ?X: The Begin.U unit now requires us before beginning to do anything ?X: interesting, to ensure proper semantics. -- RAM, 15/03/96 ?X: ?MAKE:Extractall: Extract Options ?MAKE: -pick wipe $@ %< : extract files and exit if asked to do so case "$extractsh" in true) ?X: Undo the forced silent=true when -S was supplied, by probing realsilent ?X: which was set iff -s was also given. See Options.U for details. case "$realsilent" in true) ;; *) exec 1>&4;; esac case "$config_sh" in '') config_sh='config.sh';; esac echo " " echo "Fetching answers from $config_sh..." cd .. . $config_sh test "$override" && . ./optdef.sh echo " " ?X: extract has to be run from the top directory, not within UU. . UU/extract rm -rf UU echo "Extraction done." exit 0 ;; esac metaconfig-debian-perl-5.26.1/dist/U/Filexp.U000066400000000000000000000036631316016665300206440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Filexp.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 15:52:53 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: added HOME to the ?T: line since metalint now checks ${HOME} ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:03:00 ram ?RCS: patch23: made sure error status from csh is propagated (WED) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:53 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script which will expand filenames beginning ?X: with tildes. The script is deleted at the end of Configure. ?X: ?MAKE:Filexp: startsh sed test expr eunicefix ?MAKE: -pick add $@ %< ?F:./filexp ?T:HOME LOGDIR dir me name failed : set up shell script to do ~ expansion cat >filexp <&2 exit 1 fi case "\$1" in */*) echo \$dir/\`$expr x\$1 : '..[^/]*/\(.*\)'\` ;; *) echo \$dir ;; esac fi ;; *) echo \$1 ;; esac EOSS chmod +x filexp $eunicefix filexp metaconfig-debian-perl-5.26.1/dist/U/Findhdr.U000066400000000000000000000072351316016665300207720ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Thomas Neumann ?RCS: ?RCS: $Log: Findhdr.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 15:53:08 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:03:56 ram ?RCS: patch23: cppminus must be after other cppflags, not before ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:54 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a findhdr script which is used to locate the header ?X: files in $usrinc or other stranger places using cpp capabilities. The ?X: script is given an include file base name, like 'stdio.h' or 'sys/file.h' ?X: and it returns the full path of the include file and a zero status or an ?X: empty string with an error status if the file could not be located. ?X: ?MAKE:Findhdr: grep test tr rm +usrinc awk cat startsh \ cppstdin cppminus +cppflags eunicefix osname ?MAKE: -pick add $@ %< ?LINT:define fieldn ?S:fieldn: ?S: This variable is used internally by Configure. It contains the position ?S: of the included file name in cpp output. That is to say, when cpp ?S: pre-processes a #include line, it replaces it by a # line which ?S: contains the original position in the input file and the full name of ?S: included file, between "quotes". ?S:. ?V:fieldn ?F:./findhdr !fieldn ?T:cline pos wanted name awkprg cppfilter testaccess status usrincdir : determine filename position in cpp output echo " " echo "Computing filename position in cpp output for #include directives..." >&4 echo '#include ' > foo.c case "$osname" in vos) testaccess=-e ?X: VOS: path component separator is > cppfilter="tr '\\\\>' '/' |" ;; *) testaccess=-r cppfilter='' ;; esac $cat >fieldn </dev/null | \ $grep '^[ ]*#.*stdio\.h' | \ while read cline; do pos=1 set \$cline while $test \$# -gt 0; do if $test $testaccess \`echo \$1 | $tr -d '"'\`; then echo "\$pos" exit 0 fi shift pos=\`expr \$pos + 1\` done done EOF chmod +x fieldn fieldn=`./fieldn` $rm -f foo.c fieldn case $fieldn in '') pos='???';; 1) pos=first;; 2) pos=second;; 3) pos=third;; *) pos="${fieldn}th";; esac echo "Your cpp writes the filename in the $pos field of the line." ?X: To locate a header file, we cannot simply check for $usrinc/file.h, since ?X: some machine have the headers in weird places and our only hope is that ?X: the C pre-processor will know how to find those headers. Thank you NexT! : locate header file $cat >findhdr <" > foo\$\$.c $cppstdin $cppminus $cppflags < foo\$\$.c 2>/dev/null | \ $cppfilter $grep "^[ ]*#.*\$wanted" | \ while read cline; do name=\`echo \$cline | $awk "\$awkprg" | $tr -d '"'\` case "\$name" in *[/\\\\]\$wanted) echo "\$name"; exit 1;; *[\\\\/]\$wanted) echo "\$name"; exit 1;; *) exit 2;; esac done ?X: status = 0: grep returned 0 lines, case statement not executed ?X: status = 1: headerfile found ?X: status = 2: while loop executed, no headerfile found status=\$? $rm -f foo\$\$.c if test \$status -eq 1; then exit 0 fi exit 1 EOF chmod +x findhdr $eunicefix findhdr metaconfig-debian-perl-5.26.1/dist/U/Finish.U000066400000000000000000000073661316016665300206410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Finish.U,v $ ?RCS: Revision 3.0.1.6 1995/02/15 14:09:30 ram ?RCS: patch51: now clearer about how to edit config.sh at the prompt (WED) ?RCS: ?RCS: Revision 3.0.1.5 1994/10/29 15:53:14 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.4 1994/05/06 14:19:37 ram ?RCS: patch23: added blank lines around 'End of Configure' ?RCS: ?RCS: Revision 3.0.1.3 1993/10/16 13:46:09 ram ?RCS: patch12: replaced Config_h by Magic_h in the dependency line ?RCS: ?RCS: Revision 3.0.1.2 1993/09/13 15:45:26 ram ?RCS: patch10: fixed shell evaluation w/o shell escape while in silent mode ?RCS: ?RCS: Revision 3.0.1.1 1993/08/30 08:55:59 ram ?RCS: patch8: prevents myread from blocking on empty answers, exceptionally ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:55 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit is the very last one in the Configure script. It runs all the ?X: SH files, which among other things produce config.h and (usually) Makefile. ?X: It offers to do a make depend if the Makefile contains that target. ?X: ?MAKE:Finish: Chk_MANI Extract Myread Oldsym Magic_h cat rm contains \ test package make ?MAKE: -pick add $@ %< ?F:!config.sh ?T:pwd : Finish up by extracting the .SH files case "$alldone" in exit) ?X: They supplied the -E switch echo "Stopping at your request, leaving temporary files around." exit 0 ;; cont) ;; '') dflt='' nostick=true $cat <&4 -c "$ans";; esac ;; esac : if this fails, just run all the .SH files by hand . ./config.sh ?X: ?X: Turn silent mode off from now on (we want a verbose file extraction). ?X: This means we have to explicitly test for '$silent' from now on to ?X: strip off any verbose messages. ?X: echo " " exec 1>&4 pwd=`pwd` . ./UU/extract cd "$pwd" if $contains '^depend:' [Mm]akefile >/dev/null 2>&1; then dflt=y case "$silent" in true) ;; *) $cat < makedepend.out &" It can take a while, so you might not want to run it right now. EOM ;; esac rp="Run $make depend now?" . UU/myread case "$ans" in y*) $make depend && echo "Now you must run '$make'." ;; *) echo "You must run '$make depend' then '$make'." ;; esac elif test -f [Mm]akefile; then echo " " echo "Now you must run a $make." else echo "Configure done." fi if $test -f Policy.sh; then $cat <&4 fi ?X: ?X: kit*isdone files are left over by shell archives built using the makedist ?X: script which comes from dist, while ark*isdone files are left over by ?X: the cshar archive maker. ?X: $rm -f kit*isdone ark*isdone $rm -rf UU : End of Configure metaconfig-debian-perl-5.26.1/dist/U/Getfile.U000066400000000000000000000210161316016665300207640ustar00rootroot00000000000000?RCS: $Id: Getfile.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Getfile.U,v $ ?RCS: Revision 3.0.1.7 1997/02/28 15:01:06 ram ?RCS: patch61: getfile script now begins with "startsh" ?RCS: ?RCS: Revision 3.0.1.6 1995/02/15 14:11:00 ram ?RCS: patch51: was not working if ~'s allowed with d_portable on (WED) ?RCS: ?RCS: Revision 3.0.1.5 1995/01/11 15:11:25 ram ?RCS: patch45: added support for escaping answers to skip various checks ?RCS: patch45: modified message issued after file expansion ?RCS: ?RCS: Revision 3.0.1.4 1994/10/29 15:53:19 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.3 1994/05/06 14:23:36 ram ?RCS: patch23: getfile could be confused by file name in "locate" requests ?RCS: patch23: new 'p' directive to assume file is in people's path (WED) ?RCS: ?RCS: Revision 3.0.1.2 1994/01/24 14:01:31 ram ?RCS: patch16: added metalint hint on changed 'ans' variable ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:46:27 ram ?RCS: patch10: minor format problems and misspellings fixed ?RCS: patch10: now performs from package dir and not from UU subdir ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:56 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in in order ?X: to get a file name and make some sanity checks. Optionally, a ~name ?X: expansion is performed. ?X: ?X: To use this unit, $rp and $dflt must hold the question and the ?X: default answer, which will be passed as-is to the myread script. ?X: The $fn variable must hold the file type (f or d, for file/directory). ?X: If $gfpth is set to a list of space-separated list of directories, ?X: those are prefixes for the filename. Unless $gfpthkeep is set to 'y', ?X: gfpth is cleared on return from Getfile. ?X: ?X: If is is followed by a ~, then ~name substitution will occur. Upon return, ?X: $ans is set with the filename value. If a / is specified, then only a full ?X: path name is accepted (but ~ substitution occurs before, if needed). The ?X: expanded path name is returned in that case. ?X: ?X: If a + is specified, the existence checks are skipped. This usually means ?X: the file/directory is under the full control of the program. ?X: ?X: If the 'n' (none) type is used, then the user may answer none. ?X: The 'e' (expand) switch may be used to bypass d_portable, expanding ~name. ?X: ?X: If the 'l' (locate) type is used, then it must end with a ':' and then a ?X: file name. If the answer is a directory, the file name will be appended ?X: before testing for file existence. This is useful in locate-style ?X: questions like "where is the active file?". In that case, one should ?X: use: ?X: ?X: dflt='~news/lib' ?X: fn='l~:active' ?X: rp='Where is the active file?' ?X: . ./getfile ?X: active="$ans" ?X: ?X: If the 'p' (path) letter is specified along with 'l', then an answer ?X: without a leading / will be expected to be found in everyone's path. ?X: ?X: It is also possible to include a comma-separated list of items within ?X: parentheses to specify which items should be accepted as-is with no ?X: further checks. This is useful when for instance a full path is expected ?X: but the user may escape out via "magical" answers. ?X: ?X: If the answer to the question is 'none', then the existence checks are ?X: skipped and the empty string is returned. ?X: ?MAKE:Getfile: d_portable contains startsh Myread Filexp tr trnl ?MAKE: -pick add $@ %< ?V:ansexp:fn gfpth gfpthkeep ?F:./getfile ?T:tilde type what orig_rp orig_dflt fullpath already redo skip none_ok \ value exp_file nopath_ok loc_file fp pf dir direxp ?LINT:change ans ?LINT:change gfpth : now set up to get a file name cat <getfile $startsh EOS cat <<'EOSC' >>getfile tilde='' fullpath='' already='' skip='' none_ok='' exp_file='' nopath_ok='' orig_rp="$rp" orig_dflt="$dflt" case "$gfpth" in '') gfpth='.' ;; esac ?X: Begin by stripping out any (...) grouping. case "$fn" in *\(*) : getfile will accept an answer from the comma-separated list : enclosed in parentheses even if it does not meet other criteria. expr "$fn" : '.*(\(.*\)).*' | $tr ',' $trnl >getfile.ok fn=`echo $fn | sed 's/(.*)//'` ;; esac ?X: Catch up 'locate' requests early, so that we may strip the file name ?X: before looking at the one-letter commands, in case the file name contains ?X: one of them. Reported by Wayne Davison . case "$fn" in *:*) loc_file=`expr $fn : '.*:\(.*\)'` fn=`expr $fn : '\(.*\):.*'` ;; esac case "$fn" in *~*) tilde=true;; esac case "$fn" in */*) fullpath=true;; esac case "$fn" in *+*) skip=true;; esac case "$fn" in *n*) none_ok=true;; esac case "$fn" in *e*) exp_file=true;; esac case "$fn" in *p*) nopath_ok=true;; esac case "$fn" in *f*) type='File';; *d*) type='Directory';; *l*) type='Locate';; esac what="$type" case "$what" in Locate) what='File';; esac case "$exp_file" in '') case "$d_portable" in "$define") ;; *) exp_file=true;; esac ;; esac cd .. while test "$type"; do redo='' rp="$orig_rp" dflt="$orig_dflt" case "$tilde" in true) rp="$rp (~name ok)";; esac . UU/myread ?X: check for allowed escape sequence which may be accepted verbatim. if test -f UU/getfile.ok && \ $contains "^$ans\$" UU/getfile.ok >/dev/null 2>&1 then value="$ans" ansexp="$ans" break fi case "$ans" in none) value='' ansexp='' case "$none_ok" in true) type='';; esac ;; *) case "$tilde" in '') value="$ans" ansexp="$ans";; *) value=`UU/filexp $ans` case $? in 0) if test "$ans" != "$value"; then echo "(That expands to $value on this system.)" fi ;; *) value="$ans";; esac ansexp="$value" case "$exp_file" in '') value="$ans";; esac ;; esac case "$fullpath" in true) ?X: Perform all the checks on ansexp and not value since when d_portable ?X: is defined, the original un-expanded answer which is stored in value ?X: would lead to "non-existent" error messages whilst ansexp has been ?X: properly expanded. -- Fixed by Jan.Djarv@sa.erisoft.se (Jan Djarv) ?X: Always expand ~user if '/' was requested case "$ansexp" in /*) value="$ansexp" ;; ?X: Allow for c:/some/path [a-zA-Z]:/*) value="$ansexp" ;; *) redo=true case "$already" in true) echo "I shall only accept a full path name, as in /bin/ls." >&4 echo "Use a ! shell escape if you wish to check pathnames." >&4 ;; *) echo "Please give a full path name, starting with slash." >&4 case "$tilde" in true) echo "Note that using ~name is ok provided it expands well." >&4 already=true ;; esac esac ;; esac ;; esac case "$redo" in '') case "$type" in File) for fp in $gfpth; do if test "X$fp" = X.; then pf="$ansexp" else pf="$fp/$ansexp" fi if test -f "$pf"; then type='' elif test -r "$pf" || (test -h "$pf") >/dev/null 2>&1 then echo "($value is not a plain file, but that's ok.)" type='' fi if test X"$type" = X; then value="$pf" break fi done ;; Directory) for fp in $gfpth; do if test "X$fp" = X.; then dir="$ans" direxp="$ansexp" else dir="$fp/$ansexp" direxp="$fp/$ansexp" fi if test -d "$direxp"; then type='' value="$dir" break fi done ;; Locate) if test -d "$ansexp"; then echo "(Looking for $loc_file in directory $value.)" value="$value/$loc_file" ansexp="$ansexp/$loc_file" fi if test -f "$ansexp"; then type='' fi case "$nopath_ok" in true) case "$value" in */*) ;; *) echo "Assuming $value will be in people's path." type='' ;; esac ;; esac ;; esac case "$skip" in true) type=''; esac case "$type" in '') ;; *) if test "$fastread" = yes; then dflt=y else dflt=n fi rp="$what $value doesn't exist. Use that name anyway?" . UU/myread dflt='' case "$ans" in y*) type='';; *) echo " ";; esac ;; esac ;; esac ;; esac done cd UU ans="$value" rp="$orig_rp" dflt="$orig_dflt" rm -f getfile.ok test "X$gfpthkeep" != Xy && gfpth="" EOSC metaconfig-debian-perl-5.26.1/dist/U/Guess.U000066400000000000000000000152711316016665300205010ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Guess.U,v $ ?RCS: Revision 3.0.1.5 1995/07/25 13:37:14 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.4 1994/10/29 15:53:55 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: call ./xenix explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0.1.3 1993/12/15 08:14:35 ram ?RCS: patch15: variable d_bsd was not always set properly ?RCS: ?RCS: Revision 3.0.1.2 1993/08/30 08:57:14 ram ?RCS: patch8: fixed comment which wrongly attributed the usrinc symbol ?RCS: patch8: no more ugly messages when no /usr/include/ctype.h ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:37:37 ram ?RCS: patch7: added support for OSF/1 machines ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit hazards some guesses as to what the general nature of the system ?X: is. The information it collects here is used primarily to establish default ?X: answers to other questions. ?X: ?MAKE:Guess d_eunice d_xenix d_bsd d_linux d_dos d_os2: cat test echo n c \ contains rm tr Loc eunicefix ?MAKE: -pick add $@ %< ?S:d_eunice: ?S: This variable conditionally defines the symbols EUNICE_SYSTEM, which ?S: alerts the C program that it must deal with ideosyncracies of VMS. ?S:. ?S:d_xenix: ?S: This variable conditionally defines the symbol XENIX_SYSTEM, which alerts ?S: the C program that it runs under Xenix. ?S:. ?S:d_dos: ?S: This symbol conditionally defines the symbol DOS_SYSTEM when running on ?S: DOS with DJGPP or Cygwin. ?S:. ?S:d_os2: ?S: This symbol conditionally defines the symbol OS2_SYSTEM when running on ?S: an OS/2 system. ?S:. ?S:d_bsd: ?S: This symbol conditionally defines the symbol BSD_SYSTEM when running on a ?S: BSD system. ?S:. ?S:d_linux: ?S: This symbol conditionally defines the symbol LINUX_SYSTEM when running ?S: on a Linux system. ?S:. ?C:EUNICE_SYSTEM (EUNICE): ?C: This symbol, if defined, indicates that the program is being compiled ?C: under the EUNICE package under VMS. The program will need to handle ?C: things like files that don't go away the first time you unlink them, ?C: due to version numbering. It will also need to compensate for lack ?C: of a respectable link() command. ?C:. ?C:VMS_SYSTEM (VMS): ?C: This symbol, if defined, indicates that the program is running under ?C: VMS. It is currently only set in conjunction with the EUNICE symbol. ?C:. ?C:XENIX_SYSTEM (XENIX): ?C: This symbol, if defined, indicates that the program is running under ?C: Xenix (at least 3.0 ?). ?C:. ?C:DOS_SYSTEM: ?C: This symbol, if defined, indicates that the program is running under ?C: DOS with DJGPP. ?C:. ?C:OS2_SYSTEM: ?C: This symbol, if defined, indicates that the program is running under ?C: an OS/2 system. ?C:. ?C:BSD_SYSTEM: ?C: This symbol, if defined, indicates that the program is running under ?C: a BSD system. ?C:. ?C:LINUX_SYSTEM: ?C: This symbol, if defined, indicates that the program is running under ?C: a Linux system. ?C:. ?H:#$d_eunice EUNICE_SYSTEM /**/ ?H:#$d_eunice VMS_SYSTEM /**/ ?H:#$d_xenix XENIX_SYSTEM /**/ ?H:#$d_dos DOS_SYSTEM /**/ ?H:#$d_os2 OS2_SYSTEM /**/ ?H:#$d_bsd BSD_SYSTEM /**/ ?H:#$d_linux LINUX_SYSTEM /**/ ?H:. ?F:./bsd ./usg ./v7 ./osf1 ./eunice ./xenix ./venix ./dos ./os2 ./gnu ./linux ?T:xxx DJGPP MACHTYPE : make some quick guesses about what we are up against echo " " $echo $n "Hmm... $c" echo exit 1 >bsd echo exit 1 >usg echo exit 1 >v7 echo exit 1 >osf1 echo exit 1 >eunice echo exit 1 >xenix echo exit 1 >venix echo exit 1 >os2 echo exit 1 >gnu echo exit 1 >linux echo exit 1 >dos d_bsd="$undef" d_linux="$undef" d_dos="$undef" d_os2="$undef" ?X: ?X: Do not use 'usrinc', or we get a circular dependency. because ?X: usrinc is defined in usrinc.U, which relies on us... ?X: $cat /usr/include/signal.h /usr/include/sys/signal.h >foo 2>/dev/null if test -f /osf_boot || $contains 'OSF/1' /usr/include/ctype.h >/dev/null 2>&1 then echo "Looks kind of like an OSF/1 system, but we'll see..." echo exit 0 >osf1 elif test `echo abc | $tr a-z A-Z` = Abc ; then xxx=`./loc addbib blurfl $pth` if $test -f $xxx; then echo "Looks kind of like a USG system with BSD features, but we'll see..." echo exit 0 >bsd echo exit 0 >usg else if $contains SIGTSTP foo >/dev/null 2>&1 ; then echo "Looks kind of like an extended USG system, but we'll see..." else echo "Looks kind of like a USG system, but we'll see..." fi echo exit 0 >usg fi elif $contains SIGTSTP foo >/dev/null 2>&1 ; then echo "Looks kind of like a BSD system, but we'll see..." d_bsd="$define" echo exit 0 >bsd elif $rm --version 2>/dev/null >foo; $contains "Free Software Foundation" foo >/dev/null then xxx=`uname` echo exit 0 >gnu echo "Looks kind of like a GNU/$xxx system, but we'll see..." if $test X$xxx = XLinux; then d_linux="$define" echo exit 0 >linux fi else echo "Looks kind of like a Version 7 system, but we'll see..." echo exit 0 >v7 fi case "$eunicefix" in *unixtovms*) $cat <<'EOI' There is, however, a strange, musty smell in the air that reminds me of something...hmm...yes...I've got it...there's a VMS nearby, or I'm a Blit. EOI echo exit 0 >eunice d_eunice="$define" : it so happens the Eunice I know will not run shell scripts in Unix format ;; *) echo " " echo "Congratulations. You aren't running Eunice." d_eunice="$undef" ;; esac case "$p_" in :) ;; *) $cat <<'EOI' I have the feeling something is not exactly right, however...don't tell me... EOI if test -n "$DJGPP"; then case "X${MACHTYPE:-nonesuchmach}" in cygwin) echo "hah!... you're running under Cygwin!";; *) echo "got it... you're running DOS with DJGPP!";; esac echo exit 0 >dos d_dos="$define" else $cat <<'EOI' lemme think...does HAL ring a bell?...no, of course, you're only running OS/2! EOI echo exit 0 >os2 d_os2="$define" fi ;; esac if test -f /xenix; then echo "Actually, this looks more like a XENIX system..." echo exit 0 >xenix d_xenix="$define" else echo " " echo "It's not Xenix..." d_xenix="$undef" fi chmod +x xenix $eunicefix xenix if test -f /venix; then echo "Actually, this looks more like a VENIX system..." echo exit 0 >venix else echo " " if ./xenix; then : null else echo "Nor is it Venix..." fi fi chmod +x bsd usg v7 osf1 eunice xenix venix dos os2 gnu linux $eunicefix bsd usg v7 osf1 eunice xenix venix dos os2 gnu linux $rm -f foo metaconfig-debian-perl-5.26.1/dist/U/Head.U000066400000000000000000000230561316016665300202540ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Head.U,v $ ?RCS: Revision 3.0.1.9 1997/02/28 15:02:09 ram ?RCS: patch61: make sure we unset CDPATH for shells that support this ?RCS: patch61: improved Korn shell detection and handling ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:40:02 ram ?RCS: patch56: added SVR4-ish /opt directories to path list (ADO) ?RCS: patch56: OS/2 platforms are using another path separator ?RCS: ?RCS: Revision 3.0.1.7 1995/03/21 08:46:15 ram ?RCS: patch52: definition of paths wrongly added spurious ':' chars ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 15:54:19 ram ?RCS: patch36: make sure ENV is unset before calling /bin/ksh ?RCS: ?RCS: Revision 3.0.1.5 1994/08/29 16:03:44 ram ?RCS: patch32: now sets PATH only using existing directories ?RCS: ?RCS: Revision 3.0.1.4 1994/06/20 06:54:28 ram ?RCS: patch30: now computes its invocation name into 'me' ?RCS: patch30: symbol me is made visible to all units read-only ?RCS: ?RCS: Revision 3.0.1.3 1993/12/15 08:15:07 ram ?RCS: patch15: added /sbin:/usr/sbin:/usr/libexec in PATH for BSD/386 ?RCS: ?RCS: Revision 3.0.1.2 1993/11/10 17:32:35 ram ?RCS: patch14: ensure PATH is reset to '.' before testing for alias ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:38:07 ram ?RCS: patch7: not all 'test' programs support the -x option ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This is the very first unit in the Configure script. It is mostly just ?X: things to keep people from getting into a tizzy right off the bat. ?X: ?MAKE:Head: ?MAKE: -pick wipe $@ %< ?V:PATH p_ _exe me newsh ?T:argv Id p paths OS2_SHELL DJGPP ?T:inksh needksh avoidksh newsh changesh reason ?F:!* ?LINT:extern ENV CDPATH SHELL MACHTYPE ?LINT:change ENV CDPATH ?LINT:nocomment #! /bin/sh # # If these # comments don't work, trim them. Don't worry about any other # shell scripts, Configure will trim # comments from them for you. # # (If you are trying to port this package to a machine without sh, # I would suggest you have a look at the prototypical config_h.SH file # and edit it to reflect your system. Some packages may include samples # of config.h for certain machines, so you might look for one of those.) # ?X: ?X: NOTE THAT A CONFIGURE SCRIPT IS IN THE PUBLIC DOMAIN (whether or not ?X: the software which uses it is in the public domain). ?X: # Yes, you may rip this off to use in other distribution packages. This # script belongs to the public domain and cannot be copyrighted. # ?X: ?X: WE ASK YOU NOT TO REMOVE OR ALTER THE FOLLOWING PARAGRAPH, PLEASE: ?X: # Note: this Configure script was generated automatically. Rather than # working with this copy of Configure, you may wish to get metaconfig. # The dist package (which contains metaconfig) is available via SVN: # svn co https://svn.code.sf.net/p/dist/code/trunk/dist ?X: ?X: NOTA BENE: ?X: If you develop you own version of metaconfig based on this work, ?X: you have to add some comments telling that the script was generated ?X: by your version, not mine: It credits your work. ?X: # $Id: Head.U 6 2006-08-25 22:21:46Z rmanfredi $ # # Generated on [metaconfig PL] cat >c1$$ <c2$$ </dev/null` test "$me" || me=$0 ;; esac ?X: ?X: To be able to run under OS/2, we must detect that early enough to use ?X: the proper path separator, stored in $p_. It is : on UNIX and ; on ?X: DOSish systems such as OS/2. ?X: : Proper separator for the PATH environment variable p_=: : On OS/2 this directory should exist if this is not floppy only system ":-]" if test -d c:/. ; then if test -n "$OS2_SHELL"; then p_=\; PATH=`cmd /c "echo %PATH%" | tr '\\\\' / ` ?X: That's a bug in ksh5.22 OS2_SHELL=`cmd /c "echo %OS2_SHELL%" | tr '\\\\' / | tr '[A-Z]' '[a-z]'` elif test -n "$DJGPP"; then case "X${MACHTYPE:-nonesuchmach}" in *cygwin) ;; *) p_=\; ;; esac fi fi ?X: ?X: There are two schools of thoughts here. Some people correctly argue that ?X: the user has a better chance than we do of setting a reasonable PATH and ?X: others argue that Configure is the best place there is to set up a suitable ?X: PATH. Well, here we try to compromize by keeping the user's PATH and ?X: appending some directories which are known to work on some machine or the ?X: other. The rationale behind this being that a novice user might not have a ?X: proper environment variable set, and some directories like /etc (where ?X: chown is located on some BSD systems) may be missing--RAM. ?X: ?X: SVR4 adds an /opt directory for optional packages. Some sites use ?X: various permutations on /opt as opposed to /usr or /usr/local.-- ADO ?X: ?X: We only add directories that are not already in the PATH of the ?X: user and the directories must exist also. ?X: : Proper PATH setting paths='/bin /usr/bin /usr/local/bin /usr/ucb /usr/local /usr/lbin' paths="$paths /opt/bin /opt/local/bin /opt/local /opt/lbin" paths="$paths /usr/5bin /etc /usr/gnu/bin /usr/new /usr/new/bin /usr/nbin" paths="$paths /opt/gnu/bin /opt/new /opt/new/bin /opt/nbin" paths="$paths /sys5.3/bin /sys5.3/usr/bin /bsd4.3/bin /bsd4.3/usr/ucb" paths="$paths /bsd4.3/usr/bin /usr/bsd /bsd43/bin /usr/ccs/bin" paths="$paths /etc /usr/lib /usr/ucblib /lib /usr/ccs/lib" paths="$paths /sbin /usr/sbin /usr/libexec" paths="$paths /system/gnu_library/bin" for p in $paths do case "$p_$PATH$p_" in *$p_$p$p_*) ;; *) test -d $p && PATH=$PATH$p_$p ;; esac done PATH=.$p_$PATH export PATH : shall we be using ksh? inksh='' needksh='' avoidksh='' newsh=/bin/ksh changesh='' ?X: Use (alias -x) and not (alias) since zsh and bash recognize the alias ?X: builtin but not the -x option which is typically ksh... ?X: We need to set up PATH before calling the "alias" built-in since some ?X: systems like HP-UX have a binary called /bin/alias. if (PATH=.; alias -x) >/dev/null 2>&1; then inksh=true fi ?X: On HP-UX, large Configure scripts may exercise a bug in /bin/sh, use ksh if test -f /hp-ux -a -f /bin/ksh; then needksh='to avoid sh bug in "here document" expansion' fi ?X: On AIX4, /bin/sh is really ksh and it causes problems, use sh if test -d /usr/lpp -a -f /usr/bin/bsh -a -f /usr/bin/uname; then if test X`/usr/bin/uname -v` = X4; then avoidksh="to avoid AIX 4's /bin/sh" newsh=/usr/bin/bsh fi fi ?X: On Digital UNIX, /bin/sh may start up buggy /bin/ksh, use sh if test -f /osf_boot -a -f /usr/sbin/setld; then if test X`/usr/bin/uname -s` = XOSF1; then avoidksh="to avoid Digital UNIX' ksh" newsh=/bin/sh ?X: if BIN_SH is set to 'xpg4', sh will start up ksh unset BIN_SH fi fi ?X: If we are not in ksh and need it, then feed us back to it case "$inksh/$needksh" in /[a-z]*) ?X: Clear ENV to avoid any ~/.kshrc that could alias cd or whatever... ?X: Don't use "unset ENV", that is not portable enough ENV='' changesh=true reason="$needksh" ;; esac ?X: If we are in ksh and must avoid it, then feed us back to a new shell case "$inksh/$avoidksh" in true/[a-z]*) changesh=true reason="$avoidksh" ;; esac ?X: Warn them if they use ksh on other systems, which are those where ?X: we don't need ksh nor want to avoid it explicitly, yet are using it. case "$inksh/$needksh-$avoidksh-" in true/--) cat </dev/null` case "$user" in '') user=`whoami 2>&1`;; esac if $contains "^$user\$" ../.config/instruct >/dev/null 2>&1; then firsttime=false echo " " rp='Would you like to see the instructions?' dflt=n . ./myread case "$ans" in [yY]*) ;; *) needman=false;; esac fi if $needman; then cat < package should be installed. If you get stuck on a question, you may use a ! shell escape to start a subshell or execute a command. Many of the questions will have default answers in square brackets; typing carriage return will give you the default. On some of the questions which ask for file or directory names you are allowed to use the ~name construct to specify the login directory belonging to "name", even if you don't have a shell which knows about that. Questions where this is allowed will be marked "(~name ok)". EOH rp='' dflt='Type carriage return to continue' . ./myread cat <<'EOH' The prompter used in this script allows you to use shell variables and backticks in your answers. You may use $1, $2, etc... to refer to the words in the default answer, as if the default line was a set of arguments given to a script shell. This means you may also use $* to repeat the whole default line, so you do not have to re-type everything to add something to the default. Everytime there is a substitution, you will have to confirm. If there is an error (e.g. an unmatched backtick), the default answer will remain unchanged and you will be prompted again. If you are in a hurry, you may run 'Configure -d'. This will bypass nearly all the questions and use the computed defaults (or the previous answers if there was already a config.sh file). Type 'Configure -h' for a list of options. You may also start interactively and then answer '& -d' at any prompt to turn on the non-interactive behaviour for the remainder of the execution. EOH . ./myread cat <) know how I blew it. This installation script affects things in two ways: 1) it may do direct variable substitutions on some of the files included in this kit. 2) it builds a config.h file for inclusion in C programs. You may edit any of these files as the need arises after running this script. If you make a mistake on a question, there is no easy way to back up to it currently. The easiest thing to do is to edit config.sh and rerun all the SH files. Configure will offer to let you do this before it runs the SH files. EOH ?X: In case they played with the prompter... dflt='Type carriage return to continue' . ./myread case "$firsttime" in true) echo $user >>../.config/instruct;; esac fi metaconfig-debian-perl-5.26.1/dist/U/Loc.U000066400000000000000000000226421316016665300201300ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Loc.U,v $ ?RCS: Revision 3.0.1.10 1997/02/28 15:04:16 ram ?RCS: patch61: allow users to specify paths on the command line ?RCS: patch61: will now substitute cp for ln if not supported ?RCS: ?RCS: Revision 3.0.1.9 1995/09/25 09:11:24 ram ?RCS: patch59: commented the purpose of the #un-def directive ?RCS: patch59: abort Configure run when mandatory command is missing ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:40:40 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.7 1995/01/11 15:13:37 ram ?RCS: patch45: protected "sh -c" within backquotes for Linux and SGI ?RCS: patch45: added path lookup for the 'comm' program ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 15:56:14 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: be careful and guard against wildcard searching (ADO) ?RCS: ?RCS: Revision 3.0.1.5 1994/06/20 06:54:55 ram ?RCS: patch30: now locates find ?RCS: ?RCS: Revision 3.0.1.4 1994/05/13 15:18:15 ram ?RCS: patch27: added byacc to the trylist (ADO) ?RCS: patch27: lint lines reformatted (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/01/24 14:01:44 ram ?RCS: patch16: added metalint hint on changed PATH variable ?RCS: ?RCS: Revision 3.0.1.2 1993/12/15 08:16:52 ram ?RCS: patch15: now set _test variable when test is built-in ?RCS: patch15: fixed rare cases where echo is not needed ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:47:13 ram ?RCS: patch10: test program not always in /bin/test (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:05 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script "loc" which can be used to find out ?X: where in a list of directories something is. It then uses loc to ?X: determine the location of commonly used programs. It leaves loc sitting ?X: around for other Configure units to use, but arranges for its demise ?X: at the end of Configure. ?X: ?X: To add a new program to find, add it both to the ?MAKE: line and to either ?X: the loclist or trylist variable. ?X: ?X: I put startsh at the end of the dependency list, in order to avoid the ?X: loading of the spitshell unit before the instructions. ?X: ?MAKE:Loc awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo egrep emacs expr find flex \ gmake gzip grep inews ksh less line lint ln lp lpr ls mail mailx \ make mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee test touch tr troff \ uname uniq uuname vi zcat zip: eunicefix n c startsh Instruct Warn ?MAKE: -pick weed $@ %< ?LINT:describe awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo egrep emacs expr find flex \ gmake gzip grep inews ksh less line lint ln lp lpr ls mail mailx \ make mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee test touch tr troff \ uname uniq uuname vi zcat zip ?V::pth loclist trylist ?F:./loc ?T:thisthing thing xxx dir file say DJGPP ?T:_test _grep _cp _gmake _egrep _ln _make dflt ?LINT: change PATH : find out where common programs are echo " " echo "Locating common programs..." >&4 cat <loc $startsh case \$# in 0) exit 1;; esac thing=\$1 shift dflt=\$1 shift for dir in \$*; do case "\$thing" in .) if test -d \$dir/\$thing; then echo \$dir exit 0 fi ;; *) ?X: Be careful in case thing includes wildcards that might expand to multiple ?X: files. Choose the last one. This happens when searching for shared ?X: libraries with version numbers. How to choose which one we want is ?X: probably an insoluble problem, in general. ?X: Some folks leave things like libc.so.orig around w/o read ?X: permission. A -r test would handle that, but since ./loc is ?X: also used to find executables (which are installed w/o read ?X: permission on SCO ODT 3.0, we can't include the -r test. for thisthing in \$dir/\$thing; do : just loop through to pick last item done if test -f \$thisthing; then echo \$thisthing exit 0 elif test -f \$thisthing$_exe; then echo \$thisthing exit 0 elif test -f \$dir/\$thing.exe; then if test -n "$DJGPP"; then echo \$dir/\$thing.exe else : on Eunice apparently echo \$dir/\$thing fi exit 0 fi ;; esac done echo \$dflt exit 1 EOSC chmod +x loc $eunicefix loc loclist=" ?awk:awk ?cat:cat ?chgrp:chgrp ?chmod:chmod ?chown:chown ?comm:comm ?cp:cp ?echo:echo ?expr:expr ?find:find ?grep:grep ?ls:ls ?mkdir:mkdir ?mv:mv ?rm:rm ?sed:sed ?sleep:sleep ?sort:sort ?tail:tail ?touch:touch ?tr:tr ?uniq:uniq " trylist=" ?Mcc:Mcc ?ar:ar ?bash:bash ?bison:bison ?byacc:byacc ?compress:compress ?cpio:cpio ?cpp:cpp ?csh:csh ?date:date ?egrep:egrep ?emacs:emacs ?flex:flex ?gmake:gmake ?gzip:gzip ?inews:inews ?ksh:ksh ?less:less ?line:line ?lint:lint ?ln:ln ?lp:lp ?lpr:lpr ?mail:mail ?mailx:mailx ?make:make ?more:more ?nm:nm ?nroff:nroff ?perl:perl ?pg:pg ?pmake:pmake ?pr:pr ?rmail:rmail ?sendmail:sendmail ?shar:shar ?smail:smail ?submit:submit ?tar:tar ?tbl:tbl ?tee:tee ?test:test ?troff:troff ?uname:uname ?uuname:uuname ?vi:vi ?zcat:zcat ?zip:zip " ?LINT:set awk ar bash bison byacc cat chgrp chmod chown \ comm compress cp cpio cpp csh date echo emacs expr find flex \ gmake gzip grep inews ksh less line lint lp lpr ls mail mailx \ mkdir more mv nm nroff perl pg pmake pr rm rmail sed sendmail \ shar sleep smail sort submit tail tar tbl tee touch tr troff \ uname uniq uuname vi zcat zip pth=`echo $PATH | sed -e "s/$p_/ /g"` pth="$pth /lib /usr/lib" for file in $loclist; do ?X: ?X: Allow them to -Dmake=pmake on the command line for instance... ?X: If the file is not fully qualified, as in -Dmake=pmake, then we ?X: look the for the specified command (pmake here). If they say ?X: -Dmake=/sbin/make for instance, then we make sure the file ?X: exists, or we die... ?X: eval xxx=\$$file case "$xxx" in /*|?:[\\/]*) if test -f "$xxx"; then : ok else ./warn "no $xxx -- ignoring your setting for $file." xxx=`./loc $file $file $pth` fi ;; '') xxx=`./loc $file $file $pth`;; *) xxx=`./loc $xxx $xxx $pth`;; esac eval $file=$xxx$_exe eval _$file=$xxx case "$xxx" in /*) echo $file is in $xxx. ;; ?X: Under OS/2, we have PC-like paths ?:[\\/]*) echo $file is in $xxx. ;; *) echo "I don't know where '$file' is, and my life depends on it." >&4 echo "Go find a public domain implementation or fix your PATH setting!" >&4 exit 1 ;; esac done echo " " echo "Don't worry if any of the following aren't found..." say=offhand for file in $trylist; do ?X: Allow them to -Dmake=pmake on the command line for instance (see above) eval xxx=\$$file case "$xxx" in /*|?:[\\/]*) if test -f "$xxx"; then : ok else ./warn "no $xxx -- ignoring your setting for $file." xxx=`./loc $file $file $pth` fi ;; '') xxx=`./loc $file $file $pth`;; *) xxx=`./loc $xxx $xxx $pth`;; esac eval $file=$xxx$_exe eval _$file=$xxx case "$xxx" in /*) echo $file is in $xxx. ;; ?X: Under OS/2, we have PC-like paths ?:[\\/]*) echo $file is in $xxx. ;; *) echo "I don't see $file out there, $say." say=either ;; esac done case "$egrep" in egrep) echo "Substituting grep for egrep." egrep=$grep _egrep=$_grep ;; esac @if ln case "$ln" in ln) echo "Substituting cp for ln." ln=$cp _ln=$_cp ;; esac @end @if make || gmake case "$make" in make) case "$gmake" in gmake) echo "I can't find make or gmake, and my life depends on it." >&4 echo "Go find a public domain implementation or fix your PATH setting!" >&4 exit 1 ;; esac ;; esac case "$gmake" in gmake) ;; *) # We can't have osname yet. if test -f "/system/gnu_library/bin/ar.pm"; then # Stratus VOS # Assume that gmake, if found, is definitely GNU make # and prefer it over the system make. echo "Substituting gmake for make." make=$gmake _make=$_gmake fi ;; esac @end case "$test" in test) echo "Hopefully test is built into your sh." ;; *) if `sh -c "PATH= test true" >/dev/null 2>&1`; then echo "Using the test built into your sh." ?X: ?X: We need to set both test and _test, since Oldconfig.U will use the _test ?X: value to systematically restore computed paths, which may be wrong if ?X: we choose to load an old config.sh generated on another platform. ?X: test=test _test=test fi ;; esac ?LINT:change n c case "$echo" in echo) echo "Hopefully echo is built into your sh." ;; ?X: For those rare cases where we don't need $echo... '') ;; *) echo " " echo "Checking compatibility between $echo and builtin echo (if any)..." >&4 $echo $n "hi there$c" >foo1 echo $n "hi there$c" >foo2 if cmp foo1 foo2 >/dev/null 2>&1; then echo "They are compatible. In fact, they may be identical." else case "$n" in '-n') n='' c='\c';; *) n='-n' c='';; esac cat <$c" $echo "*" fi $rm -f foo1 foo2 ;; esac metaconfig-debian-perl-5.26.1/dist/U/Loc_sed.U000066400000000000000000000023411316016665300207550ustar00rootroot00000000000000?RCS: $Id: Loc_sed.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1996, Andy Dougherty ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?X: This is used in perl.c. ?MAKE:full_sed: sed ?MAKE: -pick add $@ %< ?S:full_sed: ?S: This variable contains the full pathname to 'sed', whether or ?S: not the user has specified 'portability'. This is only used ?S: in the compiled C program, and we assume that all systems which ?S: can share this executable will have the same full pathname to ?S: 'sed.' ?S:. ?X: Yes, I know about the C symbol PORTABLE, but I think sed ?X: is unlikely to move, and I'm too lazy to add all the ?X: #ifdef PORTABLE sections to the perl source. ?X: ?C:LOC_SED: ?C: This symbol holds the complete pathname to the sed program. ?C:. ?H:#define LOC_SED "$full_sed" /**/ ?H:. : Store the full pathname to the sed program for use in the C program full_sed=$sed metaconfig-debian-perl-5.26.1/dist/U/Magic_h.U000066400000000000000000000031701316016665300207350ustar00rootroot00000000000000?RCS: $Id: Magic_h.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Magic_h.U,v $ ?RCS: Revision 3.0.1.2 1993/11/10 17:32:58 ram ?RCS: patch14: forgot to mention Id in the dependencies ?RCS: ?RCS: Revision 3.0.1.1 1993/10/16 13:46:59 ram ?RCS: patch12: created for ?M: lines support (magic symbols) ?RCS: ?X: ?X: This file ends up producing the confmagic.h include, which is used to ?X: automagically remap some C symbols via cpp redefinitions. ?X: ?X: The file ./Magic_h below contains all the ?M: lines extracted out of all ?X: the units. Metaconfig itself adds the final #endif statement. ?X: Note that this code isn't included into Configure, but must be shipped with. ?X: ?MAKE:Magic_h: Id Config_h ?MAKE: -pick cm_h_weed $@ %< ?MAKE: -pick cm_h_weed $@ ./Magic_h ?LINT:nocomment /* * This file was produced by running metaconfig and is intended to be included * after config.h and after all the other needed includes have been dealt with. * * This file may be empty, and should not be edited. Rerun metaconfig instead. * If you wish to get rid of this magic, remove this file and rerun metaconfig * without the -M option. * * $Id: Magic_h.U 1 2006-08-24 12:32:52Z rmanfredi $ */ #ifndef _confmagic_h_ #define _confmagic_h_ metaconfig-debian-perl-5.26.1/dist/U/MailAuthor.U000066400000000000000000000141061316016665300214540ustar00rootroot00000000000000?RCS: $Id: MailAuthor.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Graham Stoney ?RCS: ?RCS: $Log: MailAuthor.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 15:04:41 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.4 1994/08/29 16:05:09 ram ?RCS: patch32: avoid message sending if they said no previously ?RCS: ?RCS: Revision 3.0.1.3 1993/10/16 13:47:30 ram ?RCS: patch12: now makes sure user-specified address is in Internet format ?RCS: ?RCS: Revision 3.0.1.2 1993/09/13 15:48:49 ram ?RCS: patch10: reverted to original intent by the Author himself ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:38:38 ram ?RCS: patch7: now prompts user for its e-mail address ?RCS: patch7: no longer silent when mail has been sent ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:06 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?RCS: ?X: ?X: This unit asks the user to please send a message to the author. ?X: To force inclusion of this unit, you must add it's name to the ?X: dependancies on the MAKE line in your private copy of End.U. ?X: This allows a smart mailagent program to automatically let users know ?X: when their package is out of date, and to allow users to be notified of ?X: any future patches. ?X: ?MAKE:MailAuthor mailpatches notifypatches usermail: test cat mailer \ package Myread patchlevel baserev rm rsrc Oldconfig Configdir ?MAKE: -pick wipe $@ %< ?S:mailpatches: ?S: Indicates whether the user would like future patches to be mailed ?S: directly to them. ?S:. ?S:notifypatches: ?S: Indicates whether the user would like notification of future patches ?S: mailed to them. ?S:. ?S:usermail: ?S: This variable is used internally by Configure to keep track of the ?S: user e-mail address, where notifications or patches should be sent. ?S: A '-' value means the return address will be extracted by parsing ?S: the mail headers. ?S:. ?T:opt mailpatches notifypatches atsh status : notify author that his package is used if $test -f ../.config/mailauthor && cmp $rsrc/patchlevel.h ../.config/mailauthor >/dev/null 2>&1 then status="say that you're using $package"; case "$mailpatches" in true) status='have patches mailed to you as they are issued';; esac case "$notifypatches" in true) status='be notified when new patches are issued';; esac $cat <) mail to $status. If you wish, you may modify your previous request by sending a new mail with different options. EOM rp='Should I send a status update to ?' dflt=n else $cat <..." >&4 ?X: Bizarre hack here. We can't just put @SH in the hereis lines below, because ?X: metaconfig will interpret it as a command, and there's no quoting mechanism. ?X: Do it via a variable instead. atsh='@SH' $mailer </dev/null 2>&1 Subject: Command Precedence: junk To: $atsh package $usermail $package $baserev $patchlevel$opt EOM $rm -f ../.config/mailauthor ../.config/nomail cp $rsrc/patchlevel.h ../.config/mailauthor ;; *) case "$dflt" in "y") echo "Oh well, maybe next time." cp /dev/null ../.config/nomail ;; esac ;; esac metaconfig-debian-perl-5.26.1/dist/U/MailList.U000066400000000000000000000056411316016665300211310ustar00rootroot00000000000000?RCS: $Id: MailList.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Graham Stoney ?RCS: ?RCS: $Log: MailList.U,v $ ?RCS: Revision 3.0.1.1 1994/01/24 14:01:49 ram ?RCS: patch16: created ?RCS: ?RCS: ?X: ?X: This unit offers the user the option of subscribing to the mailing ?X: list. To force inclusion of this unit, you must add it's name to the ?X: dependancies on the MAKE line in your private copy of End.U. ?X: The address of the mailing list server must be set via a "list_request=..." ?X: entry in the .package file. This is usually done by running packinit and ?X: answering the proper questions. ?X: ?MAKE:MailList: cat mailer package Myread cf_name cf_email ?MAKE: -pick wipe $@ %< ?T:list_request list_sub list_unsub list_name ?X: ?X: The cf_name dependency is used through list_sub when the mailing list ?X: manager happens to be listserv, whereas cf_email is used whith majordomo ?X: or when the mailing list request address is scanned by a human. Since ?X: they do not appear within the unit itself, we need a lint hint. ?X: ?LINT:use cf_name cf_email : offer to join the mailing list list_request='<$list_request>' list_sub="<$list_sub>" list_unsub="<$list_unsub>" list_name="<$list_name>" $cat <&4 $mailer $list_request </dev/null 2>&1 Precedence: junk To: $list_request $list_sub EOM ;; [uU]*) echo "Sending mail to unsubscribe you from the $list_name list..." >&4 $mailer $list_request </dev/null 2>&1 Precedence: junk To: $list_request $list_unsub EOM ;; esac metaconfig-debian-perl-5.26.1/dist/U/Mkdirp.U000066400000000000000000000025431316016665300206370ustar00rootroot00000000000000?RCS: $Id: Mkdirp.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Extract.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 14:58:52 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:51:46 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:04:52 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a shell script which can launched to create a ?X: directory path like "mkdir -p" would do. ?X: ?MAKE:Mkdirp: eunicefix startsh ?MAKE: -pick add $@ %< ?F:./mkdirp ?T:name create file : script used to emulate mkdir -p cat >mkdirp <>mkdirp <<'EOS' name=$1; create=""; while test $name; do if test ! -d "$name"; then create="$name $create" name=`echo $name | sed -e "s|^[^/]*$||"` name=`echo $name | sed -e "s|\(.*\)/.*|\1|"` else name="" fi done for file in $create; do mkdir $file done EOS chmod +x mkdirp $eunicefix mkdirp metaconfig-debian-perl-5.26.1/dist/U/Mksymlinks.U000066400000000000000000000050031316016665300215440ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Copyright (c) 2000, Jarkko Hietaniemi ?RCS: ?X: ?X: This unit allows the duplication of the source tree to the current ?X: directory via symbolic links. This must be requested explicitly ?X: by them issuing a -Dmksymlinks on the command line. ?X: ?MAKE:Mksymlinks: Mkdirp lns issymlink src rsrc pkgsrc ?MAKE: -pick add $@ %< ?F:!UU ?T: dir filename tmppwd filelist ?LINT:extern mksymlinks @if {test -f ../MANIFEST} : Duplicate the tree with symbolic links if -Dmksymlinks was supplied case "$mksymlinks" in $define|true|[yY]*) echo " " case "$src" in ''|'.') echo "Cannot create symlinks in the original directory." >&4 exit 1 ;; *) case "$lns:$issymlink" in *"ln"*" -s:"*"test -"?) echo "Creating the symbolic links..." >&4 echo "(First creating the subdirectories...)" >&4 cd .. awk '{print $1}' $src/MANIFEST | grep / | sed 's:/[^/]*$::' | \ sort -u | while true do read dir test -z "$dir" && break ./UU/mkdirp $dir 2>/dev/null if test -d $dir; then : ok else echo "Failed to create '$dir'. Aborting." >&4 exit 1 fi done echo "(Now creating the symlinks...)" >&4 awk '{print $1}' $src/MANIFEST | while true; do read filename test -z "$filename" && break if test -f $filename; then if $issymlink $filename; then rm -f $filename fi fi if test -f $filename; then echo "$filename already exists, not symlinking." else ?X: Note that the following works because "$pkgsrc" is absolute ln -s $pkgsrc/$filename $filename fi done ?X: Check that everything was correctly copied echo "(Checking current directory...)" >&4 cd UU awk '$1 !~ /PACK[A-Z]+/ {print $1}' "$rsrc/MANIFEST" | \ (split -l 50 2>/dev/null || split -50) rm -f missing tmppwd=`pwd` for filelist in x??; do (cd ..; ls `cat "$tmppwd/$filelist"` \ >/dev/null 2>>"$tmppwd/missing") done if test -s missing; then echo "Failed duplication of source tree. Aborting." >&4 exit 1 fi ;; *) echo "(I cannot figure out how to do symbolic links, ignoring!)" >&4 ;; esac ;; esac ;; esac @end metaconfig-debian-perl-5.26.1/dist/U/Myinit.U000066400000000000000000000020051316016665300206530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Myinit.U,v $ ?RCS: Revision 3.0.1.1 1994/10/31 09:47:29 ram ?RCS: patch44: leading comment states this unit comes before option processing ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:07 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: If you want to initialize any default values, copy this unit to your ?X: personal U directory and add the assignments to the end. This file ?X: is included after variables are initialized but before any old ?X: config.sh file is read in and before any Configure switch processing. ?X: ?MAKE:Myinit: Init ?MAKE: -pick add $@ %< ?LINT: nocomment metaconfig-debian-perl-5.26.1/dist/U/Myread.U000066400000000000000000000130721316016665300206310ustar00rootroot00000000000000?RCS: $Id: Myread.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Myread.U,v $ ?RCS: Revision 3.0.1.6 1997/02/28 15:05:39 ram ?RCS: patch61: myread script now starts with a "startsh" ?RCS: patch61: miscellaneous fixes ?RCS: ?RCS: Revision 3.0.1.5 1995/01/11 15:14:22 ram ?RCS: patch45: added & escape allowing user to turn on -d from the prompt ?RCS: ?RCS: Revision 3.0.1.4 1994/10/31 09:48:04 ram ?RCS: patch44: added Options to the MAKE line since it's no longer in Init.U ?RCS: ?RCS: Revision 3.0.1.3 1994/10/29 15:56:20 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.2 1993/08/30 08:57:59 ram ?RCS: patch8: added new visible 'nostick' symbol, mainly for Finish.U ?RCS: ?RCS: Revision 3.0.1.1 1993/08/27 14:39:20 ram ?RCS: patch7: now sticks to the question when no default and empty answer ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:08 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in in order ?X: to do a read. It allows for shell escapes, default assignment and ?X: parameter evaluation. ?X: ?X: To use this unit, $rp and $dflt must hold the question and the ?X: default answer. The question will be printed by the script itself. ?X: Neither $rp nor $dflt is altered by the script. ?X: ?X: The myread script will stick to the question if no default is proposed ?X: and the user answer is empty, which prevents mistakes. However, at the ?X: end of Configure, there is an exception to this rule (Finish.U) where we ?X: set nostick to a non-empty value to allow the Return key to play its role! ?X: ?MAKE:Myread: Options startsh n c trnl ?MAKE: -pick add $@ %< ?V:ans:dflt rp nostick ?F:./myread ?T:COLUMNS xxxm rp dflt answ aok myecho ?LINT:change fastread ?X: Some shells (Ultrix) do not understand ${COLUMNS:-80}, sigh! : compute the number of columns on the terminal for proper question formatting case "$COLUMNS" in '') COLUMNS='80';; esac : set up the echo used in my read ?X: ?X: This variable is intended to be eval'ed. It will echo the two ?X: variables $rp and $dflt (provided this latter has a non null value). ?X: It is mainly used by the myread script to echo the questions. ?X: ?X: The $n and $c below are substituted before Loc does its silly echo check ?X: so don't put a $ on the echo below so we get builtin, even if $echo is ?X: pointing to /bin/echo. ?X: myecho="case \"\$xxxm\" in '') echo $n \"\$rp $c\" >&4;; *) case \"\$rp\" in '') echo $n \"[\$xxxm] $c\";; *) if test \`echo \"\$rp [\$xxxm] \" | wc -c\` -ge $COLUMNS; then echo \"\$rp\" >&4 echo $n \"[\$xxxm] $c\" >&4 else echo $n \"\$rp [\$xxxm] $c\" >&4 fi ;; esac;; esac" : now set up to do reads with possible shell escape and default assignment cat <myread $startsh ?X: ?X: Save value of default -- do not alter original in case of eval ?X: xxxm=\$dflt $myecho ?X: ?X: If there is no default, then stop, regardless of the value in fastread. ?X: In silent mode, no new-line is to be echoed if the question is empty, ?X: since this is used to wait for the "return" key. ?X: ans='!' case "\$fastread" in yes) case "\$dflt" in '') ;; *) ans=''; case "\$silent-\$rp" in true-) ;; *) echo " " >&4;; esac;; esac;; *) case "\$silent" in true) case "\$rp" in '') ans='';; esac;; esac;; esac while expr "X\$ans" : "X!" >/dev/null; do read answ ?X: ?X: Run 'eval' on the answer, in order to do variable substitution, in case ?X: the user types $HOME or $WHATEVER. Variables must be evaluated now. ?X: Typing '\$HOME' won't currently prevent from substitution -- use '\\$HOME' ?X: The $1 .. $9 and $*, as well as $@, are available to refer to the ?X: default value. ?X: set x \$xxxm shift aok=''; eval "ans=\\"\$answ\\"" && aok=y case "\$answ" in ?X: ?X: Use "!" and not a plain ! because of a bug in BSD 4.4 shell ?X: (reported by Wayne Davison) ?X: We must handle the shell escapes before dealing with possible variable ?X: substitution, since the shell we're launching in that case will be able ?X: to do it as well as we can -- RAM, 15/03/96 ?X "!") sh 1>&4 echo " " $myecho ;; !*) set x \`expr "X\$ans" : "X!\(.*\)\$"\` shift sh 1>&4 -c "\$*" echo " " $myecho ;; "\$ans") case "\$ans" in ?X: ?X: Answers starting with & are hooks allowing to dynamically turn on/off ?X: some Configure options. That's for the future. -- RAM, 09/01/95 ?X: Today, we only recognize '& -d' to mean 'go on as if Configure -d, which ?X: is a hardwired behaviour compatible with our general scheme. ?X: \\&*) set x \`expr "X\$ans" : "X&\(.*\)\$"\` shift case "\$1" in -d) fastread=yes echo "(OK, I'll run with -d after this question.)" >&4 ;; -*) echo "*** Sorry, \$1 not supported yet." >&4 ;; esac $myecho ans=! ;; esac;; *) case "\$aok" in y) echo "*** Substitution done -- please confirm." xxxm="\$ans" ans=\`echo $n "\$ans$c" | tr '$trnl' ' '\` xxxm="\$ans" ans=! ;; *) echo "*** Error -- try again." ans=! ;; esac $myecho ;; esac ?X: Stick in myread if no default answer and nothing was answered case "\$ans\$xxxm\$nostick" in '') ans=! $myecho ;; esac done case "\$ans" in '') ans="\$xxxm";; esac EOSC metaconfig-debian-perl-5.26.1/dist/U/Nothing.U000066400000000000000000000013461316016665300210170ustar00rootroot00000000000000?RCS: $Id: Nothing.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Nothing.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: The purpose of this file is to supply an empty target for the private ?X: Makefile built by metaconfig to order the units. ?X: ?MAKE:Nothing: Head metaconfig-debian-perl-5.26.1/dist/U/Null.U000066400000000000000000000014161316016665300203210ustar00rootroot00000000000000?RCS: $Id: Null.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Null.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:10 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit ends up producing shell code to set all variables to ''. This ?X: probably isn't necessary, but I'm paranoid. About certain things. ?X: ?MAKE:Null: Head ?MAKE: -pick add.Null $@ %< metaconfig-debian-perl-5.26.1/dist/U/Obsol_h.U000066400000000000000000000020571316016665300207760ustar00rootroot00000000000000?RCS: $Id: Obsol_h.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Obsol_h.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:11 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This file is prepended to .MT/Obsol_h if that file is not empty. That file ?X: contains the necessary mappings of new symbols to obsolete ones. ?X: ?MAKE:Obsol_h: ?MAKE: -pick prepend $@ ./Obsol_h ?LINT:nocomment /* * The following symbols are obsolete. They are mapped to the the new * symbols only to ease the transition process. The sources should be * updated so as to use the new symbols only, as the support for these * obsolete symbols may end without notice. */ metaconfig-debian-perl-5.26.1/dist/U/Obsol_sh.U000066400000000000000000000020551316016665300211570ustar00rootroot00000000000000?RCS: $Id: Obsol_sh.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Obsol_sh.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:11 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This file is prepended to .MT/Obsol_sh if that file is not empty. That file ?X: contains the necessary mappings of new symbols to obsolete ones. ?X: ?MAKE:Obsol_sh: ?MAKE: -pick prepend $@ ./Obsol_sh ?LINT:nocomment # # The following symbols are obsolete. They are mapped to the the new # symbols only to ease the transition process. The sources should be # updated so as to use the new symbols only, since supporting of those # obsolete symbols may end without notice. # metaconfig-debian-perl-5.26.1/dist/U/Oldconfig.U000066400000000000000000000441371316016665300213220ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Oldconfig.U,v $ ?RCS: Revision 3.0.1.10 1997/02/28 15:06:39 ram ?RCS: patch61: added support for src.U ?RCS: patch61: new OSNAME define ?RCS: patch61: can now sense new OSes ?RCS: ?RCS: Revision 3.0.1.9 1995/07/25 13:40:51 ram ?RCS: patch56: now knows about OS/2 platforms ?RCS: ?RCS: Revision 3.0.1.8 1995/05/12 12:04:18 ram ?RCS: patch54: config.sh reload logic now knows about new -K switch ?RCS: patch54: cleaned up and extended osvers for DEC OSF/1 (ADO) ?RCS: patch54: added MachTen detection (ADO) ?RCS: ?RCS: Revision 3.0.1.7 1995/02/15 14:13:41 ram ?RCS: patch51: adapted osvers computation for AIX (ADO) ?RCS: ?RCS: Revision 3.0.1.6 1995/01/30 14:27:15 ram ?RCS: patch49: unit Options.U now exports file optdef.sh, not a variable ?RCS: patch49: update code for myuname changed (WED) ?RCS: ?RCS: Revision 3.0.1.5 1995/01/11 15:15:36 ram ?RCS: patch45: added quotes around the INITPROG variable (ADO) ?RCS: patch45: allows variable overriding after config file loading ?RCS: ?RCS: Revision 3.0.1.4 1994/10/29 15:57:05 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: patch36: merged with the version used for perl5's Configure (ADO) ?RCS: ?RCS: Revision 3.0.1.3 1994/05/06 14:24:17 ram ?RCS: patch23: added support for osf1 hints ?RCS: patch23: new support for solaris and i386 systems (ADO) ?RCS: ?RCS: Revision 3.0.1.2 1994/01/24 14:05:02 ram ?RCS: patch16: added post-processing on myuname for Xenix targets ?RCS: patch16: message proposing config.sh defaults made consistent ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:56:32 ram ?RCS: patch10: force use of config.sh when -d option is used (WAD) ?RCS: patch10: complain about non-existent hint files (WAD) ?RCS: patch10: added Options dependency for fastread variable ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:12 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit tries to remember what we did last time we ran Configure, mostly ?X: for the sake of setting defaults. ?X: ?MAKE:Oldconfig hint myuname osname osvers: Instruct Myread Checkcc \ Mksymlinks Loc Options Tr src trnl ln uname sh awk sed test cat grep \ rm lns tr n c contains targetarch ?MAKE: -pick wipe $@ %< ?S:myuname: ?S: The output of 'uname -a' if available, otherwise the hostname. On Xenix, ?S: pseudo variables assignments in the output are stripped, thank you. The ?S: whole thing is then lower-cased. ?S:. ?S:hint: ?S: Gives the type of hints used for previous answers. May be one of ?S: "default", "recommended" or "previous". ?S:. ?S:osname: ?S: This variable contains the operating system name (e.g. sunos, ?S: solaris, hpux, etc.). It can be useful later on for setting ?S: defaults. Any spaces are replaced with underscores. It is set ?S: to a null string if we can't figure it out. ?S:. ?S:osvers: ?S: This variable contains the operating system version (e.g. ?S: 4.1.3, 5.2, etc.). It is primarily used for helping select ?S: an appropriate hints file, but might be useful elsewhere for ?S: setting defaults. It is set to '' if we can't figure it out. ?S: We try to be flexible about how much of the version number ?S: to keep, e.g. if 4.1.1, 4.1.2, and 4.1.3 are essentially the ?S: same for this package, hints files might just be os_4.0 or ?S: os_4.1, etc., not keeping separate files for each little release. ?S:. ?C:OSNAME: ?C: This symbol contains the name of the operating system, as determined ?C: by Configure. You shouldn't rely on it too much; the specific ?C: feature tests from Configure are generally more reliable. ?C:. ?C:OSVERS: ?C: This symbol contains the version of the operating system, as determined ?C: by Configure. You shouldn't rely on it too much; the specific ?C: feature tests from Configure are generally more reliable. ?C:. ?H:#define OSNAME "$osname" /**/ ?H:#define OSVERS "$osvers" /**/ ?H:. ?F:!config.sh ?T:tmp tmp_n tmp_c tmp_sh file ?T:xxxxfile xxxfile xxfile xfile hintfile newmyuname ?T:tans _ isesix INITPROG DJGPP has_uname ?D:osname='' ?LINT:change n c sh ?LINT:extern hostarch ?LINT:change hostarch : Determine the name of the machine myuname=`$uname -a 2>/dev/null` $test -z "$myuname" && myuname=`hostname 2>/dev/null` ?X: Special mention for Xenix, whose 'uname -a' gives us output like this: ?X: sysname=XENIX ?X: nodename=whatever ?X: release=2.3.2 .. etc... ?X: Therefore, we strip all this variable assignment junk and remove all the ?X: new lines to keep the myuname variable sane... --RAM myuname=`echo $myuname | $sed -e 's/^[^=]*=//' -e 's/\///g' | \ ./tr '[A-Z]' '[a-z]' | $tr $trnl ' '` ?X: Save the value we just computed to reset myuname after we get done here. newmyuname="$myuname" $test -f "$uname$_exe" && has_uname=y : Guessing of the OS name -- half the following guesses are probably wrong... : If you have better tests or hints, please send them to the metaconfig : authors and to $test -f /irix && osname=irix $test -f /xenix && osname=sco_xenix $test -f /dynix && osname=dynix $test -f /dnix && osname=dnix $test -f /lynx.os && osname=lynxos $test -f /unicos && osname=unicos && osvers=`$uname -r` $test -f /unicosmk && osname=unicosmk && osvers=`$uname -r` $test -f /unicosmk.ar && osname=unicosmk && osvers=`$uname -r` $test -f /bin/mips && /bin/mips && osname=mips $test -d /NextApps && set X `hostinfo | $grep 'NeXT Mach.*:' | \ $sed -e 's/://' -e 's/\./_/'` && osname=next && osvers=$4 $test -d /usr/apollo/bin && osname=apollo $test -f /etc/saf/_sactab && osname=svr4 $test -d /usr/include/minix && osname=minix $test -f /system/gnu_library/bin/ar.pm && osname=vos if $test -d /MachTen -o -d /MachTen_Folder; then ?X: MachTen uname -a output looks like ?X: xxx 4 0.0 Macintosh ?X: MachTen /sbin/version output looks like ?X: MachTen 4.0 Mon Aug 28 10:18:00 1995 ?X: MachTen 3.x had the 'version' command in /usr/etc/version. osname=machten if $test -x /sbin/version; then osvers=`/sbin/version | $awk '{print $2}' | $sed -e 's/[A-Za-z]$//'` elif $test -x /usr/etc/version; then osvers=`/usr/etc/version | $awk '{print $2}' | $sed -e 's/[A-Za-z]$//'` else osvers="$2.$3" fi fi $test -f /sys/posix.dll && $test -f /usr/bin/what && set X `/usr/bin/what /sys/posix.dll` && $test "$3" = UWIN && osname=uwin && osvers="$5" ?X: If we have uname, we already computed a suitable uname -a output, correctly ?X: formatted for Xenix, and it lies in $myuname. if $test "X$has_uname" != X; then set X $myuname shift case "$5" in fps*) osname=fps ;; mips*) case "$4" in umips) osname=umips ;; *) osname=mips ;; esac;; [23]100) osname=mips ;; next*) osname=next ;; ?X: Interactive Unix. i386*) tmp=`/bin/uname -X 2>/dev/null|awk '/3\.2v[45]/{ print $(NF) }'` if $test "$tmp" != "" -a "$3" = "3.2" -a -f '/etc/systemid'; then osname='sco' osvers=$tmp elif $test -f /etc/kconfig; then osname=isc if $test "$lns" = "$ln -s"; then osvers=4 elif $contains _SYSV3 /usr/include/stdio.h > /dev/null 2>&1 ; then osvers=3 elif $contains _POSIX_SOURCE /usr/include/stdio.h > /dev/null 2>&1 ; then osvers=2 fi fi tmp='' ;; ?X: MS-DOS djgpp uname -a output looks like: ?X: ms-dos xxx 6 22 pc ?X: $1 is the "dos flavor" (need not be "ms-dos"). ?X: $2 is the node name ?X: $3 and $4 are version/subversion ?X: $5 is always "pc", but that might not be unique to DJGPP. ?X: (e.g. Solaris_x86 has $5 = i86pc, which doesn't actually conflict, ?X: but it's close enought that I can easily imagine other vendors also ?X: using variants of pc* in $5.) ?X: The "DJGPP" environment variable is always set when djgpp is active. pc*) if $test -n "$DJGPP"; then osname=dos osvers=djgpp fi ;; esac case "$1" in aix) osname=aix ?X: aix 4.1 uname -a output looks like ?X: AIX foo 1 4 000123456789 ?X: where $4 is the major release number and $3 is the (minor) version. ?X: More detail on the version is available with the oslevel command. ?X: in 3.2.x, it output a string (see case statements below). In 4.1, ?X: it puts out something like 4.1.1.0 tmp=`( (oslevel) 2>/dev/null || echo "not found") 2>&1` case "$tmp" in 'not found') osvers="$4"."$3" ;; '<3240'|'<>3240') osvers=3.2.0 ;; '=3240'|'>3240'|'<3250'|'<>3250') osvers=3.2.4 ;; '=3250'|'>3250') osvers=3.2.5 ;; *) osvers=$tmp;; esac ;; bsd386) osname=bsd386 osvers=`$uname -r` ;; cygwin*) osname=cygwin osvers="$3" ;; *dc.osx) osname=dcosx osvers="$3" ;; dnix) osname=dnix osvers="$3" ;; domainos) osname=apollo osvers="$3" ;; dgux) osname=dgux osvers="$3" ;; ?X: uname -a returns ?X: DYNIX/ptx xxx 4.0 V4.1.2 i386 dynixptx*) osname=dynixptx osvers=`echo "$4"|sed 's/^v//'` ;; freebsd) osname=freebsd osvers="$3" ;; genix) osname=genix ;; ?X: HP-UX uname -a gives something like ?X: HP-UX foobar B.10.20 A 9000/735 2016483812 two-user license ?X: Preserve the full 10.20 string instead of the previous plain '10'. ?X: Thanks to Graham Barr. --AD 6/30/1998 hp*) osname=hpux osvers=`echo "$3" | $sed 's,.*\.\([0-9]*\.[0-9]*\),\1,'` ;; irix*) osname=irix case "$3" in 4*) osvers=4 ;; 5*) osvers=5 ;; *) osvers="$3" ;; esac ;; linux) osname=linux case "$3" in *) osvers="$3" ;; esac ;; MiNT) osname=mint ;; netbsd*) osname=netbsd osvers="$3" ;; news-os) osvers="$3" case "$3" in 4*) osname=newsos4 ;; *) osname=newsos ;; esac ;; next*) osname=next ;; nonstop-ux) osname=nonstopux ;; openbsd) osname=openbsd osvers="$3" ;; POSIX-BC | posix-bc ) osname=posix-bc osvers="$3" ;; powerux | power_ux | powermax_os | powermaxos | \ powerunix | power_unix) osname=powerux osvers="$3" ;; qnx) osname=qnx osvers="$4" ;; solaris) osname=solaris case "$3" in 5*) osvers=`echo $3 | $sed 's/^5/2/g'` ;; *) osvers="$3" ;; esac ;; sunos) osname=sunos case "$3" in 5*) osname=solaris osvers=`echo $3 | $sed 's/^5/2/g'` ;; *) osvers="$3" ;; esac ;; titanos) osname=titanos case "$3" in 1*) osvers=1 ;; 2*) osvers=2 ;; 3*) osvers=3 ;; 4*) osvers=4 ;; *) osvers="$3" ;; esac ;; ultrix) osname=ultrix osvers="$3" ;; osf1|mls+) case "$5" in alpha) ?X: DEC OSF/1 myuname -a output looks like: osf1 xxxx t3.2 123.4 alpha ?X: where the version number can be something like [xvt]n.n osname=dec_osf ?X: sizer knows the minor minor version: the letter osvers=`sizer -v | awk '{print $3}' | \ ./tr '[A-Z]' '[a-z]' | sed 's/^[xvt]//'` case "$osvers" in [1-9].[0-9]*) ;; *) osvers=`echo "$3" | sed 's/^[xvt]//'` ;; esac ;; hp*) osname=hp_osf1 ;; mips) osname=mips_osf1 ;; ?X: hp and mips were unsupported Technology Releases -- ADO, 24/10/94 esac ;; unixware) osname=svr5 osvers="$4" ;; uts) osname=uts osvers="$3" ;; vos) osvers="$3" ;; $2) case "$osname" in *isc*) ;; *freebsd*) ;; svr*) : svr4.x or possibly later case "svr$3" in ${osname}*) osname=svr$3 osvers=$4 ;; esac case "$osname" in svr4.0) : Check for ESIX if $test -f /stand/boot ; then eval `$grep '^INITPROG=[a-z/0-9]*$' /stand/boot` if $test -n "$INITPROG" -a -f "$INITPROG"; then isesix=`strings -a $INITPROG | \ $grep 'ESIX SYSTEM V/386 Release 4.0'` if $test -n "$isesix"; then osname=esix4 fi fi fi ;; esac ;; *) if $test -f /etc/systemid; then osname=sco set `echo $3 | $sed 's/\./ /g'` $4 if $test -f $src/hints/sco_$1_$2_$3.sh; then osvers=$1.$2.$3 elif $test -f $src/hints/sco_$1_$2.sh; then osvers=$1.$2 elif $test -f $src/hints/sco_$1.sh; then osvers=$1 fi else case "$osname" in '') : Still unknown. Probably a generic Sys V. osname="sysv" osvers="$3" ;; esac fi ;; esac ;; *) case "$osname" in '') : Still unknown. Probably a generic BSD. osname="$1" osvers="$3" ;; esac ;; esac else ?X: Try to identify sony's NEWS-OS (BSD unix) if $test -f /vmunix -a -f $src/hints/news_os.sh; then (what /vmunix | UU/tr '[A-Z]' '[a-z]') > UU/kernel.what 2>&1 if $contains news-os UU/kernel.what >/dev/null 2>&1; then osname=news_os fi $rm -f UU/kernel.what ?X: Maybe it's OS/2 or DOS or something similar elif $test -d c:/.; then set X $myuname osname=os2 osvers="$5" fi fi : Try to determine whether config.sh was made on this system case "$config_sh" in '') ?X: indentation wrong on purpose--RAM dflt=n case "$knowitall" in '') if test -f ../config.sh; then if $contains myuname= ../config.sh >/dev/null 2>&1; then eval "`$grep myuname= ../config.sh`" fi if test "X$myuname" = "X$newmyuname"; then dflt=y fi fi ;; *) dflt=y;; esac : Get old answers from config file if it was generated on the same system hint=default if $test -f ../config.sh; then echo " " rp="I see a config.sh file. Shall I use it to set the defaults?" . ./myread case "$ans" in n*|N*) echo "OK, I'll ignore it." mv ../config.sh ../config.sh.old myuname="$newmyuname" ;; *) echo "Fetching default answers from your old config.sh file..." >&4 tmp_n="$n" tmp_c="$c" tmp_sh="$sh" . ../config.sh cp ../config.sh . n="$tmp_n" c="$tmp_c" hint=previous ;; esac fi ?X: remember, case indentation is wrong--RAM ;; *) echo " " echo "Fetching default answers from $config_sh..." >&4 tmp_n="$n" tmp_c="$c" tmp_sh="$sh" cd .. ?X: preserve symbolic links, if any cp $config_sh config.sh 2>/dev/null chmod +w config.sh . ./config.sh cd UU cp ../config.sh . n="$tmp_n" c="$tmp_c" hint=previous ;; esac ?X: Older versions did not always set $sh. case "$sh" in '') sh="$tmp_sh" ;; esac $test "$override" && . ./optdef.sh : Restore computed paths for file in $loclist $trylist; do eval $file="\$_$file" done . ./checkcc ?X: Cross-compiling support case "$targetarch" in '') ;; *) hostarch=$osname osname=`echo $targetarch|sed 's,^[^-]*-,,'` osvers='' ;; esac @if {test -d ../hints} : Offer them some hints based on their OS cd .. ?X: Since we are now at the root of the source tree, we must use $src ?X: to access the sources and not $rsrc. See src.U for details... if $test ! -f config.sh; then $cat <&4 dflt='' : Now look for a hint file osname_osvers, unless one has been : specified already. case "$hintfile" in ''|' ') file=`echo "${osname}_${osvers}" | $sed -e 's%\.%_%g' -e 's%_$%%'` : Also try without trailing minor version numbers. xfile=`echo $file | $sed -e 's%_[^_]*$%%'` xxfile=`echo $xfile | $sed -e 's%_[^_]*$%%'` xxxfile=`echo $xxfile | $sed -e 's%_[^_]*$%%'` xxxxfile=`echo $xxxfile | $sed -e 's%_[^_]*$%%'` case "$file" in '') dflt=none ;; *) case "$osvers" in '') dflt=$file ;; *) if $test -f $src/hints/$file.sh ; then dflt=$file elif $test -f $src/hints/$xfile.sh ; then dflt=$xfile elif $test -f $src/hints/$xxfile.sh ; then dflt=$xxfile elif $test -f $src/hints/$xxxfile.sh ; then dflt=$xxxfile elif $test -f $src/hints/$xxxxfile.sh ; then dflt=$xxxxfile elif $test -f "$src/hints/${osname}.sh" ; then dflt="${osname}" else dflt=none fi ;; esac ;; esac if $test -f Policy.sh ; then case "$dflt" in *Policy*) ;; none) dflt="Policy" ;; *) dflt="Policy $dflt" ;; esac fi ;; *) dflt=`echo $hintfile | $sed 's/\.sh$//'` ;; esac if $test -f Policy.sh ; then $cat <> UU/config.sh elif $test -f $src/hints/$file.sh; then . $src/hints/$file.sh $cat $src/hints/$file.sh >> UU/config.sh elif $test X"$tans" = X -o X"$tans" = Xnone ; then : nothing else : Give one chance to correct a possible typo. echo "$file.sh does not exist" dflt=$file rp="hint to use instead?" . UU/myread for file in $ans; do if $test -f "$src/hints/$file.sh"; then . $src/hints/$file.sh $cat $src/hints/$file.sh >> UU/config.sh elif $test X$ans = X -o X$ans = Xnone ; then : nothing else echo "$file.sh does not exist -- ignored." fi done fi done hint=recommended : Remember our hint file for later. if $test -f "$src/hints/$file.sh" ; then hintfile="$file" else hintfile='' fi fi cd UU ?X: From here on, we must use $rsrc instead of $src @end : Process their -A options . ./posthint.sh @if osname || osvers : Ask them to confirm the OS name cat << EOM Configure uses the operating system name and version to set some defaults. The default value is probably right if the name rings a bell. Otherwise, since spelling matters for me, either accept the default or answer "none" to leave it blank. EOM @end @if osname case "$osname" in ''|' ') case "$hintfile" in ''|' '|none) dflt=none ;; *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/_.*$//'` ;; esac ;; *) dflt="$osname" ;; esac rp="Operating system name?" . ./myread case "$ans" in none) osname='' ;; *) osname=`echo "$ans" | $sed -e 's/[ ][ ]*/_/g' | ./tr '[A-Z]' '[a-z]'`;; esac @end @if osvers @if osname echo " " @end case "$osvers" in ''|' ') case "$hintfile" in ''|' '|none) dflt=none ;; *) dflt=`echo $hintfile | $sed -e 's/\.sh$//' -e 's/^[^_]*//'` dflt=`echo $dflt | $sed -e 's/^_//' -e 's/_/./g'` case "$dflt" in ''|' ') dflt=none ;; esac ;; esac ;; *) dflt="$osvers" ;; esac rp="Operating system version?" . ./myread case "$ans" in none) osvers='' ;; *) osvers="$ans" ;; esac @end metaconfig-debian-perl-5.26.1/dist/U/Oldsym.U000066400000000000000000000043301316016665300206540ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Oldsym.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:06:58 ram ?RCS: patch61: added support for src.U ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:13 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit follows the creation of the config.sh file. It adds some ?X: special symbols: defines from patchlevel.h file if any and CONFIG, ?X: which is set to true. Then, we try to keep all the new symbols that ?X: may come from a hint file or a previous config.sh file. ?X: ?MAKE:Oldsym: Config_sh Options test hint src sed sort uniq ?MAKE: -pick add $@ %< ?T:CONFIG sym tmp ?F:!UU : add special variables $test -f $src/patchlevel.h && \ awk '/^#define/ {printf "%s=%s\n",$2,$3}' $src/patchlevel.h >>config.sh echo "CONFIG=true" >>config.sh : propagate old symbols if $test -f UU/config.sh; then ?X: Make sure each symbol is unique in oldconfig.sh UU/oldconfig.sh ?X: ?X: All the symbols that appear twice come only from config.sh (hence the ?X: two config.sh in the command line). These symbols will be removed by ?X: the uniq -u command. The oldsyms file thus contains all the symbols ?X: that did not appear in the produced config.sh (Larry Wall). ?X: ?X: Do not touch the -u flag of uniq. This means you too, Jarkko. ?X: $sed -n 's/^\([a-zA-Z_0-9]*\)=.*/\1/p' \ config.sh config.sh UU/oldconfig.sh |\ $sort | $uniq -u >UU/oldsyms set X `cat UU/oldsyms` shift case $# in 0) ;; *) cat <>config.sh for sym in `cat UU/oldsyms`; do echo " Propagating $hint variable "'$'"$sym..." eval 'tmp="$'"${sym}"'"' echo "$tmp" | \ sed -e "s/'/'\"'\"'/g" -e "s/^/$sym='/" -e "s/$/'/" >>config.sh done ;; esac fi metaconfig-debian-perl-5.26.1/dist/U/Options.U000066400000000000000000000257041316016665300210500ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Options.U,v $ ?RCS: Revision 3.0.1.7 1997/02/28 15:08:15 ram ?RCS: patch61: optdef.sh now starts with a "startsh" ?RCS: patch61: moved some code from Head.U ?RCS: ?RCS: Revision 3.0.1.6 1995/09/25 09:14:46 ram ?RCS: patch59: protected option parsing code against 'echo -*' option failure ?RCS: ?RCS: Revision 3.0.1.5 1995/05/12 12:04:52 ram ?RCS: patch54: added -K option for experts ?RCS: ?RCS: Revision 3.0.1.4 1995/01/30 14:27:52 ram ?RCS: patch49: this unit now exports file optdef.sh, not a variable ?RCS: ?RCS: Revision 3.0.1.3 1995/01/11 15:19:00 ram ?RCS: patch45: new -O option allowing -D and -U to override config.sh settings ?RCS: patch45: file optdef.sh is no longer removed after sourcing ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 15:58:06 ram ?RCS: patch36: ensure option definition file is removed before appending ?RCS: patch36: protect variable definitions with spaces in them ?RCS: ?RCS: Revision 3.0.1.1 1994/06/20 06:55:44 ram ?RCS: patch30: now uses new me symbol to tag error messages ?RCS: patch30: new -D and -U options to define/undef symbols (JHI) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:14 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Command line parsing. It is really important that the variables used here ?X: be not listed in the MAKE line, or they will be saved in config.sh and ?X: loading this file to fetch default answers would clobber the values set ?X: herein. ?X: ?MAKE:Options: startsh ?MAKE: -pick wipe $@ %< ?V:reuseval alldone error realsilent silent extractsh fastread \ override knowitall: config_sh ?T:arg argn symbol config_arg0 config_args config_argc xxx yyy zzz uuu ?T:args_exp args_sep arg_exp ?F:!Configure ?F:./optdef.sh ./cmdline.opt ./posthint.sh ./cmdl.opt : Save command line options in file UU/cmdline.opt for later use in : generating config.sh. ?X: This temporary file will be read by Oldsym.U. I used a temporary ?X: file to preserve all sorts of potential command line quotes and ?X: also because we don't know in advance how many variables we'll ?X: need, so I can't actually declare them on the MAKE line. ?X: The config_args variable won't be quite correct if Configure is ?X: fed something like ./Configure -Dcc="gcc -B/usr/ccs/bin/" ?X: since the quotes are gone by the time we see them. You'd have to ?X: reconstruct the command line from the config_arg? lines, but since ?X: I don't imagine anyone actually having to do that, I'm not going ?X: to worry too much. cat > cmdline.opt <>cmdline.opt < cmdl.opt $arg EOC arg_exp=`cat cmdl.opt` args_exp="$args_exp$args_sep'$arg_exp'" argn=`expr $argn + 1` args_sep=' ' done ?X: args_exp is good for restarting self: eval "set X $args_exp"; shift; $0 "$@" ?X: used by hints/os2.sh in Perl, for instance rm -f cmdl.opt : produce awk script to parse command line options cat >options.awk <<'EOF' BEGIN { optstr = "A:dD:eEf:hKOrsSU:V"; # getopt-style specification len = length(optstr); for (i = 1; i <= len; i++) { c = substr(optstr, i, 1); ?X: some older awk's do not have the C ?: construct if (i < len) a = substr(optstr, i + 1, 1); else a = ""; if (a == ":") { arg[c] = 1; i++; } opt[c] = 1; } } { expect = 0; str = $0; if (substr(str, 1, 1) != "-") { printf("'%s'\n", str); next; } len = length($0); for (i = 2; i <= len; i++) { c = substr(str, i, 1); if (!opt[c]) { printf("-%s\n", substr(str, i)); next; } printf("-%s\n", c); if (arg[c]) { if (i < len) printf("'%s'\n", substr(str, i + 1)); else expect = 1; next; } } } END { if (expect) print "?"; } EOF : process the command line options ?X: Use "$@" to keep arguments with spaces in them from being split apart. ?X: For the same reason, awk will output quoted arguments and the final eval ?X: removes them and sets a proper $* array. An 'X' is prependend to each ?X: argument before being fed to echo to guard against 'echo -x', where -x ?X: would be understood as an echo option! It is removed before feeding awk. set X `for arg in "$@"; do echo "X$arg"; done | sed -e s/X// | awk -f options.awk` eval "set $*" shift rm -f options.awk : set up default values fastread='' reuseval=false config_sh='' alldone='' error='' silent='' extractsh='' override='' knowitall='' rm -f optdef.sh posthint.sh cat >optdef.sh <&4 redirection based on the value of the ?X: realsilent variable... -- RAM, 18/93/96 ?X: : option parsing while test $# -gt 0; do case "$1" in -d) shift; fastread=yes;; -e) shift; alldone=cont;; -f) shift cd .. if test -r "$1"; then config_sh="$1" else echo "$me: cannot read config file $1." >&2 error=true fi cd UU shift;; -h) shift; error=true;; -r) shift; reuseval=true;; -s) shift; silent=true; realsilent=true;; -E) shift; alldone=exit;; -K) shift; knowitall=true;; -O) shift; override=true;; -S) shift; silent=true; extractsh=true;; -D) shift case "$1" in *=) echo "$me: use '-U symbol=', not '-D symbol='." >&2 echo "$me: ignoring -D $1" >&2 ;; *=*) echo "$1" | \ sed -e "s/'/'\"'\"'/g" -e "s/=\(.*\)/='\1'/" >> optdef.sh;; *) echo "$1='define'" >> optdef.sh;; esac shift ;; -U) shift case "$1" in *=) echo "$1" >> optdef.sh;; *=*) echo "$me: use '-D symbol=val', not '-U symbol=val'." >&2 echo "$me: ignoring -U $1" >&2 ;; *) echo "$1='undef'" >> optdef.sh;; esac shift ;; -A) shift xxx='' yyy="$1" zzz='' uuu=undef case "$yyy" in *=*) zzz=`echo "$yyy"|sed 's!=.*!!'` case "$zzz" in *:*) zzz='' ;; *) xxx=append zzz=" "`echo "$yyy"|sed 's!^[^=]*=!!'` yyy=`echo "$yyy"|sed 's!=.*!!'` ;; esac ;; esac case "$xxx" in '') case "$yyy" in *:*) xxx=`echo "$yyy"|sed 's!:.*!!'` yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` zzz=`echo "$yyy"|sed 's!^[^=]*=!!'` yyy=`echo "$yyy"|sed 's!=.*!!'` ;; *) xxx=`echo "$yyy"|sed 's!:.*!!'` yyy=`echo "$yyy"|sed 's!^[^:]*:!!'` ;; esac ;; esac case "$xxx" in append) echo "$yyy=\"\${$yyy}$zzz\"" >> posthint.sh ;; clear) echo "$yyy=''" >> posthint.sh ;; define) case "$zzz" in '') zzz=define ;; esac echo "$yyy='$zzz'" >> posthint.sh ;; eval) echo "eval \"$yyy=$zzz\"" >> posthint.sh ;; prepend) echo "$yyy=\"$zzz\${$yyy}\"" >> posthint.sh ;; undef) case "$zzz" in '') zzz="$uuu" ;; esac echo "$yyy=$zzz" >> posthint.sh ;; *) echo "$me: unknown -A command '$xxx', ignoring -A $1" >&2 ;; esac shift ;; -V) echo "$me generated by metaconfig PL." >&2 exit 0;; --) break;; -*) echo "$me: unknown option $1" >&2; shift; error=true;; *) break;; esac done case "$error" in true) cat >&2 <&1 case "$silent" in true) exec 1>/dev/null;; esac : run the defines and the undefines, if any, but leave the file out there... touch optdef.sh . ./optdef.sh : create the posthint manipulation script and leave the file out there... ?X: this file will be perused by Oldconfig.U touch posthint.sh metaconfig-debian-perl-5.26.1/dist/U/Prefixit.U000066400000000000000000000043461316016665300212060ustar00rootroot00000000000000?RCS: $Id: Prefixit.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Prefixit.U,v $ ?RCS: Revision 3.0.1.1 1995/01/30 14:29:22 ram ?RCS: patch49: created ?RCS: ?X: ?X: Used as: "set dflt var dir; eval $prefixit" to set $dflt to be ?X: $prefix/dir by default, or the previous $var depending on certain ?X: conditions: ?X: - If the $oldprefix variable is empty, then $prefix holds the same ?X: value as on previous runs. Therefore, reuse $var if set, otherwise ?X: set $dflt to $prefix/dir. ?X: - If $oldprefix is not empty, then set $dflt to $prefix/dir if $var ?X: is empty (first run). Otherwise, if $var is $oldprefix/dir, then ?X: change it to $prefix/dir. If none of the above, reuse the old $var. ?X: ?X: When dir is omitted, the dflt variable is set to $var if prefix did not ?X: change, to an empty value otherwise. If dir=none, then a single space ?X: in var is kept as-is, even if the prefix changes. ?X: ?MAKE:Prefixit: prefix oldprefix ?MAKE: -pick add $@ %< ?LINT:define prefixit ?S:prefixit: ?S: This shell variable is used internally by Configure to reset ?S: the leading installation prefix correctly when it is changed. ?S: set dflt var [dir] ?S: eval $prefixit ?S: That will set $dflt to $var or $prefix/dir depending on the ?S: value of $var and $oldprefix. ?S:. ?V:prefixit ?T:tp : set the prefixit variable, to compute a suitable default value prefixit='case "$3" in ""|none) case "$oldprefix" in "") eval "$1=\"\$$2\"";; *) case "$3" in "") eval "$1=";; none) eval "tp=\"\$$2\""; case "$tp" in ""|" ") eval "$1=\"\$$2\"";; *) eval "$1=";; esac;; esac;; esac;; *) eval "tp=\"$oldprefix-\$$2-\""; eval "tp=\"$tp\""; case "$tp" in --|/*--|\~*--) eval "$1=\"$prefix/$3\"";; /*-$oldprefix/*|\~*-$oldprefix/*) eval "$1=\`echo \$$2 | sed \"s,^$oldprefix,$prefix,\"\`";; *) eval "$1=\"\$$2\"";; esac;; esac' metaconfig-debian-perl-5.26.1/dist/U/Prefixup.U000066400000000000000000000024641316016665300212150ustar00rootroot00000000000000?RCS: $Id: Prefixup.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Prefixup.U,v $ ?RCS: Revision 3.0.1.1 1995/01/30 14:30:40 ram ?RCS: patch49: created ?RCS: ?X: ?X: Used as: "set dflt; eval $prefixup" to set $dflt to be $prefix/dir ?X: instead of $prefixexp/dir, in case portability was involved somehow ?X: and $prefix uses ~name expansion. ?X: ?MAKE:Prefixup: prefix prefixexp ?MAKE: -pick add $@ %< ?LINT:define prefixup ?S:prefixup: ?S: This shell variable is used internally by Configure to reset ?S: the leading installation prefix correctly when $prefix uses ?S: ~name expansion. ?S: set dflt ?S: eval $prefixup ?S: That will set $dflt to $prefix/dir if it was $prefixexp/dir and ?S: $prefix differs from $prefixexp. ?S:. ?V:prefixup : set the prefixup variable, to restore leading tilda escape prefixup='case "$prefixexp" in "$prefix") ;; *) eval "$1=\`echo \$$1 | sed \"s,^$prefixexp,$prefix,\"\`";; esac' metaconfig-debian-perl-5.26.1/dist/U/Rcs.U000066400000000000000000000023631316016665300201400ustar00rootroot00000000000000?RCS: $Id: Rcs.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Rcs.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:15 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This is a unit that helps people who write SH scripts and keep them under ?X: RCS, but don't think to protect the $Log and other $Id keywords from ?X: variable substitution (or people like me who do not like to). ?X: ?MAKE:Author Date Header Id Locker Log RCSfile Revision Source State: Oldconfig ?MAKE: -pick weed $@ %< ?LINT:describe Author Date Header Id Locker Log RCSfile Revision Source State : preserve RCS keywords in files with variable substitution, grrr ?Author:Author='$Author' ?Date:Date='$Date' ?Header:Header='$Header' ?Id:Id='$Id' ?$Locker' ?Log:Log='$Log' ?RCSfile:RCSfile='$RCSfile' ?Revision:Revision='$Revision' ?Source:Source='$Source' ?State:State='$State' metaconfig-debian-perl-5.26.1/dist/U/Setvar.U000066400000000000000000000032031316016665300206470ustar00rootroot00000000000000?RCS: $Id: Setvar.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Setvar.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 15:58:28 ram ?RCS: patch36: call ./whoa explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:16 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit produces a variable that is intended to be eval'ed in ?X: order to define/undefine a symbol. A consistency check is made ?X: regarding any previous value and a warning is issued if there ?X: is any discrepancy. ?X: ?X: To use it, say: ?X: val= ?X: set d_variable ?X: eval $setvar ?X: ?MAKE:Setvar: Whoa ?MAKE: -pick add $@ %< ?LINT:define setvar ?S:setvar: ?S: This shell variable is used internally by Configure to set a value ?S: to a given symbol that is defined or not. A typical use is: ?S: val= ?S: set d_variable ?S: eval $setvar ?S: That will print a message in case the $val value is not the same ?S: as the previous value of $d_variable. ?S:. ?V:setvar:val ?T:var was td tu : function used to set '$1' to '$val' setvar='var=$1; eval "was=\$$1"; td=$define; tu=$undef; case "$val$was" in $define$undef) . ./whoa; eval "$var=\$td";; $undef$define) . ./whoa; eval "$var=\$tu";; *) eval "$var=$val";; esac' metaconfig-debian-perl-5.26.1/dist/U/Signal.U000066400000000000000000000160541316016665300206300ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Signal.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:20:01 ram ?RCS: patch61: created ?RCS: ?X: ?X: This unit produces three files: ?X: ?X: 1- A signal.c file, which, when compiled and run, produces an output like: ?X: ?X: HUP 1 ?X: INT 2 ?X: QUIT 3 ?X: etc... ?X: ?X: 2- A signal.awk script to parse the output of signal.c, fill ?X: in gaps (up to NSIG) and move duplicates to the end. ?X: ?X: 3- A signal_cmd script to compile signal.c and run it ?X: through sort -n -k 2 | uniq | awk -f signal.awk. ?X: (we try also sort -n +1 since some old hosts don't grok sort -k) ?X: (This is called signal_cmd to avoid OS/2 confusion with ?X: signal.cmd vs. signal. ?X: The signal_cmd script also falls back on checking signals one at a ?X: time in case the signal.c program fails. On at least one version of ?X: Linux 2.1.x, the header file #define'd SIGRTMAX to a symbol that ?X: is not defined by the compiler/linker. :-(. Further, on that same ?X: version of Linux, the user had a defective C-shell that gave an ?X: incorrect list for kill -l, so the fall-back didn't work. ?X: ?X: This unit is then used by sig_name.U. ?X: ?MAKE:Signal: test tr rm awk cat grep startsh eunicefix sed sort uniq \ Findhdr cppstdin +cppflags cppminus Compile trnl run ?MAKE: -pick add $@ %< ?X:all files declared as "public" since they're used from other units ?F:signal.c signal_cmd signal.lst signal signal.awk ?T: xx xxx xxxfiles ?LINT:use rm run : Trace out the files included by signal.h, then look for SIGxxx names. ?X: Remove SIGARRAYSIZE used by HPUX. ?X: Remove SIGSTKSIZE used by Linux. ?X: Remove SIGSTKSZ used by Posix. ?X: Remove SIGTYP void lines used by OS2. ?X: Some cpps, like os390, dont give the file name anywhere if [ "X$fieldn" = X ]; then : Just make some guesses. We check them later. xxx='/usr/include/signal.h /usr/include/sys/signal.h' else xxx=`echo '#include ' | $cppstdin $cppminus $cppflags 2>/dev/null | $grep '^[ ]*#.*include' | $awk "{print \\$$fieldn}" | $sed 's!"!!g' |\ $sed 's!\\\\\\\\!/!g' | $sort | $uniq` fi ?X: Check this list of files to be sure we have parsed the cpp output ok. ?X: This will also avoid potentially non-existent files, such ?X: as ../foo/bar.h xxxfiles='' ?X: Add /dev/null in case the $xxx list is empty. for xx in $xxx /dev/null ; do $test -f "$xx" && xxxfiles="$xxxfiles $xx" done ?X: If we have found no files, at least try signal.h case "$xxxfiles" in '') xxxfiles=`./findhdr signal.h` ;; esac xxx=`awk ' $1 ~ /^#define$/ && $2 ~ /^SIG[A-Z0-9]*$/ && $2 !~ /SIGARRAYSIZE/ && $2 !~ /SIGSTKSIZE/ && $2 !~ /SIGSTKSZ/ && $3 !~ /void/ { print substr($2, 4, 20) } $1 == "#" && $2 ~ /^define$/ && $3 ~ /^SIG[A-Z0-9]*$/ && $3 !~ /SIGARRAYSIZE/ && $4 !~ /void/ { print substr($3, 4, 20) }' $xxxfiles` : Append some common names just in case the awk scan failed. xxx="$xxx ABRT ALRM BUS CANCEL CHLD CLD CONT DIL EMT FPE" xxx="$xxx FREEZE HUP ILL INT IO IOT KILL LOST LWP PHONE" xxx="$xxx PIPE POLL PROF PWR QUIT RTMAX RTMIN SEGV STKFLT STOP" xxx="$xxx SYS TERM THAW TRAP TSTP TTIN TTOU URG USR1 USR2" xxx="$xxx USR3 USR4 VTALRM WAITING WINCH WIND WINDOW XCPU XFSZ" : generate a few handy files for later $cat > signal.c <<'EOCP' #include #include #include int main() { /* Strange style to avoid deeply-nested #if/#else/#endif */ #ifndef NSIG # ifdef _NSIG # define NSIG (_NSIG) # endif #endif #ifndef NSIG # ifdef SIGMAX # define NSIG (SIGMAX+1) # endif #endif #ifndef NSIG # ifdef SIG_MAX # define NSIG (SIG_MAX+1) # endif #endif #ifndef NSIG # ifdef MAXSIG # define NSIG (MAXSIG+1) # endif #endif #ifndef NSIG # ifdef MAX_SIG # define NSIG (MAX_SIG+1) # endif #endif #ifndef NSIG # ifdef SIGARRAYSIZE # define NSIG (SIGARRAYSIZE+1) /* Not sure of the +1 */ # endif #endif #ifndef NSIG # ifdef _sys_nsig # define NSIG (_sys_nsig) /* Solaris 2.5 */ # endif #endif /* Default to some arbitrary number that's big enough to get most of the common signals. */ #ifndef NSIG # define NSIG 50 #endif printf("NSIG %d\n", NSIG); #ifndef JUST_NSIG EOCP echo $xxx | $tr ' ' $trnl | $sort | $uniq | $awk ' { printf "#ifdef SIG"; printf $1; printf "\n" printf "printf(\""; printf $1; printf " %%d\\n\",SIG"; printf $1; printf ");\n" printf "#endif\n" } END { printf "#endif /* JUST_NSIG */\n"; printf "exit(0);\n}\n"; } ' >>signal.c $cat >signal.awk <<'EOP' BEGIN { ndups = 0 } $1 ~ /^NSIG$/ { nsig = $2 } ($1 !~ /^NSIG$/) && (NF == 2) { if ($2 > maxsig) { maxsig = $2 } if (sig_name[$2]) { dup_name[ndups] = $1 dup_num[ndups] = $2 ndups++ } else { sig_name[$2] = $1 sig_num[$2] = $2 } } END { if (nsig == 0) { nsig = maxsig + 1 } printf("NSIG %d\n", nsig); for (n = 1; n < nsig; n++) { if (sig_name[n]) { printf("%s %d\n", sig_name[n], sig_num[n]) } else { printf("NUM%d %d\n", n, n) } } for (n = 0; n < ndups; n++) { printf("%s %d\n", dup_name[n], dup_num[n]) } } EOP $cat >signal_cmd <>signal_cmd <<'EOS' set signal if eval $compile_ok; then $run ./signal$_exe | ($sort -n -k 2 2>/dev/null || $sort -n +1) |\ $uniq | $awk -f signal.awk >signal.lst else echo "(I can't seem be able to compile the whole test program)" >&4 echo "(I'll try it in little pieces.)" >&4 set signal -DJUST_NSIG if eval $compile_ok; then $run ./signal$_exe > signal.nsg $cat signal.nsg else echo "I can't seem to figure out how many signals you have." >&4 echo "Guessing 50." >&4 echo 'NSIG 50' > signal.nsg fi : Now look at all the signal names, one at a time. for xx in `echo $xxx | $tr ' ' $trnl | $sort | $uniq`; do $cat > signal.c < #include #include int main() { printf("$xx %d\n", SIG${xx}); return 0; } EOCP set signal if eval $compile; then echo "SIG${xx} found." $run ./signal$_exe >> signal.ls1 else echo "SIG${xx} NOT found." fi done if $test -s signal.ls1; then $cat signal.nsg signal.ls1 | $sort -n | $uniq | $awk -f signal.awk >signal.lst fi fi if $test -s signal.lst; then : else echo "(AAK! I can't compile the test programs -- Guessing)" >&4 echo 'kill -l' >signal set X `csh -f signal.lst fi $rm -f signal.c signal$_exe signal$_o signal.nsg signal.ls1 EOS chmod a+x signal_cmd $eunicefix signal_cmd metaconfig-debian-perl-5.26.1/dist/U/Tr.U000066400000000000000000000062251316016665300177770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Tr.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 18:00:54 ram ?RCS: patch43: forgot to quote $@ to protect against "evil" characters ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 15:58:35 ram ?RCS: patch36: created ?RCS: ?X: ?X: This unit produces a bit of shell code that must be dotted in in order ?X: to do a character translation. It catches translations to uppercase or ?X: to lowercase, and then invokes the real tr to perform the job. ?X: ?X: This unit is necessary on HP machines (HP strikes again!) with non-ascii ?X: ROMAN8-charset, where normal letters are not arranged in a row, so a-z ?X: covers not the whole alphabet but lots of special chars. This was reported ?X: by Andreas Sahlbach . ?X: ?X: Units performing a tr '[A-Z]' '[a-z]' or the other way round should include ?X: us in their dependency and use ./tr instead. ?X: ?MAKE:Tr: startsh tr eunicefix ?MAKE: -pick add $@ %< ?F:./tr ?T:up low LC_ALL : see whether [:lower:] and [:upper:] are supported character classes echo " " case "`echo AbyZ | LC_ALL=C $tr '[:lower:]' '[:upper:]' 2>/dev/null`" in ABYZ) echo "Good, your tr supports [:lower:] and [:upper:] to convert case." >&4 up='[:upper:]' low='[:lower:]' ;; *) # There is a discontinuity in EBCDIC between 'I' and 'J' # (0xc9 and 0xd1), therefore that is a nice testing point. if test "X$up" = X -o "X$low" = X; then case "`echo IJ | LC_ALL=C $tr '[I-J]' '[i-j]' 2>/dev/null`" in ij) up='[A-Z]' low='[a-z]' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo IJ | LC_ALL=C $tr I-J i-j 2>/dev/null`" in ij) up='A-Z' low='a-z' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo IJ | od -x 2>/dev/null`" in *C9D1*|*c9d1*) echo "Hey, this might be EBCDIC." >&4 if test "X$up" = X -o "X$low" = X; then case "`echo IJ | \ LC_ALL=C $tr '[A-IJ-RS-Z]' '[a-ij-rs-z]' 2>/dev/null`" in ij) up='[A-IJ-RS-Z]' low='[a-ij-rs-z]' ;; esac fi if test "X$up" = X -o "X$low" = X; then case "`echo IJ | LC_ALL=C $tr A-IJ-RS-Z a-ij-rs-z 2>/dev/null`" in ij) up='A-IJ-RS-Z' low='a-ij-rs-z' ;; esac fi ;; esac fi esac case "`echo IJ | LC_ALL=C $tr \"$up\" \"$low\" 2>/dev/null`" in ij) echo "Using $up and $low to convert case." >&4 ;; *) echo "I don't know how to translate letters from upper to lower case." >&4 echo "Your tr is not acting any way I know of." >&4 exit 1 ;; esac : set up the translation script tr, must be called with ./tr of course cat >tr <warn <msg else cat >msg fi ?X: Emit the warning, prefixing all lines with '*** ' echo "*** WARNING:" >&4 sed -e 's/^/*** /' &4 echo "*** " >&4 ?X: Save the warning in the logs, which will be shown again at the end cat msg >>config.msg echo " " >>config.msg rm -f msg EOS chmod +x warn $eunicefix warn metaconfig-debian-perl-5.26.1/dist/U/Warn_v7EXT.U000066400000000000000000000023341316016665300213130ustar00rootroot00000000000000?RCS: $Id: Warn_v7EXT.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: Warn_v7EXT.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:01:42 ram ?RCS: patch36: call ./v7 explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:17 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: This unit issues warnings to V7 sites that they are living dangerously. ?X: This unit needs to get mentioned in End.U to get included. ?X: ?MAKE:Warn_v7EXT: package Guess ?MAKE: -pick add $@ %< : Warnings if ./v7; then cat <whoa $startsh EOS cat <<'EOSC' >>whoa dflt=y echo " " echo "*** WHOA THERE!!! ***" >&4 echo " The $hint value for \$$var on this machine was \"$was\"!" >&4 rp=" Keep the $hint value?" . ./myread case "$ans" in y) td=$was; tu=$was;; esac EOSC metaconfig-debian-perl-5.26.1/dist/U/abortsig.U000066400000000000000000000042401316016665300212170ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: abortsig.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:02:19 ram ?RCS: patch36: call ./usg explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:20 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:abortsig: Myread Oldconfig Guess cat +cc ccflags rm ?MAKE: -pick add $@ %< ?S:abortsig: ?S: This variable holds the name of the signal used by the abort() call. ?S:. ?C:ABORTSIG: ?C: This symbol holds the signal number (symbol) used by the abort() call. To ?C: actually define the signal symbol, should be included. ?C:. ?H:#define ABORTSIG $abortsig /**/ ?H:. ?T:signal : which signal is sent by abort ? echo " " case "$abortsig" in '') echo "Checking to see which signal is sent to the process by abort()..." >&4 echo "abort" > abort.sh chmod +x abort.sh ?X: SIGABRT should replace SIGIOT on USG machines in a near future (1991). for signal in SIGIOT SIGILL SIGABRT; do case "$abortsig" in '') $cat >abort.c <*/ #include caught() { exit(0); } /* FIXME: Use _exit() or _Exit() in signal handler */ int main() { #ifdef $signal signal($signal, caught); #endif if (-1 == abort()) exit(1); exit(1); } EOP ?X: We have to use the abort.sh script otherwise sh behaves strangely on AIX. if $cc $ccflags -o abort abort.c >/dev/null 2>&1; then (./abort.sh) >/dev/null 2>&1 case $? in 0) abortsig="$signal";; esac fi ;; esac done ;; esac case "$abortsig" in '') echo "(I wasn't able to compute the signal name--guessing)" if ./usg; then dflt="SIGIOT" else dflt="SIGILL" fi;; *) dflt="$abortsig" ;; esac rp="Which signal does abort() send to the process (signal name)?" . ./myread abortsig="$ans" $rm -f core abort.sh abort abort.c metaconfig-debian-perl-5.26.1/dist/U/afs.U000066400000000000000000000032151316016665300201570ustar00rootroot00000000000000?RCS: $Id: afs.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: afs.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:23:06 ram ?RCS: patch61: can now explicitly tell Configure whether AFS is running ?RCS: ?RCS: Revision 3.0.1.1 1993/08/24 12:24:43 ram ?RCS: patch3: created ?RCS: ?MAKE:afs afsroot: test ?MAKE: -pick add $@ %< ?S:afs: ?S: This variable is set to 'true' if AFS (Andrew File System) is used ?S: on the system, 'false' otherwise. It is possible to override this ?S: with a hint value or command line option, but you'd better know ?S: what you are doing. ?S:. ?S:afsroot: ?S: This variable is by default set to '/afs'. In the unlikely case ?S: this is not the correct root, it is possible to override this with ?S: a hint value or command line option. This will be used in subsequent ?S: tests for AFSness in the configure and test process. ?S:. : allow them to override the AFS root case "$afsroot" in '') afsroot=/afs ;; *) afsroot=$afsroot ;; esac : is AFS running? echo " " case "$afs" in $define|true) afs=true ;; $undef|false) afs=false ;; *) if $test -d $afsroot; then afs=true else afs=false fi ;; esac if $afs; then echo "AFS may be running... I'll be extra cautious then..." >&4 else echo "AFS does not seem to be running..." >&4 fi metaconfig-debian-perl-5.26.1/dist/U/alignbytes.U000066400000000000000000000055231316016665300215530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: alignbytes.U,v $ ?RCS: Revision 3.0.1.2 1994/10/29 16:02:28 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:25:20 ram ?RCS: patch23: avoid ALIGNBYTES, since it conflicts on NetBSD ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:23 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:alignbytes: Assert Myread Trylink cat i_inttypes i_limits i_math ?MAKE: -pick add $@ %< ?S:alignbytes: ?S: This variable holds the number of bytes required to align an ?S: arbitrary standard type. Usual values are 2, 4 and 8. ?S:. ?X: This used to be called ALIGNBYTES, but that conflicts with ?X: in NetBSD. ?C:MEM_ALIGNBYTES (ALIGNBYTES): ?C: This symbol contains the number of bytes required to align a ?C: double. Usual values are 2, 4 and 8. ?C:. ?H:#define MEM_ALIGNBYTES $alignbytes /**/ ?H:. ?T:alignment result : check for alignment requirements echo " " case "$alignbytes" in '') echo "Checking alignment constraints..." >&4 for alignment in 8 4 2 1 16 32 error do $cat >try.c < #endif #$i_limits I_LIMITS #ifdef I_LIMITS #include #endif #$i_math I_MATH #ifdef I_MATH #include #endif union u { void *void_ptr; void (*func_ptr)(void); char c; short s; int i; long l; float f; double d; #ifdef LLONG_MAX long long ll; #else #warning "LLONG_MAX undefined" #endif #if defined(HUGE_VALL) long double ld; #else #warning "HUGE_VALL undefined" #endif #ifdef UINT32_MAX uint32_t u32; #else #warning "UINT32_MAX undefined" #endif #ifdef UINT16_MAX uint16_t u16; #else #warning "UINT32_MAX undefined" #endif #ifdef UINT64_MAX uint64_t u64; #else #warning "UINT64_MAX undefined" #endif #ifdef UINTMAX_MAX uintmax_t m; #else #warning "UINTMAX_MAX undefined" #endif #ifdef UINTPTR_MAX uintptr_t up; #else #warning "UINTPTR_MAX undefined" #endif }; struct s { char a; union u b; }; #include "static_assert.h" int main(void) { STATIC_ASSERT($alignment == ((sizeof (struct s) - (sizeof (union u))))); return 0; } EOCP result='' set result eval $trylink case "$result" in "$define") break;; esac done case "$alignment" in error) dflt='8' echo "(I can't seem to compile the test program...)" >&4 ;; *) dflt=$alignment ;; esac ;; *) dflt="$alignbytes" ;; esac rp="What is the maximum alignment in bytes required for a standard type?" . ./myread alignbytes="$ans" metaconfig-debian-perl-5.26.1/dist/U/archlib.U000066400000000000000000000101741316016665300210140ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: archlib.U,v $ ?RCS: Revision 3.0.1.5 1997/02/28 15:23:38 ram ?RCS: patch61: skip existence checks for archlib ?RCS: ?RCS: Revision 3.0.1.4 1995/09/25 09:15:18 ram ?RCS: patch59: unit is now forced to the top of Configure, if possible ?RCS: ?RCS: Revision 3.0.1.3 1995/02/15 14:14:14 ram ?RCS: patch51: architecture name is now computed by a separate unit ?RCS: ?RCS: Revision 3.0.1.2 1995/01/30 14:32:22 ram ?RCS: patch49: archname is now systematically recomputed ?RCS: patch49: can now handle installation prefix changes (from WED) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:02:36 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_archlib archlib archlibexp installarchlib: archname afs spackage \ cat Getfile Loc Oldconfig prefixexp privlib test Prefixit Prefixup ?MAKE: -pick add $@ %< ?Y:TOP ?S:d_archlib: ?S: This variable conditionally defines ARCHLIB to hold the pathname ?S: of architecture-dependent library files for $package. If ?S: $archlib is the same as $privlib, then this is set to undef. ?S:. ?S:archlib: ?S: This variable holds the name of the directory in which the user wants ?S: to put architecture-dependent public library files for $package. ?S: It is most often a local directory such as /usr/local/lib. ?S: Programs using this variable must be prepared to deal ?S: with filename expansion. ?S:. ?S:archlibexp: ?S: This variable is the same as the archlib variable, but is ?S: filename expanded at configuration time, for convenient use. ?S:. ?S:installarchlib: ?S: This variable is really the same as archlibexp but may differ on ?S: those systems using AFS. For extra portability, only this variable ?S: should be used in makefiles. ?S:. ?C:ARCHLIB: ?C: This variable, if defined, holds the name of the directory in ?C: which the user wants to put architecture-dependent public ?C: library files for $package. It is most often a local directory ?C: such as /usr/local/lib. Programs using this variable must be ?C: prepared to deal with filename expansion. If ARCHLIB is the ?C: same as PRIVLIB, it is not defined, since presumably the ?C: program already searches PRIVLIB. ?C:. ?C:ARCHLIB_EXP: ?C: This symbol contains the ~name expanded version of ARCHLIB, to be used ?C: in programs that are not prepared to deal with ~ expansion at run-time. ?C:. ?H:#$d_archlib ARCHLIB "$archlib" /**/ ?H:#$d_archlib ARCHLIB_EXP "$archlibexp" /**/ ?H:. : determine where public architecture dependent libraries go set archlib archlib eval $prefixit case "$archlib" in '') case "$privlib" in '') dflt=`./loc . "." $prefixexp/lib /usr/local/lib /usr/lib /lib` set dflt eval $prefixup ;; *) dflt="$privlib/$archname";; esac ;; *) dflt="$archlib";; esac cat < tmparch 2>&1 ; then tarch=`$sed -e 's/ *$//' -e 's/ /_/g' \ -e 's/$/'"-$osname/" tmparch` else tarch="$osname" fi $rm -f tmparch else tarch="$osname" fi case "$myarchname" in ''|"$tarch") ;; *) echo "(Your architecture name used to be $myarchname.)" archname='' ;; esac case "$archname" in '') dflt="$tarch";; *) dflt="$archname";; esac rp='What is your architecture name' . ./myread archname="$ans" myarchname="$tarch" metaconfig-debian-perl-5.26.1/dist/U/baserev.U000066400000000000000000000013701316016665300210350ustar00rootroot00000000000000?RCS: $Id: baserev.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: baserev.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:24 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:baserev: Null ?MAKE: -pick wipe $@ %< ?S:baserev: ?S: The base revision level of this package, from the .package file. ?S:. : set the base revision baserev= metaconfig-debian-perl-5.26.1/dist/U/basicshell.U000066400000000000000000000026601316016665300215220ustar00rootroot00000000000000?RCS: $Id: basicshell.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: basicshell.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:25 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:basicshell: Getfile Oldconfig bash csh ksh sh ?MAKE: -pick add $@ %< ?S:basicshell: ?S: This variable contains the eventual value of the BASICSHELL symbol, ?S: which contains the full name of the basic script shell on this ?S: system. Usual values are /bin/sh, /bin/ksh, /bin/csh. ?S:. ?C:BASICSHELL: ?C: This symbol contains the full name of the basic script shell on this ?C: system. Usual values are /bin/sh, /bin/ksh, /bin/csh. ?C:. ?H:#define BASICSHELL "$basicshell" /**/ ?H:. : find the most basic shell for scripts echo " " case "$basicshell" in '') case "$sh $bash $csh $ksh" in */sh*) dflt="$sh" ;; */ksh*) dflt="$ksh" ;; */csh*) dflt="$csh" ;; */bash*) dflt="$bash" ;; *) dflt='/bin/sh' ;; esac ;; *) dflt="$basicshell";; esac fn=f rp="Give the full path name of the most basic shell used on your system" . ./getfile basicshell=$ans metaconfig-debian-perl-5.26.1/dist/U/bin.U000066400000000000000000000055031316016665300201600ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: bin.U,v $ ?RCS: Revision 3.0.1.4 1995/09/25 09:15:32 ram ?RCS: patch59: unit is now forced to the top of Configure, if possible ?RCS: ?RCS: Revision 3.0.1.3 1995/01/30 14:32:40 ram ?RCS: patch49: can now handle installation prefix changes (from WED) ?RCS: ?RCS: Revision 3.0.1.2 1994/08/29 16:05:28 ram ?RCS: patch32: now uses installation prefix ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 15:56:51 ram ?RCS: patch10: made prompting more explicit (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:26 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:bin binexp installbin: Prefixit Getfile Oldconfig afs cat test ?MAKE: -pick add $@ %< ?Y:TOP ?S:bin: ?S: This variable holds the name of the directory in which the user wants ?S: to put publicly executable images for the package in question. It ?S: is most often a local directory such as /usr/local/bin. Programs using ?S: this variable must be prepared to deal with ~name substitution. ?S:. ?S:binexp: ?S: This is the same as the bin variable, but is filename expanded at ?S: configuration time, for use in your makefiles. ?S:. ?S:installbin: ?S: This variable is the same as binexp unless AFS is running in which case ?S: the user is explicitly prompted for it. This variable should always ?S: be used in your makefiles for maximum portability. ?S:. ?C:BIN: ?C: This symbol holds the path of the bin directory where the package will ?C: be installed. Program must be prepared to deal with ~name substitution. ?C:. ?C:BIN_EXP: ?C: This symbol is the filename expanded version of the BIN symbol, for ?C: programs that do not want to deal with that at run-time. ?C:. ?H:#define BIN "$bin" /**/ ?H:#define BIN_EXP "$binexp" /**/ ?H:. ?D:bin='/usr/local/bin' : determine where public executables go echo " " set dflt bin bin eval $prefixit fn=d~ rp='Pathname where the public executables will reside?' . ./getfile if $test "X$ansexp" != "X$binexp"; then installbin='' fi bin="$ans" binexp="$ansexp" if $afs; then $cat <&4 $cat >try.c <<'EOCP' #include ?X: Standard C requires a macro CHAR_BIT in #ifdef __STDC__ #include #ifndef CHAR_BIT #define CHAR_BIT 8 #endif #ifndef BITSPERBYTE #define BITSPERBYTE CHAR_BIT #endif #else ?X: On non standard C, try with #include #ifndef BITSPERBYTE #define BITSPERBYTE 8 #endif #endif int main() { printf("%d\n", BITSPERBYTE); } EOCP if $cc $ccflags -o try try.c >/dev/null 2>&1 ; then dflt=`./try` else dflt='8' echo "(I can't seem to compile the test program. Guessing...)" fi ;; *) dflt="$bitpbyte" ;; esac rp="What is the length of a byte (in bits)?" . ./myread bitpbyte="$ans" $rm -f try.c try metaconfig-debian-perl-5.26.1/dist/U/byteorder.U000066400000000000000000000045541316016665300214140ustar00rootroot00000000000000?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, 2012 Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?MAKE:byteorder: cat Myread Oldconfig Loc +cc +ccflags rm_try ?MAKE: -pick add $@ %< ?S:byteorder: ?S: This variable holds the byte order. In the following, larger digits ?S: indicate more significance. The variable byteorder is either 4321 ?S: on a big-endian machine, or 1234 on a little-endian, or 87654321 ?S: on a Cray ... or 3412 with weird order ! ?S:. ?C:BYTEORDER: ?C: This symbol hold the hexadecimal constant defined in byteorder, ?C: i.e. 0x1234 or 0x4321, etc... ?C:. ?H:#define BYTEORDER 0x$byteorder /* large digits for MSB */ ?H:. ?T:xxx_prompt ?F:!try : check for ordering of bytes in a long case "$byteorder" in '') $cat <<'EOM' In the following, larger digits indicate more significance. A big-endian machine like a Pyramid or a Motorola 680?0 chip will come out to 4321. A little-endian machine like a Vax or an Intel 80?86 chip would be 1234. Other machines may have weird orders like 3412. A Cray will report 87654321. If the test program works the default is probably right. I'm now running the test program... EOM $cat >try.c <<'EOCP' #include int main() { int i; union { unsigned long l; char c[sizeof(long)]; } u; if (sizeof(long) > 4) u.l = (0x08070605L << 32) | 0x04030201L; else u.l = 0x04030201L; for (i = 0; i < sizeof(long); i++) printf("%c", u.c[i]+'0'); printf("\n"); exit(0); } EOCP xxx_prompt=y if $cc $ccflags -o try try.c >/dev/null 2>&1 && ./try > /dev/null; then dflt=`./try` case "$dflt" in [1-4][1-4][1-4][1-4]|12345678|87654321) echo "(The test program ran ok.)" echo "byteorder=$dflt" xxx_prompt=n ;; ????|????????) echo "(The test program ran ok.)" ;; *) echo "(The test program didn't run right for some reason.)" ;; esac else dflt='4321' cat <<'EOM' (I can't seem to compile the test program. Guessing big-endian...) EOM fi case "$xxx_prompt" in y) rp="What is the order of bytes in a long?" . ./myread byteorder="$ans" ;; *) byteorder=$dflt ;; esac ;; esac $rm_try metaconfig-debian-perl-5.26.1/dist/U/cc.U000066400000000000000000000036121316016665300177740ustar00rootroot00000000000000?RCS: $Id: cc.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cc.U,v $ ?RCS: Revision 3.0.1.4 1995/05/12 12:06:47 ram ?RCS: patch54: may now abort Configure when cc does not work ?RCS: ?RCS: Revision 3.0.1.3 1995/01/11 15:20:11 ram ?RCS: patch45: changed gcc checking message to a more explicit one (WED) ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:04:29 ram ?RCS: patch36: detect gcc even when not called as 'gcc' (ADO) ?RCS: patch36: simplified gcc version checking (ADO) ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:26:06 ram ?RCS: patch23: added support for gcc version (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:30 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:cc: Myread Oldconfig Checkcc test ?MAKE: -pick add $@ %< ?S:cc: ?S: This variable holds the name of a command to execute a C compiler which ?S: can resolve multiple global references that happen to have the same ?S: name. Usual values are 'cc' and 'gcc'. ?S: Fervent ANSI compilers may be called 'c89'. AIX has xlc. ?S:. ?F:!cc.cbu ?D:cc='cc' : Determine the C compiler to be used echo " " case "$cc" in '') dflt=cc;; *) dflt="$cc";; esac rp="Use which C compiler?" . ./myread cc="$ans" : See whether they have no cc but they do have gcc . ./trygcc ?X: Look for a hint-file generated 'call-back-unit'. Now that the ?X: user has specified the compiler, we may need to set or change some ?X: other defaults. if $test -f cc.cbu; then . ./cc.cbu fi . ./checkcc metaconfig-debian-perl-5.26.1/dist/U/ccflags.U000066400000000000000000000255521316016665300210200ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: ccflags.U,v $ ?RCS: Revision 3.0.1.9 1997/02/28 15:27:07 ram ?RCS: patch61: removed support for NO_PROTOTYPE detection on SCO ?RCS: patch61: new locincpth variable ?RCS: patch61: added info on the "additional ld flags" question ?RCS: ?RCS: Revision 3.0.1.8 1995/07/25 13:48:54 ram ?RCS: patch56: re-arranged compile line to include ldflags before objects ?RCS: ?RCS: Revision 3.0.1.7 1995/05/12 12:08:33 ram ?RCS: patch54: now checks for cc/ccflags/ldflags coherency ?RCS: ?RCS: Revision 3.0.1.6 1994/10/29 16:07:02 ram ?RCS: patch36: gcc versioning no longer relies on the C compiler's name ?RCS: patch36: simplified check for gcc version checking (ADO) ?RCS: ?RCS: Revision 3.0.1.5 1994/08/29 16:06:35 ram ?RCS: patch32: propagate -posix flag from ccflags to ldflags ?RCS: ?RCS: Revision 3.0.1.4 1994/05/06 14:28:45 ram ?RCS: patch23: -fpcc-struct-return only needed in gcc 1.x (ADO) ?RCS: patch23: cppflags now computed on an option-by-option basis ?RCS: patch23: magically added cc flags now only done the first time ?RCS: ?RCS: Revision 3.0.1.3 1993/09/13 15:58:29 ram ?RCS: patch10: explicitly mention -DDEBUG just in case they need it (WAD) ?RCS: patch10: removed all the "tans" variable usage (WAD) ?RCS: ?RCS: Revision 3.0.1.2 1993/08/27 14:39:38 ram ?RCS: patch7: added support for OSF/1 machines ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:00:24 ram ?RCS: patch6: added defaults for cppflags, ccflags and ldflags ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:31 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:ccflags ldflags lkflags cppflags optimize locincpth: test cat \ Myread Guess Options Oldconfig gccversion mips_type +usrinc \ package contains rm rm_try +cc cppstdin cppminus cpprun cpplast libpth \ loclibpth hint ?MAKE: -pick add $@ %< ?S:ccflags: ?S: This variable contains any additional C compiler flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:cppflags: ?S: This variable holds the flags that will be passed to the C pre- ?S: processor. It is up to the Makefile to use it. ?S:. ?S:optimize: ?S: This variable contains any optimizer/debugger flag that should be used. ?S: It is up to the Makefile to use it. ?S:. ?S:ldflags: ?S: This variable contains any additional C loader flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:lkflags: ?S: This variable contains any additional C partial linker flags desired by ?S: the user. It is up to the Makefile to use this. ?S:. ?S:locincpth: ?S: This variable contains a list of additional directories to be ?S: searched by the compiler. The appropriate -I directives will ?S: be added to ccflags. This is intended to simplify setting ?S: local directories from the Configure command line. ?S: It's not much, but it parallels the loclibpth stuff in libpth.U. ?S:. ?T:inctest thisincl xxx flag inclwanted ftry previous thislibdir ?F:!cpp.c ?D:cppflags='' ?D:ccflags='' ?D:ldflags='' ?D:optimize='' ?INIT:: Possible local include directories to search. ?INIT:: Set locincpth to "" in a hint file to defeat local include searches. ?INIT:locincpth="/usr/local/include /opt/local/include /usr/gnu/include" ?INIT:locincpth="$locincpth /opt/gnu/include /usr/GNU/include /opt/GNU/include" ?INIT:: ?INIT:: no include file wanted by default ?INIT:inclwanted='' ?INIT: : determine optimize, if desired, or use for debug flag also case "$optimize" in ' '|$undef) dflt='none';; '') case "$gccversion" in '') dflt='-O';; *) dflt='-O2 -g';; esac ;; *) dflt="$optimize";; esac case "$gccversion" in '') $cat </dev/null 2>&1 then dflt="$dflt -posix" fi ;; esac ?X: turn warnings on if they're using gcc case "$gccversion" in 1*|2*) dflt="$dflt -Wall";; ?X: starting with version 3, add "-W -Wall -Wformat=2 -Wshadow" by default *) dflt="$dflt -W -Wall -Wformat=2 -Wshadow";; esac ;; esac ?X: In USG mode, a MIPS system may need some BSD includes case "$mips_type" in *BSD*|'') inclwanted="$locincpth $usrinc";; *) inclwanted="$locincpth $inclwanted $usrinc/bsd";; esac for thisincl in $inclwanted; do if $test -d $thisincl; then if $test x$thisincl != x$usrinc; then case "$dflt" in *$thisincl*);; *) dflt="$dflt -I$thisincl";; esac fi fi done ?X: Include test function (header, symbol) inctest='if $contains $2 $usrinc/$1 >/dev/null 2>&1; then xxx=true; elif $contains $2 $usrinc/sys/$1 >/dev/null 2>&1; then xxx=true; else xxx=false; fi; if $xxx; then case "$dflt" in *$2*);; *) dflt="$dflt -D$2";; esac; fi' ?X: ?X: OSF/1 uses __LANGUAGE_C__ instead of LANGUAGE_C ?X: if ./osf1; then set signal.h __LANGUAGE_C__; eval $inctest else set signal.h LANGUAGE_C; eval $inctest fi case "$hint" in default|recommended) dflt="$ccflags $dflt" ;; *) dflt="$ccflags";; esac case "$dflt" in ''|' ') dflt=none;; esac $cat <&4 set X $cppflags shift cppflags='' $cat >cpp.c <<'EOM' #define BLURFL foo BLURFL xx LFRULB EOM ?X: ?X: For each cc flag, try it out with both cppstdin and cpprun, since the ?X: first is almost surely a cc wrapper. We have to try both in case ?X: of cc flags like '-Olimit 2900' that are actually two words... ?X: previous='' for flag in $* do case "$flag" in -*) ftry="$flag";; *) ftry="$previous $flag";; esac if $cppstdin -DLFRULB=bar $ftry $cppminus cpp1.out 2>/dev/null && \ $cpprun -DLFRULB=bar $ftry $cpplast cpp2.out 2>/dev/null && \ $contains 'foo.*xx.*bar' cpp1.out >/dev/null 2>&1 && \ $contains 'foo.*xx.*bar' cpp2.out >/dev/null 2>&1 then cppflags="$cppflags $ftry" previous='' else previous="$flag" fi done set X $cppflags shift cppflags=${1+"$@"} case "$cppflags" in *-*) echo "They appear to be: $cppflags";; esac $rm -f cpp.c cpp?.out ;; esac : flags used in final linking phase case "$ldflags" in '') if ./venix; then dflt='-i -z' else dflt='' fi case "$ccflags" in *-posix*) dflt="$dflt -posix" ;; esac ;; *) dflt="$ldflags";; esac : Try to guess additional flags to pick up local libraries. for thislibdir in $libpth; do case " $loclibpth " in *" $thislibdir "*) case "$dflt " in *"-L$thislibdir "*) ;; *) dflt="$dflt -L$thislibdir" ;; esac ;; esac done case "$dflt" in '') dflt='none' ;; *) set X $dflt; shift; dflt="$@";; esac $cat <&4 ?X: Strip extra blanks in case some of the following variables are empty set X $cc $optimize $ccflags $ldflags -o try try.c shift $cat >try.msg < try.c <<'EOF' #include int main() { exit(0); } EOF dflt=y ?X: Use "sh -c" to avoid error messages tagged with leading "Configure:". ?X: We need to try the resulting executable, because cc might yield a 0 status ?X: even when ld failed, in which case the executable will not run properly, ?X: if its x bit is set at all... if sh -c "$cc $optimize $ccflags $ldflags -o try try.c" >>try.msg 2>&1; then if sh -c './try' >>try.msg 2>&1; then dflt=n else echo "The program compiled OK, but exited with status $?." >>try.msg rp="You have a problem. Shall I abort Configure" dflt=y fi else echo "I can't compile the test program." >>try.msg rp="You have a BIG problem. Shall I abort Configure" dflt=y fi case "$dflt" in y) $cat try.msg >&4 ?X: using -K will prevent default aborting--maybe they're cross compiling? case "$knowitall" in '') echo "(The supplied flags might be incorrect with this C compiler.)" ;; *) dflt=n;; esac echo " " . ./myread case "$ans" in n*|N*) ;; *) echo "Ok. Stopping Configure." >&4 exit 1 ;; esac ;; n) echo "OK, that should do.";; esac $rm_try metaconfig-debian-perl-5.26.1/dist/U/cf_email.U000066400000000000000000000034421316016665300211470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cf_email.U,v $ ?RCS: Revision 3.0.1.1 1994/01/24 14:05:06 ram ?RCS: patch16: created ?RCS: ?RCS: ?MAKE:cf_email: cat cf_by test myhostname mydomain Oldconfig Myread ?MAKE: -pick add $@ %< ?S:cf_email: ?S: Electronic mail address of the person who ran Configure. This can be ?S: used by units that require the user's e-mail, like MailList.U. ?S:. ?T:cont maildomain ?LINT:extern MAILDOMAIN : determine the e-mail address of the user who is running us $cat < ?RCS: ?RCS: $Log: cf_name.U,v $ ?RCS: Revision 3.0.1.2 1994/05/06 14:29:36 ram ?RCS: patch23: fixed user name computation from /etc/passwd in bsd systems ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:05:11 ram ?RCS: patch16: created ?RCS: ?RCS: ?MAKE:+cf_name: cf_by passcat Filexp nametype cat test ?MAKE: -pick add $@ %< ?S:cf_name: ?S: Full name of the person who ran the Configure script and answered the ?S: questions. This can be used by units that require the user's full name. ?S: This variable is for internal use only. ?S:. ?T:xxx fn NAME : figure out their full name case "$NAME" in '') case "$nametype" in other) fn=`./filexp ~/.fullname` xxx=usg $test -f $fn && xxx=other ;; *) xxx="$nametype" ;; esac case "$xxx" in bsd) cf_name=`$passcat | grep "^$cf_by:" | \ sed -e 's/^[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\):.*/\1/' \ -e 's/,.*//'` ;; usg) cf_name=`$passcat | grep "^$cf_by:" | \ sed -e 's/^[^:]*:[^:]*:[^:]*:[^:]*:\([^:]*\):.*/\1/' \ -e 's/[^-]*-\(.*\)(.*)/\1/'` ;; *) cf_name=`$cat $fn` ;; esac ;; *) cf_name="$NAME" ;; esac ?X: ?X: In the original unit, Graham asked for the user name, in case the above ?X: code was unable to figure it out correctly. Since now cf_name has been ?X: made an internal variable only (i.e. it is not saved in config.sh), letting ?X: the user override the computed default each time would be a pain. ?X: Therefore, I have decided to trust the above code to get it right, and for ?X: those rare cases where it will fail, too bad :-) --RAM. ?X: echo " " echo "Pleased to meet you, $cf_name." metaconfig-debian-perl-5.26.1/dist/U/cf_who.U000066400000000000000000000045721316016665300206620ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cf_who.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:28:50 ram ?RCS: patch61: new computation method avoiding use of temporary file ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:42:34 ram ?RCS: patch23: login name now computed the hard way ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:32 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Oldconfig dependency is there to ensure computation occurs after old values ?X: from config.sh have been loaded, so that we can supersede them. ?X: ?MAKE:cf_time cf_by: date Oldconfig ?MAKE: -pick add $@ %< ?S:cf_time: ?S: Holds the output of the "date" command when the configuration file was ?S: produced. This is used to tag both config.sh and config_h.SH. ?S:. ?S:cf_by: ?S: Login name of the person who ran the Configure script and answered the ?S: questions. This is used to tag both config.sh and config_h.SH. ?S:. ?LINT:change LC_ALL LANGUAGE : who configured the system ?X: Ensure English date -- Jarkko Hietaniemi cf_time=`LC_ALL=C; LANGUAGE=C; export LC_ALL; export LANGUAGE; $date 2>&1` ?X: ?X: Leave a white space between first two '(' for ksh. The sub-shell is needed ?X: on some machines to avoid the error message when logname is not found; e.g. ?X: on SUN-OS 3.2, (logname || whoami) would not execute whoami if logname was ?X: not found. Sigh! ?X: ?X: Convex had a broken logname executable which returned a non-zero status, ?X: and that broke the previous: ?X: cf_by=`( (logname) 2>/dev/null || whoami) 2>&1` ?X: Switch to emergency mode... -- RAM, 19/04/94 ?X: ?X: Parentheses needed to avoid error message if the program does not exist. ?X: Uses case instead of $test so it can be put before $test is defined. ?X: Don't redirect to a file because on Ultrix (under script?) logname ?X: outputs a blank line first. This method will apparently work. case "$cf_by" in "") cf_by=`(logname) 2>/dev/null` case "$cf_by" in "") cf_by=`(whoami) 2>/dev/null` case "$cf_by" in "") cf_by=unknown ;; esac ;; esac ;; esac metaconfig-debian-perl-5.26.1/dist/U/charorder.U000066400000000000000000000072151316016665300213630ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: charorder.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:07:08 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:33 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:chorder_int chorder_short chorder_long: Myread cat +cc +ccflags rm ?MAKE: -pick add $@ %< ?S:chorder_short (d_cos d_bos): ?S: Holds the value describing the byte ordering of characters in a short. ?S: On a Big-Endian machine, that would be "c0c1". ?S:. ?S:chorder_int (charoder): ?S: Holds the value describing the byte ordering of characters in an int. ?S: For instance, on a Big-Endian machine, this would be: "c0c1c2c3". ?S:. ?S:chorder_long (d_col d_bol): ?S: Holds the value describing the byte ordering of characters in a long. ?S: On a 64 bits Big-Endian machine, that would yield: "c0c1c2c3c4c5c6c7". ?S:. ?C:CHAR_ORDER_SHORT: ?C: Holds the byte ordering of characters in a short. It's a string ?C: value like "c0c1" on a Big-Endian machine. ?C:. ?C:CHAR_ORDER_INT: ?C: Holds the byte ordering of characters in an int. It's a string ?C: value like "c0c1c2c3" on a Big-Endian machine. ?C:. ?C:CHAR_ORDER_LONG: ?C: Holds the byte ordering of characters in a long. It's a string ?C: value like "c0c1c2c3c4c5c6c7" on a 64 bits Big-Endian machine. ?C:. ?H:#define CHAR_ORDER_SHORT "$chorder_short" /* byte order in a short */ ?H:#define CHAR_ORDER_INT "$chorder_int" /* byte order in an int */ ?H:#define CHAR_ORDER_LONG "$chorder_long" /* byte order in a long */ ?H:. ?F:!byteorder : check for character ordering echo " " echo "Checking out byte order..." >&4 $cat >byteorder.c <<'EOCP' #include main(argc, argv) int argc; char *argv[]; { int i; int max; union { short u_s; int u_i; long u_l; char u_c[sizeof(long)]; } u; switch (argv[1][0]) { case 'l': u.u_l = 0L; /* HMS: ASSERT: sizeof(long) < 10. */ for(i = 0; i < sizeof(long); ++i) { u.u_l *= 0x100L; u.u_l += (0xc0 + i); } max = sizeof(long); break; case 's': u.u_s = 0; /* HMS: ASSERT: sizeof(short) < 10. */ for(i = 0; i < sizeof(short); ++i) { u.u_s *= 0x100L; u.u_s += (0xc0 + i); } max = sizeof(short); break; case 'i': u.u_i = 0; /* RAM: ASSERT: sizeof(int) < 10. */ for(i = 0; i < sizeof(int); ++i) { u.u_l *= 0x100L; u.u_l += (0xc0 + i); } max = sizeof(int); break; default: max = 0; break; } for(i = 0; i < max; i++) { printf("%x", u.u_c[i] & 0x00FF); } printf("\n"); exit(0); } EOCP if $cc $ccflags -o byteorder byteorder.c >/dev/null 2>&1 ; then : null statement @if chorder_short chorder_short=`./byteorder s` @end @if chorder_int chorder_int=`./byteorder i` @end @if chorder_long chorder_long=`./byteorder l` @end else $cat <&4 for size in 1 2 4 8 error; do $cat >try.c </dev/null 2>&1; then break; fi done case "$size" in error) echo " cannot compute it." >&4 dflt=1 rp="What is the size of a character (in bytes)?" . ./myread charsize="$ans" ;; *) case "$size" in 1) s='';; *) s='s';; esac echo " $size byte$s." >&4 charsize=$size ;; esac $rm_try metaconfig-debian-perl-5.26.1/dist/U/contains.U000066400000000000000000000026421316016665300212270ustar00rootroot00000000000000?RCS: $Id: contains.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: contains.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:35 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:contains: Nothing ?MAKE: -pick add $@ %< ?S:contains: ?S: This variable holds the command to do a grep with a proper return ?S: status. On most sane systems it is simply "grep". On insane systems ?S: it is a grep followed by a cat followed by a test. This variable ?S: is primarily for the use of other Configure units. ?S:. : Some greps do not return status, grrr. echo "grimblepritz" >grimble if grep blurfldyick grimble >/dev/null 2>&1 ; then contains=contains elif grep grimblepritz grimble >/dev/null 2>&1 ; then contains=grep else contains=contains fi rm -f grimble : the following should work in any shell case "$contains" in contains*) echo " " echo "AGH! Grep doesn't return a status. Attempting remedial action." cat >contains <<'EOSS' grep "$1" "$2" >.greptmp && cat .greptmp && test -s .greptmp EOSS chmod +x contains esac metaconfig-debian-perl-5.26.1/dist/U/cpp_stuff.U000066400000000000000000000122601316016665300213770ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cpp_stuff.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:30:48 ram ?RCS: patch61: added cute quoting trick for wild stringify support ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:08:24 ram ?RCS: patch36: now uses cppstdin instead of plain cpp for consistency (ADO) ?RCS: patch36: remove temporary files when done ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:36 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:cpp_stuff cpp_quote: cat contains cppstdin cppflags cppminus rm Warn \ package ?MAKE: -pick add $@ %< ?S:cpp_stuff: ?S: This variable contains an identification of the catenation mechanism ?S: used by the C preprocessor. ?S:. ?S:cpp_quote: ?S: This variable is set to either '"' or '' depending on whether the ?S: pre-processor pre-dates ANSI or not. It is used in the production of ?S: the SQuoTe() and EQuoTe() macros, and was introduced to overcome a bug ?S: in gcc 3.x whereby the pre-processor complained loudly about the ?S: unterminated strings. ?S:. ?C:CAT2: ?C: This macro catenates 2 tokens together. ?C:. ?C:CAT3: ?C: This macro catenates 3 tokens together. ?C:. ?C:CAT4: ?C: This macro catenates 4 tokens together. ?C:. ?C:CAT5: ?C: This macro catenates 5 tokens together. ?C:. ?C:STRINGIFY: ?C: This macro surrounds its token with double quotes. ?C:. ?C:SCAT2: ?C: This macro catenates 2 tokens together and stringifies the result. ?C:. ?C:SCAT3: ?C: This macro catenates 3 tokens together and stringifies the result. ?C:. ?C:SCAT4: ?C: This macro catenates 4 tokens together and stringifies the result. ?C:. ?C:SCAT5: ?C: This macro catenates 5 tokens together and stringifies the result. ?C:. ?H:?%<:#if $cpp_stuff == 1 ?H:?CAT2:#define CAT2(a,b)a/**/b ?H:?CAT3:#define CAT3(a,b,c)a/**/b/**/c ?H:?CAT4:#define CAT4(a,b,c,d)a/**/b/**/c/**/d ?H:?CAT5:#define CAT5(a,b,c,d,e)a/**/b/**/c/**/d/**/e ?H:?STRINGIFY:#define STRINGIFY(a)"a" ?H:?%<:#define SQuoTe(a)${cpp_quote}a ?H:?%<:#define EQuoTe(a)a${cpp_quote} ?H:?SCAT2:#define SCAT2(a,b)EQuoTe(SQuoTe(a)b) ?H:?SCAT3:#define SCAT3(a,b,c)EQuoTe(SQuoTe(a)b/**/c) ?H:?SCAT4:#define SCAT4(a,b,c,d)EQuoTe(SQuoTe(a)b/**/c/**/d) ?H:?SCAT5:#define SCAT5(a,b,c,d,e)EQuoTe(SQuoTe(a)b/**/c/**/d/**/e) ?H:?%<:#endif ?H:?%<:#if $cpp_stuff == 42 ?X: The additional level of indirection enables these macros to be ?X: used as arguments to other macros. See K&R 2nd ed., page 231. ?H:?%<:#define CaTiFy(a,b) a ## b ?H:?%<:#define CAT2(a,b) CaTiFy(a,b) ?H:?CAT3:#define CAT3(a,b,c) CAT2(CaTiFy(a,b),c) ?H:?CAT4:#define CAT4(a,b,c,d) CAT2(CaTiFy(a,b), CaTiFy(c,d)) ?H:?CAT5:#define CAT5(a,b,c,d,e) CAT2(CAT2(CaTiFy(a,b), CaTiFy(c,d)), e) ?H:?%<:#define StGiFy(a)# a ?H:?STRINGIFY:#define STRINGIFY(a)StGiFy(a) ?H:?SCAT2:#define SCAT2(a,b)StGiFy(a) StGiFy(b) ?H:?SCAT3:#define SCAT3(a,b,c)StGiFy(a) StGiFy(b) StGiFy(c) ?H:?SCAT4:#define SCAT4(a,b,c,d)StGiFy(a) StGiFy(b) StGiFy(c) StGiFy(d) ?H:?SCAT5:#define SCAT5(a,b,c,d,e)StGiFy(a) StGiFy(b) StGiFy(c) StGiFy(d) StGiFy(e) ?H:?%<:#endif ?H:?%<:#if $cpp_stuff != 1 && $cpp_stuff != 42 ?H:?%<:#include "Bletch: How does this C preprocessor catenate tokens?" ?H:?%<:#endif ?H:. ?W:%<:CAT2 CAT3 CAT4 CAT5 STRINGIFY SCAT2 SCAT3 SCAT4 SCAT5 ?F:!cpp_stuff.c ?LINT:known StGiFy EQuoTe SQuoTe CaTiFy : how do we catenate cpp tokens here? echo " " echo "Checking to see how your cpp does stuff like catenate tokens..." >&4 cpp_quote='' $cat >cpp_stuff.c <<'EOCP' #define RCAT(a,b)a/**/b #define ACAT(a,b)a ## b RCAT(Rei,ser) ACAT(Cir,cus) EOCP $cppstdin $cppflags $cppminus cpp_stuff.out 2>&1 if $contains 'Circus' cpp_stuff.out >/dev/null 2>&1; then echo "Oh! Smells like ANSI's been here." echo "We can catify or stringify, separately or together!" cpp_stuff=42 elif $contains 'Reiser' cpp_stuff.out >/dev/null 2>&1; then echo "Ah, yes! The good old days!" cpp_stuff=1 $cat >cpp_stuff.c <<'EOCP' #define SQuoTe(a)"a #define EQuoTe(a)a" #define CAT2(a,b)EQuoTe(SQuoTe(a)b) CAT2(Vic,tory) EOCP $cppstdin $cppflags $cppminus cpp_stuff.out 2>&1 if $contains '"Victory"' cpp_stuff.out >/dev/null 2>&1; then echo "I'll resort to a cute trick to also be able to stringify." cpp_quote='"' else $cat <&4 $cat >foo.c <<'EOF' #define A(x) x #define B(y) y A(a)B(b) EOF if $cpp foo.c >foo.cpp; $contains ab foo.cpp >/dev/null 2>&1; then echo "Plain '$cpp' works just fine." cpp_trad="$cpp" elif $cpp -traditional foo.c >foo.cpp; \ $contains ab foo.cpp >/dev/null 2>&1; then echo "We'll use '$cpp -traditional' to get proper semantics." cpp_trad="$cpp -traditional" else echo "I don't know how to get traditional semantics with '$cpp'." >&4 cpp_trad="$cpp" fi $rm -f foo.c foo.cpp metaconfig-debian-perl-5.26.1/dist/U/cppfilecom.U000066400000000000000000000145701316016665300215350ustar00rootroot00000000000000?RCS: $Id: cppfilecom.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Orginal Author: Graham Stoney ?RCS: ?RCS: $Log: cppfilecom.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:37 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:cppfilecom cppstdinflags d_cppignhdrs d_cppcanstdin: \ contains package test Myread Oldconfig Loc Setvar cpp cc cat rm ?MAKE: -pick add $@ %< ?S:cppfilecom: ?S: This variable contains the first part of the string which will invoke ?S: the C preprocessor a file and produce to standard output, preserving ?S: comments. Typical value of "cc -E -C" or "/lib/cpp -C". ?S:. ?S:cppstdinflags: ?S: This variable contains any flags necessary to get cppfilecom to read ?S: from the standard input. ?S:. ?S:d_cppignhdrs: ?S: This symbol conditionally defines CPP_IGN_HDRS if CPP_FILE_COM ignores ?S: *.h files. ?S:. ?S:d_cppcanstdin: ?S: This symbol conditionally defines CPP_CAN_STDIN if CPP_FILE_COM can ?S: read standard input directly. ?S:. ?C:CPP_FILE_COM (CPPFILECOM): ?C: This symbol contains the first part of the string which will invoke ?C: the C preprocessor a file and produce to standard output, preserving ?C: comments. Typical value of "cc -E -C" or "/lib/cpp -C". ?C:. ?C:CPP_STDIN_FLAGS (CPPSTDINFLAGS): ?C: This variable contains any flags necessary to get CPP_FILE_COM to ?C: read from the standard input. ?C:. ?C:CPP_IGN_HDRS (CPPIGNHDRS): ?C: This symbol is defined if CPP_FILE_COM ignores *.h files. ?C:. ?C:CPP_CAN_STDIN (CPPCANSTDIN): ?C: This symbol is defined if CPP_FILE_COM can read standard input ?C: directly. ?C:. ?H:#define CPP_FILE_COM "$cppfilecom" ?H:#define CPP_STDIN_FLAGS "$cppstdinflags" ?H:#$d_cppignhdrs CPP_IGN_HDRS /* does CPP ignore .h files? */ ?H:#$d_cppcanstdin CPP_CAN_STDIN /* can CPP read stdin directly? */ ?H:. ?T:cont ?F:!testcpp.c !testcpp.h !testcpp.out ?LINT:set d_cppcanstdin d_cppignhdrs ?LINT:usefile testcpp.c testcpp.out : see how we invoke the C preprocessor $cat <testcpp.c #define ABC abc #define XYZ xyz ABC.XYZ /* comment */ EOT : if $test "X$cppfilecom" != "X" && \ $cppfilecom testcpp.c testcpp.out 2>/dev/null && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "You used to use $cppfilecom so we'll use that again." elif echo 'Maybe "'$cc' -E -C" will work...' && \ $cc -E -C testcpp.c testcpp.out 2>/dev/null && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "It works!" cppfilecom="$cc -E -C" elif echo 'Nope...maybe "'"$cc"' -P -C" will work...' && \ $cc -P -C testcpp.c testcpp.out 2>/dev/null && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Yup, that does." cppfilecom="$cc -P -C" elif echo 'No such luck, maybe "'"$cpp"' -C" will work...' && \ $cpp -C testcpp.c testcpp.out 2>/dev/null && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Yup, it does." cppfilecom="$cpp -C" else cppfilecom='' $cat <<'EOM' I can't find a C preprocessor that will preserve comments. Please name one. EOM fi : dflt="$cppfilecom" cont=true while $test "$cont" ; do echo " " rp="How should $package run your preprocessor preserving comments?" . ./myread cppfilecom="$ans" $cppfilecom testcpp.c >testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "OK, that will do." cont='' else echo "Sorry, I can't get that to work." fi done @if CPP_IGN_HDRS || d_cppignhdrs : Now see if it ignores header files. cp testcpp.c testcpp.h $cppfilecom testcpp.h >testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Terrific; it processes .h files passed on the command line too." val="$undef" else echo "It ignores .h files on the command line; pity." val="$define" fi set d_cppignhdrs eval $setvar @end @if CPP_STDIN_FLAGS || CPP_CAN_STDIN || cppstdinflags || d_cppcanstdin : Now see how to send stdin to it. echo " " cp testcpp.c testcpp.h $cppfilecom testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Great; and it will read stdin if passed no arguments." val="$define" cppstdinflags='' else $cppfilecom - testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Great; and it can read stdin by passing it '-'." val="$define" cppstdinflags='-' else $cat <testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 && \ $contains comment testcpp.out >/dev/null 2>&1 then echo "Good; that works fine." val="$define" cppstdinflags="$ans" else echo "Sorry, I couldn't get that to work." fi fi done fi fi set d_cppcanstdin eval $setvar @end : cleanup cpp test files anyway $rm -f testcpp.* metaconfig-debian-perl-5.26.1/dist/U/cppstdin.U000066400000000000000000000200331316016665300212270ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: cppstdin.U,v $ ?RCS: Revision 3.0.1.4 1994/10/29 16:08:34 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0.1.3 1994/01/24 14:05:38 ram ?RCS: patch16: comment for CPPLAST was missing ?RCS: ?RCS: Revision 3.0.1.2 1993/12/15 08:18:58 ram ?RCS: patch15: new variables cpprun and cpplast, guaranteed wrapper-free ?RCS: patch15: cppstdin now tries to use cc, even at the cost of a wrapper ?RCS: ?RCS: Revision 3.0.1.1 1993/08/25 14:00:53 ram ?RCS: patch6: remove wrapper when not actually used ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:38 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:cppstdin cppminus cpprun cpplast: contains test Myread Oldconfig Loc \ cpp +cc rm hint osname gccversion startsh eunicefix ?MAKE: -pick add $@ %< ?S:cppstdin: ?S: This variable contains the command which will invoke the C ?S: preprocessor on standard input and put the output to stdout. ?S: It is primarily used by other Configure units that ask about ?S: preprocessor symbols. ?S:. ?S:cppminus: ?S: This variable contains the second part of the string which will invoke ?S: the C preprocessor on the standard input and produce to standard ?S: output. This variable will have the value "-" if cppstdin needs ?S: a minus to specify standard input, otherwise the value is "". ?S:. ?S:cpprun: ?S: This variable contains the command which will invoke a C preprocessor ?S: on standard input and put the output to stdout. It is guaranteed not ?S: to be a wrapper and may be a null string if no preprocessor can be ?S: made directly available. This preprocessor might be different from the ?S: one used by the C compiler. Don't forget to append cpplast after the ?S: preprocessor options. ?S:. ?S:cpplast: ?S: This variable has the same functionality as cppminus, only it applies to ?S: cpprun and not cppstdin. ?S:. ?C:CPPSTDIN: ?C: This symbol contains the first part of the string which will invoke ?C: the C preprocessor on the standard input and produce to standard ?C: output. Typical value of "cc -E" or "/lib/cpp", but it can also ?C: call a wrapper. See CPPRUN. ?C:. ?C:CPPMINUS: ?C: This symbol contains the second part of the string which will invoke ?C: the C preprocessor on the standard input and produce to standard ?C: output. This symbol will have the value "-" if CPPSTDIN needs a minus ?C: to specify standard input, otherwise the value is "". ?C:. ?C:CPPRUN: ?C: This symbol contains the string which will invoke a C preprocessor on ?C: the standard input and produce to standard output. It needs to end ?C: with CPPLAST, after all other preprocessor flags have been specified. ?C: The main difference with CPPSTDIN is that this program will never be a ?C: pointer to a shell wrapper, i.e. it will be empty if no preprocessor is ?C: available directly to the user. Note that it may well be different from ?C: the preprocessor used to compile the C program. ?C:. ?C:CPPLAST: ?C: This symbol is intended to be used along with CPPRUN in the same manner ?C: symbol CPPMINUS is used with CPPSTDIN. It contains either "-" or "". ?C:. ?H:#define CPPSTDIN "$cppstdin" ?H:#define CPPMINUS "$cppminus" ?H:#define CPPRUN "$cpprun" ?H:#define CPPLAST "$cpplast" ?H:. ?F:cppstdin !testcpp.out !testcpp.c ?T:wrapper x_cpp x_minus ok : see how we invoke the C preprocessor echo " " echo "Now, how can we feed standard input to your C preprocessor..." >&4 cat <<'EOT' >testcpp.c #define ABC abc #define XYZ xyz ABC.XYZ EOT cd .. if $test ! -f cppstdin; then echo "$startsh" >cppstdin if $test "X$osname" = "Xaix" -a "X$gccversion" = X; then ?X: AIX cc -E doesn't show the absolute headerfile ?X: locations but we'll cheat by using the -M flag. echo 'cat >.$$.c; rm -f .$$.u; '"$cc"' ${1+"$@"} -M -c .$$.c 2>/dev/null; \ test -s .$$.u && \ awk '"'"'$2 ~ /\.h$/ { print "# 0 \""$2"\"" }'"'"' .$$.u; \ rm -f .$$.o .$$.u; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >> cppstdin else echo 'cat >.$$.c; '"$cc"' -E ${1+"$@"} .$$.c; rm .$$.c' >>cppstdin fi; else echo "Keeping your $hint cppstdin wrapper." fi chmod 755 cppstdin $eunicefix cppstdin wrapper=`pwd`/cppstdin ok='false' cd UU ?X: ?X: We'll run the cpp tests again if we don't have any valid C preprocessor ?X: yet or don't know how to proceed without a wrapper (in which case cpprun ?X: is empty and that's really annoying...) ?X: if $test "X$cppstdin" != "X" && \ $cppstdin $cppminus testcpp.out 2>&1 && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "You used to use $cppstdin $cppminus so we'll use that again." case "$cpprun" in '') echo "But let's see if we can live without a wrapper..." ;; *) if $cpprun $cpplast testcpp.out 2>&1 && \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "(And we'll use $cpprun $cpplast to preprocess directly.)" ok='true' else echo "(However, $cpprun $cpplast does not work, let's see...)" fi ;; esac else case "$cppstdin" in '') ;; *) echo "Good old $cppstdin $cppminus does not seem to be of any help..." ;; esac fi if $ok; then : nothing elif echo 'Maybe "'"$cc"' -E" will work...'; \ $cc -E testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yup, it does." x_cpp="$cc -E" x_minus=''; elif echo 'Nope...maybe "'"$cc"' -E -" will work...'; \ $cc -E - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yup, it does." x_cpp="$cc -E" x_minus='-'; elif echo 'Nope...maybe "'"$cc"' -P" will work...'; \ $cc -P testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Yipee, that works!" x_cpp="$cc -P" x_minus=''; elif echo 'Nope...maybe "'"$cc"' -P -" will work...'; \ $cc -P - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "At long last!" x_cpp="$cc -P" x_minus='-'; elif echo 'No such luck, maybe "'$cpp'" will work...'; \ $cpp testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "It works!" x_cpp="$cpp" x_minus=''; elif echo 'Nixed again...maybe "'$cpp' -" will work...'; \ $cpp - testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "Hooray, it works! I was beginning to wonder." x_cpp="$cpp" x_minus='-'; elif echo 'Uh-uh. Time to get fancy. Trying a wrapper...'; \ $wrapper testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then x_cpp="$wrapper" x_minus='' echo "Eureka!" else dflt='' rp="No dice. I can't find a C preprocessor. Name one:" . ./myread x_cpp="$ans" x_minus='' $x_cpp testcpp.out 2>&1 if $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 ; then echo "OK, that will do." >&4 else echo "Sorry, I can't get that to work. Go find one and rerun Configure." >&4 exit 1 fi fi case "$ok" in false) cppstdin="$x_cpp" cppminus="$x_minus" cpprun="$x_cpp" cpplast="$x_minus" ?X: ?X: If /lib/cpp is used, try using a wrapper to increase our chances to have ?X: the C compiler and our $cppstdin agree on the same symbols... However, ?X: since cpprun is guaranteed not to be a wrapper, we must clear it if the ?X: only preprocessor we found was a wrapper, with all our luck... ?X: set X $x_cpp shift case "$1" in "$cpp") echo "Perhaps can we force $cc -E using a wrapper..." if $wrapper testcpp.out 2>&1; \ $contains 'abc.*xyz' testcpp.out >/dev/null 2>&1 then echo "Yup, we can." cppstdin="$wrapper" cppminus=''; else echo "Nope, we'll have to live without it..." fi ;; esac case "$cpprun" in "$wrapper") cpprun='' cpplast='' ;; esac ;; esac case "$cppstdin" in "$wrapper"|'cppstdin') ;; *) $rm -f $wrapper;; esac $rm -f testcpp.c testcpp.out metaconfig-debian-perl-5.26.1/dist/U/d_NOFILE.U000066400000000000000000000114501316016665300206650ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_NOFILE.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:08:38 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:39 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:nofile d_gettblsz tablesize: Myread Guess cat +cc +ccflags +libs \ test rm Csym ?MAKE: -pick add $@ %< ?S:nofile: ?S: This variable contains the number of file descriptors available to the ?S: process. ?S:. ?S:d_gettblsz: ?S: This variable conditionally handles remapping of the getdtablesize() ?S: subroutine to ulimit(4,0), or the NOFILE manifest constant. ?S:. ?S:tablesize: ?S: This variable contains either the 'NOFILE' constant or 'ulimit(4, 0L)' ?S: and is used as the remapped value for the getdtablesize() macro. ?S:. ?C:getdtablesize: ?C: This catches use of the getdtablesize() subroutine, and remaps it ?C: to either ulimit(4,0) or NOFILE, if getdtablesize() isn't available. ?C:. ?C:VAL_NOFILE: ?C: This symbol contains the number of file descriptors available to the ?C: process, as determined at configuration time. Unless a static constant ?C: is needed, you should rely on getdtablesize() to obtain that number. ?C:. ?H:#$d_gettblsz getdtablesize() $tablesize /**/ ?H:#define VAL_NOFILE $nofile /* Number of file descriptors */ ?H:. ?F:!nofile ?T:d_ulimit4 val : see if getdtablesize exists echo " " ?X: Revert logical value (d_gettblsz is undef iff getdtablesize is present) case "$d_gettblsz" in $define) d_gettblsz="$undef";; $undef) d_gettblsz="$define";; esac if set getdtablesize val -f d_gettblsz; eval $csym; $val; then echo 'getdtablesize() found.' >&4 d_gettblsz="$undef" tablesize='' @if VAL_NOFILE || nofile $cat >nofile.c <<'EOCP' #include int main() { printf("%d\n", getdtablesize()); } EOCP nofile='' if $cc $ccflags -o nofile nofile.c $libs >/dev/null 2>&1; then nofile=`./nofile 2>/dev/null` fi if $test "$nofile"; then echo "(You have $nofile file descriptors available per process.)" else nofile='20' if ./bsd; then nofile='64' fi echo "(Hmm... Let's say you have $nofile file descriptors available.)" fi @end else echo 'getdtablesize() NOT found...' >&4 if set ulimit val -f; eval $csym; $val; then echo 'Maybe ulimit(4,0) will work...' $cat >nofile.c <<'EOCP' #include #ifdef GETPARAM_H #include #endif int main() { printf("%d %d\n", #ifdef NOFILE NOFILE, #else 0, #endif ulimit(4,0)); exit(0); } EOCP if $cc $ccflags -DGETPARAM_H -o nofile nofile.c $libs >/dev/null 2>&1 \ || $cc $ccflags -o nofile nofile.c $libs >/dev/null 2>&1 ; then set `./nofile` d_gettblsz=$1 d_ulimit4=$2 if $test "$d_ulimit4" -lt 0; then echo "Your ulimit() call doesn't tell me what I want to know." echo "We'll just use NOFILE in this case." nofile=$d_gettblsz d_gettblsz="$define" tablesize='NOFILE' else if $test "$d_gettblsz" -gt 0; then echo "Your system defines NOFILE to be $d_gettblsz, and" >&4 else echo "I had trouble getting NOFILE from your system, but" >&4 fi echo "ulimit returns $d_ulimit4 as the number of available file descriptors." >&4 dflt='y'; echo " " rp='Should I use ulimit to get the number of available file descriptors?' . ./myread case "$ans" in y*) nofile=$d_ulimit4 d_gettblsz="$define" tablesize='ulimit(4, 0L)' echo "Using ulimit(4,0)." ;; *) nofile=$d_gettblsz d_gettblsz="$define" tablesize='NOFILE' echo "Using NOFILE." ;; esac fi else echo "Strange, I couldn't get my test program to compile." echo "We'll just use NOFILE in this case." d_gettblsz="$define" tablesize='NOFILE' nofile='' fi else echo 'Using NOFILE instead.' d_gettblsz="$define" tablesize='NOFILE' nofile='' fi fi @if VAL_NOFILE || nofile case "$nofile" in '') $cat >nofile.c <<'EOCP' #include #ifdef GETPARAM_H #include #endif int main() { printf("%d\n", #ifdef NOFILE NOFILE, #else 0, #endif ); exit(0); } EOCP if $cc $ccflags -DGETPARAM_H -o nofile nofile.c $libs >/dev/null 2>&1 \ || $cc $ccflags -o nofile nofile.c $libs >/dev/null 2>&1 ; then nofile=`./nofile 2>/dev/null` fi if $test "$nofile"; then echo "(You have $nofile file descriptors available per process.)" else nofile='20' if ./bsd; then nofile='64' fi echo "(Hmm... Let's say you have $nofile file descriptors available.)" fi ;; esac @end $rm -f nofile* metaconfig-debian-perl-5.26.1/dist/U/d_NeWS.U000066400000000000000000000053521316016665300205310ustar00rootroot00000000000000?RCS: $Id: d_NeWS.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_NeWS.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:39 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_news d_news0 d_newshome d_textcan: test rm Myread Getfile ?MAKE: -pick add $@ %< ?S:d_news: ?S: Set if running NeWS 1.1 ?S:. ?S:d_news0: ?S: Set if running NeWS 1.0 ?S:. ?S:d_newshome: ?S: Path to the top directory of the NeWS structure. ?S:. ?S:d_textcan: ?S: Path to where the textcan.ps stuff is... ?S:. ?C:HAS_NEWS1_1 (NEWS1_1): ?C: This symbol defined if running NeWS 1.1. ?C:. ?C:HAS_NEWS1_0 (NEWS1_0): ?C: This symbol defined if running NeWS 1.0. ?C:. ?C:TEXTCAN: ?C: Tells path to where the textcan.ps stuff is... ?C:. ?H:#$d_news HAS_NEWS1_1 /**/ ?H:#$d_news0 HAS_NEWS1_0 /**/ ?H:#define TEXTCAN $d_textcan /**/ ?H:. ?INIT:: default path for NeWS ?INIT:d_newshome="/usr/NeWS" ?INIT: : Check to see what version of NeWS is being run? cd .. echo " " echo "Now for the interesting stuff... Lets see what kind of NeWS" echo "they grow round here...." echo " " dflt='y' if $test -d $d_newshome; then d_newshome=`(cd $d_newshome ; /bin/pwd)` echo "Ah...found myself a NeWS in $d_newshome..." dflt='y' rp="Is this the NeWS you want your children to grow up with?" . UU/myread fi while $test $ans = "n"; do dflt=$d_newshome fn=d rp="Path to NeWS you want:" . UU/getfile d_newshome=$ans echo " " if $test ! -d $d_newshome/lib; then echo "ARG! No lib directory in $d_newshome!!!" : heavy medicine. I wonder what the disease is... $rm -f kit*isdone $rm -rf UU : bye bye set -t; echo "Sorry... no NeWS is bad news..." fi if $test -r $d_newshome/lib/NeWS/colors.ps ; then echo 'Ahh... your running NeWS 1.1! Boy... that makes stuff easy....' echo " " d_news="$define" d_news0="$undef" if $test -r $d_newshome/lib/NeWS/textcan.ps; then d_textcan=$d_newshome/lib/NeWS echo "The textcan.ps stuff seems to be in : $d_textcan" else d_textcan=$d_newshome/clientsrc/client/nterm if $test ! -r $d_textcan/textcan.ps; then d_news="$undef" d_news0="$define" echo 'Hmm... must have been fooled... gotta be NeWS 1.1 beta!' else echo "The textcan.ps stuff seems to be in : $d_textcan" fi fi else echo 'snif... snif... I smell the dilapidated smell of NeWS 1.0..' echo 'Some things will not work under NeWS 1.0...' d_news="$undef" d_news0="$define" fi cd UU metaconfig-debian-perl-5.26.1/dist/U/d_PORTAR.U000066400000000000000000000040171316016665300207210ustar00rootroot00000000000000?RCS: $Id: d_PORTAR.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_PORTAR.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:08:42 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:40 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_PORTAR: cat +cc rm Setvar ?MAKE: -pick add $@ %< ?S:d_PORTAR: ?S: This variable conditionally handles definition of PORTAR, ?S: a creation of greater minds than I can imagine. ?S:. ?C:PORTAR: ?C: This manifest constant must be defined to 1 for some implementations ?C: of ar.h to get the portable ar most everybody uses. ?C:. ?L:ar_fmag: ?L:ARFMAG: ?L:SARMAG: ?H:#$d_PORTAR PORTAR 1 /**/ ?H:. ?F:!portar ?LINT:set d_PORTAR : see if we need to define PORTAR echo " " echo 'Checking to see if we need to define PORTAR for portable archives...' >&4 $cat >portar.c <<'EOCP' #include int main() { char *arfmag = ARFMAG; int sarmag = SARMAG; struct ar_hdr arh; strncpy(arh.ar_fmag, arfmag, 2); #ifdef PORTAR printf("D\n"); #else printf("U\n"); #endif exit(0);} EOCP if $cc -o portar portar.c >/dev/null 2>&1 || \ $cc -DPORTAR=1 -o portar portar.c >/dev/null 2>&1 ; then case "`./portar`" in D) val="$define" echo "We'll be defining PORTAR for you." ;; U) val="$undef" echo "We don't seem to need PORTAR defined here." ;; *) val="$define" echo "(My test program gave me an unexpected value!)" echo "I'll just define PORTAR to be sure." ;; esac else echo "(Strange, I couldn't get my test program to compile.)" echo "We'll just define PORTAR in this case." val="$define" fi set d_PORTAR eval $setvar $rm -f portar* metaconfig-debian-perl-5.26.1/dist/U/d_SHM_MAC.U000066400000000000000000000074401316016665300210240ustar00rootroot00000000000000?RCS: $Id: d_SHM_MAC.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_SHM_MAC.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:41 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_SHM_MAC d_SHM_PRM d_SHM_SEG d_SHM_IMMU: cat d_shm test rm +cc +ccflags ?MAKE: -pick add $@ %< ?S:d_SHM_MAC: ?S: Sometimes, the SHMLBA manifest needs sys/sysmacros.h, usually for ?S: the ctob() macro. ?S:. ?S:d_SHM_PRM: ?S: Sometimes, the SHMLBA manifest needs sys/param.h, usually for the ?S: NBPC constant. ?S:. ?S:d_SHM_SEG: ?S: Sometimes, the SHMLBA manifest needs sys/seg.h, usually for the ?S: SNUMSHFT constant. ?S:. ?S:d_SHM_IMMU: ?S: Sometimes, the SHMLBA manifest needs sys/immu.h, usually for the ?S: stob() macro. ?S:. ?C:SHMLBA_WANTS_SYSMACROS: ?C: This value tells us to include because SHMLBA ?C: needs something from there, probably the ctob() macro. ?C:. ?C:SHMLBA_WANTS_PARAM: ?C: This value tells us to include because SHMLBA needs ?C: something from there, probably the NBPC constant. ?C:. ?C:SHMLBA_WANTS_SEG: ?C: This value tells us to include because SHMLBA needs ?C: something from there, probably the SNUMSHFT constant. ?C:. ?C:SHMLBA_WANTS_IMMU: ?C: This value tells us to include because SHMLBA needs ?C: something from there, probably the stob() macro. (tower_600 only?) ?C:. ?H:#$d_SHM_MAC SHMLBA_WANTS_SYSMACROS /* SHMLBA wants ctob()? */ ?H:#$d_SHM_PRM SHMLBA_WANTS_PARAM /* SHMLBA wants NBPC? */ ?H:#$d_SHM_SEG SHMLBA_WANTS_SEG /* SHMLBA wants SNUMSHFT? */ ?H:#$d_SHM_IMMU SHMLBA_WANTS_IMMU /* SHMLBA wants stob()? */ ?H:. ?T:flags D_sys_immu D_sys_seg D_sys_sysmacros D_sys_param : check for SHMLBA braindamage d_SHM_MAC="$undef" d_SHM_PRM="$undef" d_SHM_SEG="$undef" d_SHM_IMMU="$undef" if $test "$d_shm" = "$define" ; then echo " " $cat >&4 <shm_mac.c <<'EOCP' #include #include #include #ifdef I_SYS_IMMU #include #endif #ifdef I_SYS_SYSMACROS #include #endif #ifdef I_SYS_PARAM #include #endif #ifdef I_SYS_SEG #include #endif int main() { int foo = SHMLBA ; } EOCP flags='xxx' for D_sys_immu in '' '-DI_SYS_IMMU'; do for D_sys_seg in '' '-DI_SYS_SEG'; do for D_sys_sysmacros in '' '-DI_SYS_SYSMACROS'; do for D_sys_param in '' '-DI_SYS_PARAM'; do case "$flags" in 'xxx') case "$D_sys_immu$D_sys_param$D_sys_sysmacros$D_sys_seg" in '') echo "Trying it normally..." ;; *) echo "Trying $D_sys_immu $D_sys_param $D_sys_sysmacros $D_sys_seg" ;; esac if $cc $ccflags \ $D_sys_immu $D_sys_param $D_sys_sysmacros $D_sys_seg \ -o shm_mac shm_mac.c >/dev/null 2>&1 ; then set X $D_sys_immu $D_sys_param $D_sys_sysmacros $D_sys_seg shift flags="$*" echo "Succeeded with $flags" fi ;; esac done done done done case "$flags" in xxx) echo "I don't know how to keep SHMLBA happy. Good luck!" ;; esac case "$flags" in *I_SYS_PARAM*) d_SHM_PRM="$define";; esac case "$flags" in *I_SYS_SYSMACROS*) d_SHM_MAC="$define";; esac case "$flags" in *I_SYS_SEG*) d_SHM_SEG="$define";; esac case "$flags" in *I_SYS_IMMU*) d_SHM_IMMU="$define";; esac fi $rm -f shm_mac* metaconfig-debian-perl-5.26.1/dist/U/d_access.U000066400000000000000000000042061316016665300211530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_access.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:42 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_access: test +cc cat +cppflags h_fcntl h_sysfile rm Inlibc Findhdr ?MAKE: -pick add $@ %< ?S:d_access: ?S: This variable conditionally defines HAS_ACCESS if the access() system ?S: call is available to check for access permissions using real IDs. ?S:. ?C:HAS_ACCESS: ?C: This manifest constant lets the C program know that the access() ?C: system call is available to check for accessibility using real UID/GID. ?C: (always present on UNIX.) ?C:. ?H:#$d_access HAS_ACCESS /**/ ?H:. ?W:%<:R_OK W_OK X_OK F_OK ?LINT:set d_access ?LINT:change h_fcntl h_sysfile : access call always available on UNIX set access d_access eval $inlibc : locate the flags for 'access()' case "$d_access" in "$define") echo " " $cat >access.c <<'EOCP' #include #ifdef I_FCNTL #include #endif #ifdef I_SYS_FILE #include #endif #ifdef I_UNISTD #include #endif int main() { exit(R_OK); } EOCP : check sys/file.h first, no particular reason here if $test `./findhdr sys/file.h` && \ $cc -o access $cppflags -DI_SYS_FILE access.c >/dev/null 2>&1 ; then h_sysfile=true; echo " defines the *_OK access constants." >&4 elif $test `./findhdr fcntl.h` && \ $cc -o access $cppflags -DI_FCNTL access.c >/dev/null 2>&1 ; then h_fcntl=true; echo " defines the *_OK access constants." >&4 @if I_UNISTD elif $test `./findhdr unistd.h` && \ $cc -o access $cppflags -DI_UNISTD access.c >/dev/null 2>&1 ; then echo " defines the *_OK access constants." >&4 @end else echo "I can't find the four *_OK access constants--I'll use mine." >&4 fi ;; esac $rm -f access* metaconfig-debian-perl-5.26.1/dist/U/d_alarm.U000066400000000000000000000020421316016665300210020ustar00rootroot00000000000000?RCS: $Id: d_alarm.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_alarm.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:06:58 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_alarm: Inlibc ?MAKE: -pick add $@ %< ?S:d_alarm: ?S: This variable conditionally defines the HAS_ALARM symbol, which ?S: indicates to the C program that the alarm() routine is available. ?S:. ?C:HAS_ALARM : ?C: This symbol, if defined, indicates that the alarm routine is ?C: available. ?C:. ?H:#$d_alarm HAS_ALARM /**/ ?H:. ?LINT:set d_alarm : see if alarm exists set alarm d_alarm eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_attribut.U000066400000000000000000000041411316016665300215460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_attribut.U,v $ ?RCS: Revision 3.0.1.3 1995/01/30 14:33:45 ram ?RCS: patch49: test C program now includes (WED) ?RCS: ?RCS: Revision 3.0.1.2 1995/01/11 15:25:47 ram ?RCS: patch45: fixed typo in the d_attribut variable (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:08:55 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_attribut: Myread Oldconfig cat cc ccflags rm Setvar contains ?MAKE: -pick add $@ %< ?S:d_attribut (d_attrib): ?S: This variable conditionally defines HASATTRIBUTE, which ?S: indicates the C compiler can check for function attributes, ?S: such as printf formats. ?S:. ?C:HASATTRIBUTE ~ %< (GNUC_ATTRIBUTE_CHECK): ?C: This symbol indicates the C compiler can check for function attributes, ?C: such as printf formats. This is normally only supported by GNU cc. ?C:. ?H:?%<:#$d_attribut HASATTRIBUTE /**/ ?H:?%<:#ifndef HASATTRIBUTE ?H:?%<:#define __attribute__(_arg_) ?H:?%<:#endif ?H:. ?W:%<:__attribute__ ?LINT:set d_attribut ?LINT:known __attribute__ : Look for GNU-cc style attribute checking echo " " echo "Checking whether your compiler can handle __attribute__ ..." >&4 $cat >attrib.c <<'EOCP' #include void croak (char* pat,...) __attribute__((format(printf,1,2),noreturn)); EOCP if $cc $ccflags -c attrib.c >attrib.out 2>&1 ; then if $contains 'warning' attrib.out >/dev/null 2>&1; then echo "Your C compiler doesn't fully support __attribute__." val="$undef" else echo "Your C compiler supports __attribute__." val="$define" fi else echo "Your C compiler doesn't seem to understand __attribute__ at all." val="$undef" fi set d_attribut eval $setvar $rm -f attrib* metaconfig-debian-perl-5.26.1/dist/U/d_bcmp.U000066400000000000000000000024611316016665300206340ustar00rootroot00000000000000?RCS: $Id: d_bcmp.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_bcmp.U,v $ ?RCS: Revision 3.0.1.2 1993/10/16 13:47:52 ram ?RCS: patch12: added magic support for bcmp() ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 16:00:44 ram ?RCS: patch10: now only defines HAS_BCMP, no macro remap on memcmp (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:42 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_bcmp: Inlibc ?MAKE: -pick add $@ %< ?S:d_bcmp: ?S: This variable conditionally defines the HAS_BCMP symbol if ?S: the bcmp() routine is available to compare strings. ?S:. ?C:HAS_BCMP: ?C: This symbol is defined if the bcmp() routine is available to ?C: compare blocks of memory. ?C:. ?H:#$d_bcmp HAS_BCMP /**/ ?H:. ?M:bcmp: HAS_BCMP ?M:#ifndef HAS_BCMP ?M:#ifndef bcmp ?M:#define bcmp(s,d,l) memcmp((s),(d),(l)) ?M:#endif ?M:#endif ?M:. ?LINT:set d_bcmp : see if bcmp exists set bcmp d_bcmp eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_bcopy.U000066400000000000000000000025001316016665300210210ustar00rootroot00000000000000?RCS: $Id: d_bcopy.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_bcopy.U,v $ ?RCS: Revision 3.0.1.2 1993/10/16 13:48:04 ram ?RCS: patch12: added magic support for bcopy() ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 16:01:11 ram ?RCS: patch10: now only defines HAS_BCOPY, no macro remap on memcpy (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:44 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_bcopy: Inlibc ?MAKE: -pick add $@ %< ?S:d_bcopy: ?S: This variable conditionally defines the HAS_BCOPY symbol if ?S: the bcopy() routine is available to copy strings. ?S:. ?C:HAS_BCOPY: ?C: This symbol is defined if the bcopy() routine is available to ?C: copy blocks of memory. ?C:. ?H:#$d_bcopy HAS_BCOPY /**/ ?H:. ?M:bcopy: HAS_BCOPY ?M:#ifndef HAS_BCOPY ?M:#ifndef bcopy ?M:#define bcopy(s,d,l) memcpy((d),(s),(l)) ?M:#endif ?M:#endif ?M:. ?LINT:set d_bcopy : see if bcopy exists set bcopy d_bcopy eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_brokstat.U000066400000000000000000000036771316016665300215560ustar00rootroot00000000000000?RCS: $Id: d_brokstat.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_brokstat.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:30:53 ram ?RCS: patch61: created ?RCS: ?MAKE:d_brokstat: cat contains cppstdin cppminus +cppflags rm Setvar ?MAKE: -pick add $@ %< ?S:d_brokstat: ?S: This variable conditionally defines STAT_MACROS_BROKEN if some ?S: of the S_IS*() macros from give false positive on ?S: regular files. ?S:. ?C:STAT_MACROS_BROKEN: ?C: This symbol, if defined, indicates that the S_IS*() stat macros ?C: such as S_ISBLK() give false positive and are thus unusable. ?C: Your best bet is then to supply your own set. ?C:. ?H:#$d_brokstat STAT_MACROS_BROKEN /**/ ?H:. ?F:!try.c !try ?LINT:set d_brokstat ?LINT:usefile try ?X: This test inspired by autoconf -- RAM, 28/02/97 : are stat macros sane? echo " " echo "Checking whether your stat() macros are broken..." $cat >try.c <<'EOC' #include #include #if defined(S_ISBLK) && defined(S_IFDIR) #if S_ISBLK(S_IFDIR) Broken #endif #endif #if defined(S_ISBLK) && defined(S_IFCHR) #if S_ISBLK(S_IFCHR) Broken #endif #endif #if defined(S_ISLNK) && defined(S_IFREG) #if S_ISLNK(S_IFREG) Broken. #endif #endif #if defined(S_ISSOCK) && defined(S_IFREG) #if S_ISSOCK(S_IFREG) Broken. #endif #endif EOC $cppstdin $cppflags $cppminus /dev/null >try if $contains Broken try >/dev/null 2>&1; then echo "Alas, they are. I'll use my own macro set then." >&4 val="$define" else echo "Nope, working just fine." >&4 val="$undef" fi $rm -f try try.c set d_brokstat eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_bsdjmp.U000066400000000000000000000045351316016665300211760ustar00rootroot00000000000000?RCS: $Id: d_bsdjmp.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_bsdjmp.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:31:10 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:09:09 ram ?RCS: patch36: call ./usg explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:45 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_bsdjmp: Guess Setvar cat +cc libs rm ?MAKE: -pick add $@ %< ?S:d_bsdjmp: ?S: This variable conditionally defines USE_BSDJMP if BSD _setjmp and ?S: _longjmp routines are available to do non-local gotos without saving ?S: or restoring the signal mask flag. ?S:. ?C:USE_BSDJMP (BSDJMP): ?C: This symbol, if defined, indicates that the BSD _setjmp and _longjmp ?C: routines are available to do non-local gotos wihtout saving or restoring ?C: the signal mask flag. ?C:. ?H:#$d_bsdjmp USE_BSDJMP /**/ ?H:. ?F:!set ?LINT:set d_bsdjmp : see if _setjmp and _longjmp exists ?X: We can't check for these symbols with Inlibc because of the leading "_" echo " " case "$d_bsdjmp" in '') $cat >set.c < jmp_buf env; int set = 1; int main() { if (_setjmp(env)) exit(set); set = 0; _longjmp(env, 1); exit(1); } EOP if $cc -o set set.c $libs >/dev/null 2>&1; then if ./set >/dev/null 2>&1; then echo "Good! You have BSD _setjmp and _longjmp routines." >&4 val="$define" else $cat <&4 else cat <&4;; $undef) echo "You do not have _setjmp and _longjmp, but that's fine." >&4;; esac ;; esac set d_bsdjmp eval $setvar $rm -f set.c set metaconfig-debian-perl-5.26.1/dist/U/d_byacc.U000066400000000000000000000021071316016665300207710ustar00rootroot00000000000000?RCS: $Id: d_byacc.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1996, Andy Dougherty ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_byacc.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:31:14 ram ?RCS: patch61: created ?RCS: ?MAKE:d_byacc: byacc Setvar ?MAKE: -pick add $@ %< ?S:d_byacc: ?S: This variable indicates whether byacc is available. ?S: If the user has specified 'portability', then Makefile.SH ?S: sees $byacc='byacc' whether or not the user actually has ?S: byacc. This variable allows us to determine in a makefile ?S: if we really have byacc. ?S:. ?LINT:set d_byacc : Check if we really have byacc case "$byacc" in ''|'byacc') val="$undef" ;; *) val="$define" ;; esac set d_byacc eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_bzero.U000066400000000000000000000025011316016665300210270ustar00rootroot00000000000000?RCS: $Id: d_bzero.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_bzero.U,v $ ?RCS: Revision 3.0.1.2 1993/10/16 13:48:15 ram ?RCS: patch12: added magic support for bzero() ?RCS: ?RCS: Revision 3.0.1.1 1993/09/13 16:01:33 ram ?RCS: patch10: now only defines HAS_BZERO, no macro remap on memset (WAD) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:46 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_bzero: Inlibc ?MAKE: -pick add $@ %< ?S:d_bzero: ?S: This variable conditionally defines the HAS_BZERO symbol if ?S: the bzero() routine is available to set memory to 0. ?S:. ?C:HAS_BZERO: ?C: This symbol is defined if the bzero() routine is available to ?C: set a memory block to 0. ?C:. ?H:#$d_bzero HAS_BZERO /**/ ?H:. ?M:bzero: HAS_BZERO ?M:#ifndef HAS_BZERO ?M:#ifndef bzero ?M:#define bzero(s,l) memset((s),0,(l)) ?M:#endif ?M:#endif ?M:. ?LINT:set d_bzero : see if bzero exists set bzero d_bzero eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_casti32.U000066400000000000000000000041331316016665300211610ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_casti32.U,v $ ?RCS: Revision 3.0.1.3 1995/05/12 12:10:45 ram ?RCS: patch54: made sure cc and ccflags are conditional dependencies ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:09:37 ram ?RCS: patch36: declare signal handler correctly (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:06 ram ?RCS: patch32: created by ADO ?RCS: ?X: ?X: Can the compiler cast large floats to 32-bit integers? ?X: ?MAKE:d_casti32: cat +cc +ccflags rm_try intsize Setvar test signal_t ?MAKE: -pick add $@ %< ?S:d_casti32: ?S: This variable conditionally defines CASTI32, which indicates ?S: whether the C compiler can cast large floats to 32-bit ints. ?S:. ?C:CASTI32: ?C: This symbol is defined if the C compiler can cast negative ?C: or large floating point numbers to 32-bit ints. ?C:. ?T:xxx yyy ?H:#$d_casti32 CASTI32 /**/ ?H:. ?F:!try ?LINT:set d_casti32 : check for ability to cast large floats to 32-bit ints. echo " " echo 'Checking whether your C compiler can cast large floats to int32.' >&4 if $test "$intsize" -eq 4; then xxx=int else xxx=long fi $cat >try.c < #include $signal_t blech() { exit(3); } int main() { $xxx i32; double f; int result = 0; signal(SIGFPE, blech); f = (double) 0x7fffffff; f = 10 * f; i32 = ($xxx) f; if (i32 != ($xxx) f) result |= 1; exit(result); } EOCP if $cc $ccflags -o try try.c >/dev/null 2>&1; then ./try yyy=$? else echo "(I can't seem to compile the test program--assuming it can't)" yyy=1 fi case "$yyy" in 0) val="$define" echo "Yup, it can." ;; *) val="$undef" echo "Nope, it can't." ;; esac set d_casti32 eval $setvar $rm_try metaconfig-debian-perl-5.26.1/dist/U/d_castneg.U000066400000000000000000000077731316016665300213520ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_castneg.U,v $ ?RCS: Revision 3.0.1.2 1995/05/12 12:11:21 ram ?RCS: patch54: made sure cc and ccflags are conditional dependencies ?RCS: patch54: added improved test case for Interactive Unix ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:10:50 ram ?RCS: patch36: don't forget to tell user about compilation failures (ADO) ?RCS: patch36: declare signal handler correctly using 'signal_t' (ADO) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:47 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?X: ?X: Can the compiler cast negative / odd floats to unsigned values. ?X: ?MAKE:d_castneg castflags: cat +cc +ccflags rm_try Setvar signal_t ?MAKE: -pick add $@ %< ?S:d_castneg: ?S: This variable conditionally defines CASTNEG, which indicates ?S: wether the C compiler can cast negative float to unsigned. ?S:. ?S:castflags: ?S: This variable contains a flag that precise difficulties the ?S: compiler has casting odd floating values to unsigned long: ?S: 0 = ok ?S: 1 = couldn't cast < 0 ?S: 2 = couldn't cast >= 0x80000000 ?S: 4 = couldn't cast in argument expression list ?S:. ?C:CASTNEGFLOAT: ?C: This symbol is defined if the C compiler can cast negative ?C: numbers to unsigned longs, ints and shorts. ?C:. ?C:CASTFLAGS: ?C: This symbol contains flags that say what difficulties the compiler ?C: has casting odd floating values to unsigned long: ?C: 0 = ok ?C: 1 = couldn't cast < 0 ?C: 2 = couldn't cast >= 0x80000000 ?C: 4 = couldn't cast in argument expression list ?C:. ?H:#$d_castneg CASTNEGFLOAT /**/ ?H:#define CASTFLAGS $castflags /**/ ?H:. ?F:!try ?LINT:set d_castneg : check for ability to cast negative floats to unsigned echo " " echo 'Checking whether your C compiler can cast negative float to unsigned.' >&4 $cat >try.c < #include $signal_t blech() { exit(7); } $signal_t blech_in_list() { exit(4); } unsigned long dummy_long(p) unsigned long p; { return p; } unsigned int dummy_int(p) unsigned int p; { return p; } unsigned short dummy_short(p) unsigned short p; { return p; } int main() { double f = -123.; unsigned long along; unsigned int aint; unsigned short ashort; int result = 0; signal(SIGFPE, blech); along = (unsigned long)f; aint = (unsigned int)f; ashort = (unsigned short)f; if (along != (unsigned long)-123) result |= 1; if (aint != (unsigned int)-123) result |= 1; if (ashort != (unsigned short)-123) result |= 1; f = (double)0x40000000; f = f + f; along = 0; along = (unsigned long)f; if (along != 0x80000000) result |= 2; f -= 1.; along = 0; along = (unsigned long)f; if (along != 0x7fffffff) result |= 1; f += 2.; along = 0; along = (unsigned long)f; if (along != 0x80000001) result |= 2; if (result) exit(result); ?X: ?X: The following is a test for Interactive Unix Version 4.1, which ?X: has an 'improved' compiler which can correctly cast negative ?X: floats in expression lists, but apparently not in argument lists. ?X: Contributed by Winfried Koenig ?X: signal(SIGFPE, blech_in_list); f = 123.; along = dummy_long((unsigned long)f); aint = dummy_int((unsigned int)f); ashort = dummy_short((unsigned short)f); if (along != (unsigned long)123) result |= 4; if (aint != (unsigned int)123) result |= 4; if (ashort != (unsigned short)123) result |= 4; exit(result); } EOCP if $cc $ccflags -o try try.c >/dev/null 2>&1; then ./try castflags=$? else echo "(I can't seem to compile the test program--assuming it can't)" castflags=7 fi case "$castflags" in 0) val="$define" echo "Yup, it can." ;; *) val="$undef" echo "Nope, it can't." ;; esac set d_castneg eval $setvar $rm_try metaconfig-debian-perl-5.26.1/dist/U/d_cbrt.U000066400000000000000000000017701316016665300206470ustar00rootroot00000000000000?RCS: $Id: d_cbrt.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_cbrt.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:48 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_cbrt: Inlibc ?MAKE: -pick add $@ %< ?S:d_cbrt: ?S: This variable conditionally defines the HAS_CBRT symbol, which ?S: indicates to the C program that the cbrt() (cube root) function ?S: is available. ?S:. ?C:HAS_CBRT (CBRT): ?C: This symbol, if defined, indicates that the cbrt() (cube root) ?C: function is available. ?C:. ?H:#$d_cbrt HAS_CBRT /**/ ?H:. ?LINT:set d_cbrt : see if cbrt exists set cbrt d_cbrt eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_charsprf.U000066400000000000000000000031011316016665300215130ustar00rootroot00000000000000?RCS: $Id: d_charsprf.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_charsprf.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:49 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_charsprf: cat rm +cc Setvar ?MAKE: -pick add $@ %< ?S:d_charsprf: ?S: This variable conditionally defines CHARSPRINTF if this system ?S: declares "char *sprintf()" in stdio.h. The trend seems to be to ?S: declare it as "int sprintf()". ?S:. ?C:CHARSPRINTF: ?C: This symbol is defined if this system declares "char *sprintf()" in ?C: stdio.h. The trend seems to be to declare it as "int sprintf()". It ?C: is up to the package author to declare sprintf correctly based on the ?C: symbol. ?C:. ?H:#$d_charsprf CHARSPRINTF /**/ ?H:. ?F:!ucbsprf.c !ucbsprf ?LINT:set d_charsprf : see if sprintf is declared as int or pointer to char echo " " $cat >ucbsprf.c <<'EOF' int main() { int sprintf(); char buf[10]; exit((unsigned long)sprintf(buf,"%s","foo") > 10L); } EOF if $cc -o ucbsprf ucbsprf.c >/dev/null 2>&1 && ./ucbsprf; then echo "Your sprintf() returns (int)." >&4 val="$undef" else echo "Your sprintf() returns (char*)." >&4 val="$define" fi set d_charsprf eval $setvar $rm -f ucbsprf* metaconfig-debian-perl-5.26.1/dist/U/d_chown.U000066400000000000000000000020421316016665300210240ustar00rootroot00000000000000?RCS: $Id: d_chown.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_chown.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:14 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_chown: Inlibc ?MAKE: -pick add $@ %< ?S:d_chown: ?S: This variable conditionally defines the HAS_CHOWN symbol, which ?S: indicates to the C program that the chown() routine is available. ?S:. ?C:HAS_CHOWN : ?C: This symbol, if defined, indicates that the chown routine is ?C: available. ?C:. ?H:#$d_chown HAS_CHOWN /**/ ?H:. ?LINT:set d_chown : see if chown exists set chown d_chown eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_chroot.U000066400000000000000000000020601316016665300212040ustar00rootroot00000000000000?RCS: $Id: d_chroot.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_chroot.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:17 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_chroot: Inlibc ?MAKE: -pick add $@ %< ?S:d_chroot: ?S: This variable conditionally defines the HAS_CHROOT symbol, which ?S: indicates to the C program that the chroot() routine is available. ?S:. ?C:HAS_CHROOT : ?C: This symbol, if defined, indicates that the chroot routine is ?C: available. ?C:. ?H:#$d_chroot HAS_CHROOT /**/ ?H:. ?LINT:set d_chroot : see if chroot exists set chroot d_chroot eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_chsize.U000066400000000000000000000021611316016665300211750ustar00rootroot00000000000000?RCS: $Id: d_chsize.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_chsize.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_chsize: Inlibc ?MAKE: -pick add $@ %< ?S:d_chsize: ?S: This variable conditionally defines the CHSIZE symbol, which ?S: indicates to the C program that the chsize() routine is available ?S: to truncate files. You might need a -lx to get this routine. ?S:. ?C:HAS_CHSIZE (CHSIZE): ?C: This symbol, if defined, indicates that the chsize routine is available ?C: to truncate files. You might need a -lx to get this routine. ?C:. ?H:#$d_chsize HAS_CHSIZE /**/ ?H:. ?LINT:set d_chsize : see if chsize exists set chsize d_chsize eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_ckeypad.U000066400000000000000000000031521316016665300213310ustar00rootroot00000000000000?RCS: $Id: d_ckeypad.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_ckeypad.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:50 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_ckeypad: cat cc termlib Setvar ?MAKE: -pick add $@ %< ?S:d_ckeypad: ?S: This variable controls the definition of HAS_CURSES_KEYPAD, ?S: which tells the application that the keypad() curses function ?S: is available. ?S:. ?C:HAS_CURSES_KEYPAD: ?C: This symbol indicates the availability of the keypad() function ?C: of the curses library. ?C:. ?H:#$d_ckeypad HAS_CURSES_KEYPAD /**/ ?H:. ?LINT:set d_ckeypad : check for the "keypad()" function in the curses library echo " " case "$termlib" in '') echo "You don't have a curses library, so I won't waste time looking" >&4 echo "to see if has the keypad() function." >&4 *) echo "Checking the curses library ($termlib) for the keypad() function..." >&4 $cat >c_keypad.c <<'EOCP' #include int main() { keypad(stdscr, TRUE); exit(0); } EOCP if $cc c_keypad.c >c_keypad.out 2>&1 ; then val=$define echo "It appears to have the keypad() function." else val=$undef echo "Your curses library doesn't appear to have the keypad() function." fi esac set d_ckeypad eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_closedir.U000066400000000000000000000056101316016665300215160ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_closedir.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:31:26 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.2 1994/10/29 16:11:18 ram ?RCS: patch36: added 'ldflags' to the test compile line (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:21 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_closedir d_void_closedir: Inlibc i_dirent i_sysdir i_sysndir \ cc ccflags ldflags libs Setvar rm ?MAKE: -pick add $@ %< ?S:d_closedir: ?S: This variable conditionally defines HAS_CLOSEDIR if closedir() is ?S: available. ?S:. ?C:HAS_CLOSEDIR: ?C: This symbol, if defined, indicates that the closedir() routine is ?C: available. ?C:. ?H:#$d_closedir HAS_CLOSEDIR /**/ ?H:. ?S:d_void_closedir: ?S: This variable conditionally defines VOID_CLOSEDIR if closedir() ?S: does not return a value. ?S:. ?C:VOID_CLOSEDIR: ?C: This symbol, if defined, indicates that the closedir() routine ?C: does not return a value. ?C:. ?H:#$d_void_closedir VOID_CLOSEDIR /**/ ?H:. ?F:!closedir ?LINT:set d_closedir d_void_closedir : see if closedir exists set closedir d_closedir eval $inlibc @if VOID_CLOSEDIR || d_void_closedir ?X: The following contortions are designed so we can call closedir() ?X: and check whether it returns a value. The contortions are designed ?X: to portably pick up the correct directory header, for those ?X: systems that support various mutually incompatible directory functions. ?X: This is from perl5's perl.h case "$d_closedir" in "$define") echo " " echo "Checking whether closedir() returns a status..." >&4 cat > closedir.c < #if defined(NeXT) && defined(I_SYS_DIR) /* NeXT needs dirent + sys/dir.h */ #include #endif #else #ifdef I_SYS_NDIR #include #else #ifdef I_SYS_DIR #ifdef hp9000s500 #include /* may be wrong in the future */ #else #include #endif #endif #endif #endif int main() { return closedir(opendir(".")); } EOM if $cc $ccflags $ldflags -o closedir closedir.c $libs > /dev/null 2>&1; then if ./closedir > /dev/null 2>&1 ; then echo "Yes, it does." val="$undef" else echo "No, it doesn't." val="$define" fi else echo "(I can't seem to compile the test program--assuming it doesn't)" val="$define" fi ;; *) val="$undef"; ;; esac set d_void_closedir eval $setvar $rm -f closedir* @end metaconfig-debian-perl-5.26.1/dist/U/d_const.U000066400000000000000000000037721316016665300210470ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_const.U,v $ ?RCS: Revision 3.0.1.1 1993/11/10 17:33:41 ram ?RCS: patch14: stronger const check with added typedef for MIPS cc ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:51 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_const: cat rm cc ccflags Setvar ?MAKE: -pick add $@ %< ?S:d_const: ?S: This variable conditionally defines the HASCONST symbol, which ?S: indicates to the C program that this C compiler knows about the ?S: const type. ?S:. ?C:HASCONST ~ %<: ?C: This symbol, if defined, indicates that this C compiler knows about ?C: the const type. There is no need to actually test for that symbol ?C: within your programs. The mere use of the "const" keyword will ?C: trigger the necessary tests. ?C:. ?H:?%<:#$d_const HASCONST /**/ ?H:?%<:#ifndef HASCONST ?H:?%<:#define const ?H:?%<:#endif ?H:. ?W:%<:const ?F:const.c const.o ?LINT:set d_const ?LINT:known const : check for const keyword echo " " echo 'Checking to see if your C compiler knows about "const"...' >&4 $cat >const.c <<'EOCP' ?X: mmcg@bruce.cs.monash.edu.au reports that: ?X: The MIPS cc compiler (V2.10) on a dec 5000 running Ultrix 4.2A ?X: pretends to understand `const' but doesn't - it'll also fail to ?X: handle typedefs properly if they're declared const. To guard ?X: against this, boost up the test by using an explicit typedef... typedef struct spug { int drokk; } spug; int main() { const char *foo; const spug y; } EOCP if $cc -c $ccflags const.c >/dev/null 2>&1 ; then val="$define" echo "Yup, it does." else val="$undef" echo "Nope, it doesn't." fi set d_const eval $setvar $rm -f const.c const.o metaconfig-debian-perl-5.26.1/dist/U/d_crypt.U000066400000000000000000000041121316016665300210470ustar00rootroot00000000000000?RCS: $Id: d_crypt.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_crypt.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:31:47 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:52 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_crypt cryptlib: Loc test xlibpth libpth Csym Setvar _a Inlibc ?MAKE: -pick add $@ %< ?S:d_crypt: ?S: This variable conditionally defines the CRYPT symbol, which ?S: indicates to the C program that the crypt() routine is available ?S: to encrypt passwords and the like. ?S:. ?S:cryptlib: ?S: This variable holds -lcrypt or the path to a libcrypt.a archive if ?S: the crypt() function is not defined in the standard C library. It is ?S: up to the Makefile to use this. ?S:. ?C:HAS_CRYPT (CRYPT): ?C: This symbol, if defined, indicates that the crypt routine is available ?C: to encrypt passwords and the like. ?C:. ?H:#$d_crypt HAS_CRYPT /**/ ?H:. ?LINT:set d_crypt ?T:val : see if crypt exists echo " " set crypt d_crypt eval $inlibc case "$d_crypt" in $define) cryptlib='' ;; *) if set crypt val -f d_crypt; eval $csym; $val; then echo 'crypt() found.' >&4 val="$define" cryptlib='' else cryptlib=`./loc Slibcrypt$_a "" $xlibpth` if $test -z "$cryptlib"; then cryptlib=`./loc Mlibcrypt$_a "" $xlibpth` else cryptlib=-lcrypt fi if $test -z "$cryptlib"; then cryptlib=`./loc Llibcrypt$_a "" $xlibpth` else cryptlib=-lcrypt fi if $test -z "$cryptlib"; then cryptlib=`./loc libcrypt$_a "" $libpth` else cryptlib=-lcrypt fi if $test -z "$cryptlib"; then echo 'crypt() NOT found.' >&4 val="$undef" else val="$define" fi fi set d_crypt eval $setvar ;; esac metaconfig-debian-perl-5.26.1/dist/U/d_csh.U000066400000000000000000000041041316016665300204640ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_csh.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:32:18 ram ?RCS: patch61: added full_csh to preserve the full path even when portable ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:53 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_csh full_csh: csh Setvar ?MAKE: -pick add $@ %< ?S:d_csh: ?S: This variable conditionally defines the CSH symbol, which ?S: indicates to the C program that the C-shell exists. ?S:. ?S:full_csh: ?S: This variable contains the full pathname to 'csh', whether or ?S: not the user has specified 'portability'. This is only used ?S: in the compiled C program, and we assume that all systems which ?S: can share this executable will have the same full pathname to ?S: 'csh.' ?S:. ?C:HAS_CSH: ?C: This symbol, if defined, indicates that the C-shell exists. ?C:. ?C:CSH: ?C: This symbol, if defined, contains the full pathname of csh. ?C:. ?X: Previously, I just did $d_csh CSH "$full_csh", but that caused ?X: problems on VMS where the config.sh extraction program changes ?X: $undef to a real cpp undef, and they then had #undef CSH "" ?X: which the compiler didn't like. It's easy to work around this, ?X: so I did. --AD 3/1998. ?X: And we don't want to define CSH if !HAS_CSH, but we don't want ?X: those lines in config.h if they don't need CSH, so protect with ?CSH ?X: and not ?%<. --RAM, 15/02/2004 ?H:?%<:#$d_csh HAS_CSH /**/ ?H:?CSH:#ifdef HAS_CSH ?H:?CSH:#define CSH "$full_csh" /**/ ?H:?CSH:#endif ?H:. ?LINT:set d_csh : get csh whereabouts case "$csh" in 'csh') val="$undef" ;; *) val="$define" ;; esac set d_csh eval $setvar : Respect a hint or command line value for full_csh. case "$full_csh" in '') full_csh=$csh ;; esac metaconfig-debian-perl-5.26.1/dist/U/d_ctermid.U000066400000000000000000000020131316016665300213330ustar00rootroot00000000000000?RCS: $Id: d_ctermid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_ctermid.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:54 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_ctermid: Inlibc ?MAKE: -pick add $@ %< ?S:d_ctermid: ?S: This variable conditionally defines CTERMID if ctermid() is ?S: available to generate filename for terminal. ?S:. ?C:HAS_CTERMID (CTERMID): ?C: This symbol, if defined, indicates that the ctermid routine is ?C: available to generate filename for terminal. ?C:. ?H:#$d_ctermid HAS_CTERMID /**/ ?H:. ?LINT:set d_ctermid : see if ctermid exists set ctermid d_ctermid eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_cuserid.U000066400000000000000000000021741316016665300213520ustar00rootroot00000000000000?RCS: $Id: d_cuserid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_cuserid.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:25 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_cuserid: Inlibc ?MAKE: -pick add $@ %< ?S:d_cuserid: ?S: This variable conditionally defines the HAS_CUSERID symbol, which ?S: indicates to the C program that the cuserid() routine is available ?S: to get character login names. ?S:. ?C:HAS_CUSERID : ?C: This symbol, if defined, indicates that the cuserid routine is ?C: available to get character login names. ?C:. ?H:#$d_cuserid HAS_CUSERID /**/ ?H:. ?LINT:set d_cuserid : see if cuserid exists set cuserid d_cuserid eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_dbl_dig.U000066400000000000000000000035151316016665300213000ustar00rootroot00000000000000?RCS: $Id: d_dbl_dig.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_dbl_dig.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:28 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_dbl_dig: Myread contains cat rm Setvar i_limits i_float \ cppstdin cppflags cppminus ?MAKE: -pick add $@ %< ?S:d_dbl_dig: ?S: This variable conditionally defines d_dbl_dig if this system's ?S: header files provide DBL_DIG, which is the number of significant ?S: digits in a double precision number. ?S:. ?C:HAS_DBL_DIG: ?C: This symbol, if defined, indicates that this system's ?C: or defines the symbol DBL_DIG, which is the number ?C: of significant digits in a double precision number. If this ?C: symbol is not defined, a guess of 15 is usually pretty good. ?C:. ?H:#$d_dbl_dig HAS_DBL_DIG /**/ ?H:. ?F:!dbl_dig.c ?LINT:set d_dbl_dig : See if number of significant digits in a double precision number is known echo " " $cat >dbl_dig.c < #endif #ifdef I_FLOAT #include #endif #ifdef DBL_DIG printf("Contains DBL_DIG"); #endif EOM $cppstdin $cppflags $cppminus < dbl_dig.c >dbl_dig.E 2>/dev/null if $contains 'DBL_DIG' dbl_dig.E >/dev/null 2>&1; then echo "DBL_DIG found." >&4 val="$define" else echo "DBL_DIG NOT found." >&4 val="$undef" fi $rm -f dbl_dig.? set d_dbl_dig eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_difftime.U000066400000000000000000000021141316016665300214750ustar00rootroot00000000000000?RCS: $Id: d_difftime.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_difftime.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:31 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_difftime: Inlibc ?MAKE: -pick add $@ %< ?S:d_difftime: ?S: This variable conditionally defines the HAS_DIFFTIME symbol, which ?S: indicates to the C program that the difftime() routine is available. ?S:. ?C:HAS_DIFFTIME : ?C: This symbol, if defined, indicates that the difftime routine is ?C: available. ?C:. ?H:#$d_difftime HAS_DIFFTIME /**/ ?H:. ?LINT:set d_difftime : see if difftime exists set difftime d_difftime eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_dlerror.U000066400000000000000000000032321316016665300213610ustar00rootroot00000000000000?RCS: $Id: d_dlerror.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_dlerror.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 13:52:49 ram ?RCS: patch56: force compile-link test since symbol might lie in crt0.o (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:11:23 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_dlerror: Inlibc runnm ?MAKE: -pick add $@ %< ?S:d_dlerror: ?S: This variable conditionally defines the HAS_DLERROR symbol, which ?S: indicates to the C program that the dlerror() routine is available. ?S:. ?C:HAS_DLERROR : ?C: This symbol, if defined, indicates that the dlerror routine is ?C: available to return a string describing the last error that ?C: occurred from a call to dlopen(), dlclose() or dlsym(). ?C:. ?H:#$d_dlerror HAS_DLERROR /**/ ?H:. ?T: xxx_runnm ?LINT:set d_dlerror ?X: We don't permanently change runnm, but we do temporarily. ?LINT: change runnm : see if dlerror exists ?X: On NetBSD and FreeBSD, dlerror might be available, but it is in ?X: /usr/lib/crt0.o, not in any of the libraries. Therefore, do not ?X: use the nm extraction, but use a real compile and link test instead. xxx_runnm="$runnm" runnm=false set dlerror d_dlerror eval $inlibc runnm="$xxx_runnm" metaconfig-debian-perl-5.26.1/dist/U/d_dlopen.U000066400000000000000000000027531316016665300212000ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_dlopen.U,v $ ?RCS: Revision 3.0.1.2 1995/07/25 13:52:56 ram ?RCS: patch56: force compile-link test since symbol might lie in crt0.o (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:34 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_dlopen: Inlibc runnm ?MAKE: -pick add $@ %< ?S:d_dlopen: ?S: This variable conditionally defines the HAS_DLOPEN symbol, which ?S: indicates to the C program that the dlopen() routine is available. ?S:. ?C:HAS_DLOPEN : ?C: This symbol, if defined, indicates that the dlopen routine is ?C: available. ?C:. ?H:#$d_dlopen HAS_DLOPEN /**/ ?H:. ?T: xxx_runnm ?LINT:set d_dlopen ?X: We don't permanently change runnm, but we do temporarily. ?LINT: change runnm : see if dlopen exists ?X: On NetBSD and FreeBSD, dlopen is available, but it is in ?X: /usr/lib/crt0.o, not in any of the libraries. Therefore, do not ?X: use the nm extraction, but use a real compile and link test instead. xxx_runnm="$runnm" runnm=false set dlopen d_dlopen eval $inlibc runnm="$xxx_runnm" metaconfig-debian-perl-5.26.1/dist/U/d_dosuid.U000066400000000000000000000122551316016665300212040ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Tye McQueen added safe setuid script checks. ?RCS: ?RCS: $Log: d_dosuid.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:33:03 ram ?RCS: patch61: moved unit to TOP via a ?Y: layout directive ?RCS: patch61: tell them /dev/fd is not about floppy disks ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:12:08 ram ?RCS: patch36: added checks for secure setuid scripts (Tye McQueen) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:55 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_dosuid d_suidsafe: cat contains ls rm test Myread Setvar \ Oldconfig Guess package hint ?MAKE: -pick add $@ %< ?S:d_suidsafe: ?S: This variable conditionally defines SETUID_SCRIPTS_ARE_SECURE_NOW ?S: if setuid scripts can be secure. This test looks in /dev/fd/. ?S:. ?S:d_dosuid: ?S: This variable conditionally defines the symbol DOSUID, which ?S: tells the C program that it should insert setuid emulation code ?S: on hosts which have setuid #! scripts disabled. ?S:. ?C:SETUID_SCRIPTS_ARE_SECURE_NOW: ?C: This symbol, if defined, indicates that the bug that prevents ?C: setuid scripts from being secure is not present in this kernel. ?C:. ?C:DOSUID: ?C: This symbol, if defined, indicates that the C program should ?C: check the script that it is executing for setuid/setgid bits, and ?C: attempt to emulate setuid/setgid on systems that have disabled ?C: setuid #! scripts because the kernel can't do it securely. ?C: It is up to the package designer to make sure that this emulation ?C: is done securely. Among other things, it should do an fstat on ?C: the script it just opened to make sure it really is a setuid/setgid ?C: script, it should make sure the arguments passed correspond exactly ?C: to the argument on the #! line, and it should not trust any ?C: subprocesses to which it must pass the filename rather than the ?C: file descriptor of the script to be executed. ?C:. ?H:#$d_suidsafe SETUID_SCRIPTS_ARE_SECURE_NOW /**/ ?H:#$d_dosuid DOSUID /**/ ?H:. ?Y:TOP ?F:!reflect ?LINT: set d_suidsafe ?LINT: set d_dosuid : see if setuid scripts can be secure $cat <reflect chmod +x,u+s reflect ./reflect >flect 2>&1 if $contains "/dev/fd" flect >/dev/null; then echo "Congratulations, your kernel has secure setuid scripts!" >&4 val="$define" else $cat <&4 dflt=n;; "$undef") echo "Well, the $hint value is *not* secure." >&4 dflt=n;; *) echo "Well, the $hint value *is* secure." >&4 dflt=y;; esac ;; *) $rm -f reflect flect echo "#!$ls" >reflect chmod +x,u+s reflect echo >flect chmod a+w flect echo '"su" will (probably) prompt you for '"$ans's password." su $ans -c './reflect >flect' if $contains "/dev/fd" flect >/dev/null; then echo "Okay, it looks like setuid scripts are secure." >&4 dflt=y else echo "I don't think setuid scripts are secure." >&4 dflt=n fi ;; esac rp='Does your kernel have *secure* setuid scripts?' . ./myread case "$ans" in [yY]*) val="$define";; *) val="$undef";; esac fi else echo "I don't think setuid scripts are secure (no /dev/fd directory)." >&4 echo "(That's for file descriptors, not floppy disks.)" val="$undef" fi set d_suidsafe eval $setvar $rm -f reflect flect : now see if they want to do setuid emulation echo " " val="$undef" case "$d_suidsafe" in "$define") val="$undef" echo "No need to emulate SUID scripts since they are secure here." >& 4 ;; *) $cat < ?RCS: ?RCS: $Log: d_drem.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:12:14 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_drem: Inlibc ?MAKE: -pick add $@ %< ?S:d_drem: ?S: This variable conditionally defines the HAS_DREM symbol, which ?S: indicates to the C program that the drem() routine is available. ?S:. ?C:HAS_DREM : ?C: This symbol, if defined, indicates that the drem routine is ?C: available. This routine is roughly the same as fmod, i.e. it ?C: computes the remainder r=x-n*y, where n=rint(x/y), whereas fmod ?C: uses n=trunc(x/y). ?C:. ?H:#$d_drem HAS_DREM /**/ ?H:. ?LINT:set d_drem : see if drem exists set drem d_drem eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_dup2.U000066400000000000000000000017311316016665300205640ustar00rootroot00000000000000?RCS: $Id: d_dup2.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_dup2.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:56 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_dup2: Inlibc ?MAKE: -pick add $@ %< ?S:d_dup2: ?S: This variable conditionally defines HAS_DUP2 if dup2() is ?S: available to duplicate file descriptors. ?S:. ?C:HAS_DUP2 (DUP2): ?C: This symbol, if defined, indicates that the dup2 routine is ?C: available to duplicate file descriptors. ?C:. ?H:#$d_dup2 HAS_DUP2 /**/ ?H:. ?LINT:set d_dup2 : see if dup2 exists set dup2 d_dup2 eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_eofpipe.U000066400000000000000000000046701316016665300213460ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_eofpipe.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:12:40 ram ?RCS: patch36: call ./bsd explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:05:57 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_eofpipe: cat +cc +ccflags +libs rm Oldconfig Guess echo n c ?MAKE: -pick add $@ %< ?S:d_eofpipe: ?S: This variable conditionally defines the EOFPIPE symbol, which ?S: indicates to the C program that select will correctly detect the EOF ?S: condition when pipe is closed from the other end. ?S:. ?C:EOFPIPE: ?C: This symbol, if defined, indicates that EOF condition will be detected ?C: by the reader of the pipe when it is closed by the writing process. ?C: That is, a select() call on that file descriptor will not block when ?C: only an EOF remains (typical behaviour for BSD systems). ?C:. ?H:#$d_eofpipe EOFPIPE /**/ ?H:. ?F:!mpipe : see if pipe correctly gives the EOF condition echo " " case "$d_eofpipe" in '') echo "Let's see if your pipes return EOF to select() upon closing..." >&4 $cat >pipe.c <<'EOP' int main() { int pd[2]; int mask; pipe(pd); if (0 == fork()) { close(pd[0]); close(pd[1]); exit(0); } close(pd[1]); mask = 1 << pd[0]; alarm(2); select(32, &mask, (int *) 0, (int *) 0, (char *) 0); if (0 == read(pd[0], &mask, 1)) exit(0); exit(1); } EOP if $cc $ccflags -o pipe pipe.c $libs >/dev/null 2>&1; then ?X: Use a script to avoid the possible 'alarm call' message echo "./pipe || exit 1" > mpipe chmod +x mpipe ./mpipe >/dev/null 2>&1 case $? in 0) d_eofpipe="$define";; *) d_eofpipe="$undef";; esac else echo "(The test program did not compile correctly -- Guessing.)" if ./bsd; then d_eofpipe="$define" else d_eofpipe="$undef" fi fi case "$d_eofpipe" in "$define") echo "Yes, they do.";; *) echo "No, they don't! (sigh)";; esac ;; *) $echo $n "Your pipes $c" case "$d_eofpipe" in "$define") echo "allow select() to see EOF upon closing.";; *) echo "won't let select() see EOF on closing.";; esac ;; esac $rm -f *pipe* core metaconfig-debian-perl-5.26.1/dist/U/d_euc2jis.U000066400000000000000000000020541316016665300212550ustar00rootroot00000000000000?RCS: $Id: d_euc2jis.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_euc2jis.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:58 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_euc2jis: Inlibc ?MAKE: -pick add $@ %< ?S:d_euc2jis: ?S: This variable conditionally defines the HAS_EUC2JIS symbol, which ?S: indicates to the C program that the euc2jis() routine is available ?S: to convert EUC to JIS. ?S:. ?C:HAS_EUC2JIS: ?C: This symbol, if defined, indicates that the euc2jis routine is ?C: available to convert EUC to JIS. ?C:. ?H:#$d_euc2jis HAS_EUC2JIS /**/ ?H:. ?LINT:set d_euc2jis : see if euc2jis exists set euc2jis d_euc2jis eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fchmod.U000066400000000000000000000021271316016665300211520ustar00rootroot00000000000000?RCS: $Id: d_fchmod.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fchmod.U,v $ ?RCS: Revision 3.0 1993/08/18 12:05:59 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_fchmod: Inlibc ?MAKE: -pick add $@ %< ?S:d_fchmod: ?S: This variable conditionally defines the HAS_FCHMOD symbol, which ?S: indicates to the C program that the fchmod() routine is available ?S: to change mode of opened files. ?S:. ?C:HAS_FCHMOD (FCHMOD): ?C: This symbol, if defined, indicates that the fchmod routine is available ?C: to change mode of opened files. If unavailable, use chmod(). ?C:. ?H:#$d_fchmod HAS_FCHMOD /**/ ?H:. ?LINT:set d_fchmod : see if fchmod exists set fchmod d_fchmod eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fchown.U000066400000000000000000000021411316016665300211720ustar00rootroot00000000000000?RCS: $Id: d_fchown.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fchown.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:01 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_fchown: Inlibc ?MAKE: -pick add $@ %< ?S:d_fchown: ?S: This variable conditionally defines the HAS_FCHOWN symbol, which ?S: indicates to the C program that the fchown() routine is available ?S: to change ownership of opened files. ?S:. ?C:HAS_FCHOWN (FCHOWN): ?C: This symbol, if defined, indicates that the fchown routine is available ?C: to change ownership of opened files. If unavailable, use chown(). ?C:. ?H:#$d_fchown HAS_FCHOWN /**/ ?H:. ?LINT:set d_fchown : see if fchown exists set fchown d_fchown eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fcntl.U000066400000000000000000000017431316016665300210230ustar00rootroot00000000000000?RCS: $Id: d_fcntl.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fcntl.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:01 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_fcntl: Inlibc ?MAKE: -pick add $@ %< ?S:d_fcntl: ?S: This variable conditionally defines the HAS_FCNTL symbol, and indicates ?S: whether the fcntl() function exists ?S:. ?C:HAS_FCNTL: ?C: This symbol, if defined, indicates to the C program that ?C: the fcntl() function exists. ?C:. ?H:#$d_fcntl HAS_FCNTL /**/ ?H:. ?LINT:set d_fcntl : see if this is an fcntl system set fcntl d_fcntl eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fd_set.U000066400000000000000000000102621316016665300211550ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fd_set.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:33:16 ram ?RCS: patch61: added ?F: metalint hint ?RCS: ?RCS: Revision 3.0.1.2 1994/06/20 06:57:23 ram ?RCS: patch30: extended scope for fd_set checks (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/01/24 14:06:27 ram ?RCS: patch16: comments for HAS_FD_* symbols were not consistent ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:02 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_fd_set d_fd_macros d_fds_bits: cat +cc +ccflags rm Oldconfig \ d_socket i_systime i_sysselct i_syssock ?MAKE: -pick add $@ %< ?S:d_fd_set: ?S: This variable contains the eventual value of the HAS_FD_SET symbol, ?S: which indicates if your C compiler knows about the fd_set typedef. ?S:. ?S:d_fd_macros: ?S: This variable contains the eventual value of the HAS_FD_MACROS symbol, ?S: which indicates if your C compiler knows about the macros which ?S: manipulate an fd_set. ?S:. ?S:d_fds_bits: ?S: This variable contains the eventual value of the HAS_FDS_BITS symbol, ?S: which indicates if your fd_set typedef contains the fds_bits member. ?S: If you have an fd_set typedef, but the dweebs who installed it did ?S: a half-fast job and neglected to provide the macros to manipulate ?S: an fd_set, HAS_FDS_BITS will let us know how to fix the gaffe. ?S:. ?C:HAS_FD_SET: ?C: This symbol, when defined, indicates presence of the fd_set typedef ?C: in ?C:. ?C:HAS_FD_MACROS: ?C: This symbol, when defined, indicates presence of the macros used to ?C: manipulate an fd_set. ?C:. ?C:HAS_FDS_BITS: ?C: This symbol, when defined, indicates presence of the fds_bits member in ?C: fd_set. This knowledge is useful if fd_set is available but the macros ?C: aren't. ?C:. ?H:#$d_fd_set HAS_FD_SET /**/ ?H:#$d_fd_macros HAS_FD_MACROS /**/ ?H:#$d_fds_bits HAS_FDS_BITS /**/ ?H:. ?F:!fd_set : check for fd_set items $cat <, which is included (perhaps) ?X: by . We won't force people to include ?X: because it might introduce other ?X: incompatibilities. $cat >fd_set.c < #ifdef HAS_SOCKET #ifdef I_SYS_SOCKET #include /* Might include */ #endif #endif #ifdef I_SYS_TIME #include #endif #ifdef I_SYS_SELECT #include #endif int main() { fd_set fds; #ifdef TRYBITS if(fds.fds_bits); #endif #if defined(FD_SET) && defined(FD_CLR) && defined(FD_ISSET) && defined(FD_ZERO) exit(0); #else exit(1); #endif } EOCP if $cc $ccflags -DTRYBITS -o fd_set fd_set.c >fd_set.out 2>&1 ; then d_fds_bits="$define" d_fd_set="$define" echo "Well, your system knows about the normal fd_set typedef..." >&4 if ./fd_set; then echo "and you have the normal fd_set macros (just as I'd expect)." >&4 d_fd_macros="$define" else $cat >&4 <<'EOM' but not the normal fd_set macros! Gaaack! I'll have to cover for you. EOM d_fd_macros="$undef" fi else $cat <<'EOM' Hmm, your compiler has some difficulty with fd_set. Checking further... EOM if $cc $ccflags -o fd_set fd_set.c >fd_set.out 2>&1 ; then d_fds_bits="$undef" d_fd_set="$define" echo "Well, your system has some sort of fd_set available..." >&4 if ./fd_set; then echo "and you have the normal fd_set macros." >&4 d_fd_macros="$define" else $cat <<'EOM' but not the normal fd_set macros! Gross! More work for me... EOM d_fd_macros="$undef" fi else echo "Well, you got zip. That's OK, I can roll my own fd_set stuff." >&4 d_fd_set="$undef" d_fds_bits="$undef" d_fd_macros="$undef" fi fi $rm -f fd_set* metaconfig-debian-perl-5.26.1/dist/U/d_ffs.U000066400000000000000000000021301316016665300204620ustar00rootroot00000000000000?RCS: $Id: d_ffs.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_ffs.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:03 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_ffs: Inlibc ?MAKE: -pick add $@ %< ?S:d_ffs: ?S: This variable conditionally defines the HAS_FFS symbol, which ?S: indicates to the C program that the ffs() routine is available ?S: to find the first bit which is set in its integer argument. ?S:. ?C:HAS_FFS: ?C: This symbol, if defined, indicates that the ffs routine is available ?C: to find the first bit set in its argument. If it's not available, ?C: roll your own. ?C:. ?H:#$d_ffs HAS_FFS /**/ ?H:. ?LINT:set d_ffs : see if ffs exists set ffs d_ffs eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fgetpos.U000066400000000000000000000020101316016665300213500ustar00rootroot00000000000000?RCS: $Id: d_fgetpos.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fgetpos.U,v $ ?RCS: Revision 3.0.1.1 1994/06/20 06:57:33 ram ?RCS: patch30: created ?RCS: ?MAKE:d_fgetpos: Inlibc ?MAKE: -pick add $@ %< ?S:d_fgetpos: ?S: This variable conditionally defines HAS_FGETPOS if fgetpos() is ?S: available to get the file position indicator. ?S:. ?C:HAS_FGETPOS: ?C: This symbol, if defined, indicates that the fgetpos routine is ?C: available to get the file position indicator, similar to ftell(). ?C:. ?H:#$d_fgetpos HAS_FGETPOS /**/ ?H:. ?LINT:set d_fgetpos : see if fgetpos exists set fgetpos d_fgetpos eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_flexfnam.U000066400000000000000000000047131316016665300215150ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_flexfnam.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:04 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_flexfnam: cat rm test Setvar ?MAKE: -pick add $@ %< ?S:d_flexfnam: ?S: This variable conditionally defines the FLEXFILENAMES symbol, which ?S: indicates that the system supports filenames longer than 14 characters. ?S:. ?C:FLEXFILENAMES: ?C: This symbol, if defined, indicates that the system supports filenames ?C: longer than 14 characters. ?C:. ?H:#$d_flexfnam FLEXFILENAMES /**/ ?H:. ?T:first second ?LINT:set d_flexfnam : see if we can have long filenames echo " " ?X: ?X: We have to test in both /tmp and . because of NFS (remote server may allow ?X: long filenames while the local filesystem cannot support them). If at least ?X: one of those file systems cannot support long filenames, then we assume the ?X: whole system can't. ?X: rmlist="$rmlist /tmp/cf$$" $test -d /tmp/cf$$ || mkdir /tmp/cf$$ first=123456789abcdef second=/tmp/cf$$/$first $rm -f $first $second if (echo hi >$first) 2>/dev/null; then if $test -f 123456789abcde; then echo 'You cannot have filenames longer than 14 characters. Sigh.' >&4 val="$undef" else if (echo hi >$second) 2>/dev/null; then if $test -f /tmp/cf$$/123456789abcde; then $cat <<'EOM' That's peculiar... You can have filenames longer than 14 characters, but only on some of the filesystems. Maybe you are using NFS. Anyway, to avoid problems I shall consider your system cannot support long filenames at all. EOM val="$undef" else echo 'You can have filenames longer than 14 characters.' >&4 val="$define" fi else $cat <<'EOM' How confusing! Some of your filesystems are sane enough to allow filenames longer than 14 characters but some others like /tmp can't even think about them. So, for now on, I shall assume your kernel does not allow them at all. EOM val="$undef" fi fi else $cat <<'EOM' You can't have filenames longer than 14 chars. You can't even think about them! EOM val="$undef" fi set d_flexfnam eval $setvar $rm -rf /tmp/cf$$ 123456789abcde* metaconfig-debian-perl-5.26.1/dist/U/d_flock.U000066400000000000000000000017231316016665300210110ustar00rootroot00000000000000?RCS: $Id: d_flock.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_flock.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:05 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_flock: Inlibc ?MAKE: -pick add $@ %< ?S:d_flock: ?S: This variable conditionally defines HAS_FLOCK if flock() is ?S: available to do file locking. ?S:. ?C:HAS_FLOCK (FLOCK): ?C: This symbol, if defined, indicates that the flock routine is ?C: available to do file locking. ?C:. ?H:#$d_flock HAS_FLOCK /**/ ?H:. ?LINT:set d_flock : see if flock exists set flock d_flock eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fmod.U000066400000000000000000000022201316016665300206310ustar00rootroot00000000000000?RCS: $Id: d_fmod.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_fmod.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:12:46 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_fmod: Inlibc ?MAKE: -pick add $@ %< ?S:d_fmod: ?S: This variable conditionally defines the HAS_FMOD symbol, which ?S: indicates to the C program that the fmod() routine is available. ?S: See also d_drem for the drem() routine which does roughly the same. ?S:. ?C:HAS_FMOD : ?C: This symbol, if defined, indicates that the fmod routine is ?C: available to compute the remainder r=x-n*y where n=trunc(x/y). ?C:. ?H:#$d_fmod HAS_FMOD /**/ ?H:. ?LINT:set d_fmod : see if fmod exists set fmod d_fmod eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fork.U000066400000000000000000000020241316016665300206470ustar00rootroot00000000000000?RCS: $Id: d_fork.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_fork.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:38 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_fork: Inlibc ?MAKE: -pick add $@ %< ?S:d_fork: ?S: This variable conditionally defines the HAS_FORK symbol, which ?S: indicates to the C program that the fork() routine is available. ?S:. ?C:HAS_FORK : ?C: This symbol, if defined, indicates that the fork routine is ?C: available. ?C:. ?H:#$d_fork HAS_FORK /**/ ?H:. ?LINT:set d_fork : see if fork exists set fork d_fork eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_fsetpos.U000066400000000000000000000020101316016665300213640ustar00rootroot00000000000000?RCS: $Id: d_fsetpos.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_fsetpos.U,v $ ?RCS: Revision 3.0.1.1 1994/06/20 06:57:38 ram ?RCS: patch30: created ?RCS: ?MAKE:d_fsetpos: Inlibc ?MAKE: -pick add $@ %< ?S:d_fsetpos: ?S: This variable conditionally defines HAS_FSETPOS if fsetpos() is ?S: available to set the file position indicator. ?S:. ?C:HAS_FSETPOS: ?C: This symbol, if defined, indicates that the fsetpos routine is ?C: available to set the file position indicator, similar to fseek(). ?C:. ?H:#$d_fsetpos HAS_FSETPOS /**/ ?H:. ?LINT:set d_fsetpos : see if fsetpos exists set fsetpos d_fsetpos eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_ftime.U000066400000000000000000000050371316016665300210210ustar00rootroot00000000000000?RCS: $Id: d_ftime.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_ftime.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:06 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_ftime d_gettimeod: Inlibc Setvar ?MAKE: -pick add $@ %< ?S:d_ftime: ?S: This variable conditionally defines the HAS_FTIME symbol, which indicates ?S: that the ftime() routine exists. The ftime() routine is basically ?S: a sub-second accuracy clock. ?S:. ?S:d_gettimeod: ?S: This variable conditionally defines the HAS_GETTIMEOFDAY symbol, which ?S: indicates that the gettimeofday() system call exists (to obtain a ?S: sub-second accuracy clock). You should probably include . ?S:. ?C:HAS_FTIME (FTIMER): ?C: This symbol, if defined, indicates that the ftime() routine exists. ?C: It is basically a sub-second accuracy clock, but is less accurate ?C: than gettimeofday(2) anyway. The type "Timeval" should be used to ?C: refer to "struct timeb". ?C:. ?C:HAS_GETTIMEOFDAY (GETTIMEOFDAY): ?C: This symbol, if defined, indicates that the gettimeofday() system ?C: call is available for a sub-second accuracy clock. Usually, the file ?C: needs to be included (see I_SYS_RESOURCE). ?C: The type "Timeval" should be used to refer to "struct timeval". ?C:. ?H:#$d_ftime HAS_FTIME /**/ ?H:#$d_gettimeod HAS_GETTIMEOFDAY /**/ ?H:?%<:@if HAS_FTIME ?H:?%<:#ifdef HAS_FTIME ?H:?%<:#define Timeval struct timeb /* Structure used by ftime() */ ?H:?%<:#endif ?H:?%<:@end ?H:?%<:@if HAS_GETTIMEOFDAY ?H:?%<:#ifdef HAS_GETTIMEOFDAY ?H:?%<:#define Timeval struct timeval /* Structure used by gettimeofday() */ ?H:?%<:#endif ?H:?%<:@end ?H:. ?X:FIXME ?X:?I:?d_ftime:i_systimeb ?X:?I:?d_gettimeod:i_sysresrc ?LINT:set d_gettimeod d_ftime ?LINT:known Timeval : see if gettimeofday or ftime exists ?X: ?X: Give priority to gettimeofday(2) because timing is more accurate ?X: set gettimeofday d_gettimeod eval $inlibc case "$d_gettimeod" in "$undef") set ftime d_ftime eval $inlibc ;; *) val="$undef"; set d_ftime; eval $setvar ;; esac case "$d_gettimeod$d_ftime" in "$undef$undef") echo " " echo 'No ftime() nor gettimeofday() -- timing may be less accurate.' >&4 ;; esac metaconfig-debian-perl-5.26.1/dist/U/d_ftrncate.U000066400000000000000000000020321316016665300215130ustar00rootroot00000000000000?RCS: $Id: d_ftrncate.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_ftrncate.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:07 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_ftrncate: Inlibc ?MAKE: -pick add $@ %< ?S:d_ftrncate (d_ftruncate): ?S: This variable conditionally defines the HAS_FTRUNCATE symbol, which ?S: indicates to the C program that the ftruncate() subroutine exists. ?S:. ?C:HAS_FTRUNCATE: ?C: This symbol, if defined, indicates that the ftruncate() subroutine ?C: exists. ?C:. ?H:#$d_ftrncate HAS_FTRUNCATE /**/ ?H:. ?LINT:set d_ftrncate : see if ftruncate exists set ftruncate d_ftrncate eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_gconvert.U000066400000000000000000000102361316016665300215410ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_gconvert.U,v $ ?RCS: Revision 3.0.1.3 1997/02/28 15:33:38 ram ?RCS: patch61: integrated new unit from perl5 ?RCS: ?RCS: Revision 3.0.1.2 1995/07/25 13:55:59 ram ?RCS: patch56: improved comments about the Gconvert macro (ADO) ?RCS: patch56: force compile-link test since it may exist but be unusable (ADO) ?RCS: ?RCS: Revision 3.0.1.1 1994/10/29 16:12:51 ram ?RCS: patch36: created by ADO ?RCS: ?MAKE:d_Gconvert: cat cc ccflags ldflags libs rm_try _o ?MAKE: -pick add $@ %< ?S:d_Gconvert: ?S: This variable holds what Gconvert is defined as to convert ?S: floating point numbers into strings. It could be 'gconvert' ?S: or a more complex macro emulating gconvert with gcvt() or sprintf. ?S:. ?C:Gconvert: ?C: This preprocessor macro is defined to convert a floating point ?C: number to a string without a trailing decimal point. This ?C: emulates the behavior of sprintf("%g"), but is sometimes much more ?C: efficient. If gconvert() is not available, but gcvt() drops the ?C: trailing decimal point, then gcvt() is used. If all else fails, ?C: a macro using sprintf("%g") is used. Arguments for the Gconvert ?C: macro are: value, number of digits, whether trailing zeros should ?C: be retained, and the output buffer. ?C: Possible values are: ?C: d_Gconvert='gconvert((x),(n),(t),(b))' ?C: d_Gconvert='gcvt((x),(n),(b))' ?C: d_Gconvert='sprintf((b),"%.*g",(n),(x))' ?C: The last two assume trailing zeros should not be kept. ?C:. ?H:#define Gconvert(x,n,t,b) $d_Gconvert ?H:. ?T: xxx_list xxx_convert ?F:!try ?X: : Check how to convert floats to strings. echo " " echo "Checking for an efficient way to convert floats to strings." ?X: We want to be sure to drop trailing decimal points (perl5 ?X: needs this). $cat >try.c <<'EOP' #ifdef TRY_gconvert #define Gconvert(x,n,t,b) gconvert((x),(n),(t),(b)) char *myname = "gconvert"; #endif #ifdef TRY_gcvt #define Gconvert(x,n,t,b) gcvt((x),(n),(b)) char *myname = "gcvt"; #endif #ifdef TRY_sprintf #define Gconvert(x,n,t,b) sprintf((b),"%.*g",(n),(x)) char *myname = "sprintf"; #endif #include int checkit(expect, got) char *expect; char *got; { if (strcmp(expect, got)) { printf("%s oddity: Expected %s, got %s\n", myname, expect, got); exit(1); } } int int main() { char buf[64]; buf[63] = '\0'; /* This must be 1st test on (which?) platform */ /* Alan Burlison */ Gconvert(0.1, 8, 0, buf); checkit("0.1", buf); Gconvert(1.0, 8, 0, buf); checkit("1", buf); Gconvert(0.0, 8, 0, buf); checkit("0", buf); Gconvert(-1.0, 8, 0, buf); checkit("-1", buf); /* Some Linux gcvt's give 1.e+5 here. */ Gconvert(100000.0, 8, 0, buf); checkit("100000", buf); /* Some Linux gcvt's give -1.e+5 here. */ Gconvert(-100000.0, 8, 0, buf); checkit("-100000", buf); exit(0); } EOP ?X: List of order in which to search for functions. ?X: Usual order of efficiency is gconvert gcvt sprintf ?X: Respect a previous or hinted value. case "$d_Gconvert" in gconvert*) xxx_list='gconvert gcvt sprintf' ;; gcvt*) xxx_list='gcvt gconvert sprintf' ;; sprintf*) xxx_list='sprintf gconvert gcvt' ;; *) xxx_list='gconvert gcvt sprintf' ;; esac for xxx_convert in $xxx_list; do echo "Trying $xxx_convert" $rm_try if $cc $ccflags -DTRY_$xxx_convert $ldflags -o try \ try.c $libs > /dev/null 2>&1 ; then echo "$xxx_convert" found. >&4 if ./try; then echo "I'll use $xxx_convert to convert floats into a string." >&4 break; else echo "...But $xxx_convert didn't work as I expected." fi else echo "$xxx_convert NOT found." >&4 fi done case "$xxx_convert" in gconvert) d_Gconvert='gconvert((x),(n),(t),(b))' ;; gcvt) d_Gconvert='gcvt((x),(n),(b))' ;; *) d_Gconvert='sprintf((b),"%.*g",(n),(x))' ;; esac metaconfig-debian-perl-5.26.1/dist/U/d_getgrps.U000066400000000000000000000022411316016665300213620ustar00rootroot00000000000000?RCS: $Id: d_getgrps.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getgrps.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:08 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getgrps: Inlibc ?MAKE: -pick add $@ %< ?S:d_getgrps: ?S: This variable conditionally defines the HAS_GETGROUPS symbol, which ?S: indicates to the C program that the getgroups() routine is available ?S: to get the list of process groups. ?S:. ?C:HAS_GETGROUPS (GETGROUPS): ?C: This symbol, if defined, indicates that the getgroups() routine is ?C: available to get the list of process groups. If unavailable, multiple ?C: groups are probably not supported. ?C:. ?H:#$d_getgrps HAS_GETGROUPS /**/ ?H:. ?LINT:set d_getgrps : see if getgroups exists set getgroups d_getgrps eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_gethbynm.U000066400000000000000000000022011316016665300215200ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethbynm.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:08 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethbynm: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethbynm (d_gethhstby): ?S: This variable conditionally defines the HAS_GETHOSTBYNAME symbol, which ?S: indicates to the C program that the gethostbyname() routine is available ?S: to lookup host names in some data base or other. ?S:. ?C:HAS_GETHOSTBYNAME (GETHOSTBYNAME): ?C: This symbol, if defined, indicates that the gethostbyname() routine is ?C: available to lookup host names in some data base or other. ?C:. ?H:#$d_gethbynm HAS_GETHOSTBYNAME /**/ ?H:. ?LINT:set d_gethbynm : see if gethostbyname exists set gethostbyname d_gethbynm eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_gethent.U000066400000000000000000000017741316016665300213570ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:09 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethent: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethent: ?S: This variable conditionally defines HAS_GETHOSTENT if gethostent() is ?S: available to dup file descriptors. ?S:. ?C:HAS_GETHOSTENT (GETHOSTENT): ?C: This symbol, if defined, indicates that the gethostent routine is ?C: available to lookup host names in some data base or other. ?C:. ?H:#$d_gethent HAS_GETHOSTENT /**/ ?H:. ?LINT:set d_gethent : see if gethostent exists set gethostent d_gethent eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_gethid.U000066400000000000000000000017731316016665300211640ustar00rootroot00000000000000?RCS: $Id: d_gethid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethid.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:10 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethid: Inlibc ?MAKE: -pick add $@ %< ?S:d_gethid: ?S: This variable conditionally defines HAS_GETHOSTID if gethostid() is ?S: available to get the host id. ?S:. ?C:HAS_GETHOSTID (GETHOSTID): ?C: This symbol, if defined, indicates that the gethostid system call is ?C: available to get the host id. ?C:. ?H:#$d_gethid HAS_GETHOSTID /**/ ?H:. ?LINT:set d_gethid : see if gethid exists set gethostid d_gethid eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_gethname.U000066400000000000000000000164261316016665300215110ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_gethname.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:13:00 ram ?RCS: patch36: call ./xenix explicitly instead of relying on PATH ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:11 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_gethname d_uname d_phostname aphostname: phostname cat \ myhostname package d_portable Loc echo n c +i_whoami +usrinc \ Myread Guess Oldconfig Csym ?MAKE: -pick add $@ %< ?S:d_gethname: ?S: This variable conditionally defines the HAS_GETHOSTNAME symbol, which ?S: indicates to the C program that the gethostname() routine may be ?S: used to derive the host name. ?S:. ?S:d_uname: ?S: This variable conditionally defines the HAS_UNAME symbol, which ?S: indicates to the C program that the uname() routine may be ?S: used to derive the host name. ?S:. ?S:d_phostname: ?S: This variable conditionally defines the PHOSTNAME symbol, which ?S: contains the shell command which, when fed to popen(), may be ?S: used to derive the host name. ?S:. ?S:aphostname: ?S: Thie variable contains the command which can be used to compute the ?S: host name. The command is fully qualified by its absolute path, to make ?S: it safe when used by a process with super-user privileges. ?S:. ?C:HAS_GETHOSTNAME (GETHOSTNAME): ?C: This symbol, if defined, indicates that the C program may use the ?C: gethostname() routine to derive the host name. See also HAS_UNAME ?C: and PHOSTNAME. ?C:. ?C:HAS_UNAME (UNAME): ?C: This symbol, if defined, indicates that the C program may use the ?C: uname() routine to derive the host name. See also HAS_GETHOSTNAME ?C: and PHOSTNAME. ?C:. ?C:PHOSTNAME: ?C: This symbol, if defined, indicates that the C program may use the ?C: contents of PHOSTNAME as a command to feed to the popen() routine ?C: to derive the host name. See also HAS_GETHOSTNAME and HAS_UNAME. ?C: Note that the command uses a fully qualified path, so that it is safe ?C: even if used by a process with super-user privileges. ?C:. ?H:#$d_gethname HAS_GETHOSTNAME /**/ ?H:#$d_uname HAS_UNAME /**/ ?H:#$d_phostname PHOSTNAME "$aphostname" /* How to get the host name */ ?H:. ?T:file val call ?LINT:change i_whoami : see how we will look up host name echo " " if false; then : dummy stub to allow use of elif @if HAS_GETHOSTNAME elif set gethostname val -f d_gethname; eval $csym; $val; then echo 'gethostname() found.' >&4 d_gethname="$define" call=gethostname @end @if HAS_UNAME elif set uname val -f d_uname; eval $csym; $val; then if ./xenix; then $cat <<'EOM' uname() was found, but you're running xenix, and older versions of xenix have a broken uname(). If you don't really know whether your xenix is old enough to have a broken system call, use the default answer. EOM dflt=y case "$d_uname" in "$define") dflt=n;; esac rp='Is your uname() broken?' . ./myread case "$ans" in n*) d_uname="$define"; call=uname;; esac else echo 'uname() found.' >&4 d_uname="$define" call=uname fi @end fi case "$d_gethname" in '') d_gethname="$undef";; esac case "$d_uname" in '') d_uname="$undef";; esac @if PHOSTNAME || MYHOSTNAME case "$d_uname$d_gethname" in *define*) dflt=n cat <&4;; @ end esac;; esac @elsif PHOSTNAME case "$d_uname$d_gethname" in *define*) ;; *) case "$phostname" in '') @ if WHOAMI case "$i_whoami" in "$define") $cat <&4;; esac;; @ else echo "There will be no way for $package to get your hostname." >&4;; @ end *) echo "I'll use 'popen("'"'$aphostname'", "r")'"' to get your hostname." >&4 ;; esac;; esac @elsif MYHOSTNAME case "$d_uname$d_gethname" in *define*) ;; *) @ if WHOAMI case "$i_whoami" in "$define") dflt=y $cat <&4;; esac;; @ else echo 'Hardwiring "'$myhostname'".' >&4;; @ end esac @end case "$d_phostname" in '') d_phostname="$undef";; esac metaconfig-debian-perl-5.26.1/dist/U/d_getlogin.U000066400000000000000000000021741316016665300215240ustar00rootroot00000000000000?RCS: $Id: d_getlogin.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_getlogin.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:41 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_getlogin: Inlibc ?MAKE: -pick add $@ %< ?S:d_getlogin: ?S: This variable conditionally defines the HAS_GETLOGIN symbol, which ?S: indicates to the C program that the getlogin() routine is available ?S: to get the login name. ?S:. ?C:HAS_GETLOGIN : ?C: This symbol, if defined, indicates that the getlogin routine is ?C: available to get the login name. ?C:. ?H:#$d_getlogin HAS_GETLOGIN /**/ ?H:. ?LINT:set d_getlogin : see if getlogin exists set getlogin d_getlogin eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getopt.U000066400000000000000000000020451316016665300212130ustar00rootroot00000000000000?RCS: $Id: d_getopt.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getopt.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:13 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getopt: Inlibc ?MAKE: -pick add $@ %< ?S:d_getopt: ?S: This variable conditionally defines the HAS_GETOPT symbol, which ?S: indicates that the getopt() routine exists. The getopt() routine ?S: parses command line options in a standard fashion. ?S:. ?C:HAS_GETOPT (GETOPT): ?C: This symbol, if defined, indicates that the getopt() routine exists. ?C:. ?H:#$d_getopt HAS_GETOPT /**/ ?H:. ?LINT:set d_getopt : see if getopt exists set getopt d_getopt eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getpagsz.U000066400000000000000000000055241316016665300215420ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getpagsz.U,v $ ?RCS: Revision 3.0.1.1 1994/10/29 16:13:10 ram ?RCS: patch36: added ?F: line for metalint file checking ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:14 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpagsz pagesize: Oldconfig Myread Inlibc cat contains +cc +ccflags \ libs rm Findhdr ?MAKE: -pick add $@ %< ?S:d_getpagsz: ?S: This variable conditionally defines HAS_GETPAGESIZE if getpagesize() ?S: is available to get the system page size. ?S:. ?S:pagesize (pagsize): ?S: This variable holds the size in bytes of a system page. ?S:. ?C:HAS_GETPAGESIZE (GETPAGESIZE): ?C: This symbol, if defined, indicates that the getpagesize system call ?C: is available to get system page size, which is the granularity of ?C: many memory management calls. ?C:. ?X: Don't name it PAGESIZE, this is sometimes used by ?C:PAGESIZE_VALUE (PAGSIZE): ?C: This symbol holds the size in bytes of a system page (obtained via ?C: the getpagesize() system call at configuration time or asked to the ?C: user if the system call is not available). ?C:. ?H:#$d_getpagsz HAS_GETPAGESIZE /**/ ?H:#define PAGESIZE_VALUE $pagesize /* System page size, in bytes */ ?H:. ?F:!page ?T:guess ?LINT:set d_getpagsz : see if getpagesize exists set getpagesize d_getpagsz eval $inlibc @if pagesize || PAGESIZE_VALUE : determine the system page size echo " " guess=' (OK to guess)' case "$pagesize" in '') $cat >page.c <&4 dflt='4096' case "$d_getpagsz" in "$define") if $cc $ccflags -o page page.c $libs >/dev/null 2>&1; then dflt=`./page` guess='' else echo "(I can't seem to compile the test program--guessing)" fi ;; *) if $cc $ccflags -o page page.c $libs -lPW >/dev/null 2>&1; then dflt=`./page` guess='' echo "(For your eyes only: I used the getpagesize() from -lPW.)" else if $contains PAGESIZE `./findhdr sys/param.h` >/dev/null 2>&1; then $cat >page.c < int main() { printf("%d\n", PAGESIZE); } EOP if $cc $ccflags -o page page.c $libs >/dev/null 2>&1; then dflt=`./page` guess='' echo "(Using value of PAGESIZE found in .)" fi fi fi ;; esac ;; *) dflt="$pagesize"; guess='';; esac rp="What is the system page size, in bytes$guess?" . ./myread pagesize=$ans $rm -f page.c page @end metaconfig-debian-perl-5.26.1/dist/U/d_getpgid.U000066400000000000000000000021561316016665300213370ustar00rootroot00000000000000?RCS: $Id: d_getpgid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1996, Andy Dougherty ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getpgid.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:33:44 ram ?RCS: patch61: created ?RCS: ?MAKE:d_getpgid: Inlibc ?MAKE: -pick add $@ %< ?S:d_getpgid: ?S: This variable conditionally defines the HAS_GETPGID symbol, which ?S: indicates to the C program that the getpgid(pid) function ?S: is available to get the process group id. ?S:. ?C:HAS_GETPGID: ?C: This symbol, if defined, indicates to the C program that ?C: the getpgid(pid) function is available to get the ?C: process group id. ?C:. ?H:#$d_getpgid HAS_GETPGID /**/ ?H:. ?LINT:set d_getpgid : see if getpgid exists set getpgid d_getpgid eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getpgrp.U000066400000000000000000000054431316016665300213660ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getpgrp.U,v $ ?RCS: Revision 3.0.1.1 1997/02/28 15:34:28 ram ?RCS: patch61: new USE_BSD_GETPGRP to detect the getpgrp() flavour ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:15 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpgrp d_bsdgetpgrp: Guess Inlibc Setvar cat rm \ +cc +ccflags +ldflags +libs i_unistd ?MAKE: -pick add $@ %< ?S:d_getpgrp: ?S: This variable conditionally defines HAS_GETPGRP if getpgrp() is ?S: available to get the current process group. ?S:. ?S:d_bsdgetpgrp: ?S: This variable conditionally defines USE_BSD_GETPGRP if ?S: getpgrp needs one arguments whereas USG one needs none. ?S:. ?C:HAS_GETPGRP (GETPGRP): ?C: This symbol, if defined, indicates that the getpgrp routine is ?C: available to get the current process group. ?C:. ?C:USE_BSD_GETPGRP: ?C: This symbol, if defined, indicates that getpgrp needs one ?C: arguments whereas USG one needs none. ?C:. ?H:#$d_getpgrp HAS_GETPGRP /**/ ?H:#$d_bsdgetpgrp USE_BSD_GETPGRP /**/ ?H:. ?F:!set !set.c ?T:xxx ?LINT:set d_getpgrp d_bsdgetpgrp : see if getpgrp exists set getpgrp d_getpgrp eval $inlibc @if USE_BSD_GETPGRP || d_bsdgetpgrp case "$d_getpgrp" in "$define") echo " " echo "Checking to see which flavor of getpgrp is in use..." $cat >set.c < #ifdef I_UNISTD # include #endif int main() { if (getuid() == 0) { printf("(I see you are running Configure as super-user...)\n"); setuid(1); } #ifdef TRY_BSD_PGRP if (getpgrp(1) == 0) exit(0); #else if (getpgrp() > 0) exit(0); #endif exit(1); } EOP if $cc -DTRY_BSD_PGRP $ccflags $ldflags -o set set.c $libs >/dev/null 2>&1 && ./set then echo "You have to use getpgrp(pid) instead of getpgrp()." >&4 val="$define" elif $cc $ccflags $ldflags -o set set.c $libs >/dev/null 2>&1 && ./set; then echo "You have to use getpgrp() instead of getpgrp(pid)." >&4 val="$undef" else echo "I can't seem to compile and run the test program." if ./usg; then xxx="a USG one, i.e. you use getpgrp()." else # SVR4 systems can appear rather BSD-ish. case "$i_unistd" in $undef) xxx="a BSD one, i.e. you use getpgrp(pid)." val="$define" ;; $define) xxx="probably a USG one, i.e. you use getpgrp()." val="$undef" ;; esac fi echo "Assuming your getpgrp is $xxx" >&4 fi ;; *) val="$undef";; esac set d_bsdgetpgrp eval $setvar $rm -f set set.c @end metaconfig-debian-perl-5.26.1/dist/U/d_getpgrp2.U000066400000000000000000000021711316016665300214430ustar00rootroot00000000000000?RCS: $Id: d_getpgrp2.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getpgrp2.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:15 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpgrp2: Inlibc ?MAKE: -pick add $@ %< ?S:d_getpgrp2: ?S: This variable conditionally defines the HAS_GETPGRP2 symbol, which ?S: indicates to the C program that the getpgrp2() (as in DG/UX) routine ?S: is available to get the current process group. ?S:. ?C:HAS_GETPGRP2 (GETPGRP2): ?C: This symbol, if defined, indicates that the getpgrp2() (as in DG/UX) ?C: routine is available to get the current process group. ?C:. ?H:#$d_getpgrp2 HAS_GETPGRP2 /**/ ?H:. ?LINT:set d_getpgrp2 : see if getpgrp2 exists set getpgrp2 d_getpgrp2 eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getppid.U000066400000000000000000000021741316016665300213500ustar00rootroot00000000000000?RCS: $Id: d_getppid.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_getppid.U,v $ ?RCS: Revision 3.0.1.1 1994/08/29 16:07:45 ram ?RCS: patch32: created by ADO ?RCS: ?MAKE:d_getppid: Inlibc ?MAKE: -pick add $@ %< ?S:d_getppid: ?S: This variable conditionally defines the HAS_GETPPID symbol, which ?S: indicates to the C program that the getppid() routine is available ?S: to get the parent process ID. ?S:. ?C:HAS_GETPPID : ?C: This symbol, if defined, indicates that the getppid routine is ?C: available to get the parent process ID. ?C:. ?H:#$d_getppid HAS_GETPPID /**/ ?H:. ?LINT:set d_getppid : see if getppid exists set getppid d_getppid eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getprior.U000066400000000000000000000020521316016665300215420ustar00rootroot00000000000000?RCS: $Id: d_getprior.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getprior.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:16 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getprior: Inlibc ?MAKE: -pick add $@ %< ?S:d_getprior: ?S: This variable conditionally defines HAS_GETPRIORITY if getpriority() ?S: is available to get a process's priority. ?S:. ?C:HAS_GETPRIORITY (GETPRIORITY): ?C: This symbol, if defined, indicates that the getpriority routine is ?C: available to get a process's priority. ?C:. ?H:#$d_getprior HAS_GETPRIORITY /**/ ?H:. : see if getpriority exists ?LINT:set d_getprior set getpriority d_getprior eval $inlibc metaconfig-debian-perl-5.26.1/dist/U/d_getpwent.U000066400000000000000000000023561316016665300215530ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getpwent.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:17 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getpwent: Csym Setvar ?MAKE: -pick add $@ %< ?S:d_getpwent: ?S: This variable conditionally defines the HAS_GETPWENT symbol, which ?S: indicates to the C program that it should use the getpwent() ?S: routine instead of the getpw() routine. ?S:. ?C:HAS_GETPWENT (GETPWENT): ?C: This symbol, if defined, indicates that the getpwent() routine ?C: should be used instead of the getpw() routine. ?C:. ?H:#$d_getpwent HAS_GETPWENT /**/ ?H:. ?LINT:set d_getpwent : see if there is a getpwent echo " " if set getpwent val -f d_getpwent; eval $csym; $val; then echo "getpwent() found." >&4 val="$define" else echo "No getpwent() found -- will use getpw() instead." >&4 val="$undef" fi set d_getpwent eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_getwd.U000066400000000000000000000023601316016665300210230ustar00rootroot00000000000000?RCS: $Id: d_getwd.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_getwd.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:18 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_getwd: Csym Setvar ?MAKE: -pick add $@ %< ?S:d_getwd: ?S: This variable conditionally defines HAS_GETWD if getwd() is ?S: available to get working directory. If not, you should ?S: probably use getcwd(). ?S:. ?C:HAS_GETWD (GETWD): ?C: This symbol, if defined, indicates that the getwd routine is ?C: available to get working directory. If not, you should ?C: probably use getcwd(). ?C:. ?H:#$d_getwd HAS_GETWD /**/ ?H:. ?LINT:set d_getwd : see if getwd exists echo " " if set getwd val -f d_getwd; eval $csym; $val; then echo 'getwd() found.' >&4 val="$define" else echo 'getwd() not found. Assuming getcwd() exists.' >&4 val="$undef" fi set d_getwd eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_gnulibc.U000066400000000000000000000062431316016665300213400ustar00rootroot00000000000000?RCS: $Id$ ?RCS: ?RCS: Copyright (c) 1996,1998 Andy Dougherty ?RCS: Copyright (c) 1996, Sven Verdoolaege ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic License, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic License; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?MAKE:d_gnulibc gnulibc_version: Myread Oldconfig Setvar rm_try \ cat Compile run ?MAKE: -pick add $@ %< ?S:d_gnulibc: ?S: Defined if we're dealing with the GNU C Library. ?S:. ?S:gnulibc_version: ?S: This variable contains the version number of the GNU C library. ?S: It is usually something like '2.2.5'. It is a plain '' if this ?S: is not the GNU C library, or if the version is unknown. ?S:. ?C:HAS_GNULIBC ~ %<: ?C: This symbol, if defined, indicates to the C program that ?C: the GNU C library is being used. A better check is to use ?C: the __GLIBC__ and __GLIBC_MINOR__ symbols supplied with glibc. ?C:. ?H:?%<:#$d_gnulibc HAS_GNULIBC /**/ ?H:?%<:#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE) ?H:?%<:#define _GNU_SOURCE ?H:?%<:#endif ?H:. ?F:!glibc.ver !try.c !try ?LINT: set d_gnulibc ?LINT: usefile try.c ?LINT: known _GNU_SOURCE ?X: gnulibc can be executed by calling __libc_main(). ?X: Ulrich Drepper doesn't think any other libc does that, ?X: but we check if it says 'GNU C Library' to be sure. ?X: ?X: Alas, as of 3/1998 glibc 2.0.7 reportedly isn't going to ?X: have __libc_main() anymore. :-(. Fortunately, all released ?X: versions of glibc 2.x.x _do_ have CPP variables. For 2.0.6, ?X: they are: ?X: #define __GLIBC__ 2 ?X: #define__GLIBC_MINOR__ 0. ?X: (The '6' isn't available :-(. ?X: glibc2.1 will also have ?X: extern const char * __gnu_get_libc_release(void); ?X: extern const char * __gnu_get_libc_version(void); ?X: functions. --thanks to Andreas Jaeger. --AD 6/1998. ?X: Although the exact format isn't documented, __gnu_get_libc_version() ?X: returns a simple string '2.1.3' in glibc 2.1.3. ?X: : determine whether we are using a GNU C library echo " " echo "Checking for GNU C Library..." >&4 cat >try.c <<'EOCP' /* Find out version of GNU C library. __GLIBC__ and __GLIBC_MINOR__ alone are insufficient to distinguish different versions, such as 2.0.6 and 2.0.7. The function gnu_get_libc_version() appeared in libc version 2.1.0. A. Dougherty, June 3, 2002. */ #include int main(void) { #ifdef __GLIBC__ # ifdef __GLIBC_MINOR__ # if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1 # include printf("%s\n", gnu_get_libc_version()); # else printf("%d.%d\n", __GLIBC__, __GLIBC_MINOR__); # endif # else printf("%d\n", __GLIBC__); # endif return 0; #else return 1; #endif } EOCP set try if eval $compile_ok && $run ./try > glibc.ver; then val="$define" gnulibc_version=`$cat glibc.ver` echo "You are using the GNU C Library version $gnulibc_version" else val="$undef" gnulibc_version='' echo "You are not using the GNU C Library" fi $rm_try glibc.ver set d_gnulibc eval $setvar metaconfig-debian-perl-5.26.1/dist/U/d_group.U000066400000000000000000000014271316016665300210500ustar00rootroot00000000000000?RCS: $Id: d_group.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: Original Author: Andy Dougherty ?RCS: ?RCS: $Log: d_group.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:34:52 ram ?RCS: patch61: useless unit dropped. ?RCS: ?RCS: Revision 3.0.1.1 1994/08/29 16:07:48 ram ?RCS: patch32: created by ADO ?RCS: ?X: ?X: Useless unit dropped. ?X: ?LINT:empty metaconfig-debian-perl-5.26.1/dist/U/d_havetlib.U000066400000000000000000000065441316016665300215170ustar00rootroot00000000000000?RCS: $Id: d_havetlib.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_havetlib.U,v $ ?RCS: Revision 3.0.1.2 1997/02/28 15:36:31 ram ?RCS: patch61: replaced .a with $_a all over the place ?RCS: patch61: likewise for .o replaced by $_o ?RCS: ?RCS: Revision 3.0.1.1 1994/05/06 14:44:06 ram ?RCS: patch23: added AIX support to accept shared lib stub as termlib (WED) ?RCS: ?RCS: Revision 3.0 1993/08/18 12:06:19 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_havetlib termlib: cat contains Myread Loc Filexp Oldconfig libpth \ test uname _a _o ?MAKE: -pick add $@ %< ?S:d_havetlib: ?S: This variable conditionally defines the HAS_TERMLIB symbol, which ?S: indicates to the C program that termlib-style routines are available. ?S:. ?S:termlib: ?S: This variable contains the argument to pass to the loader to get ?S: termlib-style routines. It is up to the Makefile.SH to make sure ?S: the value gets to the right command. Note that on many systems the ?S: termlib routines are emulated by the curses or terminfo library. ?S:. ?C:HAS_TERMLIB (HAVETERMLIB): ?C: This symbol, when defined, indicates that termlib-style routines ?C: are available. There is nothing to include. ?C:. ?H:#$d_havetlib HAS_TERMLIB /**/ ?H:. ?T:xxx : where do we get termlib routines from echo " " xxx=`./loc libcurses$_a x $libpth` case "$xxx" in /*) ar t $xxx >grimble if $contains tputs$_o grimble >/dev/null 2>&1; then termlib='-lcurses' d_havetlib="$define" echo "Terminfo library found." >&4 elif $test "x`$uname 2>/dev/null`" = xAIX; then # Ok, do the AIX shr.o fun thing /usr/ccs/bin/nm -en $xxx 2>/dev/null >grimble if $contains '^tputs .*|extern|' grimble >/dev/null 2>&1; then termlib='-lcurses' d_havetlib="$define" echo "AIX Terminfo library found." >&4 else xxx=x fi else xxx=x fi rm -f grimble ;; esac case "$xxx" in x) xxx=`./loc libtermlib$_a x $libpth` case "$xxx" in /usr/lib*|/lib*) termlib='-ltermlib' d_havetlib="$define" echo "Termlib library found." >&4 ;; /*) termlib="$xxx" d_havetlib="$define" echo "Termlib library found." >&4 ;; *) xxx=`./loc libtermcap$_a x $libpth` case "$xxx" in /usr/lib*|/lib*) termlib='-ltermcap' d_havetlib="$define" echo "Termcap library found." >&4 ;; /*) termlib="$xxx" d_havetlib="$define" echo "Termcap library found." >&4 ;; *) case "$termlib" in '') dflt=y rp="Your system appears to NOT have termlib-style routines. Is this true?" . ./myread case "$ans" in n*|f*) d_havetlib="$define" $cat <<'EOM' Then where are the termlib-style routines kept? Specify either -llibname or a full pathname (~name ok). EOM dflt='' rp='Specify termlib path:' . ./myread termlib=`./filexp $ans` ;; *) d_havetlib="$undef" termlib='' echo "You will have to play around with term.c then." >&4 ;; esac echo " ";; *) echo "You said termlib was $termlib before." >&4;; esac;; esac;; esac;; esac metaconfig-debian-perl-5.26.1/dist/U/d_hidnet.U000066400000000000000000000044201316016665300211630ustar00rootroot00000000000000?RCS: $Id: d_hidnet.U 1 2006-08-24 12:32:52Z rmanfredi $ ?RCS: ?RCS: Copyright (c) 1991-1997, 2004-2006, Raphael Manfredi ?RCS: ?RCS: You may redistribute only under the terms of the Artistic Licence, ?RCS: as specified in the README file that comes with the distribution. ?RCS: You may reuse parts of this distribution only within the terms of ?RCS: that same Artistic Licence; a copy of which may be found at the root ?RCS: of the source tree for dist 4.0. ?RCS: ?RCS: $Log: d_hidnet.U,v $ ?RCS: Revision 3.0 1993/08/18 12:06:20 ram ?RCS: Baseline for dist 3.0 netwide release. ?RCS: ?MAKE:d_hidnet hiddennet: cat sed myhostname mydomain Myread Oldconfig ?MAKE: -pick add $@ %< ?S:d_hidnet: ?S: This variable conditionally defines the symbol HIDDEN_NET, which ?S: tells the C program that it should pretend it is on a different ?S: host for purposes of advertising a mailing address. ?S:. ?S:hiddennet: ?S: This variable contains the value eventually given to the symbol ?S: HIDDEN_NET, if d_hidnet defines it. If defined, it's the name ?S: of the host which serves as the mail server for a network that ?S: is invisible to the outside world. ?S:. ?C:HIDDEN_NET (HIDDENNET): ?C: This symbol, if defined, contains the host name that you want to ?C: advertise to the outside world. This name can be different from ?C: your actual host name, as long as the machine you specify knows ?C: how to forward mail to you. ?C:. ?H:#$d_hidnet HIDDEN_NET "$hiddennet" /**/ ?H:. : now get the host name to advertise as our mailing address case "$hiddennet" in '') dflt=n;; *) dflt=y;; esac $cat <