mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2024-12-23 17:33:50 +03:00
Remove Trio
Trio is a rather old cross-platform printf library which was bundled with libxml2. It was needed for ancient pre-C99 systems without snprintf and should be safe to remove these days.
This commit is contained in:
parent
f5d4d33bfa
commit
7d6969d955
@ -53,7 +53,6 @@ option(LIBXML2_WITH_TESTS "Build tests" ON)
|
||||
option(LIBXML2_WITH_THREADS "Add multithread support" ON)
|
||||
option(LIBXML2_WITH_THREAD_ALLOC "Add per-thread memory" OFF)
|
||||
option(LIBXML2_WITH_TREE "Add the DOM like tree manipulation APIs" ON)
|
||||
set(LIBXML2_WITH_TRIO OFF)
|
||||
set(LIBXML2_WITH_UNICODE ON)
|
||||
option(LIBXML2_WITH_VALID "Add the DTD validation support" ON)
|
||||
option(LIBXML2_WITH_WRITER "Add the xmlWriter saving interface" ON)
|
||||
@ -73,7 +72,7 @@ if(LIBXML2_WITH_PYTHON)
|
||||
CACHE PATH "Python bindings install directory")
|
||||
endif()
|
||||
|
||||
foreach(VARIABLE IN ITEMS WITH_AUTOMATA WITH_C14N WITH_CATALOG WITH_DEBUG WITH_EXPR WITH_FTP WITH_HTML WITH_HTTP WITH_ICONV WITH_ICU WITH_ISO8859X WITH_LEGACY WITH_LZMA WITH_MEM_DEBUG WITH_MODULES WITH_OUTPUT WITH_PATTERN WITH_PUSH WITH_READER WITH_REGEXPS WITH_SAX1 WITH_SCHEMAS WITH_SCHEMATRON WITH_THREADS WITH_THREAD_ALLOC WITH_TREE WITH_TRIO WITH_UNICODE WITH_VALID WITH_WRITER WITH_XINCLUDE WITH_XPATH WITH_XPTR WITH_XPTR_LOCS WITH_ZLIB)
|
||||
foreach(VARIABLE IN ITEMS WITH_AUTOMATA WITH_C14N WITH_CATALOG WITH_DEBUG WITH_EXPR WITH_FTP WITH_HTML WITH_HTTP WITH_ICONV WITH_ICU WITH_ISO8859X WITH_LEGACY WITH_LZMA WITH_MEM_DEBUG WITH_MODULES WITH_OUTPUT WITH_PATTERN WITH_PUSH WITH_READER WITH_REGEXPS WITH_SAX1 WITH_SCHEMAS WITH_SCHEMATRON WITH_THREADS WITH_THREAD_ALLOC WITH_TREE WITH_UNICODE WITH_VALID WITH_WRITER WITH_XINCLUDE WITH_XPATH WITH_XPTR WITH_XPTR_LOCS WITH_ZLIB)
|
||||
if(LIBXML2_${VARIABLE})
|
||||
set(${VARIABLE} 1)
|
||||
else()
|
||||
@ -330,10 +329,6 @@ if(WIN32)
|
||||
)
|
||||
endif()
|
||||
|
||||
if(LIBXML2_WITH_TRIO)
|
||||
list(APPEND LIBXML2_SRCS trio.c triostr.c)
|
||||
endif()
|
||||
|
||||
add_library(LibXml2 ${LIBXML2_HDRS} ${LIBXML2_SRCS})
|
||||
add_library(LibXml2::LibXml2 ALIAS LibXml2)
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
Except where otherwise noted in the source code (e.g. the files dict.c,
|
||||
list.c and the trio files, which are covered by a similar licence but
|
||||
with different Copyright notices) all the files are:
|
||||
Except where otherwise noted in the source code (e.g. the files dict.c and
|
||||
list.c, which are covered by a similar licence but with different Copyright
|
||||
notices) all the files are:
|
||||
|
||||
Copyright (C) 1998-2012 Daniel Veillard. All Rights Reserved.
|
||||
|
||||
|
@ -97,9 +97,6 @@ endif
|
||||
if WITH_SCHEMATRON_SOURCES
|
||||
libxml2_la_SOURCES += schematron.c
|
||||
endif
|
||||
if WITH_TRIO_SOURCES
|
||||
libxml2_la_SOURCES += triostr.c trio.c
|
||||
endif
|
||||
if WITH_WRITER_SOURCES
|
||||
libxml2_la_SOURCES += xmlwriter.c
|
||||
endif
|
||||
@ -389,8 +386,7 @@ EXTRA_DIST = Copyright check-xml-test-suite.py gentest.py \
|
||||
check-xsddata-test-suite.py check-xinclude-test-suite.py \
|
||||
example/Makefile.am example/gjobread.c example/gjobs.xml \
|
||||
libxml2-config.cmake.in autogen.sh \
|
||||
trionan.c trionan.h triostr.c triostr.h trio.c trio.h \
|
||||
triop.h triodef.h libxml.h \
|
||||
libxml.h \
|
||||
genUnicode.py \
|
||||
dbgen.pl dbgenattr.pl \
|
||||
libxml2.syms timsort.h \
|
||||
|
15
configure.ac
15
configure.ac
@ -530,9 +530,6 @@ case ${host} in
|
||||
*-*-solaris*)
|
||||
XML_LIBDIR="${XML_LIBDIR} -R${libdir}"
|
||||
;;
|
||||
hppa*-hp-mpeix)
|
||||
NEED_TRIO=1
|
||||
;;
|
||||
*-*-cygwin* | *-*-mingw* | *-*-msys* )
|
||||
# If the host is Windows, and shared libraries are disabled, we
|
||||
# need to add -DLIBXML_STATIC to AM_CFLAGS in order for linking to
|
||||
@ -839,18 +836,6 @@ AC_SUBST(MODULE_PLATFORM_LIBS)
|
||||
AC_SUBST(MODULE_EXTENSION)
|
||||
AM_CONDITIONAL(WITH_MODULES_SOURCES, test "$WITH_MODULES" = "1")
|
||||
|
||||
dnl
|
||||
dnl Check for trio string functions
|
||||
dnl
|
||||
if test "${NEED_TRIO}" = "1" ; then
|
||||
echo Adding trio library for string functions
|
||||
WITH_TRIO=1
|
||||
else
|
||||
WITH_TRIO=0
|
||||
fi
|
||||
AM_CONDITIONAL(WITH_TRIO_SOURCES, test "${NEED_TRIO}" = "1")
|
||||
AC_SUBST(WITH_TRIO)
|
||||
|
||||
dnl
|
||||
dnl Thread-related stuff
|
||||
dnl
|
||||
|
@ -19,10 +19,6 @@ debugsym=None
|
||||
# C parser analysis code
|
||||
#
|
||||
ignored_files = {
|
||||
"trio": "too many non standard macros",
|
||||
"trio.c": "too many non standard macros",
|
||||
"trionan.c": "too many non standard macros",
|
||||
"triostr.c": "too many non standard macros",
|
||||
"config.h": "generated portability layer",
|
||||
"libxml.h": "internal only",
|
||||
"testOOM.c": "out of memory tester",
|
||||
|
@ -60,31 +60,6 @@ XMLPUBFUN void xmlCheckVersion(int version);
|
||||
*/
|
||||
#define LIBXML_TEST_VERSION xmlCheckVersion(@LIBXML_VERSION_NUMBER@);
|
||||
|
||||
#ifndef VMS
|
||||
#if @WITH_TRIO@
|
||||
/**
|
||||
* WITH_TRIO:
|
||||
*
|
||||
* defined if the trio support need to be configured in
|
||||
*/
|
||||
#define WITH_TRIO
|
||||
#else
|
||||
/**
|
||||
* WITHOUT_TRIO:
|
||||
*
|
||||
* defined if the trio support should not be configured in
|
||||
*/
|
||||
#define WITHOUT_TRIO
|
||||
#endif
|
||||
#else /* VMS */
|
||||
/**
|
||||
* WITH_TRIO:
|
||||
*
|
||||
* defined if the trio support need to be configured in
|
||||
*/
|
||||
#define WITH_TRIO 1
|
||||
#endif /* VMS */
|
||||
|
||||
/**
|
||||
* LIBXML_THREAD_ENABLED:
|
||||
*
|
||||
|
5
libxml.h
5
libxml.h
@ -38,11 +38,6 @@
|
||||
#define SYSCONFDIR "/etc"
|
||||
#endif
|
||||
|
||||
#ifdef WITH_TRIO
|
||||
#define TRIO_REPLACE_STDIO
|
||||
#include "trio.h"
|
||||
#endif
|
||||
|
||||
#if !defined(_WIN32) && \
|
||||
!defined(__CYGWIN__) && \
|
||||
(defined(__clang__) || \
|
||||
|
@ -29,11 +29,6 @@
|
||||
#include "libxml_wrap.h"
|
||||
#include "libxml2-py.h"
|
||||
|
||||
#if defined(WITH_TRIO)
|
||||
#include "trio.h"
|
||||
#define vsnprintf trio_vsnprintf
|
||||
#endif
|
||||
|
||||
#if PY_MAJOR_VERSION >= 3
|
||||
PyObject *PyInit_libxml2mod(void);
|
||||
|
||||
|
230
trio.h
230
trio.h
@ -1,230 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 1998 Bjorn Reese and Daniel Stenberg.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
*************************************************************************
|
||||
*
|
||||
* http://ctrio.sourceforge.net/
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
#ifndef TRIO_TRIO_H
|
||||
#define TRIO_TRIO_H
|
||||
|
||||
#if !defined(WITHOUT_TRIO)
|
||||
|
||||
/*
|
||||
* Use autoconf defines if present. Packages using trio must define
|
||||
* HAVE_CONFIG_H as a compiler option themselves.
|
||||
*/
|
||||
#if defined(TRIO_HAVE_CONFIG_H)
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "triodef.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#if defined(TRIO_COMPILER_ANCIENT)
|
||||
# include <varargs.h>
|
||||
#else
|
||||
# include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Error codes.
|
||||
*
|
||||
* Remember to add a textual description to trio_strerror.
|
||||
*/
|
||||
enum {
|
||||
TRIO_EOF = 1,
|
||||
TRIO_EINVAL = 2,
|
||||
TRIO_ETOOMANY = 3,
|
||||
TRIO_EDBLREF = 4,
|
||||
TRIO_EGAP = 5,
|
||||
TRIO_ENOMEM = 6,
|
||||
TRIO_ERANGE = 7,
|
||||
TRIO_ERRNO = 8,
|
||||
TRIO_ECUSTOM = 9
|
||||
};
|
||||
|
||||
/* Error macros */
|
||||
#define TRIO_ERROR_CODE(x) ((-(x)) & 0x00FF)
|
||||
#define TRIO_ERROR_POSITION(x) ((-(x)) >> 8)
|
||||
#define TRIO_ERROR_NAME(x) trio_strerror(x)
|
||||
|
||||
typedef int (*trio_outstream_t) TRIO_PROTO((trio_pointer_t, int));
|
||||
typedef int (*trio_instream_t) TRIO_PROTO((trio_pointer_t));
|
||||
|
||||
TRIO_CONST char *trio_strerror TRIO_PROTO((int));
|
||||
|
||||
/*************************************************************************
|
||||
* Print Functions
|
||||
*/
|
||||
|
||||
int trio_printf TRIO_PROTO((TRIO_CONST char *format, ...));
|
||||
int trio_vprintf TRIO_PROTO((TRIO_CONST char *format, va_list args));
|
||||
int trio_printfv TRIO_PROTO((TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_fprintf TRIO_PROTO((FILE *file, TRIO_CONST char *format, ...));
|
||||
int trio_vfprintf TRIO_PROTO((FILE *file, TRIO_CONST char *format, va_list args));
|
||||
int trio_fprintfv TRIO_PROTO((FILE *file, TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_dprintf TRIO_PROTO((int fd, TRIO_CONST char *format, ...));
|
||||
int trio_vdprintf TRIO_PROTO((int fd, TRIO_CONST char *format, va_list args));
|
||||
int trio_dprintfv TRIO_PROTO((int fd, TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_cprintf TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, ...));
|
||||
int trio_vcprintf TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, va_list args));
|
||||
int trio_cprintfv TRIO_PROTO((trio_outstream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_sprintf TRIO_PROTO((char *buffer, TRIO_CONST char *format, ...));
|
||||
int trio_vsprintf TRIO_PROTO((char *buffer, TRIO_CONST char *format, va_list args));
|
||||
int trio_sprintfv TRIO_PROTO((char *buffer, TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_snprintf TRIO_PROTO((char *buffer, size_t max, TRIO_CONST char *format, ...));
|
||||
int trio_vsnprintf TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
|
||||
va_list args));
|
||||
int trio_snprintfv TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
|
||||
void **args));
|
||||
|
||||
int trio_snprintfcat TRIO_PROTO((char *buffer, size_t max, TRIO_CONST char *format, ...));
|
||||
int trio_vsnprintfcat TRIO_PROTO((char *buffer, size_t bufferSize, TRIO_CONST char *format,
|
||||
va_list args));
|
||||
|
||||
char *trio_aprintf TRIO_PROTO((TRIO_CONST char *format, ...));
|
||||
char *trio_vaprintf TRIO_PROTO((TRIO_CONST char *format, va_list args));
|
||||
|
||||
int trio_asprintf TRIO_PROTO((char **ret, TRIO_CONST char *format, ...));
|
||||
int trio_vasprintf TRIO_PROTO((char **ret, TRIO_CONST char *format, va_list args));
|
||||
|
||||
/*************************************************************************
|
||||
* Scan Functions
|
||||
*/
|
||||
int trio_scanf TRIO_PROTO((TRIO_CONST char *format, ...));
|
||||
int trio_vscanf TRIO_PROTO((TRIO_CONST char *format, va_list args));
|
||||
int trio_scanfv TRIO_PROTO((TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_fscanf TRIO_PROTO((FILE *file, TRIO_CONST char *format, ...));
|
||||
int trio_vfscanf TRIO_PROTO((FILE *file, TRIO_CONST char *format, va_list args));
|
||||
int trio_fscanfv TRIO_PROTO((FILE *file, TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_dscanf TRIO_PROTO((int fd, TRIO_CONST char *format, ...));
|
||||
int trio_vdscanf TRIO_PROTO((int fd, TRIO_CONST char *format, va_list args));
|
||||
int trio_dscanfv TRIO_PROTO((int fd, TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_cscanf TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, ...));
|
||||
int trio_vcscanf TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, va_list args));
|
||||
int trio_cscanfv TRIO_PROTO((trio_instream_t stream, trio_pointer_t closure,
|
||||
TRIO_CONST char *format, void **args));
|
||||
|
||||
int trio_sscanf TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, ...));
|
||||
int trio_vsscanf TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, va_list args));
|
||||
int trio_sscanfv TRIO_PROTO((TRIO_CONST char *buffer, TRIO_CONST char *format, void **args));
|
||||
|
||||
/*************************************************************************
|
||||
* Locale Functions
|
||||
*/
|
||||
void trio_locale_set_decimal_point TRIO_PROTO((char *decimalPoint));
|
||||
void trio_locale_set_thousand_separator TRIO_PROTO((char *thousandSeparator));
|
||||
void trio_locale_set_grouping TRIO_PROTO((char *grouping));
|
||||
|
||||
/*************************************************************************
|
||||
* Renaming
|
||||
*/
|
||||
#ifdef TRIO_REPLACE_STDIO
|
||||
/* Replace the <stdio.h> functions */
|
||||
#ifndef HAVE_PRINTF
|
||||
# undef printf
|
||||
# define printf trio_printf
|
||||
#endif
|
||||
#ifndef HAVE_VPRINTF
|
||||
# undef vprintf
|
||||
# define vprintf trio_vprintf
|
||||
#endif
|
||||
#ifndef HAVE_FPRINTF
|
||||
# undef fprintf
|
||||
# define fprintf trio_fprintf
|
||||
#endif
|
||||
#ifndef HAVE_VFPRINTF
|
||||
# undef vfprintf
|
||||
# define vfprintf trio_vfprintf
|
||||
#endif
|
||||
#ifndef HAVE_SPRINTF
|
||||
# undef sprintf
|
||||
# define sprintf trio_sprintf
|
||||
#endif
|
||||
#ifndef HAVE_VSPRINTF
|
||||
# undef vsprintf
|
||||
# define vsprintf trio_vsprintf
|
||||
#endif
|
||||
#ifndef HAVE_SNPRINTF
|
||||
# undef snprintf
|
||||
# define snprintf trio_snprintf
|
||||
#endif
|
||||
#ifndef HAVE_VSNPRINTF
|
||||
# undef vsnprintf
|
||||
# define vsnprintf trio_vsnprintf
|
||||
#endif
|
||||
#ifndef HAVE_SCANF
|
||||
# undef scanf
|
||||
# define scanf trio_scanf
|
||||
#endif
|
||||
#ifndef HAVE_VSCANF
|
||||
# undef vscanf
|
||||
# define vscanf trio_vscanf
|
||||
#endif
|
||||
#ifndef HAVE_FSCANF
|
||||
# undef fscanf
|
||||
# define fscanf trio_fscanf
|
||||
#endif
|
||||
#ifndef HAVE_VFSCANF
|
||||
# undef vfscanf
|
||||
# define vfscanf trio_vfscanf
|
||||
#endif
|
||||
#ifndef HAVE_SSCANF
|
||||
# undef sscanf
|
||||
# define sscanf trio_sscanf
|
||||
#endif
|
||||
#ifndef HAVE_VSSCANF
|
||||
# undef vsscanf
|
||||
# define vsscanf trio_vsscanf
|
||||
#endif
|
||||
/* These aren't stdio functions, but we make them look similar */
|
||||
#define dprintf trio_dprintf
|
||||
#define vdprintf trio_vdprintf
|
||||
#define aprintf trio_aprintf
|
||||
#define vaprintf trio_vaprintf
|
||||
#define asprintf trio_asprintf
|
||||
#define vasprintf trio_vasprintf
|
||||
#define dscanf trio_dscanf
|
||||
#define vdscanf trio_vdscanf
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* WITHOUT_TRIO */
|
||||
|
||||
#endif /* TRIO_TRIO_H */
|
228
triodef.h
228
triodef.h
@ -1,228 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
#ifndef TRIO_TRIODEF_H
|
||||
#define TRIO_TRIODEF_H
|
||||
|
||||
/*************************************************************************
|
||||
* Platform and compiler support detection
|
||||
*/
|
||||
#if defined(__GNUC__)
|
||||
# define TRIO_COMPILER_GCC
|
||||
#elif defined(__SUNPRO_C)
|
||||
# define TRIO_COMPILER_SUNPRO
|
||||
#elif defined(__SUNPRO_CC)
|
||||
# define TRIO_COMPILER_SUNPRO
|
||||
# define __SUNPRO_C __SUNPRO_CC
|
||||
#elif defined(__xlC__) || defined(__IBMC__) || defined(__IBMCPP__)
|
||||
# define TRIO_COMPILER_XLC
|
||||
#elif defined(_AIX) && !defined(__GNUC__)
|
||||
# define TRIO_COMPILER_XLC /* Workaround for old xlc */
|
||||
#elif defined(__DECC) || defined(__DECCXX)
|
||||
# define TRIO_COMPILER_DECC
|
||||
#elif defined(__osf__) && defined(__LANGUAGE_C__)
|
||||
# define TRIO_COMPILER_DECC /* Workaround for old DEC C compilers */
|
||||
#elif defined(_MSC_VER)
|
||||
# define TRIO_COMPILER_MSVC
|
||||
#elif defined(__BORLANDC__)
|
||||
# define TRIO_COMPILER_BCB
|
||||
#endif
|
||||
|
||||
#if defined(VMS) || defined(__VMS)
|
||||
/*
|
||||
* VMS is placed first to avoid identifying the platform as Unix
|
||||
* based on the DECC compiler later on.
|
||||
*/
|
||||
# define TRIO_PLATFORM_VMS
|
||||
#elif defined(__OS400__)
|
||||
# define TRIO_PLATFORM_OS400
|
||||
#elif defined(unix) || defined(__unix) || defined(__unix__)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(TRIO_COMPILER_XLC) || defined(_AIX)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(TRIO_COMPILER_DECC) || defined(__osf___)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(__NetBSD__)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(__Lynx__)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(__QNX__)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
# define TRIO_PLATFORM_QNX
|
||||
#elif defined(__CYGWIN__)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(AMIGA) && defined(TRIO_COMPILER_GCC)
|
||||
# define TRIO_PLATFORM_UNIX
|
||||
#elif defined(TRIO_COMPILER_MSVC) || defined(WIN32) || defined(_WIN32)
|
||||
# define TRIO_PLATFORM_WIN32
|
||||
#elif defined(mpeix) || defined(__mpexl)
|
||||
# define TRIO_PLATFORM_MPEIX
|
||||
#endif
|
||||
|
||||
#if defined(_AIX)
|
||||
# define TRIO_PLATFORM_AIX
|
||||
#elif defined(__hpux)
|
||||
# define TRIO_PLATFORM_HPUX
|
||||
#elif defined(sun) || defined(__sun__)
|
||||
# if defined(__SVR4) || defined(__svr4__)
|
||||
# define TRIO_PLATFORM_SOLARIS
|
||||
# else
|
||||
# define TRIO_PLATFORM_SUNOS
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(__STDC__) || defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
|
||||
# define TRIO_COMPILER_SUPPORTS_C89
|
||||
# if defined(__STDC_VERSION__)
|
||||
# define TRIO_COMPILER_SUPPORTS_C90
|
||||
# if (__STDC_VERSION__ >= 199409L)
|
||||
# define TRIO_COMPILER_SUPPORTS_C94
|
||||
# endif
|
||||
# if (__STDC_VERSION__ >= 199901L)
|
||||
# define TRIO_COMPILER_SUPPORTS_C99
|
||||
# endif
|
||||
# elif defined(TRIO_COMPILER_SUNPRO)
|
||||
# if (__SUNPRO_C >= 0x420)
|
||||
# define TRIO_COMPILER_SUPPORTS_C94
|
||||
# endif
|
||||
# endif
|
||||
#elif defined(TRIO_COMPILER_XLC) && defined(__EXTENDED__)
|
||||
# define TRIO_COMPILER_SUPPORTS_C89
|
||||
# define TRIO_COMPILER_SUPPORTS_C90
|
||||
# define TRIO_COMPILER_SUPPORTS_C94
|
||||
#endif
|
||||
|
||||
#if defined(_XOPEN_SOURCE)
|
||||
# if defined(_XOPEN_SOURCE_EXTENDED)
|
||||
# define TRIO_COMPILER_SUPPORTS_UNIX95
|
||||
# endif
|
||||
# if (_XOPEN_VERSION >= 500)
|
||||
# define TRIO_COMPILER_SUPPORTS_UNIX98
|
||||
# endif
|
||||
# if (_XOPEN_VERSION >= 600)
|
||||
# define TRIO_COMPILER_SUPPORTS_UNIX01
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*************************************************************************
|
||||
* Generic defines
|
||||
*/
|
||||
|
||||
#if !defined(TRIO_PUBLIC)
|
||||
# define TRIO_PUBLIC
|
||||
#endif
|
||||
#if !defined(TRIO_PRIVATE)
|
||||
# define TRIO_PRIVATE static
|
||||
#endif
|
||||
|
||||
#if !(defined(TRIO_COMPILER_SUPPORTS_C89) || defined(__cplusplus))
|
||||
# define TRIO_COMPILER_ANCIENT
|
||||
#endif
|
||||
|
||||
#if defined(TRIO_COMPILER_ANCIENT)
|
||||
# define TRIO_CONST
|
||||
# define TRIO_VOLATILE
|
||||
# define TRIO_SIGNED
|
||||
typedef double trio_long_double_t;
|
||||
typedef char * trio_pointer_t;
|
||||
# define TRIO_SUFFIX_LONG(x) x
|
||||
# define TRIO_PROTO(x) ()
|
||||
# define TRIO_NOARGS
|
||||
# define TRIO_ARGS1(list,a1) list a1;
|
||||
# define TRIO_ARGS2(list,a1,a2) list a1; a2;
|
||||
# define TRIO_ARGS3(list,a1,a2,a3) list a1; a2; a3;
|
||||
# define TRIO_ARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4;
|
||||
# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5;
|
||||
# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) list a1; a2; a3; a4; a5; a6;
|
||||
# define TRIO_VARGS2(list,a1,a2) list a1; a2
|
||||
# define TRIO_VARGS3(list,a1,a2,a3) list a1; a2; a3
|
||||
# define TRIO_VARGS4(list,a1,a2,a3,a4) list a1; a2; a3; a4
|
||||
# define TRIO_VARGS5(list,a1,a2,a3,a4,a5) list a1; a2; a3; a4; a5
|
||||
# define TRIO_VA_DECL va_dcl
|
||||
# define TRIO_VA_START(x,y) va_start(x)
|
||||
# define TRIO_VA_END(x) va_end(x)
|
||||
#else /* ANSI C */
|
||||
# define TRIO_CONST const
|
||||
# define TRIO_VOLATILE volatile
|
||||
# define TRIO_SIGNED signed
|
||||
typedef long double trio_long_double_t;
|
||||
typedef void * trio_pointer_t;
|
||||
# define TRIO_SUFFIX_LONG(x) x ## L
|
||||
# define TRIO_PROTO(x) x
|
||||
# define TRIO_NOARGS void
|
||||
# define TRIO_ARGS1(list,a1) (a1)
|
||||
# define TRIO_ARGS2(list,a1,a2) (a1,a2)
|
||||
# define TRIO_ARGS3(list,a1,a2,a3) (a1,a2,a3)
|
||||
# define TRIO_ARGS4(list,a1,a2,a3,a4) (a1,a2,a3,a4)
|
||||
# define TRIO_ARGS5(list,a1,a2,a3,a4,a5) (a1,a2,a3,a4,a5)
|
||||
# define TRIO_ARGS6(list,a1,a2,a3,a4,a5,a6) (a1,a2,a3,a4,a5,a6)
|
||||
# define TRIO_VARGS2 TRIO_ARGS2
|
||||
# define TRIO_VARGS3 TRIO_ARGS3
|
||||
# define TRIO_VARGS4 TRIO_ARGS4
|
||||
# define TRIO_VARGS5 TRIO_ARGS5
|
||||
# define TRIO_VA_DECL ...
|
||||
# define TRIO_VA_START(x,y) va_start(x,y)
|
||||
# define TRIO_VA_END(x) va_end(x)
|
||||
#endif
|
||||
|
||||
#if defined(TRIO_COMPILER_SUPPORTS_C99) || defined(__cplusplus)
|
||||
# define TRIO_INLINE inline
|
||||
#elif defined(TRIO_COMPILER_GCC)
|
||||
# define TRIO_INLINE __inline__
|
||||
#elif defined(TRIO_COMPILER_MSVC)
|
||||
# define TRIO_INLINE _inline
|
||||
#elif defined(TRIO_COMPILER_BCB)
|
||||
# define TRIO_INLINE __inline
|
||||
#else
|
||||
# define TRIO_INLINE
|
||||
#endif
|
||||
|
||||
/*************************************************************************
|
||||
* Workarounds
|
||||
*/
|
||||
|
||||
#if defined(TRIO_PLATFORM_VMS)
|
||||
/*
|
||||
* Computations done with constants at compile time can trigger these
|
||||
* even when compiling with IEEE enabled.
|
||||
*/
|
||||
# pragma message disable (UNDERFLOW, FLOATOVERFL)
|
||||
|
||||
# if (__CRTL_VER < 80000000)
|
||||
/*
|
||||
* Although the compiler supports C99 language constructs, the C
|
||||
* run-time library does not contain all C99 functions.
|
||||
*
|
||||
* This was the case for 70300022. Update the 80000000 value when
|
||||
* it has been accurately determined what version of the library
|
||||
* supports C99.
|
||||
*/
|
||||
# if defined(TRIO_COMPILER_SUPPORTS_C99)
|
||||
# undef TRIO_COMPILER_SUPPORTS_C99
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Not all preprocessors supports the LL token.
|
||||
*/
|
||||
#if defined(TRIO_COMPILER_BCB)
|
||||
#else
|
||||
# define TRIO_COMPILER_SUPPORTS_LL
|
||||
#endif
|
||||
|
||||
#endif /* TRIO_TRIODEF_H */
|
914
trionan.c
914
trionan.c
@ -1,914 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
************************************************************************
|
||||
*
|
||||
* Functions to handle special quantities in floating-point numbers
|
||||
* (that is, NaNs and infinity). They provide the capability to detect
|
||||
* and fabricate special quantities.
|
||||
*
|
||||
* Although written to be as portable as possible, it can never be
|
||||
* guaranteed to work on all platforms, as not all hardware supports
|
||||
* special quantities.
|
||||
*
|
||||
* The approach used here (approximately) is to:
|
||||
*
|
||||
* 1. Use C99 functionality when available.
|
||||
* 2. Use IEEE 754 bit-patterns if possible.
|
||||
* 3. Use platform-specific techniques.
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
/*
|
||||
* TODO:
|
||||
* o Put all the magic into trio_fpclassify_and_signbit(), and use this from
|
||||
* trio_isnan() etc.
|
||||
*/
|
||||
|
||||
/*************************************************************************
|
||||
* Include files
|
||||
*/
|
||||
#include "triodef.h"
|
||||
#include "trionan.h"
|
||||
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <float.h>
|
||||
#if defined(TRIO_PLATFORM_UNIX)
|
||||
# include <signal.h>
|
||||
#endif
|
||||
#if defined(TRIO_COMPILER_DECC)
|
||||
# if defined(__linux__)
|
||||
# include <cpml.h>
|
||||
# else
|
||||
# include <fp_class.h>
|
||||
# endif
|
||||
#endif
|
||||
#include <assert.h>
|
||||
|
||||
#if defined(TRIO_DOCUMENTATION)
|
||||
# include "doc/doc_nan.h"
|
||||
#endif
|
||||
/** @addtogroup SpecialQuantities
|
||||
@{
|
||||
*/
|
||||
|
||||
/*************************************************************************
|
||||
* Definitions
|
||||
*/
|
||||
|
||||
#define TRIO_TRUE (1 == 1)
|
||||
#define TRIO_FALSE (0 == 1)
|
||||
|
||||
/*
|
||||
* We must enable IEEE floating-point on Alpha
|
||||
*/
|
||||
#if defined(__alpha) && !defined(_IEEE_FP)
|
||||
# if defined(TRIO_COMPILER_DECC)
|
||||
# if defined(TRIO_PLATFORM_VMS)
|
||||
# error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE"
|
||||
# else
|
||||
# if !defined(_CFE)
|
||||
# error "Must be compiled with option -ieee"
|
||||
# endif
|
||||
# endif
|
||||
# elif defined(TRIO_COMPILER_GCC) && (defined(__osf__) || defined(__linux__))
|
||||
# error "Must be compiled with option -mieee"
|
||||
# endif
|
||||
#endif /* __alpha && ! _IEEE_FP */
|
||||
|
||||
/*
|
||||
* In ANSI/IEEE 754-1985 64-bits double format numbers have the
|
||||
* following properties (amongst others)
|
||||
*
|
||||
* o FLT_RADIX == 2: binary encoding
|
||||
* o DBL_MAX_EXP == 1024: 11 bits exponent, where one bit is used
|
||||
* to indicate special numbers (e.g. NaN and Infinity), so the
|
||||
* maximum exponent is 10 bits wide (2^10 == 1024).
|
||||
* o DBL_MANT_DIG == 53: The mantissa is 52 bits wide, but because
|
||||
* numbers are normalized the initial binary 1 is represented
|
||||
* implicitly (the so-called "hidden bit"), which leaves us with
|
||||
* the ability to represent 53 bits wide mantissa.
|
||||
*/
|
||||
#if (FLT_RADIX == 2) && (DBL_MAX_EXP == 1024) && (DBL_MANT_DIG == 53)
|
||||
# define USE_IEEE_754
|
||||
#endif
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
* Constants
|
||||
*/
|
||||
|
||||
static TRIO_CONST char rcsid[] = "@(#)$Id$";
|
||||
|
||||
#if defined(USE_IEEE_754)
|
||||
|
||||
/*
|
||||
* Endian-agnostic indexing macro.
|
||||
*
|
||||
* The value of internalEndianMagic, when converted into a 64-bit
|
||||
* integer, becomes 0x0706050403020100 (we could have used a 64-bit
|
||||
* integer value instead of a double, but not all platforms supports
|
||||
* that type). The value is automatically encoded with the correct
|
||||
* endianness by the compiler, which means that we can support any
|
||||
* kind of endianness. The individual bytes are then used as an index
|
||||
* for the IEEE 754 bit-patterns and masks.
|
||||
*/
|
||||
#define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)])
|
||||
|
||||
#if (defined(__BORLANDC__) && __BORLANDC__ >= 0x0590)
|
||||
static TRIO_CONST double internalEndianMagic = 7.949928895127362e-275;
|
||||
#else
|
||||
static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
|
||||
#endif
|
||||
|
||||
/* Mask for the exponent */
|
||||
static TRIO_CONST unsigned char ieee_754_exponent_mask[] = {
|
||||
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
/* Mask for the mantissa */
|
||||
static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = {
|
||||
0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
|
||||
};
|
||||
|
||||
/* Mask for the sign bit */
|
||||
static TRIO_CONST unsigned char ieee_754_sign_mask[] = {
|
||||
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
/* Bit-pattern for negative zero */
|
||||
static TRIO_CONST unsigned char ieee_754_negzero_array[] = {
|
||||
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
/* Bit-pattern for infinity */
|
||||
static TRIO_CONST unsigned char ieee_754_infinity_array[] = {
|
||||
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
/* Bit-pattern for quiet NaN */
|
||||
static TRIO_CONST unsigned char ieee_754_qnan_array[] = {
|
||||
0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
* Functions
|
||||
*/
|
||||
|
||||
/*
|
||||
* trio_make_double
|
||||
*/
|
||||
TRIO_PRIVATE double
|
||||
trio_make_double
|
||||
TRIO_ARGS1((values),
|
||||
TRIO_CONST unsigned char *values)
|
||||
{
|
||||
TRIO_VOLATILE double result;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < (int)sizeof(double); i++) {
|
||||
((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* trio_is_special_quantity
|
||||
*/
|
||||
TRIO_PRIVATE int
|
||||
trio_is_special_quantity
|
||||
TRIO_ARGS2((number, has_mantissa),
|
||||
double number,
|
||||
int *has_mantissa)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned char current;
|
||||
int is_special_quantity = TRIO_TRUE;
|
||||
|
||||
*has_mantissa = 0;
|
||||
|
||||
for (i = 0; i < (unsigned int)sizeof(double); i++) {
|
||||
current = ((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)];
|
||||
is_special_quantity
|
||||
&= ((current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i]);
|
||||
*has_mantissa |= (current & ieee_754_mantissa_mask[i]);
|
||||
}
|
||||
return is_special_quantity;
|
||||
}
|
||||
|
||||
/*
|
||||
* trio_is_negative
|
||||
*/
|
||||
TRIO_PRIVATE int
|
||||
trio_is_negative
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
unsigned int i;
|
||||
int is_negative = TRIO_FALSE;
|
||||
|
||||
for (i = 0; i < (unsigned int)sizeof(double); i++) {
|
||||
is_negative |= (((unsigned char *)&number)[TRIO_DOUBLE_INDEX(i)]
|
||||
& ieee_754_sign_mask[i]);
|
||||
}
|
||||
return is_negative;
|
||||
}
|
||||
|
||||
#endif /* USE_IEEE_754 */
|
||||
|
||||
|
||||
/**
|
||||
Generate negative zero.
|
||||
|
||||
@return Floating-point representation of negative zero.
|
||||
*/
|
||||
TRIO_PUBLIC double
|
||||
trio_nzero(TRIO_NOARGS)
|
||||
{
|
||||
#if defined(USE_IEEE_754)
|
||||
return trio_make_double(ieee_754_negzero_array);
|
||||
#else
|
||||
TRIO_VOLATILE double zero = 0.0;
|
||||
|
||||
return -zero;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Generate positive infinity.
|
||||
|
||||
@return Floating-point representation of positive infinity.
|
||||
*/
|
||||
TRIO_PUBLIC double
|
||||
trio_pinf(TRIO_NOARGS)
|
||||
{
|
||||
/* Cache the result */
|
||||
static double result = 0.0;
|
||||
|
||||
if (result == 0.0) {
|
||||
|
||||
#if defined(INFINITY) && defined(__STDC_IEC_559__)
|
||||
result = (double)INFINITY;
|
||||
|
||||
#elif defined(USE_IEEE_754)
|
||||
result = trio_make_double(ieee_754_infinity_array);
|
||||
|
||||
#else
|
||||
/*
|
||||
* If HUGE_VAL is different from DBL_MAX, then HUGE_VAL is used
|
||||
* as infinity. Otherwise we have to resort to an overflow
|
||||
* operation to generate infinity.
|
||||
*/
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
|
||||
# endif
|
||||
|
||||
result = HUGE_VAL;
|
||||
if (HUGE_VAL == DBL_MAX) {
|
||||
/* Force overflow */
|
||||
result += HUGE_VAL;
|
||||
}
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal(SIGFPE, signal_handler);
|
||||
# endif
|
||||
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
Generate negative infinity.
|
||||
|
||||
@return Floating-point value of negative infinity.
|
||||
*/
|
||||
TRIO_PUBLIC double
|
||||
trio_ninf(TRIO_NOARGS)
|
||||
{
|
||||
static double result = 0.0;
|
||||
|
||||
if (result == 0.0) {
|
||||
/*
|
||||
* Negative infinity is calculated by negating positive infinity,
|
||||
* which can be done because it is legal to do calculations on
|
||||
* infinity (for example, 1 / infinity == 0).
|
||||
*/
|
||||
result = -trio_pinf();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
Generate NaN.
|
||||
|
||||
@return Floating-point representation of NaN.
|
||||
*/
|
||||
TRIO_PUBLIC double
|
||||
trio_nan(TRIO_NOARGS)
|
||||
{
|
||||
/* Cache the result */
|
||||
static double result = 0.0;
|
||||
|
||||
if (result == 0.0) {
|
||||
|
||||
#if defined(TRIO_COMPILER_SUPPORTS_C99)
|
||||
result = nan("");
|
||||
|
||||
#elif defined(NAN) && defined(__STDC_IEC_559__)
|
||||
result = (double)NAN;
|
||||
|
||||
#elif defined(USE_IEEE_754)
|
||||
result = trio_make_double(ieee_754_qnan_array);
|
||||
|
||||
#else
|
||||
/*
|
||||
* There are several ways to generate NaN. The one used here is
|
||||
* to divide infinity by infinity. I would have preferred to add
|
||||
* negative infinity to positive infinity, but that yields wrong
|
||||
* result (infinity) on FreeBSD.
|
||||
*
|
||||
* This may fail if the hardware does not support NaN, or if
|
||||
* the Invalid Operation floating-point exception is unmasked.
|
||||
*/
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
|
||||
# endif
|
||||
|
||||
result = trio_pinf() / trio_pinf();
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal(SIGFPE, signal_handler);
|
||||
# endif
|
||||
|
||||
#endif
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
Check for NaN.
|
||||
|
||||
@param number An arbitrary floating-point number.
|
||||
@return Boolean value indicating whether or not the number is a NaN.
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_isnan
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
#if (defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isnan)) \
|
||||
|| defined(TRIO_COMPILER_SUPPORTS_UNIX95)
|
||||
/*
|
||||
* C99 defines isnan() as a macro. UNIX95 defines isnan() as a
|
||||
* function. This function was already present in XPG4, but this
|
||||
* is a bit tricky to detect with compiler defines, so we choose
|
||||
* the conservative approach and only use it for UNIX95.
|
||||
*/
|
||||
return isnan(number);
|
||||
|
||||
#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
|
||||
/*
|
||||
* Microsoft Visual C++ and Borland C++ Builder have an _isnan()
|
||||
* function.
|
||||
*/
|
||||
return _isnan(number) ? TRIO_TRUE : TRIO_FALSE;
|
||||
|
||||
#elif defined(USE_IEEE_754)
|
||||
/*
|
||||
* Examine IEEE 754 bit-pattern. A NaN must have a special exponent
|
||||
* pattern, and a non-empty mantissa.
|
||||
*/
|
||||
int has_mantissa;
|
||||
int is_special_quantity;
|
||||
|
||||
is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
|
||||
|
||||
return (is_special_quantity && has_mantissa);
|
||||
|
||||
#else
|
||||
/*
|
||||
* Fallback solution
|
||||
*/
|
||||
int status;
|
||||
double integral, fraction;
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
|
||||
# endif
|
||||
|
||||
status = (/*
|
||||
* NaN is the only number which does not compare to itself
|
||||
*/
|
||||
((TRIO_VOLATILE double)number != (TRIO_VOLATILE double)number) ||
|
||||
/*
|
||||
* Fallback solution if NaN compares to NaN
|
||||
*/
|
||||
((number != 0.0) &&
|
||||
(fraction = modf(number, &integral),
|
||||
integral == fraction)));
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal(SIGFPE, signal_handler);
|
||||
# endif
|
||||
|
||||
return status;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Check for infinity.
|
||||
|
||||
@param number An arbitrary floating-point number.
|
||||
@return 1 if positive infinity, -1 if negative infinity, 0 otherwise.
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_isinf
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
#if defined(TRIO_COMPILER_DECC) && !defined(__linux__)
|
||||
/*
|
||||
* DECC has an isinf() macro, but it works differently than that
|
||||
* of C99, so we use the fp_class() function instead.
|
||||
*/
|
||||
return ((fp_class(number) == FP_POS_INF)
|
||||
? 1
|
||||
: ((fp_class(number) == FP_NEG_INF) ? -1 : 0));
|
||||
|
||||
#elif defined(isinf)
|
||||
/*
|
||||
* C99 defines isinf() as a macro.
|
||||
*/
|
||||
return isinf(number)
|
||||
? ((number > 0.0) ? 1 : -1)
|
||||
: 0;
|
||||
|
||||
#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
|
||||
/*
|
||||
* Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
|
||||
* function that can be used to detect infinity.
|
||||
*/
|
||||
return ((_fpclass(number) == _FPCLASS_PINF)
|
||||
? 1
|
||||
: ((_fpclass(number) == _FPCLASS_NINF) ? -1 : 0));
|
||||
|
||||
#elif defined(USE_IEEE_754)
|
||||
/*
|
||||
* Examine IEEE 754 bit-pattern. Infinity must have a special exponent
|
||||
* pattern, and an empty mantissa.
|
||||
*/
|
||||
int has_mantissa;
|
||||
int is_special_quantity;
|
||||
|
||||
is_special_quantity = trio_is_special_quantity(number, &has_mantissa);
|
||||
|
||||
return (is_special_quantity && !has_mantissa)
|
||||
? ((number < 0.0) ? -1 : 1)
|
||||
: 0;
|
||||
|
||||
#else
|
||||
/*
|
||||
* Fallback solution.
|
||||
*/
|
||||
int status;
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
void (*signal_handler)(int) = signal(SIGFPE, SIG_IGN);
|
||||
# endif
|
||||
|
||||
double infinity = trio_pinf();
|
||||
|
||||
status = ((number == infinity)
|
||||
? 1
|
||||
: ((number == -infinity) ? -1 : 0));
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal(SIGFPE, signal_handler);
|
||||
# endif
|
||||
|
||||
return status;
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Temporary fix - this routine is not used anywhere */
|
||||
/**
|
||||
Check for finity.
|
||||
|
||||
@param number An arbitrary floating-point number.
|
||||
@return Boolean value indicating whether or not the number is a finite.
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_isfinite
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
#if defined(TRIO_COMPILER_SUPPORTS_C99) && defined(isfinite)
|
||||
/*
|
||||
* C99 defines isfinite() as a macro.
|
||||
*/
|
||||
return isfinite(number);
|
||||
|
||||
#elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
|
||||
/*
|
||||
* Microsoft Visual C++ and Borland C++ Builder use _finite().
|
||||
*/
|
||||
return _finite(number);
|
||||
|
||||
#elif defined(USE_IEEE_754)
|
||||
/*
|
||||
* Examine IEEE 754 bit-pattern. For finity we do not care about the
|
||||
* mantissa.
|
||||
*/
|
||||
int dummy;
|
||||
|
||||
return (! trio_is_special_quantity(number, &dummy));
|
||||
|
||||
#else
|
||||
/*
|
||||
* Fallback solution.
|
||||
*/
|
||||
return ((trio_isinf(number) == 0) && (trio_isnan(number) == 0));
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The sign of NaN is always false
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_fpclassify_and_signbit
|
||||
TRIO_ARGS2((number, is_negative),
|
||||
double number,
|
||||
int *is_negative)
|
||||
{
|
||||
#if defined(fpclassify) && defined(signbit)
|
||||
/*
|
||||
* C99 defines fpclassify() and signbit() as a macros
|
||||
*/
|
||||
*is_negative = signbit(number);
|
||||
switch (fpclassify(number)) {
|
||||
case FP_NAN:
|
||||
return TRIO_FP_NAN;
|
||||
case FP_INFINITE:
|
||||
return TRIO_FP_INFINITE;
|
||||
case FP_SUBNORMAL:
|
||||
return TRIO_FP_SUBNORMAL;
|
||||
case FP_ZERO:
|
||||
return TRIO_FP_ZERO;
|
||||
default:
|
||||
return TRIO_FP_NORMAL;
|
||||
}
|
||||
|
||||
#else
|
||||
# if defined(TRIO_COMPILER_DECC)
|
||||
/*
|
||||
* DECC has an fp_class() function.
|
||||
*/
|
||||
# define TRIO_FPCLASSIFY(n) fp_class(n)
|
||||
# define TRIO_QUIET_NAN FP_QNAN
|
||||
# define TRIO_SIGNALLING_NAN FP_SNAN
|
||||
# define TRIO_POSITIVE_INFINITY FP_POS_INF
|
||||
# define TRIO_NEGATIVE_INFINITY FP_NEG_INF
|
||||
# define TRIO_POSITIVE_SUBNORMAL FP_POS_DENORM
|
||||
# define TRIO_NEGATIVE_SUBNORMAL FP_NEG_DENORM
|
||||
# define TRIO_POSITIVE_ZERO FP_POS_ZERO
|
||||
# define TRIO_NEGATIVE_ZERO FP_NEG_ZERO
|
||||
# define TRIO_POSITIVE_NORMAL FP_POS_NORM
|
||||
# define TRIO_NEGATIVE_NORMAL FP_NEG_NORM
|
||||
|
||||
# elif defined(TRIO_COMPILER_MSVC) || defined(TRIO_COMPILER_BCB)
|
||||
/*
|
||||
* Microsoft Visual C++ and Borland C++ Builder have an _fpclass()
|
||||
* function.
|
||||
*/
|
||||
# define TRIO_FPCLASSIFY(n) _fpclass(n)
|
||||
# define TRIO_QUIET_NAN _FPCLASS_QNAN
|
||||
# define TRIO_SIGNALLING_NAN _FPCLASS_SNAN
|
||||
# define TRIO_POSITIVE_INFINITY _FPCLASS_PINF
|
||||
# define TRIO_NEGATIVE_INFINITY _FPCLASS_NINF
|
||||
# define TRIO_POSITIVE_SUBNORMAL _FPCLASS_PD
|
||||
# define TRIO_NEGATIVE_SUBNORMAL _FPCLASS_ND
|
||||
# define TRIO_POSITIVE_ZERO _FPCLASS_PZ
|
||||
# define TRIO_NEGATIVE_ZERO _FPCLASS_NZ
|
||||
# define TRIO_POSITIVE_NORMAL _FPCLASS_PN
|
||||
# define TRIO_NEGATIVE_NORMAL _FPCLASS_NN
|
||||
|
||||
# elif defined(FP_PLUS_NORM)
|
||||
/*
|
||||
* HP-UX 9.x and 10.x have an fpclassify() function, that is different
|
||||
* from the C99 fpclassify() macro supported on HP-UX 11.x.
|
||||
*
|
||||
* AIX has class() for C, and _class() for C++, which returns the
|
||||
* same values as the HP-UX fpclassify() function.
|
||||
*/
|
||||
# if defined(TRIO_PLATFORM_AIX)
|
||||
# if defined(__cplusplus)
|
||||
# define TRIO_FPCLASSIFY(n) _class(n)
|
||||
# else
|
||||
# define TRIO_FPCLASSIFY(n) class(n)
|
||||
# endif
|
||||
# else
|
||||
# define TRIO_FPCLASSIFY(n) fpclassify(n)
|
||||
# endif
|
||||
# define TRIO_QUIET_NAN FP_QNAN
|
||||
# define TRIO_SIGNALLING_NAN FP_SNAN
|
||||
# define TRIO_POSITIVE_INFINITY FP_PLUS_INF
|
||||
# define TRIO_NEGATIVE_INFINITY FP_MINUS_INF
|
||||
# define TRIO_POSITIVE_SUBNORMAL FP_PLUS_DENORM
|
||||
# define TRIO_NEGATIVE_SUBNORMAL FP_MINUS_DENORM
|
||||
# define TRIO_POSITIVE_ZERO FP_PLUS_ZERO
|
||||
# define TRIO_NEGATIVE_ZERO FP_MINUS_ZERO
|
||||
# define TRIO_POSITIVE_NORMAL FP_PLUS_NORM
|
||||
# define TRIO_NEGATIVE_NORMAL FP_MINUS_NORM
|
||||
# endif
|
||||
|
||||
# if defined(TRIO_FPCLASSIFY)
|
||||
switch (TRIO_FPCLASSIFY(number)) {
|
||||
case TRIO_QUIET_NAN:
|
||||
case TRIO_SIGNALLING_NAN:
|
||||
*is_negative = TRIO_FALSE; /* NaN has no sign */
|
||||
return TRIO_FP_NAN;
|
||||
case TRIO_POSITIVE_INFINITY:
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_INFINITE;
|
||||
case TRIO_NEGATIVE_INFINITY:
|
||||
*is_negative = TRIO_TRUE;
|
||||
return TRIO_FP_INFINITE;
|
||||
case TRIO_POSITIVE_SUBNORMAL:
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_SUBNORMAL;
|
||||
case TRIO_NEGATIVE_SUBNORMAL:
|
||||
*is_negative = TRIO_TRUE;
|
||||
return TRIO_FP_SUBNORMAL;
|
||||
case TRIO_POSITIVE_ZERO:
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_ZERO;
|
||||
case TRIO_NEGATIVE_ZERO:
|
||||
*is_negative = TRIO_TRUE;
|
||||
return TRIO_FP_ZERO;
|
||||
case TRIO_POSITIVE_NORMAL:
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_NORMAL;
|
||||
case TRIO_NEGATIVE_NORMAL:
|
||||
*is_negative = TRIO_TRUE;
|
||||
return TRIO_FP_NORMAL;
|
||||
default:
|
||||
/* Just in case... */
|
||||
*is_negative = (number < 0.0);
|
||||
return TRIO_FP_NORMAL;
|
||||
}
|
||||
|
||||
# else
|
||||
/*
|
||||
* Fallback solution.
|
||||
*/
|
||||
int rc;
|
||||
|
||||
if (number == 0.0) {
|
||||
/*
|
||||
* In IEEE 754 the sign of zero is ignored in comparisons, so we
|
||||
* have to handle this as a special case by examining the sign bit
|
||||
* directly.
|
||||
*/
|
||||
# if defined(USE_IEEE_754)
|
||||
*is_negative = trio_is_negative(number);
|
||||
# else
|
||||
*is_negative = TRIO_FALSE; /* FIXME */
|
||||
# endif
|
||||
return TRIO_FP_ZERO;
|
||||
}
|
||||
if (trio_isnan(number)) {
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_NAN;
|
||||
}
|
||||
if ((rc = trio_isinf(number))) {
|
||||
*is_negative = (rc == -1);
|
||||
return TRIO_FP_INFINITE;
|
||||
}
|
||||
if ((number > 0.0) && (number < DBL_MIN)) {
|
||||
*is_negative = TRIO_FALSE;
|
||||
return TRIO_FP_SUBNORMAL;
|
||||
}
|
||||
if ((number < 0.0) && (number > -DBL_MIN)) {
|
||||
*is_negative = TRIO_TRUE;
|
||||
return TRIO_FP_SUBNORMAL;
|
||||
}
|
||||
*is_negative = (number < 0.0);
|
||||
return TRIO_FP_NORMAL;
|
||||
|
||||
# endif
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Examine the sign of a number.
|
||||
|
||||
@param number An arbitrary floating-point number.
|
||||
@return Boolean value indicating whether or not the number has the
|
||||
sign bit set (i.e. is negative).
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_signbit
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
int is_negative;
|
||||
|
||||
(void)trio_fpclassify_and_signbit(number, &is_negative);
|
||||
return is_negative;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* Temporary fix - this routine is not used in libxml */
|
||||
/**
|
||||
Examine the class of a number.
|
||||
|
||||
@param number An arbitrary floating-point number.
|
||||
@return Enumerable value indicating the class of @p number
|
||||
*/
|
||||
TRIO_PUBLIC int
|
||||
trio_fpclassify
|
||||
TRIO_ARGS1((number),
|
||||
double number)
|
||||
{
|
||||
int dummy;
|
||||
|
||||
return trio_fpclassify_and_signbit(number, &dummy);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/** @} SpecialQuantities */
|
||||
|
||||
/*************************************************************************
|
||||
* For test purposes.
|
||||
*
|
||||
* Add the following compiler option to include this test code.
|
||||
*
|
||||
* Unix : -DSTANDALONE
|
||||
* VMS : /DEFINE=(STANDALONE)
|
||||
*/
|
||||
#if defined(STANDALONE)
|
||||
# include <stdio.h>
|
||||
|
||||
static TRIO_CONST char *
|
||||
getClassification
|
||||
TRIO_ARGS1((type),
|
||||
int type)
|
||||
{
|
||||
switch (type) {
|
||||
case TRIO_FP_INFINITE:
|
||||
return "FP_INFINITE";
|
||||
case TRIO_FP_NAN:
|
||||
return "FP_NAN";
|
||||
case TRIO_FP_NORMAL:
|
||||
return "FP_NORMAL";
|
||||
case TRIO_FP_SUBNORMAL:
|
||||
return "FP_SUBNORMAL";
|
||||
case TRIO_FP_ZERO:
|
||||
return "FP_ZERO";
|
||||
default:
|
||||
return "FP_UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
print_class
|
||||
TRIO_ARGS2((prefix, number),
|
||||
TRIO_CONST char *prefix,
|
||||
double number)
|
||||
{
|
||||
printf("%-6s: %s %-15s %g\n",
|
||||
prefix,
|
||||
trio_signbit(number) ? "-" : "+",
|
||||
getClassification(TRIO_FPCLASSIFY(number)),
|
||||
number);
|
||||
}
|
||||
|
||||
int main(TRIO_NOARGS)
|
||||
{
|
||||
double my_nan;
|
||||
double my_pinf;
|
||||
double my_ninf;
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
void (*signal_handler) TRIO_PROTO((int));
|
||||
# endif
|
||||
|
||||
my_nan = trio_nan();
|
||||
my_pinf = trio_pinf();
|
||||
my_ninf = trio_ninf();
|
||||
|
||||
print_class("Nan", my_nan);
|
||||
print_class("PInf", my_pinf);
|
||||
print_class("NInf", my_ninf);
|
||||
print_class("PZero", 0.0);
|
||||
print_class("NZero", -0.0);
|
||||
print_class("PNorm", 1.0);
|
||||
print_class("NNorm", -1.0);
|
||||
print_class("PSub", 1.01e-307 - 1.00e-307);
|
||||
print_class("NSub", 1.00e-307 - 1.01e-307);
|
||||
|
||||
printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_nan,
|
||||
((unsigned char *)&my_nan)[0],
|
||||
((unsigned char *)&my_nan)[1],
|
||||
((unsigned char *)&my_nan)[2],
|
||||
((unsigned char *)&my_nan)[3],
|
||||
((unsigned char *)&my_nan)[4],
|
||||
((unsigned char *)&my_nan)[5],
|
||||
((unsigned char *)&my_nan)[6],
|
||||
((unsigned char *)&my_nan)[7],
|
||||
trio_isnan(my_nan), trio_isinf(my_nan));
|
||||
printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_pinf,
|
||||
((unsigned char *)&my_pinf)[0],
|
||||
((unsigned char *)&my_pinf)[1],
|
||||
((unsigned char *)&my_pinf)[2],
|
||||
((unsigned char *)&my_pinf)[3],
|
||||
((unsigned char *)&my_pinf)[4],
|
||||
((unsigned char *)&my_pinf)[5],
|
||||
((unsigned char *)&my_pinf)[6],
|
||||
((unsigned char *)&my_pinf)[7],
|
||||
trio_isnan(my_pinf), trio_isinf(my_pinf));
|
||||
printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_ninf,
|
||||
((unsigned char *)&my_ninf)[0],
|
||||
((unsigned char *)&my_ninf)[1],
|
||||
((unsigned char *)&my_ninf)[2],
|
||||
((unsigned char *)&my_ninf)[3],
|
||||
((unsigned char *)&my_ninf)[4],
|
||||
((unsigned char *)&my_ninf)[5],
|
||||
((unsigned char *)&my_ninf)[6],
|
||||
((unsigned char *)&my_ninf)[7],
|
||||
trio_isnan(my_ninf), trio_isinf(my_ninf));
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal_handler = signal(SIGFPE, SIG_IGN);
|
||||
# endif
|
||||
|
||||
my_pinf = DBL_MAX + DBL_MAX;
|
||||
my_ninf = -my_pinf;
|
||||
my_nan = my_pinf / my_pinf;
|
||||
|
||||
# if defined(TRIO_PLATFORM_UNIX)
|
||||
signal(SIGFPE, signal_handler);
|
||||
# endif
|
||||
|
||||
printf("NaN : %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_nan,
|
||||
((unsigned char *)&my_nan)[0],
|
||||
((unsigned char *)&my_nan)[1],
|
||||
((unsigned char *)&my_nan)[2],
|
||||
((unsigned char *)&my_nan)[3],
|
||||
((unsigned char *)&my_nan)[4],
|
||||
((unsigned char *)&my_nan)[5],
|
||||
((unsigned char *)&my_nan)[6],
|
||||
((unsigned char *)&my_nan)[7],
|
||||
trio_isnan(my_nan), trio_isinf(my_nan));
|
||||
printf("PInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_pinf,
|
||||
((unsigned char *)&my_pinf)[0],
|
||||
((unsigned char *)&my_pinf)[1],
|
||||
((unsigned char *)&my_pinf)[2],
|
||||
((unsigned char *)&my_pinf)[3],
|
||||
((unsigned char *)&my_pinf)[4],
|
||||
((unsigned char *)&my_pinf)[5],
|
||||
((unsigned char *)&my_pinf)[6],
|
||||
((unsigned char *)&my_pinf)[7],
|
||||
trio_isnan(my_pinf), trio_isinf(my_pinf));
|
||||
printf("NInf: %4g 0x%02x%02x%02x%02x%02x%02x%02x%02x (%2d, %2d)\n",
|
||||
my_ninf,
|
||||
((unsigned char *)&my_ninf)[0],
|
||||
((unsigned char *)&my_ninf)[1],
|
||||
((unsigned char *)&my_ninf)[2],
|
||||
((unsigned char *)&my_ninf)[3],
|
||||
((unsigned char *)&my_ninf)[4],
|
||||
((unsigned char *)&my_ninf)[5],
|
||||
((unsigned char *)&my_ninf)[6],
|
||||
((unsigned char *)&my_ninf)[7],
|
||||
trio_isnan(my_ninf), trio_isinf(my_ninf));
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
84
trionan.h
84
trionan.h
@ -1,84 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2001 Bjorn Reese <breese@users.sourceforge.net>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
#ifndef TRIO_NAN_H
|
||||
#define TRIO_NAN_H
|
||||
|
||||
#include "triodef.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum {
|
||||
TRIO_FP_INFINITE,
|
||||
TRIO_FP_NAN,
|
||||
TRIO_FP_NORMAL,
|
||||
TRIO_FP_SUBNORMAL,
|
||||
TRIO_FP_ZERO
|
||||
};
|
||||
|
||||
/*
|
||||
* Return NaN (Not-a-Number).
|
||||
*/
|
||||
TRIO_PUBLIC double trio_nan TRIO_PROTO((void));
|
||||
|
||||
/*
|
||||
* Return positive infinity.
|
||||
*/
|
||||
TRIO_PUBLIC double trio_pinf TRIO_PROTO((void));
|
||||
|
||||
/*
|
||||
* Return negative infinity.
|
||||
*/
|
||||
TRIO_PUBLIC double trio_ninf TRIO_PROTO((void));
|
||||
|
||||
/*
|
||||
* Return negative zero.
|
||||
*/
|
||||
TRIO_PUBLIC double trio_nzero TRIO_PROTO((TRIO_NOARGS));
|
||||
|
||||
/*
|
||||
* If number is a NaN return non-zero, otherwise return zero.
|
||||
*/
|
||||
TRIO_PUBLIC int trio_isnan TRIO_PROTO((double number));
|
||||
|
||||
/*
|
||||
* If number is positive infinity return 1, if number is negative
|
||||
* infinity return -1, otherwise return 0.
|
||||
*/
|
||||
TRIO_PUBLIC int trio_isinf TRIO_PROTO((double number));
|
||||
|
||||
/*
|
||||
* If number is finite return non-zero, otherwise return zero.
|
||||
*/
|
||||
#if 0
|
||||
/* Temporary fix - these 2 routines not used in libxml */
|
||||
TRIO_PUBLIC int trio_isfinite TRIO_PROTO((double number));
|
||||
|
||||
TRIO_PUBLIC int trio_fpclassify TRIO_PROTO((double number));
|
||||
#endif
|
||||
|
||||
TRIO_PUBLIC int trio_signbit TRIO_PROTO((double number));
|
||||
|
||||
TRIO_PUBLIC int trio_fpclassify_and_signbit TRIO_PROTO((double number, int *is_negative));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* TRIO_NAN_H */
|
150
triop.h
150
triop.h
@ -1,150 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2000 Bjorn Reese and Daniel Stenberg.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
************************************************************************
|
||||
*
|
||||
* Private functions, types, etc. used for callback functions.
|
||||
*
|
||||
* The ref pointer is an opaque type and should remain as such.
|
||||
* Private data must only be accessible through the getter and
|
||||
* setter functions.
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
#ifndef TRIO_TRIOP_H
|
||||
#define TRIO_TRIOP_H
|
||||
|
||||
#include "triodef.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#if defined(TRIO_COMPILER_ANCIENT)
|
||||
# include <varargs.h>
|
||||
#else
|
||||
# include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef TRIO_C99
|
||||
# define TRIO_C99 1
|
||||
#endif
|
||||
#ifndef TRIO_BSD
|
||||
# define TRIO_BSD 1
|
||||
#endif
|
||||
#ifndef TRIO_GNU
|
||||
# define TRIO_GNU 1
|
||||
#endif
|
||||
#ifndef TRIO_MISC
|
||||
# define TRIO_MISC 1
|
||||
#endif
|
||||
#ifndef TRIO_UNIX98
|
||||
# define TRIO_UNIX98 1
|
||||
#endif
|
||||
#ifndef TRIO_MICROSOFT
|
||||
# define TRIO_MICROSOFT 1
|
||||
#endif
|
||||
#ifndef TRIO_EXTENSION
|
||||
# define TRIO_EXTENSION 1
|
||||
#endif
|
||||
#ifndef TRIO_WIDECHAR /* Does not work yet. Do not enable */
|
||||
# define TRIO_WIDECHAR 0
|
||||
#endif
|
||||
#ifndef TRIO_ERRORS
|
||||
# define TRIO_ERRORS 1
|
||||
#endif
|
||||
|
||||
#ifndef TRIO_MALLOC
|
||||
# define TRIO_MALLOC(n) malloc(n)
|
||||
#endif
|
||||
#ifndef TRIO_REALLOC
|
||||
# define TRIO_REALLOC(x,n) realloc((x),(n))
|
||||
#endif
|
||||
#ifndef TRIO_FREE
|
||||
# define TRIO_FREE(x) free(x)
|
||||
#endif
|
||||
|
||||
|
||||
/*************************************************************************
|
||||
* User-defined specifiers
|
||||
*/
|
||||
|
||||
typedef int (*trio_callback_t) TRIO_PROTO((trio_pointer_t));
|
||||
|
||||
trio_pointer_t trio_register TRIO_PROTO((trio_callback_t callback, const char *name));
|
||||
void trio_unregister TRIO_PROTO((trio_pointer_t handle));
|
||||
|
||||
TRIO_CONST char *trio_get_format TRIO_PROTO((trio_pointer_t ref));
|
||||
trio_pointer_t trio_get_argument TRIO_PROTO((trio_pointer_t ref));
|
||||
|
||||
/* Modifiers */
|
||||
int trio_get_width TRIO_PROTO((trio_pointer_t ref));
|
||||
void trio_set_width TRIO_PROTO((trio_pointer_t ref, int width));
|
||||
int trio_get_precision TRIO_PROTO((trio_pointer_t ref));
|
||||
void trio_set_precision TRIO_PROTO((trio_pointer_t ref, int precision));
|
||||
int trio_get_base TRIO_PROTO((trio_pointer_t ref));
|
||||
void trio_set_base TRIO_PROTO((trio_pointer_t ref, int base));
|
||||
int trio_get_padding TRIO_PROTO((trio_pointer_t ref));
|
||||
void trio_set_padding TRIO_PROTO((trio_pointer_t ref, int is_padding));
|
||||
int trio_get_short TRIO_PROTO((trio_pointer_t ref)); /* h */
|
||||
void trio_set_shortshort TRIO_PROTO((trio_pointer_t ref, int is_shortshort));
|
||||
int trio_get_shortshort TRIO_PROTO((trio_pointer_t ref)); /* hh */
|
||||
void trio_set_short TRIO_PROTO((trio_pointer_t ref, int is_short));
|
||||
int trio_get_long TRIO_PROTO((trio_pointer_t ref)); /* l */
|
||||
void trio_set_long TRIO_PROTO((trio_pointer_t ref, int is_long));
|
||||
int trio_get_longlong TRIO_PROTO((trio_pointer_t ref)); /* ll */
|
||||
void trio_set_longlong TRIO_PROTO((trio_pointer_t ref, int is_longlong));
|
||||
int trio_get_longdouble TRIO_PROTO((trio_pointer_t ref)); /* L */
|
||||
void trio_set_longdouble TRIO_PROTO((trio_pointer_t ref, int is_longdouble));
|
||||
int trio_get_alternative TRIO_PROTO((trio_pointer_t ref)); /* # */
|
||||
void trio_set_alternative TRIO_PROTO((trio_pointer_t ref, int is_alternative));
|
||||
int trio_get_alignment TRIO_PROTO((trio_pointer_t ref)); /* - */
|
||||
void trio_set_alignment TRIO_PROTO((trio_pointer_t ref, int is_leftaligned));
|
||||
int trio_get_spacing TRIO_PROTO((trio_pointer_t ref)); /* TRIO_PROTO((space) */
|
||||
void trio_set_spacing TRIO_PROTO((trio_pointer_t ref, int is_space));
|
||||
int trio_get_sign TRIO_PROTO((trio_pointer_t ref)); /* + */
|
||||
void trio_set_sign TRIO_PROTO((trio_pointer_t ref, int is_showsign));
|
||||
int trio_get_quote TRIO_PROTO((trio_pointer_t ref)); /* ' */
|
||||
void trio_set_quote TRIO_PROTO((trio_pointer_t ref, int is_quote));
|
||||
int trio_get_upper TRIO_PROTO((trio_pointer_t ref));
|
||||
void trio_set_upper TRIO_PROTO((trio_pointer_t ref, int is_upper));
|
||||
#if TRIO_C99
|
||||
int trio_get_largest TRIO_PROTO((trio_pointer_t ref)); /* j */
|
||||
void trio_set_largest TRIO_PROTO((trio_pointer_t ref, int is_largest));
|
||||
int trio_get_ptrdiff TRIO_PROTO((trio_pointer_t ref)); /* t */
|
||||
void trio_set_ptrdiff TRIO_PROTO((trio_pointer_t ref, int is_ptrdiff));
|
||||
int trio_get_size TRIO_PROTO((trio_pointer_t ref)); /* z / Z */
|
||||
void trio_set_size TRIO_PROTO((trio_pointer_t ref, int is_size));
|
||||
#endif
|
||||
|
||||
/* Printing */
|
||||
int trio_print_ref TRIO_PROTO((trio_pointer_t ref, const char *format, ...));
|
||||
int trio_vprint_ref TRIO_PROTO((trio_pointer_t ref, const char *format, va_list args));
|
||||
int trio_printv_ref TRIO_PROTO((trio_pointer_t ref, const char *format, trio_pointer_t *args));
|
||||
|
||||
void trio_print_int TRIO_PROTO((trio_pointer_t ref, int number));
|
||||
void trio_print_uint TRIO_PROTO((trio_pointer_t ref, unsigned int number));
|
||||
/* void trio_print_long TRIO_PROTO((trio_pointer_t ref, long number)); */
|
||||
/* void trio_print_ulong TRIO_PROTO((trio_pointer_t ref, unsigned long number)); */
|
||||
void trio_print_double TRIO_PROTO((trio_pointer_t ref, double number));
|
||||
void trio_print_string TRIO_PROTO((trio_pointer_t ref, char *string));
|
||||
void trio_print_pointer TRIO_PROTO((trio_pointer_t ref, trio_pointer_t pointer));
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* TRIO_TRIOP_H */
|
144
triostr.h
144
triostr.h
@ -1,144 +0,0 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
|
||||
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
|
||||
*
|
||||
************************************************************************/
|
||||
|
||||
#ifndef TRIO_TRIOSTR_H
|
||||
#define TRIO_TRIOSTR_H
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include "triodef.h"
|
||||
#include "triop.h"
|
||||
|
||||
enum {
|
||||
TRIO_HASH_NONE = 0,
|
||||
TRIO_HASH_PLAIN,
|
||||
TRIO_HASH_TWOSIGNED
|
||||
};
|
||||
|
||||
#if !defined(TRIO_STRING_PUBLIC)
|
||||
# if !defined(TRIO_PUBLIC)
|
||||
# define TRIO_PUBLIC
|
||||
# endif
|
||||
# define TRIO_STRING_PUBLIC TRIO_PUBLIC
|
||||
#endif
|
||||
|
||||
/*************************************************************************
|
||||
* String functions
|
||||
*/
|
||||
|
||||
TRIO_STRING_PUBLIC int trio_copy_max TRIO_PROTO((char *target, size_t max, const char *source));
|
||||
TRIO_STRING_PUBLIC char *trio_create TRIO_PROTO((size_t size));
|
||||
TRIO_STRING_PUBLIC void trio_destroy TRIO_PROTO((char *string));
|
||||
TRIO_STRING_PUBLIC char *trio_duplicate TRIO_PROTO((const char *source));
|
||||
TRIO_STRING_PUBLIC int trio_equal TRIO_PROTO((const char *first, const char *second));
|
||||
TRIO_STRING_PUBLIC int trio_equal_case TRIO_PROTO((const char *first, const char *second));
|
||||
TRIO_STRING_PUBLIC int trio_equal_locale TRIO_PROTO((const char *first, const char *second));
|
||||
TRIO_STRING_PUBLIC int trio_equal_max TRIO_PROTO((const char *first, size_t max, const char *second));
|
||||
TRIO_STRING_PUBLIC TRIO_CONST char *trio_error TRIO_PROTO((int));
|
||||
TRIO_STRING_PUBLIC size_t trio_length TRIO_PROTO((const char *string));
|
||||
TRIO_STRING_PUBLIC double trio_to_double TRIO_PROTO((const char *source, char **endp));
|
||||
TRIO_STRING_PUBLIC long trio_to_long TRIO_PROTO((const char *source, char **endp, int base));
|
||||
TRIO_STRING_PUBLIC trio_long_double_t trio_to_long_double TRIO_PROTO((const char *source, char **endp));
|
||||
TRIO_STRING_PUBLIC int trio_to_upper TRIO_PROTO((int source));
|
||||
|
||||
#if !defined(TRIO_MINIMAL)
|
||||
|
||||
TRIO_STRING_PUBLIC int trio_append TRIO_PROTO((char *target, const char *source));
|
||||
TRIO_STRING_PUBLIC int trio_append_max TRIO_PROTO((char *target, size_t max, const char *source));
|
||||
TRIO_STRING_PUBLIC int trio_contains TRIO_PROTO((const char *string, const char *substring));
|
||||
TRIO_STRING_PUBLIC int trio_copy TRIO_PROTO((char *target, const char *source));
|
||||
TRIO_STRING_PUBLIC char *trio_duplicate_max TRIO_PROTO((const char *source, size_t max));
|
||||
TRIO_STRING_PUBLIC int trio_equal_case_max TRIO_PROTO((const char *first, size_t max, const char *second));
|
||||
#if !defined(_WIN32_WCE)
|
||||
TRIO_STRING_PUBLIC size_t trio_format_date_max TRIO_PROTO((char *target, size_t max, const char *format, const struct tm *datetime));
|
||||
#endif
|
||||
TRIO_STRING_PUBLIC unsigned long trio_hash TRIO_PROTO((const char *string, int type));
|
||||
TRIO_STRING_PUBLIC char *trio_index TRIO_PROTO((const char *string, int character));
|
||||
TRIO_STRING_PUBLIC char *trio_index_last TRIO_PROTO((const char *string, int character));
|
||||
TRIO_STRING_PUBLIC int trio_lower TRIO_PROTO((char *target));
|
||||
TRIO_STRING_PUBLIC int trio_match TRIO_PROTO((const char *string, const char *pattern));
|
||||
TRIO_STRING_PUBLIC int trio_match_case TRIO_PROTO((const char *string, const char *pattern));
|
||||
TRIO_STRING_PUBLIC size_t trio_span_function TRIO_PROTO((char *target, const char *source, int (*Function) TRIO_PROTO((int))));
|
||||
TRIO_STRING_PUBLIC char *trio_substring TRIO_PROTO((const char *string, const char *substring));
|
||||
TRIO_STRING_PUBLIC char *trio_substring_max TRIO_PROTO((const char *string, size_t max, const char *substring));
|
||||
TRIO_STRING_PUBLIC float trio_to_float TRIO_PROTO((const char *source, char **endp));
|
||||
TRIO_STRING_PUBLIC int trio_to_lower TRIO_PROTO((int source));
|
||||
TRIO_STRING_PUBLIC unsigned long trio_to_unsigned_long TRIO_PROTO((const char *source, char **endp, int base));
|
||||
TRIO_STRING_PUBLIC char *trio_tokenize TRIO_PROTO((char *string, const char *delimiters));
|
||||
TRIO_STRING_PUBLIC int trio_upper TRIO_PROTO((char *target));
|
||||
|
||||
#endif /* !defined(TRIO_MINIMAL) */
|
||||
|
||||
/*************************************************************************
|
||||
* Dynamic string functions
|
||||
*/
|
||||
|
||||
/*
|
||||
* Opaque type for dynamic strings
|
||||
*/
|
||||
|
||||
typedef struct _trio_string_t trio_string_t;
|
||||
|
||||
TRIO_STRING_PUBLIC void trio_string_destroy TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC char *trio_string_extract TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC int trio_string_size TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC void trio_string_terminate TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_append_char TRIO_PROTO((trio_string_t *self, char character));
|
||||
TRIO_STRING_PUBLIC trio_string_t *trio_xstring_duplicate TRIO_PROTO((const char *other));
|
||||
|
||||
#if !defined(TRIO_MINIMAL)
|
||||
|
||||
TRIO_STRING_PUBLIC trio_string_t *trio_string_create TRIO_PROTO((int initial_size));
|
||||
TRIO_STRING_PUBLIC char *trio_string_get TRIO_PROTO((trio_string_t *self, int offset));
|
||||
TRIO_STRING_PUBLIC void trio_xstring_set TRIO_PROTO((trio_string_t *self, char *buffer));
|
||||
|
||||
TRIO_STRING_PUBLIC int trio_string_append TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_contains TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_copy TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC trio_string_t *trio_string_duplicate TRIO_PROTO((trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_equal TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_equal_max TRIO_PROTO((trio_string_t *self, size_t max, trio_string_t *second));
|
||||
TRIO_STRING_PUBLIC int trio_string_equal_case TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_equal_case_max TRIO_PROTO((trio_string_t *self, size_t max, trio_string_t *other));
|
||||
#if !defined(_WIN32_WCE)
|
||||
TRIO_STRING_PUBLIC size_t trio_string_format_date_max TRIO_PROTO((trio_string_t *self, size_t max, const char *format, const struct tm *datetime));
|
||||
#endif
|
||||
TRIO_STRING_PUBLIC char *trio_string_index TRIO_PROTO((trio_string_t *self, int character));
|
||||
TRIO_STRING_PUBLIC char *trio_string_index_last TRIO_PROTO((trio_string_t *self, int character));
|
||||
TRIO_STRING_PUBLIC int trio_string_length TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC int trio_string_lower TRIO_PROTO((trio_string_t *self));
|
||||
TRIO_STRING_PUBLIC int trio_string_match TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_match_case TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC char *trio_string_substring TRIO_PROTO((trio_string_t *self, trio_string_t *other));
|
||||
TRIO_STRING_PUBLIC int trio_string_upper TRIO_PROTO((trio_string_t *self));
|
||||
|
||||
TRIO_STRING_PUBLIC int trio_xstring_append TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_contains TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_copy TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_equal TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_equal_max TRIO_PROTO((trio_string_t *self, size_t max, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_equal_case TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_equal_case_max TRIO_PROTO((trio_string_t *self, size_t max, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_match TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC int trio_xstring_match_case TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
TRIO_STRING_PUBLIC char *trio_xstring_substring TRIO_PROTO((trio_string_t *self, const char *other));
|
||||
|
||||
#endif /* !defined(TRIO_MINIMAL) */
|
||||
|
||||
#endif /* TRIO_TRIOSTR_H */
|
@ -28,7 +28,6 @@ var verMicroSuffix;
|
||||
var verCvs;
|
||||
var useCvsVer = true;
|
||||
/* Libxml features. */
|
||||
var withTrio = false;
|
||||
var withThreads = "native";
|
||||
var withFtp = true;
|
||||
var withHttp = true;
|
||||
@ -113,7 +112,6 @@ function usage()
|
||||
txt += "Options can be specified in the form <option>=<value>, where the value is\n";
|
||||
txt += "either 'yes' or 'no', if not stated otherwise.\n\n";
|
||||
txt += "\nXML processor options, default value given in parentheses:\n\n";
|
||||
txt += " trio: Enable TRIO string manipulator (" + (withTrio? "yes" : "no") + ")\n";
|
||||
txt += " threads: Enable thread safety [no|ctls|native|posix] (" + (withThreads) + ") \n";
|
||||
txt += " ftp: Enable FTP client (" + (withFtp? "yes" : "no") + ")\n";
|
||||
txt += " http: Enable HTTP client (" + (withHttp? "yes" : "no") + ")\n";
|
||||
@ -209,7 +207,6 @@ function discoverVersion()
|
||||
cf.Close();
|
||||
vf.WriteLine("XML_SRCDIR=" + srcDirXml);
|
||||
vf.WriteLine("UTILS_SRCDIR=" + srcDirUtils);
|
||||
vf.WriteLine("WITH_TRIO=" + (withTrio? "1" : "0"));
|
||||
vf.WriteLine("WITH_THREADS=" + withThreads);
|
||||
vf.WriteLine("WITH_FTP=" + (withFtp? "1" : "0"));
|
||||
vf.WriteLine("WITH_HTTP=" + (withHttp? "1" : "0"));
|
||||
@ -296,8 +293,6 @@ function configureLibxml()
|
||||
verMajor*10000 + verMinor*100 + verMicro*1));
|
||||
} else if (s.search(/\@LIBXML_VERSION_EXTRA\@/) != -1) {
|
||||
of.WriteLine(s.replace(/\@LIBXML_VERSION_EXTRA\@/, verCvs));
|
||||
} else if (s.search(/\@WITH_TRIO\@/) != -1) {
|
||||
of.WriteLine(s.replace(/\@WITH_TRIO\@/, withTrio? "1" : "0"));
|
||||
} else if (s.search(/\@WITH_THREADS\@/) != -1) {
|
||||
of.WriteLine(s.replace(/\@WITH_THREADS\@/, withThreads == "no"? "0" : "1"));
|
||||
} else if (s.search(/\@WITH_THREAD_ALLOC\@/) != -1) {
|
||||
@ -451,9 +446,7 @@ for (i = 0; (i < WScript.Arguments.length) && (error == 0); i++) {
|
||||
if (opt.length == 0)
|
||||
opt = arg.substring(0, arg.indexOf(":"));
|
||||
if (opt.length > 0) {
|
||||
if (opt == "trio")
|
||||
withTrio = strToBool(arg.substring(opt.length + 1, arg.length));
|
||||
else if (opt == "threads")
|
||||
if (opt == "threads")
|
||||
withThreads = arg.substring(opt.length + 1, arg.length);
|
||||
else if (opt == "ftp")
|
||||
withFtp = strToBool(arg.substring(opt.length + 1, arg.length));
|
||||
@ -647,7 +640,6 @@ WScript.Echo("Created config.h.");
|
||||
// Display the final configuration.
|
||||
var txtOut = "\nXML processor configuration\n";
|
||||
txtOut += "---------------------------\n";
|
||||
txtOut += " Trio: " + boolToStr(withTrio) + "\n";
|
||||
txtOut += " Thread safety: " + withThreads + "\n";
|
||||
txtOut += " FTP client: " + boolToStr(withFtp) + "\n";
|
||||
txtOut += " HTTP client: " + boolToStr(withHttp) + "\n";
|
||||
|
Loading…
Reference in New Issue
Block a user