Copyright (C) 1994, 2012 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 -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 make. 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()). 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) 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. 11) For functions that raise spurious underflows, try #define FIX_BAD_UF_GOT_xxx 12) For functions that overflow at the wrong point, try #define IMPL_SUPPRESS_OVER_xxx 13) 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. decwchar.h Dummy Decimal FP wchar.h mapping to Binary FP names. 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. 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 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 t0000600.fjt *_HAS_SUBNORM, *_TRUE_MIN. t0005000.fjt and *_PREC are correct. t0010000.fjt + and - work as expected (addition table) t0010100.fjt * and / work as expected (multiplication table) 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 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 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. 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 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 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 t6010000.fjt + and - work as expected (addition table) t6010100.fjt * and / work as expected (multiplication table) 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 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 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/ In ../fpcets/cmplx/bin/ In ../fpcets/cmplx/bin/compiler/ makefile Tells how to make files for this leaf directory 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) 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 t40302tt.fjt zero = finite / inf t40302uu.fjt inf = (inf or non-zero finite) / zero t4030300.fjt Arithmetic operator (binary +) is correct with complex operands. t40303mm.fjt w+z == z+w. t40303nn.fjt -(w+z) == (-w)+(-z) t4030400.fjt Arithmetic operator (binary -) is correct with complex operands. t40304mm.fjt w-z == -(z-w) for non-NaN. t40304nn.fjt w+z == w-(-z) for non-NaN. 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