Standard Libraries for EDK II.
authordarylm503 <darylm503@6f19259b-4bc3-4df7-8a09-765794883524>
Wed, 27 Apr 2011 21:42:16 +0000 (21:42 +0000)
committerdarylm503 <darylm503@6f19259b-4bc3-4df7-8a09-765794883524>
Wed, 27 Apr 2011 21:42:16 +0000 (21:42 +0000)
This set of three packages: AppPkg, StdLib, StdLibPrivateInternalFiles; contains the implementation of libraries based upon non-UEFI standards such as ISO/IEC-9899, the library portion of the C Language Standard, POSIX, etc.

AppPkg contains applications that make use of the standard libraries defined in the StdLib Package.

StdLib contains header (include) files and the implementations of the standard libraries.

StdLibPrivateInternalFiles contains files for the exclusive use of the library implementations in StdLib.  These files should never be directly referenced from applications or other code.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11600 6f19259b-4bc3-4df7-8a09-765794883524

503 files changed:
AppPkg/AppPkg.dsc [new file with mode: 0644]
AppPkg/Applications/Enquire/Enquire.c [new file with mode: 0644]
AppPkg/Applications/Enquire/Enquire.inf [new file with mode: 0644]
AppPkg/Applications/Hello/Hello.c [new file with mode: 0644]
AppPkg/Applications/Hello/Hello.inf [new file with mode: 0644]
AppPkg/Applications/Main/Main.c [new file with mode: 0644]
AppPkg/Applications/Main/Main.inf [new file with mode: 0644]
AppPkg/ReadMe.pdf [new file with mode: 0644]
StdLib/Include/Arm/machine/_math.h [new file with mode: 0644]
StdLib/Include/Arm/machine/ansi.h [new file with mode: 0644]
StdLib/Include/Arm/machine/asm.h [new file with mode: 0644]
StdLib/Include/Arm/machine/atomic.h [new file with mode: 0644]
StdLib/Include/Arm/machine/cpufunc.h [new file with mode: 0644]
StdLib/Include/Arm/machine/float.h [new file with mode: 0644]
StdLib/Include/Arm/machine/frame.h [new file with mode: 0644]
StdLib/Include/Arm/machine/ieee.h [new file with mode: 0644]
StdLib/Include/Arm/machine/lock.h [new file with mode: 0644]
StdLib/Include/Arm/machine/math.h [new file with mode: 0644]
StdLib/Include/Arm/machine/mcontext.h [new file with mode: 0644]
StdLib/Include/Arm/machine/proc.h [new file with mode: 0644]
StdLib/Include/Arm/machine/signal.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/_math.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/ansi.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/asm.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/bswap.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/byte_swap.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/endian.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/endian_machdep.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/float.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/ieee.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/int_const.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/int_limits.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/int_mwgwtypes.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/int_types.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/limits.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/math.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/param.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/signal.h [new file with mode: 0644]
StdLib/Include/Ia32/machine/types.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/_regset.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/acpi_func.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/acpi_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/acpica_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ansi.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/aout_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/asm.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/bootinfo.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/bswap.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/cdefs.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/cpu.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/cpu_counter.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/db_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/dig64.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/disklabel.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/efi.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/elf_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/endian.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/endian_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/float.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ia64_cpu.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ieee.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ieeefp.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/int_const.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/int_fmtio.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/int_limits.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/int_mwgwtypes.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/int_types.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/intr.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/intrcnt.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/limits.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/loadfile_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/math.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/mca_machdep.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/md_var.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/pal.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/param.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/pcb.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/pmap.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/pte.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ptrace.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/reg.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/sal.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/setjmp.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/signal.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/smp.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/ssc.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/stdarg.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/types.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/varargs.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/vmparam.h [new file with mode: 0644]
StdLib/Include/Ipf/machine/wchar_limits.h [new file with mode: 0644]
StdLib/Include/X64/machine/ansi.h [new file with mode: 0644]
StdLib/Include/X64/machine/asm.h [new file with mode: 0644]
StdLib/Include/X64/machine/atomic.h [new file with mode: 0644]
StdLib/Include/X64/machine/bswap.h [new file with mode: 0644]
StdLib/Include/X64/machine/byte_swap.h [new file with mode: 0644]
StdLib/Include/X64/machine/endian.h [new file with mode: 0644]
StdLib/Include/X64/machine/endian_machdep.h [new file with mode: 0644]
StdLib/Include/X64/machine/float.h [new file with mode: 0644]
StdLib/Include/X64/machine/fpu.h [new file with mode: 0644]
StdLib/Include/X64/machine/ieee.h [new file with mode: 0644]
StdLib/Include/X64/machine/int_const.h [new file with mode: 0644]
StdLib/Include/X64/machine/int_fmtio.h [new file with mode: 0644]
StdLib/Include/X64/machine/int_limits.h [new file with mode: 0644]
StdLib/Include/X64/machine/int_mwgwtypes.h [new file with mode: 0644]
StdLib/Include/X64/machine/int_types.h [new file with mode: 0644]
StdLib/Include/X64/machine/limits.h [new file with mode: 0644]
StdLib/Include/X64/machine/math.h [new file with mode: 0644]
StdLib/Include/X64/machine/param.h [new file with mode: 0644]
StdLib/Include/X64/machine/signal.h [new file with mode: 0644]
StdLib/Include/X64/machine/types.h [new file with mode: 0644]
StdLib/Include/arpa/inet.h [new file with mode: 0644]
StdLib/Include/arpa/nameser.h [new file with mode: 0644]
StdLib/Include/arpa/nameser_compat.h [new file with mode: 0644]
StdLib/Include/assert.h [new file with mode: 0644]
StdLib/Include/ctype.h [new file with mode: 0644]
StdLib/Include/dirent.h [new file with mode: 0644]
StdLib/Include/errno.h [new file with mode: 0644]
StdLib/Include/fcntl.h [new file with mode: 0644]
StdLib/Include/float.h [new file with mode: 0644]
StdLib/Include/inttypes.h [new file with mode: 0644]
StdLib/Include/iso646.h [new file with mode: 0644]
StdLib/Include/langinfo.h [new file with mode: 0644]
StdLib/Include/limits.h [new file with mode: 0644]
StdLib/Include/locale.h [new file with mode: 0644]
StdLib/Include/math.h [new file with mode: 0644]
StdLib/Include/netinet/in.h [new file with mode: 0644]
StdLib/Include/netinet6/in6.h [new file with mode: 0644]
StdLib/Include/nl_types.h [new file with mode: 0644]
StdLib/Include/paths.h [new file with mode: 0644]
StdLib/Include/setjmp.h [new file with mode: 0644]
StdLib/Include/signal.h [new file with mode: 0644]
StdLib/Include/stdarg.h [new file with mode: 0644]
StdLib/Include/stdbool.h [new file with mode: 0644]
StdLib/Include/stddef.h [new file with mode: 0644]
StdLib/Include/stdint.h [new file with mode: 0644]
StdLib/Include/stdio.h [new file with mode: 0644]
StdLib/Include/stdlib.h [new file with mode: 0644]
StdLib/Include/string.h [new file with mode: 0644]
StdLib/Include/sys/EfiCdefs.h [new file with mode: 0644]
StdLib/Include/sys/EfiSysCall.h [new file with mode: 0644]
StdLib/Include/sys/_ctype.h [new file with mode: 0644]
StdLib/Include/sys/ansi.h [new file with mode: 0644]
StdLib/Include/sys/bswap.h [new file with mode: 0644]
StdLib/Include/sys/callout.h [new file with mode: 0644]
StdLib/Include/sys/cdefs_aout.h [new file with mode: 0644]
StdLib/Include/sys/dirent.h [new file with mode: 0644]
StdLib/Include/sys/endian.h [new file with mode: 0644]
StdLib/Include/sys/errno.h [new file with mode: 0644]
StdLib/Include/sys/fcntl.h [new file with mode: 0644]
StdLib/Include/sys/fd_set.h [new file with mode: 0644]
StdLib/Include/sys/featuretest.h [new file with mode: 0644]
StdLib/Include/sys/filio.h [new file with mode: 0644]
StdLib/Include/sys/float_ieee754.h [new file with mode: 0644]
StdLib/Include/sys/ieee754.h [new file with mode: 0644]
StdLib/Include/sys/inttypes.h [new file with mode: 0644]
StdLib/Include/sys/ioccom.h [new file with mode: 0644]
StdLib/Include/sys/localedef.h [new file with mode: 0644]
StdLib/Include/sys/param.h [new file with mode: 0644]
StdLib/Include/sys/pool.h [new file with mode: 0644]
StdLib/Include/sys/resource.h [new file with mode: 0644]
StdLib/Include/sys/select.h [new file with mode: 0644]
StdLib/Include/sys/signal.h [new file with mode: 0644]
StdLib/Include/sys/sigtypes.h [new file with mode: 0644]
StdLib/Include/sys/socket.h [new file with mode: 0644]
StdLib/Include/sys/stat.h [new file with mode: 0644]
StdLib/Include/sys/stdint.h [new file with mode: 0644]
StdLib/Include/sys/syslimits.h [new file with mode: 0644]
StdLib/Include/sys/termios.h [new file with mode: 0644]
StdLib/Include/sys/time.h [new file with mode: 0644]
StdLib/Include/sys/types.h [new file with mode: 0644]
StdLib/Include/sys/uio.h [new file with mode: 0644]
StdLib/Include/time.h [new file with mode: 0644]
StdLib/Include/wchar.h [new file with mode: 0644]
StdLib/Include/wctype.h [new file with mode: 0644]
StdLib/Include/x86/float.h [new file with mode: 0644]
StdLib/Include/x86/ieee.h [new file with mode: 0644]
StdLib/Include/x86/limits.h [new file with mode: 0644]
StdLib/Include/x86/math.h [new file with mode: 0644]
StdLib/LibC/CRT/Gcc.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/ashrdi3.S [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/lldiv.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/lldvrm.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/llmul.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/llrem.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/llshl.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/mulll.S [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/shldi3.S [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/udivdi3.S [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/ulldiv.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/ulldvrm.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/ullrem.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/ullshr.c [new file with mode: 0644]
StdLib/LibC/CRT/Ia32/umoddi3.S [new file with mode: 0644]
StdLib/LibC/Ctype/CClass.c [new file with mode: 0644]
StdLib/LibC/Ctype/CConv.c [new file with mode: 0644]
StdLib/LibC/Ctype/Ctype.inf [new file with mode: 0644]
StdLib/LibC/Ctype/iCtype.c [new file with mode: 0644]
StdLib/LibC/LibC.inf [new file with mode: 0644]
StdLib/LibC/Locale/Locale.inf [new file with mode: 0644]
StdLib/LibC/Locale/__mb_cur_max.c [new file with mode: 0644]
StdLib/LibC/Locale/__wctoint.h [new file with mode: 0644]
StdLib/LibC/Locale/_def_messages.c [new file with mode: 0644]
StdLib/LibC/Locale/_def_monetary.c [new file with mode: 0644]
StdLib/LibC/Locale/_def_numeric.c [new file with mode: 0644]
StdLib/LibC/Locale/_def_time.c [new file with mode: 0644]
StdLib/LibC/Locale/_wcstod.h [new file with mode: 0644]
StdLib/LibC/Locale/_wcstol.h [new file with mode: 0644]
StdLib/LibC/Locale/_wcstoul.h [new file with mode: 0644]
StdLib/LibC/Locale/aliasname.c [new file with mode: 0644]
StdLib/LibC/Locale/aliasname_local.h [new file with mode: 0644]
StdLib/LibC/Locale/ctypeio.c [new file with mode: 0644]
StdLib/LibC/Locale/ctypeio.h [new file with mode: 0644]
StdLib/LibC/Locale/iswctype_sb.c [new file with mode: 0644]
StdLib/LibC/Locale/localeconv.c [new file with mode: 0644]
StdLib/LibC/Locale/multibyte_sb.c [new file with mode: 0644]
StdLib/LibC/Locale/nl_langinfo.c [new file with mode: 0644]
StdLib/LibC/Locale/rune.h [new file with mode: 0644]
StdLib/LibC/Locale/runetype.h [new file with mode: 0644]
StdLib/LibC/Locale/setlocale.c [new file with mode: 0644]
StdLib/LibC/Locale/setlocale1.c [new file with mode: 0644]
StdLib/LibC/Locale/setlocale32.c [new file with mode: 0644]
StdLib/LibC/Locale/wcscoll.c [new file with mode: 0644]
StdLib/LibC/Locale/wcsftime.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstod.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstof.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstoimax.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstol.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstold.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstoll.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstoul.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstoull.c [new file with mode: 0644]
StdLib/LibC/Locale/wcstoumax.c [new file with mode: 0644]
StdLib/LibC/Locale/wcsxfrm.c [new file with mode: 0644]
StdLib/LibC/Main/Arm/flt_rounds.c [new file with mode: 0644]
StdLib/LibC/Main/ByteSwap.c [new file with mode: 0644]
StdLib/LibC/Main/HtoNtoH.c [new file with mode: 0644]
StdLib/LibC/Main/Ia32/fpu_rmode.S [new file with mode: 0644]
StdLib/LibC/Main/Ia32/fpu_rmode.asm [new file with mode: 0644]
StdLib/LibC/Main/Ia32/ftol2.obj [new file with mode: 0644]
StdLib/LibC/Main/Ia32/isinfl.c [new file with mode: 0644]
StdLib/LibC/Main/Ia32/isnanl.c [new file with mode: 0644]
StdLib/LibC/Main/Ipf/FpuRmode.s [new file with mode: 0644]
StdLib/LibC/Main/Ipf/flt_rounds.c [new file with mode: 0644]
StdLib/LibC/Main/Main.c [new file with mode: 0644]
StdLib/LibC/Main/X64/fpu_rmode.S [new file with mode: 0644]
StdLib/LibC/Main/X64/fpu_rmode.asm [new file with mode: 0644]
StdLib/LibC/Main/X64/isinfl.c [new file with mode: 0644]
StdLib/LibC/Main/X64/isnanl.c [new file with mode: 0644]
StdLib/LibC/Main/assert.c [new file with mode: 0644]
StdLib/LibC/Main/bswap16.c [new file with mode: 0644]
StdLib/LibC/Main/bswap32.c [new file with mode: 0644]
StdLib/LibC/Main/bswap64.c [new file with mode: 0644]
StdLib/LibC/Main/errno.c [new file with mode: 0644]
StdLib/LibC/Main/infinityf_ieee754.c [new file with mode: 0644]
StdLib/LibC/Main/isinfd_ieee754.c [new file with mode: 0644]
StdLib/LibC/Main/isinff_ieee754.c [new file with mode: 0644]
StdLib/LibC/Main/isnand_ieee754.c [new file with mode: 0644]
StdLib/LibC/Main/isnanf_ieee754.c [new file with mode: 0644]
StdLib/LibC/Main/longjmp.c [new file with mode: 0644]
StdLib/LibC/Main/x86flt_rounds.c [new file with mode: 0644]
StdLib/LibC/Math/Math.inf [new file with mode: 0644]
StdLib/LibC/Math/e_acos.c [new file with mode: 0644]
StdLib/LibC/Math/e_asin.c [new file with mode: 0644]
StdLib/LibC/Math/e_atan2.c [new file with mode: 0644]
StdLib/LibC/Math/e_cosh.c [new file with mode: 0644]
StdLib/LibC/Math/e_exp.c [new file with mode: 0644]
StdLib/LibC/Math/e_fmod.c [new file with mode: 0644]
StdLib/LibC/Math/e_log.c [new file with mode: 0644]
StdLib/LibC/Math/e_log10.c [new file with mode: 0644]
StdLib/LibC/Math/e_log2.c [new file with mode: 0644]
StdLib/LibC/Math/e_pow.c [new file with mode: 0644]
StdLib/LibC/Math/e_rem_pio2.c [new file with mode: 0644]
StdLib/LibC/Math/e_sinh.c [new file with mode: 0644]
StdLib/LibC/Math/e_sqrt.c [new file with mode: 0644]
StdLib/LibC/Math/k_cos.c [new file with mode: 0644]
StdLib/LibC/Math/k_rem_pio2.c [new file with mode: 0644]
StdLib/LibC/Math/k_sin.c [new file with mode: 0644]
StdLib/LibC/Math/k_tan.c [new file with mode: 0644]
StdLib/LibC/Math/math_private.h [new file with mode: 0644]
StdLib/LibC/Math/s_atan.c [new file with mode: 0644]
StdLib/LibC/Math/s_ceil.c [new file with mode: 0644]
StdLib/LibC/Math/s_copysign.c [new file with mode: 0644]
StdLib/LibC/Math/s_cos.c [new file with mode: 0644]
StdLib/LibC/Math/s_expm1.c [new file with mode: 0644]
StdLib/LibC/Math/s_fabs.c [new file with mode: 0644]
StdLib/LibC/Math/s_finite.c [new file with mode: 0644]
StdLib/LibC/Math/s_floor.c [new file with mode: 0644]
StdLib/LibC/Math/s_frexp.c [new file with mode: 0644]
StdLib/LibC/Math/s_infinity.c [new file with mode: 0644]
StdLib/LibC/Math/s_ldexp.c [new file with mode: 0644]
StdLib/LibC/Math/s_modf.c [new file with mode: 0644]
StdLib/LibC/Math/s_scalbn.c [new file with mode: 0644]
StdLib/LibC/Math/s_sin.c [new file with mode: 0644]
StdLib/LibC/Math/s_tan.c [new file with mode: 0644]
StdLib/LibC/Math/s_tanh.c [new file with mode: 0644]
StdLib/LibC/Math/w_acos.c [new file with mode: 0644]
StdLib/LibC/Math/w_asin.c [new file with mode: 0644]
StdLib/LibC/Math/w_atan2.c [new file with mode: 0644]
StdLib/LibC/Math/w_cosh.c [new file with mode: 0644]
StdLib/LibC/Math/w_exp.c [new file with mode: 0644]
StdLib/LibC/Math/w_fmod.c [new file with mode: 0644]
StdLib/LibC/Math/w_log.c [new file with mode: 0644]
StdLib/LibC/Math/w_log10.c [new file with mode: 0644]
StdLib/LibC/Math/w_log2.c [new file with mode: 0644]
StdLib/LibC/Math/w_pow.c [new file with mode: 0644]
StdLib/LibC/Math/w_sinh.c [new file with mode: 0644]
StdLib/LibC/Math/w_sqrt.c [new file with mode: 0644]
StdLib/LibC/NetUtil/NetUtil.inf [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_addr.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_lnaof.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_makeaddr.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_netof.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_network.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_ntoa.c [new file with mode: 0644]
StdLib/LibC/NetUtil/inet_ntop.c [new file with mode: 0644]
StdLib/LibC/Signal/Signal.c [new file with mode: 0644]
StdLib/LibC/Signal/Signal.inf [new file with mode: 0644]
StdLib/LibC/StdLib/Bsearch.c [new file with mode: 0644]
StdLib/LibC/StdLib/Environs.c [new file with mode: 0644]
StdLib/LibC/StdLib/Malloc.c [new file with mode: 0644]
StdLib/LibC/StdLib/NumericInt.c [new file with mode: 0644]
StdLib/LibC/StdLib/Qsort.c [new file with mode: 0644]
StdLib/LibC/StdLib/Rand.c [new file with mode: 0644]
StdLib/LibC/StdLib/StdLib.inf [new file with mode: 0644]
StdLib/LibC/StdLib/Xabs.c [new file with mode: 0644]
StdLib/LibC/StdLib/Xdiv.c [new file with mode: 0644]
StdLib/LibC/StdLib/strtoimax.c [new file with mode: 0644]
StdLib/LibC/StdLib/strtoumax.c [new file with mode: 0644]
StdLib/LibC/Stdio/Stdio.inf [new file with mode: 0644]
StdLib/LibC/Stdio/clrerr.c [new file with mode: 0644]
StdLib/LibC/Stdio/fclose.c [new file with mode: 0644]
StdLib/LibC/Stdio/fdopen.c [new file with mode: 0644]
StdLib/LibC/Stdio/feof.c [new file with mode: 0644]
StdLib/LibC/Stdio/ferror.c [new file with mode: 0644]
StdLib/LibC/Stdio/fflush.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetc.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetln.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetpos.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgets.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetstr.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetwc.c [new file with mode: 0644]
StdLib/LibC/Stdio/fgetws.c [new file with mode: 0644]
StdLib/LibC/Stdio/fileext.h [new file with mode: 0644]
StdLib/LibC/Stdio/fileno.c [new file with mode: 0644]
StdLib/LibC/Stdio/findfp.c [new file with mode: 0644]
StdLib/LibC/Stdio/flags.c [new file with mode: 0644]
StdLib/LibC/Stdio/floatio.h [new file with mode: 0644]
StdLib/LibC/Stdio/flockfile.c [new file with mode: 0644]
StdLib/LibC/Stdio/fopen.c [new file with mode: 0644]
StdLib/LibC/Stdio/fparseln.c [new file with mode: 0644]
StdLib/LibC/Stdio/fprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/fpurge.c [new file with mode: 0644]
StdLib/LibC/Stdio/fputc.c [new file with mode: 0644]
StdLib/LibC/Stdio/fputs.c [new file with mode: 0644]
StdLib/LibC/Stdio/fputwc.c [new file with mode: 0644]
StdLib/LibC/Stdio/fputws.c [new file with mode: 0644]
StdLib/LibC/Stdio/fread.c [new file with mode: 0644]
StdLib/LibC/Stdio/freopen.c [new file with mode: 0644]
StdLib/LibC/Stdio/fscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/fseek.c [new file with mode: 0644]
StdLib/LibC/Stdio/fseeko.c [new file with mode: 0644]
StdLib/LibC/Stdio/fsetpos.c [new file with mode: 0644]
StdLib/LibC/Stdio/ftell.c [new file with mode: 0644]
StdLib/LibC/Stdio/ftello.c [new file with mode: 0644]
StdLib/LibC/Stdio/funopen.c [new file with mode: 0644]
StdLib/LibC/Stdio/fvwrite.c [new file with mode: 0644]
StdLib/LibC/Stdio/fvwrite.h [new file with mode: 0644]
StdLib/LibC/Stdio/fwalk.c [new file with mode: 0644]
StdLib/LibC/Stdio/fwide.c [new file with mode: 0644]
StdLib/LibC/Stdio/fwprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/fwrite.c [new file with mode: 0644]
StdLib/LibC/Stdio/fwscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/getc.c [new file with mode: 0644]
StdLib/LibC/Stdio/getchar.c [new file with mode: 0644]
StdLib/LibC/Stdio/gets.c [new file with mode: 0644]
StdLib/LibC/Stdio/gettemp.c [new file with mode: 0644]
StdLib/LibC/Stdio/getwc.c [new file with mode: 0644]
StdLib/LibC/Stdio/getwchar.c [new file with mode: 0644]
StdLib/LibC/Stdio/glue.h [new file with mode: 0644]
StdLib/LibC/Stdio/local.h [new file with mode: 0644]
StdLib/LibC/Stdio/makebuf.c [new file with mode: 0644]
StdLib/LibC/Stdio/mkdtemp.c [new file with mode: 0644]
StdLib/LibC/Stdio/mkstemp.c [new file with mode: 0644]
StdLib/LibC/Stdio/mktemp.c [new file with mode: 0644]
StdLib/LibC/Stdio/perror.c [new file with mode: 0644]
StdLib/LibC/Stdio/printf.c [new file with mode: 0644]
StdLib/LibC/Stdio/putc.c [new file with mode: 0644]
StdLib/LibC/Stdio/putchar.c [new file with mode: 0644]
StdLib/LibC/Stdio/puts.c [new file with mode: 0644]
StdLib/LibC/Stdio/putwc.c [new file with mode: 0644]
StdLib/LibC/Stdio/putwchar.c [new file with mode: 0644]
StdLib/LibC/Stdio/refill.c [new file with mode: 0644]
StdLib/LibC/Stdio/remove.c [new file with mode: 0644]
StdLib/LibC/Stdio/rewind.c [new file with mode: 0644]
StdLib/LibC/Stdio/rget.c [new file with mode: 0644]
StdLib/LibC/Stdio/scanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/setbuf.c [new file with mode: 0644]
StdLib/LibC/Stdio/setbuffer.c [new file with mode: 0644]
StdLib/LibC/Stdio/setvbuf.c [new file with mode: 0644]
StdLib/LibC/Stdio/snprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/snprintf_ss.c [new file with mode: 0644]
StdLib/LibC/Stdio/sprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/sscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/stdio.c [new file with mode: 0644]
StdLib/LibC/Stdio/swprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/swscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/tempnam.c [new file with mode: 0644]
StdLib/LibC/Stdio/tmpfile.c [new file with mode: 0644]
StdLib/LibC/Stdio/tmpnam.c [new file with mode: 0644]
StdLib/LibC/Stdio/ungetc.c [new file with mode: 0644]
StdLib/LibC/Stdio/ungetwc.c [new file with mode: 0644]
StdLib/LibC/Stdio/vasprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vfprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vfscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vfwprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vfwscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vsnprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vsnprintf_ss.c [new file with mode: 0644]
StdLib/LibC/Stdio/vsprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vsscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vswprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vswscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vwprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/vwscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/wbuf.c [new file with mode: 0644]
StdLib/LibC/Stdio/wcio.h [new file with mode: 0644]
StdLib/LibC/Stdio/wprintf.c [new file with mode: 0644]
StdLib/LibC/Stdio/wscanf.c [new file with mode: 0644]
StdLib/LibC/Stdio/wsetup.c [new file with mode: 0644]
StdLib/LibC/String/Comparison.c [new file with mode: 0644]
StdLib/LibC/String/Concatenation.c [new file with mode: 0644]
StdLib/LibC/String/Copying.c [new file with mode: 0644]
StdLib/LibC/String/ErrorList.c [new file with mode: 0644]
StdLib/LibC/String/Misc.c [new file with mode: 0644]
StdLib/LibC/String/Searching.c [new file with mode: 0644]
StdLib/LibC/String/String.inf [new file with mode: 0644]
StdLib/LibC/Time/Theory.txt [new file with mode: 0644]
StdLib/LibC/Time/Time.c [new file with mode: 0644]
StdLib/LibC/Time/Time.inf [new file with mode: 0644]
StdLib/LibC/Time/TimeEfi.c [new file with mode: 0644]
StdLib/LibC/Time/TimeVals.h [new file with mode: 0644]
StdLib/LibC/Time/ZoneProc.c [new file with mode: 0644]
StdLib/LibC/Time/strftime.c [new file with mode: 0644]
StdLib/LibC/Time/tzfile.h [new file with mode: 0644]
StdLib/LibC/Uefi/Console.c [new file with mode: 0644]
StdLib/LibC/Uefi/SysCalls.c [new file with mode: 0644]
StdLib/LibC/Uefi/SysEfi.h [new file with mode: 0644]
StdLib/LibC/Uefi/Uefi.inf [new file with mode: 0644]
StdLib/LibC/Uefi/Xform.c [new file with mode: 0644]
StdLib/LibC/Wchar/Comparison.c [new file with mode: 0644]
StdLib/LibC/Wchar/Concatenation.c [new file with mode: 0644]
StdLib/LibC/Wchar/ConsDecons.c [new file with mode: 0644]
StdLib/LibC/Wchar/Copying.c [new file with mode: 0644]
StdLib/LibC/Wchar/Searching.c [new file with mode: 0644]
StdLib/LibC/Wchar/String.c [new file with mode: 0644]
StdLib/LibC/Wchar/Wchar.inf [new file with mode: 0644]
StdLib/LibC/gdtoa/Ipf/strtold.c [new file with mode: 0644]
StdLib/LibC/gdtoa/_strtof.c [new file with mode: 0644]
StdLib/LibC/gdtoa/_strtold.c [new file with mode: 0644]
StdLib/LibC/gdtoa/atof.c [new file with mode: 0644]
StdLib/LibC/gdtoa/dmisc.c [new file with mode: 0644]
StdLib/LibC/gdtoa/dtoa.c [new file with mode: 0644]
StdLib/LibC/gdtoa/gdtoa.c [new file with mode: 0644]
StdLib/LibC/gdtoa/gdtoa.h [new file with mode: 0644]
StdLib/LibC/gdtoa/gdtoa.inf [new file with mode: 0644]
StdLib/LibC/gdtoa/gdtoaimp.h [new file with mode: 0644]
StdLib/LibC/gdtoa/gethex.c [new file with mode: 0644]
StdLib/LibC/gdtoa/gmisc.c [new file with mode: 0644]
StdLib/LibC/gdtoa/hd_init.c [new file with mode: 0644]
StdLib/LibC/gdtoa/hexnan.c [new file with mode: 0644]
StdLib/LibC/gdtoa/ldtoa.c [new file with mode: 0644]
StdLib/LibC/gdtoa/misc.c [new file with mode: 0644]
StdLib/LibC/gdtoa/smisc.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtod.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtodg.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtof.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtold_px.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtold_subr.c [new file with mode: 0644]
StdLib/LibC/gdtoa/strtopx.c [new file with mode: 0644]
StdLib/LibC/gdtoa/sum.c [new file with mode: 0644]
StdLib/LibC/gdtoa/ulp.c [new file with mode: 0644]
StdLib/ReadMe.pdf [new file with mode: 0644]
StdLib/StdLib.dec [new file with mode: 0644]
StdLib/StdLib.dsc [new file with mode: 0644]
StdLibPrivateInternalFiles/DoNotUse.dec [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Arm/arith.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Arm/gd_qnan.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Efi/Console.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Ia32/arith.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Ia32/gd_qnan.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Ipf/arith.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/Ipf/gd_qnan.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/LibConfig.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/MainData.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/X64/arith.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/X64/gd_qnan.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/extern.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/namespace.h [new file with mode: 0644]
StdLibPrivateInternalFiles/Include/reentrant.h [new file with mode: 0644]
StdLibPrivateInternalFiles/ReadMe.pdf [new file with mode: 0644]

diff --git a/AppPkg/AppPkg.dsc b/AppPkg/AppPkg.dsc
new file mode 100644 (file)
index 0000000..ffa4b0f
--- /dev/null
@@ -0,0 +1,157 @@
+## @file\r
+#   Intel(r) UEFI Application Development Kit for EDK II.\r
+#   This package contains applications which depend upon Standard Libraries\r
+#   from the StdLib package.\r
+#\r
+#   See the comments in the [LibraryClasses.IA32] and [BuildOptions] sections\r
+#   for important information about configuring this package for your\r
+#   environment.\r
+#\r
+#   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+#   This program and the accompanying materials\r
+#   are licensed and made available under the terms and conditions of the BSD License\r
+#   which accompanies this distribution. The full text of the license may be found at\r
+#   http://opensource.org/licenses/bsd-license.\r
+#\r
+#   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+##\r
+\r
+[Defines]\r
+  PLATFORM_NAME                  = AppPkg\r
+  PLATFORM_GUID                  = 0458dade-8b6e-4e45-b773-1b27cbda3e06\r
+  PLATFORM_VERSION               = 0.01\r
+  DSC_SPECIFICATION              = 0x00010006\r
+  OUTPUT_DIRECTORY               = Build/AppPkg\r
+  SUPPORTED_ARCHITECTURES        = IA32|IPF|X64\r
+  BUILD_TARGETS                  = DEBUG|RELEASE\r
+  SKUID_IDENTIFIER               = DEFAULT\r
+\r
+[PcdsFeatureFlag]\r
+\r
+[PcdsFixedAtBuild]\r
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x0f\r
+  gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0x80000000\r
+\r
+[PcdsFixedAtBuild.IPF]\r
+\r
+[LibraryClasses]\r
+  #\r
+  # Entry Point Libraries\r
+  #\r
+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf\r
+  ShellCEntryLib|ShellPkg/Library/UefiShellCEntryLib/UefiShellCEntryLib.inf\r
+  #\r
+  # Common Libraries\r
+  #\r
+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf\r
+  BaseMemoryLib|MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf\r
+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf\r
+  PrintLib|MdePkg/Library/BasePrintLib/BasePrintLib.inf\r
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf\r
+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf\r
+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf\r
+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf\r
+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf\r
+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf\r
+  PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf\r
+  IoLib|MdePkg/Library/BaseIoLibIntrinsic/BaseIoLibIntrinsic.inf\r
+  PciLib|MdePkg/Library/BasePciLibCf8/BasePciLibCf8.inf\r
+  PciCf8Lib|MdePkg/Library/BasePciCf8Lib/BasePciCf8Lib.inf\r
+  SynchronizationLib|MdePkg/Library/BaseSynchronizationLib/BaseSynchronizationLib.inf\r
+  UefiRuntimeLib|MdePkg/Library/UefiRuntimeLib/UefiRuntimeLib.inf\r
+  HiiLib|MdeModulePkg/Library/UefiHiiLib/UefiHiiLib.inf\r
+  UefiHiiServicesLib|MdeModulePkg/Library/UefiHiiServicesLib/UefiHiiServicesLib.inf\r
+  PerformanceLib|MdeModulePkg/Library/DxePerformanceLib/DxePerformanceLib.inf\r
+  HobLib|MdePkg/Library/DxeHobLib/DxeHobLib.inf\r
+  ShellLib|ShellPkg/Library/UefiShellLib/UefiShellLib.inf\r
+  FileHandleLib|ShellPkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf\r
+  SortLib|ShellPkg/Library/UefiSortLib/UefiSortLib.inf\r
+\r
+  #\r
+  # C Standard Libraries\r
+  #\r
+  LibC|StdLib/LibC/LibC.inf\r
+  LibStdLib|StdLib/LibC/StdLib/StdLib.inf\r
+  LibString|StdLib/LibC/String/String.inf\r
+  LibWchar|StdLib/LibC/Wchar/Wchar.inf\r
+  LibCType|StdLib/LibC/Ctype/Ctype.inf\r
+  LibTime|StdLib/LibC/Time/Time.inf\r
+  LibStdio|StdLib/LibC/Stdio/Stdio.inf\r
+  LibGdtoa|StdLib/LibC/gdtoa/gdtoa.inf\r
+  LibLocale|StdLib/LibC/Locale/Locale.inf\r
+  LibUefi|StdLib/LibC/Uefi/Uefi.inf\r
+  LibMath|StdLib/LibC/Math/Math.inf\r
+  LibSignal|StdLib/LibC/Signal/Signal.inf\r
+  LibNetUtil|StdLib/LibC/NetUtil/NetUtil.inf\r
+\r
+[LibraryClasses.IA32]\r
+  TimerLib|PerformancePkg/Library/DxeTscTimerLib/DxeTscTimerLib.inf\r
+  ## Comment out the above line and un-comment the line below for running under Nt32 emulation.\r
+#  TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf\r
+\r
+[LibraryClasses.X64]\r
+  TimerLib|PerformancePkg/Library/DxeTscTimerLib/DxeTscTimerLib.inf\r
+\r
+[LibraryClasses.IPF]\r
+  PalLib|MdePkg/Library/UefiPalLib/UefiPalLib.inf\r
+  TimerLib|MdePkg/Library/SecPeiDxeTimerLibCpu/SecPeiDxeTimerLibCpu.inf\r
+\r
+###################################################################################################\r
+#\r
+# Components Section - list of the modules and components that will be processed by compilation\r
+#                      tools and the EDK II tools to generate PE32/PE32+/Coff image files.\r
+#\r
+# Note: The EDK II DSC file is not used to specify how compiled binary images get placed\r
+#       into firmware volume images. This section is just a list of modules to compile from\r
+#       source into UEFI-compliant binaries.\r
+#       It is the FDF file that contains information on combining binary files into firmware\r
+#       volume images, whose concept is beyond UEFI and is described in PI specification.\r
+#       Binary modules do not need to be listed in this section, as they should be\r
+#       specified in the FDF file. For example: Shell binary (Shell_Full.efi), FAT binary (Fat.efi),\r
+#       Logo (Logo.bmp), and etc.\r
+#       There may also be modules listed in this section that are not required in the FDF file,\r
+#       When a module listed here is excluded from FDF file, then UEFI-compliant binary will be\r
+#       generated for it, but the binary will not be put into any firmware volume.\r
+#\r
+###################################################################################################\r
+\r
+[Components]\r
+# BaseLib and BaseMemoryLib need to be built with the /GL- switch when using the Microsoft\r
+# tool chain.  This is required so that the library functions can be resolved during\r
+# the second pass of the linker during Link-time-code-generation.\r
+###\r
+  MdePkg/Library/BaseLib/BaseLib.inf {\r
+    <BuildOptions>\r
+      MSFT:*_*_*_CC_FLAGS    = /X /Zc:wchar_t /GL-\r
+  }\r
+\r
+  MdePkg/Library/BaseMemoryLib/BaseMemoryLib.inf {\r
+    <BuildOptions>\r
+      MSFT:*_*_*_CC_FLAGS    = /X /Zc:wchar_t /GL-\r
+  }\r
+\r
+#### Sample Applications.\r
+  AppPkg/Applications/Hello/Hello.inf        # No LibC includes or functions.\r
+  AppPkg/Applications/Main/Main.inf          # Simple invocation. No other LibC functions.\r
+  AppPkg/Applications/Enquire/Enquire.inf\r
+\r
+################################################################\r
+#\r
+# See the additional comments below if you plan to run applications under the\r
+# Nt32 emulation environment.\r
+#\r
+\r
+[BuildOptions]\r
+  INTEL:*_*_*_CC_FLAGS      = /Qfreestanding\r
+   MSFT:*_*_*_CC_FLAGS      = /X /Zc:wchar_t\r
+    GCC:*_*_*_CC_FLAGS      = -ffreestanding -nostdinc -nostdlib\r
+\r
+# The Build Options, below, are only used when building the C library\r
+# to be run under the NT32 emulation.  They disable the clock() system call\r
+# which is currently incompatible with the NT32 environment.\r
+# Just uncomment the lines below and select the correct TimerLib instance, above.\r
+\r
+  # INTEL:*_*_IA32_CC_FLAGS     = /D NT32dvm\r
+  #  MSFT:*_*_IA32_CC_FLAGS     = /D NT32dvm\r
+  #   GCC:*_*_IA32_CC_FLAGS     = -DNT32dvm\r
diff --git a/AppPkg/Applications/Enquire/Enquire.c b/AppPkg/Applications/Enquire/Enquire.c
new file mode 100644 (file)
index 0000000..1e1db69
--- /dev/null
@@ -0,0 +1,3377 @@
+/** @file\r
+    Every thing you wanted to know about your compiler but didn't know whom to ask.\r
+\r
+    COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.\r
+    Steven Pemberton, CWI, Amsterdam; "Steven.Pemberton@cwi.nl"\r
+    Used with permission.\r
+\r
+    Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+    This program and the accompanying materials\r
+    are licensed and made available under the terms and conditions of the BSD License\r
+    which accompanies this distribution. The full text of the license may be found at\r
+    http://opensource.org/licenses/bsd-license.\r
+\r
+    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+**/\r
+#if defined(_MSC_VER)           /* Handle Microsoft VC++ compiler specifics. */\r
+  #pragma warning ( disable : 4018 )\r
+  #pragma warning ( disable : 4055 )\r
+  #pragma warning ( disable : 4116 )\r
+  #pragma warning ( disable : 4130 )\r
+  #pragma warning ( disable : 4189 )\r
+  #pragma warning ( disable : 4244 )\r
+  #pragma warning ( disable : 4723 )\r
+#endif  /* defined(_MSC_VER) */\r
+\r
+//#define NO_SC   1   // Compiler doesn't support signed char\r
+//#define NO_UC   1   // Compiler doesn't support unsigned char\r
+//#define NO_UI   1   // Compiler doesn't support unsigned short and long\r
+//#define NO_VOID 1   // Compiler doesn't support void\r
+//#define NO_SIG  1   // Compiler doesn't support signal() or setjmp/longjmp()\r
+\r
+/*  Some compilers can't cope with "#ifdef __FILE__". Use\r
+    either the FILENAME or BAD_CPP macro as described below.\r
+*/\r
+/*  If your C preprocessor doesn't have the predefined __FILE__\r
+macro, and you don't want to call this file enquire.c but, say,\r
+tell.c, uncomment the following and change enquire.c to tell.c.\r
+*/\r
+//#define FILENAME "enquire.c"\r
+\r
+/*  Some compilers won't accept the line "#include FILENAME".  Uncomment\r
+    the following macro. In that case, this file *must* be called enquire.c.\r
+*/\r
+//#define BAD_CPP     1\r
+\r
+/*  Some naughty compilers define __STDC__, but don't really\r
+    support it.  Some define it as 0, in which case we ignore it.\r
+    But if your compiler defines it, and isn't really ANSI C,\r
+    uncomment the BAD_STDC macro. (To those compiler writers: for shame).\r
+*/\r
+//#define BAD_STDC    1\r
+\r
+/*  Some naughty compilers define __STDC__, but don't have the\r
+    stddef.h include file. Uncomment the BAD_STDDEF macro. (Gcc needs this on\r
+    some machines, due to clashes between stddef.h and other include files.)\r
+*/\r
+//#define BAD_STDDEF  1\r
+\r
+/*  Some systems crash when you try to malloc all store. To save users of such\r
+    defective systems too much grief, they may uncomment the BAD_MALLOC macro,\r
+    which ignores that bit of the code.\r
+*/\r
+//#define BAD_MALLOC  1\r
+\r
+\r
+\r
+#ifndef PROGRAM\r
+#define PROGRAM enquire.c\r
+#define VERSION "5.1a"\r
+#define PURPOSE Everything you wanted to know about your machine and C compiler\r
+#define BUT didnt know who to ask\r
+#define FOR Any OS, any C compiler\r
+#define AUTHOR  Steven Pemberton, CWI, Amsterdam; "Steven.Pemberton@cwi.nl"\r
+#define COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.\r
+#define NOTE  Improvements gratefully received. Please mention the version.\r
+#define COMPILE On Unix compile with: "sh enquire.c"; see below for details\r
+#define WEB "http://www.cwi.nl/~steven/enquire.html"\r
+#endif\r
+\r
+#ifdef NOTDEFINED /* This is how you compile it; see below for details */\r
+  case $0 in\r
+  *.c) ;;\r
+  sh) echo 'Use "sh enquire.c", not "sh < enquire.c"' >&2; exit 1;;\r
+  *) echo 'Filename must end in ".c"' >&2; exit 1;;\r
+  esac\r
+  if test -r test.c\r
+  then echo Would overwrite test.c - try it somewhere safer >&2; exit 1\r
+  fi\r
+  CFLAGS=\r
+  echo Testing for needed CFLAGS ...\r
+  echo "main(){char c; c=0;}" > test.c\r
+  if ${CC=cc} ${1+"$@"} -o enquire test.c $LIBS\r
+  then :\r
+  else\r
+      echo '*** "'$CC ${1+"$@"} -o enquire test.c $LIBS'" failed'\r
+      echo '*** Giving up'\r
+      /bin/rm -f test.c\r
+      exit 1\r
+  fi\r
+  echo "main(){signed char c; c=0;}" > test.c\r
+  if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null\r
+  then echo "   Signed char ok"\r
+  else\r
+    CFLAGS=-DNO_SC\r
+    echo "   Signed char not accepted; using $CFLAGS"\r
+  fi\r
+  echo "main(){unsigned char c; c=0;}" > test.c\r
+  if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null\r
+  then echo "   Unsigned char ok"\r
+  else\r
+    CFLAGS="$CFLAGS -DNO_UC"\r
+    echo "   Unsigned char not accepted; using $CFLAGS"\r
+  fi\r
+  echo "main(){unsigned short s;unsigned long l;s=0;l=0;}" > test.c\r
+  if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null\r
+  then echo "   Unsigned short and long ok"\r
+  else\r
+    CFLAGS="$CFLAGS -DNO_UI"\r
+    echo "   Unsigned short or long not accepted; using $CFLAGS"\r
+  fi\r
+  echo "void foo(){} main(){foo();}" > test.c\r
+  if $CC ${1+"$@"} -o enquire test.c $LIBS 2>/dev/null\r
+  then echo "   Void ok"\r
+  else\r
+    CFLAGS="$CFLAGS -DNO_VOID"\r
+    echo "   Void not accepted; using $CFLAGS"\r
+  fi\r
+  /bin/rm -f test.c a.out\r
+\r
+  echo Compiling $0 ...\r
+  case $# in\r
+  0) : check bug in interpreting "$@" in some shells, if no parameters\r
+     case `echo 1 "$@" 2` in\r
+     "1  2") echo '   *** There is a bug in your shell expanding "$@"!'\r
+       echo '   *** Taking remedial action' ;;\r
+     "1 2") ;;\r
+     esac\r
+  esac\r
+  case $ID in\r
+  "") echo "   $CC" $CFLAGS "$@" $0 -o enquire $LIBS\r
+      $CC $CFLAGS ${1+"$@"} $0 -o enquire $LIBS ||\r
+    { echo '***' Try setting some CFLAGS; exit 1; }\r
+      ;;\r
+  *)  echo "   $CC" $CFLAGS "$@" -DID="\"$ID\"" $0 -o enquire $LIBS\r
+      $CC $CFLAGS ${1+"$@"} -DID="\"$ID\"" $0 -o enquire $LIBS ||\r
+    { echo '***' Try setting some CFLAGS; exit 1; }\r
+  esac\r
+  echo "Producing enquire.out limits.h and float.h ..."\r
+  echo "   enquire > enquire.out"\r
+  ./enquire > enquire.out || echo '   *** Some problems: see enquire.out'\r
+  echo "   enquire -l > limits.h"\r
+  ./enquire -l > limits.h || echo '   *** Some problems: see limits.h'\r
+  echo "   enquire -f > float.h"\r
+  ./enquire -f > float.h  || echo '   *** Some problems: see float.h'\r
+  echo "Verifying the contents of limits.h and float.h ..."\r
+  echo "   $CC" -DVERIFY $CFLAGS "$@" $0 -o verify $LIBS\r
+  $CC -DVERIFY $CFLAGS ${@+"$@"} $0 -o verify $LIBS ||\r
+    { echo '***' Failed; exit 1; }\r
+  echo "   verify -fl > verify.out"\r
+  ./verify -fl > verify.out ||\r
+    echo '   *** Some problems: see verify.out'\r
+  echo Done\r
+  exit 0\r
+#endif\r
+\r
+/*\r
+ PURPOSE\r
+    This is a program that determines many properties of the C\r
+    compiler and machine that it is run on, such as minimum and\r
+    maximum [un]signed char/int/long, many properties of float/ [long]\r
+    double, and so on.\r
+\r
+    As an option it produces the ANSI C float.h and limits.h files.\r
+\r
+    As a further option, it even checks that the compiler reads the\r
+    header files correctly.\r
+\r
+    It is a good test-case for compilers, since it exercises them with\r
+    many limiting values, such as the minimum and maximum floating-point\r
+    numbers.\r
+\r
+ COMPILING AND RUNNING ON UNIX MACHINES\r
+    With luck and a following wind, on Unix systems just the following\r
+    will work:\r
+  sh enquire.c    (or whatever filename you chose).\r
+    Any parameters are passed to the C compiler, so if the compilation\r
+    fails for any reason curable as explained below, you can do the following:\r
+  sh enquire.c -DBAD_CPP\r
+\r
+    If you do get compilation errors, check the line in question.\r
+    Very often there is a comment attached saying which define to set.\r
+\r
+    You can use a different C compiler than the default cc by setting CC:\r
+  CC=gcc sh enquire.c -ansi\r
+    You can load extra libraries by setting LIBS:\r
+  CC=gcc LIBS=-lflong sh enquire.c -ansi\r
+    Add ID="string" for the string to be added to the output; for instance:\r
+  ID="`hostname` cc -ansi" sh enquire.c -ansi\r
+\r
+    Compiling may give messages about unreachable code. These you can ignore.\r
+\r
+    Some compilers offer various flags for different floating point\r
+    modes; it's worth trying all possible combinations of these.\r
+\r
+    Don't say I haven't tried to make life easy for you...\r
+\r
+ COMPILING AND RUNNING ON NON-UNIX SYSTEMS\r
+    On non-Unix systems, you must say (the equivalent of):\r
+  cc enquire.c -o enquire\r
+  enquire > enquire.out\r
+  enquire -l > limits.h\r
+  enquire -f > float.h\r
+  cc -DVERIFY enquire.c -o verify #this includes limits.h and float.h\r
+  verify -fl > verify.out\r
+\r
+    If your compiler doesn't support:   add flag:\r
+  signed char (eg pcc)      -DNO_SC\r
+  unsigned char       -DNO_UC\r
+  unsigned short and long     -DNO_UI\r
+  void          -DNO_VOID\r
+  signal(), or setjmp/longjmp()   -DNO_SIG\r
+\r
+    Try to compile first with no flags, and see if you get any errors\r
+    - you might be surprised. (Most non-ANSI compilers need -DNO_SC,\r
+    though.)  Some compilers need a -f flag for floating point.\r
+\r
+    Don't use any optimisation flags: the program may not work if you\r
+    do.  Though "while (a+1.0-a-1.0 == 0.0)" may look like "while(1)"\r
+    to an optimiser, to a floating-point unit there's a world of difference.\r
+\r
+    Compiling may give messages about unreachable code. These you can ignore.\r
+\r
+    Some compilers offer various flags for different floating point\r
+    modes; it's worth trying all possible combinations of these.\r
+\r
+ FAULTY COMPILERS\r
+    Because of bugs and/or inadequacies, some compilers need the following\r
+    defines:\r
+\r
+    -  If your C preprocessor doesn't have the predefined __FILE__\r
+       macro, and you don't want to call this file enquire.c but, say,\r
+       tell.c, add the flag -DFILENAME=\"tell.c\" .\r
+\r
+    -  Some compilers won't accept the line "#include FILENAME".  Add\r
+       flag -DBAD_CPP. In that case, this file *must* be called\r
+       enquire.c.\r
+\r
+    -  Some compilers can't cope with "#ifdef __FILE__". Use\r
+       -DFILENAME= or -DBAD_CPP as above.\r
+\r
+    -  Some naughty compilers define __STDC__, but don't really\r
+       support it.  Some define it as 0, in which case we ignore it.\r
+       But if your compiler defines it, and isn't really ANSI C, add\r
+       flag -DBAD_STDC. (To those compiler writers: for shame).\r
+\r
+    -  Some naughty compilers define __STDC__, but don't have the\r
+       stddef.h include file. Add flag -DBAD_STDDEF. (Gcc needs this\r
+       on some machines, due to clashes between stddef.h and other\r
+       include files.)\r
+\r
+    -  Some systems crash when you try to malloc all store. To save\r
+       users of such defective systems too much grief, they may\r
+       compile with -DBAD_MALLOC, which ignores that bit of the code.\r
+\r
+    Summary of naughty-compiler flags:\r
+    If your compiler doesn't support:    add flag:\r
+  __FILE__ (and you changed the filename) -DFILENAME=\"name.c\"\r
+  #ifdef __FILE__       -DBAD_CPP or -DFILENAME=...\r
+  #include FILENAME     -DBAD_CPP\r
+  __STDC__ (properly)     -DBAD_STDC\r
+  stddef.h        -DBAD_STDDEF\r
+  malloc(LOTS) == NULL      -DBAD_MALLOC\r
+\r
+    While it is not our policy to support defective compilers, pity has been\r
+    taken on people with compilers that can't produce object files bigger than\r
+    32k (especially since it was an easy addition). Compile the program\r
+    into separate parts like this:\r
+  cc -c -DSEP -DPASS0 -o p0.o <other flags> enquire.c\r
+  cc -c -DSEP -DPASS1 -o p1.o <other flags> enquire.c\r
+  cc -c -DSEP -DPASS2 -o p2.o <other flags> enquire.c\r
+  cc -c -DSEP -DPASS3 -o p3.o <other flags> enquire.c\r
+  cc -o enquire p0.o p1.o p2.o p3.o\r
+\r
+ SYSTEM DEPENDENCIES\r
+    You may possibly need to add some calls to signal() for other sorts of\r
+    exception on your machine than SIGFPE, SIGOVER, SIGBUS, and SIGSEGV.\r
+    See lines beginning #ifdef SIGxxx (and communicate the differences to me!).\r
+\r
+ OUTPUT\r
+    Running without argument gives the information as English text. If run\r
+    with argument -l (e.g. enquire -l), output is a series of #define's for\r
+    the ANSI standard limits.h include file, excluding MB_MAX_CHAR. If run\r
+    with argument -f, output is a series of #define's for the ANSI standard\r
+    float.h include file (according to ANSI C Draft of Dec 7, 1988).\r
+    Flag -v gives verbose output: output includes the English text above\r
+    as C comments. The program exit(0)'s if everything went ok, otherwise\r
+    it exits with a positive number, telling how many problems there were.\r
+\r
+ VERIFYING THE COMPILER\r
+    If, having produced the float.h and limits.h header files, you want to\r
+    verify that the compiler reads them back correctly (there are a lot of\r
+    boundary cases, of course, like minimum and maximum numbers), you can\r
+    recompile enquire.c with -DVERIFY set (plus the other flags that you used\r
+    when compiling the version that produced the header files). This then\r
+    recompiles the program so that it #includes "limits.h" and "float.h",\r
+    and checks that the constants it finds there are the same as the\r
+    constants it produces. Run the resulting program with enquire -fl.\r
+    Many compilers fail this test.\r
+    NB: You *must* recompile with the same compiler and flags, otherwise\r
+    you may get odd results.\r
+\r
+    You can also use this option if your compiler already has both files,\r
+    and you want to confirm that this program produces the right results.\r
+\r
+ TROUBLESHOOTING.\r
+    This program is now quite trustworthy, and suspicious and wrong output\r
+    may well be caused by bugs in the compiler, not in the program (however\r
+    of course, this is not guaranteed, and no responsibility can be\r
+    accepted, etc.)\r
+\r
+    The program only works if overflows are ignored by the C system or\r
+    are catchable with signal().\r
+\r
+    If the program fails to run to completion (often with the error message\r
+    "Unexpected signal at point x"), this often turns out to be a bug in the\r
+    C compiler's run-time system. Check what was about to be printed, and\r
+    try to narrow the problem down.\r
+\r
+    Another possible problem is that you have compiled the program to produce\r
+    loss-of-precision arithmetic traps. The program cannot cope with these,\r
+    and you should re-compile without them. (They should never be the default).\r
+\r
+    Make sure you compiled with optimisation turned off.\r
+\r
+    Output preceded by *** WARNING: identifies behaviour of the C system\r
+    deemed incorrect by the program. Likely problems are that printf or\r
+    scanf don't cope properly with certain boundary numbers: this program\r
+    goes to a lot of trouble to calculate its values, and these values\r
+    are mostly boundary numbers. Experience has shown that often printf\r
+    cannot cope with these values, and so in an attempt to increase\r
+    confidence in the output, for each float and double that is printed,\r
+    the printed value is checked by using sscanf to read it back.\r
+   Care is taken that numbers are printed with enough digits to uniquely\r
+    identify them, and therefore that they can be read back identically.\r
+    If the number read back is different, then there is probably a bug in\r
+    printf or sscanf, and the program prints the warning message.\r
+    If the two numbers in the warning look identical, then printf is more\r
+    than likely rounding the last digit(s) incorrectly. To put you at ease\r
+    that the two really are different, the bit patterns of the two numbers\r
+    are also printed. The difference is very likely in the last bit.\r
+   Many scanf's read the minimum double back as 0.0, and similarly cause\r
+    overflow when reading the maximum double. This program quite ruthlessly\r
+    declares all these behaviours faulty. The point is that if you get\r
+    one of these warnings, the output may be wrong, so you should check\r
+    the result carefully if you intend to use the results. Of course, printf\r
+    and sscanf may both be wrong, and cancel each other out, so you should\r
+    check the output carefully anyway.\r
+\r
+    The warning that "a cast didn't work" refers to cases like this:\r
+\r
+  float f;\r
+  #define C 1.234567890123456789\r
+  f= C;\r
+  if (f != (float) C) printf ("Wrong!");\r
+\r
+    A faulty compiler will widen f to double and ignore the cast to float,\r
+    and because there is more accuracy in a double than a float, fail to\r
+    recognise that they are the same. In the actual case in point, f and C\r
+    are passed as parameters to a function that discovers they are not equal,\r
+    so it's just possible that the error was in the parameter passing,\r
+    not in the cast (see function Verify()).\r
+    For ANSI C, which has float constants, the error message is "constant has\r
+    wrong precision".\r
+\r
+ REPORTING PROBLEMS\r
+    If the program doesn't work for you for any reason that can't be\r
+    narrowed down to a problem in the C compiler, or it has to be\r
+    changed in order to get it to compile, or it produces suspicious\r
+    output (like a very low maximum float, for instance), please mail\r
+    the problem and an example of the incorrect output to\r
+    Steven.Pemberton@cwi.nl so that improvements can be worked into\r
+    future versions. Try to give as much information as possible;\r
+    DON'T FORGET TO MENTION THE VERSION NUMBER!\r
+\r
+    The program tries to catch and diagnose bugs in the compiler/run-time\r
+    system. I would be especially pleased to have reports of failures so\r
+    that I can improve this service.\r
+\r
+    I apologise unreservedly for the contorted use of the preprocessor...\r
+    but it was fun!\r
+\r
+ NEW VERSIONS\r
+    Worried that you may not have the latest version? Ftp to\r
+    ftp.cwi.nl, and look in directory pub/steven/enquire\r
+    for file enquireXX.c; XX is the version number. Or look at\r
+    http://www.cwi.nl/~steven/enquire.html\r
+\r
+ HOW DOES ENQUIRE WORK?\r
+    There is an article that explains a lot of the workings: The\r
+    Ergonomics of Portability; available from the above addresses as file\r
+    enquire.ps.\r
+\r
+ THE SMALL PRINT\r
+    This is not a public domain program; nor is any other program that\r
+    carries a copyright notice. It is however freely copyable under the\r
+    following conditions:\r
+\r
+       You may copy and distribute verbatim copies of this source file.\r
+       You may modify this source file, and copy and distribute such\r
+       modified versions, provided that you leave the copyright notice\r
+       at the top of the file and also cause the modified file to carry\r
+       prominent notices stating that you changed the files and the\r
+       date of any change; and cause the whole of any work that you\r
+       distribute or publish, that in whole or in part contains or is a\r
+       derivative of this program or any part thereof, to be licensed\r
+       at no charge to all third parties on terms identical to those\r
+       here.\r
+\r
+    While every effort has been taken to make this program as reliable as\r
+    possible, no responsibility can be taken for the correctness of the\r
+    output, nor suitability for any particular use.\r
+\r
+    If you do have a fix to any problem, please send it to me, so that\r
+    other people can have the benefits.\r
+\r
+    This program is an offshoot of a project funded by public funds.\r
+    If you use this program for research or commercial use (i.e. more\r
+    than just for the fun of knowing about your compiler) mailing a short\r
+    note of acknowledgement may help keep enquire.c supported.\r
+\r
+ ACKNOWLEDGEMENTS\r
+    Many people have given time and ideas to making this program what it is.\r
+    To all of them thanks, and apologies for not mentioning them by name.\r
+\r
+ HISTORY\r
+    Originally started as a program to generate configuration constants\r
+    for a large piece of software we were writing, which later took on\r
+    a life of its own...\r
+    1.0 Length 6658!; end 1984?\r
+  Unix only. Only printed a dozen maximum int/double values.\r
+    2.0 Length 10535; Spring 1985\r
+  Prints values as #defines (about 20 of them)\r
+  More extensive floating point, using Cody and Waite\r
+  Handles signals better\r
+  Programs around optimisations\r
+  Handles Cybers\r
+    3.0 Length 12648; Aug 1987; prints about 42 values\r
+  Added PASS stuff, so treats float as well as double\r
+    4.0 Length 33891; Feb 1989; prints around 85 values\r
+  First GNU version (for gcc, where they called it hard-params.c)\r
+  Generates float.h and limits.h files\r
+  Handles long double\r
+  Generates warnings for dubious output\r
+    4.1 Length 47738; April 1989\r
+  Added VERIFY and TEST\r
+    4.2 Length 63442; Feb 1990\r
+  Added SEP\r
+  Fixed eps/epsneg\r
+  Added check for pseudo-unsigned chars\r
+  Added description for each #define output\r
+  Added check for absence of defines during verify\r
+  Added prototypes\r
+  Added BAD_STDC and BAD_CPP\r
+  Fixed alignments output\r
+    4.3 Length 75000; Oct 1990; around 114 lines of output\r
+  Function xmalloc defined, Richard Stallman, June 89.\r
+  Alignments computed from member offsets rather than structure sizes,\r
+      Richard Stallman, Oct 89\r
+  Print whether char* and int* pointers have the same format;\r
+      also char * and function *\r
+  Update to Draft C version Dec 7, 1988\r
+      - types of constants produced in limits.h\r
+    (whether to put a U after unsigned shorts and chars and\r
+     whether to output -1024 as (-1023-1))\r
+      - values of SCHAR_MIN/MAX\r
+      - values of *_EPSILON (not the smallest but the effective smallest)\r
+  Added FILENAME, since ANSI C doesn't allow #define __FILE__\r
+  Renamed from config.c to enquire.c\r
+  Added size_t and ptrdiff_t enquiries\r
+  Added promotion enquiries\r
+  Added type checks of #defines\r
+  Added BAD_STDDEF\r
+  Changed endian to allow for cases where not all bits are used\r
+  Sanity check for max integrals\r
+  Fixed definition of setjmp for -DNO_SIG\r
+  Moved #define ... 0.0L inside #ifdef STDC, in case some cpp's tokenize\r
+  Added BAD_MALLOC\r
+    5.0 Length 88228; February 1993; around 120 lines of output\r
+         (depends on what you count)\r
+  Added the 'sh enquire.c' horror/delight: thanks David Mankins@think\r
+  Added checks for long names: thanks Steve Simon@leeds-poly\r
+  Added FPE signal checks: thanks Leonid A. Broukhis\r
+  Added check for dereferencing NULL\r
+  Added TESTI\r
+  Added LIBS, fixed showtype: thanks Rainer Orth@TechFak.Uni-Bielefeld.DE\r
+  Added a free(): thanks nickc@perihelion.co.uk\r
+  Added signal catching to the malloc part\r
+  Renamed naughty-compiler defines to BAD_*\r
+  Renamed and altered Verify() to better check faulty compilers\r
+  Shut some compilers up from giving incorrect warnings.\r
+  Fixed sign_of(): thanks Hugh Redelmeier@redvax\r
+  Fixed USHRT_MAX for sizeof(short)=sizeof(int) but INT_MAX > SHRT_MAX\r
+  Fixed NO_UI\r
+  Fixed -DSEP: thanks Mike Black@seismo\r
+  Fixed the case where stdio.h includes limits.h: thanks rms@gnu\r
+  Fixed exponent(): thanks Christophe BINOT\r
+    <chb%hpvpta.france.hp.com@hplb.hpl.hp.com>\r
+   5.0a Aug 1997\r
+  Made handling of ID= easier\r
+  Improved the reporting of use of bits in Floating values.\r
+   5.1  Length 88739; Sep 1998\r
+  Fixed detection of infinity for machines with no overflow trap\r
+  Speeded up search for max char (first 32 bit char machine turned up...)\r
+   5.1a Length 88832; Feb 1999\r
+  Changed identification message\r
+   5.1b Length 88926; Oct 2002\r
+        Fixed a missing \n in an output line; thanks Leonid Broukhis again\r
+*/\r
+\r
+/* Set FILENAME to the name of this file */\r
+#ifndef FILENAME\r
+#ifdef BAD_CPP\r
+#define FILENAME "enquire.c"\r
+#else\r
+#ifdef __FILE__ /* It's a compiler bug if this fails. Define BAD_CPP */\r
+#define FILENAME __FILE__\r
+#else\r
+#define FILENAME "enquire.c"\r
+#endif /* __FILE__ */\r
+#endif /* BAD_CPP */\r
+#endif /* FILENAME */\r
+\r
+/* This file is read three times (it #includes itself), to generate\r
+   otherwise identical code for each of short+float, int+double,\r
+   long+long double. If PASS isn't defined, then this is the first pass.\r
+   Code bracketed by 'PASS0' is for stuff independent of all three,\r
+   but is read during the first pass.\r
+*/\r
+#ifndef PASS\r
+#ifdef SEP /* so we're only interested if this is pass 1 or not */\r
+#ifdef PASS1\r
+#define PASS 1\r
+#else\r
+#define PASS 0\r
+#endif\r
+#else /* no SEP, so this is the first pass */\r
+#define PASS 1\r
+#define PASS0 1\r
+#define PASS1 1\r
+#endif /* SEP */\r
+\r
+/* Void just marks the functions that don't return a result */\r
+#ifdef NO_VOID\r
+#define Void int\r
+#else\r
+#define Void void\r
+#endif\r
+\r
+/* Set STDC to whether this is *really* an ANSI C compiler.\r
+   Some bad compilers define __STDC__, when they don't support it.\r
+   Compile with -DBAD_STDC to get round this.\r
+*/\r
+#ifndef BAD_STDC\r
+#ifdef __STDC__\r
+#if __STDC__ /* If __STDC__ is 0, assume it isn't supported */\r
+#define STDC\r
+#endif\r
+#endif\r
+#endif\r
+\r
+/* Stuff different for ANSI C, and old C:\r
+   ARGS and NOARGS are used for function prototypes.\r
+   Volatile is used to reduce the chance of optimisation,\r
+  and to prevent variables being put in registers (when setjmp/longjmp\r
+  wouldn't work as we want)\r
+   Long_double is the longest floating point type available.\r
+   stdc is used in tests like "if (stdc)", which is less ugly than #ifdef.\r
+   U is output after unsigned constants.\r
+ */\r
+#ifdef STDC\r
+\r
+#define ARGS(x) x\r
+#define NOARGS (void)\r
+#define Volatile volatile\r
+#define Long_double long double\r
+#define stdc 1\r
+#define U "U"\r
+\r
+#else /* Old style C */\r
+\r
+#define ARGS(x) ()\r
+#define NOARGS ()\r
+#define Volatile static\r
+#define Long_double double\r
+#define stdc 0\r
+#define U ""\r
+\r
+#endif /* STDC */\r
+\r
+/* include files */\r
+#include <stdio.h>\r
+#include  <wchar.h>\r
+\r
+#ifdef STDC\r
+#ifndef BAD_STDDEF\r
+#include <stddef.h> /* for size_t: if this fails, define BAD_STDDEF */\r
+#endif\r
+#endif\r
+\r
+#ifdef NO_SIG\r
+#define jmp_buf int\r
+#else\r
+#include <signal.h> /* if this fails, define NO_SIG */\r
+#include <setjmp.h> /* if this fails, define NO_SIG */\r
+#endif\r
+//#ifndef NO_SIG\r
+//#include <signal.h> /* if this fails, define NO_SIG */\r
+//#include <setjmp.h> /* if this fails, define NO_SIG */\r
+//#endif\r
+\r
+/* Kludge around the possiblity that <stdio.h> includes <limits.h> */\r
+#ifdef CHAR_BIT\r
+#undef CHAR_BIT\r
+#undef CHAR_MAX\r
+#undef CHAR_MIN\r
+#undef SCHAR_MAX\r
+#undef SCHAR_MIN\r
+#undef UCHAR_MAX\r
+#undef UCHAR_MIN\r
+#endif\r
+\r
+#ifdef VERIFY\r
+#include "limits.h"\r
+#include "float.h"\r
+#endif\r
+\r
+/* The largest unsigned type */\r
+#ifdef NO_UI\r
+#define ulong unsigned int\r
+#else\r
+#define ulong unsigned long\r
+#endif\r
+\r
+/* Some shorthands */\r
+#define Vprintf if (V) printf\r
+#define Unexpected(place) if (setjmp(lab)!=0) croak(place)\r
+#define fabs(x) (((x)<0.0)?(-x):(x))\r
+\r
+#endif /* PASS */\r
+\r
+/* A description of the ANSI constants */\r
+#define D_CHAR_BIT "Number of bits in a storage unit"\r
+#define D_CHAR_MAX "Maximum char"\r
+#define D_CHAR_MIN "Minimum char"\r
+#define D_SCHAR_MAX "Maximum signed char"\r
+#define D_SCHAR_MIN "Minimum signed char"\r
+#define D_UCHAR_MAX "Maximum unsigned char (minimum is always 0)"\r
+\r
+#define D_INT_MAX "Maximum %s"\r
+#define D_INT_MIN "Minimum %s"\r
+#define D_UINT_MAX "Maximum unsigned %s (minimum is always 0)"\r
+\r
+#define D_FLT_ROUNDS "Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown"\r
+#define D_FLT_RADIX "Radix of exponent representation"\r
+#define D_MANT_DIG "Number of base-FLT_RADIX digits in the significand of a %s"\r
+#define D_DIG "Number of decimal digits of precision in a %s"\r
+#define D_MIN_EXP "Minimum int x such that FLT_RADIX**(x-1) is a normalised %s"\r
+#define D_MIN_10_EXP "Minimum int x such that 10**x is a normalised %s"\r
+#define D_MAX_EXP "Maximum int x such that FLT_RADIX**(x-1) is a representable %s"\r
+#define D_MAX_10_EXP "Maximum int x such that 10**x is a representable %s"\r
+#define D_MAX "Maximum %s"\r
+#define D_EPSILON "Difference between 1.0 and the minimum %s greater than 1.0"\r
+#define D_MIN "Minimum normalised %s"\r
+\r
+#ifdef PASS0\r
+\r
+/* Prototypes for what's to come: */\r
+\r
+int false NOARGS;\r
+\r
+#ifdef BAD_STDDEF\r
+char *malloc (); /* Old style prototype, since we don't know what size_t is */\r
+#else\r
+char *malloc ARGS((size_t size));\r
+#endif\r
+Void free ARGS((char *p)); /* Syntax error here? Try -DNO_VOID */\r
+\r
+Void exit ARGS((int status));\r
+\r
+char *f_rep ARGS((int precision, Long_double val));\r
+\r
+int maximum_int NOARGS;\r
+int cprop NOARGS;\r
+int basic NOARGS;\r
+Void sprop NOARGS;\r
+Void iprop NOARGS;\r
+Void lprop NOARGS;\r
+Void usprop NOARGS;\r
+Void uiprop NOARGS;\r
+Void ulprop NOARGS;\r
+int fprop ARGS((int byte_size));\r
+int dprop ARGS((int byte_size));\r
+int ldprop ARGS((int byte_size));\r
+Void efprop ARGS((int fprec, int dprec, int lprec));\r
+Void edprop ARGS((int fprec, int dprec, int lprec));\r
+Void eldprop ARGS((int fprec, int dprec, int lprec));\r
+\r
+int setmode ARGS((char *s));\r
+Void farewell ARGS((int bugs));\r
+Void describe ARGS((char *description, char *extra));\r
+Void missing ARGS((char *s));\r
+Void fmissing ARGS((char *s));\r
+Void check_defines NOARGS;\r
+Void bitpattern ARGS((char *p, unsigned int size));\r
+int ceil_log ARGS((int base, Long_double x));\r
+Void croak ARGS((int place));\r
+Void trap1 ARGS((int sig));\r
+Void eek_a_bug ARGS((char *problem));\r
+Void endian ARGS((int byte_size));\r
+int exponent ARGS((Long_double x, Long_double *fract, int *exp));\r
+int floor_log ARGS((int base, Long_double x));\r
+Void f_define ARGS((char *desc, char *extra, char *sort, char *name,\r
+       int prec, Long_double val, char *mark));\r
+Void i_define ARGS((char *desc, char *extra, char *sort, char *name,\r
+       long val, long lim, long req, char *mark));\r
+Void u_define ARGS((char *desc, char *extra, char *sort, char *name,\r
+       ulong val, ulong req, char *mark));\r
+\r
+#ifdef NO_SIG  /* There's no signal(), or setjmp/longjmp() */\r
+\r
+  /* Dummy routines instead */\r
+  typedef int jmp_buf;\r
+\r
+  int setjmp ARGS((jmp_buf lab));\r
+\r
+  jmp_buf lab, mlab;\r
+  int setjmp(jmp_buf lab) { return(0); }\r
+  void  longjmp(jmp_buf lab, int val) { return; }\r
+\r
+  Void signal(int i, void (*p)()) {}\r
+\r
+#else\r
+  jmp_buf lab, mlab;\r
+  Void overflow(int sig)\r
+  { /* what to do on over/underflow */\r
+    signal(sig, overflow);\r
+    longjmp(lab, 1);\r
+  }\r
+\r
+  Void address(int sig)\r
+  { /* what to do on an address error */\r
+    signal(sig, address);\r
+    longjmp(mlab, 1);\r
+  }\r
+\r
+#endif /*NO_SIG*/\r
+\r
+int V= 0, /* verbose */\r
+    L= 0, /* produce limits.h */\r
+    F= 0, /* produce float.h  */\r
+    bugs=0; /* The number of (possible) bugs in the output */\r
+\r
+char co[4], oc[4]; /* Comment starter and ender symbols */\r
+\r
+int bits_per_byte; /* the number of bits per unit returned by sizeof() */\r
+int flt_rounds;    /* The calculated value of FLT_ROUNDS */\r
+int flt_radix;     /* The calculated value of FLT_RADIX */\r
+Volatile int trapped; /* For testing FPE traps */\r
+\r
+#ifdef TEST\r
+/* Set the fp modes on a SUN with 68881 chip, to check that different\r
+   rounding modes etc. get properly detected.\r
+   Compile with -f68881 for cc, -m68881 for gcc, and with additional flag\r
+   -DTEST. Run with additional parameter +hex-number, to set the 68881 mode\r
+   register to hex-number\r
+*/\r
+\r
+/* Bits 0x30 = rounding mode */\r
+#define ROUND_BITS  0x30\r
+#define TO_NEAREST  0x00\r
+#define TO_ZERO   0x10\r
+#define TO_MINUS_INF  0x20\r
+#define TO_PLUS_INF 0x30 /* The SUN FP user's guide seems to be wrong here */\r
+\r
+/* Bits 0xc0 = extended rounding */\r
+#define EXT_BITS  0xc0\r
+#define ROUND_EXTENDED  0x00\r
+#define ROUND_SINGLE  0x40\r
+#define ROUND_DOUBLE  0x80\r
+\r
+/* Enabled traps */\r
+#define EXE_INEX1  0x100\r
+#define EXE_INEX2  0x200\r
+#define EXE_DZ     0x400\r
+#define EXE_UNFL   0x800\r
+#define EXE_OVFL  0x1000\r
+#define EXE_OPERR 0x2000\r
+#define EXE_SNAN  0x4000\r
+#define EXE_BSUN  0x8000\r
+\r
+/* Only used for testing, on a Sun with 68881 chip */\r
+/* Print the FP mode */\r
+printmode(new) unsigned new; {\r
+  fpmode_(&new);\r
+  printf("New fp mode:\n");\r
+  printf("  Round toward ");\r
+  switch (new & ROUND_BITS) {\r
+        case TO_NEAREST:   printf("nearest"); break;\r
+        case TO_ZERO:      printf("zero"); break;\r
+        case TO_MINUS_INF: printf("minus infinity"); break;\r
+        case TO_PLUS_INF:  printf("plus infinity"); break;\r
+        default: printf("???"); break;\r
+  }\r
+\r
+  printf("\n  Extended rounding precision: ");\r
+\r
+  switch (new & EXT_BITS) {\r
+        case ROUND_EXTENDED: printf("extended"); break;\r
+        case ROUND_SINGLE:   printf("single"); break;\r
+        case ROUND_DOUBLE:   printf("double"); break;\r
+        default: printf("???"); break;\r
+  }\r
+\r
+  printf("\n  Enabled exceptions:");\r
+  if (new & (unsigned) EXE_INEX1) printf(" inex1");\r
+  if (new & (unsigned) EXE_INEX2) printf(" inex2");\r
+  if (new & (unsigned) EXE_DZ)    printf(" divz");\r
+  if (new & (unsigned) EXE_UNFL)  printf(" unfl");\r
+  if (new & (unsigned) EXE_OVFL)  printf(" ovfl");\r
+  if (new & (unsigned) EXE_OPERR) printf(" operr");\r
+  if (new & (unsigned) EXE_SNAN)  printf(" snan");\r
+  if (new & (unsigned) EXE_BSUN)  printf(" bsun");\r
+  printf("\n");\r
+}\r
+\r
+/* Only used for testing, on a Sun with 68881 chip */\r
+/* Set the FP mode */\r
+int setmode(s) char *s; {\r
+  unsigned mode=0, dig;\r
+  char c;\r
+\r
+  while (*s) {\r
+    c= *s++;\r
+    if  (c>='0' && c<='9') dig= c-'0';\r
+    else if (c>='a' && c<='f') dig= c-'a'+10;\r
+    else if (c>='A' && c<='F') dig= c-'A'+10;\r
+    else return 1;\r
+    mode= mode<<4 | dig;\r
+  }\r
+  printmode(mode);\r
+  return 0;\r
+}\r
+#define SETMODE\r
+#endif\r
+\r
+#ifdef TESTI /* Test mode using SunOs IEEE routines */\r
+\r
+#include <sys/ieeefp.h>\r
+\r
+int setmode(char *s) {\r
+  char *dummy, c, *cmd, *val;\r
+  while (*s) {\r
+    switch (c= *s++) {\r
+          case '=': cmd= "direction"; val= "nearest"; break;\r
+          case '0': cmd= "direction"; val= "tozero"; break;\r
+          case '+': cmd= "direction"; val= "positive"; break;\r
+          case '-': cmd= "direction"; val= "negative"; break;\r
+          case '1': cmd= "precision"; val= "single"; break;\r
+          case '2': cmd= "precision"; val= "double"; break;\r
+          case '3': cmd= "precision"; val= "extended"; break;\r
+          case '~': cmd= "exception"; val= "inexact"; break;\r
+          case '/': cmd= "exception"; val= "division"; break;\r
+          case '>': cmd= "exception"; val= "overflow"; break;\r
+          case '<': cmd= "exception"; val= "underflow"; break;\r
+          default:\r
+      printf("Bad setmode character: %c\n", c);\r
+      return 1;\r
+      break;\r
+    }\r
+    printf("Set %s %s", cmd, val);\r
+    if (ieee_flags("set", cmd, val, &dummy)) {\r
+      printf(": failed\n");\r
+      return 1;\r
+    }\r
+    printf("\n");\r
+  }\r
+  return 0;\r
+}\r
+#define SETMODE\r
+#endif\r
+\r
+#ifndef SETMODE\r
+/* ARGSUSED */\r
+int\r
+setmode(char *s)\r
+{\r
+  fprintf(stderr, "Can't set mode: not compiled with TEST\n");\r
+  return(1);\r
+}\r
+#endif\r
+\r
+int\r
+memeq(\r
+  char *p1,\r
+  int size1,\r
+  char *p2,\r
+  int size2\r
+  )\r
+{\r
+  /* See if two blocks of store are identical */\r
+  int i;\r
+  if (size1 != size2) return 0;\r
+  for (i=1; i<=size1; i++) {\r
+    if (*p1++ != *p2++) return 0;\r
+  }\r
+  return 1;\r
+}\r
+\r
+Void\r
+farewell(int bugs)\r
+{\r
+  if (bugs == 0) exit(0);\r
+  printf("\n%sFor hints on dealing with the ", co);\r
+  if (bugs == 1) printf("problem");\r
+  else printf("%d problems", bugs);\r
+  printf(" above\n   see the section 'TROUBLESHOOTING' in the file ");\r
+  printf("%s%s\n", FILENAME, oc);\r
+  exit(bugs);\r
+}\r
+\r
+/* The program has received a signal where it wasn't expecting one */\r
+Void\r
+croak(int place)\r
+{\r
+  printf("*** Unexpected signal at point %d\n", place);\r
+  farewell(bugs+1); /* An exit isn't essential here, but avoids loops */\r
+}\r
+\r
+/* This is here in case alloca.c is used, which calls this. */\r
+char *\r
+xmalloc(unsigned size)\r
+{\r
+  char *value = malloc(size);\r
+  if (value == 0) {\r
+    fprintf(stderr, "Virtual memory exceeded\n");\r
+    exit(bugs+1);\r
+  }\r
+  return value;\r
+}\r
+\r
+int maxint;\r
+\r
+int\r
+maximum_int( void )\r
+{\r
+  /* Find the maximum integer */\r
+  Volatile int newi, int_max, two=2;\r
+\r
+  /* Calculate maxint ***********************************/\r
+  /* Calculate 2**n-1 until overflow - then use the previous value  */\r
+\r
+  newi=1; int_max=0;\r
+\r
+  if (setjmp(lab)==0) { /* Yields int_max */\r
+    while(newi>int_max) {\r
+      int_max=newi;\r
+      newi=newi*two+1;\r
+    }\r
+  }\r
+  Unexpected(0);\r
+  return int_max;\r
+}\r
+\r
+/* How long are my identifiers? I could go further here, but some compilers\r
+   have line length limits that I don't want to break.\r
+*/\r
+\r
+int zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz=64;\r
+\r
+int\r
+name_len( void )\r
+{\r
+   int zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zz=32;\r
+   { int zzzzzzzzz1zzzzzz=16;\r
+     { int zzzzzzzz=8;\r
+       { int zzzzzzz=7;\r
+   { int zzzzzz=6;\r
+     return\r
+       zzzzzzzzz1zzzzzzzzz2zzzzzzzzz3zzzzzzzzz4zzzzzzzzz5zzzzzzzzz6zzzz;\r
+   }\r
+       }\r
+     }\r
+   }\r
+}\r
+\r
+#define aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa 64\r
+#define LENGTH 64\r
+\r
+#ifdef aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aa\r
+#undef LENGTH\r
+#define LENGTH 32\r
+#endif\r
+\r
+#ifdef aaaaaaaaa1aaaaaa\r
+#undef LENGTH\r
+#define LENGTH 16\r
+#endif\r
+\r
+#ifdef aaaaaaaa\r
+#undef LENGTH\r
+#define LENGTH 8\r
+#endif\r
+\r
+#undef aaaaaaaaa1aaaaaaaaa2aaaaaaaaa3aaaaaaaaa4aaaaaaaaa5aaaaaaaaa6aaaa\r
+\r
+Void long_names()\r
+{\r
+  int l= name_len();\r
+  Vprintf("Compiler names are at least %d chars long", l);\r
+  if (l != 64)\r
+    Vprintf(" (but less than %d)", l*2);\r
+  Vprintf("\n");\r
+  Vprintf("Preprocessor names are at least %d long", LENGTH);\r
+  if (LENGTH != 64)\r
+    Vprintf(" (but less than %d)", LENGTH*2);\r
+  Vprintf("\n\n");\r
+}\r
+\r
+/* Used by FPROP to see if FP traps are generated, and if they may return */\r
+\r
+Void\r
+trap2(int sig)\r
+{\r
+  longjmp(lab, 1);\r
+}\r
+\r
+Void\r
+trap1(int sig)\r
+{\r
+  trapped= 1; /* A global */\r
+  signal(sig, trap2);\r
+}\r
+\r
+Void\r
+setsignals( void )\r
+{\r
+#ifdef SIGFPE\r
+  signal(SIGFPE, overflow);\r
+#endif\r
+#ifdef SIGOVER\r
+  signal(SIGOVER, overflow);\r
+#endif\r
+#ifdef SIGBUS\r
+  signal(SIGBUS, address);\r
+#endif\r
+#ifdef SIGSEGV\r
+  signal(SIGSEGV, address);\r
+#endif\r
+  /* Add more calls as necessary */\r
+}\r
+\r
+#undef LENGTH\r
+\r
+int\r
+main(int argc, char *argv[])\r
+{\r
+  int dprec, fprec, lprec;\r
+  int i;\r
+  wchar_t *s;\r
+  int bad;\r
+\r
+  setsignals();\r
+  Unexpected(1);\r
+\r
+  bad=0;\r
+  for (i=1; i < argc; i++) {\r
+    s = (wchar_t *)(argv[i]);\r
+    if (*s == L'-') {\r
+      s++;\r
+      while (*s) {\r
+        switch (*(s++)) {\r
+              case L'v': V=1; break;\r
+              case L'l': L=1; break;\r
+              case L'f': F=1; break;\r
+              default: bad=1; break;\r
+        }\r
+      }\r
+    } else if (*s == L'+') {\r
+      s++;\r
+      bad = setmode((char *)s);\r
+    } else bad= 1;\r
+  }\r
+  if (bad) {\r
+    fprintf(stderr,\r
+      "Usage: %ls [-vlf]\n  v=Verbose l=Limits.h f=Float.h\n",\r
+      (wchar_t *)(argv[0]));\r
+    exit(1);\r
+  }\r
+  if (L || F) {\r
+    co[0]= '/'; oc[0]= ' ';\r
+    co[1]= '*'; oc[1]= '*';\r
+    co[2]= ' '; oc[2]= '/';\r
+    co[3]= '\0'; oc[3]= '\0';\r
+  } else {\r
+    co[0]= '\0'; oc[0]= '\0';\r
+    V=1;\r
+  }\r
+\r
+  if (L) printf("%slimits.h%s\n", co, oc);\r
+  if (F) printf("%sfloat.h%s\n", co, oc);\r
+#ifdef ID\r
+  printf("%sProduced by enquire version %s (%s), CWI, Amsterdam\n   %s\n",\r
+         co, VERSION, ID, WEB, oc);\r
+#else\r
+  printf("%sProduced by enquire version %s, CWI, Amsterdam\n   %s %s\n",\r
+         co, VERSION,     WEB, oc);\r
+#endif\r
+\r
+#ifdef VERIFY\r
+  printf("%sVerification phase%s\n", co, oc);\r
+#endif\r
+\r
+#ifdef NO_SIG\r
+  Vprintf("%sCompiled without signal(): %s%s\n",\r
+    co,\r
+    "there's nothing that can be done if overflow occurs",\r
+    oc);\r
+#endif\r
+#ifdef NO_SC\r
+  Vprintf("%sCompiled without signed char%s\n", co, oc);\r
+#endif\r
+#ifdef NO_UC\r
+  Vprintf("%sCompiled without unsigned char%s\n", co, oc);\r
+#endif\r
+#ifdef NO_UI\r
+  Vprintf("%sCompiled without unsigned short or long%s\n", co, oc);\r
+#endif\r
+#ifdef __STDC__\r
+  Vprintf("%sCompiler claims to be ANSI C level %d%s\n",\r
+    co, __STDC__, oc);\r
+#else\r
+  Vprintf("%sCompiler does not claim to be ANSI C%s\n", co, oc);\r
+#endif\r
+  printf("\n");\r
+\r
+  long_names();\r
+  check_defines();\r
+\r
+  maxint= maximum_int();\r
+  bits_per_byte= basic();\r
+  Vprintf("\n");\r
+  if (F||V) {\r
+    fprec= fprop(bits_per_byte);\r
+    dprec= dprop(bits_per_byte);\r
+    lprec= ldprop(bits_per_byte);\r
+    efprop(fprec, dprec, lprec);\r
+    edprop(fprec, dprec, lprec);\r
+    eldprop(fprec, dprec, lprec);\r
+  }\r
+#ifndef BAD_MALLOC\r
+  if (V) {\r
+    /* An extra goody: the approximate amount of data-space */\r
+    /* Allocate store until no more available */\r
+    /* Different implementations have a different argument type\r
+       to malloc. Here we assume that it's the same type as\r
+       that which sizeof() returns */\r
+    unsigned int size;\r
+    Volatile long total;\r
+    char kmg, *ptr, *save;\r
+    char **link;\r
+\r
+    save= NULL;\r
+    size=maximum_int()/4;\r
+    total=0;\r
+    while (size!=0) {\r
+      if (setjmp(mlab) == 0) {\r
+        while ((ptr= malloc((false()?sizeof(int):size))) != (char *)NULL) {\r
+          //if (save == NULL) save= ptr; /* save the biggest chunk */\r
+          link = (char **)ptr;\r
+          if (save == NULL) {\r
+            // Save pointer to first allocated chunk\r
+            save= ptr;\r
+            *link = NULL;\r
+          }\r
+          else {\r
+            // Build list of all subsequently allocated chunks, LIFO\r
+            *link = save;\r
+            save = ptr;\r
+          }\r
+          total+=(size/2);\r
+        }\r
+      } else {\r
+        eek_a_bug("Trying to malloc all store generates a trap");\r
+      }\r
+      size/=2;\r
+    }\r
+    if (setjmp(mlab)!=0) croak(-1);\r
+\r
+    //if (save != NULL) free(save);\r
+    while(save != NULL) {\r
+      link = (char **)save;\r
+      ptr = *link;\r
+      free(save);\r
+      save = ptr;\r
+    }\r
+\r
+    total= (total+511)/512; /* Sic */ kmg= 'K';\r
+    if (total > 10000) {\r
+      total= (total+999)/1000; kmg= 'M';\r
+    }\r
+    if (total > 10000) {\r
+      total= (total+999)/1000; kmg= 'G';\r
+    }\r
+    if (total > 10000) {\r
+      total= (total+999)/1000; kmg= 'T';\r
+    }\r
+    Vprintf("%sMemory mallocatable ~= %ld %cbytes%s\n",\r
+      co, total, kmg, oc);\r
+  }\r
+#endif\r
+  farewell(bugs);\r
+  return bugs; /* To keep compilers and lint happy */\r
+}\r
+\r
+Void\r
+eek_a_bug(char *problem)\r
+{\r
+  /* The program has discovered a problem */\r
+  printf("\n%s*** WARNING: %s%s\n", co, problem, oc);\r
+  bugs++;\r
+}\r
+\r
+Void\r
+describe(char *description, char *extra)\r
+{\r
+  /* Produce the description for a #define */\r
+  printf("   %s", co);\r
+  printf(description, extra);\r
+  printf("%s\n", oc);\r
+}\r
+\r
+Void\r
+i_define(\r
+   char *desc,\r
+   char *extra,\r
+   char *sort,\r
+   char *name,\r
+   long val,\r
+   long lim,\r
+   long req,\r
+   char *mark\r
+  )\r
+{\r
+  /* Produce a #define for a signed int type */\r
+  describe(desc, extra);\r
+  if (val >= 0) {\r
+    printf("#define %s%s %ld%s\n", sort, name, val, mark);\r
+  } else if (val + lim < 0) {\r
+    /* We may not produce a constant like -1024 if the max\r
+       allowable value is 1023. It has then to be output as\r
+       -1023-1. lim is the max allowable value. */\r
+    printf("#define %s%s (%ld%s%ld%s)\n",\r
+           sort, name, -lim, mark, val+lim, mark);\r
+  } else {\r
+    printf("#define %s%s (%ld%s)\n", sort, name, val, mark);\r
+  }\r
+  /* If VERIFY is not set, val and req are just the same value;\r
+     if it is set, val is the value as calculated, and req is\r
+     the #defined constant\r
+  */\r
+  if (val != req) {\r
+    printf("%s*** Verify failed for above #define!\n", co);\r
+    printf("       Compiler has %ld for value%s\n\n", req, oc);\r
+    bugs++;\r
+  }\r
+  Vprintf("\n");\r
+}\r
+\r
+Void\r
+u_define(\r
+  char *desc,\r
+  char *extra,\r
+  char *sort,\r
+  char *name,\r
+  ulong val,\r
+  ulong req,\r
+  char *mark\r
+  )\r
+{\r
+  /* Produce a #define for an unsigned value */\r
+  describe(desc, extra);\r
+  printf("#define %s%s %lu%s%s\n", sort, name, val, U, mark);\r
+  if (val != req) {\r
+    printf("%s*** Verify failed for above #define!\n", co);\r
+    printf("       Compiler has %lu for value%s\n\n", req, oc);\r
+    bugs++;\r
+  }\r
+  Vprintf("\n");\r
+}\r
+\r
+Void f_define(\r
+  char *desc,\r
+  char *extra,\r
+  char *sort,\r
+  char *name,\r
+  int precision,\r
+  Long_double val,\r
+  char *mark\r
+  )\r
+{\r
+  /* Produce a #define for a float/double/long double */\r
+  describe(desc, extra);\r
+  if (stdc) {\r
+    printf("#define %s%s %s%s\n",\r
+           sort, name, f_rep(precision, val), mark);\r
+  } else if (*mark == 'F') {\r
+    /* non-ANSI C has no float constants, so cast the constant */\r
+    printf("#define %s%s ((float)%s)\n",\r
+           sort, name, f_rep(precision, val));\r
+  } else {\r
+    printf("#define %s%s %s\n", sort, name, f_rep(precision, val));\r
+  }\r
+  Vprintf("\n");\r
+}\r
+\r
+int\r
+floor_log(int base, Long_double x)\r
+{\r
+  /* return floor(log base(x)) */\r
+  int r=0;\r
+  while (x>=base) { r++; x/=base; }\r
+  return r;\r
+}\r
+\r
+int\r
+ceil_log(int base, Long_double x)\r
+{\r
+  int r=0;\r
+  while (x>1.0) { r++; x/=base; }\r
+  return r;\r
+}\r
+\r
+int\r
+exponent(Long_double x, Long_double *fract, int *exp)\r
+{\r
+  /* Split x into a fraction and a power of ten;\r
+     returns 0 if x is unusable, 1 otherwise.\r
+     Only used for error messages about faulty output.\r
+  */\r
+  int r=0, neg=0;\r
+  Long_double old;\r
+  *fract=0.0; *exp=0;\r
+  if (x<0.0) {\r
+    x= -x;\r
+    neg= 1;\r
+  }\r
+  if (x==0.0) return 1;\r
+  if (x>=10.0) {\r
+    while (x>=10.0) {\r
+      old=x; r++; x/=10.0;\r
+      if (old==x) return 0;\r
+    }\r
+  } else {\r
+    while (x<1.0) {\r
+      old=x; r--; x*=10.0;\r
+      if (old==x) return 0;\r
+    }\r
+  }\r
+  if (neg) *fract= -x;\r
+  else *fract= x;\r
+  *exp=r;\r
+  return 1;\r
+}\r
+\r
+char *\r
+f_rep(int precision, Long_double val)\r
+{\r
+  /* Return the floating representation of val */\r
+  static char buf[1024];\r
+  char *f1;\r
+  if (sizeof(double) == sizeof(Long_double)) {\r
+    /* Assume they're the same, and use non-stdc format */\r
+    /* This is for stdc compilers using non-stdc libraries */\r
+    f1= "%.*e";\r
+  } else {\r
+    /* It had better support Le then */\r
+    f1= "%.*Le";\r
+  }\r
+  sprintf(buf, f1, precision, val);\r
+  return buf;\r
+}\r
+\r
+Void\r
+bitpattern(char *p, unsigned int size)\r
+{\r
+  /* Printf the bit-pattern of p */\r
+  char c;\r
+  unsigned int i;\r
+  int j;\r
+\r
+  for (i=1; i<=size; i++) {\r
+    c= *p;\r
+    p++;\r
+    for (j=bits_per_byte-1; j>=0; j--)\r
+      printf("%c", (c>>j)&1 ? '1' : '0');\r
+    if (i!=size) printf(" ");\r
+  }\r
+}\r
+\r
+Void\r
+fill(char *p, int size)\r
+{\r
+  char *ab= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";\r
+  int i;\r
+\r
+  for (i=0; i<size; i++)\r
+    p[i]= ab[i];\r
+}\r
+\r
+#define Order(x, mode)\\r
+   printf("%s%s ", co, mode); fill((char *)&x, sizeof(x)); \\r
+   for (i=1; i<=sizeof(x); i++) { c=((x>>(byte_size*(sizeof(x)-i)))&mask);\\r
+      putchar(c==0 ? '?' : (char)c); }\\r
+   printf("%s\n", oc);\r
+\r
+Void\r
+endian(int byte_size)\r
+{\r
+  /* Printf the byte-order used on this machine */\r
+  /*unsigned*/ short s=0;\r
+  /*unsigned*/ int j=0;\r
+  /*unsigned*/ long l=0;\r
+\r
+  unsigned int mask, i, c;\r
+\r
+  mask=0;\r
+  for (i=1; i<=(unsigned)byte_size; i++) mask= (mask<<1)|1;\r
+\r
+  if (V) {\r
+    printf("%sCHARACTER ORDER%s\n", co, oc);\r
+    Order(s, "short:");\r
+    Order(j, "int:  ");\r
+    Order(l, "long: ");\r
+  }\r
+}\r
+\r
+Void\r
+missing(char *s)\r
+{\r
+  printf("%s*** #define %s missing from limits.h%s\n", co, s, oc);\r
+  bugs++;\r
+}\r
+\r
+Void\r
+fmissing(char *s)\r
+{\r
+  printf("%s*** #define %s missing from float.h%s\n", co, s, oc);\r
+  bugs++;\r
+}\r
+\r
+/* To try and fool optimisers */\r
+int false( void ) { return 0; }\r
+\r
+#define Promoted(x) (false()?(x):(-1))\r
+#define is_signed(x) (Promoted(x) < 0)\r
+#define sign_of(x) (is_signed(x)?"signed":"unsigned")\r
+#define Signed 1\r
+#define Unsigned 0\r
+#define sgn(x) ((is_signed(x))?Signed:Unsigned)\r
+\r
+#define showtype(t, x) Vprintf("%s%s %s %s%s\n", co, t, sign_of(x), type_of((int)sizeof(x)), oc)\r
+\r
+char *type_of(int x)\r
+{\r
+  if (x == sizeof(char)) {\r
+    if (sizeof(char) == sizeof(int)) return "char/short/int";\r
+    if (sizeof(char) == sizeof(short)) return "char/short";\r
+    return "char";\r
+  }\r
+  if (x == sizeof(short)) {\r
+    if (sizeof(short) == sizeof(int)) return "short/int";\r
+    return "short";\r
+  }\r
+  if (x == sizeof(int)) {\r
+    if (sizeof(int) == sizeof(long)) return "int/long";\r
+    return "int";\r
+  }\r
+  if (x == sizeof(long)) return "long";\r
+  return "unknown-type";\r
+}\r
+\r
+char *ftype_of(int x)\r
+{\r
+  if (x == sizeof(float)) {\r
+    return "float";\r
+  }\r
+  if (x == sizeof(double)) {\r
+    if (sizeof(double) == sizeof(Long_double))\r
+      return "(long)double";\r
+    return "double";\r
+  }\r
+  if (x == sizeof(Long_double)) {\r
+    return "long double";\r
+  }\r
+  return "unknown-type";\r
+}\r
+\r
+Void typerr(char *name, int esign, int esize, int sign, int size)\r
+{\r
+  Vprintf("*** %s has wrong type: expected %s %s, found %s %s\n",\r
+    name, sign_of(esign), type_of(esize),\r
+    sign_of(sign), type_of(size));\r
+}\r
+\r
+Void ftyperr(char *name, int esize, int size)\r
+{\r
+  Vprintf("*** %s has wrong type: expected %s, found %s\n",\r
+    name, ftype_of(esize), ftype_of(size));\r
+}\r
+\r
+Void promotions( void )\r
+{\r
+  int si; long sl;\r
+  unsigned int ui;\r
+  short ss;\r
+\r
+#ifndef NO_UI\r
+  unsigned long ul;  /* if this fails, define NO_UI */\r
+  unsigned short us; /* if this fails, define NO_UI */\r
+\r
+  ul=0; us=0;\r
+#endif\r
+  /* Shut compiler warnings up: */\r
+  si=0; sl=0; ui=0; ss=0;\r
+\r
+  Vprintf("\n%sPROMOTIONS%s\n", co, oc);\r
+\r
+  /* Sanity checks. Possible warnings here; should be no problem */\r
+  if (is_signed(ui))\r
+    eek_a_bug("unsigned int promotes to signed!\n");\r
+  if (!is_signed(si))\r
+    eek_a_bug("signed int promotes to unsigned!\n");\r
+  if (!is_signed(sl))\r
+    eek_a_bug("signed long promotes to unsigned!\n");\r
+  if (sizeof(Promoted(si)) != sizeof(int))\r
+    eek_a_bug("int doesn't promote to int!\n");\r
+  if (sizeof(Promoted(sl)) != sizeof(long))\r
+    eek_a_bug("long doesn't promote to long!\n");\r
+  if (sizeof(Promoted(ss)) != sizeof(int))\r
+    eek_a_bug("short doesn't promote to int!\n");\r
+  if (sizeof(Promoted(ui)) != sizeof(int))\r
+    eek_a_bug("unsigned int doesn't promote to int!\n");\r
+#ifndef NO_UI\r
+  if (sizeof(Promoted(ul)) != sizeof(long))\r
+    eek_a_bug("unsigned long doesn't promote to long!\n");\r
+  if (is_signed(ul))\r
+    eek_a_bug("unsigned long promotes to signed!\n");\r
+#endif\r
+\r
+#ifndef NO_UI\r
+  showtype("unsigned short promotes to", Promoted(us));\r
+#endif\r
+  showtype("long+unsigned gives", sl+ui);\r
+}\r
+\r
+#define checktype(x, n, s, t) if((sgn(x)!=s)||(sizeof(x)!=sizeof(t))) typerr(n, s, (int)sizeof(t), sgn(x), (int)sizeof(x));\r
+\r
+#define fchecktype(x, n, t) if (sizeof(x) != sizeof(t)) ftyperr(n, (int)sizeof(x), (int)sizeof(t));\r
+\r
+Void check_defines( void )\r
+{\r
+  /* ensure that all #defines are present and have the correct type */\r
+#ifdef VERIFY\r
+  int usign;\r
+\r
+#ifdef NO_UI\r
+  usign= Signed;\r
+#else\r
+  /* Implementations promote unsigned short differently */\r
+  usign= is_signed((unsigned short)0);\r
+#endif\r
+\r
+  if (L) {\r
+#ifdef CHAR_BIT\r
+  checktype(CHAR_BIT, "CHAR_BIT", Signed, int);\r
+#else\r
+  missing("CHAR_BIT");\r
+#endif\r
+#ifdef CHAR_MAX\r
+  checktype(CHAR_MAX, "CHAR_MAX", Signed, int);\r
+#else\r
+  missing("CHAR_MAX");\r
+#endif\r
+#ifdef CHAR_MIN\r
+  checktype(CHAR_MIN, "CHAR_MIN", Signed, int);\r
+#else\r
+  missing("CHAR_MIN");\r
+#endif\r
+#ifdef SCHAR_MAX\r
+  checktype(SCHAR_MAX, "SCHAR_MAX", Signed, int);\r
+#else\r
+  missing("SCHAR_MAX");\r
+#endif\r
+#ifdef SCHAR_MIN\r
+  checktype(SCHAR_MIN, "SCHAR_MIN", Signed, int);\r
+#else\r
+  missing("SCHAR_MIN");\r
+#endif\r
+#ifdef UCHAR_MAX\r
+  checktype(UCHAR_MAX, "UCHAR_MAX", Signed, int);\r
+#else\r
+  missing("UCHAR_MAX");\r
+#endif\r
+#ifdef SHRT_MAX\r
+  checktype(SHRT_MAX, "SHRT_MAX", Signed, int);\r
+#else\r
+  missing("SHRT_MAX");\r
+#endif\r
+#ifdef SHRT_MIN\r
+  checktype(SHRT_MIN, "SHRT_MIN", Signed, int);\r
+#else\r
+  missing("SHRT_MIN");\r
+#endif\r
+#ifdef INT_MAX\r
+  checktype(INT_MAX, "INT_MAX", Signed, int);\r
+#else\r
+  missing("INT_MAX");\r
+#endif\r
+#ifdef INT_MIN\r
+  checktype(INT_MIN, "INT_MIN", Signed, int);\r
+#else\r
+  missing("INT_MIN");\r
+#endif\r
+#ifdef LONG_MAX\r
+  checktype(LONG_MAX, "LONG_MAX", Signed, long);\r
+#else\r
+  missing("LONG_MAX");\r
+#endif\r
+#ifdef LONG_MIN\r
+  checktype(LONG_MIN, "LONG_MIN", Signed, long);\r
+#else\r
+  missing("LONG_MIN");\r
+#endif\r
+#ifdef USHRT_MAX\r
+  checktype(USHRT_MAX, "USHRT_MAX", usign, int);\r
+#else\r
+  missing("USHRT_MAX");\r
+#endif\r
+#ifdef UINT_MAX\r
+  checktype(UINT_MAX, "UINT_MAX", Unsigned, int);\r
+#else\r
+  missing("UINT_MAX");\r
+#endif\r
+#ifdef ULONG_MAX\r
+  checktype(ULONG_MAX, "ULONG_MAX", Unsigned, long);\r
+#else\r
+  missing("ULONG_MAX");\r
+#endif\r
+  } /* if (L) */\r
+\r
+  if (F) {\r
+#ifdef FLT_RADIX\r
+  checktype(FLT_RADIX, "FLT_RADIX", Signed, int);\r
+#else\r
+  fmissing("FLT_RADIX");\r
+#endif\r
+#ifdef FLT_MANT_DIG\r
+  checktype(FLT_MANT_DIG, "FLT_MANT_DIG", Signed, int);\r
+#else\r
+  fmissing("FLT_MANT_DIG");\r
+#endif\r
+#ifdef FLT_DIG\r
+  checktype(FLT_DIG, "FLT_DIG", Signed, int);\r
+#else\r
+  fmissing("FLT_DIG");\r
+#endif\r
+#ifdef FLT_ROUNDS\r
+  checktype(FLT_ROUNDS, "FLT_ROUNDS", Signed, int);\r
+#else\r
+  fmissing("FLT_ROUNDS");\r
+#endif\r
+#ifdef FLT_EPSILON\r
+  fchecktype(FLT_EPSILON, "FLT_EPSILON", float);\r
+#else\r
+  fmissing("FLT_EPSILON");\r
+#endif\r
+#ifdef FLT_MIN_EXP\r
+  checktype(FLT_MIN_EXP, "FLT_MIN_EXP", Signed, int);\r
+#else\r
+  fmissing("FLT_MIN_EXP");\r
+#endif\r
+#ifdef FLT_MIN\r
+  fchecktype(FLT_MIN, "FLT_MIN", float);\r
+#else\r
+  fmissing("FLT_MIN");\r
+#endif\r
+#ifdef FLT_MIN_10_EXP\r
+  checktype(FLT_MIN_10_EXP, "FLT_MIN_10_EXP", Signed, int);\r
+#else\r
+  fmissing("FLT_MIN_10_EXP");\r
+#endif\r
+#ifdef FLT_MAX_EXP\r
+  checktype(FLT_MAX_EXP, "FLT_MAX_EXP", Signed, int);\r
+#else\r
+  fmissing("FLT_MAX_EXP");\r
+#endif\r
+#ifdef FLT_MAX\r
+  fchecktype(FLT_MAX, "FLT_MAX", float);\r
+#else\r
+  fmissing("FLT_MAX");\r
+#endif\r
+#ifdef FLT_MAX_10_EXP\r
+  checktype(FLT_MAX_10_EXP, "FLT_MAX_10_EXP", Signed, int);\r
+#else\r
+  fmissing("FLT_MAX_10_EXP");\r
+#endif\r
+#ifdef DBL_MANT_DIG\r
+  checktype(DBL_MANT_DIG, "DBL_MANT_DIG", Signed, int);\r
+#else\r
+  fmissing("DBL_MANT_DIG");\r
+#endif\r
+#ifdef DBL_DIG\r
+  checktype(DBL_DIG, "DBL_DIG", Signed, int);\r
+#else\r
+  fmissing("DBL_DIG");\r
+#endif\r
+#ifdef DBL_EPSILON\r
+  fchecktype(DBL_EPSILON, "DBL_EPSILON", double);\r
+#else\r
+  fmissing("DBL_EPSILON");\r
+#endif\r
+#ifdef DBL_MIN_EXP\r
+  checktype(DBL_MIN_EXP, "DBL_MIN_EXP", Signed, int);\r
+#else\r
+  fmissing("DBL_MIN_EXP");\r
+#endif\r
+#ifdef DBL_MIN\r
+  fchecktype(DBL_MIN, "DBL_MIN", double);\r
+#else\r
+  fmissing("DBL_MIN");\r
+#endif\r
+#ifdef DBL_MIN_10_EXP\r
+  checktype(DBL_MIN_10_EXP, "DBL_MIN_10_EXP", Signed, int);\r
+#else\r
+  fmissing("DBL_MIN_10_EXP");\r
+#endif\r
+#ifdef DBL_MAX_EXP\r
+  checktype(DBL_MAX_EXP, "DBL_MAX_EXP", Signed, int);\r
+#else\r
+  fmissing("DBL_MAX_EXP");\r
+#endif\r
+#ifdef DBL_MAX\r
+  fchecktype(DBL_MAX, "DBL_MAX", double);\r
+#else\r
+  fmissing("DBL_MAX");\r
+#endif\r
+#ifdef DBL_MAX_10_EXP\r
+  checktype(DBL_MAX_10_EXP, "DBL_MAX_10_EXP", Signed, int);\r
+#else\r
+  fmissing("DBL_MAX_10_EXP");\r
+#endif\r
+#ifdef STDC\r
+#ifdef LDBL_MANT_DIG\r
+  checktype(LDBL_MANT_DIG, "LDBL_MANT_DIG", Signed, int);\r
+#else\r
+  fmissing("LDBL_MANT_DIG");\r
+#endif\r
+#ifdef LDBL_DIG\r
+  checktype(LDBL_DIG, "LDBL_DIG", Signed, int);\r
+#else\r
+  fmissing("LDBL_DIG");\r
+#endif\r
+#ifdef LDBL_EPSILON\r
+  fchecktype(LDBL_EPSILON, "LDBL_EPSILON", long double);\r
+#else\r
+  fmissing("LDBL_EPSILON");\r
+#endif\r
+#ifdef LDBL_MIN_EXP\r
+  checktype(LDBL_MIN_EXP, "LDBL_MIN_EXP", Signed, int);\r
+#else\r
+  fmissing("LDBL_MIN_EXP");\r
+#endif\r
+#ifdef LDBL_MIN\r
+  fchecktype(LDBL_MIN, "LDBL_MIN", long double);\r
+#else\r
+  fmissing("LDBL_MIN");\r
+#endif\r
+#ifdef LDBL_MIN_10_EXP\r
+  checktype(LDBL_MIN_10_EXP, "LDBL_MIN_10_EXP", Signed, int);\r
+#else\r
+  fmissing("LDBL_MIN_10_EXP");\r
+#endif\r
+#ifdef LDBL_MAX_EXP\r
+  checktype(LDBL_MAX_EXP, "LDBL_MAX_EXP", Signed, int);\r
+#else\r
+  fmissing("LDBL_MAX_EXP");\r
+#endif\r
+#ifdef LDBL_MAX\r
+  fchecktype(LDBL_MAX, "LDBL_MAX", long double);\r
+#else\r
+  fmissing("LDBL_MAX");\r
+#endif\r
+#ifdef LDBL_MAX_10_EXP\r
+  checktype(LDBL_MAX_10_EXP, "LDBL_MAX_10_EXP", Signed, int);\r
+#else\r
+  fmissing("LDBL_MAX_10_EXP");\r
+#endif\r
+#endif /* STDC */\r
+  } /* if (F) */\r
+#endif /* VERIFY */\r
+}\r
+\r
+#ifdef VERIFY\r
+#ifndef SCHAR_MAX\r
+#define SCHAR_MAX char_max\r
+#endif\r
+#ifndef SCHAR_MIN\r
+#define SCHAR_MIN char_min\r
+#endif\r
+#ifndef UCHAR_MAX\r
+#define UCHAR_MAX char_max\r
+#endif\r
+#endif /* VERIFY */\r
+\r
+#ifndef CHAR_BIT\r
+#define CHAR_BIT  char_bit\r
+#endif\r
+#ifndef CHAR_MAX\r
+#define CHAR_MAX  char_max\r
+#endif\r
+#ifndef CHAR_MIN\r
+#define CHAR_MIN  char_min\r
+#endif\r
+#ifndef SCHAR_MAX\r
+#define SCHAR_MAX char_max\r
+#endif\r
+#ifndef SCHAR_MIN\r
+#define SCHAR_MIN char_min\r
+#endif\r
+#ifndef UCHAR_MAX\r
+#define UCHAR_MAX char_max\r
+#endif\r
+\r
+int cprop( void )\r
+{\r
+  /* Properties of type char */\r
+  Volatile char c, char_max, char_min;\r
+  Volatile int byte_size, c_signed;\r
+  long char_bit;\r
+\r
+  Unexpected(2);\r
+\r
+  /* Calculate number of bits per character *************************/\r
+  c=1; byte_size=0;\r
+  do { c=c<<1; byte_size++; } while(c!=0);\r
+  c= (char)(-1);\r
+  if (((int)c)<0) c_signed=1;\r
+  else c_signed=0;\r
+  Vprintf("%schar = %d bits, %ssigned%s\n",\r
+    co, (int)sizeof(c)*byte_size, (c_signed?"":"un"), oc);\r
+  char_bit=(long)(sizeof(c)*byte_size);\r
+  if (L) i_define(D_CHAR_BIT, "", "CHAR", "_BIT",\r
+      char_bit, 0L, (long) CHAR_BIT, "");\r
+\r
+  c=0; char_max=0;\r
+  c++;\r
+  if (setjmp(lab)==0) { /* Yields char_max */\r
+    while (c>char_max) {\r
+      char_max=c;\r
+      c=(char)(c*2+1);\r
+    }\r
+  } else {\r
+    Vprintf("%sCharacter overflow generates a trap!%s\n", co, oc);\r
+  }\r
+  c=0; char_min=0;\r
+  c--;\r
+  if (c<char_min) /* then the min char < 0 */ {\r
+     /* Minimum value: assume either two's or one's complement *********/\r
+    char_min= -char_max;\r
+    if (setjmp(lab)==0) { /* Yields char_min */\r
+        if (char_min-1 < char_min) char_min--;\r
+    }\r
+  }\r
+  Unexpected(8);\r
+  if (c_signed && char_min == 0) {\r
+    Vprintf("%sBEWARE! Chars are pseudo-unsigned:%s\n", co, oc);\r
+    Vprintf("%s   %s%s%s\n",\r
+      "They contain only nonnegative values, ",\r
+      "but sign extend when used as integers.", co, oc);\r
+  }\r
+  Unexpected(3);\r
+\r
+  if (L) {\r
+    /* Because of the integer promotions, you must use a U after\r
+       the MAX_CHARS in the following cases */\r
+    if ((sizeof(char) == sizeof(int)) && !c_signed) {\r
+      u_define(D_CHAR_MAX, "", "CHAR", "_MAX",\r
+         (ulong) char_max,\r
+         (ulong) CHAR_MAX, "");\r
+    } else {\r
+      i_define(D_CHAR_MAX, "", "CHAR", "_MAX",\r
+         (long) char_max, 0L,\r
+         (long) CHAR_MAX, "");\r
+    }\r
+    i_define(D_CHAR_MIN, "", "CHAR", "_MIN",\r
+       (long) char_min, (long) maxint,\r
+       (long) CHAR_MIN, "");\r
+    if (c_signed) {\r
+      i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",\r
+         (long) char_max, 0L,\r
+         (long) SCHAR_MAX, "");\r
+      i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",\r
+         (long) char_min, (long) maxint,\r
+         (long) SCHAR_MIN, "");\r
+    } else {\r
+      if (sizeof(char) == sizeof(int)) {\r
+        u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",\r
+           (ulong) char_max,\r
+           (ulong) UCHAR_MAX, "");\r
+      } else {\r
+        i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",\r
+           (long) char_max, 0L,\r
+           (long) UCHAR_MAX, "");\r
+      }\r
+    }\r
+\r
+    if (c_signed) {\r
+#ifndef NO_UC\r
+/* Syntax error? Define NO_UC */ Volatile unsigned char c1, char_max;\r
+      c1=0; char_max=0;\r
+      c1++;\r
+      if (setjmp(lab)==0) { /* Yields char_max */\r
+        while (c1>char_max) {\r
+          char_max=c1;\r
+          c1++;\r
+        }\r
+      }\r
+      Unexpected(4);\r
+      if (sizeof(char) == sizeof(int)) {\r
+        u_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",\r
+           (ulong) char_max,\r
+           (ulong) UCHAR_MAX, "");\r
+      } else {\r
+        i_define(D_UCHAR_MAX, "", "UCHAR", "_MAX",\r
+           (long) char_max, 0L,\r
+           (long) UCHAR_MAX, "");\r
+      }\r
+#endif\r
+    } else {\r
+#ifndef NO_SC\r
+/* Syntax error? Define NO_SC */ Volatile signed char c1, char_max, char_min;\r
+      c1=0; char_max=0;\r
+      c1++;\r
+      if (setjmp(lab)==0) { /* Yields char_max */\r
+        while (c1>char_max) {\r
+          char_max=c1;\r
+          c1++;\r
+        }\r
+      }\r
+      c1=0; char_min=0;\r
+      c1--;\r
+      if (setjmp(lab)==0) { /* Yields char_min */\r
+        while (c1<char_min) {\r
+          char_min=c1;\r
+          c1--;\r
+        }\r
+      }\r
+      Unexpected(5);\r
+      i_define(D_SCHAR_MIN, "", "SCHAR", "_MIN",\r
+         (long) char_min, (long) maxint,\r
+         (long) SCHAR_MIN, "");\r
+      i_define(D_SCHAR_MAX, "", "SCHAR", "_MAX",\r
+         (long) char_max, 0L,\r
+         (long) SCHAR_MAX, "");\r
+#endif /* NO_SC */\r
+    }\r
+  }\r
+  return byte_size;\r
+}\r
+\r
+int basic( void )\r
+{\r
+  /* The properties of the basic types.\r
+     Returns number of bits per sizeof unit */\r
+  Volatile int byte_size;\r
+  typedef int function ();\r
+  int variable;\r
+  char *cp; int *ip; function *fp;\r
+  int *p, *q;\r
+\r
+  Vprintf("%sSIZES%s\n", co, oc);\r
+  byte_size= cprop();\r
+\r
+  /* Shorts, ints and longs *****************************************/\r
+  Vprintf("%sshort=%d int=%d long=%d float=%d double=%d bits %s\n",\r
+    co,\r
+    (int) sizeof(short)*byte_size,\r
+    (int) sizeof(int)*byte_size,\r
+    (int) sizeof(long)*byte_size,\r
+    (int) sizeof(float)*byte_size,\r
+    (int) sizeof(double)*byte_size, oc);\r
+  if (stdc) {\r
+    Vprintf("%slong double=%d bits%s\n",\r
+      co, (int) sizeof(Long_double)*byte_size, oc);\r
+  }\r
+  Vprintf("%schar*=%d bits%s%s\n",\r
+    co, (int)sizeof(char *)*byte_size,\r
+    sizeof(char *)>sizeof(int)?" BEWARE! larger than int!":"",\r
+    oc);\r
+  Vprintf("%sint* =%d bits%s%s\n",\r
+    co, (int)sizeof(int *)*byte_size,\r
+    sizeof(int *)>sizeof(int)?" BEWARE! larger than int!":"",\r
+    oc);\r
+  Vprintf("%sfunc*=%d bits%s%s\n",\r
+    co, (int)sizeof(function *)*byte_size,\r
+    sizeof(function *)>sizeof(int)?" BEWARE! larger than int!":"",\r
+    oc);\r
+\r
+  showtype("Type size_t is", sizeof(0));\r
+#ifdef STDC\r
+  showtype("Type wchar_t is", L'x');\r
+#endif\r
+\r
+  /* Alignment constants ********************************************/\r
+\r
+#define alignment(TYPE) \\r
+  ((long)((char *)&((struct{char c; TYPE d;}*)0)->d - (char *)0))\r
+\r
+  Vprintf("\n%sALIGNMENTS%s\n", co, oc);\r
+\r
+  Vprintf("%schar=%ld short=%ld int=%ld long=%ld%s\n",\r
+    co,\r
+    alignment(char), alignment(short),\r
+    alignment(int), alignment(long),\r
+    oc);\r
+\r
+  Vprintf("%sfloat=%ld double=%ld%s\n",\r
+    co,\r
+    alignment(float), alignment(double),\r
+    oc);\r
+\r
+  if (stdc) {\r
+    Vprintf("%slong double=%ld%s\n",\r
+      co,\r
+      alignment(Long_double),\r
+      oc);\r
+  }\r
+  Vprintf("%schar*=%ld int*=%ld func*=%ld%s\n",\r
+    co,\r
+    alignment(char *), alignment(int *), alignment(function *),\r
+    oc);\r
+\r
+  Vprintf("\n");\r
+\r
+  /* Ten little endians *********************************************/\r
+\r
+  endian(byte_size);\r
+\r
+  /* Pointers *******************************************************/\r
+\r
+  Vprintf("\n%sPROPERTIES OF POINTERS%s\n", co, oc);\r
+  cp= (char *) &variable;\r
+  ip= (int *) &variable;\r
+  fp= (function *) &variable;\r
+\r
+  Vprintf("%sChar and int pointer formats ", co);\r
+  if (memeq((char *) &cp, sizeof(cp), (char *) &ip, sizeof(ip))) {\r
+    Vprintf("seem identical%s\n", oc);\r
+  } else {\r
+    Vprintf("are different%s\n", oc);\r
+  }\r
+  Vprintf("%sChar and function pointer formats ", co);\r
+  if (memeq((char *) &cp, sizeof(cp), (char *) &fp, sizeof(fp))) {\r
+    Vprintf("seem identical%s\n", oc);\r
+  } else {\r
+    Vprintf("are different%s\n", oc);\r
+  }\r
+\r
+  if (V) {\r
+    if ((VOID *)"abcd" == (VOID *)"abcd")\r
+      printf("%sStrings are shared%s\n", co, oc);\r
+    else printf("%sStrings are not shared%s\n", co, oc);\r
+  }\r
+\r
+  p=0; q=0;\r
+  showtype("Type ptrdiff_t is", p-q);\r
+\r
+  //if (setjmp(mlab) == 0) {\r
+  //  variable= *p;\r
+  //  Vprintf("%sBEWARE! Dereferencing NULL doesn't cause a trap%s\n",\r
+  //    co, oc);\r
+  //} else {\r
+  //  Vprintf("%sDereferencing NULL causes a trap%s\n", co, oc);\r
+  //}\r
+  if (setjmp(mlab)!=0) croak(-2);\r
+\r
+  Vprintf("\n%sPROPERTIES OF INTEGRAL TYPES%s\n", co, oc);\r
+\r
+  sprop();\r
+  iprop();\r
+  lprop();\r
+  usprop();\r
+  uiprop();\r
+  ulprop();\r
+\r
+  promotions();\r
+\r
+  Unexpected(6);\r
+\r
+  return byte_size;\r
+}\r
+\r
+#else /* not PASS0 */\r
+\r
+#ifdef SEP\r
+/* The global variables used by several passes */\r
+extern jmp_buf lab;\r
+extern int V, L, F, bugs, bits_per_byte;\r
+extern int maxint, flt_radix, flt_rounds;\r
+extern Volatile int trapped;\r
+extern char co[], oc[];\r
+extern char *f_rep();\r
+extern Void trap1();\r
+#endif /* SEP */\r
+#endif /* ifdef PASS0 */\r
+\r
+/* As I said, I apologise for the contortions below. The functions are\r
+   expanded by the preprocessor twice or three times (for float and double,\r
+   and maybe for long double, and for short, int and long). That way,\r
+   I never make a change to one that I forget to make to the other.\r
+   You can look on it as C's fault for not supporting multi-line macros.\r
+   This whole file is read 3 times by the preprocessor, with PASSn set for\r
+   n=1, 2 or 3, to decide which parts to reprocess.\r
+*/\r
+\r
+/* #undef on an already undefined thing is (wrongly) flagged as an error\r
+   by some compilers, therefore the #ifdef that follows:\r
+*/\r
+#ifdef Number\r
+#undef Number\r
+#undef THING\r
+#undef Thing\r
+#undef thing\r
+#undef FPROP\r
+#undef Fname\r
+#undef Store\r
+#undef Sum\r
+#undef Diff\r
+#undef Mul\r
+#undef Div\r
+#undef ZERO\r
+#undef HALF\r
+#undef ONE\r
+#undef TWO\r
+#undef THREE\r
+#undef FOUR\r
+#undef Self\r
+#undef F_check\r
+#undef Verify\r
+#undef EPROP\r
+#undef MARK\r
+\r
+/* These are the float.h constants */\r
+#undef F_RADIX\r
+#undef F_MANT_DIG\r
+#undef F_DIG\r
+#undef F_ROUNDS\r
+#undef F_EPSILON\r
+#undef F_MIN_EXP\r
+#undef F_MIN\r
+#undef F_MIN_10_EXP\r
+#undef F_MAX_EXP\r
+#undef F_MAX\r
+#undef F_MAX_10_EXP\r
+#endif\r
+\r
+#ifdef Integer\r
+#undef Integer\r
+#undef INT\r
+#undef IPROP\r
+#undef Iname\r
+#undef UPROP\r
+#undef Uname\r
+#undef OK_UI\r
+#undef IMARK\r
+\r
+#undef I_MAX\r
+#undef I_MIN\r
+#undef U_MAX\r
+#endif\r
+\r
+#ifdef PASS1\r
+\r
+/* Define the things we're going to use this pass */\r
+\r
+#define Number  float\r
+#define THING "FLOAT"\r
+#define Thing "Float"\r
+#define thing "float"\r
+#define Fname "FLT"\r
+#define FPROP fprop\r
+#define Store fStore\r
+#define Sum fSum\r
+#define Diff  fDiff\r
+#define Mul fMul\r
+#define Div fDiv\r
+#define ZERO  0.0\r
+#define HALF  0.5\r
+#define ONE 1.0\r
+#define TWO 2.0\r
+#define THREE 3.0\r
+#define FOUR  4.0\r
+#define Self  fSelf\r
+#define F_check fCheck\r
+#define MARK  "F"\r
+#ifdef VERIFY\r
+#define Verify fVerify\r
+#endif\r
+\r
+#define EPROP efprop\r
+\r
+#define Integer short\r
+#define INT "short"\r
+#define IPROP sprop\r
+#define Iname "SHRT"\r
+#ifndef NO_UI\r
+#define OK_UI 1\r
+#endif\r
+#define IMARK ""\r
+\r
+#define UPROP usprop\r
+#define Uname "USHRT"\r
+\r
+#ifdef VERIFY\r
+#ifdef SHRT_MAX\r
+#define I_MAX   SHRT_MAX\r
+#endif\r
+#ifdef SHRT_MIN\r
+#define I_MIN   SHRT_MIN\r
+#endif\r
+#ifdef USHRT_MAX\r
+#define U_MAX   USHRT_MAX\r
+#endif\r
+\r
+#ifdef FLT_RADIX\r
+#define F_RADIX   FLT_RADIX\r
+#endif\r
+#ifdef FLT_MANT_DIG\r
+#define F_MANT_DIG  FLT_MANT_DIG\r
+#endif\r
+#ifdef FLT_DIG\r
+#define F_DIG   FLT_DIG\r
+#endif\r
+#ifdef FLT_ROUNDS\r
+#define F_ROUNDS  FLT_ROUNDS\r
+#endif\r
+#ifdef FLT_EPSILON\r
+#define F_EPSILON FLT_EPSILON\r
+#endif\r
+#ifdef FLT_MIN_EXP\r
+#define F_MIN_EXP FLT_MIN_EXP\r
+#endif\r
+#ifdef FLT_MIN\r
+#define F_MIN   FLT_MIN\r
+#endif\r
+#ifdef FLT_MIN_10_EXP\r
+#define F_MIN_10_EXP  FLT_MIN_10_EXP\r
+#endif\r
+#ifdef FLT_MAX_EXP\r
+#define F_MAX_EXP FLT_MAX_EXP\r
+#endif\r
+#ifdef FLT_MAX\r
+#define F_MAX   FLT_MAX\r
+#endif\r
+#ifdef FLT_MAX_10_EXP\r
+#define F_MAX_10_EXP  FLT_MAX_10_EXP\r
+#endif\r
+#endif /* VERIFY */\r
+\r
+#endif /* PASS1 */\r
+\r
+#ifdef PASS2\r
+\r
+#define Number  double\r
+#define THING "DOUBLE"\r
+#define Thing "Double"\r
+#define thing "double"\r
+#define Fname "DBL"\r
+#define FPROP dprop\r
+#define Store dStore\r
+#define Sum dSum\r
+#define Diff  dDiff\r
+#define Mul dMul\r
+#define Div dDiv\r
+#define ZERO  0.0\r
+#define HALF  0.5\r
+#define ONE 1.0\r
+#define TWO 2.0\r
+#define THREE 3.0\r
+#define FOUR  4.0\r
+#define Self  dSelf\r
+#define F_check dCheck\r
+#define MARK  ""\r
+#ifdef VERIFY\r
+#define Verify dVerify\r
+#endif\r
+\r
+#define EPROP edprop\r
+\r
+#define Integer int\r
+#define INT "int"\r
+#define IPROP iprop\r
+#define Iname "INT"\r
+#define OK_UI 1 /* Unsigned int is always possible */\r
+#define IMARK ""\r
+\r
+#define UPROP uiprop\r
+#define Uname "UINT"\r
+\r
+#ifdef VERIFY\r
+#ifdef INT_MAX\r
+#define I_MAX   INT_MAX\r
+#endif\r
+#ifdef INT_MIN\r
+#define I_MIN   INT_MIN\r
+#endif\r
+#ifdef UINT_MAX\r
+#define U_MAX   UINT_MAX\r
+#endif\r
+\r
+#ifdef DBL_MANT_DIG\r
+#define F_MANT_DIG  DBL_MANT_DIG\r
+#endif\r
+#ifdef DBL_DIG\r
+#define F_DIG   DBL_DIG\r
+#endif\r
+#ifdef DBL_EPSILON\r
+#define F_EPSILON DBL_EPSILON\r
+#endif\r
+#ifdef DBL_MIN_EXP\r
+#define F_MIN_EXP DBL_MIN_EXP\r
+#endif\r
+#ifdef DBL_MIN\r
+#define F_MIN   DBL_MIN\r
+#endif\r
+#ifdef DBL_MIN_10_EXP\r
+#define F_MIN_10_EXP  DBL_MIN_10_EXP\r
+#endif\r
+#ifdef DBL_MAX_EXP\r
+#define F_MAX_EXP DBL_MAX_EXP\r
+#endif\r
+#ifdef DBL_MAX\r
+#define F_MAX   DBL_MAX\r
+#endif\r
+#ifdef DBL_MAX_10_EXP\r
+#define F_MAX_10_EXP  DBL_MAX_10_EXP\r
+#endif\r
+#endif /* VERIFY */\r
+\r
+#endif /* PASS2 */\r
+\r
+#ifdef PASS3\r
+\r
+#ifdef STDC\r
+#define Number  long double\r
+\r
+#define ZERO  0.0L\r
+#define HALF  0.5L\r
+#define ONE 1.0L\r
+#define TWO 2.0L\r
+#define THREE 3.0L\r
+#define FOUR  4.0L\r
+#endif\r
+\r
+#define THING "LONG DOUBLE"\r
+#define Thing "Long double"\r
+#define thing "long double"\r
+#define Fname "LDBL"\r
+#define FPROP ldprop\r
+#define Store ldStore\r
+#define Sum ldSum\r
+#define Diff  ldDiff\r
+#define Mul ldMul\r
+#define Div ldDiv\r
+#define Self  ldSelf\r
+#define F_check ldCheck\r
+#define MARK  "L"\r
+#ifdef VERIFY\r
+#define Verify ldVerify\r
+#endif\r
+\r
+#define EPROP eldprop\r
+\r
+#define Integer long\r
+#define INT "long"\r
+#define IPROP lprop\r
+#define Iname "LONG"\r
+#ifndef NO_UI\r
+#define OK_UI 1\r
+#endif\r
+#define IMARK "L"\r
+\r
+#define UPROP ulprop\r
+#define Uname "ULONG"\r
+\r
+#ifdef VERIFY\r
+#ifdef LONG_MAX\r
+#define I_MAX LONG_MAX\r
+#endif\r
+#ifdef LONG_MIN\r
+#define I_MIN LONG_MIN\r
+#endif\r
+#ifdef ULONG_MAX\r
+#define U_MAX ULONG_MAX\r
+#endif\r
+\r
+#ifdef LDBL_MANT_DIG\r
+#define F_MANT_DIG  LDBL_MANT_DIG\r
+#endif\r
+#ifdef LDBL_DIG\r
+#define F_DIG   LDBL_DIG\r
+#endif\r
+#ifdef LDBL_EPSILON\r
+#define F_EPSILON LDBL_EPSILON\r
+#endif\r
+#ifdef LDBL_MIN_EXP\r
+#define F_MIN_EXP LDBL_MIN_EXP\r
+#endif\r
+#ifdef LDBL_MIN\r
+#define F_MIN   LDBL_MIN\r
+#endif\r
+#ifdef LDBL_MIN_10_EXP\r
+#define F_MIN_10_EXP  LDBL_MIN_10_EXP\r
+#endif\r
+#ifdef LDBL_MAX_EXP\r
+#define F_MAX_EXP LDBL_MAX_EXP\r
+#endif\r
+#ifdef LDBL_MAX\r
+#define F_MAX   LDBL_MAX\r
+#endif\r
+#ifdef LDBL_MAX_10_EXP\r
+#define F_MAX_10_EXP  LDBL_MAX_10_EXP\r
+#endif\r
+#endif /* VERIFY */\r
+\r
+#endif /* PASS3 */\r
+\r
+/* The rest of the file gets read all three times;\r
+   the differences are encoded in the things #defined above.\r
+*/\r
+\r
+#ifndef I_MAX\r
+#define I_MAX int_max\r
+#endif\r
+#ifndef I_MIN\r
+#define I_MIN int_min\r
+#endif\r
+#ifndef U_MAX\r
+#define U_MAX u_max\r
+#endif\r
+\r
+#ifndef F_RADIX\r
+#define F_RADIX   f_radix\r
+#endif\r
+#ifndef F_MANT_DIG\r
+#define F_MANT_DIG  f_mant_dig\r
+#endif\r
+#ifndef F_DIG\r
+#define F_DIG   f_dig\r
+#endif\r
+#ifndef F_ROUNDS\r
+#define F_ROUNDS  f_rounds\r
+#endif\r
+#ifndef F_EPSILON\r
+#define F_EPSILON f_epsilon\r
+#endif\r
+#ifndef F_MIN_EXP\r
+#define F_MIN_EXP f_min_exp\r
+#endif\r
+#ifndef F_MIN\r
+#define F_MIN   f_min\r
+#endif\r
+#ifndef F_MIN_10_EXP\r
+#define F_MIN_10_EXP  f_min_10_exp\r
+#endif\r
+#ifndef F_MAX_EXP\r
+#define F_MAX_EXP f_max_exp\r
+#endif\r
+#ifndef F_MAX\r
+#define F_MAX   f_max\r
+#endif\r
+#ifndef F_MAX_10_EXP\r
+#define F_MAX_10_EXP  f_max_10_exp\r
+#endif\r
+\r
+#ifndef VERIFY\r
+#define Verify(prec, val, req, same, same1) {;}\r
+#endif\r
+\r
+#ifdef Integer\r
+\r
+Void IPROP( void )\r
+{\r
+  /* the properties of short, int, and long */\r
+  Volatile Integer newi, int_max, maxeri, int_min, minneri;\r
+  Volatile int ibits, ipower, two=2;\r
+\r
+  /* Calculate max short/int/long ***********************************/\r
+  /* Calculate 2**n-1 until overflow - then use the previous value  */\r
+\r
+  newi=1; int_max=0;\r
+\r
+  if (setjmp(lab)==0) { /* Yields int_max */\r
+    for(ipower=0; newi>int_max; ipower++) {\r
+      int_max=newi;\r
+      newi=newi*two+1;\r
+    }\r
+    Vprintf("%sOverflow of a%s %s does not generate a trap%s\n",\r
+      co, INT[0]=='i'?"n":"", INT, oc);\r
+  } else {\r
+    Vprintf("%sOverflow of a%s %s generates a trap%s\n",\r
+      co, INT[0]=='i'?"n":"", INT, oc);\r
+  }\r
+  Unexpected(7);\r
+\r
+  /* Minimum value: assume either two's or one's complement *********/\r
+  int_min= -int_max;\r
+  if (setjmp(lab)==0) { /* Yields int_min */\r
+    if (int_min-1 < int_min) int_min--;\r
+  }\r
+  Unexpected(8);\r
+\r
+  /* Now for those daft Cybers */\r
+\r
+  maxeri=0; newi=int_max;\r
+\r
+  if (setjmp(lab)==0) { /* Yields maxeri */\r
+    for(ibits=ipower; newi>maxeri; ibits++) {\r
+      maxeri=newi;\r
+      newi=newi+newi+1;\r
+    }\r
+  }\r
+  Unexpected(9);\r
+\r
+  minneri= -maxeri;\r
+  if (setjmp(lab)==0) { /* Yields minneri */\r
+    if (minneri-1 < minneri) minneri--;\r
+  }\r
+  Unexpected(10);\r
+\r
+  Vprintf("%sMaximum %s = %ld (= 2**%d-1)%s\n",\r
+    co, INT, (long)int_max, ipower, oc);\r
+  Vprintf("%sMinimum %s = %ld%s\n", co, INT, (long)int_min, oc);\r
+\r
+  if (L) i_define(D_INT_MAX, INT, Iname, "_MAX",\r
+      (long) int_max, 0L,\r
+      (long) I_MAX, IMARK);\r
+  if (L) i_define(D_INT_MIN, INT, Iname, "_MIN",\r
+      (long) int_min, (long) (PASS==1?maxint:int_max),\r
+      (long) I_MIN, IMARK);\r
+\r
+  if(int_max < 0) { /* It has happened (on a Cray) */\r
+    eek_a_bug("signed integral comparison faulty?");\r
+  }\r
+\r
+  if (maxeri>int_max) {\r
+    Vprintf("%sThere is a larger %s, %ld (= 2**%d-1), %s %s%s\n",\r
+      co, INT, (long)maxeri, ibits,\r
+      "but only for addition, not multiplication",\r
+      "(I smell a Cyber!)",\r
+      oc);\r
+  }\r
+\r
+  if (minneri<int_min) {\r
+    Vprintf("%sThere is a smaller %s, %ld, %s %s%s\n",\r
+      co, INT, (long)minneri,\r
+      "but only for addition, not multiplication",\r
+      "(I smell a Cyber!)",\r
+      oc);\r
+  }\r
+}\r
+\r
+Void UPROP ( void )\r
+{\r
+  /* The properties of unsigned short/int/long */\r
+#ifdef OK_UI\r
+  Volatile unsigned Integer u_max, newi, two;\r
+  newi=1; u_max=0; two=2;\r
+\r
+  if (setjmp(lab)==0) { /* Yields u_max */\r
+    while(newi>u_max) {\r
+      u_max=newi;\r
+      newi=newi*two+1;\r
+    }\r
+  }\r
+  Unexpected(11);\r
+  Vprintf("%sMaximum unsigned %s = %lu%s\n",\r
+    co, INT, (unsigned long) u_max, oc);\r
+\r
+  /* Oh woe: new standard C defines value preserving promotions:\r
+     3.2.1.1: "If an int can represent all values of the original type,\r
+           the value is converted to an int;\r
+         otherwise it is converted to an unsigned int."\r
+  */\r
+  if (L) {\r
+    if (PASS == 1 /* we're dealing with short */\r
+        && u_max <= maxint /* an int can represent all values */\r
+        )\r
+    { /* the value is converted to an int */\r
+      i_define(D_UINT_MAX, INT, Uname, "_MAX",\r
+         (long) u_max, 0L,\r
+         (long) U_MAX, IMARK);\r
+    } else { /* it is converted to an unsigned int */\r
+      u_define(D_UINT_MAX, INT, Uname, "_MAX",\r
+         (unsigned long) u_max,\r
+         (unsigned long) U_MAX, IMARK);\r
+    }\r
+  }\r
+#endif\r
+}\r
+\r
+#endif /* Integer */\r
+\r
+#ifdef Number\r
+\r
+/* The following routines are intended to defeat any attempt at optimisation\r
+   or use of extended precision, and to defeat faulty narrowing casts.\r
+   The weird prototypes are because of widening incompatibilities.\r
+*/\r
+#if defined(STDC) || defined(_MSC_VER)\r
+#define ARGS1(A, a) (A a)\r
+#define ARGS2(A, a, B, b) (A a, B b)\r
+#define ARGS5(A, a, B, b, C, c, D, d, E, e) (A a, B b, C c, D d, E e)\r
+#else\r
+#define ARGS1(A, a) (a) A a;\r
+#define ARGS2(A, a, B, b) (a, b) A a; B b;\r
+#define ARGS5(A, a, B, b, C, c, D, d, E, e) (a,b,c,d,e)A a; B b; C c; D d; E e;\r
+#endif\r
+\r
+Void Store ARGS2(Number, a, Number *, b) { *b=a; }\r
+Number Sum ARGS2(Number, a, Number, b) {Number r; Store(a+b, &r); return r; }\r
+Number Diff ARGS2(Number, a, Number, b){Number r; Store(a-b, &r); return r; }\r
+Number Mul ARGS2(Number, a, Number, b) {Number r; Store(a*b, &r); return r; }\r
+Number Div ARGS2(Number, a, Number, b) {Number r; Store(a/b, &r); return r; }\r
+Number Self ARGS1(Number, a)         {Number r; Store(a,   &r); return r; }\r
+\r
+Void F_check ARGS((int precision, Long_double val1));\r
+\r
+Void F_check(int precision, Long_double val1)\r
+{\r
+  /* You don't think I'm going to go to all the trouble of writing\r
+     a program that works out what all sorts of values are, only to\r
+     have printf go and print the wrong values out, do you?\r
+     No, you're right, so this function tries to see if printf\r
+     has written the right value, by reading it back again.\r
+     This introduces a new problem of course: suppose printf writes\r
+     the correct value, and scanf reads it back wrong... oh well.\r
+     But I'm adamant about this: the precision given is enough\r
+     to uniquely identify the printed number, therefore I insist\r
+     that sscanf read the number back identically. Harsh yes, but\r
+     sometimes you've got to be cruel to be kind.\r
+  */\r
+  Long_double new1, rem;\r
+  Number val, new, diff;\r
+  int e;\r
+  char *rep, *f2;\r
+\r
+  if (sizeof(double) == sizeof(Long_double)) {\r
+    /* Assume they're the same, and use non-stdc format */\r
+    /* This is for stdc compilers using non-stdc libraries */\r
+    f2= "%le";   /* Input */\r
+  } else {\r
+    /* It had better support Le then */\r
+    f2= "%Le";\r
+  }\r
+  val= (Number) val1;\r
+  rep= f_rep(precision, (Long_double) val);\r
+  if (setjmp(lab)==0) {\r
+    sscanf(rep, f2, &new1);\r
+  } else {\r
+    eek_a_bug("sscanf caused a trap");\r
+    printf("%s    scanning: %s format: %s%s\n\n", co, rep, f2, oc);\r
+    Unexpected(12);\r
+    return;\r
+  }\r
+\r
+  if (setjmp(lab)==0) { /* See if new is usable */\r
+    new= new1;\r
+    if (new != 0.0) {\r
+      diff= val/new - 1.0;\r
+      if (diff < 0.1) diff= 1.0;\r
+      /* That should be enough to generate a trap */\r
+    }\r
+  } else {\r
+    eek_a_bug("sscanf returned an unusable number");\r
+    printf("%s    scanning: %s with format: %s%s\n\n",\r
+           co, rep, f2, oc);\r
+    Unexpected(13);\r
+    return;\r
+  }\r
+\r
+  Unexpected(14);\r
+  if (new != val) {\r
+    eek_a_bug("Possibly bad output from printf above");\r
+    if (!exponent((Long_double)val, &rem, &e)) {\r
+      printf("%s    but value was an unusable number%s\n\n",\r
+             co, oc);\r
+      return;\r
+    }\r
+    printf("%s    expected value around ", co);\r
+    //if (sizeof(double) == sizeof(Long_double)) {\r
+      /* Assume they're the same, and use non-stdc format */\r
+      /* This is for stdc compilers using non-stdc libraries */\r
+      //printf("%.*fe%d, bit pattern:\n    ", precision, rem, e);\r
+    //} else {\r
+      /* It had better support Lfe then */\r
+      printf("%.*Lfe%d, bit pattern:\n    ", precision, rem, e);\r
+    //}\r
+    bitpattern((char *) &val, (unsigned)sizeof(val));\r
+    printf ("%s\n", oc);\r
+    printf("%s    sscanf gave           %s, bit pattern:\n    ",\r
+           co, f_rep(precision, (Long_double) new));\r
+    bitpattern((char *) &new, (unsigned)sizeof(new));\r
+    printf ("%s\n", oc);\r
+    if (setjmp(lab) == 0) {\r
+      diff= val-new;\r
+      printf("%s    difference= %s%s\n\n",\r
+             co, f_rep(precision, (Long_double) diff), oc);\r
+    } /* else forget it */\r
+    Unexpected(15);\r
+  }\r
+}\r
+\r
+#ifdef VERIFY\r
+Void Verify ARGS5(int, prec, Number, val, Number, req, int, same, int, same1)\r
+{\r
+  /* Check that the compiler has read a #define value correctly */\r
+  Unexpected(16);\r
+  if (!same) {\r
+    printf("%s*** Verify failed for above #define!\n", co);\r
+    if (setjmp(lab) == 0) { /* for the case that req == nan */\r
+      printf("       Compiler has %s for value\n",\r
+             f_rep(prec, req));\r
+    } else {\r
+      printf("       Compiler has %s for value\n",\r
+             "an unusable number");\r
+    }\r
+    if (setjmp(lab) == 0) {\r
+      F_check(prec, (Long_double) req);\r
+    } /*else forget it*/\r
+    if (setjmp(lab) == 0) {\r
+      if (req > 0.0 && val > 0.0) {\r
+        printf("       difference= %s\n",\r
+               f_rep(prec, val-req));\r
+      }\r
+    } /*else forget it*/\r
+    Unexpected(17);\r
+    printf("%s\n", oc);\r
+    bugs++;\r
+  } else if (!same1) {\r
+    if (stdc) eek_a_bug("constant has the wrong precision");\r
+    else eek_a_bug("the cast didn't work");\r
+    printf("\n");\r
+  }\r
+}\r
+#endif /* VERIFY */\r
+\r
+int FPROP(int byte_size)\r
+{\r
+  /* Properties of floating types, using algorithms by Cody and Waite\r
+     from MA Malcolm, as modified by WM Gentleman and SB Marovich.\r
+     Further extended by S Pemberton.\r
+\r
+     Returns the number of digits in the fraction.\r
+  */\r
+\r
+  Volatile int\r
+    i, f_radix, iexp, irnd, mrnd, f_rounds, f_mant_dig,\r
+    iz, k, inf, machep, f_max_exp, f_min_exp, mx, negeps,\r
+    mantbits, digs, f_dig, trap,\r
+    hidden, normal, f_min_10_exp, f_max_10_exp;\r
+  Volatile Number\r
+    a, b, base, basein, basem1, f_epsilon, epsneg,\r
+    eps, epsp1, etop, ebot,\r
+    f_max, newxmax, f_min, xminner, y, y1, z, z1, z2;\r
+\r
+  Unexpected(18);\r
+\r
+  Vprintf("%sPROPERTIES OF %s%s\n", co, THING, oc);\r
+\r
+  /* Base and size of significand **************************************/\r
+  /* First repeatedly double until adding 1 has no effect.    */\r
+  /* For instance, if base is 10, with 3 significant digits   */\r
+  /* it will try 1, 2, 4, 8, ... 512, 1024, and stop there,   */\r
+  /* since 1024 is only representable as 1020.        */\r
+  a=1.0;\r
+  if (setjmp(lab)==0) { /* inexact trap? */\r
+    do { a=Sum(a, a); }\r
+    while (Diff(Diff(Sum(a, ONE), a), ONE) == ZERO);\r
+  } else {\r
+    fprintf(stderr, "*** Program got loss-of-precision trap!\n");\r
+    /* And supporting those is just TOO much trouble! */\r
+    farewell(bugs+1);\r
+  }\r
+  Unexpected(19);\r
+  /* Now double until you find a number that can be added to the    */\r
+  /* above number. For 1020 this is 8 or 16, depending whether the  */\r
+  /* result is rounded or truncated.          */\r
+  /* In either case the result is 1030. 1030-1020= the base, 10.    */\r
+  b=1.0;\r
+  do { b=Sum(b, b); } while ((base=Diff(Sum(a, b), a)) == ZERO);\r
+  f_radix=base;\r
+  Vprintf("%sBase = %d%s\n", co, f_radix, oc);\r
+\r
+  /* Sanity check; if base<2, I can't guarantee the rest will work  */\r
+  if (f_radix < 2) {\r
+    eek_a_bug("Function return or parameter passing faulty? (This is a guess.)");\r
+    printf("\n");\r
+    return(0);\r
+  }\r
+\r
+  if (PASS == 1) { /* only for FLT */\r
+    flt_radix= f_radix;\r
+    if (F) i_define(D_FLT_RADIX, "", "FLT", "_RADIX",\r
+        (long) f_radix, 0L, (long) F_RADIX, "");\r
+  } else if (f_radix != flt_radix) {\r
+    printf("\n%s*** WARNING: %s %s (%d) %s%s\n",\r
+           co, thing, "arithmetic has a different radix",\r
+           f_radix, "from float", oc);\r
+    bugs++;\r
+  }\r
+\r
+  /* Now the number of digits precision */\r
+  f_mant_dig=0; b=1.0;\r
+  do { f_mant_dig++; b=Mul(b, base); }\r
+  while (Diff(Diff(Sum(b, ONE), b), ONE) == ZERO);\r
+  f_dig=floor_log(10, (Long_double)(b/base)) + (base==10?1:0);\r
+  Vprintf("%sSignificant base digits = %d %s %d %s%s\n",\r
+    co, f_mant_dig, "(= at least", f_dig, "decimal digits)", oc);\r
+  if (F) i_define(D_MANT_DIG, thing, Fname, "_MANT_DIG",\r
+      (long) f_mant_dig, 0L, (long) F_MANT_DIG, "");\r
+  if (F) i_define(D_DIG, thing, Fname, "_DIG",\r
+      (long) f_dig, 0L, (long) F_DIG, "");\r
+  digs= ceil_log(10, (Long_double)b); /* the number of digits to printf */\r
+\r
+  /* Rounding *******************************************************/\r
+  basem1=Diff(base, HALF);\r
+  if (Diff(Sum(a, basem1), a) != ZERO) {\r
+    if (f_radix == 2) basem1=0.375;\r
+    else basem1=1.0;\r
+    if (Diff(Sum(a, basem1), a) != ZERO) irnd=2; /* away from 0 */\r
+    else irnd=1; /* to nearest */\r
+  } else irnd=0; /* towards 0 */\r
+\r
+  basem1=Diff(base, HALF);\r
+\r
+  if (Diff(Diff(-a, basem1), -a) != ZERO) {\r
+    if (f_radix == 2) basem1=0.375;\r
+    else basem1=1.0;\r
+    if (Diff(Diff(-a, basem1), -a) != ZERO) mrnd=2; /* away from 0*/\r
+    else mrnd=1; /* to nearest */\r
+  } else mrnd=0; /* towards 0 */\r
+\r
+  f_rounds= -1; /* Unknown rounding */\r
+  if (irnd==0 && mrnd==0) f_rounds=0; /* zero = chops */\r
+  if (irnd==1 && mrnd==1) f_rounds=1; /* nearest */\r
+  if (irnd==2 && mrnd==0) f_rounds=2; /* +inf */\r
+  if (irnd==0 && mrnd==2) f_rounds=3; /* -inf */\r
+\r
+  if (f_rounds != -1) {\r
+    Vprintf("%sArithmetic rounds towards ", co);\r
+    switch (f_rounds) {\r
+          case 0: Vprintf("zero (i.e. it chops)"); break;\r
+          case 1: Vprintf("nearest"); break;\r
+          case 2: Vprintf("+infinity"); break;\r
+          case 3: Vprintf("-infinity"); break;\r
+          default: Vprintf("???"); break;\r
+    }\r
+    Vprintf("%s\n", oc);\r
+  } else { /* Hmm, try to give some help here */\r
+    Vprintf("%sArithmetic rounds oddly: %s\n", co, oc);\r
+    Vprintf("%s    Negative numbers %s%s\n",\r
+      co, mrnd==0 ? "towards zero" :\r
+          mrnd==1 ? "to nearest" :\r
+              "away from zero",\r
+      oc);\r
+    Vprintf("%s    Positive numbers %s%s\n",\r
+      co, irnd==0 ? "towards zero" :\r
+          irnd==1 ? "to nearest" :\r
+              "away from zero",\r
+      oc);\r
+  }\r
+  /* An extra goody */\r
+  if (f_radix == 2 && f_rounds == 1) {\r
+    if (Diff(Sum(a, ONE), a) != ZERO) {\r
+      Vprintf("%s   Tie breaking rounds up%s\n", co, oc);\r
+    } else if (Diff(Sum(a, THREE), a) == FOUR) {\r
+      Vprintf("%s   Tie breaking rounds to even%s\n", co, oc);\r
+    } else {\r
+      Vprintf("%s   Tie breaking rounds down%s\n", co, oc);\r
+    }\r
+  }\r
+  if (PASS == 1) { /* only for FLT */\r
+    flt_rounds= f_rounds;\r
+    if (F)\r
+      i_define(D_FLT_ROUNDS, "", "FLT", "_ROUNDS",\r
+         (long) f_rounds, 1L, (long) F_ROUNDS, "");\r
+  } else if (f_rounds != flt_rounds) {\r
+    printf("\n%s*** WARNING: %s %s (%d) %s%s\n\n",\r
+           co, thing, "arithmetic rounds differently",\r
+           f_rounds, "from float", oc);\r
+    bugs++;\r
+  }\r
+\r
+  /* Various flavours of epsilon ************************************/\r
+  negeps=f_mant_dig+f_mant_dig;\r
+  basein=1.0/base;\r
+  a=1.0;\r
+  for(i=1; i<=negeps; i++) a*=basein;\r
+\r
+  b=a;\r
+  while (Diff(Diff(ONE, a), ONE) == ZERO) {\r
+    a*=base;\r
+    negeps--;\r
+  }\r
+  negeps= -negeps;\r
+  Vprintf("%sSmallest x such that 1.0-base**x != 1.0 = %d%s\n",\r
+    co, negeps, oc);\r
+\r
+  etop = ONE;\r
+  ebot = ZERO;\r
+  eps = Sum(ebot, Div(Diff(etop, ebot), TWO));\r
+  /* find the smallest epsneg (1-epsneg != 1) by binary search.\r
+     ebot and etop are the current bounds */\r
+  while (eps != ebot && eps != etop) {\r
+    epsp1 = Diff(ONE, eps);\r
+    if (epsp1 < ONE) etop = eps;\r
+    else ebot = eps;\r
+    eps = Sum(ebot, Div(Diff(etop, ebot), TWO));\r
+  }\r
+  eps= etop;\r
+  /* Sanity check */\r
+  if (Diff(ONE, etop) >= ONE || Diff(ONE, ebot) != ONE) {\r
+    eek_a_bug("internal error calculating epsneg");\r
+  }\r
+  Vprintf("%sSmallest x such that 1.0-x != 1.0 = %s%s\n",\r
+    co, f_rep(digs, (Long_double) eps), oc);\r
+  if (V) F_check(digs, (Long_double) eps);\r
+\r
+  epsneg=a;\r
+  if ((f_radix!=2) && irnd) {\r
+  /*  a=(a*(1.0+a))/(1.0+1.0); => */\r
+    a=Div(Mul(a, Sum(ONE, a)), Sum(ONE, ONE));\r
+  /*  if ((1.0-a)-1.0 != 0.0) epsneg=a; => */\r
+    if (Diff(Diff(ONE, a), ONE) != ZERO) epsneg=a;\r
+  }\r
+  /* epsneg is used later */\r
+  Unexpected(20);\r
+\r
+  machep= -f_mant_dig-f_mant_dig;\r
+  a=b;\r
+  while (Diff(Sum(ONE, a), ONE) == ZERO) { a*=base; machep++; }\r
+  Vprintf("%sSmallest x such that 1.0+base**x != 1.0 = %d%s\n",\r
+    co, machep, oc);\r
+\r
+  etop = ONE;\r
+  ebot = ZERO;\r
+  eps = Sum(ebot, Div(Diff(etop, ebot), TWO));\r
+  /* find the smallest eps (1+eps != 1) by binary search.\r
+     ebot and etop are the current bounds */\r
+  while (eps != ebot && eps != etop) {\r
+    epsp1 = Sum(ONE, eps);\r
+    if (epsp1 > ONE) etop = eps;\r
+    else ebot = eps;\r
+    eps = Sum(ebot, Div(Diff(etop, ebot), TWO));\r
+  }\r
+  /* Sanity check */\r
+  if (Sum(ONE, etop) <= ONE || Sum(ONE, ebot) != ONE) {\r
+    eek_a_bug("internal error calculating eps");\r
+  }\r
+  f_epsilon=etop;\r
+\r
+  Vprintf("%sSmallest x such that 1.0+x != 1.0 = %s%s\n",\r
+    co, f_rep(digs, (Long_double) f_epsilon), oc);\r
+\r
+  f_epsilon= Diff(Sum(ONE, f_epsilon), ONE); /* New C standard defn */\r
+  Vprintf("%s(Above number + 1.0) - 1.0 = %s%s\n",\r
+    co, f_rep(digs, (Long_double) (f_epsilon)), oc);\r
+\r
+  /* Possible loss of precision warnings here from non-stdc compilers */\r
+  if (F) f_define(D_EPSILON, thing,\r
+      Fname, "_EPSILON", digs, (Long_double) f_epsilon, MARK);\r
+  if (V || F) F_check(digs, (Long_double) f_epsilon);\r
+  Unexpected(21);\r
+  if (F) Verify(digs, f_epsilon, F_EPSILON,\r
+          f_epsilon == Self(F_EPSILON),\r
+          (Long_double) f_epsilon == (Long_double) F_EPSILON);\r
+  Unexpected(22);\r
+\r
+  /* Extra chop info *************************************************/\r
+  if (f_rounds == 0) {\r
+    if (Diff(Mul(Sum(ONE,f_epsilon),ONE),ONE) !=  ZERO) {\r
+      Vprintf("%sAlthough arithmetic chops, it uses guard digits%s\n", co, oc);\r
+    }\r
+  }\r
+\r
+  /* Size of and minimum normalised exponent ************************/\r
+  y=0; i=0; k=1; z=basein; z1=(1.0+f_epsilon)/base;\r
+\r
+  /* Coarse search for the largest power of two */\r
+  if (setjmp(lab)==0) { /* for underflow trap */ /* Yields i, k, y, y1 */\r
+    do {\r
+      y=z; y1=z1;\r
+      z=Mul(y,y); z1=Mul(z1, y);\r
+      a=Mul(z,ONE);\r
+      z2=Div(z1,y);\r
+      if (z2 != y1) break;\r
+      if ((Sum(a,a) == ZERO) || (fabs(z) >= y)) break;\r
+      i++;\r
+      k+=k;\r
+    } while(1);\r
+  } else {\r
+    Vprintf("%s%s underflow generates a trap%s\n", co, Thing, oc);\r
+  }\r
+  Unexpected(23);\r
+\r
+  if (f_radix != 10) {\r
+    iexp=i+1; /* for the sign */\r
+    mx=k+k;\r
+  } else {\r
+    iexp=2;\r
+    iz=f_radix;\r
+    while (k >= iz) { iz*=f_radix; iexp++; }\r
+    mx=iz+iz-1;\r
+  }\r
+\r
+  /* Fine tune starting with y and y1 */\r
+  if (setjmp(lab)==0) { /* for underflow trap */ /* Yields k, f_min */\r
+    do {\r
+      f_min=y; z1=y1;\r
+      y=Div(y,base); y1=Div(y1,base);\r
+      a=Mul(y,ONE);\r
+      z2=Mul(y1,base);\r
+      if (z2 != z1) break;\r
+      if ((Sum(a,a) == ZERO) || (fabs(y) >= f_min)) break;\r
+      k++;\r
+    } while (1);\r
+  }\r
+  Unexpected(24);\r
+\r
+  f_min_exp=(-k)+1;\r
+\r
+  if ((mx <= k+k-3) && (f_radix != 10)) { mx+=mx; iexp+=1; }\r
+  Vprintf("%sNumber of bits used for exponent = %d%s\n", co, iexp, oc);\r
+  Vprintf("%sMinimum normalised exponent = %d%s\n", co, f_min_exp-1, oc);\r
+  if (F)\r
+    i_define(D_MIN_EXP, thing, Fname, "_MIN_EXP",\r
+       (long) f_min_exp, (long) maxint, (long) F_MIN_EXP, "");\r
+\r
+  if (setjmp(lab)==0) {\r
+    Vprintf("%sMinimum normalised positive number = %s%s\n",\r
+      co, f_rep(digs, (Long_double) f_min), oc);\r
+  } else {\r
+    eek_a_bug("printf can't print the smallest normalised number");\r
+    printf("\n");\r
+  }\r
+  Unexpected(25);\r
+  /* Possible loss of precision warnings here from non-stdc compilers */\r
+  if (setjmp(lab) == 0) {\r
+    if (F) f_define(D_MIN, thing,\r
+        Fname, "_MIN", digs, (Long_double) f_min, MARK);\r
+    if (V || F) F_check(digs, (Long_double) f_min);\r
+  } else {\r
+    eek_a_bug("xxx_MIN caused a trap");\r
+    printf("\n");\r
+  }\r
+\r
+  if (setjmp(lab) == 0) {\r
+    if (F) Verify(digs, f_min, F_MIN,\r
+            f_min == Self(F_MIN),\r
+            (Long_double) f_min == (Long_double) F_MIN);\r
+  } else {\r
+    printf("%s*** Verify failed for above #define!\n    %s %s\n\n",\r
+           co, "Compiler has an unusable number for value", oc);\r
+    bugs++;\r
+  }\r
+  Unexpected(26);\r
+\r
+  a=1.0; f_min_10_exp=0;\r
+  while (a > f_min*10.0) { a/=10.0; f_min_10_exp--; }\r
+  if (F) i_define(D_MIN_10_EXP, thing, Fname, "_MIN_10_EXP",\r
+      (long) f_min_10_exp, (long) maxint,\r
+      (long) F_MIN_10_EXP, "");\r
+\r
+  /* Minimum exponent ************************************************/\r
+  if (setjmp(lab)==0) { /* for underflow trap */ /* Yields xminner */\r
+    do {\r
+      xminner=y;\r
+      y=Div(y,base);\r
+      a=Mul(y,ONE);\r
+      if ((Sum(a,a) == ZERO) || (fabs(y) >= xminner)) break;\r
+    } while (1);\r
+  }\r
+  Unexpected(27);\r
+\r
+  if (xminner != 0.0 && xminner != f_min) {\r
+    normal= 0;\r
+    Vprintf("%sThe smallest numbers are not kept normalised%s\n",\r
+      co, oc);\r
+    if (setjmp(lab)==0) {\r
+        Vprintf("%sSmallest unnormalised positive number = %s%s\n",\r
+          co, f_rep(digs, (Long_double) xminner), oc);\r
+        if (V) F_check(digs, (Long_double) xminner);\r
+    } else {\r
+      eek_a_bug("printf can't print the smallest unnormalised number.");\r
+      printf("\n");\r
+    }\r
+    Unexpected(28);\r
+  } else {\r
+    normal= 1;\r
+    Vprintf("%sThe smallest numbers are normalised%s\n", co, oc);\r
+  }\r
+\r
+  /* Maximum exponent ************************************************/\r
+  f_max_exp=2; f_max=1.0; newxmax=base+1.0;\r
+  inf=0; trap=0;\r
+  while (f_max<newxmax) {\r
+    f_max=newxmax;\r
+    if (setjmp(lab) == 0) { /* Yields inf, f_max_exp */\r
+      newxmax=Mul(newxmax, base);\r
+    } else {\r
+      trap=1;\r
+      break;\r
+    }\r
+    if (Div(newxmax, base) != f_max) {\r
+      if (newxmax > f_max) inf=1; /* ieee infinity */\r
+      break;\r
+    }\r
+    f_max_exp++;\r
+  }\r
+  Unexpected(29);\r
+  Vprintf("%sMaximum exponent = %d%s\n", co, f_max_exp, oc);\r
+  if (F) i_define(D_MAX_EXP, thing, Fname, "_MAX_EXP",\r
+      (long) f_max_exp, 0L, (long) F_MAX_EXP, "");\r
+\r
+  /* Largest number ***************************************************/\r
+  f_max=Diff(ONE, epsneg);\r
+  if (Mul(f_max,ONE) != f_max) f_max=Diff(ONE, Mul(base,epsneg));\r
+  for (i=1; i<=f_max_exp; i++) f_max=Mul(f_max, base);\r
+\r
+  if (setjmp(lab)==0) {\r
+    Vprintf("%sMaximum number = %s%s\n",\r
+      co, f_rep(digs, (Long_double) f_max), oc);\r
+  } else {\r
+    eek_a_bug("printf can't print the largest double.");\r
+    printf("\n");\r
+  }\r
+  if (setjmp(lab)==0) {\r
+  /* Possible loss of precision warnings here from non-stdc compilers */\r
+    if (F) f_define(D_MAX, thing,\r
+        Fname, "_MAX", digs, (Long_double) f_max, MARK);\r
+    if (V || F) F_check(digs, (Long_double) f_max);\r
+  } else {\r
+    eek_a_bug("xxx_MAX caused a trap");\r
+    printf("\n");\r
+  }\r
+  if (setjmp(lab)==0) {\r
+    if (F) Verify(digs, f_max, F_MAX,\r
+            f_max == Self(F_MAX),\r
+            (Long_double) f_max == (Long_double) F_MAX);\r
+  } else {\r
+    printf("%s*** Verify failed for above #define!\n    %s %s\n\n",\r
+           co, "Compiler has an unusable number for value", oc);\r
+    bugs++;\r
+  }\r
+  Unexpected(30);\r
+\r
+  a=1.0; f_max_10_exp=0;\r
+  while (a < f_max/10.0) { a*=10.0; f_max_10_exp++; }\r
+  if (F) i_define(D_MAX_10_EXP, thing, Fname, "_MAX_10_EXP",\r
+      (long) f_max_10_exp, 0L, (long) F_MAX_10_EXP, "");\r
+\r
+  /* Traps and infinities ********************************************/\r
+  if (trap) {\r
+    Vprintf("%sOverflow generates a trap%s\n", co, oc);\r
+  } else {\r
+    Vprintf("%sOverflow doesn't seem to generate a trap%s\n",\r
+      co, oc);\r
+  }\r
+\r
+  if (inf) { Vprintf("%sThere is an 'infinite' value%s\n", co, oc); }\r
+\r
+#ifdef SIGFPE\r
+  signal(SIGFPE, trap1);\r
+#endif\r
+  if (setjmp(lab) == 0) {\r
+    trapped= 0; /* A global variable */\r
+    b= 0.0;\r
+    a= (1.0/b)/b;\r
+    if (!trapped) {\r
+      Vprintf("%sDivide by zero doesn't generate a trap%s\n",\r
+        co, oc);\r
+    } else {\r
+      Vprintf("%sDivide by zero generates a trap%s\n",\r
+        co, oc);\r
+      Vprintf("%sFP signal handlers return safely%s\n",\r
+        co, oc);\r
+    }\r
+  } else {\r
+    Vprintf("%sDivide by zero generates a trap%s\n", co, oc);\r
+    Vprintf("%sBEWARE! FP signal handlers can NOT return%s\n",\r
+      co, oc);\r
+  }\r
+  setsignals();\r
+  Unexpected(31);\r
+\r
+  /* Hidden bit + sanity check ****************************************/\r
+  if (f_radix != 10) {\r
+    hidden=0;\r
+    mantbits=floor_log(2, (Long_double)f_radix)*f_mant_dig;\r
+    if (mantbits+iexp == (int)sizeof(Number)*byte_size) {\r
+      hidden=1;\r
+      Vprintf("%sArithmetic uses a hidden bit%s\n", co, oc);\r
+    } else if (mantbits+iexp+1 == (int)sizeof(Number)*byte_size) {\r
+      Vprintf("%sArithmetic doesn't use a hidden bit%s\n",\r
+        co, oc);\r
+    } else if (mantbits+iexp+1 < (int)sizeof(Number)*byte_size) {\r
+      Vprintf("%sOnly %d of the %d bits of a %s %s%s\n",\r
+        co,\r
+        mantbits+iexp,\r
+        (int)sizeof(Number)*byte_size,\r
+        thing,\r
+        "are actually used",\r
+        oc);\r
+    } else {\r
+      printf("\n%s%s\n    %s (%d) %s (%d) %s %s (%d)!%s\n\n",\r
+             co,\r
+             "*** Something fishy here!",\r
+             "Exponent size",\r
+             iexp,\r
+             "+ significand size",\r
+             mantbits,\r
+             "doesn't match with the size of a",\r
+             thing,\r
+             (int)sizeof(Number)*byte_size,\r
+             oc);\r
+    }\r
+    if (hidden && f_radix == 2 && f_max_exp+f_min_exp==3) {\r
+      Vprintf("%sIt looks like %s length IEEE format%s\n",\r
+        co, f_mant_dig==24 ? "single" :\r
+            f_mant_dig==53 ? "double" :\r
+            f_mant_dig >53 ? "extended" :\r
+            "some", oc);\r
+      if (f_rounds != 1 || normal) {\r
+        Vprintf("%s   though ", co);\r
+        if (f_rounds != 1) {\r
+          Vprintf("the rounding is unusual");\r
+          if (normal) { Vprintf(" and "); }\r
+        }\r
+        if (normal) {\r
+            Vprintf("the normalisation is unusual");\r
+        }\r
+        Vprintf("%s\n", oc);\r
+      }\r
+    } else {\r
+      Vprintf("%sIt doesn't look like IEEE format%s\n",\r
+        co, oc);\r
+    }\r
+  }\r
+  printf("\n"); /* regardless of verbosity */\r
+  return f_mant_dig;\r
+}\r
+\r
+Void EPROP(int fprec, int dprec, int lprec)\r
+{\r
+  /* See if expressions are evaluated in extended precision.\r
+     Some compilers optimise even if you don't want it,\r
+     and then this function fails to produce the right result.\r
+     We try to diagnose this if it happens.\r
+  */\r
+  Volatile int eprec;\r
+  Volatile double a, b, base, old;\r
+  Volatile Number d, oldd, dbase, one, zero;\r
+  Volatile int bad=0;\r
+\r
+  /* Size of significand **************************************/\r
+  a=1.0;\r
+  if (setjmp(lab) == 0) { /* Yields nothing */\r
+    do { old=a; a=a+a; }\r
+    while ((((a+1.0)-a)-1.0) == 0.0 && a>old);\r
+  } else bad=1;\r
+  if (!bad && a <= old) bad=1;\r
+\r
+  if (!bad) {\r
+    b=1.0;\r
+    if (setjmp(lab) == 0) { /* Yields nothing */\r
+      do { old=b; b=b+b; }\r
+      while ((base=((a+b)-a)) == 0.0 && b>old);\r
+      if (b <= old) bad=1;\r
+    } else bad=1;\r
+  }\r
+\r
+  if (!bad) {\r
+    eprec=0; d=1.0; dbase=base; one=1.0; zero=0.0;\r
+    if (setjmp(lab) == 0) { /* Yields nothing */\r
+      do { eprec++; oldd=d; d=d*dbase; }\r
+      while ((((d+one)-d)-one) == zero && d>oldd);\r
+      if (d <= oldd) bad=1;\r
+    } else bad=1;\r
+  }\r
+\r
+  Unexpected(32);\r
+\r
+  if (bad) {\r
+    Vprintf("%sCan't determine precision for %s expressions:\n%s%s\n",\r
+     co, thing, "   check that you compiled without optimisation!",\r
+     oc);\r
+  } else if (eprec==dprec) {\r
+    Vprintf("%s%s expressions are evaluated in double precision%s\n",\r
+      co, Thing, oc);\r
+  } else if (eprec==fprec) {\r
+    Vprintf("%s%s expressions are evaluated in float precision%s\n",\r
+      co, Thing, oc);\r
+  } else if (eprec==lprec) {\r
+    Vprintf("%s%s expressions are evaluated in long double precision%s\n",\r
+      co, Thing, oc);\r
+  } else {\r
+    Vprintf("%s%s expressions are evaluated in a %s %s %d %s%s\n",\r
+      co, Thing, eprec>dprec ? "higher" : "lower",\r
+      "precision than double,\n   using",\r
+      eprec, "base digits",\r
+      oc);\r
+  }\r
+}\r
+\r
+#else /* not Number */\r
+\r
+#ifdef FPROP /* Then create dummy routines for long double */\r
+/* ARGSUSED */\r
+int FPROP(int byte_size) { return 0; }\r
+#endif\r
+#ifdef EPROP\r
+/* ARGSUSED */\r
+Void EPROP(int fprec, int dprec, int lprec) {}\r
+#endif\r
+\r
+#endif /* ifdef Number */\r
+\r
+/* Increment the pass number */\r
+#undef PASS\r
+\r
+#ifdef PASS2\r
+#undef PASS2\r
+#define PASS 3\r
+#define PASS3 1\r
+#endif\r
+\r
+#ifdef PASS1\r
+#undef PASS1\r
+#define PASS 2\r
+#define PASS2 1\r
+#endif\r
+\r
+#ifdef PASS0\r
+#undef PASS0\r
+#endif\r
+\r
+#ifndef SEP\r
+#ifdef PASS /* then rescan this file */\r
+#ifdef BAD_CPP\r
+#include "enquire.c"\r
+#else\r
+#include FILENAME  /* if this line fails to compile, define BAD_CPP */\r
+#endif\r
+#endif /* PASS */\r
+#endif /* SEP */\r
diff --git a/AppPkg/Applications/Enquire/Enquire.inf b/AppPkg/Applications/Enquire/Enquire.inf
new file mode 100644 (file)
index 0000000..b0a0a29
--- /dev/null
@@ -0,0 +1,53 @@
+## @file\r
+#  Enquire application for system integer and floating point characteristics\r
+#  enquiry.\r
+#\r
+#   Due to the level of hardware introspection, this application MUST be built\r
+#   with optimizations disabled.\r
+#\r
+# COPYRIGHT(c) 1993-9 Steven Pemberton, CWI. All rights reserved.\r
+# NOTE: Improvements gratefully received. Please mention the version.\r
+#       "http://www.cwi.nl/~steven/enquire.html"\r
+#\r
+#  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+#  This program and the accompanying materials\r
+#  are licensed and made available under the terms and conditions of the BSD License\r
+#  which accompanies this distribution. The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.\r
+#\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+##\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010006\r
+  BASE_NAME                      = Enquire\r
+  FILE_GUID                      = 42f58b27-5dc3-4fa7-844d-5a7dbff06432\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 0.1\r
+  ENTRY_POINT                    = ShellCEntryLib\r
+\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF\r
+#\r
+\r
+[Sources]\r
+  Enquire.c\r
+\r
+[Packages]\r
+  StdLib/StdLib.dec\r
+  MdePkg/MdePkg.dec\r
+\r
+[LibraryClasses]\r
+  UefiLib\r
+  LibC\r
+  LibString\r
+  LibStdio\r
+  LibGdtoa\r
+  LibWchar\r
+\r
+[BuildOptions]\r
+  INTEL:*_*_*_CC_FLAGS    = /Qdiag-disable:181,186\r
+   MSFT:*_*_*_CC_FLAGS    = /Od\r
+    GCC:*_*_*_CC_FLAGS    = -O0 -Wno-unused-variable\r
diff --git a/AppPkg/Applications/Hello/Hello.c b/AppPkg/Applications/Hello/Hello.c
new file mode 100644 (file)
index 0000000..a16b276
--- /dev/null
@@ -0,0 +1,37 @@
+/** @file\r
+    A simple, basic, EDK II native, "hello" application to verify that\r
+    we can build applications without LibC.\r
+\r
+    Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+    This program and the accompanying materials\r
+    are licensed and made available under the terms and conditions of the BSD License\r
+    which accompanies this distribution. The full text of the license may be found at\r
+    http://opensource.org/licenses/bsd-license.\r
+\r
+    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+**/\r
+#include  <Uefi.h>\r
+#include  <Library/UefiLib.h>\r
+#include  <Library/ShellCEntryLib.h>\r
+\r
+/***\r
+  Print a welcoming message.\r
+\r
+  Establishes the main structure of the application.\r
+\r
+  @retval  0         The application exited normally.\r
+  @retval  Other     An error occurred.\r
+***/\r
+INTN\r
+EFIAPI\r
+ShellAppMain (\r
+  IN UINTN Argc,\r
+  IN CHAR16 **Argv\r
+  )\r
+{\r
+  Print(L"Hello there fellow Programmer.\n");\r
+  Print(L"Welcome to the world of EDK II.\n");\r
+\r
+  return(0);\r
+}\r
diff --git a/AppPkg/Applications/Hello/Hello.inf b/AppPkg/Applications/Hello/Hello.inf
new file mode 100644 (file)
index 0000000..739478b
--- /dev/null
@@ -0,0 +1,36 @@
+## @file\r
+#  A simple, basic, EDK II native, "hello" application.\r
+#\r
+#   Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+#   This program and the accompanying materials\r
+#   are licensed and made available under the terms and conditions of the BSD License\r
+#   which accompanies this distribution. The full text of the license may be found at\r
+#   http://opensource.org/licenses/bsd-license.\r
+#\r
+#   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+##\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010006\r
+  BASE_NAME                      = Hello\r
+  FILE_GUID                      = a912f198-7f0e-4803-b908-b757b806ec83\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 0.1\r
+  ENTRY_POINT                    = ShellCEntryLib\r
+\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF\r
+#\r
+\r
+[Sources]\r
+  Hello.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  ShellPkg/ShellPkg.dec\r
+\r
+[LibraryClasses]\r
+  UefiLib\r
+  ShellCEntryLib\r
diff --git a/AppPkg/Applications/Main/Main.c b/AppPkg/Applications/Main/Main.c
new file mode 100644 (file)
index 0000000..c2762d5
--- /dev/null
@@ -0,0 +1,46 @@
+/** @file\r
+    A simple, basic, application showing how the Hello application could be\r
+    built using the "Standard C Libraries" from StdLib.\r
+\r
+    Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+    This program and the accompanying materials\r
+    are licensed and made available under the terms and conditions of the BSD License\r
+    which accompanies this distribution. The full text of the license may be found at\r
+    http://opensource.org/licenses/bsd-license.\r
+\r
+    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+**/\r
+//#include  <Uefi.h>\r
+//#include  <Library/UefiLib.h>\r
+//#include  <Library/ShellCEntryLib.h>\r
+\r
+#include  <stdio.h>\r
+\r
+/***\r
+  Demonstrates basic workings of the main() function by displaying a\r
+  welcoming message.\r
+\r
+  Note that the UEFI command line is composed of 16-bit UCS2 wide characters.\r
+  The easiest way to access the command line parameters is to cast Argv as:\r
+      wchar_t **wArgv = (wchar_t **)Argv;\r
+\r
+  @param[in]  Argc    Number of argument tokens pointed to by Argv.\r
+  @param[in]  Argv    Array of Argc pointers to command line tokens.\r
+\r
+  @retval  0         The application exited normally.\r
+  @retval  Other     An error occurred.\r
+***/\r
+int\r
+EFIAPI\r
+main (\r
+  IN int Argc,\r
+  IN char **Argv\r
+  )\r
+{\r
+\r
+  puts("Hello there fellow Programmer.");\r
+  puts("Welcome to the world of EDK II.");\r
+\r
+  return 0;\r
+}\r
diff --git a/AppPkg/Applications/Main/Main.inf b/AppPkg/Applications/Main/Main.inf
new file mode 100644 (file)
index 0000000..750cf55
--- /dev/null
@@ -0,0 +1,42 @@
+## @file\r
+#   A simple, basic, application showing how the Hello application could be\r
+#   built using the "Standard C Libraries" from StdLib.\r
+#\r
+#  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+#  This program and the accompanying materials\r
+#  are licensed and made available under the terms and conditions of the BSD License\r
+#  which accompanies this distribution. The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.\r
+#\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+##\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010006\r
+  BASE_NAME                      = Main\r
+  FILE_GUID                      = 4ea97c46-7491-4dfd-b442-747010f3ce5f\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 0.1\r
+  ENTRY_POINT                    = ShellCEntryLib\r
+\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF\r
+#\r
+\r
+[Sources]\r
+  Main.c\r
+\r
+[Packages]\r
+  StdLib/StdLib.dec\r
+  MdePkg/MdePkg.dec\r
+  ShellPkg/ShellPkg.dec\r
+\r
+[LibraryClasses]\r
+  LibC\r
+  LibStdio\r
+#  UefiLib\r
+#  ShellCEntryLib\r
+\r
+[BuildOptions]\r
+  MSFT:*_*_IA32_CC_FLAGS  = /Oi-\r
diff --git a/AppPkg/ReadMe.pdf b/AppPkg/ReadMe.pdf
new file mode 100644 (file)
index 0000000..2baca31
Binary files /dev/null and b/AppPkg/ReadMe.pdf differ
diff --git a/StdLib/Include/Arm/machine/_math.h b/StdLib/Include/Arm/machine/_math.h
new file mode 100644 (file)
index 0000000..67cf98c
--- /dev/null
@@ -0,0 +1,18 @@
+/**\r
+\r
+Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials are licensed and made available under\r
+the terms and conditions of the BSD License that accompanies this distribution.\r
+The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php.\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+#ifndef _MACHINE_MATH_H\r
+#define _MACHINE_MATH_H\r
+\r
+//#define __HUGE_VAL  ???????????.?????????????\r
+\r
+#endif    /* _MACHINE_MATH_H */\r
diff --git a/StdLib/Include/Arm/machine/ansi.h b/StdLib/Include/Arm/machine/ansi.h
new file mode 100644 (file)
index 0000000..e06f111
--- /dev/null
@@ -0,0 +1,106 @@
+/*     $NetBSD: ansi.h,v 1.7 2006/10/04 13:51:59 tnozaki Exp $ */\r
+\r
+/*\r
+ * Copyright (c) 1990, 1993\r
+ *     The Regents of the University of California.  All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the University nor the names of its contributors\r
+ *    may be used to endorse or promote products derived from this software\r
+ *    without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ *     from: @(#)ansi.h        8.2 (Berkeley) 1/4/94\r
+ */\r
+\r
+#ifndef        _ANSI_H_\r
+#define        _ANSI_H_\r
+\r
+#include <sys/cdefs.h>\r
+\r
+#include <machine/int_types.h>\r
+\r
+/*\r
+ * Types which are fundamental to the implementation and may appear in\r
+ * more than one standard header are defined here.  Standard headers\r
+ * then use:\r
+ *     #ifdef  _BSD_SIZE_T_\r
+ *     typedef _BSD_SIZE_T_ size_t;\r
+ *     #undef  _BSD_SIZE_T_\r
+ *     #endif\r
+ */\r
+#ifdef __ELF__\r
+#define        _BSD_CLOCK_T_           unsigned int    /* clock() */\r
+#define        _BSD_PTRDIFF_T_         long int        /* ptr1 - ptr2 */\r
+#define        _BSD_SIZE_T_            unsigned long int /* sizeof() */\r
+#define        _BSD_SSIZE_T_           long int        /* byte count or error */\r
+#define        _BSD_TIME_T_            int             /* time() */\r
+#else\r
+#define        _BSD_CLOCK_T_           unsigned long   /* clock() */\r
+#define        _BSD_PTRDIFF_T_         int             /* ptr1 - ptr2 */\r
+#define        _BSD_SIZE_T_            unsigned int    /* sizeof() */\r
+#define        _BSD_SSIZE_T_           int             /* byte count or error */\r
+#define        _BSD_TIME_T_            long            /* time() */\r
+#endif\r
+#if __GNUC_PREREQ__(2, 96)\r
+#define        _BSD_VA_LIST_           __builtin_va_list /* GCC built-in type */\r
+#else\r
+#define        _BSD_VA_LIST_           char *          /* va_list */\r
+#endif\r
+#define        _BSD_CLOCKID_T_         int             /* clockid_t */\r
+#define        _BSD_TIMER_T_           int             /* timer_t */\r
+#define        _BSD_SUSECONDS_T_       int             /* suseconds_t */\r
+#define        _BSD_USECONDS_T_        unsigned int    /* useconds_t */\r
+\r
+/*\r
+ * NOTE: rune_t is not covered by ANSI nor other standards, and should not\r
+ * be instantiated outside of lib/libc/locale.  use wchar_t.\r
+ *\r
+ * Runes (wchar_t) is declared to be an ``int'' instead of the more natural\r
+ * ``unsigned long'' or ``long''.  Two things are happening here.  It is not\r
+ * unsigned so that EOF (-1) can be naturally assigned to it and used.  Also,\r
+ * it looks like 10646 will be a 31 bit standard.  This means that if your\r
+ * ints cannot hold 32 bits, you will be in trouble.  The reason an int was\r
+ * chosen over a long is that the is*() and to*() routines take ints (says\r
+ * ANSI C), but they use _RUNE_T_ instead of int.  By changing it here, you\r
+ * lose a bit of ANSI conformance, but your programs will still work.\r
+ *    \r
+ * Note that _WCHAR_T_ and _RUNE_T_ must be of the same type.  When wchar_t\r
+ * and rune_t are typedef'd, _WCHAR_T_ will be undef'd, but _RUNE_T remains\r
+ * defined for ctype.h.\r
+ */\r
+#define        _BSD_WCHAR_T_           int             /* wchar_t */\r
+#define        _BSD_WINT_T_            int             /* wint_t */\r
+#define        _BSD_RUNE_T_            int             /* rune_t */\r
+#define _BSD_WCTRANS_T_                void *          /* wctrans_t */\r
+#define _BSD_WCTYPE_T_         void *          /* wctype_t */\r
+\r
+/*\r
+ * mbstate_t is an opaque object to keep conversion state, during multibyte\r
+ * stream conversions.  The content must not be referenced by user programs.\r
+ */\r
+typedef union {\r
+       __int64_t __mbstateL;   /* for alignment */\r
+       char __mbstate8[128];\r
+} __mbstate_t;\r
+#define        _BSD_MBSTATE_T_         __mbstate_t     /* mbstate_t */\r
+\r
+#endif /* _ANSI_H_ */\r
diff --git a/StdLib/Include/Arm/machine/asm.h b/StdLib/Include/Arm/machine/asm.h
new file mode 100644 (file)
index 0000000..b15698e
--- /dev/null
@@ -0,0 +1,167 @@
+/*     $NetBSD: asm.h,v 1.8 2006/01/20 22:02:40 christos Exp $ */\r
+\r
+/*\r
+ * Copyright (c) 1990 The Regents of the University of California.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to Berkeley by\r
+ * William Jolitz.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the University nor the names of its contributors\r
+ *    may be used to endorse or promote products derived from this software\r
+ *    without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ *     from: @(#)asm.h 5.5 (Berkeley) 5/7/91\r
+ */\r
+\r
+#ifndef _ARM32_ASM_H_\r
+#define _ARM32_ASM_H_\r
+\r
+#ifdef __ELF__\r
+# define _C_LABEL(x)   x\r
+#else\r
+# ifdef __STDC__\r
+#  define _C_LABEL(x)  _ ## x\r
+# else\r
+#  define _C_LABEL(x)  _/**/x\r
+# endif\r
+#endif\r
+#define        _ASM_LABEL(x)   x\r
+\r
+#ifdef __STDC__\r
+# define __CONCAT(x,y) x ## y\r
+# define __STRING(x)   #x\r
+#else\r
+# define __CONCAT(x,y) x/**/y\r
+# define __STRING(x)   "x"\r
+#endif\r
+\r
+#ifndef _ALIGN_TEXT\r
+# define _ALIGN_TEXT .align 0\r
+#endif\r
+\r
+/*\r
+ * gas/arm uses @ as a single comment character and thus cannot be used here\r
+ * Instead it recognised the # instead of an @ symbols in .type directives\r
+ * We define a couple of macros so that assembly code will not be dependant\r
+ * on one or the other.\r
+ */\r
+#define _ASM_TYPE_FUNCTION     #function\r
+#define _ASM_TYPE_OBJECT       #object\r
+#define _ENTRY(x) \\r
+       .text; _ALIGN_TEXT; .globl x; .type x,_ASM_TYPE_FUNCTION; x:\r
+\r
+#ifdef GPROF\r
+# ifdef __ELF__\r
+#  define _PROF_PROLOGUE       \\r
+       mov ip, lr; bl __mcount\r
+# else\r
+#  define _PROF_PROLOGUE       \\r
+       mov ip,lr; bl mcount\r
+# endif\r
+#else\r
+# define _PROF_PROLOGUE\r
+#endif\r
+\r
+#define        ENTRY(y)        _ENTRY(_C_LABEL(y)); _PROF_PROLOGUE\r
+#define        ENTRY_NP(y)     _ENTRY(_C_LABEL(y))\r
+#define        ASENTRY(y)      _ENTRY(_ASM_LABEL(y)); _PROF_PROLOGUE\r
+#define        ASENTRY_NP(y)   _ENTRY(_ASM_LABEL(y))\r
+\r
+#define        ASMSTR          .asciz\r
+\r
+#if defined(__ELF__) && defined(PIC)\r
+#ifdef __STDC__\r
+#define        PIC_SYM(x,y)    x ## ( ## y ## )\r
+#else\r
+#define        PIC_SYM(x,y)    x/**/(/**/y/**/)\r
+#endif\r
+#else\r
+#define        PIC_SYM(x,y)    x\r
+#endif\r
+\r
+#ifdef __ELF__\r
+#define RCSID(x)       .section ".ident"; .asciz x\r
+#else\r
+#define RCSID(x)       .text; .asciz x\r
+#endif\r
+\r
+#ifdef __ELF__\r
+#define        WEAK_ALIAS(alias,sym)                                           \\r
+       .weak alias;                                                    \\r
+       alias = sym\r
+#endif\r
+\r
+/*\r
+ * STRONG_ALIAS: create a strong alias.\r
+ */\r
+#define STRONG_ALIAS(alias,sym)                                                \\r
+       .globl alias;                                                   \\r
+       alias = sym\r
+\r
+#ifdef __STDC__\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg ## ,30,0,0,0 ;                                       \\r
+       .stabs __STRING(_C_LABEL(sym)) ## ,1,0,0,0\r
+#elif defined(__ELF__)\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg,30,0,0,0 ;                                           \\r
+       .stabs __STRING(sym),1,0,0,0\r
+#else\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg,30,0,0,0 ;                                           \\r
+       .stabs __STRING(_/**/sym),1,0,0,0\r
+#endif /* __STDC__ */\r
+\r
+#if defined (__ARM_ARCH_6__) || defined (__ARM_ARCH_6J__)\r
+#define _ARM_ARCH_6\r
+#endif\r
+\r
+#if defined (_ARM_ARCH_6) || defined (__ARM_ARCH_5__) || \\r
+    defined (__ARM_ARCH_5T__) || defined (__ARM_ARCH_5TE__) || \\r
+    defined (__ARM_ARCH_5TEJ__)\r
+#define _ARM_ARCH_5\r
+#endif\r
+\r
+#if defined (_ARM_ARCH_5) || defined (__ARM_ARCH_4T__)\r
+#define _ARM_ARCH_4T\r
+#endif\r
+\r
+\r
+#if defined (_ARM_ARCH_4T)\r
+# define RET   bx      lr\r
+# ifdef __STDC__\r
+#  define RETc(c) bx##c        lr\r
+# else\r
+#  define RETc(c) bx/**/c      lr\r
+# endif\r
+#else\r
+# define RET   mov     pc, lr\r
+# ifdef __STDC__\r
+#  define RETc(c) mov##c       pc, lr\r
+# else\r
+#  define RETc(c) mov/**/c     pc, lr\r
+# endif\r
+#endif\r
+\r
+#endif /* !_ARM_ASM_H_ */\r
diff --git a/StdLib/Include/Arm/machine/atomic.h b/StdLib/Include/Arm/machine/atomic.h
new file mode 100644 (file)
index 0000000..ffd83c7
--- /dev/null
@@ -0,0 +1,102 @@
+/* $NetBSD: atomic.h,v 1.5 2005/12/28 19:09:29 perry Exp $ */\r
+\r
+/*\r
+ * Copyright (C) 1994-1997 Mark Brinicombe\r
+ * Copyright (C) 1994 Brini\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software written for Brini by Mark Brinicombe\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *     This product includes software developed by Brini.\r
+ * 4. The name of Brini may not be used to endorse or promote products\r
+ *    derived from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR\r
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
+ * IN NO EVENT SHALL BRINI BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\r
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;\r
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,\r
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR\r
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\r
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef        _ARM_ATOMIC_H_\r
+#define        _ARM_ATOMIC_H_\r
+\r
+#ifndef ATOMIC_SET_BIT_NONINLINE_REQUIRED\r
+\r
+#if defined(__PROG26) || defined(ATOMIC_SET_BIT_NOINLINE)\r
+#define        ATOMIC_SET_BIT_NONINLINE_REQUIRED\r
+#endif\r
+\r
+#endif /* ATOMIC_SET_BIT_NONINLINE_REQUIRED */\r
+\r
+\r
+#ifndef _LOCORE\r
+\r
+#include <sys/types.h>\r
+#include <arm/armreg.h>                        /* I32_bit */\r
+\r
+#ifdef ATOMIC_SET_BIT_NONINLINE_REQUIRED\r
+void atomic_set_bit( u_int *, u_int );\r
+void atomic_clear_bit( u_int *, u_int );\r
+#endif\r
+\r
+#ifdef __PROG32\r
+#define __with_interrupts_disabled(expr) \\r
+       do {                                            \\r
+               u_int cpsr_save, tmp;                   \\r
+                                                       \\r
+               __asm volatile(                 \\r
+                       "mrs  %0, cpsr;"                \\r
+                       "orr  %1, %0, %2;"              \\r
+                       "msr  cpsr_all, %1;"            \\r
+                       : "=r" (cpsr_save), "=r" (tmp)  \\r
+                       : "I" (I32_bit)         \\r
+                       : "cc" );               \\r
+               (expr);                         \\r
+                __asm volatile(                \\r
+                       "msr  cpsr_all, %0"     \\r
+                       : /* no output */       \\r
+                       : "r" (cpsr_save)       \\r
+                       : "cc" );               \\r
+       } while(0)\r
+\r
+static __inline void\r
+inline_atomic_set_bit( u_int *address, u_int setmask )\r
+{\r
+       __with_interrupts_disabled( *address |= setmask );\r
+}\r
+\r
+static __inline void\r
+inline_atomic_clear_bit( u_int *address, u_int clearmask )\r
+{\r
+       __with_interrupts_disabled( *address &= ~clearmask );\r
+}\r
+\r
+#if !defined(ATOMIC_SET_BIT_NOINLINE)\r
+\r
+#define atomic_set_bit(a,m)   inline_atomic_set_bit(a,m)\r
+#define atomic_clear_bit(a,m) inline_atomic_clear_bit(a,m)\r
+\r
+#endif\r
+\r
+#endif /* __PROG32 */\r
+\r
+#undef __with_interrupts_disabled\r
+\r
+#endif /* _LOCORE */\r
+#endif /* _ARM_ATOMIC_H_ */\r
diff --git a/StdLib/Include/Arm/machine/cpufunc.h b/StdLib/Include/Arm/machine/cpufunc.h
new file mode 100644 (file)
index 0000000..c94a30a
--- /dev/null
@@ -0,0 +1,558 @@
+/*     $NetBSD: cpufunc.h,v 1.37.24.1 2007/02/21 18:36:02 snj Exp $    */\r
+\r
+/*\r
+ * Copyright (c) 1997 Mark Brinicombe.\r
+ * Copyright (c) 1997 Causality Limited\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *     This product includes software developed by Causality Limited.\r
+ * 4. The name of Causality Limited may not be used to endorse or promote\r
+ *    products derived from this software without specific prior written\r
+ *    permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY CAUSALITY LIMITED ``AS IS'' AND ANY EXPRESS\r
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
+ * DISCLAIMED. IN NO EVENT SHALL CAUSALITY LIMITED BE LIABLE FOR ANY DIRECT,\r
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ * RiscBSD kernel project\r
+ *\r
+ * cpufunc.h\r
+ *\r
+ * Prototypes for cpu, mmu and tlb related functions.\r
+ */\r
+\r
+#ifndef _ARM32_CPUFUNC_H_\r
+#define _ARM32_CPUFUNC_H_\r
+\r
+#ifdef _KERNEL\r
+\r
+#include <sys/types.h>\r
+#include <arm/cpuconf.h>\r
+\r
+struct cpu_functions {\r
+\r
+       /* CPU functions */\r
+\r
+       u_int   (*cf_id)                __P((void));\r
+       void    (*cf_cpwait)            __P((void));\r
+\r
+       /* MMU functions */\r
+\r
+       u_int   (*cf_control)           __P((u_int, u_int));\r
+       void    (*cf_domains)           __P((u_int));\r
+       void    (*cf_setttb)            __P((u_int));\r
+       u_int   (*cf_faultstatus)       __P((void));\r
+       u_int   (*cf_faultaddress)      __P((void));\r
+\r
+       /* TLB functions */\r
+\r
+       void    (*cf_tlb_flushID)       __P((void));\r
+       void    (*cf_tlb_flushID_SE)    __P((u_int));\r
+       void    (*cf_tlb_flushI)        __P((void));\r
+       void    (*cf_tlb_flushI_SE)     __P((u_int));\r
+       void    (*cf_tlb_flushD)        __P((void));\r
+       void    (*cf_tlb_flushD_SE)     __P((u_int));\r
+\r
+       /*\r
+        * Cache operations:\r
+        *\r
+        * We define the following primitives:\r
+        *\r
+        *      icache_sync_all         Synchronize I-cache\r
+        *      icache_sync_range       Synchronize I-cache range\r
+        *\r
+        *      dcache_wbinv_all        Write-back and Invalidate D-cache\r
+        *      dcache_wbinv_range      Write-back and Invalidate D-cache range\r
+        *      dcache_inv_range        Invalidate D-cache range\r
+        *      dcache_wb_range         Write-back D-cache range\r
+        *\r
+        *      idcache_wbinv_all       Write-back and Invalidate D-cache,\r
+        *                              Invalidate I-cache\r
+        *      idcache_wbinv_range     Write-back and Invalidate D-cache,\r
+        *                              Invalidate I-cache range\r
+        *\r
+        * Note that the ARM term for "write-back" is "clean".  We use\r
+        * the term "write-back" since it's a more common way to describe\r
+        * the operation.\r
+        *\r
+        * There are some rules that must be followed:\r
+        *\r
+        *      I-cache Synch (all or range):\r
+        *              The goal is to synchronize the instruction stream,\r
+        *              so you may beed to write-back dirty D-cache blocks\r
+        *              first.  If a range is requested, and you can't\r
+        *              synchronize just a range, you have to hit the whole\r
+        *              thing.\r
+        *\r
+        *      D-cache Write-Back and Invalidate range:\r
+        *              If you can't WB-Inv a range, you must WB-Inv the\r
+        *              entire D-cache.\r
+        *\r
+        *      D-cache Invalidate:\r
+        *              If you can't Inv the D-cache, you must Write-Back\r
+        *              and Invalidate.  Code that uses this operation\r
+        *              MUST NOT assume that the D-cache will not be written\r
+        *              back to memory.\r
+        *\r
+        *      D-cache Write-Back:\r
+        *              If you can't Write-back without doing an Inv,\r
+        *              that's fine.  Then treat this as a WB-Inv.\r
+        *              Skipping the invalidate is merely an optimization.\r
+        *\r
+        *      All operations:\r
+        *              Valid virtual addresses must be passed to each\r
+        *              cache operation.\r
+        */\r
+       void    (*cf_icache_sync_all)   __P((void));\r
+       void    (*cf_icache_sync_range) __P((vaddr_t, vsize_t));\r
+\r
+       void    (*cf_dcache_wbinv_all)  __P((void));\r
+       void    (*cf_dcache_wbinv_range) __P((vaddr_t, vsize_t));\r
+       void    (*cf_dcache_inv_range)  __P((vaddr_t, vsize_t));\r
+       void    (*cf_dcache_wb_range)   __P((vaddr_t, vsize_t));\r
+\r
+       void    (*cf_idcache_wbinv_all) __P((void));\r
+       void    (*cf_idcache_wbinv_range) __P((vaddr_t, vsize_t));\r
+\r
+       /* Other functions */\r
+\r
+       void    (*cf_flush_prefetchbuf) __P((void));\r
+       void    (*cf_drain_writebuf)    __P((void));\r
+       void    (*cf_flush_brnchtgt_C)  __P((void));\r
+       void    (*cf_flush_brnchtgt_E)  __P((u_int));\r
+\r
+       void    (*cf_sleep)             __P((int mode));\r
+\r
+       /* Soft functions */\r
+\r
+       int     (*cf_dataabt_fixup)     __P((void *));\r
+       int     (*cf_prefetchabt_fixup) __P((void *));\r
+\r
+       void    (*cf_context_switch)    __P((void));\r
+\r
+       void    (*cf_setup)             __P((char *));\r
+};\r
+\r
+extern struct cpu_functions cpufuncs;\r
+extern u_int cputype;\r
+\r
+#define cpu_id()               cpufuncs.cf_id()\r
+#define        cpu_cpwait()            cpufuncs.cf_cpwait()\r
+\r
+#define cpu_control(c, e)      cpufuncs.cf_control(c, e)\r
+#define cpu_domains(d)         cpufuncs.cf_domains(d)\r
+#define cpu_setttb(t)          cpufuncs.cf_setttb(t)\r
+#define cpu_faultstatus()      cpufuncs.cf_faultstatus()\r
+#define cpu_faultaddress()     cpufuncs.cf_faultaddress()\r
+\r
+#define        cpu_tlb_flushID()       cpufuncs.cf_tlb_flushID()\r
+#define        cpu_tlb_flushID_SE(e)   cpufuncs.cf_tlb_flushID_SE(e)\r
+#define        cpu_tlb_flushI()        cpufuncs.cf_tlb_flushI()\r
+#define        cpu_tlb_flushI_SE(e)    cpufuncs.cf_tlb_flushI_SE(e)\r
+#define        cpu_tlb_flushD()        cpufuncs.cf_tlb_flushD()\r
+#define        cpu_tlb_flushD_SE(e)    cpufuncs.cf_tlb_flushD_SE(e)\r
+\r
+#define        cpu_icache_sync_all()   cpufuncs.cf_icache_sync_all()\r
+#define        cpu_icache_sync_range(a, s) cpufuncs.cf_icache_sync_range((a), (s))\r
+\r
+#define        cpu_dcache_wbinv_all()  cpufuncs.cf_dcache_wbinv_all()\r
+#define        cpu_dcache_wbinv_range(a, s) cpufuncs.cf_dcache_wbinv_range((a), (s))\r
+#define        cpu_dcache_inv_range(a, s) cpufuncs.cf_dcache_inv_range((a), (s))\r
+#define        cpu_dcache_wb_range(a, s) cpufuncs.cf_dcache_wb_range((a), (s))\r
+\r
+#define        cpu_idcache_wbinv_all() cpufuncs.cf_idcache_wbinv_all()\r
+#define        cpu_idcache_wbinv_range(a, s) cpufuncs.cf_idcache_wbinv_range((a), (s))\r
+\r
+#define        cpu_flush_prefetchbuf() cpufuncs.cf_flush_prefetchbuf()\r
+#define        cpu_drain_writebuf()    cpufuncs.cf_drain_writebuf()\r
+#define        cpu_flush_brnchtgt_C()  cpufuncs.cf_flush_brnchtgt_C()\r
+#define        cpu_flush_brnchtgt_E(e) cpufuncs.cf_flush_brnchtgt_E(e)\r
+\r
+#define cpu_sleep(m)           cpufuncs.cf_sleep(m)\r
+\r
+#define cpu_dataabt_fixup(a)           cpufuncs.cf_dataabt_fixup(a)\r
+#define cpu_prefetchabt_fixup(a)       cpufuncs.cf_prefetchabt_fixup(a)\r
+#define ABORT_FIXUP_OK         0       /* fixup succeeded */\r
+#define ABORT_FIXUP_FAILED     1       /* fixup failed */\r
+#define ABORT_FIXUP_RETURN     2       /* abort handler should return */\r
+\r
+#define cpu_setup(a)                   cpufuncs.cf_setup(a)\r
+\r
+int    set_cpufuncs            __P((void));\r
+#define ARCHITECTURE_NOT_PRESENT       1       /* known but not configured */\r
+#define ARCHITECTURE_NOT_SUPPORTED     2       /* not known */\r
+\r
+void   cpufunc_nullop          __P((void));\r
+int    cpufunc_null_fixup      __P((void *));\r
+int    early_abort_fixup       __P((void *));\r
+int    late_abort_fixup        __P((void *));\r
+u_int  cpufunc_id              __P((void));\r
+u_int  cpufunc_control         __P((u_int, u_int));\r
+void   cpufunc_domains         __P((u_int));\r
+u_int  cpufunc_faultstatus     __P((void));\r
+u_int  cpufunc_faultaddress    __P((void));\r
+\r
+#ifdef CPU_ARM3\r
+u_int  arm3_control            __P((u_int, u_int));\r
+void   arm3_cache_flush        __P((void));\r
+#endif /* CPU_ARM3 */\r
+\r
+#if defined(CPU_ARM6) || defined(CPU_ARM7)\r
+void   arm67_setttb            __P((u_int));\r
+void   arm67_tlb_flush         __P((void));\r
+void   arm67_tlb_purge         __P((u_int));\r
+void   arm67_cache_flush       __P((void));\r
+void   arm67_context_switch    __P((void));\r
+#endif /* CPU_ARM6 || CPU_ARM7 */\r
+\r
+#ifdef CPU_ARM6\r
+void   arm6_setup              __P((char *));\r
+#endif /* CPU_ARM6 */\r
+\r
+#ifdef CPU_ARM7\r
+void   arm7_setup              __P((char *));\r
+#endif /* CPU_ARM7 */\r
+\r
+#ifdef CPU_ARM7TDMI\r
+int    arm7_dataabt_fixup      __P((void *));\r
+void   arm7tdmi_setup          __P((char *));\r
+void   arm7tdmi_setttb         __P((u_int));\r
+void   arm7tdmi_tlb_flushID    __P((void));\r
+void   arm7tdmi_tlb_flushID_SE __P((u_int));\r
+void   arm7tdmi_cache_flushID  __P((void));\r
+void   arm7tdmi_context_switch __P((void));\r
+#endif /* CPU_ARM7TDMI */\r
+\r
+#ifdef CPU_ARM8\r
+void   arm8_setttb             __P((u_int));\r
+void   arm8_tlb_flushID        __P((void));\r
+void   arm8_tlb_flushID_SE     __P((u_int));\r
+void   arm8_cache_flushID      __P((void));\r
+void   arm8_cache_flushID_E    __P((u_int));\r
+void   arm8_cache_cleanID      __P((void));\r
+void   arm8_cache_cleanID_E    __P((u_int));\r
+void   arm8_cache_purgeID      __P((void));\r
+void   arm8_cache_purgeID_E    __P((u_int entry));\r
+\r
+void   arm8_cache_syncI        __P((void));\r
+void   arm8_cache_cleanID_rng  __P((vaddr_t, vsize_t));\r
+void   arm8_cache_cleanD_rng   __P((vaddr_t, vsize_t));\r
+void   arm8_cache_purgeID_rng  __P((vaddr_t, vsize_t));\r
+void   arm8_cache_purgeD_rng   __P((vaddr_t, vsize_t));\r
+void   arm8_cache_syncI_rng    __P((vaddr_t, vsize_t));\r
+\r
+void   arm8_context_switch     __P((void));\r
+\r
+void   arm8_setup              __P((char *));\r
+\r
+u_int  arm8_clock_config       __P((u_int, u_int));\r
+#endif\r
+\r
+#ifdef CPU_SA110\r
+void   sa110_setup             __P((char *));\r
+void   sa110_context_switch    __P((void));\r
+#endif /* CPU_SA110 */\r
+\r
+#if defined(CPU_SA1100) || defined(CPU_SA1110)\r
+void   sa11x0_drain_readbuf    __P((void));\r
+\r
+void   sa11x0_context_switch   __P((void));\r
+void   sa11x0_cpu_sleep        __P((int));\r
+\r
+void   sa11x0_setup            __P((char *));\r
+#endif\r
+\r
+#if defined(CPU_SA110) || defined(CPU_SA1100) || defined(CPU_SA1110)\r
+void   sa1_setttb              __P((u_int));\r
+\r
+void   sa1_tlb_flushID_SE      __P((u_int));\r
+\r
+void   sa1_cache_flushID       __P((void));\r
+void   sa1_cache_flushI        __P((void));\r
+void   sa1_cache_flushD        __P((void));\r
+void   sa1_cache_flushD_SE     __P((u_int));\r
+\r
+void   sa1_cache_cleanID       __P((void));\r
+void   sa1_cache_cleanD        __P((void));\r
+void   sa1_cache_cleanD_E      __P((u_int));\r
+\r
+void   sa1_cache_purgeID       __P((void));\r
+void   sa1_cache_purgeID_E     __P((u_int));\r
+void   sa1_cache_purgeD        __P((void));\r
+void   sa1_cache_purgeD_E      __P((u_int));\r
+\r
+void   sa1_cache_syncI         __P((void));\r
+void   sa1_cache_cleanID_rng   __P((vaddr_t, vsize_t));\r
+void   sa1_cache_cleanD_rng    __P((vaddr_t, vsize_t));\r
+void   sa1_cache_purgeID_rng   __P((vaddr_t, vsize_t));\r
+void   sa1_cache_purgeD_rng    __P((vaddr_t, vsize_t));\r
+void   sa1_cache_syncI_rng     __P((vaddr_t, vsize_t));\r
+\r
+#endif\r
+\r
+#ifdef CPU_ARM9\r
+void   arm9_setttb             __P((u_int));\r
+\r
+void   arm9_tlb_flushID_SE     __P((u_int));\r
+\r
+void   arm9_icache_sync_all    __P((void));\r
+void   arm9_icache_sync_range  __P((vaddr_t, vsize_t));\r
+\r
+void   arm9_dcache_wbinv_all   __P((void));\r
+void   arm9_dcache_wbinv_range __P((vaddr_t, vsize_t));\r
+void   arm9_dcache_inv_range   __P((vaddr_t, vsize_t));\r
+void   arm9_dcache_wb_range    __P((vaddr_t, vsize_t));\r
+\r
+void   arm9_idcache_wbinv_all  __P((void));\r
+void   arm9_idcache_wbinv_range __P((vaddr_t, vsize_t));\r
+\r
+void   arm9_context_switch     __P((void));\r
+\r
+void   arm9_setup              __P((char *));\r
+\r
+extern unsigned arm9_dcache_sets_max;\r
+extern unsigned arm9_dcache_sets_inc;\r
+extern unsigned arm9_dcache_index_max;\r
+extern unsigned arm9_dcache_index_inc;\r
+#endif\r
+\r
+#if defined(CPU_ARM9E) || defined(CPU_ARM10)\r
+void   arm10_tlb_flushID_SE    __P((u_int));\r
+void   arm10_tlb_flushI_SE     __P((u_int));\r
+\r
+void   arm10_context_switch    __P((void));\r
+\r
+void   arm10_setup             __P((char *));\r
+#endif\r
+\r
+#ifdef CPU_ARM11\r
+void   arm11_setttb            __P((u_int));\r
+\r
+void   arm11_tlb_flushID_SE    __P((u_int));\r
+void   arm11_tlb_flushI_SE     __P((u_int));\r
+\r
+void   arm11_context_switch    __P((void));\r
+\r
+void   arm11_setup             __P((char *string));\r
+void   arm11_tlb_flushID       __P((void));\r
+void   arm11_tlb_flushI        __P((void));\r
+void   arm11_tlb_flushD        __P((void));\r
+void   arm11_tlb_flushD_SE     __P((u_int va));\r
+\r
+void   arm11_drain_writebuf    __P((void));\r
+#endif\r
+\r
+#if defined(CPU_ARM9E) || defined (CPU_ARM10)\r
+void   armv5_ec_setttb                 __P((u_int));\r
+\r
+void   armv5_ec_icache_sync_all        __P((void));\r
+void   armv5_ec_icache_sync_range      __P((vaddr_t, vsize_t));\r
+\r
+void   armv5_ec_dcache_wbinv_all       __P((void));\r
+void   armv5_ec_dcache_wbinv_range     __P((vaddr_t, vsize_t));\r
+void   armv5_ec_dcache_inv_range       __P((vaddr_t, vsize_t));\r
+void   armv5_ec_dcache_wb_range        __P((vaddr_t, vsize_t));\r
+\r
+void   armv5_ec_idcache_wbinv_all      __P((void));\r
+void   armv5_ec_idcache_wbinv_range    __P((vaddr_t, vsize_t));\r
+#endif\r
+\r
+#if defined (CPU_ARM10) || defined (CPU_ARM11)\r
+void   armv5_setttb            __P((u_int));\r
+\r
+void   armv5_icache_sync_all   __P((void));\r
+void   armv5_icache_sync_range __P((vaddr_t, vsize_t));\r
+\r
+void   armv5_dcache_wbinv_all  __P((void));\r
+void   armv5_dcache_wbinv_range __P((vaddr_t, vsize_t));\r
+void   armv5_dcache_inv_range  __P((vaddr_t, vsize_t));\r
+void   armv5_dcache_wb_range   __P((vaddr_t, vsize_t));\r
+\r
+void   armv5_idcache_wbinv_all __P((void));\r
+void   armv5_idcache_wbinv_range __P((vaddr_t, vsize_t));\r
+\r
+extern unsigned armv5_dcache_sets_max;\r
+extern unsigned armv5_dcache_sets_inc;\r
+extern unsigned armv5_dcache_index_max;\r
+extern unsigned armv5_dcache_index_inc;\r
+#endif\r
+\r
+#if defined(CPU_ARM9) || defined(CPU_ARM9E) || defined(CPU_ARM10) || \\r
+    defined(CPU_SA110) || defined(CPU_SA1100) || defined(CPU_SA1110) || \\r
+    defined(CPU_XSCALE_80200) || defined(CPU_XSCALE_80321) || \\r
+    defined(__CPU_XSCALE_PXA2XX) || defined(CPU_XSCALE_IXP425)\r
+\r
+void   armv4_tlb_flushID       __P((void));\r
+void   armv4_tlb_flushI        __P((void));\r
+void   armv4_tlb_flushD        __P((void));\r
+void   armv4_tlb_flushD_SE     __P((u_int));\r
+\r
+void   armv4_drain_writebuf    __P((void));\r
+#endif\r
+\r
+#if defined(CPU_IXP12X0)\r
+void   ixp12x0_drain_readbuf   __P((void));\r
+void   ixp12x0_context_switch  __P((void));\r
+void   ixp12x0_setup           __P((char *));\r
+#endif\r
+\r
+#if defined(CPU_XSCALE_80200) || defined(CPU_XSCALE_80321) || \\r
+    defined(__CPU_XSCALE_PXA2XX) || defined(CPU_XSCALE_IXP425)\r
+void   xscale_cpwait           __P((void));\r
+\r
+void   xscale_cpu_sleep        __P((int));\r
+\r
+u_int  xscale_control          __P((u_int, u_int));\r
+\r
+void   xscale_setttb           __P((u_int));\r
+\r
+void   xscale_tlb_flushID_SE   __P((u_int));\r
+\r
+void   xscale_cache_flushID    __P((void));\r
+void   xscale_cache_flushI     __P((void));\r
+void   xscale_cache_flushD     __P((void));\r
+void   xscale_cache_flushD_SE  __P((u_int));\r
+\r
+void   xscale_cache_cleanID    __P((void));\r
+void   xscale_cache_cleanD     __P((void));\r
+void   xscale_cache_cleanD_E   __P((u_int));\r
+\r
+void   xscale_cache_clean_minidata __P((void));\r
+\r
+void   xscale_cache_purgeID    __P((void));\r
+void   xscale_cache_purgeID_E  __P((u_int));\r
+void   xscale_cache_purgeD     __P((void));\r
+void   xscale_cache_purgeD_E   __P((u_int));\r
+\r
+void   xscale_cache_syncI      __P((void));\r
+void   xscale_cache_cleanID_rng __P((vaddr_t, vsize_t));\r
+void   xscale_cache_cleanD_rng __P((vaddr_t, vsize_t));\r
+void   xscale_cache_purgeID_rng __P((vaddr_t, vsize_t));\r
+void   xscale_cache_purgeD_rng __P((vaddr_t, vsize_t));\r
+void   xscale_cache_syncI_rng  __P((vaddr_t, vsize_t));\r
+void   xscale_cache_flushD_rng __P((vaddr_t, vsize_t));\r
+\r
+void   xscale_context_switch   __P((void));\r
+\r
+void   xscale_setup            __P((char *));\r
+#endif /* CPU_XSCALE_80200 || CPU_XSCALE_80321 || __CPU_XSCALE_PXA2XX || CPU_XSCALE_IXP425 */\r
+\r
+#define tlb_flush      cpu_tlb_flushID\r
+#define setttb         cpu_setttb\r
+#define drain_writebuf cpu_drain_writebuf\r
+\r
+/*\r
+ * Macros for manipulating CPU interrupts\r
+ */\r
+#ifdef __PROG32\r
+static __inline u_int32_t __set_cpsr_c(u_int bic, u_int eor) __attribute__((__unused__));\r
+\r
+static __inline u_int32_t\r
+__set_cpsr_c(u_int bic, u_int eor)\r
+{\r
+       u_int32_t       tmp, ret;\r
+\r
+       __asm volatile(\r
+               "mrs     %0, cpsr\n"    /* Get the CPSR */\r
+               "bic     %1, %0, %2\n"  /* Clear bits */\r
+               "eor     %1, %1, %3\n"  /* XOR bits */\r
+               "msr     cpsr_c, %1\n"  /* Set the control field of CPSR */\r
+       : "=&r" (ret), "=&r" (tmp)\r
+       : "r" (bic), "r" (eor) : "memory");\r
+\r
+       return ret;\r
+}\r
+\r
+#define disable_interrupts(mask)                                       \\r
+       (__set_cpsr_c((mask) & (I32_bit | F32_bit), \\r
+                     (mask) & (I32_bit | F32_bit)))\r
+\r
+#define enable_interrupts(mask)                                                \\r
+       (__set_cpsr_c((mask) & (I32_bit | F32_bit), 0))\r
+\r
+#define restore_interrupts(old_cpsr)                                   \\r
+       (__set_cpsr_c((I32_bit | F32_bit), (old_cpsr) & (I32_bit | F32_bit)))\r
+#else /* ! __PROG32 */\r
+#define        disable_interrupts(mask)                                        \\r
+       (set_r15((mask) & (R15_IRQ_DISABLE | R15_FIQ_DISABLE),          \\r
+                (mask) & (R15_IRQ_DISABLE | R15_FIQ_DISABLE)))\r
+\r
+#define        enable_interrupts(mask)                                         \\r
+       (set_r15((mask) & (R15_IRQ_DISABLE | R15_FIQ_DISABLE), 0))\r
+\r
+#define        restore_interrupts(old_r15)                                     \\r
+       (set_r15((R15_IRQ_DISABLE | R15_FIQ_DISABLE),                   \\r
+                (old_r15) & (R15_IRQ_DISABLE | R15_FIQ_DISABLE)))\r
+#endif /* __PROG32 */\r
+\r
+#ifdef __PROG32\r
+/* Functions to manipulate the CPSR. */\r
+u_int  SetCPSR(u_int, u_int);\r
+u_int  GetCPSR(void);\r
+#else\r
+/* Functions to manipulate the processor control bits in r15. */\r
+u_int  set_r15(u_int, u_int);\r
+u_int  get_r15(void);\r
+#endif /* __PROG32 */\r
+\r
+/*\r
+ * Functions to manipulate cpu r13\r
+ * (in arm/arm32/setstack.S)\r
+ */\r
+\r
+void set_stackptr      __P((u_int, u_int));\r
+u_int get_stackptr     __P((u_int));\r
+\r
+/*\r
+ * Miscellany\r
+ */\r
+\r
+int get_pc_str_offset  __P((void));\r
+\r
+/*\r
+ * CPU functions from locore.S\r
+ */\r
+\r
+void cpu_reset         __P((void)) __attribute__((__noreturn__));\r
+\r
+/*\r
+ * Cache info variables.\r
+ */\r
+\r
+/* PRIMARY CACHE VARIABLES */\r
+extern int     arm_picache_size;\r
+extern int     arm_picache_line_size;\r
+extern int     arm_picache_ways;\r
+\r
+extern int     arm_pdcache_size;       /* and unified */\r
+extern int     arm_pdcache_line_size;\r
+extern int     arm_pdcache_ways;\r
+\r
+extern int     arm_pcache_type;\r
+extern int     arm_pcache_unified;\r
+\r
+extern int     arm_dcache_align;\r
+extern int     arm_dcache_align_mask;\r
+\r
+#endif /* _KERNEL */\r
+#endif /* _ARM32_CPUFUNC_H_ */\r
+\r
+/* End of cpufunc.h */\r
diff --git a/StdLib/Include/Arm/machine/float.h b/StdLib/Include/Arm/machine/float.h
new file mode 100644 (file)
index 0000000..4bd79b3
--- /dev/null
@@ -0,0 +1,31 @@
+/*     $NetBSD: float.h,v 1.6 2005/12/11 12:16:47 christos Exp $       */\r
+\r
+#ifndef _ARM_FLOAT_H_\r
+#define _ARM_FLOAT_H_\r
+\r
+#ifndef __VFP_FP__\r
+#define LDBL_MANT_DIG  64\r
+#define LDBL_EPSILON   1.0842021724855044340E-19L\r
+#define LDBL_DIG       18\r
+#define LDBL_MIN_EXP   (-16381)\r
+#define LDBL_MIN       1.6810515715560467531E-4932L\r
+#define LDBL_MIN_10_EXP        (-4931)\r
+#define LDBL_MAX_EXP   16384\r
+#define LDBL_MAX       1.1897314953572317650E+4932L\r
+#define LDBL_MAX_10_EXP        4932\r
+#endif\r
+\r
+#include <sys/float_ieee754.h>\r
+\r
+#ifndef __VFP_FP__\r
+#if !defined(_ANSI_SOURCE) && !defined(_POSIX_C_SOURCE) && \\r
+    !defined(_XOPEN_SOURCE) || \\r
+    ((__STDC_VERSION__ - 0) >= 199901L) || \\r
+    ((_POSIX_C_SOURCE - 0) >= 200112L) || \\r
+    ((_XOPEN_SOURCE  - 0) >= 600) || \\r
+    defined(_ISOC99_SOURCE) || defined(_NETBSD_SOURCE)\r
+#define        DECIMAL_DIG     21\r
+#endif /* !defined(_ANSI_SOURCE) && ... */\r
+#endif /* !__VFP_FP__ */\r
+\r
+#endif /* !_ARM_FLOAT_H_ */\r
diff --git a/StdLib/Include/Arm/machine/frame.h b/StdLib/Include/Arm/machine/frame.h
new file mode 100644 (file)
index 0000000..1037a9f
--- /dev/null
@@ -0,0 +1,123 @@
+/*     $NetBSD: frame.h,v 1.8 2005/12/11 12:16:47 christos Exp $       */\r
+\r
+/*\r
+ * Copyright (c) 1994-1997 Mark Brinicombe.\r
+ * Copyright (c) 1994 Brini.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software written for Brini by Mark Brinicombe\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *     This product includes software developed by Brini.\r
+ * 4. The name of the company nor the name of the author may be used to\r
+ *    endorse or promote products derived from this software without specific\r
+ *    prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR IMPLIED\r
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
+ * IN NO EVENT SHALL BRINI OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\r
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ */\r
+/*\r
+ * arm/frame.h - Stack frames structures common to arm26 and arm32\r
+ */\r
+\r
+#ifndef _ARM_FRAME_H_\r
+#define _ARM_FRAME_H_\r
+\r
+#ifndef _LOCORE\r
+\r
+#include <sys/signal.h>\r
+#include <sys/sa.h>\r
+#include <sys/ucontext.h>\r
+\r
+/*\r
+ * Trap frame.  Pushed onto the kernel stack on a trap (synchronous exception).\r
+ */\r
+\r
+typedef struct trapframe {\r
+       register_t tf_spsr; /* Zero on arm26 */\r
+       register_t tf_r0;\r
+       register_t tf_r1;\r
+       register_t tf_r2;\r
+       register_t tf_r3;\r
+       register_t tf_r4;\r
+       register_t tf_r5;\r
+       register_t tf_r6;\r
+       register_t tf_r7;\r
+       register_t tf_r8;\r
+       register_t tf_r9;\r
+       register_t tf_r10;\r
+       register_t tf_r11;\r
+       register_t tf_r12;\r
+       register_t tf_usr_sp;\r
+       register_t tf_usr_lr;\r
+       register_t tf_svc_sp; /* Not used on arm26 */\r
+       register_t tf_svc_lr; /* Not used on arm26 */\r
+       register_t tf_pc;\r
+} trapframe_t;\r
+\r
+/* Register numbers */\r
+#define tf_r13 tf_usr_sp\r
+#define tf_r14 tf_usr_lr\r
+#define tf_r15 tf_pc\r
+\r
+/*\r
+ * Signal frame.  Pushed onto user stack before calling sigcode.\r
+ */\r
+#ifdef COMPAT_16\r
+struct sigframe_sigcontext {\r
+       struct  sigcontext sf_sc;\r
+};\r
+#endif\r
+\r
+/* the pointers are use in the trampoline code to locate the ucontext */\r
+struct sigframe_siginfo {\r
+       siginfo_t       sf_si;          /* actual saved siginfo */\r
+       ucontext_t      sf_uc;          /* actual saved ucontext */\r
+};\r
+\r
+/*\r
+ * Scheduler activations upcall frame.  Pushed onto user stack before\r
+ * calling an SA upcall.\r
+ */\r
+\r
+struct saframe {\r
+#if 0 /* in registers on entry to upcall */\r
+       int             sa_type;\r
+       struct sa_t **  sa_sas;\r
+       int             sa_events;\r
+       int             sa_interrupted;\r
+#endif\r
+       void *          sa_arg;\r
+};\r
+\r
+#ifdef _KERNEL\r
+__BEGIN_DECLS\r
+void sendsig_sigcontext(const ksiginfo_t *, const sigset_t *);\r
+void *getframe(struct lwp *, int, int *);\r
+__END_DECLS\r
+#define process_frame(l) ((l)->l_addr->u_pcb.pcb_tf)\r
+#endif\r
+\r
+#endif /* _LOCORE */\r
+\r
+#endif /* _ARM_FRAME_H_ */\r
+  \r
+/* End of frame.h */\r
diff --git a/StdLib/Include/Arm/machine/ieee.h b/StdLib/Include/Arm/machine/ieee.h
new file mode 100644 (file)
index 0000000..5e6b4d9
--- /dev/null
@@ -0,0 +1,13 @@
+/*     $NetBSD: ieee.h,v 1.9 2005/12/11 12:16:47 christos Exp $        */\r
+\r
+#include <sys/ieee754.h>\r
+\r
+/*\r
+ * A NaN is a `signalling NaN' if its QUIETNAN bit is clear in its\r
+ * high fraction; if the bit is set, it is a `quiet NaN'.\r
+ */\r
+\r
+#if 0\r
+#define        SNG_QUIETNAN    (1 << 22)\r
+#define        DBL_QUIETNAN    (1 << 19)\r
+#endif\r
diff --git a/StdLib/Include/Arm/machine/lock.h b/StdLib/Include/Arm/machine/lock.h
new file mode 100644 (file)
index 0000000..be11a47
--- /dev/null
@@ -0,0 +1,89 @@
+/*     $NetBSD: lock.h,v 1.7 2005/12/28 19:09:29 perry Exp $   */\r
+\r
+/*-\r
+ * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to The NetBSD Foundation\r
+ * by Jason R. Thorpe.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *     This product includes software developed by the NetBSD\r
+ *     Foundation, Inc. and its contributors.\r
+ * 4. Neither the name of The NetBSD Foundation nor the names of its\r
+ *    contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS\r
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS\r
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+/*\r
+ * Machine-dependent spin lock operations.\r
+ *\r
+ * NOTE: The SWP insn used here is available only on ARM architecture\r
+ * version 3 and later (as well as 2a).  What we are going to do is\r
+ * expect that the kernel will trap and emulate the insn.  That will\r
+ * be slow, but give us the atomicity that we need.\r
+ */\r
+\r
+#ifndef _ARM_LOCK_H_\r
+#define        _ARM_LOCK_H_\r
+\r
+static __inline int\r
+__swp(int __val, volatile int *__ptr)\r
+{\r
+\r
+       __asm volatile("swp %0, %1, [%2]"\r
+           : "=r" (__val) : "r" (__val), "r" (__ptr) : "memory");\r
+       return __val;\r
+}\r
+\r
+static __inline void __attribute__((__unused__))\r
+__cpu_simple_lock_init(__cpu_simple_lock_t *alp)\r
+{\r
+\r
+       *alp = __SIMPLELOCK_UNLOCKED;\r
+}\r
+\r
+static __inline void __attribute__((__unused__))\r
+__cpu_simple_lock(__cpu_simple_lock_t *alp)\r
+{\r
+\r
+       while (__swp(__SIMPLELOCK_LOCKED, alp) != __SIMPLELOCK_UNLOCKED)\r
+               continue;\r
+}\r
+\r
+static __inline int __attribute__((__unused__))\r
+__cpu_simple_lock_try(__cpu_simple_lock_t *alp)\r
+{\r
+\r
+       return (__swp(__SIMPLELOCK_LOCKED, alp) == __SIMPLELOCK_UNLOCKED);\r
+}\r
+\r
+static __inline void __attribute__((__unused__))\r
+__cpu_simple_unlock(__cpu_simple_lock_t *alp)\r
+{\r
+\r
+       *alp = __SIMPLELOCK_UNLOCKED;\r
+}\r
+\r
+#endif /* _ARM_LOCK_H_ */\r
diff --git a/StdLib/Include/Arm/machine/math.h b/StdLib/Include/Arm/machine/math.h
new file mode 100644 (file)
index 0000000..7eca111
--- /dev/null
@@ -0,0 +1,3 @@
+/*     $NetBSD: math.h,v 1.2 2002/02/19 13:08:14 simonb Exp $  */\r
+\r
+#define        __HAVE_NANF\r
diff --git a/StdLib/Include/Arm/machine/mcontext.h b/StdLib/Include/Arm/machine/mcontext.h
new file mode 100644 (file)
index 0000000..0f450c4
--- /dev/null
@@ -0,0 +1,114 @@
+/*     $NetBSD: mcontext.h,v 1.5 2005/12/11 12:16:47 christos Exp $    */\r
+\r
+/*-\r
+ * Copyright (c) 2001, 2002 The NetBSD Foundation, Inc.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to The NetBSD Foundation\r
+ * by Klaus Klein and by Jason R. Thorpe of Wasabi Systems, Inc.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *        This product includes software developed by the NetBSD\r
+ *        Foundation, Inc. and its contributors.\r
+ * 4. Neither the name of The NetBSD Foundation nor the names of its\r
+ *    contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS\r
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS\r
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef _ARM_MCONTEXT_H_\r
+#define _ARM_MCONTEXT_H_\r
+\r
+/*\r
+ * General register state\r
+ */\r
+#define _NGREG         17\r
+typedef unsigned int   __greg_t;\r
+typedef __greg_t       __gregset_t[_NGREG];\r
+\r
+#define _REG_R0                0\r
+#define _REG_R1                1\r
+#define _REG_R2                2\r
+#define _REG_R3                3\r
+#define _REG_R4                4\r
+#define _REG_R5                5\r
+#define _REG_R6                6\r
+#define _REG_R7                7\r
+#define _REG_R8                8\r
+#define _REG_R9                9\r
+#define _REG_R10       10\r
+#define _REG_R11       11\r
+#define _REG_R12       12\r
+#define _REG_R13       13\r
+#define _REG_R14       14\r
+#define _REG_R15       15\r
+#define _REG_CPSR      16\r
+/* Convenience synonyms */\r
+#define _REG_FP                _REG_R11\r
+#define _REG_SP                _REG_R13\r
+#define _REG_LR                _REG_R14\r
+#define _REG_PC                _REG_R15\r
+\r
+/*\r
+ * Floating point register state\r
+ */\r
+/* Note: the storage layout of this structure must be identical to ARMFPE! */\r
+typedef struct {\r
+       unsigned int    __fp_fpsr;\r
+       struct {\r
+               unsigned int    __fp_exponent;\r
+               unsigned int    __fp_mantissa_hi;\r
+               unsigned int    __fp_mantissa_lo;\r
+       }               __fp_fr[8];\r
+} __fpregset_t;\r
+\r
+typedef struct {\r
+       unsigned int    __vfp_fpscr;\r
+       unsigned int    __vfp_fstmx[33];\r
+       unsigned int    __vfp_fpsid;\r
+} __vfpregset_t;\r
+\r
+typedef struct {\r
+       __gregset_t     __gregs;\r
+       union {\r
+               __fpregset_t __fpregs;\r
+               __vfpregset_t __vfpregs;\r
+       } __fpu;\r
+} mcontext_t;\r
+\r
+/* Machine-dependent uc_flags */\r
+#define        _UC_ARM_VFP     0x00010000      /* FPU field is VFP */\r
+\r
+/* used by signal delivery to indicate status of signal stack */\r
+#define _UC_SETSTACK   0x00020000\r
+#define _UC_CLRSTACK   0x00040000\r
+\r
+#define _UC_MACHINE_PAD        3               /* Padding appended to ucontext_t */\r
+\r
+#define _UC_MACHINE_SP(uc)     ((uc)->uc_mcontext.__gregs[_REG_SP])\r
+#define _UC_MACHINE_PC(uc)     ((uc)->uc_mcontext.__gregs[_REG_PC])\r
+#define _UC_MACHINE_INTRV(uc)  ((uc)->uc_mcontext.__gregs[_REG_R0])\r
+\r
+#define        _UC_MACHINE_SET_PC(uc, pc)      _UC_MACHINE_PC(uc) = (pc)\r
+\r
+#endif /* !_ARM_MCONTEXT_H_ */\r
diff --git a/StdLib/Include/Arm/machine/proc.h b/StdLib/Include/Arm/machine/proc.h
new file mode 100644 (file)
index 0000000..1471861
--- /dev/null
@@ -0,0 +1,55 @@
+/*     $NetBSD: proc.h,v 1.6 2003/03/05 11:28:14 agc Exp $     */\r
+\r
+/*\r
+ * Copyright (c) 1994 Mark Brinicombe.\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *     This product includes software developed by the RiscBSD team.\r
+ * 4. The name "RiscBSD" nor the name of the author may be used to\r
+ *    endorse or promote products derived from this software without specific\r
+ *    prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY RISCBSD ``AS IS'' AND ANY EXPRESS OR IMPLIED\r
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
+ * IN NO EVENT SHALL RISCBSD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,\r
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\r
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef        _ARM32_PROC_H_\r
+#define        _ARM32_PROC_H_\r
+\r
+/*\r
+ * Machine-dependent part of the proc structure for arm.\r
+ */\r
+\r
+struct trapframe;\r
+struct lwp;\r
+\r
+struct mdlwp {\r
+       int     md_dummy;               /* must have at least one member */\r
+};\r
+\r
+struct mdproc {\r
+       void    (*md_syscall)(struct trapframe *, struct lwp *, u_int32_t);\r
+       int     pmc_enabled;            /* bitfield of enabled counters */\r
+       void    *pmc_state;             /* port-specific pmc state */\r
+};\r
+\r
+#endif /* _ARM32_PROC_H_ */\r
diff --git a/StdLib/Include/Arm/machine/signal.h b/StdLib/Include/Arm/machine/signal.h
new file mode 100644 (file)
index 0000000..d42ca13
--- /dev/null
@@ -0,0 +1,22 @@
+/**\r
+Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials are licensed and made available under\r
+the terms and conditions of the BSD License that accompanies this distribution.\r
+The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php.\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+#ifndef _MACHINE_SIGNAL_H\r
+#define _MACHINE_SIGNAL_H\r
+#include  <sys/common.h>\r
+\r
+/** The type sig_atomic_t is the (possibly volatile-qualified) integer type of\r
+    an object that can be accessed as an atomic entity, even in the presence\r
+    of asynchronous interrupts.\r
+**/\r
+typedef INTN sig_atomic_t;\r
+\r
+#endif    /* _MACHINE_SIGNAL_H */\r
diff --git a/StdLib/Include/Ia32/machine/_math.h b/StdLib/Include/Ia32/machine/_math.h
new file mode 100644 (file)
index 0000000..67cf98c
--- /dev/null
@@ -0,0 +1,18 @@
+/**\r
+\r
+Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>\r
+This program and the accompanying materials are licensed and made available under\r
+the terms and conditions of the BSD License that accompanies this distribution.\r
+The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php.\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+#ifndef _MACHINE_MATH_H\r
+#define _MACHINE_MATH_H\r
+\r
+//#define __HUGE_VAL  ???????????.?????????????\r
+\r
+#endif    /* _MACHINE_MATH_H */\r
diff --git a/StdLib/Include/Ia32/machine/ansi.h b/StdLib/Include/Ia32/machine/ansi.h
new file mode 100644 (file)
index 0000000..5872eb3
--- /dev/null
@@ -0,0 +1,94 @@
+/*     $NetBSD: ansi.h,v 1.19 2006/10/04 13:52:00 tnozaki Exp $        */\r
+\r
+/*-\r
+ * Copyright (c) 1990, 1993\r
+ *     The Regents of the University of California.  All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the University nor the names of its contributors\r
+ *    may be used to endorse or promote products derived from this software\r
+ *    without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ *     @(#)ansi.h      8.2 (Berkeley) 1/4/94\r
+ */\r
+\r
+#ifndef        _ANSI_H_\r
+#define        _ANSI_H_\r
+\r
+#include  <sys/EfiCdefs.h>\r
+\r
+#include <machine/int_types.h>\r
+\r
+/*\r
+ * Types which are fundamental to the implementation and may appear in\r
+ * more than one standard header are defined here.  Standard headers\r
+ * then use:\r
+ *     #ifdef  _BSD_SIZE_T_\r
+ *     typedef _BSD_SIZE_T_ size_t;\r
+ *     #undef  _BSD_SIZE_T_\r
+ *     #endif\r
+ */\r
+#define _BSD_CLOCK_T_     _EFI_CLOCK_T      /* clock() */\r
+#define _BSD_PTRDIFF_T_   _EFI_PTRDIFF_T_   /* ptr1 - ptr2 */\r
+#define _BSD_SIZE_T_      _EFI_SIZE_T_      /* sizeof() */\r
+#define _BSD_SSIZE_T_     INTN              /* byte count or error */\r
+#define _BSD_TIME_T_      _EFI_TIME_T       /* time() */\r
+#define _BSD_VA_LIST_     VA_LIST\r
+#define _BSD_CLOCKID_T_   INT64             /* clockid_t */\r
+#define _BSD_TIMER_T_     INT64             /* timer_t */\r
+#define _BSD_SUSECONDS_T_ INT64             /* suseconds_t */\r
+#define _BSD_USECONDS_T_  UINT64            /* useconds_t */\r
+\r
+/*\r
+ * NOTE: rune_t is not covered by ANSI nor other standards, and should not\r
+ * be instantiated outside of lib/libc/locale.  use wchar_t.\r
+ *\r
+ * Runes (wchar_t) is declared to be an ``int'' instead of the more natural\r
+ * ``unsigned long'' or ``long''.  Two things are happening here.  It is not\r
+ * unsigned so that EOF (-1) can be naturally assigned to it and used.  Also,\r
+ * it looks like 10646 will be a 31 bit standard.  This means that if your\r
+ * ints cannot hold 32 bits, you will be in trouble.  The reason an int was\r
+ * chosen over a long is that the is*() and to*() routines take ints (says\r
+ * ANSI C), but they use _RUNE_T_ instead of int.  By changing it here, you\r
+ * lose a bit of ANSI conformance, but your programs will still work.\r
+ *    \r
+ * Note that _WCHAR_T_ and _RUNE_T_ must be of the same type.  When wchar_t\r
+ * and rune_t are typedef'd, _WCHAR_T_ will be undef'd, but _RUNE_T remains\r
+ * defined for ctype.h.\r
+ */\r
+#define _BSD_WCHAR_T_     _EFI_WCHAR_T    /* wchar_t */\r
+#define _BSD_WINT_T_      _EFI_WINT_T     /* wint_t */\r
+#define _BSD_RUNE_T_      _EFI_WCHAR_T    /* rune_t */\r
+#define _BSD_WCTRANS_T_                void *          /* wctrans_t */\r
+#define _BSD_WCTYPE_T_    unsigned int    /* wctype_t */\r
+\r
+/*\r
+ * mbstate_t is an opaque object to keep conversion state, during multibyte\r
+ * stream conversions.  The content must not be referenced by user programs.\r
+ */\r
+typedef union {\r
+       __int64_t __mbstateL;   /* for alignment */\r
+       char __mbstate8[128];\r
+} __mbstate_t;\r
+#define        _BSD_MBSTATE_T_         __mbstate_t     /* mbstate_t */\r
+\r
+#endif /* _ANSI_H_ */\r
diff --git a/StdLib/Include/Ia32/machine/asm.h b/StdLib/Include/Ia32/machine/asm.h
new file mode 100644 (file)
index 0000000..3d8f11f
--- /dev/null
@@ -0,0 +1,208 @@
+/*     $NetBSD: asm.h,v 1.30 2006/01/20 22:02:40 christos Exp $        */\r
+\r
+/*-\r
+ * Copyright (c) 1990 The Regents of the University of California.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to Berkeley by\r
+ * William Jolitz.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. Neither the name of the University nor the names of its contributors\r
+ *    may be used to endorse or promote products derived from this software\r
+ *    without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ *     @(#)asm.h       5.5 (Berkeley) 5/7/91\r
+ */\r
+\r
+#ifndef _I386_ASM_H_\r
+#define _I386_ASM_H_\r
+\r
+#ifdef _KERNEL_OPT\r
+#include "opt_multiprocessor.h"\r
+#endif\r
+\r
+#ifdef PIC\r
+#define PIC_PROLOGUE   \\r
+       pushl   %ebx;   \\r
+       call    1f;     \\r
+1:                     \\r
+       popl    %ebx;   \\r
+       addl    $_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx\r
+#define PIC_EPILOGUE   \\r
+       popl    %ebx\r
+#define PIC_PLT(x)     x@PLT\r
+#define PIC_GOT(x)     x@GOT(%ebx)\r
+#define PIC_GOTOFF(x)  x@GOTOFF(%ebx)\r
+#else\r
+#define PIC_PROLOGUE\r
+#define PIC_EPILOGUE\r
+#define PIC_PLT(x)     x\r
+#define PIC_GOT(x)     x\r
+#define PIC_GOTOFF(x)  x\r
+#endif\r
+\r
+#ifdef __ELF__\r
+# define _C_LABEL(x)   x\r
+#else\r
+# ifdef __STDC__\r
+#  define _C_LABEL(x)  _ ## x\r
+# else\r
+#  define _C_LABEL(x)  _/**/x\r
+# endif\r
+#endif\r
+#define        _ASM_LABEL(x)   x\r
+\r
+#define CVAROFF(x, y)          _C_LABEL(x) + y\r
+\r
+#ifdef __STDC__\r
+# define __CONCAT(x,y) x ## y\r
+# define __STRING(x)   #x\r
+#else\r
+# define __CONCAT(x,y) x/**/y\r
+# define __STRING(x)   "x"\r
+#endif\r
+\r
+/* let kernels and others override entrypoint alignment */\r
+#if !defined(_ALIGN_TEXT) && !defined(_KERNEL)\r
+# ifdef __ELF__\r
+#  define _ALIGN_TEXT .align 4\r
+# else\r
+#  define _ALIGN_TEXT .align 2\r
+# endif\r
+#endif\r
+\r
+#define _ENTRY(x) \\r
+       .text; _ALIGN_TEXT; .globl x; .type x,@function; x:\r
+\r
+#ifdef _KERNEL\r
+\r
+#if defined(MULTIPROCESSOR)\r
+#define CPUVAR(off) %fs:__CONCAT(CPU_INFO_,off)\r
+#else\r
+#define CPUVAR(off) _C_LABEL(cpu_info_primary)+__CONCAT(CPU_INFO_,off)\r
+#endif /* MULTIPROCESSOR */\r
+\r
+/* XXX Can't use __CONCAT() here, as it would be evaluated incorrectly. */\r
+#ifdef __ELF__\r
+#ifdef __STDC__\r
+#define        IDTVEC(name) \\r
+       ALIGN_TEXT; .globl X ## name; .type X ## name,@function; X ## name:\r
+#else \r
+#define        IDTVEC(name) \\r
+       ALIGN_TEXT; .globl X/**/name; .type X/**/name,@function; X/**/name:\r
+#endif /* __STDC__ */ \r
+#else \r
+#ifdef __STDC__\r
+#define        IDTVEC(name) \\r
+       ALIGN_TEXT; .globl _X ## name; .type _X ## name,@function; _X ## name: \r
+#else\r
+#define        IDTVEC(name) \\r
+       ALIGN_TEXT; .globl _X/**/name; .type _X/**/name,@function; _X/**/name:\r
+#endif /* __STDC__ */\r
+#endif /* __ELF__ */\r
+\r
+#ifdef __ELF__\r
+#define ALIGN_DATA     .align  4\r
+#define ALIGN_TEXT     .align  4,0x90  /* 4-byte boundaries, NOP-filled */\r
+#define SUPERALIGN_TEXT        .align  16,0x90 /* 16-byte boundaries better for 486 */\r
+#else\r
+#define ALIGN_DATA     .align  2\r
+#define ALIGN_TEXT     .align  2,0x90  /* 4-byte boundaries, NOP-filled */\r
+#define SUPERALIGN_TEXT        .align  4,0x90  /* 16-byte boundaries better for 486 */\r
+#endif /* __ELF__ */\r
+\r
+#define _ALIGN_TEXT ALIGN_TEXT\r
+\r
+#ifdef GPROF\r
+#ifdef __ELF__\r
+#define        MCOUNT_ASM      call    _C_LABEL(__mcount)\r
+#else /* __ELF__ */\r
+#define        MCOUNT_ASM      call    _C_LABEL(mcount)\r
+#endif /* __ELF__ */\r
+#else /* GPROF */\r
+#define        MCOUNT_ASM      /* nothing */\r
+#endif /* GPROF */\r
+\r
+#endif /* _KERNEL */\r
+\r
+\r
+\r
+#ifdef GPROF\r
+# ifdef __ELF__\r
+#  define _PROF_PROLOGUE       \\r
+       pushl %ebp; movl %esp,%ebp; call PIC_PLT(__mcount); popl %ebp\r
+# else \r
+#  define _PROF_PROLOGUE       \\r
+       pushl %ebp; movl %esp,%ebp; call PIC_PLT(mcount); popl %ebp\r
+# endif\r
+#else\r
+# define _PROF_PROLOGUE\r
+#endif\r
+\r
+#define        ENTRY(y)        _ENTRY(_C_LABEL(y)); _PROF_PROLOGUE\r
+#define        NENTRY(y)       _ENTRY(_C_LABEL(y))\r
+#define        ASENTRY(y)      _ENTRY(_ASM_LABEL(y)); _PROF_PROLOGUE\r
+\r
+#define        ASMSTR          .asciz\r
+\r
+#ifdef __ELF__\r
+#define RCSID(x)       .section ".ident"; .asciz x\r
+#else\r
+#define RCSID(x)       .text; .asciz x\r
+#endif\r
+\r
+#ifdef NO_KERNEL_RCSIDS\r
+#define        __KERNEL_RCSID(_n, _s)  /* nothing */\r
+#else\r
+#define        __KERNEL_RCSID(_n, _s)  RCSID(_s)\r
+#endif\r
+\r
+#ifdef __ELF__\r
+#define        WEAK_ALIAS(alias,sym)                                           \\r
+       .weak alias;                                                    \\r
+       alias = sym\r
+#endif\r
+/*\r
+ * STRONG_ALIAS: create a strong alias.\r
+ */\r
+#define STRONG_ALIAS(alias,sym)                                                \\r
+       .globl alias;                                                   \\r
+       alias = sym\r
+\r
+#ifdef __STDC__\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg ## ,30,0,0,0 ;                                       \\r
+       .stabs __STRING(_C_LABEL(sym)) ## ,1,0,0,0\r
+#elif defined(__ELF__)\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg,30,0,0,0 ;                                           \\r
+       .stabs __STRING(sym),1,0,0,0\r
+#else\r
+#define        WARN_REFERENCES(sym,msg)                                        \\r
+       .stabs msg,30,0,0,0 ;                                           \\r
+       .stabs __STRING(_/**/sym),1,0,0,0\r
+#endif /* __STDC__ */\r
+\r
+\r
+\r
+#endif /* !_I386_ASM_H_ */\r
diff --git a/StdLib/Include/Ia32/machine/bswap.h b/StdLib/Include/Ia32/machine/bswap.h
new file mode 100644 (file)
index 0000000..7016f7c
--- /dev/null
@@ -0,0 +1,13 @@
+/*      $NetBSD: bswap.h,v 1.3 2006/01/31 07:49:18 dsl Exp $      */\r
+\r
+/* Written by Manuel Bouyer. Public domain */\r
+\r
+#ifndef _MACHINE_BSWAP_H_\r
+#define        _MACHINE_BSWAP_H_\r
+\r
+#include <machine/byte_swap.h>\r
+\r
+#define __BSWAP_RENAME\r
+#include <sys/bswap.h>\r
+\r
+#endif /* !_MACHINE_BSWAP_H_ */\r
diff --git a/StdLib/Include/Ia32/machine/byte_swap.h b/StdLib/Include/Ia32/machine/byte_swap.h
new file mode 100644 (file)
index 0000000..db16c97
--- /dev/null
@@ -0,0 +1,79 @@
+/*     $NetBSD: byte_swap.h,v 1.10 2006/01/30 22:46:36 dsl Exp $       */\r
+\r
+/*-\r
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to The NetBSD Foundation\r
+ * by Charles M. Hannum.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *        This product includes software developed by the NetBSD\r
+ *        Foundation, Inc. and its contributors.\r
+ * 4. Neither the name of The NetBSD Foundation nor the names of its\r
+ *    contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS\r
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS\r
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef _I386_BYTE_SWAP_H_\r
+#define        _I386_BYTE_SWAP_H_\r
+\r
+#include <sys/types.h>\r
+\r
+#if defined(_KERNEL_OPT)\r
+#include "opt_cputype.h"\r
+#endif\r
+\r
+#ifdef  __GNUC__\r
+#include <sys/types.h>\r
+__BEGIN_DECLS\r
+\r
+#define        __BYTE_SWAP_U32_VARIABLE __byte_swap_u32_variable\r
+static __inline uint32_t __byte_swap_u32_variable(uint32_t);\r
+static __inline uint32_t\r
+__byte_swap_u32_variable(uint32_t x)\r
+{\r
+       __asm volatile (\r
+#if defined(_KERNEL) && !defined(_LKM) && !defined(I386_CPU)\r
+           "bswap %1"\r
+#else\r
+           "rorw $8, %w1\n\trorl $16, %1\n\trorw $8, %w1"\r
+#endif\r
+           : "=r" (x) : "0" (x));\r
+       return (x);\r
+}\r
+\r
+#define        __BYTE_SWAP_U16_VARIABLE __byte_swap_u16_variable\r
+static __inline uint16_t __byte_swap_u16_variable(uint16_t);\r
+static __inline uint16_t\r
+__byte_swap_u16_variable(uint16_t x)\r
+{\r
+       __asm volatile ("rorw $8, %w1" : "=r" (x) : "0" (x)); \r
+       return (x);\r
+}\r
+\r
+__END_DECLS\r
+#endif\r
+\r
+#endif /* !_I386_BYTE_SWAP_H_ */\r
diff --git a/StdLib/Include/Ia32/machine/endian.h b/StdLib/Include/Ia32/machine/endian.h
new file mode 100644 (file)
index 0000000..8c2cfd1
--- /dev/null
@@ -0,0 +1,3 @@
+/*     $NetBSD: endian.h,v 1.29 2000/03/17 00:09:20 mycroft Exp $      */\r
+\r
+#include <sys/endian.h>\r
diff --git a/StdLib/Include/Ia32/machine/endian_machdep.h b/StdLib/Include/Ia32/machine/endian_machdep.h
new file mode 100644 (file)
index 0000000..83947a5
--- /dev/null
@@ -0,0 +1,3 @@
+/*     $NetBSD: endian_machdep.h,v 1.3 2006/01/30 21:52:38 dsl Exp $   */\r
+\r
+#define _BYTE_ORDER _LITTLE_ENDIAN\r
diff --git a/StdLib/Include/Ia32/machine/float.h b/StdLib/Include/Ia32/machine/float.h
new file mode 100644 (file)
index 0000000..c7dc620
--- /dev/null
@@ -0,0 +1,3 @@
+/*  $NetBSD: float.h,v 1.12 2003/02/26 21:29:00 fvdl Exp $  */\r
+\r
+#include <x86/float.h>\r
diff --git a/StdLib/Include/Ia32/machine/ieee.h b/StdLib/Include/Ia32/machine/ieee.h
new file mode 100644 (file)
index 0000000..17a1d48
--- /dev/null
@@ -0,0 +1,3 @@
+/*     $NetBSD: ieee.h,v 1.2 2003/02/26 21:29:01 fvdl Exp $    */\r
+\r
+#include <x86/ieee.h>\r
diff --git a/StdLib/Include/Ia32/machine/int_const.h b/StdLib/Include/Ia32/machine/int_const.h
new file mode 100644 (file)
index 0000000..c3a59d7
--- /dev/null
@@ -0,0 +1,63 @@
+/*     $NetBSD: int_const.h,v 1.1 2001/04/14 22:38:38 kleink Exp $     */\r
+\r
+/*-\r
+ * Copyright (c) 2001 The NetBSD Foundation, Inc.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to The NetBSD Foundation\r
+ * by Klaus Klein.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *        This product includes software developed by the NetBSD\r
+ *        Foundation, Inc. and its contributors.\r
+ * 4. Neither the name of The NetBSD Foundation nor the names of its\r
+ *    contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS\r
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS\r
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+ */\r
+\r
+#ifndef _I386_INT_CONST_H_\r
+#define _I386_INT_CONST_H_\r
+\r
+/*\r
+ * 7.18.4 Macros for integer constants\r
+ */\r
+\r
+/* 7.18.4.1 Macros for minimum-width integer constants */\r
+\r
+#define        INT8_C(c)       c\r
+#define        INT16_C(c)      c\r
+#define        INT32_C(c)      c\r
+#define        INT64_C(c)      c ## LL\r
+\r
+#define        UINT8_C(c)      c ## U\r
+#define        UINT16_C(c)     c ## U\r
+#define        UINT32_C(c)     c ## U\r
+#define        UINT64_C(c)     c ## ULL\r
+\r
+/* 7.18.4.2 Macros for greatest-width integer constants */\r
+\r
+#define        INTMAX_C(c)     c ## LL\r
+#define        UINTMAX_C(c)    c ## ULL\r
+\r
+#endif /* !_I386_INT_CONST_H_ */\r
diff --git a/StdLib/Include/Ia32/machine/int_limits.h b/StdLib/Include/Ia32/machine/int_limits.h
new file mode 100644 (file)
index 0000000..b0aa9d5
--- /dev/null
@@ -0,0 +1,141 @@
+/** @file\r
+  7.18.2 Limits of specified-width integer types.\r
+\r
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>\r
+  This program and the accompanying materials are licensed and made available under\r
+  the terms and conditions of the BSD License that accompanies this distribution.\r
+  The full text of the license may be found at\r
+  http://opensource.org/licenses/bsd-license.\r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+ * Copyright (c) 2001 The NetBSD Foundation, Inc.\r
+ * All rights reserved.\r
+ *\r
+ * This code is derived from software contributed to The NetBSD Foundation\r
+ * by Klaus Klein.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ * 3. All advertising materials mentioning features or use of this software\r
+ *    must display the following acknowledgement:\r
+ *        This product includes software developed by the NetBSD\r
+ *        Foundation, Inc. and its contributors.\r
+ * 4. Neither the name of The NetBSD Foundation nor the names of its\r
+ *    contributors may be used to endorse or promote products derived\r
+ *    from this software without specific prior written permission.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS\r
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED\r
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS\r
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\r
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\r
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
+ * POSSIBILITY OF SUCH DAMAGE.\r
+\r
+  NetBSD: int_limits.h,v 1.5 2004/05/22 14:16:59 kleink Exp\r
+**/\r
+#ifndef _I386_INT_LIMITS_H_\r
+#define _I386_INT_LIMITS_H_\r
+\r
+/* 7.18.2.1 Limits of exact-width integer types */\r
+\r
+/* minimum values of exact-width signed integer types */\r
+#define INT8_MIN  ((-0x7f)-1)     /* int8_t   */\r
+#define INT16_MIN ((-0x7fff)-1)     /* int16_t    */\r
+#define INT32_MIN ((-0x7fffffff)-1)     /* int32_t    */\r
+#define INT64_MIN ((-0x7fffffffffffffffLL)-1) /* int64_t    */\r
+\r
+/* maximum values of exact-width signed integer types */\r
+#define INT8_MAX  0x7f        /* int8_t   */\r
+#define INT16_MAX 0x7fff        /* int16_t    */\r
+#define INT32_MAX 0x7fffffff      /* int32_t    */\r
+#define INT64_MAX 0x7fffffffffffffffLL    /* int64_t    */\r
+\r
+/* maximum values of exact-width unsigned integer types */\r
+#define UINT8_MAX 0xffU     &nb