Copyright (C) 1994, 2015 Tydeman Consulting. All rights reserved.
Fred J. Tydeman tydeman@tybor.com
This file (readme.2nd) describes the setup of the entire FPCE test
suite.
HARD DISK SETUP
---- ---- -----
DOS and Window's C:\ is the 'same' as Unix and Linux's ~/ for paths
and directory separators. There is no requirement that these files go
on the C: disk for DOS, that is, they may go on any disk partition.
There is no requirement that these files go in your Unix home
directory ~/.
There is nothing special about the directory name ~/fpcets/, it can be
anything you wish.
It is assumed that the files of the FPCE Test Suite (the source) will
be in their own directories. The files are only read (so once the
install has been done, the files can be made read only). There are
many directories involved:
~/fpcets
~/fpcets/other
~/fpcets/unix2
~/fpcets/dos2
~/fpcets/manual
~/fpcets/common
~/fpcets/real
~/fpcets/real/bin
~/fpcets/real/bin/compiler
~/fpcets/real/bin/errors
~/fpcets/real/bin/error2
~/fpcets/real/bin/fenv
~/fpcets/real/bin/io
~/fpcets/real/bin/math
~/fpcets/real/dec
~/fpcets/real/dec/compiler
~/fpcets/real/dec/errors
~/fpcets/real/dec/fenv
~/fpcets/real/dec/io
~/fpcets/real/dec/math
A brief high-level description of the directory structure can be found
in the file readme.3rd.
In addition, for each compiler version or configuration being tested
there should be a directory tree where files will be written. These
directories need not be related to the source directories (~/fpcets).
For a two compiler setup, the directories might be like:
~/fpcets/compiler1
~/fpcets/compiler2
Under each of these compilerN directories, there is a 'target'
sub-directory tree that corresponds to the source sub-directory tree.
The top level 'make' does a 'cd' to each target leaf directory and
then invokes 'make' with the same target, e.g., all or bringup, with a
makefile in the corresponding source leaf directory.
In each compilerN, are the results of running wc (word count) so you
can check if your source files match Tydeman's.
In addition, if you want, you can put the files from the public web
site (or FTP site) into a sample directory:
~/fpcets/sample
~/fpcets should contain any shell scripts, batch files, .... common
to all compilers being tested.
~/fpcets/dos2 has files useful as starting points for setting up tests
on DOS and Windows systems.
~/fpcets/unix2 has files useful as starting points for setting up
tests on Unix and Linux systems.
~/fpcets/common should contain *.bug, *.flt, and pass.ret files.
~/fpcets/real/... should contain *.fjt, *.h, *.bug, *.flt files
related to testing of real (versus complex). The *.fjt files are
renamed to *.c, *.C, or *.cpp as they are copied to
~/fpcets/compilerN/real/....
~/fpcets/compilerN should have the setenv files, makefiles, bug and
flt files, batch (*.bat or *.cmd) or shell script (*.sh or *.csh)
files (copied from either the Dos, Unix or sample directory), tailored
for that compiler. The *.obj (or *.o), *.lib (or *.a), *.res and
*.bad files should be created here and in sub-directories. It is
assumed that this directory (and sub-directories) will be the current
directory when you invoke make.
INSTALLATION
------------
There is no install program.
1) Separate sections for DOS (or Windows) and Unix (or Linux) on
getting files from distribution media to correct directories.
a) For DOS / Windows (starting with fpcets.zip from the Tybor.com FTP site)
# In the following, there is nothing magic about the disk 'C:',
# the directory 'compilerN', nor the directory 'fpcets'.
# Create, or find, the directory to put the source code.
C:
mkdir fpcets
# Change to that directory:
cd fpcets
# Get fpcets.zip from the FTP site (in binary mode).
# The zip file of about 25 Meg will be expanded to about 80 Meg.
# Unzip that zip file, preserving the directory structure:
pkunzip -d *.zip
# That should create subdirectories:
# common
# dos2
# manual
# other
# real (and lots of subdirectories)
# unix2
# wcfiles
# You may encounter a hidden system file 'ea data. sf' that is
# unique to OS/2; it can be ignored. At this point, the zip
# related files may be deleted from the hard disk:
del *.zip
b) For Unix / Linux (starting with targzip.gz or fpcets.zip from the
Tybor.com FTP site)
# In the following, there is nothing magic about the directory
# 'compilerN', nor the directory 'fpcets'.
# Make the directory where to put the source code.
mkdir ~/fpcets/
# Change to that directory:
cd ~/fpcets/
# You have two methods to process the files.
# 1) gunzip (the *.gz file), then tar (the tar file).
# 2) unzip the *.zip file (this is what Tydeman does).
# Method 1)
# Get targzip.gz from the FTP site (in binary mode).
# The gzip file of about 25 Meg will be expanded to about 80 Meg.
# Expand the file:
gunzip targz*.gz # or gzip -d targz*.gz
gunzip TARGZ*.GZ # or gzip -d TARGZ*.GZ
# Extract the separate files:
tar -x -v -f targzip # or tar -xvf targzip
rm targz*
rm TARGZ*
# Method 2)
# An alternate method is to process the zip file (instead of
# gz file). This also is a way to convert the text files to
# have the correct line end and make filenames be lowercase.
# Get fpcets.zip from the FTP site (in binary mode).
# Expand the file:
unzip -u -a -aa -L fpcets.zip
rm fpcets.zip
# That should create subdirectories:
# common
# dos2
# manual
# other
# real (and lots of subdirectories)
# unix2
# wcfiles
# The file names here should all be lower case.
# Make the shell script files executable:
chmod +x *.sh *.csh
chmod +x unix2/*.sh unix2/*.csh
# Once you have a working setup (steps 2 thru 9 work), then you
# may do:
cd ~/fpcets/compilerN
source setenv.sh
# See if files in source directory tree are OK:
make check_wc
2) Review .../other/readme.1st item 3) The other three tests... for
instructions on configuring sample.bug. Using either sample.bug,
sample2.bug, sample3.bug or the lines after #error in mydefs.h,
create a new yourfile.bug for your compiler. Add a new
#elif (hardware) && (software)
as described in mydefs.h to include yourfile.bug. Feedback your
#elif line and #include line to Tydeman so he can put them in the
master mydefs.h. That way, when a new mydefs.h is distributed, you
will not have to reenter your modifications. If your compiler only
supports C89 (so called ANSI C), then it may be best to start with
sample3.bug as it is for compilers that know nothing about
or FPCE. If you need help, contact Tydeman.
3) Review .../other/readme.1st item 3) The other three tests... for
instructions on configuring sample.flt. Using either sample.flt or
the lines after #error in myfloat.h, create a new yourfile.flt for
your compiler. Add a new
#elif (hardware) && (software)
as described in myfloat.h to include yourfile.flt. Feedback your
#elif line and #include line to Tydeman so he can put them in the
master myfloat.h. That way, when a new myfloat.h is distributed,
you will not have to reenter your modifications. If you need help,
contact Tydeman.
4) If your compiler, library and hardware support control modes beyond
floating-point rounding (such as precision or trap enable/disable),
tailor the function fegetmodes() in the file .../common/s0000000.fjt
5) Tailor the setenv file. It defines to the global environment the
critial symbols (such as paths to the FPCE Test Suite and the
compiler being tested) needed by the makefiles and the files
invoked by the makefile. The name of the file depends upon your
operating system and command processor, e.g., setenv.bat,
setenv.cmd, setenv.sh, or setenv.csh
For Unix / Linux, my understanding is there are two families of shells:
sh, ksh, bash, ash, zsh, Posix
csh, tcsh
Here is a brief description of the things you need to tailor
(marked with: <-- CHECK THIS). By default, it is setup for Gnu gmake.
There are four symbols that define which set(s) of tests should be run.
They can be assigned the values 0 and 1. They are independent of each other.
The last two letters of the symbols describe the set:
R is Real, C is Complex, B is Binary FP, D is Decimal FP
By default, they are setup to do just the real binary floating-point tests.
If you are testing decimal FP, then set TEST_RD and TEST_CD to 1.
If you are testing complex binary, then set TEST_CB to 1.
TEST_RB = 1
TEST_RD = 0
TEST_CB = 0
TEST_CD = 0
BAT = file name suffix of files to execute commands. Most likely,
one of: sh, csh, bat, cmd. By default, the setenv.* files have
the correct suffix.
MAKE = The name of the 'make' program.
F = Command line argument to 'make' that tells 'make' that the next
command line argument is the name of the makefile. Some makes
require a blank between this argument and the file names,
other makes prohibit a blank, and some do not care. If the
blank is required, then do something like F="-f ".
FAKE = special dependent required by some makes to indicate that
this target is a symbolic name (rather than a real file to
create). Examples of symbolic names are: all, bringup, clean.
FAKE2 = special target required by some makes to indicate that all
the dependents are symbolic names (rather than real files to
create).
SRCDRV = DOS / Windows drive (partition) letter where the FPCE Test
Suite is. This is needed by chkwc to switch between drives (cd
does not switch drives).
SRCPATH = Base path name of where the source of the FPCE Test Suite is.
MDL = Memory model testing (mostly for DOS / Windows compilers).
VRM = Version / Release / Modification level of the compiler being
tested. This allows multilple similar compilers to be tested,
each in their own directory tree.
TRGTDRV = DOS / Windows drive (partition) letter where the results
will be. This is needed by chkwc to switch between drives (cd
does not switch drives).
TRGTABS = Base path name (without drive letter) of where the
results will be. It need not be related to SRCPATH. It might
contain ${MDL} or ${VRM}. This is the location where you need
to be to run make.
INCn = Directories to search for *.h files. n = 0 to 4 are the
places in the FPCE Test Suite source tree to search. You can
add you own directories if needed (make sure you also add them
to INCS and INCS2).
O = file type or suffix of object files created by the compiler.
Common names are 'o' and 'obj'.
CPATH = Path to the compiler being tested. Can be empty if the
compiler can be invoked via PATH.
CC = Name to use to invoke the compiler being tested.
CLFLAGS = Command line flags common to compiler and linker.
CFLAGS = Command line flags for compiler.
CFLAGS2 = Command line flags to suppress warnings.
CFLAGSW = Command line flags to allow extra warnings (for the
*2wrn.* files)
LFLAGS = Command line flags for the linker.
LIB2 = Command line flag to get the math library (and any other
needed libraries).
DEP = Common files that are dependents of (almost) everything.
That is, if any of these files change, then need to rerun all
tests. Can be set to nothing.
PATH = List of directories to search for executable programs.
INCLUDE = list of directories to search for include files.
LIB = list of directories to search for object libraries.
6) Create a makefile. There are sample makefiles provided
(makefile.unx, makefile.uny and makefile.dos) which you can use as
a starting point (which should be copied from either the Dos2 or
Unix2 directory to the compilerN directory and named makefile or
Makefile). If your 'make' can do implicit rules across directories
and redirection, then there is no need to call the external shell
scripts or batch files. If you need to use the external shell
scripts or batch files, they need to be tailored for the compiler
being tested. The sample makefiles are for both DOS and Unix. The
flow of file types is:
.fjt -> .c -> .o/.obj -> .exe -> .res
7) Run the setenv file so that 'make' will know where things are:
a) For DOS, Windows, or OS/2: setenv
b) For Unix or Linux: source setenv.sh or source setenv.csh
8) Make the target sub-directory structure and copy the makefiles to
those sub-directories by doing "make install". This will also copy
default *.bat, *.cmd, *.sh, or *.csh files to the current
directory. Tailor these files if needed (might be best to just try
them as is). Make those files executable (Unix: chmod +x *.sh *.csh).
9) Make the FPCE Test Suite support library by doing "make libsup"
(and perhaps "doitall").
10) Use make with that makefile to attempt to compile and run the critial
tests by doing: "make bringup" (and perhaps "doitall"). It does these tests:
e021* -- Find out what functions and macros are missing from headers.
t02602* -- Find out if functions are missing from object libraries.
t010* -- Find out if FPCE hex floating-point is supported.
t005* -- Find out if any traps need to be disabled at startup.
t000* -- Find out if myfloat.h and float.h are correct, consistent.
t00402* -- Find out if myfloat.h values are correct.
t008* -- Find out if decimal to binary conversions are correct.
Note: Last few lines of results file have the worst error found.
"grep Worse t008*.res" may help find the worst of the worst.
t02500* -- Find out if isnan() is correct.
t02406* -- Find out if isfinite() is correct.
t02907* -- Find out if -0.0 is supported and if -x flips sign of x.
t03102* -- Find out if casts do convert.
t210* -- Find out if feclearexcept() is correct.
t212* -- Find out if feraiseexcept() is correct.
t214* -- Find out if fetestexcept() is correct.
t32506* -- Find out if binary to decimal conversions are correct.
ulp_* (in s0000000) are needed for most math library function tests.
ulp_*() need either frexp/ldexp or logb/scalbn to be correct.
t133* -- Find out if frexp*() are correct.
t134* -- Find out if ldexp*() are correct.
t139* -- Find out if logb*() are correct.
t142* -- Find out if scalbn*() are correct.
t191* -- Find out if nan*() are correct.
e016* -- Find out if the macro operators accept integers or pointers.
If there are any failures, then add appropriate FIXs to your
*.bug file until the tests run "clean". See the Math Library
Tests section for some suggestions. You may also need to
tailor your *.flt file.
11) Use "make" with that "makefile" to attempt to compile and run all the
other tests by doing "make all" (and perhaps "doitall").
12) Analyze the output by doing "make summary". See next section on
what is expected.
13) If your compiler supports a way for the user to specify FLT_EVAL_METHOD,
then alter FLT_EVAL_METHOD to a new value and do: "make flteval",
"make bringup" and "make all". This will rerun those tests dependent
upon FLT_EVAL_METHOD.
14) If your compiler supports a way for the user to specify DEC_EVAL_METHOD,
then alter DEC_EVAL_METHOD to a new value and do: "make deceval",
"make bringup" and "make all". This will rerun those tests dependent
upon DEC_EVAL_METHOD.
15) If your compiler supports a way for the user to specify both
FLT_EVAL_METHOD and DEC_EVAL_METHOD, then alter one or the other
or both to a new value and do: "make eval", "make bringup" and "make all".
This will rerun just those few tests dependent upon BOTH of the symbols
FLT_EVAL_METHOD and DEC_EVAL_METHOD.
16) If your compiler supports more than three binary floating-point
types (a 4th FP type might be 80-bit extended or 128-bit quad),
you may test it/them by the use of QUAD_LDBL and/or QUAD_DBL. See
sample2.bug and sample2.flt for a starting point on such a usage.
TEST CASE NAMING CONVENTION
---- ---- ------ ----------
t*.fjt Test files that should compile and run without error. They may
have compile time warnings. Correct output is about 19 bytes
in the *.res files (size depends upon line end convention).
m*.fjt Manual review of output to check for absence of warnings during
the compile (shall, not a should). They shall run without error
(*.res files are about 19 bytes long). Since the Common warnings
annex says that extra warnings are allowed it is only a should.
w*.fjt Tests cases with expected compile time warnings. They should
still run and produce 19 byte *.res files.
e*.fjt Tests cases with compile time errors. They should not compile
nor run. If there are any e*.o or e*.obj files created, then
the error was not caught (which is bad).
s*.fjt Support files used by the tests.
g*.h Generic "macro" or "template" to test a math library function.
It is written so that it can test float, double or long double
(each of those three cases is a unique t*.fjt file that includes
the g*.h file). In turn, the g*.h file includes a v*.h file.
v*.h Test vectors used to define an array of structs. These files
are included (or read) by a g*.h file.
compile-time math lib fenv I/O lib
bin real t0* t1* t2* t3*
bin complex t4* t1*
dec real t6* t1* t8* t9*
dec complex t7* t1*
bessel tb*
stat ts*
MATH LIBRARY TESTS
---- ------- -----
There are several files for testing any one math library routine.
They are of the form:
tnnnF00M.fjt
gnnn0000.h
vnnn000M.h
where 'nnn' is a code to indicate which library routine is being tested,
'F' is a code to indicate the floating-point type being tested:
Binary FP Decimal FP
0 => double <= d == decimal
1 => float <= e
2 => long double <= f
3 => complex double <= a
4 => complex float <= b
5 => complex long double <= c == complex
6 => imaginary double <= g
7 => imaginary float <= h
8 => imaginary long double <= i == imaginary
and 'M' is a code to indicate kinds of numbers being tested
0 => IEEE-754 binary FP
1 => general (arg is 21-bits or less AND 6-digits or less)
2 => additional general. So far, only sine, cosine, and tangent
need this
3 => general (arg is 113-bits or less OR 34-digits or less)
The general kinds of numbers are exact decimal values that should
produce the same result for any radix, any precision and any C
floating-point type (float, double, or long double). The expected
result is in terms of an approximate decimal value with enough
precision so that it should be usable on any hardware (but it is
dependent upon the decimal to binary conversion done by the compiler).
Many of the argument values chosen are exactly representable in
binary, such as, 0.125 or 1.-1./64. There should not be any domain or
range errors for the values in the general files.
The IEEE-754 test vectors, have arguments of NaN, +/- infinity, -0.0,
or denormal; values that will produce NaN, +/- infinity, -0.0 or
denormal; values that depend upon the precision; values that produce
overflow, underflow, or invalid.
In the messages, FUT means Function Under Test.
Suggestions on how to have the math library tests run clean. In the
following 'xxx' is name (without 'f' or 'l' suffix) of the math
function.
1) If any of the failures are due to arguments being a Signaling NaN,
then the nan*() functions are bad (such as happens with gcc glibc's nanl()).
First, try:
#define FIX_FLAG_nan /* convert SNaN into QNaN */
If that fails, then try:
#define FIX_FUNCS_nan /* nan*() not really needed for sample */
#define FIX_FUNC_nan /* nan() not really needed for sample */
#define FIX_FUNC_nanl /* nanl() returns Signaling NaN */
2) If you get any failure messages about rounding, first try
#define IMPL_NO_STRONG_RND_xxx
3) If you still get any failure messages about rounding, next try
#define IMPL_NO_WEAK_RND_xxx
4) If you get any failure messages about flags and errno mismatches for
underflow cases, try
#define IMPL_UF_WIERD_xxx
5) If you still get any failure messages about flags and errno mismatches, try
#define FIX_ERRNO_MATH_xxx
6) If you get any failure messages about any FP exception flag, try
#define FIX_FLAG_xxx
7) If you wish to limit testing to just Round to Nearest, add
#define FIX_INEXACT_xxx
8) If you get any failure messages about too large ULP error, try
#define ULP_xxx 0.5
Replace the 0.5 with the value for max_ulp_err found at bottom of output file.
9) To suppress the printout of the maximum ULP error found by t1*3, try
#define IMPL_SUPPRESS_MAX_ULP_xxx
10) If you get many functions failing f(NAN) == same NAN, first try:
#define IMPL_SIGN_NAN
#define IMPL_SIGN_2NAN
If that does not help, then try:
#define IMPL_DIFF_NAN
#define IMPL_DIFF_2NAN
But, if you get only a few functions with this failure, try:
#define FIX_NAN_xxx
11) For many cases, you can exclude certain tests by excluding
arguments or results that meet certain conditions. Such as NaN,
zero, denormal, small (near minimum normal for type), large (near
maximum finite for type), infinity.
12) For functions that raise spurious underflows, try
#define FIX_BAD_UF_GOT_xxx
13) For functions that overflow at the wrong point, try
#define IMPL_SUPPRESS_OVER_xxx
14) If you still have failures, look at the g1*.h file at the line
listed in the failure message and see if that block of code is
covered by a FIX_..._xxx symbol.
FILES IN THIS TEST SUITE:
----- -- ---- ---- -----
In ../fpcets/other/
maint*.txt Files that describe changes done in each maintenance release.
operands.txt Describes the mapping from one letter or digit to a type.
opers.txt Describes the mapping from a two digit number to an operation
(some macros are considered operations).
readme.1st Describes the sample FPCE test suite files found at
ftp://ftp.tybor.com
These may be obtained via anonymous FTP or via the WWW.
readme.2nd This file. List of files in the entire test suite.
Instructions on how to install, tailor, and use the FPCE
test suite.
readme.3rd Describes the old and new diretory tree structure. Lists
the environment variables (setenv.*) used to describe
each directory.
sample.bug Minimal sample configuration and bug workaround file. It
shows how to define symbols to bypass known bugs in the
compiler, headers and/or library being tested. It is
included by mydefs.h.
sample.flt Sample floating-point and integral types definition file.
This defines the attributes of the hardware being tested.
It is included by myfloat.h.
sample2.bug More extensive sample configuration and bug workaround file.
sample2.flt Sample floating-point and integral types definition file.
This one uses the C99 hex floating-point format.
sample3.bug Sample configuration and bug workaround file for compilers
that have never heard of . Uses fenvdumy.h. This
would be for C89 (ANSI C) compilers.
In ../fpcets/unix2/
chkwc.csh Finds differences between source you have and Tydeman's source.
chkwc.sh Finds differences between source you have and Tydeman's source.
clean.csh Removes "result" files from current directory.
clean.sh Removes "result" files from current directory.
deldecev.csh Delete result files dependent upon DEC_EVAL_METHOD or IMPL_DEC_EVAL_*
deldecev.sh Delete result files dependent upon DEC_EVAL_METHOD or IMPL_DEC_EVAL_*
delfltev.csh Delete result files dependent upon FLT_EVAL_METHOD or IMPL_FLT_EVAL_*
delfltev.sh Delete result files dependent upon FLT_EVAL_METHOD or IMPL_FLT_EVAL_*
makefile.cb2 makefile for complex bin error#2 tests.
makefile.cbc makefile for complex bin compiler tests.
makefile.cbe makefile for complex bin error#1 tests.
makefile.cbm makefile for complex bin math tests.
makefile.cdc makefile for complex dec compiler tests.
makefile.cde makefile for complex dec error tests.
makefile.cdm makefile for complex dec math tests.
makefile.rb2 makefile for real bin error#2 tests.
makefile.rbc makefile for real bin compiler tests.
makefile.rbe makefile for real bin error#1 tests.
makefile.rbf makefile for real bin fenv tests.
makefile.rbi makefile for real bin I/O tests.
makefile.rbm makefile for real bin math tests.
makefile.rdc makefile for real dec compiler tests.
makefile.rde makefile for real dec error tests.
makefile.rdf makefile for real dec fenv tests.
makefile.rdi makefile for real dec I/O tests.
makefile.rdm makefile for real dec math tests.
makefile.unx Compile and run test suite under Unix (just binary FP).
makefile.uny Similare to makefile.unx, but not "ifeq".
setenv.csh Sets global environment symbols used in other files; C shell
setenv.sh Sets global environment symbols used in other files; Bourne shell
sum.csh Used to make a summary of the test results in one directory.
sum.sh Used to make a summary of the test results in one directory.
sum2.csh Lists # pass and not pass from summary results files.
sum2.sh Lists # pass and not pass from summary results files.
sumall.csh Runs sum2 in each target leaf directory.
sumall.sh Runs sum2 in each target leaf directory.
unx2bad.csh Used to compile: .fjt -> .bad
unx2bad.sh Used to compile: .fjt -> .bad
unx2lib.csh Used to create library: .o -> .a
unx2lib.sh Used to create library: .o -> .a
unx2obj.csh Used to compile: .fjt -> .o
unx2obj.sh Used to compile: .fjt -> .o
unx2res.csh Used to compile: .fjt -> .res
unx2res.sh Used to compile: .fjt -> .res
unx2wrn.csh Used to compile: .fjt -> .res w/ warnings or manual
unx2wrn.sh Used to compile: .fjt -> .res w/ warnings or manual
In ../fpcets/dos2/
arg2file.fjt Copies command line argument to doit.bat file. This is
needed for DOS make's that cannot run external batch files.
This allows make to be run to build doit.bat which contains
calls to the batch files to be run to build the out of date
targets. Sample usage is in makefile.dos.
cb.bat cd to each target complex bin leaf directory, run make
cd.bat cd to each target complex dec leaf directory, run make
chkwc.bat ((Needs work))
clean.bat Deletes result files from current (target leaf) directory.
deldecev.bat: Delete result files dependent upon DEC_EVAL_METHOD or IMPL_DEC_EVAL_*
deldecev.cmd: Delete result files dependent upon DEC_EVAL_METHOD or IMPL_DEC_EVAL_*
deldoit.bat Deletes doit.bat from each target leaf directory.
delfltev.bat: Delete result files dependent upon FLT_EVAL_METHOD or IMPL_FLT_EVAL_*
delfltev.cmd: Delete result files dependent upon FLT_EVAL_METHOD or IMPL_FLT_EVAL_*
doitall.bat Runs the doit.bat file in each target leaf directory.
dos2bad.bat Used by makefile for .fjt -> .bad
dos2lib.bat Used by makefile for .obj -> .lib
dos2obj.bat Used by makefile for .fjt -> .obj
dos2res.bat Used by makefile for .fjt -> .res
dos2wrn.bat Used by makefile for .fjt -> .res w/ warnings or manual
makeall.bat Calls other *.bat files to cd to each leaf and run make there.
makeall.cmd cd to each leaf and run make there.
makefile.cb2 makefile for complex bin error#2 tests.
makefile.cbc makefile for complex bin compiler tests.
makefile.cbe makefile for complex bin error#1 tests.
makefile.cbm makefile for complex bin math tests.
makefile.cdc makefile for complex dec compiler tests.
makefile.cde makefile for complex dec error tests.
makefile.cdm makefile for complex dec math tests.
makefile.dos Compile and run test suite under DOS.
makefile.rb2 makefile for real bin error#2 tests.
makefile.rbc makefile for real bin compiler tests.
makefile.rbe makefile for real bin error#1 tests.
makefile.rbf makefile for real bin fenv tests.
makefile.rbi makefile for real bin I/O tests.
makefile.rbm makefile for real bin math tests.
makefile.rdc makefile for real dec compiler tests.
makefile.rde makefile for real dec error tests.
makefile.rdf makefile for real dec fenv tests.
makefile.rdi makefile for real dec I/O tests.
makefile.rdm makefile for real dec math tests.
rb.bat cd to each target real bin leaf directory, run make
rd.bat cd to each target real dec leaf directory, run make
setenv.bat Sets global environment symbols used in other files.
sum.bat Lists "good" tests that produced "wrong" results.
sum.cmd Lists "good" tests that produced "wrong" results.
sumall.bat cd to each target leaf directory and call sum
sumall.cmd cd to each target leaf directory and call sum
sumerr.bat Lists "bad" tests that produced "wrong" results.
sumerr.cmd Lists "bad" tests that produced "wrong" results.
In ../fpcets/common/
c11float.h Macros added to by C11.
decfenv.h Dummy Decimal FP fenv.h mapping to Binary FP names.
decfloat.h Dummy Decimal FP float.h macros.
declib.h Dummy Decimal FP stdlib.h mapping to Binary FP names.
decmath.h Dummy Decimal FP math.h mapping to Binary FP names.
decmath2.h True Decimal FP math.h prototypes of s6000000.h functions.
decwchar.h Dummy Decimal FP wchar.h mapping to Binary FP names.
defline.h #define LINE __LINE__
do106113.bug *.bug file for simulating 106 and 113 bit FP on 64 bit FP system.
do106113.flt *.flt file for simulating 106 and 113 bit FP on 64 bit FP system.
fenvdumy.h Dummy useful for compilers that have never heard
of (such as existing C89 compilers). It is used
by sample3.bug by the use of the symbol FENV_H.
fenvx87.h Dummy useful for compilers that have never heard
of (such as existing C89 compilers) for Intel
80x86/80x87 based machines. It has implementations of some
fe*except() and fe*round() functions in terms of common
_*87() functions.
fenv*.h Various forms of FENV ACCESS pragma.
file1.h middle part of assert() macro call.
file2.h first part of assert() macro call.
fpcon*.h Various forms of FP CONTRACT pragma.
intdummy.h Subset of inttypes.h for systems missing inttypes.h
leaf.h ck() macro, SetSuccess() macro
line.h __LINE__
lineline.h #line __LINE__ and __LINE__
macline.h Start of macro invocation
mydefs.h Defines for required symbols not yet in correct place
myfloat.h FPCE hex constants of float.h values + others
myfuncs.h Prototypes of hex_ld, hex_d, hex_f, ulp_*, and s015* functions
pass.ret Expected output from tests.
s0000000.fjt hex_*(), ulp_*(), fegetmodes() support functions for binary FP
s6000000.fjt hex_*(), ulp_*(), fegetmodes() support functions for decimal FP
testsyms.h Test for existence of required FPCE macro symbols.
tbin2dec.h Uses mydefs.h
tdfp2dec.h Uses mydefs.h
tflt2int.h Uses mydefs.h
tint2flt.h Uses mydefs.h
tsin.h Uses mydefs.h
In ../fpcets/wcfiles/
*.wc Results of running word count (wc) against all the files
in the various sub-directories. They are used by your
makefile with a target of check_wc. Each *.wc file
corresponds to one sub-directory. The 2 and 3 letter
file names follow this shorthand:
r = real versus c = complex
b = binary FP versus d = decimal FP
c = compiler
e = errors
f = fenv
i = I/O
m = math
*.txt Statistics on code for each directory
*.tx2 Statistics on test vectors for each directory
In ../fpcets/manual/
m0100211.fjt Program to generate the e01003?? programs
m0210199.fjt Program to generate the e02102??, e02103?? and e02104?? programs
m0210200.h Old list of external FPCE functions in and
m0210201.h C99 list of external FPCE functions in and
In ../fpcets/override/
gendef.cmd OS/2 program to generate initial override.h file.
override.h Defines needed for v1*.ovr files.
v1??0001.ovr Overrides for corresponding v1??0001.h file. This is for
compilers that have poor translation time decimal to
binary conversions, but have good runtime conversions.
In ../fpcets/real/
g1100000.h acos() generic test case included by t110*.fjt
g1110000.h asin() generic test case included by t111*.fjt
g1110009.h asin() identity test case included by t111*9.fjt
g1120000.h atan() generic test case included by t112*.fjt
g1130000.h atan2() generic test case included by t113*.fjt
g1140000.h cos() generic test case included by t114*.fjt
g1150000.h sin() generic test case included by t115*.fjt
g1160000.h tan() generic test case included by t116*.fjt
g1200000.h acosh() generic test case included by t120*.fjt
g1210000.h asinh() generic test case included by t121*.fjt
g1220000.h atanh() generic test case included by t122*.fjt
g1230000.h cosh() generic test case included by t123*.fjt
g1240000.h sinh() generic test case included by t124*.fjt
g1250000.h tanh() generic test case included by t125*.fjt
g1300000.h exp() generic test case included by t130*.fjt
g1310000.h exp2() generic test case included by t131*.fjt
g1320000.h expm1() generic test case included by t132*.fjt
g1330000.h frexp() generic test case included by t133*.fjt
g1340000.h ldexp() generic test case included by t134*.fjt
g1350000.h log() generic test case included by t135*.fjt
g1360000.h log10() generic test case included by t136*.fjt
g1370000.h log1p() generic test case included by t137*.fjt
g1380000.h log2() generic test case included by t138*.fjt
g1390000.h logb() generic test case included by t139*.fjt
g1400000.h modf() generic test case included by t140*.fjt
g1420000.h scalbn() generic test case included by t142*.fjt
g1430000.h scalbln() generic test case included by t143*.fjt
g1440000.h ilogb() generic test case included by t144*.fjt
g1450000.h quantexp() generic test case included by t145*.fjt
g1470000.h quantize() generic test case included by t147*.fjt
g1500000.h fabs() generic test case included by t150*.fjt
g1510000.h hypot() generic test case included by t151*.fjt
g1520000.h pow() generic test case included by t152*.fjt
g1530000.h sqrt() generic test case included by t153*.fjt
g1540000.h cbrt() generic test case included by t154*.fjt
g1600000.h erf() generic test case included by t160*.fjt
g1610000.h erfc() generic test case included by t161*.fjt
g1620000.h tgamma() generic test case included by t162*.fjt
g1630000.h lgamma() generic test case included by t163*.fjt
g1700000.h ceil() generic test case included by t170*.fjt
g1710000.h floor() generic test case included by t171*.fjt
g1720000.h nearbyint() generic test case included by t172*.fjt
g1730000.h rint() generic test case included by t173*.fjt
g1740000.h lrint() generic test case included by t174*.fjt
g1750000.h round() generic test case included by t175*.fjt
g1760000.h lround() generic test case included by t176*.fjt
g1770000.h trunc() generic test case included by t177*.fjt
g1780000.h llrint() generic test case included by t178*.fjt
g1790000.h llround() generic test case included by t179*.fjt
g1800000.h fmod() generic test case included by t180*.fjt
g1810000.h remainder() generic test case included by t181*.fjt
g1820000.h remquo() generic test case included by t182*.fjt
g1820001.h remquo() test fixup code (got too big for main)
g1900000.h copysign() generic test case included by t190*.fjt
g1910000.h nan() generic test case included by t191*.fjt
g1920000.h nextafter() generic test case included by t192*.fjt
g1930000.h nexttoward() generic test case included by t193*.fjt
g1950000.h fdim() generic test case included by t195*.fjt
g1960000.h fmax() generic test case included by t196*.fjt
g1970000.h fmin() generic test case included by t197*.fjt
g1980000.h fma() generic test case included by t198*.fjt
g1errno.h Checks consistentcy between errno and FP exception flags.
g1rnd1.h Checks directed rounding of math functions (one argument).
g1rnd1i.h Checks directed rounding of math functions (one argument, int result).
g1rnd2.h Checks directed rounding of math functions (two arguments).
g1rnd3.h Checks directed rounding of math functions (three arguments).
g1xx0003.h Checks partial ULP and directed rounding of 1 arg math functions.
g1xy0003.h Checks partial ULP and directed rounding of 2 arg math functions.
v008007?.h Decimal constants IEEE DFP 7-digit test vectors
v008016?.h Decimal constants IEEE DFP 16-digit test vectors
v008034?.h Decimal constants IEEE DFP 34-digit test vectors
v0080100.h Decimal constants general #s test vectors
v0080108.h Hex FP constants general #s test vectors
v008023?.h 7 digit decimal constants to denormal IEEE 24-bit test vectors
v0080248.h Hex FP constants IEEE 24-bit test vectors
v008024?.h Decimal constants IEEE 24-bit test vectors
v008052?.h 16 digit decimal constants to denormal IEEE 53-bit test vectors
v0080538.h Hex FP constants IEEE 53-bit test vectors
v008053?.h Decimal constants IEEE 53-bit test vectors
v008063?.h 34 digit decimal constants to denormal IEEE 64-bit test vectors
v0080648.h Hex FP constants IEEE 64-bit test vectors
v008064?.h Decimal constants IEEE 64-bit test vectors
v0081068.h Hex FP constants double-double 106-bit test vectors
v008106?.h Decimal constants double-double 106-bit test vectors
v008112?.h 34 digit decimal constants to denormal IEEE 113-bit test vectors
v0081138.h Hex FP constants IEEE 113-bit test vectors
v008113?.h Decimal constants IEEE 113-bit test vectors
v1??0003.h Vectors for partial ULP error testing.
v110000?.h acos() test vectors included by g110*.h
v111000?.h asin() test vectors included by g111*.h
v112000?.h atan() test vectors included by g112*.h
v113000?.h atan2() test vectors included by g113*.h
v114000?.h cos() test vectors included by g114*.h
v115000?.h sin() test vectors included by g115*.h
v116000?.h tan() test vectors included by g116*.h
v120000?.h acosh() test vectors included by g120*.h
v121000?.h asinh() test vectors included by g121*.h
v122000?.h atanh() test vectors included by g122*.h
v123000?.h cosh() test vectors included by g123*.h
v124000?.h sinh() test vectors included by g124*.h
v125000?.h tanh() test vectors included by g125*.h
v130000?.h exp() test vectors included by g130*.h
v131000?.h exp2() test vectors included by g131*.h
v132000?.h expm1() test vectors included by g132*.h
v133000?.h frexp() test vectors included by g133*.h
v134000?.h ldexp() test vectors included by g134*.h
v135000?.h log() test vectors included by g135*.h
v136000?.h log10() test vectors included by g136*.h
v137000?.h log1p() test vectors included by g137*.h
v138000?.h log2() test vectors included by g138*.h
v139000?.h logb() test vectors included by g139*.h
v140000?.h modf() test vectors included by g140*.h
v142000?.h scalbn() test vectors included by g142*.h
v143000?.h scalbln() test vectors included by g143*.h
v144000?.h ilogb() test vectors included by g144*.h
v145000?.h quantexp() test vectors included by g145*.h
v147000?.h quantexp() test vectors included by g147*.h
v150000?.h fabs() test vectors included by g150*.h
v151000?.h hypot() test vectors included by g151*.h
v152000?.h pow() test vectors included by g152*.h
v153000?.h sqrt() test vectors included by g153*.h
v154000?.h cbrt() test vectors included by g154*.h
v160000?.h erf() test vectors included by g160*.h
v161000?.h erfc() test vectors included by g161*.h
v162000?.h tgamma() test vectors included by g162*.h
v163000?.h lgamma() test vectors included by g163*.h
v170000?.h ceil() test vectors included by g170*.h
v171000?.h floor() test vectors included by g171*.h
v172000?.h nearbyint() test vectors included by g172*.h
v173000?.h rint() test vectors included by g173*.h
v174000?.h lrint() test vectors included by g174*.h
v175000?.h round() test vectors included by g175*.h
v176000?.h lround() test vectors included by g176*.h
v177000?.h trunc() test vectors included by g177*.h
v178000?.h llrint() test vectors included by g178*.h
v179000?.h llround() test vectors included by g179*.h
v180000?.h fmod() test vectors included by g180*.h
v181000?.h remainder() test vectors included by g181*.h
v182000?.h remquo() test vectors included by g182*.h
v190000?.h copysign() test vectors included by g190*.h
v191000?.h nan() test vectors included by g191*.h
v192000?.h nextafter() test vectors included by g192*.h
v193000?.h nexttoward() test vectors included by g193*.h
v195000?.h fdim() test vectors included by g195*.h
v196000?.h fmax() test vectors included by g196*.h
v197000?.h fmin() test vectors included by g197*.h
v198000?.h fma() test vectors included by g198*.h
v306024?.h IEEE 24-bit test vectors for bin -> decimal conversion testing
v306053?.h IEEE 53-bit test vectors for bin -> decimal conversion testing
v306064?.h IEEE 64-bit test vectors for bin -> decimal conversion testing
v306106?.h double-double 106-bit test vectors for bin -> decimal conversion testing
v306113?.h IEEE 113-bit test vectors for bin -> decimal conversion testing
v30700??.h printf %f test vectors included by g307*.h, g347*.h, v907*.h
v30701??.h printf %e test vectors included by g307*.h, g347*.h, v907*.h
v30702??.h printf %g test vectors included by g307*.h, g347*.h, v907*.h
In ../fpcets/real/bin/
g0080100.h Decimal constants are converted correctly. Generic test.
g0880100.h Negative decimal constants are converted correctly. Generic test.
In ../fpcets/real/bin/compiler/
makefile Tells how to make files for this leaf directory (was makefile.cmp).
m0010000.fjt Unknown pragma
m0040040.fjt No Warnings of translation time Exceptions for inexact
m0040050.fjt No Warnings of translation time Exceptions for sizeof(1./0.)
t0000000.fjt myfloat.h and float.h are correct, consistent; ulp_*() OK.
t0000100.fjt sizeof(floating-point object) is correct
t0000200.fjt bool bit-fields: packing, size
t0000300.fjt Preprocessor token concatenation; # non-directive lines
t0000600.fjt *_HAS_SUBNORM, *_TRUE_MIN.
t0000700.fjt *_MIN is normalized (has full precision).
t0000800.fjt MAX_* and *_MAX are largest finite numbers.
t0000900.fjt Count number of 'digits' in various constants.
t0005000.fjt and *_PREC are correct.
t0010000.fjt + and - work as expected (addition table)
t0010100.fjt * and / work as expected (multiplication table)
t0010200.fjt many operations work for all integer types
t0010300.fjt * and / work as expected w.r.t. rounding
t0010400.fjt * and / work as expected w.r.t. rounding
t0010500.fjt * and / work as expected w.r.t. rounding for subnormals (ends)
t0010600.fjt * works as expected w.r.t. rounding for subnormals (mid-point)
t0010700.fjt / works as expected w.r.t. rounding for subnormals (mid-point)
t0011000.fjt signed bit-fields (16-bit int) work as expected
t0011100.fjt unsigned bit-fields (16-bit int) work as expected
t0011200.fjt plain (signed) bit-fields (16-bit int) work as expected
t0011300.fjt plain (unsigned) bit-fields (16-bit int) work as expected
t00114?0.fjt signed bit-fields (32-bit int) work as expected
t00115?0.fjt unsigned bit-fields (32-bit int) work as expected
t00116?0.fjt plain (signed) bit-fields (32-bit int) work as expected
t00117?0.fjt plain (unsigned) bit-fields (32-bit int) work as expected
t0011800.fjt bool bit-fields (16-bit int) work as expected
t0011900.fjt bool bit-fields (32-bit int) work as expected
t0012000.fjt Hex character constants of various number of digits
t0020000.fjt FENV_ACCESS pragma (many expressions to test optimization)
t0020600.fjt Dynamic rounding direction
t0030000.fjt Exception flags
t0040100.fjt Translation rounding direction
t0040200.fjt Translation rounding precision (many powers of 2)
t0040300.fjt Translation traps disabled
t0040400.fjt Translation arithmetic matches execution arithmetic
t0050000.fjt Startup: Exceptions flags are clear
t0050001.fjt Startup: Exceptions flags are clear; FENV_ACCESS off
t0050100.fjt Startup: Rounding direction
t0050101.fjt Startup: Rounding direction; FENV_ACCESS off
t0050200.fjt Startup: Rounding precision
t0050201.fjt Startup: Rounding precision; FENV_ACCESS off
t0050300.fjt Startup: Traps disabled
t0050301.fjt Startup: Traps disabled; FENV_ACCESS off
t0060000.fjt FLT_ROUNDS is dynamic
t0060100.fjt FLT_EVAL_METHOD (was _MIN_EVAL_FORMAT) is in
t0060300.fjt FLT_EVAL_METHOD (was _MIN_EVAL_FORMAT) is correct
t0060400.fjt FLT_EVAL_METHOD of translation time matches execution time
t0060500.fjt FLT_EVAL_METHOD w/ FP cast to int.
t0070000.fjt long double has more precision than double
t0070100.fjt double has more precision than float
t0070300.fjt C type float is IEEE single
t0070400.fjt C type double is IEEE double
t0070500.fjt C type long double is IEEE extended...
t0080000.fjt Constants are converted at translation time (many conversions)
t008007?.fjt Decimal constants are converted correctly IEEE DFP 7-digit
t008016?.fjt Decimal constants are converted correctly IEEE DFP 16-digit
t008034?.fjt Decimal constants are converted correctly IEEE DFP 34-digit
t0080100.fjt Decimal constants are converted correctly (general #s).
t0080108.fjt Hex FP constants are converted correctly (general #s).
t008023?.fjt Decimal constants are converted correctly IEEE 24-bit denormals
t0080248.fjt Hex FP constants are converted correctly IEEE 24-bit
t008024?.fjt Decimal constants are converted correctly IEEE 24-bit
t008052?.fjt Decimal constants are converted correctly IEEE 53-bit denormals
t0080538.fjt Hex FP constants are converted correctly IEEE 53-bit
t008053?.fjt Decimal constants are converted correctly IEEE 53-bit
t008063?.fjt Decimal constants are converted correctly IEEE 64-bit denormals
t0080648.fjt Hex FP constants are converted correctly IEEE 64-bit
t008064?.fjt Decimal constants are converted correctly IEEE 64-bit
t0081068.fjt Hex FP constants are converted correctly double-double 106-bit
t008106?.fjt Decimal constants are converted correctly double-double 106-bit
t008112?.fjt Decimal constants are converted correctly IEEE 113-bit denormals
t0081138.fjt Hex FP constants are converted correctly IEEE 113-bit
t008113?.fjt Decimal constants are converted correctly IEEE 113-bit
t0090000.fjt Translation-time conversion matches execution-time conversion
t0100000.fjt Hexadecimal floating constants (double) are valid floating-constants (each operator)
t0100001.fjt Hexadecimal floating constants (float) are valid floating-constants (each operator)
t0100002.fjt Hexadecimal floating constants (long double) are valid floating-constants (each operator)
t0100100.fjt pp-number allows P | p
t0100200.fjt Hexadecimal-floating-constant (valid forms)
t0110000.fjt Hexadecimal-floating-constants are rounded (many constants)
t0110200.fjt enum constants are of type int
t0120000.fjt Infinity converted to integral raises invalid
t0120100.fjt NaN converted to integral raises invalid
t0120200.fjt Large invalid FP integers converted to integral raises invalid (many conversions)
t0120250.fjt Large valid FP integers converted to integral raises nothing (many conversions)
t0120300.fjt Conversion from FP to integral truncates toward zero
t0120400.fjt Conversion from integral to FP rounds as per IEEE
t0120500.fjt Infinity converted to bool and bool bit-field
t0120600.fjt NaN converted to bool and bool bit-field
t0120700.fjt Finite FP converted to bool and bool bit-field
t0120800.fjt Integer converted to bool and bool bit-field
t0120900.fjt bool from BFP
t0130000.fjt Expression evaluation is one of the floating types
t0130100.fjt Expression evaluation (each operator)
t0140000.fjt Contraction operations
t0140100.fjt #pragma FP_CONTRACT affects contraction operations
t0140400.fjt Contraction operations honor infinities
t0140500.fjt Contraction operations honor NaNs
t0140600.fjt Contraction operations honor signed zeros w/ variables
t0140610.fjt Contraction operations honor signed zeros w/ constants
t0140700.fjt Contraction operations honor subnormals
t0140800.fjt Contraction operations raise exceptions
t0140900.fjt Contraction operations and inline
t0160000.fjt Arithmetic operators have correct precision, no double rounding.
t0160100.fjt Arithmetic operators (unary) are usable with floating-point operands.
t0160101.fjt Arithmetic operator (binary *) is usable with floating-point operands.
t0160102.fjt Arithmetic operator (binary /) is usable with floating-point operands.
t0160103.fjt Arithmetic operator (binary +) is usable with floating-point operands.
t0160104.fjt Arithmetic operator (binary -) is usable with floating-point operands.
t0160105.fjt Arithmetic operator (binary < ) is usable with floating-point operands.
t0160106.fjt Arithmetic operator (binary <=) is usable with floating-point operands.
t0160107.fjt Arithmetic operator (binary > ) is usable with floating-point operands.
t0160108.fjt Arithmetic operator (binary >=) is usable with floating-point operands.
t0160109.fjt Arithmetic operator (binary ==) is usable with floating-point operands.
t0160110.fjt Arithmetic operator (binary !=) is usable with floating-point operands.
t0160111.fjt Arithmetic operator (binary &&) is usable with floating-point operands.
t0160112.fjt Arithmetic operator (binary ||) is usable with floating-point operands.
t0160113.fjt Arithmetic operator (binary ?:) is usable with floating-point operands.
t0160114.fjt Arithmetic operator (binary =) is usable with floating-point operands.
t0160115.fjt Arithmetic operator (binary +=) is usable with floating-point operands.
t0160116.fjt Arithmetic operator (binary -=) is usable with floating-point operands.
t0160117.fjt Arithmetic operator (binary *=) is usable with floating-point operands.
t0160118.fjt Arithmetic operator (binary /=) is usable with floating-point operands.
t0160119.fjt Arithmetic operator (binary ,) is usable with floating-point operands.
t0160120.fjt Complicated arithmetic expressions are usable.
t0160129.fjt Arithmetic operator (binary ==) is usable with signed FP zeros.
t0160200.fjt Arithmetic operator (unary) is usable with FP and Bool operands.
t0160201.fjt Arithmetic operator (binary *) is usable with FP and Bool operands.
t0160202.fjt Arithmetic operator (binary /) is usable with FP and Bool operands.
t0160203.fjt Arithmetic operator (binary +) is usable with FP and Bool operands.
t0160204.fjt Arithmetic operator (binary -) is usable with FP and Bool operands.
t0160205.fjt Arithmetic operator (binary < ) is usable with FP and Bool operands.
t0160206.fjt Arithmetic operator (binary <=) is usable with FP and Bool operands.
t0160207.fjt Arithmetic operator (binary > ) is usable with FP and Bool operands.
t0160208.fjt Arithmetic operator (binary >=) is usable with FP and Bool operands.
t0160209.fjt Arithmetic operator (binary ==) is usable with FP and Bool operands.
t0160210.fjt Arithmetic operator (binary !=) is usable with FP and Bool operands.
t0160211.fjt Arithmetic operator (binary &&) is usable with FP and Bool operands.
t0160212.fjt Arithmetic operator (binary ||) is usable with FP and Bool operands.
t0160213.fjt Arithmetic operator (binary ?:) is usable with FP and Bool operands.
t0160214.fjt Arithmetic operator (binary =) is usable with FP and Bool operands.
t0160215.fjt Arithmetic operator (binary +=) is usable with FP and Bool operands.
t0160216.fjt Arithmetic operator (binary -=) is usable with FP and Bool operands.
t0160217.fjt Arithmetic operator (binary *=) is usable with FP and Bool operands.
t0160218.fjt Arithmetic operator (binary /=) is usable with FP and Bool operands.
t0160219.fjt Arithmetic operator (binary ,) is usable with FP and Bool operands.
t0160230.fjt Arithmetic operators are usable with FP and compound literal operands.
t0160301.fjt Arithmetic operator (binary *) is usable with arithmetic operands.
t0160302.fjt Arithmetic operator (binary /) is usable with arithmetic operands.
t0160303.fjt Arithmetic operator (binary +) is usable with arithmetic operands.
t0160304.fjt Arithmetic operator (binary -) is usable with arithmetic operands.
t0160305.fjt Arithmetic operator (binary <) is usable with arithmetic operands.
t0160306.fjt Arithmetic operator (binary <=) is usable with arithmetic operands.
t0160307.fjt Arithmetic operator (binary >) is usable with arithmetic operands.
t0160308.fjt Arithmetic operator (binary >=) is usable with arithmetic operands.
t0160309.fjt Arithmetic operator (binary ==) is usable with arithmetic operands.
t0160310.fjt Arithmetic operator (binary !=) is usable with arithmetic operands.
t0160311.fjt Arithmetic operator (binary &&) is usable with arithmetic operands.
t0160312.fjt Arithmetic operator (binary ||) is usable with arithmetic operands.
t0160313.fjt Arithmetic operator (triary ?:) is usable with arithmetic operands.
t0160314.fjt Arithmetic operator (binary =) is usable with arithmetic operands.
t0160315.fjt Arithmetic operator (binary +=) is usable with arithmetic operands.
t0160316.fjt Arithmetic operator (binary -=) is usable with arithmetic operands.
t0160317.fjt Arithmetic operator (binary *=) is usable with arithmetic operands.
t0160318.fjt Arithmetic operator (binary /=) is usable with arithmetic operands.
t0160319.fjt Arithmetic operator (binary ,) is usable with arithmetic operands.
t0160320.fjt Arithmetic operator (cast) is usable with arithmetic operands.
t0160321.fjt Arithmetic operator (parameter assignment) is usable with arithmetic operands.
t0160322.fjt Arithmetic operator (varargs parameter assignment) is usable with arithmetic operands.
t0160323.fjt Arithmetic operator (no prototype parameter assignment) is usable with arithmetic operands.
t0160324.fjt Arithmetic operator (old style parameter assignment) is usable with arithmetic operands.
t0160325.fjt Arithmetic operator (return) is usable with arithmetic operands.
t0160326.fjt Arithmetic operator (sizeof) is usable with arithmetic operands.
t0160327.fjt Arithmetic operator (unary & and *) is usable with arithmetic operands.
t0160328.fjt Arithmetic operator (unary .) is usable with arithmetic operands.
t0160329.fjt Arithmetic operator (unary ->) is usable with arithmetic operands.
t0160330.fjt Arithmetic operator (binary []) is usable with arithmetic operands.
t0160331.fjt Arithmetic operator (binary [] and VLA) is usable with arithmetic operands.
t0160332.fjt Arithmetic operator (binary [] and flex) is usable with arithmetic operands.
t0160333.fjt Arithmetic operator (unary post ++ and --) is usable with arithmetic operands.
t0160334.fjt Arithmetic operator (unary pre ++ and --) is usable with arithmetic operands.
t0160335.fjt Arithmetic operator (unary + and -) is usable with arithmetic operands.
t0160336.fjt Arithmetic operator (unary !) is usable with arithmetic operands.
t0160337.fjt Arithmetic operator (unary ~) is usable with arithmetic operands.
t0160338.fjt Arithmetic operator (binary %) is usable with arithmetic operands.
t0160339.fjt Arithmetic operator (binary <<) is usable with arithmetic operands.
t0160340.fjt Arithmetic operator (binary >>) is usable with arithmetic operands.
t0160341.fjt Arithmetic operator (binary &) is usable with arithmetic operands.
t0160342.fjt Arithmetic operator (binary ^) is usable with arithmetic operands.
t0160343.fjt Arithmetic operator (binary |) is usable with arithmetic operands.
t0160344.fjt Arithmetic operator (binary %=) is usable with arithmetic operands.
t0160345.fjt Arithmetic operator (binary <<=) is usable with arithmetic operands.
t0160346.fjt Arithmetic operator (binary >>=) is usable with arithmetic operands.
t0160347.fjt Arithmetic operator (binary &=) is usable with arithmetic operands.
t0160348.fjt Arithmetic operator (binary ^=) is usable with arithmetic operands.
t0160349.fjt Arithmetic operator (binary |=) is usable with arithmetic operands.
t0160350.fjt Arithmetic operator (isless) is usable with arithmetic operands.
t0160351.fjt Arithmetic operator (islessequal) is usable with arithmetic operands.
t0160352.fjt Arithmetic operator (isgreaterequal) is usable with arithmetic operands.
t0160353.fjt Arithmetic operator (isgreater) is usable with arithmetic operands.
t0160354.fjt Arithmetic operator (islessgreater) is usable with arithmetic operands.
t0160355.fjt Arithmetic operator (isunordered) is usable with arithmetic operands.
t0160360.fjt Arithmetic operator (fpclassify) is usable with arithmetic operands.
t0160361.fjt Arithmetic operator (isfinite) is usable with arithmetic operands.
t0160362.fjt Arithmetic operator (isinf) is usable with arithmetic operands.
t0160363.fjt Arithmetic operator (isnan) is usable with arithmetic operands.
t0160364.fjt Arithmetic operator (isnormal) is usable with arithmetic operands.
t0160365.fjt Arithmetic operator (signbit) is usable with arithmetic operands.
t0160400.fjt Arithmetic operator (compound =) is usable with arithmetic operands.
t0160900.fjt Integer promotions, usual arithmetic conversions, and [bool] bit-fields.
t01700?0.fjt Relational operator < yields 0, raises invalid for NaN
t01701?0.fjt Relational operator <= yields 0, raises invalid for NaN
t01702?0.fjt Relational operator >= yields 0, raises invalid for NaN
t01703?0.fjt Relational operator > yields 0, raises invalid for NaN
t0180000.fjt Constant expressions are execution time
t0180100.fjt Auto aggregate initializers are execution time
t0180601.fjt nonVLA array bound in struct
t0180701.fjt nonVLA array bound in union
t0180801.fjt static and nonVLA
t0180901.fjt extern and nonVLA
t0181001.fjt file scope and nonVLA
t0181101.fjt file scope typedef and nonVLA
t0181201.fjt initialization and nonVLA
t0181301.fjt compound literal and nonVLA
t0181401.fjt switch and nonVLA
t0181501.fjt goto and nonVLA
t0182100.fjt VLA w/ constant expression for size are execution time
t0182200.fjt Typedef VLA w/ constant expression for size are execution time
t0182300.fjt Recursion and VLA w/ constant expression for size are execution time
t0182400.fjt VLAs work as expected w/ FP types when passed to function.
t0182500.fjt Flexible arrays work as expected w/ FP types.
t0190000.fjt Auto (even aggregates) initialization is done at execution time
t0190100.fjt Static initialization is done at translation time
t0190200.fjt Characterictics of translation time FP expressions; precision, range, ...
t0190300.fjt Translation time FP expressions and designated initializer.
t0200000.fjt #elif(0) is not a function call (was test of __FPCE__)
t0200100.fjt __STDC_IEC_559__ (or __FPCE_IEEE__) is 1
t0210000.fjt fp.h and fenv.h functions are not built-in to compiler
t0220000.fjt strtof() prototype is in
t0220050.fjt strtof() prototype is only in
t0220100.fjt strtold() prototype is in
t0220150.fjt strtold() prototype is only in
t0220200.fjt strtod() prototype is in
t0220250.fjt strtod() prototype is only in
t0230000.fjt declares several things
t0230050.fjt external functions are not built-in
t0230100.fjt float_t
t0230200.fjt double_t
t0230300.fjt HUGE_VAL
t0230400.fjt HUGE_VALF
t0230500.fjt HUGE_VALL
t0230600.fjt INFINITY
t0230650.fjt INF_* op finite
t0230700.fjt NAN
t0230800.fjt FP_ILOGB0, FP_ILOGBNAN
t0230850.fjt FP_FAST_FMA, FP_FAST_FMAF, FP_FAST_FMAL
t0230900.fjt MATH_ERRNO, MATH_ERREXCEPT, math_errhandling
t0240000.fjt Conversions of infinity
t0240100.fjt Conversions of nan
t0240200.fjt FP_* classification macros are different
t0240300.fjt macros evaluate arguments exactly once
t0240400.fjt fpclassify()
t0240500.fjt signbit()
t0240600.fjt isfinite()
t0240700.fjt isnormal()
t0240800.fjt All classification macros with specific bit patterns.
t0240900.fjt isinf() macro
t0240950.fjt isinf() macro w/ MAX_DBL+MAX_DBL
t0250000.fjt isnan() macro
t0250050.fjt (x != x) is same as isnan() macro
t0250100.fjt Relational operator ( isless ) no raise invalid for NaN
t0250101.fjt Relational operator ( islessequal ) no raise invalid for NaN
t0250102.fjt Relational operator ( isgreaterequal ) no raise invalid for NaN
t0250103.fjt Relational operator ( isgreater ) no raise invalid for NaN
t0250200.fjt Relational operator ( islessgreater ) no raise invalid for NaN
t0250300.fjt Relational operator ( isunordered ) no raise invalid for NaN
t0250500.fjt DECIMAL_DIG is an int constant with certain value
t0250600.fjt *_DECIMAL_DIG is an int constant with certain value
t0260000.fjt Type-Generic functions are not built-in
t0260100.fjt Type-Generic functions of floating type arguments
t0260210.fjt FP_H C89 functions are linkable - Part A: trig functions
t0260220.fjt FP_H C89 functions are linkable - Part B: non-trig functions
t0260250.fjt FP_H FPCE functions are linkable - Part A
t0260260.fjt FP_H FPCE functions are linkable - Part B
t0260290.fjt functions are linkable
t0260400.fjt Type-Generic functions of specific values
t02605??.fjt Type-Generic 2-argument functions of bool and FP arguments
t0260600.fjt Type-Generic functions of integral type arguments
t0260700.fjt signgam is in user's name space
t0260800.fjt Type-Generic functions of FP const expression arguments
t0260900.fjt Type-Generic functions of FP compound literal arguments
t0270000.fjt external functions
t0270050.fjt external functions are not built-in
t0270100.fjt fenv_t
t0270200.fjt fexcept_t
t0270300.fjt FE_INVALID, FE_DIVBYZERO, FE_OVERFLOW, FE_UNDERFLOW, FE_INEXACT
t0270400.fjt FE_ALL_EXCEPT
t0270500.fjt FE_TONEAREST, FE_UPWARD, FE_DOWNWARD, FE_TOWARDZERO
t0270600.fjt FE_DFL_ENV is f.p. env at program startup
t0270700.fjt FE_DFL_ENV
t0280000.fjt Side effects of expressions cannot be optimized away
t0290000.fjt Removal of parentheses is invalid
t0290100.fjt Factoring is invalid
t0290200.fjt x-x .ne. 0
t0290300.fjt x-y .ne. -(y-x)
t0290400.fjt x/5.0 .ne. x*0.2
t0290500.fjt 0*x .ne. 0 and 0/x .ne. 0
t0290600.fjt 1*x .ne. x, x/1 .ne. x
t0290700.fjt 0+x .ne. x
t0290800.fjt x-0 .ne. x
t0290900.fjt 0-x .ne. -x
t0291000.fjt x/x .ne. 1
t0300000.fjt (x != x) .ne. false
t0300100.fjt (x == x) .ne. true
t0300200.fjt (x < y) .ne. isless(x,y)
t0300210.fjt (x <= y) .ne. islessequal(x,y)
t0300220.fjt (x >= y) .ne. isgreaterequal(x,y)
t0300230.fjt (x > y) .ne. isgreater(x,y)
t0300300.fjt a**=b?g:f
t0300310.fjt a<=b?f:g .ne. a>b?g:f
t0300400.fjt isless(x,y) same as < (for non-NaN arguments)
t0300500.fjt islessequal(x,y) same as <= (for non-NaN arguments)
t0300600.fjt isgreater(x,y) same as > (for non-NaN arguments)
t0300700.fjt isgreaterequal(x,y) same as >= (for non-NaN arguments)
t0300800.fjt islessgreater(x,y) same as < || > (for non-NaN simple arguments)
t0310100.fjt explicit store/load must round
t0310200.fjt casts and assignments must convert
t0310300.fjt casts of constants (DR 318)
t0320000.fjt HUGE_VAL* are +infinity
t0320100.fjt nan(), nanf(), nanl() all are declared
t0330000.fjt if( FP )
t0330100.fjt while( FP )
t0330200.fjt do while( FP )
t0330300.fjt for( ; FP ; )
t0350000.fjt macros are parenthesized
t0350001.fjt macros are parenthesized
t0350002.fjt macros are parenthesized
t0350004.fjt macros are parenthesized
t0350005.fjt macros are parenthesized
t0350006.fjt macros are parenthesized
t0350007.fjt macros are parenthesized
t0350008.fjt macros are parenthesized
t0350009.fjt macros are parenthesized
t0350010.fjt macros are parenthesized
t0350011.fjt macros are parenthesized
t0350012.fjt macros are parenthesized
t0350013.fjt macros are parenthesized
t0350014.fjt macros are parenthesized
t0350015.fjt macros are parenthesized
t0350016.fjt macros are parenthesized
t0350017.fjt macros are parenthesized
t03600*.fjt Permutations of keywords in declarations - real binary: func locals
t03601*.fjt "" - in 'for' statement
t0400000.fjt _Generic: controlling expression is not evaluated
t0400100.fjt _Generic: result expression
t0500000.fjt Long macro names
t0500100.fjt __LINE__ that spans multiple physical lines and line splicing.
t0500200.fjt __LINE__ and macros.
t0500300.fjt LINE that spans multiple physical lines and line splicing.
t0500400.fjt LINE and macros.
t0500500.fjt Dynamic __LINE__; a ## b.
t0500600.fjt __LINE__ and macro invocation in two files.
t0500700.fjt Many forms of definition and invocation of LINE.
t0500800.fjt Many forms of definition and invocation of MAC().
t0500900.fjt #line and constants.
t0501000.fjt #line and "octal" constants.
t0501100.fjt #line and __LINE__.
t0501200.fjt #line and LINE.
t0501300.fjt #line and MAC( constant ).
t0501400.fjt #line and MAC( __LINE__ ).
t0501500.fjt #line and MAC( LINE ).
t0501600.fjt #line and MAC( MAC2() ).
t0501700.fjt #line and MAC( a ## b ).
t0501900.fjt #if and __LINE__
t0502000.fjt /**//**/#/**//**/line/**//**/500/**//**/
t0502100.fjt assert() macro invocation in three files.
t0550000.fjt Name space pollution of headers
t0560000.fjt #else versus #elif when skipped
t0570000.fjt x+x*y versus x*(1+y) and optimization
t0570100.fjt sqrt(1-x*x) versus sqrt((1+x)*(1-x)) versus sqrt(1+x)*sqrt(1-x)
t0880100.fjt Negative decimal constants are converted correctly (general #s).
t088007?.fjt Negative decimal constants are converted correctly IEEE DFP 7-digit
t088016?.fjt Negative decimal constants are converted correctly IEEE DFP 16-digit
t088034?.fjt Negative decimal constants are converted correctly IEEE DFP 34-digit
t088023?.fjt Negative decimal constants are converted correctly IEEE 24-bit denormals
t088024?.fjt Negative decimal constants are converted correctly IEEE 24-bit
t088052?.fjt Negative decimal constants are converted correctly IEEE 53-bit denormals
t088053?.fjt Negative decimal constants are converted correctly IEEE 53-bit
t088063?.fjt Negative decimal constants are converted correctly IEEE 64-bit denormals
t088064?.fjt Negative decimal constants are converted correctly IEEE 64-bit
t088106?.fjt Negative decimal constants are converted correctly double-double 106-bit
t088112?.fjt Negative decimal constants are converted correctly IEEE 113-bit denormals
t088113?.fjt Negative decimal constants are converted correctly IEEE 113-bit
t0880108.fjt Negative hex fp constants are converted correctly (general #s).
t0880248.fjt Negative hex fp constants are converted correctly IEEE 24-bit
t0880538.fjt Negative hex fp constants are converted correctly IEEE 53-bit
t0880648.fjt Negative hex fp constants are converted correctly IEEE 64-bit
t0881068.fjt Negative hex fp constants are converted correctly double-double 106-bit
t0881138.fjt Negative hex fp constants are converted correctly IEEE 113-bit
t0990000.fjt # is a valid pp statement
tflt2int.fjt Tests conversions from float types to int types (most systems fail).
tint2flt.fjt Tests conversions from int types to float types.
w0040000.fjt Warnings of translation time Exceptions invalid
w0040010.fjt Warnings of translation time Exceptions divide by zero
w0040020.fjt Warnings of translation time Exceptions overflow
w0040030.fjt Warnings of translation time Exceptions underflow
w0110100.fjt Inexact hexadecimal-floating-constants cause warning (many constants)
In ../fpcets/real/bin/errors/
e0000210.fjt Large width bool bit-field
e0000220.fjt Zero width bool bit-field with declarator
e0100010.fjt Hexadecimal floating constants cast to int in #if is error
e0100210.fjt Hexadecimal-floating-constant (invalid forms); all at once
e0100212.h Hexadecimal-floating-constant (invalid forms)
e01003??.fjt Hexadecimal-floating-constant (invalid forms); one per file
e0110300.fjt Valid enum constants are representalbe as an int
e01626??.fjt Arithmetic operator (sizeof) with bad operands.
e01627??.fjt Arithmetic operator (unary & and *) with bad operands.
e01628??.fjt Arithmetic operator (unary .) with bad operands.
e01629??.fjt Arithmetic operator (unary ->) with bad operands.
e01630??.fjt Arithmetic operator (binary []) with bad operands.
e01631??.fjt Arithmetic operator (binary [] and VLA) with bad operands.
e01632??.fjt Arithmetic operator (binary [] and flex) with bad operands.
e01633??.fjt Arithmetic operator (unary post ++ and --) with bad operands.
e01634??.fjt Arithmetic operator (unary pre ++ and --) with bad operands.
e01635??.fjt Arithmetic operator (unary + and -) with bad operands.
e01637??.fjt Arithmetic operator (unary ~) with bad operands.
e01638??.fjt Arithmetic operator (binary %) with bad operands.
e01639??.fjt Arithmetic operator (binary <<) with bad operands.
e01640??.fjt Arithmetic operator (binary >>) with bad operands.
e01641??.fjt Arithmetic operator (binary &) with bad operands.
e01642??.fjt Arithmetic operator (binary ^) with bad operands.
e01643??.fjt Arithmetic operator (binary |) with bad operands.
e01644??.fjt Arithmetic operator (binary %=) with bad operands.
e01645??.fjt Arithmetic operator (binary <<=) with bad operands.
e01646??.fjt Arithmetic operator (binary >>=) with bad operands.
e01647??.fjt Arithmetic operator (binary &=) with bad operands.
e01648??.fjt Arithmetic operator (binary ^=) with bad operands.
e01649??.fjt Arithmetic operator (binary |=) with bad operands.
e0180100.fjt Invalid integral constant exp. using FP: bit field size
e0180200.fjt Invalid integral constant exp. using FP: enum value
e0180300.fjt Invalid integral constant exp. using FP: array bound
e0180400.fjt Invalid integral constant exp. using FP: case value
e0180500.fjt Invalid integral constant exp. using FP: #if value
e0180600.fjt Invalid "": VLA array in struct: (int)(4./3.)
e0180602.fjt Invalid "": VLA array in struct: (int)+4.
e0180603.fjt Invalid "": flex array in struct: flex array w/ nonVLA
e0180700.fjt Invalid "": VLA array in union
e0180702.fjt Invalid "": VLA array in union
e0180703.fjt Invalid "": flex array in union
e0180800.fjt Invalid "": static and VLA
e0180802.fjt Invalid "": static and VLA
e0180803.fjt Invalid "": static and flex array
e0180900.fjt Invalid "": extern and VLA
e0180902.fjt Invalid "": extern and VLA
e0180903.fjt Invalid "": extern and flex array
e0181000.fjt Invalid "": file scope and VLA
e0181002.fjt Invalid "": file scope and VLA
e0181003.fjt Invalid "": file scope and flex array
e0181100.fjt Invalid "": file scope typedef and VLA
e0181102.fjt Invalid "": file scope typedef and VLA
e0181103.fjt Invalid "": file scope typedef and flex array
e0181200.fjt Invalid "": initialization and VLA
e0181202.fjt Invalid "": initialization and VLA
e0181203.fjt Invalid "": initialization and flex array
e0181300.fjt Invalid "": compound literal and VLA
e0181302.fjt Invalid "": compound literal and VLA
e0181303.fjt Invalid "": compound literal and flex array
e0181400.fjt Invalid "": switch and VLA
e0181402.fjt Invalid "": switch and VLA
e0181403.fjt Invalid "": switch and flex array
e0181404.fjt Invalid case in switch
e0181500.fjt Invalid "": goto and VLA
e0181502.fjt Invalid "": goto and VLA
e0181503.fjt Invalid "": goto and flex array
e0200150.fjt __STDC_IEC_559__ (or __FPCE_IEEE__) can't be #undef nor #define
e0200200.fjt ISO/ANSI __*__ can't be #undef nor #define
e0210100.fjt fp.h and fenv.h functions are reserved identifiers
e02102??.fjt Invalid reuse of external fenv.h/fp.h/math.h function names
e02103??.fjt Invalid reuse of external fenv.h/fp.h/math.h function names
e02104??.fjt Invalid reuse of external fenv.h/fp.h/math.h function names
e0270800.fjt FE_DFL_ENV is const qualified
e0360*.fjt Bad combinations of keywords in declarations - real binary: func locals
e0361*.fjt Bad combinations of keywords in 'for' declarations - real binary
e0370*.fjt sizeof type -- no () around type.
makefile Tells how to make files for this leaf directory (was makefile.err).
makefile.018 For e000*, e010*, e018*, e020*, e021*, e027*
makefile.036 For e0360*
makefile.210 For e021*
makefile.300 For e01003*
makefile.26 For e01626*
makefile.27 For e01627*
makefile.28 For e01628*
makefile.29 For e01629*
makefile.30 For e01630*
makefile.31 For e01631*
makefile.32 For e01632*
makefile.33 For e01633*
makefile.34 For e01634*
makefile.35 For e01635*
makefile.37 For e01637*
makefile.38 For e01638*
makefile.39 For e01639*
makefile.40 For e01640*
makefile.41 For e01641*
makefile.42 For e01642*
makefile.43 For e01643*
makefile.44 For e01644*
makefile.45 For e01645*
makefile.46 For e01646*
makefile.47 For e01647*
makefile.48 For e01648*
makefile.49 For e01649*
In ../fpcets/real/bin/error2/
e01650??.fjt Arithmetic operator (isless) with bad operands.
e01651??.fjt Arithmetic operator (islessequal) with bad operands.
e01652??.fjt Arithmetic operator (isgreaterequal) with bad operands.
e01653??.fjt Arithmetic operator (isgreater) with bad operands.
e01654??.fjt Arithmetic operator (islessgreater) with bad operands.
e01655??.fjt Arithmetic operator (isunordered) with bad operands.
e01660??.fjt Arithmetic operator (fpclassify) with bad operands.
e01661??.fjt Arithmetic operator (isfinite) with bad operands.
e01662??.fjt Arithmetic operator (isinf) with bad operands.
e01663??.fjt Arithmetic operator (isnan) with bad operands.
e01664??.fjt Arithmetic operator (isnormal) with bad operands.
e01665??.fjt Arithmetic operator (signbit) with bad operands.
makefile Tells how to make files for this leaf directory (was makefile.err).
makefile.501 For e01650*
makefile.502 For e01650*
makefile.503 For e01650*
makefile.511 For e01651*
makefile.512 For e01651*
makefile.513 For e01651*
makefile.521 For e01652*
makefile.522 For e01652*
makefile.523 For e01652*
makefile.531 For e01653*
makefile.532 For e01653*
makefile.533 For e01653*
makefile.541 For e01654*
makefile.542 For e01654*
makefile.543 For e01654*
makefile.551 For e01655*
makefile.552 For e01655*
makefile.553 For e01655*
makefile.60 For e01660*
makefile.61 For e01661*
makefile.62 For e01662*
makefile.63 For e01663*
makefile.64 For e01664*
makefile.65 For e01665*
In ../fpcets/real/bin/fenv/
makefile Tells how to make files for this leaf directory (was part of makefile.mth).
t2100000.fjt feclearexcept() clears exception flags
t2101000.fjt feclearexcept() returns success/failure
t2110000.fjt fegetexceptflag() gets exception flag's status
t2111000.fjt fegetexceptflag() returns success/failure
t2120000.fjt feraiseexcept() raises exception flags
t2121000.fjt feraiseexcept() returns success/failure
t2130000.fjt fesetexceptflag() sets exception flag's status
t2131000.fjt fesetexceptflag() returns success/failure
t2140000.fjt fetestexcept() tests exception flags
t2200000.fjt fegetround() gets rounding control direction
t2210000.fjt fesetround() sets rounding control direction
t2300000.fjt fegetenv() gets entire FPU environment
t2301000.fjt fegetenv() returns success/failure
t2310000.fjt feholdexcept() gets entire FPU environment, clears flags, ...
t2320000.fjt fesetenv() sets entire FPU environment
t2321000.fjt fesetenv() returns success/failure
t2330000.fjt feupdateenv() ORs flags while restoring the FPU environment
t2331000.fjt feupdateenv() returns success/failure
In ../fpcets/real/bin/io/
g3050000.h binary->decimal conversions; %e. Generic test of printf
g3050e00.h binary->decimal conversions; %e.
g3060000.h binary->decimal->binary roundtrip conversions; %e. Generic test of printf.
g3060e00.h binary->decimal->binary roundtrip conversions; %e; *_DECIMAL_DIG.
g3070000.h printf %e,%f,%g supports all 32 combinations of flags. Generic test.
g3070300.h printf %a supports all 32 combinations of flags. Generic test.
g3080100.h scanf of decimal #s are converted correctly. Generic test.
g3450000.h binary->decimal conversions; %e. Generic test of wprintf
g3450e00.h binary->decimal conversions; %e.
g3460000.h binary->decimal->binary roundtrip conversions; %e. Generic test of wprintf
g3460e00.h binary->decimal->binary roundtrip conversions; %e; *_DECIMAL_DIG.
g3470000.h wprintf %e,%f,%g supports all 32 combinations of flags. Generic test.
g3470300.h wprintf %a supports all 32 combinations of flags. Generic test.
g3480100.h wscanf of decimal #s are converted correctly. Generic test.
g3880100.h scanf of negative decimal #s are converted correctly. Generic test.
g3980100.h wscanf of negative decimal #s are converted correctly. Generic test.
makefile Tells how to make files for this leaf directory (was part of makefile.io).
makefile.304 For t304*
makefile.305 For t305*
makefile.306 For t306*
makefile.307 For t307*
makefile.308 For t308*
makefile.344 For t344*
makefile.345 For t345*
makefile.346 For t346*
makefile.347 For t347*
makefile.348 For t348*
makefile.388 For t388*
makefile.398 For t398*
t3030000.fjt printf("%.2a\n", DBL_MAX) => inf or 0x2.00p+1023?
t3040000.fjt scanf vs strtod on wierd FP strings
t3041000.fjt scanf & strtod of long FP strings (decimal and hex)
t3042000.fjt Specific tests of sscanf; " %n" at EOF.
t305024?.fjt binary->decimal conversions; %e, IEEE 24-bit; printf
t305053?.fjt binary->decimal conversions; %e, IEEE 53-bit
t305064?.fjt binary->decimal conversions; %e, IEEE 64-bit
t305106?.fjt binary->decimal conversions; %e, double-double 106-bit
t305113?.fjt binary->decimal conversions; %e, IEEE 113-bit
t306024?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 24-bit; printf
t306053?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 53-bit
t306064?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 64-bit
t306106?.fjt binary->decimal->binary roundtrip conversions; %e, double-double 106-bit
t306113?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 113-bit
t30700??.fjt printf %f supports all 32 combinations of flags in format string.
t30701??.fjt printf %e supports all 32 combinations of flags in format string.
t30702??.fjt printf %g supports all 32 combinations of flags in format string.
t30703??.fjt printf %a supports all 32 combinations of flags in format string.
t308007?.fjt scanf of decimal #s are converted correctly IEEE 7-digit
t3080100.fjt scanf of decimal #s are converted correctly (general #s).
t3080108.fjt scanf of hex fp #s are converted correctly (general #s).
t308016?.fjt scanf of decimal #s are converted correctly IEEE 16-digit
t3080248.fjt scanf of hex fp #s are converted correctly IEEE 24-bit
t308024?.fjt scanf of decimal #s are converted correctly IEEE 24-bit
t308034?.fjt scanf of decimal #s are converted correctly IEEE 34-digit
t3080538.fjt scanf of hex fp #s are converted correctly IEEE 53-bit
t308053?.fjt scanf of decimal #s are converted correctly IEEE 53-bit
t3080648.fjt scanf of hex fp #s are converted correctly IEEE 64-bit
t308064?.fjt scanf of decimal #s are converted correctly IEEE 64-bit
t3081068.fjt scanf of hex fp #s are converted correctly double-double 106-bit
t308106?.fjt scanf of decimal #s are converted correctly double-double 106-bit
t3081138.fjt scanf of hex fp #s are converted correctly IEEE 113-bit
t308113?.fjt scanf of decimal #s are converted correctly IEEE 113-bit
t3250600.fjt Conversion from FP to decimal via %g/%G of DECIMAL_DIG digits and back; printf/scanf/strto*
t3250700.fjt Conversion from FP to decimal via %e/%E of *_DECIMAL_DIG digits and back; printf/scanf/strto*
t3250800.fjt Conversion from FP to decimal via %f/%F of DECIMAL_DIG digits and back; printf/scanf/strto*
t3250900.fjt Conversion from FP to hexadecimal via %a/%A and back (roundtrip printf/scanf/strto*).
t3430000.fjt wprintf(L"%.2a\n", DBL_MAX) => inf or 0x2.00p+1023?
t3440000.fjt wscanf vs wcstod on wierd FP strings
t3441000.fjt wscanf & wcstod of long FP strings (decimal and hex)
t3442000.fjt Specific tests of swscanf; " %n" at EOF.
t345024?.fjt binary->decimal conversions; %e, IEEE 24-bit; wprintf
t345053?.fjt binary->decimal conversions; %e, IEEE 53-bit
t3450600.fjt Conversion from FP to decimal via %g/%G of DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
t345064?.fjt binary->decimal conversions; %e, IEEE 64-bit
t3450700.fjt Conversion from FP to decimal via %e/%E of *_DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
t3450800.fjt Conversion from FP to decimal via %f/%F of DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
t3450900.fjt Conversion from FP to hexadecimal via %a/%A and back (roundtrip wprintf/wscanf/wcsto*).
t345106?.fjt binary->decimal conversions; %e, double-double 106-bit
t345113?.fjt binary->decimal conversions; %e, IEEE 113-bit
t346024?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 24-bit; wprintf
t346053?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 53-bit
t346064?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 64-bit
t346106?.fjt binary->decimal->binary roundtrip conversions; %e, double-double 106-bit
t346113?.fjt binary->decimal->binary roundtrip conversions; %e, IEEE 113-bit
t34700??.fjt wprintf %f supports all 32 combinations of flags in format string.
t34701??.fjt wprintf %e supports all 32 combinations of flags in format string.
t34702??.fjt wprintf %g supports all 32 combinations of flags in format string.
t34703??.fjt wprintf %a supports all 32 combinations of flags in format string.
t348007?.fjt wscanf of decimal #s are converted correctly IEEE 7-digit
t3480100.fjt wscanf of decimal #s are converted correctly (general #s).
t3480108.fjt wscanf of hex fp #s are converted correctly (general #s).
t348016?.fjt wscanf of decimal #s are converted correctly IEEE 16-digit
t3480248.fjt wscanf of hex fp #s are converted correctly IEEE 24-bit
t348024?.fjt wscanf of decimal #s are converted correctly IEEE 24-bit
t348034?.fjt wscanf of decimal #s are converted correctly IEEE 34-digit
t3480538.fjt wscanf of hex fp #s are converted correctly IEEE 53-bit
t348053?.fjt wscanf of decimal #s are converted correctly IEEE 53-bit
t3480648.fjt wscanf of hex fp #s are converted correctly IEEE 64-bit
t348064?.fjt wscanf of decimal #s are converted correctly IEEE 64-bit
t3481068.fjt wscanf of hex fp #s are converted correctly double-double 106-bit
t348106?.fjt wscanf of decimal #s are converted correctly double-double 106-bit
t3481138.fjt wscanf of hex fp #s are converted correctly IEEE 113-bit
t348113?.fjt wscanf of decimal #s are converted correctly IEEE 113-bit
t388007?.fjt scanf of negative decimal #s are converted correctly IEEE 7-digit
t3880100.fjt scanf of negative decimal #s are converted correctly (general #s).
t3880108.fjt scanf of negative hex fp #s are converted correctly (general #s).
t388016?.fjt scanf of negative decimal #s are converted correctly IEEE 16-digit
t3880248.fjt scanf of negative hex fp #s are converted correctly IEEE 24-bit
t388024?.fjt scanf of negative decimal #s are converted correctly IEEE 24-bit
t388034?.fjt scanf of negative decimal #s are converted correctly IEEE 34-digit
t3880538.fjt scanf of negative hex fp #s are converted correctly IEEE 53-bit
t388053?.fjt scanf of negative decimal #s are converted correctly IEEE 53-bit
t3880648.fjt scanf of negative hex fp #s are converted correctly IEEE 64-bit
t388064?.fjt scanf of negative decimal #s are converted correctly IEEE 64-bit
t3881068.fjt scanf of negative hex fp #s are converted correctly double-double 106-bit
t388106?.fjt scanf of negative decimal #s are converted correctly double-double 106-bit
t3881138.fjt scanf of negative hex fp #s are converted correctly IEEE 113-bit
t388113?.fjt scanf of negative decimal #s are converted correctly IEEE 113-bit
t398007?.fjt wscanf of negative decimal #s are converted correctly IEEE 7-digit
t3980100.fjt wscanf of negative decimal #s are converted correctly (general #s).
t3980108.fjt wscanf of negative hex fp #s are converted correctly (general #s).
t398016?.fjt wscanf of negative decimal #s are converted correctly IEEE 16-digit
t3980248.fjt wscanf of negative hex fp #s are converted correctly IEEE 24-bit
t398024?.fjt wscanf of negative decimal #s are converted correctly IEEE 24-bit
t398034?.fjt wscanf of negative decimal #s are converted correctly IEEE 34-digit
t3980538.fjt wscanf of negative hex fp #s are converted correctly IEEE 53-bit
t398053?.fjt wscanf of negative decimal #s are converted correctly IEEE 53-bit
t3980648.fjt wscanf of negative hex fp #s are converted correctly IEEE 64-bit
t398064?.fjt wscanf of negative decimal #s are converted correctly IEEE 64-bit
t3981068.fjt wscanf of negative hex fp #s are converted correctly double-double 106-bit
t398106?.fjt wscanf of negative decimal #s are converted correctly double-double 106-bit
t3981138.fjt wscanf of negative hex fp #s are converted correctly IEEE 113-bit
t398113?.fjt wscanf of negative decimal #s are converted correctly IEEE 113-bit
tbin2dec.fjt Test printf() of binary FP to decimal string conversions.
v3040000.h test vectors included by t3040000, t3440000
v30703??.h printf %a test vectors included by t3070300.h, t3470300.h
In ../fpcets/real/bin/math/
makefile Tells how to make files for this leaf directory (was part of makefile.io).
makefile.10 For t11* and t12*
makefile.30 For t13* and t14*
makefile.50 For t15* and t16*
makefile.70 For t17*, t18*, and t19*
t110?00?.fjt acos() is arc cosine
t111?00?.fjt asin() is arc sine
t112?00?.fjt atan() is arc tangent
t113?00?.fjt atan2() is arc tangent2
t114?00?.fjt cos() is cosine
t115?00?.fjt sin() is sine
t116?00?.fjt tan() is tangent
t120?00?.fjt acosh() is arc hyperbolic cosine
t121?00?.fjt asinh() is arc hyperbolic sin
t122?00?.fjt atanh() is arc hyperbolic tangent
t123?00?.fjt cosh() is hyperbolic cosine
t124?00?.fjt sinh() is hyperbolic sine
t125?00?.fjt tanh() is hyperbolic tangent
t130?00?.fjt exp() is base-e exponential
t131?00?.fjt exp2() is base-2 exponential
t132?00?.fjt expm1() is exp(x) - 1
t133?00?.fjt frexp() is fraction + exponent
t134?00?.fjt ldexp() is scale by power of 2
t135?00?.fjt log() is base-e logarithm
t136?00?.fjt log10() is base-10 logarithm
t137?00?.fjt log1p() is log(1+x)
t138?00?.fjt log2() is base-2 logarithm
t139?00?.fjt logb() is base-radix logarithm
t140?00?.fjt modf() is fraction + integer
t142?00?.fjt scalbn() is scale by power of radix
t143?00?.fjt scalbln() is scale by power of radix
t144?00?.fjt ilogb() is base-radix logarithm
t150?00?.fjt fabs() is floating-point absolute value
t151?00?.fjt hypot() is sqrt( x*x + y*y )
t152?00?.fjt pow() is x ** y
t153?00?.fjt sqrt() is x ** 1/2
t154?00?.fjt cbrt() is x ** 1/3
t160?00?.fjt erf() is error function
t161?00?.fjt erfc() is complementary error function
t162?00?.fjt tgamma() is true gamma
t163?00?.fjt lgamma() is ln(|gamma|)
t170?00?.fjt ceil() is ceil (round +INF)
t171?00?.fjt floor() is floor (round -INF)
t172?00?.fjt nearbyint() is exact round to FP integeral
t173?00?.fjt rint() is inexact round to FP integeral
t174?00?.fjt lrint() is round to long int
t175?00?.fjt round() is biased round nearest
t176?00?.fjt lround() is biased round to long int
t177?00?.fjt trunc() is trunc toward zero
t178?00?.fjt llrint() is round to long long int
t179?00?.fjt llround() is biased round to long long int
t180?00?.fjt fmod() is remainder of x/y
t181?00?.fjt remainder() is IEEE-754 remainder of x/y
t182?00?.fjt remquo() is IEEE-754 reminder & quotient of x/y
t190?00?.fjt copysign() is copysign
t191?00?.fjt nan() is nan creation
t192?00?.fjt nextafter() is nextafter
t193?00?.fjt nexttoward() is nextafter w/ 2nd arg a long double
t195?00?.fjt fdim() is positive difference between arguments
t196?00?.fjt fmax() is maximum
t197?00?.fjt fmin() is minimum
t198?00?.fjt fma() is floating multiply-add
tsin.fjt sin(355.)
In ../fpcets/real/dec/
gdec2bfp.h Pos/Neg Decimal string converts to Decimal FP. Generic test.
g6080100.h Positive Decimal const converted to Decimal FP. Generic test.
g6480100.h Positive Decimal FP converted to Binary FP. Generic test.
g6580100.h Negative Decimal FP converted to Binary FP. Generic test.
g6680100.h Pos/Neg Binary FP converted to Decimal FP. Generic test.
g6880100.h Negative Decimal const converted to Decimal FP. Generic test.
In ../fpcets/real/dec/compiler/
makefile Tells how to make files for this leaf directory
t6000000.fjt myfloat.h and float.h are correct, consistent; ulp_*() OK.
t6000100.fjt sizeof(decimal floating-point object) is correct
t6000800.fjt MAX_* and *_MAX are largest finite numbers.
t6010000.fjt + and - work as expected (addition table)
t6010100.fjt * and / work as expected (multiplication table)
t6010300.fjt * and / work as expected w.r.t. rounding
t6010400.fjt * and / work as expected w.r.t. rounding
t6010500.fjt * and / work as expected w.r.t. rounding for subnormals (ends)
t6010600.fjt * works as expected w.r.t. rounding for subnormals (mid-point)
t6010700.fjt / works as expected w.r.t. rounding for subnormals (mid-point)
t6020000.fjt FENV_ACCESS pragma (many expressions to test optimization)
t6020600.fjt Dynamic rounding direction
t6030000.fjt Exception flags
t6040100.fjt Translation rounding direction
t6040200.fjt Translation rounding precision (many powers of 10)
t6040300.fjt Translation traps disabled
t6040400.fjt Translation arithmetic matches execution arithmetic
t6050000.fjt Startup: Exceptions flags are clear
t6050001.fjt Startup: Exceptions flags are clear; FENV_ACCESS off
t6050100.fjt Startup: Rounding direction
t6050101.fjt Startup: Rounding direction; FENV_ACCESS off
t6050200.fjt Startup: Rounding precision
t6050201.fjt Startup: Rounding precision; FENV_ACCESS off
t6050300.fjt Startup: Traps disabled
t6050301.fjt Startup: Traps disabled; FENV_ACCESS off
t6060100.fjt DEC_EVAL_METHOD is in
t6060200.fjt Multiple includes of DFP headers versus __STDC_WANT_DEC_FP__.
t6060300.fjt DEC_EVAL_METHOD is correct.
t6060400.fjt DEC_EVAL_METHOD of translation time matches execution time
t6060500.fjt DEC_EVAL_METHOD w/ DFP cast to int.
t6060600.fjt FLT_EVAL_METHOD & DEC_EVAL_METHOD w/ mixed BFP and DFP.
t6070000.fjt _Decimal128 has more precision than _Decimal64
t6070100.fjt _Decimal64 has more precision than _Decimal32
t6070300.fjt C type _Decimal32 is IEEE Decimal32
t6070400.fjt C type _Decimal64 is IEEE Decimal64
t6070500.fjt C type _Decimal128 is IEEE Decimal128
t6080000.fjt Constants are converted at translation time (many conversions)
t6080100.fjt Decimal constants are converted correctly (general #s).
t608007?.fjt Decimal constants are converted correctly IEEE DFP 7-digit
t608016?.fjt Decimal constants are converted correctly IEEE DFP 16-digit
t608034?.fjt Decimal constants are converted correctly IEEE DFP 34-digit
t608023?.fjt Decimal constants are converted correctly IEEE 24-bit denormals
t608024?.fjt Decimal constants are converted correctly IEEE 24-bit
t608052?.fjt Decimal constants are converted correctly IEEE 53-bit denormals
t608053?.fjt Decimal constants are converted correctly IEEE 53-bit
t608063?.fjt Decimal constants are converted correctly IEEE 64-bit denormals
t608064?.fjt Decimal constants are converted correctly IEEE 64-bit
t608106?.fjt Decimal constants are converted correctly double-double 106-bit
t608112?.fjt Decimal constants are converted correctly IEEE 113-bit denormals
t608113?.fjt Decimal constants are converted correctly IEEE 113-bit
t6089000.fjt DFP constants have correct quantum exponent.
t6090000.fjt Translation-time conversion matches execution-time conversion
t6100000.fjt DFP floating constants (D10) are valid floating-constants (each operator)
t6100001.fjt DFP floating constants (F10) are valid floating-constants (each operator)
t6100002.fjt DFP floating constants (LD10) are valid floating-constants (each operator)
t6120000.fjt Infinity converted to integral raises invalid
t6120100.fjt NaN converted to integral raises invalid
t6120200.fjt Large invalid integers converted to integral raises invalid (many conversions)
t6120250.fjt Large valid integers converted to integral raises nothing (many conversions)
t6120300.fjt Conversion to integral truncates toward zero
t6120400.fjt Conversion from integral rounds as per IEEE
t6120500.fjt Infinity converted to bool and bool bit-field
t6120600.fjt NaN converted to bool and bool bit-field
t6120700.fjt Finite FP converted to bool and bool bit-field
t6120900.fjt bool from DFP
t6130000.fjt Expression evaluation is one of the decimal floating types
t6130100.fjt Expression evaluation (each operator)
t6140000.fjt Contraction operations
t6140100.fjt #pragma FP_CONTRACT affects contraction operations
t6140400.fjt Contraction operations honor infinities
t6140500.fjt Contraction operations honor NaNs
t6140600.fjt Contraction operations honor signed zeros w/ variables
t6140610.fjt Contraction operations honor signed zeros w/ constants
t6140700.fjt Contraction operations honor subnormals
t6140800.fjt Contraction operations raise exceptions
t6160000.fjt Arithmetic operators have correct precision, no double rounding.
t6160100.fjt Arithmetic operators (unary) are usable with DFP operands.
t6160101.fjt Arithmetic operator (binary *) is usable with floating-point operands.
t6160102.fjt Arithmetic operator (binary /) is usable with floating-point operands.
t6160103.fjt Arithmetic operator (binary +) is usable with floating-point operands.
t6160104.fjt Arithmetic operator (binary -) is usable with floating-point operands.
t6160105.fjt Arithmetic operator (binary < ) is usable with floating-point operands.
t6160106.fjt Arithmetic operator (binary <=) is usable with floating-point operands.
t6160107.fjt Arithmetic operator (binary > ) is usable with floating-point operands.
t6160108.fjt Arithmetic operator (binary >=) is usable with floating-point operands.
t6160109.fjt Arithmetic operator (binary ==) is usable with floating-point operands.
t6160110.fjt Arithmetic operator (binary !=) is usable with floating-point operands.
t6160111.fjt Arithmetic operator (binary &&) is usable with floating-point operands.
t6160112.fjt Arithmetic operator (binary ||) is usable with floating-point operands.
t6160113.fjt Arithmetic operator (binary ?:) is usable with floating-point operands.
t6160114.fjt Arithmetic operator (binary =) is usable with floating-point operands.
t6160115.fjt Arithmetic operator (binary +=) is usable with floating-point operands.
t6160116.fjt Arithmetic operator (binary -=) is usable with floating-point operands.
t6160117.fjt Arithmetic operator (binary *=) is usable with floating-point operands.
t6160118.fjt Arithmetic operator (binary /=) is usable with floating-point operands.
t6160119.fjt Arithmetic operator (binary ,) is usable with floating-point t6160120.
t6160120.fjt Complicated arithmetic expressions are usable.
t6160129.fjt Arithmetic operator (binary ==) is usable with signed DFP zeros.
t6160200.fjt Arithmetic operator (unary) is usable with DFP and Bool operands.
t6160201.fjt Arithmetic operator (binary *) is usable with DFP and Bool operands.
t6160202.fjt Arithmetic operator (binary /) is usable with DFP and Bool operands.
t6160203.fjt Arithmetic operator (binary +) is usable with DFP and Bool operands.
t6160204.fjt Arithmetic operator (binary -) is usable with DFP and Bool operands.
t6160205.fjt Arithmetic operator (binary < ) is usable with DFP and Bool operands.
t6160206.fjt Arithmetic operator (binary <=) is usable with DFP and Bool operands.
t6160207.fjt Arithmetic operator (binary > ) is usable with DFP and Bool operands.
t6160208.fjt Arithmetic operator (binary >=) is usable with DFP and Bool operands.
t6160209.fjt Arithmetic operator (binary ==) is usable with DFP and Bool operands.
t6160210.fjt Arithmetic operator (binary !=) is usable with DFP and Bool operands.
t6160211.fjt Arithmetic operator (binary &&) is usable with DFP and Bool operands.
t6160212.fjt Arithmetic operator (binary ||) is usable with DFP and Bool operands.
t6160213.fjt Arithmetic operator (binary ?:) is usable with DFP and Bool operands.
t6160214.fjt Arithmetic operator (binary =) is usable with DFP and Bool operands.
t6160215.fjt Arithmetic operator (binary +=) is usable with DFP and Bool operands.
t6160216.fjt Arithmetic operator (binary -=) is usable with DFP and Bool operands.
t6160217.fjt Arithmetic operator (binary *=) is usable with DFP and Bool operands.
t6160218.fjt Arithmetic operator (binary /=) is usable with DFP and Bool operands.
t6160219.fjt Arithmetic operator (binary ,) is usable with DFP and Bool operands.
t6160230.fjt Arithmetic operators are usable with DFP and compound literal operands.
t6160301.fjt Arithmetic operator (binary *) is usable with DFP operands.
t6160302.fjt Arithmetic operator (binary /) is usable with DFP operands.
t6160303.fjt Arithmetic operator (binary +) is usable with DFP operands.
t6160304.fjt Arithmetic operator (binary -) is usable with DFP operands.
t6160305.fjt Arithmetic operator (binary <) is usable with DFP operands.
t6160306.fjt Arithmetic operator (binary <=) is usable with DFP operands.
t6160307.fjt Arithmetic operator (binary >) is usable with DFP operands.
t6160308.fjt Arithmetic operator (binary >=) is usable with DFP operands.
t6160309.fjt Arithmetic operator (binary ==) is usable with DFP operands.
t6160310.fjt Arithmetic operator (binary !=) is usable with DFP operands.
t6160311.fjt Arithmetic operator (binary &&) is usable with DFP operands.
t6160312.fjt Arithmetic operator (binary ||) is usable with DFP operands.
t6160313.fjt Arithmetic operator (triary ?:) is usable with DFP operands.
t6160314.fjt Arithmetic operator (binary =) is usable with DFP operands.
t6160315.fjt Arithmetic operator (binary +=) is usable with DFP operands.
t6160316.fjt Arithmetic operator (binary -=) is usable with DFP operands.
t6160317.fjt Arithmetic operator (binary *=) is usable with DFP operands.
t6160318.fjt Arithmetic operator (binary /=) is usable with DFP operands.
t6160319.fjt Arithmetic operator (binary ,) is usable with DFP operands.
t6160320.fjt Arithmetic operator (cast) is usable with DFP operands.
t6160321.fjt Arithmetic operator (parameter assignment) is usable with DFP operands.
t6160322.fjt Arithmetic operator (varargs parameter assignment) is usable with DFP operands.
t6160323.fjt Arithmetic operator (no prototype parameter assignment) is usable with DFP operands.
t6160324.fjt Arithmetic operator (old style parameter assignment) is usable with DFP operands.
t6160325.fjt Arithmetic operator (return) is usable with DFP operands.
t6160326.fjt Arithmetic operator (sizeof) is usable with DFP operands.
t6160327.fjt Arithmetic operator (unary & and *) is usable with DFP operands.
t6160328.fjt Arithmetic operator (unary .) is usable with DFP operands.
t6160329.fjt Arithmetic operator (unary ->) is usable with DFP operands.
t6160330.fjt Arithmetic operator (binary []) is usable with DFP operands.
t6160331.fjt Arithmetic operator (binary [] and VLA) is usable with DFP operands.
t6160332.fjt Arithmetic operator (binary [] and flex) is usable with DFP operands.
t6160333.fjt Arithmetic operator (unary post ++ and --) is usable with DFP operands.
t6160334.fjt Arithmetic operator (unary pre ++ and --) is usable with DFP operands.
t6160335.fjt Arithmetic operator (unary + and -) is usable with DFP operands.
t6160336.fjt Arithmetic operator (unary !) is usable with DFP operands.
t6160350.fjt Arithmetic operator (isless) is usable with DFP operands.
t6160351.fjt Arithmetic operator (islessequal) is usable with DFP operands.
t6160352.fjt Arithmetic operator (isgreaterequal) is usable with DFP operands.
t6160353.fjt Arithmetic operator (isgreater) is usable with DFP operands.
t6160354.fjt Arithmetic operator (islessgreater) is usable with DFP operands.
t6160355.fjt Arithmetic operator (isunordered) is usable with DFP operands.
t6160360.fjt Arithmetic operator (fpclassify) is usable with DFP operands.
t6160361.fjt Arithmetic operator (isfinite) is usable with DFP operands.
t6160362.fjt Arithmetic operator (isinf) is usable with DFP operands.
t6160363.fjt Arithmetic operator (isnan) is usable with DFP operands.
t6160364.fjt Arithmetic operator (isnormal) is usable with DFP operands.
t6160365.fjt Arithmetic operator (signbit) is usable with DFP operands.
t6160400.fjt Arithmetic operator (compound =) is usable with arithmetic operands.
t61700?0.fjt Relational operator < yields 0, raises invalid for NaN
t61701?0.fjt Relational operator <= yields 0, raises invalid for NaN
t61702?0.fjt Relational operator >= yields 0, raises invalid for NaN
t61703?0.fjt Relational operator > yields 0, raises invalid for NaN
t6180000.fjt Constant expressions are execution time
t6180100.fjt Auto aggregate initializers are execution time
t6180601.fjt nonVLA array bound in struct
t6180701.fjt nonVLA array bound in union
t6180801.fjt static and nonVLA
t6180901.fjt extern and nonVLA
t6181001.fjt file scope and nonVLA
t6181101.fjt file scope typedef and nonVLA
t6181201.fjt initialization and nonVLA
t6181301.fjt compound literal and nonVLA
t6181401.fjt switch and nonVLA
t6181501.fjt goto and nonVLA
t6182100.fjt VLA w/ constant expression for size are execution time
t6182200.fjt Typedef VLA w/ constant expression for size are execution time
t6182300.fjt Recursion and VLA w/ constant expression for size are execution time
t6182400.fjt VLAs work as expected w/ FP types when passed to function.
t6182500.fjt Flexible arrays work as expected w/ FP types.
t6190000.fjt Auto (even aggregates) initialization is done at execution time
t6190100.fjt Static initialization is done at translation time
t6190200.fjt Characterictics of translation time FP expressions.
t6190300.fjt Translation time FP expressions and designated initializer.
t6200100.fjt __STDC_DEC_FP__ is defined and is 200805L.
t6210000.fjt math.h and fenv.h functions are not built-in to compiler
t6220000.fjt strtod32() prototype is in
t6220050.fjt strtod32() prototype is only in
t6220100.fjt strtod128() prototype is in
t6220150.fjt strtod128() prototype is only in
t6220200.fjt strtod64() prototype is in
t6220250.fjt strtod64() prototype is only in
t6230000.fjt declares several DFP things
t6230050.fjt external DFP functions are not built-in
t6230100.fjt _Decimal32_t
t6230200.fjt _Decimal64_t
t6230300.fjt HUGE_VAL_D64
t6230400.fjt HUGE_VAL_D32
t6230500.fjt HUGE_VAL_D128
t6230600.fjt DEC_INFINITY
t6230650.fjt INF_* op finite
t6230700.fjt DEC_NAN
t6230850.fjt FP_FAST_FMAD64, FP_FAST_FMAD32, FP_FAST_FMAD128
t6240000.fjt Conversions of infinity
t6240100.fjt Conversions of nan
t6240300.fjt macros evaluate arguments exactly once
t6240400.fjt fpclassify()
t6240500.fjt signbit()
t6240600.fjt isfinite()
t6240700.fjt isnormal()
t6240800.fjt All classification macros with specific values.
t6240900.fjt isinf() macro
t6240950.fjt isinf() macro w/ MAX_DBL+MAX_DBL
t6250000.fjt isnan() macro
t6250050.fjt (x != x) is same as isnan() macro
t6250100.fjt Relational operator ( isless ) no raise invalid for NaN
t6250101.fjt Relational operator ( islessequal ) no raise invalid for NaN
t6250102.fjt Relational operator ( isgreaterequal ) no raise invalid for NaN
t6250103.fjt Relational operator ( isgreater ) no raise invalid for NaN
t6250200.fjt Relational operator ( islessgreater ) no raise invalid for NaN
t6250300.fjt Relational operator ( isunordered ) no raise invalid for NaN
t6260000.fjt Type-Generic functions are not built-in
t6260100.fjt Type-Generic functions of floating type arguments
t6260210.fjt DFP C89 functions are linkable - Part A: trig functions
t6260220.fjt DFP C89 functions are linkable - Part B: non-trig functions
t6260250.fjt DFP FPCE functions are linkable - Part A
t6260260.fjt DFP FPCE functions are linkable - Part B
t6260290.fjt DFP functions are linkable
t6260400.fjt Type-Generic functions of specific values
t62605??.fjt Type-Generic 2-argument functions of bool and FP arguments
t6260600.fjt Type-Generic functions of integral type arguments
t6260800.fjt Type-Generic functions of FP const expression arguments
t6260900.fjt Type-Generic functions of FP compound literal
t6270000.fjt DFP external functions
t6270050.fjt DFP external functions are not built-in
t6270500.fjt FE_DEC_TONEAREST, FE_DEC_UPWARD, FE_DEC_DOWNWARD, FE_DEC_TOWARDZERO
t6280000.fjt Side effects of expressions cannot be optimized away
t6290000.fjt Removal of parentheses is invalid
t6290100.fjt Factoring is invalid
t6290200.fjt x-x .ne. 0
t6290300.fjt x-y .ne. -(y-x)
t6290400.fjt x/5.0 .ne. x*0.2
t6290500.fjt 0*x .ne. 0 and 0/x .ne. 0
t6290600.fjt 1*x .ne. x, x/1 .ne. x
t6290700.fjt 0+x .ne. x
t6290800.fjt x-0 .ne. x
t6290900.fjt 0-x .ne. -x
t6291000.fjt x/x .ne. 1
t6300000.fjt (x != x) .ne. false
t6300100.fjt (x == x) .ne. true
t6300200.fjt (x < y) .ne. isless(x,y)
t6300210.fjt (x <= y) .ne. islessequal(x,y)
t6300220.fjt (x >= y) .ne. isgreaterequal(x,y)
t6300230.fjt (x > y) .ne. isgreater(x,y)
t6300300.fjt a****=b?g:f
t6300310.fjt a<=b?f:g .ne. a>b?g:f
t6310100.fjt explicit store/load must round
t6310200.fjt casts and assignments must convert
t6310300.fjt casts of constants (DR 318)
t6320000.fjt HUGE_VAL* are +infinity
t6320100.fjt nand64(), nand32(), nand128() all are declared
t6330000.fjt if( FP )
t6330100.fjt while( FP )
t6330200.fjt do while( FP )
t6330300.fjt for( ; FP ; )
t6350000.fjt macros are parenthesized
t6350001.fjt macros are parenthesized
t6350002.fjt macros are parenthesized
t63600*.fjt: Permutations of keywords in declarations - real decimal: func locals
t63601*.fjt: "" - in 'for' statement
t6400000.fjt FLOAT_CONST_DECIMAL64 pragma controls type of unsuffixed decimal FP consts
t6400100.fjt Standard headers work with FLOAT_CONST_DECIMAL64 pragma
t6400200.fjt Scope of FLOAT_CONST_DECIMAL64 pragma is a stack
t648010?.fjt Positive Decimal FP converted to Binary FP (v008010*)
t648007?.fjt Positive Decimal FP converted to Binary FP (v008007*)
t648016?.fjt Positive Decimal FP converted to Binary FP (v008016*)
t648034?.fjt Positive Decimal FP converted to Binary FP (v008034*)
t648023?.fjt Positive Decimal FP converted to Binary FP (v008023*)
t648024?.fjt Positive Decimal FP converted to Binary FP (v008024*)
t648052?.fjt Positive Decimal FP converted to Binary FP (v008052*)
t648053?.fjt Positive Decimal FP converted to Binary FP (v008053*)
t648063?.fjt Positive Decimal FP converted to Binary FP (v008063*)
t648064?.fjt Positive Decimal FP converted to Binary FP (v008064*)
t648106?.fjt Positive Decimal FP converted to Binary FP (v008106*)
t648112?.fjt Positive Decimal FP converted to Binary FP (v008112*)
t648113?.fjt Positive Decimal FP converted to Binary FP (v008113*)
t658010?.fjt Negative Decimal FP converted to Binary FP (v008010*)
t658007?.fjt Negative Decimal FP converted to Binary FP (v008007*)
t658016?.fjt Negative Decimal FP converted to Binary FP (v008016*)
t658034?.fjt Negative Decimal FP converted to Binary FP (v008034*)
t658023?.fjt Negative Decimal FP converted to Binary FP (v008023*)
t658024?.fjt Negative Decimal FP converted to Binary FP (v008024*)
t658052?.fjt Negative Decimal FP converted to Binary FP (v008052*)
t658053?.fjt Negative Decimal FP converted to Binary FP (v008053*)
t658063?.fjt Negative Decimal FP converted to Binary FP (v008063*)
t658064?.fjt Negative Decimal FP converted to Binary FP (v008064*)
t658106?.fjt Negative Decimal FP converted to Binary FP (v008106*)
t658112?.fjt Negative Decimal FP converted to Binary FP (v008112*)
t658113?.fjt Negative Decimal FP converted to Binary FP (v008113*)
t668024?.fjt IEEE 24-bit FP converted to Decimal FP (v306024*)
t668053?.fjt IEEE 53-bit FP converted to Decimal FP (v306053*)
t668064?.fjt IEEE 64-bit FP converted to Decimal FP (v306064*)
t668106?.fjt IEEE 106-bit FP converted to Decimal FP (v306106*)
t668113?.fjt IEEE 113-bit FP converted to Decimal FP (v306113*)
t6880100.fjt Decimal constants are converted correctly (general #s).
t688007?.fjt Decimal constants are converted correctly IEEE DFP 7-digit
t688016?.fjt Decimal constants are converted correctly IEEE DFP 16-digit
t688034?.fjt Decimal constants are converted correctly IEEE DFP 34-digit
t688023?.fjt Decimal constants are converted correctly IEEE 24-bit denormals
t688024?.fjt Decimal constants are converted correctly IEEE 24-bit
t688052?.fjt Decimal constants are converted correctly IEEE 53-bit denormals
t688053?.fjt Decimal constants are converted correctly IEEE 53-bit
t688063?.fjt Decimal constants are converted correctly IEEE 64-bit denormals
t688064?.fjt Decimal constants are converted correctly IEEE 64-bit
t688106?.fjt Decimal constants are converted correctly double-double 106-bit
t688112?.fjt Decimal constants are converted correctly IEEE 113-bit denormals
t688113?.fjt Decimal constants are converted correctly IEEE 113-bit
tdfp2int.fjt Tests conversions from decimal float types to int types.
In ../fpcets/real/dec/errors/
e61004??.fjt Decimal-floating-constant (invalid forms); one per file
e61601??.fjt Arithmetic operator (binary *) with bad DFP operands.
e61602??.fjt Arithmetic operator (binary /) with bad DFP operands.
e61603??.fjt Arithmetic operator (binary +) with bad DFP operands.
e61604??.fjt Arithmetic operator (binary -) with bad DFP operands.
e61605??.fjt Arithmetic operator (binary <) with bad DFP operands.
e61606??.fjt Arithmetic operator (binary <=) with bad DFP operands.
e61607??.fjt Arithmetic operator (binary >) with bad DFP operands.
e61608??.fjt Arithmetic operator (binary >=) with bad DFP operands.
e61609??.fjt Arithmetic operator (binary ==) with bad DFP operands.
e61610??.fjt Arithmetic operator (binary !=) with bad DFP operands.
e61613??.fjt Arithmetic operator (triary ?:) with bad DFP operands.
e61615??.fjt Arithmetic operator (binary +=) with bad DFP operands.
e61616??.fjt Arithmetic operator (binary -=) with bad DFP operands.
e61617??.fjt Arithmetic operator (binary *=) with bad DFP operands.
e61618??.fjt Arithmetic operator (binary /=) with bad DFP operands.
e61627??.fjt Arithmetic operator (unary & and *) with bad DFP operands.
e61630??.fjt Arithmetic operator (binary []) with bad DFP operands.
e61631??.fjt Arithmetic operator (binary [] and VLA) with bad DFP operands.
e61632??.fjt Arithmetic operator (binary [] and flex) with bad DFP operands.
e61637??.fjt Arithmetic operator (unary ~) with bad DFP operands.
e61638??.fjt Arithmetic operator (binary %) with bad DFP operands.
e61639??.fjt Arithmetic operator (binary <<) with bad DFP operands.
e61640??.fjt Arithmetic operator (binary >>) with bad DFP operands.
e61641??.fjt Arithmetic operator (binary &) with bad DFP operands.
e61642??.fjt Arithmetic operator (binary ^) with bad DFP operands.
e61643??.fjt Arithmetic operator (binary |) with bad DFP operands.
e61644??.fjt Arithmetic operator (binary %=) with bad DFP operands.
e61645??.fjt Arithmetic operator (binary <<=) with bad DFP operands.
e61646??.fjt Arithmetic operator (binary >>=) with bad DFP operands.
e61647??.fjt Arithmetic operator (binary &=) with bad DFP operands.
e61648??.fjt Arithmetic operator (binary ^=) with bad DFP operands.
e61649??.fjt Arithmetic operator (binary |=) with bad DFP operands.
e61650??.fjt Arithmetic operator (isless) with bad DFP operands.
e61651??.fjt Arithmetic operator (islessequal) with bad DFP operands.
e61652??.fjt Arithmetic operator (isgreaterequal) with bad DFP operands.
e61653??.fjt Arithmetic operator (isgreater) with bad DFP operands.
e61654??.fjt Arithmetic operator (islessgreater) with bad DFP operands.
e61655??.fjt Arithmetic operator (isunordered) with bad DFP operands.
e6360*.fjt Bad combinations of keywords in declarations - real decimal: func locals
e6361*.fjt Bad combinations of keywords in 'for' declarations - real decimal
e6400000.fjt #pragma FLOAT_CONST_DECIMAL64 /* nothing */
e6400100.fjt #pragma FLOAT_CONST_DECIMAL64 on
e6400200.fjt #pragma FLOAT_CONST_DECIMAL64 off
e6400300.fjt #pragma FLOAT_CONST_DECIMAL64 default
e6400400.fjt #pragma FLOAT_CONST_DECIMAL64 junk
e6400500.fjt #pragma FLOAT_CONST_DECIMAL64 ON ON
e6400600.fjt #pragma FLOAT_CONST_DECIMAL64 OFF OFF
e6400700.fjt #pragma FLOAT_CONST_DECIMAL64 DEFAULT DEFAULT
e6400800.fjt #pragma FLOAT_CONST_DECIMAL64 ON after declarations
e6400900.fjt #pragma FLOAT_CONST_DECIMAL64 ON amoung statements
e6401000.fjt #pragma FLOAT_CONST_DECIMAL64 ON w/ "mixed" expression
e6401100.fjt #pragma FLOAT_CONST_DECIMAL64 OFF w/ "mixed" expression
t6402000.fjt #pragma FLOAT_CONST_DECIMAL64 ON w/ unsuffixed hexadecimal FP consts
makefile Tells how to make files for this leaf directory
makefile.00 For files other than e616*
makefile.01 For e61601*
makefile.02 For e61602*
makefile.03 For e61603*
makefile.04 For e61604*
makefile.05 For e61605*
makefile.06 For e61606*
makefile.07 For e61607*
makefile.08 For e61608*
makefile.09 For e61609*
makefile.10 For e61610*
makefile.13 For e61613*
makefile.15 For e61615*
makefile.16 For e61616*
makefile.17 For e61617*
makefile.18 For e61618*
makefile.27 For e61627*
makefile.30 For e61630*
makefile.31 For e61631*
makefile.32 For e61632*
makefile.37 For e61637*
makefile.38 For e61638*
makefile.39 For e61639*
makefile.40 For e61640*
makefile.41 For e61641*
makefile.42 For e61642*
makefile.43 For e61643*
makefile.44 For e61644*
makefile.45 For e61645*
makefile.46 For e61646*
makefile.47 For e61647*
makefile.48 For e61648*
makefile.49 For e61649*
makefile.50 For e61650*
makefile.51 For e61651*
makefile.52 For e61652*
makefile.53 For e61653*
makefile.54 For e61654*
makefile.55 For e61655*
makefile.036 For e6360*
In ../fpcets/real/dec/fenv/
makefile Tells how to make files for this leaf directory
t8100000.fjt feclearexcept() clears exception flags raised by DFP operations
t8101000.fjt feclearexcept() returns success/failure
t8140000.fjt fetestexcept() tests exception flags raised by DFP operations
t8200000.fjt fe_dec_getround() gets rounding control direction
t8210000.fjt fe_dec_setround() sets rounding control direction
In ../fpcets/real/dec/io/
g9050000.h binary->decimal conversions; %e. Generic test of printf
g9050e00.h binary->decimal conversions; %e.
g9060000.h binary->decimal->binary roundtrip conversions; %e. Generic test of printf.
g9060e00.h binary->decimal->binary roundtrip conversions; %e.
g9070000.h printf %e,%f,%g,%a supports all 32 combinations of flags. Generic test.
g9080100.h scanf of decimal #s are converted correctly. Generic test.
g9450000.h binary->decimal conversions; %e. Generic test of wprintf
g9450e00.h binary->decimal conversions; %e.
g9460000.h binary->decimal->binary roundtrip conversions; %e. Generic test of wprintf
g9460e00.h binary->decimal->binary roundtrip conversions; %e.
g9470000.h wprintf %e,%f,%g,%a supports all 32 combinations of flags. Generic test.
g9480100.h wscanf of decimal #s are converted correctly. Generic test.
g9880100.h scanf of negative decimal #s are converted correctly. Generic test.
g9980100.h wscanf of negative decimal #s are converted correctly. Generic test.
makefile Tells how to make files for this leaf directory
makefile.904 For t904*
makefile.905 For t905*
makefile.906 For t906*
makefile.907 For t907*
makefile.908 For t908*
makefile.944 For t944*
makefile.945 For t945*
makefile.946 For t946*
makefile.947 For t947*
makefile.948 For t948*
makefile.988 For t988*
makefile.998 For t998*
t9030000.fjt printf("%.2Da\n", MAX_D10)
t9040000.fjt scanf vs strtod on wierd FP strings
t9041000.fjt scanf & strtod of long FP strings (decimal)
t9042000.fjt Specific tests of sscanf; " %n" at EOF.
t905024?.fjt DFP->decimal conversions; %e, IEEE 24-bit; printf
t905053?.fjt DFP->decimal conversions; %e, IEEE 53-bit
t905064?.fjt DFP->decimal conversions; %e, IEEE 64-bit
t905106?.fjt DFP->decimal conversions; %e, double-double 106-bit
t905113?.fjt DFP->decimal conversions; %e, IEEE 113-bit
t906024?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 24-bit; printf
t906053?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 53-bit
t906064?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 64-bit
t906106?.fjt DFP->decimal->DFP roundtrip conversions; %e, double-double 106-bit
t906113?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 113-bit
t90700??.fjt printf %f supports all 32 combinations of flags in format string.
t90701??.fjt printf %e supports all 32 combinations of flags in format string.
t90702??.fjt printf %g supports all 32 combinations of flags in format string.
t90703??.fjt printf %a supports all 32 combinations of flags in format string.
t908007?.fjt scanf of decimal #s are converted correctly IEEE 7-digit
t9080100.fjt scanf of decimal #s are converted correctly (general #s).
t908016?.fjt scanf of decimal #s are converted correctly IEEE 16-digit
t908024?.fjt scanf of decimal #s are converted correctly IEEE 24-bit
t908034?.fjt scanf of decimal #s are converted correctly IEEE 34-digit
t908053?.fjt scanf of decimal #s are converted correctly IEEE 53-bit
t908064?.fjt scanf of decimal #s are converted correctly IEEE 64-bit
t908106?.fjt scanf of decimal #s are converted correctly double-double 106-bit
t908113?.fjt scanf of decimal #s are converted correctly IEEE 113-bit
t9250600.fjt Conversion from FP to decimal via %g/%G of DECIMAL_DIG digits and back; printf/scanf/strto*
t9250700.fjt Conversion from FP to decimal via %e/%E of DECIMAL_DIG digits and back; printf/scanf/strto*
t9250800.fjt Conversion from FP to decimal via %f/%F of DECIMAL_DIG digits and back; printf/scanf/strto*
*t9250900.fjt Conversion from FP to decimal via %a/%A and back (roundtrip printf/scanf/strto*).
t9430000.fjt wprintf(L"%.2Da\n", MAX_D10)
t9440000.fjt wscanf vs wcstod on wierd FP strings
t9441000.fjt wscanf & wcstod of long FP strings (decimal and hex)
t9442000.fjt Specific tests of swscanf; " %n" at EOF.
t945024?.fjt DFP->decimal conversions; %e, IEEE 24-bit; wprintf
t945053?.fjt DFP->decimal conversions; %e, IEEE 53-bit
t9450600.fjt Conversion from FP to decimal via %g/%G of DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
t945064?.fjt DFP->decimal conversions; %e, IEEE 64-bit
t9450700.fjt Conversion from FP to decimal via %e/%E of DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
t9450800.fjt Conversion from FP to decimal via %f/%F of DECIMAL_DIG digits and back; wprintf/wscanf/wcsto*
*t9450900.fjt Conversion from FP to decimal via %a/%A and back (roundtrip wprintf/wscanf/wcsto*).
t945106?.fjt DFP->decimal conversions; %e, double-double 106-bit
t945113?.fjt DFP->decimal conversions; %e, IEEE 113-bit
t946024?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 24-bit; wprintf
t946053?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 53-bit
t946064?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 64-bit
t946106?.fjt DFP->decimal->DFP roundtrip conversions; %e, double-double 106-bit
t946113?.fjt DFP->decimal->DFP roundtrip conversions; %e, IEEE 113-bit
t94700??.fjt wprintf %f supports all 32 combinations of flags in format string.
t94701??.fjt wprintf %e supports all 32 combinations of flags in format string.
t94702??.fjt wprintf %g supports all 32 combinations of flags in format string.
t94703??.fjt wprintf %a supports all 32 combinations of flags in format string.
t948007?.fjt wscanf of decimal #s are converted correctly IEEE 7-digit
t9480100.fjt wscanf of decimal #s are converted correctly (general #s).
t948016?.fjt wscanf of decimal #s are converted correctly IEEE 16-digit
t948024?.fjt wscanf of decimal #s are converted correctly IEEE 24-bit
t948034?.fjt wscanf of decimal #s are converted correctly IEEE 34-digit
t948053?.fjt wscanf of decimal #s are converted correctly IEEE 53-bit
t948064?.fjt wscanf of decimal #s are converted correctly IEEE 64-bit
t948106?.fjt wscanf of decimal #s are converted correctly double-double 106-bit
t948113?.fjt wscanf of decimal #s are converted correctly IEEE 113-bit
t988007?.fjt scanf of negative decimal #s are converted correctly IEEE 7-digit
t9880100.fjt scanf of negative decimal #s are converted correctly (general #s).
t988016?.fjt scanf of negative decimal #s are converted correctly IEEE 16-digit
t988024?.fjt scanf of negative decimal #s are converted correctly IEEE 24-bit
t988034?.fjt scanf of negative decimal #s are converted correctly IEEE 34-digit
t988053?.fjt scanf of negative decimal #s are converted correctly IEEE 53-bit
t988064?.fjt scanf of negative decimal #s are converted correctly IEEE 64-bit
t988106?.fjt scanf of negative decimal #s are converted correctly double-double 106-bit
t988113?.fjt scanf of negative decimal #s are converted correctly IEEE 113-bit
t998007?.fjt wscanf of negative decimal #s are converted correctly IEEE 7-digit
t9980100.fjt wscanf of negative decimal #s are converted correctly (general #s).
t998016?.fjt wscanf of negative decimal #s are converted correctly IEEE 16-digit
t998024?.fjt wscanf of negative decimal #s are converted correctly IEEE 24-bit
t998034?.fjt wscanf of negative decimal #s are converted correctly IEEE 34-digit
t998053?.fjt wscanf of negative decimal #s are converted correctly IEEE 53-bit
t998064?.fjt wscanf of negative decimal #s are converted correctly IEEE 64-bit
t998106?.fjt wscanf of negative decimal #s are converted correctly double-double 106-bit
t998113?.fjt wscanf of negative decimal #s are converted correctly IEEE 113-bit
v9040000.h test vectors included by t9040000, t9440000
v90703??.h printf %a test vectors included by t9070300.h, t9470300.h
In ../fpcets/real/dec/math/
makefile Tells how to make files for this leaf directory (was part of makefile.io).
makefile.10 For t11* and t12*
makefile.30 For t13* and t14*
makefile.50 For t15* and t16*
makefile.70 For t17*, t18*, and t19*
t110?00?.fjt acos() is arc cosine
t111?00?.fjt asin() is arc sine
t112?00?.fjt atan() is arc tangent
t113?00?.fjt atan2() is arc tangent2
t114?00?.fjt cos() is cosine
t115?00?.fjt sin() is sine
t116?00?.fjt tan() is tangent
t120?00?.fjt acosh() is arc hyperbolic cosine
t121?00?.fjt asinh() is arc hyperbolic sin
t122?00?.fjt atanh() is arc hyperbolic tangent
t123?00?.fjt cosh() is hyperbolic cosine
t124?00?.fjt sinh() is hyperbolic sine
t125?00?.fjt tanh() is hyperbolic tangent
t130?00?.fjt exp() is base-e exponential
t131?00?.fjt exp2() is base-2 exponential
t132?00?.fjt expm1() is exp(x) - 1
t133?00?.fjt frexp() is fraction + exponent
t134?00?.fjt ldexp() is scale by power of 2
t135?00?.fjt log() is base-e logarithm
t136?00?.fjt log10() is base-10 logarithm
t137?00?.fjt log1p() is log(1+x)
t138?00?.fjt log2() is base-2 logarithm
t139?00?.fjt logb() is base-radix logarithm
t140?00?.fjt modf() is fraction + integer
t142?00?.fjt scalbn() is scale by power of radix
t143?00?.fjt scalbln() is scale by power of radix
t144?00?.fjt ilogb() is base-radix logarithm
t145?00?.fjt quantexp() is DFP quantum exponent
t147?00?.fjt quantize() is DFP quantize
t150?00?.fjt fabs() is floating-point absolute value
t151?00?.fjt hypot() is sqrt( x*x + y*y )
t152?00?.fjt pow() is x ** y
t153?00?.fjt sqrt() is x ** 1/2
t154?00?.fjt cbrt() is x ** 1/3
t160?00?.fjt erf() is error function
t161?00?.fjt erfc() is complementary error function
t162?00?.fjt tgamma() is true gamma
t163?00?.fjt lgamma() is ln(|gamma|)
t170?00?.fjt ceil() is ceil (round +INF)
t171?00?.fjt floor() is floor (round -INF)
t172?00?.fjt nearbyint() is exact round to FP integeral
t173?00?.fjt rint() is inexact round to FP integeral
t174?00?.fjt lrint() is round to long int
t175?00?.fjt round() is biased round nearest
t176?00?.fjt lround() is biased round to long int
t177?00?.fjt trunc() is trunc toward zero
t178?00?.fjt llrint() is round to long long int
t179?00?.fjt llround() is biased round to long long int
t180?00?.fjt fmod() is remainder of x/y
t181?00?.fjt remainder() is IEEE-754 remainder of x/y
t190?00?.fjt copysign() is copysign
t191?00?.fjt nan() is nan creation
t192?00?.fjt nextafter() is nextafter
t193?00?.fjt nexttoward() is nextafter w/ 2nd arg a long double
t195?00?.fjt fdim() is positive difference between arguments
t196?00?.fjt fmax() is maximum
t197?00?.fjt fmin() is minimum
t198?00?.fjt fma() is floating multiply-add
In ../fpcets/cmplx/
g1103000.h cacos() generic test case included by t110*.fjt
g1113000.h casin() generic test case included by t111*.fjt
g1123000.h catan() generic test case included by t112*.fjt
g1133000.h carg() generic test case included by t113*.fjt
g1143000.h ccos() generic test case included by t114*.fjt
g1153000.h csin() generic test case included by t115*.fjt
g1163000.h ctan() generic test case included by t116*.fjt
g1203000.h cacosh() generic test case included by t120*.fjt
g1213000.h casinh() generic test case included by t121*.fjt
g1223000.h catanh() generic test case included by t122*.fjt
g1233000.h ccosh() generic test case included by t123*.fjt
g1243000.h csinh() generic test case included by t124*.fjt
g1253000.h ctanh() generic test case included by t125*.fjt
g1303000.h cexp() generic test case included by t130*.fjt
g1353000.h clog() generic test case included by t135*.fjt
g1513000.h cabs() generic test case included by t151*.fjt
g1523000.h cpow() generic test case included by t152*.fjt
g1533000.h csqrt() generic test case included by t153*.fjt
g1643000.h cimag() generic test case included by t164*.fjt
g1653000.h creal() generic test case included by t165*.fjt
g1663000.h conj() generic test case included by t166*.fjt
g1673000.h cproj() generic test case included by t167*.fjt
g1683000.h CMPLX() generic test case included by t168*.fjt
g1crnd1.h Checks directed rounding of math functions (one complex argument and result).
g1crndr.h Checks directed rounding of math functions (one complex argument, real result).
g2crnd1.h Checks directed rounding of math functions (two complex arguments, one result).
v110300?.h cacos() test vectors included by g110*.h
v111300?.h casin() test vectors included by g111*.h
v112300?.h catan() test vectors included by g112*.h
v113300?.h carg() test vectors included by g113*.h
v114300?.h ccos() test vectors included by g114*.h
v115300?.h csin() test vectors included by g115*.h
v116300?.h ctan() test vectors included by g116*.h
v120300?.h cacosh() test vectors included by g120*.h
v121300?.h casinh() test vectors included by g121*.h
v122300?.h catanh() test vectors included by g122*.h
v123300?.h ccosh() test vectors included by g123*.h
v124300?.h csinh() test vectors included by g124*.h
v125300?.h ctanh() test vectors included by g125*.h
v130300?.h cexp() test vectors included by g130*.h
v135300?.h clog() test vectors included by g135*.h
v151300?.h cabs() test vectors included by g151*.h
v152300?.h cpow() test vectors included by g152*.h
v153300?.h csqrt() test vectors included by g153*.h
v164300?.h cimag() test vectors included by g164*.h
v165300?.h creal() test vectors included by g165*.h
v166300?.h conj() test vectors included by g166*.h
v167300?.h cproj() test vectors included by g167*.h
v168300?.h CMPLX() test vectors included by g168*.h
In ../fpcets/cmplx/bin/
In ../fpcets/cmplx/bin/compiler/
makefile Tells how to make files for this leaf directory
t4000000.fjt (GET,SET)x(REAL,IMAG,CMPLX), *_CMPLX_C work as expected.
t40301??.fjt Arithmetic operator (binary *) is correct with complex operands.
t40301mm.fjt w*z == z*w.
t40301nn.fjt w*z == (-w)*(-z)
t40301pp.fjt w*(+/-1) == w*(+/-1+0I) == w*(+/-1-0I)
t40301qq.fjt w*(+/-I) == w*(+0+/-I) == w*(-0+/-I)
t40301rr.fjt 0 == cimag(w*conj(w)), for non-NaN.
t40301ss.fjt inf == inf * (inf or non-zero finite)
t40301tt.fjt zero == zero * finite
t40302??.fjt Arithmetic operator (binary /) is correct with complex operands.
t40302mm.fjt w/z == (1/z)/(1/w) within ULPS_CMPLX_DIV_* for each axis.
t40302nn.fjt w/z == (-w)/(-z)
t40302pp.fjt w/(+/-1) == w/(+/-1+0I) == w/(+/-1-0I)
t40302qq.fjt w/(+/-I) == w/(+0+/-I) == w/(-0+/-I)
t40302rr.fjt w/w == 1+0I, for non-NaN non-inf non-zero w.
t40302ss.fjt inf = inf / finite == inf * (1 / finite)
t40302tt.fjt zero = finite / inf == finite * (1 / inf)
t40302uu.fjt inf = (inf or non-zero finite) / zero == (inf or non-zero finite) * (1 / zero)
t40302vv.fjt zero = zero / non-zero
t40302ww.fjt z == 1/(1/z) == r/(r/z) within ULPS_CMPLX_DIV_* for each axis.
t4030300.fjt Arithmetic operator (binary +) is correct with complex operands.
t40303mm.fjt w+z == z+w.
t40303nn.fjt -(w+z) == (-w)+(-z) for non-NaN, non-zero.
t4030400.fjt Arithmetic operator (binary -) is correct with complex operands.
t40304mm.fjt w-z == -(z-w) for non-NaN, non-zero.
t40304nn.fjt w+z == w-(-z) for non-NaN, non-zero.
t4120900.fjt bool from Complex
t4120901.fjt bool from Imaginary.
t4160301.fjt Arithmetic operator (binary *) is usable with complex operands.
t4160302.fjt Arithmetic operator (binary /) is usable with complex operands.
t4160303.fjt Arithmetic operator (binary +) is usable with complex operands.
t4160304.fjt Arithmetic operator (binary -) is usable with complex operands.
t4160309.fjt Arithmetic operator (binary ==) is usable with complex operands.
t4160310.fjt Arithmetic operator (binary !=) is usable with complex operands.
t4160311.fjt Arithmetic operator (binary &&) is usable with complex operands.
t4160312.fjt Arithmetic operator (binary ||) is usable with complex operands.
t4160313.fjt Arithmetic operator (triary ?:) is usable with complex operands.
t4160314.fjt Arithmetic operator (binary =) is usable with complex operands.
t4160315.fjt Arithmetic operator (binary +=) is usable with complex operands.
t4160316.fjt Arithmetic operator (binary -=) is usable with complex operands.
t4160317.fjt Arithmetic operator (binary *=) is usable with complex operands.
t4160318.fjt Arithmetic operator (binary /=) is usable with complex operands.
t4160319.fjt Arithmetic operator (binary ,) is usable with complex operands.
t4160320.fjt Arithmetic operator (cast) is usable with complex operands.
t4160321.fjt Arithmetic operator (parameter assignment) is usable with complex operands.
t4160322.fjt Arithmetic operator (varargs parameter assignment) is usable with complex operands.
t4160323.fjt Arithmetic operator (no prototype parameter assignment) is usable with complex operands.
t4160324.fjt Arithmetic operator (old style parameter assignment) is usable with complex operands.
t4160325.fjt Arithmetic operator (return) is usable with complex operands.
t4160326.fjt Arithmetic operator (sizeof) is usable with complex operands.
t4160327.fjt Arithmetic operator (unary & and *) is usable with complex operands.
t4160328.fjt Arithmetic operator (unary .) is usable with complex operands.
t4160329.fjt Arithmetic operator (unary ->) is usable with complex operands.
t4160330.fjt Arithmetic operator (binary []) is usable with complex operands.
t4160331.fjt Arithmetic operator (binary [] and VLA) is usable with complex operands.
t4160332.fjt Arithmetic operator (binary [] and flex) is usable with complex operands.
t4160335.fjt Arithmetic operator (unary + and -) is usable with complex operands.
t4160336.fjt Arithmetic operator (unary !) is usable with complex operands.
t4160400.fjt Arithmetic operator (compound =) is usable with arithmetic operands.
t4350003.fjt macros are parenthesized
t43600*.fjt Permutations of keywords in declarations - complex binary: func locals
t43601*.fjt "" - in 'for' statement
t4380000.fjt defines several macros
In ../fpcets/cmplx/bin/errors/
e41638??.fjt Arithmetic operator (binary %) with bad complex operands.
e41639??.fjt Arithmetic operator (binary <<) with bad complex operands.
e41640??.fjt Arithmetic operator (binary >>) with bad complex operands.
e41641??.fjt Arithmetic operator (binary &) with bad complex operands.
e41642??.fjt Arithmetic operator (binary ^) with bad complex operands.
e41643??.fjt Arithmetic operator (binary |) with bad complex operands.
e41644??.fjt Arithmetic operator (binary %=) with bad complex operands.
e41645??.fjt Arithmetic operator (binary <<=) with bad complex operands.
e41646??.fjt Arithmetic operator (binary >>=) with bad complex operands.
e41647??.fjt Arithmetic operator (binary &=) with bad complex operands.
e41648??.fjt Arithmetic operator (binary ^=) with bad complex operands.
e41649??.fjt Arithmetic operator (binary |=) with bad complex operands.
e4360*.fjt Bad combinations of keywords in declarations - cmplx binary: func locals
e4361*.fjt Bad combinations of keywords in 'for' declarations - cmplx binary
makefile Tells how to make files for this leaf directory
makefile.381 For e41638*
makefile.382 For e41638*
makefile.391 For e41639*
makefile.392 For e41639*
makefile.401 For e41640*
makefile.402 For e41640*
makefile.411 For e41641*
makefile.412 For e41641*
makefile.421 For e41642*
makefile.422 For e41642*
makefile.431 For e41643*
makefile.432 For e41643*
makefile.441 For e41644*
makefile.442 For e41644*
makefile.451 For e41645*
makefile.452 For e41645*
makefile.461 For e41646*
makefile.462 For e41646*
makefile.471 For e41647*
makefile.472 For e41647*
makefile.481 For e41648*
makefile.482 For e41648*
makefile.491 For e41649*
makefile.492 For e41649*
makefile.036 For e4360*
In ../fpcets/cmplx/bin/error2/
e41605??.fjt Arithmetic operator (binary <) with bad complex operands.
e41606??.fjt Arithmetic operator (binary <=) with bad complex operands.
e41607??.fjt Arithmetic operator (binary >) with bad complex operands.
e41608??.fjt Arithmetic operator (binary >=) with bad complex operands.
e41627??.fjt Arithmetic operator (unary & and *) with bad complex operands.
e41630??.fjt Arithmetic operator (binary []) with bad complex operands.
e41631??.fjt Arithmetic operator (binary [] and VLA) with bad complex operands.
e41632??.fjt Arithmetic operator (binary [] and flex) with bad complex operands.
e41633??.fjt Arithmetic operator (unary post ++ and --) with bad complex operands.
e41634??.fjt Arithmetic operator (unary pre ++ and --) with bad complex operands.
e41637??.fjt Arithmetic operator (unary ~) with bad complex operands.
e41650??.fjt Arithmetic operator (isless) with bad complex operands.
e41651??.fjt Arithmetic operator (islessequal) with bad complex operands.
e41652??.fjt Arithmetic operator (isgreaterequal) with bad complex operands.
e41653??.fjt Arithmetic operator (isgreater) with bad complex operands.
e41654??.fjt Arithmetic operator (islessgreater) with bad complex operands.
e41655??.fjt Arithmetic operator (isunordered) with bad complex operands.
e41660??.fjt Arithmetic operator (fpclassify) with bad complex operands.
e41661??.fjt Arithmetic operator (isfinite) with bad complex operands.
e41662??.fjt Arithmetic operator (isinf) with bad complex operands.
e41663??.fjt Arithmetic operator (isnan) with bad complex operands.
e41664??.fjt Arithmetic operator (isnormal) with bad complex operands.
e41665??.fjt Arithmetic operator (signbit) with bad complex operands.
makefile Tells how to make files for this leaf directory
makefile.051 For e41605*
makefile.052 For e41605*
makefile.061 For e41606*
makefile.062 For e41606*
makefile.071 For e41607*
makefile.072 For e41607*
makefile.081 For e41608*
makefile.082 For e41608*
makefile.27 For e41627*
makefile.30 For e41630*
makefile.31 For e41631*
makefile.32 For e41632*
makefile.33 For e41633*
makefile.34 For e41634*
makefile.37 For e41637*
makefile.501 For e41650*
makefile.502 For e41650*
makefile.511 For e41651*
makefile.512 For e41651*
makefile.521 For e41652*
makefile.522 For e41652*
makefile.531 For e41653*
makefile.532 For e41653*
makefile.541 For e41654*
makefile.542 For e41654*
makefile.551 For e41655*
makefile.552 For e41655*
makefile.60 For e41660*
makefile.61 For e41661*
makefile.62 For e41662*
makefile.63 For e41663*
makefile.64 For e41664*
makefile.65 For e41665*
In ../fpcets/cmplx/bin/math/
makefile Tells how to make files for this leaf directory
makefile.10 For t11* and t12*
makefile.30 For t13* and t14*
makefile.50 For t15* and t16*
t110?00?.fjt cacos() is complex arc cosine
t111?00?.fjt casin() is complex arc sine
t112?00?.fjt catan() is complex arc tangent
t113?00?.fjt carg() is complex argument or phase angle = atan2(y,x)
t114?00?.fjt ccos() is complex cosine
t115?00?.fjt csin() is complex sine
t116?00?.fjt ctan() is complex tangent
t120?00?.fjt cacosh() is complex arc hyperbolic cosine
t121?00?.fjt casinh() is complex arc hyperbolic sin
t122?00?.fjt catanh() is complex arc hyperbolic tangent
t123?00?.fjt ccosh() is complex hyperbolic cosine
t124?00?.fjt csinh() is complex hyperbolic sine
t125?00?.fjt ctanh() is complex hyperbolic tangent
t130?00?.fjt cexp() is complex base-e exponential
t135?00?.fjt clog() is complex base-e logarithm
t151?00?.fjt cabs() is complex absolute value = hypot(x,y)
t152?00?.fjt cpow() is complex x ** y
t153?00?.fjt csqrt() is complex x ** 1/2
t164?00?.fjt cimag() is imaginary part
t165?00?.fjt creal() is real part
t166?00?.fjt conj() is complex conjugate
t167?00?.fjt cproj() is projection onto the Riemann sphere
t168?00?.fjt CMPLX() creates a complex number
In ../fpcets/cmplx/dec/
In ../fpcets/cmplx/dec/compiler/
makefile Tells how to make files for this leaf directory
t7160311.fjt Arithmetic operator (binary &&) is usable with complex & DFP operands.
t7160312.fjt Arithmetic operator (binary ||) is usable with complex & DFP operands.
t7160314.fjt Arithmetic operator (binary =) is usable with complex & DFP operands.
t7160319.fjt Arithmetic operator (binary ,) is usable with complex & DFP operands.
t7160320.fjt Arithmetic operator (cast) is usable with complex & DFP operands.
t7160321.fjt Arithmetic operator (parameter assignment) is usable with complex & DFP operands.
t7160325.fjt Arithmetic operator (return) is usable with complex & DFP operands.
In ../fpcets/cmplx/dec/errors/
e71601??.fjt Arithmetic operator (binary *) with bad complex/DFP operands.
e71602??.fjt Arithmetic operator (binary /) with bad complex/DFP operands.
e71603??.fjt Arithmetic operator (binary +) with bad complex/DFP operands.
e71604??.fjt Arithmetic operator (binary -) with bad complex/DFP operands.
e71605??.fjt Arithmetic operator (binary <) with bad complex/DFP operands.
e71606??.fjt Arithmetic operator (binary <=) with bad complex/DFP operands.
e71607??.fjt Arithmetic operator (binary >) with bad complex/DFP operands.
e71608??.fjt Arithmetic operator (binary >=) with bad complex/DFP operands.
e71609??.fjt Arithmetic operator (binary ==) with bad complex/DFP operands.
e71610??.fjt Arithmetic operator (binary !=) with bad complex/DFP operands.
e71613??.fjt Arithmetic operator (triary ?:) with bad complex/DFP operands.
e71615??.fjt Arithmetic operator (binary +=) with bad complex/DFP operands.
e71616??.fjt Arithmetic operator (binary -=) with bad complex/DFP operands.
e71617??.fjt Arithmetic operator (binary *=) with bad complex/DFP operands.
e71618??.fjt Arithmetic operator (binary /=) with bad complex/DFP operands.
e71630??.fjt Arithmetic operator (binary []) with bad complex/DFP operands.
e71631??.fjt Arithmetic operator (binary [] and VLA) with bad complex/DFP operands.
e71632??.fjt Arithmetic operator (binary [] and flex) with bad complex/DFP operands.
e71638??.fjt Arithmetic operator (binary %) with bad complex/DFP operands.
e71639??.fjt Arithmetic operator (binary <<) with bad complex/DFP operands.
e71640??.fjt Arithmetic operator (binary >>) with bad complex/DFP operands.
e71641??.fjt Arithmetic operator (binary &) with bad complex/DFP operands.
e71642??.fjt Arithmetic operator (binary ^) with bad complex/DFP operands.
e71643??.fjt Arithmetic operator (binary |) with bad complex/DFP operands.
e71644??.fjt Arithmetic operator (binary %=) with bad complex/DFP operands.
e71645??.fjt Arithmetic operator (binary <<=) with bad complex/DFP operands.
e71646??.fjt Arithmetic operator (binary >>=) with bad complex/DFP operands.
e71647??.fjt Arithmetic operator (binary &=) with bad complex/DFP operands.
e71648??.fjt Arithmetic operator (binary ^=) with bad complex/DFP operands.
e71649??.fjt Arithmetic operator (binary |=) with bad complex/DFP operands.
e71650??.fjt Arithmetic operator (isless) with bad complex/DFP operands.
e71651??.fjt Arithmetic operator (islessequal) with bad complex/DFP operands.
e71652??.fjt Arithmetic operator (isgreaterequal) with bad complex/DFP operands.
e71653??.fjt Arithmetic operator (isgreater) with bad complex/DFP operands.
e71654??.fjt Arithmetic operator (islessgreater) with bad complex/DFP operands.
e71655??.fjt Arithmetic operator (isunordered) with bad complex/DFP operands.
e7360*.fjt Bad combinations of keywords in declarations - cmplx decimal: func locals
e7361*.fjt Bad combinations of keywords in 'for' declarations - cmplx decimal
makefile Tells how to make files for this leaf directory
makefile.01 For e71601*
makefile.02 For e71602*
makefile.03 For e71603*
makefile.04 For e71604*
makefile.05 For e71605*
makefile.06 For e71606*
makefile.07 For e71607*
makefile.08 For e71608*
makefile.09 For e71609*
makefile.10 For e71610*
makefile.13 For e71613*
makefile.15 For e71615*
makefile.16 For e71616*
makefile.17 For e71617*
makefile.18 For e71618*
makefile.30 For e71630*
makefile.31 For e71631*
makefile.32 For e71632*
makefile.38 For e71638*
makefile.39 For e71639*
makefile.40 For e71640*
makefile.41 For e71641*
makefile.42 For e71642*
makefile.43 For e71643*
makefile.44 For e71644*
makefile.45 For e71645*
makefile.46 For e71646*
makefile.47 For e71647*
makefile.48 For e71648*
makefile.49 For e71649*
makefile.50 For e71650*
makefile.51 For e71651*
makefile.52 For e71652*
makefile.53 For e71653*
makefile.54 For e71654*
makefile.55 For e71655*
makefile.036 For e7360*
In ../fpcets/cmplx/dec/math/
makefile Tells how to make files for this leaf directory
In ../fpcets/sample/
To Be Done
In ../fpcets/compilerN/
setenv.* Sets the environment variables for your setup.
makefile High level file to direct 'make' in each target leaf directory.
*.bug Implementation defined accuracy; FIX_*s of bugs found.
*.flt Correct values to describe floating-point environment (float.h is
wrong for some compilers).
support.lib s0* files, as *.obj, combined; built on the fly via make.
or
support.a s0* files, as *.o, combined; built on the fly via make.
In my test suite, all files names are lower case. In the Taligent
test environment, the file names were mixed case and the Unix shell
script mixed.sh was needed after an install.
================================================================
The following are files from previous versions of the FPCE Test Suite.
They are no longer shipped (but may be asked for if still needed).
In ../fpcets/
makefile.shp The makefile used to create the files shipped to you.
It is not needed to run the tests. No longer shipped.
The following (dos and unix) files are part of the previous setup and
directory structure (and are no longer needed).
In ..\fpcets\dos\
makefile.cmp Dependencies of the compiler tests
makefile.dep Lowest level dependencies of all files
makefile.io Dependencies of the I/O library tests
makefile.mth Dependencies of the math library tests
makefile.rul Rules used by make to compile/link/run
listlib*.txt Sample list of libraries used during Borland link edit.
There may be one listlib file for each memory model.
In ../fpcets/unix/
makefile.cmp Dependencies of the compiler tests
makefile.dep Lowest level dependencies of all files
makefile.io Dependencies of the I/O library tests
makefile.mth Dependencies of the math library tests
check_wc.sh Check the word count (wc) results of the source; if make check_wc fails.
flip.sh Optional: Change line end conventions (from DOS to Unix).
longdbl.sh Optional: Makes fake long double results files.
lower.sh Optional: Make file names be lower case.
mixed.sh Optional: Make file names be mixed case (no longer needed).
notxt.sh Optional: Fix file names uploaded by Mac fetch.
The following ../fpcets/.../ files, are not needed for testing C99
conformance. These are for tests of features that were part of FPCE
that were not adopted into C99. Or, for the m*.* files, they are used
by Tydeman to generate other test files.
e0200050.fjt __FPCE__ can't be #undef nor #define
e0210254.fjt scalb
e0210382.fjt sclabf
e0210383.fjt scalbl
e0210446.fjt j0
e0210447.fjt j0f
e0210448.fjt j0l
e0210449.fjt j1
e0210450.fjt j1f
e0210451.fjt j1l
e0210452.fjt jn
e0210453.fjt jnf
e0210454.fjt jnl
e0210455.fjt y0
e0210456.fjt y0f
e0210457.fjt y0l
e0210458.fjt y1
e0210459.fjt y1f
e0210460.fjt y1l
e0210461.fjt yn
e0210462.fjt ynf
e0210463.fjt ynl
e0210464.fjt lgamma_r
e0210465.fjt lgammaf_r
e0210466.fjt lgammal_r
e0210467.fjt annuity
e0210468.fjt annuityf
e0210469.fjt annuityl
e0210470.fjt compound
e0210471.fjt compoundf
e0210472.fjt compoundl
g1410000.h scalb() generic test case included by t141*.fjt
s0150000.fjt #pragma fp_wide_function_returns support functions
s0150100.fjt #pragma fp_wide_function_parameters support functions
s0150200.fjt Currently not needed. Was for testing some NCEG pragmas.
t0060200.fjt _WIDEST_NEED_EVAL is in
t0150000.fjt #pragma fp_wide_function_returns allows widened return value
t0150100.fjt #pragma fp_wide_function_parameters allows widened parameters
t0150200.fjt #pragma fp_wide_variables allows widened variables
t0150800.fjt #pragma fp_wide_function_* has no effect on prototypes
t0151100.fjt Casts and #pragma fp_wide_*
t0260280.fjt Proposed additions to FPCE / C99 functions are linkable
t141?00?.fjt scalb() is scale by power of radix
t2400000.fjt fetesttrap() returns FPU traps currently enabled
t2410000.fjt feenabletrap() enables FPU traps, tests SIGFPE.
v141000?.h scalb() test vectors included by g141*.h
w0070200.fjt Warning if precision requirements are not met
w0150900.fjt sizeof widened var is warning
w0150901.fjt address of widened var is warning
w0150902.fjt sizeof widened parm is warning
w0150903.fjt address of widened parm is warning
**