- remove ddcxinfos, replaced by monitor-edid (which is in a separate package)

- add many resolutions (they are structured by aspect ratio for next move)
- put the "Monitor preferred modeline" from EDID in xorg.conf
- for this ModeLine must be exported from the monitor section
- specifying a VendorName|ModelName in auto_inst is valid, don't overwrite it with edid probe
- the strange /dev/zero needed (?) by ddcxinfos is no more needed
- field {size} is now {diagonal_size}, and is no more "corrected"
- add @CVT_ratios and @CVT_vfreqs (unused at the moment)
- Getopt::Long is needed by monitor-parse-edid

1 files changed, 0 insertions, 765 deletions

diff --git a/tools/ddcprobe/x86emu/validate.c b/tools/ddcprobe/x86emu/validate.c
deleted file mode 100644
index 239f6c1f3..000000000
--- a/tools/ddcprobe/x86emu/validate.c
+++ /dev/null
@@ -1,765 +0,0 @@
-/****************************************************************************
-*
-*						Realmode X86 Emulator Library
-*
-*            	Copyright (C) 1996-1999 SciTech Software, Inc.
-* 				     Copyright (C) David Mosberger-Tang
-* 					   Copyright (C) 1999 Egbert Eich
-*
-*  ========================================================================
-*
-*  Permission to use, copy, modify, distribute, and sell this software and
-*  its documentation for any purpose is hereby granted without fee,
-*  provided that the above copyright notice appear in all copies and that
-*  both that copyright notice and this permission notice appear in
-*  supporting documentation, and that the name of the authors not be used
-*  in advertising or publicity pertaining to distribution of the software
-*  without specific, written prior permission.  The authors makes no
-*  representations about the suitability of this software for any purpose.
-*  It is provided "as is" without express or implied warranty.
-*
-*  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-*  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
-*  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
-*  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
-*  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-*  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-*  PERFORMANCE OF THIS SOFTWARE.
-*
-*  ========================================================================
-*
-* Language:     Watcom C 10.6 or later
-* Environment:  32-bit DOS
-* Developer:    Kendall Bennett
-*
-* Description:  Program to validate the x86 emulator library for
-*               correctness. We run the emulator primitive operations
-*               functions against the real x86 CPU, and compare the result
-*               and flags to ensure correctness.
-*
-*               We use inline assembler to compile and build this program.
-*
-****************************************************************************/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include "x86emu.h"
-#include "x86emu/prim_asm.h"
-
-/*-------------------------- Implementation -------------------------------*/
-
-#define true 1
-#define false 0
-
-#define ALL_FLAGS   (F_CF | F_PF | F_AF | F_ZF | F_SF | F_OF)
-
-#define VAL_START_BINARY(parm_type,res_type,dmax,smax,dincr,sincr)  \
-{                                                                   \
-    parm_type   d,s;                                                \
-    res_type    r,r_asm;                                            \
-	ulong     	flags,inflags;                                      \
-	int         f,failed = false;                                   \
-    char        buf1[80],buf2[80];                                  \
-    for (d = 0; d < dmax; d += dincr) {                             \
-        for (s = 0; s < smax; s += sincr) {                         \
-            M.x86.R_EFLG = inflags = flags = def_flags;             \
-            for (f = 0; f < 2; f++) {
-
-#define VAL_TEST_BINARY(name)                                           \
-                r_asm = name##_asm(&flags,d,s);                         \
-                r = name(d,s);                                  \
-                if (r != r_asm || M.x86.R_EFLG != flags)                \
-                    failed = true;                                      \
-                if (failed || trace) {
-
-#define VAL_TEST_BINARY_VOID(name)                                      \
-                name##_asm(&flags,d,s);                                 \
-                name(d,s);                                      \
-                r = r_asm = 0;                                          \
-                if (M.x86.R_EFLG != flags)                              \
-                    failed = true;                                      \
-                if (failed || trace) {
-
-#define VAL_FAIL_BYTE_BYTE_BINARY(name)                                                                 \
-                    if (failed)                                                                         \
-                        printk("fail\n");                                                               \
-                    printk("0x%02X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
-                        r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
-                    printk("0x%02X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
-                        r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_FAIL_WORD_WORD_BINARY(name)                                                                 \
-                    if (failed)                                                                         \
-                        printk("fail\n");                                                               \
-                    printk("0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                         \
-                        r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));   \
-                    printk("0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                         \
-                        r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_FAIL_LONG_LONG_BINARY(name)                                                                 \
-                    if (failed)                                                                         \
-                        printk("fail\n");                                                               \
-                    printk("0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                         \
-                        r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG)); \
-                    printk("0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                         \
-                        r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_END_BINARY()                                                    \
-                    }                                                       \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_BYTE_BYTE_BINARY(name)          \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_BINARY(u8,u8,0xFF,0xFF,1,1)   \
-    VAL_TEST_BINARY(name)                   \
-    VAL_FAIL_BYTE_BYTE_BINARY(name)         \
-    VAL_END_BINARY()
-
-#define VAL_WORD_WORD_BINARY(name)                      \
-    printk("Validating %s ... ", #name);                \
-    VAL_START_BINARY(u16,u16,0xFF00,0xFF00,0x100,0x100) \
-    VAL_TEST_BINARY(name)                               \
-    VAL_FAIL_WORD_WORD_BINARY(name)                     \
-    VAL_END_BINARY()
-
-#define VAL_LONG_LONG_BINARY(name)                                      \
-    printk("Validating %s ... ", #name);                                \
-    VAL_START_BINARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000) \
-    VAL_TEST_BINARY(name)                                               \
-    VAL_FAIL_LONG_LONG_BINARY(name)                                     \
-    VAL_END_BINARY()
-
-#define VAL_VOID_BYTE_BINARY(name)          \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_BINARY(u8,u8,0xFF,0xFF,1,1)   \
-    VAL_TEST_BINARY_VOID(name)              \
-    VAL_FAIL_BYTE_BYTE_BINARY(name)         \
-    VAL_END_BINARY()
-
-#define VAL_VOID_WORD_BINARY(name)                      \
-    printk("Validating %s ... ", #name);                \
-    VAL_START_BINARY(u16,u16,0xFF00,0xFF00,0x100,0x100) \
-    VAL_TEST_BINARY_VOID(name)                          \
-    VAL_FAIL_WORD_WORD_BINARY(name)                     \
-    VAL_END_BINARY()
-
-#define VAL_VOID_LONG_BINARY(name)                                      \
-    printk("Validating %s ... ", #name);                                \
-    VAL_START_BINARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000) \
-    VAL_TEST_BINARY_VOID(name)                                          \
-    VAL_FAIL_LONG_LONG_BINARY(name)                                     \
-    VAL_END_BINARY()
-
-#define VAL_BYTE_ROTATE(name)               \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_BINARY(u8,u8,0xFF,8,1,1)      \
-    VAL_TEST_BINARY(name)                   \
-    VAL_FAIL_BYTE_BYTE_BINARY(name)         \
-    VAL_END_BINARY()
-
-#define VAL_WORD_ROTATE(name)                           \
-    printk("Validating %s ... ", #name);                \
-    VAL_START_BINARY(u16,u16,0xFF00,16,0x100,1)         \
-    VAL_TEST_BINARY(name)                               \
-    VAL_FAIL_WORD_WORD_BINARY(name)                     \
-    VAL_END_BINARY()
-
-#define VAL_LONG_ROTATE(name)                                           \
-    printk("Validating %s ... ", #name);                                \
-    VAL_START_BINARY(u32,u32,0xFF000000,32,0x1000000,1)                 \
-    VAL_TEST_BINARY(name)                                               \
-    VAL_FAIL_LONG_LONG_BINARY(name)                                     \
-    VAL_END_BINARY()
-
-#define VAL_START_TERNARY(parm_type,res_type,dmax,smax,dincr,sincr,maxshift)\
-{                                                                   \
-    parm_type   d,s;                                                \
-    res_type    r,r_asm;                                            \
-    u8          shift;                                              \
-	u32         flags,inflags;                                      \
-    int         f,failed = false;                                   \
-    char        buf1[80],buf2[80];                                  \
-    for (d = 0; d < dmax; d += dincr) {                             \
-        for (s = 0; s < smax; s += sincr) {                         \
-            for (shift = 0; shift < maxshift; shift += 1) {        \
-                M.x86.R_EFLG = inflags = flags = def_flags;         \
-                for (f = 0; f < 2; f++) {
-
-#define VAL_TEST_TERNARY(name)                                          \
-                    r_asm = name##_asm(&flags,d,s,shift);               \
-                    r = name(d,s,shift);                           \
-                    if (r != r_asm || M.x86.R_EFLG != flags)            \
-                        failed = true;                                  \
-                    if (failed || trace) {
-
-#define VAL_FAIL_WORD_WORD_TERNARY(name)                                                                \
-                        if (failed)                                                                         \
-                            printk("fail\n");                                                               \
-                        printk("0x%04X = %-15s(0x%04X,0x%04X,%d), flags = %s -> %s\n",                      \
-                            r, #name, d, s, shift, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));   \
-                        printk("0x%04X = %-15s(0x%04X,0x%04X,%d), flags = %s -> %s\n",                      \
-                            r_asm, #name"_asm", d, s, shift, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_FAIL_LONG_LONG_TERNARY(name)                                                                \
-                        if (failed)                                                                         \
-                            printk("fail\n");                                                               \
-                        printk("0x%08X = %-15s(0x%08X,0x%08X,%d), flags = %s -> %s\n",                      \
-                            r, #name, d, s, shift, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));  \
-                        printk("0x%08X = %-15s(0x%08X,0x%08X,%d), flags = %s -> %s\n",                      \
-                            r_asm, #name"_asm", d, s, shift, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_END_TERNARY()                                                   \
-                        }                                                       \
-                    M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                    if (failed)                                                 \
-                        break;                                                  \
-                    }                                                           \
-                if (failed)                                                     \
-                    break;                                                      \
-                }                                                               \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_WORD_ROTATE_DBL(name)                           \
-    printk("Validating %s ... ", #name);                    \
-    VAL_START_TERNARY(u16,u16,0xFF00,0xFF00,0x100,0x100,16) \
-    VAL_TEST_TERNARY(name)                                  \
-    VAL_FAIL_WORD_WORD_TERNARY(name)                        \
-    VAL_END_TERNARY()
-
-#define VAL_LONG_ROTATE_DBL(name)                                           \
-    printk("Validating %s ... ", #name);                                    \
-    VAL_START_TERNARY(u32,u32,0xFF000000,0xFF000000,0x1000000,0x1000000,32) \
-    VAL_TEST_TERNARY(name)                                                  \
-    VAL_FAIL_LONG_LONG_TERNARY(name)                                        \
-    VAL_END_TERNARY()
-
-#define VAL_START_UNARY(parm_type,max,incr)                 \
-{                                                           \
-    parm_type   d,r,r_asm;                                  \
-	u32         flags,inflags;                              \
-    int         f,failed = false;                           \
-    char        buf1[80],buf2[80];                          \
-    for (d = 0; d < max; d += incr) {                       \
-        M.x86.R_EFLG = inflags = flags = def_flags;         \
-        for (f = 0; f < 2; f++) {
-
-#define VAL_TEST_UNARY(name)                                \
-            r_asm = name##_asm(&flags,d);                   \
-            r = name(d);                                \
-            if (r != r_asm || M.x86.R_EFLG != flags) {      \
-                failed = true;
-
-#define VAL_FAIL_BYTE_UNARY(name)                                                               \
-                printk("fail\n");                                                               \
-                printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n",                            \
-                    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));    \
-                printk("0x%02X = %-15s(0x%02X), flags = %s -> %s\n",                            \
-                    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_FAIL_WORD_UNARY(name)                                                               \
-                printk("fail\n");                                                               \
-                printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n",                            \
-                    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));  \
-                printk("0x%04X = %-15s(0x%04X), flags = %s -> %s\n",                            \
-                    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_FAIL_LONG_UNARY(name)                                                               \
-                printk("fail\n");                                                               \
-                printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n",                            \
-                    r, #name, d, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));    \
-                printk("0x%08X = %-15s(0x%08X), flags = %s -> %s\n",                            \
-                    r_asm, #name"_asm", d, print_flags(buf1,inflags), print_flags(buf2,flags));
-
-#define VAL_END_UNARY()                                                 \
-                }                                                       \
-            M.x86.R_EFLG = inflags = flags = def_flags | ALL_FLAGS;     \
-            if (failed)                                                 \
-                break;                                                  \
-            }                                                           \
-        if (failed)                                                     \
-            break;                                                      \
-        }                                                               \
-    if (!failed)                                                        \
-        printk("passed\n");                                             \
-}
-
-#define VAL_BYTE_UNARY(name)                \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_UNARY(u8,0xFF,0x1)            \
-    VAL_TEST_UNARY(name)                    \
-    VAL_FAIL_BYTE_UNARY(name)               \
-    VAL_END_UNARY()
-
-#define VAL_WORD_UNARY(name)                \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_UNARY(u16,0xFF00,0x100)       \
-    VAL_TEST_UNARY(name)                    \
-    VAL_FAIL_WORD_UNARY(name)               \
-    VAL_END_UNARY()
-
-#define VAL_WORD_BYTE_UNARY(name)           \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_UNARY(u16,0xFF,0x1)           \
-    VAL_TEST_UNARY(name)                    \
-    VAL_FAIL_WORD_UNARY(name)               \
-    VAL_END_UNARY()
-
-#define VAL_LONG_UNARY(name)                \
-    printk("Validating %s ... ", #name);    \
-    VAL_START_UNARY(u32,0xFF000000,0x1000000) \
-    VAL_TEST_UNARY(name)                    \
-    VAL_FAIL_LONG_UNARY(name)               \
-    VAL_END_UNARY()
-
-#define VAL_BYTE_MUL(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u8          d,s;                                                    \
-    u16         r,r_asm;                                                \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF; d += 1) {                                     \
-        for (s = 0; s < 0xFF; s += 1) {                                 \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                name##_asm(&flags,&r_asm,d,s);                          \
-                M.x86.R_AL = d;                                         \
-                name(s);                                            \
-                r = M.x86.R_AX;                                         \
-                if (r != r_asm || M.x86.R_EFLG != flags)                \
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
-                        r, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
-                    printk("0x%04X = %-15s(0x%02X,0x%02X), flags = %s -> %s\n",                         \
-                        r_asm, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
-                    }                                                       \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_WORD_MUL(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u16         d,s;                                                    \
-    u16         r_lo,r_asm_lo;                                          \
-    u16         r_hi,r_asm_hi;                                          \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF00; d += 0x100) {                               \
-        for (s = 0; s < 0xFF00; s += 0x100) {                           \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s);             \
-                M.x86.R_AX = d;                                         \
-                name(s);                                            \
-                r_lo = M.x86.R_AX;                                      \
-                r_hi = M.x86.R_DX;                                      \
-                if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                              \
-                        r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));       \
-                    printk("0x%04X:0x%04X = %-15s(0x%04X,0x%04X), flags = %s -> %s\n",                              \
-                        r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
-                    }                                                                                               \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_LONG_MUL(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u32         d,s;                                                    \
-    u32         r_lo,r_asm_lo;                                          \
-    u32         r_hi,r_asm_hi;                                          \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF000000; d += 0x1000000) {                       \
-        for (s = 0; s < 0xFF000000; s += 0x1000000) {                   \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                name##_asm(&flags,&r_asm_lo,&r_asm_hi,d,s);             \
-                M.x86.R_EAX = d;                                        \
-                name(s);                                            \
-                r_lo = M.x86.R_EAX;                                     \
-                r_hi = M.x86.R_EDX;                                     \
-                if (r_lo != r_asm_lo || r_hi != r_asm_hi || M.x86.R_EFLG != flags)\
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                              \
-                        r_hi,r_lo, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));       \
-                    printk("0x%08X:0x%08X = %-15s(0x%08X,0x%08X), flags = %s -> %s\n",                              \
-                        r_asm_hi,r_asm_lo, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
-                    }                                                                                               \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_BYTE_DIV(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u16         d,s;                                                    \
-    u8          r_quot,r_rem,r_asm_quot,r_asm_rem;                      \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF00; d += 0x100) {                               \
-        for (s = 1; s < 0xFF; s += 1) {                                 \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                M.x86.intr = 0;                                         \
-                M.x86.R_AX = d;                                         \
-                name(s);                                            \
-                r_quot = M.x86.R_AL;                                    \
-                r_rem = M.x86.R_AH;                                     \
-                if (M.x86.intr & INTR_SYNCH)                            \
-                    continue;                                           \
-                name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,s);          \
-                if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n",                      \
-                        r_quot, r_rem, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
-                    printk("0x%02X:0x%02X = %-15s(0x%04X,0x%02X), flags = %s -> %s\n",                      \
-                        r_asm_quot, r_asm_rem, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
-                    }                                                       \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_WORD_DIV(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u32         d,s;                                                    \
-    u16         r_quot,r_rem,r_asm_quot,r_asm_rem;                      \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF000000; d += 0x1000000) {                       \
-        for (s = 0x100; s < 0xFF00; s += 0x100) {                       \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                M.x86.intr = 0;                                         \
-                M.x86.R_AX = d & 0xFFFF;                                \
-                M.x86.R_DX = d >> 16;                                   \
-                name(s);                                            \
-                r_quot = M.x86.R_AX;                                    \
-                r_rem = M.x86.R_DX;                                     \
-                if (M.x86.intr & INTR_SYNCH)                            \
-                    continue;                                           \
-                name##_asm(&flags,&r_asm_quot,&r_asm_rem,d & 0xFFFF,d >> 16,s);\
-                if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%04X:0x%04X = %-15s(0x%08X,0x%04X), flags = %s -> %s\n",                      \
-                        r_quot, r_rem, #name, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));     \
-                    printk("0x%04X:0x%04X = %-15s(0x%08X,0x%04X), flags = %s -> %s\n",                      \
-                        r_asm_quot, r_asm_rem, #name"_asm", d, s, print_flags(buf1,inflags), print_flags(buf2,flags));  \
-                    }                                                       \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-#define VAL_LONG_DIV(name)                                              \
-    printk("Validating %s ... ", #name);                                \
-{                                                                       \
-    u32         d,s;                                                    \
-    u32         r_quot,r_rem,r_asm_quot,r_asm_rem;                      \
-	u32         flags,inflags;                                          \
-    int         f,failed = false;                                       \
-    char        buf1[80],buf2[80];                                      \
-    for (d = 0; d < 0xFF000000; d += 0x1000000) {                       \
-        for (s = 0x100; s < 0xFF00; s += 0x100) {                       \
-            M.x86.R_EFLG = inflags = flags = def_flags;                 \
-            for (f = 0; f < 2; f++) {                                   \
-                M.x86.intr = 0;                                         \
-                M.x86.R_EAX = d;                                        \
-                M.x86.R_EDX = 0;                                        \
-                name(s);                                            \
-                r_quot = M.x86.R_EAX;                                   \
-                r_rem = M.x86.R_EDX;                                    \
-                if (M.x86.intr & INTR_SYNCH)                            \
-                    continue;                                           \
-                name##_asm(&flags,&r_asm_quot,&r_asm_rem,d,0,s);        \
-                if (r_quot != r_asm_quot || r_rem != r_asm_rem || M.x86.R_EFLG != flags) \
-                    failed = true;                                      \
-                if (failed || trace) {                                  \
-                    if (failed)                                         \
-                        printk("fail\n");                               \
-                    printk("0x%08X:0x%08X = %-15s(0x%08X:0x%08X,0x%08X), flags = %s -> %s\n",                       \
-                        r_quot, r_rem, #name, 0, d, s, print_flags(buf1,inflags), print_flags(buf2,M.x86.R_EFLG));  \
-                    printk("0x%08X:0x%08X = %-15s(0x%08X:0x%08X,0x%08X), flags = %s -> %s\n",                       \
-                        r_asm_quot, r_asm_rem, #name"_asm", 0, d, s, print_flags(buf1,inflags), print_flags(buf2,flags));   \
-                    }                                                       \
-                M.x86.R_EFLG = inflags = flags = def_flags | (ALL_FLAGS & ~F_OF);   \
-                if (failed)                                                 \
-                    break;                                                  \
-                }                                                           \
-            if (failed)                                                     \
-                break;                                                      \
-            }                                                               \
-        if (failed)                                                         \
-            break;                                                          \
-        }                                                                   \
-    if (!failed)                                                            \
-        printk("passed\n");                                                 \
-}
-
-void printk(const char *fmt, ...)
-{
-    va_list argptr;
-    va_start(argptr, fmt);
-    vfprintf(stdout, fmt, argptr);
-    fflush(stdout);
-    va_end(argptr);
-}
-
-char * print_flags(char *buf,ulong flags)
-{
-    char *separator = "";
-
-    buf[0] = 0;
-    if (flags & F_CF) {
-        strcat(buf,separator);
-        strcat(buf,"CF");
-        separator = ",";
-        }
-    if (flags & F_PF) {
-        strcat(buf,separator);
-        strcat(buf,"PF");
-        separator = ",";
-        }
-    if (flags & F_AF) {
-        strcat(buf,separator);
-        strcat(buf,"AF");
-        separator = ",";
-        }
-    if (flags & F_ZF) {
-        strcat(buf,separator);
-        strcat(buf,"ZF");
-        separator = ",";
-        }
-    if (flags & F_SF) {
-        strcat(buf,separator);
-        strcat(buf,"SF");
-        separator = ",";
-        }
-    if (flags & F_OF) {
-        strcat(buf,separator);
-        strcat(buf,"OF");
-        separator = ",";
-        }
-    if (separator[0] == 0)
-        strcpy(buf,"None");
-    return buf;
-}
-
-int main(int argc)
-{
-    ulong   def_flags;
-    int trace = false;
-
-    if (argc > 1)
-        trace = true;
-    memset(&M, 0, sizeof(M));
-    def_flags = get_flags_asm() & ~ALL_FLAGS;
-
-    VAL_WORD_UNARY(aaa_word);
-    VAL_WORD_UNARY(aas_word);
-
-    VAL_WORD_UNARY(aad_word);
-    VAL_WORD_UNARY(aam_word);
-
-    VAL_BYTE_BYTE_BINARY(adc_byte);
-    VAL_WORD_WORD_BINARY(adc_word);
-    VAL_LONG_LONG_BINARY(adc_long);
-
-    VAL_BYTE_BYTE_BINARY(add_byte);
-    VAL_WORD_WORD_BINARY(add_word);
-    VAL_LONG_LONG_BINARY(add_long);
-
-    VAL_BYTE_BYTE_BINARY(and_byte);
-    VAL_WORD_WORD_BINARY(and_word);
-    VAL_LONG_LONG_BINARY(and_long);
-
-    VAL_BYTE_BYTE_BINARY(cmp_byte);
-    VAL_WORD_WORD_BINARY(cmp_word);
-    VAL_LONG_LONG_BINARY(cmp_long);
-
-    VAL_BYTE_UNARY(daa_byte);
-    VAL_BYTE_UNARY(das_byte);   // Fails for 0x9A (out of range anyway)
-
-    VAL_BYTE_UNARY(dec_byte);
-    VAL_WORD_UNARY(dec_word);
-    VAL_LONG_UNARY(dec_long);
-
-    VAL_BYTE_UNARY(inc_byte);
-    VAL_WORD_UNARY(inc_word);
-    VAL_LONG_UNARY(inc_long);
-
-    VAL_BYTE_BYTE_BINARY(or_byte);
-    VAL_WORD_WORD_BINARY(or_word);
-    VAL_LONG_LONG_BINARY(or_long);
-
-    VAL_BYTE_UNARY(neg_byte);
-    VAL_WORD_UNARY(neg_word);
-    VAL_LONG_UNARY(neg_long);
-
-    VAL_BYTE_UNARY(not_byte);
-    VAL_WORD_UNARY(not_word);
-    VAL_LONG_UNARY(not_long);
-
-    VAL_BYTE_ROTATE(rcl_byte);
-    VAL_WORD_ROTATE(rcl_word);
-    VAL_LONG_ROTATE(rcl_long);
-
-    VAL_BYTE_ROTATE(rcr_byte);
-    VAL_WORD_ROTATE(rcr_word);
-    VAL_LONG_ROTATE(rcr_long);
-
-    VAL_BYTE_ROTATE(rol_byte);
-    VAL_WORD_ROTATE(rol_word);
-    VAL_LONG_ROTATE(rol_long);
-
-    VAL_BYTE_ROTATE(ror_byte);
-    VAL_WORD_ROTATE(ror_word);
-    VAL_LONG_ROTATE(ror_long);
-
-    VAL_BYTE_ROTATE(shl_byte);
-    VAL_WORD_ROTATE(shl_word);
-    VAL_LONG_ROTATE(shl_long);
-
-    VAL_BYTE_ROTATE(shr_byte);
-    VAL_WORD_ROTATE(shr_word);
-    VAL_LONG_ROTATE(shr_long);
-
-    VAL_BYTE_ROTATE(sar_byte);
-    VAL_WORD_ROTATE(sar_word);
-    VAL_LONG_ROTATE(sar_long);
-
-    VAL_WORD_ROTATE_DBL(shld_word);
-    VAL_LONG_ROTATE_DBL(shld_long);
-
-    VAL_WORD_ROTATE_DBL(shrd_word);
-    VAL_LONG_ROTATE_DBL(shrd_long);
-
-    VAL_BYTE_BYTE_BINARY(sbb_byte);
-    VAL_WORD_WORD_BINARY(sbb_word);
-    VAL_LONG_LONG_BINARY(sbb_long);
-
-    VAL_BYTE_BYTE_BINARY(sub_byte);
-    VAL_WORD_WORD_BINARY(sub_word);
-    VAL_LONG_LONG_BINARY(sub_long);
-
-    VAL_BYTE_BYTE_BINARY(xor_byte);
-    VAL_WORD_WORD_BINARY(xor_word);
-    VAL_LONG_LONG_BINARY(xor_long);
-
-    VAL_VOID_BYTE_BINARY(test_byte);
-    VAL_VOID_WORD_BINARY(test_word);
-    VAL_VOID_LONG_BINARY(test_long);
-
-    VAL_BYTE_MUL(imul_byte);
-    VAL_WORD_MUL(imul_word);
-    VAL_LONG_MUL(imul_long);
-
-    VAL_BYTE_MUL(mul_byte);
-    VAL_WORD_MUL(mul_word);
-    VAL_LONG_MUL(mul_long);
-
-    VAL_BYTE_DIV(idiv_byte);
-    VAL_WORD_DIV(idiv_word);
-    VAL_LONG_DIV(idiv_long);
-
-    VAL_BYTE_DIV(div_byte);
-    VAL_WORD_DIV(div_word);
-    VAL_LONG_DIV(div_long);
-
-    return 0;
-}