[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.4 and 1.1540.2.12

version 1.1540.2.4, 2004/11/23 17:15:22 version 1.1540.2.12, 2005/01/24 18:25:28
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 48  NOCLEAN?=  NO # don't clean up after upd
Line 43  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 52  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 69  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 95  PLIST_SRC+=  ${PKGDIR}/PLIST.common_end
Line 90  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
 DEPENDS?=               # empty  DEPENDS?=               # empty
 DESCR_SRC?=             ${PKGDIR}/DESCR  DESCR_SRC?=             ${PKGDIR}/DESCR
 DIGEST_ALGORITHM?=      SHA1  DIGEST_ALGORITHM?=      SHA1
Line 111  CONFIGURE_DIRS?= ${WRKSRC}
Line 106  CONFIGURE_DIRS?= ${WRKSRC}
 CONFIGURE_SCRIPT?=      ./configure  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
Line 135  BUILD_DEFS_FIXED+= NO_SRC_ON_FTP NO_SRC_
Line 132  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  ##### 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
Line 161  PRESERVE_FILE=  ${WRKDIR}/.PRESERVE
Line 158  PRESERVE_FILE=  ${WRKDIR}/.PRESERVE
 ${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 204  PKG_FAIL_REASON+=' cd ${PKGSRCDIR}/pkgto
Line 201  PKG_FAIL_REASON+=' cd ${PKGSRCDIR}/pkgto
 .  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'
 PKG_FAIL_REASON+='assignment of WRKSRC= $${WRKDIR}'  PKG_FAIL_REASON+='assignment of WRKSRC= $${WRKDIR}'
Line 245  PKG_FAIL_REASON+='ONLY/NOT_FOR_ARCHS/OPS
Line 246  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 352  ${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
Line 365  ALL_ENV+= CPPFLAGS=${CPPFLAGS:Q}
Line 364  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=${F77:Q}
   ALL_ENV+=       FC=${FC:Q}
 ALL_ENV+=       FFLAGS=${FFLAGS:Q}  ALL_ENV+=       FFLAGS=${FFLAGS:Q}
 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}
Line 437  _ULIMIT_CMD+= ${ULIMIT_CMD_${res}:D${ULI
Line 438  _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 528  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 557  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 614  MESSAGE_SUBST+= X11PREFIX=${X11PREFIX}
Line 625  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 662  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 864  BUILD_DEFS_FIXED+= IGNORE_RECOMMENDED
Line 875  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 1052  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
Line 1045  _REAL_TARGETS.patch+= patch-message pre-
Line 1073  _REAL_TARGETS.patch+= patch-message pre-
 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  _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 1058  _REAL_TARGETS.tools+= tools-message pre-
Line 1084  _REAL_TARGETS.tools+= tools-message pre-
 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  _REAL_TARGETS.wrapper+= wrapper-message pre-wrapper do-wrapper post-wrapper
Line 1078  _REAL_TARGETS.wrapper+= wrapper-message 
Line 1099  _REAL_TARGETS.wrapper+= wrapper-message 
 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 1120  CONFIG_GUESS_OVERRIDE?=  \
Line 1139  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 1311  pre-install: .OPTIONAL
Line 1331  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 1373  post-install-man:
Line 1400  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 1448  _REAL_TARGETS.undo-replace+= do-su-undo-
Line 1475  _REAL_TARGETS.undo-replace+= do-su-undo-
 # 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.package+= do-su-package
   
 _REAL_TARGETS.su-package+=  _REAL_TARGETS.su-package+=
Line 1516  _PKG_ALL_TARGET= test
Line 1554  _PKG_ALL_TARGET= test
 .MAIN: all  .MAIN: all
 all dependall: recurse-${_PKG_ALL_TARGET:Ubuild}  all dependall: recurse-${_PKG_ALL_TARGET:Ubuild}
   
   # 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 this package will be skipped, use placebo targets.
   
 .if defined(_PKG_SKIPPED)  .if defined(_PKG_SKIPPED)
Line 1525  all dependall: recurse-${_PKG_ALL_TARGET
Line 1574  all dependall: recurse-${_PKG_ALL_TARGET
                 update                  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)
Line 1560  undo-replace: real-undo-replace
Line 1608  undo-replace: real-undo-replace
   
 .  for targ in ${_PKG_PHASES_WRKDIR}  .  for targ in ${_PKG_PHASES_WRKDIR}
 ${${targ}_COOKIE}: real-${targ}  ${${targ}_COOKIE}: real-${targ}
         ${_PKG_SILENT}${_PKG_DEBUG}${ECHO} ${PKGNAME} >${${targ}_COOKIE}          ${_PKG_SILENT}${_PKG_DEBUG}${RM} -f $@ && ${ECHO} ${PKGNAME} >$@
 .  endfor  .  endfor
   
 # mark a stage as complete if its cookie (and all parent cookies) exist  # mark a stage as complete if its cookie (and all parent cookies) exist
Line 1809  _RESUME_TRANSFER=       \
Line 1857  _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 1822  _RESUME_TRANSFER=       \
Line 1870  _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 1888  _FETCH_FILE=        \
Line 1936  _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 1897  _FETCH_FILE=        \
Line 1945  _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 2012  do-fetch:
Line 2060  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 2492  do-ltconfig-override:
Line 2408  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 2508  do-config-star-override:
Line 2424  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 2520  do-config-star-override:
Line 2436  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 2540  SUBST_FILES.pkgconfig=  ${PKGCONFIG_OVER
Line 2468  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 2630  BUILD_MAKE_FLAGS?= ${MAKE_FLAGS}
Line 2558  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 2650  do-test:
Line 2578  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 2992  ${DDIR}: ${DLIST}
Line 2907  ${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 3145  distclean: pre-distclean clean
Line 3040  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 3291  real-su-bin-install:
Line 3092  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 3345  run-depends-list:
Line 3121  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 3365  package-noinstall:
Line 3160  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 3419  build-depends-list:
Line 3213  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 3976  real-su-remove-views:
Line 3520  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  
   
 .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.4  
changed lines
  Added in v.1.1540.2.12

CVSweb <webmaster@jp.NetBSD.org>