# Remember the MAKELEVEL at the top
MAKETOPLEVEL?=$(MAKELEVEL)
-ifneq ($(findstring dont-optimize,$(MAKECMDGOALS)),dont-optimize)
+ifeq ($(findstring dont-optimize,$(MAKECMDGOALS)),)
# More GSM codec optimization
# Uncomment to enable MMXTM optimizations for x86 architecture CPU's
# which support MMX instructions. This should be newer pentiums,
# Uncomment next one to enable ast_frame tracing (for debugging)
TRACE_FRAMES = #-DTRACE_FRAMES
-# Uncomment next one to enable malloc debugging
-# You can view malloc debugging with:
-# *CLI> show memory allocations [filename]
-# *CLI> show memory summary [filename]
-#
-MALLOC_DEBUG = #-include $(PWD)/include/asterisk/astmm.h
-
# Where to install asterisk after compiling
# Default -> leave empty
INSTALL_PREFIX?=
ASTCFLAGS=
-# Define this to use files larger than 2GB (useful for sound files longer than 37 hours and logfiles)
-ASTCFLAGS+=-D_FILE_OFFSET_BITS=64
-
# Uncomment this to use the older DSP routines
#ASTCFLAGS+=-DOLD_DSP_ROUTINES
# If the file .asterisk.makeopts is present in your home directory, you can
-# include all of your favorite Makefile options so that every time you download
-# a new version of Asterisk, you don't have to edit the makefile to set them.
-# The file, /etc/asterisk.makeopts will also be included, but can be overridden
+# include all of your favorite menuselect options so that every time you download
+# a new version of Asterisk, you don't have to run menuselect to set them.
+# The file /etc/asterisk.makeopts will also be included but can be overridden
# by the file in your home directory.
-ifneq ($(wildcard /etc/asterisk.makeopts),)
- include /etc/asterisk.makeopts
+GLOBAL_MAKEOPTS=$(wildcard /etc/asterisk.makeopts)
+USER_MAKEOPTS=$(wildcard ~/.asterisk.makeopts)
+
+ifneq ($(wildcard menuselect.makeopts),)
+ include menuselect.makeopts
+endif
+
+ifneq ($(wildcard makeopts),)
+ include makeopts
endif
-ifneq ($(wildcard ~/.asterisk.makeopts),)
- include ~/.asterisk.makeopts
+ASTCFLAGS+=$(MENUSELECT_CFLAGS)
+TOPDIR_CFLAGS=-include include/autoconfig.h
+MOD_SUBDIR_CFLAGS=-include ../include/autoconfig.h
+
+# *CLI> show memory allocations [filename]
+# *CLI> show memory summary [filename]
+ifneq ($(findstring -DMALLOC_DEBUG,$(ASTCFLAGS)),)
+ TOPDIR_CFLAGS+=-include include/asterisk/astmm.h
+ MOD_SUBDIR_CFLAGS+=-include ../include/asterisk/astmm.h
endif
+MOD_SUBDIR_CFLAGS+=-fPIC
+
ifeq ($(OSARCH),Linux)
ifeq ($(PROC),x86_64)
# You must have GCC 3.4 to use k8, otherwise use athlon
endif
INCLUDE+=-Iinclude -I../include
-ASTCFLAGS+=-pipe -Wall -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations $(DEBUG) $(INCLUDE) -D_REENTRANT -D_GNU_SOURCE #-DMAKE_VALGRIND_HAPPY
+ASTCFLAGS+=-pipe -Wall -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations $(DEBUG) $(INCLUDE) #-DMAKE_VALGRIND_HAPPY
ASTCFLAGS+=$(OPTIMIZE)
-ASTCFLAGS+=# -Werror -Wunused
+
+ifeq ($(AST_DEVMODE),yes)
+ ASTCFLAGS+=-Werror -Wunused
+endif
+
ifeq ($(shell gcc -v 2>&1 | grep 'gcc version' | cut -f3 -d' ' | cut -f1 -d.),4)
ASTCFLAGS+= -Wno-pointer-sign
endif
ASTCFLAGS+=-fsigned-char
endif
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/osp/osp.h),)
- ASTCFLAGS+=-DOSP_SUPPORT -I$(CROSS_COMPILE_TARGET)/usr/local/include/osp
-else
- ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/osp/osp.h),)
- ASTCFLAGS+=-DOSP_SUPPORT -I$(CROSS_COMPILE_TARGET)/usr/include/osp
- endif
-endif
-
ifeq ($(OSARCH),FreeBSD)
BSDVERSION=$(shell make -V OSVERSION -f $(CROSS_COMPILE_TARGET)/usr/share/mk/bsd.port.subdir.mk)
ASTCFLAGS+=$(shell if test $(BSDVERSION) -lt 500016 ; then echo "-D_THREAD_SAFE"; fi)
INCLUDE+=-Iinclude/solaris-compat -I$(CROSS_COMPILE_TARGET)/usr/local/ssl/include
endif
-ifeq ($(findstring CYGWIN,$(OSARCH)),CYGWIN)
- CYGLOADER=cygwin_a
- OSARCH=CYGWIN
- ASTOBJ=-shared -o asterisk.dll -Wl,--out-implib=libasterisk.dll.a -Wl,--export-all-symbols
- ASTLINK=
- LIBS+=-lpthread -lncurses -lm -lresolv
- ASTSBINDIR=$(MODULES_DIR)
-endif
-
-ifndef WITHOUT_ZAPTEL
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/linux/zaptel.h)$(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/zaptel.h)$(wildcard $(CROSS_COMPILE_TARGET)/usr/pkg/include/zaptel.h),)
- ASTCFLAGS+=-DZAPTEL_OPTIMIZATIONS
-endif
-
-endif # WITHOUT_ZAPTEL
-
LIBEDIT=editline/libedit.a
+ASTERISKVERSION:=$(shell build_tools/make_version .)
+
ifneq ($(wildcard .version),)
- ASTERISKVERSION:=$(shell cat .version)
ASTERISKVERSIONNUM:=$(shell awk -F. '{printf "%02d%02d%02d", $$1, $$2, $$3}' .version)
RPMVERSION:=$(shell sed 's/[-\/:]/_/g' .version)
else
# showing the branch they are made from
ifneq ($(wildcard .svnrevision),)
ASTERISKVERSIONNUM=999999
- ASTERISKVERSION:=SVN-$(shell cat .svnbranch)-r$(shell cat .svnrevision)
else
ifneq ($(wildcard .svn),)
ASTERISKVERSIONNUM=999999
- ASTERISKVERSION=SVN-$(shell build_tools/make_svn_branch_name)
endif
endif
ASTCFLAGS+= $(MALLOC_DEBUG)
ASTCFLAGS+= $(BUSYDETECT)
ASTCFLAGS+= $(OPTIONS)
-ifneq ($(findstring dont-optimize,$(MAKECMDGOALS)),dont-optimize)
+ifeq ($(findstring dont-optimize,$(MAKECMDGOALS)),)
ASTCFLAGS+= -fomit-frame-pointer
endif
-SUBDIRS=res channels pbx apps codecs formats agi cdr funcs utils stdtime
+MOD_SUBDIRS=res channels pbx apps codecs formats cdr funcs
+SUBDIRS:=$(MOD_SUBDIRS) utils stdtime agi
OBJS=io.o sched.o logger.o frame.o loader.o config.o channel.o \
translate.o file.o pbx.o cli.o md5.o term.o \
endif
ifeq ($(MAKETOPLEVEL),$(MAKELEVEL))
- CFLAGS+=$(ASTCFLAGS)
+ CFLAGS+=$(ASTCFLAGS) $(TOPDIR_CFLAGS)
endif
# This is used when generating the doxygen documentation
-ifneq ($(wildcard /usr/local/bin/dot)$(wildcard /usr/bin/dot),)
+ifneq ($(DOT),:)
HAVEDOT=yes
else
HAVEDOT=no
INSTALL=install
-CFLAGS+=-DT38_SUPPORT
-
_all: all
@echo " +--------- Asterisk Build Complete ---------+"
@echo " + Asterisk has successfully been built, but +"
@echo " + cannot be run before being installed by +"
@echo " + running: +"
@echo " + +"
- @echo " + $(MAKE) install +"
+ @echo " + make install +"
@echo " +-------------------------------------------+"
-all: cleantest depend asterisk subdirs
+all: include/autoconfig.h menuselect.makeopts cleantest depend asterisk subdirs
+
+configure:
+ -@./bootstrap.sh
+
+include/autoconfig.h: configure
+ @CFLAGS="" ./configure
+ @echo "****"
+ @echo "**** The configure script was just executed, so 'make' needs to be"
+ @echo "**** restarted."
+ @echo "****"
+ @echo exit 1
+
+makeopts: configure
+ @CFLAGS="" ./configure
+ @echo "****"
+ @echo "**** The configure script was just executed, so 'make' needs to be"
+ @echo "**** restarted."
+ @echo "****"
+ @echo exit 1
+
+menuselect.makeopts: build_tools/menuselect makeopts.xml
+ @build_tools/menuselect --check-deps ${GLOBAL_MAKEOPTS} ${USER_MAKEOPTS} $@
#ifneq ($(wildcard tags),)
ctags: tags
all: TAGS
endif
-noclean: depend asterisk subdirs
-
editline/config.h:
cd editline && unset CFLAGS LIBS && ./configure ; \
-editline/libedit.a: FORCE
+editline/libedit.a:
cd editline && unset CFLAGS LIBS && test -f config.h || ./configure
$(MAKE) -C editline libedit.a
-db1-ast/libdb1.a: FORCE
+db1-ast/libdb1.a:
$(MAKE) -C db1-ast libdb1.a
ifneq ($(wildcard .depend),)
asterisk.txt: asterisk.sgml
docbook2txt asterisk.sgml
-defaults.h: FORCE
+defaults.h: makeopts
build_tools/make_defaults_h > $@.tmp
if cmp -s $@.tmp $@ ; then echo ; else \
mv $@.tmp $@ ; \
fi
rm -f $@.tmp
-include/asterisk/version.h: FORCE
+include/asterisk/version.h:
build_tools/make_version_h > $@.tmp
if cmp -s $@.tmp $@ ; then echo; else \
mv $@.tmp $@ ; \
fi
rm -f $@.tmp
-stdtime/libtime.a: FORCE
- $(MAKE) -C stdtime libtime.a
+stdtime/libtime.a:
+ CFLAGS="$(ASTCFLAGS) $(MOD_SUBDIR_CFLAGS)" $(MAKE) -C stdtime libtime.a
-cygwin_a:
- $(MAKE) -C cygwin all
-
-asterisk: $(CYGLOADER) editline/libedit.a db1-ast/libdb1.a stdtime/libtime.a $(OBJS)
+asterisk: editline/libedit.a db1-ast/libdb1.a stdtime/libtime.a $(OBJS)
build_tools/make_build_h > include/asterisk/build.h.tmp
if cmp -s include/asterisk/build.h.tmp include/asterisk/build.h ; then echo ; else \
mv include/asterisk/build.h.tmp include/asterisk/build.h ; \
$(CC) $(AUDIO_LIBS) -o muted muted.o
subdirs:
- for x in $(SUBDIRS); do $(MAKE) -C $$x || exit 1 ; done
+ for x in $(MOD_SUBDIRS); do CFLAGS="$(ASTCFLAGS) $(MOD_SUBDIR_CFLAGS)" $(MAKE) -C $$x || exit 1 ; done
+ CFLAGS="$(ASTCFLAGS)" $(MAKE) -C utils
+ CFLAGS="$(ASTCFLAGS) -include ../include/autoconfig.h" $(MAKE) -C agi
clean-depend:
for x in $(SUBDIRS); do $(MAKE) -C $$x clean-depend || exit 1 ; done
$(MAKE) -C db1-ast clean
$(MAKE) -C stdtime clean
+dist-clean: clean
+ rm -f menuselect.makeopts makeopts makeopts.xml
+ rm -f config.log config.status
+ rm -f include/autoconfig.h
+ $(MAKE) -C mxml clean
+ $(MAKE) -C build_tools dist-clean
+
datafiles: all
if [ x`$(ID) -un` = xroot ]; then sh build_tools/mkpkgconfig $(DESTDIR)/usr/lib/pkgconfig; fi
- # Should static HTTP be installed during make samples or even with its own target ala
- # webvoicemail? There are portions here that *could* be customized but might also be
- # improved a lot. I'll put it here for now.
+# Should static HTTP be installed during make samples or even with its own target ala
+# webvoicemail? There are portions here that *could* be customized but might also be
+# improved a lot. I'll put it here for now.
mkdir -p $(DESTDIR)$(ASTDATADIR)/static-http
for x in static-http/*; do \
install -m 644 $$x $(DESTDIR)$(ASTDATADIR)/static-http ; \
mkdir -p $(DESTDIR)$(ASTSPOOLDIR)/meetme
mkdir -p $(DESTDIR)$(ASTSPOOLDIR)/monitor
if [ -f asterisk ]; then $(INSTALL) -m 755 asterisk $(DESTDIR)$(ASTSBINDIR)/; fi
- if [ -f cygwin/asterisk.exe ]; then $(INSTALL) -m 755 cygwin/asterisk.exe $(DESTDIR)$(ASTSBINDIR)/; fi
if [ -f asterisk.dll ]; then $(INSTALL) -m 755 asterisk.dll $(DESTDIR)$(ASTSBINDIR)/; fi
ln -sf asterisk $(DESTDIR)$(ASTSBINDIR)/rasterisk
$(INSTALL) -m 755 contrib/scripts/astgenkey $(DESTDIR)$(ASTSBINDIR)/
depend: include/asterisk/version.h .depend defaults.h
for x in $(SUBDIRS); do $(MAKE) -C $$x depend || exit 1 ; done
-.depend: include/asterisk/version.h
+.depend: include/asterisk/version.h defaults.h
build_tools/mkdep $(CFLAGS) $(wildcard *.c)
.tags-depend:
# If the cleancount has been changed, force a make clean.
# .cleancount is the global clean count, and .lastclean is the
# last clean count we had
-# We can avoid this by making noclean
cleantest:
if cmp -s .cleancount .lastclean ; then echo ; else \
rm -rf $(DESTDIR)$(ASTSPOOLDIR)
rm -rf $(DESTDIR)$(ASTETCDIR)
rm -rf $(DESTDIR)$(ASTLOGDIR)
+
+menuselect: build_tools/menuselect makeopts.xml
+ -@build_tools/menuselect ${GLOBAL_MAKEOPTS} ${USER_MAKEOPTS} menuselect.makeopts && echo "menuselect changes saved!" || echo "menuselect changes NOT saved!"
+
+build_tools/menuselect: build_tools/menuselect.c build_tools/menuselect.h mxml/libmxml.a
+ $(MAKE) -C build_tools menuselect
+
+mxml/libmxml.a:
+ @cd mxml && unset CFLAGS && test -f config.h || ./configure
+ $(MAKE) -C mxml libmxml.a
+
+makeopts.xml: $(foreach dir,$(MOD_SUBDIRS),$(dir)/*.c) build_tools/cflags.xml
+ @echo "Generating list of available modules ..."
+ @build_tools/prep_moduledeps > $@
Information for Upgrading From Previous Asterisk Releases
=========================================================
+Build Process (configure script):
+
+Asterisk now uses an autoconf-generated configuration script to learn how it
+should build itself for your system. As it is a standard script, running:
+
+$ ./configure --help
+
+will show you all the options available. This script can be used to tell the
+build process what libraries you have on your system (if it cannot find them
+automatically), which libraries you wish to have ignored even though they may
+be present, etc.
+
+You must run the configure script before Asterisk will build, although it will
+attempt to automatically run it for you with no options specified; for most users,
+that will result in a similar build to what they would have had before the
+configure script was added to the build process (except for having to run 'make'
+again after the configure script is run). Note that the configure script does NOT
+need to be re-run just to rebuild Asterisk; you only need to re-run it when your
+system configuration changes or you wish to build Asterisk with different options.
+
+Build Process (module selection):
+
+The Asterisk source tree now includes a basic module selection and build option
+selection tool called 'menuselect'. Run 'make menuselect' to make your choices.
+In this tool, you can disable building of modules that you don't care about,
+turn on/off global options for the build and see which modules will not (and cannot)
+be built because your system does not have the required external dependencies
+installed.
+
+(TODO: document where 'global' and 'per-user' menuselect input files should go
+and what they need to contain)
+
PBX Core:
* The (very old and undocumented) ability to use BYEXTENSION for dialing
--- /dev/null
+# AST_EXT_LIB([NAME], [FUNCTION], [package header], [package symbol name], [package friendly name], [additional LIB data])
+
+AC_DEFUN([AST_EXT_LIB],
+[
+AC_ARG_WITH([$1], AC_HELP_STRING([--with-$1=PATH],[use $5 files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_$1=no
+ ;;
+ y|ye|yes)
+ $1_MANDATORY="yes"
+ ;;
+ *)
+ $1_DIR="${withval}"
+ $1_MANDATORY="yes"
+ ;;
+esac
+])
+
+PBX_LIB$1=0
+
+if test "${USE_$1}" != "no"; then
+ AC_CHECK_LIB([$1], [$2], AC_DEFINE_UNQUOTED([HAVE_$4], 1,
+ [Define to indicate the $5 library]), [], -L${$1_DIR}/lib $6)
+
+ if test "${ac_cv_lib_$1_$2}" = "yes"; then
+ $1_LIB="-l$1 $6"
+ $4_HEADER_FOUND="1"
+ if test "x${$1_DIR}" != "x"; then
+ $1_LIB="-L${$1_DIR}/lib ${$1_LIB}"
+ $1_INCLUDE="-I${$1_DIR}/include"
+ if test "x$3" != "x" ; then
+ AC_CHECK_HEADER([${$1_DIR}/include/$3], [$4_HEADER_FOUND=1], [$4_HEADER_FOUND=0] )
+ fi
+ else
+ if test "x$3" != "x" ; then
+ AC_CHECK_HEADER([$3], [$4_HEADER_FOUND=1], [$4_HEADER_FOUND=0] )
+ fi
+ fi
+ if test "x${$4_HEADER_FOUND}" = "x0" ; then
+ echo " ***"
+ echo " *** It appears that you do not have the $5 development package installed."
+ echo " *** Please install it to include $5 support, or re-run configure"
+ echo " *** with the argument --without-$1"
+ exit 1
+ fi
+ PBX_LIB$1=1
+ elif test ! -z "${$1_MANDATORY}";
+ then
+ echo "***"
+ echo "*** The $5 installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-$1"
+ exit 1
+ fi
+fi
+AC_SUBST([$1_LIB])
+AC_SUBST([$1_INCLUDE])
+AC_SUBST([PBX_LIB$1])
+])
+
+
+AC_DEFUN(
+[AST_CHECK_GNU_MAKE], [ AC_CACHE_CHECK( for GNU make, GNU_MAKE,
+ GNU_MAKE='Not Found' ;
+ for a in make gmake gnumake ; do
+ if test -z "$a" ; then continue ; fi ;
+ if ( sh -c "$a --version" 2> /dev/null | grep GNU 2>&1 > /dev/null ) ; then
+ GNU_MAKE=$a ;
+ break;
+ fi
+ done ;
+) ;
+if test "x$GNU_MAKE" = "xNot Found" ; then
+ echo " *** Please install GNU make. It is required to build Asterisk!"
+ exit 1
+fi
+AC_SUBST([GNU_MAKE])
+] )
#
# Makefile for AGI-related stuff
#
-# Copyright (C) 1999-2005, Digium
+# Copyright (C) 1999-2006, Digium
#
# Mark Spencer <markster@digium.com>
#
AGIS=agi-test.agi eagi-test eagi-sphinx-test jukebox.agi
-CFLAGS+=-DNO_AST_MM
-
LIBS=
ifeq ($(OSARCH),SunOS)
LIBS=-lsocket -lnsl ../strcompat.o
for x in $(AGIS); do rm -f $(DESTDIR)$(AGI_DIR)/$$x ; done
eagi-test: eagi-test.o
- $(CC) $(CFLAGS) -o eagi-test eagi-test.o $(LIBS)
+ $(CC) $(CFLAGS) -include ../include/autoconfig.h -o eagi-test eagi-test.o $(LIBS)
eagi-sphinx-test: eagi-sphinx-test.o
- $(CC) $(CFLAGS) -o eagi-sphinx-test eagi-sphinx-test.o $(LIBS)
+ $(CC) $(CFLAGS) -include ../include/autoconfig.h -o eagi-sphinx-test eagi-sphinx-test.o $(LIBS)
clean-depend:
rm -f .depend
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
-#include <asterisk/compat.h>
+
+#include "asterisk.h"
+
+#include "asterisk/compat.h"
#define AUDIO_FILENO (STDERR_FILENO + 1)
#include <errno.h>
#include <string.h>
#include <sys/select.h>
-#include <asterisk/compat.h>
+
+#include "asterisk.h"
+
+#include "asterisk/compat.h"
#define AUDIO_FILENO (STDERR_FILENO + 1)
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard app_*.c))
+MODS:=$(filter-out $(MENUSELECT_APPS),$(patsubst %.c,%.so,$(wildcard app_*.c)))
-#
-# Experimental things
-#
-MODS:=$(filter-out app_ivrdemo.so,$(MODS))
-MODS:=$(filter-out app_skel.so,$(MODS))
-MODS:=$(filter-out app_rpt.so,$(MODS))
-
-ifndef WITHOUT_ZAPTEL
-ZAPAVAIL:=$(wildcard $(CROSS_COMPILE_TARGET)/usr/include/linux/zaptel.h $(CROSS_COMPILE_TARGET)/usr/local/include/zaptel.h)
-endif
-
-ifeq (${ZAPAVAIL},)
- MODS:=$(filter-out app_zapras.so app_meetme.so app_flash.so app_zapbarge.so app_zapscan.so app_page.so,$(MODS))
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/osp/osp.h $(CROSS_COMPILE_TARGET)/usr/include/osp/osp.h),)
- MODS:=$(filter-out app_osplookup.so,$(MODS))
-endif
-
-ifneq (${WITH_SMDI},)
+ifneq ($(WITH_SMDI),)
CFLAGS+=-DWITH_SMDI
endif
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -L../res -lasterisk.dll -lres_features.so -lres_adsi.so -lres_monitor.so
- MODS:=$(filter-out app_sms.so,$(MODS))
-else
- CFLAGS+=-fPIC
-endif
-
# If you have UnixODBC you can use ODBC voicemail
# storage
#
clean: clean-depend
rm -f *.so *.o
-%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+%.so: %.o
+ $(CC) $(SOLINK) -o $@ $<
+
+app_rpt.so: app_rpt.o
+ $(CC) $(SOLINK) -o $@ $< $(ZAPTEL_LIB)
-app_rpt.so : app_rpt.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -ltonezone
+app_rpt.o: app_rpt.c
+ $(CC) $(SOLINK) -o $@ $< $(ZAPTEL_INCLUDE)
install: all
for x in $(MODS); do $(INSTALL) -m 755 $$x $(DESTDIR)$(MODULES_DIR) ; done
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <defaultenabled>no</defaultenabled>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
{
return ASTERISK_GPL_KEY;
}
-
+
STD_MOD(MOD_1, reload, NULL, NULL);
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>libosptk</depend>
+ <depend>ssl</depend>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
}
STD_MOD1;
+
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
}
STD_MOD1;
+
*
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ <defaultenabled>no</defaultenabled>
+ ***/
+
/* The following is JUST GROSS!! There is some soft of underlying problem,
probably in channel_iax2.c, that causes an IAX2 connection to sometimes
stop transmitting randomly. We have been working for weeks to try to
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <defaultenabled>no</defaultenabled>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <sys/ioctl.h>
#include <sys/wait.h>
#ifdef __linux__
}
STD_MOD1;
+
* \ingroup applications
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
}
STD_MOD1;
+
#include <errno.h>
#include <regex.h>
#include <limits.h>
-#include <asterisk/ast_expr.h>
-#include <asterisk/logger.h>
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/ast_expr.h"
+#include "asterisk/logger.h"
#if defined(LONG_LONG_MIN) && !defined(QUAD_MIN)
#define QUAD_MIN LONG_LONG_MIN
#include <errno.h>
#include <regex.h>
#include <limits.h>
-#include <asterisk/ast_expr.h>
-#include <asterisk/logger.h>
-#include <asterisk/strings.h>
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/ast_expr.h"
+#include "asterisk/logger.h"
+#include "asterisk/strings.h"
enum valtype {
AST_EXPR_integer, AST_EXPR_numeric_string, AST_EXPR_string
#include <errno.h>
#include <regex.h>
#include <limits.h>
-#include <asterisk/ast_expr.h>
-#include <asterisk/logger.h>
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/ast_expr.h"
+#include "asterisk/logger.h"
#if defined(LONG_LONG_MIN) && !defined(QUAD_MIN)
#define QUAD_MIN LONG_LONG_MIN
#include <errno.h>
#include <regex.h>
#include <limits.h>
-#include <asterisk/ast_expr.h>
-#include <asterisk/logger.h>
-#include <asterisk/strings.h>
+
+#include "asterisk.h"
+
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include "asterisk/ast_expr.h"
+#include "asterisk/logger.h"
+#include "asterisk/strings.h"
enum valtype {
AST_EXPR_integer, AST_EXPR_numeric_string, AST_EXPR_string
--- /dev/null
+#!/bin/sh
+
+check_for_app() {
+ $1 --version 2>&1 >/dev/null
+ if [ $? != 0 ]
+ then
+ echo "Please install $1 and run bootstrap.sh again!"
+ exit 1
+ fi
+}
+
+uname -s | grep -q FreeBSD
+if [ $? = 0 ]
+then
+ check_for_app aclocal19
+ check_for_app autoconf259
+ check_for_app autoheader259
+ check_for_app automake19
+
+ aclocal19 2>/dev/null
+ autoconf259
+ autoheader259
+ automake19 --add-missing --copy 2>/dev/null
+else
+ export AUTOCONF_VERSION=2.59
+ export AUTOMAKE_VERSION=1.9
+
+ check_for_app aclocal
+ check_for_app autoconf
+ check_for_app autoheader
+ check_for_app automake
+
+ aclocal 2>/dev/null
+ autoconf
+ autoheader
+ automake --add-missing --copy 2>/dev/null
+fi
--- /dev/null
+MENUSELECT_OBJS=menuselect.o menuselect_curses.o
+MENUSELECT_CFLAGS=-g -c -D_GNU_SOURCE -I../ -I../include/
+MENUSELECT_LIBS=../mxml/libmxml.a $(CURSES_LIB)
+
+menuselect: $(MENUSELECT_OBJS)
+ $(CC) -g -o $@ $(MENUSELECT_OBJS) $(MENUSELECT_LIBS)
+
+menuselect.o: menuselect.c menuselect.h
+ $(CC) -o $@ $(MENUSELECT_CFLAGS) $<
+
+menuselect_curses.o: menuselect_curses.c menuselect.h
+ $(CC) -o $@ $(MENUSELECT_CFLAGS) $(CURSES_INCLUDE) $<
+
+clean:
+ rm -f menuselect *.o
+
+dist-clean: clean
+ rm -f menuselect-deps
--- /dev/null
+ <category name="MENUSELECT_CFLAGS" displayname="Compiler Flags" positive_output="yes" force_clean_on_change="yes">
+ <member name="-DDEBUG_SCHEDULER">
+ </member>
+ <member name="-DDEBUG_THREADS">
+ </member>
+ <member name="-DDETECT_DEADLOCKS">
+ </member>
+ <member name="-DDUMP_SCHEDULER">
+ </member>
+ <member name="-DLOW_MEMORY">
+ </member>
+ <member name="-DMALLOC_DEBUG">
+ </member>
+ <member name="-DRADIO_RELAX">
+ </member>
+ <member name="-DTRACE_FRAMES">
+ </member>
+ <member name="-DMTX_PROFILE">
+ </member>
+ <member name="-DT38_SUPPORT">
+ <defaultenabled>yes</defaultenabled>
+ </member>
+ </category>
--- /dev/null
+/\/\*\*\* MODULEINFO/ {printit=1; next}
+/\*\*\*\// {exit}
+// {if (printit) print}
+++ /dev/null
-#!/bin/sh
-
-PARTS=`LANG=C svn info | grep URL | awk '{print $2;}' | sed -e 's:^.*/svn/asterisk/::' | sed -e 's:/: :g'`
-BRANCH=0
-TEAM=0
-
-REV=`svnversion -c . | cut -d: -f2`
-
-if [ "${PARTS}" = "trunk" ]
-then
- echo 'trunk'-r${REV}
- exit 0
-fi
-
-for PART in $PARTS
-do
- if [ ${BRANCH} != 0 ]
- then
- RESULT="${RESULT}-${PART}"
- break
- fi
-
- if [ ${TEAM} != 0 ]
- then
- RESULT="${RESULT}-${PART}"
- continue
- fi
-
- if [ "${PART}" = "branches" ]
- then
- BRANCH=1
- RESULT="branch"
- continue
- fi
-
- if [ "${PART}" = "tags" ]
- then
- BRANCH=1
- RESULT="tag"
- continue
- fi
-
- if [ "${PART}" = "team" ]
- then
- TEAM=1
- continue
- fi
-done
-
-echo ${RESULT##-}-r${REV}
--- /dev/null
+#!/bin/sh
+
+if [ -f ${1}/.version ]; then
+ cat ${1}.version
+elif [ -f ${1}/.svnrevision ]; then
+ echo SVN-`cat ${1}/.svnbranch`-r`cat ${1}.svnrevision`
+elif [ -d .svn ]; then
+ PARTS=`LANG=C svn info ${1} | grep URL | awk '{print $2;}' | sed -e s:^.*/svn/asterisk/:: | sed -e 's:/: :g'`
+ BRANCH=0
+ TEAM=0
+
+ REV=`svnversion -c ${1} | cut -d: -f2`
+
+ if [ "${PARTS}" = "trunk" ]
+ then
+ echo SVN-'trunk'-r${REV}
+ exit 0
+ fi
+
+ for PART in $PARTS
+ do
+ if [ ${BRANCH} != 0 ]
+ then
+ RESULT="${RESULT}-${PART}"
+ break
+ fi
+
+ if [ ${TEAM} != 0 ]
+ then
+ RESULT="${RESULT}-${PART}"
+ continue
+ fi
+
+ if [ "${PART}" = "branches" ]
+ then
+ BRANCH=1
+ RESULT="branch"
+ continue
+ fi
+
+ if [ "${PART}" = "tags" ]
+ then
+ BRANCH=1
+ RESULT="tag"
+ continue
+ fi
+
+ if [ "${PART}" = "team" ]
+ then
+ TEAM=1
+ continue
+ fi
+ done
+
+ echo SVN-${RESULT##-}-r${REV}
+fi
--- /dev/null
+ASOUND=@PBX_LIBasound@
+CURL=@PBX_CURL@
+FREETDS=@PBX_LIBtds@
+GTK=@PBX_GTK@
+H323=@PBX_H323@
+KDE=@PBX_KDE@
+LIBMFCR2=@PBX_LIBmfcr2@
+LIBNEWT=@PBX_LIBnewt@
+LIBOSPTK=@PBX_LIBosptk@
+LIBPOPT=@PBX_LIBpopt@
+LIBPRI=@PBX_LIBpri@
+LIBSPEEX=@PBX_LIBspeex@
+LIBVORBIS=@PBX_LIBvorbis@
+NBS=@PBX_LIBnbs@
+OGG=@PBX_LIBogg@
+OSSAUDIO=@PBX_LIBossaudio@
+PGSQL=@PBX_LIBpq@
+PTLIB=@PBX_LIBPWLIB@
+QT=@PBX_QT@
+SQLITE=@PBX_LIBsqlite@
+SSL=@PBX_LIBssl@
+UNIXODBC=@PBX_LIBodbc@
+VPBAPI=@PBX_LIBvpb@
+WIN32=@OSISWIN32@
+ZLIB=@PBX_LIBz@
+ZAPTEL=@PBX_LIBtonezone@
+LIBGSM=@PBX_LIBgsm@
--- /dev/null
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2005 - 2006, Russell Bryant
+ *
+ * Russell Bryant <russell@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*
+ * \file
+ *
+ * \author Russell Bryant <russell@digium.com>
+ *
+ * \brief A menu-driven system for Asterisk module selection
+ */
+
+#include "autoconfig.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "mxml/mxml.h"
+#include "menuselect.h"
+
+#include "asterisk.h"
+
+#include "asterisk/linkedlists.h"
+
+#undef MENUSELECT_DEBUG
+
+struct depend {
+ /*! the name of the dependency */
+ const char *name;
+ /*! for linking */
+ AST_LIST_ENTRY(depend) list;
+};
+
+struct conflict {
+ /*! the name of the conflict */
+ const char *name;
+ /*! for linking */
+ AST_LIST_ENTRY(conflict) list;
+};
+
+/*! The list of categories */
+struct categories categories = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
+
+/*!
+ We have to maintain a pointer to the root of the trees generated from reading
+ the build options XML files so that we can free it when we're done. We don't
+ copy any of the information over from these trees. Our list is just a
+ convenient mapping to the information contained in these lists with one
+ additional piece of information - whether the build option is enabled or not.
+*/
+struct tree {
+ /*! the root of the tree */
+ mxml_node_t *root;
+ /*! for linking */
+ AST_LIST_ENTRY(tree) list;
+};
+
+/*! The list of trees from makeopts.xml files */
+AST_LIST_HEAD_NOLOCK_STATIC(trees, tree);
+
+const char * const makeopts_files[] = {
+ "makeopts.xml"
+};
+
+char *output_makeopts = OUTPUT_MAKEOPTS_DEFAULT;
+
+/*! This is set to 1 if menuselect.makeopts pre-existed the execution of this app */
+int existing_config = 0;
+
+/*! This is set when the --check-deps argument is provided. */
+int check_deps = 0;
+
+/*! Force a clean of the source tree */
+int force_clean = 0;
+
+int add_category(struct category *cat);
+int add_member(struct member *mem, struct category *cat);
+int parse_makeopts_xml(const char *makeopts_xml);
+int process_deps(void);
+int build_member_list(void);
+void mark_as_present(const char *member, const char *category);
+int parse_existing_config(const char *infile);
+int generate_makeopts_file(void);
+void free_member_list(void);
+void free_trees(void);
+
+/*! \brief a wrapper for calloc() that generates an error message if the allocation fails */
+static inline void *my_calloc(size_t num, size_t len)
+{
+ void *tmp;
+
+ tmp = calloc(num, len);
+
+ if (!tmp)
+ fprintf(stderr, "Memory allocation error!\n");
+
+ return tmp;
+}
+
+/*! \brief return a pointer to the first non-whitespace character */
+static inline char *skip_blanks(char *str)
+{
+ if (!str)
+ return NULL;
+
+ while (*str && *str < 33)
+ str++;
+
+ return str;
+}
+
+/*! \brief Add a category to the category list, ensuring that there are no duplicates */
+int add_category(struct category *cat)
+{
+ struct category *tmp;
+
+ AST_LIST_TRAVERSE(&categories, tmp, list) {
+ if (!strcmp(tmp->name, cat->name)) {
+ fprintf(stderr, "Category '%s' specified more than once!\n", cat->name);
+ return -1;
+ }
+ }
+ AST_LIST_INSERT_TAIL(&categories, cat, list);
+
+ return 0;
+}
+
+/*! \brief Add a member to the member list of a category, ensuring that there are no duplicates */
+int add_member(struct member *mem, struct category *cat)
+{
+ struct member *tmp;
+
+ AST_LIST_TRAVERSE(&cat->members, tmp, list) {
+ if (!strcmp(tmp->name, mem->name)) {
+ fprintf(stderr, "Member '%s' already exists in category '%s', ignoring.\n", mem->name, cat->name);
+ return -1;
+ }
+ }
+ AST_LIST_INSERT_TAIL(&cat->members, mem, list);
+
+ return 0;
+}
+
+/*! \brief Parse an input makeopts file */
+int parse_makeopts_xml(const char *makeopts_xml)
+{
+ FILE *f;
+ struct category *cat;
+ struct tree *tree;
+ struct member *mem;
+ struct depend *dep;
+ struct conflict *cnf;
+ mxml_node_t *cur;
+ mxml_node_t *cur2;
+ mxml_node_t *cur3;
+ mxml_node_t *menu;
+ const char *tmp;
+
+ if (!(f = fopen(makeopts_xml, "r"))) {
+ fprintf(stderr, "Unable to open '%s' for reading!\n", makeopts_xml);
+ return -1;
+ }
+
+ if (!(tree = my_calloc(1, sizeof(*tree)))) {
+ fclose(f);
+ return -1;
+ }
+
+ if (!(tree->root = mxmlLoadFile(NULL, f, MXML_OPAQUE_CALLBACK))) {
+ fclose(f);
+ free(tree);
+ return -1;
+ }
+
+ AST_LIST_INSERT_HEAD(&trees, tree, list);
+
+ menu = mxmlFindElement(tree->root, tree->root, "menu", NULL, NULL, MXML_DESCEND);
+ for (cur = mxmlFindElement(menu, menu, "category", NULL, NULL, MXML_DESCEND);
+ cur;
+ cur = mxmlFindElement(cur, menu, "category", NULL, NULL, MXML_DESCEND))
+ {
+ if (!(cat = my_calloc(1, sizeof(*cat))))
+ return -1;
+
+ cat->name = mxmlElementGetAttr(cur, "name");
+ cat->displayname = mxmlElementGetAttr(cur, "displayname");
+ if ((tmp = mxmlElementGetAttr(cur, "positive_output")))
+ cat->positive_output = !strcasecmp(tmp, "yes");
+ if ((tmp = mxmlElementGetAttr(cur, "force_clean_on_change")))
+ cat->force_clean_on_change = !strcasecmp(tmp, "yes");
+
+ if (add_category(cat)) {
+ free(cat);
+ continue;
+ }
+
+ for (cur2 = mxmlFindElement(cur, cur, "member", NULL, NULL, MXML_DESCEND);
+ cur2;
+ cur2 = mxmlFindElement(cur2, cur, "member", NULL, NULL, MXML_DESCEND))
+ {
+ if (!(mem = my_calloc(1, sizeof(*mem))))
+ return -1;
+
+ if (!cat->positive_output)
+ mem->enabled = 1; /* Enabled by default */
+
+ mem->name = mxmlElementGetAttr(cur2, "name");
+
+ cur3 = mxmlFindElement(cur2, cur2, "defaultenabled", NULL, NULL, MXML_DESCEND);
+ if (cur3 && cur3->child) {
+ if (!strcasecmp("no", cur3->child->value.opaque))
+ mem->enabled = 0;
+ else if (!strcasecmp("yes", cur3->child->value.opaque))
+ mem->enabled = 1;
+ else
+ fprintf(stderr, "Invalid value '%s' for <defaultenabled> !\n", cur3->child->value.opaque);
+ }
+
+ for (cur3 = mxmlFindElement(cur2, cur2, "depend", NULL, NULL, MXML_DESCEND);
+ cur3 && cur3->child;
+ cur3 = mxmlFindElement(cur3, cur2, "depend", NULL, NULL, MXML_DESCEND))
+ {
+ if (!(dep = my_calloc(1, sizeof(*dep))))
+ return -1;
+ if (!strlen_zero(cur3->child->value.opaque)) {
+ dep->name = cur3->child->value.opaque;
+ AST_LIST_INSERT_HEAD(&mem->deps, dep, list);
+ } else
+ free(dep);
+ }
+
+ for (cur3 = mxmlFindElement(cur2, cur2, "conflict", NULL, NULL, MXML_DESCEND);
+ cur3 && cur3->child;
+ cur3 = mxmlFindElement(cur3, cur2, "conflict", NULL, NULL, MXML_DESCEND))
+ {
+ if (!(cnf = my_calloc(1, sizeof(*cnf))))
+ return -1;
+ if (!strlen_zero(cur3->child->value.opaque)) {
+ cnf->name = cur3->child->value.opaque;
+ AST_LIST_INSERT_HEAD(&mem->conflicts, cnf, list);
+ } else
+ free(cnf);
+ }
+
+ if (add_member(mem, cat))
+ free(mem);
+ }
+ }
+
+ fclose(f);
+
+ return 0;
+}
+
+/*! \brief Process dependencies against the input dependencies file */
+int process_deps(void)
+{
+ struct category *cat;
+ struct member *mem;
+ struct depend *dep;
+ struct conflict *cnf;
+ FILE *f;
+ struct dep_file {
+ char name[32];
+ int met;
+ AST_LIST_ENTRY(dep_file) list;
+ } *dep_file;
+ AST_LIST_HEAD_NOLOCK_STATIC(deps_file, dep_file);
+ char buf[80];
+ char *p;
+ int res = 0;
+
+ if (!(f = fopen(MENUSELECT_DEPS, "r"))) {
+ fprintf(stderr, "Unable to open '%s' for reading! Did you run ./configure ?\n", MENUSELECT_DEPS);
+ return -1;
+ }
+
+ /* Build a dependency list from the file generated by configure */
+ while (memset(buf, 0, sizeof(buf)), fgets(buf, sizeof(buf), f)) {
+ p = buf;
+ strsep(&p, "=");
+ if (!p)
+ continue;
+ if (!(dep_file = my_calloc(1, sizeof(*dep_file))))
+ break;
+ strncpy(dep_file->name, buf, sizeof(dep_file->name) - 1);
+ dep_file->met = atoi(p);
+ AST_LIST_INSERT_TAIL(&deps_file, dep_file, list);
+ }
+
+ fclose(f);
+
+ /* Process dependencies of all modules */
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ AST_LIST_TRAVERSE(&mem->deps, dep, list) {
+ mem->depsfailed = 1;
+ AST_LIST_TRAVERSE(&deps_file, dep_file, list) {
+ if (!strcasecmp(dep_file->name, dep->name)) {
+ if (dep_file->met)
+ mem->depsfailed = 0;
+ break;
+ }
+ }
+ if (mem->depsfailed)
+ break; /* This dependency is not met, so we can stop now */
+ }
+ if (mem->depsfailed) {
+ if (check_deps && existing_config && mem->enabled) {
+ /* Config already existed, but this module was not disabled.
+ * However, according to our current list of dependencies that
+ * have been met, this can not be built. */
+ res = -1;
+ fprintf(stderr, "\nThe existing menuselect.makeopts did not specify that %s should not be built\n", mem->name);
+ fprintf(stderr, "However, menuselect-deps indicates that dependencies for this module have not\n");
+ fprintf(stderr, "been met. So, either remove the existing menuselect.makeopts file, or run\n");
+ fprintf(stderr, "'make menuselect' to generate a file that is correct.\n\n");
+ goto deps_file_free;
+ }
+ mem->enabled = 0; /* Automatically disable it if dependencies not met */
+ }
+ }
+ }
+
+ /* Process conflicts of all modules */
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ AST_LIST_TRAVERSE(&mem->conflicts, cnf, list) {
+ mem->conflictsfailed = 0;
+ AST_LIST_TRAVERSE(&deps_file, dep_file, list) {
+ if (!strcasecmp(dep_file->name, cnf->name)) {
+ if (dep_file->met)
+ mem->conflictsfailed = 1;
+ break;
+ }
+ }
+ if (mem->conflictsfailed)
+ break; /* This conflict was found, so we can stop now */
+ }
+ if (mem->conflictsfailed) {
+ if (check_deps && existing_config && mem->enabled) {
+ /* Config already existed, but this module was not disabled.
+ * However, according to our current list of conflicts that
+ * exist, this can not be built. */
+ res = -1;
+ fprintf(stderr, "\nThe existing menuselect.makeopts did not specify that %s should not be built\n", mem->name);
+ fprintf(stderr, "However, menuselect-deps indicates that conflicts for this module exist.\n");
+ fprintf(stderr, "So, either remove the existing menuselect.makeopts file, or run\n");
+ fprintf(stderr, "'make menuselect' to generate a file that is correct.\n\n");
+ goto deps_file_free;
+ }
+ mem->enabled = 0; /* Automatically disable it if conflicts exist */
+ }
+ }
+ }
+
+deps_file_free:
+
+ /* Free the dependency list we built from the file */
+ while ((dep_file = AST_LIST_REMOVE_HEAD(&deps_file, list)))
+ free(dep_file);
+
+ return res;
+}
+
+/*! \brief Iterate through all of the input makeopts files and call the parse function on them */
+int build_member_list(void)
+{
+ int i;
+ int res = -1;
+
+ for (i = 0; i < (sizeof(makeopts_files) / sizeof(makeopts_files[0])); i++) {
+ if ((res = parse_makeopts_xml(makeopts_files[i]))) {
+ fprintf(stderr, "Error parsing '%s'!\n", makeopts_files[i]);
+ break;
+ }
+ }
+
+ return res;
+}
+
+/*! \brief Given the string representation of a member and category, mark it as present in a given input file */
+void mark_as_present(const char *member, const char *category)
+{
+ struct category *cat;
+ struct member *mem;
+
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ if (strcmp(category, cat->name))
+ continue;
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ if (!strcmp(member, mem->name)) {
+ mem->enabled = cat->positive_output;
+ break;
+ }
+ }
+ if (!mem)
+ fprintf(stderr, "member '%s' in category '%s' not found, ignoring.\n", member, category);
+ break;
+ }
+
+ if (!cat)
+ fprintf(stderr, "category '%s' not found! Can't mark '%s' as disabled.\n", category, member);
+}
+
+/*! \brief Toggle a member of a category at the specified index to enabled/disabled */
+void toggle_enabled(struct category *cat, int index)
+{
+ struct member *mem;
+ int i = 0;
+
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ if (i++ == index)
+ break;
+ }
+
+ if (mem && !(mem->depsfailed || mem->conflictsfailed)) {
+ mem->enabled = !mem->enabled;
+ if (cat->force_clean_on_change)
+ force_clean = 1;
+ }
+}
+
+/*! \brief Parse an existing output makeopts file and enable members previously selected */
+int parse_existing_config(const char *infile)
+{
+ FILE *f;
+ char buf[2048];
+ char *category, *parse, *member;
+ int lineno = 0;
+
+ if (!(f = fopen(infile, "r"))) {
+#ifdef MENUSELECT_DEBUG
+ /* This isn't really an error, so only print the message in debug mode */
+ fprintf(stderr, "Unable to open '%s' for reading existing config.\n", infile);
+#endif
+ return -1;
+ }
+
+ while (fgets(buf, sizeof(buf), f)) {
+ lineno++;
+
+ if (strlen_zero(buf))
+ continue;
+
+ /* skip lines that are not for this tool */
+ if (strncasecmp(buf, "MENUSELECT_", strlen("MENUSELECT_")))
+ continue;
+
+ parse = buf;
+ parse = skip_blanks(parse);
+ if (strlen_zero(parse))
+ continue;
+
+ /* Grab the category name */
+ category = strsep(&parse, "=");
+ if (!parse) {
+ fprintf(stderr, "Invalid string in '%s' at line '%d'!\n", output_makeopts, lineno);
+ continue;
+ }
+
+ parse = skip_blanks(parse);
+ while ((member = strsep(&parse, " \n"))) {
+ member = skip_blanks(member);
+ if (strlen_zero(member))
+ continue;
+
+ mark_as_present(member, category);
+ }
+ }
+
+ fclose(f);
+
+ return 0;
+}
+
+/*! \brief Create the output makeopts file that results from the user's selections */
+int generate_makeopts_file(void)
+{
+ FILE *f;
+ struct category *cat;
+ struct member *mem;
+
+ if (!(f = fopen(output_makeopts, "w"))) {
+ fprintf(stderr, "Unable to open build configuration file (%s) for writing!\n", output_makeopts);
+ return -1;
+ }
+
+ /* Traverse all categories and members and output them as var/val pairs */
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ fprintf(f, "%s=", cat->name);
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ if ((!cat->positive_output && (!mem->enabled || mem->depsfailed || mem->conflictsfailed)) ||
+ (cat->positive_output && mem->enabled && !mem->depsfailed && !mem->conflictsfailed))
+ fprintf(f, "%s ", mem->name);
+ }
+ fprintf(f, "\n");
+ }
+
+ fclose(f);
+
+ return 0;
+}
+
+#ifdef MENUSELECT_DEBUG
+/*! \brief Print out all of the information contained in our tree */
+void dump_member_list(void)
+{
+ struct category *cat;
+ struct member *mem;
+ struct depend *dep;
+ struct conflict *cnf;
+
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ fprintf(stderr, "Category: '%s'\n", cat->name);
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ fprintf(stderr, " ==>> Member: '%s' (%s)\n", mem->name, mem->enabled ? "Enabled" : "Disabled");
+ AST_LIST_TRAVERSE(&mem->deps, dep, list)
+ fprintf(stderr, " --> Depends on: '%s'\n", dep->name);
+ if (!AST_LIST_EMPTY(&mem->deps))
+ fprintf(stderr, " --> Dependencies Met: %s\n", mem->depsfailed ? "No" : "Yes");
+ AST_LIST_TRAVERSE(&mem->conflicts, cnf, list)
+ fprintf(stderr, " --> Conflicts with: '%s'\n", cnf->name);
+ if (!AST_LIST_EMPTY(&mem->conflicts))
+ fprintf(stderr, " --> Conflicts Found: %s\n", mem->conflictsfailed ? "Yes" : "No");
+ }
+ }
+}
+#endif
+
+/*! \brief Free all categories and their members */
+void free_member_list(void)
+{
+ struct category *cat;
+ struct member *mem;
+ struct depend *dep;
+ struct conflict *cnf;
+
+ while ((cat = AST_LIST_REMOVE_HEAD(&categories, list))) {
+ while ((mem = AST_LIST_REMOVE_HEAD(&cat->members, list))) {
+ while ((dep = AST_LIST_REMOVE_HEAD(&mem->deps, list)))
+ free(dep);
+ while ((cnf = AST_LIST_REMOVE_HEAD(&mem->conflicts, list)))
+ free(cnf);
+ free(mem);
+ }
+ free(cat);
+ }
+}
+
+/*! \brief Free all of the XML trees */
+void free_trees(void)
+{
+ struct tree *tree;
+
+ while ((tree = AST_LIST_REMOVE_HEAD(&trees, list))) {
+ mxmlDelete(tree->root);
+ free(tree);
+ }
+}
+
+/*! \brief Enable/Disable all members of a category as long as dependencies have been met and no conflicts are found */
+void set_all(struct category *cat, int val)
+{
+ struct member *mem;
+
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ if (!(mem->depsfailed || mem->conflictsfailed))
+ mem->enabled = val;
+ }
+}
+
+int count_categories(void)
+{
+ struct category *cat;
+ int count = 0;
+
+ AST_LIST_TRAVERSE(&categories, cat, list)
+ count++;
+
+ return count;
+}
+
+int count_members(struct category *cat)
+{
+ struct member *mem;
+ int count = 0;
+
+ AST_LIST_TRAVERSE(&cat->members, mem, list)
+ count++;
+
+ return count;
+}
+
+int main(int argc, char *argv[])
+{
+ int res = 0;
+ unsigned int x;
+
+ /* Parse the input XML files to build the list of available options */
+ if ((res = build_member_list()))
+ exit(res);
+
+ /* The --check-deps option is used to ask this application to check to
+ * see if that an existing menuselect.makeopts file contails all of the
+ * modules that have dependencies that have not been met. If this
+ * is not the case, an informative message will be printed to the
+ * user and the build will fail. */
+ for (x = 1; x < argc; x++) {
+ if (!strcmp(argv[x], "--check-deps"))
+ check_deps = 1;
+ else {
+ res = parse_existing_config(argv[x]);
+ if (!res && !strcasecmp(argv[x], OUTPUT_MAKEOPTS_DEFAULT))
+ existing_config = 1;
+ }
+ }
+
+ /* Process module dependencies */
+ res = process_deps();
+
+#ifdef MENUSELECT_DEBUG
+ /* Dump the list produced by parsing the various input files */
+ dump_member_list();
+#endif
+
+ /* Run the menu to let the user enable/disable options */
+ if (!check_deps && !res)
+ res = run_menu();
+
+ /* Write out the menuselect.makeopts file if
+ * 1) menuselect was not executed with --check-deps
+ * 2) menuselect was executed with --check-deps but menuselect.makeopts
+ * did not already exist.
+ */
+ if ((!check_deps || !existing_config) && !res)
+ res = generate_makeopts_file();
+
+ /* free everything we allocated */
+ free_trees();
+ free_member_list();
+
+ if (check_deps && !existing_config && !res) {
+ fprintf(stderr, "\n***********************************************************\n");
+ fprintf(stderr, "* menuselect.makeopts file generated with default values! *\n");
+ fprintf(stderr, "* Please rerun make to build Asterisk. *\n");
+ fprintf(stderr, "***********************************************************\n\n");
+ res = -1;
+ }
+
+ if (force_clean)
+ unlink(".lastclean");
+
+ exit(res);
+}
--- /dev/null
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2005-2006, Russell Bryant
+ *
+ * Russell Bryant <russell@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*!
+ * \file
+ *
+ * \brief defaults for menuselect
+ *
+ */
+
+#ifndef MENUSELECT_H
+#define MENUSELECT_H
+
+#include "asterisk/linkedlists.h"
+
+#define OUTPUT_MAKEOPTS_DEFAULT "menuselect.makeopts"
+#define MENUSELECT_DEPS "build_tools/menuselect-deps"
+
+struct depend;
+struct conflict;
+
+struct member {
+ /*! What will be sent to the makeopts file */
+ const char *name;
+ /*! This module is currently selected */
+ int enabled;
+ /*! This module has failed dependencies */
+ int depsfailed;
+ /*! This module has failed conflicts */
+ int conflictsfailed;
+ /*! dependencies of this module */
+ AST_LIST_HEAD_NOLOCK(, depend) deps;
+ /*! conflicts of this module */
+ AST_LIST_HEAD_NOLOCK(, conflict) conflicts;
+ /*! for making a list of modules */
+ AST_LIST_ENTRY(member) list;
+};
+
+struct category {
+ /*! the Makefile variable */
+ const char *name;
+ /*! the name displayed in the menu */
+ const char *displayname;
+ /*! Display what is selected, as opposed to not selected */
+ int positive_output;
+ /*! Force a clean of the source tree if anything in this category changes */
+ int force_clean_on_change;
+ /*! the list of possible values to be set in this variable */
+ AST_LIST_HEAD_NOLOCK(, member) members;
+ /*! for linking */
+ AST_LIST_ENTRY(category) list;
+};
+
+extern AST_LIST_HEAD_NOLOCK(categories, category) categories;
+
+/*! This is implemented by the frontend */
+int run_menu(void);
+
+int count_categories(void);
+
+int count_members(struct category *cat);
+
+/*! \brief Toggle a member of a category at the specified index to enabled/disabled */
+void toggle_enabled(struct category *cat, int index);
+
+/*! \brief Enable/Disable all members of a category as long as dependencies have been met and no conflicts are found */
+void set_all(struct category *cat, int val);
+
+/*! \brief returns non-zero if the string is not defined, or has zero length */
+static inline int strlen_zero(const char *s)
+{
+ return (!s || (*s == '\0'));
+}
+
+#endif /* MENUSELECT_H */
--- /dev/null
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2005 - 2006, Russell Bryant
+ *
+ * Russell Bryant <russell@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*
+ * \file
+ *
+ * \author Russell Bryant <russell@digium.com>
+ *
+ * \brief curses frontend for Asterisk module selection
+ */
+
+#include "autoconfig.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <curses.h>
+
+#include "menuselect.h"
+
+#define MENU_TITLE1 "*************************************"
+#define MENU_TITLE2 "* Asterisk Module Selection *"
+#define MENU_TITLE3 "*************************************"
+
+#define TITLE_HEIGHT 5
+
+#define MIN_X 80
+#define MIN_Y 20
+
+#define PAGE_OFFSET 10
+
+
+/*! Maximum number of characters horizontally */
+int max_x = 0;
+/*! Maximum number of characters vertically */
+int max_y = 0;
+
+const char * const help_info[] = {
+ "scroll => up/down arrows",
+ "(de)select => Enter",
+ "select all => F8",
+ "deselect all => F7",
+ "back => left arrow",
+ "quit => q",
+ "save and quit => x",
+ "",
+ "XXX means dependencies have not been met"
+};
+
+void winch_handler(int sig);
+void show_help(WINDOW *win);
+void draw_main_menu(WINDOW *menu, int curopt);
+void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt);
+int run_category_menu(WINDOW *menu, int cat_num);
+int run_category_menu(WINDOW *menu, int cat_num);
+void draw_title_window(WINDOW *title);
+
+/*! \brief Handle a window resize in xterm */
+void winch_handler(int sig)
+{
+ getmaxyx(stdscr, max_y, max_x);
+
+ if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
+ fprintf(stderr, "Terminal must be at least 80 x 25.\n");
+ max_x = MIN_X - 1;
+ max_y = MIN_Y - 1;
+ }
+}
+
+/*! \brief Display help information */
+void show_help(WINDOW *win)
+{
+ int i;
+
+ wclear(win);
+ for (i = 0; i < (sizeof(help_info) / sizeof(help_info[0])); i++) {
+ wmove(win, i, max_x / 2 - 15);
+ waddstr(win, help_info[i]);
+ }
+ wrefresh(win);
+ getch(); /* display the help until the user hits a key */
+}
+
+void draw_main_menu(WINDOW *menu, int curopt)
+{
+ struct category *cat;
+ char buf[64];
+ int i = 0;
+
+ wclear(menu);
+
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ wmove(menu, i++, max_x / 2 - 10);
+ if (!strlen_zero(cat->displayname))
+ snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->displayname);
+ else
+ snprintf(buf, sizeof(buf), "%d.%s %s", i, i < 10 ? " " : "", cat->name);
+ waddstr(menu, buf);
+ }
+
+ wmove(menu, curopt, (max_x / 2) - 15);
+ waddstr(menu, "--->");
+ wmove(menu, 0, 0);
+
+ wrefresh(menu);
+}
+
+void draw_category_menu(WINDOW *menu, struct category *cat, int start, int end, int curopt)
+{
+ int i = 0;
+ int j = 0;
+ struct member *mem;
+ char buf[64];
+
+ wclear(menu);
+
+ AST_LIST_TRAVERSE(&cat->members, mem, list) {
+ if (i < start) {
+ i++;
+ continue;
+ }
+ wmove(menu, j++, max_x / 2 - 10);
+ i++;
+ if (mem->depsfailed)
+ snprintf(buf, sizeof(buf), "XXX %d.%s %s", i, i < 10 ? " " : "", mem->name);
+ else
+ snprintf(buf, sizeof(buf), "[%s] %d.%s %s", mem->enabled ? "*" : " ", i, i < 10 ? " " : "", mem->name);
+ waddstr(menu, buf);
+ if (i == end)
+ break;
+ }
+
+ wmove(menu, curopt - start, max_x / 2 - 9);
+
+ wrefresh(menu);
+}
+
+int run_category_menu(WINDOW *menu, int cat_num)
+{
+ struct category *cat;
+ int i = 0;
+ int start = 0;
+ int end = max_y - TITLE_HEIGHT - 2;
+ int c;
+ int curopt = 0;
+ int maxopt;
+
+ AST_LIST_TRAVERSE(&categories, cat, list) {
+ if (i++ == cat_num)
+ break;
+ }
+ if (!cat)
+ return -1;
+
+ maxopt = count_members(cat) - 1;
+
+ draw_category_menu(menu, cat, start, end, curopt);
+
+ while ((c = getch())) {
+ switch (c) {
+ case KEY_UP:
+ if (curopt > 0) {
+ curopt--;
+ if (curopt < start) {
+ start--;
+ end--;
+ }
+ }
+ break;
+ case KEY_DOWN:
+ if (curopt < maxopt) {
+ curopt++;
+ if (curopt > end - 1) {
+ start++;
+ end++;
+ }
+ }
+ break;
+ case KEY_NPAGE:
+ /* XXX Move down the list by PAGE_OFFSET */
+ break;
+ case KEY_PPAGE:
+ /* XXX Move up the list by PAGE_OFFSET */
+ break;
+ case KEY_LEFT:
+ return 0;
+ case KEY_RIGHT:
+ case KEY_ENTER:
+ case '\n':
+ case ' ':
+ toggle_enabled(cat, curopt);
+ break;
+ case 'h':
+ case 'H':
+ show_help(menu);
+ break;
+ case KEY_F(7):
+ set_all(cat, 0);
+ break;
+ case KEY_F(8):
+ set_all(cat, 1);
+ default:
+ break;
+ }
+ if (c == 'x' || c == 'q')
+ break;
+ draw_category_menu(menu, cat, start, end, curopt);
+ }
+
+ wrefresh(menu);
+
+ return c;
+}
+
+void draw_title_window(WINDOW *title)
+{
+ wmove(title, 1, (max_x / 2) - (strlen(MENU_TITLE1) / 2));
+ waddstr(title, MENU_TITLE1);
+ wmove(title, 2, (max_x / 2) - (strlen(MENU_TITLE2) / 2));
+ waddstr(title, MENU_TITLE2);
+ wmove(title, 3, (max_x / 2) - (strlen(MENU_TITLE3) / 2));
+ waddstr(title, MENU_TITLE3);
+ wmove(title, 0, 0);
+ wrefresh(title);
+}
+
+
+
+int run_menu(void)
+{
+ WINDOW *title;
+ WINDOW *menu;
+ int maxopt;
+ int curopt = 0;
+ int c;
+ int res = 0;
+
+ initscr();
+ getmaxyx(stdscr, max_y, max_x);
+ signal(SIGWINCH, winch_handler); /* handle window resizing in xterm */
+
+ if (max_x < MIN_X - 1 || max_y < MIN_Y - 1) {
+ fprintf(stderr, "Terminal must be at least %d x %d.\n", MIN_X, MIN_Y);
+ endwin();
+ return -1;
+ }
+
+ cbreak(); /* don't buffer input until the enter key is pressed */
+ noecho(); /* don't echo user input to the screen */
+ keypad(stdscr, TRUE); /* allow the use of arrow keys */
+ clear();
+ refresh();
+
+ maxopt = count_categories() - 1;
+
+ /* We have two windows - the title window at the top, and the menu window gets the rest */
+ title = newwin(TITLE_HEIGHT, max_x, 0, 0);
+ menu = newwin(max_y - TITLE_HEIGHT, max_x, TITLE_HEIGHT, 0);
+ draw_title_window(title);
+ draw_main_menu(menu, curopt);
+
+ while ((c = getch())) {
+ switch (c) {
+ case KEY_UP:
+ if (curopt > 0)
+ curopt--;
+ break;
+ case KEY_DOWN:
+ if (curopt < maxopt)
+ curopt++;
+ break;
+ case KEY_RIGHT:
+ case KEY_ENTER:
+ case '\n':
+ case ' ':
+ c = run_category_menu(menu, curopt);
+ break;
+ case 'h':
+ case 'H':
+ show_help(menu);
+ default:
+ break;
+ }
+ if (c == 'q') {
+ res = -1;
+ break;
+ }
+ if (c == 'x')
+ break;
+ draw_main_menu(menu, curopt);
+ }
+
+ endwin();
+
+ return res;
+}
--- /dev/null
+#!/bin/sh
+
+process_dir() {
+ dir=${1}
+ prefix=${2}_
+ catsuffix=${3}
+ displayname=${4}
+
+ echo -e "\t<category name=\"MENUSELECT_${catsuffix}\" displayname=\"${displayname}\">"
+ for file in ${dir}/${prefix}*.c
+ do
+ fname=${file##${dir}/}
+ echo -e "\t\t<member name=\"${fname%%.c}.so\">"
+ awk -f build_tools/get_moduledeps ${file}
+ echo -e "\t\t</member>"
+ done
+ echo -e "\t</category>"
+}
+
+echo "<?xml version="1.0"?>"
+echo
+echo "<menu>"
+process_dir apps app APPS Applications
+process_dir cdr cdr CDR "Call Detail Recording"
+process_dir channels chan CHANNELS "Channel Drivers"
+process_dir codecs codec CODECS "Codec Translators"
+process_dir formats format FORMATS "Format Interpreters"
+process_dir funcs func FUNCS "Diaplan Functions"
+process_dir pbx pbx PBX "PBX Modules"
+process_dir res res RES "Resource Modules"
+cat build_tools/cflags.xml
+echo "</menu>"
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard cdr_*.c))
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/odbcinst.h $(CROSS_COMPILE_TARGET)/usr/local/include/odbcinst.h),)
- MODS:=$(filter-out cdr_odbc.so,$(MODS))
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql $(CROSS_COMPILE_TARGET)/usr/local/pgsql/include $(CROSS_COMPILE_TARGET)/usr/include/pgsql $(CROSS_COMPILE_TARGET)/usr/local/include/pgsql $(CROSS_COMPILE_TARGET)/opt/pgsql/include $(CROSS_COMPILE_TARGET)/usr/include/libpq-fe.h),)
- MODS:=$(filter-out cdr_pgsql.so,$(MODS))
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/sqlite.h),)
- MODS:=$(filter-out cdr_sqlite.so,$(MODS))
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/tds.h $(CROSS_COMPILE_TARGET)/usr/local/include/tds.h $(CROSS_COMPILE_TARGET)/usr/include/freetds/tds.h),)
- MODS:=$(filter-out cdr_tds.so,$(MODS))
- NOTDS=1
-endif
-
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -lasterisk.dll
-else
- CFLAGS+=-fPIC
-endif
+MODS:=$(filter-out $(MENUSELECT_CDR),$(patsubst %.c,%.so,$(wildcard cdr_*.c)))
#The problem with sparc is the best stuff is in newer versions of gcc (post 3.0) only.
#This works for even old (2.96) versions of gcc and provides a small boost either way.
CFLAGS += -mtune=$(PROC) -O3 -pipe -fomit-frame-pointer -mcpu=v8
endif
-ifeq (${NOTDS},)
+ifneq ($(TDS_LIB),)
ifeq ($(shell grep -s TDS_VERSION_NO $(CROSS_COMPILE_TARGET)/usr/include/tdsver.h $(CROSS_COMPILE_TARGET)/usr/local/include/tdsver.h $(CROSS_COMPILE_TARGET)/usr/include/freetds/tdsver.h | grep -c 0.63),1)
CFLAGS += -DFREETDS_0_63
else
endif
endif
-MLFLAGS=
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/freetds),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/freetds
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib/postgresql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/postgresql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib/postgresql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/pgsql/include),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/pgsql/include
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/local/pgsql/lib
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/pgsql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/pgsql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib/pgsql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/pgsql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/include/pgsql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/local/lib/pgsql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/opt/pgsql/include),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/opt/pgsql/include
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET) /opt/pgsql/lib
-endif
-
-ifneq ($(wilcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/postgresql
-endif
-
-ifneq ($(wilcard $(CROSS_COMPILE_TARGET)/usr/lib/libpq.so),)
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib
-endif
-
all: depend $(MODS)
install: all
rm -f *.so *.o
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
-
-ifneq ($(wildcard .depend),)
- include .depend
-endif
+ $(CC) $(SOLINK) -o $@ $<
cdr_odbc.so: cdr_odbc.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lodbc $(MLFLAGS)
+ $(CC) $(SOLINK) -o $@ $< $(ODBC_LIB)
+
+cdr_odbc.o: cdr_odbc.c
+ $(CC) -c -o $@ $(CFLAGS) $(ODBC_INCLUDE) $<
cdr_tds.so: cdr_tds.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -ltds $(MLFLAGS)
+ $(CC) $(SOLINK) -o $@ $< $(TDS_LIB)
+
+cdr_tds.o: cdr_tds.c
+ $(CC) -c -o $@ $(CFLAGS) $(TDS_INCLUDE) $<
cdr_pgsql.so: cdr_pgsql.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lpq -lz $(MLFLAGS)
+ $(CC) $(SOLINK) -o $@ $< $(PGSQL_LIB)
+
+cdr_pgsql.o: cdr_pgsql.c
+ $(CC) -c -o $@ $(CFLAGS) $(PGSQL_INCLUDE) $<
cdr_sqlite.so: cdr_sqlite.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lsqlite $(MLFLAGS)
+ $(CC) $(SOLINK) -o $@ $< $(SQLITE_LIB)
+
+cdr_sqlite.o: cdr_sqlite.c
+ $(CC) -c -o $@ $(CFLAGS) $(SQLITE_INCLUDE) $<
+
+ifneq ($(wildcard .depend),)
+ include .depend
+endif
depend: .depend
* \ingroup cdr_drivers
*/
+/*** MODULEINFO
+ <depend>unixodbc</depend>
+ ***/
+
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
* \ingroup cdr_drivers
*/
+/*** MODULEINFO
+ <depend>pgsql</depend>
+ ***/
+
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
* \ingroup cdr_drivers
*/
+/*** MODULEINFO
+ <depend>sqlite</depend>
+ ***/
+
#include <sys/types.h>
#include <unistd.h>
*/
+/*** MODULEINFO
+ <depend>freetds</depend>
+ ***/
+
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <math.h> /* For PI */
-#ifdef ZAPTEL_OPTIMIZATIONS
+#include "asterisk.h"
+
+#ifdef HAVE_ZAPTEL
#include <sys/ioctl.h>
#ifdef __linux__
#include <linux/zaptel.h>
#endif
#endif
-#include "asterisk.h"
-
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/pbx.h"
for (x=0; x<AST_MAX_FDS - 2; x++)
tmp->fds[x] = -1;
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
tmp->timingfd = open("/dev/zap/timer", O_RDWR);
if (tmp->timingfd > -1) {
/* Check if timing interface supports new
if (write(chan->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah))
ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n",
chan->name, f->frametype, f->subclass, qlen, strerror(errno));
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
} else if (chan->timingfd > -1) {
ioctl(chan->timingfd, ZT_TIMERPING, &blah);
#endif
int ast_settimeout(struct ast_channel *c, int samples, int (*func)(void *data), void *data)
{
int res = -1;
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
if (c->timingfd > -1) {
if (!func) {
samples = 0;
if (chan->alertpipe[0] > -1)
read(chan->alertpipe[0], &blah, sizeof(blah));
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
int res;
#
# Mark Spencer <markster@digium.com>
#
-# Edited By Belgarath <> Aug 28 2004
-# Added bare bones ultrasparc-linux support.
-#
# This program is free software, distributed under the terms of
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard chan_*.c))
+MODS:=$(filter-out $(MENUSELECT_CHANNELS),$(patsubst %.c,%.so,$(wildcard chan_*.c)))
-ifeq (${OSARCH},OpenBSD)
+ifeq ($(OSARCH),OpenBSD)
PTLIB=-lpt_OpenBSD_x86_r
H323LIB=-lh323_OpenBSD_x86_r
endif
-ifeq (${OSARCH},Linux)
+ifeq ($(OSARCH),Linux)
PTLIB=-lpt_linux_x86_r
H323LIB=-lh323_linux_x86_r
CHANH323LIB=-ldl
endif
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -L../res -lasterisk.dll -lres_features.so
- CYG_CHAN_AGENT=-lres_monitor.so
-endif
-
ifeq ($(PROC),sparc64)
PROC=ultrasparc
CFLAGS += -mtune=$(PROC) -O3 -pipe -fomit-frame-pointer -mcpu=v8
endif
-ifeq (${OSARCH},FreeBSD)
+ifeq ($(OSARCH),FreeBSD)
PTLIB=-lpt_FreeBSD_x86_r
H323LIB=-lh323_FreeBSD_x86_r
CHANH323LIB=-pthread
endif
-ifeq (${OSARCH},NetBSD)
+ifeq ($(OSARCH),NetBSD)
PTLIB=-lpt_NetBSD_x86_r
H323LIB=-lh323_NetBSD_x86_r
endif
-ifeq (${OSARCH},Darwin)
- MODS:=$(filter-out chan_oss.so,$(MODS))
-endif
-
-ifeq (${OSARCH},SunOS)
- MODS:=$(filter-out chan_oss.so,$(MODS))
+ifeq ($(OSARCH),SunOS)
SOLINK+=-lrt
endif
-ifeq (${OSARCH},CYGWIN)
- MODS:=$(filter-out chan_oss.so,$(MODS))
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/linux/ixjuser.h $(CROSS_COMPILE_TARGET)/usr/local/include/ixjuser.h),)
- MODS:=$(filter-out chan_phone.so,$(MODS))
-endif
-
-ifeq (${WITH_SMDI},1)
-CFLAGS+=-DWITH_SMDI
+ifeq ($(WITH_SMDI),1)
+ CFLAGS+=-DWITH_SMDI
endif
ifeq ($(wildcard h323/libchanh323.a),)
CFLAGS+=-Imisdn
endif
-CFLAGS+=-Wno-missing-prototypes -Wno-missing-declarations
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/alsa/asoundlib.h),)
- MODS:=$(filter-out chan_alsa.so,$(MODS))
-endif
-
-ifndef WITHOUT_PRI
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/lib/libpri.so.1 $(CROSS_COMPILE_TARGET)/usr/local/lib/libpri.so.1),)
- CFLAGS+=-DZAPATA_PRI
- ZAPPRI=-lpri
-endif
-endif # WITHOUT_PRI
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/lib/libmfcr2.so.1 $(CROSS_COMPILE_TARGET)/usr/local/lib/libmfcr2.so.1),)
- CFLAGS+=-DZAPATA_R2
- ZAPR2=-lmfcr2
-endif
-
-ALSA_SRC=chan_alsa.c
-
-ifneq ($(wildcard alsa-monitor.h),)
- CFLAGS+=-DALSA_MONITOR
- ALSA_SRC+=alsa-monitor.h
-endif
-
-ifndef WITHOUT_ZAPTEL
-ZAPAVAIL:=$(wildcard $(CROSS_COMPILE_TARGET)/usr/include/linux/zaptel.h $(CROSS_COMPILE_TARGET)/usr/local/include/zaptel.h)
-endif
-
-ifeq (${ZAPAVAIL},)
- MODS:=$(filter-out chan_zap.so,$(MODS))
-else
- ifeq (${OSARCH},NetBSD)
- SOLINK+=-L$(CROSS_COMPILE_TARGET)/usr/pkg/lib
- endif
- ifeq (${OSARCH},FreeBSD)
- SOLINK+=-L$(CROSS_COMPILE_TARGET)/usr/local/lib
- endif
- CFLAGS+=-DIAX_TRUNKING
-endif
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/vpbapi.h),)
- MODS:=$(filter-out chan_vpb.so,$(MODS))
-else
- CFLAGS+=-DLINUX
-endif
-
-CFLAGS+=-DCRYPTO
-
-ifneq ($(OSARCH),CYGWIN)
- CFLAGS+=-fPIC
-endif
-
-CFLAGS+=#-DVOFRDUMPER
-
-ZAPDIR=/usr/lib
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/nbs.h),)
- MODS:=$(filter-out chan_nbs.so,$(MODS))
-endif
-
ifndef OPENH323DIR
OPENH323DIR=$(HOME)/openh323
endif
rm -f busy.h ringtone.h gentone gentone-ulaw
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} ${LIBS}
+ $(CC) $(SOLINK) -o $@ $<
ifneq ($(wildcard .depend),)
include .depend
chan_oss.o: chan_oss.c busy.h ringtone.h
-chan_alsa.o: chan_alsa.c busy.h ringtone.h
-
-ifeq (${OSARCH},OpenBSD)
+ifeq ($(OSARCH),OpenBSD)
chan_oss.so: chan_oss.o
$(CC) $(SOLINK) -o $@ chan_oss.o -lossaudio
endif
-ifeq (${OSARCH},NetBSD)
+ifeq ($(OSARCH),NetBSD)
chan_oss.so: chan_oss.o
$(CC) $(SOLINK) -o $@ chan_oss.o -lossaudio
endif
chan_iax2.so: chan_iax2.o iax2-parser.o iax2-provision.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} chan_iax2.o iax2-parser.o iax2-provision.o ${CYGSOLIB}
-
-chan_zap.o: chan_zap.c
- $(CC) -c $(CFLAGS) -o chan_zap.o chan_zap.c
+ $(CC) $(SOLINK) -o $@ $< iax2-parser.o iax2-provision.o
chan_zap.so: chan_zap.o
- $(CC) $(SOLINK) -o $@ $< $(ZAPPRI) $(ZAPR2) -ltonezone
-
-chan_sip.so: chan_sip.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} chan_sip.o ${CYGSOLIB}
+ $(CC) $(SOLINK) -o $@ $< $(PRI_LIB) $(MFCR2_LIB) $(ZAPTEL_LIB)
-chan_agent.so: chan_agent.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} chan_agent.o ${CYGSOLIB} ${CYG_CHAN_AGENT}
-
-chan_alsa.o: $(ALSA_SRC)
+chan_zap.o: chan_zap.c
+ $(CC) -c -o $@ $(CFLAGS) $(ZAPTEL_INCLUDE) $<
chan_alsa.so: chan_alsa.o
- $(CC) $(SOLINK) -o $@ $< -lasound -lm -ldl
+ $(CC) $(SOLINK) -o $@ $< $(ASOUND_LIB)
+
+chan_alsa.o: chan_alsa.c busy.h ringtone.h
+ $(CC) -c -o $@ $(CFLAGS) $(ASOUND_INCLUDE) $<
chan_nbs.so: chan_nbs.o
- $(CC) $(SOLINK) -o $@ $< -lnbs
+ $(CC) $(SOLINK) -o $@ $< $(NBS_LIB)
+
+chan_nbs.o: chan_nbs.c
+ $(CC) -c -o $@ $(CFLAGS) $(NBS_INCLUDE) $<
chan_vpb.o: chan_vpb.c
$(CXX) -c $(CFLAGS:-Werror=) -o $@ chan_vpb.c
chan_vpb.so: chan_vpb.o
$(CXX) $(SOLINK) -o $@ $< -lvpb -lpthread -lm -ldl
-ifeq (${OSARCH},Linux)
+ifeq ($(OSARCH),Linux)
chan_h323.so: chan_h323.o h323/libchanh323.a h323/Makefile.ast
$(CC) $(SOLINK) $(H323LDFLAGS) -o $@ $< h323/libchanh323.a $(H323LDLIBS) -lstdc++
else
return res;
}
-struct agent_pvt *find_agent(char *agentid)
+static struct agent_pvt *find_agent(char *agentid)
{
struct agent_pvt *cur;
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>asound</depend>
+ ***/
#include <unistd.h>
#include <fcntl.h>
{ { "autoanswer", NULL }, console_autoanswer, "Sets/displays autoanswer", autoanswer_usage, autoanswer_complete }
};
-int load_module(void)
+static int load_module(void *mod)
{
int res;
int x;
return 0;
}
-
-
-int unload_module(void)
+static int unload_module(void *mod)
{
int x;
return 0;
}
-const char *description(void)
+static const char *description(void)
{
return (char *) desc;
}
-int usecount(void)
-{
- return usecnt;
-}
-
-const char *key(void)
+static const char *key(void)
{
return ASTERISK_GPL_KEY;
}
+
+STD_MOD(MOD_0, NULL, NULL, NULL);
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>h323</depend>
+ ***/
+
#include <sys/socket.h>
#include <sys/signal.h>
#include <sys/param.h>
{
return ASTERISK_GPL_KEY;
}
+
#include <fcntl.h>
#include <sys/stat.h>
#include <regex.h>
-#ifdef IAX_TRUNKING
+
+#include "asterisk.h"
+
+#ifdef HAVE_ZAPTEL
#include <sys/ioctl.h>
#ifdef __linux__
#include <linux/zaptel.h>
#endif /* __linux__ */
#endif
-#include "asterisk.h"
-
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/lock.h"
static void set_timing(void)
{
-#ifdef IAX_TRUNKING
+#ifdef HAVE_ZAPTEL
int bs = trunkfreq * 8;
if (timingfd > -1) {
if (
jb_setoutput(jb_error_output, jb_warning_output, NULL);
#endif
-#ifdef IAX_TRUNKING
+#ifdef HAVE_ZAPTEL
#ifdef ZT_TIMERACK
timingfd = open("/dev/zap/timer", O_RDWR);
if (timingfd < 0)
static int tracing = 0 ;
-static int usecnt=0;
-
static char **misdn_key_vector=NULL;
static int misdn_key_vector_size=0;
/* Only alaw and mulaw is allowed for now */
static int prefformat = AST_FORMAT_ALAW ; /* AST_FORMAT_SLINEAR ; AST_FORMAT_ULAW | */
-static ast_mutex_t usecnt_lock;
-
static int *misdn_debug;
static int *misdn_debug_only;
static int max_ports;
-void reload_config(void)
+static void reload_config(void)
{
int i, cfg_debug;
chan_misdn_log(-1, 0, "Dynamic Crypting Activation is not support during reload at the moment\n");
-void config_jitterbuffer(struct chan_list *ch)
+static void config_jitterbuffer(struct chan_list *ch)
{
struct misdn_bchannel *bc=ch->bc;
int len=ch->jb_len, threshold=ch->jb_upper_threshold;
-enum ast_bridge_result misdn_bridge (struct ast_channel *c0,
+static enum ast_bridge_result misdn_bridge (struct ast_channel *c0,
struct ast_channel *c1, int flags,
struct ast_frame **fo,
struct ast_channel **rc,
}
-int misdn_send_text (struct ast_channel *chan, const char *text)
+static int misdn_send_text (struct ast_channel *chan, const char *text)
{
struct chan_list *tmp=chan->tech_pvt;
static int g_config_initialized=0;
-int unload_module(void)
+static int unload_module(void *mod)
{
/* First, take us out of the channel loop */
ast_log(LOG_VERBOSE, "-- Unregistering mISDN Channel Driver --\n");
return 0;
}
-int load_module(void)
+static int load_module(void *mod)
{
int i;
{
if (ast_channel_register(&misdn_tech)) {
ast_log(LOG_ERROR, "Unable to register channel class %s\n", misdn_type);
- unload_module();
+ unload_module(mod);
return -1;
}
}
-int reload(void)
+static int reload(void *mod)
{
reload_config();
return 0;
}
-int usecount(void)
-{
- int res;
- ast_mutex_lock(&usecnt_lock);
- res = usecnt;
- ast_mutex_unlock(&usecnt_lock);
- return res;
-}
-
-const char *description(void)
+static const char *description(void)
{
return desc;
}
-const char *key(void)
+static const char *key(void)
{
return ASTERISK_GPL_KEY;
}
}
}
-
+STD_MOD(MOD_0, reload, NULL, NULL);
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>nbs</depend>
+ ***/
+
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
{
return ASTERISK_GPL_KEY;
}
+
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>osssound</depend>
+ ***/
+
#include <stdio.h>
#include <ctype.h> /* for isalnum */
#include <math.h> /* exp and log */
}
STD_MOD(MOD_1, NULL, NULL, NULL);
+
+
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>ixjuser</depend>
+ ***/
+
#include <stdio.h>
#include <string.h>
#include <ctype.h>
}
STD_MOD1;
+
+
/*! \brief Initialize the initital request packet in the pvt structure.
This packet is used for creating replies and future requests in
a dialog */
-void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
+static void initialize_initreq(struct sip_pvt *p, struct sip_request *req)
{
if (p->initreq.headers) {
ast_log(LOG_WARNING, "Initializing already initialized SIP dialog??? %s\n", p->callid);
}
/*! \brief Allocate SIP refer structure */
-int sip_refer_allocate(struct sip_pvt *p) {
+static int sip_refer_allocate(struct sip_pvt *p)
+{
p->refer = ast_calloc(1, sizeof(struct sip_refer));
return p->refer ? 1 : 0;
}
/*! \brief func_header_read: Read SIP header (dialplan function) */
-int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
+static int func_header_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
{
struct sip_pvt *p;
const char *content;
};
/*! \brief Dial plan function to check if domain is local */
-int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
+static int func_check_sipdomain(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
{
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "CHECKSIPDOMAIN requires an argument - A domain name\n");
};
/*! \brief ${SIPCHANINFO()} Dialplan function - reads sip channel data */
-int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
+static int function_sipchaninfo_read(struct ast_channel *chan, char *cmd, char *data, char *buf, size_t len)
{
struct sip_pvt *p;
char iabuf[INET_ADDRSTRLEN];
* \ingroup channel_drivers
*/
+/*** MODULEINFO
+ <depend>vpbapi</depend>
+ ***/
extern "C" {
}
#endif
/**/
+
+
*
* \ingroup channel_drivers
*
- * \todo Decprecate the "musiconhold" configuration option in v1.5dev
+ * \todo Decprecate the "musiconhold" configuration option post 1.4
*/
+/*** MODULEINFO
+ <depend>zaptel</depend>
+ ***/
+
#include <stdio.h>
#include <string.h>
#ifdef __NetBSD__
#include <math.h>
#include <tonezone.h>
#include <ctype.h>
-#ifdef ZAPATA_PRI
+
+#include "asterisk.h"
+
+#ifdef HAVE_LIBPRI
#include <libpri.h>
#ifndef PRI_KEYPAD_FACILITY_TX
#error "You need newer libpri"
#endif
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
#include <libmfcr2.h>
#endif
-#include "asterisk.h"
-
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/lock.h"
#define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */
#endif
-#if !defined(ZT_SIG_EM_E1) || (defined(ZAPATA_PRI) && !defined(ZT_SIG_HARDHDLC))
+#if !defined(ZT_SIG_EM_E1) || (defined(HAVE_LIBPRI) && !defined(ZT_SIG_HARDHDLC))
#error "Your zaptel is too old. please update"
#endif
/*! \brief Signaling types that need to use MF detection should be placed in this macro */
#define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
-
static const char tdesc[] = "Zapata Telephony Driver"
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
" w/PRI"
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
" w/R2"
#endif
;
static int priindication_oob = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static int minunused = 2;
static int minidle = 0;
static char idleext[AST_MAX_EXTENSION];
static int ifcount = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
#endif
struct zt_pvt;
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
static int r2prot = -1;
#endif
static int ringt_base = DEFAULT_RINGT;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
#define PVT_TO_CHANNEL(p) (((p)->prioffset) | ((p)->logicalspan << 8) | (p->pri->mastertrunkgroup ? 0x10000 : 0))
#define PRI_CHANNEL(p) ((p) & 0xff)
unsigned int usedistinctiveringdetection:1;
unsigned int zaptrcallerid:1; /*!< should we use the callerid from incoming call on zap transfer or not */
unsigned int transfertobusy:1; /*!< allow flash-transfers to busy channels */
-#if defined(ZAPATA_PRI)
+#if defined(HAVE_LIBPRI)
unsigned int alerting:1;
unsigned int alreadyhungup:1;
unsigned int isidlecall:1;
unsigned int resetting:1;
unsigned int setup_ack:1;
#endif
-#if defined(ZAPATA_R2)
+#if defined(HAVE_MFCR2)
unsigned int hasr2call:1;
unsigned int r2blocked:1;
unsigned int sigchecked:1;
int polarityonanswerdelay;
struct timeval polaritydelaytv;
int sendcalleridafter;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
struct zt_pri *pri;
struct zt_pvt *bearer;
struct zt_pvt *realcall;
int prioffset;
int logicalspan;
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
int r2prot;
mfcr2_t *r2;
#endif
.setoption = zt_setoption,
};
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
#define GET_CHANNEL(p) ((p)->bearer ? (p)->bearer->channel : p->channel)
#else
#define GET_CHANNEL(p) ((p)->channel)
struct zt_pvt *round_robin[32];
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri)
{
int res;
return res;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static void wakeup_sub(struct zt_pvt *p, int a, struct zt_pri *pri)
#else
static void wakeup_sub(struct zt_pvt *p, int a, void *pri)
#endif
{
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_mutex_unlock(&pri->lock);
#endif
} else
break;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_mutex_lock(&pri->lock);
#endif
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, struct zt_pri *pri)
#else
static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, void *pri)
#endif
{
/* We must unlock the PRI to avoid the possibility of a deadlock */
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_mutex_unlock(&pri->lock);
#endif
} else
break;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_mutex_lock(&pri->lock);
#endif
close(fd);
}
-int zt_setlinear(int zfd, int linear)
+static int zt_setlinear(int zfd, int linear)
{
int res;
res = ioctl(zfd, ZT_SETLINEAR, &linear);
}
-int zt_setlaw(int zfd, int law)
+static int zt_setlaw(int zfd, int law)
{
int res;
res = ioctl(zfd, ZT_SETLAW, &law);
ast_mutex_lock(&p->lock);
index = zt_get_index(ast, p, 0);
if ((index == SUB_REAL) && p->owner) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if ((p->sig == SIG_PRI) && (ast->_state == AST_STATE_DIALING) && !p->proceeding) {
if (p->setup_ack) {
if (!pri_grab(p, p->pri)) {
return buf;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static char *dialplan2str(int dialplan)
{
if (dialplan == -1) {
}
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
static int str2r2prot(char *swtype)
{
if (!strcasecmp(swtype, "ar"))
}
}
-int set_actual_txgain(int fd, int chan, float gain, int law)
+static int set_actual_txgain(int fd, int chan, float gain, int law)
{
struct zt_gains g;
int res;
return ioctl(fd, ZT_SETGAINS, &g);
}
-int set_actual_rxgain(int fd, int chan, float gain, int law)
+static int set_actual_rxgain(int fd, int chan, float gain, int law)
{
struct zt_gains g;
int res;
return ioctl(fd, ZT_SETGAINS, &g);
}
-int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
+static int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
{
return set_actual_txgain(fd, chan, txgain, law) | set_actual_rxgain(fd, chan, rxgain, law);
}
static int send_callerid(struct zt_pvt *p);
-int send_cwcidspill(struct zt_pvt *p)
+static int send_cwcidspill(struct zt_pvt *p)
{
p->callwaitcas = 0;
p->cidcwexpire = 0;
struct zt_pvt *p = ast->tech_pvt;
int x, res, index,mysig;
char *c, *n, *l;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
char *s=NULL;
#endif
char dest[256]; /* must be same length as p->dialdest */
ast_mutex_unlock(&p->lock);
return -1;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
/* Start the trunk, if not GR-303 */
if (!p->pri) {
#endif
return -1;
}
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
}
#endif
ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
ast_mutex_unlock(&p->lock);
return -1;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->pri) {
struct pri_sr *sr;
#ifdef SUPPORT_USERUSER
return 0;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static char *zap_send_keypad_facility_app = "ZapSendKeypadFacility";
static char *zap_send_keypad_facility_synopsis = "Send digits out of band over a PRI";
return 0;
}
-int pri_is_up(struct zt_pri *pri)
+static int pri_is_up(struct zt_pri *pri)
{
int x;
for (x=0;x<NUM_DCHANS;x++) {
return 0;
}
-int pri_assign_bearer(struct zt_pvt *crv, struct zt_pri *pri, struct zt_pvt *bearer)
+static int pri_assign_bearer(struct zt_pvt *crv, struct zt_pri *pri, struct zt_pvt *bearer)
{
bearer->owner = &inuse;
bearer->realcall = crv;
}
/* Returns fd of the active dchan */
-int pri_active_dchan_fd(struct zt_pri *pri)
+static int pri_active_dchan_fd(struct zt_pri *pri)
{
int x = -1;
return pri->fds[x];
}
-int pri_find_dchan(struct zt_pri *pri)
+static int pri_find_dchan(struct zt_pri *pri)
{
int oldslot = -1;
struct pri *old;
p->faxhandled = 0;
p->pulsedial = 0;
p->onhooktime = time(NULL);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
p->proceeding = 0;
p->progress = 0;
p->alerting = 0;
if (res < 0)
ast_log(LOG_WARNING, "Unable to set law on channel %d to default\n", p->channel);
/* Perform low level hangup if no owner left */
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->pri) {
#ifdef SUPPORT_USERUSER
const char *useruser = pbx_builtin_getvar_helper(ast,"USERUSERINFO");
}
}
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (p->sig == SIG_R2) {
if (p->hasr2call) {
mfcr2_DropCall(p->r2, NULL, UC_NORMAL_CLEARING);
x = 0;
ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->bearer) {
ast_log(LOG_DEBUG, "Freeing up bearer channel %d\n", p->bearer->channel);
/* Free up the bearer channel as well, and
zt_train_ec(p);
}
break;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
case SIG_PRI:
/* Send a pri acknowledge */
if (!pri_grab(p, p->pri)) {
}
break;
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
case SIG_R2:
res = mfcr2_AnswerCall(p->r2, NULL);
if (res)
return 0;
}
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
static struct ast_frame *handle_r2_event(struct zt_pvt *p, mfcr2_event_t *e, int index)
{
struct ast_frame *f;
else
p->pulsedial = 0;
ast_log(LOG_DEBUG, "Detected %sdigit '%c'\n", p->pulsedial ? "pulse ": "", res & 0xff);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!p->proceeding && p->sig == SIG_PRI && p->pri && p->pri->overlapdial) {
/* absorb event */
} else {
p->subs[index].f.subclass = res & 0xff;
dtmf_frame.subclass = res & 0xff;
p->subs[index].f.next = ast_frdup(&dtmf_frame);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
}
#endif
/* Unmute conference, return the captured digit */
#endif
case ZT_EVENT_BITSCHANGED:
if (p->sig == SIG_R2) {
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
struct ast_frame *f = &p->subs[index].f;
mfcr2_event_t *e;
e = r2_get_event_bits(p);
}
break;
case ZT_EVENT_ALARM:
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->call) {
if (p->pri && p->pri->pri) {
if (!pri_grab(p, p->pri)) {
break;
case ZT_EVENT_NOALARM:
p->inalarm = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
/* Extremely unlikely but just in case */
if (p->bearer)
p->bearer->inalarm = 0;
f = NULL;
}
} else if (f->frametype == AST_FRAME_DTMF) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!p->proceeding && p->sig==SIG_PRI && p->pri && p->pri->overlapdial) {
/* Don't accept in-band DTMF when in overlap dial mode */
f->frametype = AST_FRAME_NULL;
}
#if 0
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
ast_mutex_lock(&p->lock);
if (!p->proceeding && p->sig==SIG_PRI && p->pri && !p->outgoing) {
if (p->pri->pri) {
if (index == SUB_REAL) {
switch(condition) {
case AST_CONTROL_BUSY:
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->priindication_oob && p->sig == SIG_PRI) {
chan->hangupcause = AST_CAUSE_USER_BUSY;
chan->_softhangup |= AST_SOFTHANGUP_DEV;
res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_BUSY);
break;
case AST_CONTROL_RINGING:
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if ((!p->alerting) && p->sig==SIG_PRI && p->pri && !p->outgoing && (chan->_state != AST_STATE_UP)) {
if (p->pri->pri) {
if (!pri_grab(p, p->pri)) {
break;
case AST_CONTROL_PROCEEDING:
ast_log(LOG_DEBUG,"Received AST_CONTROL_PROCEEDING on %s\n",chan->name);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!p->proceeding && p->sig==SIG_PRI && p->pri && !p->outgoing) {
if (p->pri->pri) {
if (!pri_grab(p, p->pri)) {
break;
case AST_CONTROL_PROGRESS:
ast_log(LOG_DEBUG,"Received AST_CONTROL_PROGRESS on %s\n",chan->name);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
p->digital = 0; /* Digital-only calls isn't allows any inband progress messages */
if (!p->progress && p->sig==SIG_PRI && p->pri && !p->outgoing) {
if (p->pri->pri) {
break;
case AST_CONTROL_CONGESTION:
chan->hangupcause = AST_CAUSE_CONGESTION;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->priindication_oob && p->sig == SIG_PRI) {
chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
chan->_softhangup |= AST_SOFTHANGUP_DEV;
#endif
res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
break;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
case AST_CONTROL_HOLD:
if (p->pri) {
if (!pri_grab(p, p->pri)) {
}
y = 1;
do {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (i->bearer || (i->pri && (i->sig == SIG_FXSKS)))
ast_string_field_build(tmp, name, "Zap/%d:%d-%d", i->pri->trunkgroup, i->channel, y);
else
i->dsp = NULL;
if (i->dsp) {
i->dsp_features = features & ~DSP_PROGRESS_TALK;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
/* We cannot do progress detection until receives PROGRESS message */
if (i->outgoing && (i->sig == SIG_PRI)) {
/* Remember requested DSP features, don't treat
#endif
tmp->cid.cid_pres = i->callingpres;
tmp->cid.cid_ton = i->cid_ton;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
tmp->transfercapability = transfercapability;
pbx_builtin_setvar_helper(tmp, "TRANSFERCAPABILITY", ast_transfercapability2str(transfercapability));
if (transfercapability & PRI_TRANS_CAP_DIGITAL) {
if (p->dsp)
ast_dsp_digitreset(p->dsp);
switch(p->sig) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
case SIG_PRI:
/* Now loop looking for an extension */
ast_copy_string(exten, p->exten, sizeof(exten));
case SIG_FXSLS:
case SIG_FXSGS:
case SIG_FXSKS:
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->pri) {
/* This is a GR-303 trunk actually. Wait for the first ring... */
struct ast_frame *f;
return NULL;
}
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
static int handle_init_r2_event(struct zt_pvt *i, mfcr2_event_t *e)
{
struct ast_channel *chan;
case ZT_EVENT_NONE:
case ZT_EVENT_BITSCHANGED:
if (i->radio) break;
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (i->r2) {
mfcr2_event_t *e;
e = r2_get_event_bits(i);
pfds[count].events = POLLPRI;
pfds[count].revents = 0;
/* Message waiting or r2 channels also get watched for reading */
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (i->cidspill || i->r2)
#else
if (i->cidspill)
pollres = ast_fdisset(pfds, i->subs[SUB_REAL].zfd, count, &spoint);
if (pollres & POLLIN) {
if (i->owner || i->subs[SUB_REAL].owner) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!i->pri)
#endif
ast_log(LOG_WARNING, "Whoa.... I'm owned but found (%d) in read...\n", i->subs[SUB_REAL].zfd);
i = i->next;
continue;
}
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (i->r2) {
/* If it's R2 signalled, we always have to check for events */
mfcr2_event_t *e;
handle_init_event(i, res);
ast_mutex_lock(&iflock);
}
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if ((pollres & POLLPRI) || (i->r2 && !i->sigchecked))
#else
if (pollres & POLLPRI)
#endif
{
if (i->owner || i->subs[SUB_REAL].owner) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!i->pri)
#endif
ast_log(LOG_WARNING, "Whoa.... I'm owned but found (%d)...\n", i->subs[SUB_REAL].zfd);
return 0;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static int pri_resolve_span(int *span, int channel, int offset, struct zt_spaninfo *si)
{
int x;
wlist = &iflist;
wend = &ifend;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri) {
wlist = &pri->crvs;
wend = &pri->crvend;
return NULL;
}
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if ((signalling == SIG_PRI) || (signalling == SIG_GR303FXOKS) || (signalling == SIG_GR303FXSKS)) {
int offset;
int myswitchtype;
tmp->prioffset = 0;
}
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (signalling == SIG_R2) {
if (r2prot < 0) {
ast_log(LOG_WARNING, "R2 Country not specified for channel %d -- Assuming China\n", tmp->channel);
zt_set_hook(tmp->subs[SUB_REAL].zfd, ZT_ONHOOK);
}
ioctl(tmp->subs[SUB_REAL].zfd,ZT_SETTONEZONE,&tmp->tonezone);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
/* the dchannel is down so put the channel in alarm */
if (tmp->pri && !pri_is_up(tmp->pri))
tmp->inalarm = 1;
/* If no owner definitely available */
if (!p->owner) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
/* Trust PRI */
if (p->pri) {
if (p->resetting || p->call)
return 1;
}
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
/* Trust R2 as well */
if (p->r2) {
if (p->hasr2call || p->r2blocked)
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static int pri_find_empty_chan(struct zt_pri *pri, int backwards)
{
int x;
char opt=0;
int res=0, y=0;
int backwards = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int crv;
int bearer = -1;
int trunkgroup;
x = CHAN_PSEUDO;
channelmatch = x;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
else if ((res = sscanf(s, "%d:%d%c%d", &trunkgroup, &crv, &opt, &y)) > 1) {
if ((trunkgroup < 1) || (crv < 1)) {
ast_log(LOG_WARNING, "Unable to determine trunk group and CRV for data %s\n", (char *)data);
goto next;
callwait = (p->owner != NULL);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri && (p->subs[SUB_REAL].zfd < 0)) {
if (p->sig != SIG_FXSKS) {
/* Gotta find an actual channel to use for this
}
p->outgoing = 1;
tmp = zt_new(p, AST_STATE_RESERVED, 0, p->owner ? SUB_CALLWAIT : SUB_REAL, 0, 0);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (p->bearer) {
/* Log owner to bearer channel, too */
p->bearer->owner = tmp;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
static struct zt_pvt *pri_find_crv(struct zt_pri *pri, int crv)
{
struct zt_pvt *p;
ast_mutex_lock(&pri->lock);
return 0;
}
-char * redirectingreason2str(int redirectingreason)
+
+static char * redirectingreason2str(int redirectingreason)
{
switch (redirectingreason) {
case 0:
"Ends PRI debug output to file" },
};
-#endif /* ZAPATA_PRI */
+#endif /* HAVE_LIBPRI */
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
static int handle_r2_no_debug(int fd, int argc, char *argv[])
{
int chan;
char tmps[20] = "";
ast_mutex_t *lock;
struct zt_pvt *start;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int trunkgroup;
struct zt_pri *pri=NULL;
int x;
lock = &iflock;
start = iflist;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (argc == 4) {
if ((trunkgroup = atoi(argv[3])) < 1)
return RESULT_SHOWUSAGE;
return RESULT_SHOWUSAGE;
ast_mutex_lock(lock);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
ast_cli(fd, FORMAT2, pri ? "CRV" : "Chan", "Extension", "Context", "Language", "MusicOnHold");
#else
ast_cli(fd, FORMAT2, "Chan", "Extension", "Context", "Language", "MusicOnHold");
int x;
ast_mutex_t *lock;
struct zt_pvt *start;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
char *c;
int trunkgroup;
struct zt_pri *pri=NULL;
if (argc != 4)
return RESULT_SHOWUSAGE;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if ((c = strchr(argv[3], ':'))) {
if (sscanf(argv[3], "%d:%d", &trunkgroup, &channel) != 2)
return RESULT_SHOWUSAGE;
tmp = start;
while (tmp) {
if (tmp->channel == channel) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_cli(fd, "Trunk/CRV: %d/%d\n", trunkgroup, tmp->channel);
else
if (tmp->slaves[x])
ast_cli(fd, "Slave Channel: %d\n", tmp->slaves[x]->channel);
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (tmp->pri) {
ast_cli(fd, "PRI Flags: ");
if (tmp->resetting)
}
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
if (tmp->r2) {
ast_cli(fd, "R2 Flags: ");
if (tmp->r2blocked)
{
int x = 0;
struct zt_pvt *p, *pl;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int i;
for(i=0;i<NUM_SPANS;i++) {
if (pris[i].master != AST_PTHREADT_NULL)
ast_cli_unregister_multiple(zap_pri_cli, sizeof(zap_pri_cli) / sizeof(zap_pri_cli[0]));
ast_unregister_application(zap_send_keypad_facility_app);
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
ast_cli_unregister_multiple(zap_r2_cli, sizeof(zap_r2_cli) / sizeof(zap_r2_cli[0]));
#endif
ast_cli_unregister_multiple(zap_cli, sizeof(zap_cli) / sizeof(zap_cli[0]));
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
for(i=0;i<NUM_SPANS;i++) {
if (pris[i].master && (pris[i].master != AST_PTHREADT_NULL))
pthread_join(pris[i].master, NULL);
static int unload_module(void *mod)
{
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int y;
for (y=0;y<NUM_SPANS;y++)
ast_mutex_destroy(&pris[y].lock);
int y;
int found_pseudo = 0;
int cur_radio = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int spanno;
int i;
int logicalspan;
ast_log(LOG_ERROR, "Unable to lock interface list???\n");
return -1;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!reload) {
/* Process trunkgroups first */
v = ast_variable_browse(cfg, "trunkgroups");
while(v) {
/* Create the interface list */
if (!strcasecmp(v->name, "channel")
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
|| !strcasecmp(v->name, "crv")
#endif
) {
}
c = v->value;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
pri = NULL;
if (!strcasecmp(v->name, "crv")) {
if (sscanf(c, "%d:%n", &trunkgroup, &y) != 1) {
}
if (cur_outsignalling < 0) cur_outsignalling = cur_signalling;
for (x=start;x<=finish;x++) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
tmp = mkintf(x, cur_signalling, cur_outsignalling, cur_radio, pri, reload);
#else
tmp = mkintf(x, cur_signalling, cur_outsignalling, cur_radio, NULL, reload);
if (tmp) {
if (option_verbose > 2) {
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (pri)
ast_verbose(VERBOSE_PREFIX_3 "%s CRV %d:%d, %s signalling\n", reload ? "Reconfigured" : "Registered", trunkgroup,x, sig2str(tmp->sig));
else
} else if (!strcasecmp(v->value, "featb")) {
cur_signalling = SIG_FEATB;
cur_radio = 0;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
} else if (!strcasecmp(v->value, "pri_net")) {
cur_radio = 0;
cur_signalling = SIG_PRI;
cur_radio = 0;
pritype = PRI_CPE;
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
} else if (!strcasecmp(v->value, "r2")) {
cur_signalling = SIG_R2;
cur_radio = 0;
} else {
ast_log(LOG_ERROR, "Unknown signalling method '%s'\n", v->value);
}
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
} else if (!strcasecmp(v->name, "r2country")) {
r2prot = str2r2prot(v->value);
if (r2prot < 0) {
ast_log(LOG_WARNING, "Unknown R2 Country '%s' at line %d.\n", v->value, v->lineno);
}
#endif
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
} else if (!strcasecmp(v->name, "pridialplan")) {
if (!strcasecmp(v->value, "national")) {
dialplan = PRI_NATIONAL_ISDN + 1;
} else if (!strcasecmp(v->name, "facilityenable")) {
facilityenable = ast_true(v->value);
#endif /* PRI_GETSET_TIMERS */
-#endif /* ZAPATA_PRI */
+#endif /* HAVE_LIBPRI */
} else if (!strcasecmp(v->name, "cadence")) {
/* setup to scan our argument */
int element_count, c[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
}
ast_mutex_unlock(&iflock);
ast_config_destroy(cfg);
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
if (!reload) {
for (x=0;x<NUM_SPANS;x++) {
if (pris[x].pvts[0]) {
{
int res;
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
int y,i;
memset(pris, 0, sizeof(pris));
for (y=0;y<NUM_SPANS;y++) {
__unload_module();
return -1;
}
-#ifdef ZAPATA_PRI
+#ifdef HAVE_LIBPRI
ast_string_field_init(&inuse, 16);
ast_string_field_set(&inuse, name, "GR-303InUse");
ast_cli_register_multiple(zap_pri_cli, sizeof(zap_pri_cli) / sizeof(zap_pri_cli[0]));
#endif
-#ifdef ZAPATA_R2
+#ifdef HAVE_MFCR2
ast_cli_register_multiple(zap_r2_cli, sizeof(zap_r2_cli) / sizeof(zap_r2_cli[0]));
#endif
ast_cli_register_multiple(zap_cli, sizeof(zap_cli) / sizeof(zap_cli[0]));
{
return ASTERISK_GPL_KEY;
}
+
STD_MOD(MOD_1, reload, NULL, NULL);
+
+
# Verify those options with main Makefile
STDCCFLAGS += -DNDEBUG
STDCCFLAGS += $(shell grep ^DEBUG_THREADS ../../Makefile | sed -e "s/^DEBUG_THREADS[ ]*=//" -e "s/\([^\#]*\)\#.*/\1/")
-STDCCFLAGS += -I../../include
+STDCCFLAGS += -I../../include -include autoconfig.h
STDCCFLAGS += -Wmissing-prototypes
STDCCFLAGS += -fPIC
#OPTCCFLAGS +=
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard codec_*.c))
-
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -lasterisk.dll
-else
- CFLAGS+=-fPIC
-endif
+MODS:=$(filter-out $(MENUSELECT_CODECS),$(patsubst %.c,%.so,$(wildcard codec_*.c)))
ifeq ($(wildcard g723.1/coder.c),)
MODS:=$(filter-out codec_g723_1.so,$(MODS))
LIBG723B=g723.1b/libg723b.a
endif
-SPEEX_PATH:=/usr/local/include /usr/include /usr/include/speex /usr/local/include/speex
-SPEEX_SYSTEM_HEADERS:=$(firstword $(wildcard $(SPEEX_PATH:%=$(CROSS_COMPILE_TARGET)%/speex.h)))
-ifeq (${SPEEX_SYSTEM_HEADERS},)
- MODS:=$(filter-out codec_speex.so,$(MODS))
-else
- CFLAGS+=-I$(subst /speex.h,,${SPEEX_SYSTEM_HEADERS})
- LIBSPEEX=-lspeex -lm
-endif
-
ifeq ($(wildcard ilbc/iLBC_decode.h),)
MODS:=$(filter-out codec_ilbc.so,$(MODS))
else
LIBILBC=ilbc/libilbc.a
endif
-LIBGSM_PATH:=/usr/local/include /usr/include
-LIBGSM_SYSTEM_HEADERS:=$(firstword $(wildcard $(LIBGSM_PATH:%=$(CROSS_COMPILE_TARGET)%/gsm/gsm.h)))
-ifneq ($(LIBGSM_SYSTEM_HEADERS),)
- LIBGSM=-lgsm
- LIBGSMT=
- CFLAGS+=-DUSE_EXTERNAL_GSM_LIB
-else
- LIBGSM=gsm/lib/libgsm.a
- LIBGSMT=$(LIBGSM)
- CFLAGS+=-I.
-endif
-
LIBLPC10=lpc10/liblpc10.a
all: depend $(MODS)
$(MAKE) -C ilbc clean
$(LIBG723):
- $(MAKE) -C g723.1 all
+ CFLAGS="$(ASTCFLAGS)" $(MAKE) -C g723.1 all
-$(LIBGSM):
- $(MAKE) -C gsm lib/libgsm.a
+gsm/lib/libgsm.a:
+ CFLAGS="$(ASTCFLAGS) -I." $(MAKE) -C gsm lib/libgsm.a
$(LIBG723B):
- $(MAKE) -C g723.1b all
+ CFLAGS="$(ASTCFLAGS)" $(MAKE) -C g723.1b all
$(LIBLPC10):
- $(MAKE) -C lpc10 all
+ CFLAGS="$(ASTCFLAGS)" $(MAKE) -C lpc10 all
$(LIBILBC):
- $(MAKE) -C ilbc all
+ CFLAGS="$(ASTCFLAGS)" $(MAKE) -C ilbc all
codec_ilbc.so: codec_ilbc.o $(LIBILBC)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBILBC)
+ $(CC) $(SOLINK) -o $@ $< $(LIBILBC)
codec_g723_1.so : codec_g723_1.o $(LIBG723)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBG723)
+ $(CC) $(SOLINK) -o $@ $< $(LIBG723)
codec_g723_1b.o : codec_g723_1.c
$(CC) -c -o $@ $(CFLAGS) -DANNEX_B -Dsingle $<
codec_g723_1b.so : codec_g723_1b.o $(LIBG723B)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBG723B) -lm
+ $(CC) $(SOLINK) -o $@ $< $(LIBG723B) -lm
+
+ifeq ($(GSM_LIB),internal)
+codec_gsm.o: codec_gsm.c
+ $(CC) -c -o $@ $(CFLAGS) -Igsm/inc $<
+
+codec_gsm.so: codec_gsm.o gsm/lib/libgsm.a
+ $(CC) $(SOLINK) -o $@ $< gsm/lib/libgsm.a
+else
+codec_gsm.o: codec_gsm.c
+ $(CC) -c -o $@ $(CFLAGS) $(GSM_INCLUDE) $<
+
+codec_gsm.so: codec_gsm.o
+ $(CC) $(SOLINK) -o $@ $< $(GSM_LIB)
+endif
-codec_gsm.so: codec_gsm.o $(LIBGSMT)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBGSM)
+codec_speex.o: codec_speex.c
+ $(CC) -c -o $@ $(CFLAGS) $(SPEEX_INCLUDE) $<
codec_speex.so: codec_speex.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBSPEEX)
+ $(CC) $(SOLINK) -o $@ $< $(SPEEX_LIB)
codec_lpc10.so: codec_lpc10.o $(LIBLPC10)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(LIBLPC10) -lm
+ $(CC) $(SOLINK) -o $@ $< $(LIBLPC10) -lm
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+ $(CC) $(SOLINK) -o $@ $<
ifneq ($(wildcard .depend),)
include .depend
* \ingroup codecs
*/
+/*** MODULEINFO
+ <depend>libgsm</depend>
+ ***/
+
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include "asterisk/channel.h"
#include "asterisk/utils.h"
-#ifdef USE_EXTERNAL_GSM_LIB
-#include <gsm/gsm.h>
-#else
-#include "gsm/inc/gsm.h"
-#endif
+#include "gsm.h"
#include "../formats/msgsm.h"
* \ingroup codecs
*/
+/*** MODULEINFO
+ <depend>libspeex</depend>
+ ***/
+
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
-#include <speex.h>
+#include <speex/speex.h>
/* We require a post 1.1.8 version of Speex to enable preprocessing
and better type handling */
}
STD_MOD(MOD_1, reload, NULL, NULL);
+
CC ?= gcc
CCFLAGS += -c -DNeedFunctionPrototypes=1 -funroll-loops $(OPTIMIZE)
-ifneq ($(findstring CYGWIN,${OSARCH}),CYGWIN)
CCFLAGS += -fPIC
-endif
-
LD = $(CC)
ARCH=$(PROC)
CFLAGS+=-Wall -O3 -funroll-loops
-ifneq (${OSARCH},CYGWIN)
CFLAGS += -fPIC
-endif
LIB=libilbc.a
OBJS= anaFilter.o iCBSearch.o packing.o \
WARNINGS = -Wall -Wno-comment -Wno-error
CFLAGS += $(OPTIMIZE) -I$(LIB_TARGET_DIR) $(WARNINGS)
-ifneq (${OSARCH},CYGWIN)
CFLAGS += -fPIC
-endif
#CFLAGS+= $(shell if uname -m | grep -q 86; then echo "-mpentium" ; fi)
#fix for PPC processors and ALPHA, And UltraSparc too
--- /dev/null
+#! /bin/sh
+# Attempt to guess a canonical system name.
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+# Inc.
+
+timestamp='2006-03-13'
+
+# This file 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 of the License, or
+# (at your option) any later version.
+#
+# This program 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 this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Originally written by Per Bothner <per@bothner.com>.
+# Please send patches to <config-patches@gnu.org>. Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# This script attempts to guess a canonical system name similar to
+# config.sub. If it succeeds, it prints the system name on stdout, and
+# exits with 0. Otherwise, it exits with 1.
+#
+# The plan is that this can be called by configure scripts if you
+# don't specify an explicit build system type.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION]
+
+Output the configuration name of the system \`$me' is run on.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit ;;
+ --version | -v )
+ echo "$version" ; exit ;;
+ --help | --h* | -h )
+ echo "$usage"; exit ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help" >&2
+ exit 1 ;;
+ * )
+ break ;;
+ esac
+done
+
+if test $# != 0; then
+ echo "$me: too many arguments$help" >&2
+ exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,) echo "int x;" > $dummy.c ;
+ for c in cc gcc c89 c99 ; do
+ if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+ CC_FOR_BUILD="$c"; break ;
+ fi ;
+ done ;
+ if test x"$CC_FOR_BUILD" = x ; then
+ CC_FOR_BUILD=no_compiler_found ;
+ fi
+ ;;
+ ,,*) CC_FOR_BUILD=$CC ;;
+ ,*,*) CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+ PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+ *:NetBSD:*:*)
+ # NetBSD (nbsd) targets should (where applicable) match one or
+ # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
+ # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
+ # switched to ELF, *-*-netbsd* would select the old
+ # object file format. This provides both forward
+ # compatibility and a consistent mechanism for selecting the
+ # object file format.
+ #
+ # Note: NetBSD doesn't particularly care about the vendor
+ # portion of the name. We always set it to "unknown".
+ sysctl="sysctl -n hw.machine_arch"
+ UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
+ /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
+ case "${UNAME_MACHINE_ARCH}" in
+ armeb) machine=armeb-unknown ;;
+ arm*) machine=arm-unknown ;;
+ sh3el) machine=shl-unknown ;;
+ sh3eb) machine=sh-unknown ;;
+ *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+ esac
+ # The Operating System including object format, if it has switched
+ # to ELF recently, or will in the future.
+ case "${UNAME_MACHINE_ARCH}" in
+ arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+ eval $set_cc_for_build
+ if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+ | grep __ELF__ >/dev/null
+ then
+ # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+ # Return netbsd for either. FIX?
+ os=netbsd
+ else
+ os=netbsdelf
+ fi
+ ;;
+ *)
+ os=netbsd
+ ;;
+ esac
+ # The OS release
+ # Debian GNU/NetBSD machines have a different userland, and
+ # thus, need a distinct triplet. However, they do not need
+ # kernel version information, so it can be replaced with a
+ # suitable tag, in the style of linux-gnu.
+ case "${UNAME_VERSION}" in
+ Debian*)
+ release='-gnu'
+ ;;
+ *)
+ release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
+ ;;
+ esac
+ # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+ # contains redundant information, the shorter form:
+ # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+ echo "${machine}-${os}${release}"
+ exit ;;
+ *:OpenBSD:*:*)
+ UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+ echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+ exit ;;
+ *:ekkoBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+ exit ;;
+ *:SolidBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+ exit ;;
+ macppc:MirBSD:*:*)
+ echo powerppc-unknown-mirbsd${UNAME_RELEASE}
+ exit ;;
+ *:MirBSD:*:*)
+ echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+ exit ;;
+ alpha:OSF1:*:*)
+ case $UNAME_RELEASE in
+ *4.0)
+ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+ ;;
+ *5.*)
+ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+ ;;
+ esac
+ # According to Compaq, /usr/sbin/psrinfo has been available on
+ # OSF/1 and Tru64 systems produced since 1995. I hope that
+ # covers most systems running today. This code pipes the CPU
+ # types through head -n 1, so we only detect the type of CPU 0.
+ ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
+ case "$ALPHA_CPU_TYPE" in
+ "EV4 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "EV4.5 (21064)")
+ UNAME_MACHINE="alpha" ;;
+ "LCA4 (21066/21068)")
+ UNAME_MACHINE="alpha" ;;
+ "EV5 (21164)")
+ UNAME_MACHINE="alphaev5" ;;
+ "EV5.6 (21164A)")
+ UNAME_MACHINE="alphaev56" ;;
+ "EV5.6 (21164PC)")
+ UNAME_MACHINE="alphapca56" ;;
+ "EV5.7 (21164PC)")
+ UNAME_MACHINE="alphapca57" ;;
+ "EV6 (21264)")
+ UNAME_MACHINE="alphaev6" ;;
+ "EV6.7 (21264A)")
+ UNAME_MACHINE="alphaev67" ;;
+ "EV6.8CB (21264C)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8AL (21264B)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.8CX (21264D)")
+ UNAME_MACHINE="alphaev68" ;;
+ "EV6.9A (21264/EV69A)")
+ UNAME_MACHINE="alphaev69" ;;
+ "EV7 (21364)")
+ UNAME_MACHINE="alphaev7" ;;
+ "EV7.9 (21364A)")
+ UNAME_MACHINE="alphaev79" ;;
+ esac
+ # A Pn.n version is a patched version.
+ # A Vn.n version is a released version.
+ # A Tn.n version is a released field test version.
+ # A Xn.n version is an unreleased experimental baselevel.
+ # 1.2 uses "1.2" for uname -r.
+ echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ exit ;;
+ Alpha\ *:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # Should we change UNAME_MACHINE based on the output of uname instead
+ # of the specific Alpha model?
+ echo alpha-pc-interix
+ exit ;;
+ 21064:Windows_NT:50:3)
+ echo alpha-dec-winnt3.5
+ exit ;;
+ Amiga*:UNIX_System_V:4.0:*)
+ echo m68k-unknown-sysv4
+ exit ;;
+ *:[Aa]miga[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-amigaos
+ exit ;;
+ *:[Mm]orph[Oo][Ss]:*:*)
+ echo ${UNAME_MACHINE}-unknown-morphos
+ exit ;;
+ *:OS/390:*:*)
+ echo i370-ibm-openedition
+ exit ;;
+ *:z/VM:*:*)
+ echo s390-ibm-zvmoe
+ exit ;;
+ *:OS400:*:*)
+ echo powerpc-ibm-os400
+ exit ;;
+ arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
+ echo arm-acorn-riscix${UNAME_RELEASE}
+ exit ;;
+ arm:riscos:*:*|arm:RISCOS:*:*)
+ echo arm-unknown-riscos
+ exit ;;
+ SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+ echo hppa1.1-hitachi-hiuxmpp
+ exit ;;
+ Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+ # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+ if test "`(/bin/universe) 2>/dev/null`" = att ; then
+ echo pyramid-pyramid-sysv3
+ else
+ echo pyramid-pyramid-bsd
+ fi
+ exit ;;
+ NILE*:*:*:dcosx)
+ echo pyramid-pyramid-svr4
+ exit ;;
+ DRS?6000:unix:4.0:6*)
+ echo sparc-icl-nx6
+ exit ;;
+ DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+ case `/usr/bin/uname -p` in
+ sparc) echo sparc-icl-nx7; exit ;;
+ esac ;;
+ sun4H:SunOS:5.*:*)
+ echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+ echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ i86pc:SunOS:5.*:*)
+ echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:6*:*)
+ # According to config.sub, this is the proper way to canonicalize
+ # SunOS6. Hard to guess exactly what SunOS6 will be like, but
+ # it's likely to be more like Solaris than SunOS4.
+ echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ sun4*:SunOS:*:*)
+ case "`/usr/bin/arch -k`" in
+ Series*|S4*)
+ UNAME_RELEASE=`uname -v`
+ ;;
+ esac
+ # Japanese Language versions have a version number like `4.1.3-JL'.
+ echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+ exit ;;
+ sun3*:SunOS:*:*)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ exit ;;
+ sun*:*:4.2BSD:*)
+ UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+ test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+ case "`/bin/arch`" in
+ sun3)
+ echo m68k-sun-sunos${UNAME_RELEASE}
+ ;;
+ sun4)
+ echo sparc-sun-sunos${UNAME_RELEASE}
+ ;;
+ esac
+ exit ;;
+ aushp:SunOS:*:*)
+ echo sparc-auspex-sunos${UNAME_RELEASE}
+ exit ;;
+ # The situation for MiNT is a little confusing. The machine name
+ # can be virtually everything (everything which is not
+ # "atarist" or "atariste" at least should have a processor
+ # > m68000). The system name ranges from "MiNT" over "FreeMiNT"
+ # to the lowercase version "mint" (or "freemint"). Finally
+ # the system name "TOS" denotes a system which is actually not
+ # MiNT. But MiNT is downward compatible to TOS, so this should
+ # be no problem.
+ atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+ echo m68k-atari-mint${UNAME_RELEASE}
+ exit ;;
+ milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+ echo m68k-milan-mint${UNAME_RELEASE}
+ exit ;;
+ hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+ echo m68k-hades-mint${UNAME_RELEASE}
+ exit ;;
+ *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+ echo m68k-unknown-mint${UNAME_RELEASE}
+ exit ;;
+ m68k:machten:*:*)
+ echo m68k-apple-machten${UNAME_RELEASE}
+ exit ;;
+ powerpc:machten:*:*)
+ echo powerpc-apple-machten${UNAME_RELEASE}
+ exit ;;
+ RISC*:Mach:*:*)
+ echo mips-dec-mach_bsd4.3
+ exit ;;
+ RISC*:ULTRIX:*:*)
+ echo mips-dec-ultrix${UNAME_RELEASE}
+ exit ;;
+ VAX*:ULTRIX*:*:*)
+ echo vax-dec-ultrix${UNAME_RELEASE}
+ exit ;;
+ 2020:CLIX:*:* | 2430:CLIX:*:*)
+ echo clipper-intergraph-clix${UNAME_RELEASE}
+ exit ;;
+ mips:*:*:UMIPS | mips:*:*:RISCos)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+#ifdef __cplusplus
+#include <stdio.h> /* for printf() prototype */
+ int main (int argc, char *argv[]) {
+#else
+ int main (argc, argv) int argc; char *argv[]; {
+#endif
+ #if defined (host_mips) && defined (MIPSEB)
+ #if defined (SYSTYPE_SYSV)
+ printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
+ #endif
+ #if defined (SYSTYPE_SVR4)
+ printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
+ #endif
+ #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+ printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
+ #endif
+ #endif
+ exit (-1);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c &&
+ dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
+ SYSTEM_NAME=`$dummy $dummyarg` &&
+ { echo "$SYSTEM_NAME"; exit; }
+ echo mips-mips-riscos${UNAME_RELEASE}
+ exit ;;
+ Motorola:PowerMAX_OS:*:*)
+ echo powerpc-motorola-powermax
+ exit ;;
+ Motorola:*:4.3:PL8-*)
+ echo powerpc-harris-powermax
+ exit ;;
+ Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+ echo powerpc-harris-powermax
+ exit ;;
+ Night_Hawk:Power_UNIX:*:*)
+ echo powerpc-harris-powerunix
+ exit ;;
+ m88k:CX/UX:7*:*)
+ echo m88k-harris-cxux7
+ exit ;;
+ m88k:*:4*:R4*)
+ echo m88k-motorola-sysv4
+ exit ;;
+ m88k:*:3*:R3*)
+ echo m88k-motorola-sysv3
+ exit ;;
+ AViiON:dgux:*:*)
+ # DG/UX returns AViiON for all architectures
+ UNAME_PROCESSOR=`/usr/bin/uname -p`
+ if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
+ then
+ if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
+ [ ${TARGET_BINARY_INTERFACE}x = x ]
+ then
+ echo m88k-dg-dgux${UNAME_RELEASE}
+ else
+ echo m88k-dg-dguxbcs${UNAME_RELEASE}
+ fi
+ else
+ echo i586-dg-dgux${UNAME_RELEASE}
+ fi
+ exit ;;
+ M88*:DolphinOS:*:*) # DolphinOS (SVR3)
+ echo m88k-dolphin-sysv3
+ exit ;;
+ M88*:*:R3*:*)
+ # Delta 88k system running SVR3
+ echo m88k-motorola-sysv3
+ exit ;;
+ XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+ echo m88k-tektronix-sysv3
+ exit ;;
+ Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+ echo m68k-tektronix-bsd
+ exit ;;
+ *:IRIX*:*:*)
+ echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+ exit ;;
+ ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+ echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id
+ exit ;; # Note that: echo "'`uname -s`'" gives 'AIX '
+ i*86:AIX:*:*)
+ echo i386-ibm-aix
+ exit ;;
+ ia64:AIX:*:*)
+ if [ -x /usr/bin/oslevel ] ; then
+ IBM_REV=`/usr/bin/oslevel`
+ else
+ IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+ fi
+ echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+ exit ;;
+ *:AIX:2:3)
+ if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include <sys/systemcfg.h>
+
+ main()
+ {
+ if (!__power_pc())
+ exit(1);
+ puts("powerpc-ibm-aix3.2.5");
+ exit(0);
+ }
+EOF
+ if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+ then
+ echo "$SYSTEM_NAME"
+ else
+ echo rs6000-ibm-aix3.2.5
+ fi
+ elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+ echo rs6000-ibm-aix3.2.4
+ else
+ echo rs6000-ibm-aix3.2
+ fi
+ exit ;;
+ *:AIX:*:[45])
+ IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+ if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+ IBM_ARCH=rs6000
+ else
+ IBM_ARCH=powerpc
+ fi
+ if [ -x /usr/bin/oslevel ] ; then
+ IBM_REV=`/usr/bin/oslevel`
+ else
+ IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+ fi
+ echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+ exit ;;
+ *:AIX:*:*)
+ echo rs6000-ibm-aix
+ exit ;;
+ ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+ echo romp-ibm-bsd4.4
+ exit ;;
+ ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
+ echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
+ exit ;; # report: romp-ibm BSD 4.3
+ *:BOSX:*:*)
+ echo rs6000-bull-bosx
+ exit ;;
+ DPX/2?00:B.O.S.:*:*)
+ echo m68k-bull-sysv3
+ exit ;;
+ 9000/[34]??:4.3bsd:1.*:*)
+ echo m68k-hp-bsd
+ exit ;;
+ hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
+ echo m68k-hp-bsd4.4
+ exit ;;
+ 9000/[34678]??:HP-UX:*:*)
+ HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+ case "${UNAME_MACHINE}" in
+ 9000/31? ) HP_ARCH=m68000 ;;
+ 9000/[34]?? ) HP_ARCH=m68k ;;
+ 9000/[678][0-9][0-9])
+ if [ -x /usr/bin/getconf ]; then
+ sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+ sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+ case "${sc_cpu_version}" in
+ 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
+ 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+ 532) # CPU_PA_RISC2_0
+ case "${sc_kernel_bits}" in
+ 32) HP_ARCH="hppa2.0n" ;;
+ 64) HP_ARCH="hppa2.0w" ;;
+ '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
+ esac ;;
+ esac
+ fi
+ if [ "${HP_ARCH}" = "" ]; then
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+
+ #define _HPUX_SOURCE
+ #include <stdlib.h>
+ #include <unistd.h>
+
+ int main ()
+ {
+ #if defined(_SC_KERNEL_BITS)
+ long bits = sysconf(_SC_KERNEL_BITS);
+ #endif
+ long cpu = sysconf (_SC_CPU_VERSION);
+
+ switch (cpu)
+ {
+ case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+ case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+ case CPU_PA_RISC2_0:
+ #if defined(_SC_KERNEL_BITS)
+ switch (bits)
+ {
+ case 64: puts ("hppa2.0w"); break;
+ case 32: puts ("hppa2.0n"); break;
+ default: puts ("hppa2.0"); break;
+ } break;
+ #else /* !defined(_SC_KERNEL_BITS) */
+ puts ("hppa2.0"); break;
+ #endif
+ default: puts ("hppa1.0"); break;
+ }
+ exit (0);
+ }
+EOF
+ (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+ test -z "$HP_ARCH" && HP_ARCH=hppa
+ fi ;;
+ esac
+ if [ ${HP_ARCH} = "hppa2.0w" ]
+ then
+ eval $set_cc_for_build
+
+ # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+ # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler
+ # generating 64-bit code. GNU and HP use different nomenclature:
+ #
+ # $ CC_FOR_BUILD=cc ./config.guess
+ # => hppa2.0w-hp-hpux11.23
+ # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+ # => hppa64-hp-hpux11.23
+
+ if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+ grep __LP64__ >/dev/null
+ then
+ HP_ARCH="hppa2.0w"
+ else
+ HP_ARCH="hppa64"
+ fi
+ fi
+ echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+ exit ;;
+ ia64:HP-UX:*:*)
+ HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
+ echo ia64-hp-hpux${HPUX_REV}
+ exit ;;
+ 3050*:HI-UX:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include <unistd.h>
+ int
+ main ()
+ {
+ long cpu = sysconf (_SC_CPU_VERSION);
+ /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+ true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
+ results, however. */
+ if (CPU_IS_PA_RISC (cpu))
+ {
+ switch (cpu)
+ {
+ case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+ case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+ default: puts ("hppa-hitachi-hiuxwe2"); break;
+ }
+ }
+ else if (CPU_IS_HP_MC68K (cpu))
+ puts ("m68k-hitachi-hiuxwe2");
+ else puts ("unknown-hitachi-hiuxwe2");
+ exit (0);
+ }
+EOF
+ $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+ { echo "$SYSTEM_NAME"; exit; }
+ echo unknown-hitachi-hiuxwe2
+ exit ;;
+ 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
+ echo hppa1.1-hp-bsd
+ exit ;;
+ 9000/8??:4.3bsd:*:*)
+ echo hppa1.0-hp-bsd
+ exit ;;
+ *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+ echo hppa1.0-hp-mpeix
+ exit ;;
+ hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
+ echo hppa1.1-hp-osf
+ exit ;;
+ hp8??:OSF1:*:*)
+ echo hppa1.0-hp-osf
+ exit ;;
+ i*86:OSF1:*:*)
+ if [ -x /usr/sbin/sysversion ] ; then
+ echo ${UNAME_MACHINE}-unknown-osf1mk
+ else
+ echo ${UNAME_MACHINE}-unknown-osf1
+ fi
+ exit ;;
+ parisc*:Lites*:*:*)
+ echo hppa1.1-hp-lites
+ exit ;;
+ C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+ echo c1-convex-bsd
+ exit ;;
+ C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit ;;
+ C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+ echo c34-convex-bsd
+ exit ;;
+ C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+ echo c38-convex-bsd
+ exit ;;
+ C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+ echo c4-convex-bsd
+ exit ;;
+ CRAY*Y-MP:*:*:*)
+ echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*[A-Z]90:*:*:*)
+ echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
+ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+ -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*TS:*:*:*)
+ echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*T3E:*:*:*)
+ echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ CRAY*SV1:*:*:*)
+ echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ *:UNICOS/mp:*:*)
+ echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
+ exit ;;
+ F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+ FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+ FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+ FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+ echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+ exit ;;
+ 5000:UNIX_System_V:4.*:*)
+ FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
+ FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+ echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+ exit ;;
+ i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+ echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+ exit ;;
+ sparc*:BSD/OS:*:*)
+ echo sparc-unknown-bsdi${UNAME_RELEASE}
+ exit ;;
+ *:BSD/OS:*:*)
+ echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+ exit ;;
+ *:FreeBSD:*:*)
+ case ${UNAME_MACHINE} in
+ pc98)
+ echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+ *)
+ echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
+ esac
+ exit ;;
+ i*:CYGWIN*:*)
+ echo ${UNAME_MACHINE}-pc-cygwin
+ exit ;;
+ i*:MINGW*:*)
+ echo ${UNAME_MACHINE}-pc-mingw32
+ exit ;;
+ i*:windows32*:*)
+ # uname -m includes "-pc" on this system.
+ echo ${UNAME_MACHINE}-mingw32
+ exit ;;
+ i*:PW*:*)
+ echo ${UNAME_MACHINE}-pc-pw32
+ exit ;;
+ x86:Interix*:[345]*)
+ echo i586-pc-interix${UNAME_RELEASE}
+ exit ;;
+ EM64T:Interix*:[345]*)
+ echo x86_64-unknown-interix${UNAME_RELEASE}
+ exit ;;
+ [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
+ echo i${UNAME_MACHINE}-pc-mks
+ exit ;;
+ i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
+ # How do we know it's Interix rather than the generic POSIX subsystem?
+ # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
+ # UNAME_MACHINE based on the output of uname instead of i386?
+ echo i586-pc-interix
+ exit ;;
+ i*:UWIN*:*)
+ echo ${UNAME_MACHINE}-pc-uwin
+ exit ;;
+ amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+ echo x86_64-unknown-cygwin
+ exit ;;
+ p*:CYGWIN*:*)
+ echo powerpcle-unknown-cygwin
+ exit ;;
+ prep*:SunOS:5.*:*)
+ echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
+ exit ;;
+ *:GNU:*:*)
+ # the GNU system
+ echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+ exit ;;
+ *:GNU/*:*:*)
+ # other systems with GNU libc and userland
+ echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
+ exit ;;
+ i*86:Minix:*:*)
+ echo ${UNAME_MACHINE}-pc-minix
+ exit ;;
+ arm*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ cris:Linux:*:*)
+ echo cris-axis-linux-gnu
+ exit ;;
+ crisv32:Linux:*:*)
+ echo crisv32-axis-linux-gnu
+ exit ;;
+ frv:Linux:*:*)
+ echo frv-unknown-linux-gnu
+ exit ;;
+ ia64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ m32r*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ m68*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ mips:Linux:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #undef CPU
+ #undef mips
+ #undef mipsel
+ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+ CPU=mipsel
+ #else
+ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+ CPU=mips
+ #else
+ CPU=
+ #endif
+ #endif
+EOF
+ eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+ /^CPU/{
+ s: ::g
+ p
+ }'`"
+ test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+ ;;
+ mips64:Linux:*:*)
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #undef CPU
+ #undef mips64
+ #undef mips64el
+ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+ CPU=mips64el
+ #else
+ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+ CPU=mips64
+ #else
+ CPU=
+ #endif
+ #endif
+EOF
+ eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+ /^CPU/{
+ s: ::g
+ p
+ }'`"
+ test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
+ ;;
+ or32:Linux:*:*)
+ echo or32-unknown-linux-gnu
+ exit ;;
+ ppc:Linux:*:*)
+ echo powerpc-unknown-linux-gnu
+ exit ;;
+ ppc64:Linux:*:*)
+ echo powerpc64-unknown-linux-gnu
+ exit ;;
+ alpha:Linux:*:*)
+ case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
+ EV5) UNAME_MACHINE=alphaev5 ;;
+ EV56) UNAME_MACHINE=alphaev56 ;;
+ PCA56) UNAME_MACHINE=alphapca56 ;;
+ PCA57) UNAME_MACHINE=alphapca56 ;;
+ EV6) UNAME_MACHINE=alphaev6 ;;
+ EV67) UNAME_MACHINE=alphaev67 ;;
+ EV68*) UNAME_MACHINE=alphaev68 ;;
+ esac
+ objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
+ if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
+ echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
+ exit ;;
+ parisc:Linux:*:* | hppa:Linux:*:*)
+ # Look for CPU level
+ case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+ PA7*) echo hppa1.1-unknown-linux-gnu ;;
+ PA8*) echo hppa2.0-unknown-linux-gnu ;;
+ *) echo hppa-unknown-linux-gnu ;;
+ esac
+ exit ;;
+ parisc64:Linux:*:* | hppa64:Linux:*:*)
+ echo hppa64-unknown-linux-gnu
+ exit ;;
+ s390:Linux:*:* | s390x:Linux:*:*)
+ echo ${UNAME_MACHINE}-ibm-linux
+ exit ;;
+ sh64*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ sh*:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ sparc:Linux:*:* | sparc64:Linux:*:*)
+ echo ${UNAME_MACHINE}-unknown-linux-gnu
+ exit ;;
+ vax:Linux:*:*)
+ echo ${UNAME_MACHINE}-dec-linux-gnu
+ exit ;;
+ x86_64:Linux:*:*)
+ echo x86_64-unknown-linux-gnu
+ exit ;;
+ i*86:Linux:*:*)
+ # The BFD linker knows what the default object file format is, so
+ # first see if it will tell us. cd to the root directory to prevent
+ # problems with other programs or directories called `ld' in the path.
+ # Set LC_ALL=C to ensure ld outputs messages in English.
+ ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
+ | sed -ne '/supported targets:/!d
+ s/[ ][ ]*/ /g
+ s/.*supported targets: *//
+ s/ .*//
+ p'`
+ case "$ld_supported_targets" in
+ elf32-i386)
+ TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
+ ;;
+ a.out-i386-linux)
+ echo "${UNAME_MACHINE}-pc-linux-gnuaout"
+ exit ;;
+ coff-i386)
+ echo "${UNAME_MACHINE}-pc-linux-gnucoff"
+ exit ;;
+ "")
+ # Either a pre-BFD a.out linker (linux-gnuoldld) or
+ # one that does not give us useful --help.
+ echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
+ exit ;;
+ esac
+ # Determine whether the default compiler is a.out or elf
+ eval $set_cc_for_build
+ sed 's/^ //' << EOF >$dummy.c
+ #include <features.h>
+ #ifdef __ELF__
+ # ifdef __GLIBC__
+ # if __GLIBC__ >= 2
+ LIBC=gnu
+ # else
+ LIBC=gnulibc1
+ # endif
+ # else
+ LIBC=gnulibc1
+ # endif
+ #else
+ #if defined(__INTEL_COMPILER) || defined(__PGI) || defined(__sun)
+ LIBC=gnu
+ #else
+ LIBC=gnuaout
+ #endif
+ #endif
+ #ifdef __dietlibc__
+ LIBC=dietlibc
+ #endif
+EOF
+ eval "`$CC_FOR_BUILD -E $dummy.c 2>/dev/null | sed -n '
+ /^LIBC/{
+ s: ::g
+ p
+ }'`"
+ test x"${LIBC}" != x && {
+ echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
+ exit
+ }
+ test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
+ ;;
+ i*86:DYNIX/ptx:4*:*)
+ # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+ # earlier versions are messed up and put the nodename in both
+ # sysname and nodename.
+ echo i386-sequent-sysv4
+ exit ;;
+ i*86:UNIX_SV:4.2MP:2.*)
+ # Unixware is an offshoot of SVR4, but it has its own version
+ # number series starting with 2...
+ # I am not positive that other SVR4 systems won't match this,
+ # I just have to hope. -- rms.
+ # Use sysv4.2uw... so that sysv4* matches it.
+ echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+ exit ;;
+ i*86:OS/2:*:*)
+ # If we were able to find `uname', then EMX Unix compatibility
+ # is probably installed.
+ echo ${UNAME_MACHINE}-pc-os2-emx
+ exit ;;
+ i*86:XTS-300:*:STOP)
+ echo ${UNAME_MACHINE}-unknown-stop
+ exit ;;
+ i*86:atheos:*:*)
+ echo ${UNAME_MACHINE}-unknown-atheos
+ exit ;;
+ i*86:syllable:*:*)
+ echo ${UNAME_MACHINE}-pc-syllable
+ exit ;;
+ i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
+ echo i386-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ i*86:*DOS:*:*)
+ echo ${UNAME_MACHINE}-pc-msdosdjgpp
+ exit ;;
+ i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
+ UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+ if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+ echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+ else
+ echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+ fi
+ exit ;;
+ i*86:*:5:[678]*)
+ # UnixWare 7.x, OpenUNIX and OpenServer 6.
+ case `/bin/uname -X | grep "^Machine"` in
+ *486*) UNAME_MACHINE=i486 ;;
+ *Pentium) UNAME_MACHINE=i586 ;;
+ *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+ esac
+ echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+ exit ;;
+ i*86:*:3.2:*)
+ if test -f /usr/options/cb.name; then
+ UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+ echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+ elif /bin/uname -X 2>/dev/null >/dev/null ; then
+ UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+ (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+ (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+ && UNAME_MACHINE=i586
+ (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+ && UNAME_MACHINE=i686
+ (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+ && UNAME_MACHINE=i686
+ echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+ else
+ echo ${UNAME_MACHINE}-pc-sysv32
+ fi
+ exit ;;
+ pc:*:*:*)
+ # Left here for compatibility:
+ # uname -m prints for DJGPP always 'pc', but it prints nothing about
+ # the processor, so we play safe by assuming i386.
+ echo i386-pc-msdosdjgpp
+ exit ;;
+ Intel:Mach:3*:*)
+ echo i386-pc-mach3
+ exit ;;
+ paragon:*:*:*)
+ echo i860-intel-osf1
+ exit ;;
+ i860:*:4.*:*) # i860-SVR4
+ if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+ echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+ else # Add other i860-SVR4 vendors below as they are discovered.
+ echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
+ fi
+ exit ;;
+ mini*:CTIX:SYS*5:*)
+ # "miniframe"
+ echo m68010-convergent-sysv
+ exit ;;
+ mc68k:UNIX:SYSTEM5:3.51m)
+ echo m68k-convergent-sysv
+ exit ;;
+ M680?0:D-NIX:5.3:*)
+ echo m68k-diab-dnix
+ exit ;;
+ M68*:*:R3V[5678]*:*)
+ test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+ 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+ OS_REL=''
+ test -r /etc/.relid \
+ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+ 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
+ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+ && { echo i486-ncr-sysv4; exit; } ;;
+ m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+ echo m68k-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ mc68030:UNIX_System_V:4.*:*)
+ echo m68k-atari-sysv4
+ exit ;;
+ TSUNAMI:LynxOS:2.*:*)
+ echo sparc-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ rs6000:LynxOS:2.*:*)
+ echo rs6000-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
+ echo powerpc-unknown-lynxos${UNAME_RELEASE}
+ exit ;;
+ SM[BE]S:UNIX_SV:*:*)
+ echo mips-dde-sysv${UNAME_RELEASE}
+ exit ;;
+ RM*:ReliantUNIX-*:*:*)
+ echo mips-sni-sysv4
+ exit ;;
+ RM*:SINIX-*:*:*)
+ echo mips-sni-sysv4
+ exit ;;
+ *:SINIX-*:*:*)
+ if uname -p 2>/dev/null >/dev/null ; then
+ UNAME_MACHINE=`(uname -p) 2>/dev/null`
+ echo ${UNAME_MACHINE}-sni-sysv4
+ else
+ echo ns32k-sni-sysv
+ fi
+ exit ;;
+ PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+ # says <Richard.M.Bartel@ccMail.Census.GOV>
+ echo i586-unisys-sysv4
+ exit ;;
+ *:UNIX_System_V:4*:FTX*)
+ # From Gerald Hewes <hewes@openmarket.com>.
+ # How about differentiating between stratus architectures? -djm
+ echo hppa1.1-stratus-sysv4
+ exit ;;
+ *:*:*:FTX*)
+ # From seanf@swdc.stratus.com.
+ echo i860-stratus-sysv4
+ exit ;;
+ i*86:VOS:*:*)
+ # From Paul.Green@stratus.com.
+ echo ${UNAME_MACHINE}-stratus-vos
+ exit ;;
+ *:VOS:*:*)
+ # From Paul.Green@stratus.com.
+ echo hppa1.1-stratus-vos
+ exit ;;
+ mc68*:A/UX:*:*)
+ echo m68k-apple-aux${UNAME_RELEASE}
+ exit ;;
+ news*:NEWS-OS:6*:*)
+ echo mips-sony-newsos6
+ exit ;;
+ R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+ if [ -d /usr/nec ]; then
+ echo mips-nec-sysv${UNAME_RELEASE}
+ else
+ echo mips-unknown-sysv${UNAME_RELEASE}
+ fi
+ exit ;;
+ BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
+ echo powerpc-be-beos
+ exit ;;
+ BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
+ echo powerpc-apple-beos
+ exit ;;
+ BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
+ echo i586-pc-beos
+ exit ;;
+ SX-4:SUPER-UX:*:*)
+ echo sx4-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-5:SUPER-UX:*:*)
+ echo sx5-nec-superux${UNAME_RELEASE}
+ exit ;;
+ SX-6:SUPER-UX:*:*)
+ echo sx6-nec-superux${UNAME_RELEASE}
+ exit ;;
+ Power*:Rhapsody:*:*)
+ echo powerpc-apple-rhapsody${UNAME_RELEASE}
+ exit ;;
+ *:Rhapsody:*:*)
+ echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+ exit ;;
+ *:Darwin:*:*)
+ UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+ case $UNAME_PROCESSOR in
+ unknown) UNAME_PROCESSOR=powerpc ;;
+ esac
+ echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+ exit ;;
+ *:procnto*:*:* | *:QNX:[0123456789]*:*)
+ UNAME_PROCESSOR=`uname -p`
+ if test "$UNAME_PROCESSOR" = "x86"; then
+ UNAME_PROCESSOR=i386
+ UNAME_MACHINE=pc
+ fi
+ echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+ exit ;;
+ *:QNX:*:4*)
+ echo i386-pc-qnx
+ exit ;;
+ NSE-?:NONSTOP_KERNEL:*:*)
+ echo nse-tandem-nsk${UNAME_RELEASE}
+ exit ;;
+ NSR-?:NONSTOP_KERNEL:*:*)
+ echo nsr-tandem-nsk${UNAME_RELEASE}
+ exit ;;
+ *:NonStop-UX:*:*)
+ echo mips-compaq-nonstopux
+ exit ;;
+ BS2000:POSIX*:*:*)
+ echo bs2000-siemens-sysv
+ exit ;;
+ DS/*:UNIX_System_V:*:*)
+ echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+ exit ;;
+ *:Plan9:*:*)
+ # "uname -m" is not consistent, so use $cputype instead. 386
+ # is converted to i386 for consistency with other x86
+ # operating systems.
+ if test "$cputype" = "386"; then
+ UNAME_MACHINE=i386
+ else
+ UNAME_MACHINE="$cputype"
+ fi
+ echo ${UNAME_MACHINE}-unknown-plan9
+ exit ;;
+ *:TOPS-10:*:*)
+ echo pdp10-unknown-tops10
+ exit ;;
+ *:TENEX:*:*)
+ echo pdp10-unknown-tenex
+ exit ;;
+ KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+ echo pdp10-dec-tops20
+ exit ;;
+ XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+ echo pdp10-xkl-tops20
+ exit ;;
+ *:TOPS-20:*:*)
+ echo pdp10-unknown-tops20
+ exit ;;
+ *:ITS:*:*)
+ echo pdp10-unknown-its
+ exit ;;
+ SEI:*:*:SEIUX)
+ echo mips-sei-seiux${UNAME_RELEASE}
+ exit ;;
+ *:DragonFly:*:*)
+ echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
+ exit ;;
+ *:*VMS:*:*)
+ UNAME_MACHINE=`(uname -p) 2>/dev/null`
+ case "${UNAME_MACHINE}" in
+ A*) echo alpha-dec-vms ; exit ;;
+ I*) echo ia64-dec-vms ; exit ;;
+ V*) echo vax-dec-vms ; exit ;;
+ esac ;;
+ *:XENIX:*:SysV)
+ echo i386-pc-xenix
+ exit ;;
+ i*86:skyos:*:*)
+ echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+ exit ;;
+ i*86:rdos:*:*)
+ echo ${UNAME_MACHINE}-pc-rdos
+ exit ;;
+esac
+
+#echo '(No uname command or uname output not recognized.)' 1>&2
+#echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
+
+eval $set_cc_for_build
+cat >$dummy.c <<EOF
+#ifdef _SEQUENT_
+# include <sys/types.h>
+# include <sys/utsname.h>
+#endif
+main ()
+{
+#if defined (sony)
+#if defined (MIPSEB)
+ /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed,
+ I don't know.... */
+ printf ("mips-sony-bsd\n"); exit (0);
+#else
+#include <sys/param.h>
+ printf ("m68k-sony-newsos%s\n",
+#ifdef NEWSOS4
+ "4"
+#else
+ ""
+#endif
+ ); exit (0);
+#endif
+#endif
+
+#if defined (__arm) && defined (__acorn) && defined (__unix)
+ printf ("arm-acorn-riscix\n"); exit (0);
+#endif
+
+#if defined (hp300) && !defined (hpux)
+ printf ("m68k-hp-bsd\n"); exit (0);
+#endif
+
+#if defined (NeXT)
+#if !defined (__ARCHITECTURE__)
+#define __ARCHITECTURE__ "m68k"
+#endif
+ int version;
+ version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
+ if (version < 4)
+ printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
+ else
+ printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
+ exit (0);
+#endif
+
+#if defined (MULTIMAX) || defined (n16)
+#if defined (UMAXV)
+ printf ("ns32k-encore-sysv\n"); exit (0);
+#else
+#if defined (CMU)
+ printf ("ns32k-encore-mach\n"); exit (0);
+#else
+ printf ("ns32k-encore-bsd\n"); exit (0);
+#endif
+#endif
+#endif
+
+#if defined (__386BSD__)
+ printf ("i386-pc-bsd\n"); exit (0);
+#endif
+
+#if defined (sequent)
+#if defined (i386)
+ printf ("i386-sequent-dynix\n"); exit (0);
+#endif
+#if defined (ns32000)
+ printf ("ns32k-sequent-dynix\n"); exit (0);
+#endif
+#endif
+
+#if defined (_SEQUENT_)
+ struct utsname un;
+
+ uname(&un);
+
+ if (strncmp(un.version, "V2", 2) == 0) {
+ printf ("i386-sequent-ptx2\n"); exit (0);
+ }
+ if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
+ printf ("i386-sequent-ptx1\n"); exit (0);
+ }
+ printf ("i386-sequent-ptx\n"); exit (0);
+
+#endif
+
+#if defined (vax)
+# if !defined (ultrix)
+# include <sys/param.h>
+# if defined (BSD)
+# if BSD == 43
+ printf ("vax-dec-bsd4.3\n"); exit (0);
+# else
+# if BSD == 199006
+ printf ("vax-dec-bsd4.3reno\n"); exit (0);
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# endif
+# else
+ printf ("vax-dec-bsd\n"); exit (0);
+# endif
+# else
+ printf ("vax-dec-ultrix\n"); exit (0);
+# endif
+#endif
+
+#if defined (alliant) && defined (i860)
+ printf ("i860-alliant-bsd\n"); exit (0);
+#endif
+
+ exit (1);
+}
+EOF
+
+$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
+ { echo "$SYSTEM_NAME"; exit; }
+
+# Apollos put the system type in the environment.
+
+test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
+
+# Convex versions that predate uname can use getsysinfo(1)
+
+if [ -x /usr/convex/getsysinfo ]
+then
+ case `getsysinfo -f cpu_type` in
+ c1*)
+ echo c1-convex-bsd
+ exit ;;
+ c2*)
+ if getsysinfo -f scalar_acc
+ then echo c32-convex-bsd
+ else echo c2-convex-bsd
+ fi
+ exit ;;
+ c34*)
+ echo c34-convex-bsd
+ exit ;;
+ c38*)
+ echo c38-convex-bsd
+ exit ;;
+ c4*)
+ echo c4-convex-bsd
+ exit ;;
+ esac
+fi
+
+cat >&2 <<EOF
+$0: unable to guess system type
+
+This script, last modified $timestamp, has failed to recognize
+the operating system you are using. It is advised that you
+download the most up to date version of the config scripts from
+
+ http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
+and
+ http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
+
+If the version you run ($0) is already up to date, please
+send the following data and any information you think might be
+pertinent to <config-patches@gnu.org> in order to provide the needed
+information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo = `(hostinfo) 2>/dev/null`
+/bin/universe = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = ${UNAME_MACHINE}
+UNAME_RELEASE = ${UNAME_RELEASE}
+UNAME_SYSTEM = ${UNAME_SYSTEM}
+UNAME_VERSION = ${UNAME_VERSION}
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
--- /dev/null
+#! /bin/sh
+# Configuration validation subroutine script.
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+# 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+# Inc.
+
+timestamp='2006-03-07'
+
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine. It does not imply ALL GNU software can.
+#
+# This file 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 of the License, or
+# (at your option) any later version.
+#
+# This program 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 this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+
+# Please send patches to <config-patches@gnu.org>. Submit a context
+# diff and a properly formatted ChangeLog entry.
+#
+# Configuration subroutine to validate and canonicalize a configuration type.
+# Supply the specified configuration type as an argument.
+# If it is invalid, we print an error message on stderr and exit with code 1.
+# Otherwise, we print the canonical config type on stdout and succeed.
+
+# This file is supposed to be the same for all GNU packages
+# and recognize all the CPU types, system types and aliases
+# that are meaningful with *any* GNU software.
+# Each package is responsible for reporting which valid configurations
+# it does not support. The user should be able to distinguish
+# a failure to support a valid configuration from a meaningless
+# configuration.
+
+# The goal of this file is to map all the various variations of a given
+# machine specification into a single specification in the form:
+# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or in some cases, the newer four-part form:
+# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# It is wrong to echo any other type of specification.
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 [OPTION] CPU-MFR-OPSYS
+ $0 [OPTION] ALIAS
+
+Canonicalize a configuration name.
+
+Operation modes:
+ -h, --help print this help, then exit
+ -t, --time-stamp print date of last modification, then exit
+ -v, --version print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.sub ($timestamp)
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+ case $1 in
+ --time-stamp | --time* | -t )
+ echo "$timestamp" ; exit ;;
+ --version | -v )
+ echo "$version" ; exit ;;
+ --help | --h* | -h )
+ echo "$usage"; exit ;;
+ -- ) # Stop option processing
+ shift; break ;;
+ - ) # Use stdin as input.
+ break ;;
+ -* )
+ echo "$me: invalid option $1$help"
+ exit 1 ;;
+
+ *local*)
+ # First pass through any local machine types.
+ echo $1
+ exit ;;
+
+ * )
+ break ;;
+ esac
+done
+
+case $# in
+ 0) echo "$me: missing argument$help" >&2
+ exit 1;;
+ 1) ;;
+ *) echo "$me: too many arguments$help" >&2
+ exit 1;;
+esac
+
+# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any).
+# Here we must recognize all the valid KERNEL-OS combinations.
+maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
+case $maybe_os in
+ nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \
+ uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \
+ storm-chaos* | os2-emx* | rtmk-nova*)
+ os=-$maybe_os
+ basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
+ ;;
+ *)
+ basic_machine=`echo $1 | sed 's/-[^-]*$//'`
+ if [ $basic_machine != $1 ]
+ then os=`echo $1 | sed 's/.*-/-/'`
+ else os=; fi
+ ;;
+esac
+
+### Let's recognize common machines as not being operating systems so
+### that things like config.sub decstation-3100 work. We also
+### recognize some manufacturers as not being operating systems, so we
+### can provide default operating systems below.
+case $os in
+ -sun*os*)
+ # Prevent following clause from handling this invalid input.
+ ;;
+ -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
+ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
+ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \
+ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
+ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
+ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
+ -apple | -axis | -knuth | -cray)
+ os=
+ basic_machine=$1
+ ;;
+ -sim | -cisco | -oki | -wec | -winbond)
+ os=
+ basic_machine=$1
+ ;;
+ -scout)
+ ;;
+ -wrs)
+ os=-vxworks
+ basic_machine=$1
+ ;;
+ -chorusos*)
+ os=-chorusos
+ basic_machine=$1
+ ;;
+ -chorusrdb)
+ os=-chorusrdb
+ basic_machine=$1
+ ;;
+ -hiux*)
+ os=-hiuxwe2
+ ;;
+ -sco6)
+ os=-sco5v6
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco5)
+ os=-sco3.2v5
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco4)
+ os=-sco3.2v4
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2.[4-9]*)
+ os=`echo $os | sed -e 's/sco3.2./sco3.2v/'`
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco3.2v[4-9]*)
+ # Don't forget version if it is 3.2v4 or newer.
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco5v6*)
+ # Don't forget version if it is 3.2v4 or newer.
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -sco*)
+ os=-sco3.2v2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -udk*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -isc)
+ os=-isc2.2
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -clix*)
+ basic_machine=clipper-intergraph
+ ;;
+ -isc*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
+ ;;
+ -lynx*)
+ os=-lynxos
+ ;;
+ -ptx*)
+ basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'`
+ ;;
+ -windowsnt*)
+ os=`echo $os | sed -e 's/windowsnt/winnt/'`
+ ;;
+ -psos*)
+ os=-psos
+ ;;
+ -mint | -mint[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+esac
+
+# Decode aliases for certain CPU-COMPANY combinations.
+case $basic_machine in
+ # Recognize the basic CPU types without company name.
+ # Some are omitted here because they have special meanings below.
+ 1750a | 580 \
+ | a29k \
+ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
+ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
+ | am33_2.0 \
+ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr \
+ | bfin \
+ | c4x | clipper \
+ | d10v | d30v | dlx | dsp16xx \
+ | fr30 | frv \
+ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
+ | i370 | i860 | i960 | ia64 \
+ | ip2k | iq2000 \
+ | m32r | m32rle | m68000 | m68k | m88k | maxq | mb | microblaze | mcore \
+ | mips | mipsbe | mipseb | mipsel | mipsle \
+ | mips16 \
+ | mips64 | mips64el \
+ | mips64vr | mips64vrel \
+ | mips64orion | mips64orionel \
+ | mips64vr4100 | mips64vr4100el \
+ | mips64vr4300 | mips64vr4300el \
+ | mips64vr5000 | mips64vr5000el \
+ | mips64vr5900 | mips64vr5900el \
+ | mipsisa32 | mipsisa32el \
+ | mipsisa32r2 | mipsisa32r2el \
+ | mipsisa64 | mipsisa64el \
+ | mipsisa64r2 | mipsisa64r2el \
+ | mipsisa64sb1 | mipsisa64sb1el \
+ | mipsisa64sr71k | mipsisa64sr71kel \
+ | mipstx39 | mipstx39el \
+ | mn10200 | mn10300 \
+ | mt \
+ | msp430 \
+ | nios | nios2 \
+ | ns16k | ns32k \
+ | or32 \
+ | pdp10 | pdp11 | pj | pjl \
+ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
+ | pyramid \
+ | sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+ | sh64 | sh64le \
+ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
+ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \
+ | strongarm \
+ | tahoe | thumb | tic4x | tic80 | tron \
+ | v850 | v850e \
+ | we32k \
+ | x86 | xscale | xscalee[bl] | xstormy16 | xtensa \
+ | z8k)
+ basic_machine=$basic_machine-unknown
+ ;;
+ m32c)
+ basic_machine=$basic_machine-unknown
+ ;;
+ m6811 | m68hc11 | m6812 | m68hc12)
+ # Motorola 68HC11/12.
+ basic_machine=$basic_machine-unknown
+ os=-none
+ ;;
+ m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
+ ;;
+ ms1)
+ basic_machine=mt-unknown
+ ;;
+
+ # We use `pc' rather than `unknown'
+ # because (1) that's what they normally are, and
+ # (2) the word "unknown" tends to confuse beginning users.
+ i*86 | x86_64)
+ basic_machine=$basic_machine-pc
+ ;;
+ # Object if more than one company name word.
+ *-*-*)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+ # Recognize the basic CPU types with company name.
+ 580-* \
+ | a29k-* \
+ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
+ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
+ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
+ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \
+ | avr-* \
+ | bfin-* | bs2000-* \
+ | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+ | clipper-* | craynv-* | cydra-* \
+ | d10v-* | d30v-* | dlx-* \
+ | elxsi-* \
+ | f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \
+ | h8300-* | h8500-* \
+ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
+ | i*86-* | i860-* | i960-* | ia64-* \
+ | ip2k-* | iq2000-* \
+ | m32r-* | m32rle-* \
+ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
+ | m88110-* | m88k-* | maxq-* | mcore-* \
+ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
+ | mips16-* \
+ | mips64-* | mips64el-* \
+ | mips64vr-* | mips64vrel-* \
+ | mips64orion-* | mips64orionel-* \
+ | mips64vr4100-* | mips64vr4100el-* \
+ | mips64vr4300-* | mips64vr4300el-* \
+ | mips64vr5000-* | mips64vr5000el-* \
+ | mips64vr5900-* | mips64vr5900el-* \
+ | mipsisa32-* | mipsisa32el-* \
+ | mipsisa32r2-* | mipsisa32r2el-* \
+ | mipsisa64-* | mipsisa64el-* \
+ | mipsisa64r2-* | mipsisa64r2el-* \
+ | mipsisa64sb1-* | mipsisa64sb1el-* \
+ | mipsisa64sr71k-* | mipsisa64sr71kel-* \
+ | mipstx39-* | mipstx39el-* \
+ | mmix-* \
+ | mt-* \
+ | msp430-* \
+ | nios-* | nios2-* \
+ | none-* | np1-* | ns16k-* | ns32k-* \
+ | orion-* \
+ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
+ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
+ | pyramid-* \
+ | romp-* | rs6000-* \
+ | sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
+ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
+ | sparclite-* \
+ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
+ | tahoe-* | thumb-* \
+ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
+ | tron-* \
+ | v850-* | v850e-* | vax-* \
+ | we32k-* \
+ | x86-* | x86_64-* | xps100-* | xscale-* | xscalee[bl]-* \
+ | xstormy16-* | xtensa-* \
+ | ymp-* \
+ | z8k-*)
+ ;;
+ m32c-*)
+ ;;
+ # Recognize the various machine names and aliases which stand
+ # for a CPU type and a company and sometimes even an OS.
+ 386bsd)
+ basic_machine=i386-unknown
+ os=-bsd
+ ;;
+ 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
+ basic_machine=m68000-att
+ ;;
+ 3b*)
+ basic_machine=we32k-att
+ ;;
+ a29khif)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ abacus)
+ basic_machine=abacus-unknown
+ ;;
+ adobe68k)
+ basic_machine=m68010-adobe
+ os=-scout
+ ;;
+ alliant | fx80)
+ basic_machine=fx80-alliant
+ ;;
+ altos | altos3068)
+ basic_machine=m68k-altos
+ ;;
+ am29k)
+ basic_machine=a29k-none
+ os=-bsd
+ ;;
+ amd64)
+ basic_machine=x86_64-pc
+ ;;
+ amd64-*)
+ basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ amdahl)
+ basic_machine=580-amdahl
+ os=-sysv
+ ;;
+ amiga | amiga-*)
+ basic_machine=m68k-unknown
+ ;;
+ amigaos | amigados)
+ basic_machine=m68k-unknown
+ os=-amigaos
+ ;;
+ amigaunix | amix)
+ basic_machine=m68k-unknown
+ os=-sysv4
+ ;;
+ apollo68)
+ basic_machine=m68k-apollo
+ os=-sysv
+ ;;
+ apollo68bsd)
+ basic_machine=m68k-apollo
+ os=-bsd
+ ;;
+ aux)
+ basic_machine=m68k-apple
+ os=-aux
+ ;;
+ balance)
+ basic_machine=ns32k-sequent
+ os=-dynix
+ ;;
+ c90)
+ basic_machine=c90-cray
+ os=-unicos
+ ;;
+ convex-c1)
+ basic_machine=c1-convex
+ os=-bsd
+ ;;
+ convex-c2)
+ basic_machine=c2-convex
+ os=-bsd
+ ;;
+ convex-c32)
+ basic_machine=c32-convex
+ os=-bsd
+ ;;
+ convex-c34)
+ basic_machine=c34-convex
+ os=-bsd
+ ;;
+ convex-c38)
+ basic_machine=c38-convex
+ os=-bsd
+ ;;
+ cray | j90)
+ basic_machine=j90-cray
+ os=-unicos
+ ;;
+ craynv)
+ basic_machine=craynv-cray
+ os=-unicosmp
+ ;;
+ cr16c)
+ basic_machine=cr16c-unknown
+ os=-elf
+ ;;
+ crds | unos)
+ basic_machine=m68k-crds
+ ;;
+ crisv32 | crisv32-* | etraxfs*)
+ basic_machine=crisv32-axis
+ ;;
+ cris | cris-* | etrax*)
+ basic_machine=cris-axis
+ ;;
+ crx)
+ basic_machine=crx-unknown
+ os=-elf
+ ;;
+ da30 | da30-*)
+ basic_machine=m68k-da30
+ ;;
+ decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn)
+ basic_machine=mips-dec
+ ;;
+ decsystem10* | dec10*)
+ basic_machine=pdp10-dec
+ os=-tops10
+ ;;
+ decsystem20* | dec20*)
+ basic_machine=pdp10-dec
+ os=-tops20
+ ;;
+ delta | 3300 | motorola-3300 | motorola-delta \
+ | 3300-motorola | delta-motorola)
+ basic_machine=m68k-motorola
+ ;;
+ delta88)
+ basic_machine=m88k-motorola
+ os=-sysv3
+ ;;
+ djgpp)
+ basic_machine=i586-pc
+ os=-msdosdjgpp
+ ;;
+ dpx20 | dpx20-*)
+ basic_machine=rs6000-bull
+ os=-bosx
+ ;;
+ dpx2* | dpx2*-bull)
+ basic_machine=m68k-bull
+ os=-sysv3
+ ;;
+ ebmon29k)
+ basic_machine=a29k-amd
+ os=-ebmon
+ ;;
+ elxsi)
+ basic_machine=elxsi-elxsi
+ os=-bsd
+ ;;
+ encore | umax | mmax)
+ basic_machine=ns32k-encore
+ ;;
+ es1800 | OSE68k | ose68k | ose | OSE)
+ basic_machine=m68k-ericsson
+ os=-ose
+ ;;
+ fx2800)
+ basic_machine=i860-alliant
+ ;;
+ genix)
+ basic_machine=ns32k-ns
+ ;;
+ gmicro)
+ basic_machine=tron-gmicro
+ os=-sysv
+ ;;
+ go32)
+ basic_machine=i386-pc
+ os=-go32
+ ;;
+ h3050r* | hiux*)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ h8300hms)
+ basic_machine=h8300-hitachi
+ os=-hms
+ ;;
+ h8300xray)
+ basic_machine=h8300-hitachi
+ os=-xray
+ ;;
+ h8500hms)
+ basic_machine=h8500-hitachi
+ os=-hms
+ ;;
+ harris)
+ basic_machine=m88k-harris
+ os=-sysv3
+ ;;
+ hp300-*)
+ basic_machine=m68k-hp
+ ;;
+ hp300bsd)
+ basic_machine=m68k-hp
+ os=-bsd
+ ;;
+ hp300hpux)
+ basic_machine=m68k-hp
+ os=-hpux
+ ;;
+ hp3k9[0-9][0-9] | hp9[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k2[0-9][0-9] | hp9k31[0-9])
+ basic_machine=m68000-hp
+ ;;
+ hp9k3[2-9][0-9])
+ basic_machine=m68k-hp
+ ;;
+ hp9k6[0-9][0-9] | hp6[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hp9k7[0-79][0-9] | hp7[0-79][0-9])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k78[0-9] | hp78[0-9])
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893)
+ # FIXME: really hppa2.0-hp
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][13679] | hp8[0-9][13679])
+ basic_machine=hppa1.1-hp
+ ;;
+ hp9k8[0-9][0-9] | hp8[0-9][0-9])
+ basic_machine=hppa1.0-hp
+ ;;
+ hppa-next)
+ os=-nextstep3
+ ;;
+ hppaosf)
+ basic_machine=hppa1.1-hp
+ os=-osf
+ ;;
+ hppro)
+ basic_machine=hppa1.1-hp
+ os=-proelf
+ ;;
+ i370-ibm* | ibm*)
+ basic_machine=i370-ibm
+ ;;
+# I'm not sure what "Sysv32" means. Should this be sysv3.2?
+ i*86v32)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv32
+ ;;
+ i*86v4*)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv4
+ ;;
+ i*86v)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-sysv
+ ;;
+ i*86sol2)
+ basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
+ os=-solaris2
+ ;;
+ i386mach)
+ basic_machine=i386-mach
+ os=-mach
+ ;;
+ i386-vsta | vsta)
+ basic_machine=i386-unknown
+ os=-vsta
+ ;;
+ iris | iris4d)
+ basic_machine=mips-sgi
+ case $os in
+ -irix*)
+ ;;
+ *)
+ os=-irix4
+ ;;
+ esac
+ ;;
+ isi68 | isi)
+ basic_machine=m68k-isi
+ os=-sysv
+ ;;
+ m88k-omron*)
+ basic_machine=m88k-omron
+ ;;
+ magnum | m3230)
+ basic_machine=mips-mips
+ os=-sysv
+ ;;
+ merlin)
+ basic_machine=ns32k-utek
+ os=-sysv
+ ;;
+ mingw32)
+ basic_machine=i386-pc
+ os=-mingw32
+ ;;
+ miniframe)
+ basic_machine=m68000-convergent
+ ;;
+ *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*)
+ basic_machine=m68k-atari
+ os=-mint
+ ;;
+ mips3*-*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`
+ ;;
+ mips3*)
+ basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown
+ ;;
+ monitor)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ morphos)
+ basic_machine=powerpc-unknown
+ os=-morphos
+ ;;
+ msdos)
+ basic_machine=i386-pc
+ os=-msdos
+ ;;
+ ms1-*)
+ basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
+ ;;
+ mvs)
+ basic_machine=i370-ibm
+ os=-mvs
+ ;;
+ ncr3000)
+ basic_machine=i486-ncr
+ os=-sysv4
+ ;;
+ netbsd386)
+ basic_machine=i386-unknown
+ os=-netbsd
+ ;;
+ netwinder)
+ basic_machine=armv4l-rebel
+ os=-linux
+ ;;
+ news | news700 | news800 | news900)
+ basic_machine=m68k-sony
+ os=-newsos
+ ;;
+ news1000)
+ basic_machine=m68030-sony
+ os=-newsos
+ ;;
+ news-3600 | risc-news)
+ basic_machine=mips-sony
+ os=-newsos
+ ;;
+ necv70)
+ basic_machine=v70-nec
+ os=-sysv
+ ;;
+ next | m*-next )
+ basic_machine=m68k-next
+ case $os in
+ -nextstep* )
+ ;;
+ -ns2*)
+ os=-nextstep2
+ ;;
+ *)
+ os=-nextstep3
+ ;;
+ esac
+ ;;
+ nh3000)
+ basic_machine=m68k-harris
+ os=-cxux
+ ;;
+ nh[45]000)
+ basic_machine=m88k-harris
+ os=-cxux
+ ;;
+ nindy960)
+ basic_machine=i960-intel
+ os=-nindy
+ ;;
+ mon960)
+ basic_machine=i960-intel
+ os=-mon960
+ ;;
+ nonstopux)
+ basic_machine=mips-compaq
+ os=-nonstopux
+ ;;
+ np1)
+ basic_machine=np1-gould
+ ;;
+ nsr-tandem)
+ basic_machine=nsr-tandem
+ ;;
+ op50n-* | op60c-*)
+ basic_machine=hppa1.1-oki
+ os=-proelf
+ ;;
+ openrisc | openrisc-*)
+ basic_machine=or32-unknown
+ ;;
+ os400)
+ basic_machine=powerpc-ibm
+ os=-os400
+ ;;
+ OSE68000 | ose68000)
+ basic_machine=m68000-ericsson
+ os=-ose
+ ;;
+ os68k)
+ basic_machine=m68k-none
+ os=-os68k
+ ;;
+ pa-hitachi)
+ basic_machine=hppa1.1-hitachi
+ os=-hiuxwe2
+ ;;
+ paragon)
+ basic_machine=i860-intel
+ os=-osf
+ ;;
+ pbd)
+ basic_machine=sparc-tti
+ ;;
+ pbb)
+ basic_machine=m68k-tti
+ ;;
+ pc532 | pc532-*)
+ basic_machine=ns32k-pc532
+ ;;
+ pc98)
+ basic_machine=i386-pc
+ ;;
+ pc98-*)
+ basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentium | p5 | k5 | k6 | nexgen | viac3)
+ basic_machine=i586-pc
+ ;;
+ pentiumpro | p6 | 6x86 | athlon | athlon_*)
+ basic_machine=i686-pc
+ ;;
+ pentiumii | pentium2 | pentiumiii | pentium3)
+ basic_machine=i686-pc
+ ;;
+ pentium4)
+ basic_machine=i786-pc
+ ;;
+ pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*)
+ basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumpro-* | p6-* | 6x86-* | athlon-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*)
+ basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pentium4-*)
+ basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ pn)
+ basic_machine=pn-gould
+ ;;
+ power) basic_machine=power-ibm
+ ;;
+ ppc) basic_machine=powerpc-unknown
+ ;;
+ ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppcle | powerpclittle | ppc-le | powerpc-little)
+ basic_machine=powerpcle-unknown
+ ;;
+ ppcle-* | powerpclittle-*)
+ basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64) basic_machine=powerpc64-unknown
+ ;;
+ ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ppc64le | powerpc64little | ppc64-le | powerpc64-little)
+ basic_machine=powerpc64le-unknown
+ ;;
+ ppc64le-* | powerpc64little-*)
+ basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
+ ;;
+ ps2)
+ basic_machine=i386-ibm
+ ;;
+ pw32)
+ basic_machine=i586-unknown
+ os=-pw32
+ ;;
+ rdos)
+ basic_machine=i386-pc
+ os=-rdos
+ ;;
+ rom68k)
+ basic_machine=m68k-rom68k
+ os=-coff
+ ;;
+ rm[46]00)
+ basic_machine=mips-siemens
+ ;;
+ rtpc | rtpc-*)
+ basic_machine=romp-ibm
+ ;;
+ s390 | s390-*)
+ basic_machine=s390-ibm
+ ;;
+ s390x | s390x-*)
+ basic_machine=s390x-ibm
+ ;;
+ sa29200)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ sb1)
+ basic_machine=mipsisa64sb1-unknown
+ ;;
+ sb1el)
+ basic_machine=mipsisa64sb1el-unknown
+ ;;
+ sei)
+ basic_machine=mips-sei
+ os=-seiux
+ ;;
+ sequent)
+ basic_machine=i386-sequent
+ ;;
+ sh)
+ basic_machine=sh-hitachi
+ os=-hms
+ ;;
+ sh64)
+ basic_machine=sh64-unknown
+ ;;
+ sparclite-wrs | simso-wrs)
+ basic_machine=sparclite-wrs
+ os=-vxworks
+ ;;
+ sps7)
+ basic_machine=m68k-bull
+ os=-sysv2
+ ;;
+ spur)
+ basic_machine=spur-unknown
+ ;;
+ st2000)
+ basic_machine=m68k-tandem
+ ;;
+ stratus)
+ basic_machine=i860-stratus
+ os=-sysv4
+ ;;
+ sun2)
+ basic_machine=m68000-sun
+ ;;
+ sun2os3)
+ basic_machine=m68000-sun
+ os=-sunos3
+ ;;
+ sun2os4)
+ basic_machine=m68000-sun
+ os=-sunos4
+ ;;
+ sun3os3)
+ basic_machine=m68k-sun
+ os=-sunos3
+ ;;
+ sun3os4)
+ basic_machine=m68k-sun
+ os=-sunos4
+ ;;
+ sun4os3)
+ basic_machine=sparc-sun
+ os=-sunos3
+ ;;
+ sun4os4)
+ basic_machine=sparc-sun
+ os=-sunos4
+ ;;
+ sun4sol2)
+ basic_machine=sparc-sun
+ os=-solaris2
+ ;;
+ sun3 | sun3-*)
+ basic_machine=m68k-sun
+ ;;
+ sun4)
+ basic_machine=sparc-sun
+ ;;
+ sun386 | sun386i | roadrunner)
+ basic_machine=i386-sun
+ ;;
+ sv1)
+ basic_machine=sv1-cray
+ os=-unicos
+ ;;
+ symmetry)
+ basic_machine=i386-sequent
+ os=-dynix
+ ;;
+ t3e)
+ basic_machine=alphaev5-cray
+ os=-unicos
+ ;;
+ t90)
+ basic_machine=t90-cray
+ os=-unicos
+ ;;
+ tic54x | c54x*)
+ basic_machine=tic54x-unknown
+ os=-coff
+ ;;
+ tic55x | c55x*)
+ basic_machine=tic55x-unknown
+ os=-coff
+ ;;
+ tic6x | c6x*)
+ basic_machine=tic6x-unknown
+ os=-coff
+ ;;
+ tx39)
+ basic_machine=mipstx39-unknown
+ ;;
+ tx39el)
+ basic_machine=mipstx39el-unknown
+ ;;
+ toad1)
+ basic_machine=pdp10-xkl
+ os=-tops20
+ ;;
+ tower | tower-32)
+ basic_machine=m68k-ncr
+ ;;
+ tpf)
+ basic_machine=s390x-ibm
+ os=-tpf
+ ;;
+ udi29k)
+ basic_machine=a29k-amd
+ os=-udi
+ ;;
+ ultra3)
+ basic_machine=a29k-nyu
+ os=-sym1
+ ;;
+ v810 | necv810)
+ basic_machine=v810-nec
+ os=-none
+ ;;
+ vaxv)
+ basic_machine=vax-dec
+ os=-sysv
+ ;;
+ vms)
+ basic_machine=vax-dec
+ os=-vms
+ ;;
+ vpp*|vx|vx-*)
+ basic_machine=f301-fujitsu
+ ;;
+ vxworks960)
+ basic_machine=i960-wrs
+ os=-vxworks
+ ;;
+ vxworks68)
+ basic_machine=m68k-wrs
+ os=-vxworks
+ ;;
+ vxworks29k)
+ basic_machine=a29k-wrs
+ os=-vxworks
+ ;;
+ w65*)
+ basic_machine=w65-wdc
+ os=-none
+ ;;
+ w89k-*)
+ basic_machine=hppa1.1-winbond
+ os=-proelf
+ ;;
+ xbox)
+ basic_machine=i686-pc
+ os=-mingw32
+ ;;
+ xps | xps100)
+ basic_machine=xps100-honeywell
+ ;;
+ ymp)
+ basic_machine=ymp-cray
+ os=-unicos
+ ;;
+ z8k-*-coff)
+ basic_machine=z8k-unknown
+ os=-sim
+ ;;
+ none)
+ basic_machine=none-none
+ os=-none
+ ;;
+
+# Here we handle the default manufacturer of certain CPU types. It is in
+# some cases the only manufacturer, in others, it is the most popular.
+ w89k)
+ basic_machine=hppa1.1-winbond
+ ;;
+ op50n)
+ basic_machine=hppa1.1-oki
+ ;;
+ op60c)
+ basic_machine=hppa1.1-oki
+ ;;
+ romp)
+ basic_machine=romp-ibm
+ ;;
+ mmix)
+ basic_machine=mmix-knuth
+ ;;
+ rs6000)
+ basic_machine=rs6000-ibm
+ ;;
+ vax)
+ basic_machine=vax-dec
+ ;;
+ pdp10)
+ # there are many clones, so DEC is not a safe bet
+ basic_machine=pdp10-unknown
+ ;;
+ pdp11)
+ basic_machine=pdp11-dec
+ ;;
+ we32k)
+ basic_machine=we32k-att
+ ;;
+ sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)
+ basic_machine=sh-unknown
+ ;;
+ sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
+ basic_machine=sparc-sun
+ ;;
+ cydra)
+ basic_machine=cydra-cydrome
+ ;;
+ orion)
+ basic_machine=orion-highlevel
+ ;;
+ orion105)
+ basic_machine=clipper-highlevel
+ ;;
+ mac | mpw | mac-mpw)
+ basic_machine=m68k-apple
+ ;;
+ pmac | pmac-mpw)
+ basic_machine=powerpc-apple
+ ;;
+ *-unknown)
+ # Make sure to match an already-canonicalized machine name.
+ ;;
+ *)
+ echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+
+# Here we canonicalize certain aliases for manufacturers.
+case $basic_machine in
+ *-digital*)
+ basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
+ ;;
+ *-commodore*)
+ basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
+ ;;
+ *)
+ ;;
+esac
+
+# Decode manufacturer-specific aliases for certain operating systems.
+
+if [ x"$os" != x"" ]
+then
+case $os in
+ # First match some system type aliases
+ # that might get confused with valid system types.
+ # -solaris* is a basic system type, with this one exception.
+ -solaris1 | -solaris1.*)
+ os=`echo $os | sed -e 's|solaris1|sunos4|'`
+ ;;
+ -solaris)
+ os=-solaris2
+ ;;
+ -svr4*)
+ os=-sysv4
+ ;;
+ -unixware*)
+ os=-sysv4.2uw
+ ;;
+ -gnu/linux*)
+ os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
+ ;;
+ # First accept the basic system types.
+ # The portable systems comes first.
+ # Each alternative MUST END IN A *, to match a version number.
+ # -sysv* is not here because it comes later, after sysvr4.
+ -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
+ | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
+ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+ | -aos* \
+ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
+ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
+ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
+ | -openbsd* | -solidbsd* \
+ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
+ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
+ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
+ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
+ | -chorusos* | -chorusrdb* \
+ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+ | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \
+ | -uxpv* | -beos* | -mpeix* | -udk* \
+ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
+ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
+ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
+ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
+ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
+ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
+ | -skyos* | -haiku* | -rdos*)
+ # Remember, each alternative MUST END IN *, to match a version number.
+ ;;
+ -qnx*)
+ case $basic_machine in
+ x86-* | i*86-*)
+ ;;
+ *)
+ os=-nto$os
+ ;;
+ esac
+ ;;
+ -nto-qnx*)
+ ;;
+ -nto*)
+ os=`echo $os | sed -e 's|nto|nto-qnx|'`
+ ;;
+ -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
+ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
+ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
+ ;;
+ -mac*)
+ os=`echo $os | sed -e 's|mac|macos|'`
+ ;;
+ -linux-dietlibc)
+ os=-linux-dietlibc
+ ;;
+ -linux*)
+ os=`echo $os | sed -e 's|linux|linux-gnu|'`
+ ;;
+ -sunos5*)
+ os=`echo $os | sed -e 's|sunos5|solaris2|'`
+ ;;
+ -sunos6*)
+ os=`echo $os | sed -e 's|sunos6|solaris3|'`
+ ;;
+ -opened*)
+ os=-openedition
+ ;;
+ -os400*)
+ os=-os400
+ ;;
+ -wince*)
+ os=-wince
+ ;;
+ -osfrose*)
+ os=-osfrose
+ ;;
+ -osf*)
+ os=-osf
+ ;;
+ -utek*)
+ os=-bsd
+ ;;
+ -dynix*)
+ os=-bsd
+ ;;
+ -acis*)
+ os=-aos
+ ;;
+ -atheos*)
+ os=-atheos
+ ;;
+ -syllable*)
+ os=-syllable
+ ;;
+ -386bsd)
+ os=-bsd
+ ;;
+ -ctix* | -uts*)
+ os=-sysv
+ ;;
+ -nova*)
+ os=-rtmk-nova
+ ;;
+ -ns2 )
+ os=-nextstep2
+ ;;
+ -nsk*)
+ os=-nsk
+ ;;
+ # Preserve the version number of sinix5.
+ -sinix5.*)
+ os=`echo $os | sed -e 's|sinix|sysv|'`
+ ;;
+ -sinix*)
+ os=-sysv4
+ ;;
+ -tpf*)
+ os=-tpf
+ ;;
+ -triton*)
+ os=-sysv3
+ ;;
+ -oss*)
+ os=-sysv3
+ ;;
+ -svr4)
+ os=-sysv4
+ ;;
+ -svr3)
+ os=-sysv3
+ ;;
+ -sysvr4)
+ os=-sysv4
+ ;;
+ # This must come after -sysvr4.
+ -sysv*)
+ ;;
+ -ose*)
+ os=-ose
+ ;;
+ -es1800*)
+ os=-ose
+ ;;
+ -xenix)
+ os=-xenix
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ os=-mint
+ ;;
+ -aros*)
+ os=-aros
+ ;;
+ -kaos*)
+ os=-kaos
+ ;;
+ -zvmoe)
+ os=-zvmoe
+ ;;
+ -none)
+ ;;
+ *)
+ # Get rid of the `-' at the beginning of $os.
+ os=`echo $os | sed 's/[^-]*-//'`
+ echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
+ exit 1
+ ;;
+esac
+else
+
+# Here we handle the default operating systems that come with various machines.
+# The value should be what the vendor currently ships out the door with their
+# machine or put another way, the most popular os provided with the machine.
+
+# Note that if you're going to try to match "-MANUFACTURER" here (say,
+# "-sun"), then you have to tell the case statement up towards the top
+# that MANUFACTURER isn't an operating system. Otherwise, code above
+# will signal an error saying that MANUFACTURER isn't an operating
+# system, and we'll never get to this point.
+
+case $basic_machine in
+ *-acorn)
+ os=-riscix1.2
+ ;;
+ arm*-rebel)
+ os=-linux
+ ;;
+ arm*-semi)
+ os=-aout
+ ;;
+ c4x-* | tic4x-*)
+ os=-coff
+ ;;
+ # This must come before the *-dec entry.
+ pdp10-*)
+ os=-tops20
+ ;;
+ pdp11-*)
+ os=-none
+ ;;
+ *-dec | vax-*)
+ os=-ultrix4.2
+ ;;
+ m68*-apollo)
+ os=-domain
+ ;;
+ i386-sun)
+ os=-sunos4.0.2
+ ;;
+ m68000-sun)
+ os=-sunos3
+ # This also exists in the configure program, but was not the
+ # default.
+ # os=-sunos4
+ ;;
+ m68*-cisco)
+ os=-aout
+ ;;
+ mips*-cisco)
+ os=-elf
+ ;;
+ mips*-*)
+ os=-elf
+ ;;
+ or32-*)
+ os=-coff
+ ;;
+ *-tti) # must be before sparc entry or we get the wrong os.
+ os=-sysv3
+ ;;
+ sparc-* | *-sun)
+ os=-sunos4.1.1
+ ;;
+ *-be)
+ os=-beos
+ ;;
+ *-haiku)
+ os=-haiku
+ ;;
+ *-ibm)
+ os=-aix
+ ;;
+ *-knuth)
+ os=-mmixware
+ ;;
+ *-wec)
+ os=-proelf
+ ;;
+ *-winbond)
+ os=-proelf
+ ;;
+ *-oki)
+ os=-proelf
+ ;;
+ *-hp)
+ os=-hpux
+ ;;
+ *-hitachi)
+ os=-hiux
+ ;;
+ i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
+ os=-sysv
+ ;;
+ *-cbm)
+ os=-amigaos
+ ;;
+ *-dg)
+ os=-dgux
+ ;;
+ *-dolphin)
+ os=-sysv3
+ ;;
+ m68k-ccur)
+ os=-rtu
+ ;;
+ m88k-omron*)
+ os=-luna
+ ;;
+ *-next )
+ os=-nextstep
+ ;;
+ *-sequent)
+ os=-ptx
+ ;;
+ *-crds)
+ os=-unos
+ ;;
+ *-ns)
+ os=-genix
+ ;;
+ i370-*)
+ os=-mvs
+ ;;
+ *-next)
+ os=-nextstep3
+ ;;
+ *-gould)
+ os=-sysv
+ ;;
+ *-highlevel)
+ os=-bsd
+ ;;
+ *-encore)
+ os=-bsd
+ ;;
+ *-sgi)
+ os=-irix
+ ;;
+ *-siemens)
+ os=-sysv4
+ ;;
+ *-masscomp)
+ os=-rtu
+ ;;
+ f30[01]-fujitsu | f700-fujitsu)
+ os=-uxpv
+ ;;
+ *-rom68k)
+ os=-coff
+ ;;
+ *-*bug)
+ os=-coff
+ ;;
+ *-apple)
+ os=-macos
+ ;;
+ *-atari*)
+ os=-mint
+ ;;
+ *)
+ os=-none
+ ;;
+esac
+fi
+
+# Here we handle the case where we know the os, and the CPU type, but not the
+# manufacturer. We pick the logical manufacturer.
+vendor=unknown
+case $basic_machine in
+ *-unknown)
+ case $os in
+ -riscix*)
+ vendor=acorn
+ ;;
+ -sunos*)
+ vendor=sun
+ ;;
+ -aix*)
+ vendor=ibm
+ ;;
+ -beos*)
+ vendor=be
+ ;;
+ -hpux*)
+ vendor=hp
+ ;;
+ -mpeix*)
+ vendor=hp
+ ;;
+ -hiux*)
+ vendor=hitachi
+ ;;
+ -unos*)
+ vendor=crds
+ ;;
+ -dgux*)
+ vendor=dg
+ ;;
+ -luna*)
+ vendor=omron
+ ;;
+ -genix*)
+ vendor=ns
+ ;;
+ -mvs* | -opened*)
+ vendor=ibm
+ ;;
+ -os400*)
+ vendor=ibm
+ ;;
+ -ptx*)
+ vendor=sequent
+ ;;
+ -tpf*)
+ vendor=ibm
+ ;;
+ -vxsim* | -vxworks* | -windiss*)
+ vendor=wrs
+ ;;
+ -aux*)
+ vendor=apple
+ ;;
+ -hms*)
+ vendor=hitachi
+ ;;
+ -mpw* | -macos*)
+ vendor=apple
+ ;;
+ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
+ vendor=atari
+ ;;
+ -vos*)
+ vendor=stratus
+ ;;
+ esac
+ basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
+ ;;
+esac
+
+echo $basic_machine$os
+exit
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:
--- /dev/null
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ(2.59)
+
+m4_define([PBX_VERSION],
+ m4_bpatsubst(m4_esyscmd([build_tools/make_version .]),
+ [\([0-9.]*\)\(\w\|\W\)*],
+ [\1]))
+AC_INIT(asterisk, PBX_VERSION, www.asterisk.org)
+
+# cross-compile macros
+AC_CANONICAL_BUILD
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+
+# check existence of the package
+AC_CONFIG_SRCDIR([asterisk.c])
+
+# specify output header file
+AC_CONFIG_HEADER(include/autoconfig.h)
+
+AC_COPYRIGHT("Asterisk")
+AC_REVISION($Revision$)
+
+AC_PREFIX_DEFAULT()
+
+### ** Platform.
+AC_DEFINE_UNQUOTED(PBX_PLATFORM, "${host}",
+[Define this to be the canonical name (cpu-vendor-os) of your system.])
+AC_DEFINE_UNQUOTED(PBX_CPU, "${host_cpu}",
+[Define this to be the name of the CPU of your system.])
+AC_DEFINE_UNQUOTED(PBX_VENDOR, "${host_vendor}",
+[Define this to be the name of the vendor of your system.])
+AC_DEFINE_UNQUOTED(PBX_OS, "${host_os}",
+[Define this to be the name of the OS of your system.])
+
+# export some useful defines
+PBX_PLATFORM=${host}
+PBX_CPU=${host_cpu}
+PBX_VENDOR=${host_vendor}
+PBX_OS=${host_os}
+AC_SUBST(PBX_PLATFORM)
+AC_SUBST(PBX_CPU)
+AC_SUBST(PBX_VENDOR)
+AC_SUBST(PBX_OS)
+
+# check for uname
+AC_PATH_TOOL([UNAME], [uname], No)
+if test ! x"${UNAME}" = xNo; then
+ PBX_OSREV=$(${UNAME} -r)
+fi
+AC_SUBST(PBX_OSREV)
+
+# guest OS type
+case "${host}" in
+ cygwin*|mingw*|windows*|winnt)
+ AC_DEFINE(Win32, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="CYGWIN"
+# this is ugly - KPF
+ OSISWIN32=1
+ AC_SUBST(OSISWIN32)
+ ;;
+ *linux*)
+ AC_DEFINE(Linux, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="Linux"
+ ;;
+ *netbsd*)
+ AC_DEFINE(NetBSD, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="NetBSD"
+ ;;
+ *freebsd*)
+ AC_DEFINE(FreeBSD, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="FreeBSD"
+ ;;
+ *openbsd*)
+ AC_DEFINE(OpenBSD, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="OpenBSD"
+ ;;
+ *sun*)
+ AC_DEFINE(SunOS, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="SunOS"
+ ;;
+ *darwin*)
+ AC_DEFINE(Darwin, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="Darwin"
+ ;;
+ *)
+ AC_DEFINE(Unix, 1,
+ [Define according to your operating system type.])
+ PBX_OSTYPE="Unix"
+ ;;
+esac
+AC_SUBST(PBX_OSTYPE)
+
+# This needs to be before any macros that use the C compiler
+AC_GNU_SOURCE
+
+AH_TOP(
+#ifndef _REENTRANT
+#define _REENTRANT
+#endif
+)
+
+# cross-compile checks
+if test x"${build}" != x"${host}";
+then
+ AC_CHECK_TOOL(CC, gcc, :)
+ AC_CHECK_TOOL(CXX, g++, :)
+ AC_CHECK_TOOL(RANLIB, ranlib, :)
+ AC_CHECK_TOOL(AR, ar, :)
+
+ if test x"${PBX_OSTYPE}" = xWin32;
+ then
+ AC_CHECK_TOOL(NM, nm, :)
+ AC_CHECK_TOOL(WINDRES, windres, :)
+ AC_CHECK_TOOL(DLLWRAP, dllwrap, :)
+ fi
+ crossCompile="Yes"
+fi
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_CXX
+AC_PROG_CPP
+AC_PROG_CXXCPP
+AC_PROG_AWK
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_RANLIB
+AST_CHECK_GNU_MAKE
+
+AC_PATH_PROG([GREP], [grep], :)
+AC_PATH_PROG([AR], [ar], :)
+AC_PATH_PROG([FIND], [find], :)
+AC_PATH_PROG([COMPRESS], [compress], :)
+AC_PATH_PROG([BASENAME], [basename], :)
+AC_PATH_PROG([DIRNAME], [dirname], :)
+AC_PATH_PROG([SHELL], [sh], :)
+AC_PATH_PROG([LN], [ln], :)
+AC_PATH_PROG([DOT], [dot], :)
+
+AC_LANG(C)
+
+AC_ARG_ENABLE(dev-mode,
+ [ --enable-dev-mode Turn on developer mode],
+ [case "${enableval}" in
+ y|ye|yes) AST_DEVMODE=yes ;;
+ n|no) AST_DEVMODE=no ;;
+ *) AC_MSG_ERROR(bad value ${enableval} for --enable-dev-mode) ;;
+ esac])
+AC_SUBST(AST_DEVMODE)
+
+AST_EXT_LIB([asound], [snd_spcm_init], [alsa/asoundlib.h], [ALSA], [Advanced Linux Sound Architecture], [-lm -ldl])
+AST_EXT_LIB([curses], [initscr], [curses.h], [CURSES], [curses], [])
+AST_EXT_LIB([mfcr2], [mfcr2_MakeCall], [libmfcr2.h], [MFCR2], [MFCR2])
+AST_EXT_LIB([nbs], [nbs_setup], [nbs.h], [NBS], [Network Broadcast Sound])
+AST_EXT_LIB([newt], [newtBell], [newt.h], [NEWT], [newt])
+AST_EXT_LIB([odbc], [SQLConnect], [sql.h], [UNIXODBC], [unixODBC])
+AST_EXT_LIB([ogg], [ogg_sync_init], [], [OGG], [OGG])
+AST_EXT_LIB([osptk], [OSPPCryptoDecrypt], [osp/osp.h], [OSPTK], [OSP Toolkit], [-lcrypto -lssl])
+AST_EXT_LIB([popt], [poptStrerror], [popt.h], [POPT], [popt])
+AST_EXT_LIB([pri], [pri_call], [libpri.h], [LIBPRI], [ISDN PRI])
+AST_EXT_LIB([speex], [speex_encode], [speex/speex.h], [SPEEX], [Speex], [-lm])
+AST_EXT_LIB([sqlite], [sqlite_exec], [sqlite.h], [SQLITE], [SQLite])
+AST_EXT_LIB([ssl], [ssl2_connect], [openssl/ssl.h], [OPENSSL], [OpenSSL], [-lcrypto])
+AST_EXT_LIB([tds], [tds_version], [tds.h], [FREETDS], [FreeTDS])
+AST_EXT_LIB([vorbis], [vorbis_info_init], [vorbis/codec.h], [VORBIS], [Vorbis], [-lm -lvorbisenc])
+AST_EXT_LIB([z], [compress], [zlib.h], [ZLIB], [zlib])
+
+if test "x${PBX_OSTYPE}" = "xLinux" ; then
+ AST_EXT_LIB([ossaudio], [oss_ioctl_mixer], [linux/soundcard.h], [OSS], [Open Sound System])
+elif test "x${PBX_OSTYPE}" = "xFreeBSD" ; then
+ AST_EXT_LIB([ossaudio], [oss_ioctl_mixer], [sys/soundcard.h], [OSS], [Open Sound System])
+else
+ AST_EXT_LIB([ossaudio], [oss_ioctl_mixer], [soundcard.h], [OSS], [Open Sound System])
+fi
+
+if test "x${PBX_OSTYPE}" = "xLinux" ; then
+ AST_EXT_LIB([tonezone], [tone_zone_find], [linux/zaptel.h], [ZAPTEL], [Zaptel])
+else
+ AST_EXT_LIB([tonezone], [tone_zone_find], [zaptel.h], [ZAPTEL], [Zaptel])
+fi
+
+GSM_INTERNAL="yes"
+GSM_SYSTEM="yes"
+AC_ARG_WITH([gsm], AC_HELP_STRING([--with-gsm=PATH], [use libgsm files in PATH, or 'internal']), [
+case ${withval} in
+ n|no)
+ USE_GSM=no
+ ;;
+ y|ye|yes)
+ ;;
+ internal)
+ GSM_SYSTEM="no"
+ ;;
+ *)
+ GSM_DIR="${withval}"
+ GSM_INTERNAL="no"
+ ;;
+esac
+])
+
+PBX_LIBgsm=0
+
+if test "${USE_GSM}" != "no"; then
+ if test "${GSM_SYSTEM}" = "yes"; then
+ AC_CHECK_LIB([gsm], [gsm_create], AC_DEFINE_UNQUOTED([HAVE_GSM], 1,
+ [Define to indicate the GSM library]), [], -L${GSM_DIR}/lib)
+ if test "${ac_cv_lib_gsm_gsm_create}" = "yes"; then
+ gsm_LIB="-lgsm"
+ if test "x${GSM_DIR}" != "x"; then
+ gsm_LIB="-L${GSM_DIR}/lib ${gsm_LIB}"
+ gsm_INCLUDE="-I${GSM_DIR}/include"
+ fi
+ PBX_LIBgsm=1
+ GSM_INTERNAL="no"
+ fi
+ fi
+ if test "${GSM_INTERNAL}" = "yes"; then
+ gsm_LIB="internal"
+ PBX_LIBgsm=1
+ fi
+ if test "x${PBX_LIBgsm}" = "x0"; then
+ echo "***"
+ echo "*** The GSM installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-gsm"
+ exit 1
+ fi
+fi
+
+AC_SUBST([gsm_LIB])
+AC_SUBST([gsm_INCLUDE])
+AC_SUBST([PBX_LIBgsm])
+
+AC_ARG_WITH([pq], AC_HELP_STRING([--with-pq=PATH],[use PostgreSQL files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_PQ=no
+ ;;
+ y|ye|yes)
+ PQ_MANDATORY="yes"
+ ;;
+ *)
+ PQ_DIR="${withval}"
+ PQ_MANDATORY="yes"
+ ;;
+esac
+])
+
+PBX_LIBpq=0
+PG_CONFIG=No
+if test "${USE_PQ}" != "no"; then
+ if test "x${PQ_DIR}" != "x"; then
+ AC_PATH_TOOL([PG_CONFIG], [pg_config], No, [${PQ_DIR}/bin])
+ if test x"${PG_CONFIG}" = xNo; then
+ echo "***"
+ echo "*** pg_config was not found in the path you specified:"
+ echo "*** ${PQ_DIR}/bin"
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-pq"
+ exit 1
+ fi
+ else
+ AC_PATH_TOOL([PG_CONFIG], [pg_config], No)
+ fi
+fi
+
+if test x"${PG_CONFIG}" != xNo; then
+ PQ_libdir=`pg_config --libdir`
+ PQ_includedir=`pg_config --includedir`
+
+ AC_CHECK_LIB([pq], [PQexec], AC_DEFINE_UNQUOTED([HAVE_PQ], 1,
+ [Define to indicate the PostgreSQL library]), [], -L${PQ_libdir} -lz)
+
+ if test "${ac_cv_lib_pq_PQexec}" = "yes"; then
+ pq_LIB="-L${PQ_libdir} -lpq -lz"
+ pq_INCLUDE="-I${PQ_includedir}"
+ PBX_LIBpq=1
+ elif test ! -z "${PQ_MANDATORY}";
+ then
+ echo "***"
+ echo "*** The PostgreSQL installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-pq"
+ exit 1
+ fi
+fi
+AC_SUBST([pq_INCLUDE])
+AC_SUBST([pq_LIB])
+AC_SUBST([PBX_LIBpq])
+
+PBX_H323=0
+AC_CHECK_HEADER([h323.h], [PBX_H323=1], [])
+AC_SUBST(PBX_H323)
+
+HAVE_QUICKNET=0
+AC_CHECK_HEADER([ixjuser.h], [HAVE_QUICKNET=1],[])
+AC_SUBST(HAVE_QUICKNET)
+
+AC_ARG_WITH([vpb], AC_HELP_STRING([--with-vpb=PATH],[use vpb files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_VPB=no
+ VPB_MANDATORY="yes"
+ ;;
+ y|ye|yes)
+ ;;
+ *)
+ VPB_DIR="${withval}"
+ VPB_MANDATORY="yes"
+ ;;
+esac
+])
+if test "${USE_VPB}" != "no"; then
+ echo -n "checking for vpb_open in -lvpb..."
+ saved_ldflags="${LDFLAGS}"
+ LDFLAGS="${LDFLAGS} -L${VPB_DIR} -lvpb"
+ AC_LINK_IFELSE(
+ [
+ AC_LANG_PROGRAM(
+ [#include "${VPB_DIR}vpbapi.h"],
+ [int q = vpb_open(0,0);])
+ ],
+ [ AC_MSG_RESULT(yes)
+ ac_cv_lib_vpb_vpb_open="yes"
+ ],
+ [ AC_MSG_RESULT(no)
+ ac_cv_lib_vpb_vpb_open="no"
+ ]
+ )
+ LDFLAGS="${saved_ldflags}"
+
+ PBX_LIBvpb=0
+ if test "${ac_cv_lib_vpb_vpb_open}" = "yes"; then
+ VPB_LIB="-lvpb"
+ if test "${VPB_DIR}" != ""; then
+ VPB_LIB="-L${VPB_DIR}/lib ${VPB_LIB}"
+ VPB_INCLUDE="-I${VPB_DIR}/include"
+ AC_SUBST([VPB_INCLUDE])
+ fi
+ AC_SUBST([VPB_LIB])
+ PBX_LIBvpb=1
+ AC_DEFINE([HAVE_LIBVPB], 1, [Define if your system has the VoiceTronix (vpb) libraries.])
+ elif test ! -z "${VPB_MANDATORY}";
+ then
+ echo "***"
+ echo "*** The VoiceTronix (vpb) installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-vpb."
+ exit 1
+ fi
+fi
+AC_SUBST([PBX_LIBvpb])
+
+
+AC_LANG_PUSH(C++)
+
+AC_ARG_WITH([qt], AC_HELP_STRING([--with-qt=PATH],[use Qt files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_QT=no
+ QT_MANDATORY="yes"
+ ;;
+ y|ye|yes)
+ ;;
+ *)
+ QT_DIR="${withval}"
+ QT_MANDATORY="yes"
+ ;;
+esac
+])
+
+PBX_QT=0
+if test "${USE_QT}" != "no"; then
+ echo -n "checking for QDate in -lqt..."
+ saved_ldflags="${LDFLAGS}"
+ LDFLAGS="${LDFLAGS} -L${QT_DIR}/lib -lqt"
+ qtlib="qt"
+ AC_LINK_IFELSE(
+ [
+ AC_LANG_PROGRAM(
+ [#include "${QT_DIR}include/qdatetime.h"],
+ [QDate date();])
+ ],
+ [ac_cv_lib_qt_qt_date="yes"],
+ [ac_cv_lib_qt_qt_date="no"])
+
+ if test "${ac_cv_lib_qt_qt_date}" = "no"; then
+ qtlib="qt-mt"
+ LDFLAGS="${saved_ldflags} -L${QT_DIR}/lib -lqt-mt"
+ AC_LINK_IFELSE(
+ [
+ AC_LANG_PROGRAM(
+ [#include "${QT_DIR}include/qdatetime.h"],
+ [QDate date();])
+ ],
+ [ac_cv_lib_qt_qt_date="yes"],
+ [ac_cv_lib_qt_qt_date="no"])
+ fi
+
+ LDFLAGS="${saved_ldflags}"
+
+ if test "${ac_cv_lib_qt_qt_date}" = "yes"; then
+ AC_MSG_RESULT(yes)
+ else
+ AC_MSG_RESULT(no)
+ fi
+
+ if test "${ac_cv_lib_qt_qt_date}" = "yes"; then
+ QT_LIB="-l${qtlib}"
+ if test "${QT_DIR}" != ""; then
+ QT_LIB="-L${QT_DIR}/lib ${QT_LIB}"
+ QT_INCLUDE="-I${QT_DIR}/include"
+ AC_SUBST([QT_INCLUDE])
+ fi
+ AC_SUBST([QT_LIB])
+ PBX_QT=1
+ AC_DEFINE([HAVE_LIBQT], 1, [Define if your system has the Qt library])
+ AC_PATH_TOOL(QTMOC, moc, No)
+ elif test ! -z "${QT_MANDATORY}";
+ then
+ echo "***"
+ echo "*** The Qt installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-qt."
+ exit 1
+ fi
+fi
+AC_SUBST([PBX_QT])
+
+
+
+
+AC_ARG_WITH([kde], AC_HELP_STRING([--with-kde=PATH],[use KDE files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_KDE=no
+ KDE_MANDATORY="yes"
+ ;;
+ y|ye|yes)
+ ;;
+ *)
+ KDE_DIR="${withval}"
+ KDE_MANDATORY="yes"
+ ;;
+esac
+])
+
+PBX_KDE=0
+if test "${USE_KDE}" != "no"; then
+ echo -n "checking for crashHandler in -lkdecore..."
+ saved_ldflags="${LDFLAGS}"
+ LDFLAGS="-I${KDE_DIR}/include ${LDFLAGS} -L${KDE_DIR}/lib -lkdecore"
+ AC_LINK_IFELSE(
+ [
+ AC_LANG_PROGRAM(
+ [#include "kcrash.h"],
+ [KCrash::defaultCrashHandler(1);])
+ ],
+ [ac_cv_lib_kde_crash="yes"],
+ [ac_cv_lib_kde_crash="no"])
+
+ LDFLAGS="${saved_ldflags}"
+
+ if test "${ac_cv_lib_kde_crash}" = "yes"; then
+ AC_MSG_RESULT(yes)
+ else
+ AC_MSG_RESULT(no)
+ fi
+
+ if test "${ac_cv_lib_kde_crash}" = "yes"; then
+ KDE_LIBS="-lkdecore -lkdeui"
+ if test "${KDE_DIR}" != ""; then
+ KDE_LIBS="-L${KDE_DIR}/lib ${KDE_LIBS}"
+ KDE_INCLUDE="-I${KDE_DIR}/include"
+ AC_SUBST([KDE_INCLUDE])
+ fi
+ AC_SUBST([KDE_LIBS])
+ PBX_KDE=1
+ AC_DEFINE([HAVE_LIBKDE], 1, [Define if your system has the KDE library])
+ elif test ! -z "${KDE_MANDATORY}";
+ then
+ echo "***"
+ echo "*** The KDE installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-kde."
+ exit 1
+ fi
+fi
+AC_SUBST([PBX_KDE])
+
+if test x"${PBX_KDE}" = x1; then
+ AC_PATH_TOOL(KDEINIT, kdeinit, No)
+ if test ! x"${KDEINIT}" = xNo; then
+ KDEDIR=$(${DIRNAME} ${KDEINIT})
+ KDEDIR=$(${DIRNAME} ${KDEDIR})
+ fi
+ AC_SUBST([KDEDIR])
+fi
+
+AC_LANG_POP
+
+PBX_GTK=0
+AC_CHECK_TOOL(GTKCONFIG, gtk-config, No)
+if test ! "x${GTKCONFIG}" = xNo; then
+ GTK_INCLUDE=$(${GTKCONFIG} --cflags gthread)
+ GTK_LIBS=$(${GTKCONFIG} --libs gthread)
+ PBX_GTK=1
+ AC_DEFINE([HAVE_GTK], 1, [Define if your system has the GTK libraries.])
+fi
+AC_SUBST(PBX_GTK)
+AC_SUBST(GTK_INCLUDE)
+AC_SUBST(GTK_LIBS)
+
+PLATFORM_PTLIB="ptlib_${OSTYPE}_${MACHTYPE}_r"
+
+AC_ARG_WITH([pwlib], AC_HELP_STRING([--with-pwlib=PATH],[use PWLib files in PATH]),[
+case ${withval} in
+ n|no)
+ USE_PWLIB=no
+ ;;
+ y|ye|yes)
+ ;;
+ *)
+ PWLIB_DIR="${withval}"
+ ;;
+esac
+])
+if test "${USE_PWLIB}" != "no"; then
+ echo -n "checking for existence of pwlib..."
+
+ saved_ldflags="${LDFLAGS}"
+ LDFLAGS="${LDFLAGS} -L${PWLIB_DIR} -l${PLATFORM_PTLIB}"
+
+ AC_LINK_IFELSE(
+ [
+ AC_LANG_PROGRAM(
+ [#include "${PWDIR_DIR}ptime.h"],
+ [int q = PTime::IsDaylightSaving();])
+ ],
+ [ AC_MSG_RESULT(yes)
+ ac_cv_lib_pwlib="yes"
+ ],
+ [ AC_MSG_RESULT(no)
+ ac_cv_lib_pwlib="no"
+ ]
+ )
+ LDFLAGS="${saved_ldflags}"
+
+ PBX_LIBPWLIB=0
+
+ if test "${ac_cv_lib_pwlib}" = "yes"; then
+ PWLIB_LIB="-l{PLATFORM_PWLIB}"
+ if test "${PWLIB_DIR}" != ""; then
+ PWLIB_LIB="-L${PWLIB_DIR}/lib ${PWLIB_LIB}"
+ PWLIB_INCLUDE="-I${PWLIB_DIR}/include"
+ AC_SUBST([PWLIB_INCLUDE])
+ fi
+ AC_SUBST([PWLIB_LIB])
+ PBX_LIBPWLIB=1
+ AC_DEFINE([HAVE_LIBPWLIB], 1, [Define if your system has the pwlib libraries.])
+ elif test ! -z "${PWLIB_DIR}";
+ then
+ echo "***"
+ echo "*** The PWLIB installation on this system appears to be broken."
+ echo "*** Either correct the installation, or run configure"
+ echo "*** including --without-pwlib"
+ exit 1
+ fi
+fi
+AC_SUBST([PBX_LIBPWLIB])
+
+PBX_CURL=0
+AC_PATH_TOOL([CURL], [curl-config], No)
+if test ! x"${CURL}" = xNo; then
+# check for version
+ CURLLIBS=$(${CURL} --libs)
+ PBX_CURL=1
+ AC_DEFINE([HAVE_CURL], 1, [Define if your system has the curl libraries.])
+fi
+AC_SUBST(PBX_CURL)
+AC_SUBST(CURLLIBS)
+
+AC_FUNC_ALLOCA
+AC_HEADER_DIRENT
+AC_HEADER_STDC
+AC_HEADER_SYS_WAIT
+AC_CHECK_HEADERS([arpa/inet.h fcntl.h inttypes.h libintl.h limits.h locale.h malloc.h netdb.h netinet/in.h stddef.h stdint.h stdlib.h string.h strings.h sys/file.h sys/ioctl.h sys/param.h sys/socket.h sys/time.h syslog.h termios.h unistd.h utime.h])
+
+AC_SYS_LARGEFILE
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_HEADER_STDBOOL
+AC_C_CONST
+AC_TYPE_UID_T
+AC_C_INLINE
+AC_TYPE_MODE_T
+AC_TYPE_OFF_T
+AC_TYPE_PID_T
+AC_TYPE_SIZE_T
+AC_CHECK_MEMBERS([struct stat.st_blksize])
+AC_HEADER_TIME
+AC_STRUCT_TM
+AC_C_VOLATILE
+AC_CHECK_TYPES([ptrdiff_t])
+
+# Checks for library functions.
+AC_FUNC_CHOWN
+AC_FUNC_CLOSEDIR_VOID
+AC_FUNC_ERROR_AT_LINE
+AC_FUNC_FORK
+AC_FUNC_FSEEKO
+AC_PROG_GCC_TRADITIONAL
+AC_FUNC_MALLOC
+AC_FUNC_MEMCMP
+AC_FUNC_MKTIME
+AC_FUNC_MMAP
+AC_FUNC_REALLOC
+AC_FUNC_SELECT_ARGTYPES
+AC_FUNC_SETVBUF_REVERSED
+AC_TYPE_SIGNAL
+AC_FUNC_STAT
+AC_FUNC_STRCOLL
+AC_FUNC_STRFTIME
+AC_FUNC_STRNLEN
+AC_FUNC_STRTOD
+AC_FUNC_UTIME_NULL
+AC_FUNC_VPRINTF
+AC_CHECK_FUNCS([atexit bzero dup2 endpwent floor ftruncate getcwd gethostbyname gethostname gettimeofday inet_ntoa isascii localtime_r memchr memmove memset mkdir munmap pow putenv re_comp regcomp rint select setenv socket sqrt strcasecmp strchr strcspn strdup strerror strncasecmp strndup strrchr strsep strspn strstr strtol unsetenv utime strtoq strcasestr asprintf vasprintf])
+
+AC_CONFIG_FILES([build_tools/menuselect-deps makeopts])
+AC_OUTPUT
+
+echo
+echo " .\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$=.. "
+echo " .\$7\$7.. .7\$\$7:. "
+echo " .\$\$:. ,\$7.7 "
+echo " .\$7. 7\$\$\$\$ .\$\$77 "
+echo " ..\$\$. \$\$\$\$\$ .\$\$\$7 "
+echo " ..7\$ .?. \$\$\$\$\$ .?. 7\$\$\$."
+echo " \$.\$. .\$\$\$7. \$\$\$\$7 .7\$\$\$. .\$\$\$."
+echo " .777. .\$\$\$\$\$\$77\$\$\$77\$\$\$\$\$7. \$\$\$,"
+echo " \$\$\$~ .7\$\$\$\$\$\$\$\$\$\$\$\$\$7. .\$\$\$."
+echo ".\$\$7 .7\$\$\$\$\$\$\$7: ?\$\$\$."
+echo "\$\$\$ ?7\$\$\$\$\$\$\$\$\$\$I .\$\$\$7 "
+echo "\$\$\$ .7\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$ :\$\$\$. "
+echo "\$\$\$ \$\$\$\$\$\$7\$\$\$\$\$\$\$\$\$\$\$\$ .\$\$\$. "
+echo "\$\$\$ \$\$\$ 7\$\$\$7 .\$\$\$ .\$\$\$. "
+echo "\$\$\$\$ \$\$\$\$7 .\$\$\$. "
+echo "7\$\$\$7 7\$\$\$\$ 7\$\$\$ "
+echo " \$\$\$\$\$ \$\$\$ "
+echo " \$\$\$\$7. \$\$ (TM) "
+echo " \$\$\$\$\$\$\$. .7\$\$\$\$\$\$ \$\$ "
+echo " \$\$\$\$\$\$\$\$\$\$\$\$7\$\$\$\$\$\$\$\$\$.\$\$\$\$\$\$ "
+echo " \$\$\$\$\$\$\$\$\$\$\$\$\$\$\$\$. "
+echo
+
+echo "Package configured for: "
+echo " OS type : $PBX_OSTYPE"
+echo " host cpu : $host_cpu"
+if test "x${crossCompile}" = xYes; then
+ echo ""
+ echo " Cross Compilation = YES"
+ echo " Target = ${host}"
+fi
+
#include <unistd.h>
#include <stdlib.h>
+#include "asterisk.h"
+
#include "asterisk/crypto.h"
#include "asterisk/logger.h"
CFLAGS += -mtune=$(PROC) -O3 -pipe -fomit-frame-pointer -mcpu=v8
endif
+ifeq ($(OSARCH),Darwin)
+ OSARCH_DEFINE+=-D__Darwin__
+endif
+
LIBDBSO=libdb.so.$(SOVER)
PROG= db_dump185
OBJ1= hash.o hash_bigkey.o hash_buf.o hash_func.o hash_log2.o hash_page.o \
db_dump185.o: db_dump185.c
$(CL) -o $@ $<
%.o: hash/%.c
- $(CL) -Ihash -o $@ $<
+ $(CL) -Ihash $(OSARCH_DEFINE) -o $@ $<
%.os: hash/%.c
$(CL) -Ihash -fPIC -o $@ $<
%.o: btree/%.c
#include <assert.h>
#endif
-#include "../include/asterisk/compat.h"
-
#include <db.h>
#include "hash.h"
#include "page.h"
if (fr)
ast_log(LOG_WARNING, "Failed to write frame\n");
s->owner->streamid = -1;
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
ast_settimeout(s->owner, 0, NULL, NULL);
#endif
return 0;
}
}
if (whennext != s->lasttimeout) {
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
if (s->owner->timingfd > -1)
ast_settimeout(s->owner, whennext, ast_readaudio_callback, s);
else
if (f->owner->streamid > -1)
ast_sched_del(f->owner->sched, f->owner->streamid);
f->owner->streamid = -1;
-#ifdef ZAPTEL_OPTIMIZATIONS
+#ifdef HAVE_ZAPTEL
ast_settimeout(f->owner, 0, NULL, NULL);
#endif
} else {
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard format_*.c))
-
-# OGG/Vorbis format
-# (on FreeBSD is in /usr/local/include/...
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/vorbis/codec.h),)
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/vorbis/codec.h),)
- MODS:=$(filter-out format_ogg_vorbis.so,$(MODS))
-endif
-endif
+MODS:=$(filter-out $(MENUSELECT_FORMATS),$(patsubst %.c,%.so,$(wildcard format_*.c)))
GSMLIB=../codecs/gsm/lib/libgsm.a
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -lasterisk.dll
-else
- CFLAGS+=-fPIC
-endif
-
all: depend $(MODS)
clean-depend:
rm -f *.so *.o
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+ $(CC) $(SOLINK) -o $@ $<
ifneq ($(wildcard .depend),)
include .depend
endif
-format_mp3.so : format_mp3.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lm
-
format_ogg_vorbis.so : format_ogg_vorbis.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -logg -lvorbis -lvorbisenc -lm
+ $(CC) $(SOLINK) -o $@ $< $(OGG_LIB) $(VORBIS_LIB)
+
+format_ogg_vorbis.o: format_ogg_vorbis.c
+ $(CC) -c -o $@ $(CFLAGS) $(OGG_INCLUDE) $(VORBIS_INCLUDE) $<
install: all
for x in $(MODS); do $(INSTALL) -m 755 $$x $(DESTDIR)$(MODULES_DIR) ; done
* \ingroup formats
*/
+/*** MODULEINFO
+ <depend>libvorbis</depend>
+ <depend>ogg</depend>
+ ***/
+
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
}
STD_MOD1;
+
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard func_*.c))
-
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/odbcinst.h $(CROSS_COMPILE_TARGET)/usr/local/include/odbcinst.h),)
- MODS:=$(filter-out func_odbc.so,$(MODS))
-endif
+MODS:=$(filter-out $(MENUSELECT_FUNCS),$(patsubst %.c,%.so,$(wildcard func_*.c)))
+# TODO This check needs to be handled with autoconf
ifeq ($(OSARCH),SunOS)
-ifneq ($(shell if [ 0x`$(CROSS_COMPILE_BIN)curl-config --vernum` -ge 0x70907 ]; then echo "OK" ; fi),)
- CURLLIBS:=$(shell $(CROSS_COMPILE_BIN)curl-config --libs)
-endif
+ ifeq ($(shell if [ 0x`$(CROSS_COMPILE_BIN)curl-config --vernum` -ge 0x70907 ]; then echo "OK" ; fi),)
+ MODS:=$(filter-out func_curl.so,$(MODS))
+ endif
else
-ifneq ($(shell if [[ 0x`$(CROSS_COMPILE_BIN)curl-config --vernum` -ge 0x70907 ]]; then echo "OK" ; fi),)
- CURLLIBS:=$(shell $(CROSS_COMPILE_BIN)curl-config --libs)
-endif
-endif
-
-ifeq (${CURLLIBS},)
- MODS:=$(filter-out func_curl.so,$(MODS))
-endif
-
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -lasterisk.dll
-else
- CFLAGS+=-fPIC
+ ifeq ($(shell if [[ 0x`$(CROSS_COMPILE_BIN)curl-config --vernum` -ge 0x70907 ]]; then echo "OK" ; fi),)
+ MODS:=$(filter-out func_curl.so,$(MODS))
+ endif
endif
all: $(MODS)
rm -f *.so *.o
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+ $(CC) $(SOLINK) -o $@ $<
func_curl.so: func_curl.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(CURLLIBS)
+ $(CC) $(SOLINK) -o $@ $< $(CURL_LIB)
+
+func_curl.o: func_curl.c
+ $(CC) -c -o $@ $(CFLAGS) $(CURL_INCLUDE) $<
func_odbc.so: func_odbc.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lodbc
+ $(CC) $(SOLINK) -o $@ $< $(ODBC_LIB)
+
+func_odbc.o: func_odbc.c
+ $(CC) -c -o $@ $(CFLAGS) $(ODBC_INCLUDE) $<
install: all
for x in $(MODS); do $(INSTALL) -m 755 $$x $(DESTDIR)$(MODULES_DIR) ; done
* \ingroup functions
*/
+/*** MODULEINFO
+ <depend>curl</depend>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
}
STD_MOD(MOD_1 | NO_USECOUNT, NULL, NULL, NULL);
+
* \author Tilghman Lesher <func_odbc__200508@the-tilghman.com>
*/
+/*** MODULEINFO
+ <depend>unixodbc</depend>
+ ***/
+
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
{
return ASTERISK_GPL_KEY;
}
+
STD_MOD(MOD_1, reload, NULL, NULL);
+
*
* General Definitions for Asterisk top level program
*
- * Copyright (C) 1999-2005, Mark Spencer
+ * Copyright (C) 1999-2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
*
* \brief Asterisk main include file. File version handling, generic pbx functions.
*/
-#include "asterisk/compat.h"
-
#ifndef _ASTERISK_H
#define _ASTERISK_H
+#include "asterisk/compat.h"
+
#define DEFAULT_LANGUAGE "en"
#define DEFAULT_SAMPLE_RATE 8000
* \brief Asterisk memory usage debugging
*/
-#ifndef NO_AST_MM
#ifndef _ASTERISK_ASTMM_H
#define _ASTERISK_ASTMM_H
#else
#error "NEVER INCLUDE astmm.h DIRECTLY!!"
#endif /* _ASTERISK_ASTMM_H */
-#endif
/*
* Asterisk -- A telephony toolkit for Linux.
*
- * Copyright (C) 1999-2005, Mark Spencer
+ * Copyright (C) 1999-2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
*
#ifndef _COMPAT_H
#define _COMPAT_H
+#ifndef HAVE_STRSEP
+char* strsep(char** str, const char* delims);
+#endif
+
+#ifndef HAVE_SETENV
+int setenv(const char *name, const char *value, int overwrite);
+#endif
+
+#ifndef HAVE_UNSETENV
+int unsetenv(const char *name);
+#endif
+
#ifdef SOLARIS
#define __BEGIN_DECLS
#define __END_DECLS
typedef unsigned int u_int32_t;
#endif
-char* strsep(char** str, const char* delims);
-int setenv(const char *name, const char *value, int overwrite);
-int unsetenv(const char *name);
#endif /* SOLARIS */
#ifdef __CYGWIN__
#endif
#endif /* __CYGWIN__ */
-#define HAVE_ASPRINTF
-#define HAVE_VASPRINTF
-#define HAVE_STRTOQ
-
-#ifdef _BSD_SOURCE
-#define HAVE_GETLOADAVG
-#endif
-
#ifdef __linux__
#include <inttypes.h>
-#define HAVE_STRCASESTR
-#define HAVE_STRNDUP
-#define HAVE_STRNLEN
#endif
#ifdef __Darwin__
#include <sys/types.h>
#endif
-#ifdef SOLARIS
-#undef HAVE_ASPRINTF
-#undef HAVE_VASPRINTF
-#undef HAVE_STRTOQ
-#endif
-
#ifdef __CYGWIN__
-#undef HAVE_STRTOQ
typedef unsigned long long uint64_t;
#endif
--- /dev/null
+CC=@CC@
+HOST_CC=@CC@
+CXX=@CXX@
+
+INSTALL=@INSTALL@
+GREP=@GREP@
+AR=@AR@
+RANLIB=@RANLIB@
+FIND=@FIND@
+COMPRESS=@COMPRESS@
+BASENAME=@BASENAME@
+SHELL=@SHELL@
+LN=@LN@
+QTMOC=@QTMOC@
+DOT=@DOT@
+
+CROSS_ARCH=@PBX_OSTYPE@
+CROSS_PROC=@PBX_CPU@
+PROC=@PBX_CPU@
+OSARCH=@PBX_OSTYPE@
+OSREV=@PBX_OSREV@
+
+INSTALL_PREFIX=@prefix@
+
+AST_DEVMODE=@AST_DEVMODE@
+
+OGG_LIB=@ogg_LIB@
+OGG_INCLUDE=@ogg_INCLUDE@
+
+VORBIS_LIB=@vorbis_LIB@
+VORBIS_INCLUDE=@vorbis_INCLUDE@
+
+ASOUND_LIB=@asound_LIB@
+ASOUND_INCLUDE=@asound_INCLUDE@
+
+NBS_LIB=@nbs_LIB@
+NBS_INCLUDE=@nbs_INCLUDE@
+
+OSSAUDIO_LIB=@ossaudio_LIB@
+OSSAUDIO_INCLUDE=@ossaudio_INCLUDE@
+
+SPEEX_LIB=@speex_LIB@
+SPEEX_INCLUDE=@speex_INCLUDE@
+
+ZAPTEL_LIB=@tonezone_LIB@
+ZAPTEL_INCLUDE=@tonezone_INCLUDE@
+
+VPB_LIB=@VPB_LIB@
+VPB_INCLUDE=@VPB_INCLUDE@
+
+PRI_LIB=@pri_LIB@
+PRI_INCLUDE=@pri_INCLUDE@
+
+MFCR2_LIB=@mfcr2_LIB@
+MFCR2_INCLUDE=@mfcr2_INCLUDE@
+
+OSPTK_LIB=@osptk_LIB@
+OSPTK_INCLUDE=@osptk_INCLUDE@
+
+ODBC_LIB=@odbc_LIB@
+ODBC_INCLUDE=@odbc_INCLUDE@
+
+PGSQL_LIB=@pq_LIB@
+PGSQL_INCLUDE=@pq_INCLUDE@
+
+SQLITE_LIB=@sqlite_LIB@
+SQLITE_INCLUDE=@sqlite_INCLUDE@
+
+TDS_LIB=@tds_LIB@
+TDS_INCLUDE=@tds_INCLUDE@
+
+POPT_LIB=@popt_LIB@
+POPT_INCLUDE=@popt_INCLUDE@
+
+NEWT_LIB=@newt_LIB@
+NEWT_INCLUDE=@newt_INCLUDE@
+
+PWLIB_LIB=@PWLIB_LIB@
+PWLIB_INCLUDE=@PWLIB_INCLUDE@
+
+SSL_LIB=@ssl_LIB@
+SSL_INCLUDE=@ssl_INCLUDE@
+
+Z_LIB=@z_LIB@
+Z_INCLUDE=@z_INCLUDE@
+
+QT_LIB=@QT_LIB@
+QT_INCLUDE=@QT_INCLUDE@
+
+KDEDIR=@KDEDIR@
+KDE_INCLUDE=@KDE_INCLUDE@
+KDE_LIBS=@KDE_LIBS@
+
+GTK_INCLUDE=@GTK_INCLUDE@
+GTK_LIBS=@GTK_LIBS@
+
+CURL_LIB=@CURLLIBS@
+
+GSM_LIB=@gsm_LIB@
+GSM_INCLUDE=@gsm_INCLUDE@
+
+CURSES_LIB=@curses_LIB@
+CURSES_INCLUDE=@curses_INCLUDE@
--- /dev/null
+*.bck
+*.bak
+Makefile
+autom4te*.cache
+config.cache
+config.h
+config.log
+config.status
+libmxml.a
+mxml.list
+mxmldoc
+testmxml
--- /dev/null
+Mini-XML 2.2.2 is now available for download from:
+
+ http://www.easysw.com/~mike/mxml/software.php
+
+Mini-XML 2.2.2 fixes a bug in the reading of custom data nodes.
--- /dev/null
+CHANGES - 05/19/2005
+--------------------
+
+CHANGES IN Mini-XML 2.2.2
+
+ - mxmlLoad*() did not treat custom data as opaque, so
+ whitespace characters would be lost.
+
+
+CHANGES IN Mini-XML 2.2.1
+
+ - mxmlLoadFd(), mxmlLoadFile(), and mxmlLoadString() now
+ correctly return NULL on error (STR #21)
+ - mxmlNewInteger(), mxmlNewOpaque(), mxmlNewReal(),
+ mxmlNewText(), and mxmlNewTextf() incorrectly required
+ a parent node (STR #22)
+ - Fixed an XML output bug in mxmldoc.
+ - The "make install" target now uses the install command
+ to set the proper permissions on UNIX/Linux/OSX.
+ - Fixed a MingW/Cygwin compilation problem (STR #18)
+
+
+CHANGES IN Mini-XML 2.2
+
+ - Added shared library support (STR #17)
+ - mxmlLoad*() now returns an error when an XML stream
+ contains illegal control characters (STR #10)
+ - mxmlLoad*() now returns an error when an element
+ contains two attributes with the same name in
+ conformance with the XML spec (STR #16)
+ - Added support for CDATA (STR #14, STR #15)
+ - Updated comment and processing instruction handling -
+ no entity support per XML specification.
+ - Added checking for invalid comment termination ("--->"
+ is not allowed)
+
+
+CHANGES IN Mini-XML 2.1
+
+ - Added support for custom data nodes (STR #6)
+ - Now treat UTF-8 sequences which are longer than
+ necessary as an error (STR #4)
+ - Fixed entity number support (STR #8)
+ - Fixed mxmlLoadString() bug with UTF-8 (STR #7)
+ - Fixed entity lookup bug (STR #5)
+ - Added mxmlLoadFd() and mxmlSaveFd() functions.
+ - Fixed multi-word UTF-16 handling.
+
+
+CHANGES IN Mini-XML 2.0
+
+ - New programmers manual.
+ - Added Visual C++ project files for Microsoft Windows
+ users.
+ - Added optimizations to mxmldoc, mxmlSaveFile(), and
+ mxmlIndexNew() (STR #2)
+ - mxmlEntityAddCallback() now returns an integer status
+ (STR #2)
+ - Added UTF-16 support (input only; all output is UTF-8)
+ - Added index functions to build a searchable index of
+ XML nodes.
+ - Added character entity callback interface to support
+ additional character entities beyond those defined in
+ the XHTML specification.
+ - Added support for XHTML character entities.
+ - The mxmldoc utility now produces XML output which
+ conforms to an updated XML schema, described in the file
+ "doc/mxmldoc.xsd".
+ - Changed the whitespace callback interface to return
+ strings instead of a single character, allowing for
+ greater control over the formatting of XML files
+ written using Mini-XML. THIS CHANGE WILL REQUIRE
+ CHANGES TO YOUR 1.x CODE IF YOU USE WHITESPACE
+ CALLBACKS.
+ - The mxmldoc utility is now capable of documenting C++
+ classes, functions, and structures, and correctly
+ handles C++ comments.
+ - Added new modular tests for mxmldoc.
+ - Updated the mxmldoc output to be more compatible with
+ embedding in manuals produced with HTMLDOC.
+ - The makefile incorrectly included a "/" separator
+ between the destination path and install path. This
+ caused problems when building and installing with
+ MingW.
+
+
+CHANGES IN Mini-XML 1.3
+
+ - Fixes for mxmldoc.
+ - Added support for reading standard HTML entity names.
+ - mxmlLoadString/File() did not decode character
+ entities in element names, attribute names, or
+ attribute values.
+ - mxmlLoadString/File() would crash when loading non-
+ conformant XML data under an existing parent (top)
+ node.
+ - Fixed several bugs in the mxmldoc utility.
+ - Added new error callback function to catch a variety
+ of errors and log them to someplace other than stderr.
+ - The mxmlElementSetAttr() function now allows for NULL
+ attribute values.
+ - The load and save functions now properly handle quoted
+ element and attribute name strings properly, e.g. for
+ !DOCTYPE declarations.
+
+
+CHANGES IN Mini-XML 1.2
+
+ - Added new "set" methods to set the value of a node.
+ - Added new formatted text methods mxmlNewTextf() and
+ mxmlSetTextf() to create/set a text node value using
+ printf-style formats.
+ - Added new standard callbacks for use with the mxmlLoad
+ functions.
+ - Updated the HTML documentation to include examples of
+ the walk and load function output.
+ - Added --with/without-ansi configure option to control
+ the strdup() function check.
+ - Added --with/without-snprintf configure option to
+ control the snprintf() and vsnprintf() function
+ checks.
+
+
+CHANGES IN Mini-XML 1.1.2
+
+ - The mxml(3) man page wasn't updated for the string
+ functions.
+ - mxmlSaveString() returned the wrong number of
+ characters.
+ - mxml_add_char() updated the buffer pointer in the
+ wrong place.
+
+
+CHANGES IN Mini-XML 1.1.1
+
+ - The private mxml_add_ch() function did not update the
+ start-of-buffer pointer which could cause a crash when
+ using mxmlSaveString().
+ - The private mxml_write_ws() function called putc()
+ instead of using the proper callback which could cause
+ a crash when using mxmlSaveString().
+ - Added a mxmlSaveAllocString() convenience function for
+ saving an XML node tree to an allocated string.
+
+
+CHANGES IN Mini-XML 1.1
+
+ - The mxmlLoadFile() function now uses dynamically
+ allocated string buffers for element names, attribute
+ names, and attribute values. Previously they were
+ capped at 16383, 255, and 255 bytes, respectively.
+ - Added a new mxmlLoadString() function for loading an
+ XML node tree from a string.
+ - Added a new mxmlSaveString() function for saving an
+ XML node tree to a string.
+ - Add emulation of strdup() if the local platform does
+ not provide the function.
+
+
+CHANGES IN Mini-XML 1.0
+
+ - The mxmldoc program now handles function arguments,
+ structures, unions, enumerations, classes, and
+ typedefs properly.
+ - Documentation provided via mxmldoc and more in-line
+ comments in the code.
+ - Added man pages and packaging files.
+
+
+CHANGES IN Mini-XML 0.93
+
+ - New mxmldoc example program that is also used to
+ create and update code documentation using XML and
+ produce HTML reference pages.
+ - Added mxmlAdd() and mxmlRemove() functions to add and
+ remove nodes from a tree. This provides more
+ flexibility over where the nodes are inserted and
+ allows nodes to be moved within the tree as needed.
+ - mxmlLoadFile() now correctly handles comments.
+ - mxmlLoadFile() now supports the required "gt", "quot",
+ and "nbsp" character entities.
+ - mxmlSaveFile() now uses newlines as whitespace
+ when valid to do so.
+ - mxmlFindElement() now also takes attribute name and
+ attribute value string arguments to limit the search
+ to specific elements with attributes and/or values.
+ NULL pointers can be used as "wildcards".
+ - Added uninstall target to makefile, and auto-reconfig
+ if Makefile.in or configure.in are changed.
+ - mxmlFindElement(), mxmlWalkNext(), and mxmlWalkPrev()
+ now all provide "descend" arguments to control whether
+ they descend into child nodes in the tree.
+ - Fixed some whitespace issues in mxmlLoadFile().
+ - Fixed Unicode output and whitespace issues in
+ mxmlSaveFile().
+ - mxmlSaveFile() now supports a whitespace callback to
+ provide more human-readable XML output under program
+ control.
+
+
+CHANGES IN Mini-XML 0.92
+
+ - mxmlSaveFile() didn't return a value on success.
+
+
+CHANGES IN Mini-XML 0.91
+
+ - mxmlWalkNext() would go into an infinite loop.
+
+
+CHANGES IN Mini-XML 0.9
+
+ - Initial public release.
--- /dev/null
+ GNU LIBRARY GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ [This is the first released version of the library GPL. It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it. You can use it for
+your libraries, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library. If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+\f
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software. To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+ Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs. This
+license, the GNU Library General Public License, applies to certain
+designated libraries. This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+ The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it. Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program. However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+ Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries. We
+concluded that weaker conditions might promote sharing better.
+
+ However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves. This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them. (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.) The hope is that this
+will lead to faster development of free libraries.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+ Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+\f
+ GNU LIBRARY GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License"). Each licensee is
+addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+\f
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+\f
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+\f
+ 6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ c) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ d) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+\f
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+\f
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+\f
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+\f
+ Appendix: How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with this library; if not, write to the Free
+ Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
--- /dev/null
+#
+# "$Id$"
+#
+# Makefile for Mini-XML, a small XML-like file parsing library.
+#
+# Copyright 2003-2005 by Michael Sweet.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2, or (at your option) any later version.
+#
+# This program 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.
+#
+
+#
+# Compiler tools definitions...
+#
+
+AR = @AR@
+ARFLAGS = @ARFLAGS@
+CC = @CC@
+CFLAGS = $(OPTIM) @CFLAGS@ @CPPFLAGS@
+CP = @CP@
+DSO = @DSO@
+DSOFLAGS = @DSOFLAGS@
+LDFLAGS = $(OPTIM) @LDFLAGS@
+INSTALL = @INSTALL@
+LIBMXML = @LIBMXML@
+LN = @LN@ -s
+MKDIR = @MKDIR@
+NROFF = @NROFF@
+OPTIM = @OPTIM@
+RANLIB = @RANLIB@
+RM = @RM@ -f
+SHELL = /bin/sh
+
+
+#
+# Configured directories...
+#
+
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+bindir = @bindir@
+includedir = @includedir@
+libdir = @libdir@
+mandir = @mandir@
+docdir = @docdir@
+BUILDROOT = $(DSTROOT)
+
+
+#
+# Manpage extensions...
+#
+
+CAT1EXT = @CAT1EXT@
+CAT3EXT = @CAT3EXT@
+MAN1EXT = @MAN1EXT@
+MAN3EXT = @MAN3EXT@
+
+
+#
+# Install commands...
+#
+
+INSTALL_BIN = $(LIBTOOL) $(INSTALL) -m 755 -s
+INSTALL_DATA = $(INSTALL) -m 644
+INSTALL_DIR = $(INSTALL) -d
+INSTALL_LIB = $(LIBTOOL) $(INSTALL) -m 755
+INSTALL_MAN = $(INSTALL) -m 644
+INSTALL_SCRIPT = $(INSTALL) -m 755
+
+
+#
+# Rules...
+#
+
+.SUFFIXES: .0 .1 .3 .c .man .o
+.c.o:
+ $(CC) $(CFLAGS) -c $<
+.man.0 .man.1 .man.3:
+ $(RM) $@
+ $(NROFF) -man $< >$@
+
+
+#
+# Targets...
+#
+
+DOCFILES = doc/mxml.html doc/mxmldoc.xsd \
+ README COPYING CHANGES
+PUBLIBOBJS = mxml-attr.o mxml-entity.o mxml-file.o mxml-index.o \
+ mxml-node.o mxml-search.o mxml-set.o
+LIBOBJS = $(PUBLIBOBJS) mxml-private.o mxml-string.o
+OBJS = mxmldoc.o testmxml.o $(LIBOBJS)
+TARGETS = $(LIBMXML) mxmldoc doc/mxml.$(CAT3EXT) \
+ doc/mxmldoc.$(CAT1EXT) testmxml mxml.xml
+
+
+#
+# Make everything...
+#
+
+all: Makefile configure config.h $(TARGETS)
+
+
+#
+# Clean everything...
+#
+
+clean:
+ $(RM) $(OBJS) $(TARGETS)
+ $(RM) mxmldoc-static libmxml.a
+ $(RM) *.bck *.bak
+ $(RM) config.cache config.log config.status
+ $(RM) -r autom4te*.cache
+
+
+#
+# Install everything...
+#
+
+install: $(TARGETS) install-$(LIBMXML) install-libmxml.a
+ $(INSTALL_DIR) $(BUILDROOT)$(bindir)
+ $(INSTALL_BIN) mxmldoc $(BUILDROOT)$(bindir)
+ $(INSTALL_DIR) $(BUILDROOT)$(docdir)
+ for file in $(DOCFILES); do \
+ $(INSTALL_MAN) $$file $(BUILDROOT)$(docdir); \
+ done
+ $(INSTALL_DIR) $(BUILDROOT)$(includedir)
+ $(INSTALL_DATA) mxml.h $(BUILDROOT)$(includedir)
+ $(INSTALL_DIR) $(BUILDROOT)$(libdir)/pkgconfig
+ $(INSTALL_DATA) mxml.pc $(BUILDROOT)$(libdir)/pkgconfig
+ $(INSTALL_DIR) $(BUILDROOT)$(mandir)/cat1
+ $(INSTALL_MAN) doc/mxmldoc.$(CAT1EXT) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
+ $(INSTALL_DIR) $(BUILDROOT)$(mandir)/cat3
+ $(INSTALL_MAN) doc/mxml.$(CAT3EXT) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
+ $(INSTALL_DIR) $(BUILDROOT)$(mandir)/man1
+ $(INSTALL_MAN) doc/mxmldoc.man $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
+ $(INSTALL_DIR) $(BUILDROOT)$(mandir)/man3
+ $(INSTALL_MAN) doc/mxml.man $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
+
+install-libmxml.a:
+ $(INSTALL_DIR) $(BUILDROOT)$(libdir)
+ $(INSTALL_LIB) libmxml.a $(BUILDROOT)$(libdir)
+
+install-libmxml.so.1.0:
+ $(INSTALL_DIR) $(BUILDROOT)$(libdir)
+ $(INSTALL_LIB) libmxml.so.1.0 $(BUILDROOT)$(libdir)
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so
+ $(LN) libmxml.so.1.0 $(BUILDROOT)$(libdir)/libmxml.so
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
+ $(LN) libmxml.so.1.0 $(BUILDROOT)$(libdir)/libmxml.so.1
+
+install-libmxml.sl.1:
+ $(INSTALL_DIR) $(BUILDROOT)$(libdir)
+ $(INSTALL_LIB) libmxml.sl.1 $(BUILDROOT)$(libdir)
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so
+ $(LN) libmxml.sl.1 $(BUILDROOT)$(libdir)/libmxml.sl
+
+install-libmxml.1.dylib:
+ $(INSTALL_DIR) $(BUILDROOT)$(libdir)
+ $(INSTALL_LIB) libmxml.1.dylib $(BUILDROOT)$(libdir)
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
+ $(LN) libmxml.1.dylib $(BUILDROOT)$(libdir)/libmxml.dylib
+
+
+#
+# Uninstall everything...
+#
+
+uninstall: uninstall-$(LIBMXML) uninstall-libmxml.a
+ $(RM) $(BUILDROOT)$(bindir)/mxmldoc
+ $(RM) -r $(BUILDROOT)$(docdir)
+ $(RM) $(BUILDROOT)$(includedir)/mxml.h
+ $(RM) $(BUILDROOT)$(libdir)/pkgconfig/mxml.pc
+ $(RM) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
+ $(RM) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
+ $(RM) $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
+ $(RM) $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
+
+uninstall-libmxml.a:
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.a
+
+uninstall-libmxml.so.1.0:
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1.0
+
+uninstall-libmxml.sl.1:
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.sl
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.sl.1
+
+uninstall-libmxml.1.dylib:
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
+ $(RM) $(BUILDROOT)$(libdir)/libmxml.1.dylib
+
+
+#
+# Make packages using EPM (http://www.easysw.com/epm/)
+#
+
+epm: all
+ epm --output-dir dist -v -f native mxml
+ epm --output-dir dist -v -f portable mxml
+
+
+#
+# autoconf stuff...
+#
+
+Makefile: configure Makefile.in
+ if test -f config.status; then \
+ ./config.status --recheck; \
+ ./config.status; \
+ else \
+ ./configure; \
+ fi
+ touch config.h
+
+
+configure: configure.in
+ autoconf
+ if test -f config.status; then \
+ ./config.status --recheck; \
+ ./config.status; \
+ else \
+ ./configure; \
+ fi
+ touch config.h
+
+
+config.h: configure config.h.in
+ autoconf
+ if test -f config.status; then \
+ ./config.status --recheck; \
+ ./config.status; \
+ else \
+ ./configure; \
+ fi
+ touch config.h
+
+
+#
+# libmxml.a
+#
+
+libmxml.a: $(LIBOBJS)
+ $(RM) $@
+ $(AR) $(ARFLAGS) $@ $(LIBOBJS)
+ $(RANLIB) $@
+
+$(LIBOBJS): mxml.h
+
+
+#
+# libmxml.so.1.0
+#
+
+libmxml.so.1.0: $(LIBOBJS)
+ $(DSO) $(DSOFLAGS) -o libmxml.so.1.0 $(LIBOBJS)
+ $(RM) libmxml.so libmxml.so.1
+ $(LN) libmxml.so.1.0 libmxml.so
+ $(LN) libmxml.so.1.0 libmxml.so.1
+
+
+#
+# libmxml.sl.1
+#
+
+libmxml.sl.1: $(LIBOBJS)
+ $(DSO) $(DSOFLAGS) -o libmxml.sl.1 $(LIBOBJS)
+ $(RM) libmxml.sl libmxml.sl.1
+ $(LN) libmxml.sl.1 libmxml.sl
+
+
+#
+# libmxml.1.dylib
+#
+
+libmxml.1.dylib: $(LIBOBJS)
+ $(DSO) $(DSOFLAGS) -o libmxml.1.dylib \
+ -install_name $(libdir)/libmxml.dylib \
+ -current_version 1.0.0 \
+ -compatibility_version 1.0.0 \
+ $(LIBOBJS)
+ $(RM) libmxml.dylib libmxml.1.dylib
+ $(LN) libmxml.1.dylib libmxml.dylib
+
+
+#
+# mxmldoc
+#
+
+mxmldoc: $(LIBMXML) mxmldoc.o
+ $(CC) $(LDFLAGS) -o $@ mxmldoc.o -L. -lmxml
+
+mxmldoc-static: libmxml.a mxmldoc.o
+ $(CC) $(LDFLAGS) -o $@ mxmldoc.o libmxml.a
+
+mxmldoc.o: mxml.h
+
+
+#
+# testmxml
+#
+
+testmxml: libmxml.a testmxml.o
+ $(CC) $(LDFLAGS) -o $@ testmxml.o libmxml.a
+ @echo Testing library...
+ ./testmxml test.xml >temp1.xml 2>temp1s.xml
+ ./testmxml temp1.xml >temp2.xml 2>temp2s.xml
+ @if cmp temp1.xml temp2.xml; then \
+ echo Stdio file test passed!; \
+ $(RM) temp2.xml temp2s.xml; \
+ else \
+ echo Stdio file test failed!; \
+ fi
+ @if cmp temp1.xml temp1s.xml; then \
+ echo String test passed!; \
+ $(RM) temp1.xml temp1s.xml; \
+ else \
+ echo String test failed!; \
+ fi
+ @if cmp test.xml test.xmlfd; then \
+ echo File descriptor test passed!; \
+ $(RM) test.xmlfd; \
+ else \
+ echo File descriptor test failed!; \
+ fi
+
+testmxml.o: mxml.h
+
+
+#
+# mxml.xml
+#
+
+mxml.xml: mxmldoc-static mxml.h $(PUBLIBOBJS:.o=.c)
+ $(RM) mxml.xml
+ ./mxmldoc-static mxml.xml mxml.h $(PUBLIBOBJS:.o=.c) >doc/reference.html
+
+valgrind: mxmldoc-static
+ $(RM) valgrind.xml
+ valgrind --tool=memcheck --leak-check=yes ./mxmldoc-static \
+ valgrind.xml mxml.h $(PUBLIBOBJS:.o=.c) \
+ >valgrind.html 2>valgrind.out
+
+
+#
+# All object files depend on the makefile...
+#
+
+$(OBJS): Makefile config.h
+
+
+#
+# End of "$Id$".
+#
--- /dev/null
+README - 05/19/2005
+-------------------
+
+
+INTRODUCTION
+
+ This README file describes the Mini-XML library version
+ 2.2.2.
+
+ Mini-XML is a small XML parsing library that you can use to
+ read XML and XML-like data files in your application without
+ requiring large non-standard libraries. Mini-XML only
+ requires an ANSI C compatible compiler (GCC works, as do
+ most vendors' ANSI C compilers) and a "make" program.
+
+ Mini-XML provides the following functionality:
+
+ - Reading of UTF-8 and UTF-16 and writing of UTF-8
+ encoded XML files and strings.
+ - Data is stored in a linked-list tree structure,
+ preserving the XML data hierarchy.
+ - Supports arbitrary element names, attributes, and
+ attribute values with no preset limits, just available
+ memory.
+ - Supports integer, real, opaque ("cdata"), and text
+ data types in "leaf" nodes.
+ - Functions for creating and managing trees of data.
+ - "Find" and "walk" functions for easily locating and
+ navigating trees of data.
+
+ Mini-XML doesn't do validation or other types of processing
+ on the data based upon schema files or other sources of
+ definition information.
+
+
+BUILDING Mini-XML
+
+ Mini-XML comes with an autoconf-based configure script; just
+ type the following command to get things going:
+
+ ./configure
+
+ The default install prefix is /usr/local, which can be
+ overridden using the --prefix option:
+
+ ./configure --prefix=/foo
+
+ Other configure options can be found using the --help
+ option:
+
+ ./configure --help
+
+ Once you have configured the software, type "make" to do the
+ build and run the test program to verify that things are
+ working, as follows:
+
+ make
+
+ If you are using Mini-XML under Microsoft Windows with
+ Visual C++, use the included project files in the "vcnet"
+ subdirectory to build the library instead.
+
+
+INSTALLING Mini-XML
+
+ The "install" target will install Mini-XML in the lib and
+ include directories:
+
+ make install
+
+ Once you have installed it, use the "-lmxml" option to link
+ your application against it.
+
+
+DOCUMENTATION
+
+ The documentation is available in the "doc" subdirectory in
+ the files "mxml.html" (HTML) and "mxml.pdf" (PDF). You can
+ also look at the "testmxml.c" and "mxmldoc.c" source files
+ for examples of using Mini-XML.
+
+ Mini-XML provides a single header file which you include:
+
+ #include <mxml.h>
+
+ Nodes are defined by the "mxml_node_t" structure; the "type"
+ member defines the node type (element, integer, opaque,
+ real, or text) which determines which value you want to look
+ at in the "value" union. New nodes can be created using the
+ "mxmlNewElement()", "mxmlNewInteger()", "mxmlNewOpaque()",
+ "mxmlNewReal()", and "mxmlNewText()" functions. Only
+ elements can have child nodes, and the top node must be an
+ element, usually "?xml".
+
+ You load an XML file using the "mxmlLoadFile()" function:
+
+ FILE *fp;
+ mxml_node_t *tree;
+
+ fp = fopen("filename.xml", "r");
+ tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
+ fclose(fp);
+
+ Similarly, you save an XML file using the "mxmlSaveFile()"
+ function:
+
+ FILE *fp;
+ mxml_node_t *tree;
+
+ fp = fopen("filename.xml", "w");
+ mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
+ fclose(fp);
+
+ The "mxmlLoadString()", "mxmlSaveAllocString()", and
+ "mxmlSaveString()" functions load XML node trees from and
+ save XML node trees to strings:
+
+ char buffer[8192];
+ char *ptr;
+ mxml_node_t *tree;
+
+ ...
+ tree = mxmlLoadString(NULL, buffer, MXML_NO_CALLBACK);
+
+ ...
+ mxmlSaveString(tree, buffer, sizeof(buffer), MXML_NO_CALLBACK);
+
+ ...
+ ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
+
+ You can find a named element/node using the
+ "mxmlFindElement()" function:
+
+ mxml_node_t *node = mxmlFindElement(tree, tree, "name", "attr",
+ "value", MXML_DESCEND);
+
+ The "name", "attr", and "value" arguments can be passed as
+ NULL to act as wildcards, e.g.:
+
+ /* Find the first "a" element */
+ node = mxmlFindElement(tree, tree, "a", NULL, NULL, MXML_DESCEND);
+
+ /* Find the first "a" element with "href" attribute */
+ node = mxmlFindElement(tree, tree, "a", "href", NULL, MXML_DESCEND);
+
+ /* Find the first "a" element with "href" to a URL */
+ node = mxmlFindElement(tree, tree, "a", "href",
+ "http://www.easysw.com/~mike/mxml/",
+ MXML_DESCEND);
+
+ /* Find the first element with a "src" attribute*/
+ node = mxmlFindElement(tree, tree, NULL, "src", NULL, MXML_DESCEND);
+
+ /* Find the first element with a "src" = "foo.jpg" */
+ node = mxmlFindElement(tree, tree, NULL, "src", "foo.jpg",
+ MXML_DESCEND);
+
+ You can also iterate with the same function:
+
+ mxml_node_t *node;
+
+ for (node = mxmlFindElement(tree, tree, "name", NULL, NULL,
+ MXML_DESCEND);
+ node != NULL;
+ node = mxmlFindElement(node, tree, "name", NULL, NULL,
+ MXML_DESCEND))
+ {
+ ... do something ...
+ }
+
+ Finally, once you are done with the XML data, use the
+ "mxmlDelete()" function to recursively free the memory that
+ is used for a particular node or the entire tree:
+
+ mxmlDelete(tree);
+
+
+GETTING HELP AND REPORTING PROBLEMS
+
+ You can email me at "mxml@easysw.com" to report problems
+ and/or ask for help. Just don't expect an instant response,
+ as I get a *lot* of email...
+
+
+LEGAL STUFF
+
+ The Mini-XML library is Copyright 2003-2005 by Michael Sweet.
+
+ This library is free software; you can redistribute it
+ and/or modify it under the terms of the GNU Library General
+ Public License as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any
+ later version.
+
+ This library 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 Library General Public License for
+ more details.
+
+ You should have received a copy of the GNU Library General
+ Public License along with this library; if not, write to the
+ Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
+ 02139, USA.
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Configuration file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+
+/*
+ * Version number...
+ */
+
+#define MXML_VERSION ""
+
+
+/*
+ * Do we have the vsnprintf() function?
+ */
+
+#undef HAVE_VSNPRINTF
+
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#undef HAVE_STRDUP
+
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+# ifndef HAVE_STRDUP
+extern char *mxml_strdup(const char *);
+# define strdup mxml_strdup
+# endif /* !HAVE_STRDUP */
+
+extern char *mxml_strdupf(const char *, va_list);
+
+# ifndef HAVE_VSNPRINTF
+extern int mxml_vsnprintf(char *, size_t, const char *, va_list);
+# define vsnprintf mxml_vsnprintf
+# endif /* !HAVE_VSNPRINTF */
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.57.
+#
+# Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
+# Free Software Foundation, Inc.
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## --------------------- ##
+## M4sh Initialization. ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+ emulate sh
+ NULLCMD=:
+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+ # is contrary to our usage. Disable this feature.
+ alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+ set -o posix
+fi
+
+# Support unset when possible.
+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
+ as_unset=unset
+else
+ as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+ LC_TELEPHONE LC_TIME
+do
+ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
+ eval $as_var=C; export $as_var
+ else
+ $as_unset $as_var
+ fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+ as_expr=expr
+else
+ as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+ as_basename=basename
+else
+ as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+ X"$0" : 'X\(//\)$' \| \
+ X"$0" : 'X\(/\)$' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+ /^X\/\(\/\/\)$/{ s//\1/; q; }
+ /^X\/\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+ echo "#! /bin/sh" >conf$$.sh
+ echo "exit 0" >>conf$$.sh
+ chmod +x conf$$.sh
+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+ PATH_SEPARATOR=';'
+ else
+ PATH_SEPARATOR=:
+ fi
+ rm -f conf$$.sh
+fi
+
+
+ as_lineno_1=$LINENO
+ as_lineno_2=$LINENO
+ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+ test "x$as_lineno_1" != "x$as_lineno_2" &&
+ test "x$as_lineno_3" = "x$as_lineno_2" || {
+ # Find who we are. Look in the path if we contain no path at all
+ # relative or not.
+ case $0 in
+ *[\\/]* ) as_myself=$0 ;;
+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+ ;;
+ esac
+ # We did not find ourselves, most probably we were run as `sh COMMAND'
+ # in which case we are not to be found in the path.
+ if test "x$as_myself" = x; then
+ as_myself=$0
+ fi
+ if test ! -f "$as_myself"; then
+ { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
+ { (exit 1); exit 1; }; }
+ fi
+ case $CONFIG_SHELL in
+ '')
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for as_base in sh bash ksh sh5; do
+ case $as_dir in
+ /*)
+ if ("$as_dir/$as_base" -c '
+ as_lineno_1=$LINENO
+ as_lineno_2=$LINENO
+ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+ test "x$as_lineno_1" != "x$as_lineno_2" &&
+ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then
+ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+ CONFIG_SHELL=$as_dir/$as_base
+ export CONFIG_SHELL
+ exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+ fi;;
+ esac
+ done
+done
+;;
+ esac
+
+ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+ # uniformly replaced by the line number. The first 'sed' inserts a
+ # line-number line before each line; the second 'sed' does the real
+ # work. The second script uses 'N' to pair each line-number line
+ # with the numbered line, and appends trailing '-' during
+ # substitution so that $LINENO is not a special case at line end.
+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-)
+ sed '=' <$as_myself |
+ sed '
+ N
+ s,$,-,
+ : loop
+ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+ t loop
+ s,-$,,
+ s,^['$as_cr_digits']*\n,,
+ ' >$as_me.lineno &&
+ chmod +x $as_me.lineno ||
+ { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+ { (exit 1); exit 1; }; }
+
+ # Don't try to exec as it changes $[0], causing all sort of problems
+ # (the dirname of $[0] is not the place where we might find the
+ # original and so on. Autoconf is especially sensible to this).
+ . ./$as_me.lineno
+ # Exit status is that of the last command.
+ exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+ *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T=' ' ;;
+ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+ *) ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+ as_expr=expr
+else
+ as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+ # We could just check for DJGPP; but this test a) works b) is more generic
+ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+ if test -f conf$$.exe; then
+ # Don't use ln at all; we don't have any links
+ as_ln_s='cp -p'
+ else
+ as_ln_s='ln -s'
+ fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+ as_ln_s=ln
+else
+ as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+ as_mkdir_p=:
+else
+ as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" $as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+
+# Name of the host.
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+exec 6>&1
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_config_libobj_dir=.
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+# Maximum number of lines to put in a shell here document.
+# This variable seems obsolete. It should probably be removed, and
+# only ac_max_sed_lines should be used.
+: ${ac_max_here_lines=38}
+
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+
+ac_unique_file="mxml.h"
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS VERSION LDFLAGS OPTIM docdir CC CFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA RANLIB ac_ct_RANLIB AR CP LN MKDIR NROFF GROFF RM ARFLAGS DSO DSOFLAGS LIBMXML PICFLAG CAT1EXT CAT3EXT MAN1EXT MAN3EXT PC_CFLAGS PC_LIBS LIBOBJS LTLIBOBJS'
+ac_subst_files=''
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datadir='${prefix}/share'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+libdir='${exec_prefix}/lib'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+infodir='${prefix}/info'
+mandir='${prefix}/man'
+
+ac_prev=
+for ac_option
+do
+ # If the previous option needs an argument, assign it.
+ if test -n "$ac_prev"; then
+ eval "$ac_prev=\$ac_option"
+ ac_prev=
+ continue
+ fi
+
+ ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
+
+ # Accept the important Cygnus configure options, so we can diagnose typos.
+
+ case $ac_option in
+
+ -bindir | --bindir | --bindi | --bind | --bin | --bi)
+ ac_prev=bindir ;;
+ -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+ bindir=$ac_optarg ;;
+
+ -build | --build | --buil | --bui | --bu)
+ ac_prev=build_alias ;;
+ -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+ build_alias=$ac_optarg ;;
+
+ -cache-file | --cache-file | --cache-fil | --cache-fi \
+ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+ ac_prev=cache_file ;;
+ -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+ cache_file=$ac_optarg ;;
+
+ --config-cache | -C)
+ cache_file=config.cache ;;
+
+ -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
+ ac_prev=datadir ;;
+ -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
+ | --da=*)
+ datadir=$ac_optarg ;;
+
+ -disable-* | --disable-*)
+ ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+ { (exit 1); exit 1; }; }
+ ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+ eval "enable_$ac_feature=no" ;;
+
+ -enable-* | --enable-*)
+ ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+ { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+ { (exit 1); exit 1; }; }
+ ac_feature=`echo $ac_feature | sed 's/-/_/g'`
+ case $ac_option in
+ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) ac_optarg=yes ;;
+ esac
+ eval "enable_$ac_feature='$ac_optarg'" ;;
+
+ -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+ | --exec | --exe | --ex)
+ ac_prev=exec_prefix ;;
+ -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+ | --exec=* | --exe=* | --ex=*)
+ exec_prefix=$ac_optarg ;;
+
+ -gas | --gas | --ga | --g)
+ # Obsolete; use --with-gas.
+ with_gas=yes ;;
+
+ -help | --help | --hel | --he | -h)
+ ac_init_help=long ;;
+ -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+ ac_init_help=recursive ;;
+ -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+ ac_init_help=short ;;
+
+ -host | --host | --hos | --ho)
+ ac_prev=host_alias ;;
+ -host=* | --host=* | --hos=* | --ho=*)
+ host_alias=$ac_optarg ;;
+
+ -includedir | --includedir | --includedi | --included | --include \
+ | --includ | --inclu | --incl | --inc)
+ ac_prev=includedir ;;
+ -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+ | --includ=* | --inclu=* | --incl=* | --inc=*)
+ includedir=$ac_optarg ;;
+
+ -infodir | --infodir | --infodi | --infod | --info | --inf)
+ ac_prev=infodir ;;
+ -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+ infodir=$ac_optarg ;;
+
+ -libdir | --libdir | --libdi | --libd)
+ ac_prev=libdir ;;
+ -libdir=* | --libdir=* | --libdi=* | --libd=*)
+ libdir=$ac_optarg ;;
+
+ -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+ | --libexe | --libex | --libe)
+ ac_prev=libexecdir ;;
+ -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+ | --libexe=* | --libex=* | --libe=*)
+ libexecdir=$ac_optarg ;;
+
+ -localstatedir | --localstatedir | --localstatedi | --localstated \
+ | --localstate | --localstat | --localsta | --localst \
+ | --locals | --local | --loca | --loc | --lo)
+ ac_prev=localstatedir ;;
+ -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+ | --localstate=* | --localstat=* | --localsta=* | --localst=* \
+ | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
+ localstatedir=$ac_optarg ;;
+
+ -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+ ac_prev=mandir ;;
+ -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+ mandir=$ac_optarg ;;
+
+ -nfp | --nfp | --nf)
+ # Obsolete; use --without-fp.
+ with_fp=no ;;
+
+ -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+ | --no-cr | --no-c | -n)
+ no_create=yes ;;
+
+ -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+ no_recursion=yes ;;
+
+ -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+ | --oldin | --oldi | --old | --ol | --o)
+ ac_prev=oldincludedir ;;
+ -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+ oldincludedir=$ac_optarg ;;
+
+ -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+ ac_prev=prefix ;;
+ -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+ prefix=$ac_optarg ;;
+
+ -program-prefix | --program-prefix | --program-prefi | --program-pref \
+ | --program-pre | --program-pr | --program-p)
+ ac_prev=program_prefix ;;
+ -program-prefix=* | --program-prefix=* | --program-prefi=* \
+ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+ program_prefix=$ac_optarg ;;
+
+ -program-suffix | --program-suffix | --program-suffi | --program-suff \
+ | --program-suf | --program-su | --program-s)
+ ac_prev=program_suffix ;;
+ -program-suffix=* | --program-suffix=* | --program-suffi=* \
+ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+ program_suffix=$ac_optarg ;;
+
+ -program-transform-name | --program-transform-name \
+ | --program-transform-nam | --program-transform-na \
+ | --program-transform-n | --program-transform- \
+ | --program-transform | --program-transfor \
+ | --program-transfo | --program-transf \
+ | --program-trans | --program-tran \
+ | --progr-tra | --program-tr | --program-t)
+ ac_prev=program_transform_name ;;
+ -program-transform-name=* | --program-transform-name=* \
+ | --program-transform-nam=* | --program-transform-na=* \
+ | --program-transform-n=* | --program-transform-=* \
+ | --program-transform=* | --program-transfor=* \
+ | --program-transfo=* | --program-transf=* \
+ | --program-trans=* | --program-tran=* \
+ | --progr-tra=* | --program-tr=* | --program-t=*)
+ program_transform_name=$ac_optarg ;;
+
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil)
+ silent=yes ;;
+
+ -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+ ac_prev=sbindir ;;
+ -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+ | --sbi=* | --sb=*)
+ sbindir=$ac_optarg ;;
+
+ -sharedstatedir | --sharedstatedir | --sharedstatedi \
+ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+ | --sharedst | --shareds | --shared | --share | --shar \
+ | --sha | --sh)
+ ac_prev=sharedstatedir ;;
+ -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+ | --sha=* | --sh=*)
+ sharedstatedir=$ac_optarg ;;
+
+ -site | --site | --sit)
+ ac_prev=site ;;
+ -site=* | --site=* | --sit=*)
+ site=$ac_optarg ;;
+
+ -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+ ac_prev=srcdir ;;
+ -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+ srcdir=$ac_optarg ;;
+
+ -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+ | --syscon | --sysco | --sysc | --sys | --sy)
+ ac_prev=sysconfdir ;;
+ -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+ sysconfdir=$ac_optarg ;;
+
+ -target | --target | --targe | --targ | --tar | --ta | --t)
+ ac_prev=target_alias ;;
+ -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+ target_alias=$ac_optarg ;;
+
+ -v | -verbose | --verbose | --verbos | --verbo | --verb)
+ verbose=yes ;;
+
+ -version | --version | --versio | --versi | --vers | -V)
+ ac_init_version=: ;;
+
+ -with-* | --with-*)
+ ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+ { echo "$as_me: error: invalid package name: $ac_package" >&2
+ { (exit 1); exit 1; }; }
+ ac_package=`echo $ac_package| sed 's/-/_/g'`
+ case $ac_option in
+ *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) ac_optarg=yes ;;
+ esac
+ eval "with_$ac_package='$ac_optarg'" ;;
+
+ -without-* | --without-*)
+ ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
+ { echo "$as_me: error: invalid package name: $ac_package" >&2
+ { (exit 1); exit 1; }; }
+ ac_package=`echo $ac_package | sed 's/-/_/g'`
+ eval "with_$ac_package=no" ;;
+
+ --x)
+ # Obsolete; use --with-x.
+ with_x=yes ;;
+
+ -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+ | --x-incl | --x-inc | --x-in | --x-i)
+ ac_prev=x_includes ;;
+ -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+ x_includes=$ac_optarg ;;
+
+ -x-libraries | --x-libraries | --x-librarie | --x-librari \
+ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+ ac_prev=x_libraries ;;
+ -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+ x_libraries=$ac_optarg ;;
+
+ -*) { echo "$as_me: error: unrecognized option: $ac_option
+Try \`$0 --help' for more information." >&2
+ { (exit 1); exit 1; }; }
+ ;;
+
+ *=*)
+ ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+ # Reject names that are not valid shell variable names.
+ expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+ { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+ { (exit 1); exit 1; }; }
+ ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
+ eval "$ac_envvar='$ac_optarg'"
+ export $ac_envvar ;;
+
+ *)
+ # FIXME: should be removed in autoconf 3.0.
+ echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+ expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+ echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+ : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+ ;;
+
+ esac
+done
+
+if test -n "$ac_prev"; then
+ ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+ { echo "$as_me: error: missing argument to $ac_option" >&2
+ { (exit 1); exit 1; }; }
+fi
+
+# Be sure to have absolute paths.
+for ac_var in exec_prefix prefix
+do
+ eval ac_val=$`echo $ac_var`
+ case $ac_val in
+ [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
+ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+ { (exit 1); exit 1; }; };;
+ esac
+done
+
+# Be sure to have absolute paths.
+for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
+ localstatedir libdir includedir oldincludedir infodir mandir
+do
+ eval ac_val=$`echo $ac_var`
+ case $ac_val in
+ [\\/$]* | ?:[\\/]* ) ;;
+ *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+ { (exit 1); exit 1; }; };;
+ esac
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+ if test "x$build_alias" = x; then
+ cross_compiling=maybe
+ echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+ If a cross compiler is detected then cross compile mode will be used." >&2
+ elif test "x$build_alias" != "x$host_alias"; then
+ cross_compiling=yes
+ fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+ ac_srcdir_defaulted=yes
+ # Try the directory containing this script, then its parent.
+ ac_confdir=`(dirname "$0") 2>/dev/null ||
+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$0" : 'X\(//\)[^/]' \| \
+ X"$0" : 'X\(//\)$' \| \
+ X"$0" : 'X\(/\)' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X"$0" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+ /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+ /^X\(\/\/\)$/{ s//\1/; q; }
+ /^X\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+ srcdir=$ac_confdir
+ if test ! -r $srcdir/$ac_unique_file; then
+ srcdir=..
+ fi
+else
+ ac_srcdir_defaulted=no
+fi
+if test ! -r $srcdir/$ac_unique_file; then
+ if test "$ac_srcdir_defaulted" = yes; then
+ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
+ { (exit 1); exit 1; }; }
+ else
+ { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+ { (exit 1); exit 1; }; }
+ fi
+fi
+(cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
+ { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
+ { (exit 1); exit 1; }; }
+srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
+ac_env_build_alias_set=${build_alias+set}
+ac_env_build_alias_value=$build_alias
+ac_cv_env_build_alias_set=${build_alias+set}
+ac_cv_env_build_alias_value=$build_alias
+ac_env_host_alias_set=${host_alias+set}
+ac_env_host_alias_value=$host_alias
+ac_cv_env_host_alias_set=${host_alias+set}
+ac_cv_env_host_alias_value=$host_alias
+ac_env_target_alias_set=${target_alias+set}
+ac_env_target_alias_value=$target_alias
+ac_cv_env_target_alias_set=${target_alias+set}
+ac_cv_env_target_alias_value=$target_alias
+ac_env_CC_set=${CC+set}
+ac_env_CC_value=$CC
+ac_cv_env_CC_set=${CC+set}
+ac_cv_env_CC_value=$CC
+ac_env_CFLAGS_set=${CFLAGS+set}
+ac_env_CFLAGS_value=$CFLAGS
+ac_cv_env_CFLAGS_set=${CFLAGS+set}
+ac_cv_env_CFLAGS_value=$CFLAGS
+ac_env_LDFLAGS_set=${LDFLAGS+set}
+ac_env_LDFLAGS_value=$LDFLAGS
+ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
+ac_cv_env_LDFLAGS_value=$LDFLAGS
+ac_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_env_CPPFLAGS_value=$CPPFLAGS
+ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
+ac_cv_env_CPPFLAGS_value=$CPPFLAGS
+ac_env_CXX_set=${CXX+set}
+ac_env_CXX_value=$CXX
+ac_cv_env_CXX_set=${CXX+set}
+ac_cv_env_CXX_value=$CXX
+ac_env_CXXFLAGS_set=${CXXFLAGS+set}
+ac_env_CXXFLAGS_value=$CXXFLAGS
+ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
+ac_cv_env_CXXFLAGS_value=$CXXFLAGS
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+ # Omit some internal or obsolete options to make the list less imposing.
+ # This message is too long to be a string in the A/UX 3.1 sh.
+ cat <<_ACEOF
+\`configure' configures this package to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE. See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+ -h, --help display this help and exit
+ --help=short display options specific to this package
+ --help=recursive display the short help of all the included packages
+ -V, --version display version information and exit
+ -q, --quiet, --silent do not print \`checking...' messages
+ --cache-file=FILE cache test results in FILE [disabled]
+ -C, --config-cache alias for \`--cache-file=config.cache'
+ -n, --no-create do not create output files
+ --srcdir=DIR find the sources in DIR [configure dir or \`..']
+
+_ACEOF
+
+ cat <<_ACEOF
+Installation directories:
+ --prefix=PREFIX install architecture-independent files in PREFIX
+ [$ac_default_prefix]
+ --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
+ [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+ --bindir=DIR user executables [EPREFIX/bin]
+ --sbindir=DIR system admin executables [EPREFIX/sbin]
+ --libexecdir=DIR program executables [EPREFIX/libexec]
+ --datadir=DIR read-only architecture-independent data [PREFIX/share]
+ --sysconfdir=DIR read-only single-machine data [PREFIX/etc]
+ --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
+ --localstatedir=DIR modifiable single-machine data [PREFIX/var]
+ --libdir=DIR object code libraries [EPREFIX/lib]
+ --includedir=DIR C header files [PREFIX/include]
+ --oldincludedir=DIR C header files for non-gcc [/usr/include]
+ --infodir=DIR info documentation [PREFIX/info]
+ --mandir=DIR man documentation [PREFIX/man]
+_ACEOF
+
+ cat <<\_ACEOF
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+
+ cat <<\_ACEOF
+
+Optional Features:
+ --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
+ --enable-FEATURE[=ARG] include FEATURE [ARG=yes]
+ --enable-debug turn on debugging, default=no
+ --enable-shared turn on shared libraries, default=no
+
+Optional Packages:
+ --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
+ --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)
+ --with-ansi set full ANSI C mode, default=no
+ --with-docdir set directory for documentation, default=${prefix}/share/doc/mxml
+ --with-vsnprintf use vsnprintf emulation functions, default=auto
+
+Some influential environment variables:
+ CC C compiler command
+ CFLAGS C compiler flags
+ LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
+ nonstandard directory <lib dir>
+ CPPFLAGS C/C++ preprocessor flags, e.g. -I<include dir> if you have
+ headers in a nonstandard directory <include dir>
+ CXX C++ compiler command
+ CXXFLAGS C++ compiler flags
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+_ACEOF
+fi
+
+if test "$ac_init_help" = "recursive"; then
+ # If there are subdirs, report their specific --help.
+ ac_popdir=`pwd`
+ for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+ test -d $ac_dir || continue
+ ac_builddir=.
+
+if test "$ac_dir" != .; then
+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+ # A "../" for each directory in $ac_dir_suffix.
+ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+ ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+ .) # No --srcdir option. We are building in place.
+ ac_srcdir=.
+ if test -z "$ac_top_builddir"; then
+ ac_top_srcdir=.
+ else
+ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+ fi ;;
+ [\\/]* | ?:[\\/]* ) # Absolute path.
+ ac_srcdir=$srcdir$ac_dir_suffix;
+ ac_top_srcdir=$srcdir ;;
+ *) # Relative path.
+ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+ ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
+# absolute.
+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
+ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
+
+ cd $ac_dir
+ # Check for guested configure; otherwise get Cygnus style configure.
+ if test -f $ac_srcdir/configure.gnu; then
+ echo
+ $SHELL $ac_srcdir/configure.gnu --help=recursive
+ elif test -f $ac_srcdir/configure; then
+ echo
+ $SHELL $ac_srcdir/configure --help=recursive
+ elif test -f $ac_srcdir/configure.ac ||
+ test -f $ac_srcdir/configure.in; then
+ echo
+ $ac_configure --help
+ else
+ echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+ fi
+ cd $ac_popdir
+ done
+fi
+
+test -n "$ac_init_help" && exit 0
+if $ac_init_version; then
+ cat <<\_ACEOF
+
+Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
+Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+ exit 0
+fi
+exec 5>config.log
+cat >&5 <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by $as_me, which was
+generated by GNU Autoconf 2.57. Invocation command line was
+
+ $ $0 $@
+
+_ACEOF
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
+
+/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
+/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+hostinfo = `(hostinfo) 2>/dev/null || echo unknown`
+/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
+/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
+/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ echo "PATH: $as_dir"
+done
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_sep=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+ for ac_arg
+ do
+ case $ac_arg in
+ -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil)
+ continue ;;
+ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+ ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ esac
+ case $ac_pass in
+ 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
+ 2)
+ ac_configure_args1="$ac_configure_args1 '$ac_arg'"
+ if test $ac_must_keep_next = true; then
+ ac_must_keep_next=false # Got value, back to normal.
+ else
+ case $ac_arg in
+ *=* | --config-cache | -C | -disable-* | --disable-* \
+ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+ | -with-* | --with-* | -without-* | --without-* | --x)
+ case "$ac_configure_args0 " in
+ "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+ esac
+ ;;
+ -* ) ac_must_keep_next=true ;;
+ esac
+ fi
+ ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
+ # Get rid of the leading space.
+ ac_sep=" "
+ ;;
+ esac
+ done
+done
+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log. We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Be sure not to use single quotes in there, as some shells,
+# such as our DU 5.0 friend, will then `close' the trap.
+trap 'exit_status=$?
+ # Save into config.log some information that might help in debugging.
+ {
+ echo
+
+ cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+ echo
+ # The following way of writing the cache mishandles newlines in values,
+{
+ (set) 2>&1 |
+ case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
+ *ac_space=\ *)
+ sed -n \
+ "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
+ ;;
+ *)
+ sed -n \
+ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+ ;;
+ esac;
+}
+ echo
+
+ cat <<\_ASBOX
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+_ASBOX
+ echo
+ for ac_var in $ac_subst_vars
+ do
+ eval ac_val=$`echo $ac_var`
+ echo "$ac_var='"'"'$ac_val'"'"'"
+ done | sort
+ echo
+
+ if test -n "$ac_subst_files"; then
+ cat <<\_ASBOX
+## ------------- ##
+## Output files. ##
+## ------------- ##
+_ASBOX
+ echo
+ for ac_var in $ac_subst_files
+ do
+ eval ac_val=$`echo $ac_var`
+ echo "$ac_var='"'"'$ac_val'"'"'"
+ done | sort
+ echo
+ fi
+
+ if test -s confdefs.h; then
+ cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+ echo
+ sed "/^$/d" confdefs.h | sort
+ echo
+ fi
+ test "$ac_signal" != 0 &&
+ echo "$as_me: caught signal $ac_signal"
+ echo "$as_me: exit $exit_status"
+ } >&5
+ rm -f core core.* *.core &&
+ rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
+ exit $exit_status
+ ' 0
+for ac_signal in 1 2 13 15; do
+ trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -rf conftest* confdefs.h
+# AIX cpp loses on an empty file, so make sure it contains at least a newline.
+echo >confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer explicitly selected file to automatically selected ones.
+if test -z "$CONFIG_SITE"; then
+ if test "x$prefix" != xNONE; then
+ CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+ else
+ CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+ fi
+fi
+for ac_site_file in $CONFIG_SITE; do
+ if test -r "$ac_site_file"; then
+ { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+echo "$as_me: loading site script $ac_site_file" >&6;}
+ sed 's/^/| /' "$ac_site_file" >&5
+ . "$ac_site_file"
+ fi
+done
+
+if test -r "$cache_file"; then
+ # Some versions of bash will fail to source /dev/null (special
+ # files actually), so we avoid doing that.
+ if test -f "$cache_file"; then
+ { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+echo "$as_me: loading cache $cache_file" >&6;}
+ case $cache_file in
+ [\\/]* | ?:[\\/]* ) . $cache_file;;
+ *) . ./$cache_file;;
+ esac
+ fi
+else
+ { echo "$as_me:$LINENO: creating cache $cache_file" >&5
+echo "$as_me: creating cache $cache_file" >&6;}
+ >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in `(set) 2>&1 |
+ sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
+ eval ac_old_set=\$ac_cv_env_${ac_var}_set
+ eval ac_new_set=\$ac_env_${ac_var}_set
+ eval ac_old_val="\$ac_cv_env_${ac_var}_value"
+ eval ac_new_val="\$ac_env_${ac_var}_value"
+ case $ac_old_set,$ac_new_set in
+ set,)
+ { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+ ac_cache_corrupted=: ;;
+ ,set)
+ { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+ ac_cache_corrupted=: ;;
+ ,);;
+ *)
+ if test "x$ac_old_val" != "x$ac_new_val"; then
+ { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+ { echo "$as_me:$LINENO: former value: $ac_old_val" >&5
+echo "$as_me: former value: $ac_old_val" >&2;}
+ { echo "$as_me:$LINENO: current value: $ac_new_val" >&5
+echo "$as_me: current value: $ac_new_val" >&2;}
+ ac_cache_corrupted=:
+ fi;;
+ esac
+ # Pass precious variables to config.status.
+ if test "$ac_new_set" = set; then
+ case $ac_new_val in
+ *" "*|*" "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
+ ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+ *) ac_arg=$ac_var=$ac_new_val ;;
+ esac
+ case " $ac_configure_args " in
+ *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
+ *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+ esac
+ fi
+done
+if $ac_cache_corrupted; then
+ { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
+echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+ { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
+ { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ac_config_headers="$ac_config_headers config.h"
+
+
+VERSION=2.2.2
+
+cat >>confdefs.h <<_ACEOF
+#define MXML_VERSION "Mini-XML v$VERSION"
+_ACEOF
+
+
+CFLAGS="${CFLAGS:=}"
+CXXFLAGS="${CXXFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+
+OPTIM="-O"
+
+
+
+# Check whether --with-ansi or --without-ansi was given.
+if test "${with_ansi+set}" = set; then
+ withval="$with_ansi"
+ use_ansi="$withval"
+else
+ use_ansi="no"
+fi;
+
+# Check whether --enable-debug or --disable-debug was given.
+if test "${enable_debug+set}" = set; then
+ enableval="$enable_debug"
+ if eval "test x$enable_debug = xyes"; then
+ OPTIM="-g"
+else
+ LDFLAGS="$LDFLAGS -s"
+fi
+fi;
+
+
+# Check whether --with-docdir or --without-docdir was given.
+if test "${with_docdir+set}" = set; then
+ withval="$with_docdir"
+ docdir="$withval"
+else
+ docdir="NONE"
+fi;
+
+
+
+
+# Check whether --with-vsnprintf or --without-vsnprintf was given.
+if test "${with_vsnprintf+set}" = set; then
+ withval="$with_vsnprintf"
+ use_vsnprintf="$withval"
+else
+ use_vsnprintf="no"
+fi;
+
+uname=`uname`
+uversion=`uname -r | sed -e '1,$s/[^0-9]//g'`
+if test x$uname = xIRIX64; then
+ uname="IRIX"
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="${ac_tool_prefix}gcc"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+ ac_ct_CC=$CC
+ # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$ac_ct_CC"; then
+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CC="gcc"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ CC=$ac_ct_CC
+else
+ CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="${ac_tool_prefix}cc"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+ ac_ct_CC=$CC
+ # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$ac_ct_CC"; then
+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CC="cc"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ CC=$ac_ct_CC
+else
+ CC="$ac_cv_prog_CC"
+fi
+
+fi
+if test -z "$CC"; then
+ # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+ ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+ ac_prog_rejected=yes
+ continue
+ fi
+ ac_cv_prog_CC="cc"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+if test $ac_prog_rejected = yes; then
+ # We found a bogon in the path, so make sure we never use it.
+ set dummy $ac_cv_prog_CC
+ shift
+ if test $# != 0; then
+ # We chose a different compiler from the bogus one.
+ # However, it has the same basename, so the bogon will be chosen
+ # first if we set CC to just the basename; use the full file name.
+ shift
+ ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+ fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$CC"; then
+ if test -n "$ac_tool_prefix"; then
+ for ac_prog in cl
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$CC"; then
+ ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+ echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$CC" && break
+ done
+fi
+if test -z "$CC"; then
+ ac_ct_CC=$CC
+ for ac_prog in cl
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$ac_ct_CC"; then
+ ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CC="$ac_prog"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+ echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$ac_ct_CC" && break
+done
+
+ CC=$ac_ct_CC
+fi
+
+fi
+
+
+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&5
+echo "$as_me: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&2;}
+ { (exit 1); exit 1; }; }
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO:" \
+ "checking for C compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+ (eval $ac_compiler --version </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+ (eval $ac_compiler -v </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+ (eval $ac_compiler -V </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+echo "$as_me:$LINENO: checking for C compiler default output" >&5
+echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
+ (eval $ac_link_default) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; then
+ # Find the output, starting from the most likely. This scheme is
+# not robust to junk in `.', hence go to wildcards (a.*) only as a last
+# resort.
+
+# Be careful to initialize this variable, since it used to be cached.
+# Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
+ac_cv_exeext=
+# b.out is created by i960 compilers.
+for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
+do
+ test -f "$ac_file" || continue
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
+ ;;
+ conftest.$ac_ext )
+ # This is the source file.
+ ;;
+ [ab].out )
+ # We found the default executable, but exeext='' is most
+ # certainly right.
+ break;;
+ *.* )
+ ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+ # FIXME: I believe we export ac_cv_exeext for Libtool,
+ # but it would be cool to find out if it's true. Does anybody
+ # maintain Libtool? --akim.
+ export ac_cv_exeext
+ break;;
+ * )
+ break;;
+ esac
+done
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
+See \`config.log' for more details." >&5
+echo "$as_me: error: C compiler cannot create executables
+See \`config.log' for more details." >&2;}
+ { (exit 77); exit 77; }; }
+fi
+
+ac_exeext=$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_file" >&5
+echo "${ECHO_T}$ac_file" >&6
+
+# Check the compiler produces executables we can run. If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+# If not cross compiling, check that we can run a simple program.
+if test "$cross_compiling" != yes; then
+ if { ac_try='./$ac_file'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ cross_compiling=no
+ else
+ if test "$cross_compiling" = maybe; then
+ cross_compiling=yes
+ else
+ { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&2;}
+ { (exit 1); exit 1; }; }
+ fi
+ fi
+fi
+echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+
+rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+# Check the compiler produces executables we can run. If not, either
+# the compiler is broken, or we cross compile.
+echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
+echo "$as_me:$LINENO: result: $cross_compiling" >&5
+echo "${ECHO_T}$cross_compiling" >&6
+
+echo "$as_me:$LINENO: checking for suffix of executables" >&5
+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; then
+ # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+ test -f "$ac_file" || continue
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
+ *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+ export ac_cv_exeext
+ break;;
+ * ) break;;
+ esac
+done
+else
+ { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&2;}
+ { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest$ac_cv_exeext
+echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+echo "${ECHO_T}$ac_cv_exeext" >&6
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+echo "$as_me:$LINENO: checking for suffix of object files" >&5
+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
+if test "${ac_cv_objext+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; then
+ for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
+ case $ac_file in
+ *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
+ *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+ break;;
+ esac
+done
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&2;}
+ { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+echo "${ECHO_T}$ac_cv_objext" >&6
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
+if test "${ac_cv_c_compiler_gnu+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+#ifndef __GNUC__
+ choke me
+#endif
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_compiler_gnu=yes
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
+GCC=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+CFLAGS="-g"
+echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_g+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_cv_prog_cc_g=yes
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_cc_g=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
+if test "$ac_test_CFLAGS" = set; then
+ CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+ if test "$GCC" = yes; then
+ CFLAGS="-g -O2"
+ else
+ CFLAGS="-g"
+ fi
+else
+ if test "$GCC" = yes; then
+ CFLAGS="-O2"
+ else
+ CFLAGS=
+ fi
+fi
+echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
+echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
+if test "${ac_cv_prog_cc_stdc+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ ac_cv_prog_cc_stdc=no
+ac_save_CC=$CC
+cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+ char **p;
+ int i;
+{
+ return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+ char *s;
+ va_list v;
+ va_start (v,p);
+ s = g (p, va_arg (v,int));
+ va_end (v);
+ return s;
+}
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];
+ ;
+ return 0;
+}
+_ACEOF
+# Don't try gcc -ansi; that turns off useful extensions and
+# breaks some systems' header files.
+# AIX -qlanglvl=ansi
+# Ultrix and OSF/1 -std1
+# HP-UX 10.20 and later -Ae
+# HP-UX older versions -Aa -D_HPUX_SOURCE
+# SVR4 -Xc -D__EXTENSIONS__
+for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+ CC="$ac_save_CC $ac_arg"
+ rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_cv_prog_cc_stdc=$ac_arg
+break
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.$ac_objext
+done
+rm -f conftest.$ac_ext conftest.$ac_objext
+CC=$ac_save_CC
+
+fi
+
+case "x$ac_cv_prog_cc_stdc" in
+ x|xno)
+ echo "$as_me:$LINENO: result: none needed" >&5
+echo "${ECHO_T}none needed" >&6 ;;
+ *)
+ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
+ CC="$CC $ac_cv_prog_cc_stdc" ;;
+esac
+
+# Some people use a C++ compiler to compile C. Since we use `exit',
+# in C++ we need to declare it. In case someone uses the same compiler
+# for both compiling C and C++ we need to have the C++ compiler decide
+# the declaration of exit, since it's the most demanding environment.
+cat >conftest.$ac_ext <<_ACEOF
+#ifndef __cplusplus
+ choke me
+#endif
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ for ac_declaration in \
+ ''\
+ '#include <stdlib.h>' \
+ 'extern "C" void std::exit (int) throw (); using std::exit;' \
+ 'extern "C" void std::exit (int); using std::exit;' \
+ 'extern "C" void exit (int) throw ();' \
+ 'extern "C" void exit (int);' \
+ 'void exit (int);'
+do
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+#include <stdlib.h>
+$ac_declaration
+int
+main ()
+{
+exit (42);
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ :
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+continue
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_declaration
+int
+main ()
+{
+exit (42);
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ break
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+done
+rm -f conftest*
+if test -n "$ac_declaration"; then
+ echo '#ifdef __cplusplus' >>confdefs.h
+ echo $ac_declaration >>confdefs.h
+ echo '#endif' >>confdefs.h
+fi
+
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=cc
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+ for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
+ do
+ # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_CXX+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$CXX"; then
+ ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+ echo "$as_me:$LINENO: result: $CXX" >&5
+echo "${ECHO_T}$CXX" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$CXX" && break
+ done
+fi
+if test -z "$CXX"; then
+ ac_ct_CXX=$CXX
+ for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$ac_ct_CXX"; then
+ ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_CXX="$ac_prog"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+ echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
+echo "${ECHO_T}$ac_ct_CXX" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ test -n "$ac_ct_CXX" && break
+done
+test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
+
+ CXX=$ac_ct_CXX
+fi
+
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO:" \
+ "checking for C++ compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
+ (eval $ac_compiler --version </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
+ (eval $ac_compiler -v </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
+ (eval $ac_compiler -V </dev/null >&5) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }
+
+echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
+if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+#ifndef __GNUC__
+ choke me
+#endif
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_compiler_gnu=yes
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_compiler_gnu=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
+GXX=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CXXFLAGS=${CXXFLAGS+set}
+ac_save_CXXFLAGS=$CXXFLAGS
+CXXFLAGS="-g"
+echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
+echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
+if test "${ac_cv_prog_cxx_g+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ ac_cv_prog_cxx_g=yes
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+ac_cv_prog_cxx_g=no
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
+if test "$ac_test_CXXFLAGS" = set; then
+ CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+ if test "$GXX" = yes; then
+ CXXFLAGS="-g -O2"
+ else
+ CXXFLAGS="-g"
+ fi
+else
+ if test "$GXX" = yes; then
+ CXXFLAGS="-O2"
+ else
+ CXXFLAGS=
+ fi
+fi
+for ac_declaration in \
+ ''\
+ '#include <stdlib.h>' \
+ 'extern "C" void std::exit (int) throw (); using std::exit;' \
+ 'extern "C" void std::exit (int); using std::exit;' \
+ 'extern "C" void exit (int) throw ();' \
+ 'extern "C" void exit (int);' \
+ 'void exit (int);'
+do
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+#include <stdlib.h>
+$ac_declaration
+int
+main ()
+{
+exit (42);
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ :
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+continue
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+$ac_declaration
+int
+main ()
+{
+exit (42);
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
+ (eval $ac_compile) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest.$ac_objext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ break
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+fi
+rm -f conftest.$ac_objext conftest.$ac_ext
+done
+rm -f conftest*
+if test -n "$ac_declaration"; then
+ echo '#ifdef __cplusplus' >>confdefs.h
+ echo $ac_declaration >>confdefs.h
+ echo '#endif' >>confdefs.h
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_aux_dir=
+for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
+ if test -f $ac_dir/install-sh; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/install-sh -c"
+ break
+ elif test -f $ac_dir/install.sh; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/install.sh -c"
+ break
+ elif test -f $ac_dir/shtool; then
+ ac_aux_dir=$ac_dir
+ ac_install_sh="$ac_aux_dir/shtool install -c"
+ break
+ fi
+done
+if test -z "$ac_aux_dir"; then
+ { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
+echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
+ { (exit 1); exit 1; }; }
+fi
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"
+ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
+
+# Find a good install program. We prefer a C program (faster),
+# so one script is as good as another. But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# ./install, which can be erroneously created by make from ./install.sh.
+echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
+if test -z "$INSTALL"; then
+if test "${ac_cv_path_install+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in
+ ./ | .// | /cC/* | \
+ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+ /usr/ucb/* ) ;;
+ *)
+ # OSF1 and SCO ODT 3.0 have their own names for install.
+ # Don't use installbsd from OSF since it installs stuff as root
+ # by default.
+ for ac_prog in ginstall scoinst install; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+ if test $ac_prog = install &&
+ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # AIX install. It has an incompatible calling convention.
+ :
+ elif test $ac_prog = install &&
+ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # program-specific install script used by HP pwplus--don't use.
+ :
+ else
+ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+ break 3
+ fi
+ fi
+ done
+ done
+ ;;
+esac
+done
+
+
+fi
+ if test "${ac_cv_path_install+set}" = set; then
+ INSTALL=$ac_cv_path_install
+ else
+ # As a last resort, use the slow shell script. We don't cache a
+ # path for INSTALL within a source directory, because that will
+ # break other packages using the cache if that directory is
+ # removed, or if the path is relative.
+ INSTALL=$ac_install_sh
+ fi
+fi
+echo "$as_me:$LINENO: result: $INSTALL" >&5
+echo "${ECHO_T}$INSTALL" >&6
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+if test "$INSTALL" = "$ac_install_sh"; then
+ # Use full path to install-sh script...
+ INSTALL="`pwd`/install-sh -c"
+fi
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_RANLIB+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$RANLIB"; then
+ ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+ echo "$as_me:$LINENO: result: $RANLIB" >&5
+echo "${ECHO_T}$RANLIB" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+ ac_ct_RANLIB=$RANLIB
+ # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ if test -n "$ac_ct_RANLIB"; then
+ ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_RANLIB="ranlib"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+ echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+echo "${ECHO_T}$ac_ct_RANLIB" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ RANLIB=$ac_ct_RANLIB
+else
+ RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+# Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_AR+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $AR in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_AR="$AR" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+AR=$ac_cv_path_AR
+
+if test -n "$AR"; then
+ echo "$as_me:$LINENO: result: $AR" >&5
+echo "${ECHO_T}$AR" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+# Extract the first word of "cp", so it can be a program name with args.
+set dummy cp; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_CP+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $CP in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_CP="$CP" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+CP=$ac_cv_path_CP
+
+if test -n "$CP"; then
+ echo "$as_me:$LINENO: result: $CP" >&5
+echo "${ECHO_T}$CP" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+# Extract the first word of "ln", so it can be a program name with args.
+set dummy ln; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_LN+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $LN in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_LN="$LN" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+LN=$ac_cv_path_LN
+
+if test -n "$LN"; then
+ echo "$as_me:$LINENO: result: $LN" >&5
+echo "${ECHO_T}$LN" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+# Extract the first word of "mkdir", so it can be a program name with args.
+set dummy mkdir; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_MKDIR+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $MKDIR in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+MKDIR=$ac_cv_path_MKDIR
+
+if test -n "$MKDIR"; then
+ echo "$as_me:$LINENO: result: $MKDIR" >&5
+echo "${ECHO_T}$MKDIR" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+# Extract the first word of "nroff", so it can be a program name with args.
+set dummy nroff; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_NROFF+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $NROFF in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_NROFF="$NROFF" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_NROFF="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+NROFF=$ac_cv_path_NROFF
+
+if test -n "$NROFF"; then
+ echo "$as_me:$LINENO: result: $NROFF" >&5
+echo "${ECHO_T}$NROFF" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+if test x$NROFF = x; then
+ # Extract the first word of "groff", so it can be a program name with args.
+set dummy groff; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_GROFF+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $GROFF in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_GROFF="$GROFF" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_GROFF="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+GROFF=$ac_cv_path_GROFF
+
+if test -n "$GROFF"; then
+ echo "$as_me:$LINENO: result: $GROFF" >&5
+echo "${ECHO_T}$GROFF" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+ if test x$GROFF = x; then
+ NROFF="echo"
+ else
+ NROFF="$GROFF -T ascii"
+ fi
+fi
+# Extract the first word of "rm", so it can be a program name with args.
+set dummy rm; ac_word=$2
+echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
+if test "${ac_cv_path_RM+set}" = set; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ case $RM in
+ [\\/]* | ?:[\\/]*)
+ ac_cv_path_RM="$RM" # Let the user override the test with a path.
+ ;;
+ *)
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
+ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+done
+
+ ;;
+esac
+fi
+RM=$ac_cv_path_RM
+
+if test -n "$RM"; then
+ echo "$as_me:$LINENO: result: $RM" >&5
+echo "${ECHO_T}$RM" >&6
+else
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+fi
+
+
+case "$uname" in
+ Darwin* | *BSD*)
+ ARFLAGS="-rcv"
+ ;;
+ *)
+ ARFLAGS="crvs"
+ ;;
+esac
+
+
+
+if test "x$use_ansi" != xyes; then
+
+
+for ac_func in strdup
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+/* System header to define __stub macros and hopefully few prototypes,
+ which can conflict with char $ac_func (); below.
+ Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+ <limits.h> exists even on freestanding compilers. */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+/* Override any gcc2 internal prototype to avoid an error. */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+ builtin and then its argument prototype would still apply. */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+ to always fail with ENOSYS. Some functions are actually named
+ something starting with __ and the normal name is an alias. */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest$ac_exeext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ eval "$as_ac_var=yes"
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+fi
+
+if test "x$use_vsnprintf" != xyes; then
+
+for ac_func in vsnprintf
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
+if eval "test \"\${$as_ac_var+set}\" = set"; then
+ echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+ cat >conftest.$ac_ext <<_ACEOF
+#line $LINENO "configure"
+/* confdefs.h. */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h. */
+/* System header to define __stub macros and hopefully few prototypes,
+ which can conflict with char $ac_func (); below.
+ Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+ <limits.h> exists even on freestanding compilers. */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+/* Override any gcc2 internal prototype to avoid an error. */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+/* We use char because int might match the return type of a gcc2
+ builtin and then its argument prototype would still apply. */
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+ to always fail with ENOSYS. Some functions are actually named
+ something starting with __ and the normal name is an alias. */
+#if defined (__stub_$ac_func) || defined (__stub___$ac_func)
+choke me
+#else
+char (*f) () = $ac_func;
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+int
+main ()
+{
+return f != $ac_func;
+ ;
+ return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
+ (eval $ac_link) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); } &&
+ { ac_try='test -s conftest$ac_exeext'
+ { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
+ (eval $ac_try) 2>&5
+ ac_status=$?
+ echo "$as_me:$LINENO: \$? = $ac_status" >&5
+ (exit $ac_status); }; }; then
+ eval "$as_ac_var=yes"
+else
+ echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+eval "$as_ac_var=no"
+fi
+rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
+fi
+echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
+echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+ cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+fi
+
+DSO="${DSO:=:}"
+DSOFLAGS="${DSOFLAGS:=}"
+
+# Check whether --enable-shared or --disable-shared was given.
+if test "${enable_shared+set}" = set; then
+ enableval="$enable_shared"
+
+fi;
+
+if test x$enable_shared = xyes; then
+ echo "$as_me:$LINENO: checking for shared library support" >&5
+echo $ECHO_N "checking for shared library support... $ECHO_C" >&6
+ PICFLAG=1
+
+ case "$uname" in
+ SunOS* | UNIX_S*)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-h,libmxml.so.1 -G -R\$(libdir) \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -R\$(libdir)"
+ ;;
+
+ HP-UX*)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.sl.1"
+ DSO="ld"
+ DSOFLAGS="$DSOFLAGS -b -z +h libmxml.sl.1 +s +b \$(libdir)"
+ LDFLAGS="$LDFLAGS -Wl,+s,+b,\$(libdir)"
+ ;;
+
+ IRIX)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-rpath,\$(libdir),-set_version,sgi1.0,-soname,libmxml.so.1 -shared \$(OPTIM)"
+ ;;
+
+ OSF1* | Linux | GNU)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-rpath,\$(libdir) -shared \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -Wl,-rpath,\$(libdir)"
+ ;;
+
+ *BSD*)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-R\$(libdir) -shared \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -Wl,-R\$(libdir)"
+ ;;
+
+ Darwin*)
+ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6
+ LIBMXML="libmxml.1.dylib"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS \$(RC_CFLAGS) -dynamiclib -lc"
+ ;;
+
+ *)
+ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6
+ { echo "$as_me:$LINENO: WARNING: shared libraries not supported on this platform." >&5
+echo "$as_me: WARNING: shared libraries not supported on this platform." >&2;}
+ PICFLAG=0
+ LIBMXML="libmxml.a"
+ ;;
+ esac
+else
+ PICFLAG=0
+ LIBMXML="libmxml.a"
+fi
+
+
+
+
+
+
+if test -n "$GCC"; then
+ CFLAGS="-Wall $CFLAGS"
+
+ if test "x$use_ansi" = xyes; then
+ CFLAGS="-ansi -pedantic $CFLAGS"
+ fi
+
+ if test $PICFLAG = 1 -a $uname != AIX; then
+ OPTIM="-fPIC $OPTIM"
+ fi
+else
+ case $uname in
+ HP-UX*)
+ CFLAGS="-Ae $CFLAGS"
+ OPTIM="+DAportable $OPTIM"
+
+ if test $PICFLAG = 1; then
+ OPTIM="+z $OPTIM"
+ fi
+ ;;
+
+ UNIX_SVR* | SunOS*)
+ if test $PICFLAG = 1; then
+ OPTIM="-KPIC $OPTIM"
+ fi
+ ;;
+ esac
+fi
+
+if test "$prefix" = "NONE"; then
+ prefix="/usr/local"
+fi
+
+if test "$exec_prefix" = "NONE"; then
+ exec_prefix="$prefix"
+fi
+
+if test "$docdir" = "NONE"; then
+ docdir="$datadir/doc/mxml"
+fi
+
+if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/usr"; then
+ case "$uname" in
+ *BSD* | Darwin* | Linux*)
+ # BSD, Darwin (MacOS X), and Linux
+ mandir="/usr/share/man"
+ ;;
+ IRIX*)
+ # SGI IRIX
+ mandir="/usr/share/catman/u_man"
+ ;;
+ *)
+ # All others
+ mandir="/usr/man"
+ ;;
+ esac
+fi
+
+case "$uname" in
+ *BSD* | Darwin*)
+ # *BSD
+ CAT1EXT="0"
+ MAN1EXT="1"
+ CAT3EXT="0"
+ MAN3EXT="3"
+ ;;
+ *)
+ # All others
+ CAT1EXT="1"
+ MAN1EXT="1"
+ CAT3EXT="3"
+ MAN3EXT="3"
+ ;;
+esac
+
+
+
+
+
+
+if test "$includedir" != /usr/include; then
+ PC_CFLAGS="-I$includedir"
+else
+ PC_CFLAGS=""
+fi
+
+if test "$libdir" != /usr/lib; then
+ PC_LIBS="-L$libdir -lmxml"
+else
+ PC_LIBS="-lmxml"
+fi
+
+
+
+
+ ac_config_files="$ac_config_files Makefile mxml.list mxml.pc"
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems. If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, don't put newlines in cache variables' values.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+{
+ (set) 2>&1 |
+ case `(ac_space=' '; set | grep ac_space) 2>&1` in
+ *ac_space=\ *)
+ # `set' does not quote correctly, so add quotes (double-quote
+ # substitution turns \\\\ into \\, and sed turns \\ into \).
+ sed -n \
+ "s/'/'\\\\''/g;
+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+ ;;
+ *)
+ # `set' quotes correctly as required by POSIX, so do not add quotes.
+ sed -n \
+ "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
+ ;;
+ esac;
+} |
+ sed '
+ t clear
+ : clear
+ s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+ t end
+ /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+ : end' >>confcache
+if diff $cache_file confcache >/dev/null 2>&1; then :; else
+ if test -w $cache_file; then
+ test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
+ cat confcache >$cache_file
+ else
+ echo "not updating unwritable cache $cache_file"
+ fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+ ac_vpsub='/^[ ]*VPATH[ ]*=/{
+s/:*\$(srcdir):*/:/;
+s/:*\${srcdir}:*/:/;
+s/:*@srcdir@:*/:/;
+s/^\([^=]*=[ ]*\):*/\1/;
+s/:*$//;
+s/^[^=]*=[ ]*$//;
+}'
+fi
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+ # 1. Remove the extension, and $U if already installed.
+ ac_i=`echo "$ac_i" |
+ sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
+ # 2. Add them.
+ ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
+ ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: ${CONFIG_STATUS=./config.status}
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
+echo "$as_me: creating $CONFIG_STATUS" >&6;}
+cat >$CONFIG_STATUS <<_ACEOF
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+SHELL=\${CONFIG_SHELL-$SHELL}
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+## --------------------- ##
+## M4sh Initialization. ##
+## --------------------- ##
+
+# Be Bourne compatible
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+ emulate sh
+ NULLCMD=:
+ # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+ # is contrary to our usage. Disable this feature.
+ alias -g '${1+"$@"}'='"$@"'
+elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
+ set -o posix
+fi
+
+# Support unset when possible.
+if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
+ as_unset=unset
+else
+ as_unset=false
+fi
+
+
+# Work around bugs in pre-3.0 UWIN ksh.
+$as_unset ENV MAIL MAILPATH
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+ LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+ LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+ LC_TELEPHONE LC_TIME
+do
+ if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
+ eval $as_var=C; export $as_var
+ else
+ $as_unset $as_var
+ fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1; then
+ as_expr=expr
+else
+ as_expr=false
+fi
+
+if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
+ as_basename=basename
+else
+ as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+ X"$0" : 'X\(//\)$' \| \
+ X"$0" : 'X\(/\)$' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X/"$0" |
+ sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
+ /^X\/\(\/\/\)$/{ s//\1/; q; }
+ /^X\/\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+
+
+# PATH needs CR, and LINENO needs CR and PATH.
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+ echo "#! /bin/sh" >conf$$.sh
+ echo "exit 0" >>conf$$.sh
+ chmod +x conf$$.sh
+ if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+ PATH_SEPARATOR=';'
+ else
+ PATH_SEPARATOR=:
+ fi
+ rm -f conf$$.sh
+fi
+
+
+ as_lineno_1=$LINENO
+ as_lineno_2=$LINENO
+ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+ test "x$as_lineno_1" != "x$as_lineno_2" &&
+ test "x$as_lineno_3" = "x$as_lineno_2" || {
+ # Find who we are. Look in the path if we contain no path at all
+ # relative or not.
+ case $0 in
+ *[\\/]* ) as_myself=$0 ;;
+ *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+
+ ;;
+ esac
+ # We did not find ourselves, most probably we were run as `sh COMMAND'
+ # in which case we are not to be found in the path.
+ if test "x$as_myself" = x; then
+ as_myself=$0
+ fi
+ if test ! -f "$as_myself"; then
+ { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
+echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
+ { (exit 1); exit 1; }; }
+ fi
+ case $CONFIG_SHELL in
+ '')
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for as_base in sh bash ksh sh5; do
+ case $as_dir in
+ /*)
+ if ("$as_dir/$as_base" -c '
+ as_lineno_1=$LINENO
+ as_lineno_2=$LINENO
+ as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
+ test "x$as_lineno_1" != "x$as_lineno_2" &&
+ test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then
+ $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
+ $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
+ CONFIG_SHELL=$as_dir/$as_base
+ export CONFIG_SHELL
+ exec "$CONFIG_SHELL" "$0" ${1+"$@"}
+ fi;;
+ esac
+ done
+done
+;;
+ esac
+
+ # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+ # uniformly replaced by the line number. The first 'sed' inserts a
+ # line-number line before each line; the second 'sed' does the real
+ # work. The second script uses 'N' to pair each line-number line
+ # with the numbered line, and appends trailing '-' during
+ # substitution so that $LINENO is not a special case at line end.
+ # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+ # second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-)
+ sed '=' <$as_myself |
+ sed '
+ N
+ s,$,-,
+ : loop
+ s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
+ t loop
+ s,-$,,
+ s,^['$as_cr_digits']*\n,,
+ ' >$as_me.lineno &&
+ chmod +x $as_me.lineno ||
+ { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
+echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
+ { (exit 1); exit 1; }; }
+
+ # Don't try to exec as it changes $[0], causing all sort of problems
+ # (the dirname of $[0] is not the place where we might find the
+ # original and so on. Autoconf is especially sensible to this).
+ . ./$as_me.lineno
+ # Exit status is that of the last command.
+ exit
+}
+
+
+case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
+ *c*,-n*) ECHO_N= ECHO_C='
+' ECHO_T=' ' ;;
+ *c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;;
+ *) ECHO_N= ECHO_C='\c' ECHO_T= ;;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1; then
+ as_expr=expr
+else
+ as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+ # We could just check for DJGPP; but this test a) works b) is more generic
+ # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
+ if test -f conf$$.exe; then
+ # Don't use ln at all; we don't have any links
+ as_ln_s='cp -p'
+ else
+ as_ln_s='ln -s'
+ fi
+elif ln conf$$.file conf$$ 2>/dev/null; then
+ as_ln_s=ln
+else
+ as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.file
+
+if mkdir -p . 2>/dev/null; then
+ as_mkdir_p=:
+else
+ as_mkdir_p=false
+fi
+
+as_executable_p="test -f"
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.
+as_nl='
+'
+IFS=" $as_nl"
+
+# CDPATH.
+$as_unset CDPATH
+
+exec 6>&1
+
+# Open the log real soon, to keep \$[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling. Logging --version etc. is OK.
+exec 5>>config.log
+{
+ echo
+ sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+} >&5
+cat >&5 <<_CSEOF
+
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.57. Invocation command line was
+
+ CONFIG_FILES = $CONFIG_FILES
+ CONFIG_HEADERS = $CONFIG_HEADERS
+ CONFIG_LINKS = $CONFIG_LINKS
+ CONFIG_COMMANDS = $CONFIG_COMMANDS
+ $ $0 $@
+
+_CSEOF
+echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
+echo >&5
+_ACEOF
+
+# Files that config.status was made for.
+if test -n "$ac_config_files"; then
+ echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_headers"; then
+ echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_links"; then
+ echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
+fi
+
+if test -n "$ac_config_commands"; then
+ echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+ac_cs_usage="\
+\`$as_me' instantiates files from templates according to the
+current configuration.
+
+Usage: $0 [OPTIONS] [FILE]...
+
+ -h, --help print this help, then exit
+ -V, --version print version number, then exit
+ -q, --quiet do not print progress messages
+ -d, --debug don't remove temporary files
+ --recheck update $as_me by reconfiguring in the same conditions
+ --file=FILE[:TEMPLATE]
+ instantiate the configuration file FILE
+ --header=FILE[:TEMPLATE]
+ instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Report bugs to <bug-autoconf@gnu.org>."
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+ac_cs_version="\\
+config.status
+configured by $0, generated by GNU Autoconf 2.57,
+ with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
+
+Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+srcdir=$srcdir
+INSTALL="$INSTALL"
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+# If no file are specified by the user, then we need to provide default
+# value. By we need to know if files were specified by the user.
+ac_need_defaults=:
+while test $# != 0
+do
+ case $1 in
+ --*=*)
+ ac_option=`expr "x$1" : 'x\([^=]*\)='`
+ ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
+ ac_shift=:
+ ;;
+ -*)
+ ac_option=$1
+ ac_optarg=$2
+ ac_shift=shift
+ ;;
+ *) # This is not an option, so the user has probably given explicit
+ # arguments.
+ ac_option=$1
+ ac_need_defaults=false;;
+ esac
+
+ case $ac_option in
+ # Handling of the options.
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+ -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+ ac_cs_recheck=: ;;
+ --version | --vers* | -V )
+ echo "$ac_cs_version"; exit 0 ;;
+ --he | --h)
+ # Conflict between --help and --header
+ { { echo "$as_me:$LINENO: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&2;}
+ { (exit 1); exit 1; }; };;
+ --help | --hel | -h )
+ echo "$ac_cs_usage"; exit 0 ;;
+ --debug | --d* | -d )
+ debug=: ;;
+ --file | --fil | --fi | --f )
+ $ac_shift
+ CONFIG_FILES="$CONFIG_FILES $ac_optarg"
+ ac_need_defaults=false;;
+ --header | --heade | --head | --hea )
+ $ac_shift
+ CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+ ac_need_defaults=false;;
+ -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+ | -silent | --silent | --silen | --sile | --sil | --si | --s)
+ ac_cs_silent=: ;;
+
+ # This is an error.
+ -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&5
+echo "$as_me: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&2;}
+ { (exit 1); exit 1; }; } ;;
+
+ *) ac_config_targets="$ac_config_targets $1" ;;
+
+ esac
+ shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+ exec 6>/dev/null
+ ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+if \$ac_cs_recheck; then
+ echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+ exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+fi
+
+_ACEOF
+
+
+
+
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_config_target in $ac_config_targets
+do
+ case "$ac_config_target" in
+ # Handling of arguments.
+ "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+ "mxml.list" ) CONFIG_FILES="$CONFIG_FILES mxml.list" ;;
+ "mxml.pc" ) CONFIG_FILES="$CONFIG_FILES mxml.pc" ;;
+ "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+ *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+ { (exit 1); exit 1; }; };;
+ esac
+done
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used. Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+ test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+ test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+fi
+
+# Have a temporary directory for convenience. Make it in the build tree
+# simply because there is no reason to put it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Create a temporary directory, and hook for its removal unless debugging.
+$debug ||
+{
+ trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
+ trap '{ (exit 1); exit 1; }' 1 2 13 15
+}
+
+# Create a (secure) tmp directory for tmp files.
+
+{
+ tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
+ test -n "$tmp" && test -d "$tmp"
+} ||
+{
+ tmp=./confstat$$-$RANDOM
+ (umask 077 && mkdir $tmp)
+} ||
+{
+ echo "$me: cannot create a temporary directory in ." >&2
+ { (exit 1); exit 1; }
+}
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+
+#
+# CONFIG_FILES section.
+#
+
+# No need to generate the scripts if there are no CONFIG_FILES.
+# This happens for instance when ./config.status config.h
+if test -n "\$CONFIG_FILES"; then
+ # Protect against being on the right side of a sed subst in config.status.
+ sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
+ s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
+s,@SHELL@,$SHELL,;t t
+s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
+s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
+s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
+s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
+s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
+s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
+s,@exec_prefix@,$exec_prefix,;t t
+s,@prefix@,$prefix,;t t
+s,@program_transform_name@,$program_transform_name,;t t
+s,@bindir@,$bindir,;t t
+s,@sbindir@,$sbindir,;t t
+s,@libexecdir@,$libexecdir,;t t
+s,@datadir@,$datadir,;t t
+s,@sysconfdir@,$sysconfdir,;t t
+s,@sharedstatedir@,$sharedstatedir,;t t
+s,@localstatedir@,$localstatedir,;t t
+s,@libdir@,$libdir,;t t
+s,@includedir@,$includedir,;t t
+s,@oldincludedir@,$oldincludedir,;t t
+s,@infodir@,$infodir,;t t
+s,@mandir@,$mandir,;t t
+s,@build_alias@,$build_alias,;t t
+s,@host_alias@,$host_alias,;t t
+s,@target_alias@,$target_alias,;t t
+s,@DEFS@,$DEFS,;t t
+s,@ECHO_C@,$ECHO_C,;t t
+s,@ECHO_N@,$ECHO_N,;t t
+s,@ECHO_T@,$ECHO_T,;t t
+s,@LIBS@,$LIBS,;t t
+s,@VERSION@,$VERSION,;t t
+s,@LDFLAGS@,$LDFLAGS,;t t
+s,@OPTIM@,$OPTIM,;t t
+s,@docdir@,$docdir,;t t
+s,@CC@,$CC,;t t
+s,@CFLAGS@,$CFLAGS,;t t
+s,@CPPFLAGS@,$CPPFLAGS,;t t
+s,@ac_ct_CC@,$ac_ct_CC,;t t
+s,@EXEEXT@,$EXEEXT,;t t
+s,@OBJEXT@,$OBJEXT,;t t
+s,@CXX@,$CXX,;t t
+s,@CXXFLAGS@,$CXXFLAGS,;t t
+s,@ac_ct_CXX@,$ac_ct_CXX,;t t
+s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
+s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
+s,@INSTALL_DATA@,$INSTALL_DATA,;t t
+s,@RANLIB@,$RANLIB,;t t
+s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
+s,@AR@,$AR,;t t
+s,@CP@,$CP,;t t
+s,@LN@,$LN,;t t
+s,@MKDIR@,$MKDIR,;t t
+s,@NROFF@,$NROFF,;t t
+s,@GROFF@,$GROFF,;t t
+s,@RM@,$RM,;t t
+s,@ARFLAGS@,$ARFLAGS,;t t
+s,@DSO@,$DSO,;t t
+s,@DSOFLAGS@,$DSOFLAGS,;t t
+s,@LIBMXML@,$LIBMXML,;t t
+s,@PICFLAG@,$PICFLAG,;t t
+s,@CAT1EXT@,$CAT1EXT,;t t
+s,@CAT3EXT@,$CAT3EXT,;t t
+s,@MAN1EXT@,$MAN1EXT,;t t
+s,@MAN3EXT@,$MAN3EXT,;t t
+s,@PC_CFLAGS@,$PC_CFLAGS,;t t
+s,@PC_LIBS@,$PC_LIBS,;t t
+s,@LIBOBJS@,$LIBOBJS,;t t
+s,@LTLIBOBJS@,$LTLIBOBJS,;t t
+CEOF
+
+_ACEOF
+
+ cat >>$CONFIG_STATUS <<\_ACEOF
+ # Split the substitutions into bite-sized pieces for seds with
+ # small command number limits, like on Digital OSF/1 and HP-UX.
+ ac_max_sed_lines=48
+ ac_sed_frag=1 # Number of current file.
+ ac_beg=1 # First line for current file.
+ ac_end=$ac_max_sed_lines # Line after last line for current file.
+ ac_more_lines=:
+ ac_sed_cmds=
+ while $ac_more_lines; do
+ if test $ac_beg -gt 1; then
+ sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+ else
+ sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
+ fi
+ if test ! -s $tmp/subs.frag; then
+ ac_more_lines=false
+ else
+ # The purpose of the label and of the branching condition is to
+ # speed up the sed processing (if there are no `@' at all, there
+ # is no need to browse any of the substitutions).
+ # These are the two extra sed commands mentioned above.
+ (echo ':t
+ /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
+ if test -z "$ac_sed_cmds"; then
+ ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
+ else
+ ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
+ fi
+ ac_sed_frag=`expr $ac_sed_frag + 1`
+ ac_beg=$ac_end
+ ac_end=`expr $ac_end + $ac_max_sed_lines`
+ fi
+ done
+ if test -z "$ac_sed_cmds"; then
+ ac_sed_cmds=cat
+ fi
+fi # test -n "$CONFIG_FILES"
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
+ # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+ case $ac_file in
+ - | *:- | *:-:* ) # input from stdin
+ cat >$tmp/stdin
+ ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+ *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+ * ) ac_file_in=$ac_file.in ;;
+ esac
+
+ # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
+ ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$ac_file" : 'X\(//\)[^/]' \| \
+ X"$ac_file" : 'X\(//\)$' \| \
+ X"$ac_file" : 'X\(/\)' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+ /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+ /^X\(\/\/\)$/{ s//\1/; q; }
+ /^X\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+ { if $as_mkdir_p; then
+ mkdir -p "$ac_dir"
+ else
+ as_dir="$ac_dir"
+ as_dirs=
+ while test ! -d "$as_dir"; do
+ as_dirs="$as_dir $as_dirs"
+ as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$as_dir" : 'X\(//\)[^/]' \| \
+ X"$as_dir" : 'X\(//\)$' \| \
+ X"$as_dir" : 'X\(/\)' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+ /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+ /^X\(\/\/\)$/{ s//\1/; q; }
+ /^X\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+ done
+ test ! -n "$as_dirs" || mkdir $as_dirs
+ fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+ { (exit 1); exit 1; }; }; }
+
+ ac_builddir=.
+
+if test "$ac_dir" != .; then
+ ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+ # A "../" for each directory in $ac_dir_suffix.
+ ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
+else
+ ac_dir_suffix= ac_top_builddir=
+fi
+
+case $srcdir in
+ .) # No --srcdir option. We are building in place.
+ ac_srcdir=.
+ if test -z "$ac_top_builddir"; then
+ ac_top_srcdir=.
+ else
+ ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
+ fi ;;
+ [\\/]* | ?:[\\/]* ) # Absolute path.
+ ac_srcdir=$srcdir$ac_dir_suffix;
+ ac_top_srcdir=$srcdir ;;
+ *) # Relative path.
+ ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
+ ac_top_srcdir=$ac_top_builddir$srcdir ;;
+esac
+# Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
+# absolute.
+ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
+ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
+ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
+ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
+
+
+ case $INSTALL in
+ [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+ *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
+ esac
+
+ if test x"$ac_file" != x-; then
+ { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+ rm -f "$ac_file"
+ fi
+ # Let's still pretend it is `configure' which instantiates (i.e., don't
+ # use $as_me), people would be surprised to read:
+ # /* config.h. Generated by config.status. */
+ if test x"$ac_file" = x-; then
+ configure_input=
+ else
+ configure_input="$ac_file. "
+ fi
+ configure_input=$configure_input"Generated from `echo $ac_file_in |
+ sed 's,.*/,,'` by configure."
+
+ # First look for the input files in the build tree, otherwise in the
+ # src tree.
+ ac_file_inputs=`IFS=:
+ for f in $ac_file_in; do
+ case $f in
+ -) echo $tmp/stdin ;;
+ [\\/$]*)
+ # Absolute (can't be DOS-style, as IFS=:)
+ test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+ { (exit 1); exit 1; }; }
+ echo $f;;
+ *) # Relative
+ if test -f "$f"; then
+ # Build tree
+ echo $f
+ elif test -f "$srcdir/$f"; then
+ # Source tree
+ echo $srcdir/$f
+ else
+ # /dev/null tree
+ { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+ { (exit 1); exit 1; }; }
+ fi;;
+ esac
+ done` || { (exit 1); exit 1; }
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+ sed "$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s,@configure_input@,$configure_input,;t t
+s,@srcdir@,$ac_srcdir,;t t
+s,@abs_srcdir@,$ac_abs_srcdir,;t t
+s,@top_srcdir@,$ac_top_srcdir,;t t
+s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
+s,@builddir@,$ac_builddir,;t t
+s,@abs_builddir@,$ac_abs_builddir,;t t
+s,@top_builddir@,$ac_top_builddir,;t t
+s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
+s,@INSTALL@,$ac_INSTALL,;t t
+" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
+ rm -f $tmp/stdin
+ if test x"$ac_file" != x-; then
+ mv $tmp/out $ac_file
+ else
+ cat $tmp/out
+ rm -f $tmp/out
+ fi
+
+done
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+#
+# CONFIG_HEADER section.
+#
+
+# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
+# NAME is the cpp macro being defined and VALUE is the value it is being given.
+#
+# ac_d sets the value in "#define NAME VALUE" lines.
+ac_dA='s,^\([ ]*\)#\([ ]*define[ ][ ]*\)'
+ac_dB='[ ].*$,\1#\2'
+ac_dC=' '
+ac_dD=',;t'
+# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
+ac_uA='s,^\([ ]*\)#\([ ]*\)undef\([ ][ ]*\)'
+ac_uB='$,\1#\2define\3'
+ac_uC=' '
+ac_uD=',;t'
+
+for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue
+ # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
+ case $ac_file in
+ - | *:- | *:-:* ) # input from stdin
+ cat >$tmp/stdin
+ ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+ *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
+ ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
+ * ) ac_file_in=$ac_file.in ;;
+ esac
+
+ test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+
+ # First look for the input files in the build tree, otherwise in the
+ # src tree.
+ ac_file_inputs=`IFS=:
+ for f in $ac_file_in; do
+ case $f in
+ -) echo $tmp/stdin ;;
+ [\\/$]*)
+ # Absolute (can't be DOS-style, as IFS=:)
+ test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+ { (exit 1); exit 1; }; }
+ echo $f;;
+ *) # Relative
+ if test -f "$f"; then
+ # Build tree
+ echo $f
+ elif test -f "$srcdir/$f"; then
+ # Source tree
+ echo $srcdir/$f
+ else
+ # /dev/null tree
+ { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
+echo "$as_me: error: cannot find input file: $f" >&2;}
+ { (exit 1); exit 1; }; }
+ fi;;
+ esac
+ done` || { (exit 1); exit 1; }
+ # Remove the trailing spaces.
+ sed 's/[ ]*$//' $ac_file_inputs >$tmp/in
+
+_ACEOF
+
+# Transform confdefs.h into two sed scripts, `conftest.defines' and
+# `conftest.undefs', that substitutes the proper values into
+# config.h.in to produce config.h. The first handles `#define'
+# templates, and the second `#undef' templates.
+# And first: Protect against being on the right side of a sed subst in
+# config.status. Protect against being in an unquoted here document
+# in config.status.
+rm -f conftest.defines conftest.undefs
+# Using a here document instead of a string reduces the quoting nightmare.
+# Putting comments in sed scripts is not portable.
+#
+# `end' is used to avoid that the second main sed command (meant for
+# 0-ary CPP macros) applies to n-ary macro definitions.
+# See the Autoconf documentation for `clear'.
+cat >confdef2sed.sed <<\_ACEOF
+s/[\\&,]/\\&/g
+s,[\\$`],\\&,g
+t clear
+: clear
+s,^[ ]*#[ ]*define[ ][ ]*\([^ (][^ (]*\)\(([^)]*)\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
+t end
+s,^[ ]*#[ ]*define[ ][ ]*\([^ ][^ ]*\)[ ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
+: end
+_ACEOF
+# If some macros were called several times there might be several times
+# the same #defines, which is useless. Nevertheless, we may not want to
+# sort them, since we want the *last* AC-DEFINE to be honored.
+uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines
+sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs
+rm -f confdef2sed.sed
+
+# This sed command replaces #undef with comments. This is necessary, for
+# example, in the case of _POSIX_SOURCE, which is predefined and required
+# on some systems where configure will not decide to define it.
+cat >>conftest.undefs <<\_ACEOF
+s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
+_ACEOF
+
+# Break up conftest.defines because some shells have a limit on the size
+# of here documents, and old seds have small limits too (100 cmds).
+echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
+echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
+echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
+echo ' :' >>$CONFIG_STATUS
+rm -f conftest.tail
+while grep . conftest.defines >/dev/null
+do
+ # Write a limited-size here document to $tmp/defines.sed.
+ echo ' cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
+ # Speed up: don't consider the non `#define' lines.
+ echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS
+ # Work around the forget-to-reset-the-flag bug.
+ echo 't clr' >>$CONFIG_STATUS
+ echo ': clr' >>$CONFIG_STATUS
+ sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS
+ echo 'CEOF
+ sed -f $tmp/defines.sed $tmp/in >$tmp/out
+ rm -f $tmp/in
+ mv $tmp/out $tmp/in
+' >>$CONFIG_STATUS
+ sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail
+ rm -f conftest.defines
+ mv conftest.tail conftest.defines
+done
+rm -f conftest.defines
+echo ' fi # grep' >>$CONFIG_STATUS
+echo >>$CONFIG_STATUS
+
+# Break up conftest.undefs because some shells have a limit on the size
+# of here documents, and old seds have small limits too (100 cmds).
+echo ' # Handle all the #undef templates' >>$CONFIG_STATUS
+rm -f conftest.tail
+while grep . conftest.undefs >/dev/null
+do
+ # Write a limited-size here document to $tmp/undefs.sed.
+ echo ' cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
+ # Speed up: don't consider the non `#undef'
+ echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS
+ # Work around the forget-to-reset-the-flag bug.
+ echo 't clr' >>$CONFIG_STATUS
+ echo ': clr' >>$CONFIG_STATUS
+ sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS
+ echo 'CEOF
+ sed -f $tmp/undefs.sed $tmp/in >$tmp/out
+ rm -f $tmp/in
+ mv $tmp/out $tmp/in
+' >>$CONFIG_STATUS
+ sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail
+ rm -f conftest.undefs
+ mv conftest.tail conftest.undefs
+done
+rm -f conftest.undefs
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+ # Let's still pretend it is `configure' which instantiates (i.e., don't
+ # use $as_me), people would be surprised to read:
+ # /* config.h. Generated by config.status. */
+ if test x"$ac_file" = x-; then
+ echo "/* Generated by configure. */" >$tmp/config.h
+ else
+ echo "/* $ac_file. Generated by configure. */" >$tmp/config.h
+ fi
+ cat $tmp/in >>$tmp/config.h
+ rm -f $tmp/in
+ if test x"$ac_file" != x-; then
+ if diff $ac_file $tmp/config.h >/dev/null 2>&1; then
+ { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+echo "$as_me: $ac_file is unchanged" >&6;}
+ else
+ ac_dir=`(dirname "$ac_file") 2>/dev/null ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$ac_file" : 'X\(//\)[^/]' \| \
+ X"$ac_file" : 'X\(//\)$' \| \
+ X"$ac_file" : 'X\(/\)' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X"$ac_file" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+ /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+ /^X\(\/\/\)$/{ s//\1/; q; }
+ /^X\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+ { if $as_mkdir_p; then
+ mkdir -p "$ac_dir"
+ else
+ as_dir="$ac_dir"
+ as_dirs=
+ while test ! -d "$as_dir"; do
+ as_dirs="$as_dir $as_dirs"
+ as_dir=`(dirname "$as_dir") 2>/dev/null ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$as_dir" : 'X\(//\)[^/]' \| \
+ X"$as_dir" : 'X\(//\)$' \| \
+ X"$as_dir" : 'X\(/\)' \| \
+ . : '\(.\)' 2>/dev/null ||
+echo X"$as_dir" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
+ /^X\(\/\/\)[^/].*/{ s//\1/; q; }
+ /^X\(\/\/\)$/{ s//\1/; q; }
+ /^X\(\/\).*/{ s//\1/; q; }
+ s/.*/./; q'`
+ done
+ test ! -n "$as_dirs" || mkdir $as_dirs
+ fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
+echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
+ { (exit 1); exit 1; }; }; }
+
+ rm -f $ac_file
+ mv $tmp/config.h $ac_file
+ fi
+ else
+ cat $tmp/config.h
+ rm -f $tmp/config.h
+ fi
+done
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+{ (exit 0); exit 0; }
+_ACEOF
+chmod +x $CONFIG_STATUS
+ac_clean_files=$ac_clean_files_save
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded. So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status. When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+ ac_cs_success=:
+ ac_config_status_args=
+ test "$silent" = yes &&
+ ac_config_status_args="$ac_config_status_args --quiet"
+ exec 5>/dev/null
+ $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+ exec 5>>config.log
+ # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+ # would make configure fail if this is the last instruction.
+ $ac_cs_success || { (exit 1); exit 1; }
+fi
+
+
--- /dev/null
+dnl
+dnl "$Id$"
+dnl
+dnl Configuration script for Mini-XML, a small XML-like file parsing library.
+dnl
+dnl Copyright 2003-2005 by Michael Sweet.
+dnl
+dnl This program is free software; you can redistribute it and/or
+dnl modify it under the terms of the GNU Library General Public
+dnl License as published by the Free Software Foundation; either
+dnl version 2, or (at your option) any later version.
+dnl
+dnl This program is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+dnl GNU General Public License for more details.
+dnl
+
+dnl Specify a source file from the distribution...
+AC_INIT(mxml.h)
+
+dnl Set the name of the config header file...
+AC_CONFIG_HEADER(config.h)
+
+dnl Version number...
+VERSION=2.2.2
+AC_SUBST(VERSION)
+AC_DEFINE_UNQUOTED(MXML_VERSION, "Mini-XML v$VERSION")
+
+dnl Clear default debugging options and set normal optimization by
+dnl default unless the user asks for debugging specifically.
+CFLAGS="${CFLAGS:=}"
+CXXFLAGS="${CXXFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+AC_SUBST(LDFLAGS)
+OPTIM="-O"
+AC_SUBST(OPTIM)
+
+AC_ARG_WITH(ansi, [ --with-ansi set full ANSI C mode, default=no],
+ use_ansi="$withval",
+ use_ansi="no")
+
+AC_ARG_ENABLE(debug, [ --enable-debug turn on debugging, default=no],
+if eval "test x$enable_debug = xyes"; then
+ OPTIM="-g"
+else
+ LDFLAGS="$LDFLAGS -s"
+fi)
+
+AC_ARG_WITH(docdir, [ --with-docdir set directory for documentation, default=${prefix}/share/doc/mxml],
+ docdir="$withval",
+ docdir="NONE")
+
+AC_SUBST(docdir)
+
+AC_ARG_WITH(vsnprintf, [ --with-vsnprintf use vsnprintf emulation functions, default=auto],
+ use_vsnprintf="$withval",
+ use_vsnprintf="no")
+
+dnl Get the operating system and version number...
+uname=`uname`
+uversion=`uname -r | sed -e '1,$s/[[^0-9]]//g'`
+if test x$uname = xIRIX64; then
+ uname="IRIX"
+fi
+
+dnl Checks for programs...
+AC_PROG_CC
+AC_PROG_CXX
+AC_PROG_INSTALL
+if test "$INSTALL" = "$ac_install_sh"; then
+ # Use full path to install-sh script...
+ INSTALL="`pwd`/install-sh -c"
+fi
+AC_PROG_RANLIB
+AC_PATH_PROG(AR,ar)
+AC_PATH_PROG(CP,cp)
+AC_PATH_PROG(LN,ln)
+AC_PATH_PROG(MKDIR,mkdir)
+AC_PATH_PROG(NROFF,nroff)
+if test x$NROFF = x; then
+ AC_PATH_PROG(GROFF,groff)
+ if test x$GROFF = x; then
+ NROFF="echo"
+ else
+ NROFF="$GROFF -T ascii"
+ fi
+fi
+AC_PATH_PROG(RM,rm)
+
+dnl Flags for "ar" command...
+case "$uname" in
+ Darwin* | *BSD*)
+ ARFLAGS="-rcv"
+ ;;
+ *)
+ ARFLAGS="crvs"
+ ;;
+esac
+
+AC_SUBST(ARFLAGS)
+
+dnl Checks for string functions.
+if test "x$use_ansi" != xyes; then
+ AC_CHECK_FUNCS(strdup)
+fi
+
+if test "x$use_vsnprintf" != xyes; then
+ AC_CHECK_FUNCS(vsnprintf)
+fi
+
+dnl Shared library support...
+DSO="${DSO:=:}"
+DSOFLAGS="${DSOFLAGS:=}"
+
+AC_ARG_ENABLE(shared, [ --enable-shared turn on shared libraries, default=no])
+
+if test x$enable_shared = xyes; then
+ AC_MSG_CHECKING(for shared library support)
+ PICFLAG=1
+
+ case "$uname" in
+ SunOS* | UNIX_S*)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-h,libmxml.so.1 -G -R\$(libdir) \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -R\$(libdir)"
+ ;;
+
+ HP-UX*)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.sl.1"
+ DSO="ld"
+ DSOFLAGS="$DSOFLAGS -b -z +h libmxml.sl.1 +s +b \$(libdir)"
+ LDFLAGS="$LDFLAGS -Wl,+s,+b,\$(libdir)"
+ ;;
+
+ IRIX)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-rpath,\$(libdir),-set_version,sgi1.0,-soname,libmxml.so.1 -shared \$(OPTIM)"
+ ;;
+
+ OSF1* | Linux | GNU)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-rpath,\$(libdir) -shared \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -Wl,-rpath,\$(libdir)"
+ ;;
+
+ *BSD*)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.so.1.0"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-R\$(libdir) -shared \$(OPTIM)"
+ LDFLAGS="$LDFLAGS -Wl,-R\$(libdir)"
+ ;;
+
+ Darwin*)
+ AC_MSG_RESULT(yes)
+ LIBMXML="libmxml.1.dylib"
+ DSO="\$(CC)"
+ DSOFLAGS="$DSOFLAGS \$(RC_CFLAGS) -dynamiclib -lc"
+ ;;
+
+ *)
+ AC_MSG_RESULT(no)
+ AC_MSG_WARN(shared libraries not supported on this platform.)
+ PICFLAG=0
+ LIBMXML="libmxml.a"
+ ;;
+ esac
+else
+ PICFLAG=0
+ LIBMXML="libmxml.a"
+fi
+
+AC_SUBST(DSO)
+AC_SUBST(DSOFLAGS)
+AC_SUBST(LIBMXML)
+AC_SUBST(PICFLAG)
+
+dnl Add -Wall for GCC...
+if test -n "$GCC"; then
+ CFLAGS="-Wall $CFLAGS"
+
+ if test "x$use_ansi" = xyes; then
+ CFLAGS="-ansi -pedantic $CFLAGS"
+ fi
+
+ if test $PICFLAG = 1 -a $uname != AIX; then
+ OPTIM="-fPIC $OPTIM"
+ fi
+else
+ case $uname in
+ HP-UX*)
+ CFLAGS="-Ae $CFLAGS"
+ OPTIM="+DAportable $OPTIM"
+
+ if test $PICFLAG = 1; then
+ OPTIM="+z $OPTIM"
+ fi
+ ;;
+
+ UNIX_SVR* | SunOS*)
+ if test $PICFLAG = 1; then
+ OPTIM="-KPIC $OPTIM"
+ fi
+ ;;
+ esac
+fi
+
+dnl Fix "prefix" variable if it hasn't been specified...
+if test "$prefix" = "NONE"; then
+ prefix="/usr/local"
+fi
+
+dnl Fix "exec_prefix" variable if it hasn't been specified...
+if test "$exec_prefix" = "NONE"; then
+ exec_prefix="$prefix"
+fi
+
+dnl Fix "docdir" variable if it hasn't been specified...
+if test "$docdir" = "NONE"; then
+ docdir="$datadir/doc/mxml"
+fi
+
+dnl Fix "mandir" variable if it hasn't been specified...
+if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/usr"; then
+ case "$uname" in
+ *BSD* | Darwin* | Linux*)
+ # BSD, Darwin (MacOS X), and Linux
+ mandir="/usr/share/man"
+ ;;
+ IRIX*)
+ # SGI IRIX
+ mandir="/usr/share/catman/u_man"
+ ;;
+ *)
+ # All others
+ mandir="/usr/man"
+ ;;
+ esac
+fi
+
+dnl More manpage stuff...
+case "$uname" in
+ *BSD* | Darwin*)
+ # *BSD
+ CAT1EXT="0"
+ MAN1EXT="1"
+ CAT3EXT="0"
+ MAN3EXT="3"
+ ;;
+ *)
+ # All others
+ CAT1EXT="1"
+ MAN1EXT="1"
+ CAT3EXT="3"
+ MAN3EXT="3"
+ ;;
+esac
+
+AC_SUBST(CAT1EXT)
+AC_SUBST(CAT3EXT)
+AC_SUBST(MAN1EXT)
+AC_SUBST(MAN3EXT)
+
+dnl pkg-config stuff...
+if test "$includedir" != /usr/include; then
+ PC_CFLAGS="-I$includedir"
+else
+ PC_CFLAGS=""
+fi
+
+if test "$libdir" != /usr/lib; then
+ PC_LIBS="-L$libdir -lmxml"
+else
+ PC_LIBS="-lmxml"
+fi
+
+AC_SUBST(PC_CFLAGS)
+AC_SUBST(PC_LIBS)
+
+dnl Output the makefile, etc...
+AC_OUTPUT(Makefile mxml.list mxml.pc)
+
+dnl
+dnl End of "$Id$".
+dnl
--- /dev/null
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission. M.I.T. makes no representations about the
+# suitability of this software for any purpose. It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch. It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+ case $1 in
+ -c) instcmd="$cpprog"
+ shift
+ continue;;
+
+ -d) dir_arg=true
+ shift
+ continue;;
+
+ -m) chmodcmd="$chmodprog $2"
+ shift
+ shift
+ continue;;
+
+ -o) chowncmd="$chownprog $2"
+ shift
+ shift
+ continue;;
+
+ -g) chgrpcmd="$chgrpprog $2"
+ shift
+ shift
+ continue;;
+
+ -s) stripcmd="$stripprog"
+ shift
+ continue;;
+
+ -t=*) transformarg=`echo $1 | sed 's/-t=//'`
+ shift
+ continue;;
+
+ -b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+ shift
+ continue;;
+
+ *) if [ x"$src" = x ]
+ then
+ src=$1
+ else
+ # this colon is to work around a 386BSD /bin/sh bug
+ :
+ dst=$1
+ fi
+ shift
+ continue;;
+ esac
+done
+
+if [ x"$src" = x ]
+then
+ echo "install: no input file specified"
+ exit 1
+else
+ :
+fi
+
+if [ x"$dir_arg" != x ]; then
+ dst=$src
+ src=""
+
+ if [ -d $dst ]; then
+ instcmd=:
+ chmodcmd=""
+ else
+ instcmd=$mkdirprog
+ fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad
+# if $src (and thus $dsttmp) contains '*'.
+
+ if [ -f $src -o -d $src ]
+ then
+ :
+ else
+ echo "install: $src does not exist"
+ exit 1
+ fi
+
+ if [ x"$dst" = x ]
+ then
+ echo "install: no destination specified"
+ exit 1
+ else
+ :
+ fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+ if [ -d $dst ]
+ then
+ dst="$dst"/`basename $src`
+ else
+ :
+ fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+# this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='
+ '
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+ pathcomp="${pathcomp}${1}"
+ shift
+
+ if [ ! -d "${pathcomp}" ] ;
+ then
+ $mkdirprog "${pathcomp}"
+ else
+ :
+ fi
+
+ pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+ $doit $instcmd $dst &&
+
+ if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else : ; fi &&
+ if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else : ; fi &&
+ if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else : ; fi &&
+ if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else : ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+ if [ x"$transformarg" = x ]
+ then
+ dstfile=`basename $dst`
+ else
+ dstfile=`basename $dst $transformbasename |
+ sed $transformarg`$transformbasename
+ fi
+
+# don't allow the sed command to completely eliminate the filename
+
+ if [ x"$dstfile" = x ]
+ then
+ dstfile=`basename $dst`
+ else
+ :
+ fi
+
+# Make a temp file name in the proper directory.
+
+ dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+ $doit $instcmd $src $dsttmp &&
+
+ trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing. If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+ if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else :;fi &&
+ if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else :;fi &&
+ if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else :;fi &&
+ if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else :;fi &&
+
+# Now rename the file to the real destination.
+
+ $doit $rmcmd -f $dstdir/$dstfile &&
+ $doit $mvcmd $dsttmp $dstdir/$dstfile
+
+fi &&
+
+
+exit 0
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Attribute support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlElementGetAttr() - Get an attribute.
+ * mxmlElementSetAttr() - Set an attribute.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlElementGetAttr()' - Get an attribute.
+ *
+ * This function returns NULL if the node is not an element or the
+ * named attribute does not exist.
+ */
+
+const char * /* O - Attribute value or NULL */
+mxmlElementGetAttr(mxml_node_t *node, /* I - Element node */
+ const char *name) /* I - Name of attribute */
+{
+ int i; /* Looping var */
+ mxml_attr_t *attr; /* Cirrent attribute */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
+ node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_ELEMENT || !name)
+ return (NULL);
+
+ /*
+ * Look for the attribute...
+ */
+
+ for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+ i > 0;
+ i --, attr ++)
+ if (!strcmp(attr->name, name))
+ return (attr->value);
+
+ /*
+ * Didn't find attribute, so return NULL...
+ */
+
+ return (NULL);
+}
+
+
+/*
+ * 'mxmlElementSetAttr()' - Set an attribute.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new string value. The string value is copied
+ * into the element node. This function does nothing if the node is
+ * not an element.
+ */
+
+void
+mxmlElementSetAttr(mxml_node_t *node, /* I - Element node */
+ const char *name, /* I - Name of attribute */
+ const char *value) /* I - Attribute value */
+{
+ int i; /* Looping var */
+ mxml_attr_t *attr; /* New attribute */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
+ node, name ? name : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_ELEMENT || !name)
+ return;
+
+ /*
+ * Look for the attribute...
+ */
+
+ for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+ i > 0;
+ i --, attr ++)
+ if (!strcmp(attr->name, name))
+ {
+ /*
+ * Replace the attribute value and return...
+ */
+
+ if (attr->value)
+ free(attr->value);
+
+ if (value)
+ {
+ if ((attr->value = strdup(value)) == NULL)
+ mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+ name, node->value.element.name);
+ }
+ else
+ attr->value = NULL;
+
+ return;
+ }
+
+ /*
+ * Attribute not found, so add a new one...
+ */
+
+ if (node->value.element.num_attrs == 0)
+ attr = malloc(sizeof(mxml_attr_t));
+ else
+ attr = realloc(node->value.element.attrs,
+ (node->value.element.num_attrs + 1) * sizeof(mxml_attr_t));
+
+ if (!attr)
+ {
+ mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+ name, node->value.element.name);
+ return;
+ }
+
+ node->value.element.attrs = attr;
+ attr += node->value.element.num_attrs;
+
+ attr->name = strdup(name);
+ if (value)
+ attr->value = strdup(value);
+ else
+ attr->value = NULL;
+
+ if (!attr->name || (!attr->value && value))
+ {
+ if (attr->name)
+ free(attr->name);
+
+ if (attr->value)
+ free(attr->value);
+
+ mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+ name, node->value.element.name);
+
+ return;
+ }
+
+ node->value.element.num_attrs ++;
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Character entity support code for Mini-XML, a small XML-like
+ * file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlEntityAddCallback() - Add a callback to convert entities to
+ * Unicode.
+ * mxmlEntityGetName() - Get the name that corresponds to the
+ * character value.
+ * mxmlEntityGetValue() - Get the character corresponding to a named
+ * entity.
+ * mxmlEntityRemoveCallback() - Remove a callback.
+ * default_callback() - Lookup standard (X)HTML entities.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static int default_callback(const char *name);
+
+
+/*
+ * Callback array...
+ */
+
+static int num_callbacks = 1;
+static int (*callbacks[100])(const char *name) =
+ {
+ default_callback
+ };
+
+
+/*
+ * 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlEntityAddCallback(int (*cb)(const char *name))
+ /* I - Callback function to add */
+{
+ if (num_callbacks < (int)(sizeof(callbacks) / sizeof(callbacks[0])))
+ {
+ callbacks[num_callbacks] = cb;
+ num_callbacks ++;
+
+ return (0);
+ }
+ else
+ {
+ mxml_error("Unable to add entity callback!");
+
+ return (-1);
+ }
+}
+
+
+/*
+ * 'mxmlEntityGetName()' - Get the name that corresponds to the character value.
+ *
+ * If val does not need to be represented by a named entity, NULL is returned.
+ */
+
+const char * /* O - Entity name or NULL */
+mxmlEntityGetName(int val) /* I - Character value */
+{
+ switch (val)
+ {
+ case '&' :
+ return ("amp");
+
+ case '<' :
+ return ("lt");
+
+ case '>' :
+ return ("gt");
+
+ case '\"' :
+ return ("quot");
+
+ default :
+ return (NULL);
+ }
+}
+
+
+/*
+ * 'mxmlEntityGetValue()' - Get the character corresponding to a named entity.
+ *
+ * The entity name can also be a numeric constant. -1 is returned if the
+ * name is not known.
+ */
+
+int /* O - Character value or -1 on error */
+mxmlEntityGetValue(const char *name) /* I - Entity name */
+{
+ int i; /* Looping var */
+ int ch; /* Character value */
+
+
+ for (i = 0; i < num_callbacks; i ++)
+ if ((ch = (callbacks[i])(name)) >= 0)
+ return (ch);
+
+ return (-1);
+}
+
+
+/*
+ * 'mxmlEntityRemoveCallback()' - Remove a callback.
+ */
+
+void
+mxmlEntityRemoveCallback(int (*cb)(const char *name))
+ /* I - Callback function to remove */
+{
+ int i; /* Looping var */
+
+
+ for (i = 0; i < num_callbacks; i ++)
+ if (cb == callbacks[i])
+ {
+ /*
+ * Remove the callback...
+ */
+
+ num_callbacks --;
+
+ if (i < num_callbacks)
+ memmove(callbacks + i, callbacks + i + 1,
+ (num_callbacks - i) * sizeof(callbacks[0]));
+
+ return;
+ }
+}
+
+
+/*
+ * 'default_callback()' - Lookup standard (X)HTML entities.
+ */
+
+static int /* O - Unicode value or -1 */
+default_callback(const char *name) /* I - Entity name */
+{
+ int diff, /* Difference between names */
+ current, /* Current entity in search */
+ first, /* First entity in search */
+ last; /* Last entity in search */
+ static const struct
+ {
+ const char *name; /* Entity name */
+ int val; /* Character value */
+ } entities[] =
+ {
+ { "AElig", 198 },
+ { "Aacute", 193 },
+ { "Acirc", 194 },
+ { "Agrave", 192 },
+ { "Alpha", 913 },
+ { "Aring", 197 },
+ { "Atilde", 195 },
+ { "Auml", 196 },
+ { "Beta", 914 },
+ { "Ccedil", 199 },
+ { "Chi", 935 },
+ { "Dagger", 8225 },
+ { "Delta", 916 },
+ { "Dstrok", 208 },
+ { "ETH", 208 },
+ { "Eacute", 201 },
+ { "Ecirc", 202 },
+ { "Egrave", 200 },
+ { "Epsilon", 917 },
+ { "Eta", 919 },
+ { "Euml", 203 },
+ { "Gamma", 915 },
+ { "Iacute", 205 },
+ { "Icirc", 206 },
+ { "Igrave", 204 },
+ { "Iota", 921 },
+ { "Iuml", 207 },
+ { "Kappa", 922 },
+ { "Lambda", 923 },
+ { "Mu", 924 },
+ { "Ntilde", 209 },
+ { "Nu", 925 },
+ { "OElig", 338 },
+ { "Oacute", 211 },
+ { "Ocirc", 212 },
+ { "Ograve", 210 },
+ { "Omega", 937 },
+ { "Omicron", 927 },
+ { "Oslash", 216 },
+ { "Otilde", 213 },
+ { "Ouml", 214 },
+ { "Phi", 934 },
+ { "Pi", 928 },
+ { "Prime", 8243 },
+ { "Psi", 936 },
+ { "Rho", 929 },
+ { "Scaron", 352 },
+ { "Sigma", 931 },
+ { "THORN", 222 },
+ { "Tau", 932 },
+ { "Theta", 920 },
+ { "Uacute", 218 },
+ { "Ucirc", 219 },
+ { "Ugrave", 217 },
+ { "Upsilon", 933 },
+ { "Uuml", 220 },
+ { "Xi", 926 },
+ { "Yacute", 221 },
+ { "Yuml", 376 },
+ { "Zeta", 918 },
+ { "aacute", 225 },
+ { "acirc", 226 },
+ { "acute", 180 },
+ { "aelig", 230 },
+ { "agrave", 224 },
+ { "alefsym", 8501 },
+ { "alpha", 945 },
+ { "amp", '&' },
+ { "and", 8743 },
+ { "ang", 8736 },
+ { "aring", 229 },
+ { "asymp", 8776 },
+ { "atilde", 227 },
+ { "auml", 228 },
+ { "bdquo", 8222 },
+ { "beta", 946 },
+ { "brkbar", 166 },
+ { "brvbar", 166 },
+ { "bull", 8226 },
+ { "cap", 8745 },
+ { "ccedil", 231 },
+ { "cedil", 184 },
+ { "cent", 162 },
+ { "chi", 967 },
+ { "circ", 710 },
+ { "clubs", 9827 },
+ { "cong", 8773 },
+ { "copy", 169 },
+ { "crarr", 8629 },
+ { "cup", 8746 },
+ { "curren", 164 },
+ { "dArr", 8659 },
+ { "dagger", 8224 },
+ { "darr", 8595 },
+ { "deg", 176 },
+ { "delta", 948 },
+ { "diams", 9830 },
+ { "die", 168 },
+ { "divide", 247 },
+ { "eacute", 233 },
+ { "ecirc", 234 },
+ { "egrave", 232 },
+ { "empty", 8709 },
+ { "emsp", 8195 },
+ { "ensp", 8194 },
+ { "epsilon", 949 },
+ { "equiv", 8801 },
+ { "eta", 951 },
+ { "eth", 240 },
+ { "euml", 235 },
+ { "euro", 8364 },
+ { "exist", 8707 },
+ { "fnof", 402 },
+ { "forall", 8704 },
+ { "frac12", 189 },
+ { "frac14", 188 },
+ { "frac34", 190 },
+ { "frasl", 8260 },
+ { "gamma", 947 },
+ { "ge", 8805 },
+ { "gt", '>' },
+ { "hArr", 8660 },
+ { "harr", 8596 },
+ { "hearts", 9829 },
+ { "hellip", 8230 },
+ { "hibar", 175 },
+ { "iacute", 237 },
+ { "icirc", 238 },
+ { "iexcl", 161 },
+ { "igrave", 236 },
+ { "image", 8465 },
+ { "infin", 8734 },
+ { "int", 8747 },
+ { "iota", 953 },
+ { "iquest", 191 },
+ { "isin", 8712 },
+ { "iuml", 239 },
+ { "kappa", 954 },
+ { "lArr", 8656 },
+ { "lambda", 955 },
+ { "lang", 9001 },
+ { "laquo", 171 },
+ { "larr", 8592 },
+ { "lceil", 8968 },
+ { "ldquo", 8220 },
+ { "le", 8804 },
+ { "lfloor", 8970 },
+ { "lowast", 8727 },
+ { "loz", 9674 },
+ { "lrm", 8206 },
+ { "lsaquo", 8249 },
+ { "lsquo", 8216 },
+ { "lt", '<' },
+ { "macr", 175 },
+ { "mdash", 8212 },
+ { "micro", 181 },
+ { "middot", 183 },
+ { "minus", 8722 },
+ { "mu", 956 },
+ { "nabla", 8711 },
+ { "nbsp", 160 },
+ { "ndash", 8211 },
+ { "ne", 8800 },
+ { "ni", 8715 },
+ { "not", 172 },
+ { "notin", 8713 },
+ { "nsub", 8836 },
+ { "ntilde", 241 },
+ { "nu", 957 },
+ { "oacute", 243 },
+ { "ocirc", 244 },
+ { "oelig", 339 },
+ { "ograve", 242 },
+ { "oline", 8254 },
+ { "omega", 969 },
+ { "omicron", 959 },
+ { "oplus", 8853 },
+ { "or", 8744 },
+ { "ordf", 170 },
+ { "ordm", 186 },
+ { "oslash", 248 },
+ { "otilde", 245 },
+ { "otimes", 8855 },
+ { "ouml", 246 },
+ { "para", 182 },
+ { "part", 8706 },
+ { "permil", 8240 },
+ { "perp", 8869 },
+ { "phi", 966 },
+ { "pi", 960 },
+ { "piv", 982 },
+ { "plusmn", 177 },
+ { "pound", 163 },
+ { "prime", 8242 },
+ { "prod", 8719 },
+ { "prop", 8733 },
+ { "psi", 968 },
+ { "quot", '\"' },
+ { "rArr", 8658 },
+ { "radic", 8730 },
+ { "rang", 9002 },
+ { "raquo", 187 },
+ { "rarr", 8594 },
+ { "rceil", 8969 },
+ { "rdquo", 8221 },
+ { "real", 8476 },
+ { "reg", 174 },
+ { "rfloor", 8971 },
+ { "rho", 961 },
+ { "rlm", 8207 },
+ { "rsaquo", 8250 },
+ { "rsquo", 8217 },
+ { "sbquo", 8218 },
+ { "scaron", 353 },
+ { "sdot", 8901 },
+ { "sect", 167 },
+ { "shy", 173 },
+ { "sigma", 963 },
+ { "sigmaf", 962 },
+ { "sim", 8764 },
+ { "spades", 9824 },
+ { "sub", 8834 },
+ { "sube", 8838 },
+ { "sum", 8721 },
+ { "sup", 8835 },
+ { "sup1", 185 },
+ { "sup2", 178 },
+ { "sup3", 179 },
+ { "supe", 8839 },
+ { "szlig", 223 },
+ { "tau", 964 },
+ { "there4", 8756 },
+ { "theta", 952 },
+ { "thetasym", 977 },
+ { "thinsp", 8201 },
+ { "thorn", 254 },
+ { "tilde", 732 },
+ { "times", 215 },
+ { "trade", 8482 },
+ { "uArr", 8657 },
+ { "uacute", 250 },
+ { "uarr", 8593 },
+ { "ucirc", 251 },
+ { "ugrave", 249 },
+ { "uml", 168 },
+ { "upsih", 978 },
+ { "upsilon", 965 },
+ { "uuml", 252 },
+ { "weierp", 8472 },
+ { "xi", 958 },
+ { "yacute", 253 },
+ { "yen", 165 },
+ { "yuml", 255 },
+ { "zeta", 950 },
+ { "zwj", 8205 },
+ { "zwnj", 8204 }
+ };
+
+
+ /*
+ * Do a binary search for the named entity...
+ */
+
+ first = 0;
+ last = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
+
+ while ((last - first) > 1)
+ {
+ current = (first + last) / 2;
+
+ if ((diff = strcmp(name, entities[current].name)) == 0)
+ return (entities[current].val);
+ else if (diff < 0)
+ last = current;
+ else
+ first = current;
+ }
+
+ /*
+ * If we get here, there is a small chance that there is still
+ * a match; check first and last...
+ */
+
+ if (!strcmp(name, entities[first].name))
+ return (entities[first].val);
+ else if (!strcmp(name, entities[last].name))
+ return (entities[last].val);
+ else
+ return (-1);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * File loading code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlLoadFd() - Load a file descriptor into an XML node tree.
+ * mxmlLoadFile() - Load a file into an XML node tree.
+ * mxmlLoadString() - Load a string into an XML node tree.
+ * mxmlSaveAllocString() - Save an XML node tree to an allocated string.
+ * mxmlSaveFd() - Save an XML tree to a file descriptor.
+ * mxmlSaveFile() - Save an XML tree to a file.
+ * mxmlSaveString() - Save an XML node tree to a string.
+ * mxmlSetCustomHandlers() - Set the handling functions for custom data.
+ * mxmlSetErrorCallback() - Set the error message callback.
+ * mxml_add_char() - Add a character to a buffer, expanding as needed.
+ * mxml_fd_getc() - Read a character from a file descriptor.
+ * mxml_fd_putc() - Write a character to a file descriptor.
+ * mxml_fd_read() - Read a buffer of data from a file descriptor.
+ * mxml_fd_write() - Write a buffer of data to a file descriptor.
+ * mxml_file_getc() - Get a character from a file.
+ * mxml_file_putc() - Write a character to a file.
+ * mxml_get_entity() - Get the character corresponding to an entity...
+ * mxml_load_data() - Load data into an XML node tree.
+ * mxml_parse_element() - Parse an element for any attributes...
+ * mxml_string_getc() - Get a character from a string.
+ * mxml_string_putc() - Write a character to a string.
+ * mxml_write_name() - Write a name string.
+ * mxml_write_node() - Save an XML node to a file.
+ * mxml_write_string() - Write a string, escaping & and < as needed.
+ * mxml_write_ws() - Do whitespace callback...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#ifdef WIN32
+# include <io.h>
+#else
+# include <unistd.h>
+#endif /* WIN32 */
+
+
+/*
+ * Character encoding...
+ */
+
+#define ENCODE_UTF8 0 /* UTF-8 */
+#define ENCODE_UTF16BE 1 /* UTF-16 Big-Endian */
+#define ENCODE_UTF16LE 2 /* UTF-16 Little-Endian */
+
+
+/*
+ * Macro to test for a bad XML character...
+ */
+
+#define mxml_bad_char(ch) ((ch) < ' ' && (ch) != '\n' && (ch) != '\r' && (ch) != '\t')
+
+
+/*
+ * Structures...
+ */
+
+typedef struct mxml_fdbuf_s /**** File descriptor buffer (@private) ****/
+{
+ int fd; /* File descriptor */
+ unsigned char *current, /* Current position in buffer */
+ *end, /* End of buffer */
+ buffer[8192]; /* Character buffer */
+} mxml_fdbuf_t;
+
+
+/*
+ * Global error handler...
+ */
+
+extern void (*mxml_error_cb)(const char *);
+
+
+/*
+ * Custom data handlers...
+ */
+
+static mxml_custom_load_cb_t mxml_custom_load_cb = NULL;
+static mxml_custom_save_cb_t mxml_custom_save_cb = NULL;
+
+
+/*
+ * Local functions...
+ */
+
+static int mxml_add_char(int ch, char **ptr, char **buffer,
+ int *bufsize);
+static int mxml_fd_getc(void *p, int *encoding);
+static int mxml_fd_putc(int ch, void *p);
+static int mxml_fd_read(mxml_fdbuf_t *buf);
+static int mxml_fd_write(mxml_fdbuf_t *buf);
+static int mxml_file_getc(void *p, int *encoding);
+static int mxml_file_putc(int ch, void *p);
+static int mxml_get_entity(mxml_node_t *parent, void *p,
+ int *encoding,
+ int (*getc_cb)(void *, int *));
+static mxml_node_t *mxml_load_data(mxml_node_t *top, void *p,
+ mxml_type_t (*cb)(mxml_node_t *),
+ int (*getc_cb)(void *, int *));
+static int mxml_parse_element(mxml_node_t *node, void *p,
+ int *encoding,
+ int (*getc_cb)(void *, int *));
+static int mxml_string_getc(void *p, int *encoding);
+static int mxml_string_putc(int ch, void *p);
+static int mxml_write_name(const char *s, void *p,
+ int (*putc_cb)(int, void *));
+static int mxml_write_node(mxml_node_t *node, void *p,
+ const char *(*cb)(mxml_node_t *, int),
+ int col,
+ int (*putc_cb)(int, void *));
+static int mxml_write_string(const char *s, void *p,
+ int (*putc_cb)(int, void *));
+static int mxml_write_ws(mxml_node_t *node, void *p,
+ const char *(*cb)(mxml_node_t *, int), int ws,
+ int col, int (*putc_cb)(int, void *));
+
+
+/*
+ * 'mxmlLoadFd()' - Load a file descriptor into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t * /* O - First node or NULL if the file could not be read. */
+mxmlLoadFd(mxml_node_t *top, /* I - Top node */
+ int fd, /* I - File descriptor to read from */
+ mxml_type_t (*cb)(mxml_node_t *node))
+ /* I - Callback function or MXML_NO_CALLBACK */
+{
+ mxml_fdbuf_t buf; /* File descriptor buffer */
+
+
+ /*
+ * Initialize the file descriptor buffer...
+ */
+
+ buf.fd = fd;
+ buf.current = buf.buffer;
+ buf.end = buf.buffer;
+
+ /*
+ * Read the XML data...
+ */
+
+ return (mxml_load_data(top, &buf, cb, mxml_fd_getc));
+}
+
+
+/*
+ * 'mxmlLoadFile()' - Load a file into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t * /* O - First node or NULL if the file could not be read. */
+mxmlLoadFile(mxml_node_t *top, /* I - Top node */
+ FILE *fp, /* I - File to read from */
+ mxml_type_t (*cb)(mxml_node_t *node))
+ /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+ * Read the XML data...
+ */
+
+ return (mxml_load_data(top, fp, cb, mxml_file_getc));
+}
+
+
+/*
+ * 'mxmlLoadString()' - Load a string into an XML node tree.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t * /* O - First node or NULL if the string has errors. */
+mxmlLoadString(mxml_node_t *top, /* I - Top node */
+ const char *s, /* I - String to load */
+ mxml_type_t (*cb)(mxml_node_t *node))
+ /* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+ * Read the XML data...
+ */
+
+ return (mxml_load_data(top, &s, cb, mxml_string_getc));
+}
+
+
+/*
+ * 'mxmlSaveAllocString()' - Save an XML node tree to an allocated string.
+ *
+ * This function returns a pointer to a string containing the textual
+ * representation of the XML node tree. The string should be freed
+ * using the free() function when you are done with it. NULL is returned
+ * if the node would produce an empty string or if the string cannot be
+ * allocated.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+char * /* O - Allocated string or NULL */
+mxmlSaveAllocString(mxml_node_t *node, /* I - Node to write */
+ const char *(*cb)(mxml_node_t *node, int ws))
+ /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+ int bytes; /* Required bytes */
+ char buffer[8192]; /* Temporary buffer */
+ char *s; /* Allocated string */
+
+
+ /*
+ * Write the node to the temporary buffer...
+ */
+
+ bytes = mxmlSaveString(node, buffer, sizeof(buffer), cb);
+
+ if (bytes <= 0)
+ return (NULL);
+
+ if (bytes < (int)(sizeof(buffer) - 1))
+ {
+ /*
+ * Node fit inside the buffer, so just duplicate that string and
+ * return...
+ */
+
+ return (strdup(buffer));
+ }
+
+ /*
+ * Allocate a buffer of the required size and save the node to the
+ * new buffer...
+ */
+
+ if ((s = malloc(bytes + 1)) == NULL)
+ return (NULL);
+
+ mxmlSaveString(node, s, bytes + 1, cb);
+
+ /*
+ * Return the allocated string...
+ */
+
+ return (s);
+}
+
+
+/*
+ * 'mxmlSaveFd()' - Save an XML tree to a file descriptor.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int /* O - 0 on success, -1 on error. */
+mxmlSaveFd(mxml_node_t *node, /* I - Node to write */
+ int fd, /* I - File descriptor to write to */
+ const char *(*cb)(mxml_node_t *node, int ws))
+ /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+ int col; /* Final column */
+ mxml_fdbuf_t buf; /* File descriptor buffer */
+
+
+ /*
+ * Initialize the file descriptor buffer...
+ */
+
+ buf.fd = fd;
+ buf.current = buf.buffer;
+ buf.end = buf.buffer + sizeof(buf.buffer) - 4;
+
+ /*
+ * Write the node...
+ */
+
+ if ((col = mxml_write_node(node, &buf, cb, 0, mxml_fd_putc)) < 0)
+ return (-1);
+
+ if (col > 0)
+ if (mxml_fd_putc('\n', &buf) < 0)
+ return (-1);
+
+ /*
+ * Flush and return...
+ */
+
+ return (mxml_fd_write(&buf));
+}
+
+
+/*
+ * 'mxmlSaveFile()' - Save an XML tree to a file.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int /* O - 0 on success, -1 on error. */
+mxmlSaveFile(mxml_node_t *node, /* I - Node to write */
+ FILE *fp, /* I - File to write to */
+ const char *(*cb)(mxml_node_t *node, int ws))
+ /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+ int col; /* Final column */
+
+
+ /*
+ * Write the node...
+ */
+
+ if ((col = mxml_write_node(node, fp, cb, 0, mxml_file_putc)) < 0)
+ return (-1);
+
+ if (col > 0)
+ if (putc('\n', fp) < 0)
+ return (-1);
+
+ /*
+ * Return 0 (success)...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSaveString()' - Save an XML node tree to a string.
+ *
+ * This function returns the total number of bytes that would be
+ * required for the string but only copies (bufsize - 1) characters
+ * into the specified buffer.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int /* O - Size of string */
+mxmlSaveString(mxml_node_t *node, /* I - Node to write */
+ char *buffer, /* I - String buffer */
+ int bufsize, /* I - Size of string buffer */
+ const char *(*cb)(mxml_node_t *node, int ws))
+ /* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+ int col; /* Final column */
+ char *ptr[2]; /* Pointers for putc_cb */
+
+
+ /*
+ * Write the node...
+ */
+
+ ptr[0] = buffer;
+ ptr[1] = buffer + bufsize;
+
+ if ((col = mxml_write_node(node, ptr, cb, 0, mxml_string_putc)) < 0)
+ return (-1);
+
+ if (col > 0)
+ mxml_string_putc('\n', ptr);
+
+ /*
+ * Nul-terminate the buffer...
+ */
+
+ if (ptr[0] >= ptr[1])
+ buffer[bufsize - 1] = '\0';
+ else
+ ptr[0][0] = '\0';
+
+ /*
+ * Return the number of characters...
+ */
+
+ return (ptr[0] - buffer);
+}
+
+
+/*
+ * 'mxmlSetCustomHandlers()' - Set the handling functions for custom data.
+ *
+ * The load function accepts a node pointer and a data string and must
+ * return 0 on success and non-zero on error.
+ *
+ * The save function accepts a node pointer and must return a malloc'd
+ * string on success and NULL on error.
+ *
+ */
+
+void
+mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
+ /* I - Load function */
+ mxml_custom_save_cb_t save)
+ /* I - Save function */
+{
+ mxml_custom_load_cb = load;
+ mxml_custom_save_cb = save;
+}
+
+
+/*
+ * 'mxmlSetErrorCallback()' - Set the error message callback.
+ */
+
+void
+mxmlSetErrorCallback(void (*cb)(const char *))
+ /* I - Error callback function */
+{
+ mxml_error_cb = cb;
+}
+
+
+/*
+ * 'mxml_add_char()' - Add a character to a buffer, expanding as needed.
+ */
+
+static int /* O - 0 on success, -1 on error */
+mxml_add_char(int ch, /* I - Character to add */
+ char **bufptr, /* IO - Current position in buffer */
+ char **buffer, /* IO - Current buffer */
+ int *bufsize) /* IO - Current buffer size */
+{
+ char *newbuffer; /* New buffer value */
+
+
+ if (*bufptr >= (*buffer + *bufsize - 4))
+ {
+ /*
+ * Increase the size of the buffer...
+ */
+
+ if (*bufsize < 1024)
+ (*bufsize) *= 2;
+ else
+ (*bufsize) += 1024;
+
+ if ((newbuffer = realloc(*buffer, *bufsize)) == NULL)
+ {
+ free(*buffer);
+
+ mxml_error("Unable to expand string buffer to %d bytes!", *bufsize);
+
+ return (-1);
+ }
+
+ *bufptr = newbuffer + (*bufptr - *buffer);
+ *buffer = newbuffer;
+ }
+
+ if (ch < 0x80)
+ {
+ /*
+ * Single byte ASCII...
+ */
+
+ *(*bufptr)++ = ch;
+ }
+ else if (ch < 0x800)
+ {
+ /*
+ * Two-byte UTF-8...
+ */
+
+ *(*bufptr)++ = 0xc0 | (ch >> 6);
+ *(*bufptr)++ = 0x80 | (ch & 0x3f);
+ }
+ else if (ch < 0x10000)
+ {
+ /*
+ * Three-byte UTF-8...
+ */
+
+ *(*bufptr)++ = 0xe0 | (ch >> 12);
+ *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+ *(*bufptr)++ = 0x80 | (ch & 0x3f);
+ }
+ else
+ {
+ /*
+ * Four-byte UTF-8...
+ */
+
+ *(*bufptr)++ = 0xf0 | (ch >> 18);
+ *(*bufptr)++ = 0x80 | ((ch >> 12) & 0x3f);
+ *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+ *(*bufptr)++ = 0x80 | (ch & 0x3f);
+ }
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_fd_getc()' - Read a character from a file descriptor.
+ */
+
+static int /* O - Character or EOF */
+mxml_fd_getc(void *p, /* I - File descriptor buffer */
+ int *encoding) /* IO - Encoding */
+{
+ mxml_fdbuf_t *buf; /* File descriptor buffer */
+ int ch, /* Current character */
+ temp; /* Temporary character */
+
+
+ /*
+ * Grab the next character in the buffer...
+ */
+
+ buf = (mxml_fdbuf_t *)p;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ ch = *(buf->current)++;
+
+ switch (*encoding)
+ {
+ case ENCODE_UTF8 :
+ /*
+ * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+ */
+
+ if (!(ch & 0x80))
+ {
+#if DEBUG > 1
+ printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+
+ return (ch);
+ }
+ else if (ch == 0xfe)
+ {
+ /*
+ * UTF-16 big-endian BOM?
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ ch = *(buf->current)++;
+
+ if (ch != 0xff)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16BE;
+
+ return (mxml_fd_getc(p, encoding));
+ }
+ else if (ch == 0xff)
+ {
+ /*
+ * UTF-16 little-endian BOM?
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ ch = *(buf->current)++;
+
+ if (ch != 0xfe)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16LE;
+
+ return (mxml_fd_getc(p, encoding));
+ }
+ else if ((ch & 0xe0) == 0xc0)
+ {
+ /*
+ * Two-byte value...
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+ if (ch < 0x80)
+ return (EOF);
+ }
+ else if ((ch & 0xf0) == 0xe0)
+ {
+ /*
+ * Three-byte value...
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if (ch < 0x800)
+ return (EOF);
+ }
+ else if ((ch & 0xf8) == 0xf0)
+ {
+ /*
+ * Four-byte value...
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ if ((temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if (ch < 0x10000)
+ return (EOF);
+ }
+ else
+ return (EOF);
+ break;
+
+ case ENCODE_UTF16BE :
+ /*
+ * Read UTF-16 big-endian char...
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ ch = (ch << 8) | temp;
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ lch = *(buf->current)++;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ lch = (lch << 8) | temp;
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+ break;
+
+ case ENCODE_UTF16LE :
+ /*
+ * Read UTF-16 little-endian char...
+ */
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ ch |= (temp << 8);
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ lch = *(buf->current)++;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_read(buf) < 0)
+ return (EOF);
+
+ temp = *(buf->current)++;
+
+ lch |= (temp << 8);
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+ break;
+ }
+
+#if DEBUG > 1
+ printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+}
+
+
+/*
+ * 'mxml_fd_putc()' - Write a character to a file descriptor.
+ */
+
+static int /* O - 0 on success, -1 on error */
+mxml_fd_putc(int ch, /* I - Character */
+ void *p) /* I - File descriptor buffer */
+{
+ mxml_fdbuf_t *buf; /* File descriptor buffer */
+
+
+ /*
+ * Flush the write buffer as needed - note above that "end" still leaves
+ * 4 characters at the end so that we can avoid a lot of extra tests...
+ */
+
+ buf = (mxml_fdbuf_t *)p;
+
+ if (buf->current >= buf->end)
+ if (mxml_fd_write(buf) < 0)
+ return (-1);
+
+ if (ch < 0x80)
+ {
+ /*
+ * Write ASCII character directly...
+ */
+
+ *(buf->current)++ = ch;
+ }
+ else if (ch < 0x800)
+ {
+ /*
+ * Two-byte UTF-8 character...
+ */
+
+ *(buf->current)++ = 0xc0 | (ch >> 6);
+ *(buf->current)++ = 0x80 | (ch & 0x3f);
+ }
+ else if (ch < 0x10000)
+ {
+ /*
+ * Three-byte UTF-8 character...
+ */
+
+ *(buf->current)++ = 0xe0 | (ch >> 12);
+ *(buf->current)++ = 0x80 | ((ch >> 6) & 0x3f);
+ *(buf->current)++ = 0x80 | (ch & 0x3f);
+ }
+ else
+ {
+ /*
+ * Four-byte UTF-8 character...
+ */
+
+ *(buf->current)++ = 0xf0 | (ch >> 18);
+ *(buf->current)++ = 0x80 | ((ch >> 12) & 0x3f);
+ *(buf->current)++ = 0x80 | ((ch >> 6) & 0x3f);
+ *(buf->current)++ = 0x80 | (ch & 0x3f);
+ }
+
+ /*
+ * Return successfully...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_fd_read()' - Read a buffer of data from a file descriptor.
+ */
+
+static int /* O - 0 on success, -1 on error */
+mxml_fd_read(mxml_fdbuf_t *buf) /* I - File descriptor buffer */
+{
+ int bytes; /* Bytes read... */
+
+
+ /*
+ * Range check input...
+ */
+
+ if (!buf)
+ return (-1);
+
+ /*
+ * Read from the file descriptor...
+ */
+
+ while ((bytes = read(buf->fd, buf->buffer, sizeof(buf->buffer))) < 0)
+ if (errno != EAGAIN && errno != EINTR)
+ return (-1);
+
+ if (bytes == 0)
+ return (-1);
+
+ /*
+ * Update the pointers and return success...
+ */
+
+ buf->current = buf->buffer;
+ buf->end = buf->buffer + bytes;
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_fd_write()' - Write a buffer of data to a file descriptor.
+ */
+
+static int /* O - 0 on success, -1 on error */
+mxml_fd_write(mxml_fdbuf_t *buf) /* I - File descriptor buffer */
+{
+ int bytes; /* Bytes written */
+ unsigned char *ptr; /* Pointer into buffer */
+
+
+ /*
+ * Range check...
+ */
+
+ if (!buf)
+ return (-1);
+
+ /*
+ * Return 0 if there is nothing to write...
+ */
+
+ if (buf->current == buf->buffer)
+ return (0);
+
+ /*
+ * Loop until we have written everything...
+ */
+
+ for (ptr = buf->buffer; ptr < buf->current; ptr += bytes)
+ if ((bytes = write(buf->fd, ptr, buf->current - ptr)) < 0)
+ return (-1);
+
+ /*
+ * All done, reset pointers and return success...
+ */
+
+ buf->current = buf->buffer;
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_file_getc()' - Get a character from a file.
+ */
+
+static int /* O - Character or EOF */
+mxml_file_getc(void *p, /* I - Pointer to file */
+ int *encoding) /* IO - Encoding */
+{
+ int ch, /* Character from file */
+ temp; /* Temporary character */
+ FILE *fp; /* Pointer to file */
+
+
+ /*
+ * Read a character from the file and see if it is EOF or ASCII...
+ */
+
+ fp = (FILE *)p;
+ ch = getc(fp);
+
+ if (ch == EOF)
+ return (EOF);
+
+ switch (*encoding)
+ {
+ case ENCODE_UTF8 :
+ /*
+ * Got a UTF-8 character; convert UTF-8 to Unicode and return...
+ */
+
+ if (!(ch & 0x80))
+ {
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+
+#if DEBUG > 1
+ printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+ }
+ else if (ch == 0xfe)
+ {
+ /*
+ * UTF-16 big-endian BOM?
+ */
+
+ ch = getc(fp);
+ if (ch != 0xff)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16BE;
+
+ return (mxml_file_getc(p, encoding));
+ }
+ else if (ch == 0xff)
+ {
+ /*
+ * UTF-16 little-endian BOM?
+ */
+
+ ch = getc(fp);
+ if (ch != 0xfe)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16LE;
+
+ return (mxml_file_getc(p, encoding));
+ }
+ else if ((ch & 0xe0) == 0xc0)
+ {
+ /*
+ * Two-byte value...
+ */
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+ if (ch < 0x80)
+ return (EOF);
+ }
+ else if ((ch & 0xf0) == 0xe0)
+ {
+ /*
+ * Three-byte value...
+ */
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if (ch < 0x800)
+ return (EOF);
+ }
+ else if ((ch & 0xf8) == 0xf0)
+ {
+ /*
+ * Four-byte value...
+ */
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = (ch << 6) | (temp & 0x3f);
+
+ if (ch < 0x10000)
+ return (EOF);
+ }
+ else
+ return (EOF);
+ break;
+
+ case ENCODE_UTF16BE :
+ /*
+ * Read UTF-16 big-endian char...
+ */
+
+ ch = (ch << 8) | getc(fp);
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch = (getc(fp) << 8) | getc(fp);
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+ break;
+
+ case ENCODE_UTF16LE :
+ /*
+ * Read UTF-16 little-endian char...
+ */
+
+ ch |= (getc(fp) << 8);
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch = getc(fp) | (getc(fp) << 8);
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+ break;
+ }
+
+#if DEBUG > 1
+ printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+}
+
+
+/*
+ * 'mxml_file_putc()' - Write a character to a file.
+ */
+
+static int /* O - 0 on success, -1 on failure */
+mxml_file_putc(int ch, /* I - Character to write */
+ void *p) /* I - Pointer to file */
+{
+ char buffer[4], /* Buffer for character */
+ *bufptr; /* Pointer into buffer */
+ int buflen; /* Number of bytes to write */
+
+
+ if (ch < 0x80)
+ return (putc(ch, (FILE *)p) == EOF ? -1 : 0);
+
+ bufptr = buffer;
+
+ if (ch < 0x800)
+ {
+ /*
+ * Two-byte UTF-8 character...
+ */
+
+ *bufptr++ = 0xc0 | (ch >> 6);
+ *bufptr++ = 0x80 | (ch & 0x3f);
+ }
+ else if (ch < 0x10000)
+ {
+ /*
+ * Three-byte UTF-8 character...
+ */
+
+ *bufptr++ = 0xe0 | (ch >> 12);
+ *bufptr++ = 0x80 | ((ch >> 6) & 0x3f);
+ *bufptr++ = 0x80 | (ch & 0x3f);
+ }
+ else
+ {
+ /*
+ * Four-byte UTF-8 character...
+ */
+
+ *bufptr++ = 0xf0 | (ch >> 18);
+ *bufptr++ = 0x80 | ((ch >> 12) & 0x3f);
+ *bufptr++ = 0x80 | ((ch >> 6) & 0x3f);
+ *bufptr++ = 0x80 | (ch & 0x3f);
+ }
+
+ buflen = bufptr - buffer;
+
+ return (fwrite(buffer, 1, buflen, (FILE *)p) < buflen ? -1 : 0);
+}
+
+
+/*
+ * 'mxml_get_entity()' - Get the character corresponding to an entity...
+ */
+
+static int /* O - Character value or EOF on error */
+mxml_get_entity(mxml_node_t *parent, /* I - Parent node */
+ void *p, /* I - Pointer to source */
+ int *encoding, /* IO - Character encoding */
+ int (*getc_cb)(void *, int *))
+ /* I - Get character function */
+{
+ int ch; /* Current character */
+ char entity[64], /* Entity string */
+ *entptr; /* Pointer into entity */
+
+
+ entptr = entity;
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ if (ch > 126 || (!isalnum(ch) && ch != '#'))
+ break;
+ else if (entptr < (entity + sizeof(entity) - 1))
+ *entptr++ = ch;
+ else
+ {
+ mxml_error("Entity name too long under parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ break;
+ }
+
+ *entptr = '\0';
+
+ if (ch != ';')
+ {
+ mxml_error("Character entity \"%s\" not terminated under parent <%s>!",
+ entity, parent ? parent->value.element.name : "null");
+ return (EOF);
+ }
+
+ if (entity[0] == '#')
+ {
+ if (entity[1] == 'x')
+ ch = strtol(entity + 2, NULL, 16);
+ else
+ ch = strtol(entity + 1, NULL, 10);
+ }
+ else if ((ch = mxmlEntityGetValue(entity)) < 0)
+ mxml_error("Entity name \"%s;\" not supported under parent <%s>!",
+ entity, parent ? parent->value.element.name : "null");
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x under parent <%s> not allowed by XML standard!",
+ ch, parent ? parent->value.element.name : "null");
+ return (EOF);
+ }
+
+ return (ch);
+}
+
+
+/*
+ * 'mxml_load_data()' - Load data into an XML node tree.
+ */
+
+static mxml_node_t * /* O - First node or NULL if the file could not be read. */
+mxml_load_data(mxml_node_t *top, /* I - Top node */
+ void *p, /* I - Pointer to data */
+ mxml_type_t (*cb)(mxml_node_t *),
+ /* I - Callback function or MXML_NO_CALLBACK */
+ int (*getc_cb)(void *, int *))
+ /* I - Read function */
+{
+ mxml_node_t *node, /* Current node */
+ *first, /* First node added */
+ *parent; /* Current parent node */
+ int ch, /* Character from file */
+ whitespace; /* Non-zero if whitespace seen */
+ char *buffer, /* String buffer */
+ *bufptr; /* Pointer into buffer */
+ int bufsize; /* Size of buffer */
+ mxml_type_t type; /* Current node type */
+ int encoding; /* Character encoding */
+ static const char * const types[] = /* Type strings... */
+ {
+ "MXML_ELEMENT", /* XML element with attributes */
+ "MXML_INTEGER", /* Integer value */
+ "MXML_OPAQUE", /* Opaque string */
+ "MXML_REAL", /* Real value */
+ "MXML_TEXT", /* Text fragment */
+ "MXML_CUSTOM" /* Custom data */
+ };
+
+
+ /*
+ * Read elements and other nodes from the file...
+ */
+
+ if ((buffer = malloc(64)) == NULL)
+ {
+ mxml_error("Unable to allocate string buffer!");
+ return (NULL);
+ }
+
+ bufsize = 64;
+ bufptr = buffer;
+ parent = top;
+ first = NULL;
+ whitespace = 0;
+ encoding = ENCODE_UTF8;
+
+ if (cb && parent)
+ type = (*cb)(parent);
+ else
+ type = MXML_TEXT;
+
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+ {
+ if ((ch == '<' ||
+ (isspace(ch) && type != MXML_OPAQUE && type != MXML_CUSTOM)) &&
+ bufptr > buffer)
+ {
+ /*
+ * Add a new value node...
+ */
+
+ *bufptr = '\0';
+
+ switch (type)
+ {
+ case MXML_INTEGER :
+ node = mxmlNewInteger(parent, strtol(buffer, &bufptr, 0));
+ break;
+
+ case MXML_OPAQUE :
+ node = mxmlNewOpaque(parent, buffer);
+ break;
+
+ case MXML_REAL :
+ node = mxmlNewReal(parent, strtod(buffer, &bufptr));
+ break;
+
+ case MXML_TEXT :
+ node = mxmlNewText(parent, whitespace, buffer);
+ break;
+
+ case MXML_CUSTOM :
+ if (mxml_custom_load_cb)
+ {
+ /*
+ * Use the callback to fill in the custom data...
+ */
+
+ node = mxmlNewCustom(parent, NULL, NULL);
+
+ if ((*mxml_custom_load_cb)(node, buffer))
+ {
+ mxml_error("Bad custom value '%s' in parent <%s>!",
+ buffer, parent ? parent->value.element.name : "null");
+ mxmlDelete(node);
+ node = NULL;
+ }
+ break;
+ }
+
+ default : /* Should never happen... */
+ node = NULL;
+ break;
+ }
+
+ if (*bufptr)
+ {
+ /*
+ * Bad integer/real number value...
+ */
+
+ mxml_error("Bad %s value '%s' in parent <%s>!",
+ type == MXML_INTEGER ? "integer" : "real", buffer,
+ parent ? parent->value.element.name : "null");
+ break;
+ }
+
+ bufptr = buffer;
+ whitespace = isspace(ch) && type == MXML_TEXT;
+
+ if (!node)
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Unable to add value node of type %s to parent <%s>!",
+ types[type], parent ? parent->value.element.name : "null");
+ goto error;
+ }
+
+ if (!first)
+ first = node;
+ }
+ else if (isspace(ch) && type == MXML_TEXT)
+ whitespace = 1;
+
+ /*
+ * Add lone whitespace node if we have an element and existing
+ * whitespace...
+ */
+
+ if (ch == '<' && whitespace && type == MXML_TEXT)
+ {
+ mxmlNewText(parent, whitespace, "");
+ whitespace = 0;
+ }
+
+ if (ch == '<')
+ {
+ /*
+ * Start of open/close tag...
+ */
+
+ bufptr = buffer;
+
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+ if (isspace(ch) || ch == '>' || (ch == '/' && bufptr > buffer))
+ break;
+ else if (ch == '&')
+ {
+ if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+ else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ else if (((bufptr - buffer) == 1 && buffer[0] == '?') ||
+ ((bufptr - buffer) == 3 && !strncmp(buffer, "!--", 3)) ||
+ ((bufptr - buffer) == 8 && !strncmp(buffer, "![CDATA[", 8)))
+ break;
+
+ *bufptr = '\0';
+
+ if (!strcmp(buffer, "!--"))
+ {
+ /*
+ * Gather rest of comment...
+ */
+
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+ {
+ if (ch == '>' && bufptr > (buffer + 4) &&
+ bufptr[-3] != '-' && bufptr[-2] == '-' && bufptr[-1] == '-')
+ break;
+ else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+
+ /*
+ * Error out if we didn't get the whole comment...
+ */
+
+ if (ch != '>')
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Early EOF in comment node!");
+ goto error;
+ }
+
+
+ /*
+ * Otherwise add this as an element under the current parent...
+ */
+
+ *bufptr = '\0';
+
+ if (!mxmlNewElement(parent, buffer))
+ {
+ /*
+ * Just print error for now...
+ */
+
+ mxml_error("Unable to add comment node to parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ break;
+ }
+ }
+ else if (!strcmp(buffer, "![CDATA["))
+ {
+ /*
+ * Gather CDATA section...
+ */
+
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+ {
+ if (ch == '>' && !strncmp(bufptr - 2, "]]", 2))
+ break;
+ else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+
+ /*
+ * Error out if we didn't get the whole comment...
+ */
+
+ if (ch != '>')
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Early EOF in CDATA node!");
+ goto error;
+ }
+
+
+ /*
+ * Otherwise add this as an element under the current parent...
+ */
+
+ *bufptr = '\0';
+
+ if (!mxmlNewElement(parent, buffer))
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Unable to add CDATA node to parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ goto error;
+ }
+ }
+ else if (buffer[0] == '?')
+ {
+ /*
+ * Gather rest of processing instruction...
+ */
+
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+ {
+ if (ch == '>' && bufptr > buffer && bufptr[-1] == '?')
+ break;
+ else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+
+ /*
+ * Error out if we didn't get the whole processing instruction...
+ */
+
+ if (ch != '>')
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Early EOF in processing instruction node!");
+ goto error;
+ }
+
+
+ /*
+ * Otherwise add this as an element under the current parent...
+ */
+
+ *bufptr = '\0';
+
+ if (!(parent = mxmlNewElement(parent, buffer)))
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Unable to add processing instruction node to parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ goto error;
+ }
+
+ if (cb)
+ type = (*cb)(parent);
+ }
+ else if (buffer[0] == '!')
+ {
+ /*
+ * Gather rest of declaration...
+ */
+
+ do
+ {
+ if (ch == '>')
+ break;
+ else
+ {
+ if (ch == '&')
+ if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+ }
+ while ((ch = (*getc_cb)(p, &encoding)) != EOF);
+
+ /*
+ * Error out if we didn't get the whole declaration...
+ */
+
+ if (ch != '>')
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Early EOF in declaration node!");
+ goto error;
+ }
+
+ /*
+ * Otherwise add this as an element under the current parent...
+ */
+
+ *bufptr = '\0';
+
+ node = mxmlNewElement(parent, buffer);
+ if (!node)
+ {
+ /*
+ * Print error and return...
+ */
+
+ mxml_error("Unable to add declaration node to parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ goto error;
+ }
+
+ /*
+ * Descend into this node, setting the value type as needed...
+ */
+
+ parent = node;
+
+ if (cb)
+ type = (*cb)(parent);
+ }
+ else if (buffer[0] == '/')
+ {
+ /*
+ * Handle close tag...
+ */
+
+ if (!parent || strcmp(buffer + 1, parent->value.element.name))
+ {
+ /*
+ * Close tag doesn't match tree; print an error for now...
+ */
+
+ mxml_error("Mismatched close tag <%s> under parent <%s>!",
+ buffer, parent->value.element.name);
+ goto error;
+ }
+
+ /*
+ * Keep reading until we see >...
+ */
+
+ while (ch != '>' && ch != EOF)
+ ch = (*getc_cb)(p, &encoding);
+
+ /*
+ * Ascend into the parent and set the value type as needed...
+ */
+
+ parent = parent->parent;
+
+ if (cb && parent)
+ type = (*cb)(parent);
+ }
+ else
+ {
+ /*
+ * Handle open tag...
+ */
+
+ node = mxmlNewElement(parent, buffer);
+
+ if (!node)
+ {
+ /*
+ * Just print error for now...
+ */
+
+ mxml_error("Unable to add element node to parent <%s>!",
+ parent ? parent->value.element.name : "null");
+ goto error;
+ }
+
+ if (isspace(ch))
+ ch = mxml_parse_element(node, p, &encoding, getc_cb);
+ else if (ch == '/')
+ {
+ if ((ch = (*getc_cb)(p, &encoding)) != '>')
+ {
+ mxml_error("Expected > but got '%c' instead for element <%s/>!",
+ ch, buffer);
+ goto error;
+ }
+
+ ch = '/';
+ }
+
+ if (ch == EOF)
+ break;
+
+ if (ch != '/')
+ {
+ /*
+ * Descend into this node, setting the value type as needed...
+ */
+
+ parent = node;
+
+ if (cb && parent)
+ type = (*cb)(parent);
+ }
+ }
+
+ bufptr = buffer;
+ }
+ else if (ch == '&')
+ {
+ /*
+ * Add character entity to current buffer...
+ */
+
+ if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+ else if (type == MXML_OPAQUE || type == MXML_CUSTOM || !isspace(ch))
+ {
+ /*
+ * Add character to current buffer...
+ */
+
+ if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+ goto error;
+ }
+ }
+
+ /*
+ * Free the string buffer - we don't need it anymore...
+ */
+
+ free(buffer);
+
+ /*
+ * Find the top element and return it...
+ */
+
+ if (parent)
+ {
+ while (parent->parent != top && parent->parent)
+ parent = parent->parent;
+ }
+
+ return (parent);
+
+ /*
+ * Common error return...
+ */
+
+error:
+
+ mxmlDelete(first);
+
+ free(buffer);
+
+ return (NULL);
+}
+
+
+/*
+ * 'mxml_parse_element()' - Parse an element for any attributes...
+ */
+
+static int /* O - Terminating character */
+mxml_parse_element(mxml_node_t *node, /* I - Element node */
+ void *p, /* I - Data to read from */
+ int *encoding,
+ /* IO - Encoding */
+ int (*getc_cb)(void *, int *))
+ /* I - Data callback */
+{
+ int ch, /* Current character in file */
+ quote; /* Quoting character */
+ char *name, /* Attribute name */
+ *value, /* Attribute value */
+ *ptr; /* Pointer into name/value */
+ int namesize, /* Size of name string */
+ valsize; /* Size of value string */
+
+
+
+
+ /*
+ * Initialize the name and value buffers...
+ */
+
+ if ((name = malloc(64)) == NULL)
+ {
+ mxml_error("Unable to allocate memory for name!");
+ return (EOF);
+ }
+
+ namesize = 64;
+
+ if ((value = malloc(64)) == NULL)
+ {
+ free(name);
+ mxml_error("Unable to allocate memory for value!");
+ return (EOF);
+ }
+
+ valsize = 64;
+
+ /*
+ * Loop until we hit a >, /, ?, or EOF...
+ */
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ {
+#if DEBUG > 1
+ fprintf(stderr, "parse_element: ch='%c'\n", ch);
+#endif /* DEBUG > 1 */
+
+ /*
+ * Skip leading whitespace...
+ */
+
+ if (isspace(ch))
+ continue;
+
+ /*
+ * Stop at /, ?, or >...
+ */
+
+ if (ch == '/' || ch == '?')
+ {
+ /*
+ * Grab the > character and print an error if it isn't there...
+ */
+
+ quote = (*getc_cb)(p, encoding);
+
+ if (quote != '>')
+ {
+ mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+ ch, node->value.element.name, quote);
+ ch = EOF;
+ }
+
+ break;
+ }
+ else if (ch == '>')
+ break;
+
+ /*
+ * Read the attribute name...
+ */
+
+ name[0] = ch;
+ ptr = name + 1;
+
+ if (ch == '\"' || ch == '\'')
+ {
+ /*
+ * Name is in quotes, so get a quoted string...
+ */
+
+ quote = ch;
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ {
+ if (ch == '&')
+ if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &ptr, &name, &namesize))
+ goto error;
+
+ if (ch == quote)
+ break;
+ }
+ }
+ else
+ {
+ /*
+ * Grab an normal, non-quoted name...
+ */
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ if (isspace(ch) || ch == '=' || ch == '/' || ch == '>' || ch == '?')
+ break;
+ else
+ {
+ if (ch == '&')
+ if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &ptr, &name, &namesize))
+ goto error;
+ }
+ }
+
+ *ptr = '\0';
+
+ if (mxmlElementGetAttr(node, name))
+ goto error;
+
+ if (ch == '=')
+ {
+ /*
+ * Read the attribute value...
+ */
+
+ if ((ch = (*getc_cb)(p, encoding)) == EOF)
+ {
+ mxml_error("Missing value for attribute '%s' in element %s!",
+ name, node->value.element.name);
+ return (EOF);
+ }
+
+ if (ch == '\'' || ch == '\"')
+ {
+ /*
+ * Read quoted value...
+ */
+
+ quote = ch;
+ ptr = value;
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ if (ch == quote)
+ break;
+ else
+ {
+ if (ch == '&')
+ if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &ptr, &value, &valsize))
+ goto error;
+ }
+
+ *ptr = '\0';
+ }
+ else
+ {
+ /*
+ * Read unquoted value...
+ */
+
+ value[0] = ch;
+ ptr = value + 1;
+
+ while ((ch = (*getc_cb)(p, encoding)) != EOF)
+ if (isspace(ch) || ch == '=' || ch == '/' || ch == '>')
+ break;
+ else
+ {
+ if (ch == '&')
+ if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+ goto error;
+
+ if (mxml_add_char(ch, &ptr, &value, &valsize))
+ goto error;
+ }
+
+ *ptr = '\0';
+ }
+
+ /*
+ * Set the attribute with the given string value...
+ */
+
+ mxmlElementSetAttr(node, name, value);
+ }
+ else
+ {
+ /*
+ * Set the attribute with a NULL value...
+ */
+
+ mxmlElementSetAttr(node, name, NULL);
+ }
+
+ /*
+ * Check the end character...
+ */
+
+ if (ch == '/' || ch == '?')
+ {
+ /*
+ * Grab the > character and print an error if it isn't there...
+ */
+
+ quote = (*getc_cb)(p, encoding);
+
+ if (quote != '>')
+ {
+ mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+ ch, node->value.element.name, quote);
+ ch = EOF;
+ }
+
+ break;
+ }
+ else if (ch == '>')
+ break;
+ }
+
+ /*
+ * Free the name and value buffers and return...
+ */
+
+ free(name);
+ free(value);
+
+ return (ch);
+
+ /*
+ * Common error return point...
+ */
+
+error:
+
+ free(name);
+ free(value);
+
+ return (EOF);
+}
+
+
+/*
+ * 'mxml_string_getc()' - Get a character from a string.
+ */
+
+static int /* O - Character or EOF */
+mxml_string_getc(void *p, /* I - Pointer to file */
+ int *encoding) /* IO - Encoding */
+{
+ int ch; /* Character */
+ const char **s; /* Pointer to string pointer */
+
+
+ s = (const char **)p;
+
+ if ((ch = (*s)[0] & 255) != 0 || *encoding == ENCODE_UTF16LE)
+ {
+ /*
+ * Got character; convert UTF-8 to integer and return...
+ */
+
+ (*s)++;
+
+ switch (*encoding)
+ {
+ case ENCODE_UTF8 :
+ if (!(ch & 0x80))
+ {
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+
+ return (ch);
+ }
+ else if (ch == 0xfe)
+ {
+ /*
+ * UTF-16 big-endian BOM?
+ */
+
+ if (((*s)[0] & 255) != 0xff)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16BE;
+ (*s)++;
+
+ return (mxml_string_getc(p, encoding));
+ }
+ else if (ch == 0xff)
+ {
+ /*
+ * UTF-16 little-endian BOM?
+ */
+
+ if (((*s)[0] & 255) != 0xfe)
+ return (EOF);
+
+ *encoding = ENCODE_UTF16LE;
+ (*s)++;
+
+ return (mxml_string_getc(p, encoding));
+ }
+ else if ((ch & 0xe0) == 0xc0)
+ {
+ /*
+ * Two-byte value...
+ */
+
+ if (((*s)[0] & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((ch & 0x1f) << 6) | ((*s)[0] & 0x3f);
+
+ (*s)++;
+
+ if (ch < 0x80)
+ return (EOF);
+
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+ }
+ else if ((ch & 0xf0) == 0xe0)
+ {
+ /*
+ * Three-byte value...
+ */
+
+ if (((*s)[0] & 0xc0) != 0x80 ||
+ ((*s)[1] & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((((ch & 0x0f) << 6) | ((*s)[0] & 0x3f)) << 6) | ((*s)[1] & 0x3f);
+
+ (*s) += 2;
+
+ if (ch < 0x800)
+ return (EOF);
+
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+ }
+ else if ((ch & 0xf8) == 0xf0)
+ {
+ /*
+ * Four-byte value...
+ */
+
+ if (((*s)[0] & 0xc0) != 0x80 ||
+ ((*s)[1] & 0xc0) != 0x80 ||
+ ((*s)[2] & 0xc0) != 0x80)
+ return (EOF);
+
+ ch = ((((((ch & 0x07) << 6) | ((*s)[0] & 0x3f)) << 6) |
+ ((*s)[1] & 0x3f)) << 6) | ((*s)[2] & 0x3f);
+
+ (*s) += 3;
+
+ if (ch < 0x10000)
+ return (EOF);
+
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+ }
+ else
+ return (EOF);
+
+ case ENCODE_UTF16BE :
+ /*
+ * Read UTF-16 big-endian char...
+ */
+
+ ch = (ch << 8) | ((*s)[0] & 255);
+ (*s) ++;
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch; /* Lower word */
+
+
+ if (!(*s)[0])
+ return (EOF);
+
+ lch = (((*s)[0] & 255) << 8) | ((*s)[1] & 255);
+ (*s) += 2;
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+
+ case ENCODE_UTF16LE :
+ /*
+ * Read UTF-16 little-endian char...
+ */
+
+ ch = ch | (((*s)[0] & 255) << 8);
+
+ if (!ch)
+ {
+ (*s) --;
+ return (EOF);
+ }
+
+ (*s) ++;
+
+ if (mxml_bad_char(ch))
+ {
+ mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+ ch);
+ return (EOF);
+ }
+ else if (ch >= 0xd800 && ch <= 0xdbff)
+ {
+ /*
+ * Multi-word UTF-16 char...
+ */
+
+ int lch; /* Lower word */
+
+
+ if (!(*s)[1])
+ return (EOF);
+
+ lch = (((*s)[1] & 255) << 8) | ((*s)[0] & 255);
+ (*s) += 2;
+
+ if (lch < 0xdc00 || lch >= 0xdfff)
+ return (EOF);
+
+ ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+ }
+
+#if DEBUG > 1
+ printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+ return (ch);
+ }
+ }
+
+ return (EOF);
+}
+
+
+/*
+ * 'mxml_string_putc()' - Write a character to a string.
+ */
+
+static int /* O - 0 on success, -1 on failure */
+mxml_string_putc(int ch, /* I - Character to write */
+ void *p) /* I - Pointer to string pointers */
+{
+ char **pp; /* Pointer to string pointers */
+
+
+ pp = (char **)p;
+
+ if (ch < 0x80)
+ {
+ /*
+ * Plain ASCII doesn't need special encoding...
+ */
+
+ if (pp[0] < pp[1])
+ pp[0][0] = ch;
+
+ pp[0] ++;
+ }
+ else if (ch < 0x800)
+ {
+ /*
+ * Two-byte UTF-8 character...
+ */
+
+ if ((pp[0] + 1) < pp[1])
+ {
+ pp[0][0] = 0xc0 | (ch >> 6);
+ pp[0][1] = 0x80 | (ch & 0x3f);
+ }
+
+ pp[0] += 2;
+ }
+ else if (ch < 0x10000)
+ {
+ /*
+ * Three-byte UTF-8 character...
+ */
+
+ if ((pp[0] + 2) < pp[1])
+ {
+ pp[0][0] = 0xe0 | (ch >> 12);
+ pp[0][1] = 0x80 | ((ch >> 6) & 0x3f);
+ pp[0][2] = 0x80 | (ch & 0x3f);
+ }
+
+ pp[0] += 3;
+ }
+ else
+ {
+ /*
+ * Four-byte UTF-8 character...
+ */
+
+ if ((pp[0] + 2) < pp[1])
+ {
+ pp[0][0] = 0xf0 | (ch >> 18);
+ pp[0][1] = 0x80 | ((ch >> 12) & 0x3f);
+ pp[0][2] = 0x80 | ((ch >> 6) & 0x3f);
+ pp[0][3] = 0x80 | (ch & 0x3f);
+ }
+
+ pp[0] += 4;
+ }
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_write_name()' - Write a name string.
+ */
+
+static int /* O - 0 on success, -1 on failure */
+mxml_write_name(const char *s, /* I - Name to write */
+ void *p, /* I - Write pointer */
+ int (*putc_cb)(int, void *))
+ /* I - Write callback */
+{
+ char quote; /* Quote character */
+ const char *name; /* Entity name */
+
+
+ if (*s == '\"' || *s == '\'')
+ {
+ /*
+ * Write a quoted name string...
+ */
+
+ if ((*putc_cb)(*s, p) < 0)
+ return (-1);
+
+ quote = *s++;
+
+ while (*s && *s != quote)
+ {
+ if ((name = mxmlEntityGetName(*s)) != NULL)
+ {
+ if ((*putc_cb)('&', p) < 0)
+ return (-1);
+
+ while (*name)
+ {
+ if ((*putc_cb)(*name, p) < 0)
+ return (-1);
+
+ name ++;
+ }
+
+ if ((*putc_cb)(';', p) < 0)
+ return (-1);
+ }
+ else if ((*putc_cb)(*s, p) < 0)
+ return (-1);
+
+ s ++;
+ }
+
+ /*
+ * Write the end quote...
+ */
+
+ if ((*putc_cb)(quote, p) < 0)
+ return (-1);
+ }
+ else
+ {
+ /*
+ * Write a non-quoted name string...
+ */
+
+ while (*s)
+ {
+ if ((*putc_cb)(*s, p) < 0)
+ return (-1);
+
+ s ++;
+ }
+ }
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_write_node()' - Save an XML node to a file.
+ */
+
+static int /* O - Column or -1 on error */
+mxml_write_node(mxml_node_t *node, /* I - Node to write */
+ void *p, /* I - File to write to */
+ const char *(*cb)(mxml_node_t *, int),
+ /* I - Whitespace callback */
+ int col, /* I - Current column */
+ int (*putc_cb)(int, void *))
+{
+ int i, /* Looping var */
+ width; /* Width of attr + value */
+ mxml_attr_t *attr; /* Current attribute */
+ char s[255]; /* Temporary string */
+
+
+ while (node != NULL)
+ {
+ /*
+ * Print the node value...
+ */
+
+ switch (node->type)
+ {
+ case MXML_ELEMENT :
+ col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_OPEN, col, putc_cb);
+
+ if ((*putc_cb)('<', p) < 0)
+ return (-1);
+ if (node->value.element.name[0] == '?' ||
+ !strncmp(node->value.element.name, "!--", 3) ||
+ !strncmp(node->value.element.name, "![CDATA[", 8))
+ {
+ /*
+ * Comments, CDATA, and processing instructions do not
+ * use character entities.
+ */
+
+ const char *ptr; /* Pointer into name */
+
+
+ for (ptr = node->value.element.name; *ptr; ptr ++)
+ if ((*putc_cb)(*ptr, p) < 0)
+ return (-1);
+
+ /*
+ * Prefer a newline for whitespace after ?xml...
+ */
+
+ if (!strncmp(node->value.element.name, "?xml", 4))
+ col = MXML_WRAP;
+ }
+ else if (mxml_write_name(node->value.element.name, p, putc_cb) < 0)
+ return (-1);
+
+ col += strlen(node->value.element.name) + 1;
+
+ for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+ i > 0;
+ i --, attr ++)
+ {
+ width = strlen(attr->name);
+
+ if (attr->value)
+ width += strlen(attr->value) + 3;
+
+ if ((col + width) > MXML_WRAP)
+ {
+ if ((*putc_cb)('\n', p) < 0)
+ return (-1);
+
+ col = 0;
+ }
+ else
+ {
+ if ((*putc_cb)(' ', p) < 0)
+ return (-1);
+
+ col ++;
+ }
+
+ if (mxml_write_name(attr->name, p, putc_cb) < 0)
+ return (-1);
+
+ if (attr->value)
+ {
+ if ((*putc_cb)('=', p) < 0)
+ return (-1);
+ if ((*putc_cb)('\"', p) < 0)
+ return (-1);
+ if (mxml_write_string(attr->value, p, putc_cb) < 0)
+ return (-1);
+ if ((*putc_cb)('\"', p) < 0)
+ return (-1);
+ }
+
+ col += width;
+ }
+
+ if (node->child)
+ {
+ /*
+ * Write children...
+ */
+
+ if ((*putc_cb)('>', p) < 0)
+ return (-1);
+ else
+ col ++;
+
+ col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+
+ if ((col = mxml_write_node(node->child, p, cb, col, putc_cb)) < 0)
+ return (-1);
+
+ /*
+ * The ? and ! elements are special-cases and have no end tags...
+ */
+
+ if (node->value.element.name[0] != '!' &&
+ node->value.element.name[0] != '?')
+ {
+ col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_CLOSE, col, putc_cb);
+
+ if ((*putc_cb)('<', p) < 0)
+ return (-1);
+ if ((*putc_cb)('/', p) < 0)
+ return (-1);
+ if (mxml_write_string(node->value.element.name, p, putc_cb) < 0)
+ return (-1);
+ if ((*putc_cb)('>', p) < 0)
+ return (-1);
+
+ col += strlen(node->value.element.name) + 3;
+
+ col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_CLOSE, col, putc_cb);
+ }
+ }
+ else if (node->value.element.name[0] == '!' ||
+ node->value.element.name[0] == '?')
+ {
+ /*
+ * The ? and ! elements are special-cases...
+ */
+
+ if ((*putc_cb)('>', p) < 0)
+ return (-1);
+ else
+ col ++;
+
+ col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+ }
+ else
+ {
+ if ((*putc_cb)(' ', p) < 0)
+ return (-1);
+ if ((*putc_cb)('/', p) < 0)
+ return (-1);
+ if ((*putc_cb)('>', p) < 0)
+ return (-1);
+
+ col += 3;
+
+ col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+ }
+ break;
+
+ case MXML_INTEGER :
+ if (node->prev)
+ {
+ if (col > MXML_WRAP)
+ {
+ if ((*putc_cb)('\n', p) < 0)
+ return (-1);
+
+ col = 0;
+ }
+ else if ((*putc_cb)(' ', p) < 0)
+ return (-1);
+ else
+ col ++;
+ }
+
+ sprintf(s, "%d", node->value.integer);
+ if (mxml_write_string(s, p, putc_cb) < 0)
+ return (-1);
+
+ col += strlen(s);
+ break;
+
+ case MXML_OPAQUE :
+ if (mxml_write_string(node->value.opaque, p, putc_cb) < 0)
+ return (-1);
+
+ col += strlen(node->value.opaque);
+ break;
+
+ case MXML_REAL :
+ if (node->prev)
+ {
+ if (col > MXML_WRAP)
+ {
+ if ((*putc_cb)('\n', p) < 0)
+ return (-1);
+
+ col = 0;
+ }
+ else if ((*putc_cb)(' ', p) < 0)
+ return (-1);
+ else
+ col ++;
+ }
+
+ sprintf(s, "%f", node->value.real);
+ if (mxml_write_string(s, p, putc_cb) < 0)
+ return (-1);
+
+ col += strlen(s);
+ break;
+
+ case MXML_TEXT :
+ if (node->value.text.whitespace && col > 0)
+ {
+ if (col > MXML_WRAP)
+ {
+ if ((*putc_cb)('\n', p) < 0)
+ return (-1);
+
+ col = 0;
+ }
+ else if ((*putc_cb)(' ', p) < 0)
+ return (-1);
+ else
+ col ++;
+ }
+
+ if (mxml_write_string(node->value.text.string, p, putc_cb) < 0)
+ return (-1);
+
+ col += strlen(node->value.text.string);
+ break;
+
+ case MXML_CUSTOM :
+ if (mxml_custom_save_cb)
+ {
+ char *data; /* Custom data string */
+ const char *newline; /* Last newline in string */
+
+
+ if ((data = (*mxml_custom_save_cb)(node)) == NULL)
+ return (-1);
+
+ if (mxml_write_string(data, p, putc_cb) < 0)
+ return (-1);
+
+ if ((newline = strrchr(data, '\n')) == NULL)
+ col += strlen(data);
+ else
+ col = strlen(newline);
+
+ free(data);
+ break;
+ }
+
+ default : /* Should never happen */
+ return (-1);
+ }
+
+ /*
+ * Next node...
+ */
+
+ node = node->next;
+ }
+
+ return (col);
+}
+
+
+/*
+ * 'mxml_write_string()' - Write a string, escaping & and < as needed.
+ */
+
+static int /* O - 0 on success, -1 on failure */
+mxml_write_string(const char *s, /* I - String to write */
+ void *p, /* I - Write pointer */
+ int (*putc_cb)(int, void *))
+ /* I - Write callback */
+{
+ const char *name; /* Entity name, if any */
+
+
+ while (*s)
+ {
+ if ((name = mxmlEntityGetName(*s)) != NULL)
+ {
+ if ((*putc_cb)('&', p) < 0)
+ return (-1);
+
+ while (*name)
+ {
+ if ((*putc_cb)(*name, p) < 0)
+ return (-1);
+ name ++;
+ }
+
+ if ((*putc_cb)(';', p) < 0)
+ return (-1);
+ }
+ else if ((*putc_cb)(*s, p) < 0)
+ return (-1);
+
+ s ++;
+ }
+
+ return (0);
+}
+
+
+/*
+ * 'mxml_write_ws()' - Do whitespace callback...
+ */
+
+static int /* O - New column */
+mxml_write_ws(mxml_node_t *node, /* I - Current node */
+ void *p, /* I - Write pointer */
+ const char *(*cb)(mxml_node_t *, int),
+ /* I - Callback function */
+ int ws, /* I - Where value */
+ int col, /* I - Current column */
+ int (*putc_cb)(int, void *))
+ /* I - Write callback */
+{
+ const char *s; /* Whitespace string */
+
+
+ if (cb && (s = (*cb)(node, ws)) != NULL)
+ {
+ while (*s)
+ {
+ if ((*putc_cb)(*s, p) < 0)
+ return (-1);
+ else if (*s == '\n')
+ col = 0;
+ else if (*s == '\t')
+ {
+ col += MXML_TAB;
+ col = col - (col % MXML_TAB);
+ }
+ else
+ col ++;
+
+ s ++;
+ }
+ }
+
+ return (col);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Index support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlIndexDelete() - Delete an index.
+ * mxmlIndexEnum() - Return the next node in the index.
+ * mxmlIndexFind() - Find the next matching node.
+ * mxmlIndexNew() - Create a new index.
+ * mxmlIndexReset() - Reset the enumeration/find pointer in the index and
+ * return the first node in the index.
+ * index_compare() - Compare two nodes.
+ * index_find() - Compare a node with index values.
+ * index_sort() - Sort the nodes in the index...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Sort functions...
+ */
+
+static int index_compare(mxml_index_t *ind, mxml_node_t *first,
+ mxml_node_t *second);
+static int index_find(mxml_index_t *ind, const char *element,
+ const char *value, mxml_node_t *node);
+static void index_sort(mxml_index_t *ind, int left, int right);
+
+
+/*
+ * 'mxmlIndexDelete()' - Delete an index.
+ */
+
+void
+mxmlIndexDelete(mxml_index_t *ind) /* I - Index to delete */
+{
+ /*
+ * Range check input..
+ */
+
+ if (!ind)
+ return;
+
+ /*
+ * Free memory...
+ */
+
+ if (ind->attr)
+ free(ind->attr);
+
+ if (ind->alloc_nodes)
+ free(ind->nodes);
+
+ free(ind);
+}
+
+
+/*
+ * 'mxmlIndexEnum()' - Return the next node in the index.
+ *
+ * Nodes are returned in the sorted order of the index.
+ */
+
+mxml_node_t * /* O - Next node or NULL if there is none */
+mxmlIndexEnum(mxml_index_t *ind) /* I - Index to enumerate */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!ind)
+ return (NULL);
+
+ /*
+ * Return the next node...
+ */
+
+ if (ind->cur_node < ind->num_nodes)
+ return (ind->nodes[ind->cur_node ++]);
+ else
+ return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexFind()' - Find the next matching node.
+ *
+ * You should call mxmlIndexReset() prior to using this function for
+ * the first time with a particular set of "element" and "value"
+ * strings. Passing NULL for both "element" and "value" is equivalent
+ * to calling mxmlIndexEnum().
+ */
+
+mxml_node_t * /* O - Node or NULL if none found */
+mxmlIndexFind(mxml_index_t *ind, /* I - Index to search */
+ const char *element, /* I - Element name to find, if any */
+ const char *value) /* I - Attribute value, if any */
+{
+ int diff, /* Difference between names */
+ current, /* Current entity in search */
+ first, /* First entity in search */
+ last; /* Last entity in search */
+
+
+#ifdef DEBUG
+ printf("mxmlIndexFind(ind=%p, element=\"%s\", value=\"%s\")\n",
+ ind, element ? element : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!ind || (!ind->attr && value))
+ {
+#ifdef DEBUG
+ puts(" returning NULL...");
+ printf(" ind->attr=\"%s\"\n", ind->attr ? ind->attr : "(null)");
+#endif /* DEBUG */
+
+ return (NULL);
+ }
+
+ /*
+ * If both element and value are NULL, just enumerate the nodes in the
+ * index...
+ */
+
+ if (!element && !value)
+ return (mxmlIndexEnum(ind));
+
+ /*
+ * If there are no nodes in the index, return NULL...
+ */
+
+ if (!ind->num_nodes)
+ {
+#ifdef DEBUG
+ puts(" returning NULL...");
+ puts(" no nodes!");
+#endif /* DEBUG */
+
+ return (NULL);
+ }
+
+ /*
+ * If cur_node == 0, then find the first matching node...
+ */
+
+ if (ind->cur_node == 0)
+ {
+ /*
+ * Find the first node using a modified binary search algorithm...
+ */
+
+ first = 0;
+ last = ind->num_nodes - 1;
+
+#ifdef DEBUG
+ printf(" find first time, num_nodes=%d...\n", ind->num_nodes);
+#endif /* DEBUG */
+
+ while ((last - first) > 1)
+ {
+ current = (first + last) / 2;
+
+#ifdef DEBUG
+ printf(" first=%d, last=%d, current=%d\n", first, last, current);
+#endif /* DEBUG */
+
+ if ((diff = index_find(ind, element, value, ind->nodes[current])) == 0)
+ {
+ /*
+ * Found a match, move back to find the first...
+ */
+
+#ifdef DEBUG
+ puts(" match!");
+#endif /* DEBUG */
+
+ while (current > 0 &&
+ !index_find(ind, element, value, ind->nodes[current - 1]))
+ current --;
+
+#ifdef DEBUG
+ printf(" returning first match=%d\n", current);
+#endif /* DEBUG */
+
+ /*
+ * Return the first match and save the index to the next...
+ */
+
+ ind->cur_node = current + 1;
+
+ return (ind->nodes[current]);
+ }
+ else if (diff < 0)
+ last = current;
+ else
+ first = current;
+
+#ifdef DEBUG
+ printf(" diff=%d\n", diff);
+#endif /* DEBUG */
+ }
+
+ /*
+ * If we get this far, then we found exactly 0 or 1 matches...
+ */
+
+ for (current = first; current <= last; current ++)
+ if (!index_find(ind, element, value, ind->nodes[current]))
+ {
+ /*
+ * Found exactly one (or possibly two) match...
+ */
+
+#ifdef DEBUG
+ printf(" returning only match %d...\n", current);
+#endif /* DEBUG */
+
+ ind->cur_node = current + 1;
+
+ return (ind->nodes[current]);
+ }
+
+ /*
+ * No matches...
+ */
+
+ ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+ puts(" returning NULL...");
+#endif /* DEBUG */
+
+ return (NULL);
+ }
+ else if (ind->cur_node < ind->num_nodes &&
+ !index_find(ind, element, value, ind->nodes[ind->cur_node]))
+ {
+ /*
+ * Return the next matching node...
+ */
+
+#ifdef DEBUG
+ printf(" returning next match %d...\n", ind->cur_node);
+#endif /* DEBUG */
+
+ return (ind->nodes[ind->cur_node ++]);
+ }
+
+ /*
+ * If we get this far, then we have no matches...
+ */
+
+ ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+ puts(" returning NULL...");
+#endif /* DEBUG */
+
+ return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexNew()' - Create a new index.
+ *
+ * The index will contain all nodes that contain the named element and/or
+ * attribute. If both "element" and "attr" are NULL, then the index will
+ * contain a sorted list of the elements in the node tree. Nodes are
+ * sorted by element name and optionally by attribute value if the "attr"
+ * argument is not NULL.
+ */
+
+mxml_index_t * /* O - New index */
+mxmlIndexNew(mxml_node_t *node, /* I - XML node tree */
+ const char *element, /* I - Element to index or NULL for all */
+ const char *attr) /* I - Attribute to index or NULL for none */
+{
+ mxml_index_t *ind; /* New index */
+ mxml_node_t *current, /* Current node in index */
+ **temp; /* Temporary node pointer array */
+
+
+ /*
+ * Range check input...
+ */
+
+#ifdef DEBUG
+ printf("mxmlIndexNew(node=%p, element=\"%s\", attr=\"%s\")\n",
+ node, element ? element : "(null)", attr ? attr : "(null)");
+#endif /* DEBUG */
+
+ if (!node)
+ return (NULL);
+
+ /*
+ * Create a new index...
+ */
+
+ if ((ind = calloc(1, sizeof(mxml_index_t))) == NULL)
+ {
+ mxml_error("Unable to allocate %d bytes for index - %s",
+ sizeof(mxml_index_t), strerror(errno));
+ return (NULL);
+ }
+
+ if (attr)
+ ind->attr = strdup(attr);
+
+ if (!element && !attr)
+ current = node;
+ else
+ current = mxmlFindElement(node, node, element, attr, NULL, MXML_DESCEND);
+
+ while (current)
+ {
+ if (ind->num_nodes >= ind->alloc_nodes)
+ {
+ if (!ind->alloc_nodes)
+ temp = malloc(64 * sizeof(mxml_node_t *));
+ else
+ temp = realloc(ind->nodes, (ind->alloc_nodes + 64) * sizeof(mxml_node_t *));
+
+ if (!temp)
+ {
+ /*
+ * Unable to allocate memory for the index, so abort...
+ */
+
+ mxml_error("Unable to allocate %d bytes for index: %s",
+ (ind->alloc_nodes + 64) * sizeof(mxml_node_t *),
+ strerror(errno));
+
+ mxmlIndexDelete(ind);
+ return (NULL);
+ }
+
+ ind->nodes = temp;
+ ind->alloc_nodes += 64;
+ }
+
+ ind->nodes[ind->num_nodes ++] = current;
+
+ current = mxmlFindElement(current, node, element, attr, NULL, MXML_DESCEND);
+ }
+
+ /*
+ * Sort nodes based upon the search criteria...
+ */
+
+#ifdef DEBUG
+ {
+ int i; /* Looping var */
+
+
+ printf("%d node(s) in index.\n\n", ind->num_nodes);
+
+ if (attr)
+ {
+ printf("Node Address Element %s\n", attr);
+ puts("-------- -------- -------------- ------------------------------");
+
+ for (i = 0; i < ind->num_nodes; i ++)
+ printf("%8d %-8p %-14.14s %s\n", i, ind->nodes[i],
+ ind->nodes[i]->value.element.name,
+ mxmlElementGetAttr(ind->nodes[i], attr));
+ }
+ else
+ {
+ puts("Node Address Element");
+ puts("-------- -------- --------------");
+
+ for (i = 0; i < ind->num_nodes; i ++)
+ printf("%8d %-8p %s\n", i, ind->nodes[i],
+ ind->nodes[i]->value.element.name);
+ }
+
+ putchar('\n');
+ }
+#endif /* DEBUG */
+
+ if (ind->num_nodes > 1)
+ index_sort(ind, 0, ind->num_nodes - 1);
+
+#ifdef DEBUG
+ {
+ int i; /* Looping var */
+
+
+ puts("After sorting:\n");
+
+ if (attr)
+ {
+ printf("Node Address Element %s\n", attr);
+ puts("-------- -------- -------------- ------------------------------");
+
+ for (i = 0; i < ind->num_nodes; i ++)
+ printf("%8d %-8p %-14.14s %s\n", i, ind->nodes[i],
+ ind->nodes[i]->value.element.name,
+ mxmlElementGetAttr(ind->nodes[i], attr));
+ }
+ else
+ {
+ puts("Node Address Element");
+ puts("-------- -------- --------------");
+
+ for (i = 0; i < ind->num_nodes; i ++)
+ printf("%8d %-8p %s\n", i, ind->nodes[i],
+ ind->nodes[i]->value.element.name);
+ }
+
+ putchar('\n');
+ }
+#endif /* DEBUG */
+
+ /*
+ * Return the new index...
+ */
+
+ return (ind);
+}
+
+
+/*
+ * 'mxmlIndexReset()' - Reset the enumeration/find pointer in the index and
+ * return the first node in the index.
+ *
+ * This function should be called prior to using mxmlIndexEnum() or
+ * mxmlIndexFind() for the first time.
+ */
+
+mxml_node_t * /* O - First node or NULL if there is none */
+mxmlIndexReset(mxml_index_t *ind) /* I - Index to reset */
+{
+#ifdef DEBUG
+ printf("mxmlIndexReset(ind=%p)\n", ind);
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!ind)
+ return (NULL);
+
+ /*
+ * Set the index to the first element...
+ */
+
+ ind->cur_node = 0;
+
+ /*
+ * Return the first node...
+ */
+
+ if (ind->num_nodes)
+ return (ind->nodes[0]);
+ else
+ return (NULL);
+}
+
+
+/*
+ * 'index_compare()' - Compare two nodes.
+ */
+
+static int /* O - Result of comparison */
+index_compare(mxml_index_t *ind, /* I - Index */
+ mxml_node_t *first, /* I - First node */
+ mxml_node_t *second) /* I - Second node */
+{
+ int diff; /* Difference */
+
+
+ /*
+ * Check the element name...
+ */
+
+ if ((diff = strcmp(first->value.element.name,
+ second->value.element.name)) != 0)
+ return (diff);
+
+ /*
+ * Check the attribute value...
+ */
+
+ if (ind->attr)
+ {
+ if ((diff = strcmp(mxmlElementGetAttr(first, ind->attr),
+ mxmlElementGetAttr(second, ind->attr))) != 0)
+ return (diff);
+ }
+
+ /*
+ * No difference, return 0...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'index_find()' - Compare a node with index values.
+ */
+
+static int /* O - Result of comparison */
+index_find(mxml_index_t *ind, /* I - Index */
+ const char *element, /* I - Element name or NULL */
+ const char *value, /* I - Attribute value or NULL */
+ mxml_node_t *node) /* I - Node */
+{
+ int diff; /* Difference */
+
+
+ /*
+ * Check the element name...
+ */
+
+ if (element)
+ {
+ if ((diff = strcmp(element, node->value.element.name)) != 0)
+ return (diff);
+ }
+
+ /*
+ * Check the attribute value...
+ */
+
+ if (value)
+ {
+ if ((diff = strcmp(value, mxmlElementGetAttr(node, ind->attr))) != 0)
+ return (diff);
+ }
+
+ /*
+ * No difference, return 0...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'index_sort()' - Sort the nodes in the index...
+ *
+ * This function implements the classic quicksort algorithm...
+ */
+
+static void
+index_sort(mxml_index_t *ind, /* I - Index to sort */
+ int left, /* I - Left node in partition */
+ int right) /* I - Right node in partition */
+{
+ mxml_node_t *pivot, /* Pivot node */
+ *temp; /* Swap node */
+ int templ, /* Temporary left node */
+ tempr; /* Temporary right node */
+
+
+ /*
+ * Loop until we have sorted all the way to the right...
+ */
+
+ do
+ {
+ /*
+ * Sort the pivot in the current partition...
+ */
+
+ pivot = ind->nodes[left];
+
+ for (templ = left, tempr = right; templ < tempr;)
+ {
+ /*
+ * Move left while left node <= pivot node...
+ */
+
+ while ((templ < right) &&
+ index_compare(ind, ind->nodes[templ], pivot) <= 0)
+ templ ++;
+
+ /*
+ * Move right while right node > pivot node...
+ */
+
+ while ((tempr > left) &&
+ index_compare(ind, ind->nodes[tempr], pivot) > 0)
+ tempr --;
+
+ /*
+ * Swap nodes if needed...
+ */
+
+ if (templ < tempr)
+ {
+ temp = ind->nodes[templ];
+ ind->nodes[templ] = ind->nodes[tempr];
+ ind->nodes[tempr] = temp;
+ }
+ }
+
+ /*
+ * When we get here, the right (tempr) node is the new position for the
+ * pivot node...
+ */
+
+ if (index_compare(ind, pivot, ind->nodes[tempr]) > 0)
+ {
+ ind->nodes[left] = ind->nodes[tempr];
+ ind->nodes[tempr] = pivot;
+ }
+
+ /*
+ * Recursively sort the left partition as needed...
+ */
+
+ if (left < (tempr - 1))
+ index_sort(ind, left, tempr - 1);
+ }
+ while (right > (left = tempr + 1));
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Node support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlAdd() - Add a node to a tree.
+ * mxmlDelete() - Delete a node and all of its children.
+ * mxmlNewElement() - Create a new element node.
+ * mxmlNewInteger() - Create a new integer node.
+ * mxmlNewOpaque() - Create a new opaque string.
+ * mxmlNewReal() - Create a new real number node.
+ * mxmlNewText() - Create a new text fragment node.
+ * mxmlNewTextf() - Create a new formatted text fragment node.
+ * mxmlRemove() - Remove a node from its parent.
+ * mxml_new() - Create a new node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t *mxml_new(mxml_node_t *parent, mxml_type_t type);
+
+
+/*
+ * 'mxmlAdd()' - Add a node to a tree.
+ *
+ * Adds the specified node to the parent. If the child argument is not
+ * NULL, puts the new node before or after the specified child depending
+ * on the value of the where argument. If the child argument is NULL,
+ * puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
+ * or at the end of the child list (MXML_ADD_AFTER). The constant
+ * MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.
+ */
+
+void
+mxmlAdd(mxml_node_t *parent, /* I - Parent node */
+ int where, /* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */
+ mxml_node_t *child, /* I - Child node for where or MXML_ADD_TO_PARENT */
+ mxml_node_t *node) /* I - Node to add */
+{
+#ifdef DEBUG
+ fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,
+ where, child, node);
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!parent || !node)
+ return;
+
+#if DEBUG > 1
+ fprintf(stderr, " BEFORE: node->parent=%p\n", node->parent);
+ if (parent)
+ {
+ fprintf(stderr, " BEFORE: parent->child=%p\n", parent->child);
+ fprintf(stderr, " BEFORE: parent->last_child=%p\n", parent->last_child);
+ fprintf(stderr, " BEFORE: parent->prev=%p\n", parent->prev);
+ fprintf(stderr, " BEFORE: parent->next=%p\n", parent->next);
+ }
+#endif /* DEBUG > 1 */
+
+ /*
+ * Remove the node from any existing parent...
+ */
+
+ if (node->parent)
+ mxmlRemove(node);
+
+ /*
+ * Reset pointers...
+ */
+
+ node->parent = parent;
+
+ switch (where)
+ {
+ case MXML_ADD_BEFORE :
+ if (!child || child == parent->child || child->parent != parent)
+ {
+ /*
+ * Insert as first node under parent...
+ */
+
+ node->next = parent->child;
+
+ if (parent->child)
+ parent->child->prev = node;
+ else
+ parent->last_child = node;
+
+ parent->child = node;
+ }
+ else
+ {
+ /*
+ * Insert node before this child...
+ */
+
+ node->next = child;
+ node->prev = child->prev;
+
+ if (child->prev)
+ child->prev->next = node;
+ else
+ parent->child = node;
+
+ child->prev = node;
+ }
+ break;
+
+ case MXML_ADD_AFTER :
+ if (!child || child == parent->last_child || child->parent != parent)
+ {
+ /*
+ * Insert as last node under parent...
+ */
+
+ node->parent = parent;
+ node->prev = parent->last_child;
+
+ if (parent->last_child)
+ parent->last_child->next = node;
+ else
+ parent->child = node;
+
+ parent->last_child = node;
+ }
+ else
+ {
+ /*
+ * Insert node after this child...
+ */
+
+ node->prev = child;
+ node->next = child->next;
+
+ if (child->next)
+ child->next->prev = node;
+ else
+ parent->last_child = node;
+
+ child->next = node;
+ }
+ break;
+ }
+
+#if DEBUG > 1
+ fprintf(stderr, " AFTER: node->parent=%p\n", node->parent);
+ if (parent)
+ {
+ fprintf(stderr, " AFTER: parent->child=%p\n", parent->child);
+ fprintf(stderr, " AFTER: parent->last_child=%p\n", parent->last_child);
+ fprintf(stderr, " AFTER: parent->prev=%p\n", parent->prev);
+ fprintf(stderr, " AFTER: parent->next=%p\n", parent->next);
+ }
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlDelete()' - Delete a node and all of its children.
+ *
+ * If the specified node has a parent, this function first removes the
+ * node from its parent using the mxmlRemove() function.
+ */
+
+void
+mxmlDelete(mxml_node_t *node) /* I - Node to delete */
+{
+ int i; /* Looping var */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlDelete(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!node)
+ return;
+
+ /*
+ * Remove the node from its parent, if any...
+ */
+
+ mxmlRemove(node);
+
+ /*
+ * Delete children...
+ */
+
+ while (node->child)
+ mxmlDelete(node->child);
+
+ /*
+ * Now delete any node data...
+ */
+
+ switch (node->type)
+ {
+ case MXML_ELEMENT :
+ if (node->value.element.name)
+ free(node->value.element.name);
+
+ if (node->value.element.num_attrs)
+ {
+ for (i = 0; i < node->value.element.num_attrs; i ++)
+ {
+ if (node->value.element.attrs[i].name)
+ free(node->value.element.attrs[i].name);
+ if (node->value.element.attrs[i].value)
+ free(node->value.element.attrs[i].value);
+ }
+
+ free(node->value.element.attrs);
+ }
+ break;
+ case MXML_INTEGER :
+ /* Nothing to do */
+ break;
+ case MXML_OPAQUE :
+ if (node->value.opaque)
+ free(node->value.opaque);
+ break;
+ case MXML_REAL :
+ /* Nothing to do */
+ break;
+ case MXML_TEXT :
+ if (node->value.text.string)
+ free(node->value.text.string);
+ break;
+ case MXML_CUSTOM :
+ if (node->value.custom.data &&
+ node->value.custom.destroy)
+ (*(node->value.custom.destroy))(node->value.custom.data);
+ break;
+ }
+
+ /*
+ * Free this node...
+ */
+
+ free(node);
+}
+
+
+/*
+ * 'mxmlNewCustom()' - Create a new custom data node.
+ *
+ * The new custom node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent. NULL can be passed when the data in the
+ * node is not dynamically allocated or is separately managed.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewCustom(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ void *data, /* I - Pointer to data */
+ void (*destroy)(void *))
+ /* I - Function to destroy data */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,
+ data, destroy);
+#endif /* DEBUG */
+
+ /*
+ * Create the node and set the value...
+ */
+
+ if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)
+ {
+ node->value.custom.data = data;
+ node->value.custom.destroy = destroy;
+ }
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewElement()' - Create a new element node.
+ *
+ * The new element node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewElement(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ const char *name) /* I - Name of element */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,
+ name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!name)
+ return (NULL);
+
+ /*
+ * Create the node and set the element name...
+ */
+
+ if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+ node->value.element.name = strdup(name);
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewInteger()' - Create a new integer node.
+ *
+ * The new integer node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * integer node has no parent.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewInteger(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ int integer) /* I - Integer value */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);
+#endif /* DEBUG */
+
+ /*
+ * Create the node and set the element name...
+ */
+
+ if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)
+ node->value.integer = integer;
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewOpaque()' - Create a new opaque string.
+ *
+ * The new opaque node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * opaque node has no parent. The opaque string must be nul-terminated and
+ * is copied into the new node.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewOpaque(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ const char *opaque) /* I - Opaque string */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,
+ opaque ? opaque : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!opaque)
+ return (NULL);
+
+ /*
+ * Create the node and set the element name...
+ */
+
+ if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)
+ node->value.opaque = strdup(opaque);
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewReal()' - Create a new real number node.
+ *
+ * The new real number node is added to the end of the specified parent's
+ * child list. The constant MXML_NO_PARENT can be used to specify that
+ * the new real number node has no parent.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewReal(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ double real) /* I - Real number value */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);
+#endif /* DEBUG */
+
+ /*
+ * Create the node and set the element name...
+ */
+
+ if ((node = mxml_new(parent, MXML_REAL)) != NULL)
+ node->value.real = real;
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewText()' - Create a new text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The text
+ * string must be nul-terminated and is copied into the new node.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewText(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
+ const char *string) /* I - String */
+{
+ mxml_node_t *node; /* New node */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",
+ parent, whitespace, string ? string : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!string)
+ return (NULL);
+
+ /*
+ * Create the node and set the text value...
+ */
+
+ if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+ {
+ node->value.text.whitespace = whitespace;
+ node->value.text.string = strdup(string);
+ }
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlNewTextf()' - Create a new formatted text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The format
+ * string must be nul-terminated and is formatted into the new node.
+ */
+
+mxml_node_t * /* O - New node */
+mxmlNewTextf(mxml_node_t *parent, /* I - Parent node or MXML_NO_PARENT */
+ int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
+ const char *format, /* I - Printf-style frmat string */
+ ...) /* I - Additional args as needed */
+{
+ mxml_node_t *node; /* New node */
+ va_list ap; /* Pointer to arguments */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",
+ parent, whitespace, format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!format)
+ return (NULL);
+
+ /*
+ * Create the node and set the text value...
+ */
+
+ if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+ {
+ va_start(ap, format);
+
+ node->value.text.whitespace = whitespace;
+ node->value.text.string = mxml_strdupf(format, ap);
+
+ va_end(ap);
+ }
+
+ return (node);
+}
+
+
+/*
+ * 'mxmlRemove()' - Remove a node from its parent.
+ *
+ * Does not free memory used by the node - use mxmlDelete() for that.
+ * This function does nothing if the node has no parent.
+ */
+
+void
+mxmlRemove(mxml_node_t *node) /* I - Node to remove */
+{
+#ifdef DEBUG
+ fprintf(stderr, "mxmlRemove(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+ * Range check input...
+ */
+
+ if (!node || !node->parent)
+ return;
+
+ /*
+ * Remove from parent...
+ */
+
+#if DEBUG > 1
+ fprintf(stderr, " BEFORE: node->parent=%p\n", node->parent);
+ if (node->parent)
+ {
+ fprintf(stderr, " BEFORE: node->parent->child=%p\n", node->parent->child);
+ fprintf(stderr, " BEFORE: node->parent->last_child=%p\n", node->parent->last_child);
+ }
+ fprintf(stderr, " BEFORE: node->child=%p\n", node->child);
+ fprintf(stderr, " BEFORE: node->last_child=%p\n", node->last_child);
+ fprintf(stderr, " BEFORE: node->prev=%p\n", node->prev);
+ fprintf(stderr, " BEFORE: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+
+ if (node->prev)
+ node->prev->next = node->next;
+ else
+ node->parent->child = node->next;
+
+ if (node->next)
+ node->next->prev = node->prev;
+ else
+ node->parent->last_child = node->prev;
+
+ node->parent = NULL;
+ node->prev = NULL;
+ node->next = NULL;
+
+#if DEBUG > 1
+ fprintf(stderr, " AFTER: node->parent=%p\n", node->parent);
+ if (node->parent)
+ {
+ fprintf(stderr, " AFTER: node->parent->child=%p\n", node->parent->child);
+ fprintf(stderr, " AFTER: node->parent->last_child=%p\n", node->parent->last_child);
+ }
+ fprintf(stderr, " AFTER: node->child=%p\n", node->child);
+ fprintf(stderr, " AFTER: node->last_child=%p\n", node->last_child);
+ fprintf(stderr, " AFTER: node->prev=%p\n", node->prev);
+ fprintf(stderr, " AFTER: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxml_new()' - Create a new node.
+ */
+
+static mxml_node_t * /* O - New node */
+mxml_new(mxml_node_t *parent, /* I - Parent node */
+ mxml_type_t type) /* I - Node type */
+{
+ mxml_node_t *node; /* New node */
+
+
+#if DEBUG > 1
+ fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);
+#endif /* DEBUG > 1 */
+
+ /*
+ * Allocate memory for the node...
+ */
+
+ if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)
+ {
+#if DEBUG > 1
+ fputs(" returning NULL\n", stderr);
+#endif /* DEBUG > 1 */
+
+ return (NULL);
+ }
+
+#if DEBUG > 1
+ fprintf(stderr, " returning %p\n", node);
+#endif /* DEBUG > 1 */
+
+ /*
+ * Set the node type...
+ */
+
+ node->type = type;
+
+ /*
+ * Add to the parent if present...
+ */
+
+ if (parent)
+ mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+
+ /*
+ * Return the new node...
+ */
+
+ return (node);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Private functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxml_error() - Display an error message.
+ * mxml_integer_cb() - Default callback for integer values.
+ * mxml_opaque_cb() - Default callback for opaque values.
+ * mxml_real_cb() - Default callback for real number values.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Error callback function...
+ */
+
+void (*mxml_error_cb)(const char *) = NULL;
+
+
+/*
+ * 'mxml_error()' - Display an error message.
+ */
+
+void
+mxml_error(const char *format, /* I - Printf-style format string */
+ ...) /* I - Additional arguments as needed */
+{
+ va_list ap; /* Pointer to arguments */
+ char *s; /* Message string */
+
+
+ /*
+ * Range check input...
+ */
+
+ if (!format)
+ return;
+
+ /*
+ * Format the error message string...
+ */
+
+ va_start(ap, format);
+
+ s = mxml_strdupf(format, ap);
+
+ va_end(ap);
+
+ /*
+ * And then display the error message...
+ */
+
+ if (mxml_error_cb)
+ (*mxml_error_cb)(s);
+ else
+ fprintf(stderr, "mxml: %s\n", s);
+
+ /*
+ * Free the string...
+ */
+
+ free(s);
+}
+
+
+/*
+ * 'mxml_integer_cb()' - Default callback for integer values.
+ */
+
+mxml_type_t /* O - Node type */
+mxml_integer_cb(mxml_node_t *node) /* I - Current node */
+{
+ (void)node;
+
+ return (MXML_INTEGER);
+}
+
+
+/*
+ * 'mxml_opaque_cb()' - Default callback for opaque values.
+ */
+
+mxml_type_t /* O - Node type */
+mxml_opaque_cb(mxml_node_t *node) /* I - Current node */
+{
+ (void)node;
+
+ return (MXML_OPAQUE);
+}
+
+
+/*
+ * 'mxml_real_cb()' - Default callback for real number values.
+ */
+
+mxml_type_t /* O - Node type */
+mxml_real_cb(mxml_node_t *node) /* I - Current node */
+{
+ (void)node;
+
+ return (MXML_REAL);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Search/navigation functions for Mini-XML, a small XML-like file
+ * parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlFindElement() - Find the named element.
+ * mxmlWalkNext() - Walk to the next logical node in the tree.
+ * mxmlWalkPrev() - Walk to the previous logical node in the tree.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlFindElement()' - Find the named element.
+ *
+ * The search is constrained by the name, attribute name, and value; any
+ * NULL names or values are treated as wildcards, so different kinds of
+ * searches can be implemented by looking for all elements of a given name
+ * or all elements with a specific attribute. The descend argument determines
+ * whether the search descends into child nodes; normally you will use
+ * MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
+ * additional direct descendents of the node. The top node argument
+ * constrains the search to a particular node's children.
+ */
+
+mxml_node_t * /* O - Element node or NULL */
+mxmlFindElement(mxml_node_t *node, /* I - Current node */
+ mxml_node_t *top, /* I - Top node */
+ const char *name, /* I - Element name or NULL for any */
+ const char *attr, /* I - Attribute name, or NULL for none */
+ const char *value, /* I - Attribute value, or NULL for any */
+ int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+ const char *temp; /* Current attribute value */
+
+
+ /*
+ * Range check input...
+ */
+
+ if (!node || !top || (!attr && value))
+ return (NULL);
+
+ /*
+ * Start with the next node...
+ */
+
+ node = mxmlWalkNext(node, top, descend);
+
+ /*
+ * Loop until we find a matching element...
+ */
+
+ while (node != NULL)
+ {
+ /*
+ * See if this node matches...
+ */
+
+ if (node->type == MXML_ELEMENT &&
+ node->value.element.name &&
+ (!name || !strcmp(node->value.element.name, name)))
+ {
+ /*
+ * See if we need to check for an attribute...
+ */
+
+ if (!attr)
+ return (node); /* No attribute search, return it... */
+
+ /*
+ * Check for the attribute...
+ */
+
+ if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
+ {
+ /*
+ * OK, we have the attribute, does it match?
+ */
+
+ if (!value || !strcmp(value, temp))
+ return (node); /* Yes, return it... */
+ }
+ }
+
+ /*
+ * No match, move on to the next node...
+ */
+
+ if (descend == MXML_DESCEND)
+ node = mxmlWalkNext(node, top, MXML_DESCEND);
+ else
+ node = node->next;
+ }
+
+ return (NULL);
+}
+
+
+/*
+ * 'mxmlWalkNext()' - Walk to the next logical node in the tree.
+ *
+ * The descend argument controls whether the first child is considered
+ * to be the next node. The top node argument constrains the walk to
+ * the node's children.
+ */
+
+mxml_node_t * /* O - Next node or NULL */
+mxmlWalkNext(mxml_node_t *node, /* I - Current node */
+ mxml_node_t *top, /* I - Top node */
+ int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+ if (!node)
+ return (NULL);
+ else if (node->child && descend)
+ return (node->child);
+ else if (node->next)
+ return (node->next);
+ else if (node->parent && node->parent != top)
+ {
+ node = node->parent;
+
+ while (!node->next)
+ if (node->parent == top || !node->parent)
+ return (NULL);
+ else
+ node = node->parent;
+
+ return (node->next);
+ }
+ else
+ return (NULL);
+}
+
+
+/*
+ * 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.
+ *
+ * The descend argument controls whether the previous node's last child
+ * is considered to be the previous node. The top node argument constrains
+ * the walk to the node's children.
+ */
+
+mxml_node_t * /* O - Previous node or NULL */
+mxmlWalkPrev(mxml_node_t *node, /* I - Current node */
+ mxml_node_t *top, /* I - Top node */
+ int descend) /* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+ if (!node)
+ return (NULL);
+ else if (node->prev)
+ {
+ if (node->prev->last_child && descend)
+ {
+ /*
+ * Find the last child under the previous node...
+ */
+
+ node = node->prev->last_child;
+
+ while (node->last_child)
+ node = node->last_child;
+
+ return (node);
+ }
+ else
+ return (node->prev);
+ }
+ else if (node->parent != top)
+ return (node->parent);
+ else
+ return (NULL);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Node set functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxmlSetElement() - Set the name of an element node.
+ * mxmlSetInteger() - Set the value of an integer node.
+ * mxmlSetOpaque() - Set the value of an opaque node.
+ * mxmlSetReal() - Set the value of a real number node.
+ * mxmlSetText() - Set the value of a text node.
+ * mxmlSetTextf() - Set the value of a text node to a formatted string.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlSetCustom()' - Set the data and destructor of a custom data node.
+ *
+ * The node is not changed if it is not a custom node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetCustom(mxml_node_t *node, /* I - Node to set */
+ void *data, /* I - New data pointer */
+ void (*destroy)(void *))
+ /* I - New destructor function */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_CUSTOM)
+ return (-1);
+
+ /*
+ * Free any old element value and set the new value...
+ */
+
+ if (node->value.custom.data && node->value.custom.destroy)
+ (*(node->value.custom.destroy))(node->value.custom.data);
+
+ node->value.custom.data = data;
+ node->value.custom.destroy = destroy;
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetElement()' - Set the name of an element node.
+ *
+ * The node is not changed if it is not an element node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetElement(mxml_node_t *node, /* I - Node to set */
+ const char *name) /* I - New name string */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_ELEMENT || !name)
+ return (-1);
+
+ /*
+ * Free any old element value and set the new value...
+ */
+
+ if (node->value.element.name)
+ free(node->value.element.name);
+
+ node->value.element.name = strdup(name);
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetInteger()' - Set the value of an integer node.
+ *
+ * The node is not changed if it is not an integer node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetInteger(mxml_node_t *node, /* I - Node to set */
+ int integer) /* I - Integer value */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_INTEGER)
+ return (-1);
+
+ /*
+ * Set the new value and return...
+ */
+
+ node->value.integer = integer;
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetOpaque()' - Set the value of an opaque node.
+ *
+ * The node is not changed if it is not an opaque node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetOpaque(mxml_node_t *node, /* I - Node to set */
+ const char *opaque) /* I - Opaque string */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_OPAQUE || !opaque)
+ return (-1);
+
+ /*
+ * Free any old opaque value and set the new value...
+ */
+
+ if (node->value.opaque)
+ free(node->value.opaque);
+
+ node->value.opaque = strdup(opaque);
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetReal()' - Set the value of a real number node.
+ *
+ * The node is not changed if it is not a real number node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetReal(mxml_node_t *node, /* I - Node to set */
+ double real) /* I - Real number value */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_REAL)
+ return (-1);
+
+ /*
+ * Set the new value and return...
+ */
+
+ node->value.real = real;
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetText()' - Set the value of a text node.
+ *
+ * The node is not changed if it is not a text node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetText(mxml_node_t *node, /* I - Node to set */
+ int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
+ const char *string) /* I - String */
+{
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_TEXT || !string)
+ return (-1);
+
+ /*
+ * Free any old string value and set the new value...
+ */
+
+ if (node->value.text.string)
+ free(node->value.text.string);
+
+ node->value.text.whitespace = whitespace;
+ node->value.text.string = strdup(string);
+
+ return (0);
+}
+
+
+/*
+ * 'mxmlSetTextf()' - Set the value of a text node to a formatted string.
+ *
+ * The node is not changed if it is not a text node.
+ */
+
+int /* O - 0 on success, -1 on failure */
+mxmlSetTextf(mxml_node_t *node, /* I - Node to set */
+ int whitespace, /* I - 1 = leading whitespace, 0 = no whitespace */
+ const char *format, /* I - Printf-style format string */
+ ...) /* I - Additional arguments as needed */
+{
+ va_list ap; /* Pointer to arguments */
+
+
+ /*
+ * Range check input...
+ */
+
+ if (!node || node->type != MXML_TEXT || !format)
+ return (-1);
+
+ /*
+ * Free any old string value and set the new value...
+ */
+
+ if (node->value.text.string)
+ free(node->value.text.string);
+
+ va_start(ap, format);
+
+ node->value.text.whitespace = whitespace;
+ node->value.text.string = mxml_strdupf(format, ap);
+
+ va_end(ap);
+
+ return (0);
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * String functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * mxml_strdup() - Duplicate a string.
+ * mxml_strdupf() - Format and duplicate a string.
+ * mxml_vsnprintf() - Format a string into a fixed size buffer.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+
+
+/*
+ * 'mxml_strdup()' - Duplicate a string.
+ */
+
+#ifndef HAVE_STRDUP
+char * /* O - New string pointer */
+mxml_strdup(const char *s) /* I - String to duplicate */
+{
+ char *t; /* New string pointer */
+
+
+ if (s == NULL)
+ return (NULL);
+
+ if ((t = malloc(strlen(s) + 1)) == NULL)
+ return (NULL);
+
+ return (strcpy(t, s));
+}
+#endif /* !HAVE_STRDUP */
+
+
+/*
+ * 'mxml_strdupf()' - Format and duplicate a string.
+ */
+
+char * /* O - New string pointer */
+mxml_strdupf(const char *format, /* I - Printf-style format string */
+ va_list ap) /* I - Pointer to additional arguments */
+{
+ int bytes; /* Number of bytes required */
+ char *buffer, /* String buffer */
+ temp[256]; /* Small buffer for first vsnprintf */
+
+
+ /*
+ * First format with a tiny buffer; this will tell us how many bytes are
+ * needed...
+ */
+
+ bytes = vsnprintf(temp, sizeof(temp), format, ap);
+
+ if (bytes < sizeof(temp))
+ {
+ /*
+ * Hey, the formatted string fits in the tiny buffer, so just dup that...
+ */
+
+ return (strdup(temp));
+ }
+
+ /*
+ * Allocate memory for the whole thing and reformat to the new, larger
+ * buffer...
+ */
+
+ if ((buffer = calloc(1, bytes + 1)) != NULL)
+ vsnprintf(buffer, bytes + 1, format, ap);
+
+ /*
+ * Return the new string...
+ */
+
+ return (buffer);
+}
+
+
+#ifndef HAVE_VSNPRINTF
+/*
+ * 'mxml_vsnprintf()' - Format a string into a fixed size buffer.
+ */
+
+int /* O - Number of bytes formatted */
+mxml_vsnprintf(char *buffer, /* O - Output buffer */
+ size_t bufsize, /* O - Size of output buffer */
+ const char *format, /* I - Printf-style format string */
+ va_list ap) /* I - Pointer to additional arguments */
+{
+ char *bufptr, /* Pointer to position in buffer */
+ *bufend, /* Pointer to end of buffer */
+ sign, /* Sign of format width */
+ size, /* Size character (h, l, L) */
+ type; /* Format type character */
+ const char *bufformat; /* Start of format */
+ int width, /* Width of field */
+ prec; /* Number of characters of precision */
+ char tformat[100], /* Temporary format string for sprintf() */
+ temp[1024]; /* Buffer for formatted numbers */
+ char *s; /* Pointer to string */
+ int slen; /* Length of string */
+ int bytes; /* Total number of bytes needed */
+
+
+ /*
+ * Loop through the format string, formatting as needed...
+ */
+
+ bufptr = buffer;
+ bufend = buffer + bufsize - 1;
+ bytes = 0;
+
+ while (*format)
+ {
+ if (*format == '%')
+ {
+ bufformat = format;
+ format ++;
+
+ if (*format == '%')
+ {
+ *bufptr++ = *format++;
+ continue;
+ }
+ else if (strchr(" -+#\'", *format))
+ sign = *format++;
+ else
+ sign = 0;
+
+ width = 0;
+ while (isdigit(*format))
+ width = width * 10 + *format++ - '0';
+
+ if (*format == '.')
+ {
+ format ++;
+ prec = 0;
+
+ while (isdigit(*format))
+ prec = prec * 10 + *format++ - '0';
+ }
+ else
+ prec = -1;
+
+ if (*format == 'l' && format[1] == 'l')
+ {
+ size = 'L';
+ format += 2;
+ }
+ else if (*format == 'h' || *format == 'l' || *format == 'L')
+ size = *format++;
+
+ if (!*format)
+ break;
+
+ type = *format++;
+
+ switch (type)
+ {
+ case 'E' : /* Floating point formats */
+ case 'G' :
+ case 'e' :
+ case 'f' :
+ case 'g' :
+ if ((format - bufformat + 1) > sizeof(tformat) ||
+ (width + 2) > sizeof(temp))
+ break;
+
+ strncpy(tformat, bufformat, format - bufformat);
+ tformat[format - bufformat] = '\0';
+
+ sprintf(temp, tformat, va_arg(ap, double));
+
+ bytes += strlen(temp);
+
+ if (bufptr)
+ {
+ if ((bufptr + strlen(temp)) > bufend)
+ {
+ strncpy(bufptr, temp, bufend - bufptr);
+ bufptr = bufend;
+ break;
+ }
+ else
+ {
+ strcpy(bufptr, temp);
+ bufptr += strlen(temp);
+ }
+ }
+ break;
+
+ case 'B' : /* Integer formats */
+ case 'X' :
+ case 'b' :
+ case 'd' :
+ case 'i' :
+ case 'o' :
+ case 'u' :
+ case 'x' :
+ if ((format - bufformat + 1) > sizeof(tformat) ||
+ (width + 2) > sizeof(temp))
+ break;
+
+ strncpy(tformat, bufformat, format - bufformat);
+ tformat[format - bufformat] = '\0';
+
+ sprintf(temp, tformat, va_arg(ap, int));
+
+ bytes += strlen(temp);
+
+ if (bufptr)
+ {
+ if ((bufptr + strlen(temp)) > bufend)
+ {
+ strncpy(bufptr, temp, bufend - bufptr);
+ bufptr = bufend;
+ break;
+ }
+ else
+ {
+ strcpy(bufptr, temp);
+ bufptr += strlen(temp);
+ }
+ }
+ break;
+
+ case 'p' : /* Pointer value */
+ if ((format - bufformat + 1) > sizeof(tformat) ||
+ (width + 2) > sizeof(temp))
+ break;
+
+ strncpy(tformat, bufformat, format - bufformat);
+ tformat[format - bufformat] = '\0';
+
+ sprintf(temp, tformat, va_arg(ap, void *));
+
+ bytes += strlen(temp);
+
+ if (bufptr)
+ {
+ if ((bufptr + strlen(temp)) > bufend)
+ {
+ strncpy(bufptr, temp, bufend - bufptr);
+ bufptr = bufend;
+ break;
+ }
+ else
+ {
+ strcpy(bufptr, temp);
+ bufptr += strlen(temp);
+ }
+ }
+ break;
+
+ case 'c' : /* Character or character array */
+ bytes += width;
+
+ if (bufptr)
+ {
+ if (width <= 1)
+ *bufptr++ = va_arg(ap, int);
+ else
+ {
+ if ((bufptr + width) > bufend)
+ width = bufend - bufptr;
+
+ memcpy(bufptr, va_arg(ap, char *), width);
+ bufptr += width;
+ }
+ }
+ break;
+
+ case 's' : /* String */
+ if ((s = va_arg(ap, char *)) == NULL)
+ s = "(null)";
+
+ slen = strlen(s);
+ if (slen > width && prec != width)
+ width = slen;
+
+ bytes += width;
+
+ if (bufptr)
+ {
+ if ((bufptr + width) > bufend)
+ width = bufend - bufptr;
+
+ if (slen > width)
+ slen = width;
+
+ if (sign == '-')
+ {
+ strncpy(bufptr, s, slen);
+ memset(bufptr + slen, ' ', width - slen);
+ }
+ else
+ {
+ memset(bufptr, ' ', width - slen);
+ strncpy(bufptr + width - slen, s, slen);
+ }
+
+ bufptr += width;
+ }
+ break;
+
+ case 'n' : /* Output number of chars so far */
+ if ((format - bufformat + 1) > sizeof(tformat) ||
+ (width + 2) > sizeof(temp))
+ break;
+
+ strncpy(tformat, bufformat, format - bufformat);
+ tformat[format - bufformat] = '\0';
+
+ sprintf(temp, tformat, va_arg(ap, int));
+
+ bytes += strlen(temp);
+
+ if (bufptr)
+ {
+ if ((bufptr + strlen(temp)) > bufend)
+ {
+ strncpy(bufptr, temp, bufend - bufptr);
+ bufptr = bufend;
+ break;
+ }
+ else
+ {
+ strcpy(bufptr, temp);
+ bufptr += strlen(temp);
+ }
+ }
+ break;
+ }
+ }
+ else
+ {
+ bytes ++;
+
+ if (bufptr && bufptr < bufend)
+ *bufptr++ = *format++;
+ }
+ }
+
+ /*
+ * Nul-terminate the string and return the number of characters needed.
+ */
+
+ *bufptr = '\0';
+
+ return (bytes);
+}
+#endif /* !HAVE_VSNPRINTF */
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Header file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ */
+
+/*
+ * Prevent multiple inclusion...
+ */
+
+#ifndef _mxml_h_
+# define _mxml_h_
+
+/*
+ * Include necessary headers...
+ */
+
+# include <stdio.h>
+# include <stdlib.h>
+# include <string.h>
+# include <ctype.h>
+# include <errno.h>
+
+
+/*
+ * Constants...
+ */
+
+# define MXML_WRAP 72 /* Wrap XML output at this column position */
+# define MXML_TAB 8 /* Tabs every N columns */
+
+# define MXML_NO_CALLBACK 0 /* Don't use a type callback */
+# define MXML_INTEGER_CALLBACK mxml_integer_cb
+ /* Treat all data as integers */
+# define MXML_OPAQUE_CALLBACK mxml_opaque_cb
+ /* Treat all data as opaque */
+# define MXML_REAL_CALLBACK mxml_real_cb
+ /* Treat all data as real numbers */
+# define MXML_TEXT_CALLBACK 0 /* Treat all data as text */
+
+# define MXML_NO_PARENT 0 /* No parent for the node */
+
+# define MXML_DESCEND 1 /* Descend when finding/walking */
+# define MXML_NO_DESCEND 0 /* Don't descend when finding/walking */
+# define MXML_DESCEND_FIRST -1 /* Descend for first find */
+
+# define MXML_WS_BEFORE_OPEN 0 /* Callback for before open tag */
+# define MXML_WS_AFTER_OPEN 1 /* Callback for after open tag */
+# define MXML_WS_BEFORE_CLOSE 2 /* Callback for before close tag */
+# define MXML_WS_AFTER_CLOSE 3 /* Callback for after close tag */
+
+# define MXML_ADD_BEFORE 0 /* Add node before specified node */
+# define MXML_ADD_AFTER 1 /* Add node after specified node */
+# define MXML_ADD_TO_PARENT NULL /* Add node relative to parent */
+
+
+/*
+ * Data types...
+ */
+
+typedef enum mxml_type_e /**** The XML node type. ****/
+{
+ MXML_ELEMENT, /* XML element with attributes */
+ MXML_INTEGER, /* Integer value */
+ MXML_OPAQUE, /* Opaque string */
+ MXML_REAL, /* Real value */
+ MXML_TEXT, /* Text fragment */
+ MXML_CUSTOM /* Custom data */
+} mxml_type_t;
+
+typedef struct mxml_attr_s /**** An XML element attribute value. ****/
+{
+ char *name; /* Attribute name */
+ char *value; /* Attribute value */
+} mxml_attr_t;
+
+typedef struct mxml_value_s /**** An XML element value. ****/
+{
+ char *name; /* Name of element */
+ int num_attrs; /* Number of attributes */
+ mxml_attr_t *attrs; /* Attributes */
+} mxml_element_t;
+
+typedef struct mxml_text_s /**** An XML text value. ****/
+{
+ int whitespace; /* Leading whitespace? */
+ char *string; /* Fragment string */
+} mxml_text_t;
+
+typedef struct mxml_custom_s /**** An XML custom value. ****/
+{
+ void *data; /* Pointer to (allocated) custom data */
+ void (*destroy)(void *);
+ /* Pointer to destructor function */
+} mxml_custom_t;
+
+typedef union mxml_value_u /**** An XML node value. ****/
+{
+ mxml_element_t element; /* Element */
+ int integer; /* Integer number */
+ char *opaque; /* Opaque string */
+ double real; /* Real number */
+ mxml_text_t text; /* Text fragment */
+ mxml_custom_t custom; /* Custom data */
+} mxml_value_t;
+
+typedef struct mxml_node_s /**** An XML node. ****/
+{
+ mxml_type_t type; /* Node type */
+ struct mxml_node_s *next; /* Next node under same parent */
+ struct mxml_node_s *prev; /* Previous node under same parent */
+ struct mxml_node_s *parent; /* Parent node */
+ struct mxml_node_s *child; /* First child node */
+ struct mxml_node_s *last_child; /* Last child node */
+ mxml_value_t value; /* Node value */
+} mxml_node_t;
+
+typedef struct mxml_index_s /**** An XML node index. ****/
+{
+ char *attr; /* Attribute used for indexing or NULL */
+ int num_nodes; /* Number of nodes in index */
+ int alloc_nodes; /* Allocated nodes in index */
+ int cur_node; /* Current node */
+ mxml_node_t **nodes; /* Node array */
+} mxml_index_t;
+
+typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *);
+ /**** Custom data load callback function ****/
+
+typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *);
+ /**** Custom data save callback function ****/
+
+
+/*
+ * C++ support...
+ */
+
+# ifdef __cplusplus
+extern "C" {
+# endif /* __cplusplus */
+
+/*
+ * Prototypes...
+ */
+
+extern void mxmlAdd(mxml_node_t *parent, int where,
+ mxml_node_t *child, mxml_node_t *node);
+extern void mxmlDelete(mxml_node_t *node);
+extern const char *mxmlElementGetAttr(mxml_node_t *node, const char *name);
+extern void mxmlElementSetAttr(mxml_node_t *node, const char *name,
+ const char *value);
+extern int mxmlEntityAddCallback(int (*cb)(const char *name));
+extern const char *mxmlEntityGetName(int val);
+extern int mxmlEntityGetValue(const char *name);
+extern void mxmlEntityRemoveCallback(int (*cb)(const char *name));
+extern mxml_node_t *mxmlFindElement(mxml_node_t *node, mxml_node_t *top,
+ const char *name, const char *attr,
+ const char *value, int descend);
+extern void mxmlIndexDelete(mxml_index_t *ind);
+extern mxml_node_t *mxmlIndexEnum(mxml_index_t *ind);
+extern mxml_node_t *mxmlIndexFind(mxml_index_t *ind,
+ const char *element,
+ const char *value);
+extern mxml_index_t *mxmlIndexNew(mxml_node_t *node, const char *element,
+ const char *attr);
+extern mxml_node_t *mxmlIndexReset(mxml_index_t *ind);
+extern mxml_node_t *mxmlLoadFd(mxml_node_t *top, int fd,
+ mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t *mxmlLoadFile(mxml_node_t *top, FILE *fp,
+ mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t *mxmlLoadString(mxml_node_t *top, const char *s,
+ mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t *mxmlNewCustom(mxml_node_t *parent, void *data,
+ void (*destroy)(void *));
+extern mxml_node_t *mxmlNewElement(mxml_node_t *parent, const char *name);
+extern mxml_node_t *mxmlNewInteger(mxml_node_t *parent, int integer);
+extern mxml_node_t *mxmlNewOpaque(mxml_node_t *parent, const char *opaque);
+extern mxml_node_t *mxmlNewReal(mxml_node_t *parent, double real);
+extern mxml_node_t *mxmlNewText(mxml_node_t *parent, int whitespace,
+ const char *string);
+extern mxml_node_t *mxmlNewTextf(mxml_node_t *parent, int whitespace,
+ const char *format, ...)
+# ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+# endif /* __GNUC__ */
+;
+extern void mxmlRemove(mxml_node_t *node);
+extern char *mxmlSaveAllocString(mxml_node_t *node,
+ const char *(*cb)(mxml_node_t *, int));
+extern int mxmlSaveFd(mxml_node_t *node, int fd,
+ const char *(*cb)(mxml_node_t *, int));
+extern int mxmlSaveFile(mxml_node_t *node, FILE *fp,
+ const char *(*cb)(mxml_node_t *, int));
+extern int mxmlSaveString(mxml_node_t *node, char *buffer,
+ int bufsize,
+ const char *(*cb)(mxml_node_t *, int));
+extern int mxmlSetCustom(mxml_node_t *node, void *data,
+ void (*destroy)(void *));
+extern void mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
+ mxml_custom_save_cb_t save);
+extern int mxmlSetElement(mxml_node_t *node, const char *name);
+extern void mxmlSetErrorCallback(void (*cb)(const char *));
+extern int mxmlSetInteger(mxml_node_t *node, int integer);
+extern int mxmlSetOpaque(mxml_node_t *node, const char *opaque);
+extern int mxmlSetReal(mxml_node_t *node, double real);
+extern int mxmlSetText(mxml_node_t *node, int whitespace,
+ const char *string);
+extern int mxmlSetTextf(mxml_node_t *node, int whitespace,
+ const char *format, ...)
+# ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+# endif /* __GNUC__ */
+;
+extern mxml_node_t *mxmlWalkNext(mxml_node_t *node, mxml_node_t *top,
+ int descend);
+extern mxml_node_t *mxmlWalkPrev(mxml_node_t *node, mxml_node_t *top,
+ int descend);
+
+
+/*
+ * Private functions...
+ */
+
+extern void mxml_error(const char *format, ...);
+extern mxml_type_t mxml_integer_cb(mxml_node_t *node);
+extern mxml_type_t mxml_opaque_cb(mxml_node_t *node);
+extern mxml_type_t mxml_real_cb(mxml_node_t *node);
+
+
+/*
+ * C++ support...
+ */
+
+# ifdef __cplusplus
+}
+# endif /* __cplusplus */
+#endif /* !_mxml_h_ */
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+#
+# "$Id$"
+#
+# EPM software list file for Mini-XML, a small XML library.
+#
+# Copyright 2003-2005 by Michael Sweet.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2, or (at your option) any later version.
+#
+# This program 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.
+#
+
+# Directories...
+$prefix=@prefix@
+$exec_prefix=@exec_prefix@
+$bindir=@bindir@
+$docdir=@docdir@
+$includedir=@includedir@
+$libdir=@libdir@
+$mandir=@mandir@
+$srcdir=@srcdir@
+
+$PICFLAG=@PICFLAG@
+
+# Product information
+%product mxml
+%copyright 2003-2005 by Michael Sweet
+%vendor Michael Sweet
+%license ${srcdir}/COPYING
+%readme ${srcdir}/README
+%version @VERSION@
+
+%description <<EOF
+Mini-XML is a small XML parsing library that you can use to read
+XML and XML-like data files in your application without
+requiring large non-standard libraries. Mini-XML provides the
+following functionality:
+
+ - Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded
+ XML files and strings.
+ - Data is stored in a linked-list tree structure, preserving
+ the XML data hierarchy.
+ - Supports arbitrary element names, attributes, and
+ attribute values with no preset limits, just available
+ memory.
+ - Supports integer, real, opaque ("cdata"), and text data
+ types in "leaf" nodes.
+ - Functions for creating and managing trees of data.
+ - "Find" and "walk" functions for easily locating and
+ navigating trees of data.
+
+Mini-XML doesn't do validation or other types of processing on
+the data based upon schema files or other sources of definition
+information, nor does it support character entities other than
+those required by the XML specification.
+EOF
+
+# Manpage extensions...
+$CAT1EXT=@CAT1EXT@
+$CAT3EXT=@CAT3EXT@
+$MAN1EXT=@MAN1EXT@
+$MAN3EXT=@MAN3EXT@
+
+# Executables
+f 0555 root sys ${bindir}/mxmldoc mxmldoc
+
+# Header files
+f 0444 root sys ${includedir}/mxml.h mxml.h
+
+# Libraries
+%if $PICFLAG
+%system hpux
+f 0555 root sys ${libdir}/libmxml.sl.1 libmxml.sl.1
+l 0555 root sys ${libdir}/libmxml.sl libmxml.sl.1
+
+%system dylib
+f 0555 root sys ${libdir}/libmxml.1.dylib libmxml.1.dylib
+l 0555 root sys ${libdir}/libmxml.dylib libmxml.1.dylib
+
+%system freebsd irix linux netbsd openbsd solaris tru64
+f 0555 root sys ${libdir}/libmxml.so.1.0 libmxml.so.1.0
+l 0555 root sys ${libdir}/libmxml.sl.1 libmxml.sl.1.0
+l 0555 root sys ${libdir}/libmxml.sl libmxml.sl.1.0
+
+%system all
+%endif
+
+f 0444 root sys ${libdir}/libmxml.a libmxml.a
+
+# pkg-config info
+f 0444 root sys $(libdir)/pkgconfig/mxml.pc mxml.pc
+
+# Documentation
+f 0444 root sys ${docdir}/README $srcdir/README
+f 0444 root sys ${docdir}/COPYING $srcdir/COPYING
+f 0444 root sys ${docdir}/CHANGES $srcdir/CHANGES
+f 0444 root sys ${docdir}/mxml.html $srcdir/doc/mxml.html
+f 0444 root sys ${docdir}/mxml.pdf $srcdir/doc/mxml.pdf
+
+# Man pages
+f 0444 root sys ${mandir}/cat1/mxmldoc.$CAT1EXT $srcdir/mxmldoc.$CAT1EXT
+f 0444 root sys ${mandir}/man1/mxmldoc.$MAN1EXT $srcdir/mxmldoc.man
+f 0444 root sys ${mandir}/cat3/mxml.$CAT3EXT $srcdir/mxml.$CAT3EXT
+f 0444 root sys ${mandir}/man3/mxml.$MAN3EXT $srcdir/mxml.man
+
+#
+# End of "$Id$".
+#
--- /dev/null
+prefix=/usr/local
+exec_prefix=/usr/local
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: Mini-XML
+Description: Lightweight XML support library
+Version: 2.2.2
+Libs: -L${exec_prefix}/lib -lmxml
+Cflags: -I${prefix}/include
--- /dev/null
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: Mini-XML
+Description: Lightweight XML support library
+Version: @VERSION@
+Libs: @PC_LIBS@
+Cflags: @PC_CFLAGS@
--- /dev/null
+#
+# "$Id$"
+#
+# RPM "spec" file for Mini-XML, a small XML library.
+#
+# Copyright 2003-2005 by Michael Sweet.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2, or (at your option) any later version.
+#
+# This program 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.
+#
+
+Summary: Miniature XML development library
+Name: mxml
+Version: 2.2.2
+Release: 1
+Copyright: GPL
+Group: Development/Libraries
+Source: http://www.easysw.com/~mike/mxml/mxml-%{version}.tar.gz
+Url: http://www.easysw.com/~mike/mxml/
+Packager: Michael Sweet <mxml@easysw.com>
+Vendor: Michael Sweet
+
+# Use buildroot so as not to disturb the version already installed
+BuildRoot: /var/tmp/%{name}-root
+
+%description
+Mini-XML is a small XML parsing library that you can use to read
+XML and XML-like data files in your application without
+requiring large non-standard libraries. Mini-XML provides the
+following functionality:
+
+ - Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded
+ XML files and strings.
+ - Data is stored in a linked-list tree structure, preserving
+ the XML data hierarchy.
+ - Supports arbitrary element names, attributes, and
+ attribute values with no preset limits, just available
+ memory.
+ - Supports integer, real, opaque ("cdata"), and text data
+ types in "leaf" nodes.
+ - Functions for creating and managing trees of data.
+ - "Find" and "walk" functions for easily locating and
+ navigating trees of data.
+
+Mini-XML doesn't do validation or other types of processing on
+the data based upon schema files or other sources of definition
+information, nor does it support character entities other than
+those required by the XML specification.
+
+%prep
+%setup
+
+%build
+CFLAGS="$RPM_OPT_FLAGS" CXXFLAGS="$RPM_OPT_FLAGS" LDFLAGS="$RPM_OPT_FLAGS" ./configure --enable-shared --prefix=/usr
+
+# If we got this far, all prerequisite libraries must be here.
+make
+
+%install
+# Make sure the RPM_BUILD_ROOT directory exists.
+rm -rf $RPM_BUILD_ROOT
+
+make BUILDROOT=$RPM_BUILD_ROOT install
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root)
+
+%dir /usr/bin
+/usr/bin/*
+%dir /usr/include
+/usr/include/mxml.h
+%dir /usr/lib
+/usr/lib/*
+%dir /usr/lib/pkgconfig
+/usr/lib/pkgconfig/mxml.pc
+%dir /usr/share/doc/mxml
+/usr/share/doc/mxml/*
+%dir /usr/share/man/cat1
+/usr/share/man/cat1/*
+%dir /usr/share/man/cat3
+/usr/share/man/cat3/*
+%dir /usr/share/man/man1
+/usr/share/man/man1/*
+%dir /usr/share/man/man3
+/usr/share/man/man3/*
+
+#
+# End of "$Id$".
+#
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Documentation generator using Mini-XML, a small XML-like file parsing
+ * library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * main() - Main entry for test program.
+ * add_variable() - Add a variable or argument.
+ * safe_strcpy() - Copy a string allowing for overlapping strings.
+ * scan_file() - Scan a source file.
+ * sort_node() - Insert a node sorted into a tree.
+ * update_comment() - Update a comment node.
+ * write_documentation() - Write HTML documentation.
+ * write_element() - Write an elements text nodes.
+ * write_string() - Write a string, quoting XHTML special chars
+ * as needed...
+ * ws_cb() - Whitespace callback for saving.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * This program scans source and header files and produces public API
+ * documentation for code that conforms to the CUPS Configuration
+ * Management Plan (CMP) coding standards. Please see the following web
+ * page for details:
+ *
+ * http://www.cups.org/cmp.html
+ *
+ * Using Mini-XML, this program creates and maintains an XML representation
+ * of the public API code documentation which can then be converted to HTML
+ * as desired. The following is a poor-man's schema:
+ *
+ * <?xml version="1.0"?>
+ * <mxmldoc xmlns="http://www.easysw.com"
+ * xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ * xsi:schemaLocation="http://www.easysw.com/~mike/mxml/mxmldoc.xsd">
+ *
+ * <namespace name=""> [optional...]
+ * <constant name="">
+ * <description>descriptive text</description>
+ * </constant>
+ *
+ * <enumeration name="">
+ * <description>descriptive text</description>
+ * <constant name="">...</constant>
+ * </enumeration>
+ *
+ * <typedef name="">
+ * <description>descriptive text</description>
+ * <type>type string</type>
+ * </typedef>
+ *
+ * <function name="" scope="">
+ * <description>descriptive text</description>
+ * <argument name="" direction="I|O|IO" default="">
+ * <description>descriptive text</description>
+ * <type>type string</type>
+ * </argument>
+ * <returnvalue>
+ * <description>descriptive text</description>
+ * <type>type string</type>
+ * </returnvalue>
+ * <seealso>function names separated by spaces</seealso>
+ * </function>
+ *
+ * <variable name="" scope="">
+ * <description>descriptive text</description>
+ * <type>type string</type>
+ * </variable>
+ *
+ * <struct name="">
+ * <description>descriptive text</description>
+ * <variable name="">...</variable>
+ * <function name="">...</function>
+ * </struct>
+ *
+ * <union name="">
+ * <description>descriptive text</description>
+ * <variable name="">...</variable>
+ * </union>
+ *
+ * <class name="" parent="">
+ * <description>descriptive text</description>
+ * <class name="">...</class>
+ * <enumeration name="">...</enumeration>
+ * <function name="">...</function>
+ * <struct name="">...</struct>
+ * <variable name="">...</variable>
+ * </class>
+ * </namespace>
+ * </mxmldoc>
+ */
+
+
+/*
+ * Basic states for file parser...
+ */
+
+#define STATE_NONE 0 /* No state - whitespace, etc. */
+#define STATE_PREPROCESSOR 1 /* Preprocessor directive */
+#define STATE_C_COMMENT 2 /* Inside a C comment */
+#define STATE_CXX_COMMENT 3 /* Inside a C++ comment */
+#define STATE_STRING 4 /* Inside a string constant */
+#define STATE_CHARACTER 5 /* Inside a character constant */
+#define STATE_IDENTIFIER 6 /* Inside a keyword/identifier */
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t *add_variable(mxml_node_t *parent, const char *name,
+ mxml_node_t *type);
+static void safe_strcpy(char *dst, const char *src);
+static int scan_file(const char *filename, FILE *fp,
+ mxml_node_t *doc);
+static void sort_node(mxml_node_t *tree, mxml_node_t *func);
+static void update_comment(mxml_node_t *parent,
+ mxml_node_t *comment);
+static void write_documentation(mxml_node_t *doc);
+static void write_element(mxml_node_t *doc, mxml_node_t *element);
+static void write_string(const char *s);
+static const char *ws_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int /* O - Exit status */
+main(int argc, /* I - Number of command-line args */
+ char *argv[]) /* I - Command-line args */
+{
+ int i; /* Looping var */
+ FILE *fp; /* File to read */
+ mxml_node_t *doc; /* XML documentation tree */
+ mxml_node_t *mxmldoc; /* mxmldoc node */
+
+
+ /*
+ * Check arguments...
+ */
+
+ if (argc < 2)
+ {
+ fputs("Usage: mxmldoc filename.xml [source files] >filename.html\n", stderr);
+ return (1);
+ }
+
+ /*
+ * Read the XML documentation file, if it exists...
+ */
+
+ if ((fp = fopen(argv[1], "r")) != NULL)
+ {
+ /*
+ * Read the existing XML file...
+ */
+
+ doc = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
+
+ fclose(fp);
+
+ if (!doc)
+ {
+ mxmldoc = NULL;
+
+ fprintf(stderr, "mxmldoc: Unable to read the XML documentation file \"%s\"!\n",
+ argv[1]);
+ }
+ else if ((mxmldoc = mxmlFindElement(doc, doc, "mxmldoc", NULL,
+ NULL, MXML_DESCEND)) == NULL)
+ {
+ fprintf(stderr, "mxmldoc: XML documentation file \"%s\" is missing <mxmldoc> node!!\n",
+ argv[1]);
+
+ mxmlDelete(doc);
+ doc = NULL;
+ }
+ }
+ else
+ {
+ doc = NULL;
+ mxmldoc = NULL;
+ }
+
+ if (!doc)
+ {
+ /*
+ * Create an empty XML documentation file...
+ */
+
+ doc = mxmlNewElement(NULL, "?xml version=\"1.0\"?");
+
+ mxmldoc = mxmlNewElement(doc, "mxmldoc");
+
+#ifdef MXML_INCLUDE_SCHEMA
+ /*
+ * Currently we don't include the schema/namespace stuff with the
+ * XML output since some validators don't seem to like it...
+ */
+
+ mxmlElementSetAttr(mxmldoc, "xmlns", "http://www.easysw.com");
+ mxmlElementSetAttr(mxmldoc, "xmlns:xsi",
+ "http://www.w3.org/2001/XMLSchema-instance");
+ mxmlElementSetAttr(mxmldoc, "xsi:schemaLocation",
+ "http://www.easysw.com/~mike/mxml/mxmldoc.xsd");
+#endif /* MXML_INCLUDE_SCHEMA */
+ }
+
+ /*
+ * Loop through all of the source files...
+ */
+
+ for (i = 2; i < argc; i ++)
+ if ((fp = fopen(argv[i], "r")) == NULL)
+ {
+ fprintf(stderr, "Unable to open source file \"%s\": %s\n", argv[i],
+ strerror(errno));
+ mxmlDelete(doc);
+ return (1);
+ }
+ else if (scan_file(argv[i], fp, mxmldoc))
+ {
+ fclose(fp);
+ mxmlDelete(doc);
+ return (1);
+ }
+ else
+ fclose(fp);
+
+ if (argc > 2)
+ {
+ /*
+ * Save the updated XML documentation file...
+ */
+
+ if ((fp = fopen(argv[1], "w")) != NULL)
+ {
+ /*
+ * Write over the existing XML file...
+ */
+
+ if (mxmlSaveFile(doc, fp, ws_cb))
+ {
+ fprintf(stderr, "Unable to write the XML documentation file \"%s\": %s!\n",
+ argv[1], strerror(errno));
+ fclose(fp);
+ mxmlDelete(doc);
+ return (1);
+ }
+
+ fclose(fp);
+ }
+ else
+ {
+ fprintf(stderr, "Unable to create the XML documentation file \"%s\": %s!\n",
+ argv[1], strerror(errno));
+ mxmlDelete(doc);
+ return (1);
+ }
+ }
+
+ /*
+ * Write HTML documentation...
+ */
+
+ write_documentation(mxmldoc);
+
+ /*
+ * Delete the tree and return...
+ */
+
+ mxmlDelete(doc);
+
+ return (0);
+}
+
+
+/*
+ * 'add_variable()' - Add a variable or argument.
+ */
+
+static mxml_node_t * /* O - New variable/argument */
+add_variable(mxml_node_t *parent, /* I - Parent node */
+ const char *name, /* I - "argument" or "variable" */
+ mxml_node_t *type) /* I - Type nodes */
+{
+ mxml_node_t *variable, /* New variable */
+ *node, /* Current node */
+ *next; /* Next node */
+ char buffer[16384], /* String buffer */
+ *bufptr; /* Pointer into buffer */
+
+
+ /*
+ * Range check input...
+ */
+
+ if (!type || !type->child)
+ return (NULL);
+
+ /*
+ * Create the variable/argument node...
+ */
+
+ variable = mxmlNewElement(parent, name);
+
+ /*
+ * Check for a default value...
+ */
+
+ for (node = type->child; node; node = node->next)
+ if (!strcmp(node->value.text.string, "="))
+ break;
+
+ if (node)
+ {
+ /*
+ * Default value found, copy it and add as a "default" attribute...
+ */
+
+ for (bufptr = buffer; node; bufptr += strlen(bufptr))
+ {
+ if (node->value.text.whitespace && bufptr > buffer)
+ *bufptr++ = ' ';
+
+ strcpy(bufptr, node->value.text.string);
+
+ next = node->next;
+ mxmlDelete(node);
+ node = next;
+ }
+
+ mxmlElementSetAttr(variable, "default", buffer);
+ }
+
+ /*
+ * Extract the argument/variable name...
+ */
+
+ if (type->last_child->value.text.string[0] == ')')
+ {
+ /*
+ * Handle "type (*name)(args)"...
+ */
+
+ for (node = type->child; node; node = node->next)
+ if (node->value.text.string[0] == '(')
+ break;
+
+ for (bufptr = buffer; node; bufptr += strlen(bufptr))
+ {
+ if (node->value.text.whitespace && bufptr > buffer)
+ *bufptr++ = ' ';
+
+ strcpy(bufptr, node->value.text.string);
+
+ next = node->next;
+ mxmlDelete(node);
+ node = next;
+ }
+ }
+ else
+ {
+ /*
+ * Handle "type name"...
+ */
+
+ strcpy(buffer, type->last_child->value.text.string);
+ mxmlDelete(type->last_child);
+ }
+
+ /*
+ * Set the name...
+ */
+
+ mxmlElementSetAttr(variable, "name", buffer);
+
+ /*
+ * Add the remaining type information to the variable node...
+ */
+
+ mxmlAdd(variable, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+ /*
+ * Add new new variable node...
+ */
+
+ return (variable);
+}
+
+
+/*
+ * 'safe_strcpy()' - Copy a string allowing for overlapping strings.
+ */
+
+static void
+safe_strcpy(char *dst, /* I - Destination string */
+ const char *src) /* I - Source string */
+{
+ while (*src)
+ *dst++ = *src++;
+
+ *dst = '\0';
+}
+
+
+/*
+ * 'scan_file()' - Scan a source file.
+ */
+
+static int /* O - 0 on success, -1 on error */
+scan_file(const char *filename, /* I - Filename */
+ FILE *fp, /* I - File to scan */
+ mxml_node_t *tree) /* I - Function tree */
+{
+ int state, /* Current parser state */
+ braces, /* Number of braces active */
+ parens; /* Number of active parenthesis */
+ int ch; /* Current character */
+ char buffer[65536], /* String buffer */
+ *bufptr; /* Pointer into buffer */
+ const char *scope; /* Current variable/function scope */
+ mxml_node_t *comment, /* <comment> node */
+ *constant, /* <constant> node */
+ *enumeration, /* <enumeration> node */
+ *function, /* <function> node */
+ *fstructclass, /* function struct/class node */
+ *structclass, /* <struct> or <class> node */
+ *typedefnode, /* <typedef> node */
+ *variable, /* <variable> or <argument> node */
+ *returnvalue, /* <returnvalue> node */
+ *type, /* <type> node */
+ *description, /* <description> node */
+ *node, /* Current node */
+ *next; /* Next node */
+#if DEBUG > 1
+ mxml_node_t *temp; /* Temporary node */
+ int oldstate, /* Previous state */
+ oldch; /* Old character */
+ static const char *states[] = /* State strings */
+ {
+ "STATE_NONE",
+ "STATE_PREPROCESSOR",
+ "STATE_C_COMMENT",
+ "STATE_CXX_COMMENT",
+ "STATE_STRING",
+ "STATE_CHARACTER",
+ "STATE_IDENTIFIER"
+ };
+#endif /* DEBUG > 1 */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "scan_file(filename=\"%s\", fp=%p, tree=%p)\n", filename,
+ fp, tree);
+#endif // DEBUG
+
+ /*
+ * Initialize the finite state machine...
+ */
+
+ state = STATE_NONE;
+ braces = 0;
+ parens = 0;
+ bufptr = buffer;
+
+ comment = mxmlNewElement(MXML_NO_PARENT, "temp");
+ constant = NULL;
+ enumeration = NULL;
+ function = NULL;
+ variable = NULL;
+ returnvalue = NULL;
+ type = NULL;
+ description = NULL;
+ typedefnode = NULL;
+ structclass = NULL;
+ fstructclass = NULL;
+
+ if (!strcmp(tree->value.element.name, "class"))
+ scope = "private";
+ else
+ scope = NULL;
+
+ /*
+ * Read until end-of-file...
+ */
+
+ while ((ch = getc(fp)) != EOF)
+ {
+#if DEBUG > 1
+ oldstate = state;
+ oldch = ch;
+#endif /* DEBUG > 1 */
+
+ switch (state)
+ {
+ case STATE_NONE : /* No state - whitespace, etc. */
+ switch (ch)
+ {
+ case '/' : /* Possible C/C++ comment */
+ ch = getc(fp);
+ bufptr = buffer;
+
+ if (ch == '*')
+ state = STATE_C_COMMENT;
+ else if (ch == '/')
+ state = STATE_CXX_COMMENT;
+ else
+ {
+ ungetc(ch, fp);
+
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< / >>>\n", stderr);
+#endif /* DEBUG */
+ ch = type->last_child->value.text.string[0];
+ mxmlNewText(type, isalnum(ch) || ch == '_', "/");
+ }
+ }
+ break;
+
+ case '#' : /* Preprocessor */
+#ifdef DEBUG
+ fputs(" #preprocessor...\n", stderr);
+#endif /* DEBUG */
+ state = STATE_PREPROCESSOR;
+ break;
+
+ case '\'' : /* Character constant */
+ state = STATE_CHARACTER;
+ bufptr = buffer;
+ *bufptr++ = ch;
+ break;
+
+ case '\"' : /* String constant */
+ state = STATE_STRING;
+ bufptr = buffer;
+ *bufptr++ = ch;
+ break;
+
+ case '{' :
+#ifdef DEBUG
+ fprintf(stderr, " open brace, function=%p, type=%p...\n",
+ function, type);
+ if (type)
+ fprintf(stderr, " type->child=\"%s\"...\n",
+ type->child->value.text.string);
+#endif /* DEBUG */
+
+ if (function)
+ {
+ if (fstructclass)
+ {
+ sort_node(fstructclass, function);
+ fstructclass = NULL;
+ }
+ else
+ sort_node(tree, function);
+
+ function = NULL;
+ }
+ else if (type && type->child &&
+ ((!strcmp(type->child->value.text.string, "typedef") &&
+ type->child->next &&
+ (!strcmp(type->child->next->value.text.string, "struct") ||
+ !strcmp(type->child->next->value.text.string, "union") ||
+ !strcmp(type->child->next->value.text.string, "class"))) ||
+ !strcmp(type->child->value.text.string, "union") ||
+ !strcmp(type->child->value.text.string, "struct") ||
+ !strcmp(type->child->value.text.string, "class")))
+ {
+ /*
+ * Start of a class or structure...
+ */
+
+ if (!strcmp(type->child->value.text.string, "typedef"))
+ {
+#ifdef DEBUG
+ fputs(" starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+ typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+ mxmlDelete(type->child);
+ }
+ else
+ typedefnode = NULL;
+
+ structclass = mxmlNewElement(MXML_NO_PARENT,
+ type->child->value.text.string);
+
+#ifdef DEBUG
+ fprintf(stderr, "%c%s: <<<< %s >>>\n",
+ toupper(type->child->value.text.string[0]),
+ type->child->value.text.string + 1,
+ type->child->next ?
+ type->child->next->value.text.string : "(noname)");
+
+ fputs(" type =", stderr);
+ for (node = type->child; node; node = node->next)
+ fprintf(stderr, " \"%s\"", node->value.text.string);
+ putc('\n', stderr);
+
+ fprintf(stderr, " scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+ if (comment->last_child &&
+ strstr(comment->last_child->value.text.string, "@private"))
+ {
+ mxmlDelete(type);
+ type = NULL;
+
+ if (typedefnode)
+ {
+ mxmlDelete(typedefnode);
+ typedefnode = NULL;
+ }
+
+ mxmlDelete(structclass);
+ structclass = NULL;
+
+ braces ++;
+ function = NULL;
+ variable = NULL;
+ break;
+ }
+
+ if (type->child->next)
+ {
+ mxmlElementSetAttr(structclass, "name",
+ type->child->next->value.text.string);
+ sort_node(tree, structclass);
+ }
+
+ if (typedefnode && type->child)
+ type->child->value.text.whitespace = 0;
+ else if (structclass && type->child &&
+ type->child->next && type->child->next->next)
+ {
+ for (bufptr = buffer, node = type->child->next->next;
+ node;
+ bufptr += strlen(bufptr))
+ {
+ if (node->value.text.whitespace && bufptr > buffer)
+ *bufptr++ = ' ';
+
+ strcpy(bufptr, node->value.text.string);
+
+ next = node->next;
+ mxmlDelete(node);
+ node = next;
+ }
+
+ mxmlElementSetAttr(structclass, "parent", buffer);
+
+ mxmlDelete(type);
+ type = NULL;
+ }
+ else
+ {
+ mxmlDelete(type);
+ type = NULL;
+ }
+
+ if (typedefnode && comment->last_child)
+ {
+ /*
+ * Copy comment for typedef as well as class/struct/union...
+ */
+
+ mxmlNewText(comment, 0,
+ comment->last_child->value.text.string);
+ description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+ fputs(" duplicating comment for typedef...\n", stderr);
+#endif /* DEBUG */
+ update_comment(typedefnode, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+ }
+
+ description = mxmlNewElement(structclass, "description");
+#ifdef DEBUG
+ fprintf(stderr, " adding comment to %s...\n",
+ structclass->value.element.name);
+#endif /* DEBUG */
+ update_comment(structclass, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+
+ if (scan_file(filename, fp, structclass))
+ {
+ mxmlDelete(comment);
+ return (-1);
+ }
+
+#ifdef DEBUG
+ fputs(" ended typedef...\n", stderr);
+#endif /* DEBUG */
+ structclass = NULL;
+ break;
+ }
+ else if (type && type->child && type->child->next &&
+ (!strcmp(type->child->value.text.string, "enum") ||
+ (!strcmp(type->child->value.text.string, "typedef") &&
+ !strcmp(type->child->next->value.text.string, "enum"))))
+ {
+ /*
+ * Enumeration type...
+ */
+
+ if (!strcmp(type->child->value.text.string, "typedef"))
+ {
+#ifdef DEBUG
+ fputs(" starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+ typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+ mxmlDelete(type->child);
+ }
+ else
+ typedefnode = NULL;
+
+ enumeration = mxmlNewElement(MXML_NO_PARENT, "enumeration");
+
+#ifdef DEBUG
+ fprintf(stderr, "Enumeration: <<<< %s >>>\n",
+ type->child->next ?
+ type->child->next->value.text.string : "(noname)");
+#endif /* DEBUG */
+
+ if (type->child->next)
+ {
+ mxmlElementSetAttr(enumeration, "name",
+ type->child->next->value.text.string);
+ sort_node(tree, enumeration);
+ }
+
+ if (typedefnode && type->child)
+ type->child->value.text.whitespace = 0;
+ else
+ {
+ mxmlDelete(type);
+ type = NULL;
+ }
+
+ if (typedefnode && comment->last_child)
+ {
+ /*
+ * Copy comment for typedef as well as class/struct/union...
+ */
+
+ mxmlNewText(comment, 0,
+ comment->last_child->value.text.string);
+ description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+ fputs(" duplicating comment for typedef...\n", stderr);
+#endif /* DEBUG */
+ update_comment(typedefnode, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+ }
+
+ description = mxmlNewElement(enumeration, "description");
+#ifdef DEBUG
+ fputs(" adding comment to enumeration...\n", stderr);
+#endif /* DEBUG */
+ update_comment(enumeration, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+ }
+ else if (type && type->child &&
+ !strcmp(type->child->value.text.string, "extern"))
+ {
+ if (scan_file(filename, fp, tree))
+ {
+ mxmlDelete(comment);
+ return (-1);
+ }
+ }
+ else if (type)
+ {
+ mxmlDelete(type);
+ type = NULL;
+ }
+
+ braces ++;
+ function = NULL;
+ variable = NULL;
+ break;
+
+ case '}' :
+#ifdef DEBUG
+ fputs(" close brace...\n", stderr);
+#endif /* DEBUG */
+
+ if (structclass)
+ scope = NULL;
+
+ enumeration = NULL;
+ constant = NULL;
+ structclass = NULL;
+
+ if (braces > 0)
+ braces --;
+ else
+ {
+ mxmlDelete(comment);
+ return (0);
+ }
+ break;
+
+ case '(' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< ( >>>\n", stderr);
+#endif /* DEBUG */
+ mxmlNewText(type, 0, "(");
+ }
+
+ parens ++;
+ break;
+
+ case ')' :
+ if (parens > 0)
+ parens --;
+
+ if (type && parens)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< ) >>>\n", stderr);
+#endif /* DEBUG */
+ mxmlNewText(type, 0, ")");
+ }
+
+ if (function && type && !parens)
+ {
+ variable = add_variable(function, "argument", type);
+ type = NULL;
+ }
+ break;
+
+ case ';' :
+#ifdef DEBUG
+ fputs("Identifier: <<<< ; >>>\n", stderr);
+ fprintf(stderr, " function=%p, type=%p\n", function, type);
+#endif /* DEBUG */
+
+ if (function)
+ {
+ if (!strcmp(tree->value.element.name, "class"))
+ {
+#ifdef DEBUG
+ fputs(" ADDING FUNCTION TO CLASS\n", stderr);
+#endif /* DEBUG */
+ sort_node(tree, function);
+ }
+ else
+ mxmlDelete(function);
+
+ function = NULL;
+ variable = NULL;
+ }
+
+ if (type)
+ {
+ mxmlDelete(type);
+ type = NULL;
+ }
+ break;
+
+ case ':' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< : >>>\n", stderr);
+#endif /* DEBUG */
+ mxmlNewText(type, 1, ":");
+ }
+ break;
+
+ case '*' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< * >>>\n", stderr);
+#endif /* DEBUG */
+ ch = type->last_child->value.text.string[0];
+ mxmlNewText(type, isalnum(ch) || ch == '_', "*");
+ }
+ break;
+
+ case '&' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< & >>>\n", stderr);
+#endif /* DEBUG */
+ mxmlNewText(type, 1, "&");
+ }
+ break;
+
+ case '+' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< + >>>\n", stderr);
+#endif /* DEBUG */
+ ch = type->last_child->value.text.string[0];
+ mxmlNewText(type, isalnum(ch) || ch == '_', "+");
+ }
+ break;
+
+ case '-' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< - >>>\n", stderr);
+#endif /* DEBUG */
+ ch = type->last_child->value.text.string[0];
+ mxmlNewText(type, isalnum(ch) || ch == '_', "-");
+ }
+ break;
+
+ case '=' :
+ if (type)
+ {
+#ifdef DEBUG
+ fputs("Identifier: <<<< = >>>\n", stderr);
+#endif /* DEBUG */
+ ch = type->last_child->value.text.string[0];
+ mxmlNewText(type, isalnum(ch) || ch == '_', "=");
+ }
+ break;
+
+ default : /* Other */
+ if (isalnum(ch) || ch == '_' || ch == '.' || ch == ':' || ch == '~')
+ {
+ state = STATE_IDENTIFIER;
+ bufptr = buffer;
+ *bufptr++ = ch;
+ }
+ break;
+ }
+ break;
+
+ case STATE_PREPROCESSOR : /* Preprocessor directive */
+ if (ch == '\n')
+ state = STATE_NONE;
+ else if (ch == '\\')
+ getc(fp);
+ break;
+
+ case STATE_C_COMMENT : /* Inside a C comment */
+ switch (ch)
+ {
+ case '\n' :
+ while ((ch = getc(fp)) != EOF)
+ if (ch == '*')
+ {
+ ch = getc(fp);
+
+ if (ch == '/')
+ {
+ *bufptr = '\0';
+
+ if (comment->child != comment->last_child)
+ {
+#ifdef DEBUG
+ fprintf(stderr, " removing comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ mxmlDelete(comment->child);
+#ifdef DEBUG
+ fprintf(stderr, " new comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ }
+
+#ifdef DEBUG
+ fprintf(stderr, " processing comment, variable=%p, constant=%p, tree=\"%s\"\n",
+ variable, constant, tree->value.element.name);
+#endif /* DEBUG */
+
+ if (variable)
+ {
+ description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+ fputs(" adding comment to variable...\n", stderr);
+#endif /* DEBUG */
+ update_comment(variable,
+ mxmlNewText(description, 0, buffer));
+ variable = NULL;
+ }
+ else if (constant)
+ {
+ description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+ fputs(" adding comment to constant...\n", stderr);
+#endif /* DEBUG */
+ update_comment(constant,
+ mxmlNewText(description, 0, buffer));
+ constant = NULL;
+ }
+ else if (typedefnode)
+ {
+ description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+ fprintf(stderr, " adding comment to typedef %s...\n",
+ mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+ update_comment(typedefnode,
+ mxmlNewText(description, 0, buffer));
+ }
+ else if (strcmp(tree->value.element.name, "mxmldoc") &&
+ !mxmlFindElement(tree, tree, "description",
+ NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+ fputs(" adding comment to parent...\n", stderr);
+#endif /* DEBUG */
+ update_comment(tree,
+ mxmlNewText(description, 0, buffer));
+ }
+ else
+ {
+#ifdef DEBUG
+ fprintf(stderr, " before adding comment, child=%p, last_child=%p\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ mxmlNewText(comment, 0, buffer);
+#ifdef DEBUG
+ fprintf(stderr, " after adding comment, child=%p, last_child=%p\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ }
+#ifdef DEBUG
+ fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+ state = STATE_NONE;
+ break;
+ }
+ else
+ ungetc(ch, fp);
+ }
+ else if (ch == '\n' && bufptr > buffer &&
+ bufptr < (buffer + sizeof(buffer) - 1))
+ *bufptr++ = ch;
+ else if (!isspace(ch))
+ break;
+
+ if (ch != EOF)
+ ungetc(ch, fp);
+
+ if (bufptr > buffer && bufptr < (buffer + sizeof(buffer) - 1))
+ *bufptr++ = '\n';
+ break;
+
+ case '/' :
+ if (ch == '/' && bufptr > buffer && bufptr[-1] == '*')
+ {
+ while (bufptr > buffer &&
+ (bufptr[-1] == '*' || isspace(bufptr[-1] & 255)))
+ bufptr --;
+ *bufptr = '\0';
+
+ if (comment->child != comment->last_child)
+ {
+#ifdef DEBUG
+ fprintf(stderr, " removing comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ mxmlDelete(comment->child);
+#ifdef DEBUG
+ fprintf(stderr, " new comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ }
+
+ if (variable)
+ {
+ description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+ fputs(" adding comment to variable...\n", stderr);
+#endif /* DEBUG */
+ update_comment(variable,
+ mxmlNewText(description, 0, buffer));
+ variable = NULL;
+ }
+ else if (constant)
+ {
+ description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+ fputs(" adding comment to constant...\n", stderr);
+#endif /* DEBUG */
+ update_comment(constant,
+ mxmlNewText(description, 0, buffer));
+ constant = NULL;
+ }
+ else if (typedefnode)
+ {
+ description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+ fprintf(stderr, " adding comment to typedef %s...\n",
+ mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+ update_comment(typedefnode,
+ mxmlNewText(description, 0, buffer));
+ }
+ else if (strcmp(tree->value.element.name, "mxmldoc") &&
+ !mxmlFindElement(tree, tree, "description",
+ NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+ fputs(" adding comment to parent...\n", stderr);
+#endif /* DEBUG */
+ update_comment(tree,
+ mxmlNewText(description, 0, buffer));
+ }
+ else
+ mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+ fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+ state = STATE_NONE;
+ break;
+ }
+
+ default :
+ if (ch == ' ' && bufptr == buffer)
+ break;
+
+ if (bufptr < (buffer + sizeof(buffer) - 1))
+ *bufptr++ = ch;
+ break;
+ }
+ break;
+
+ case STATE_CXX_COMMENT : /* Inside a C++ comment */
+ if (ch == '\n')
+ {
+ state = STATE_NONE;
+ *bufptr = '\0';
+
+ if (comment->child != comment->last_child)
+ {
+#ifdef DEBUG
+ fprintf(stderr, " removing comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ mxmlDelete(comment->child);
+#ifdef DEBUG
+ fprintf(stderr, " new comment %p, last comment %p...\n",
+ comment->child, comment->last_child);
+#endif /* DEBUG */
+ }
+
+ if (variable)
+ {
+ description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+ fputs(" adding comment to variable...\n", stderr);
+#endif /* DEBUG */
+ update_comment(variable,
+ mxmlNewText(description, 0, buffer));
+ variable = NULL;
+ }
+ else if (constant)
+ {
+ description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+ fputs(" adding comment to constant...\n", stderr);
+#endif /* DEBUG */
+ update_comment(constant,
+ mxmlNewText(description, 0, buffer));
+ constant = NULL;
+ }
+ else if (typedefnode)
+ {
+ description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+ fprintf(stderr, " adding comment to typedef %s...\n",
+ mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+ update_comment(typedefnode,
+ mxmlNewText(description, 0, buffer));
+ }
+ else if (strcmp(tree->value.element.name, "mxmldoc") &&
+ !mxmlFindElement(tree, tree, "description",
+ NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+ fputs(" adding comment to parent...\n", stderr);
+#endif /* DEBUG */
+ update_comment(tree,
+ mxmlNewText(description, 0, buffer));
+ }
+ else
+ mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+ fprintf(stderr, "C++ comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+ }
+ else if (ch == ' ' && bufptr == buffer)
+ break;
+ else if (bufptr < (buffer + sizeof(buffer) - 1))
+ *bufptr++ = ch;
+ break;
+
+ case STATE_STRING : /* Inside a string constant */
+ *bufptr++ = ch;
+
+ if (ch == '\\')
+ *bufptr++ = getc(fp);
+ else if (ch == '\"')
+ {
+ *bufptr = '\0';
+
+ if (type)
+ mxmlNewText(type, type->child != NULL, buffer);
+
+ state = STATE_NONE;
+ }
+ break;
+
+ case STATE_CHARACTER : /* Inside a character constant */
+ *bufptr++ = ch;
+
+ if (ch == '\\')
+ *bufptr++ = getc(fp);
+ else if (ch == '\'')
+ {
+ *bufptr = '\0';
+
+ if (type)
+ mxmlNewText(type, type->child != NULL, buffer);
+
+ state = STATE_NONE;
+ }
+ break;
+
+ case STATE_IDENTIFIER : /* Inside a keyword or identifier */
+ if (isalnum(ch) || ch == '_' || ch == '[' || ch == ']' ||
+ (ch == ',' && parens > 1) || ch == ':' || ch == '.' || ch == '~')
+ {
+ if (bufptr < (buffer + sizeof(buffer) - 1))
+ *bufptr++ = ch;
+ }
+ else
+ {
+ ungetc(ch, fp);
+ *bufptr = '\0';
+ state = STATE_NONE;
+
+#ifdef DEBUG
+ fprintf(stderr, " braces=%d, type=%p, type->child=%p, buffer=\"%s\"\n",
+ braces, type, type ? type->child : NULL, buffer);
+#endif /* DEBUG */
+
+ if (!braces)
+ {
+ if (!type || !type->child)
+ {
+ if (!strcmp(tree->value.element.name, "class"))
+ {
+ if (!strcmp(buffer, "public") ||
+ !strcmp(buffer, "public:"))
+ {
+ scope = "public";
+#ifdef DEBUG
+ fputs(" scope = public\n", stderr);
+#endif /* DEBUG */
+ break;
+ }
+ else if (!strcmp(buffer, "private") ||
+ !strcmp(buffer, "private:"))
+ {
+ scope = "private";
+#ifdef DEBUG
+ fputs(" scope = private\n", stderr);
+#endif /* DEBUG */
+ break;
+ }
+ else if (!strcmp(buffer, "protected") ||
+ !strcmp(buffer, "protected:"))
+ {
+ scope = "protected";
+#ifdef DEBUG
+ fputs(" scope = protected\n", stderr);
+#endif /* DEBUG */
+ break;
+ }
+ }
+ }
+
+ if (!type)
+ type = mxmlNewElement(MXML_NO_PARENT, "type");
+
+#ifdef DEBUG
+ fprintf(stderr, " function=%p (%s), type->child=%p, ch='%c', parens=%d\n",
+ function,
+ function ? mxmlElementGetAttr(function, "name") : "null",
+ type->child, ch, parens);
+#endif /* DEBUG */
+
+ if (!function && ch == '(')
+ {
+ if (type->child &&
+ !strcmp(type->child->value.text.string, "extern"))
+ {
+ /*
+ * Remove external declarations...
+ */
+
+ mxmlDelete(type);
+ type = NULL;
+ break;
+ }
+
+ if (type->child &&
+ !strcmp(type->child->value.text.string, "static") &&
+ !strcmp(tree->value.element.name, "mxmldoc"))
+ {
+ /*
+ * Remove static functions...
+ */
+
+ mxmlDelete(type);
+ type = NULL;
+ break;
+ }
+
+ function = mxmlNewElement(MXML_NO_PARENT, "function");
+ if ((bufptr = strchr(buffer, ':')) != NULL && bufptr[1] == ':')
+ {
+ *bufptr = '\0';
+ bufptr += 2;
+
+ if ((fstructclass =
+ mxmlFindElement(tree, tree, "class", "name", buffer,
+ MXML_DESCEND_FIRST)) == NULL)
+ fstructclass =
+ mxmlFindElement(tree, tree, "struct", "name", buffer,
+ MXML_DESCEND_FIRST);
+ }
+ else
+ bufptr = buffer;
+
+ mxmlElementSetAttr(function, "name", bufptr);
+
+ if (scope)
+ mxmlElementSetAttr(function, "scope", scope);
+
+#ifdef DEBUG
+ fprintf(stderr, "function: %s\n", buffer);
+ fprintf(stderr, " scope = %s\n", scope ? scope : "(null)");
+ fprintf(stderr, " comment = %p\n", comment);
+ fprintf(stderr, " child = (%p) %s\n",
+ comment->child,
+ comment->child ?
+ comment->child->value.text.string : "(null)");
+ fprintf(stderr, " last_child = (%p) %s\n",
+ comment->last_child,
+ comment->last_child ?
+ comment->last_child->value.text.string : "(null)");
+#endif /* DEBUG */
+
+ if (type->last_child &&
+ strcmp(type->last_child->value.text.string, "void"))
+ {
+ returnvalue = mxmlNewElement(function, "returnvalue");
+
+ mxmlAdd(returnvalue, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+ description = mxmlNewElement(returnvalue, "description");
+#ifdef DEBUG
+ fputs(" adding comment to returnvalue...\n", stderr);
+#endif /* DEBUG */
+ update_comment(returnvalue, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+ }
+ else
+ mxmlDelete(type);
+
+ description = mxmlNewElement(function, "description");
+#ifdef DEBUG
+ fputs(" adding comment to function...\n", stderr);
+#endif /* DEBUG */
+ update_comment(function, comment->last_child);
+ mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+ comment->last_child);
+
+ type = NULL;
+ }
+ else if (function && ((ch == ')' && parens == 1) || ch == ','))
+ {
+ /*
+ * Argument definition...
+ */
+
+ mxmlNewText(type, type->child != NULL &&
+ type->last_child->value.text.string[0] != '(' &&
+ type->last_child->value.text.string[0] != '*',
+ buffer);
+
+#ifdef DEBUG
+ fprintf(stderr, "Argument: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+ variable = add_variable(function, "argument", type);
+ type = NULL;
+ }
+ else if (type->child && !function && (ch == ';' || ch == ','))
+ {
+#ifdef DEBUG
+ fprintf(stderr, " got semicolon, typedefnode=%p, structclass=%p\n",
+ typedefnode, structclass);
+#endif /* DEBUG */
+
+ if (typedefnode || structclass)
+ {
+#ifdef DEBUG
+ fprintf(stderr, "Typedef/struct/class: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+ if (typedefnode)
+ {
+ mxmlElementSetAttr(typedefnode, "name", buffer);
+
+ sort_node(tree, typedefnode);
+ }
+
+ if (structclass && !mxmlElementGetAttr(structclass, "name"))
+ {
+#ifdef DEBUG
+ fprintf(stderr, "setting struct/class name to %s!\n",
+ type->last_child->value.text.string);
+#endif /* DEBUG */
+ mxmlElementSetAttr(structclass, "name", buffer);
+
+ sort_node(tree, structclass);
+ structclass = NULL;
+ }
+
+ if (typedefnode)
+ mxmlAdd(typedefnode, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT,
+ type);
+ else
+ mxmlDelete(type);
+
+ type = NULL;
+ typedefnode = NULL;
+ }
+ else if (type->child &&
+ !strcmp(type->child->value.text.string, "typedef"))
+ {
+ /*
+ * Simple typedef...
+ */
+
+#ifdef DEBUG
+ fprintf(stderr, "Typedef: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+ typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+ mxmlElementSetAttr(typedefnode, "name", buffer);
+ mxmlDelete(type->child);
+
+ sort_node(tree, typedefnode);
+
+ if (type->child)
+ type->child->value.text.whitespace = 0;
+
+ mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+ type = NULL;
+ }
+ else if (!parens)
+ {
+ /*
+ * Variable definition...
+ */
+
+ if (type->child &&
+ !strcmp(type->child->value.text.string, "static") &&
+ !strcmp(tree->value.element.name, "mxmldoc"))
+ {
+ /*
+ * Remove static functions...
+ */
+
+ mxmlDelete(type);
+ type = NULL;
+ break;
+ }
+
+ mxmlNewText(type, type->child != NULL &&
+ type->last_child->value.text.string[0] != '(' &&
+ type->last_child->value.text.string[0] != '*',
+ buffer);
+
+#ifdef DEBUG
+ fprintf(stderr, "Variable: <<<< %s >>>>\n", buffer);
+ fprintf(stderr, " scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+ variable = add_variable(MXML_NO_PARENT, "variable", type);
+ type = NULL;
+
+ sort_node(tree, variable);
+
+ if (scope)
+ mxmlElementSetAttr(variable, "scope", scope);
+ }
+ }
+ else
+ {
+#ifdef DEBUG
+ fprintf(stderr, "Identifier: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+ mxmlNewText(type, type->child != NULL &&
+ type->last_child->value.text.string[0] != '(' &&
+ type->last_child->value.text.string[0] != '*',
+ buffer);
+ }
+ }
+ else if (enumeration && !isdigit(buffer[0] & 255))
+ {
+#ifdef DEBUG
+ fprintf(stderr, "Constant: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+ constant = mxmlNewElement(MXML_NO_PARENT, "constant");
+ mxmlElementSetAttr(constant, "name", buffer);
+ sort_node(enumeration, constant);
+ }
+ else if (type)
+ {
+ mxmlDelete(type);
+ type = NULL;
+ }
+ }
+ break;
+ }
+
+#if DEBUG > 1
+ if (state != oldstate)
+ {
+ fprintf(stderr, " changed states from %s to %s on receipt of character '%c'...\n",
+ states[oldstate], states[state], oldch);
+ fprintf(stderr, " variable = %p\n", variable);
+ if (type)
+ {
+ fputs(" type =", stderr);
+ for (temp = type->child; temp; temp = temp->next)
+ fprintf(stderr, " \"%s\"", temp->value.text.string);
+ fputs("\n", stderr);
+ }
+ }
+#endif /* DEBUG > 1 */
+ }
+
+ mxmlDelete(comment);
+
+ /*
+ * All done, return with no errors...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'sort_node()' - Insert a node sorted into a tree.
+ */
+
+static void
+sort_node(mxml_node_t *tree, /* I - Tree to sort into */
+ mxml_node_t *node) /* I - Node to add */
+{
+ mxml_node_t *temp; /* Current node */
+ const char *tempname, /* Name of current node */
+ *nodename, /* Name of node */
+ *scope; /* Scope */
+
+
+#if DEBUG > 1
+ fprintf(stderr, " sort_node(tree=%p, node=%p)\n", tree, node);
+#endif /* DEBUG > 1 */
+
+ /*
+ * Range check input...
+ */
+
+ if (!tree || !node || node->parent == tree)
+ return;
+
+ /*
+ * Get the node name...
+ */
+
+ if ((nodename = mxmlElementGetAttr(node, "name")) == NULL)
+ return;
+
+#if DEBUG > 1
+ fprintf(stderr, " nodename=%p (\"%s\")\n", nodename, nodename);
+#endif /* DEBUG > 1 */
+
+ /*
+ * Delete any existing definition at this level, if one exists...
+ */
+
+ if ((temp = mxmlFindElement(tree, tree, node->value.element.name,
+ "name", nodename, MXML_DESCEND_FIRST)) != NULL)
+ {
+ /*
+ * Copy the scope if needed...
+ */
+
+ if ((scope = mxmlElementGetAttr(temp, "scope")) != NULL &&
+ mxmlElementGetAttr(node, "scope") == NULL)
+ {
+#ifdef DEBUG
+ fprintf(stderr, " copying scope %s for %s\n", scope, nodename);
+#endif /* DEBUG */
+
+ mxmlElementSetAttr(node, "scope", scope);
+ }
+
+ mxmlDelete(temp);
+ }
+
+ /*
+ * Add the node into the tree at the proper place...
+ */
+
+ for (temp = tree->child; temp; temp = temp->next)
+ {
+#if DEBUG > 1
+ fprintf(stderr, " temp=%p\n", temp);
+#endif /* DEBUG > 1 */
+
+ if ((tempname = mxmlElementGetAttr(temp, "name")) == NULL)
+ continue;
+
+#if DEBUG > 1
+ fprintf(stderr, " tempname=%p (\"%s\")\n", tempname, tempname);
+#endif /* DEBUG > 1 */
+
+ if (strcmp(nodename, tempname) < 0)
+ break;
+ }
+
+ if (temp)
+ mxmlAdd(tree, MXML_ADD_BEFORE, temp, node);
+ else
+ mxmlAdd(tree, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+}
+
+
+/*
+ * 'update_comment()' - Update a comment node.
+ */
+
+static void
+update_comment(mxml_node_t *parent, /* I - Parent node */
+ mxml_node_t *comment) /* I - Comment node */
+{
+ char *ptr; /* Pointer into comment */
+
+
+#ifdef DEBUG
+ fprintf(stderr, "update_comment(parent=%p, comment=%p)\n",
+ parent, comment);
+#endif /* DEBUG */
+
+ /*
+ * Range check the input...
+ */
+
+ if (!parent || !comment)
+ return;
+
+ /*
+ * Update the comment...
+ */
+
+ ptr = comment->value.text.string;
+
+ if (*ptr == '\'')
+ {
+ /*
+ * Convert "'name()' - description" to "description".
+ */
+
+ for (ptr ++; *ptr && *ptr != '\''; ptr ++);
+
+ if (*ptr == '\'')
+ {
+ ptr ++;
+ while (isspace(*ptr & 255))
+ ptr ++;
+
+ if (*ptr == '-')
+ ptr ++;
+
+ while (isspace(*ptr & 255))
+ ptr ++;
+
+ safe_strcpy(comment->value.text.string, ptr);
+ }
+ }
+ else if (!strncmp(ptr, "I ", 2) || !strncmp(ptr, "O ", 2) ||
+ !strncmp(ptr, "IO ", 3))
+ {
+ /*
+ * 'Convert "I - description", "IO - description", or "O - description"
+ * to description + directory attribute.
+ */
+
+ ptr = strchr(ptr, ' ');
+ *ptr++ = '\0';
+
+ if (!strcmp(parent->value.element.name, "argument"))
+ mxmlElementSetAttr(parent, "direction", comment->value.text.string);
+
+ while (isspace(*ptr & 255))
+ ptr ++;
+
+ if (*ptr == '-')
+ ptr ++;
+
+ while (isspace(*ptr & 255))
+ ptr ++;
+
+ safe_strcpy(comment->value.text.string, ptr);
+ }
+
+ /*
+ * Eliminate leading and trailing *'s...
+ */
+
+ for (ptr = comment->value.text.string; *ptr == '*'; ptr ++);
+ for (; isspace(*ptr & 255); ptr ++);
+ if (ptr > comment->value.text.string)
+ safe_strcpy(comment->value.text.string, ptr);
+
+ for (ptr = comment->value.text.string + strlen(comment->value.text.string) - 1;
+ ptr > comment->value.text.string && *ptr == '*';
+ ptr --)
+ *ptr = '\0';
+ for (; ptr > comment->value.text.string && isspace(*ptr & 255); ptr --)
+ *ptr = '\0';
+
+#ifdef DEBUG
+ fprintf(stderr, " updated comment = %s\n", comment->value.text.string);
+#endif /* DEBUG */
+}
+
+
+/*
+ * 'write_documentation()' - Write HTML documentation.
+ */
+
+static void
+write_documentation(mxml_node_t *doc) /* I - XML documentation */
+{
+ int i; /* Looping var */
+ mxml_node_t *function, /* Current function */
+ *scut, /* Struct/class/union/typedef */
+ *arg, /* Current argument */
+ *description, /* Description of function/var */
+ *type; /* Type for argument */
+ const char *name, /* Name of function/type */
+ *cname, /* Class name */
+ *defval, /* Default value */
+ *parent; /* Parent class */
+ int inscope; /* Variable/method scope */
+ char prefix; /* Prefix character */
+ static const char * const scopes[] = /* Scope strings */
+ {
+ "private",
+ "protected",
+ "public"
+ };
+
+
+ /*
+ * Standard header...
+ */
+
+ puts("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
+ "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n"
+ "<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en' lang='en'>\n"
+ "<head>\n"
+ "\t<title>Documentation</title>\n"
+ "\t<meta name='creator' content='" MXML_VERSION "'/>\n"
+ "\t<style><!--\n"
+ "\th1, h2, h3, p { font-family: sans-serif; text-align: justify; }\n"
+ "\ttt, pre a:link, pre a:visited, tt a:link, tt a:visited { font-weight: bold; color: #7f0000; }\n"
+ "\tpre { font-weight: bold; color: #7f0000; margin-left: 2em; }\n"
+ "\t--></style>\n"
+ "</head>\n"
+ "<body>");
+
+ /*
+ * Table of contents...
+ */
+
+ puts("<h2>Contents</h2>");
+ puts("<ul>");
+ if (mxmlFindElement(doc, doc, "class", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_classes'>Classes</a></li>");
+ if (mxmlFindElement(doc, doc, "enumeration", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_enumerations'>Enumerations</a></li>");
+ if (mxmlFindElement(doc, doc, "function", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_functions'>Functions</a></li>");
+ if (mxmlFindElement(doc, doc, "struct", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_structures'>Structures</a></li>");
+ if (mxmlFindElement(doc, doc, "typedef", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_types'>Types</a></li>");
+ if (mxmlFindElement(doc, doc, "union", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_unions'>Unions</a></li>");
+ if (mxmlFindElement(doc, doc, "variable", NULL, NULL, MXML_DESCEND_FIRST))
+ puts("\t<li><a href='#_variables'>Variables</a></li>");
+ puts("</ul>");
+
+ /*
+ * List of classes...
+ */
+
+ if (mxmlFindElement(doc, doc, "class", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_classes'>Classes</a></h2>\n"
+ "<ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "class", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "class", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "class", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "class", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ cname = mxmlElementGetAttr(scut, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>\n", cname, cname);
+
+ description = mxmlFindElement(scut, scut, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ printf("<h4>Definition</h4>\n"
+ "<pre>\n"
+ "class %s", cname);
+ if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+ printf(" %s", parent);
+ puts("\n{");
+
+ for (i = 0; i < 3; i ++)
+ {
+ inscope = 0;
+
+ for (arg = mxmlFindElement(scut, scut, "variable", "scope", scopes[i],
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", "scope", scopes[i],
+ MXML_NO_DESCEND))
+ {
+ if (!inscope)
+ {
+ inscope = 1;
+ printf(" %s:\n", scopes[i]);
+ }
+
+ printf(" ");
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ printf(" %s;\n", mxmlElementGetAttr(arg, "name"));
+ }
+
+ for (function = mxmlFindElement(scut, scut, "function", "scope", scopes[i],
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, scut, "function", "scope", scopes[i],
+ MXML_NO_DESCEND))
+ {
+ if (!inscope)
+ {
+ inscope = 1;
+ printf(" %s:\n", scopes[i]);
+ }
+
+ name = mxmlElementGetAttr(function, "name");
+
+ printf(" ");
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (arg)
+ {
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ putchar(' ');
+ }
+ else if (strcmp(cname, name) && strcmp(cname, name + 1))
+ fputs("void ", stdout);
+
+ printf("<a href='#%s.%s'>%s</a>", cname, name, name);
+
+ for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+ MXML_DESCEND_FIRST), prefix = '(';
+ arg;
+ arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+ MXML_NO_DESCEND), prefix = ',')
+ {
+ type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+ MXML_DESCEND_FIRST);
+
+ putchar(prefix);
+ if (prefix == ',')
+ putchar(' ');
+
+ if (type->child)
+ {
+ write_element(doc, type);
+ putchar(' ');
+ }
+ fputs(mxmlElementGetAttr(arg, "name"), stdout);
+ if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+ printf(" %s", defval);
+ }
+
+ if (prefix == '(')
+ puts("(void);");
+ else
+ puts(");");
+ }
+ }
+
+ puts("};\n</pre>\n"
+ "<h4>Members</h4>\n"
+ "<p class='table'><table align='center' border='1' "
+ "cellpadding='5' cellspacing='0' width='80%'>\n"
+ "<thead><tr bgcolor='#cccccc'><th>Name</th><th>Description</th></tr></thead>\n"
+ "<tbody>");
+
+ for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf("<tr><td><tt>%s</tt></td><td>", mxmlElementGetAttr(arg, "name"));
+
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+
+ puts("</td></tr>");
+ }
+
+ for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, scut, "function", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(function, "name");
+
+ printf("<tr><td><tt><a name='%s.%s'>%s()</a></tt></td><td>",
+ cname, name, name);
+
+ description = mxmlFindElement(function, function, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ write_element(NULL, description);
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (arg)
+ {
+ fputs("\n<i>Returns:</i> ", stdout);
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ }
+
+ puts("</td></tr>");
+ }
+
+ puts("</tbody></table></p>");
+ }
+ }
+
+ /*
+ * List of enumerations...
+ */
+
+ if (mxmlFindElement(doc, doc, "enumeration", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_enumerations'>Enumerations</a></h2>\n"
+ "<ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "enumeration", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "enumeration", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "enumeration", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "enumeration", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>\n", name, name);
+
+ description = mxmlFindElement(scut, scut, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ puts("<h4>Values</h4>\n"
+ "<p class='table'><table align='center' border='1' width='80%' "
+ "cellpadding='5' cellspacing='0' width='80%'>\n"
+ "<thead><tr bgcolor='#cccccc'><th>Name</th><th>Description</th></tr></thead>\n"
+ "<tbody>");
+
+ for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf("<tr><td><tt>%s</tt></td><td>", mxmlElementGetAttr(arg, "name"));
+
+ write_element(doc, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+
+ puts("</td></tr>");
+ }
+
+ puts("</tbody></table></p>");
+ }
+ }
+
+ /*
+ * List of functions...
+ */
+
+ if (mxmlFindElement(doc, doc, "function", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_functions'>Functions</a></h2>\n"
+ "<ul>");
+
+ for (function = mxmlFindElement(doc, doc, "function", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, doc, "function", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(function, "name");
+ printf("\t<li><a href='#%s'><tt>%s()</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (function = mxmlFindElement(doc, doc, "function", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, doc, "function", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(function, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s()</a></h3>\n"
+ "<hr noshade/>\n", name, name);
+
+ description = mxmlFindElement(function, function, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ puts("<h4>Syntax</h4>\n"
+ "<pre>");
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (arg)
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ else
+ fputs("void", stdout);
+
+ printf("\n%s", name);
+ for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+ MXML_DESCEND_FIRST), prefix = '(';
+ arg;
+ arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+ MXML_NO_DESCEND), prefix = ',')
+ {
+ type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+ MXML_DESCEND_FIRST);
+
+ printf("%c\n ", prefix);
+ if (type->child)
+ {
+ write_element(doc, type);
+ putchar(' ');
+ }
+ fputs(mxmlElementGetAttr(arg, "name"), stdout);
+ if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+ printf(" %s", defval);
+ }
+
+ if (prefix == '(')
+ puts("(void);\n</pre>");
+ else
+ puts(");\n</pre>");
+
+ puts("<h4>Arguments</h4>");
+
+ if (prefix == '(')
+ puts("<p>None.</p>");
+ else
+ {
+ puts("<p class='table'><table align='center' border='1' width='80%' "
+ "cellpadding='5' cellspacing='0' width='80%'>\n"
+ "<thead><tr bgcolor='#cccccc'><th>Name</th><th>Description</th></tr></thead>\n"
+ "<tbody>");
+
+ for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf("<tr><td><tt>%s</tt></td><td>", mxmlElementGetAttr(arg, "name"));
+
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+
+ puts("</td></tr>");
+ }
+
+ puts("</tbody></table></p>");
+ }
+
+ puts("<h4>Returns</h4>");
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (!arg)
+ puts("<p>Nothing.</p>");
+ else
+ {
+ fputs("<p>", stdout);
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ puts("</p>");
+ }
+ }
+ }
+
+ /*
+ * List of structures...
+ */
+
+ if (mxmlFindElement(doc, doc, "struct", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_structures'>Structures</a></h2>\n"
+ "<ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "struct", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "struct", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "struct", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "struct", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ cname = mxmlElementGetAttr(scut, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>\n", cname, cname);
+
+ description = mxmlFindElement(scut, scut, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ printf("<h4>Definition</h4>\n"
+ "<pre>\n"
+ "struct %s\n{\n", cname);
+ for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf(" ");
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ printf(" %s;\n", mxmlElementGetAttr(arg, "name"));
+ }
+
+ for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, scut, "function", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(function, "name");
+
+ printf(" ");
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (arg)
+ {
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ putchar(' ');
+ }
+ else if (strcmp(cname, name) && strcmp(cname, name + 1))
+ fputs("void ", stdout);
+
+ printf("<a href='#%s.%s'>%s</a>", cname, name, name);
+
+ for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+ MXML_DESCEND_FIRST), prefix = '(';
+ arg;
+ arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+ MXML_NO_DESCEND), prefix = ',')
+ {
+ type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+ MXML_DESCEND_FIRST);
+
+ putchar(prefix);
+ if (prefix == ',')
+ putchar(' ');
+
+ if (type->child)
+ {
+ write_element(doc, type);
+ putchar(' ');
+ }
+ fputs(mxmlElementGetAttr(arg, "name"), stdout);
+ if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+ printf(" %s", defval);
+ }
+
+ if (prefix == '(')
+ puts("(void);");
+ else
+ puts(");");
+ }
+
+ puts("};\n</pre>\n"
+ "<h4>Members</h4>\n"
+ "<p class='table'><table align='center' border='1' width='80%' "
+ "cellpadding='5' cellspacing='0' width='80%'>\n"
+ "<thead><tr bgcolor='#cccccc'><th>Name</th><th>Description</th></tr></thead>\n"
+ "<tbody>");
+
+ for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf("<tr><td><tt>%s</tt></td><td>", mxmlElementGetAttr(arg, "name"));
+
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+
+ puts("</td></tr>");
+ }
+
+ for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ function;
+ function = mxmlFindElement(function, scut, "function", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(function, "name");
+
+ printf("<tr><td><tt><a name='%s.%s'>%s()</a></tt></td><td>",
+ cname, name, name);
+
+ description = mxmlFindElement(function, function, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ write_element(NULL, description);
+
+ arg = mxmlFindElement(function, function, "returnvalue", NULL,
+ NULL, MXML_DESCEND_FIRST);
+
+ if (arg)
+ {
+ fputs("\n<i>Returns:</i> ", stdout);
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ }
+
+ puts("</td></tr>");
+ }
+
+ puts("</tbody></table></p>");
+ }
+ }
+
+ /*
+ * List of types...
+ */
+
+ if (mxmlFindElement(doc, doc, "typedef", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_types'>Types</a></h2>\n"
+ "<ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "typedef", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "typedef", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "typedef", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "typedef", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>\n", name, name);
+
+ description = mxmlFindElement(scut, scut, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ fputs("<h4>Definition</h4>\n"
+ "<pre>\n"
+ "typedef ", stdout);
+ write_element(doc, mxmlFindElement(scut, scut, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ printf(" %s;\n</pre>\n", name);
+ }
+ }
+
+ /*
+ * List of unions...
+ */
+
+ if (mxmlFindElement(doc, doc, "union", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_unions'>Unions</a></h2>\n"
+ "<ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "union", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "union", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (scut = mxmlFindElement(doc, doc, "union", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ scut;
+ scut = mxmlFindElement(scut, doc, "union", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(scut, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>\n", name, name);
+
+ description = mxmlFindElement(scut, scut, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ printf("<h4>Definition</h4>\n"
+ "<pre>\n"
+ "union %s\n{\n", name);
+ for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf(" ");
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ printf(" %s;\n", mxmlElementGetAttr(arg, "name"));
+ }
+
+ puts("};\n</pre>\n"
+ "<h4>Members</h4>\n"
+ "<p class='table'><table align='center' border='1' width='80%' "
+ "cellpadding='5' cellspacing='0' width='80%'>\n"
+ "<thead><tr bgcolor='#cccccc'><th>Name</th><th>Description</th></tr></thead>\n"
+ "<tbody>");
+
+ for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ printf("<tr><td><tt>%s</tt></td><td>", mxmlElementGetAttr(arg, "name"));
+
+ write_element(NULL, mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST));
+
+ puts("</td></tr>");
+ }
+
+ puts("</tbody></table></p>");
+ }
+ }
+
+ /*
+ * Variables...
+ */
+
+ if (mxmlFindElement(doc, doc, "variable", NULL, NULL, MXML_DESCEND_FIRST))
+ {
+ puts("<!-- NEW PAGE -->\n"
+ "<h2><a name='_variables'>Variables</a></h2>\n"
+ "<ul>");
+
+ for (arg = mxmlFindElement(doc, doc, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, doc, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(arg, "name");
+ printf("\t<li><a href='#%s'><tt>%s</tt></a></li>\n", name, name);
+ }
+
+ puts("</ul>");
+
+ for (arg = mxmlFindElement(doc, doc, "variable", NULL, NULL,
+ MXML_DESCEND_FIRST);
+ arg;
+ arg = mxmlFindElement(arg, doc, "variable", NULL, NULL,
+ MXML_NO_DESCEND))
+ {
+ name = mxmlElementGetAttr(arg, "name");
+ printf("<!-- NEW PAGE -->\n"
+ "<h3><a name='%s'>%s</a></h3>\n"
+ "<hr noshade/>", name, name);
+
+ description = mxmlFindElement(arg, arg, "description", NULL,
+ NULL, MXML_DESCEND_FIRST);
+ if (description)
+ {
+ fputs("<h4>Description</h4>\n"
+ "<p>", stdout);
+ write_element(NULL, description);
+ puts("</p>");
+ }
+
+ puts("<h4>Definition</h4>\n"
+ "<pre>");
+
+ write_element(doc, mxmlFindElement(arg, arg, "type", NULL,
+ NULL, MXML_DESCEND_FIRST));
+ printf(" %s", mxmlElementGetAttr(arg, "name"));
+ if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+ printf(" %s", defval);
+ puts(";\n</pre>");
+ }
+ }
+
+ /*
+ * Standard footer...
+ */
+
+ puts("</body>\n"
+ "</html>");
+}
+
+
+/*
+ * 'write_element()' - Write an element's text nodes.
+ */
+
+static void
+write_element(mxml_node_t *doc, /* I - Document tree */
+ mxml_node_t *element) /* I - Element to write */
+{
+ mxml_node_t *node; /* Current node */
+
+
+ if (!element)
+ return;
+
+ for (node = element->child;
+ node;
+ node = mxmlWalkNext(node, element, MXML_NO_DESCEND))
+ if (node->type == MXML_TEXT)
+ {
+ if (node->value.text.whitespace)
+ putchar(' ');
+
+ if (mxmlFindElement(doc, doc, "class", "name", node->value.text.string,
+ MXML_DESCEND) ||
+ mxmlFindElement(doc, doc, "enumeration", "name",
+ node->value.text.string, MXML_DESCEND) ||
+ mxmlFindElement(doc, doc, "struct", "name", node->value.text.string,
+ MXML_DESCEND) ||
+ mxmlFindElement(doc, doc, "typedef", "name", node->value.text.string,
+ MXML_DESCEND) ||
+ mxmlFindElement(doc, doc, "union", "name", node->value.text.string,
+ MXML_DESCEND))
+ {
+ printf("<a href='#");
+ write_string(node->value.text.string);
+ printf("'>");
+ write_string(node->value.text.string);
+ printf("</a>");
+ }
+ else
+ write_string(node->value.text.string);
+ }
+}
+
+
+/*
+ * 'write_string()' - Write a string, quoting XHTML special chars as needed...
+ */
+
+static void
+write_string(const char *s) /* I - String to write */
+{
+ while (*s)
+ {
+ if (*s == '&')
+ fputs("&", stdout);
+ else if (*s == '<')
+ fputs("<", stdout);
+ else if (*s == '>')
+ fputs(">", stdout);
+ else if (*s == '\"')
+ fputs(""", stdout);
+ else if (*s & 128)
+ {
+ /*
+ * Convert UTF-8 to Unicode constant...
+ */
+
+ int ch; /* Unicode character */
+
+
+ ch = *s & 255;
+
+ if ((ch & 0xe0) == 0xc0)
+ {
+ ch = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
+ s ++;
+ }
+ else if ((ch & 0xf0) == 0xe0)
+ {
+ ch = ((((ch * 0x0f) << 6) | (s[1] & 0x3f)) << 6) | (s[2] & 0x3f);
+ s += 2;
+ }
+
+ if (ch == 0xa0)
+ {
+ /*
+ * Handle non-breaking space as-is...
+ */
+
+ fputs(" ", stdout);
+ }
+ else
+ printf("&#x%x;", ch);
+ }
+ else
+ putchar(*s);
+
+ s ++;
+ }
+}
+
+
+/*
+ * 'ws_cb()' - Whitespace callback for saving.
+ */
+
+static const char * /* O - Whitespace string or NULL for none */
+ws_cb(mxml_node_t *node, /* I - Element node */
+ int where) /* I - Where value */
+{
+ const char *name; /* Name of element */
+ int depth; /* Depth of node */
+ static const char *spaces = " ";
+ /* Whitespace (40 spaces) for indent */
+
+
+ name = node->value.element.name;
+
+ switch (where)
+ {
+ case MXML_WS_BEFORE_CLOSE :
+ if (strcmp(name, "argument") &&
+ strcmp(name, "class") &&
+ strcmp(name, "constant") &&
+ strcmp(name, "enumeration") &&
+ strcmp(name, "function") &&
+ strcmp(name, "mxmldoc") &&
+ strcmp(name, "namespace") &&
+ strcmp(name, "returnvalue") &&
+ strcmp(name, "struct") &&
+ strcmp(name, "typedef") &&
+ strcmp(name, "union") &&
+ strcmp(name, "variable"))
+ return (NULL);
+
+ for (depth = -4; node; node = node->parent, depth += 2);
+ if (depth > 40)
+ return (spaces);
+ else if (depth < 2)
+ return (NULL);
+ else
+ return (spaces + 40 - depth);
+
+ case MXML_WS_AFTER_CLOSE :
+ return ("\n");
+
+ case MXML_WS_BEFORE_OPEN :
+ for (depth = -4; node; node = node->parent, depth += 2);
+ if (depth > 40)
+ return (spaces);
+ else if (depth < 2)
+ return (NULL);
+ else
+ return (spaces + 40 - depth);
+
+ default :
+ case MXML_WS_AFTER_OPEN :
+ if (strcmp(name, "argument") &&
+ strcmp(name, "class") &&
+ strcmp(name, "constant") &&
+ strcmp(name, "enumeration") &&
+ strcmp(name, "function") &&
+ strcmp(name, "mxmldoc") &&
+ strcmp(name, "namespace") &&
+ strcmp(name, "returnvalue") &&
+ strcmp(name, "struct") &&
+ strcmp(name, "typedef") &&
+ strcmp(name, "union") &&
+ strcmp(name, "variable"))
+ return (NULL);
+ else
+ return ("\n");
+ }
+}
+
+
+/*
+ * End of "$Id$".
+ */
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<group>
+ <option>
+ <keyword type="opaque">InputSlot</keyword>
+ <default type="opaque">Auto</default>
+ <text>Media Source</text>
+ <order type="real">10.000000</order>
+ <choice>
+ <keyword type="opaque">Auto</keyword>
+ <text>Auto Tray Selection</text>
+ <code type="opaque" />
+ </choice>
+ <choice>
+ <keyword type="opaque">Upper</keyword>
+ <text>Tray 1</text>
+ <code type="opaque"><</MediaPosition 0>>setpagedevice</code>
+ </choice>
+ <choice>
+ <keyword type="opaque">Lower</keyword>
+ <text>Tray 2</text>
+ <code type="opaque"><</MediaPosition 1>>setpagedevice</code>
+ </choice>
+ </option>
+ <integer>123</integer>
+ <string>Now is the time for all good men to come to the aid of their
+country.</string>
+ <!-- this is a comment -->
+ <![CDATA[this is CDATA 0123456789ABCDEF]]>
+</group>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<group>
+ <option>
+ <keyword type="opaque">InputSlot</keyword>
+ <default type="opaque">Auto</default>
+ <text>Media Source</text>
+ <order type="real">10.000000</order>
+ <choice>
+ <keyword type="opaque">Auto</keyword>
+ <text>Auto Tray Selection</text>
+ <code type="opaque" />
+ </choice>
+ <choice>
+ <keyword type="opaque">Upper</keyword>
+ <text>Tray 1</text>
+ <code type="opaque"><</MediaPosition 0>>setpagedevice</code>
+ </choice>
+ <choice>
+ <keyword type="opaque">Lower</keyword>
+ <text>Tray 2</text>
+ <code type="opaque"><</MediaPosition 1>>setpagedevice</code>
+ </choice>
+ </option>
+ <integer>123</integer>
+ <string>Now is the time for all good men to come to the aid of their
+country.</string>
+ <!-- this is a comment -->
+ <![CDATA[this is CDATA 0123456789ABCDEF]]>
+</group>
--- /dev/null
+/*
+ * "$Id$"
+ *
+ * Test program for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2005 by Michael Sweet.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2, or (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Contents:
+ *
+ * main() - Main entry for test program.
+ * type_cb() - XML data type callback for mxmlLoadFile()...
+ * whitespace_cb() - Let the mxmlSaveFile() function know when to insert
+ * newlines and tabs...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#ifdef WIN32
+# include <io.h>
+#else
+# include <unistd.h>
+#endif /* WIN32 */
+#include <fcntl.h>
+#ifndef O_BINARY
+# define O_BINARY 0
+#endif /* !O_BINARY */
+
+
+/*
+ * Local functions...
+ */
+
+mxml_type_t type_cb(mxml_node_t *node);
+const char *whitespace_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int /* O - Exit status */
+main(int argc, /* I - Number of command-line args */
+ char *argv[]) /* I - Command-line args */
+{
+ int i; /* Looping var */
+ FILE *fp; /* File to read */
+ int fd; /* File descriptor */
+ mxml_node_t *tree, /* XML tree */
+ *node; /* Node which should be in test.xml */
+ mxml_index_t *ind; /* XML index */
+ char buffer[16384]; /* Save string */
+ static const char *types[] = /* Strings for node types */
+ {
+ "MXML_ELEMENT",
+ "MXML_INTEGER",
+ "MXML_OPAQUE",
+ "MXML_REAL",
+ "MXML_TEXT"
+ };
+
+
+ /*
+ * Check arguments...
+ */
+
+ if (argc != 2)
+ {
+ fputs("Usage: testmxml filename.xml\n", stderr);
+ return (1);
+ }
+
+ /*
+ * Test the basic functionality...
+ */
+
+ tree = mxmlNewElement(MXML_NO_PARENT, "element");
+
+ if (!tree)
+ {
+ fputs("ERROR: No parent node in basic test!\n", stderr);
+ return (1);
+ }
+
+ if (tree->type != MXML_ELEMENT)
+ {
+ fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
+ tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
+ "UNKNOWN" : types[tree->type], tree->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (strcmp(tree->value.element.name, "element"))
+ {
+ fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
+ tree->value.element.name);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlNewInteger(tree, 123);
+ mxmlNewOpaque(tree, "opaque");
+ mxmlNewReal(tree, 123.4f);
+ mxmlNewText(tree, 1, "text");
+
+ mxmlLoadString(tree, "<group type='string'>string string string</group>",
+ MXML_NO_CALLBACK);
+ mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
+ MXML_INTEGER_CALLBACK);
+ mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
+ MXML_REAL_CALLBACK);
+ mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
+ MXML_OPAQUE_CALLBACK);
+
+ node = tree->child;
+
+ if (!node)
+ {
+ fputs("ERROR: No first child node in basic test!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->type != MXML_INTEGER)
+ {
+ fprintf(stderr, "ERROR: First child has type %s (%d), expected MXML_INTEGER!\n",
+ node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+ "UNKNOWN" : types[node->type], node->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->value.integer != 123)
+ {
+ fprintf(stderr, "ERROR: First child value is %d, expected 123!\n",
+ node->value.integer);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ node = node->next;
+
+ if (!node)
+ {
+ fputs("ERROR: No second child node in basic test!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->type != MXML_OPAQUE)
+ {
+ fprintf(stderr, "ERROR: Second child has type %s (%d), expected MXML_OPAQUE!\n",
+ node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+ "UNKNOWN" : types[node->type], node->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (!node->value.opaque || strcmp(node->value.opaque, "opaque"))
+ {
+ fprintf(stderr, "ERROR: Second child value is \"%s\", expected \"opaque\"!\n",
+ node->value.opaque ? node->value.opaque : "(null)");
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ node = node->next;
+
+ if (!node)
+ {
+ fputs("ERROR: No third child node in basic test!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->type != MXML_REAL)
+ {
+ fprintf(stderr, "ERROR: Third child has type %s (%d), expected MXML_REAL!\n",
+ node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+ "UNKNOWN" : types[node->type], node->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->value.real != 123.4f)
+ {
+ fprintf(stderr, "ERROR: Third child value is %f, expected 123.4!\n",
+ node->value.real);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ node = node->next;
+
+ if (!node)
+ {
+ fputs("ERROR: No fourth child node in basic test!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->type != MXML_TEXT)
+ {
+ fprintf(stderr, "ERROR: Fourth child has type %s (%d), expected MXML_TEXT!\n",
+ node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+ "UNKNOWN" : types[node->type], node->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (!node->value.text.whitespace ||
+ !node->value.text.string || strcmp(node->value.text.string, "text"))
+ {
+ fprintf(stderr, "ERROR: Fourth child value is %d,\"%s\", expected 1,\"text\"!\n",
+ node->value.text.whitespace,
+ node->value.text.string ? node->value.text.string : "(null)");
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ for (i = 0; i < 4; i ++)
+ {
+ node = node->next;
+
+ if (!node)
+ {
+ fprintf(stderr, "ERROR: No group #%d child node in basic test!\n", i + 1);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (node->type != MXML_ELEMENT)
+ {
+ fprintf(stderr, "ERROR: Group child #%d has type %s (%d), expected MXML_ELEMENT!\n",
+ i + 1, node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+ "UNKNOWN" : types[node->type], node->type);
+ mxmlDelete(tree);
+ return (1);
+ }
+ }
+
+ /*
+ * Test indices...
+ */
+
+ ind = mxmlIndexNew(tree, NULL, NULL);
+ if (!ind)
+ {
+ fputs("ERROR: Unable to create index of all nodes!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (ind->num_nodes != 5)
+ {
+ fprintf(stderr, "ERROR: Index of all nodes contains %d "
+ "nodes; expected 5!\n", ind->num_nodes);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexReset(ind);
+ if (!mxmlIndexFind(ind, "group", NULL))
+ {
+ fputs("ERROR: mxmlIndexFind for \"group\" failed!\n", stderr);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexDelete(ind);
+
+ ind = mxmlIndexNew(tree, "group", NULL);
+ if (!ind)
+ {
+ fputs("ERROR: Unable to create index of groups!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (ind->num_nodes != 4)
+ {
+ fprintf(stderr, "ERROR: Index of groups contains %d "
+ "nodes; expected 4!\n", ind->num_nodes);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexReset(ind);
+ if (!mxmlIndexEnum(ind))
+ {
+ fputs("ERROR: mxmlIndexEnum failed!\n", stderr);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexDelete(ind);
+
+ ind = mxmlIndexNew(tree, NULL, "type");
+ if (!ind)
+ {
+ fputs("ERROR: Unable to create index of type attributes!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (ind->num_nodes != 3)
+ {
+ fprintf(stderr, "ERROR: Index of type attributes contains %d "
+ "nodes; expected 3!\n", ind->num_nodes);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexReset(ind);
+ if (!mxmlIndexFind(ind, NULL, "string"))
+ {
+ fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexDelete(ind);
+
+ ind = mxmlIndexNew(tree, "group", "type");
+ if (!ind)
+ {
+ fputs("ERROR: Unable to create index of elements and attributes!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if (ind->num_nodes != 3)
+ {
+ fprintf(stderr, "ERROR: Index of elements and attributes contains %d "
+ "nodes; expected 3!\n", ind->num_nodes);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexReset(ind);
+ if (!mxmlIndexFind(ind, "group", "string"))
+ {
+ fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
+ mxmlIndexDelete(ind);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ mxmlIndexDelete(ind);
+
+ /*
+ * Check the mxmlDelete() works properly...
+ */
+
+ for (i = 0; i < 8; i ++)
+ {
+ if (tree->child)
+ mxmlDelete(tree->child);
+ else
+ {
+ fprintf(stderr, "ERROR: Child pointer prematurely NULL on child #%d\n",
+ i + 1);
+ mxmlDelete(tree);
+ return (1);
+ }
+ }
+
+ if (tree->child)
+ {
+ fputs("ERROR: Child pointer not NULL after deleting all children!\n", stderr);
+ return (1);
+ }
+
+ if (tree->last_child)
+ {
+ fputs("ERROR: Last child pointer not NULL after deleting all children!\n", stderr);
+ return (1);
+ }
+
+ mxmlDelete(tree);
+
+ /*
+ * Open the file...
+ */
+
+ if (argv[1][0] == '<')
+ tree = mxmlLoadString(NULL, argv[1], type_cb);
+ else if ((fp = fopen(argv[1], "rb")) == NULL)
+ {
+ perror(argv[1]);
+ return (1);
+ }
+ else
+ {
+ /*
+ * Read the file...
+ */
+
+ tree = mxmlLoadFile(NULL, fp, type_cb);
+
+ fclose(fp);
+ }
+
+ if (!tree)
+ {
+ fputs("Unable to read XML file!\n", stderr);
+ return (1);
+ }
+
+ if (!strcmp(argv[1], "test.xml"))
+ {
+ /*
+ * Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
+ * properly...
+ */
+
+ if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
+ MXML_DESCEND)) == NULL)
+ {
+ fputs("Unable to find first <choice> element in XML tree!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ if ((node = mxmlFindElement(node, tree, "choice", NULL, NULL,
+ MXML_NO_DESCEND)) == NULL)
+ {
+ fputs("Unable to find second <choice> element in XML tree!\n", stderr);
+ mxmlDelete(tree);
+ return (1);
+ }
+ }
+
+ /*
+ * Print the XML tree...
+ */
+
+ mxmlSaveFile(tree, stdout, whitespace_cb);
+
+ /*
+ * Save the XML tree to a string and print it...
+ */
+
+ if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0)
+ fputs(buffer, stderr);
+
+ /*
+ * Delete the tree...
+ */
+
+ mxmlDelete(tree);
+
+ /*
+ * Read from/write to file descriptors...
+ */
+
+ if (argv[1][0] != '<')
+ {
+ /*
+ * Open the file again...
+ */
+
+ if ((fd = open(argv[1], O_RDONLY | O_BINARY)) < 0)
+ {
+ perror(argv[1]);
+ return (1);
+ }
+
+ /*
+ * Read the file...
+ */
+
+ tree = mxmlLoadFd(NULL, fd, type_cb);
+
+ close(fd);
+
+ /*
+ * Create filename.xmlfd...
+ */
+
+ snprintf(buffer, sizeof(buffer), "%sfd", argv[1]);
+
+ if ((fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0)
+ {
+ perror(buffer);
+ mxmlDelete(tree);
+ return (1);
+ }
+
+ /*
+ * Write the file...
+ */
+
+ mxmlSaveFd(tree, fd, whitespace_cb);
+
+ close(fd);
+
+ /*
+ * Delete the tree...
+ */
+
+ mxmlDelete(tree);
+ }
+
+ /*
+ * Return...
+ */
+
+ return (0);
+}
+
+
+/*
+ * 'type_cb()' - XML data type callback for mxmlLoadFile()...
+ */
+
+mxml_type_t /* O - Data type */
+type_cb(mxml_node_t *node) /* I - Element node */
+{
+ const char *type; /* Type string */
+
+
+ /*
+ * You can lookup attributes and/or use the element name, hierarchy, etc...
+ */
+
+ if ((type = mxmlElementGetAttr(node, "type")) == NULL)
+ type = node->value.element.name;
+
+ if (!strcmp(type, "integer"))
+ return (MXML_INTEGER);
+ else if (!strcmp(type, "opaque") || !strcmp(type, "pre"))
+ return (MXML_OPAQUE);
+ else if (!strcmp(type, "real"))
+ return (MXML_REAL);
+ else
+ return (MXML_TEXT);
+}
+
+
+/*
+ * 'whitespace_cb()' - Let the mxmlSaveFile() function know when to insert
+ * newlines and tabs...
+ */
+
+const char * /* O - Whitespace string or NULL */
+whitespace_cb(mxml_node_t *node, /* I - Element node */
+ int where) /* I - Open or close tag? */
+{
+ mxml_node_t *parent; /* Parent node */
+ int level; /* Indentation level */
+ const char *name; /* Name of element */
+ static const char *tabs = "\t\t\t\t\t\t\t\t";
+ /* Tabs for indentation */
+
+
+ /*
+ * We can conditionally break to a new line before or after any element.
+ * These are just common HTML elements...
+ */
+
+ name = node->value.element.name;
+
+ if (!strcmp(name, "html") || !strcmp(name, "head") || !strcmp(name, "body") ||
+ !strcmp(name, "pre") || !strcmp(name, "p") ||
+ !strcmp(name, "h1") || !strcmp(name, "h2") || !strcmp(name, "h3") ||
+ !strcmp(name, "h4") || !strcmp(name, "h5") || !strcmp(name, "h6"))
+ {
+ /*
+ * Newlines before open and after close...
+ */
+
+ if (where == MXML_WS_BEFORE_OPEN || where == MXML_WS_AFTER_CLOSE)
+ return ("\n");
+ }
+ else if (!strcmp(name, "dl") || !strcmp(name, "ol") || !strcmp(name, "ul"))
+ {
+ /*
+ * Put a newline before and after list elements...
+ */
+
+ return ("\n");
+ }
+ else if (!strcmp(name, "dd") || !strcmp(name, "dt") || !strcmp(name, "li"))
+ {
+ /*
+ * Put a tab before <li>'s, <dd>'s, and <dt>'s, and a newline after them...
+ */
+
+ if (where == MXML_WS_BEFORE_OPEN)
+ return ("\t");
+ else if (where == MXML_WS_AFTER_CLOSE)
+ return ("\n");
+ }
+ else if (!strcmp(name, "?xml"))
+ {
+ return (NULL);
+ }
+ else if (where == MXML_WS_BEFORE_OPEN ||
+ ((!strcmp(name, "choice") || !strcmp(name, "option")) &&
+ where == MXML_WS_BEFORE_CLOSE))
+ {
+ for (level = -1, parent = node->parent;
+ parent;
+ level ++, parent = parent->parent);
+
+ if (level > 8)
+ level = 8;
+ else if (level < 0)
+ level = 0;
+
+ return (tabs + 8 - level);
+ }
+ else if (where == MXML_WS_AFTER_CLOSE ||
+ ((!strcmp(name, "group") || !strcmp(name, "option") ||
+ !strcmp(name, "choice")) &&
+ where == MXML_WS_AFTER_OPEN))
+ return ("\n");
+ else if (where == MXML_WS_AFTER_OPEN && !node->child)
+ return ("\n");
+
+ /*
+ * Return NULL for no added whitespace...
+ */
+
+ return (NULL);
+}
+
+
+/*
+ * End of "$Id$".
+ */
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard pbx_*.c))
+MODS:=$(filter-out $(MENUSELECT_PBX),$(patsubst %.c,%.so,$(wildcard pbx_*.c)))
-#GTK=$(shell $(CROSS_COMPILE_BIN)gtk-config --cflags >/dev/null 2>/dev/null && echo "OK")
-ifeq (${GTK},)
- MODS:=$(filter-out pbx_gtkconsole.so,$(MODS))
-endif
-
-#KDE=$(shell [ "$$QTDIR" != "" ] && echo "OK")
-ifeq (${GTK},)
- MODS:=$(filter-out pbx_kdeconsole.so,$(MODS))
-endif
-
-GTK_FLAGS=`${CROSS_COMPILE_BIN}gtk-config --cflags gthread`
-GTK_LIBS=`${CROSS_COMPILE_BIN}gtk-config --libs gthread`
MOC=$(QTDIR)/bin/moc
KDE_FLAGS=-I$(KDEDIR)/include -I$(KDEDIR)/include/kde -I$(QTDIR)/include
KDE_LIBS=-L$(KDEDIR)/lib -L$(QTDIR)/lib -lqt -lkdecore -lkdeui
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -L../res -lasterisk.dll
-else
- CFLAGS+=-fPIC
-endif
-
KDE_CONSOLE_OBJS=pbx_kdeconsole_main.o pbx_kdeconsole.o
all: depend $(MODS)
pbx_kdeconsole.so: $(KDE_CONSOLE_OBJS)
$(CC) $(SOLINK) -o $@ $(KDE_CONSOLE_OBJS) $(KDE_LIBS)
-pbx_dundi.so: dundi-parser.o pbx_dundi.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} pbx_dundi.o dundi-parser.o -lz ${CYGSOLIB}
+pbx_dundi.so: pbx_dundi.o dundi-parser.o
+ $(CC) $(SOLINK) -o $@ $< dundi-parser.o $(Z_LIB)
+
+pbx_dundi.o: pbx_dundi.c
+ $(CC) -c -o $@ $(CFLAGS) $(Z_INCLUDE) $<
%.moc : %.h
$(MOC) $< -o $@
%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+ $(CC) $(SOLINK) -o $@ $<
ifneq ($(wildcard .depend),)
include .depend
*
*/
+/*** MODULEINFO
+ <depend>zlib</depend>
+ ***/
+
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
}
STD_MOD(MOD_1 | NO_USECOUNT | NO_UNLOAD, reload, NULL, NULL);
+
*
*/
-/*
- * I know this might seem somewhat pointless in its current phase, but one
- * of the most important parts of this module is demonstrate that modules
- * can require other external libraries and still be loaded (in this
- * case, a host of libraries involving gtk), so long as they are properly
- * linked (see the Makefile)
- */
+/*** MODULEINFO
+ <depend>gtk</depend>
+ <defaultenabled>no</defaultenabled>
+ ***/
#include <sys/types.h>
#include <stdlib.h>
{
return ASTERISK_GPL_KEY;
}
+
* the GNU General Public License
*/
+/*** MODULEINFO
+ <depend>qt</depend>
+ ***/
+
#include "pbx_kdeconsole.moc"
KAsteriskConsole::KAsteriskConsole() : KTMainWindow()
# the GNU General Public License
#
-MODS:=$(patsubst %.c,%.so,$(wildcard res_*.c))
+MODS:=$(filter-out $(MENUSELECT_RES),$(patsubst %.c,%.so,$(wildcard res_*.c)))
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/odbcinst.h $(CROSS_COMPILE_TARGET)/usr/local/include/odbcinst.h),)
- MODS:=$(filter-out res_odbc.so,$(MODS))
- MODS:=$(filter-out res_config_odbc.so,$(MODS))
-else
- ifeq (${OSARCH},FreeBSD)
- MODS:=$(filter-out $(shell if test ${BSDVERSION} -lt 500000 ; then echo "res_config_odbc.so"; fi),$(MODS))
- endif
-endif
-
-ifeq ($(NOCRYPTO),yes)
- MODS:=$(filter-out res_crypto.so,$(MODS))
- MODS:=$(filter-out res_osp.so,$(MODS))
-endif
-
-OSPLIB:=$(wildcard $(CROSS_COMPILE_TARGET)/usr/lib/libosptk.a $(CROSS_COMPILE_TARGET)/usr/local/lib/libosptk.a)
-ifeq (${OSPLIB},)
- MODS:=$(filter-out res_osp.so,$(MODS))
+ifeq ($(OSARCH),FreeBSD)
+ MODS:=$(filter-out $(shell if test ${BSDVERSION} -lt 500000 ; then echo "res_config_odbc.so"; fi),$(MODS))
endif
# NETsnmp has some difficulties on some platforms (conflict with unload_module)
endif
endif
-ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql $(CROSS_COMPILE_TARGET)/usr/local/pgsql/include $(CROSS_COMPILE_TARGET)/usr/include/pgsql $(CROSS_COMPILE_TARGET)/usr/local/include/pgsql $(CROSS_COMPILE_TARGET)/opt/pgsql/include $(CROSS_COMPILE_TARGET)/usr/include/libpq-fe.h),)
- MODS:=$(filter-out res_config_pgsql.so,$(MODS))
-endif
-
ifeq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/net-snmp/net-snmp-config.h),)
MODS:=$(filter-out res_snmp.so,$(MODS))
else
SNMP_LDLIBS+=$(shell net-snmp-config --agent-libs)
endif
-ifeq (${WITH_SMDI},)
- MODS:=$(filter-out res_smdi.so,$(MODS))
-endif
-
-MLFLAGS=
-
-# Now, go find postgresql libraries
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/postgresql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib/postgresql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/pgsql/include),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/pgsql/include
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/local/pgsql/lib
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/pgsql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/pgsql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib/pgsql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/pgsql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/local/include/pgsql
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/local/lib/pgsql
-endif
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/opt/pgsql/include),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/opt/pgsql/include
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/opt/pgsql/lib
-endif
-
-ifneq ($(wilcard $(CROSS_COMPILE_TARGET)/usr/include/postgresql),)
- CFLAGS+=-I$(CROSS_COMPILE_TARGET)/usr/include/postgresql
-endif
-
-ifneq ($(wilcard $(CROSS_COMPILE_TARGET)/usr/lib/libpq.so),)
- MLFLAGS+=-L$(CROSS_COMPILE_TARGET)/usr/lib
-endif
-
-ifeq (${OSARCH},CYGWIN)
- CYGSOLINK=-Wl,--out-implib=lib$@.a -Wl,--export-all-symbols
- CYGSOLIB=-L.. -L. -lasterisk.dll
- CYG_RES_CONFIG_ODBC_LIB=-lres_odbc.so
- CYG_RES_FEATURES_LIB=-lres_adsi.so -lres_monitor.so
- MODS:=$(filter-out res_musiconhold.so,$(MODS))
-endif
-
-CRYPTO_LIBS=-lssl -lcrypto
-
-CFLAGS+=
-
-ifndef WITHOUT_ZAPTEL
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/linux/zaptel.h)$(wildcard $(CROSS_COMPILE_TARGET)/usr/local/include/zaptel.h),)
- CFLAGS+=-DZAPATA_MOH
-endif
-endif # WITHOUT_ZAPTEL
#
# Work around buggy RedHat 9.0
#
-ifeq (${OSARCH},CYGWIN)
CFLAGS+=-DOPENSSL_NO_KRB5
-else
-CFLAGS+=-DOPENSSL_NO_KRB5 -fPIC
-endif
all: depend $(MODS)
uninstall:
res_crypto.so: res_crypto.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(CRYPTO_LIBS)
+ $(CC) $(SOLINK) -o $@ $< $(SSL_LIB)
+
+res_crypto.o: res_crypto.c
+ $(CC) -c -o $@ $(CFLAGS) $(SSL_INCLUDE) $<
clean-depend:
rm -f .depend
rm -f *.so *.o
res_odbc.so: res_odbc.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lodbc
+ $(CC) $(SOLINK) -o $@ $< $(ODBC_LIB)
-res_osp.so: res_osp.o $(OSPLIB)
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} $(OSPLIB) $(CRYPTO_LIBS)
+res_odbc.o: res_odbc.c
+ $(CC) -c -o $@ $(CFLAGS) $(ODBC_INCLUDE) $<
-%.so : %.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB}
+res_osp.so: res_osp.o
+ $(CC) $(SOLINK) -o $@ $< $(OSPTK_LIB)
+
+res_osp.o: res_osp.c
+ $(CC) -c -o $@ $(CFLAGS) $(OSPTK_INCLUDE) $<
-res_features.so: res_features.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} ${CYG_RES_FEATURES_LIB}
+%.so : %.o
+ $(CC) -o $@ $(SOLINK) $<
-res_config_odbc.so: res_config_odbc.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} ${CYG_RES_CONFIG_ODBC_LIB}
+res_config_odbc.o: res_config_odbc.c
+ $(CC) -c -o $@ $(CFLAGS) $(ODBC_INCLUDE) $<
res_snmp.so: res_snmp.o snmp/agent.o
- $(CC) $(SOLINK) ${SNMP_LDFLAGS} -o $@ ${CYGSOLINK} res_snmp.o snmp/agent.o ${CYGSOLIB} ${SNMP_LDLIBS}
+ $(CC) $(SOLINK) $(SNMP_LDFLAGS) -o $@ $< snmp/agent.o $(SNMP_LDLIBS)
res_config_pgsql.so: res_config_pgsql.o
- $(CC) $(SOLINK) -o $@ ${CYGSOLINK} $< ${CYGSOLIB} -lpq -lz $(MLFLAGS)
+ $(CC) $(SOLINK) -o $@ $< $(PGSQL_LIB)
+
+res_config_pgsql.o: res_config_pgsql.c
+ $(CC) -c -o $@ $(CFLAGS) $(PGSQL_INCLUDE) $<
ifneq ($(wildcard .depend),)
include .depend
* \arg http://www.unixodbc.org
*/
+/*** MODULEINFO
+ <depend>unixodbc</depend>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
* \arg http://www.postgresql.org
*/
+/*** MODULEINFO
+ <depend>pgsql</depend>
+ ***/
+
#include <stdlib.h>
#include <string.h>
#include <libpq-fe.h> /* PostgreSQL */
* \author Mark Spencer <markster@digium.com>
*/
+/*** MODULEINFO
+ <depend>ssl</depend>
+ ***/
+
#include <sys/types.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
{
return ASTERISK_GPL_KEY;
}
+
STD_MOD(MOD_0 | NO_USECOUNT | NO_UNLOAD, reload, NULL, NULL);
+
/*
* Asterisk -- An open source telephony toolkit.
*
- * Copyright (C) 1999 - 2005, Digium, Inc.
+ * Copyright (C) 1999 - 2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
*
* \author Mark Spencer <markster@digium.com>
*/
+/*** MODULEINFO
+ <conflict>win32</conflict>
+ ***/
+
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/stat.h>
#include <dirent.h>
-#ifdef ZAPATA_MOH
-#ifdef __linux__
-#include <linux/zaptel.h>
-#else
-#include <zaptel.h>
-#endif /* __linux__ */
-#endif
#include <unistd.h>
#include <sys/ioctl.h>
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+#ifdef HAVE_ZAPTEL
+#ifdef __linux__
+#include <linux/zaptel.h>
+#else
+#include <zaptel.h>
+#endif /* __linux__ */
+#endif
+
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
static int moh_register(struct mohclass *moh, int reload)
{
-#ifdef ZAPATA_MOH
+#ifdef HAVE_ZAPTEL
int x;
#endif
ast_mutex_lock(&moh_lock);
ast_set_flag(moh, MOH_QUIET);
moh->srcfd = -1;
-#ifdef ZAPATA_MOH
+#ifdef HAVE_ZAPTEL
/* Open /dev/zap/pseudo for timing... Is
there a better, yet reliable way to do this? */
moh->pseudofd = open("/dev/zap/pseudo", O_RDONLY);
}
STD_MOD(MOD_0 | NO_USECOUNT | NO_UNLOAD, reload, NULL, NULL);
+
* at the top of the source tree.
*/
-
/*! \file
*
* \brief ODBC resource manager
* \arg See also: \ref cdr_odbc
*/
+/*** MODULEINFO
+ <depend>unixodbc</depend>
+ ***/
+
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/*
* Asterisk -- An open source telephony toolkit.
*
- * Copyright (C) 1999 - 2005, Digium, Inc.
+ * Copyright (C) 1999 - 2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
*
* \arg See also: \ref app_osplookup.c
*/
+/*** MODULEINFO
+ <depend>libosptk</depend>
+ <depend>ssl</depend>
+ ***/
+
#include <sys/types.h>
-#include <osp.h>
-#include <osputils.h>
+#include <osp/osp.h>
+#include <osp/osputils.h>
#include <openssl/err.h>
#include <stdio.h>
#include <dirent.h>
}
STD_MOD(MOD_0, reload, NULL, NULL)
+
+
* \author Thorsten Lockert <tholo@voop.as>
*/
+/*** MODULEINFO
+ <defaultenabled>no</defaultenabled>
+ ***/
+
#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include <sys/types.h>
#include <stdio.h>
+#include "asterisk.h"
+
#include "asterisk/compat.h"
+#ifndef HAVE_STRSEP
char* strsep(char** str, const char* delims)
{
char* token;
*str=NULL;
return token;
}
+#endif
-
-
+#ifndef HAVE_SETENV
int setenv(const char *name, const char *value, int overwrite)
{
unsigned char *buf;
return putenv(buf);
}
+#endif
+#ifndef HAVE_UNSETENV
int unsetenv(const char *name)
{
return setenv(name, "", 0);
}
-
+#endif
#
# Various utilities
#
-# Copyright (C) 1999-2005, Digium
+# Copyright (C) 1999-2006, Digium
#
# Mark Spencer <markster@digium.com>
#
#
# Don't use ast mm routines
#
-CFLAGS+=-DNO_AST_MM
+UTILS:=astman smsq stereorize streamplayer
-TARGET=stereorize streamplayer
-
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/popt.h)$(wildcard -f $(CROSS_COMPILE_TARGET)/usr/local/include/popt.h),)
- TARGET+=smsq
+ifeq (${OSARCH},SunOS)
+ SOL=../strcompat.o
+ SOLLIBS=-lsocket -lnsl
endif
-ifneq ($(wildcard $(CROSS_COMPILE_TARGET)/usr/include/newt.h)$(wildcard -f $(CROSS_COMPILE_TARGET)/usr/local/include/newt.h),)
- TARGET+=astman
+ifeq ($(POPT_LIB),)
+ UTILS:=$(filter-out smsq,$(UTILS))
endif
-ifeq (${OSARCH},SunOS)
- SOL=../strcompat.o
- SOLLIBS=-lsocket -lnsl
+ifeq ($(NEWT_LIB),)
+ UTILS:=$(filter-out astman,$(UTILS))
endif
-all: depend $(TARGET)
+all: depend $(UTILS)
install:
- for x in $(TARGET); do \
+ for x in $(UTILS); do \
if [ "$$x" != "none" ]; then \
$(INSTALL) -m 755 $$x $(DESTDIR)$(ASTSBINDIR)/$$x; \
fi; \
rm -f .depend
clean: clean-depend
- rm -f *.o astman smsq stereorize streamplayer check_expr
+ rm -f *.o $(TARGET) check_expr
rm -f ast_expr2.o ast_expr2f.o
+astman.o: astman.c
+ $(CC) $(CFLAGS) -include ../include/autoconfig.h -c -o $@ $<
+
astman: astman.o ../md5.o
- $(CC) $(CFLAGS) -o astman astman.o ../md5.o -lnewt
+ $(CC) -D_GNU_SOURCE -o $@ $< ../md5.o -lnewt
stereorize: stereorize.o frame.o
$(CC) $(CFLAGS) -o stereorize stereorize.o frame.o -lm
check_expr: check_expr.c ast_expr2.o ast_expr2f.o
$(CC) $(CFLAGS) -o $@ $^
+smsq.o: smsq.c
+ $(CC) $(CFLAGS) -include ../include/autoconfig.h -c -o $@ $<
+
smsq: smsq.o
$(CC) $(CFLAGS) -o smsq ${SOL} smsq.o -lpopt
projects / thirdparty / asterisk.git / commitdiff
