lib/libxml2
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2025-07-30 22:43:14 +03:00
Code Activity

Remove Trio

Browse Source 
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:
Nick Wellnhofer
2023-11-23 15:48:52 +01:00
parent f5d4d33bfa
commit 7d6969d955
17 changed files with 6 additions and 10831 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
CMakeLists.txt
View File

@ -53,7 +53,6 @@ option(LIBXML2_WITH_TESTS "Build tests" ON)
option(LIBXML2_WITH_THREADS "Add multithread support" ON) option(LIBXML2_WITH_THREADS "Add multithread support" ON)
option(LIBXML2_WITH_THREAD_ALLOC "Add per-thread memory" OFF) option(LIBXML2_WITH_THREAD_ALLOC "Add per-thread memory" OFF)
option(LIBXML2_WITH_TREE "Add the DOM like tree manipulation APIs" ON) option(LIBXML2_WITH_TREE "Add the DOM like tree manipulation APIs" ON)
set(LIBXML2_WITH_TRIO OFF)
set(LIBXML2_WITH_UNICODE ON) set(LIBXML2_WITH_UNICODE ON)
option(LIBXML2_WITH_VALID "Add the DTD validation support" ON) option(LIBXML2_WITH_VALID "Add the DTD validation support" ON)
option(LIBXML2_WITH_WRITER "Add the xmlWriter saving interface" 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") CACHE PATH "Python bindings install directory")
endif() 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}) if(LIBXML2_${VARIABLE})
set(${VARIABLE} 1) set(${VARIABLE} 1)
else() else()
@ -330,10 +329,6 @@ if(WIN32)
) )
endif() 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_HDRS} ${LIBXML2_SRCS})
add_library(LibXml2::LibXml2 ALIAS LibXml2) add_library(LibXml2::LibXml2 ALIAS LibXml2)

6
Copyright
View File

@ -1,6 +1,6 @@
Except where otherwise noted in the source code (e.g. the files dict.c, Except where otherwise noted in the source code (e.g. the files dict.c and
list.c and the trio files, which are covered by a similar licence but list.c, which are covered by a similar licence but with different Copyright
with different Copyright notices) all the files are: notices) all the files are:
Copyright (C) 1998-2012 Daniel Veillard. All Rights Reserved. Copyright (C) 1998-2012 Daniel Veillard. All Rights Reserved.

6
Makefile.am
View File

@ -97,9 +97,6 @@ endif
if WITH_SCHEMATRON_SOURCES if WITH_SCHEMATRON_SOURCES
libxml2_la_SOURCES += schematron.c libxml2_la_SOURCES += schematron.c
endif endif
if WITH_TRIO_SOURCES
libxml2_la_SOURCES += triostr.c trio.c
endif
if WITH_WRITER_SOURCES if WITH_WRITER_SOURCES
libxml2_la_SOURCES += xmlwriter.c libxml2_la_SOURCES += xmlwriter.c
endif 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 \ check-xsddata-test-suite.py check-xinclude-test-suite.py \
example/Makefile.am example/gjobread.c example/gjobs.xml \ example/Makefile.am example/gjobread.c example/gjobs.xml \
libxml2-config.cmake.in autogen.sh \ libxml2-config.cmake.in autogen.sh \
trionan.c trionan.h triostr.c triostr.h trio.c trio.h \ libxml.h \
triop.h triodef.h libxml.h \
genUnicode.py \ genUnicode.py \
dbgen.pl dbgenattr.pl \ dbgen.pl dbgenattr.pl \
libxml2.syms timsort.h \ libxml2.syms timsort.h \

15
configure.ac
View File

@ -530,9 +530,6 @@ case ${host} in
*-*-solaris*) *-*-solaris*)
XML_LIBDIR="${XML_LIBDIR} -R${libdir}" XML_LIBDIR="${XML_LIBDIR} -R${libdir}"
;; ;;
hppa*-hp-mpeix)
NEED_TRIO=1
;;
*-*-cygwin* | *-*-mingw* | *-*-msys* ) *-*-cygwin* | *-*-mingw* | *-*-msys* )
# If the host is Windows, and shared libraries are disabled, we # If the host is Windows, and shared libraries are disabled, we
# need to add -DLIBXML_STATIC to AM_CFLAGS in order for linking to # 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) AC_SUBST(MODULE_EXTENSION)
AM_CONDITIONAL(WITH_MODULES_SOURCES, test "$WITH_MODULES" = "1") 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
dnl Thread-related stuff dnl Thread-related stuff
dnl dnl

4
doc/apibuild.py
View File

@ -19,10 +19,6 @@ debugsym=None
# C parser analysis code # C parser analysis code
# #
ignored_files = { 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", "config.h": "generated portability layer",
"libxml.h": "internal only", "libxml.h": "internal only",
"testOOM.c": "out of memory tester", "testOOM.c": "out of memory tester",

25
include/libxml/xmlversion.h.in
View File

@ -60,31 +60,6 @@ XMLPUBFUN void xmlCheckVersion(int version);
*/ */
#define LIBXML_TEST_VERSION xmlCheckVersion(@LIBXML_VERSION_NUMBER@); #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: * LIBXML_THREAD_ENABLED:
* *

5
libxml.h
View File

@ -38,11 +38,6 @@
#define SYSCONFDIR "/etc" #define SYSCONFDIR "/etc"
#endif #endif
#ifdef WITH_TRIO
#define TRIO_REPLACE_STDIO
#include "trio.h"
#endif
#if !defined(_WIN32) && \ #if !defined(_WIN32) && \
!defined(__CYGWIN__) && \ !defined(__CYGWIN__) && \
(defined(__clang__) || \ (defined(__clang__) || \

5
python/libxml.c
View File

@ -29,11 +29,6 @@
#include "libxml_wrap.h" #include "libxml_wrap.h"
#include "libxml2-py.h" #include "libxml2-py.h"
#if defined(WITH_TRIO)
#include "trio.h"
#define vsnprintf trio_vsnprintf
#endif
#if PY_MAJOR_VERSION >= 3 #if PY_MAJOR_VERSION >= 3
PyObject *PyInit_libxml2mod(void); PyObject *PyInit_libxml2mod(void);

6892
trio.c
View File

File diff suppressed because it is too large Load Diff

230
trio.h
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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 */

2112
triostr.c
View File

File diff suppressed because it is too large Load Diff

144
triostr.h
View File

@ -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 */

10
win32/configure.js
View File

@ -28,7 +28,6 @@ var verMicroSuffix;
var verCvs; var verCvs;
var useCvsVer = true; var useCvsVer = true;
/* Libxml features. */ /* Libxml features. */
var withTrio = false;
var withThreads = "native"; var withThreads = "native";
var withFtp = true; var withFtp = true;
var withHttp = 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 += "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 += "either 'yes' or 'no', if not stated otherwise.\n\n";
txt += "\nXML processor options, default value given in parentheses:\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 += " threads: Enable thread safety [no|ctls|native|posix] (" + (withThreads) + ") \n";
txt += " ftp: Enable FTP client (" + (withFtp? "yes" : "no") + ")\n"; txt += " ftp: Enable FTP client (" + (withFtp? "yes" : "no") + ")\n";
txt += " http: Enable HTTP client (" + (withHttp? "yes" : "no") + ")\n"; txt += " http: Enable HTTP client (" + (withHttp? "yes" : "no") + ")\n";
@ -209,7 +207,6 @@ function discoverVersion()
cf.Close(); cf.Close();
vf.WriteLine("XML_SRCDIR=" + srcDirXml); vf.WriteLine("XML_SRCDIR=" + srcDirXml);
vf.WriteLine("UTILS_SRCDIR=" + srcDirUtils); vf.WriteLine("UTILS_SRCDIR=" + srcDirUtils);
vf.WriteLine("WITH_TRIO=" + (withTrio? "1" : "0"));
vf.WriteLine("WITH_THREADS=" + withThreads); vf.WriteLine("WITH_THREADS=" + withThreads);
vf.WriteLine("WITH_FTP=" + (withFtp? "1" : "0")); vf.WriteLine("WITH_FTP=" + (withFtp? "1" : "0"));
vf.WriteLine("WITH_HTTP=" + (withHttp? "1" : "0")); vf.WriteLine("WITH_HTTP=" + (withHttp? "1" : "0"));
@ -296,8 +293,6 @@ function configureLibxml()
verMajor*10000 + verMinor*100 + verMicro*1)); verMajor*10000 + verMinor*100 + verMicro*1));
} else if (s.search(/\@LIBXML_VERSION_EXTRA\@/) != -1) { } else if (s.search(/\@LIBXML_VERSION_EXTRA\@/) != -1) {
of.WriteLine(s.replace(/\@LIBXML_VERSION_EXTRA\@/, verCvs)); 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) { } else if (s.search(/\@WITH_THREADS\@/) != -1) {
of.WriteLine(s.replace(/\@WITH_THREADS\@/, withThreads == "no"? "0" : "1")); of.WriteLine(s.replace(/\@WITH_THREADS\@/, withThreads == "no"? "0" : "1"));
} else if (s.search(/\@WITH_THREAD_ALLOC\@/) != -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) if (opt.length == 0)
opt = arg.substring(0, arg.indexOf(":")); opt = arg.substring(0, arg.indexOf(":"));
if (opt.length > 0) { if (opt.length > 0) {
if (opt == "trio") if (opt == "threads")
withTrio = strToBool(arg.substring(opt.length + 1, arg.length));
else if (opt == "threads")
withThreads = arg.substring(opt.length + 1, arg.length); withThreads = arg.substring(opt.length + 1, arg.length);
else if (opt == "ftp") else if (opt == "ftp")
withFtp = strToBool(arg.substring(opt.length + 1, arg.length)); withFtp = strToBool(arg.substring(opt.length + 1, arg.length));
@ -647,7 +640,6 @@ WScript.Echo("Created config.h.");
// Display the final configuration. // Display the final configuration.
var txtOut = "\nXML processor configuration\n"; var txtOut = "\nXML processor configuration\n";
txtOut += "---------------------------\n"; txtOut += "---------------------------\n";
txtOut += " Trio: " + boolToStr(withTrio) + "\n";
txtOut += " Thread safety: " + withThreads + "\n"; txtOut += " Thread safety: " + withThreads + "\n";
txtOut += " FTP client: " + boolToStr(withFtp) + "\n"; txtOut += " FTP client: " + boolToStr(withFtp) + "\n";
txtOut += " HTTP client: " + boolToStr(withHttp) + "\n"; txtOut += " HTTP client: " + boolToStr(withHttp) + "\n";