mk/bsd.pkg.readme.mk

   1 # $NetBSD: bsd.pkg.readme.mk,v 1.25 2011/09/08 20:17:15 abs Exp $
   2 #
   3 # This Makefile fragment is included by bsd.pkg.mk and encapsulates the
   4 # code to produce README.html files in each package directory.
   5 #
   6 # The following are the "public" targets provided by this module.
   7 #
   8 #    readme             This target generates a README.html file suitable
   9 #                       for being served via FTP.
  10 #
  11 #    cdrom-readme       This target generates a README.html file suitable
  12 #                       for being served from a mounted CD-ROM.
  13 #
  14 # The following are the user-settable variables that may be defined in
  15 # /etc/mk.conf.
  16 #
  17 #    FTP_PKG_URL_HOST is the host portion of the URL to embed in each
  18 #       README.html file to be served via FTP, and defaults to
  19 #       "ftp://ftp.NetBSD.org".
  20 #
  21 #    FTP_PKG_URL_DIR is the directory portion of the URL to embed in each
  22 #       README.html file to be served via FTP, and defaults to
  23 #       "/pub/pkgsrc/packages".
  24 #
  25 #    CDROM_PKG_URL_HOST is the host portion of the URL to embed in each
  26 #       README.html file to be served from a mounted CD-ROM, and defaults
  27 #       to "file://localhost".
  28 #
  29 #    CDROM_PKG_URL_DIR is the directory portion of the URL to embed in each
  30 #       README.html file to be served from a mounted CD-ROM, and defaults
  31 #       to "/usr/pkgsrc/packages".
  32 #
  33
  34 # Set to "html" by the README.html target to generate HTML code,
  35 # or to "svr4" to print SVR4 (Solaris, ...) short package names, from
  36 # SVR4_PKGNAME variable.
  37 # This variable is passed down via build-depends-list and run-depends-list
  38 PACKAGE_NAME_TYPE?=     name
  39
  40 _HTML_PKGLINK=          <a href="../../${PKGPATH}/README.html">${PKGNAME}</a>
  41
  42 .PHONY: package-name
  43 .if !target(package-name)
  44 package-name:
  45 .  if (${PACKAGE_NAME_TYPE} == "html")
  46         @${ECHO} ${_HTML_PKGLINK:Q}
  47 .  elif (${PACKAGE_NAME_TYPE} == "svr4")
  48         @${ECHO} ${SVR4_PKGNAME}
  49 .  else
  50         @${ECHO} ${PKGNAME}
  51 .  endif # PACKAGE_NAME_TYPE
  52 .endif # !target(package-name)
  53
  54 .PHONY: make-readme-html-help
  55 .if !target(make-readme-html-help)
  56 make-readme-html-help:
  57         @${ECHO} '${PKGNAME}</a>: <TD>'${COMMENT:Q}
  58 .endif # !target(make-readme-html-help)
  59
  60 # Show (non-recursively) all the packages this package depends on.
  61 # If PACKAGE_DEPENDS_WITH_PATTERNS is set, print as pattern (if possible)
  62 PACKAGE_DEPENDS_WITH_PATTERNS?=true
  63 .PHONY: run-depends-list
  64 .if !target(run-depends-list)
  65 run-depends-list:
  66 .  for dep in ${DEPENDS}
  67         @pkg="${dep:C/:.*//}";                                          \
  68         dir="${dep:C/[^:]*://}";                                        \
  69         cd ${.CURDIR};                                                  \
  70         if ${PACKAGE_DEPENDS_WITH_PATTERNS}; then                       \
  71                 ${ECHO} "$$pkg";                                        \
  72         else                                                            \
  73                 if cd $$dir 2>/dev/null; then                           \
  74                         ${RECURSIVE_MAKE} ${MAKEFLAGS} package-name PACKAGE_NAME_TYPE=${PACKAGE_NAME_TYPE}; \
  75                 else                                                    \
  76                         ${ECHO_MSG} "Warning: \"$$dir\" non-existent -- @pkgdep registration incomplete" >&2; \
  77                 fi;                                                     \
  78         fi
  79 .  endfor
  80 .endif # target(run-depends-list)
  81
  82 .PHONY: build-depends-list
  83 .if !target(build-depends-list)
  84 build-depends-list:
  85         @${_DEPENDS_WALK_CMD} ${PKGPATH} |                              \
  86         while read dir; do                                              \
  87                 ( cd ../../$$dir && ${RECURSIVE_MAKE} ${MAKEFLAGS} package-name) \
  88         done
  89 .endif
  90
  91 # If PACKAGES is set to the default (../../pkgsrc/packages), the current
  92 # ${MACHINE_ARCH} and "release" (uname -r) will be used. Otherwise a directory
  93 # structure of ...pkgsrc/packages/`uname -r`/${MACHINE_ARCH} is assumed.
  94 # The PKG_URL is set from FTP_PKG_URL_* or CDROM_PKG_URL_*, depending on
  95 # the target used to generate the README.html file.
  96 .PHONY: binpkg-list
  97 .if !target(binpkg-list)
  98 binpkg-list:
  99         @if ${TEST} -d ${PACKAGES}; then                                        \
 100                 cd ${PACKAGES};                                         \
 101                 case ${.CURDIR} in                                      \
 102                 */pkgsrc/packages)                                      \
 103                         for pkg in ${PKGREPOSITORYSUBDIR}/${PKGWILDCARD}${PKG_SUFX} ; \
 104                         do                                              \
 105                                 if [ -f "$$pkg" ] ; then                \
 106                                         pkgname=`${ECHO} $$pkg | ${SED} 's@.*/@@'`; \
 107                                         ${ECHO} "<TR><TD>${MACHINE_ARCH}:<TD><a href=\"${PKG_URL}/$$pkg\">$$pkgname</a><TD>(${OPSYS} ${OS_VERSION})"; \
 108                                 fi ;                                    \
 109                         done ;                                          \
 110                         ;;                                              \
 111                 *)                                                      \
 112                         cd ${PACKAGES}/../..;                           \
 113                         for i in [1-9].*/*; do                          \
 114                                 if cd ${PACKAGES}/../../$$i/${PKGREPOSITORYSUBDIR} 2>/dev/null; then \
 115                                         for j in ${PKGWILDCARD}${PKG_SUFX}; \
 116                                         do                              \
 117                                                 if [ -f "$$j" ]; then   \
 118                                                         ${ECHO} $$i/$$j;\
 119                                                 fi;                     \
 120                                         done;                           \
 121                                 fi;                                     \
 122                         done | ${AWK} -F/ '                             \
 123                                 {                                       \
 124                                         release = $$1;                  \
 125                                         arch = $$2;                     \
 126                                         pkg = $$3;                      \
 127                                         gsub("\\.tgz","", pkg);         \
 128                                         if (arch != "m68k" && arch != "mipsel") { \
 129                                                 if (arch in urls)       \
 130                                                         urls[arch "/" pkg "/" release] = "<a href=\"${PKG_URL}/" release "/" arch "/${PKGREPOSITORYSUBDIR}/" pkg "${PKG_SUFX}\">" pkg "</a>, " urls[arch]; \
 131                                                 else                    \
 132                                                         urls[arch "/" pkg "/" release] = "<a href=\"${PKG_URL}/" release "/" arch "/${PKGREPOSITORYSUBDIR}/" pkg "${PKG_SUFX}\">" pkg "</a> "; \
 133                                         }                               \
 134                                 }                                       \
 135                                 END {                                   \
 136                                         for (av in urls) {              \
 137                                                 split(av, ava, "/");    \
 138                                                 arch=ava[1];            \
 139                                                 pkg=ava[2];             \
 140                                                 release=ava[3];         \
 141                                                 print "<TR><TD>" arch ":<TD>" urls[av] "<TD>(${OPSYS} " release ")"; \
 142                                         }                               \
 143                                 }' | ${SORT}                            \
 144                         ;;                                              \
 145                 esac;                                                   \
 146         fi
 147 .endif
 148
 149 # This target generates an index entry suitable for aggregation into
 150 # a large index.  Format is:
 151 #
 152 # distribution-name|package-path|installation-prefix|comment| \
 153 #  description-file|maintainer|categories|build deps|run deps|for arch| \
 154 #  not for opsys
 155 #
 156 # XXX Need to handle BUILD_DEPENDS/TOOL_DEPENDS split.
 157 #
 158 .PHONY: describe
 159 .if !target(describe)
 160 describe:
 161         @${ECHO_N} "${PKGNAME}|${.CURDIR}|";                            \
 162         ${ECHO_N} "${PREFIX}|";                                         \
 163         ${ECHO_N} ${COMMENT:Q};                                         \
 164         if [ -f "${DESCR_SRC}" ]; then                                  \
 165                 ${ECHO_N} "|${DESCR_SRC}";                              \
 166         else                                                            \
 167                 ${ECHO_N} "|/dev/null";                                 \
 168         fi;                                                             \
 169         ${ECHO_N} "|${MAINTAINER}|${CATEGORIES}|";                      \
 170         case "A${BUILD_DEPENDS}B${DEPENDS}C" in \
 171                 ABC) ;;                                                 \
 172                 *) cd ${.CURDIR} && ${ECHO_N} `${RECURSIVE_MAKE} ${MAKEFLAGS} build-depends-list | ${SORT} -u`;; \
 173         esac;                                                           \
 174         ${ECHO_N} "|";                                                  \
 175         if [ "${DEPENDS}" != "" ]; then                                 \
 176                 cd ${.CURDIR} && ${ECHO_N} `${RECURSIVE_MAKE} ${MAKEFLAGS} run-depends-list | ${SORT} -u`; \
 177         fi;                                                             \
 178         ${ECHO_N} "|";                                                  \
 179         if [ "${ONLY_FOR_PLATFORM}" = "" ]; then                        \
 180                 ${ECHO_N} "any";                                        \
 181         else                                                            \
 182                 ${ECHO_N} "${ONLY_FOR_PLATFORM}";                       \
 183         fi;                                                             \
 184         ${ECHO_N} "|";                                                  \
 185         if [ "${NOT_FOR_PLATFORM}" = "" ]; then                         \
 186                 ${ECHO_N} "any";                                        \
 187         else                                                            \
 188                 ${ECHO_N} "not ${NOT_FOR_PLATFORM}";                    \
 189         fi;                                                             \
 190         ${ECHO} ""
 191 .endif
 192
 193 .PHONY: readmes
 194 .if !target(readmes)
 195 readmes:        readme
 196 .endif
 197
 198 # This target is used to generate README.html files
 199 .PHONY: readme
 200 .if !target(readme)
 201 FTP_PKG_URL_HOST?=      ftp://ftp.NetBSD.org
 202 FTP_PKG_URL_DIR?=       /pub/pkgsrc/packages
 203
 204 readme:
 205         @cd ${.CURDIR} && ${RECURSIVE_MAKE} ${MAKEFLAGS} README.html PKG_URL=${FTP_PKG_URL_HOST}${FTP_PKG_URL_DIR}
 206 .endif
 207
 208 # This target is used to generate README.html files, very like "readme"
 209 # However, a different target was used for ease of use.
 210 .PHONY: cdrom-readme
 211 .if !target(cdrom-readme)
 212 CDROM_PKG_URL_HOST?=    file://localhost
 213 CDROM_PKG_URL_DIR?=     /usr/pkgsrc/packages
 214
 215 cdrom-readme:
 216         @cd ${.CURDIR} && ${RECURSIVE_MAKE} ${MAKEFLAGS} README.html PKG_URL=${CDROM_PKG_URL_HOST}${CDROM_PKG_URL_DIR}
 217 .endif
 218
 219 README_NAME=    ${TEMPLATES}/README.pkg
 220
 221 # set up the correct license information as a sed expression
 222 .if defined(LICENSE)
 223 SED_LICENSE_EXPR=       -e 's|%%LICENSE%%|<p>Please note that this package has a ${LICENSE} license.</p>|'
 224 .else
 225 SED_LICENSE_EXPR=       -e 's|%%LICENSE%%||'
 226 .endif
 227
 228 # set up the "more info URL" information as a sed expression
 229 .if defined(HOMEPAGE)
 230 SED_HOMEPAGE_EXPR=      -e 's|%%HOMEPAGE%%|<p>This package has a home page at <a HREF="${HOMEPAGE}">${HOMEPAGE}</a>.</p>|'
 231 .else
 232 SED_HOMEPAGE_EXPR=      -e 's|%%HOMEPAGE%%||'
 233 .endif
 234
 235 # If PACKAGES is set to the default (../../packages), the current
 236 # ${MACHINE_ARCH} and "release" (uname -r) will be used. Otherwise a directory
 237 # structure of ...pkgsrc/packages/`uname -r`/${MACHINE_ARCH} is assumed.
 238 # The PKG_URL is set from FTP_PKG_URL_* or CDROM_PKG_URL_*, depending on
 239 # the target used to generate the README.html file.
 240 .PHONY: README.html
 241 README.html: .PRECIOUS
 242         @${PKGSRC_SETENV} BMAKE=${MAKE:Q} ${SH} ../../mk/scripts/mkdatabase -f $@.tmp1
 243         @if ${TEST} -d ${PACKAGES}; then                                \
 244                 cd ${PACKAGES};                                         \
 245                 case `${PWD_CMD}` in                                    \
 246                         ${PKGSRCDIR}/packages)                          \
 247                                 MULTIARCH=no;                           \
 248                                 ;;                                      \
 249                         *)                                              \
 250                                 MULTIARCH=yes;                          \
 251                                 ;;                                      \
 252                 esac;                                                   \
 253                 cd ${.CURDIR} ;                                         \
 254         fi;                                                             \
 255         if [ `${PKG_ADMIN} -V` -lt 20080415 ]; then                     \
 256                 SCAN_VULNERABILITIES=0;                                 \
 257         else                                                            \
 258         _PVDIR=`${PKG_ADMIN} config-var PKGVULNDIR`;                    \
 259         if [ -e "$${_PVDIR}"/pkg-vulnerabilities ]; then                \
 260                 SCAN_VULNERABILITIES=2;                                 \
 261         else                                                            \
 262                 SCAN_VULNERABILITIES=1;                                 \
 263         fi;                                                             \
 264         fi;                                                             \
 265         ${AWK} -f ../../mk/scripts/genreadme.awk \
 266                 builddependsfile=/dev/null \
 267                 dependsfile=/dev/null \
 268                 AWK=${AWK:Q} \
 269                 CMP=${CMP:Q} \
 270                 DISTDIR=${DISTDIR:Q} \
 271                 GREP=${GREP:Q} \
 272                 PACKAGES=${PACKAGES:Q} \
 273                 PKG_ADMIN=${PKG_ADMIN:Q} \
 274                 PKG_INFO=${PKG_INFO:Q} \
 275                 PKG_SUFX=${PKG_SUFX:Q} \
 276                 PKG_URL=${PKG_URL:Q} \
 277                 PKGSRCDIR=${.CURDIR:C|/[^/]*/[^/]*$||:Q} \
 278                 PKGTOOLS_VERSION=${PKGTOOLS_VERSION} \
 279                 SCAN_VULNERABILITIES=$${SCAN_VULNERABILITIES} \
 280                 SED=${SED:Q} \
 281                 SETENV=${SETENV:Q} \
 282                 SORT=${SORT:Q} \
 283                 TMPDIR=${TMPDIR:U/tmp:Q} \
 284                 SINGLEPKG=${PKGPATH:Q} \
 285                 $@.tmp1
 286         @${RM} $@.tmp1
 287
 288 .PHONY: print-build-depends-list
 289 .if !target(print-build-depends-list)
 290 print-build-depends-list:
 291 .  if !empty(BUILD_DEPENDS) || !empty(DEPENDS)
 292         @${ECHO_N} 'This package requires package(s) "'
 293         @${ECHO_N} `${RECURSIVE_MAKE} ${MAKEFLAGS} build-depends-list | ${SORT} -u`
 294         @${ECHO} '" to build.'
 295 .  endif
 296 .endif
 297
 298 .PHONY: print-run-depends-list
 299 .if !target(print-run-depends-list)
 300 print-run-depends-list:
 301 .  if !empty(DEPENDS)
 302         @${ECHO_N} 'This package requires package(s) "'
 303         @${ECHO_N} `${RECURSIVE_MAKE} ${MAKEFLAGS} run-depends-list | ${SORT} -u`
 304         @${ECHO} '" to run.'
 305 .  endif
 306 .endif
 307
 308 # This target is used by the mk/scripts/mkreadme script to generate
 309 # README.html files
 310 .PHONY: print-summary-data
 311 .if !target(print-summary-data)
 312 print-summary-data:
 313         @${ECHO} depends ${PKGPATH} ${DEPENDS:Q}
 314         @${ECHO} build_depends ${PKGPATH} ${BUILD_DEPENDS:Q}
 315         @${ECHO} conflicts ${PKGPATH} ${CONFLICTS:Q}
 316         @${ECHO} index ${PKGPATH} ${PKGNAME:Q}
 317         @${ECHO} htmlname ${PKGPATH} ${_HTML_PKGLINK:Q}
 318         @${ECHO} homepage ${PKGPATH} ${HOMEPAGE:Q}
 319         @${ECHO} wildcard ${PKGPATH} ${PKGWILDCARD:Q}
 320         @${ECHO} comment ${PKGPATH} ${COMMENT:Q}
 321         @${ECHO} license ${PKGPATH} ${LICENSE:Q}
 322         @if [ "${ONLY_FOR_PLATFORM}" = "" ]; then                       \
 323                 ${ECHO} "onlyfor ${PKGPATH} any";                       \
 324         else                                                            \
 325                 ${ECHO} "onlyfor ${PKGPATH} ${ONLY_FOR_PLATFORM}";      \
 326         fi
 327         @if [ "${NOT_FOR_PLATFORM}" = "" ]; then                        \
 328                 ${ECHO} "notfor ${PKGPATH} any";                        \
 329         else                                                            \
 330                 ${ECHO} "notfor ${PKGPATH} not ${NOT_FOR_PLATFORM}";    \
 331         fi;
 332         @if [ -n "${OWNER}" ]; then                                     \
 333                 ${ECHO} "owner ${PKGPATH} ${OWNER}";                    \
 334         else                                                            \
 335                 ${ECHO} "maintainer ${PKGPATH} ${MAINTAINER}";          \
 336         fi
 337         @${ECHO} "categories ${PKGPATH} ${CATEGORIES}"
 338         @if [ -f "${DESCR_SRC}" ]; then                                 \
 339                 ${ECHO}  "descr ${PKGPATH} ${DESCR_SRC:S;${PKGSRCDIR}/;;g}"; \
 340         else                                                            \
 341                 ${ECHO}  "descr ${PKGPATH} /dev/null";                  \
 342         fi
 343         @${ECHO} "prefix ${PKGPATH} ${PREFIX}"
 344 .endif