1. xemacs
  2. xemacs-packages

Commits

scop  committed f26c3b4

The meat from Ben's packages patch <n0nrtshm.fsf@xemacs.org>

  • Participants
  • Parent commits 887958c
  • Branches default

Comments (0)

Files changed (11)

File ChangeLog

View file
+2002-12-08  Ville Skyttä  <scop@xemacs.org>
+
+	* Local.rules.template (TEXI2HTML_FLAGS): Wiggle around
+	different args for different texi2html versions.
+	* package-net-packages.el
+	(package-net-packages-batch-convert-index-to-ini): Typo fix.
+
 2002-11-29  Ben Wing  <ben@xemacs.org>
 
+	* INSTALL (IMPORTANT):
+	Rewrite in accordance with changes in Local.rules.template, and
+	generally clarify the proper way to build packages.
+	
+	* Local.rules.mk:
+	Remove bogus comment.
+	
+	* Local.rules.template:
+	* Local.rules.template (XEMACS):
+	* Local.rules.template (symlink): Removed.
+	* Local.rules.template (BUILD_WITHOUT_MULE):
+	* Local.rules.template (BUILD_UNSUPPORTED): New.
+	* Local.rules.template (XEMACS_NATIVE_NT):
+	* Local.rules.template (XEMACS_INSTALLED_PACKAGES_ROOT): New.
+	* Local.rules.template (XEMACS_NATIVE_NT_NEEDS_EXTRA_QUOTING): Removed.
+	* Local.rules.template (NONMULE_INSTALLED_PACKAGES_ROOT): New.
+	* Local.rules.template (XEMACS_STAGING): Removed.
+	* Local.rules.template (MULE_INSTALLED_PACKAGES_ROOT): New.
+	* Local.rules.template (MULE_STAGING): Removed.
+	* Local.rules.template (UNSUPPORTED_INSTALLED_PACKAGES_ROOT): New.
+	* Local.rules.template (MULE_PACKAGES):
+	* Local.rules.template (XEMACS_PACKAGES): Removed.
+	* Local.rules.template (NONMULE_PACKAGES): New.
+	* Local.rules.template (PACKAGE_INDEX):
+	* Local.rules.template (UNSUPPORTED_PACKAGES): New.
+	* Local.rules.template (STAGING): Removed.
+	* Local.rules.template (VANILLA):
+	* Local.rules.template (BATCH): New.
+	* Local.rules.template (MAKEINFO):
+	* Local.rules.template (TEXI2HTML_FLAGS):
+	* Local.rules.template (TEXI2DVI): New.
+	* Local.rules.template (DVIPS): New.
+	* Local.rules.template (TEXI2PDF): New.
+	Add BUILD_UNSUPPORTED for building unsupported/*.  Rearrange so
+	that the stuff people actually need to change is all at the top.
+	Replace confusing *_STAGING names with names indicating that these
+	are the roots of installed packages.  Support broken TEXI2DVI and
+	TEXI2PDF, e.g. current Cygwin.	Add $(BATCH), for use when running
+	XEmacs in batch mode -- automatically sets stack-trace-on-error
+	and various load-* flags.  Add comment about using `pax' under
+	FreeBSD to generate links.
+
+	* meta-iterate.rules: New file.  Generalize the stuff in
+	`Makefile', for use also in unsupported/Makefile.
+	
+	* Makefile (SUBDIRS):
+	* Makefile (XEMACS_PACKAGES_BASE):
+	* Makefile (all):
+	* Makefile (.PHONY): Removed.
+	* Makefile (ALL_TARGETS): Removed.
+	* Makefile (AUTOLOADS_TARGETS): Removed.
+	* Makefile (BYTECOMPILE_TARGETS): Removed.
+	* Makefile (BINDIST_TARGETS): Removed.
+	* Makefile (CLEAN_TARGETS): Removed.
+	* Makefile (DISTCLEAN_TARGETS): Removed.
+	* Makefile (ELCCLEAN_TARGETS): Removed.
+	* Makefile (HTML_TARGETS): Removed.
+	* Makefile (JUST_INSTALL_TARGETS): Removed.
+	* Makefile (all-bytecompile): Removed.
+	* Makefile (autoloads): Removed.
+	* Makefile (bytecompile): Removed.
+	* Makefile (bindist-real): Removed.
+	* Makefile (bindist): Removed.
+	* Makefile (clean): Removed.
+	* Makefile (distclean): Removed.
+	* Makefile (elcclean): Removed.
+	* Makefile (html): Removed.
+	* Makefile (World): Removed.
+	* Makefile (install): Removed.
+	* Makefile (just-install): Removed.
+	Delete this file and include meta-iterate.rules instead.
+
+	* XEmacs.rules:
+	* XEmacs.rules (bytecompile):
+	* XEmacs.rules (all): New.
+	* XEmacs.rules (.SUFFIXES):
+	* XEmacs.rules (STAGING): New.
+	* XEmacs.rules (check-staging): New.
+	* XEmacs.rules (FORMAT_INFO_LEVEL_3_USING_XEMACS_NO_SAVE_ARGS):
+	* XEmacs.rules (html):
+	* XEmacs.rules (BOOT_XEMACS):
+	* XEmacs.rules (compile): New.
+	* XEmacs.rules (elcclean):
+	* XEmacs.rules (AUTOLOAD_FILE):
+	* XEmacs.rules (package-info):
+	* XEmacs.rules (bindist):
+	* XEmacs.rules (setup-info):
+	* XEmacs.rules (install):
+	* XEmacs.rules (autoloads):
+	* XEmacs.rules (binkit-common):
+	* XEmacs.rules (just-install): New.
+	Make sure that we get consistent results when running `make'
+	from this directory -- rebuild all autoloads below, then bytecompile.
+	Handle unsupported/ directory.
+	Check that STAGING is set so we don't have file system trashage.
+	Use $(BATCH).
+	Correct usage of texi2html consistent with latest versions.
+
+	* hack-package-index.el (batch-hack-package-index):
+	Handle unsupported/ directory.
+
+	* iterate.rules:
+	* iterate.rules (XEMACS_PACKAGES_BASE): New.
+	* iterate.rules (JUST_INSTALL_TARGETS): New.
+	* iterate.rules (all): New.
+	* iterate.rules (.PHONY):
+	* iterate.rules (just-install): New.
+	* iterate.rules (DEPENDS_FILES):
+	Make sure that we get consistent results when running `make'
+	from this directory -- rebuild all autoloads below, then bytecompile.
+	Allow for this file to be included anywhere in the directory tree.
+	Support target `just-install'.
+	
+	* package-compile.el:
+	* package-compile.el (package-directory-map):
+	* package-compile.el (package-source-root): New.
+	* package-compile.el (package-name-to-directory):
+	Handle unsupported/ directory.
+	Set various new load-* flags for better debugging results.
+	Set load-ignore-out-of-date-elc-files for better compilation results.
+
+	* package-net-packages.el:
+	* package-net-packages.el (package-net-packages-convert-index-to-ini):
+	* package-net-packages.el (package-net-packages-batch-convert-index-to-ini):
+	Handle unsupported/ directory.
+
 	* xemacs-packages/Makefile: Fix comment.
 
 2002-12-06  Rendhalver [Peter Brown]  <rendhalver@xemacs.org>

File INSTALL

View file
 
 * Building:
 -----------
-** Building Quickstart:
+** Getting Started Quickly:
 
 	(1) Create a 'Local.rules' file in the toplevel directory and
 	    edit it to suit your needs.  There is a
 -------------
 ** Installing after a 'make install'
 
-	I know that sounds odd, but if you set $XEMACS_STAGING and
-	$MULE_STAGING to anything other than
-	<emacs-roots>/lib/xemacs/xemacs-packages and
-	<emacs-roots>/lib/xemacs/mule-packages respectively, you will
-	need to either copy, move or symlink.
+	Under normal circumstances, the packages should be installed to
+	<xemacs-root>/lib/xemacs/xemacs-packages and
+	<xemacs-root>/lib/xemacs/mule-packages.  <xemacs-root> is the
+	topmost-level directory under which everything is installed --
+	normally /usr/local, and set using the `--prefix'
+	parameter to `configure'.
+
+	If you installed elsewhere (see Local.rules.template), you will
+	need to either (1) copy, move or symlink to those locations, or (2)
+	tell XEmacs about your particular package locations at configure
+	time.  (1) is useful when you want a properly installed XEmacs that
+	you and perhaps others can run (but then why didn't you install
+	directly to <xemacs-root>?).  (2) is better, on the other hand, when
+	you're doing development work on XEmacs and possibly the packages,
+	and you'd rather have your own private copy of everything, including
+	the installed packages.
+
+	(1) To copy to the default location:
 
 		- mkdir /usr/local/lib/xemacs/xemacs-packages
 		- mkdir /usr/local/lib/xemacs/mule-packages
 		- cd /usr/local/lib/xemacs/xemacs-packages
-		- cp -a /path/to/$XEMACS_STAGING/* ./
+		- cp -a $NONMULE_INSTALLED_PACKAGES_ROOT/* ./
 		- cd ../mule-packages
-		- cp -a /path/to/$MULE_STAGING/* ./
+		- cp -a $MULE_INSTALLED_PACKAGES_ROOT/* ./
 		- restart XEmacs.
 
+	NOTE: /usr/local is only the default value of <xemacs-root>, as
+	described above.
+
+	(2) To specifically set where the package hierarchies are using
+            `configure', use the `--package-path' parameter, as follows:
+
+	Assume you're basically following the suggested layout described
+	in the top-level README file of recent XEmacs distributions.
+	Assume you set XEMACS_INSTALLED_PACKAGES_ROOT to
+	${XEMACS_PACKAGES_BASE}/.., as described in to comments in
+	Local.rules.template -- generally a good idea if you're trying to
+	develop XEmacs, not just install it.  Assume you have a /src/xemacs
+	directory, and under it is all your XEmacs build trees, your
+	packages, etc.  Specifically, the package source is in
+	/src/xemacs/package-src.  By setting XEMACS_INSTALLED_PACKAGES_ROOT
+	as indicated, you will get two package hierarchies installed in
+	/src/xemacs/xemacs-packages and /src/xemacs/mule-packages.
+	Therefore, you'd use a parameter to `configure' like this:
+
+	configure --package-path=~/.xemacs::/src/xemacs/xemacs-packages:/src/xemacs/mule-packages ...
+       
+
 ** Installing after a 'make bindist'
 
 	M-x pui-add-install-directory
-		- enter the value of $XEMACS_STAGING
+		- enter the value of $NONMULE_INSTALLED_PACKAGES_ROOT
 	M-x package-get-update-base
-		- enter '$XEMACS_STAGING/package-index'
+		- enter '$NONMULE_INSTALLED_PACKAGES_ROOT/package-index'
 	M-x pui-list-packages
 		- select the packages you want to install
 		- hit 'x' to install
 	Restart XEmacs.
 
+	NOTE: Normally NONMULE_INSTALLED_PACKAGES_ROOT is defined to be
+	${XEMACS_INSTALLED_PACKAGES_ROOT}/xemacs-packages, and this is
+  	probably the value it has for you, too.
+
 ** Installing - running "in place"
 
 	You can't run XEmacs packages from the CVS source tree because
-	the hierarchy is not what XEmacs expects.  But you can come
-	close to a "running in place" install.
+	the hierarchy is not what XEmacs expects. (In particular, the
+	source hierarchy logically puts all parts of a package -- `lisp',
+	`etc', `man', `info', `lib-src', and `pkginfo' -- together under a
+	single directory.  The installation, however, follows a much less
+	logical organization by instead combining all `lisp' together into
+	a single directory tree, all `man' together, etc.  Under each of
+	these is a directory for each package.)
 
-	Set the following in 'Local.rules':
-
-	   - symlink = t
-	   - XEMACS_STAGING = /usr/local/lib/xemacs/xemacs-packages
-	   - MULE_STAGING = /usr/local/lib/xemacs/mule-packages
-
-	And then run 'make install'.
-
-	This will build the packages and install them via symlinks to
+	But you can come close to a "running in place" install -- set
+	`symlink = t' in 'Local.rules' and then run 'make install'.  This
+	will build the packages and install them via symlinks to
 	the normal XEmacs package directories.
 
 * Local.rules format:
 These are the variables in 'Local.rules' that you will need to
 address.
 
-	symlink =
-		Set this to 't' if you want to do a "run in place".
-		Setting this doesn't work well with 'make bindist'.
-
-	XEMACS_PACKAGES =
-		This is where you list the the normal (i.e. non-mule)
-		packages that you want to install. eg:
-		   XEMACS_PACKAGES = xemacs-packages/xemacs-base xemacs-packages/bbdb
-
-	XEMACS_STAGING = ${XEMACS_PACKAGES_BASE}/../Packages
-		Set this to where you want normal packages to be
-		installed to.
-
-	PACKAGE_INDEX = package-index
-		If you want the package-index file to have a different
-		name, change this.
+	XEMACS = xemacs
+		If your XEmacs isn't in your path, change this.
 
 	BUILD_WITHOUT_MULE =
 		Building from CVS defaults to building the Mule
 		packages.  Set this to 't' if you don't want/have Mule
 
-	MULE_PACKAGES =
-		Same as for 'XEMACS_PACKAGES' except you list the Mule
+	XEMACS_NATIVE_NT =
+		Set this to 't' if you are building on WinNT.
+
+	XEMACS_INSTALLED_PACKAGES_ROOT = /usr/local/lib/xemacs
+		Directory tree under which the directories xemacs-packages/
+		and mule-packages/ are installed.  See Local.rules.template
+		for a description of what you might want to set this to, and
+		how it varies depending on whether you're installing a release
+		version or developing XEmacs. Depending on how you set
+                this, you may have to tell configure about it specially.
+		See above, "Installing after a 'make install'".
+
+	symlink =
+		Set this to 't' if you want to do a "run in place".
+		Setting this doesn't work well with 'make bindist'.
+
+These are other variables you might possibly need to change, but probably
+won't.
+
+	NONMULE_INSTALLED_PACKAGES_ROOT = ${XEMACS_INSTALLED_PACKAGES_ROOT}/xemacs-packages
+		Set this to where you want normal packages to be
+		installed to.  Normally you don't set this directly.
+
+	MULE_INSTALLED_PACKAGES_ROOT = ${XEMACS_INSTALLED_PACKAGES_ROOT}/mule-packages
+		Set this to where you want Mule packages installed
+		to.  Normally you don't set this directly.
+                Note: 'make bindist' does not use this variable.
+
+	NONMULE_PACKAGES = xemacs-packages
+		This is where you list the the normal (i.e. non-Mule)
+		packages that you want to install. eg:
+		   NONMULE_PACKAGES = xemacs-packages/xemacs-base \
+                                      xemacs-packages/bbdb
+                The default value installs all normal packages.
+
+	MULE_PACKAGES = mule-packages
+		Same as for 'NONMULE_PACKAGES' except you list the Mule
 		packages you want to install here. eg:
 		   MULE_PACKAGES = mule-packages/mule-base mule-packages/skk
+                The default value installs all Mule packages.
 
-	MULE_STAGING = ${XEMACS_PACKAGES_BASE}/../Mule-Packages
-		Set this to where you want Mule packages installed
-		to.  Note:  'make bindist' does not use this variable.
-
-	XEMACS = xemacs
-		If your XEmacs isn't in your path, change this.
-
-	XEMACS_NATIVE_NT =
-		Set this to 't' if you are building on WinNT.
+	PACKAGE_INDEX = package-index
+		If you want the package-index file to have a different
+		name, change this.
 
 	INSTALL = install -c
 		The path to your BSD compatible install program.

File Local.rules.mk

View file
-# This block must be duplicated in XEmacs.rules and the toplevel Makefile.
-
 ifeq (${XEMACS_PACKAGES_BASE},)
 ___ := $(error XEMACS_PACKAGES_BASE not defined??)
 endif

File Local.rules.template

View file
 
 ##################### Begin settings that commonly need to be changed
 
-# When `t', a symlink tree will be built for running a live CVS
-# checkout.  Requires GNU `cp', and that you configure your XEmacs
-# to use ${STAGING} in the package-path.  Create the tree with `make
-# install'.
-#
-symlink = 
-
 # Path to XEmacs to use for byte compilation.
 #
 # (Double-quote path under native MS Windows if there are embedded spaces.)
 XEMACS = xemacs
 
-# Should we build the mule package?  Set to 't' if you do not have/want Mule.
+# Should we build the Mule packages?  Set to 't' if you do not have/want Mule.
 #
 BUILD_WITHOUT_MULE =
 
+# Should we build the unsupported packages?  Set to 't' if yes.
+#
+BUILD_UNSUPPORTED =
+
 # Following test, which would be performed by every makefile
 # including XEmacs.rules, slows down the make process terribly
 # according to
 # Date: 14 Oct 2000 12:28:44 +0100
 #
 # XEMACS_NATIVE_NT = \
-# $(shell $(XEMACS) $(VANILLA) -batch \
+# $(shell $(XEMACS) $(BATCH) \
 # -eval "(princ (eq system-type 'windows-nt))")
 #
 # Therefore this has become a make variable instead:
 # This only concerns how XEmacs itself was built.
 XEMACS_NATIVE_NT =
 
-# XEmacs native MS Windows needs this quoting of command-line
-# arguments due to basic differences in the handling of command-line
-# arguments in Unix and MS Windows.
-#### not any more, as of Cygwin 1.1.8-2 (Feb 2001) -- ben
-# set this to 't' if you get errors under MS Windows without it.
-XEMACS_NATIVE_NT_NEEDS_EXTRA_QUOTING =
+#
+# The directory tree under which the installed packages go.  Under this
+# directory will be directories xemacs-packages/ (non-Mule packages),
+# mule-packages/ (Mule packages, if you built XEmacs with Mule,
+# i.e. international, support), and maybe site-packages/ (packages you
+# created yourself).  If you are installing XEmacs normally, this should be
+# <xemacs-root>/lib/xemacs, where <xemacs-root> is the topmost-level
+# directory under which everything is installed -- normally /usr/local, and
+# set using the `--prefix' parameter to `configure'.  See the INSTALL file.
+
+XEMACS_INSTALLED_PACKAGES_ROOT = /usr/local/lib/xemacs
+
+# If you are developing XEmacs, you probably don't want to install the
+# packages under /usr/local, which is where the stable, released version of
+# XEmacs goes.  Instead, we suggest a layout as described in the base
+# README file of recent versions of XEmacs.  In a nutshell, we suggest you
+# put your source under /src/xemacs, and under this put the package sources
+# in package-src/, and the installed packages in xemacs-packages/ and
+# mule-packages/.  If you do everything this way, you might want to set things as follows:
+#
+#XEMACS_INSTALLED_PACKAGES_ROOT = ${XEMACS_PACKAGES_BASE}/..
+#
+# which puts the xemacs-packages/ and mule-packages/ directories as sisters
+# of the package-src/ directory, and you have to tell configure the
+# location of the installed packages using `--package-path', something like
+#
+#	configure --package-path=/src/xemacs/xemacs-packages;/src/xemacs/mule-packages ...
+#
+
+# When `t', a symlink tree will be built for running a live CVS
+# checkout.  Requires GNU `cp', and that you configure your XEmacs
+# to use ${STAGING} in the package-path.  Create the tree with `make
+# install'.
+#
+symlink = 
+
+##################### End settings that commonly need to be changed
 
 #
-# Where to stage or install the non-Mule packages, or where the
-# symlink tree will go.
+# Where to install the non-Mule packages, or where the symlink tree will
+# go.  You probably don't want to change this.
 #
-XEMACS_STAGING = ${XEMACS_PACKAGES_BASE}/../xemacs-packages
+NONMULE_INSTALLED_PACKAGES_ROOT = ${XEMACS_INSTALLED_PACKAGES_ROOT}/xemacs-packages
 
 #
-# Where to stage or install the Mule packages, or where the
-# symlink tree will go.
+# Where to install the Mule packages, odr where the symlink tree will go.
+# You probably don't want to change this.
 #
-MULE_STAGING = ${XEMACS_PACKAGES_BASE}/../mule-packages
+MULE_INSTALLED_PACKAGES_ROOT = ${XEMACS_INSTALLED_PACKAGES_ROOT}/mule-packages
 
-# XEmacs packages or groups of packages to install. 'make bindist'
-# doesn't look at this, it's used by 'make install'.
+#
+# Where to install the unsupported packages, or where the symlink tree will
+# go.  You probably don't want to change this.
+#
+UNSUPPORTED_INSTALLED_PACKAGES_ROOT = ${XEMACS_INSTALLED_PACKAGES_ROOT}/site-packages
+
+# Non-Mule packages or groups of packages to build/install.  'make bindist'
+# doesn't look at this, it's used by 'make install'.  You probably don't
+# want to change this.
 #
 # The format for this is: xemacs-packages/pkg1 xemacs-packages/pkg2...
 # e.g. xemacs-packages/xemacs-base xemacs-packages/bbdb
-XEMACS_PACKAGES = xemacs-packages
+NONMULE_PACKAGES = xemacs-packages
 
-# Mule packages or groups of packages to install.  'make bindist'
-# doesn't look at this, it's used by 'make install'.
+# Mule packages or groups of packages to build/install.  'make bindist'
+# doesn't look at this, it's used by 'make install'.  You probably don't
+# want to change this.  If you don't want any Mule packages, don't change
+# this, instead set BUILD_WITHOUT_MULE above.
 #
 # The format for this is: mule-packages/pkg1 mule-packages/pkg2...
 # e.g. mule-packages/mule-base mule-packages/skk
 MULE_PACKAGES = mule-packages
 
-##################### End settings that commonly need to be changed
+# Unsupported packages or groups of packages to build/install.  'make
+# bindist' doesn't look at this, it's used by 'make install'.  You probably
+# don't want to change this.
+#
+# NOTE: This only controls which unsupported packages to build/install, not
+# whether unsupported packages will be built or installed at all, which is
+# controlled by BUILD_UNSUPPORTED above (off by default!).
+#
+# The format for this is: unsupported/$developer-name/pkg1 unsupported/$developer-name/pkg2...
+# e.g. unsupported/simon/asn1 unsupported/scop/docbookide
+UNSUPPORTED_PACKAGES = unsupported
 
+ifeq ('$(CATEGORY)','unsupported')
+PACKAGE_INDEX = package-index-unsupported
+else
 PACKAGE_INDEX = package-index
-
-# See: Makefile and XEmacs.rules to see how $(XEMACS_STAGING),
-# $(MULE_STAGING), and $(STAGING) are used.
-#
-
-# We need to set STAGING so that `make' run from a lower-level directory
-# works right.
-
-# the first endif is really not necessary, because STAGING is set from
-# the command line, and variable settings should not override command-line
-# ones.
-ifeq ('$(STAGING)','')
-ifeq ('$(CATEGORY)','mule')
-STAGING := $(MULE_STAGING)
-else
-STAGING := $(XEMACS_STAGING)
-endif
-endif
-
-# 'make bindist' needs STAGING to be set to XEMACS_STAGING regardless of
-# whether a Mule package or not so we don't end up with 2 package-index 
-# files.
-ifeq ('$(MAKECMDGOALS)','bindist')
-STAGING := $(XEMACS_STAGING)
 endif
 
 # Path to BSD install.
 
 VANILLA = -vanilla
 
+# Flags to run XEmacs from Makefiles.
+#
+BATCH = $(VANILLA) -batch -eval '(setq stack-trace-on-error t load-ignore-out-of-date-elc-files t load-show-full-path-in-messages t)'
+
 # path to makeinfo
 #
 MAKEINFO = makeinfo
 
-# path to texi2info
+# path to texi2html
 #
 TEXI2HTML = texi2html
+# texi2html 1.56k on Cygwin has "-split_chapter", whereas newer versions
+# (eg. 1.64) has "-split chapter", this should work either way.  1.56k doesn't
+# have "-help" and 1.64 doesn't have "-usage", but doing "-help" with 1.56k
+# outputs the usage anyway :P
+ifneq ('$(shell sh -c "texi2html -help 2>&1 | grep -l split_chapter")','')
+TEXI2HTML_FLAGS = -split_chapter
+else
 TEXI2HTML_FLAGS = -split chapter
+endif
+
+
+# path to texi2dvi, dvips, texi2pdf; If not defined, no conversion will happen
+#
+ifeq ($(XEMACS_NATIVE_NT),t)
+# Cygwin versions currently broken.
+TEXI2DVI =
+DVIPS =
+TEXI2PDF =
+else
+TEXI2DVI = texi2dvi
+DVIPS = dvips
+TEXI2PDF = texi2pdf
+endif
 
 ifneq ('$(symlink)','t')
  # path to GNU cp, use the latter if no GNU cp is available.
 else
  # This next one is for running in-place from a CVS checkout.
  # NOTE: cp on FreeBSD does not have a --symbolic-link option
- # so this may not work.
+ # so this will not work.  You could try something like
+ # `pax -rw -l -p p', but this will create hard links rather than
+ # symbolic links.
  #
  RCOPY = cp --force --recursive --symbolic-link
 endif

File Makefile

View file
 # the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 # Boston, MA 02111-1307, USA.
 
-# 
 SUBDIRS = xemacs-packages
 
-# Use a Local.rules file to specify what you wish to have installed
-XEMACS_PACKAGES_BASE := $(shell pwd)
+XEMACS_PACKAGES_BASE:= $(shell while [ ! -f XEmacs.rules ]; do \
+				cd ..;	\
+				done;	\
+				pwd)
 
-all:: bytecompile
+all: autoloads bytecompile
 
 include Local.rules.mk
 -include Local.rules
 ifeq ($(BUILD_WITHOUT_MULE),)
 SUBDIRS += mule-packages
 endif
-
-.PHONY: all all-bytecompile autoloads bytecompile bindist-real bindist clean distclean elcclean html World install just-install
-
-# The toplevel has slightly different rules so we do not use iterate.rules
-# directly
-
-ALL_TARGETS= $(SUBDIRS:=/all.target)
-AUTOLOADS_TARGETS= $(SUBDIRS:=/autoloads.target)
-BYTECOMPILE_TARGETS= $(SUBDIRS:=/bytecompile.target)
-BINDIST_TARGETS= $(SUBDIRS:=/bindist.target)
-CLEAN_TARGETS= $(SUBDIRS:=/clean.target)
-DISTCLEAN_TARGETS= $(SUBDIRS:=/distclean.target)
-ELCCLEAN_TARGETS= $(SUBDIRS:=/elcclean.target)
-HTML_TARGETS= $(SUBDIRS:=/html.target)
-JUST_INSTALL_TARGETS = $(XEMACS_PACKAGES:=/XEMACS.install)
-ifeq ($(BUILD_WITHOUT_MULE),)
-JUST_INSTALL_TARGETS += $(MULE_PACKAGES:=/MULE.install)
+ifeq ($(BUILD_UNSUPPORTED),t)
+SUBDIRS += unsupported
 endif
 
-# At some point we might have dependencies here...
+include meta-iterate.rules
 
-%.target:
-	[ -d $(*D) ] && $(MAKE) $(MFLAGS) -C $(*D) $(*F)
-
-%.install:
-	[ -d $(*D) ] && $(MAKE) $(MFLAGS) -C $(*D) STAGING=$($(*F:=_STAGING)) install
-
-all-bytecompile: autoloads bytecompile html
-
-autoloads: $(AUTOLOADS_TARGETS)
-
-bytecompile: $(BYTECOMPILE_TARGETS)
-
-bindist-real: $(BINDIST_TARGETS)
-
-bindist: bindist-real
-
-clean: $(CLEAN_TARGETS)
-
-distclean: $(DISTCLEAN_TARGETS)
-
-elcclean:
-	$(XEMACS) $(VANILLA) -batch -l package-clean.el
-
-html: $(HTML_TARGETS)
-
-World: distclean install
-
-install: all just-install
-
-just-install: $(JUST_INSTALL_TARGETS)
-
-

File XEmacs.rules

View file
 # Common Makefile material for package Makefiles
 # Copyright (C) 1997 Free Software Foundation Inc.
+# Copyright (C) 2002 Ben Wing.
 
 # This file is part of XEmacs.
 
 
 DEPENDS_FILE_NAME = pdepends.mk
 
-# Make this the first target
-bytecompile:: all
+all: autoloads bytecompile
+
+bytecompile:: compile
 
 include ${XEMACS_PACKAGES_BASE}/Local.rules.mk
 -include ${XEMACS_PACKAGES_BASE}/Local.rules
 .SUFFIXES:
 .SUFFIXES: .html .info .txi .texi .texinfo .dvi .elc .el
 
+# STAGING is the top of the directory tree where a particular package's
+# files are installed, or where tarballs are installed using `make bindist'.
+
+# 'make bindist' needs STAGING to be set to NONMULE_INSTALLED_PACKAGES_ROOT
+# if we are building a Mule package so we don't end up with 2 package-index
+# files. (Unsupported packages have a separate package-index-unsupported,
+# so this doesn't apply to them.)
+
+ifeq ('$(CATEGORY)','unsupported')
+STAGING:= $(UNSUPPORTED_INSTALLED_PACKAGES_ROOT)
+else
+ ifeq ('$(MAKECMDGOALS)','bindist')
+STAGING:= $(NONMULE_INSTALLED_PACKAGES_ROOT)
+ else
+  ifeq ('$(CATEGORY)','mule')
+STAGING:= $(MULE_INSTALLED_PACKAGES_ROOT)
+  else
+STAGING:= $(NONMULE_INSTALLED_PACKAGES_ROOT)
+  endif
+ endif
+endif
+
+# If something goes wrong and $(STAGING) is blank, the commands below will
+# attempt to install files into absolute paths /lisp/* and /etc/* -- not
+# a good idea at all.
+
+check-staging:
+ifeq ($(STAGING),)
+	$(error STAGING is not set; potential major filesystem trashing!  Fix this)
+endif
+
 FORMAT_INFO_LEVEL_3_USING_XEMACS_NO_SAVE_ARGS = -eval '(setq load-path (append (list "../../../xemacs-packages/texinfo" "../../../xemacs-packages/xemacs-base") load-path))' -l informat -l texinfmt -f texinfo-format-buffer
 
 %-ja.info: %-ja.texi
-	$(XEMACS) -batch -q -no-site-file -insert $< \
+	$(XEMACS) $(BATCH) -insert $< \
 		-eval '(unless (featurep (quote mule)) (kill-emacs 0))' \
 		$(FORMAT_INFO_LEVEL_3_USING_XEMACS_NO_SAVE_ARGS) \
 		-eval '(setq file-coding-system (quote iso-2022-7))' \
 %.info: %.texi
 	$(MAKEINFO) $(MAKEINFO_FLAGS) -o $@ $<
 
-html: $(HTML_DEP)
+html: check-staging $(HTML_DEP)
 ifneq ($(HTML_FILES),)
 	@-mkdir -p $(STAGING)/html
 endif
 	$(RCOPY) $(addprefix $(PWD)/, $(HTML_FILES)) $(STAGING)/html
 endif
 %.html: %.txi
-	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+#	V 1.56k (with Cygwin) does not allow -p flag.  Works fine without it.
+#	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+	$(TEXI2HTML) $(TEXI2HTML_FLAGS) $<
 %.html: %.texi
-	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+#	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+	$(TEXI2HTML) $(TEXI2HTML_FLAGS) $<
 %.html: %.texinfo
-	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+#	$(TEXI2HTML) $(TEXI2HTML_FLAGS) -p $* $<
+	$(TEXI2HTML) $(TEXI2HTML_FLAGS) $<
 
 FORMAT_INFO_USING_XEMACS_NO_SAVE_ARGS = -eval '(setq load-path (append (list "../../xemacs-packages/texinfo" "../../xemacs-packages/xemacs-base") load-path))' -l informat -l texinfmt -f texinfo-format-buffer
 
 endif
 
 # Behaves like an XEmacs with the required packages setup
-BOOT_XEMACS= $(XEMACS) -no-autoloads -batch -l $(PACKAGE_COMPILE) -- $(REQUIRES) -- $(PRELOADS)
+BOOT_XEMACS= $(XEMACS) -no-autoloads $(BATCH) -l $(PACKAGE_COMPILE) -- $(REQUIRES) -- $(PRELOADS)
 
 %.elc: %.el
 	$(BOOT_XEMACS) -f batch-byte-compile $<
 
-all:: $(AUTOLOAD_PATH)/_pkg.el
+compile:: $(AUTOLOAD_PATH)/_pkg.el
 
 dist:: binkit package-info
 
 # correctly.
 
 elcclean:
-	$(XEMACS) $(VANILLA) -batch -l $(PACKAGE_CLEAN)
+	$(XEMACS) $(BATCH) -l $(PACKAGE_CLEAN)
 
 # XEmacs native MS Windows needs this quoting of command-line
 # arguments due to basic differences in the handling of command-line
 endif
 
 $(AUTOLOAD_PATH)/auto-autoloads.el : $(ELCS:.elc=.el) $(AUTOLOAD_PATH)/_pkg.el
-	$(XEMACS) $(VANILLA) -batch -no-autoloads \
+	$(XEMACS) $(BATCH) -no-autoloads \
 		-eval "$(AUTOLOAD_PACKAGE_NAME)" \
 		-eval "$(AUTOLOAD_FILE)" \
 		-l autoload -f batch-update-autoloads $^
 	@rm -f $(AUTOLOAD_PATH)/auto-autoloads.el~
 
 $(AUTOLOAD_PATH)/custom-load.el : $(ELCS:.elc=.el)
-	$(XEMACS) $(VANILLA) -batch -l cus-dep \
+	$(XEMACS) $(BATCH) -l cus-dep \
 		-f Custom-make-dependencies $(AUTOLOAD_PATH)
 
 pkg_tar = $(STAGING)/$(PACKAGE)-$(VERSION)-pkg.tar
 # Make the $(pkg_tar).gz first, then the $(pkg_tar).bz2
 package-info : package-info.in Makefile $(AUTOLOAD_PATH)/_pkg.el \
 		$(pkg_tar).gz $(pkg_tar).bz2
-	$(XEMACS) $(VANILLA) -batch \
+	$(XEMACS) $(BATCH) \
 		-l package-info.elc -f batch-update-package-info \
 		'$(VERSION)' $(PKG_TAR_GZ) \
 		'$(REQUIRES)' \
 		'$(AUTHOR_VERSION)' '$(MAINTAINER)' '$(CATEGORY)'
-	$(XEMACS) $(VANILLA) -batch \
+	$(XEMACS) $(BATCH) \
 		-l ../../hack-package-index.el -f batch-hack-package-index \
-			$(PACKAGE) package-info $(PACKAGE_INFO)
+			$(PACKAGE) package-info $(PACKAGE_INFO) $(CATEGORY)
 
 ifeq ($(BUILD_TARS),t)
 $(pkg_tar): $(STAGING)/$(MANIFEST)
 .PHONY: binkit-sourceonly binkit-sourceinfo binkit-sourcedata binkit-sourcedatainfo binkit-with-html
 .PHONY: bindist install autoloads
 
-bindist: binkit package-info setup-info
+bindist: all binkit package-info setup-info
 
 setup-info:
-	$(XEMACS) $(VANILLA) -batch -l $(PACKAGE_NET_PACKAGES) \
+	$(XEMACS) $(BATCH) -l $(PACKAGE_NET_PACKAGES) \
 		-l $(PACKAGE_INFO) \
-		-f package-net-packages-batch-convert-index-to-ini $(PACKAGE_STAGING)
+		-f package-net-packages-batch-convert-index-to-ini $(PACKAGE_STAGING) $(CATEGORY)
 
-install: binkit
+install: all binkit
+
+just-install: binkit
 
 autoloads: $(AUTOLOAD_PATH)/auto-autoloads.el
 
-
-binkit-common: all
+binkit-common: check-staging
 	(if test -d $(STAGING); then		\
 		cd $(STAGING);			\
 		if test -f $(MANIFEST); then	\

File hack-package-index.el

View file
       (replace-match "\n" t t))))
 
 (defun batch-hack-package-index ()
-  (let ((package-name (pop command-line-args-left))
-	(package-info (pop command-line-args-left))
-	(package-get-base (pop command-line-args-left)))
+  (let* ((package-name (pop command-line-args-left))
+	 (package-info (pop command-line-args-left))
+	 (package-get-base (pop command-line-args-left))
+	 (category (pop command-line-args-left))
+	 (unsupinfo (if (equal category "unsupported")
+			" (Unsupported Packages)" "")))
     (set-buffer (get-buffer-create "*package index*"))
     (when (file-exists-p package-get-base)
       (insert-file-contents-literally package-get-base))
     (when (eq (point-min) (point-max))
-      (insert ";; Package Index file -- Do not edit manually.\n")
+      (insert (format ";; Package Index file%s -- Do not edit manually.\n"
+		      unsupinfo))
       (insert end-of-package-marker "\n")
-      (insert ";; Package Index file ends here\n"))
+      (insert (format ";; Package Index file%s ends here\n"
+		      unsupinfo)))
     (locate-package-entry package-name)
     (insert "))\n")
     (insert end-of-package-marker "\n")

File iterate.rules

View file
 # This file is part of XEmacs.
 
+# Copyright (C) 2002 Ben Wing.
+
 # XEmacs is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by the
 # Free Software Foundation; either version 2, or (at your option) any
 # Boston, MA 02111-1307, USA.
 
 #
-# Used by all the subdirectory makefiles..
+# This is used by subdirectories that directly contain packages.  Higher-level
+# subdirectories should use meta-iterate.rules instead.
 #
 
+XEMACS_PACKAGES_BASE:= $(shell while [ ! -f XEmacs.rules ]; do \
+				cd ..;	\
+				done;	\
+				pwd)
+
 AUTOLOADS_TARGETS= $(PACKAGES:=/autoloads.target)
 BYTECOMPILE_TARGETS= $(PACKAGES:=/bytecompile.target)
 BINDIST_TARGETS= $(PACKAGES:=/bindist.target)
 ELCCLEAN_TARGETS= $(PACKAGES:=/elcclean.target)
 HTML_TARGETS= $(PACKAGES:=/html.target)
 INSTALL_TARGETS= $(PACKAGES:=/install.target)
+JUST_INSTALL_TARGETS = $(PACKAGES:=/just-install.target)
+
+# Make this the first target
+all: autoloads bytecompile
 
 ALL_TARGETS = \
 	$(AUTOLOADS_TARGETS)  $(BYTECOMPILE_TARGETS) $(BINDIST_TARGETS) \
 	$(CLEAN_TARGETS) $(DISTCLEAN_TARGETS) $(ELCCLEAN_TARGETS) \
-	$(HTML_TARGETS) $(INSTALL_TARGETS)
+	$(HTML_TARGETS) $(INSTALL_TARGETS) $(JUST_INSTALL_TARGETS)
 
 .PHONY: $(ALL_TARGETS) autoloads bytecompile bindist clean \
-	distclean elcclean html install
+	distclean elcclean html install just-install
 
 # Master rule to pass down actual building 
 # Use a static pattern because of the extra dependencies
 
 # Standard dependencies
 
-$(BYTECOMPILE_TARGETS): %bytecompile.target: %autoloads.target
+# $(BYTECOMPILE_TARGETS): %bytecompile.target: %autoloads.target
 
 $(BINDIST_TARGETS)= %bindist.target: %bytecompile.target %html.target
 
 
 install: $(INSTALL_TARGETS)
 
+just-install: $(JUST_INSTALL_TARGETS)
+
 # Optionally put in fake rules for packages that we cannot
 # recursively build (yet)
 ifneq ($(strip (ASSUMED_PRESENT)),)
 
 DEPENDS_FILES = $(PACKAGES:=/$(DEPENDS_FILE_NAME))
 
-$(DEPENDS_FILES): %$(DEPENDS_FILE_NAME): %Makefile ../XEmacs.rules
+$(DEPENDS_FILES): %$(DEPENDS_FILE_NAME): %Makefile $(XEMACS_PACKAGES_BASE)/XEmacs.rules
 	$(MAKE) $(MFLAGS) -C $(*D) TARGET_BASE=$(dir $(*D)) \
 		$(DEPENDS_FILE_NAME)
 

File meta-iterate.rules

View file
+# This file is part of XEmacs.
+# Copyright (C) 2002 Ben Wing.
+
+# XEmacs is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2, or (at your option) any
+# later version.
+
+# XEmacs is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with XEmacs; see the file COPYING.  If not, write to
+# the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+#
+# This is used by higher-level subdirectories that do not directly contain
+# packages.  Subdirectories directly containing packages should use
+# iterate.rules instead.
+#
+
+XEMACS_PACKAGES_BASE := $(shell while [ ! -f XEmacs.rules ]; do \
+                                    cd ..;	\
+                                done;		\
+                                pwd)
+
+all: autoloads bytecompile
+
+.PHONY: all all-bytecompile autoloads bytecompile bindist-real bindist clean distclean elcclean html World install just-install
+
+# The toplevel has slightly different rules so we do not use iterate.rules
+# directly
+
+ALL_TARGETS= $(SUBDIRS:=/all.target)
+AUTOLOADS_TARGETS= $(SUBDIRS:=/autoloads.target)
+BYTECOMPILE_TARGETS= $(SUBDIRS:=/bytecompile.target)
+BINDIST_TARGETS= $(SUBDIRS:=/bindist.target)
+CLEAN_TARGETS= $(SUBDIRS:=/clean.target)
+DISTCLEAN_TARGETS= $(SUBDIRS:=/distclean.target)
+ELCCLEAN_TARGETS= $(SUBDIRS:=/elcclean.target)
+HTML_TARGETS= $(SUBDIRS:=/html.target)
+JUST_INSTALL_TARGETS = $(NONMULE_PACKAGES:=/NONMULE.install)
+ifeq ($(BUILD_WITHOUT_MULE),)
+JUST_INSTALL_TARGETS += $(MULE_PACKAGES:=/MULE.install)
+endif
+ifeq ($(BUILD_UNSUPPORTED),t)
+JUST_INSTALL_TARGETS += $(UNSUPPORTED_PACKAGES:=/UNSUPPORTED.install)
+endif
+
+# At some point we might have dependencies here...
+
+%.target:
+	[ -d $(*D) ] && $(MAKE) $(MFLAGS) -C $(*D) $(*F)
+
+%.install:
+	[ -d $(*D) ] && $(MAKE) $(MFLAGS) -C $(*D) just-install
+
+all-bytecompile: autoloads bytecompile html
+
+autoloads: $(AUTOLOADS_TARGETS)
+
+bytecompile: $(BYTECOMPILE_TARGETS)
+
+bindist-real: $(BINDIST_TARGETS)
+
+bindist: bindist-real
+
+clean: $(CLEAN_TARGETS)
+
+distclean: $(DISTCLEAN_TARGETS)
+
+elcclean:
+	$(XEMACS) $(BATCH) -l package-clean.el
+
+html: $(HTML_TARGETS)
+
+World: distclean install
+
+install: all just-install
+
+just-install: $(JUST_INSTALL_TARGETS)
+
+# Local Variables:
+# mode: Makefile
+# end:

File package-compile.el

View file
 ;;; package-compile.el --- Bytecompiler wrapper for building packages from source
 
 ;; Copyright (C) 1998 by Free Software Foundation, Inc.
+;; Copyright (C) 2002 Ben Wing.
 
 ;; Author: SL Baur <steve@xemacs.org>
 ;; Keywords: internal, lisp
 ;;; Code:
 
 (setq stack-trace-on-error t)
+;; #### We ought to set load-ignore-elc-files here.  However, that causes
+;; a crash when loading auto-autoload files, for obscure reasons that I
+;; haven't yet tracked down.  So we set it down below, after all the
+;; auto-autoloads have been loaded.
+;;
+;; Using load-ignore-elc-files is the ONLY way to ensure that compilation
+;; of the package tree proceeds properly regardless of the state of .elc
+;; files wrt .el files. (Of course, another solution would be to simply
+;; erase all .elc files; but this is less drastic.) Using
+;; load-ignore-out-of-date-elc-files is a start, but not enough -- it's
+;; possible, for example, for a .elc file that gets loaded to be out of
+;; date even if its date is later than its .el file.  This happens, for
+;; example, with a file containing top-level calls to macros located in
+;; another file -- if the macros are changed in the other file, the .elc
+;; file will be out of date because it will contain the old macros.
+;; Loading the .el file (ala `load-ignore-elc-files') works, since the new
+;; macros will be retrieved on-the-fly when the macro is first called.
+(setq load-ignore-out-of-date-elc-files t)
+(setq load-always-display-messages t)
+;; Don't enable this by default, as it clutters up the output so much.
+;; Turn it on if you're doubtful that the right files are being loaded.
+;; (setq load-show-full-path-in-messages t)
 
 (when (interactive-p)
   (error "package-compile may only be used with -batch"))
 
 (load (expand-file-name "auto-autoloads" (car load-path)))
 
+
 ;;; Step 2, collect the dependencies into load-path and load the autoloads.
-(require 'bytecomp)
+(let ((load-ignore-elc-files nil)
+      (load-ignore-out-of-date-elc-files t))
+  ;; Make sure we get the compiled version of the byte compiler, otherwise
+  ;; compilation will be UNGODLY slow.
+  (require 'bytecomp)
+  (require 'byte-optimize))
 
 (defconst package-directory-map
   '(
     ("xslide" . "xemacs-packages")
     ("xslt-process" . "xemacs-packages")
     ("zenirc" . "xemacs-packages")
-    ;; mule/*
+    ;; mule-packages
     ("edict" . "mule-packages")
     ("egg-its" . "mule-packages")
     ("latin-unity" . "mule-packages")
     ("lookup" . "mule-packages")
     ("mule-base" . "mule-packages")
     ("mule-ucs" . "mule-packages")
-    ("skk" . "mule-packages")))
+    ("skk" . "mule-packages")
+    ;; unsupported
+    ("antlr-mode" . "scop")
+    ("asn1" . "simon")
+    ("cogre" . "scop")
+    ("ecb" . "scop")
+    ("ede" . "scop")
+    ("epop3" . "simon")
+    ("flim" . "simon")
+    ))
 
+(defvar package-source-root nil)
+(let ((defdir default-directory))
+  (while (not (file-exists-p (expand-file-name "XEmacs.rules" defdir)))
+    (setq defdir (expand-file-name (concat defdir "/.."))))
+  (setq package-source-root defdir))
 
 (defun package-name-to-directory (package)
   "Map `package' to a source directory."
 	      package
 	      (expand-file-name (cdr (assoc package
 					    package-directory-map))
-				"../.."))))
+				package-source-root))))
     (cond ((equal package "gnus")
 	   (expand-file-name "gnus/lisp" (file-name-as-directory dir)))
 	  ((or (equal package "w3") 
 ;; Let the caller specify command
 ;(batch-byte-compile)
 
+;; See comment at top of file.
+;; #### Let's see whether we actually need this.
+;;(setq load-ignore-elc-files t)
+
 (provide 'package-compile)
 
 ;;; package-compile.el ends here

File package-net-packages.el

View file
 ;;
 ;; 2. Generating setup.ini should be more automatic.
 
-(defun package-net-packages-convert-index-to-ini (&optional destdir remote)
+(defun package-net-packages-convert-index-to-ini (&optional destdir remote category)
   "Convert the package index to ini file format in DESTDIR.
 DESTDIR defaults to the value of `data-directory'."
 ;  (package-get-require-base remote)
 
   (setq destdir (file-name-as-directory (or destdir data-directory)))
-  (let ((buf (get-buffer-create "*setup-packages.ini*")))
+  (let* ((fname (if (equal category "unsupported")
+		    "setup-unsupported-packages.ini"
+		  "setup-packages.ini"))
+	 (buf (get-buffer-create (format "*%s*" fname))))
     (unwind-protect
         (save-excursion
           (set-buffer buf)
 	      ;; (insert (format "source: %s\n" (plist-get plist 'source)))
 		(insert "\n"))
 	      (setq entries (cdr entries))))
-	  (insert "# setup-packages.ini file ends here\n")
-	  (write-region (point-min) (point-max) (concat destdir "setup-packages.ini")))
+	  (insert (format "# %s file ends here\n" fname))
+	  (write-region (point-min) (point-max) (concat destdir fname)))
       (kill-buffer buf))))
 
 (defun package-net-packages-batch-convert-index-to-ini ()
   (unless noninteractive
     (error "`package-net-packages-batch-convert-index-to-ini' is to be used only with -batch"))
   (let ((dir (car command-line-args-left))
+	(category (cadr command-line-args-left))
 	(package-get-require-signed-base-updates nil))
-    (package-net-packages-convert-index-to-ini dir nil)))
+    (package-net-packages-convert-index-to-ini dir nil category)))
 
 ;; package-net-packages.el ends here