Remove trio printf().

This commit is contained in:
Matthias Clasen 2003-07-28 23:00:51 +00:00
parent 3c51de64fe
commit 352c03fd39
12 changed files with 0 additions and 10729 deletions

View File

@ -1,28 +0,0 @@
## Process this file with automake to produce Makefile.in
noinst_LTLIBRARIES = libtrio.la
libtrio_la_LIBADD = @TRIO_LIBS@
libtrio_la_SOURCES = \
trio.c \
trionan.c \
triostr.c \
trio.h \
triodef.h \
trionan.h \
triop.h \
triostr.h \
glibtrio.h
INCLUDES = -DTRIO_EXTENSION=0
EXTRA_DIST = README

View File

@ -1,27 +0,0 @@
The sources are derived from the trio package, version 1.9, by
Bjorn Reese and Daniel Stenberg, which can be found at:
http://daniel.haxx.se/trio/
http://sourceforge.net/projects/ctrio/
The license on the files taken from the trio package is reproduced
below.
Matthias Clasen
20 November 2002
====
Copyright (C) 1998-2001 by 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
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.

View File

@ -1,166 +0,0 @@
#define TrioCalcThousandSeparatorLength _GTrioCalcThousandSeparatorLength
#define TrioDuplicateMax _GTrioDuplicateMax
#define TrioFollowedBySeparator _GTrioFollowedBySeparator
#define TrioFormat _GTrioFormat
#define TrioFormatProcess _GTrioFormatProcess
#define TrioFormatRef _GTrioFormatRef
#define TrioGetCharacterClass _GTrioGetCharacterClass
#define TrioGetPosition _GTrioGetPosition
#define TrioInStreamCustom _GTrioInStreamCustom
#define TrioInStreamFile _GTrioInStreamFile
#define TrioInStreamFileDescriptor _GTrioInStreamFileDescriptor
#define TrioInStreamString _GTrioInStreamString
#define TrioIsQualifier _GTrioIsQualifier
#define TrioLogarithm _GTrioLogarithm
#define TrioLogarithmBase _GTrioLogarithmBase
#define TrioOutStreamCustom _GTrioOutStreamCustom
#define TrioOutStreamFile _GTrioOutStreamFile
#define TrioOutStreamFileDescriptor _GTrioOutStreamFileDescriptor
#define TrioOutStreamString _GTrioOutStreamString
#define TrioOutStreamStringDynamic _GTrioOutStreamStringDynamic
#define TrioOutStreamStringMax _GTrioOutStreamStringMax
#define TrioParse _GTrioParse
#define TrioPower _GTrioPower
#define TrioReadChar _GTrioReadChar
#define TrioReadDouble _GTrioReadDouble
#define TrioReadGroup _GTrioReadGroup
#define TrioReadNumber _GTrioReadNumber
#define TrioReadPointer _GTrioReadPointer
#define TrioReadString _GTrioReadString
#define TrioScan _GTrioScan
#define TrioScanProcess _GTrioScanProcess
#define TrioSetLocale _GTrioSetLocale
#define TrioSkipWhitespaces _GTrioSkipWhitespaces
#define TrioStringAlloc _GTrioStringAlloc
#define TrioStringGrow _GTrioStringGrow
#define TrioStringGrowTo _GTrioStringGrowTo
#define TrioWriteDouble _GTrioWriteDouble
#define TrioWriteNumber _GTrioWriteNumber
#define TrioWriteString _GTrioWriteString
#define TrioWriteStringCharacter _GTrioWriteStringCharacter
#define trio_append _g_trio_append
#define trio_append_max _g_trio_append_max
#define trio_aprintf _g_trio_aprintf
#define trio_asprintf _g_trio_asprintf
#define trio_contains _g_trio_contains
#define trio_copy _g_trio_copy
#define trio_copy_max _g_trio_copy_max
#define trio_cprintf _g_trio_cprintf
#define trio_cprintfv _g_trio_cprintfv
#define trio_create _g_trio_create
#define trio_cscanf _g_trio_cscanf
#define trio_cscanfv _g_trio_cscanfv
#define trio_destroy _g_trio_destroy
#define trio_dprintf _g_trio_dprintf
#define trio_dprintfv _g_trio_dprintfv
#define trio_dscanf _g_trio_dscanf
#define trio_dscanfv _g_trio_dscanfv
#define trio_duplicate _g_trio_duplicate
#define trio_duplicate_max _g_trio_duplicate_max
#define trio_equal _g_trio_equal
#define trio_equal_case _g_trio_equal_case
#define trio_equal_case_max _g_trio_equal_case_max
#define trio_equal_locale _g_trio_equal_locale
#define trio_equal_max _g_trio_equal_max
#define trio_error _g_trio_error
#define trio_format_date_max _g_trio_format_date_max
#define trio_fpclassify _g_trio_fpclassify
#define trio_fpclassify_and_signbit _g_trio_fpclassify_and_signbit
#define trio_fprintf _g_trio_fprintf
#define trio_fprintfv _g_trio_fprintfv
#define trio_fscanf _g_trio_fscanf
#define trio_fscanfv _g_trio_fscanfv
#define trio_hash _g_trio_hash
#define trio_index _g_trio_index
#define trio_index_last _g_trio_index_last
#define trio_is_negative _g_trio_is_negative
#define trio_is_special_quantity _g_trio_is_special_quantity
#define trio_isfinite _g_trio_isfinite
#define trio_isinf _g_trio_isinf
#define trio_isnan _g_trio_isnan
#define trio_length _g_trio_length
#define trio_locale_set_decimal_point _g_trio_locale_set_decimal_point
#define trio_locale_set_grouping _g_trio_locale_set_grouping
#define trio_locale_set_thousand_separator _g_trio_locale_set_thousand_separator
#define trio_lower _g_trio_lower
#define trio_make_double _g_trio_make_double
#define trio_match _g_trio_match
#define trio_match_case _g_trio_match_case
#define trio_nan _g_trio_nan
#define trio_ninf _g_trio_ninf
#define trio_nzero _g_trio_nzero
#define trio_pinf _g_trio_pinf
#define trio_print_pointer _g_trio_print_pointer
#define trio_printf _g_trio_printf
#define trio_printfv _g_trio_printfv
#define trio_scanf _g_trio_scanf
#define trio_scanfv _g_trio_scanfv
#define trio_signbit _g_trio_signbit
#define trio_snprintf _g_trio_snprintf
#define trio_snprintfcat _g_trio_snprintfcat
#define trio_snprintfv _g_trio_snprintfv
#define trio_span_function _g_trio_span_function
#define trio_sprintf _g_trio_sprintf
#define trio_sprintfv _g_trio_sprintfv
#define trio_sscanf _g_trio_sscanf
#define trio_sscanfv _g_trio_sscanfv
#define trio_strerror _g_trio_strerror
#define trio_string_append _g_trio_string_append
#define trio_string_contains _g_trio_string_contains
#define trio_string_copy _g_trio_string_copy
#define trio_string_create _g_trio_string_create
#define trio_string_destroy _g_trio_string_destroy
#define trio_string_duplicate _g_trio_string_duplicate
#define trio_string_equal _g_trio_string_equal
#define trio_string_equal_case _g_trio_string_equal_case
#define trio_string_equal_case_max _g_trio_string_equal_case_max
#define trio_string_equal_max _g_trio_string_equal_max
#define trio_string_extract _g_trio_string_extract
#define trio_string_format_date_max _g_trio_string_format_date_max
#define trio_string_get _g_trio_string_get
#define trio_string_index _g_trio_string_index
#define trio_string_index_last _g_trio_string_index_last
#define trio_string_length _g_trio_string_length
#define trio_string_lower _g_trio_string_lower
#define trio_string_match _g_trio_string_match
#define trio_string_match_case _g_trio_string_match_case
#define trio_string_size _g_trio_string_size
#define trio_string_substring _g_trio_string_substring
#define trio_string_terminate _g_trio_string_terminate
#define trio_string_upper _g_trio_string_upper
#define trio_substring _g_trio_substring
#define trio_substring_max _g_trio_substring_max
#define trio_to_double _g_trio_to_double
#define trio_to_float _g_trio_to_float
#define trio_to_long _g_trio_to_long
#define trio_to_long_double _g_trio_to_long_double
#define trio_to_unsigned_long _g_trio_to_unsigned_long
#define trio_tokenize _g_trio_tokenize
#define trio_upper _g_trio_upper
#define trio_vaprintf _g_trio_vaprintf
#define trio_vasprintf _g_trio_vasprintf
#define trio_vcprintf _g_trio_vcprintf
#define trio_vcscanf _g_trio_vcscanf
#define trio_vdprintf _g_trio_vdprintf
#define trio_vdscanf _g_trio_vdscanf
#define trio_vfprintf _g_trio_vfprintf
#define trio_vfscanf _g_trio_vfscanf
#define trio_vprintf _g_trio_vprintf
#define trio_vscanf _g_trio_vscanf
#define trio_vsnprintf _g_trio_vsnprintf
#define trio_vsnprintfcat _g_trio_vsnprintfcat
#define trio_vsprintf _g_trio_vsprintf
#define trio_vsscanf _g_trio_vsscanf
#define trio_xstring_append _g_trio_xstring_append
#define trio_xstring_append_char _g_trio_xstring_append_char
#define trio_xstring_contains _g_trio_xstring_contains
#define trio_xstring_copy _g_trio_xstring_copy
#define trio_xstring_duplicate _g_trio_xstring_duplicate
#define trio_xstring_equal _g_trio_xstring_equal
#define trio_xstring_equal_case _g_trio_xstring_equal_case
#define trio_xstring_equal_case_max _g_trio_xstring_equal_case_max
#define trio_xstring_equal_max _g_trio_xstring_equal_max
#define trio_xstring_match _g_trio_xstring_match
#define trio_xstring_match_case _g_trio_xstring_match_case
#define trio_xstring_set _g_trio_xstring_set
#define trio_xstring_substring _g_trio_xstring_substring

View File

@ -1,16 +0,0 @@
!IFDEF DEBUG
CRT=-MDd
!ELSE
CRT=-MD
!ENDIF
OBJECTS = \
trio.obj \
trionan.obj \
triostr.obj
trio.lib : $(OBJECTS)
lib -out:trio.lib $(OBJECTS)
.c.obj:
$(CC) $(CRT) -Ox -GD -c $<

File diff suppressed because it is too large Load Diff

View File

@ -1,216 +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
* MERCHANTIBILITY 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
#include <stdio.h>
#include <stdlib.h>
#if defined(TRIO_COMPILER_ANCIENT)
# include <varargs.h>
#else
# include <stdarg.h>
#endif
#if !defined(WITHOUT_TRIO)
/*
* Use autoconf defines if present. Packages using trio must define
* HAVE_CONFIG_H as a compiler option themselves.
*/
#if defined(HAVE_CONFIG_H)
# include <config.h>
#endif
#include "triodef.h"
#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
# define printf trio_printf
#endif
#ifndef HAVE_VPRINTF
# define vprintf trio_vprintf
#endif
#ifndef HAVE_FPRINTF
# define fprintf trio_fprintf
#endif
#ifndef HAVE_VFPRINTF
# define vfprintf trio_vfprintf
#endif
#ifndef HAVE_SPRINTF
# define sprintf trio_sprintf
#endif
#ifndef HAVE_VSPRINTF
# define vsprintf trio_vsprintf
#endif
#ifndef HAVE_SNPRINTF
# define snprintf trio_snprintf
#endif
#ifndef HAVE_VSNPRINTF
# define vsnprintf trio_vsnprintf
#endif
#ifndef HAVE_SCANF
# define scanf trio_scanf
#endif
#ifndef HAVE_VSCANF
# define vscanf trio_vscanf
#endif
#ifndef HAVE_FSCANF
# define fscanf trio_fscanf
#endif
#ifndef HAVE_VFSCANF
# define vfscanf trio_vfscanf
#endif
#ifndef HAVE_SSCANF
# define sscanf trio_sscanf
#endif
#ifndef HAVE_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 */

View File

@ -1,206 +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
* MERCHANTIBILITY 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(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(__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
#endif
#if defined(__STDC__) || defined(TRIO_COMPILER_MSVC)
# 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
#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
#endif /* TRIO_TRIODEF_H */

View File

@ -1,926 +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
* MERCHANTIBILITY 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 "glibtrio.h"
#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)
# include <fp_class.h>
#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 (amoungst 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
* endianess by the compiler, which means that we can support any
* kind of endianess. 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)])
static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
/* 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)
/*
* MSVC has an _isnan() function
*/
return _isnan(number);
#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)
/*
* 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)
/*
* MSVC has 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
}
/**
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)
/*
* MSVC uses _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
}
/*
* 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;
}
#elif defined(TRIO_COMPILER_DECC)
/*
* DECC has an fp_class() function.
*/
switch (fp_class(number)) {
case FP_QNAN:
case FP_SNAN:
*is_negative = TRIO_FALSE; /* NaN has no sign */
return TRIO_FP_NAN;
case FP_POS_INF:
*is_negative = TRIO_FALSE;
return TRIO_FP_INFINITE;
case FP_NEG_INF:
*is_negative = TRIO_TRUE;
return TRIO_FP_INFINITE;
case FP_POS_DENORM:
*is_negative = TRIO_FALSE;
return TRIO_FP_SUBNORMAL;
case FP_NEG_DENORM:
*is_negative = TRIO_TRUE;
return TRIO_FP_SUBNORMAL;
case FP_POS_ZERO:
*is_negative = TRIO_FALSE;
return TRIO_FP_ZERO;
case FP_NEG_ZERO:
*is_negative = TRIO_TRUE;
return TRIO_FP_ZERO;
case FP_POS_NORM:
*is_negative = TRIO_FALSE;
return TRIO_FP_NORMAL;
case FP_NEG_NORM:
*is_negative = TRIO_TRUE;
return TRIO_FP_NORMAL;
default:
/* Just in case... */
*is_negative = (number < 0.0);
return TRIO_FP_NORMAL;
}
#elif defined(TRIO_COMPILER_MSVC)
/*
* MSVC has an _fpclass() function.
*/
switch (_fpclass(number)) {
case _FPCLASS_QNAN:
case _FPCLASS_SNAN:
*is_negative = TRIO_FALSE;
return TRIO_FP_NAN;
case _FPCLASS_PINF:
*is_negative = TRIO_FALSE;
return TRIO_FP_INFINITE;
case _FPCLASS_NINF:
*is_negative = TRIO_TRUE;
return TRIO_FP_INFINITE;
case _FPCLASS_PD:
*is_negative = TRIO_FALSE;
return TRIO_FP_SUBNORMAL;
case _FPCLASS_ND:
*is_negative = TRIO_TRUE;
return TRIO_FP_SUBNORMAL;
case _FPCLASS_PZ:
*is_negative = TRIO_FALSE;
return TRIO_FP_ZERO;
case _FPCLASS_NZ:
*is_negative = TRIO_TRUE;
return TRIO_FP_ZERO;
case _FPCLASS_PN:
*is_negative = TRIO_FALSE;
return TRIO_FP_NORMAL;
case _FPCLASS_NN:
*is_negative = TRIO_TRUE;
return TRIO_FP_NORMAL;
default:
/* Just in case... */
*is_negative = (number < 0.0);
return TRIO_FP_NORMAL;
}
#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 fpclassify(x) _class(x)
# else
# define fpclassify(x) class(x)
# endif
# endif
switch (fpclassify(number)) {
case FP_QNAN:
case FP_SNAN:
*is_negative = TRIO_FALSE;
return TRIO_FP_NAN;
case FP_PLUS_INF:
*is_negative = TRIO_FALSE;
return TRIO_FP_INFINITE;
case FP_MINUS_INF:
*is_negative = TRIO_TRUE;
return TRIO_FP_INFINITE;
case FP_PLUS_DENORM:
*is_negative = TRIO_FALSE;
return TRIO_FP_SUBNORMAL;
case FP_MINUS_DENORM:
*is_negative = TRIO_TRUE;
return TRIO_FP_SUBNORMAL;
case FP_PLUS_ZERO:
*is_negative = TRIO_FALSE;
return TRIO_FP_ZERO;
case FP_MINUS_ZERO:
*is_negative = TRIO_TRUE;
return TRIO_FP_ZERO;
case FP_PLUS_NORM:
*is_negative = TRIO_FALSE;
return TRIO_FP_NORMAL;
case FP_MINUS_NORM:
*is_negative = TRIO_TRUE;
return TRIO_FP_NORMAL;
default:
assert(0);
}
#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
}
/**
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;
}
/**
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);
}
/** @} 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

View File

@ -1,81 +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
* MERCHANTIBILITY 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.
*/
TRIO_PUBLIC int trio_isfinite TRIO_PROTO((double number));
TRIO_PUBLIC int trio_signbit TRIO_PROTO((double number));
TRIO_PUBLIC int trio_fpclassify 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 */

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

File diff suppressed because it is too large Load Diff

View File

@ -1,127 +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
* MERCHANTIBILITY 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_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 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 char *trio_duplicate_max TRIO_PROTO((const char *source, size_t max));
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_case_max TRIO_PROTO((const char *first, size_t max, 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_format_date_max TRIO_PROTO((char *target, size_t max, const char *format, const struct tm *datetime));
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 size_t trio_length TRIO_PROTO((const char *string));
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 double trio_to_double TRIO_PROTO((const char *source, char **endp));
TRIO_STRING_PUBLIC float trio_to_float TRIO_PROTO((const char *source, char **endp));
TRIO_STRING_PUBLIC trio_long_double_t trio_to_long_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 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));
/*************************************************************************
* Dynamic string functions
*/
/*
* Opaque type for dynamic strings
*/
typedef struct _trio_string_t trio_string_t;
TRIO_STRING_PUBLIC trio_string_t *trio_string_create TRIO_PROTO((int initial_size));
TRIO_STRING_PUBLIC void trio_string_destroy TRIO_PROTO((trio_string_t *self));
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 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_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));
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));
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_char TRIO_PROTO((trio_string_t *self, char character));
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 trio_string_t *trio_xstring_duplicate TRIO_PROTO((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 /* TRIO_TRIOSTR_H */