[BACK]Return to bsd.pkg.mk CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / pkgsrc / mk

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /pkgsrc/mk/bsd.pkg.mk between version 1.1540.2.1 and 1.1540.2.26

version 1.1540.2.1, 2004/11/22 22:48:04 version 1.1540.2.26, 2005/03/21 15:43:00
Line 4 
Line 4 
 #  #
 # This file is derived from bsd.port.mk - 940820 Jordan K. Hubbard.  # This file is derived from bsd.port.mk - 940820 Jordan K. Hubbard.
 #  #
 # Please see the NetBSD packages(7) manual page for details on the  # Please see the pkgsrc/doc/guide manual for details on the
 # variables used in this make file template.  # variables used in this make file template.
 #  #
 # Some interesting targets:  # XXX tv: rev 1.1554 is not merged yet (phase "error handlers")
 #  #
 # all:                  Recurses to "make test".  
 # show-var:             Show the value of the variable named by VARNAME.  
 # show-var-noeval:      Same as show-var, but skips phase-specific evaluations.  
 # show-vars:            Show the value of the variables named by VARNAMES.  
 # show-vars-noeval:     Same as show-vars, but skips phase-specific evaluations.  
   
 ############################################################################  ############################################################################
 # Include any preferences, if not already included, and common definitions  # Include any preferences, if not already included, and common definitions
Line 30  _PKG_PHASES_ALL= fetch checksum ${_PKG_P
Line 25  _PKG_PHASES_ALL= fetch checksum ${_PKG_P
 _PKG_PHASES_WRKDIR=     depends extract patch tools wrapper \  _PKG_PHASES_WRKDIR=     depends extract patch tools wrapper \
                         configure build test install package                          configure build test install package
   
 # PATH is recalculated below, so save its original incarnation here.  
 .if !defined(_PATH_ORIG)  
 _PATH_ORIG:=            ${PATH}  
 MAKEFLAGS+=             _PATH_ORIG=${_PATH_ORIG:Q}  
 .endif  
   
 ############################################################################  ############################################################################
 # Transform package Makefile variables and set defaults  # Transform package Makefile variables and set defaults
 ############################################################################  ############################################################################
   
   CHECK_FILES?=           NO      # run check-files after install
   CHECK_FILES_STRICT?=    NO      # make check-files very strict on errors
 CHECK_SHLIBS?=          YES     # run check-shlibs after install  CHECK_SHLIBS?=          YES     # run check-shlibs after install
 CLEANDEPENDS?=          NO  CLEANDEPENDS?=          NO
 DEINSTALLDEPENDS?=      NO      # add -R to pkg_delete  DEINSTALLDEPENDS?=      NO      # add -R to pkg_delete
Line 48  NOCLEAN?=  NO # don't clean up after upd
Line 39  NOCLEAN?=  NO # don't clean up after upd
 REINSTALL?=             NO      # reinstall upon update  REINSTALL?=             NO      # reinstall upon update
 SHLIB_HANDLING?=        YES     # do automatic shared lib handling  SHLIB_HANDLING?=        YES     # do automatic shared lib handling
   
 ### Variant spellings  ##### Variant spellings
   
 .if defined(LICENCE) && !defined(LICENSE)  .if defined(LICENCE) && !defined(LICENSE)
 LICENSE=                ${LICENCE}  LICENSE=                ${LICENCE}
Line 57  LICENSE=  ${LICENCE}
Line 48  LICENSE=  ${LICENCE}
 ACCEPTABLE_LICENSES=    ${ACCEPTABLE_LICENCES}  ACCEPTABLE_LICENSES=    ${ACCEPTABLE_LICENCES}
 .endif  .endif
   
 ### PKGBASE, PKGNAME[_NOREV], PKGVERSION  ##### PKGBASE, PKGNAME[_NOREV], PKGVERSION
   
 PKGBASE?=               ${PKGNAME:C/-[^-]*$//}  PKGBASE?=               ${PKGNAME:C/-[^-]*$//}
 PKGVERSION?=            ${PKGNAME:C/^.*-//}  PKGVERSION?=            ${PKGNAME:C/^.*-//}
Line 74  PKGNAME?=  ${DISTNAME}
Line 65  PKGNAME?=  ${DISTNAME}
 PKGNAME_NOREV=          ${PKGNAME}  PKGNAME_NOREV=          ${PKGNAME}
 .endif  .endif
   
 ### PLIST  ##### PLIST
   
 .if ${PKG_INSTALLATION_TYPE} == "pkgviews"  .if ${PKG_INSTALLATION_TYPE} == "pkgviews"
 PLIST_TYPE?=            dynamic  PLIST_TYPE?=            dynamic
Line 87  PLIST_SRC+=  ${PKGDIR}/PLIST.common
Line 78  PLIST_SRC+=  ${PKGDIR}/PLIST.common
 .  endif  .  endif
 .  if exists(${PKGDIR}/PLIST.${OPSYS})  .  if exists(${PKGDIR}/PLIST.${OPSYS})
 PLIST_SRC+=             ${PKGDIR}/PLIST.${OPSYS}  PLIST_SRC+=             ${PKGDIR}/PLIST.${OPSYS}
 .  elif exists(${PKGDIR}/PLIST)  .  endif
   .  if exists(${PKGDIR}/PLIST.${MACHINE_ARCH:C/i[3-6]86/i386/g})
   PLIST_SRC+=             ${PKGDIR}/PLIST.${MACHINE_ARCH:C/i[3-6]86/i386/g}
   .  endif
   .  if exists(${PKGDIR}/PLIST.${OPSYS}-${MACHINE_ARCH:C/i[3-6]86/i386/g})
   PLIST_SRC+=             ${PKGDIR}/PLIST.${OPSYS}-${MACHINE_ARCH:C/i[3-6]86/i386/g}
   .  endif
   .  if exists(${PKGDIR}/PLIST)
 PLIST_SRC+=             ${PKGDIR}/PLIST  PLIST_SRC+=             ${PKGDIR}/PLIST
 .  endif  .  endif
 .  if exists(${PKGDIR}/PLIST.common_end)  .  if exists(${PKGDIR}/PLIST.common_end)
 PLIST_SRC+=             ${PKGDIR}/PLIST.common_end  PLIST_SRC+=             ${PKGDIR}/PLIST.common_end
 .  endif  .  endif
 .endif  # !PLIST_SRC  .endif # !PLIST_SRC
   
 ### Others  ##### Others
   
 _DISTDIR?=              ${DISTDIR}/${DIST_SUBDIR}  _DISTDIR?=              ${DISTDIR}/${DIST_SUBDIR}
 ALL_TARGET?=            all  
 BUILD_DEFS?=            # empty  BUILD_DEFS?=            # empty
 BUILD_DEPENDS?=         # empty  BUILD_DEPENDS?=         # empty
   BUILD_TARGET?=          all
   COMMENT?=               (no description)
   CONFIGURE_DIRS?=        ${WRKSRC}
   CONFIGURE_SCRIPT?=      ./configure
 DEPENDS?=               # empty  DEPENDS?=               # empty
 DESCR_SRC?=             ${PKGDIR}/DESCR  DESCR_SRC?=             ${PKGDIR}/DESCR
 DIGEST_ALGORITHM?=      SHA1  DIGEST_ALGORITHMS?=     SHA1 RMD160
 DISTFILES?=             ${DISTNAME}${EXTRACT_SUFX}  DISTFILES?=             ${DISTNAME}${EXTRACT_SUFX}
 DISTINFO_FILE?=         ${PKGDIR}/distinfo  DISTINFO_FILE?=         ${PKGDIR}/distinfo
 COMMENT?=               (no description)  
 CONFIGURE_DIRS?=        ${WRKSRC}  
 CONFIGURE_SCRIPT?=      ./configure  
 EXTRACT_ONLY?=          ${DISTFILES}  EXTRACT_ONLY?=          ${DISTFILES}
 EXTRACT_SUFX?=          .tar.gz  EXTRACT_SUFX?=          .tar.gz
   INSTALL_DIRS?=          ${BUILD_DIRS}
   INSTALL_MAKE_FLAGS?=    ${MAKE_FLAGS}
 INSTALL_TARGET?=        install  INSTALL_TARGET?=        install
 INTERACTIVE_STAGE?=     none  INTERACTIVE_STAGE?=     none
 MAINTAINER?=            tech-pkg@NetBSD.org  MAINTAINER?=            tech-pkg@NetBSD.org
 MAKE_FLAGS?=            # empty  MAKE_FLAGS?=            # empty
 MAKEFILE?=              Makefile  MAKEFILE?=              Makefile
   PATCH_DIGEST_ALGORITHM?=SHA1
 PKG_SUFX?=              .tgz  PKG_SUFX?=              .tgz
 PKGFILE?=               ${PKGREPOSITORY}/${PKGNAME}${PKG_SUFX}  PKGFILE?=               ${PKGREPOSITORY}/${PKGNAME}${PKG_SUFX}
 PKGREPOSITORY?=         ${PACKAGES}/${PKGREPOSITORYSUBDIR}  PKGREPOSITORY?=         ${PACKAGES}/${PKGREPOSITORYSUBDIR}
Line 135  BUILD_DEFS_FIXED+= NO_SRC_ON_FTP NO_SRC_
Line 136  BUILD_DEFS_FIXED+= NO_SRC_ON_FTP NO_SRC_
 BUILD_DEFS_FIXED+=      NO_BIN_ON_FTP NO_BIN_ON_CDROM  BUILD_DEFS_FIXED+=      NO_BIN_ON_FTP NO_BIN_ON_CDROM
 BUILD_DEFS_FIXED+=      ${OSVERSION_SPECIFIC:DOSVERSION_SPECIFIC}  BUILD_DEFS_FIXED+=      ${OSVERSION_SPECIFIC:DOSVERSION_SPECIFIC}
   
 ### Non-overridable constants  .if (defined(INSTALL_UNSTRIPPED) && !empty(INSTALL_UNSTRIPPED:M[yY][eE][sS])) || defined(DEBUG_FLAGS)
   _INSTALL_UNSTRIPPED=    # set (flag used by platform/*.mk)
   .endif
   
   ##### Non-overridable constants
   
 # Latest versions of tools required for correct pkgsrc operation.  # Latest versions of tools required for correct pkgsrc operation.
 DIGEST_REQD=            20010302  DIGEST_REQD=            20010302
 PKGTOOLS_REQD=          ${_OPSYS_PKGTOOLS_REQD:U20030918}  PKGTOOLS_REQD=          ${_OPSYS_PKGTOOLS_REQD:U20050204}
   
   PKG_DB_TMPDIR=          ${WRKDIR}/.pkgdb
 DDIR=                   ${WRKDIR}/.DDIR  DDIR=                   ${WRKDIR}/.DDIR
 DESCR=                  ${WRKDIR}/.DESCR  DESCR=                  ${PKG_DB_TMPDIR}/+DESC
 DLIST=                  ${WRKDIR}/.DLIST  DLIST=                  ${WRKDIR}/.DLIST
 PLIST=                  ${WRKDIR}/.PLIST  PLIST=                  ${WRKDIR}/.PLIST
   
 # Files to create for versioning and build information  # Files to create for versioning and build information
 BUILD_VERSION_FILE=     ${WRKDIR}/.build_version  BUILD_VERSION_FILE=     ${PKG_DB_TMPDIR}/+BUILD_VERSION
 BUILD_INFO_FILE=        ${WRKDIR}/.build_info  BUILD_INFO_FILE=        ${PKG_DB_TMPDIR}/+BUILD_INFO
   
 # Files containing size of pkg w/o and w/ all required pkgs  # Files containing size of pkg w/o and w/ all required pkgs
 SIZE_PKG_FILE=          ${WRKDIR}/.SizePkg  SIZE_PKG_FILE=          ${PKG_DB_TMPDIR}/+SIZE_PKG
 SIZE_ALL_FILE=          ${WRKDIR}/.SizeAll  SIZE_ALL_FILE=          ${PKG_DB_TMPDIR}/+SIZE_ALL
   
 # File to denote "no deletion of a package"  # File to denote "no deletion of a package"
 PRESERVE_FILE=          ${WRKDIR}/.PRESERVE  PRESERVE_FILE=          ${PKG_DB_TMPDIR}/+PRESERVE
   
 .for targ in ${_PKG_PHASES_WRKDIR}  .for targ in ${_PKG_PHASES_WRKDIR}
 ${targ}_COOKIE=         ${WRKDIR}/.${targ}_done  ${targ}_COOKIE=         ${WRKDIR}/.${targ}_done
 .endfor  .endfor
   
 ### Transform USE_* into dependencies  ##### Transform USE_* into dependencies
   
 .include "../../mk/bsd.pkg.use.mk"  .include "../../mk/bsd.pkg.use.mk"
   
Line 202  PKG_FAIL_REASON+='them to at least ${PKG
Line 208  PKG_FAIL_REASON+='them to at least ${PKG
 PKG_FAIL_REASON+=''  PKG_FAIL_REASON+=''
 PKG_FAIL_REASON+='      cd ${PKGSRCDIR}/pkgtools/pkg_install && ${MAKE} clean && ${MAKE} install'  PKG_FAIL_REASON+='      cd ${PKGSRCDIR}/pkgtools/pkg_install && ${MAKE} clean && ${MAKE} install'
 .  endif  .  endif
 .endif # NO_PKGTOOLS_REQD_CHECK  .endif # !NO_PKGTOOLS_REQD_CHECK
   
   .if defined(ALL_TARGET)
   PKG_FAIL_REASON+='ALL_TARGET is deprecated and must be replaced with BUILD_TARGET.'
   .endif
   
 .if defined(NO_WRKSUBDIR)  .if defined(NO_WRKSUBDIR)
 PKG_FAIL_REASON+='NO_WRKSUBDIR has been deprecated - please replace it with an explicit'  PKG_FAIL_REASON+='NO_WRKSUBDIR has been deprecated - please replace it with an explicit'
Line 245  PKG_FAIL_REASON+='ONLY/NOT_FOR_ARCHS/OPS
Line 255  PKG_FAIL_REASON+='ONLY/NOT_FOR_ARCHS/OPS
 .endif  .endif
   
 .if (${PKGSRC_LOCKTYPE} == "sleep" || ${PKGSRC_LOCKTYPE} == "once")  .if (${PKGSRC_LOCKTYPE} == "sleep" || ${PKGSRC_LOCKTYPE} == "once")
 . if !defined(OBJHOSTNAME)  .  if !defined(OBJHOSTNAME)
 PKG_FAIL_REASON+='PKGSRC_LOCKTYPE needs OBJHOSTNAME defined.'  PKG_FAIL_REASON+='PKGSRC_LOCKTYPE needs OBJHOSTNAME defined.'
 . elif !exists(${SHLOCK})  .  elif !exists(${SHLOCK})
 PKG_FAIL_REASON+='The ${SHLOCK} utility does not exist, and is necessary for locking.'  PKG_FAIL_REASON+='The ${SHLOCK} utility does not exist, and is necessary for locking.'
 PKG_FAIL_REASON+='Please "${MAKE} install" in ../../pkgtools/shlock.'  PKG_FAIL_REASON+='Please "${MAKE} install" in ../../pkgtools/shlock.'
 . endif  .  endif
 .endif  .endif
   
 #  #
Line 351  ${var}+= ${${var}.*}
Line 361  ${var}+= ${${var}.*}
 .  endfor  .  endfor
   
 CPPFLAGS+=      ${CPP_PRECOMP_FLAGS}  CPPFLAGS+=      ${CPP_PRECOMP_FLAGS}
 DEPENDS+=       ${USE_USERADD:D${_USER_DEPENDS}}  
 DEPENDS+=       ${USE_GROUPADD:D${_USER_DEPENDS}}  
   
 .if !empty(USE_BUILDLINK3:M[nN][oO])  .  if !empty(USE_BUILDLINK3:M[nN][oO])
 LDFLAGS+=       ${COMPILER_RPATH_FLAG}${LOCALBASE}/lib  LDFLAGS+=       ${COMPILER_RPATH_FLAG}${LOCALBASE}/lib
 LDFLAGS+=       -L${LOCALBASE}/lib  LDFLAGS+=       -L${LOCALBASE}/lib
 .endif  .  endif
   
 ALL_ENV+=       CC=${CC:Q}  ALL_ENV+=       CC=${CC:Q}
 ALL_ENV+=       CFLAGS=${CFLAGS:Q}  ALL_ENV+=       CFLAGS=${CFLAGS:Q}
Line 365  ALL_ENV+= CPPFLAGS=${CPPFLAGS:Q}
Line 373  ALL_ENV+= CPPFLAGS=${CPPFLAGS:Q}
 ALL_ENV+=       CXX=${CXX:Q}  ALL_ENV+=       CXX=${CXX:Q}
 ALL_ENV+=       CXXFLAGS=${CXXFLAGS:Q}  ALL_ENV+=       CXXFLAGS=${CXXFLAGS:Q}
 ALL_ENV+=       COMPILER_RPATH_FLAG=${COMPILER_RPATH_FLAG:Q}  ALL_ENV+=       COMPILER_RPATH_FLAG=${COMPILER_RPATH_FLAG:Q}
   ALL_ENV+=       F77=${FC:Q}
   ALL_ENV+=       FC=${FC:Q}
 ALL_ENV+=       FFLAGS=${FFLAGS:Q}  ALL_ENV+=       FFLAGS=${FFLAGS:Q}
   ALL_ENV+=       LANG=C
   ALL_ENV+=       LC_COLLATE=C
   ALL_ENV+=       LC_CTYPE=C
   ALL_ENV+=       LC_MESSAGES=C
   ALL_ENV+=       LC_MONETARY=C
   ALL_ENV+=       LC_NUMERIC=C
   ALL_ENV+=       LC_TIME=C
 ALL_ENV+=       LDFLAGS=${LDFLAGS:Q}  ALL_ENV+=       LDFLAGS=${LDFLAGS:Q}
 ALL_ENV+=       LINKER_RPATH_FLAG=${LINKER_RPATH_FLAG:Q}  ALL_ENV+=       LINKER_RPATH_FLAG=${LINKER_RPATH_FLAG:Q}
 ALL_ENV+=       PATH=${PATH:Q}:${LOCALBASE}/bin:${X11BASE}/bin  ALL_ENV+=       PATH=${PATH:Q}:${LOCALBASE}/bin:${X11BASE}/bin
Line 437  _ULIMIT_CMD+= ${ULIMIT_CMD_${res}:D${ULI
Line 454  _ULIMIT_CMD+= ${ULIMIT_CMD_${res}:D${ULI
 .    endfor  .    endfor
 .  endif  .  endif
   
   # if automatic manual page compression is done by the package according
   # to MANZ's value, set MANCOMPRESSED if MANZ is set
   .  if defined(MANCOMPRESSED_IF_MANZ) && defined(MANZ)
   MANCOMPRESSED=  yes
   MAKE_ENV+=      MANZ=${MANZ}
   .  endif
   
   # CONF_DEPENDS notes a dependency where the config directory for the
   # package matches the dependency's config directory.  CONF_DEPENDS is
   # only meaningful if ${PKG_INSTALLATION_TYPE} == "pkgviews".
   #
   CONF_DEPENDS?=          # empty
   .  if !empty(CONF_DEPENDS)
   USE_PKGINSTALL=         YES
   .  endif
   
 .endif  # !_PKG_SKIPPED  .endif  # !_PKG_SKIPPED
   
 ############################################################################  ############################################################################
Line 511  SCRIPTS_ENV+=  ${_INSTALL_MACROS}
Line 544  SCRIPTS_ENV+=  ${_INSTALL_MACROS}
 .  if defined(USE_GNU_TOOLS) && !empty(USE_GNU_TOOLS:Mmake)  .  if defined(USE_GNU_TOOLS) && !empty(USE_GNU_TOOLS:Mmake)
 MAKE_PROGRAM=           ${GMAKE}  MAKE_PROGRAM=           ${GMAKE}
 .  elif defined(USE_IMAKE)  .  elif defined(USE_IMAKE)
   .    if ${_IMAKE_MAKE} == ${GMAKE}
   USE_GNU_TOOLS+=         make
   .    endif
 MAKE_PROGRAM=           ${_IMAKE_MAKE}  MAKE_PROGRAM=           ${_IMAKE_MAKE}
 .  endif  .  endif
 MAKE_PROGRAM?=          ${MAKE}  MAKE_PROGRAM?=          ${MAKE}
Line 537  PKG_ARGS_BINPKG= -p ${PREFIX:S/^${DESTDI
Line 573  PKG_ARGS_BINPKG= -p ${PREFIX:S/^${DESTDI
 .endif  # !_PKG_SKIPPED  .endif  # !_PKG_SKIPPED
   
 ############################################################################  ############################################################################
 # External bsd.pkg.mk fragments  # External bsd.pkg.mk fragments needing to perform overrides
 ############################################################################  ############################################################################
   
 .if !defined(_PKG_SKIPPED)  .if !defined(_PKG_SKIPPED)
   
 # CONF_DEPENDS notes a dependency where the config directory for the  
 # package matches the dependency's config directory.  CONF_DEPENDS is  
 # only meaningful if ${PKG_INSTALLATION_TYPE} == "pkgviews".  
 #  
 CONF_DEPENDS?=          # empty  
 .  if !empty(CONF_DEPENDS)  
 USE_PKGINSTALL=         YES  
 .  endif  
   
 USE_PKGINSTALL?=        NO  USE_PKGINSTALL?=        NO
 .  if !empty(USE_PKGINSTALL:M[yY][eE][sS])  .  if !empty(USE_PKGINSTALL:M[yY][eE][sS])
 .    include "../../mk/bsd.pkg.install.mk"  .    include "../../mk/bsd.pkg.install.mk"
Line 597  MESSAGE_SRC+= ${PKGDIR}/MESSAGE.${OPSYS}
Line 624  MESSAGE_SRC+= ${PKGDIR}/MESSAGE.${OPSYS}
 .  endif  .  endif
   
 .  if defined(MESSAGE_SRC)  .  if defined(MESSAGE_SRC)
 MESSAGE=                ${WRKDIR}/.MESSAGE  MESSAGE=                ${PKG_DB_TMPDIR}/+DISPLAY
   
 # Set MESSAGE_SUBST to substitute "${variable}" to "value" in MESSAGE  # Set MESSAGE_SUBST to substitute "${variable}" to "value" in MESSAGE
 MESSAGE_SUBST+= LOCALBASE=${LOCALBASE}  MESSAGE_SUBST+= LOCALBASE=${LOCALBASE}
Line 614  MESSAGE_SUBST+= X11PREFIX=${X11PREFIX}
Line 641  MESSAGE_SUBST+= X11PREFIX=${X11PREFIX}
 MESSAGE_SUBST_SED=      ${MESSAGE_SUBST:S/=/}!/:S/$/!g/:S/^/ -e s!\\\${/}  MESSAGE_SUBST_SED=      ${MESSAGE_SUBST:S/=/}!/:S/$/!g/:S/^/ -e s!\\\${/}
 .  endif  .  endif
   
 ### Config file related settings - see Packages.txt  ##### Config file related settings - see doc/guide
   
 PKG_SYSCONFVAR?=        ${PKGBASE}  PKG_SYSCONFVAR?=        ${PKGBASE}
 PKG_SYSCONFSUBDIR?=     # empty  PKG_SYSCONFSUBDIR?=     # empty
Line 651  BUILD_DEFS_FIXED+= PKG_SYSCONFBASEDIR PK
Line 678  BUILD_DEFS_FIXED+= PKG_SYSCONFBASEDIR PK
   
 .endif  # !_PKG_SKIPPED  .endif  # !_PKG_SKIPPED
   
 ### Checksum and other file handling support  ##### Checksum and other file handling support
 # not skipped by _PKG_SKIPPED  # not skipped by _PKG_SKIPPED
   
 ALLFILES?=      ${DISTFILES} ${PATCHFILES}  ALLFILES?=      ${DISTFILES} ${PATCHFILES}
Line 719  _CHECK_VULNERABLE=       \
Line 746  _CHECK_VULNERABLE=       \
                   PKGBASE="${PKGBASE}"                                  \                    PKGBASE="${PKGBASE}"                                  \
                 ${AWK} '/^$$/ { next }                                  \                  ${AWK} '/^$$/ { next }                                  \
                         /^\#.*/ { next }                                \                          /^\#.*/ { next }                                \
                         $$1 !~ ENVIRON["PKGBASE"] { next }              \                          $$1 !~ ENVIRON["PKGBASE"] && $$1 !~ /\{/ { next } \
                         { s = sprintf("${PKG_ADMIN} pmatch \"%s\" %s && ${ECHO} \"*** WARNING - %s vulnerability in %s - see %s for more information ***\"", $$1, ENVIRON["PKGNAME"], $$2, ENVIRON["PKGNAME"], $$3); system(s); } \                          { s = sprintf("${PKG_ADMIN} pmatch \"%s\" %s && ${ECHO} \"*** WARNING - %s vulnerability in %s - see %s for more information ***\"", $$1, ENVIRON["PKGNAME"], $$2, ENVIRON["PKGNAME"], $$3); system(s); } \
                 ' < ${PKGVULNDIR}/pkg-vulnerabilities || ${ECHO} 'could not check pkg-vulnerabilities file'                  ' < ${PKGVULNDIR}/pkg-vulnerabilities || ${ECHO} 'could not check pkg-vulnerabilities file'
   
Line 805  do-checksum: uptodate-digest
Line 832  do-checksum: uptodate-digest
         if [ ! -f ${DISTINFO_FILE} ]; then                              \          if [ ! -f ${DISTINFO_FILE} ]; then                              \
                 ${ECHO_MSG} "=> No checksum file.";                     \                  ${ECHO_MSG} "=> No checksum file.";                     \
         else                                                            \          else                                                            \
                 (cd ${DISTDIR}; OK="true";                              \                  (cd ${DISTDIR}; OK="true"; missing="";                  \
                   for file in "" ${_CKSUMFILES}; do                     \                    for file in "" ${_CKSUMFILES}; do                     \
                         if [ "X$$file" = X"" ]; then continue; fi;      \                          if [ "X$$file" = X"" ]; then continue; fi;      \
                         alg=`${AWK} 'NF == 4 && $$2 == "('$$file')" && $$3 == "=" {print $$1;}' ${DISTINFO_FILE}`; \                          filesummed=false;                               \
                         if [ "X$$alg" = "X" ]; then                     \                          for a in ${DIGEST_ALGORITHMS}; do               \
                                 ${ECHO_MSG} "=> No checksum recorded for $$file."; \                                  CKSUM2=`${AWK} 'NF == 4 && $$1 == "'$$a'" && $$2 == "('$$file')" && $$3 == "=" {print $$4;}' ${DISTINFO_FILE}`; \
                                 OK="false";                             \                                  case "$${CKSUM2}" in                    \
                         else                                            \                                  "")     ${ECHO_MSG} "=> No $$a checksum recorded for $$file."; \
                                 CKSUM=`${DIGEST} $$alg < $$file`;       \                                          ;;                              \
                                 CKSUM2=`${AWK} '$$1 == "'$$alg'" && $$2 == "('$$file')"{print $$4;}' ${DISTINFO_FILE}`; \                                  *)      filesummed=true;                \
                                 if [ "$$CKSUM2" = "IGNORE" ]; then      \                                          CKSUM=`${DIGEST} $$a < $$file`; \
                                         ${ECHO_MSG} "=> Checksum for $$file is set to IGNORE in checksum file even though"; \                                          if [ "$$CKSUM2" = "IGNORE" ]; then \
                                         ${ECHO_MSG} "   the file is not in the "'$$'"{IGNOREFILES} list."; \                                                  ${ECHO_MSG} "=> Checksum for $$file is set to IGNORE in checksum file even though"; \
                                         OK="false";                     \                                                  ${ECHO_MSG} "   the file is not in the "'$$'"{IGNOREFILES} list."; \
                                 elif [ "$$CKSUM" = "$$CKSUM2" ]; then   \                                                  OK="false";             \
                                         ${ECHO_MSG} "=> Checksum OK for $$file."; \                                          elif [ "$$CKSUM" = "$$CKSUM2" ]; then   \
                                 else                                    \                                                  ${ECHO_MSG} "=> Checksum $$a OK for $$file."; \
                                         ${ECHO_MSG} "=> Checksum mismatch for $$file."; \                                          else                            \
                                         OK="false";                     \                                                  ${ECHO_MSG} "=> Checksum $$a mismatch for $$file."; \
                                 fi;                                     \                                                  OK="false";             \
                         fi;                                             \                                          fi ;;                           \
                                   esac;                                   \
                           done;                                           \
                           case "$$filesummed" in                          \
                           false)  missing="$$missing $$file";             \
                                   OK=false ;;                             \
                           esac;                                           \
                   done;                                                 \                    done;                                                 \
                   for file in "" ${_IGNOREFILES}; do                    \                    for file in "" ${_IGNOREFILES}; do                    \
                         if [ "X$$file" = X"" ]; then continue; fi;      \                          if [ "X$$file" = X"" ]; then continue; fi;      \
Line 840  do-checksum: uptodate-digest
Line 873  do-checksum: uptodate-digest
                         fi;                                             \                          fi;                                             \
                   done;                                                 \                    done;                                                 \
                   if [ "$$OK" != "true" ]; then                         \                    if [ "$$OK" != "true" ]; then                         \
                           case "$$missing" in                             \
                           "")     ;;                                      \
                           *)      ${ECHO_MSG} "Missing checksums for $$missing";; \
                           esac;                                           \
                         ${ECHO_MSG} "Make sure the Makefile and checksum file (${DISTINFO_FILE})"; \                          ${ECHO_MSG} "Make sure the Makefile and checksum file (${DISTINFO_FILE})"; \
                         ${ECHO_MSG} "are up to date.  If you want to override this check, type"; \                          ${ECHO_MSG} "are up to date.  If you want to override this check, type"; \
                         ${ECHO_MSG} "\"${MAKE} NO_CHECKSUM=yes [other args]\"."; \                          ${ECHO_MSG} "\"${MAKE} NO_CHECKSUM=yes [other args]\"."; \
Line 864  BUILD_DEFS_FIXED+= IGNORE_RECOMMENDED
Line 901  BUILD_DEFS_FIXED+= IGNORE_RECOMMENDED
 .    endif  .    endif
 .  endif  .  endif
   
   .  include "../../mk/tools.mk"
   
   # If NO_BUILD is defined, default to not needing a compiler.
   .  if defined(NO_BUILD)
   USE_LANGUAGES?=         # empty
   .  endif
   .  include "../../mk/compiler.mk"
   
   # USE_BUILDLINK3 == "no" implies NO_BUILDLINK
   .  if !empty(USE_BUILDLINK3:M[nN][oO])
   NO_BUILDLINK=           yes
   .  endif
   .  if !defined(NO_BUILDLINK)
   .    include "../../mk/buildlink3/bsd.buildlink3.mk"
   .  endif
   
   ##### "depends" target implementation
   
 # Remove some redundant dependencies from the DEPENDS list.  # Remove some redundant dependencies from the DEPENDS list.
 .  include "../../mk/reduce-depends.mk"  .  include "../../mk/reduce-depends.mk"
   
 _REAL_TARGETS.depends+=         depends-message  _REAL_TARGETS.depends+=         depends-message
   
 #===> "install-depends"  #===> "do-depends"
   
 _REAL_TARGETS.depends+=         install-depends  _REAL_TARGETS.depends+=         do-depends
 .PHONY: install-depends  .PHONY: do-depends
 #install-depends:  
   
 .endif  # !empty(PKG_PHASES:Mdepends) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mdepends) && !defined(_PKG_SKIPPED)
   
Line 1024  PATCH_DIST_CAT.${i:S/=/--/}?= { patchfil
Line 1078  PATCH_DIST_CAT.${i:S/=/--/}?= { patchfil
 .  if !empty(PKGSRC_SHOW_PATCH_ERRORMSG:M[yY][eE][sS])  .  if !empty(PKGSRC_SHOW_PATCH_ERRORMSG:M[yY][eE][sS])
 PKGSRC_PATCH_FAIL=                                                      \  PKGSRC_PATCH_FAIL=                                                      \
 if [ -n "${PKG_OPTIONS}" ] || [ -n "${_LOCALPATCHFILES}" ]; then        \  if [ -n "${PKG_OPTIONS}" ] || [ -n "${_LOCALPATCHFILES}" ]; then        \
         ${ECHO} "==========================================================================";                                                           \          ${ECHO} "=========================================================================="; \
         ${ECHO};                                                        \          ${ECHO};                                                        \
         ${ECHO} "Some of the selected build options and/or local patches may be incompatible.";                                                         \          ${ECHO} "Some of the selected build options and/or local patches may be incompatible."; \
         ${ECHO} "Please try building with fewer options or patches.";   \          ${ECHO} "Please try building with fewer options or patches.";   \
         ${ECHO};                                                        \          ${ECHO};                                                        \
         ${ECHO} "==========================================================================";                                                           \          ${ECHO} "=========================================================================="; \
 fi; exit 1  fi; exit 1
 .  endif  .  endif
 PKGSRC_PATCH_FAIL?=     exit 1  PKGSRC_PATCH_FAIL?=     exit 1
   
   _REAL_TARGETS.patch+=   patch-message pre-patch do-patch post-patch
   
 .endif  # !empty(PKG_PHASES:Mpatch) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mpatch) && !defined(_PKG_SKIPPED)
   
 ############################################################################  ############################################################################
Line 1043  PKGSRC_PATCH_FAIL?= exit 1
Line 1099  PKGSRC_PATCH_FAIL?= exit 1
 do-tools: .OPTIONAL  do-tools: .OPTIONAL
 .if !empty(PKG_PHASES:Mtools) && !defined(_PKG_SKIPPED)  .if !empty(PKG_PHASES:Mtools) && !defined(_PKG_SKIPPED)
   
 .  include "../../mk/tools.mk"  _REAL_TARGETS.tools+=   tools-message pre-tools do-tools post-tools
   
 .endif  # !empty(PKG_PHASES:Mtools) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mtools) && !defined(_PKG_SKIPPED)
   
Line 1054  do-tools: .OPTIONAL
Line 1110  do-tools: .OPTIONAL
 do-wrapper: .OPTIONAL  do-wrapper: .OPTIONAL
 .if !empty(PKG_PHASES:Mwrapper) && !defined(_PKG_SKIPPED)  .if !empty(PKG_PHASES:Mwrapper) && !defined(_PKG_SKIPPED)
   
 # If NO_BUILD is defined, default to not needing a compiler.  
 .  if defined(NO_BUILD)  
 USE_LANGUAGES?=         # empty  
 .  endif  
 .  include "../../mk/compiler.mk"  
 .  include "../../mk/wrapper/bsd.wrapper.mk"  .  include "../../mk/wrapper/bsd.wrapper.mk"
   
   _REAL_TARGETS.wrapper+= wrapper-message pre-wrapper do-wrapper post-wrapper
   
 .endif  # !empty(PKG_PHASES:Mwrapper) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mwrapper) && !defined(_PKG_SKIPPED)
   
 ############################################################################  ############################################################################
Line 1072  USE_LANGUAGES?=  # empty
Line 1125  USE_LANGUAGES?=  # empty
 CONFIGURE_ENV+=         ${ALL_ENV}  CONFIGURE_ENV+=         ${ALL_ENV}
 CONFIGURE_ENV+=         ac_given_INSTALL="`${TYPE} ${INSTALL} | ${AWK} '{ print $$NF }'` -c -o ${BINOWN} -g ${BINGRP}"  CONFIGURE_ENV+=         ac_given_INSTALL="`${TYPE} ${INSTALL} | ${AWK} '{ print $$NF }'` -c -o ${BINOWN} -g ${BINGRP}"
 CONFIGURE_ENV+=         AWK=${AWK:Q}  CONFIGURE_ENV+=         AWK=${AWK:Q}
 CONFIGURE_ENV+=         F77=${FC:Q}  
 CONFIGURE_ENV+=         FC=${FC:Q}  
 CONFIGURE_ENV+=         INSTALL="`${TYPE} ${INSTALL} | ${AWK} '{ print $$NF }'` -c -o ${BINOWN} -g ${BINGRP}"  CONFIGURE_ENV+=         INSTALL="`${TYPE} ${INSTALL} | ${AWK} '{ print $$NF }'` -c -o ${BINOWN} -g ${BINGRP}"
 CONFIGURE_ENV+=         MAKE=${MAKE_PROGRAM:T:Q}  CONFIGURE_ENV+=         MAKE=${MAKE_PROGRAM:T:Q}
 CONFIGURE_ENV+=         M4=${M4:Q}  CONFIGURE_ENV+=         M4=${M4:Q}
Line 1088  CONFIG_SHELL?=  ${SH}
Line 1139  CONFIG_SHELL?=  ${SH}
 CONFIGURE_ENV+=         CONFIG_SHELL=${CONFIG_SHELL}  CONFIGURE_ENV+=         CONFIG_SHELL=${CONFIG_SHELL}
 CONFIGURE_ENV+=         install_sh=${INSTALL:Q}  CONFIGURE_ENV+=         install_sh=${INSTALL:Q}
 CONFIGURE_ENV+=         LIBS=${LIBS:Q}  CONFIGURE_ENV+=         LIBS=${LIBS:Q}
 CONFIGURE_ENV+=         ${USE_LIBTOOL:Dlt_cv_sys_max_cmd_len=${_OPSYS_MAX_CMDLEN}}  CONFIGURE_ENV+=         ${USE_LIBTOOL:Dlt_cv_sys_max_cmd_len=${_OPSYS_MAX_CMDLEN_CMD:D${_OPSYS_MAX_CMDLEN_CMD:sh}}}
 #  #
 # GNU_CONFIGURE_PREFIX is the argument to the --prefix option passed to the  # GNU_CONFIGURE_PREFIX is the argument to the --prefix option passed to the
 # GNU configure script.  # GNU configure script.
Line 1114  CONFIG_GUESS_OVERRIDE?=  \
Line 1165  CONFIG_GUESS_OVERRIDE?=  \
         config.guess */config.guess */*/config.guess          config.guess */config.guess */*/config.guess
 CONFIG_SUB_OVERRIDE?=           \  CONFIG_SUB_OVERRIDE?=           \
         config.sub */config.sub */*/config.sub          config.sub */config.sub */*/config.sub
   CONFIG_RPATH_OVERRIDE?=         # set by platform file as needed
 #  #
 # By default, override config.status for GNU configure packages.  We  # By default, override config.status for GNU configure packages.  We
 # never want it to execute after the configure phase has ended as it  # never want it to execute after the configure phase has ended as it
Line 1124  CONFIG_STATUS_OVERRIDE?= \
Line 1176  CONFIG_STATUS_OVERRIDE?= \
         config.status */config.status */*/config.status          config.status */config.status */*/config.status
 .  endif  .  endif
   
   _REAL_TARGETS.configure+=configure-message pre-configure pre-configure-override do-configure post-configure
   
 .endif  # !empty(PKG_PHASES:Mconfigure) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mconfigure) && !defined(_PKG_SKIPPED)
   
 ############################################################################  ############################################################################
Line 1132  CONFIG_STATUS_OVERRIDE?= \
Line 1186  CONFIG_STATUS_OVERRIDE?= \
   
 .if !empty(PKG_PHASES:Mbuild) && !defined(_PKG_SKIPPED)  .if !empty(PKG_PHASES:Mbuild) && !defined(_PKG_SKIPPED)
   
   _REAL_TARGETS.build+=   build-message pre-build do-build post-build
   
 .endif  # !empty(PKG_PHASES:Mbuild) && !defined(_PKG_SKIPPED)  .endif  # !empty(PKG_PHASES:Mbuild) && !defined(_PKG_SKIPPED)
   
 ############################################################################  ############################################################################
Line 1139  CONFIG_STATUS_OVERRIDE?= \
Line 1195  CONFIG_STATUS_OVERRIDE?= \
 ############################################################################  ############################################################################
   
 .if !empty(PKG_PHASES:Mtest)  .if !empty(PKG_PHASES:Mtest)
   
   _REAL_TARGETS.test+=    test-message pre-test do-test post-test
   
 .endif  # !empty(PKG_PHASES:Mtest)  .endif  # !empty(PKG_PHASES:Mtest)
   
 ############################################################################  ############################################################################
Line 1149  CONFIG_STATUS_OVERRIDE?= \
Line 1208  CONFIG_STATUS_OVERRIDE?= \
   
 ##### PLIST manipulation  ##### PLIST manipulation
   
 .  if ${PKG_INSTALLATION_TYPE} == "pkgviews"  .  include "../../mk/plist.mk"
 #  
 # _PLIST_IGNORE_FILES basically mirrors the list of ignored files found  
 # in pkg_views(1).  It's used by the dynamic PLIST generator to skip  
 # adding the named files to the PLIST.  
 #  
 _PLIST_IGNORE_FILES=    +*                      # package metadata files  
 _PLIST_IGNORE_FILES+=   info/dir  
 .    if defined(INFO_DIR) && empty(INFO_DIR:Minfo)  
 _PLIST_IGNORE_FILES+=   ${INFO_DIR}/dir  
 .    endif  
 _PLIST_IGNORE_FILES+=   *[~\#] *.OLD *.orig *,v # scratch config files  
 _PLIST_IGNORE_FILES+=   ${PLIST_IGNORE_FILES}  
   
 PKG_ARGS_INSTALL+=      -U      # don't update the pkgdb.byfile.db  ##### Handle alternatives
 PKG_ARGS_BINPKG+=       -E      # create an empty views file in the binpkg  
 .  endif # PKG_INSTALLATION_TYPE  
   
 BUILD_DEFS_FIXED+=      _PLIST_IGNORE_FILES  .  include "../../mk/alternatives.mk"
   
 ##### Make subtargets for non-su portion of "install".  ##### Make subtargets for non-su portion of "install".
   
Line 1253  init-install:
Line 1298  init-install:
                 ${ECHO_MSG} "***    dependencies, risking various problems."; \                  ${ECHO_MSG} "***    dependencies, risking various problems."; \
                 exit 1;                                                 \                  exit 1;                                                 \
         fi          fi
 .  endif # !NO_PKG_REGISTER && !NO_FORCE_REGISTER && overwrite  .  endif # !NO_PKG_REGISTER && !FORCE_PKG_REGISTER && overwrite
 .  if ${PKG_INSTALLATION_TYPE} == "pkgviews"  .  if ${PKG_INSTALLATION_TYPE} == "pkgviews"
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         found="`${PKG_INFO} -e ${PKGNAME} || ${TRUE}`";                 \          found="`${PKG_INFO} -e ${PKGNAME} || ${TRUE}`";                 \
Line 1263  init-install:
Line 1308  init-install:
         fi          fi
 .  endif  .  endif
         ${_PKG_SILENT}${_PKG_DEBUG}if [ `${SH} -c umask` -ne ${DEF_UMASK} ]; then \          ${_PKG_SILENT}${_PKG_DEBUG}if [ `${SH} -c umask` -ne ${DEF_UMASK} ]; then \
                 ${ECHO_MSG} "${_PKGSRC_IN}>  Warning: your umask is \"`${SH} -c umask`"\".; \                  ${ECHO_MSG} "${_PKGSRC_IN}> Warning: your umask is \"`${SH} -c umask`"\".; \
                 ${ECHO_MSG} "If this is not desired, set it to an appropriate value (${DEF_UMASK})"; \                  ${ECHO_MSG} "If this is not desired, set it to an appropriate value (${DEF_UMASK})"; \
                 ${ECHO_MSG} "and install this package again by \`\`${MAKE} deinstall reinstall''."; \                  ${ECHO_MSG} "and install this package again by \`\`${MAKE} deinstall reinstall''."; \
         fi          fi
   .  if defined(PKG_DEVELOPER) && (${CHECK_FILES} == "YES")
           ${_PKG_SILENT}${_PKG_DEBUG}${ECHO_MSG} "${_PKGSRC_IN}> Generating pre-install file lists"
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${PREFIX} -type f -or -type l -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.prefix.pre \
                   || ${TRUE}
   .    if ${CHECK_FILES_STRICT} == "YES"
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${PKG_SYSCONFDIR} -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.sysconfdir.pre \
                   || ${TRUE}
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${VARBASE} -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.varbase.pre \
                   || ${TRUE}
   .    endif
   .  endif
 .  if defined(INSTALLATION_DIRS) && !empty(INSTALLATION_DIRS)  .  if defined(INSTALLATION_DIRS) && !empty(INSTALLATION_DIRS)
         ${_PKG_SILENT}${_PKG_DEBUG}${ECHO_MSG} "${_PKGSRC_IN}> Creating installation directories"          ${_PKG_SILENT}${_PKG_DEBUG}${ECHO_MSG} "${_PKGSRC_IN}> Creating installation directories"
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
Line 1301  init-install:
Line 1360  init-install:
         ${_PKG_SILENT}${_PKG_DEBUG}[ -d ${PREFIX} ] || ${MKDIR} ${PREFIX}          ${_PKG_SILENT}${_PKG_DEBUG}[ -d ${PREFIX} ] || ${MKDIR} ${PREFIX}
 .  endif # !NO_MTREE  .  endif # !NO_MTREE
   
   #===> "pre-install-fake-pkg"
   
   .  if !defined(NO_PKG_REGISTER)
   _REAL_TARGETS.su-install+=      pre-install-fake-pkg
   .  endif # !NO_PKG_REGISTER
   
 #===> "pre-install-script"  #===> "pre-install-script"
   
 _REAL_TARGETS.su-install+=      pre-install-script  _REAL_TARGETS.su-install+=      pre-install-script
Line 1316  pre-install: .OPTIONAL
Line 1381  pre-install: .OPTIONAL
 #===> "do-install"  #===> "do-install"
   
 _REAL_TARGETS.su-install+=      do-install  _REAL_TARGETS.su-install+=      do-install
   .PHONY: do-install
   .if !target(do-install)
   do-install:
   .  for DIR in ${INSTALL_DIRS}
           ${_PKG_SILENT}${_PKG_DEBUG}${_ULIMIT_CMD}cd ${DIR} && ${SETENV} ${MAKE_ENV} ${MAKE_PROGRAM} ${INSTALL_MAKE_FLAGS} -f ${MAKEFILE} ${INSTALL_TARGET}
   .  endfor
   .endif
   
 #===> "post-install"  #===> "post-install"
   
Line 1338  _REAL_TARGETS.su-install+= plist
Line 1410  _REAL_TARGETS.su-install+= plist
 .PHONY: plist  .PHONY: plist
 plist: ${PLIST}  plist: ${PLIST}
   
   #===> "post-install-check-files"
   
   .if defined(PKG_DEVELOPER) && (${CHECK_FILES} == "YES")
   _REAL_TARGETS.su-install+=      post-install-check-files
   .PHONY: post-install-check-files
   post-install-check-files:
           ${_PKG_SILENT}${_PKG_DEBUG}${ECHO_MSG} "${_PKGSRC_IN}> Generating post-install file lists"
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${PREFIX} -type f -or -type l -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.prefix.post \
                   || ${TRUE}
   .  if ${CHECK_FILES_STRICT} == "YES"
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${PKG_SYSCONFDIR} -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.sysconfdir.post\
                   || ${TRUE}
           ${_PKG_SILENT}${_PKG_DEBUG}${FIND} ${VARBASE} -print \
                   2>/dev/null ${CHECK_FILES_SKIP_CMD} >${WRKDIR}/.varbase.post \
                   || ${TRUE}
   .  endif
   .endif
   
 #===> "post-install-script"  #===> "post-install-script"
   
 _REAL_TARGETS.su-install+=      post-install-script  _REAL_TARGETS.su-install+=      post-install-script
Line 1378  post-install-man:
Line 1470  post-install-man:
                 for manpage in $$newmanpages; do                        \                  for manpage in $$newmanpages; do                        \
                         manpage=`${ECHO} $$manpage | ${SED} -e 's|\.gz$$||'`; \                          manpage=`${ECHO} $$manpage | ${SED} -e 's|\.gz$$||'`; \
                         if [ -h ${PREFIX}/$$manpage ]; then             \                          if [ -h ${PREFIX}/$$manpage ]; then             \
                                 set - `${LS} -l ${PREFIX}/$$manpage`; \                                  set - `${LS} -l ${PREFIX}/$$manpage`;   \
                                 shift `expr $$# - 1`;                   \                                  shift `expr $$# - 1`;                   \
                                 ${RM} -f ${PREFIX}/$$manpage.gz;        \                                  ${RM} -f ${PREFIX}/$$manpage.gz;        \
                                 ${LN} -s $${1}.gz ${PREFIX}/$$manpage.gz; \                                  ${LN} -s $${1}.gz ${PREFIX}/$$manpage.gz; \
Line 1427  post-install-message:
Line 1519  post-install-message:
 .    endif  .    endif
 .  endif  .  endif
   
 #===> "fake-pkg"  #===> "register-pkg"
   
 _REAL_TARGETS.su-install+=      fake-pkg  .  if !defined(NO_PKG_REGISTER)
   _REAL_TARGETS.su-install+=      register-pkg
   .  endif # !NO_PKG_REGISTER
   
 #===> "check-shlibs"  #===> "check-shlibs"
   
Line 1437  _REAL_TARGETS.su-install+= fake-pkg
Line 1531  _REAL_TARGETS.su-install+= fake-pkg
 _REAL_TARGETS.su-install+=      check-shlibs  _REAL_TARGETS.su-install+=      check-shlibs
 .  endif  .  endif
   
   #===> "check-files"
   
   .  if defined(PKG_DEVELOPER) && (${CHECK_FILES} == "YES")
   _REAL_TARGETS.su-install+=      check-files
   .  endif
   
 .endif  # !empty(PKG_PHASES:Minstall)  .endif  # !empty(PKG_PHASES:Minstall)
   
 ############################################################################  ############################################################################
   # Special install phase `replace'
   ############################################################################
   
   _REAL_TARGETS.replace+= do-su-replace
   
   _REAL_TARGETS.su-replace+=
   
   _REAL_TARGETS.undo-replace+= do-su-undo-replace
   
   ############################################################################
 # Phase `package'  # Phase `package'
 ############################################################################  ############################################################################
   
   .PHONY: descr
   descr: ${DESCR}
   ${DESCR}: ${DESCR_SRC}
           @${CAT} ${DESCR_SRC}     >${DESCR}
   .if defined(HOMEPAGE)
           @\
           ${ECHO}                 >>${DESCR} ; \
           ${ECHO} "Homepage:"     >>${DESCR} ; \
           ${ECHO} '${HOMEPAGE}'   >>${DESCR}
   .endif
   
   _REAL_TARGETS.package+= do-su-package
   
   _REAL_TARGETS.su-package+=
   
 ############################################################################  ############################################################################
 # Recursive invocation support  # Variables calculated after all the above, and recursion support
 ############################################################################  ############################################################################
   
   # explicit "-f Makefile" here to work around problems with the MAKEFILE var
   # and case-insensitive filesystems (see PR pkg/28392)
   #
 .for targ in ${_PKG_PHASES_ALL}  .for targ in ${_PKG_PHASES_ALL}
 .PHONY: recurse-${targ}  .PHONY: recurse-${targ}
 recurse-${targ}:  recurse-${targ}:
         ${_PKG_SILENT}${_PKG_DEBUG}cd ${PKGDIR} && ${MAKE} ${targ}          ${_PKG_SILENT}${_PKG_DEBUG}cd ${PKGDIR} && ${MAKE} -f Makefile ${targ}
 .endfor  .endfor
   
 # Find out the PREFIX of dependencies where the PREFIX is needed at build time.  
 .if defined(EVAL_PREFIX)  
 .  for def in ${EVAL_PREFIX}  
 .    if !defined(${def:C/=.*$//})  
 ${def:C/=.*$//}_DEFAULT?=${LOCALBASE}  
 _${def:C/=.*$//}_CMD=   ${PKG_INFO} -qp ${def:C/^.*=//} 2>/dev/null | ${AWK} '{ print $$2; exit }' | grep '' || ${ECHO} ${${def:C/=.*$//}_DEFAULT}  
 ${def:C/=.*$//}=        ${_${def:C/=.*$//}_CMD:sh}  
 .    endif  
 .  endfor  
 .endif  
   
 # convenience target, to display make variables from command line  # convenience target, to display make variables from command line
 # i.e. "make show-var VARNAME=var", will print var's value  # i.e. "make show-var VARNAME=var", will print var's value
 .PHONY: show-var show-var-noeval  .PHONY: show-var show-var-noeval
Line 1477  show-vars show-vars-noeval:
Line 1594  show-vars show-vars-noeval:
         @${ECHO} ${${VARNAME}:Q}          @${ECHO} ${${VARNAME}:Q}
 .endfor  .endfor
   
 PREPEND_PATH?=          # empty  # Find out the PREFIX of dependencies where the PREFIX is needed at build time.
   .if defined(EVAL_PREFIX)
   .  for def in ${EVAL_PREFIX}
   .    if !defined(${def:C/=.*$//})
   ${def:C/=.*$//}_DEFAULT?=${LOCALBASE}
   _${def:C/=.*$//}_CMD=   ${PKG_INFO} -qp ${def:C/^.*=//} 2>/dev/null | ${AWK} '{ print $$2; exit }' | ${GREP} . || ${ECHO} ${${def:C/=.*$//}_DEFAULT}
   ${def:C/=.*$//}=        ${_${def:C/=.*$//}_CMD:sh}
   .    endif
   .  endfor
   .endif
   
   .if !defined(_PATH_ORIG)
   _PATH_ORIG:=            ${PATH}
   MAKEFLAGS+=             _PATH_ORIG=${_PATH_ORIG:Q}
   .endif
   
 .if !empty(PREPEND_PATH)  .if !empty(PREPEND_PATH)
 # This is very Special.  Because PREPEND_PATH is set with += in reverse order,  # This is very Special.  Because PREPEND_PATH is set with += in reverse order,
 # the awk expression reverses the order again (since bootstrap bmake doesn't  # the awk expression reverses the order again (since bootstrap bmake doesn't
 # yet support the :[-1..1] construct).  # yet support the :[-1..1] construct).
 _PATH_CMD=              ${ECHO} `${ECHO} ${PREPEND_PATH:Q} | ${AWK} '{for (i=NF;i>0;i--) print $$i}'`:${_PATH_ORIG} | ${TR} ' ' :  _PATH_CMD=              ${ECHO} `${ECHO} ${PREPEND_PATH:Q} | ${AWK} '{ORS=":";for (i=NF;i>0;i--) print $$i}'`${_PATH_ORIG}
 PATH=                   ${_PATH_CMD:sh} # DOES NOT use :=, to defer evaluation  PATH=                   ${_PATH_CMD:sh} # DOES NOT use :=, to defer evaluation
 .endif  .endif
   
Line 1504  _PKG_ALL_TARGET= test
Line 1636  _PKG_ALL_TARGET= test
 .MAIN: all  .MAIN: all
 all dependall: recurse-${_PKG_ALL_TARGET:Ubuild}  all dependall: recurse-${_PKG_ALL_TARGET:Ubuild}
   
 ### If this package will be skipped, use placebo targets.  # Depend is generally meaningless for arbitrary packages, but if someone wants
   # one they can override this.  This is just to catch people who've gotten into
   # the habit of typing `${MAKE} depend all install' as a matter of course.
   
   .PHONY: depend
   depend: .OPTIONAL
   
   # Same goes for tags
   .PHONY: tags
   tags: .OPTIONAL
   
   ##### If this package will be skipped, use placebo targets.
   
 .if defined(_PKG_SKIPPED)  .if defined(_PKG_SKIPPED)
 .  for targ in ${_PKG_PHASES_ALL} replace update  
   .  for targ in ${_PKG_PHASES_ALL} \
                   replace undo-replace \
                   update
 ${targ}:  ${targ}:
 .    if !defined(SKIP_SILENT)  .    if !defined(SKIP_SILENT)
         @for str in ${PKG_FAIL_REASON} ${PKG_SKIP_REASON} ; \          @for str in ${PKG_FAIL_REASON} ${PKG_SKIP_REASON}; do           \
         do \                  ${ECHO} "${_PKGSRC_IN}> $$str";                         \
                 ${ECHO} "${_PKGSRC_IN}> $$str" ; \  
         done          done
 .    endif  .    endif
 .    if defined(PKG_FAIL_REASON)  .    if defined(PKG_FAIL_REASON)
         @${FALSE}          @${FALSE}
 .    endif  .    endif
 .  endfor  .  endfor
 .endif  # _PKG_SKIPPED  
   
 ### Skip specific phases based on package settings.  
   
 .if defined(NO_PACKAGE) && !defined(FORCE_PACKAGE)  
 real-package: .MADE  
 .  if !defined(SKIP_SILENT)  
         @${ECHO_MSG} "${_PKGSRC_IN}> ${PKGNAME} may not be packaged: ${NO_PACKAGE}."  
 .  endif  
 .endif  
   
 ### Real targets.  These don't have any commands attached; they simply defer  .else   # !defined(_PKG_SKIPPED)
 ### to other implementation targets below.  
   
 .if !defined(_PKG_SKIPPED)  ##### Real targets.  These don't have any commands attached; they simply defer
   ##### to other implementation targets below.
   
 .PHONY: ${_PKG_PHASES_ALL} replace undo-replace  .PHONY: ${_PKG_PHASES_ALL} replace undo-replace
 fetch: real-fetch  fetch: real-fetch
Line 1551  package: install acquire-package-lock ${
Line 1686  package: install acquire-package-lock ${
 replace: build real-replace  replace: build real-replace
 undo-replace: real-undo-replace  undo-replace: real-undo-replace
   
 .endif  # !defined(_PKG_SKIPPED)  ##### *_COOKIE to real-* layer for targets which use cookies.
   
 ############################################################################  
 # Package maintenance targets  
 ############################################################################  
   
 # Checksumming utilities  
   
 .PHONY: makesum  .  for targ in ${_PKG_PHASES_WRKDIR}
 makesum: recurse-fetch uptodate-digest  ${${targ}_COOKIE}: real-${targ}
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f $@ && ${ECHO} ${PKGNAME} >$@
         newfile=${DISTINFO_FILE}.$$$$;                                  \  .  endfor
         if [ -f ${DISTINFO_FILE} ]; then                                \  
                 ${GREP} '^.NetBSD' ${DISTINFO_FILE} > $$newfile ||      \  
                         (${ECHO_N} "$$" > $$newfile &&                  \  
                          ${ECHO_N} "NetBSD" >> $$newfile &&             \  
                          ${ECHO} "$$" >> $$newfile)                     \  
         else                                                            \  
                 ${ECHO_N} "$$" > $$newfile;                             \  
                 ${ECHO_N} "NetBSD" >> $$newfile;                        \  
                 ${ECHO} "$$" >> $$newfile;                              \  
         fi;                                                             \  
         ${ECHO} "" >> $$newfile;                                        \  
         cd ${DISTDIR};                                                  \  
         for sumfile in "" ${_CKSUMFILES}; do                            \  
                 if [ "X$$sumfile" = "X" ]; then continue; fi;           \  
                 ${DIGEST} ${DIGEST_ALGORITHM} $$sumfile >> $$newfile;   \  
                 ${WC} -c $$sumfile | ${AWK} '{ print "Size (" $$2 ") = " $$1 " bytes" }' >> $$newfile; \  
         done;                                                           \  
         for ignore in "" ${_IGNOREFILES}; do                            \  
                 if [ "X$$ignore" = "X" ]; then continue; fi;            \  
                 ${ECHO} "${DIGEST_ALGORITHM} ($$ignore) = IGNORE" >> $$newfile; \  
         done;                                                           \  
         if [ -f ${DISTINFO_FILE} ]; then                                \  
                 ${AWK} '$$2 ~ /\(patch-[a-z0-9]+\)/ { print $$0 }' < ${DISTINFO_FILE} >> $$newfile; \  
         fi;                                                             \  
         if ${CMP} -s $$newfile ${DISTINFO_FILE}; then                   \  
                 ${RM} -f $$newfile;                                     \  
                 ${ECHO_MSG} "=> distinfo: distfiles part unchanged.";   \  
         else                                                            \  
                 ${MV} $$newfile ${DISTINFO_FILE};                       \  
         fi  
   
 .PHONY: makepatchsum mps  # mark a stage as complete if its cookie (and all parent cookies) exist
 makepatchsum mps: uptodate-digest  .  if exists(${depends_COOKIE})
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  ${depends_COOKIE}: .MADE
         newfile=${DISTINFO_FILE}.$$$$;                                  \  .    if exists(${extract_COOKIE})
         if [ -f ${DISTINFO_FILE} ]; then                                \  ${extract_COOKIE}: .MADE
                 ${AWK} '$$2 !~ /\(patch-[a-z0-9]+\)/ { print $$0 }' < ${DISTINFO_FILE} >> $$newfile; \  .      if exists(${patch_COOKIE})
         else \  ${patch_COOKIE}: .MADE
                 ${ECHO_N} "$$" > $$newfile;                             \  .        if exists(${tools_COOKIE})
                 ${ECHO_N} "NetBSD" >> $$newfile;                        \  ${tools_COOKIE}: .MADE
                 ${ECHO} "$$" >> $$newfile;                              \  .          if exists(${wrapper_COOKIE})
                 ${ECHO} "" >> $$newfile;                                \  ${wrapper_COOKIE}: .MADE
         fi;                                                             \  .            if exists(${configure_COOKIE})
         if [ -d ${PATCHDIR} ]; then                                     \  ${configure_COOKIE}: .MADE
                 (cd ${PATCHDIR};                                        \  .              if exists(${build_COOKIE})
                 for sumfile in "" patch-*; do                           \  ${build_COOKIE}: .MADE
                         if [ "X$$sumfile" = "X" ]; then continue; fi;   \  .                if exists(${test_COOKIE})
                         if [ "X$$sumfile" = "Xpatch-*" ]; then break; fi; \  ${test_COOKIE}: .MADE
                         case $$sumfile in                               \  .                  if exists(${install_COOKIE})
                                 patch-local-*) ;;                       \  ${install_COOKIE}: .MADE
                                 *.orig|*.rej|*~) continue ;;            \  .                    if exists(${package_COOKIE})
                                 *)      ${ECHO} "${DIGEST_ALGORITHM} ($$sumfile) = `${SED} -e '/\$$NetBSD.*/d' $$sumfile | ${DIGEST} ${DIGEST_ALGORITHM}`" >> $$newfile;; \  ${package_COOKIE}: .MADE
                         esac;                                           \  .                    endif
                 done);                                                  \  .                  endif
         fi;                                                             \  .                endif
         if ${CMP} -s $$newfile ${DISTINFO_FILE}; then                   \  .              endif
                 ${RM} -f $$newfile;                                     \  .            endif
                 ${ECHO_MSG} "=> distinfo: patches part unchanged.";     \  .          endif
         else                                                            \  .        endif
                 ${MV} $$newfile ${DISTINFO_FILE};                       \  .      endif
         fi  .    endif
   .  endif
   
 makedistinfo mdi distinfo: makesum makepatchsum  ##### NO_* for skipping phases
   
 ############################################################################  .  if defined(NO_DEPENDS) || (empty(DEPENDS) && empty(BUILD_DEPENDS))
   ${depends_COOKIE}: .MADE
   .  endif
   .  if defined(NO_TOOLS)
   ${tools_COOKIE}: .MADE
   .  endif
   .  if defined(NO_WRAPPER)
   ${wrapper_COOKIE}: .MADE
   .  endif
   .  if defined(NO_CONFIGURE)
   ${configure_COOKIE}: .MADE
   .  endif
   .  if defined(NO_BUILD)
   ${build_COOKIE}: .MADE
   .  endif
   .  if empty(PKGSRC_RUN_TEST:M[yY][eE][sS])
   real-test: .MADE
   .  endif
   .  if defined(NO_INSTALL)
   ${install_COOKIE}: .MADE
   .  endif
   
   .  if defined(NO_PACKAGE) && !defined(FORCE_PACKAGE)
   _REAL_TARGETS.package:= no-package
   no-package:
   .    if !defined(SKIP_SILENT)
           @${ECHO_MSG} "${_PKGSRC_IN}> ${PKGNAME} may not be packaged: ${NO_PACKAGE}."
   .    endif
   .  endif
   
   .  for targ in extract configure build install
   .    if !empty(INTERACTIVE_STAGE:M${targ}) && defined(BATCH)
   _REAL_TARGETS.${targ}:= ${targ}-is-interactive
   ${targ}-is-interactive:
           @${ECHO} "*** The ${targ} stage of this package requires user interaction"
           @${ECHO} "*** Please ${targ} manually with \"cd ${PKGDIR} && ${MAKE} ${targ}\""
           @${FALSE}
   .    endif
   .  endfor
   
   ##### User-visible messages for most targets
   
   _PHASE_MSG.depends=     Verifying dependencies
   _PHASE_MSG.extract=     Extracting
   _PHASE_MSG.patch=       Patching
   _PHASE_MSG.tools=       Overriding tools
   _PHASE_MSG.wrapper=     Creating toolchain wrappers
   _PHASE_MSG.configure=   Configuring
   _PHASE_MSG.build=       Building
   _PHASE_MSG.test=        Testing
   _PHASE_MSG.install=     Installing
   _PHASE_MSG.package=     Packaging
   
   .  for targ in ${_PKG_PHASES_WRKDIR}
   .PHONY: ${targ}-message
   ${targ}-message:
           @${ECHO_MSG} "${_PKGSRC_IN}> ${_PHASE_MSG.${targ}} for ${PKGNAME}"
   .  endfor
   
   ##### real-* to actual component target layer
   
   # Simple dependencies are not used, deliberately, so that it is possible
   # to invoke a single subtarget by hand while working on a new package.
   #
   # Please note that the order of the targets in _REAL_TARGETS.<phase> is
   # important, and should not be modified (.ORDER is not recognized by
   # make(1) in a serial make; i.e., without "-j n").
   
   .  for targ in ${_PKG_PHASES_ALL} replace undo-replace su-install
   .PHONY: real-${targ}
   .ORDER: ${_REAL_TARGETS.${targ}}
   real-${targ}: ${_REAL_TARGETS.${targ}}
   .  endfor
   
   .endif  # !defined(_PKG_SKIPPED)
   
   ##### su target support
   
   .for targ in install package replace undo-replace deinstall
   .PHONY: do-su-${targ}
   do-su-${targ}:
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           if [ `${ID} -u` = `${ID} -u ${ROOT_USER}` ]; then               \
                   ${MAKE} ${MAKEFLAGS} $$realtarget;                      \
           elif [ "X${BATCH}" != X"" ]; then                               \
                   ${ECHO_MSG} "Warning: Batch mode, not superuser, can't run $$action for ${PKGNAME}."; \
                   ${ECHO_MSG} "Become ${ROOT_USER} and try again to ensure correct permissions."; \
           else                                                            \
                   args="DEINSTALLDEPENDS=${DEINSTALLDEPENDS}";            \
                   if [ "X${FORCE_PKG_REGISTER}" != X"" ]; then            \
                           args="$$args FORCE_PKG_REGISTER=1";             \
                   fi;                                                     \
                   if [ "X${PKG_DEBUG_LEVEL}" != X"" ]; then               \
                           args="$$args PKG_DEBUG_LEVEL=${PKG_DEBUG_LEVEL}"; \
                   fi;                                                     \
                   if [ "X${PRE_ROOT_CMD}" != "X${TRUE}" ]; then           \
                           ${ECHO} "*** WARNING *** Running: ${PRE_ROOT_CMD}"; \
                           ${PRE_ROOT_CMD};                                \
                   fi;                                                     \
                   ${ECHO_MSG} "${_PKGSRC_IN}> Becoming ${ROOT_USER}@`${HOSTNAME_CMD}` to ${targ} ${PKGBASE}."; \
                   ${ECHO_N} "`${ECHO} ${SU_CMD} | ${AWK} '{ print $$1 }'` ";\
                   ${SU_CMD} "cd ${.CURDIR}; ${SETENV} PATH=$${PATH}:${SU_CMD_PATH_APPEND} ${MAKE} $$args ${MAKEFLAGS} real-su-${targ} $$realflags"; \
           fi
   .endfor
   
   ############################################################################
   # Package maintenance targets
   ############################################################################
   
   # Checksumming utilities
   
   .PHONY: makesum
   makesum: recurse-fetch uptodate-digest
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           newfile=${DISTINFO_FILE}.$$$$;                                  \
           if [ -f ${DISTINFO_FILE} ]; then                                \
                   ${GREP} '^.NetBSD' ${DISTINFO_FILE} > $$newfile ||      \
                           (${ECHO_N} "$$" > $$newfile &&                  \
                            ${ECHO_N} "NetBSD" >> $$newfile &&             \
                            ${ECHO} "$$" >> $$newfile)                     \
           else                                                            \
                   ${ECHO_N} "$$" > $$newfile;                             \
                   ${ECHO_N} "NetBSD" >> $$newfile;                        \
                   ${ECHO} "$$" >> $$newfile;                              \
           fi;                                                             \
           ${ECHO} "" >> $$newfile;                                        \
           cd ${DISTDIR};                                                  \
           for sumfile in "" ${_CKSUMFILES}; do                            \
                   if [ "X$$sumfile" = "X" ]; then continue; fi;           \
                   for a in "" ${DIGEST_ALGORITHMS}; do                    \
                           if [ "X$$a" = "X" ]; then continue; fi;         \
                           ${DIGEST} $$a $$sumfile >> $$newfile;           \
                   done;                                                   \
                   ${WC} -c $$sumfile | ${AWK} '{ print "Size (" $$2 ") = " $$1 " bytes" }' >> $$newfile; \
           done;                                                           \
           for ignore in "" ${_IGNOREFILES}; do                            \
                   if [ "X$$ignore" = "X" ]; then continue; fi;            \
                   for a in "" ${DIGEST_ALGORITHMS}; do                    \
                           if [ "X$$a" = "X" ]; then continue; fi;         \
                           ${ECHO} "$$a ($$ignore) = IGNORE" >> $$newfile; \
                   done;                                                   \
           done;                                                           \
           if [ -f ${DISTINFO_FILE} ]; then                                \
                   ${AWK} '$$2 ~ /\(patch-[a-z0-9]+\)/ { print $$0 }' < ${DISTINFO_FILE} >> $$newfile; \
           fi;                                                             \
           if ${CMP} -s $$newfile ${DISTINFO_FILE}; then                   \
                   ${RM} -f $$newfile;                                     \
                   ${ECHO_MSG} "=> distinfo: distfiles part unchanged.";   \
           else                                                            \
                   ${MV} $$newfile ${DISTINFO_FILE};                       \
           fi
   
   .PHONY: makepatchsum mps
   makepatchsum mps: uptodate-digest
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           newfile=${DISTINFO_FILE}.$$$$;                                  \
           if [ -f ${DISTINFO_FILE} ]; then                                \
                   ${AWK} '$$2 !~ /\(patch-[a-z0-9]+\)/ { print $$0 }' < ${DISTINFO_FILE} >> $$newfile; \
           else \
                   ${ECHO_N} "$$" > $$newfile;                             \
                   ${ECHO_N} "NetBSD" >> $$newfile;                        \
                   ${ECHO} "$$" >> $$newfile;                              \
                   ${ECHO} "" >> $$newfile;                                \
           fi;                                                             \
           if [ -d ${PATCHDIR} ]; then                                     \
                   (cd ${PATCHDIR};                                        \
                   for sumfile in "" patch-*; do                           \
                           if [ "X$$sumfile" = "X" ]; then continue; fi;   \
                           if [ "X$$sumfile" = "Xpatch-*" ]; then break; fi; \
                           case $$sumfile in                               \
                                   patch-local-*) ;;                       \
                                   *.orig|*.rej|*~) continue ;;            \
                                   *)      ${ECHO} "${PATCH_DIGEST_ALGORITHM} ($$sumfile) = `${SED} -e '/\$$NetBSD.*/d' $$sumfile | ${DIGEST} ${DIGEST_ALGORITHM}`" >> $$newfile;; \
                           esac;                                           \
                   done);                                                  \
           fi;                                                             \
           if ${CMP} -s $$newfile ${DISTINFO_FILE}; then                   \
                   ${RM} -f $$newfile;                                     \
                   ${ECHO_MSG} "=> distinfo: patches part unchanged.";     \
           else                                                            \
                   ${MV} $$newfile ${DISTINFO_FILE};                       \
           fi
   
   makedistinfo mdi distinfo: makesum makepatchsum
   
   ############################################################################
 # XXXTV CUT  # XXXTV CUT
 ############################################################################  ############################################################################
   
Line 1660  _RESUME_TRANSFER=       \
Line 1945  _RESUME_TRANSFER=       \
         tsize=`${AWK} '/^Size/ && $$2 == '"\"($$file)\""' { print $$4 }' ${DISTINFO_FILE}` || ${TRUE}; \          tsize=`${AWK} '/^Size/ && $$2 == '"\"($$file)\""' { print $$4 }' ${DISTINFO_FILE}` || ${TRUE}; \
         if [ ! -f "${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp" ]; then      \          if [ ! -f "${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp" ]; then      \
                 ${CP} ${DISTDIR}/${DIST_SUBDIR}/$$bfile ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp; \                  ${CP} ${DISTDIR}/${DIST_SUBDIR}/$$bfile ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp; \
         fi;     \          fi;                                                             \
         dsize=`${WC} -c < ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp`;      \          dsize=`${WC} -c < ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp`;      \
         if [ "$$dsize" -eq "$$tsize" -a -f "${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp" ]; then     \          if [ "$$dsize" -eq "$$tsize" -a -f "${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp" ]; then \
                 ${MV} ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp ${DISTDIR}/${DIST_SUBDIR}/$$bfile; \                  ${MV} ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp ${DISTDIR}/${DIST_SUBDIR}/$$bfile; \
         fi;     \          fi;                                                             \
         case "$$tsize" in                                               \          case "$$tsize" in                                               \
         "")     ${ECHO_MSG} "No size in distinfo file (${DISTINFO_FILE})"; \          "")     ${ECHO_MSG} "No size in distinfo file (${DISTINFO_FILE})"; \
                 break ;;                                                \                  break ;;                                                \
Line 1673  _RESUME_TRANSFER=       \
Line 1958  _RESUME_TRANSFER=       \
                 ${ECHO_MSG} "===> Resume is not supported by ftp(1) using http/ftp proxies.";   \                  ${ECHO_MSG} "===> Resume is not supported by ftp(1) using http/ftp proxies.";   \
                 break;                                                  \                  break;                                                  \
         else                                                            \          else                                                            \
                 if [ "$$dsize" -lt "$$tsize" ]; then            \                  if [ "$$dsize" -lt "$$tsize" ]; then                    \
                         if [ "${FETCH_CMD:T}" != "ftp" -a -z "${FETCH_RESUME_ARGS}" ]; then \                          if [ "${FETCH_CMD:T}" != "ftp" -a -z "${FETCH_RESUME_ARGS}" ]; then \
                                 ${ECHO_MSG} "=> Resume transfers are not supported, FETCH_RESUME_ARGS is empty."; \                                  ${ECHO_MSG} "=> Resume transfers are not supported, FETCH_RESUME_ARGS is empty."; \
                                 break;                                  \                                  break;                                  \
                         else                                            \                          else                                            \
                                 for res_site in $$sites; do                     \                                  for res_site in $$sites; do             \
                                         if [ -z "${FETCH_OUTPUT_ARGS}" ]; then  \                                          if [ -z "${FETCH_OUTPUT_ARGS}" ]; then \
                                                 ${ECHO_MSG} "=> FETCH_OUTPUT_ARGS has to be defined.";  \                                                  ${ECHO_MSG} "=> FETCH_OUTPUT_ARGS has to be defined."; \
                                                 break;                  \                                                  break;                  \
                                         fi;                             \                                          fi;                             \
                                         ${ECHO_MSG} "=> $$bfile not completed, resuming:";      \                                          ${ECHO_MSG} "=> $$bfile not completed, resuming:"; \
                                         ${ECHO_MSG} "=> Downloaded: $$dsize Total: $$tsize.";   \                                          ${ECHO_MSG} "=> Downloaded: $$dsize Total: $$tsize."; \
                                         ${ECHO_MSG};                    \                                          ${ECHO_MSG};                    \
                                         cd ${_DISTDIR};                 \                                          cd ${_DISTDIR};                 \
                                         ${FETCH_CMD} ${FETCH_BEFORE_ARGS} ${FETCH_RESUME_ARGS}  \                                          ${FETCH_CMD} ${FETCH_BEFORE_ARGS} ${FETCH_RESUME_ARGS} \
                                                 ${FETCH_OUTPUT_ARGS} $${bfile}.temp $${res_site}$${bfile}; \                                                  ${FETCH_OUTPUT_ARGS} $${bfile}.temp $${res_site}$${bfile}; \
                                         if [ $$? -eq 0 ]; then          \                                          if [ $$? -eq 0 ]; then          \
                                                 ndsize=`${WC} -c < ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp`;     \                                                  ndsize=`${WC} -c < ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp`; \
                                                 if [ "$$tsize" -eq "$$ndsize" ]; then   \                                                  if [ "$$tsize" -eq "$$ndsize" ]; then \
                                                         ${MV} ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp ${DISTDIR}/${DIST_SUBDIR}/$$bfile;                                         \                                                          ${MV} ${DISTDIR}/${DIST_SUBDIR}/$$bfile.temp ${DISTDIR}/${DIST_SUBDIR}/$$bfile; \
                                                 fi;                     \                                                  fi;                     \
                                                 break;                  \                                                  break;                  \
                                         fi;                             \                                          fi;                             \
                                 done;                                   \                                  done;                                   \
                         fi;                                             \                          fi;                                             \
                 elif [ "$$dsize" -gt "$$tsize" ]; then                  \                  elif [ "$$dsize" -gt "$$tsize" ]; then                  \
                         ${ECHO_MSG} "==> Downloaded file larger than the recorded size.";       \                          ${ECHO_MSG} "==> Downloaded file larger than the recorded size."; \
                         break;                                          \                          break;                                          \
                 fi;                                                     \                  fi;                                                     \
         fi          fi
Line 1721  _FETCH_FILE=        \
Line 2006  _FETCH_FILE=        \
                         fi;                                             \                          fi;                                             \
                         if ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${site}$${bfile} ${FETCH_AFTER_ARGS}; then \                          if ${FETCH_CMD} ${FETCH_BEFORE_ARGS} $${site}$${bfile} ${FETCH_AFTER_ARGS}; then \
                                 if [ -n "${FAILOVER_FETCH}" -a -f ${DISTINFO_FILE} -a -f ${_DISTDIR}/$$bfile ]; then \                                  if [ -n "${FAILOVER_FETCH}" -a -f ${DISTINFO_FILE} -a -f ${_DISTDIR}/$$bfile ]; then \
                                         alg=`${AWK} 'NF == 4 && $$2 == "('$$file')" && $$3 == "=" {print $$1;}' ${DISTINFO_FILE}`; \                                          alg=`${AWK} 'NF == 4 && $$2 == "('$$file')" && $$3 == "=" {print $$1; exit}' ${DISTINFO_FILE}`; \
                                         if [ -z "$$alg" ]; then         \                                          if [ -z "$$alg" ]; then         \
                                                 alg=${DIGEST_ALGORITHM};\                                                  alg=${PATCH_DIGEST_ALGORITHM};\
                                         fi;                             \                                          fi;                             \
                                         CKSUM=`${DIGEST} $$alg < ${_DISTDIR}/$$bfile`; \                                          CKSUM=`${DIGEST} $$alg < ${_DISTDIR}/$$bfile`; \
                                         CKSUM2=`${AWK} '$$1 == "'$$alg'" && $$2 == "('$$file')" {print $$4;}' <${DISTINFO_FILE}`; \                                          CKSUM2=`${AWK} '$$1 == "'$$alg'" && $$2 == "('$$file')" {print $$4;}' <${DISTINFO_FILE}`; \
Line 1739  _FETCH_FILE=        \
Line 2024  _FETCH_FILE=        \
                                 fi;                                     \                                  fi;                                     \
                         fi                                              \                          fi                                              \
                 done;                                                   \                  done;                                                   \
                 if [ ! -f ${_DISTDIR}/$$bfile ]; then \                  if [ ! -f ${_DISTDIR}/$$bfile ]; then                   \
                         ${ECHO_MSG} "=> Couldn't fetch $$bfile - please try to retrieve this";\                          ${ECHO_MSG} "=> Couldn't fetch $$bfile - please try to retrieve this";\
                         ${ECHO_MSG} "=> file manually into ${_DISTDIR} and try again."; \                          ${ECHO_MSG} "=> file manually into ${_DISTDIR} and try again."; \
                         exit 1;                                         \                          exit 1;                                         \
Line 1748  _FETCH_FILE=        \
Line 2033  _FETCH_FILE=        \
   
 _CHECK_DIST_PATH=                                                       \  _CHECK_DIST_PATH=                                                       \
         if [ "X${DIST_PATH}" != "X" ]; then                             \          if [ "X${DIST_PATH}" != "X" ]; then                             \
                 for d in "" ${DIST_PATH:S/:/ /g}; do    \                  for d in "" ${DIST_PATH:S/:/ /g}; do                    \
                         if [ "X$$d" = "X" -o "X$$d" = "X${DISTDIR}" ]; then continue; fi; \                          if [ "X$$d" = "X" -o "X$$d" = "X${DISTDIR}" ]; then continue; fi; \
                         if [ -f $$d/${DIST_SUBDIR}/$$bfile ]; then      \                          if [ -f $$d/${DIST_SUBDIR}/$$bfile ]; then      \
                                 ${ECHO} "Using $$d/${DIST_SUBDIR}/$$bfile"; \                                  ${ECHO} "Using $$d/${DIST_SUBDIR}/$$bfile"; \
Line 1863  do-fetch:
Line 2148  do-fetch:
 .  endif # !empty(_ALLFILES)  .  endif # !empty(_ALLFILES)
 .endif  .endif
   
 # show both build and run depends directories (non-recursively)  
 .PHONY: show-depends-dirs  
 show-depends-dirs:  
         @dlist="";                                                      \  
         thisdir=`${PWD_CMD}`;                                           \  
         for reldir in "" ${DEPENDS:C/^[^:]*://:C/:.*$//} ${BUILD_DEPENDS:C/^[^:]*://:C/:.*$//} ;\  
         do                                                              \  
                 if [ "X$$reldir" = "X" ]; then continue; fi;            \  
                 cd $$thisdir/$$reldir;                                  \  
                 WD=`${PWD_CMD}`;                                        \  
                 d=`dirname $$WD`;                                       \  
                 absdir=`basename $$d`/`basename $$WD`;                  \  
                 dlist="$$dlist $$absdir";                               \  
         done;                                                           \  
         cd $$thisdir;                                                   \  
         ${ECHO} "$$dlist"  
   
 # Show all build and run depends, reverse-breadth first, with options.  
   
 # "awk" macro to recurse over the dependencies efficiently, never running in  
 # the same same directory twice. You may set the following options via "-v":  
 #  
 #       NonSelf = 1     to not print own directory;  
 #       RootsOnly = 1   to print only root directories (i.e. directories  
 #                       of packages with no dependencies), including possibly  
 #                       own directory  
 #  
 _RECURSE_DEPENDS_DIRS=                                                  \  
         function append_dirs(dir) {                                     \  
                 command = "cd ../../" dir " && ${MAKE} show-depends-dirs"; \  
                 command | getline tmp_dirs;                             \  
                 close(command);                                         \  
                 if (tmp_dirs ~ /^$$/)                                   \  
                         root_dirs[p++] = dir;                           \  
                 for (i = 1; i <= split(tmp_dirs, tmp_r); i++)           \  
                         if (!(tmp_r[i] in hash_all_dirs)) {             \  
                                 all_dirs[n++] = tmp_r[i];               \  
                                 hash_all_dirs[tmp_r[i]] = 1             \  
                         }                                               \  
         }                                                               \  
         BEGIN {                                                         \  
                 command = "${PWD_CMD}";                                 \  
                 command | getline start_dir;                            \  
                 close(command);                                         \  
                 i = split(start_dir, tmp_r, /\//);                      \  
                 all_dirs[n++] = tmp_r[i-1] "/" tmp_r[i];                \  
                 for (; m < n; )                                         \  
                         append_dirs(all_dirs[m++]);                     \  
                 if (RootsOnly) {                                        \  
                         printf("%s", root_dirs[--p]);                   \  
                         for (; p > 0; )                                 \  
                                 printf(" %s", root_dirs[--p])           \  
                 }                                                       \  
                 else {                                                  \  
                         if (m > NonSelf)                                \  
                                 printf("%s", all_dirs[--m]);            \  
                         for (; m > NonSelf; )                           \  
                                 printf(" %s", all_dirs[--m])            \  
                 }                                                       \  
                 print                                                   \  
         }  
   
 _SHOW_ALL_DEPENDS_DIRS_EXCL=    ${AWK} -v NonSelf=1 '${_RECURSE_DEPENDS_DIRS}'  
   
 .PHONY: show-all-depends-dirs  
 show-all-depends-dirs:  
         @${AWK} '${_RECURSE_DEPENDS_DIRS}'  
   
 .PHONY: show-root-dirs  
 show-root-dirs:  
         ${_PKG_SILENT}${_PKG_DEBUG}${AWK} -v RootsOnly=1 '${_RECURSE_DEPENDS_DIRS}'  
   
 .PHONY: show-distfiles  
 show-distfiles:  
 .if !defined(PKG_FAIL_REASON)  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         for file in "" ${_CKSUMFILES}; do                               \  
                 if [ "X$$file" = "X" ]; then continue; fi;              \  
                 ${ECHO} $$file;                                         \  
         done  
 .endif  
   
 .PHONY: show-downlevel  
 show-downlevel:  
 .if !defined(PKG_FAIL_REASON)  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         found="`${PKG_BEST_EXISTS} \"${PKGWILDCARD}\" || ${TRUE}`";     \  
         if [ "X$$found" != "X" -a "X$$found" != "X${PKGNAME}" ]; then   \  
                 ${ECHO} "${PKGBASE} package: $$found installed, pkgsrc version ${PKGNAME}"; \  
                 if [ "X$$STOP_DOWNLEVEL_AFTER_FIRST" != "X" ]; then     \  
                         ${ECHO} "stopping after first downlevel pkg found"; \  
                         exit 1;                                         \  
                 fi;                                                     \  
         fi  
 .endif  
   
 .PHONY: show-installed-depends  
 show-installed-depends:  
 .if !empty(DEPENDS)  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         for i in ${DEPENDS:C/:.*$//:Q:S/\ / /g} ; do                    \  
                 echo "$$i =>" `${PKG_BEST_EXISTS} "$$i"` ;              \  
         done  
 .endif  
   
 .PHONY: show-needs-update  
 show-needs-update:  
 .if !empty(DEPENDS)  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         for i in `${MAKE} show-all-depends-dirs`; do                    \  
                 cd ${PKGSRCDIR}/$$i;                                    \  
                 want=`${MAKE} show-var-noeval VARNAME=PKGNAME`;         \  
                 wild=`${MAKE} show-var-noeval VARNAME=PKGWILDCARD`;     \  
                 have=`${PKG_BEST_EXISTS} "$$wild" || ${TRUE}`;          \  
                 if [ -z "$$have" ]; then                                \  
                         ${ECHO} "$$i => (none) => needs install of $$want"; \  
                 elif [ "$$have" != "$$want" ]; then                     \  
                         ${ECHO} "$$i => $$have => needs update to $$want"; \  
                 fi;                                                     \  
         done  
 .endif  
   
 .PHONY: show-pkgsrc-dir  
 show-pkgsrc-dir:  
 .if !defined(PKG_FAIL_REASON)  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         found="`${PKG_BEST_EXISTS} \"${PKGWILDCARD}\" || ${TRUE}`";     \  
         if [ "X$$found" != "X" ]; then                                  \  
                 ${ECHO} ${PKGPATH};                                     \  
         fi  
 .endif  
   
 # Extract  # Extract
   
 ${WRKDIR}:  ${WRKDIR}:
Line 2006  ${WRKDIR}:
Line 2159  ${WRKDIR}:
 .  endif  .  endif
 .endif  .endif
         ${_PKG_SILENT}${_PKG_DEBUG}${MKDIR} ${WRKDIR}          ${_PKG_SILENT}${_PKG_DEBUG}${MKDIR} ${WRKDIR}
           ${_PKG_SILENT}${_PKG_DEBUG}${MKDIR} ${PKG_DB_TMPDIR}
 .ifdef WRKOBJDIR  .ifdef WRKOBJDIR
 .  if ${PKGSRC_LOCKTYPE} == "sleep" || ${PKGSRC_LOCKTYPE} == "once"  .  if ${PKGSRC_LOCKTYPE} == "sleep" || ${PKGSRC_LOCKTYPE} == "once"
 .    if !exists(${LOCKFILE})  .    if !exists(${LOCKFILE})
Line 2343  do-ltconfig-override:
Line 2497  do-ltconfig-override:
 .  endfor  .  endfor
 .endif  .endif
   
 .if defined(CONFIG_GUESS_OVERRIDE) || defined(CONFIG_SUB_OVERRIDE)  
 _CONFIGURE_PREREQ+=     do-config-star-override  _CONFIGURE_PREREQ+=     do-config-star-override
 .PHONY: do-config-star-override  .PHONY: do-config-star-override
 do-config-star-override:  do-config-star-override:
 .  if defined(CONFIG_GUESS_OVERRIDE) && !empty(CONFIG_GUESS_OVERRIDE)  .if defined(GNU_CONFIGURE)
   .  if !empty(CONFIG_GUESS_OVERRIDE)
 .    for _pattern_ in ${CONFIG_GUESS_OVERRIDE}  .    for _pattern_ in ${CONFIG_GUESS_OVERRIDE}
         ${_PKG_SILENT}${_PKG_DEBUG}cd ${WRKSRC};                        \          ${_PKG_SILENT}${_PKG_DEBUG}cd ${WRKSRC};                        \
         for file in ${_pattern_}; do                                    \          for file in ${_pattern_}; do                                    \
Line 2359  do-config-star-override:
Line 2513  do-config-star-override:
         done          done
 .    endfor  .    endfor
 .  endif  .  endif
 .  if defined(CONFIG_SUB_OVERRIDE) && !empty(CONFIG_SUB_OVERRIDE)  .  if !empty(CONFIG_SUB_OVERRIDE)
 .    for _pattern_ in ${CONFIG_SUB_OVERRIDE}  .    for _pattern_ in ${CONFIG_SUB_OVERRIDE}
         ${_PKG_SILENT}${_PKG_DEBUG}cd ${WRKSRC};                        \          ${_PKG_SILENT}${_PKG_DEBUG}cd ${WRKSRC};                        \
         for file in ${_pattern_}; do                                    \          for file in ${_pattern_}; do                                    \
Line 2371  do-config-star-override:
Line 2525  do-config-star-override:
         done          done
 .    endfor  .    endfor
 .  endif  .  endif
   .  if !empty(CONFIG_RPATH_OVERRIDE)
   .    for _pattern_ in ${CONFIG_RPATH_OVERRIDE}
           ${_PKG_SILENT}${_PKG_DEBUG}cd ${WRKSRC};                        \
           for file in ${_pattern_}; do                                    \
                   if [ -f "$$file" ]; then                                \
                           ${RM} -f $$file;                                \
                           ${LN} -s ${PKGSRCDIR}/mk/gnu-config/config.rpath \
                                   $$file;                                 \
                   fi;                                                     \
           done
   .    endfor
   .  endif
 .endif  .endif
   
 PKGCONFIG_OVERRIDE_SED= \  PKGCONFIG_OVERRIDE_SED= \
Line 2391  SUBST_FILES.pkgconfig=  ${PKGCONFIG_OVER
Line 2557  SUBST_FILES.pkgconfig=  ${PKGCONFIG_OVER
 SUBST_SED.pkgconfig=            ${PKGCONFIG_OVERRIDE_SED}  SUBST_SED.pkgconfig=            ${PKGCONFIG_OVERRIDE_SED}
 .endif  .endif
   
 # By adding this target, it makes sure the the above PREREQ's work.  # By adding this target, it makes sure the above PREREQ's work.
 .PHONY: pre-configure-override  .PHONY: pre-configure-override
 pre-configure-override: ${_CONFIGURE_PREREQ}  pre-configure-override: ${_CONFIGURE_PREREQ}
   
Line 2481  BUILD_MAKE_FLAGS?= ${MAKE_FLAGS}
Line 2647  BUILD_MAKE_FLAGS?= ${MAKE_FLAGS}
 .if !target(do-build)  .if !target(do-build)
 do-build:  do-build:
 .  for DIR in ${BUILD_DIRS}  .  for DIR in ${BUILD_DIRS}
         ${_PKG_SILENT}${_PKG_DEBUG}${_ULIMIT_CMD}cd ${DIR} && ${SETENV} ${MAKE_ENV} ${MAKE_PROGRAM} ${BUILD_MAKE_FLAGS} -f ${MAKEFILE} ${ALL_TARGET}          ${_PKG_SILENT}${_PKG_DEBUG}${_ULIMIT_CMD}cd ${DIR} && ${SETENV} ${MAKE_ENV} ${MAKE_PROGRAM} ${BUILD_MAKE_FLAGS} -f ${MAKEFILE} ${BUILD_TARGET}
 .  endfor  .  endfor
 .endif  .endif
   
Line 2501  do-test:
Line 2667  do-test:
 .  endif  .  endif
 .endif  .endif
   
 # Install  
   
 INSTALL_DIRS?=          ${BUILD_DIRS}  
 INSTALL_MAKE_FLAGS?=    ${MAKE_FLAGS}  
   
 .PHONY: do-install  
 .if !target(do-install)  
 do-install:  
 .  for DIR in ${INSTALL_DIRS}  
         ${_PKG_SILENT}${_PKG_DEBUG}${_ULIMIT_CMD}cd ${DIR} && ${SETENV} ${MAKE_ENV} ${MAKE_PROGRAM} ${INSTALL_MAKE_FLAGS} -f ${MAKEFILE} ${INSTALL_TARGET}  
 .  endfor  
 .endif  
   
 # Package  # Package
   
 .PHONY: real-su-package  .PHONY: real-su-package
Line 2578  delete-package-links:
Line 2731  delete-package-links:
 delete-package: delete-package-links  delete-package: delete-package-links
         ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${PKGFILE}          ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${PKGFILE}
   
   
   
 # Do handling of shared libs for two cases:  
 #  
 # SHLIB_PLIST_MODE=1: when first called via the ${PLIST} target,  
 #                     update the PLIST to contain ELF symlink, run  
 #                     ldconfig on a.out,  etc. (used when called via  
 #                     the ${PLIST} target). Will update ${PLIST}.  
 # SHLIB_PLIST_MODE=0: when called via the real-su-install target,  
 #                     actually generate symlinks for ELF, run ldconfig  
 #                     for a.out, etc. Will not modify ${PLIST}.  
 #  
 # XXX This target could need some cleanup after it was ripped out of  
 #     real-su-install  
 #  
 _AOUT_AWK = \  
         BEGIN { linkc = 1 }                     \  
         /^@/ { lines[NR] = $$0; next }          \  
         function libtool_release(lib) {         \  
                 if (gsub("-[^-]+\\.so\\.", ".so.", lib)) { \  
                         if (system("${TEST} -h ${PREFIX}/" lib) == 0) { \  
                                 rels[NR] = lib; \  
                         }                       \  
                 }                               \  
         }                                       \  
         /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+\.[0-9]+$$/ { \  
                 libtool_release($$0);           \  
                 lines[NR] = $$0;                \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+$$/ { \  
                 libtool_release($$0);           \  
                 lines[NR] = $$0;                \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         { lines[NR] = $$0 }                     \  
         END {                                   \  
                 for (i = 0 ; i <= linkc ; i++)  \  
                         for (j = 1 ; j < NR ; j++) \  
                                 if (lines[j] == links[i]) \  
                                         lines[j] = "@comment " lines[j]; \  
                 if (${SHLIB_PLIST_MODE})        \  
                         for (i = 1 ; i <= NR ; i++) { \  
                                 print lines[i]; \  
                                 if (rels[i] != "") \  
                                         print rels[i]; \  
                         }                       \  
         }  
   
 _DYLIB_AWK= \  
         /^@/ { lines[NR] = $$0; next }          \  
                 function libtool_release(lib) {         \  
                 if (gsub("\\.so\\.", ".", lib) || gsub("\\.so$$", "", lib)) { \  
                         lib = lib ".dylib"; \  
                         if (system("${TEST} -h ${PREFIX}/" lib) == 0) { \  
                                 rels[NR] = lib; \  
                         }                       \  
                 }                               \  
         }                                       \  
         /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+\.[0-9]+$$/ { \  
                 libtool_release($$0);           \  
                 lines[NR] = $$0;                \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+$$/ { \  
                 libtool_release($$0);           \  
                 lines[NR] = $$0;                \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         /.*\/lib[^\/]+\.so\.[0-9]+$$/ {         \  
                 libtool_release($$0);           \  
                 lines[NR] = $$0;                \  
                 links[linkc++] = $$0;           \  
                 sub("\\.[0-9]+$$", "");         \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         /.*\/lib[^\/]+\.so$$/ {                 \  
                 lines[NR] = $$0;                \  
                 if (system("${TEST} -f ${PREFIX}/" $$0) == 0) { \  
                         next;                   \  
                 }                               \  
                 libtool_release($$0);           \  
                 links[linkc++] = $$0;           \  
                 if (sub("-[^-]+\\.so$$", ".so")) { \  
                         links[linkc++] = $$0;   \  
                 }                               \  
                 next                            \  
         }                                       \  
         { lines[NR] = $$0 }                     \  
         END {                                   \  
                 for (i = 0 ; i <= linkc ; i++)  \  
                         for (j = 1 ; j <= NR ; j++) \  
                                 if (lines[j] == links[i]) \  
                                         lines[j] = "@comment " lines[j]; \  
                 if (${SHLIB_PLIST_MODE})        \  
                         for (i = 1 ; i <= NR ; i++) { \  
                                 print lines[i]; \  
                                 if (rels[i] != "") { \  
                                         print rels[i]; \  
                                         cmd = "${LS} -l ${PREFIX}/" rels[i]; \  
                                         cmd | getline tgt; \  
                                         close(cmd); \  
                                         gsub(".* ", "", tgt); \  
                                         if (tgts[tgt] == "") { \  
                                                 tgts[tgt] = tgt; \  
                                                 if (index(tgt, "/") == 1) \  
                                                         print tgt; \  
                                                 else { \  
                                                         prefix=""; \  
                                                         if (match(rels[i], ".*/") != 0) \  
                                                                 prefix=substr(rels[i],1,RLENGTH); \  
                                                         print prefix tgt; \  
                                                 } \  
                                         }       \  
                                 }               \  
                         }                       \  
         }  
   
 # Turn lib*.so.*, lib*.so into lib*.a.  Drop duplicates.  
 _AIXLIB_AWK= \  
         /^@/ { lines[NR] = $$0; next }          \  
         /.*\/lib[^\/]+\.so(\.[0-9]+)*$$/ {      \  
                 sub("(\\.[0-9]+)*$$", "");      \  
                 sub("\\.so$$", ".a");           \  
                 lines[NR] = $$0;                \  
                 next                            \  
         }                                       \  
         { lines[NR] = $$0 }                     \  
         END {                                   \  
                 nlibs = 0;                      \  
                 for (i = 1; i <= NR; i++) {     \  
                         for (j = 0; j < nlibs; j++) { \  
                                 if (libs[j] == lines[i]) \  
                                         break;  \  
                         }                       \  
                         if (j >= nlibs)         \  
                                 print lines[i]; \  
                         if (match(lines[i], ".*/lib[^/]+\\.a$$")) { \  
                                 libs[nlibs] = lines[i]; \  
                                 nlibs++;        \  
                         }                       \  
                 }                               \  
         }  
   
 .PHONY: do-shlib-handling  
 do-shlib-handling:  
 .if ${SHLIB_HANDLING} == "YES"  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         sos=`${EGREP} -h '^.*/lib[^/]+\.so$$' ${PLIST} || ${TRUE}`;     \  
         if [ "$$sos" != "" ]; then                                      \  
                 shlib_type=`${_GET_SHLIB_TYPE}`;                        \  
                 if [ "${SHLIB_PLIST_MODE}" = "0" ]; then                \  
                         ${ECHO_MSG} "${_PKGSRC_IN}> [Automatic $$shlib_type shared object handling]"; \  
                 fi;                                                     \  
                 case "$$shlib_type" in                                  \  
                 ELF)    ;;                                              \  
                 "a.out")                                                \  
                         ${AWK} '${_AOUT_AWK}' <${PLIST} >${PLIST}.tmp ; \  
                         if [ "${SHLIB_PLIST_MODE}" = "1" ]; then        \  
                                 ${MV} ${PLIST}.tmp ${PLIST};            \  
                         else                                            \  
                                 ${RM} ${PLIST}.tmp ;                    \  
                         fi ;                                            \  
                         cnt=`${EGREP} -c '^@exec[       ]*${LDCONFIG}$$' ${PLIST} || ${TRUE}`; \  
                         if [ "${SHLIB_PLIST_MODE}" = "1" ]; then        \  
                                 if [ $$cnt -eq 0 ]; then                \  
                                         ${ECHO} "@exec ${LDCONFIG}" >> ${PLIST}; \  
                                         ${ECHO} "@unexec ${LDCONFIG}" >> ${PLIST}; \  
                                 fi                                      \  
                         fi;                                             \  
                         if [ "${SHLIB_PLIST_MODE}" = "0" ]; then        \  
                                 if [ "${PKG_VERBOSE}" != "" ]; then     \  
                                         ${ECHO_MSG} "$$sos";            \  
                                         ${ECHO_MSG} "Running ${LDCONFIG}"; \  
                                 fi;                                     \  
                                 ${LDCONFIG} || ${TRUE};                 \  
                         fi                                              \  
                         ;;                                              \  
                 "dylib")                                                \  
                         ${AWK} '${_DYLIB_AWK}' <${PLIST} >${PLIST}.tmp && \  
                         if [ "${SHLIB_PLIST_MODE}" = "1" ]; then        \  
                                 ${MV} ${PLIST}.tmp ${PLIST};            \  
                         else                                            \  
                                 ${RM} ${PLIST}.tmp ;                    \  
                         fi ;                                            \  
                         ;;                                              \  
                 "aixlib")                                               \  
                         ${AWK} '${_AIXLIB_AWK}' <${PLIST} >${PLIST}.tmp && \  
                         ${MV} ${PLIST}.tmp ${PLIST};                    \  
                         ;;                                              \  
                 "*")                                                    \  
                         if [ "${SHLIB_PLIST_MODE}" = "0" ]; then        \  
                                 ${ECHO_MSG} "No shared libraries for ${MACHINE_ARCH}"; \  
                         fi ;                                            \  
                         if [ "${SHLIB_PLIST_MODE}" = "1" ]; then        \  
                                 for so in $$sos; do                     \  
                                         if [ X"${PKG_VERBOSE}" != X"" ]; then \  
                                                 ${ECHO_MSG} >&2 "Ignoring $$so"; \  
                                         fi;                             \  
                                         ${SED} -e "s;^$$so$$;@comment No shared objects - &;" \  
                                                 ${PLIST} >${PLIST}.tmp && ${MV} ${PLIST}.tmp ${PLIST};  \  
                                 done;                                   \  
                         fi ;                                            \  
                         ;;                                              \  
                 esac;                                                   \  
         fi  
 .endif # SHLIB_HANDLING == "YES"  
   
   
 # Check if all binaries and shlibs find their needed libs  # Check if all binaries and shlibs find their needed libs
 # Must be run after "make install", so that files are installed, and  # Must be run after "make install", so that files are installed, and
 # ${PLIST} exists.  # ${PLIST} exists.
Line 2864  check-shlibs:
Line 2770  check-shlibs:
                 ${SHCOMMENT} Might not error-out for non-pkg-developers; \                  ${SHCOMMENT} Might not error-out for non-pkg-developers; \
                 exit 1;                                                 \                  exit 1;                                                 \
         fi          fi
 .endif # NO_PKG_REGISTER  .endif # !NO_PKG_REGISTER
   
   # CHECK_FILES_SKIP is a list of file names that will be skipped when
 # Macro to print out the actual shared library type.  # analyzing file lists in the check-files target.  This is useful to
 .if defined(USE_LANGUAGES) && !empty(USE_LANGUAGES)  # avoid getting errors triggered by changes in directories not really
 .  if ${_OPSYS_SHLIB_TYPE} == "ELF/a.out"  # handled by pkgsrc.
 .    if (${OBJECT_FMT} == "ELF" || ${OBJECT_FMT} == "a.out")  #
 _GET_SHLIB_TYPE=        ${ECHO} '${OBJECT_FMT}' # speedup if already known  # We have to do this here, i.e., quite late in bsd.pkg.mk parsing, so
 .    else  # that the variables used in them are defined.  Otherwise we may get
 _GET_SHLIB_TYPE=\  # problems with the 'for' expressions.
         @cd ${WRKDIR} &&                                                \  .if defined(INFO_DIR)
         sotype=none;                                                    \  CHECK_FILES_SKIP+=      ${PREFIX}/${INFO_DIR}/dir
         if [ "X${MKPIC}" != "Xno" -a "X${NOPIC}" = "X" ]; then          \  
                 ${ECHO} "int main() { return(0); }" > a.$$$$.c;         \  
                 ${SETENV} PATH=${PATH}                                  \  
                 ${CC} ${CFLAGS} a.$$$$.c -o a.$$$$.out;                 \  
                 case `${FILE_CMD} a.$$$$.out` in                        \  
                 *ELF*dynamically*)                                      \  
                         sotype=ELF ;;                                   \  
                 *shared*library*|*dynamically*)                         \  
                         sotype="a.out" ;;                               \  
                 esac;                                                   \  
         fi;                                                             \  
         ${ECHO} "$$sotype";                                             \  
         ${RM} -f a.$$$$.c a.$$$$.out  
 .    endif  
 .  else  
 _GET_SHLIB_TYPE=        ${ECHO} '${_OPSYS_SHLIB_TYPE}'  
 .  endif  
 .endif  .endif
 _GET_SHLIB_TYPE?=       ${ECHO} none  CHECK_FILES_SKIP+=      ${PREFIX}/emul/linux/proc
   
   .for e c in ${CONF_FILES} ${SUPPORT_FILES}
   CHECK_FILES_SKIP+=      ${c}/.pkgsrc
   .endfor
   .for e c o g m in ${CONF_FILES_PERMS} ${SUPPORT_FILES_PERMS}
   CHECK_FILES_SKIP+=      ${c}/.pkgsrc
   .endfor
   .for d in ${MAKE_DIRS} ${OWN_DIRS}
   CHECK_FILES_SKIP+=      ${d}
   .endfor
   .for d o g m in ${MAKE_DIRS_PERMS} ${OWN_DIRS_PERMS}
   CHECK_FILES_SKIP+=      ${d}
   .endfor
   
   CHECK_FILES_SKIP_CMD=   | ${GREP} -v ${CHECK_FILES_SKIP:@f@-e ${f:Q}@}
   
 # Not to be used by pkgsrc; available for human inspection only.  # Check if the generated PLIST matches the list of really installed files.
 show-shlib-type:  #
         @${_GET_SHLIB_TYPE}  .PHONY: check-files
   check-files:
   .if !defined(NO_PKG_REGISTER)
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           errors=0;                                                       \
           diff -u ${WRKDIR}/.prefix.pre ${WRKDIR}/.prefix.post            \
                   >${WRKDIR}/.files.diff || ${TRUE};                      \
           ${GREP} '^+/' ${WRKDIR}/.files.diff | ${SED} "s|^+||" | ${SORT} \
                   >${WRKDIR}/.files.added;                                \
           ${GREP} '^-/' ${WRKDIR}/.files.diff | ${SED} "s|^-||" | ${SORT} \
                   >${WRKDIR}/.files.deleted;                              \
           if ${TEST} `${WC} -l ${WRKDIR}/.files.deleted |                 \
                   ${AWK} '{ print $$1; }'` -gt 0;                         \
           then                                                            \
                   echo "*** The following files have been deleted from"   \
                        "${PREFIX}!";                                      \
                   ${SED} "s|^|        |" <${WRKDIR}/.files.deleted;       \
                   errors=1;                                               \
           fi;                                                             \
           ${GREP} '^[A-Za-z]' ${PLIST} | ${SED} "s|^|${PREFIX}/|" |       \
                   ${SORT} >${WRKDIR}/.files.expected;                     \
           if ! ${CMP} -s ${WRKDIR}/.files.expected ${WRKDIR}/.files.added; then \
                   echo "*** The PLIST does not match installed files!";   \
                   echo "    The following files were not expected in ${PREFIX}:";\
                   diff -u ${WRKDIR}/.files.expected ${WRKDIR}/.files.added | \
                           ${GREP} '^+[^+]' | ${SED} "s|^+|        |";     \
                   errors=1;                                               \
           fi;                                                             \
           if [ ${CHECK_FILES_STRICT} = "YES" ] &&                         \
              ! ${CMP} -s ${WRKDIR}/.sysconfdir.pre ${WRKDIR}/.sysconfdir.post; \
           then                                                            \
                   echo "*** The package has modified ${PKG_SYSCONFDIR}"   \
                        "contents directly!";                              \
                   echo "    The offending files/directories are:";        \
                   diff -u ${WRKDIR}/.sysconfdir.pre ${WRKDIR}/.sysconfdir.post | \
                           ${GREP} '^+[^+]' | ${SED} "s|^+|        |";     \
                   errors=1;                                               \
           fi;                                                             \
           if [ ${CHECK_FILES_STRICT} = "YES" ] &&                         \
              ! ${CMP} -s ${WRKDIR}/.varbase.pre ${WRKDIR}/.varbase.post; then \
                   echo "*** The package has modified ${VARBASE} contents" \
                        "directly!";                                       \
                   echo "    The offending files/directories are:";        \
                   diff -u ${WRKDIR}/.varbase.pre ${WRKDIR}/.varbase.post |\
                           ${GREP} '^+[^+]' | ${SED} "s|^+|        |";     \
                   errors=1;                                               \
           fi;                                                             \
           ${RM} -f ${WRKDIR}/.files.added ${WRKDIR}/.files.deleted        \
                    ${WRKDIR}/.files.diff ${WRKDIR}/.files.expected;       \
           ${TEST} $$errors -eq 0
   .endif
   
 LOCKFILE=       ${WRKDIR}/.lockfile  LOCKFILE=       ${WRKDIR}/.lockfile
 .for targ in ${_PKG_PHASES_WRKDIR}  .for targ in ${_PKG_PHASES_WRKDIR}
Line 2915  acquire-${targ}-lock:
Line 2869  acquire-${targ}-lock:
                 ${FALSE};                                               \                  ${FALSE};                                               \
         fi;                                                             \          fi;                                                             \
         while true; do                                                  \          while true; do                                                  \
                 if ${TEST} -f /var/run/dmesg.boot -a -f ${LOCKFILE} -a  \                  : "Remove lock files older than the last reboot";       \
                      /var/run/dmesg.boot -nt ${LOCKFILE}; then          \                  if ${TEST} -f /var/run/dmesg.boot -a -f ${LOCKFILE}; then \
                         ${ECHO} "=> Removing stale ${LOCKFILE}";        \                          rebooted=`${FIND} /var/run/dmesg.boot -newer ${LOCKFILE} -print`; \
                         ${RM} ${LOCKFILE};                              \                          if ${TEST} x"$$rebooted" != x; then             \
                                   ${ECHO} "=> Removing stale ${LOCKFILE}"; \
                                   ${RM} ${LOCKFILE};                      \
                           fi;                                             \
                 fi;                                                     \                  fi;                                                     \
                 ${SHLOCK} -f ${LOCKFILE} -p $$ppid && break;            \                  ${SHLOCK} -f ${LOCKFILE} -p $$ppid && break;            \
                 ${ECHO} "=> Lock is held by pid `cat ${LOCKFILE}`";     \                  ${ECHO} "=> Lock is held by pid `cat ${LOCKFILE}`";     \
Line 2940  release-${targ}-lock:
Line 2897  release-${targ}-lock:
 .  endif # PKGSRC_LOCKTYPE  .  endif # PKGSRC_LOCKTYPE
 .endfor  .endfor
   
 ################################################################  
 # Skeleton targets start here  
 #  
 # You shouldn't have to change these.  Either add the pre-* or  
 # post-* targets/scripts or redefine the do-* targets.  These  
 # targets don't do anything other than checking for cookies and  
 # call the necessary targets/scripts.  
 ################################################################  
   
 ##### *_COOKIE to real-* layer  # Empty pre-* and post-* targets
   
 .for targ in ${_PKG_PHASES_WRKDIR}  
 ${${targ}_COOKIE}: real-${targ}  
         ${_PKG_SILENT}${_PKG_DEBUG}${ECHO} ${PKGNAME} >${${targ}_COOKIE}  
 .endfor  
   
 # mark a stage as complete if its cookie (and all parent cookies) exist  
 .if exists(${depends_COOKIE})  
 ${depends_COOKIE}: .MADE  
 .  if exists(${extract_COOKIE})  
 ${extract_COOKIE}: .MADE  
 .    if exists(${patch_COOKIE})  
 ${patch_COOKIE}: .MADE  
 .      if exists(${tools_COOKIE})  
 ${tools_COOKIE}: .MADE  
 .        if exists(${wrapper_COOKIE})  
 ${wrapper_COOKIE}: .MADE  
 .          if exists(${configure_COOKIE})  
 ${configure_COOKIE}: .MADE  
 .            if exists(${build_COOKIE})  
 ${build_COOKIE}: .MADE  
 .              if exists(${test_COOKIE})  
 ${test_COOKIE}: .MADE  
 .                if exists(${install_COOKIE})  
 ${install_COOKIE}: .MADE  
 .                  if exists(${package_COOKIE})  
 ${package_COOKIE}: .MADE  
 .                  endif  
 .                endif  
 .              endif  
 .            endif  
 .          endif  
 .        endif  
 .      endif  
 .    endif  
 .  endif  
 .endif  
   
 # NO_* for skipping phases  
 # XXX this should be a .for loop, but we need the :tu modifier for that  
 .if defined(NO_DEPENDS) || (empty(DEPENDS) && empty(BUILD_DEPENDS))  
 ${depends_COOKIE}: .MADE  
 .endif  
 .if defined(NO_TOOLS)  
 ${tools_COOKIE}: .MADE  
 .endif  
 .if defined(NO_WRAPPER)  
 ${wrapper_COOKIE}: .MADE  
 .endif  
 .if defined(NO_CONFIGURE)  
 ${configure_COOKIE}: .MADE  
 .endif  
 .if defined(NO_BUILD)  
 ${build_COOKIE}: .MADE  
 .endif  
 .if empty(PKGSRC_RUN_TEST:M[yY][eE][sS])  
 real-test: .MADE  
 .endif  
 .if defined(NO_INSTALL)  
 ${install_COOKIE}: .MADE  
 .endif  
   
 ##### real-* to actual component target layer  
   
 # Simple dependencies are not used, deliberately, so that it is possible  
 # to invoke a single subtarget by hand while working on a new package.  
 #  
 # Please note that the order of the following targets is important, and  
 # should not be modified (.ORDER is not recognised by make(1) in a serial  
 # make i.e. without -j n)  
   
 _REAL_TARGETS.patch=    patch-message pre-patch do-patch post-patch  
 _REAL_TARGETS.tools=    tools-message pre-tools do-tools post-tools  
 _REAL_TARGETS.wrapper=  wrapper-message pre-wrapper do-wrapper post-wrapper  
 _REAL_TARGETS.configure=configure-message pre-configure pre-configure-override do-configure post-configure  
 _REAL_TARGETS.build=    build-message pre-build do-build post-build  
 _REAL_TARGETS.test=     test-message pre-test do-test post-test  
 _REAL_TARGETS.package=  do-su-package  
 _REAL_TARGETS.replace=  do-su-replace  
 _REAL_TARGETS.undo-replace= do-su-undo-replace  
   
 _REAL_TARGETS.su-package=  
 _REAL_TARGETS.su-replace=  
   
 .for targ in extract configure build install  
 .  if !empty(INTERACTIVE_STAGE:M${targ}) && defined(BATCH)  
 _REAL_TARGETS.${targ}:= ${targ}-is-interactive  
 ${targ}-is-interactive:  
         @${ECHO} "*** The ${targ} stage of this package requires user interaction"  
         @${ECHO} "*** Please ${targ} manually with \"cd ${PKGDIR} && ${MAKE} ${targ}\""  
         @${FALSE}  
 .  endif  
 .endfor  
   
 .for targ in ${_PKG_PHASES_ALL} replace undo-replace su-install  
 .PHONY: real-${targ}  
 .ORDER: ${_REAL_TARGETS.${targ}}  
 real-${targ}: ${_REAL_TARGETS.${targ}}  
 .endfor  
   
 ##### target internals  
   
 _PHASE_MSG.depends=     Verifying dependencies  
 _PHASE_MSG.extract=     Extracting  
 _PHASE_MSG.patch=       Patching  
 _PHASE_MSG.tools=       Overriding tools  
 _PHASE_MSG.wrapper=     Creating toolchain wrappers  
 _PHASE_MSG.configure=   Configuring  
 _PHASE_MSG.build=       Building  
 _PHASE_MSG.test=        Testing  
 _PHASE_MSG.install=     Installing  
 _PHASE_MSG.package=     Packaging  
   
 .for targ in ${_PKG_PHASES_WRKDIR}  
 .PHONY: ${targ}-message  
 ${targ}-message:  
         @${ECHO_MSG} "${_PKGSRC_IN}> ${_PHASE_MSG.${targ}} for ${PKGNAME}"  
 .endfor  
   
 .for targ in install package replace undo-replace deinstall  
 .PHONY: do-su-${targ}  
 do-su-${targ}:  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         if [ `${ID} -u` = `${ID} -u ${ROOT_USER}` ]; then               \  
                 ${MAKE} ${MAKEFLAGS} $$realtarget;                      \  
         elif [ "X${BATCH}" != X"" ]; then                               \  
                 ${ECHO_MSG} "Warning: Batch mode, not superuser, can't run $$action for ${PKGNAME}."; \  
                 ${ECHO_MSG} "Become ${ROOT_USER} and try again to ensure correct permissions."; \  
         else                                                            \  
                 args="DEINSTALLDEPENDS=${DEINSTALLDEPENDS}";            \  
                 if [ "X${FORCE_PKG_REGISTER}" != X"" ]; then            \  
                         args="$$args FORCE_PKG_REGISTER=1";             \  
                 fi;                                                     \  
                 if [ "X${PKG_DEBUG_LEVEL}" != X"" ]; then               \  
                         args="$$args PKG_DEBUG_LEVEL=${PKG_DEBUG_LEVEL}"; \  
                 fi;                                                     \  
                 if [ "X${PRE_ROOT_CMD}" != "X${TRUE}" ]; then           \  
                         ${ECHO} "*** WARNING *** Running: ${PRE_ROOT_CMD}"; \  
                         ${PRE_ROOT_CMD};                                \  
                 fi;                                                     \  
                 ${ECHO_MSG} "${_PKGSRC_IN}> Becoming ${ROOT_USER}@`${HOSTNAME_CMD}` to ${targ} ${PKGBASE}."; \  
                 ${ECHO_N} "`${ECHO} ${SU_CMD} | ${AWK} '{ print $$1 }'` ";\  
                 ${SU_CMD} "cd ${.CURDIR}; ${SETENV} PATH=$${PATH}:${SU_CMD_PATH_APPEND} ${MAKE} $$args ${MAKEFLAGS} real-su-${targ} $$realflags"; \  
         fi  
 .endfor  
   
 # Empty pre-* and post-* targets  
   
 .for targ in fetch ${_PKG_PHASES_WRKDIR} install-script clean distclean  .for targ in fetch ${_PKG_PHASES_WRKDIR} install-script clean distclean
 .PHONY: pre-${targ} post-${targ}  .PHONY: pre-${targ} post-${targ}
Line 3279  ${DDIR}: ${DLIST}
Line 3081  ${DDIR}: ${DLIST}
 ${DLIST}: ${WRKDIR}  ${DLIST}: ${WRKDIR}
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         { ${PKG_DELETE} -n "${PKGWILDCARD}" 2>&1 |                      \          { ${PKG_DELETE} -n "${PKGWILDCARD}" 2>&1 |                      \
                 ${GREP} '^      ' |                                             \                  ${GREP} '^      ' |                                     \
                 ${AWK} '{ l[NR]=$$0 } END { for (i=NR;i>0;--i) print l[i] }' \                  ${AWK} '{ l[NR]=$$0 } END { for (i=NR;i>0;--i) print l[i] }' \
         || ${TRUE}; } > ${DLIST}          || ${TRUE}; } > ${DLIST}
   
 # The 'info' target can be used to display information about a package.  
 .PHONY: info  
 info:  
         ${_PKG_SILENT}${_PKG_DEBUG}${PKG_INFO} "${PKGWILDCARD}"  
   
 # The 'check' target can be used to check an installed package.  
 .PHONY: check  
 check:  
         ${_PKG_SILENT}${_PKG_DEBUG}${PKG_ADMIN} check "${PKGWILDCARD}"  
   
 # The 'list' target can be used to list the files installed by a package.  
 .PHONY: list  
 list:  
         ${_PKG_SILENT}${_PKG_DEBUG}${PKG_INFO} -L "${PKGWILDCARD}"  
   
 # Run pkglint:  
 .PHONY: lint  
 lint:  
         ${_PKG_SILENT}${_PKG_DEBUG}${LOCALBASE}/bin/pkglint | ${GREP} -v ^OK  
   
 # Create a binary package from an install package using "pkg_tarup"  # Create a binary package from an install package using "pkg_tarup"
 .PHONY: tarup  .PHONY: tarup
 tarup:  tarup:
 .if ${PKG_INSTALLATION_TYPE} == "overwrite"  .if ${PKG_INSTALLATION_TYPE} == "overwrite"
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         ${RM} -f ${PACKAGES}/All/${PKGNAME}${PKG_SUFX};                 \          ${RM} -f ${PACKAGES}/All/${PKGNAME}${PKG_SUFX};                 \
         ${SETENV} PKG_DBDIR=${_PKG_DBDIR} PKG_SUFX=${PKG_SUFX}  \          ${SETENV} PKG_DBDIR=${_PKG_DBDIR} PKG_SUFX=${PKG_SUFX}          \
                 PKGREPOSITORY=${PACKAGES}/All                           \                  PKGREPOSITORY=${PACKAGES}/All                           \
                 ${LOCALBASE}/bin/pkg_tarup ${PKGNAME};                  \                  ${LOCALBASE}/bin/pkg_tarup ${PKGNAME};                  \
         for CATEGORY in ${CATEGORIES}; do                               \          for CATEGORY in ${CATEGORIES}; do                               \
Line 3432  distclean: pre-distclean clean
Line 3214  distclean: pre-distclean clean
 .endif  .endif
         -${_PKG_SILENT}${_PKG_DEBUG}${RM} -f README.html          -${_PKG_SILENT}${_PKG_DEBUG}${RM} -f README.html
   
 # Prints out a script to fetch all needed files (no checksumming).  
 .PHONY: fetch-list  
 fetch-list:  
         @${ECHO} '#!/bin/sh'  
         @${ECHO} '#'  
         @${ECHO} '# This is an auto-generated script, the result of running'  
         @${ECHO} '# `${MAKE} fetch-list'"'"' in directory "'"`${PWD_CMD}`"'"'  
         @${ECHO} '# on host "'"`${UNAME} -n`"'" on "'"`date`"'".'  
         @${ECHO} '#'  
         @${MAKE} ${MAKEFLAGS} fetch-list-recursive  
   
 .PHONY: fetch-list-recursive  
 fetch-list-recursive:  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         for dir in `${MAKE} ${MAKEFLAGS} show-all-depends-dirs`; do     \  
                 (cd ../../$$dir &&                                      \  
                 ${MAKE} ${MAKEFLAGS} fetch-list-one-pkg                 \  
                 | ${AWK} '                                              \  
                 /^[^#]/ { FoundSomething = 1 }                          \  
                 /^unsorted/ { gsub(/[[:space:]]+/, " \\\n\t") }         \  
                 /^echo/ { gsub(/;[[:space:]]+/, "\n") }                 \  
                 { block[line_c++] = $$0 }                               \  
                 END { if (FoundSomething)                               \  
                         for (line = 0; line < line_c; line++)           \  
                                 print block[line] }                     \  
                 ')                                                      \  
         done  
   
 .PHONY: fetch-list-one-pkg  
 fetch-list-one-pkg:  
 .if !empty(_ALLFILES)  
         @${ECHO}  
         @${ECHO} '#'  
         @location=`${PWD_CMD} | ${AWK} -F / '{ print $$(NF-1) "/" $$NF }'`; \  
                 ${ECHO} '# Need additional files for ${PKGNAME} ('$$location')...'  
         @${ECHO} '#'  
         @${MKDIR} ${_DISTDIR}  
 .  for fetchfile in ${_ALLFILES}  
 .    if defined(_FETCH_MESSAGE)  
         @(cd ${_DISTDIR};                                               \  
         if [ ! -f ${fetchfile:T} ]; then                                \  
                 ${ECHO};                                                \  
                 filesize=`${AWK} '                                      \  
                         /^Size/ && $$2 == "(${fetchfile})" { print $$4 } \  
                         ' ${DISTINFO_FILE}` || true;                    \  
                 ${ECHO} '# Prompt user to get ${fetchfile} ('$${filesize-???}' bytes) manually:'; \  
                 ${ECHO} '#';                                            \  
                 ${ECHO} ${_FETCH_MESSAGE:Q};                            \  
         fi)  
 .    elif defined(DYNAMIC_MASTER_SITES)  
         @(cd ${_DISTDIR};                                               \  
         if [ ! -f ${fetchfile:T} ]; then                                \  
                 ${ECHO};                                                \  
                 filesize=`${AWK} '                                      \  
                         /^Size/ && $$2 == "(${fetchfile})" { print $$4 } \  
                         ' ${DISTINFO_FILE}` || true;                    \  
                 ${ECHO} '# Fetch ${fetchfile} ('$${filesize-???}' bytes):'; \  
                 ${ECHO} '#';                                            \  
                 ${ECHO} '${SH} -s ${fetchfile:T} <<"EOF" |(';           \  
                 ${CAT} ${FILESDIR}/getsite.sh;                          \  
                 ${ECHO} EOF;                                            \  
                 ${ECHO} read unsorted_sites;                            \  
                 ${ECHO} 'unsorted_sites="$${unsorted_sites} ${_MASTER_SITE_BACKUP}"'; \  
                 ${ECHO} sites='"'${ORDERED_SITES:Q}'"';                 \  
                 ${ECHO} "${MKDIR} ${_DISTDIR}";                         \  
                 ${ECHO} 'cd ${_DISTDIR} && [ -f ${fetchfile} -o -f ${fetchfile:T} ] ||'; \  
                 ${ECHO} 'for site in $$sites; do';                      \  
                 ${ECHO} '       ${FETCH_CMD} ${FETCH_BEFORE_ARGS} "$${site}${fetchfile:T}" ${FETCH_AFTER_ARGS} && break ||'; \  
                 ${ECHO} '       ${ECHO} ${fetchfile} not fetched';      \  
                 ${ECHO} done;                                           \  
                 ${ECHO} ')';                                            \  
         fi)  
 .    else  
         @(cd ${_DISTDIR};                                               \  
         if [ ! -f ${fetchfile:T} ]; then                                \  
                 ${ECHO};                                                \  
                 filesize=`${AWK} '                                      \  
                         /^Size/ && $$2 == "(${fetchfile})" { print $$4 } \  
                         ' ${DISTINFO_FILE}` || true;                    \  
                 ${ECHO} '# Fetch ${fetchfile} ('$${filesize-???}' bytes):'; \  
                 ${ECHO} '#';                                            \  
                 ${ECHO} 'unsorted_sites="${SITES_${fetchfile:T:S/=/--/}} ${_MASTER_SITE_BACKUP}"'; \  
                 ${ECHO} sites='"'${ORDERED_SITES:Q}'"';                 \  
                 ${ECHO} "${MKDIR} ${_DISTDIR}";                         \  
                 ${ECHO} 'cd ${_DISTDIR} && [ -f ${fetchfile} -o -f ${fetchfile:T} ] ||'; \  
                 ${ECHO} 'for site in $$sites; do';                      \  
                 ${ECHO} '       ${FETCH_CMD} ${FETCH_BEFORE_ARGS} "$${site}${fetchfile:T}" ${FETCH_AFTER_ARGS} && break ||'; \  
                 ${ECHO} '       ${ECHO} ${fetchfile} not fetched';      \  
                 ${ECHO} done;                                           \  
         fi)  
 .    endif # defined(_FETCH_MESSAGE) || defined(DYNAMIC_MASTER_SITES)  
 .  endfor  
 .endif # !empty(_ALLFILES)  
   
 # List of sites carrying binary pkgs. Variables "rel" and "arch" are  # List of sites carrying binary pkgs. Variables "rel" and "arch" are
 # replaced with OS release ("1.5", ...) and architecture ("mipsel", ...)  # replaced with OS release ("1.5", ...) and architecture ("mipsel", ...)
 BINPKG_SITES?= \  BINPKG_SITES?= \
Line 3578  real-su-bin-install:
Line 3266  real-su-bin-install:
 bin-install:  bin-install:
         @${ECHO_MSG} "${_PKGSRC_IN}> Binary install for ${PKGNAME}"          @${ECHO_MSG} "${_PKGSRC_IN}> Binary install for ${PKGNAME}"
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         realtarget="real-su-bin-install";                                       \          realtarget="real-su-bin-install";                               \
         action="binary install";                                        \          action="binary install";                                        \
         ${_SU_TARGET}          ${_SU_TARGET}
   
   
   
 ################################################################  ################################################################
 # The special package-building targets  # The special package-building targets
 # You probably won't need to touch these  # You probably won't need to touch these
 ################################################################  ################################################################
   
 # Set to "html" by the README.html target to generate HTML code,  
 # or to "svr4" to print SVR4 (Solaris, ...) short package names, from  
 # SVR4_PKGNAME variable.  
 # This variable is passed down via build-depends-list and run-depends-list  
 PACKAGE_NAME_TYPE?=     name  
   
 # Nobody should want to override this unless PKGNAME is simply bogus.  
 HTML_PKGNAME=<a href="../../${PKGPATH:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}/README.html">${PKGNAME:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}</A>  
   
 .PHONY: package-name  
 package-name:  
 .if (${PACKAGE_NAME_TYPE} == "html")  
         @${ECHO} '<a href="../../${PKGPATH:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}/README.html">${PKGNAME:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}</A>'  
 .elif (${PACKAGE_NAME_TYPE} == "svr4")  
         @${ECHO} ${SVR4_PKGNAME}  
 .else  
         @${ECHO} ${PKGNAME}  
 .endif # PACKAGE_NAME_TYPE  
   
 .PHONY: make-readme-html-help  
 make-readme-html-help:  
         @${ECHO} '${PKGNAME:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}</a>: <TD>'${COMMENT:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g:Q}  
   
 # Show (recursively) all the packages this package depends on.  # Show (recursively) all the packages this package depends on.
 # If PACKAGE_DEPENDS_WITH_PATTERNS is set, print as pattern (if possible)  # If PACKAGE_DEPENDS_WITH_PATTERNS is set, print as pattern (if possible)
 PACKAGE_DEPENDS_WITH_PATTERNS?=true  PACKAGE_DEPENDS_WITH_PATTERNS?=true
Line 3632  run-depends-list:
Line 3295  run-depends-list:
         fi          fi
 .endfor  .endfor
   
   # Set to "html" by the README.html target to generate HTML code,
   # or to "svr4" to print SVR4 (Solaris, ...) short package names, from
   # SVR4_PKGNAME variable.
   # This variable is passed down via build-depends-list and run-depends-list
   PACKAGE_NAME_TYPE?=     name
   
   # Nobody should want to override this unless PKGNAME is simply bogus.
   HTML_PKGNAME=<a href="../../${PKGPATH:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}/README.html">${PKGNAME:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}</A>
   
   .PHONY: package-name
   package-name:
   .if (${PACKAGE_NAME_TYPE} == "html")
           @${ECHO} '<a href="../../${PKGPATH:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}/README.html">${PKGNAME:S/&/\&amp;/g:S/>/\&gt;/g:S/</\&lt;/g}</A>'
   .elif (${PACKAGE_NAME_TYPE} == "svr4")
           @${ECHO} ${SVR4_PKGNAME}
   .else
           @${ECHO} ${PKGNAME}
   .endif # PACKAGE_NAME_TYPE
   
 # Build a package but don't check the package cookie  # Build a package but don't check the package cookie
   
 .PHONY: repackage  .PHONY: repackage
Line 3652  package-noinstall:
Line 3334  package-noinstall:
 # Dependency checking  # Dependency checking
 ################################################################  ################################################################
   
 .PHONY: install-depends  
 # Tells whether to halt execution if the object formats differ  # Tells whether to halt execution if the object formats differ
 FATAL_OBJECT_FMT_SKEW?= yes  FATAL_OBJECT_FMT_SKEW?= yes
 WARN_NO_OBJECT_FMT?= yes  WARN_NO_OBJECT_FMT?= yes
   
 install-depends:  do-depends:
 .for dep in ${DEPENDS} ${BUILD_DEPENDS}  .for dep in ${DEPENDS} ${BUILD_DEPENDS}
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         pkg="${dep:C/:.*//}";                                           \          pkg="${dep:C/:.*//}";                                           \
Line 3706  build-depends-list:
Line 3387  build-depends-list:
                 ${MAKE} ${MAKEFLAGS} package-name)                      \                  ${MAKE} ${MAKEFLAGS} package-name)                      \
         done          done
   
 # If PACKAGES is set to the default (../../pkgsrc/packages), the current  
 # ${MACHINE_ARCH} and "release" (uname -r) will be used. Otherwise a directory  
 # structure of ...pkgsrc/packages/`uname -r`/${MACHINE_ARCH} is assumed.  
 # The PKG_URL is set from FTP_PKG_URL_* or CDROM_PKG_URL_*, depending on  
 # the target used to generate the README.html file.  
 .PHONY: binpkg-list  
 binpkg-list:  
         @if ${TEST} -d ${PACKAGES}; then                                \  
                 cd ${PACKAGES};                                         \  
                 case ${.CURDIR} in                                      \  
                 */pkgsrc/packages)                                      \  
                         for pkg in ${PKGREPOSITORYSUBDIR}/${PKGWILDCARD}${PKG_SUFX} ; \  
                         do                                              \  
                                 if [ -f "$$pkg" ] ; then                \  
                                         pkgname=`${ECHO} $$pkg | ${SED} 's@.*/@@'`; \  
                                         ${ECHO} "<TR><TD>${MACHINE_ARCH}:<TD><a href=\"${PKG_URL}/$$pkg\">$$pkgname</a><TD>(${OPSYS} ${OS_VERSION})"; \  
                                 fi ;                                    \  
                         done ;                                          \  
                         ;;                                              \  
                 *)                                                      \  
                         cd ${PACKAGES}/../..;                           \  
                         for i in [1-9].*/*; do                          \  
                                 if cd ${PACKAGES}/../../$$i/${PKGREPOSITORYSUBDIR} 2>/dev/null; then \  
                                         for j in ${PKGWILDCARD}${PKG_SUFX}; \  
                                         do                              \  
                                                 if [ -f "$$j" ]; then   \  
                                                         ${ECHO} $$i/$$j;\  
                                                 fi;                     \  
                                         done;                           \  
                                 fi;                                     \  
                         done | ${AWK} -F/ '                             \  
                                 {                                       \  
                                         release = $$1;                  \  
                                         arch = $$2;                     \  
                                         pkg = $$3;                      \  
                                         gsub("\\.tgz","", pkg);         \  
                                         if (arch != "m68k" && arch != "mipsel") { \  
                                                 if (arch in urls)       \  
                                                         urls[arch "/" pkg "/" release] = "<a href=\"${PKG_URL}/" release "/" arch "/${PKGREPOSITORYSUBDIR}/" pkg "${PKG_SUFX}\">" pkg "</a>, " urls[arch]; \  
                                                 else                    \  
                                                         urls[arch "/" pkg "/" release] = "<a href=\"${PKG_URL}/" release "/" arch "/${PKGREPOSITORYSUBDIR}/" pkg "${PKG_SUFX}\">" pkg "</a> "; \  
                                         }                               \  
                                 }                                       \  
                                 END {                                   \  
                                         for (av in urls) {              \  
                                                 split(av, ava, "/");    \  
                                                 arch=ava[1];            \  
                                                 pkg=ava[2];             \  
                                                 release=ava[3];         \  
                                                 print "<TR><TD>" arch ":<TD>" urls[av] "<TD>(${OPSYS} " release ")"; \  
                                         }                               \  
                                 }' | ${SORT}                            \  
                         ;;                                              \  
                 esac;                                                   \  
         fi  
   
 ################################################################  
 # Everything after here are internal targets and really  
 # shouldn't be touched by anybody but the release engineers.  
 ################################################################  
   
 # This target generates an index entry suitable for aggregation into  
 # a large index.  Format is:  
 #  
 # distribution-name|package-path|installation-prefix|comment| \  
 #  description-file|maintainer|categories|build deps|run deps|for arch| \  
 #  not for opsys  
 #  
 .PHONY: describe  
 describe:  
         @${ECHO_N} "${PKGNAME}|${.CURDIR}|";                            \  
         ${ECHO_N} "${PREFIX}|";                                         \  
         ${ECHO_N} ${COMMENT:Q};                                         \  
         if [ -f ${DESCR_SRC} ]; then                                    \  
                 ${ECHO_N} "|${DESCR_SRC}";                              \  
         else                                                            \  
                 ${ECHO_N} "|/dev/null";                                 \  
         fi;                                                             \  
         ${ECHO_N} "|${MAINTAINER}|${CATEGORIES}|";                      \  
         case "A${BUILD_DEPENDS}B${DEPENDS}C" in \  
                 ABC) ;;                                                 \  
                 *) cd ${.CURDIR} && ${ECHO_N} `${MAKE} ${MAKEFLAGS} build-depends-list | ${SORT} -u`;; \  
         esac;                                                           \  
         ${ECHO_N} "|";                                                  \  
         if [ "${DEPENDS}" != "" ]; then                                 \  
                 cd ${.CURDIR} && ${ECHO_N} `${MAKE} ${MAKEFLAGS} run-depends-list | ${SORT} -u`; \  
         fi;                                                             \  
         ${ECHO_N} "|";                                                  \  
         if [ "${ONLY_FOR_ARCHS}" = "" ]; then                           \  
                 ${ECHO_N} "any";                                        \  
         else                                                            \  
                 ${ECHO_N} "${ONLY_FOR_ARCHS}";                          \  
         fi;                                                             \  
         ${ECHO_N} "|";                                                  \  
         if [ "${NOT_FOR_OPSYS}" = "" ]; then                            \  
                 ${ECHO_N} "any";                                        \  
         else                                                            \  
                 ${ECHO_N} "not ${NOT_FOR_OPSYS}";                       \  
         fi;                                                             \  
         ${ECHO} ""  
   
 # This target is used to generate README.html files  
 FTP_PKG_URL_HOST?=      ftp://ftp.NetBSD.org  
 FTP_PKG_URL_DIR?=       /pub/NetBSD/packages  
   
 .PHONY: readme readmes  
 readme readmes:  
         @cd ${.CURDIR} && ${MAKE} ${MAKEFLAGS} README.html PKG_URL=${FTP_PKG_URL_HOST}${FTP_PKG_URL_DIR}  
   
 # This target is used to generate README.html files, very like "readme"  
 # However, a different target was used for ease of use.  
 CDROM_PKG_URL_HOST?=    file://localhost  
 CDROM_PKG_URL_DIR?=     /usr/pkgsrc/packages  
   
 .PHONY: cdrom-readme  
 cdrom-readme:  
         @cd ${.CURDIR} && ${MAKE} ${MAKEFLAGS} README.html PKG_URL=${CDROM_PKG_URL_HOST}${CDROM_PKG_URL_DIR}  
   
 README_NAME=    ${TEMPLATES}/README.pkg  
   
 # set up the correct license information as a sed expression  
 .ifdef LICENSE  
 SED_LICENSE_EXPR=       -e 's|%%LICENSE%%|<p>Please note that this package has a ${LICENSE} license.</p>|'  
 .else  
 SED_LICENSE_EXPR=       -e 's|%%LICENSE%%||'  
 .endif  
   
 # set up the "more info URL" information as a sed expression  
 .ifdef HOMEPAGE  
 SED_HOMEPAGE_EXPR=       -e 's|%%HOMEPAGE%%|<p>This package has a home page at <a HREF="${HOMEPAGE}">${HOMEPAGE}</a>.</p>|'  
 .else  
 SED_HOMEPAGE_EXPR=       -e 's|%%HOMEPAGE%%||'  
 .endif  
   
 .PHONY: show-vulnerabilities-html  
 show-vulnerabilities-html:  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         if [ -f ${PKGVULNDIR}/pkg-vulnerabilities ]; then                       \  
                 ${AWK} '/^${PKGBASE}[-<>=]+[0-9]/ { gsub("\<", "\\&lt;", $$1);  \  
                          gsub("\>", "\\&gt;", $$1);                     \  
                          printf("<LI><STRONG>%s has a %s exploit (see <a href=\"%s\">%s</a> for more details)</STRONG></LI>\n", $$1, $$2, $$3, $$3) }' \  
                         ${PKGVULNDIR}/pkg-vulnerabilities;                      \  
         fi  
   
   
 # If PACKAGES is set to the default (../../packages), the current  
 # ${MACHINE_ARCH} and "release" (uname -r) will be used. Otherwise a directory  
 # structure of ...pkgsrc/packages/`uname -r`/${MACHINE_ARCH} is assumed.  
 # The PKG_URL is set from FTP_PKG_URL_* or CDROM_PKG_URL_*, depending on  
 # the target used to generate the README.html file.  
 .PHONY: README.html  
 README.html: .PRECIOUS  
         @${SETENV} AWK=${AWK} BMAKE=${MAKE} ../../mk/scripts/mkdatabase -f $@.tmp1  
         @if ${TEST} -d ${PACKAGES}; then                                        \  
                 cd ${PACKAGES};                                         \  
                 case `${PWD_CMD}` in                                    \  
                         ${PKGSRCDIR}/packages)                          \  
                                 MULTIARCH=no;                           \  
                                 ;;                                      \  
                         *)                                              \  
                                 MULTIARCH=yes;                          \  
                                 ;;                                      \  
                 esac;                                                   \  
                 cd ${.CURDIR} ;                                         \  
         fi;                                                             \  
         ${AWK} -f ../../mk/scripts/genreadme.awk \  
                 builddependsfile=/dev/null \  
                 dependsfile=/dev/null \  
                 DISTDIR=${DISTDIR} \  
                 MACHINE_ARCH=${MACHINE_ARCH} \  
                 MULTIARCH=$$MULTIARCH \  
                 OPSYS=${OPSYS} \  
                 OS_VERSION=${OS_VERSION} \  
                 PACKAGES=${PACKAGES} \  
                 PKG_SUFX=${PKG_SUFX} \  
                 PKG_URL=${PKG_URL} \  
                 PKGREPOSITORYSUBDIR=${PKGREPOSITORYSUBDIR} \  
                 PKGSRCDIR=${.CURDIR:C|/[^/]*/[^/]*$||} \  
                 TMPDIR=${TMPDIR:U/tmp} \  
                 SINGLEPKG=${PKGPATH} \  
                 $@.tmp1  
         @${RM} $@.tmp1  
   
 .PHONY: show-pkgtools-version  
 show-pkgtools-version:  
         @${ECHO} ${PKGTOOLS_VERSION}  
   
 .PHONY: print-build-depends-list  
 print-build-depends-list:  
 .if !empty(BUILD_DEPENDS) || !empty(DEPENDS)  
         @${ECHO_N} 'This package requires package(s) "'  
         @${ECHO_N} `${MAKE} ${MAKEFLAGS} build-depends-list | ${SORT} -u`  
         @${ECHO} '" to build.'  
 .endif  
   
 .PHONY: print-run-depends-list  
 print-run-depends-list:  
 .if !empty(DEPENDS)  
         @${ECHO_N} 'This package requires package(s) "'  
         @${ECHO_N} `${MAKE} ${MAKEFLAGS} run-depends-list | ${SORT} -u`  
         @${ECHO} '" to run.'  
 .endif  
   
 # This target is used by the mk/scripts/mkreadme script to generate  
 # README.html files  
 .PHONY: print-summary-data  
 print-summary-data:  
         @${ECHO} "depends ${PKGPATH} ${DEPENDS}"  
         @${ECHO} "build_depends ${PKGPATH} ${BUILD_DEPENDS}"  
         @${ECHO} "conflicts ${PKGPATH} ${CONFLICTS}"  
         @${ECHO} "index ${PKGPATH} ${PKGNAME}"  
         @${ECHO} htmlname ${PKGPATH} ${HTML_PKGNAME:Q}  
         @${ECHO} homepage ${PKGPATH} ${HOMEPAGE:Q}  
         @${ECHO} wildcard ${PKGPATH} ${PKGWILDCARD:Q}  
         @${ECHO} comment ${PKGPATH} ${COMMENT:Q}  
         @${ECHO} license ${PKGPATH} ${LICENSE:Q}  
         @if [ "${ONLY_FOR_ARCHS}" = "" ]; then                          \  
                 ${ECHO} "onlyfor ${PKGPATH} any";                       \  
         else                                                            \  
                 ${ECHO} "onlyfor ${PKGPATH} ${ONLY_FOR_ARCHS}";         \  
         fi;  
         @if [ "${NOT_FOR_OPSYS}" = "" ]; then                           \  
                 ${ECHO} "notfor ${PKGPATH} any";                        \  
         else                                                            \  
                 ${ECHO} "notfor ${PKGPATH} not ${NOT_FOR_OPSYS}";       \  
         fi;  
         @${ECHO} "maintainer ${PKGPATH} ${MAINTAINER}"  
         @${ECHO} "categories ${PKGPATH} ${CATEGORIES}"  
         @if [ -f ${DESCR_SRC} ]; then                                           \  
                 ${ECHO}  "descr ${PKGPATH} ${DESCR_SRC:S;${PKGSRCDIR}/;;g}";    \  
         else                                                                    \  
                 ${ECHO}  "descr ${PKGPATH} /dev/null";                          \  
         fi  
         @${ECHO} "prefix ${PKGPATH} ${PREFIX}"  
   
 .PHONY: show-license show-licence  
 show-license show-licence:  
         @if [ "${LICENSE}" != "" ]; then                                \  
                 if ${TEST} -f ${PKGSRCDIR}/licenses/${LICENSE}; then    \  
                         if [ "${PAGER}" != "" ]; then                   \  
                                 ${PAGER} ${PKGSRCDIR}/licenses/${LICENSE};\  
                         else                                            \  
                                 ${CAT} ${PKGSRCDIR}/licenses/${LICENSE};\  
                         fi                                              \  
                 else                                                    \  
                         ${ECHO} "Generic ${LICENSE} information not available"; \  
                         ${ECHO} "See the package description (pkg_info -d ${PKGNAME}) for more information."; \  
                 fi                                                      \  
         fi  
   
 # Stat all the files of one pkg and sum the sizes up.  # Stat all the files of one pkg and sum the sizes up.
 #  #
 # XXX This is intended to be run before pkg_create is called, so the  # XXX This is intended to be run before pkg_create is called, so the
Line 3971  print-pkg-size-this:
Line 3402  print-pkg-size-this:
         | ${SORT} -u                                                    \          | ${SORT} -u                                                    \
         | ${SED} -e "s/'/'\\\\''/g" -e "s/.*/'&'/"                      \          | ${SED} -e "s/'/'\\\\''/g" -e "s/.*/'&'/"                      \
         | ${XARGS} -n 256 ${LS} -ld                                     \          | ${XARGS} -n 256 ${LS} -ld                                     \
         | ${AWK} 'BEGIN { print("0 "); }                                \          | ${AWK} '{ s += $$5; } END { print s; }'                       \
                   { print($$5, " + "); }                                \  
                   END { print("p"); }'                                  \  
         | ${DC}  
   
 # Sizes of required pkgs (only)  # Sizes of required pkgs (only)
 #  #
Line 3988  print-pkg-size-depends:
Line 3416  print-pkg-size-depends:
                 | ${XARGS} -n 1 ${SETENV} ${PKG_BEST_EXISTS}            \                  | ${XARGS} -n 1 ${SETENV} ${PKG_BEST_EXISTS}            \
                 | ${SORT} -u                                            \                  | ${SORT} -u                                            \
                 | ${XARGS} -n 256 ${SETENV} ${PKG_INFO} -qs             \                  | ${XARGS} -n 256 ${SETENV} ${PKG_INFO} -qs             \
                 | ${AWK} -- 'BEGIN { print("0 "); }                     \                  | ${AWK} '/^[0-9]+$$/ { s += $$1; } END { print s; }';  \
                         /^[0-9]+$$/ { print($$1, " + "); }              \  
                         END { print("p"); }'                            \  
                 | ${DC};                                                \  
         else                                                            \          else                                                            \
                 ${ECHO} "0";                                            \                  ${ECHO} "0";                                            \
         fi          fi
   
   
 ###  
 ### Automatic PLIST generation  
 ###  - files & symlinks first  
 ###  - @dirrm statements last  
 ###  - empty directories are handled properly  
 ###  - dirs from mtree files are excluded  
 ###  - substitute for platform or package specifics substrings  
 ###  
 ### Usage:  
 ###  - make install  
 ###  - make print-PLIST | brain >PLIST  
 ###  
   
 _PRINT_PLIST_AWK_SUBST={                                                \  
         gsub(/${OPSYS}/, "$${OPSYS}");                                  \  
         gsub(/${OS_VERSION:S/./\./g}/, "$${OS_VERSION}");               \  
         gsub(/${MACHINE_GNU_PLATFORM}/, "$${MACHINE_GNU_PLATFORM}");    \  
         gsub(/${MACHINE_ARCH}/, "$${MACHINE_ARCH}");                    \  
         gsub(/${MACHINE_GNU_ARCH}/, "$${MACHINE_GNU_ARCH}");  
 .if !empty(LOWER_VENDOR)  
 _PRINT_PLIST_AWK_SUBST+=        gsub(/${LOWER_VENDOR}/, "$${LOWER_VENDOR}");  
 .endif  
 _PRINT_PLIST_AWK_SUBST+=                                                \  
         gsub(/${LOWER_OS_VERSION:S/./\./g}/, "$${LOWER_OS_VERSION}");   \  
         gsub(/${LOWER_OPSYS}/, "$${LOWER_OPSYS}");                      \  
         gsub(/${PKGNAME_NOREV}/, "$${PKGNAME}");                        \  
         gsub(/${PKGVERSION:S/./\./g:C/nb[0-9]*$$//}/, "$${PKGVERSION}");\  
         gsub(/${PKGLOCALEDIR}\/locale/, "$${PKGLOCALEDIR}/locale");     \  
 }  
   
 _PRINT_PLIST_AWK_IGNORE=        ($$0 ~ /emul\/linux\/proc/)  
 _PRINT_PLIST_AWK_IGNORE+=       || ($$0 ~ /^info\/dir$$/)  
 .if defined(INFO_DIR) && empty(INFO_DIR:Minfo)  
 _PRINT_PLIST_AWK_IGNORE+=       || ($$0 ~ /^${INFO_DIR:S|/|\\/|g}\/dir$$/)  
 .endif  
 .if !empty(INFO_FILES)  
 .  for _f_ in ${INFO_FILES}  
 _PRINT_PLIST_AWK_IGNORE+=      || ($$0 ~ /^${INFO_DIR:S|/|\\/|g}\/${_f_:S|+|\+|g}(-[0-9]+)?(\.gz)?$$/)  
 .  endfor  
 .endif  
   
 # Common (system) directories not to generate @dirrm statements for  
 # Reads MTREE_FILE and generate awk statements that will  
 # sort out which directories NOT to include into the PLIST @dirrm list  
 .if make(print-PLIST)  
 _PRINT_PLIST_COMMON_DIRS!=      ${AWK} 'BEGIN  {                        \  
                         i=0;                                            \  
                         stack[i]="${PREFIX}" ;                          \  
                         cwd="";                                         \  
                 }                                                       \  
                 ! ( /^\// || /^\#/ || /^$$/ ) {                         \  
                         if ( $$1 == ".." ){                             \  
                                 i=i-1;                                  \  
                                 cwd = stack[i];                         \  
                         } else if ( $$1 == "." ){                       \  
                         } else {                                        \  
                                 stack[i] = cwd ;                        \  
                                 if ( i == 0 ){                          \  
                                         cwd = $$1 ;                     \  
                                 } else {                                \  
                                         cwd = cwd "\\/" $$1 ;   \  
                                 }                                       \  
                                 print "/^" cwd "$$$$/ { next; }";       \  
                                 i=i+1 ;                                 \  
                         }                                               \  
                 }                                                       \  
                 END { print "{ print $$$$0; }"; }                       \  
         ' <${MTREE_FILE}  
 .endif  
   
   
 # scan $PREFIX for any files/dirs modified since the package was extracted  
 # will emit "@exec mkdir"-statements for empty directories  
 # XXX will fail for data files that were copied using tar (e.g. emacs)!  
 # XXX should check $LOCALBASE and $X11BASE, and add @cwd statements  
   
 _PRINT_PLIST_FILES_CMD= \  
         ${FIND} ${PREFIX}/. -xdev -newer ${extract_COOKIE} \! -type d -print  
 _PRINT_PLIST_DIRS_CMD=  \  
         ${FIND} ${PREFIX}/. -xdev -newer ${extract_COOKIE} -type d -print  
 _PRINT_LA_LIBNAMES=     ${SETENV} ECHO=${ECHO:Q} GREP=${GREP:Q} SORT=${SORT:Q} \  
                         ${SH} ${.CURDIR}/../../mk/scripts/print-la-libnames  
   
 .if !empty(LIBTOOLIZE_PLIST:M[yY][eE][sS])  
 _PRINT_PLIST_LIBTOOLIZE_FILTER?=                                        \  
         (                                                               \  
           if ${TEST} -d ${WRKDIR}; then                                 \  
                 tmpdir="${WRKDIR}";                                     \  
           else                                                          \  
                 tmpdir="$${TMPDIR-/tmp}";                               \  
           fi;                                                           \  
           fileslist="$$tmpdir/print.plist.files.$$$$";                  \  
           libslist="$$tmpdir/print.plist.libs.$$$$";                    \  
           while read file; do                                           \  
                 case $$file in                                          \  
                 *.la)                                                   \  
                         ${_PRINT_LA_LIBNAMES} $$file >> $$libslist;     \  
                         ;;                                              \  
                 esac;                                                   \  
                 ${ECHO} "$$file";                                       \  
           done > $$fileslist;                                           \  
           if ${TEST} -f "$$libslist"; then                              \  
                 ${GREP} -hvxF "`${SORT} -u $$libslist`" "$$fileslist";  \  
           else                                                          \  
                 ${CAT} "$$fileslist";                                   \  
           fi;                                                           \  
           ${RM} -f "$$fileslist" "$$libslist";                          \  
         )  
 .else  
 _PRINT_PLIST_LIBTOOLIZE_FILTER?=        ${CAT}  
 .endif  
   
 .PHONY: print-PLIST  
 print-PLIST:  
         ${_PKG_SILENT}${_PKG_DEBUG}\  
         ${ECHO} '@comment $$'NetBSD'$$'  
         ${_PKG_SILENT}${_PKG_DEBUG}\  
         shlib_type=`${_GET_SHLIB_TYPE}`;                                \  
         case $$shlib_type in                                            \  
         "a.out")        genlinks=1 ;;                                   \  
         *)              genlinks=0 ;;                                   \  
         esac;                                                           \  
         ${_PRINT_PLIST_FILES_CMD}                                       \  
          | ${_PRINT_PLIST_LIBTOOLIZE_FILTER}                            \  
          | ${SORT}                                                      \  
          | ${AWK} '                                                     \  
                 { sub("${PREFIX}/\\./", ""); }                          \  
                 ${_PRINT_PLIST_AWK_IGNORE} { next; }                    \  
                 ${_PRINT_PLIST_AWK_SUBST}                               \  
                 /^@/ { print $$0; next }                                \  
                 /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+\.[0-9]+$$/ {         \  
                         print $$0;                                      \  
                         sub("\\.[0-9]+$$", "");                         \  
                         if ('$$genlinks') print $$0;                    \  
                         sub("\\.[0-9]+$$", "");                         \  
                         if ('$$genlinks') print $$0;                    \  
                         sub("\\.[0-9]+$$", "");                         \  
                         if ('$$genlinks') print $$0;                    \  
                         next;                                           \  
                 }                                                       \  
                 /.*\/lib[^\/]+\.so\.[0-9]+\.[0-9]+$$/ {                 \  
                         print $$0;                                      \  
                         sub("\\.[0-9]+$$", "");                         \  
                         if ('$$genlinks') print $$0;                    \  
                         sub("\\.[0-9]+$$", "");                         \  
                         if ('$$genlinks') print $$0;                    \  
                         next;                                           \  
                 }                                                       \  
                 ${PRINT_PLIST_AWK}                                      \  
                 { print $$0; }'  
         ${_PKG_SILENT}${_PKG_DEBUG}\  
         for i in `${_PRINT_PLIST_DIRS_CMD}                              \  
                         | ${SORT} -r                                    \  
                         | ${AWK} '                                      \  
                                 /emul\/linux\/proc/ { next; }           \  
                                 /${PREFIX:S|/|\\/|g}\/\.$$/ { next; }   \  
                                 { sub("${PREFIX}/\\\\./", ""); }        \  
                                 ${_PRINT_PLIST_COMMON_DIRS}'` ;         \  
         do                                                              \  
                 if [ `${LS} -la ${PREFIX}/$$i | ${WC} -l` = 3 ]; then   \  
                         ${ECHO} @exec \$${MKDIR} %D/$$i | ${AWK} '      \  
                         ${PRINT_PLIST_AWK}                              \  
                         { print $$0; }' ;                               \  
                 fi ;                                                    \  
                 ${ECHO} @dirrm $$i | ${AWK} '                           \  
                         ${PRINT_PLIST_AWK}                              \  
                         { print $$0; }' ;                               \  
         done                                                            \  
         | ${AWK} '${_PRINT_PLIST_AWK_SUBST} { print $$0; }'  
   
 # By default, all packages attempt to link into the views.  # By default, all packages attempt to link into the views.
 .if ${PKG_INSTALLATION_TYPE} == "pkgviews"  .if ${PKG_INSTALLATION_TYPE} == "pkgviews"
 BUILD_VIEWS?=   yes  BUILD_VIEWS?=   yes
Line 4189  MAKE_ENV+= VIEWBASE=${VIEWBASE}
Line 3443  MAKE_ENV+= VIEWBASE=${VIEWBASE}
   
 PKGVIEWS+=      ${DEFAULT_VIEW.${PKGBASE}}  PKGVIEWS+=      ${DEFAULT_VIEW.${PKGBASE}}
   
 # Fake installation of package so that user can pkg_delete it later.  .PHONY: pre-install-fake-pkg
 # Also, make sure that an installed package is recognized correctly in  pre-install-fake-pkg:
 # accordance to the @pkgdep directive in the packing lists.  
   
 .PHONY: fake-pkg  
 fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         if [ ! -f ${PLIST} -o ! -f ${DESCR} ]; then                     \  
                 ${ECHO} "** Missing package files for ${PKGNAME} - installation not recorded."; \  
                 exit 1;                                                 \  
         fi  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         if [ ! -d ${_PKG_DBDIR} ]; then                                 \  
                 ${RM} -f ${_PKG_DBDIR};                                 \  
                 ${MKDIR} ${_PKG_DBDIR};                                 \  
         fi  
 .if defined(FORCE_PKG_REGISTER)  
         ${_PKG_SILENT}${_PKG_DEBUG}${PKG_ADMIN} delete ${PKGNAME}  
 .  if ${PKG_INSTALLATION_TYPE} == "overwrite"  
         ${_PKG_SILENT}${_PKG_DEBUG}${RM} -rf ${_PKG_DBDIR}/${PKGNAME}  
 .  endif  
 .endif  
         ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${BUILD_VERSION_FILE} ${BUILD_INFO_FILE}  
         ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${SIZE_PKG_FILE} ${SIZE_ALL_FILE}  
         ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${PRESERVE_FILE}          ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${PRESERVE_FILE}
 .if defined(PKG_PRESERVE)  .if defined(PKG_PRESERVE)
         ${_PKG_SILENT}${_PKG_DEBUG}${DATE} > ${PRESERVE_FILE}          ${_PKG_SILENT}${_PKG_DEBUG}${DATE} > ${PRESERVE_FILE}
Line 4241  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
Line 3473  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
                 done;                                                   \                  done;                                                   \
         fi;                                                             \          fi;                                                             \
         eval ${GREP} '\$$NetBSD' $$files | ${SED} -e 's|^${PKGSRCDIR}/||' > ${BUILD_VERSION_FILE}          eval ${GREP} '\$$NetBSD' $$files | ${SED} -e 's|^${PKGSRCDIR}/||' > ${BUILD_VERSION_FILE}
           ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${BUILD_INFO_FILE}
 .for def in ${BUILD_DEFS} ${BUILD_DEFS_FIXED}  .for def in ${BUILD_DEFS} ${BUILD_DEFS_FIXED}
         @${ECHO} ${def}=${${def}:Q} | ${SED} -e 's|^PATH=[^     ]*|PATH=...|' >> ${BUILD_INFO_FILE}          @${ECHO} ${def}=${${def}:Q} | ${SED} -e 's|^PATH=[^     ]*|PATH=...|' >> ${BUILD_INFO_FILE}
 .endfor  .endfor
Line 4253  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
Line 3486  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
 .if !empty(USE_GNU_TOOLS:Mmake)  .if !empty(USE_GNU_TOOLS:Mmake)
         @${ECHO} "GMAKE=`${GMAKE} --version | ${GREP} Make`" >> ${BUILD_INFO_FILE}          @${ECHO} "GMAKE=`${GMAKE} --version | ${GREP} Make`" >> ${BUILD_INFO_FILE}
 .endif  .endif
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           ${ECHO} "_PKGTOOLS_VER=${PKGTOOLS_VERSION}" >> ${BUILD_INFO_FILE}
   
   .PHONY: post-install-fake-pkg
   post-install-fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           if [ ! -f ${PLIST} -o ! -f ${DESCR} ]; then                     \
                   ${ECHO} "** Missing package files for ${PKGNAME} - installation not recorded."; \
                   exit 1;                                                 \
           fi
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           if [ ! -d ${_PKG_DBDIR} ]; then                                 \
                   ${RM} -f ${_PKG_DBDIR};                                 \
                   ${MKDIR} ${_PKG_DBDIR};                                 \
           fi
   .if defined(FORCE_PKG_REGISTER)
           ${_PKG_SILENT}${_PKG_DEBUG}${PKG_ADMIN} delete ${PKGNAME}
   .endif
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           ${ECHO} ${COMMENT:Q} > ${PKG_DB_TMPDIR}/+COMMENT
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           case "${DESCR}" in                                              \
           ${PKG_DB_TMPDIR}/*|"") ;;                                       \
           *)      if ${TEST} -f ${DESCR}; then                            \
                           ${CP} ${DESCR} ${PKG_DB_TMPDIR}/+DESC;          \
                   fi ;;                                                   \
           esac
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           case "${MESSAGE}" in                                            \
           ${PKG_DB_TMPDIR}/*|"") ;;                                       \
           *)      if ${TEST} -f ${MESSAGE}; then                          \
                           ${CP} ${MESSAGE} ${PKG_DB_TMPDIR}/+DISPLAY;     \
                   fi ;;                                                   \
           esac
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           case ${PKG_INSTALLATION_TYPE} in                                \
           pkgview)        ${TOUCH} ${PKG_DB_TMPDIR}/+VIEWS ;;             \
           esac
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           case "${INSTALL_FILE}" in                                       \
           ${PKG_DB_TMPDIR}/*|"") ;;                                       \
           *)      if ${TEST} -f ${INSTALL_FILE}; then                     \
                           ${CP} ${INSTALL_FILE} ${PKG_DB_TMPDIR}/+INSTALL; \
                   fi ;;                                                   \
           esac
           ${_PKG_SILENT}${_PKG_DEBUG}                                     \
           case "${DEINSTALL_FILE}" in                                     \
           ${PKG_DB_TMPDIR}/*|"") ;;                                       \
           *)      if ${TEST} -f ${DEINSTALL_FILE}; then                   \
                           ${CP} ${DEINSTALL_FILE} ${PKG_DB_TMPDIR}/+DEINSTALL; \
                   fi ;;                                                   \
           esac
           ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f ${SIZE_PKG_FILE} ${SIZE_ALL_FILE}
 .if ${SHLIB_HANDLING} == "YES" && ${CHECK_SHLIBS} == "YES"  .if ${SHLIB_HANDLING} == "YES" && ${CHECK_SHLIBS} == "YES"
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         case "${LDD}" in                                                \          case "${LDD}" in                                                \
Line 4291  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
Line 3577  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
         done          done
 .endif  .endif
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         ${ECHO} "_PKGTOOLS_VER=${PKGTOOLS_VERSION}" >> ${BUILD_INFO_FILE}  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         size_this=`${MAKE} ${MAKEFLAGS} print-pkg-size-this`;           \          size_this=`${MAKE} ${MAKEFLAGS} print-pkg-size-this`;           \
         size_depends=`${MAKE} ${MAKEFLAGS} print-pkg-size-depends`;     \          size_depends=`${MAKE} ${MAKEFLAGS} print-pkg-size-depends`;     \
         ${ECHO} $$size_this >${SIZE_PKG_FILE};                          \          ${ECHO} $$size_this >${SIZE_PKG_FILE};                          \
         ${ECHO} $$size_this $$size_depends + p | ${DC} >${SIZE_ALL_FILE}          ${ECHO} $$size_this $$size_depends                              \
                   | ${AWK} '{ print $$1 + $$2; }' >${SIZE_ALL_FILE}
   
   # Fake installation of package so that user can pkg_delete it later.
   # Also, make sure that an installed package is recognized correctly in
   # accordance to the @pkgdep directive in the packing lists.
   #
   .PHONY: register-pkg
   register-pkg: post-install-fake-pkg
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \          ${_PKG_SILENT}${_PKG_DEBUG}                                     \
         doit=yes;                                                       \          doit=yes;                                                       \
         case ${PKG_INSTALLATION_TYPE} in                                \          case ${PKG_INSTALLATION_TYPE} in                                \
Line 4307  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
Line 3599  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
         case $$doit in                                                  \          case $$doit in                                                  \
         yes)                                                            \          yes)                                                            \
                 ${ECHO_MSG} "${_PKGSRC_IN}> Registering installation for ${PKGNAME}"; \                  ${ECHO_MSG} "${_PKGSRC_IN}> Registering installation for ${PKGNAME}"; \
                 ${MKDIR} ${_PKG_DBDIR}/${PKGNAME};                      \                  ${PKG_CREATE} ${PKG_ARGS_INSTALL} -O ${PKGFILE} > ${PKG_DB_TMPDIR}/+CONTENTS; \
                 ${PKG_CREATE} ${PKG_ARGS_INSTALL} -O ${PKGFILE} > ${_PKG_DBDIR}/${PKGNAME}/+CONTENTS; \  
                 ${CP} ${DESCR} ${_PKG_DBDIR}/${PKGNAME}/+DESC;  \  
                 ${ECHO} ${COMMENT:Q} > ${_PKG_DBDIR}/${PKGNAME}/+COMMENT; \  
                 ${CP} ${BUILD_VERSION_FILE} ${_PKG_DBDIR}/${PKGNAME}/+BUILD_VERSION; \  
                 ${CP} ${BUILD_INFO_FILE} ${_PKG_DBDIR}/${PKGNAME}/+BUILD_INFO; \  
                 if ${TEST} -f ${SIZE_PKG_FILE}; then                    \  
                         ${CP} ${SIZE_PKG_FILE} ${_PKG_DBDIR}/${PKGNAME}/+SIZE_PKG; \  
                 fi ;                                                    \  
                 if ${TEST} -f ${SIZE_ALL_FILE}; then                    \  
                         ${CP} ${SIZE_ALL_FILE} ${_PKG_DBDIR}/${PKGNAME}/+SIZE_ALL; \  
                 fi ;                                                    \  
                 if ${TEST} -f ${PRESERVE_FILE}; then                    \  
                         ${CP} ${PRESERVE_FILE} ${_PKG_DBDIR}/${PKGNAME}/+PRESERVE; \  
                 fi ;                                                    \  
                 if [ "${PKG_INSTALLATION_TYPE}" = "pkgviews" ]; then    \  
                         ${TOUCH} ${_PKG_DBDIR}/${PKGNAME}/+VIEWS;       \  
                 fi ;                                                    \  
                 if [ -n "${INSTALL_FILE}" ]; then                       \  
                         if ${TEST} -f ${INSTALL_FILE}; then             \  
                                 ${CP} ${INSTALL_FILE} ${_PKG_DBDIR}/${PKGNAME}/+INSTALL; \  
                         fi;                                             \  
                 fi;                                                     \  
                 if [ -n "${DEINSTALL_FILE}" ]; then                     \  
                         if ${TEST} -f ${DEINSTALL_FILE}; then           \  
                                 ${CP} ${DEINSTALL_FILE} ${_PKG_DBDIR}/${PKGNAME}/+DEINSTALL; \  
                         fi;                                             \  
                 fi;                                                     \  
                 if [ -n "${MESSAGE}" ]; then                            \  
                         if ${TEST} -f ${MESSAGE}; then                  \  
                                 ${CP} ${MESSAGE} ${_PKG_DBDIR}/${PKGNAME}/+DISPLAY; \  
                         fi;                                             \  
                 fi;                                                     \  
                 list="`${MAKE} ${MAKEFLAGS} run-depends-list ECHO_MSG=${TRUE} | ${SORT} -u`" ; \                  list="`${MAKE} ${MAKEFLAGS} run-depends-list ECHO_MSG=${TRUE} | ${SORT} -u`" ; \
                 for realdep in `${ECHO} $$list | ${XARGS} -n 1 ${SETENV} ${PKG_BEST_EXISTS} | ${SORT} -u`; do \                  for realdep in `${ECHO} $$list | ${XARGS} -n 1 ${SETENV} ${PKG_BEST_EXISTS} | ${SORT} -u`; do \
                         if ${TEST} -z "$$realdep"; then                 \                          if ${TEST} -z "$$realdep"; then                 \
Line 4356  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
Line 3616  fake-pkg: ${PLIST} ${DESCR} ${MESSAGE}
                                 ${MV} ${_PKG_DBDIR}/$$realdep/reqby.$$$$ ${_PKG_DBDIR}/$$realdep/+REQUIRED_BY; \                                  ${MV} ${_PKG_DBDIR}/$$realdep/reqby.$$$$ ${_PKG_DBDIR}/$$realdep/+REQUIRED_BY; \
                                 ${ECHO} "${PKGNAME} requires installed package $$realdep"; \                                  ${ECHO} "${PKGNAME} requires installed package $$realdep"; \
                         fi;                                             \                          fi;                                             \
                 done ;;                                                 \                  done;                                                   \
                   case ${PKG_INSTALLATION_TYPE} in                        \
                   overwrite)      ${RM} -rf ${_PKG_DBDIR}/${PKGNAME} ;;   \
                   esac;                                                   \
                   ${MKDIR} ${_PKG_DBDIR}/${PKGNAME};                      \
                   ${CP} ${PKG_DB_TMPDIR}/+* ${_PKG_DBDIR}/${PKGNAME};     \
                   ;;                                                      \
         esac          esac
 .if (${PKG_INSTALLATION_TYPE} == "pkgviews") && \  .if (${PKG_INSTALLATION_TYPE} == "pkgviews") && \
       !empty(BUILD_VIEWS:M[yY][eE][sS])        !empty(BUILD_VIEWS:M[yY][eE][sS])
Line 4434  real-su-remove-views:
Line 3700  real-su-remove-views:
         done          done
 .endif  .endif
   
 # Depend is generally meaningless for arbitrary packages, but if someone wants  .include "../../mk/bsd.pkg.data.mk"
 # one they can override this.  This is just to catch people who've gotten into  
 # the habit of typing `${MAKE} depend all install' as a matter of course.  
 #  
 .PHONY: depend  
 depend: .OPTIONAL  
   
 # Same goes for tags  
 .PHONY: tags  
 tags: .OPTIONAL  
   
 # if automatic manual page compression is done by the package according  
 # to MANZ's value, set MANCOMPRESSED if MANZ is set  
 .if defined(MANCOMPRESSED_IF_MANZ) && defined(MANZ)  
 MANCOMPRESSED=  yes  
 MAKE_ENV+=      MANZ="${MANZ}"  
 .endif  
   
 # generate ${PLIST} from ${PLIST_SRC} by:  
 # - substituting for PLIST_SUBST entries  
 # - fixing list of man-pages according to MANZ, MANINSTALL.  
 # - adding symlinks for shared libs (ELF) or ldconfig calls (a.out).  
   
 # plist awk pattern-action statement to handle MANINSTALL  
 _PLIST_AWK_MANINSTALL=                                                  \  
 {                                                                       \  
         if (!"${MANINSTALL:Mmaninstall}" &&                             \  
                 match($$0, "^([^/]*/)*man/([^/]*/)?man[1-9ln]") ) {     \  
                         next;                                           \  
         }                                                               \  
         if (!"${MANINSTALL:Mcatinstall}" &&                             \  
                 match($$0, "^([^/]*/)*man/([^/]*/)?cat[1-9ln]") ) {     \  
                         next;                                           \  
         }                                                               \  
 }  
   
 # plist awk pattern-action statement to strip '.gz' from man  
 # entries  
 _PLIST_AWK_STRIP_MANZ=                                                        \  
 /^([^\/]*\/)*man\/([^\/]*\/)?(man[1-9ln]\/.*[1-9ln]|cat[1-9ln]\/.*0)\.gz$$/ { \  
         $$0 = substr($$0, 1, length($$0) - 3);                                \  
 }  
   
 # plist awk pattern-action statement to add '.gz' to man entries  
 _PLIST_AWK_ADD_MANZ=                                                      \  
 /^([^\/]*\/)*man\/([^\/]*\/)?(man[1-9ln]\/.*[1-9ln]|cat[1-9ln]\/.*0)$$/ { \  
         $$0 = $$0 ".gz";                                                  \  
 }  
   
 # plist awk pattern-action statement to handle PLIST_SUBST substitutions  
 # BEWARE: the awk script quote is closed and reopened around the  
 # string argument of gsub() calls so historic quoting semantic of  
 # PLIST_SUBST is preserved.  
 # XXX `_str_quote_{start,end}_' is a gross hack to work around weird word  
 # splitting.  
 _PLIST_AWK_SUBST= { ${PLIST_SUBST:S|=|\\}/,_str_quote_start_|:S|$|_str_quote_end_);|:S|^|gsub(/\\\$\\{|:S|_str_quote_start_|"'|g:S|_str_quote_end_|'"|g} }  
   
 # plist awk pattern-action statement to rewrite "imake installed" catman pages  
 # as plain manpages.  
 _PLIST_AWK_IMAKE_MAN=                                                   \  
 /^([^\/]*\/)*man\/([^\/]*\/)?cat[1-9ln]\/.*0$$/ {                       \  
         n = match($$0, "/cat[1-9ln]");                                  \  
         sect = sprintf(".%s", substr($$0, n + 4, 1));                   \  
         sub("/cat", "/man");                                            \  
         sub("\\.0$$", sect);                                            \  
 }  
   
 # plist awk pattern-action statement to handle info files:  
 # generate list of files matching  
 # ${PREFIX}/${INFO_DIR}/filename(-[0-9]+)?(.gz)?  
 # for `filename' being each word of INFO_FILES in turn.  
 # Notes:  
 # - first the filenames matching ${PREFIX}/${INFO_DIR}/filename*  
 # are generated with ls then they are filtered by the exact pattern.  
 # - ${PREFIX}/${INFO_DIR}/filename is single quoted and single quote  
 # escaped  
 # XXX When all info file entries will be removed from PLIST files  
 # the non-BEGIN pattern-action statements generated below will be retired.  
 _PLIST_AWK_INFO=  
 .if ${PLIST_TYPE} == "static"  
 .  if !empty(INFO_FILES)  
 .    for _f_ in ${INFO_FILES}  
 _PLIST_AWK_INFO+=                                                       \  
 BEGIN {                                                                 \  
         cmd="${_f_}"; gsub("'\''", "\\'\''", cmd);                      \  
         sub("^", "${LS} '\''${PREFIX}/${INFO_DIR}/", cmd);              \  
         sub("$$", "'\''*", cmd);                                        \  
         while ((cmd | getline l) > 0) {                                 \  
                 if (match(l, ".*/${_f_:S|+|\\\+|g}(-[0-9]+)?(\\.gz)?$$")) { \  
                         sub("^${PREFIX}/", "", l);                      \  
                         print l;                                        \  
                 }                                                       \  
         }                                                               \  
         close(cmd);                                                     \  
 }                                                                       \  
 /^${INFO_DIR:S|/|\\/|g}\/${_f_}(-[0-9]+)?$$/ { next; }  
 .    endfor  
 .  endif  
 .endif  
   
 # plist awk pattern-action statement to expand libtool archives into  
 # shared and/or static libraries.  
 #  
 .if ${PLIST_TYPE} == "dynamic"  
 _PLIST_AWK_LIBTOOL?=    # empty  
 .elif empty(LIBTOOLIZE_PLIST:M[yY][eE][sS])  
 BROKEN+=                "USE_LIBTOOL requires LIBTOOLIZE_PLIST=yes for proper PLIST generation"  
 .else  
 _PLIST_AWK_LIBTOOL?=                                                    \  
 /^[^@].*\.la$$/ {                                                       \  
         system("cd ${PREFIX} && ${_PRINT_LA_LIBNAMES} " $$0)            \  
 }  
 .endif  
   
 # _PLIST_AWK_SCRIPT hold the complete awk script for plist target.  
 #  
 _PLIST_AWK_SCRIPT=      '  
 # Do the substitutions  
 # See comments above about _PLIST_AWK_SUBST: it contains single quotes!  
 # So _PLIST_AWK_SCRIPT is intended to be single quoted.  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_SUBST}  
 # Generated entries for info files  
 .if !empty(INFO_FILES)  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_INFO}  
 .endif  
 # Expand libtool archives  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_LIBTOOL}  
 # Strip the '.gz' suffixes on man entries  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_STRIP_MANZ}  
 # Deal with MANINSTALL and man entries  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_MANINSTALL}  
 # Deal with "imake installed" catman pages  
 .if defined(USE_IMAKE) && ${_PREFORMATTED_MAN_DIR} == "man"  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_IMAKE_MAN}  
 .endif  
 # Add '.gz' suffixes on man entries if needed  
 .if defined(MANZ)  
 _PLIST_AWK_SCRIPT+=     ${_PLIST_AWK_ADD_MANZ}  
 .endif  
 # Print the entry  
 _PLIST_AWK_SCRIPT+=     { print $$0; }  
 #  
 _PLIST_AWK_SCRIPT+=     '  
   
 # GENERATE_PLIST is a sequence of commands, terminating in a semicolon,  
 #       that outputs contents for a PLIST to stdout and is appended to  
 #       the contents of ${PLIST_SRC}.  
 #  
 GENERATE_PLIST?=        ${TRUE};  
 .if ${PLIST_TYPE} == "dynamic"  
 _PLIST_IGNORE_CMD=                                                      \  
         ( while read i; do                                              \  
                 ignore=no;                                              \  
                 for p in ${_PLIST_IGNORE_FILES}; do                     \  
                         case "$$i" in                                   \  
                         $$p)    ignore=yes; break ;;                    \  
                         esac;                                           \  
                 done;                                                   \  
                 [ "$$ignore" = "yes" ] || ${ECHO} "$$i";                \  
           done )  
 _GENERATE_PLIST=                                                        \  
         ${FIND} ${PREFIX} \! -type d -print | ${SORT} |                 \  
                 ${SED} -e "s|^${PREFIX}/||" |                           \  
                 ${_PLIST_IGNORE_CMD};                                   \  
         ${FIND} ${PREFIX} -type d -print | ${SORT} -r |                 \  
                 ${GREP} -v "^${PREFIX}$$" |                             \  
                 ${_PLIST_IGNORE_CMD} |                                  \  
                 ${SED} -e "s|^${PREFIX}/|@unexec ${RMDIR} -p %D/|"      \  
                        -e "s,$$, 2>/dev/null || ${TRUE},";  
 .else  
 _GENERATE_PLIST=        ${CAT} ${PLIST_SRC}; ${GENERATE_PLIST}  
 .endif  
   
 .if ${PLIST_TYPE} == "static"  
 ${PLIST}: ${PLIST_SRC}  
 .endif  
 ${PLIST}:  
         ${_PKG_SILENT}${_PKG_DEBUG}                                     \  
         { ${_GENERATE_PLIST} } | ${AWK} ${_PLIST_AWK_SCRIPT}            \  
                 > ${PLIST};                                             \  
           ${MAKE} ${MAKEFLAGS} do-shlib-handling                        \  
                 SHLIB_PLIST_MODE=1  
   
 # generate ${DESCR} from ${DESCR_SRC} by:  
 # - Appending the homepage URL, if any  
   
 .PHONY: descr  
 descr: ${DESCR}  
 ${DESCR}: ${DESCR_SRC}  
         @${CAT} ${DESCR_SRC}     >${DESCR}  
 .if defined(HOMEPAGE)  
         @\  
         ${ECHO}                 >>${DESCR} ; \  
         ${ECHO} "Homepage:"     >>${DESCR} ; \  
         ${ECHO} '${HOMEPAGE}'   >>${DESCR}  
 .endif  
   
 .include "../../mk/subst.mk"  .include "../../mk/subst.mk"
   
 #  #

Legend:
Removed from v.1.1540.2.1  
changed lines
  Added in v.1.1540.2.26

CVSweb <webmaster@jp.NetBSD.org>