xcpt4u.c File Reference

#include "stdio.h"
#include "setjmp.h"
#include "float.h"
#include "windows.h"
#include "math.h"

Include dependency graph for xcpt4u.c:

Go to the source code of this file.

Macros
#define	WIN32_LEAN_AND_MEAN
#define	STATUS_SUCCESS   0
#define	STATUS_UNSUCCESSFUL   ((NTSTATUS)0xC0000001L)
#define	BLUE   0
#define	RED   1

Functions
VOID	addtwo (IN LONG First, IN LONG Second, IN PLONG Place)
VOID	bar1 (IN NTSTATUS Status, IN PLONG Counter)
VOID	bar2 (IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter)
VOID	dojump (IN jmp_buf JumpBuffer, IN PLONG Counter)
LONG	Echo (IN LONG Value)
VOID	eret (IN NTSTATUS Status, IN PLONG Counter)
VOID	except1 (IN PLONG Counter)
ULONG	except2 (IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
ULONG	except3 (IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
VOID	foo1 (IN NTSTATUS Status)
VOID	foo2 (IN PLONG BlackHole, IN PLONG BadAddress)
VOID	fret (IN PLONG Counter)
BOOLEAN	Tkm (VOID)
VOID	Test61Part2 (IN OUT PULONG Counter)
double	SquareDouble (IN double op)
DECLSPEC_NOINLINE ULONG	PgFilter (VOID)
VOID	PgTest69 (IN PLONG State, IN PLONG Fault)
VOID	PgTest70 (IN PLONG State, IN PLONG Fault)
VOID	PgTest71 (IN PLONG State, IN PLONG Fault)
VOID	PgTest72 (IN PLONG State, IN PLONG Fault)
VOID	PgTest73 (IN PLONG State, IN PLONG Fault)
VOID	PgTest74 (IN PLONG State, IN PLONG Fault)
VOID	PgTest75 (IN PLONG State, IN PLONG Fault)
VOID	PgTest76 (IN PLONG State, IN PLONG Fault)
VOID	PgTest77 (IN PLONG State, IN PLONG Fault)
VOID	PgTest78 (IN PLONG State, IN PLONG Fault)
VOID	Test79 (PLONG Counter, PLONG Fault)
ULONG	Test80 (VOID)
void	Test81 (int *pCounter)
DECLSPEC_NOINLINE VOID	Test82Foo (VOID)
VOID	Test82 (__inout PLONG Counter)
LONG	Test83 (VOID)
DECLSPEC_NOINLINE VOID	Test84 (_Inout_ PLONG Counter)
DECLSPEC_NOINLINE LONG	Test85 (_Inout_ PLONG Counter)
DECLSPEC_NOINLINE VOID	Test86 (_Inout_ PLONG Counter)
VOID	Test87 (_Inout_ PLONG Counter)
VOID	Test88 (_Inout_ PLONG Counter)
int	main (int argc, char *argv[])
VOID	addtwo (long First, long Second, long *Place)

Variables
ULONG	G

Macro Definition Documentation

BLUE

#define BLUE   0

Definition at line 65 of file xcpt4u.c.

RED

#define RED   1

Definition at line 66 of file xcpt4u.c.

STATUS_SUCCESS

#define STATUS_SUCCESS   0

Definition at line 55 of file xcpt4u.c.

STATUS_UNSUCCESSFUL

#define STATUS_UNSUCCESSFUL   ((NTSTATUS)0xC0000001L)

Definition at line 58 of file xcpt4u.c.

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 41 of file xcpt4u.c.

Function Documentation

addtwo() [1/2]

VOID addtwo	(	IN LONG	First,
		IN LONG	Second,
		IN PLONG	Place
	)

Referenced by main().

addtwo() [2/2]

VOID addtwo	(	long	First,
		long	Second,
		long *	Place
	)

Definition at line 3256 of file xcpt4u.c.

{

  RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  *Place = First + Second;
  return;
}

bar1()

VOID bar1	(	IN NTSTATUS	Status,
		IN PLONG	Counter
	)

Definition at line 3266 of file xcpt4u.c.

                                                {

  try {
    foo1(Status);
  }
  finally {
    if (abnormal_termination() != FALSE) {
      *Counter = 99;

    } else {
      *Counter = 100;
    }
  }

  return;
}

Referenced by main().

bar2()

VOID bar2	(	IN PLONG	BlackHole,
		IN PLONG	BadAddress,
		IN PLONG	Counter
	)

Definition at line 3283 of file xcpt4u.c.

                                                                     {

  try {
    foo2(BlackHole, BadAddress);
  }
  finally {
    if (abnormal_termination() != FALSE) {
      *Counter = 99;

    } else {
      *Counter = 100;
    }
  }

  return;
}

Referenced by main().

dojump()

VOID dojump	(	IN jmp_buf	JumpBuffer,
		IN PLONG	Counter
	)

Definition at line 3300 of file xcpt4u.c.

{

  try {
    try {
      *Counter += 1;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
    finally { *Counter += 1; }
  }
  finally {
    *Counter += 1;
    longjmp(JumpBuffer, 1);
  }
}

Referenced by main().

Echo()

LONG Echo

(

IN LONG

Value

)

Definition at line 3438 of file xcpt4u.c.

{
  return Value;
}

Referenced by main().

eret()

VOID eret	(	IN NTSTATUS	Status,
		IN PLONG	Counter
	)

Definition at line 3318 of file xcpt4u.c.

{

  try {
    try {
      foo1(Status);
    }
    except((GetExceptionCode() == Status) ? EXCEPTION_EXECUTE_HANDLER
                                          : EXCEPTION_CONTINUE_SEARCH) {
      *Counter += 1;
      return;
    }
  }
  finally { *Counter += 1; }

  return;
}

Referenced by main().

except1()

VOID except1

(

IN PLONG

Counter

)

Definition at line 3338 of file xcpt4u.c.

{

  try {
    *Counter += 5;
    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  }
  except(except3(GetExceptionInformation(), Counter)) { *Counter += 7; }

  *Counter += 9;
  return;
}

Referenced by main().

except2()

ULONG except2	(	IN PEXCEPTION_POINTERS	ExceptionPointers,
		IN PLONG	Counter
	)

Definition at line 3353 of file xcpt4u.c.

{

  PEXCEPTION_RECORD ExceptionRecord;

  ExceptionRecord = ExceptionPointers->ExceptionRecord;
  if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
      ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
    *Counter += 11;
    return EXCEPTION_EXECUTE_HANDLER;

  } else {
    *Counter += 13;
    return EXCEPTION_CONTINUE_SEARCH;
  }
}

Referenced by main().

except3()

ULONG except3	(	IN PEXCEPTION_POINTERS	ExceptionPointers,
		IN PLONG	Counter
	)

Definition at line 3372 of file xcpt4u.c.

{

  PEXCEPTION_RECORD ExceptionRecord;

  ExceptionRecord = ExceptionPointers->ExceptionRecord;
  if ((ExceptionRecord->ExceptionCode == STATUS_INTEGER_OVERFLOW) &&
      ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
    *Counter += 17;
    RtlRaiseStatus(STATUS_UNSUCCESSFUL);

  } else if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
             ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) != 0)) {
    *Counter += 19;
    return EXCEPTION_CONTINUE_SEARCH;
  }

  *Counter += 23;
  return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by except1().

foo1()

VOID foo1

(

IN NTSTATUS

Status

)

Definition at line 3394 of file xcpt4u.c.

{

  //
  // Raise exception.
  //

  RtlRaiseStatus(Status);
  return;
}

Referenced by bar1(), eret(), and main().

foo2()

VOID foo2	(	IN PLONG	BlackHole,
		IN PLONG	BadAddress
	)

Definition at line 3406 of file xcpt4u.c.

{

  //
  // Raise exception.
  //

  *BlackHole += *BadAddress;
  return;
}

Referenced by bar2(), and main().

fret()

VOID fret

(

IN PLONG

Counter

)

Definition at line 3419 of file xcpt4u.c.

{

  try {
    try {
      *Counter += 1;
    }
    finally {
      *Counter += 1;
      return;
    }
  }
  finally { *Counter += 1; }

  return;
}

Referenced by main().

main()

int main	(	int argc	,
		char *	argv[]
	)

hosttype.c Copyright (C) 2002 by Brian Palmer brian.nosp@m.p@sg.nosp@m.inet..nosp@m.com

Definition at line 926 of file xcpt4u.c.

{

  PLONG BadAddress;
  PCHAR BadByte;
  PLONG BlackHole;
  ULONG Index1;
  ULONG Index2 = RED;
  jmp_buf JumpBuffer;
  LONG Counter;
  EXCEPTION_RECORD ExceptionRecord;
  double doubleresult;

  //
  // Announce start of exception test.
  //

  printf("Start of exception test\n");

  //
  // Initialize exception record.
  //

  ExceptionRecord.ExceptionCode = STATUS_INTEGER_OVERFLOW;
  ExceptionRecord.ExceptionFlags = 0;
  ExceptionRecord.ExceptionRecord = NULL;
  ExceptionRecord.NumberParameters = 0;

  //
  // Initialize pointers.
  //

  BadAddress = (PLONG)NULL;
  BadByte = (PCHAR)NULL;
  BadByte += 1;
  BlackHole = &Counter;

  //
  // Simply try statement with a finally clause that is entered sequentially.
  //

  printf("    test1...");
  Counter = 0;
  try {
    Counter += 1;
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 1;
    }
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try statement with an exception clause that is never executed
  // because there is no exception raised in the try clause.
  //

  printf("    test2...");
  Counter = 0;
  try {
    Counter += 1;
  }
  except(Counter) { Counter += 1; }

  if (Counter != 1) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try statement with an exception handler that is never executed
  // because the exception expression continues execution.
  //

  printf("    test3...");
  Counter = 0;
  try {
    Counter -= 1;
    RtlRaiseException(&ExceptionRecord);
  }
  except(Counter) { Counter -= 1; }

  if (Counter != -1) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try statement with an exception clause that is always executed.
  //

  printf("    test4...");
  Counter = 0;
  try {
    Counter += 1;
    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  }
  except(Counter) { Counter += 1; }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try statement with an exception clause that is always executed.
  //

  printf("    test5...");
  Counter = 0;
  try {
    Counter += 1;
    *BlackHole += *BadAddress;
  }
  except(Counter) { Counter += 1; }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simply try statement with a finally clause that is entered as the
  // result of an exception.
  //

  printf("    test6...");
  Counter = 0;
  try {
    try {
      Counter += 1;
      RtlRaiseException(&ExceptionRecord);
    }
    finally {
      if (abnormal_termination() != FALSE) {
        Counter += 1;
      }
    }
  }
  except(Counter) {
    if (Counter == 2) {
      Counter += 1;
    }
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simply try statement with a finally clause that is entered as the
  // result of an exception.
  //

  printf("    test7...");
  Counter = 0;
  try {
    try {
      Counter += 1;
      *BlackHole += *BadAddress;
    }
    finally {
      if (abnormal_termination() != FALSE) {
        Counter += 1;
      }
    }
  }
  except(Counter) {
    if (Counter == 2) {
      Counter += 1;
    }
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try that calls a function which raises an exception.
  //

  printf("    test8...");
  Counter = 0;
  try {
    Counter += 1;
    foo1(STATUS_ACCESS_VIOLATION);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try that calls a function which raises an exception.
  //

  printf("    test9...");
  Counter = 0;
  try {
    Counter += 1;
    foo2(BlackHole, BadAddress);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try that calls a function which calls a function that
  // raises an exception. The first function has a finally clause
  // that must be executed for this test to work.
  //

  printf("    test10...");
  Counter = 0;
  try {
    bar1(STATUS_ACCESS_VIOLATION, &Counter);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter -= 1;
  }

  if (Counter != 98) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try that calls a function which calls a function that
  // raises an exception. The first function has a finally clause
  // that must be executed for this test to work.
  //

  printf("    test11...");
  Counter = 0;
  try {
    bar2(BlackHole, BadAddress, &Counter);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter -= 1;
  }

  if (Counter != 98) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try within an except
  //

  printf("    test12...");
  Counter = 0;
  try {
    foo1(STATUS_ACCESS_VIOLATION);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
    try {
      foo1(STATUS_SUCCESS);
    }
    except((GetExceptionCode() == STATUS_SUCCESS) ? EXCEPTION_EXECUTE_HANDLER
                                                  : EXCEPTION_CONTINUE_SEARCH) {
      if (Counter != 1) {
        printf("failed, count = %d\n", Counter);

      } else {
        printf("succeeded...");
      }

      Counter += 1;
    }
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try within an except
  //

  printf("    test13...");
  Counter = 0;
  try {
    foo2(BlackHole, BadAddress);
  }
  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
    try {
      foo1(STATUS_SUCCESS);
    }
    except((GetExceptionCode() == STATUS_SUCCESS) ? EXCEPTION_EXECUTE_HANDLER
                                                  : EXCEPTION_CONTINUE_SEARCH) {
      if (Counter != 1) {
        printf("failed, count = %d\n", Counter);

      } else {
        printf("succeeded...");
      }

      Counter += 1;
    }
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from except/finally not allowed on WinCE
  //
  // A goto from an exception clause that needs to pass
  // through a finally
  //

  printf("    test14...");
  Counter = 0;
  try {
    try {
      foo1(STATUS_ACCESS_VIOLATION);
    }
    except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
               ? EXCEPTION_EXECUTE_HANDLER
               : EXCEPTION_CONTINUE_SEARCH) {
      Counter += 1;
      goto t9;
    }
  }
  finally { Counter += 1; }

t9:
  ;
  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A goto from an finally clause that needs to pass
  // through a finally
  //

  printf("    test15...");
  Counter = 0;
  try {
    try {
      Counter += 1;
    }
    finally {
      Counter += 1;
      goto t10;
    }
  }
  finally { Counter += 1; }

t10:
  ;
  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A goto from an exception clause that needs to pass
  // through a finally into the outer finally clause.
  //

  printf("    test16...");
  Counter = 0;
  try {
    try {
      try {
        Counter += 1;
        foo1(STATUS_INTEGER_OVERFLOW);
      }
      except(EXCEPTION_EXECUTE_HANDLER) {
        Counter += 1;
        goto t11;
      }
    }
    finally { Counter += 1; }
  t11:
    ;
  }
  finally { Counter += 1; }

  if (Counter != 4) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A goto from an finally clause that needs to pass
  // through a finally into the outer finally clause.
  //

  printf("    test17...");
  Counter = 0;
  try {
    try {
      Counter += 1;
    }
    finally {
      Counter += 1;
      goto t12;
    }
  t12:
    ;
  }
  finally { Counter += 1; }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A return from an except clause
  //

  printf("    test18...");
  Counter = 0;
  try {
    Counter += 1;
    eret(STATUS_ACCESS_VIOLATION, &Counter);
  }
  finally { Counter += 1; }

  if (Counter != 4) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A return from a finally clause
  //

  printf("    test19...");
  Counter = 0;
  try {
    Counter += 1;
    fret(&Counter);
  }
  finally { Counter += 1; }

  if (Counter != 5) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // A simple set jump followed by a long jump.
  //

  printf("    test20...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    Counter += 1;
    longjmp(JumpBuffer, 1);

  } else {
    Counter += 1;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump followed by a long jump out of a finally clause that is
  // sequentially executed.
  //

  printf("    test21...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    try {
      Counter += 1;
    }
    finally {
      Counter += 1;
      longjmp(JumpBuffer, 1);
    }

  } else {
    Counter += 1;
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump within a try clause followed by a long jump out of a
  // finally clause that is sequentially executed.
  //

  printf("    test22...");
  Counter = 0;
  try {
    if (setjmp(JumpBuffer) == 0) {
      Counter += 1;

    } else {
      Counter += 1;
    }
  }
  finally {
    Counter += 1;
    if (Counter == 2) {
      Counter += 1;
      longjmp(JumpBuffer, 1);
    }
  }

  if (Counter != 5) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump followed by a try/except, followed by a try/finally where
  // the try body of the try/finally raises an exception that is handled
  // by the try/excecpt which causes the try/finally to do a long jump out
  // of a finally clause. This will create a collided unwind.
  //

  printf("    test23...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    try {
      try {
        Counter += 1;
        RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
      }
      finally {
        Counter += 1;
        longjmp(JumpBuffer, 1);
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }

  } else {
    Counter += 1;
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump followed by a try/except, followed by a several nested
  // try/finally's where the inner try body of the try/finally raises an
  // exception that is handled by the try/except which causes the
  // try/finally to do a long jump out of a finally clause. This will
  // create a collided unwind.
  //

  printf("    test24...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    try {
      try {
        try {
          try {
            Counter += 1;
            RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
          }
          finally { Counter += 1; }
        }
        finally {
          Counter += 1;
          longjmp(JumpBuffer, 1);
        }
      }
      finally { Counter += 1; }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }

  } else {
    Counter += 1;
  }

  if (Counter != 5) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump followed by a try/except, followed by a try/finally which
  // calls a subroutine which contains a try finally that raises an
  // exception that is handled to the try/except.
  //

  printf("    test25...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    try {
      try {
        try {
          Counter += 1;
          dojump(JumpBuffer, &Counter);
        }
        finally { Counter += 1; }
      }
      finally { Counter += 1; }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }

  } else {
    Counter += 1;
  }

  if (Counter != 7) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A set jump followed by a try/except, followed by a try/finally which
  // calls a subroutine which contains a try finally that raises an
  // exception that is handled to the try/except.
  //

  printf("    test26...");
  Counter = 0;
  if (setjmp(JumpBuffer) == 0) {
    try {
      try {
        try {
          try {
            Counter += 1;
            dojump(JumpBuffer, &Counter);
          }
          finally { Counter += 1; }
        }
        finally {
          Counter += 1;
          longjmp(JumpBuffer, 1);
        }
      }
      finally { Counter += 1; }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }

  } else {
    Counter += 1;
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Test nested exceptions.
  //

  printf("    test27...");
  Counter = 0;
  try {
    try {
      Counter += 1;
      except1(&Counter);
    }
    except(except2(GetExceptionInformation(), &Counter)) { Counter += 2; }
  }
  except(EXCEPTION_EXECUTE_HANDLER) { Counter += 3; }

  if (Counter != 55) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Simple try that causes an integer overflow exception.
  //

  printf("    test28...");
  Counter = 0;
  try {
    Counter += 1;
    addtwo(0x7fff0000, 0x10000, &Counter);
  }
  except((GetExceptionCode() == STATUS_INTEGER_OVERFLOW)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

//
// Simple try that raises an misaligned data exception.
//
#if !defined(i386) && !defined(_M_IA64) && !defined(_M_AMD64) &&               \
    !defined(_M_ARM) && !defined(_M_ARM64)
  printf("    test29...");
  Counter = 0;
  try {
    Counter += 1;
    foo2(BlackHole, (PLONG)BadByte);
  }
  except((GetExceptionCode() == STATUS_DATATYPE_MISALIGNMENT)
             ? EXCEPTION_EXECUTE_HANDLER
             : EXCEPTION_CONTINUE_SEARCH) {
    Counter += 1;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#endif
  //
  // Continue from a try body with an exception clause in a loop.
  //

  printf("    test30...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 0) {
        continue;

      } else {
        Counter += 1;
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }

    Counter += 2;
  }

  if (Counter != 15) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Continue from a try body with an finally clause in a loop.
  //

  printf("    test31...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 0) {
        continue;

      } else {
        Counter += 1;
      }
    }
    finally { Counter += 2; }

    Counter += 3;
  }

  if (Counter != 40) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Continue from doubly nested try body with an exception clause in a
  // loop.
  //

  printf("    test32...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 0) {
          continue;

        } else {
          Counter += 1;
        }
      }
      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }

      Counter += 2;
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }

    Counter += 3;
  }

  if (Counter != 30) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Continue from doubly nested try body with an finally clause in a loop.
  //

  printf("    test33...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 0) {
          continue;

        } else {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 3;
    }
    finally { Counter += 4; }

    Counter += 5;
  }

  if (Counter != 105) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Continue from a finally clause in a loop.
  //

  printf("    test34...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 0) {
        Counter += 1;
      }
    }
    finally {
      Counter += 2;
      continue;
    }

    Counter += 4;
  }

  if (Counter != 25) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Continue from a doubly nested finally clause in a loop.
  //

  printf("    test35...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 0) {
          Counter += 1;
        }
      }
      finally {
        Counter += 2;
        continue;
      }

      Counter += 4;
    }
    finally { Counter += 5; }

    Counter += 6;
  }

  if (Counter != 75) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Continue from a doubly nested finally clause in a loop.
  //

  printf("    test36...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 0) {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 4;
    }
    finally {
      Counter += 5;
      continue;
    }

    Counter += 6;
  }

  if (Counter != 115) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Break from a try body with an exception clause in a loop.
  //

  printf("    test37...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 1) {
        break;

      } else {
        Counter += 1;
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }

    Counter += 2;
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Break from a try body with an finally clause in a loop.
  //

  printf("    test38...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 1) {
        break;

      } else {
        Counter += 1;
      }
    }
    finally { Counter += 2; }

    Counter += 3;
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Break from doubly nested try body with an exception clause in a
  // loop.
  //

  printf("    test39...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          break;

        } else {
          Counter += 1;
        }
      }
      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }

      Counter += 2;
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }

    Counter += 3;
  }

  if (Counter != 6) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Break from doubly nested try body with an finally clause in a loop.
  //

  printf("    test40...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          break;

        } else {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 3;
    }
    finally { Counter += 4; }

    Counter += 5;
  }

  if (Counter != 21) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a finally clause in a loop.
  //

  printf("    test41...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      if ((Index1 & 0x1) == 1) {
        Counter += 1;
      }
    }
    finally {
      Counter += 2;
      break;
    }

    Counter += 4;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a doubly nested finally clause in a loop.
  //

  printf("    test42...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          Counter += 1;
        }
      }
      finally {
        Counter += 2;
        break;
      }

      Counter += 4;
    }
    finally { Counter += 5; }

    Counter += 6;
  }

  if (Counter != 7) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a doubly nested finally clause in a loop.
  //

  printf("    test43...");
  Counter = 0;
  for (Index1 = 0; Index1 < 10; Index1 += 1) {
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 4;
    }
    finally {
      Counter += 5;
      break;
    }

    Counter += 6;
  }

  if (Counter != 11) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Break from a try body with an exception clause in a switch.
  //

  printf("    test44...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      if ((Index1 & 0x1) == 1) {
        break;

      } else {
        Counter += 1;
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }

    Counter += 2;
    break;
  }

  if (Counter != 0) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Break from a try body with an finally clause in a switch.
  //

  printf("    test45...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      if ((Index1 & 0x1) == 1) {
        break;

      } else {
        Counter += 1;
      }
    }
    finally { Counter += 2; }

    Counter += 3;
  }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Break from doubly nested try body with an exception clause in a
  // switch.
  //

  printf("    test46...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          break;

        } else {
          Counter += 1;
        }
      }
      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }

      Counter += 2;
    }
    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }

    Counter += 3;
  }

  if (Counter != 0) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
  //
  // Break from doubly nested try body with an finally clause in a switch.
  //

  printf("    test47...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          break;

        } else {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 3;
    }
    finally { Counter += 4; }

    Counter += 5;
  }

  if (Counter != 6) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a finally clause in a switch.
  //

  printf("    test48...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      if ((Index1 & 0x1) == 1) {
        Counter += 1;
      }
    }
    finally {
      Counter += 2;
      break;
    }

    Counter += 4;
  }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a doubly nested finally clause in a switch.
  //

  printf("    test49...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          Counter += 1;
        }
      }
      finally {
        Counter += 2;
        break;
      }

      Counter += 4;
    }
    finally { Counter += 5; }

    Counter += 6;
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Break from a doubly nested finally clause in a switch.
  //

  printf("    test50...");
  Counter = 0;
  Index1 = 1;
  switch (Index2) {
  case BLUE:
    Counter += 100;
    break;

  case RED:
    try {
      try {
        if ((Index1 & 0x1) == 1) {
          Counter += 1;
        }
      }
      finally { Counter += 2; }

      Counter += 4;
    }
    finally {
      Counter += 5;
      break;
    }

    Counter += 6;
  }

  if (Counter != 12) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Leave from an if in a simple try/finally.
  //

  printf("    test51...");
  Counter = 0;
  try {
    if (Echo(Counter) == Counter) {
      Counter += 3;
      leave;

    } else {
      Counter += 100;
    }
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 5;
    }
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Leave from a loop in a simple try/finally.
  //

  printf("    test52...");
  Counter = 0;
  try {
    for (Index1 = 0; Index1 < 10; Index1 += 1) {
      if (Echo(Index1) == Index1) {
        Counter += 3;
        leave;
      }

      Counter += 100;
    }
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 5;
    }
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Leave from a switch in a simple try/finally.
  //

  printf("    test53...");
  Counter = 0;
  try {
    switch (Index2) {
    case BLUE:
      break;

    case RED:
      Counter += 3;
      leave;
    }

    Counter += 100;
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 5;
    }
  }

  if (Counter != 8) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Leave from an if in doubly nested try/finally followed by a leave
  // from an if in the outer try/finally.
  //

  printf("    test54...");
  Counter = 0;
  try {
    try {
      if (Echo(Counter) == Counter) {
        Counter += 3;
        leave;

      } else {
        Counter += 100;
      }
    }
    finally {
      if (abnormal_termination() == FALSE) {
        Counter += 5;
      }
    }

    if (Echo(Counter) == Counter) {
      Counter += 3;
      leave;

    } else {
      Counter += 100;
    }
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 5;
    }
  }

  if (Counter != 16) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#if !defined(WIN_CE) // leave from finally not allowed on WinCE
  //
  // Leave from an if in doubly nested try/finally followed by a leave
  // from the finally of the outer try/finally.
  //

  printf("    test55...");
  Counter = 0;
  try {
    try {
      if (Echo(Counter) == Counter) {
        Counter += 3;
        leave;

      } else {
        Counter += 100;
      }
    }
    finally {
      if (abnormal_termination() == FALSE) {
        Counter += 5;
        leave;
      }
    }

    Counter += 100;
  }
  finally {
    if (abnormal_termination() == FALSE) {
      Counter += 5;
    }
  }

  if (Counter != 13) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif

  //
  // Try/finally within the except clause of a try/except that is always
  // executed.
  //

  printf("    test56...");
  Counter = 0;
  try {
    Counter += 1;
    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  }
  except(Counter) {
    try {
      Counter += 3;
    }
    finally {
      if (abnormal_termination() == FALSE) {
        Counter += 5;
      }
    }
  }

  if (Counter != 9) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Try/finally within the finally clause of a try/finally.
  //

  printf("    test57...");
  Counter = 0;
  try {
    Counter += 1;
  }
  finally {
    if (abnormal_termination() == FALSE) {
      try {
        Counter += 3;
      }
      finally {
        if (abnormal_termination() == FALSE) {
          Counter += 5;
        }
      }
    }
  }

  if (Counter != 9) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Try/except within the finally clause of a try/finally.
  //

  printf("    test58...");
#if !defined(NEST_IN_FINALLY)
  printf("skipped\n");
#else
  Counter = 0;
  try {
    Counter -= 1;
  }
  finally {
    try {
      Counter += 2;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
    except(Counter) {
      try {
        Counter += 3;
      }
      finally {
        if (abnormal_termination() == FALSE) {
          Counter += 5;
        }
      }
    }
  }

  if (Counter != 9) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif /* def(NEST_IN_FINALLY) */

  //
  // Try/except within the except clause of a try/except that is always
  // executed.
  //

  printf("    test59...");
  Counter = 0;
  try {
    Counter += 1;
    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  }
  except(Counter) {
    try {
      Counter += 3;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
    except(Counter - 3) { Counter += 5; }
  }

  if (Counter != 9) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Try with a Try which exits the scope with a goto
  //

  printf("    test60...");
  Counter = 0;
  try {
    try {
      goto outside;
    }
    except(1) { Counter += 1; }

  outside:
    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
  }
  except(1) { Counter += 3; }

  if (Counter != 3) {
    printf("failed, count = %d\n", Counter);
  } else {
    printf("succeeded\n");
  }

  //
  // Try/except which gets an exception from a subfunction within
  // a try/finally which has a try/except in the finally clause
  //

  printf("    test61...");
#if !defined(NEST_IN_FINALLY)
  printf("skipped\n");
#else
  Counter = 0;
  try {
    Test61Part2(&Counter);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { Counter += 11; }

  if (Counter != 24) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }
#endif /* def(NEST_IN_FINALLY) */

  //
  // Check for precision of exception on floating point
  //

  printf("    test62...");

#if defined(i386) || defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_AMD64)

/* enable floating point overflow */
#if defined(i386)
  _control87(_control87(0, 0) & ~EM_OVERFLOW, _MCW_EM);
#else
  //
  // use portable version of _control87
  //
  _controlfp(_controlfp(0, 0) & ~EM_OVERFLOW, _MCW_EM);
#endif

  Counter = 0;
  try {
    doubleresult = SquareDouble(1.7e300);

    try {
      doubleresult = SquareDouble(1.0);
    }
    except(1) { Counter += 3; }
  }
  except(1) { Counter += 1; }

  if (Counter != 1) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

/* clear up pending unmasked exceptions and restore FP control registers */
#if defined(i386)
  _clear87();
  _control87(_control87(0, 0) | EM_OVERFLOW, 0xfffff);
#else
  _clearfp();
  _controlfp(_controlfp(0, 0) | EM_OVERFLOW, 0xfffff);
#endif

#else
  printf("skipped\n");
#endif

  //
  // A try/finally inside a try/except where an exception is raised in the
  // try/finally.
  //

  printf("    test63...");
  Counter = 0;
  try {
    try {
      Counter += 1;
    }
    finally {
      Counter += 3;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
  }
  except(1) { Counter += 6; }

  if (Counter != 10) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try/finally inside a try/except where an exception is raised in the
  // in the try/except and the try/finally.
  //

  printf("    test64...");
  Counter = 0;
  try {
    try {
      Counter += 1;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
    finally {
      Counter += 3;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
  }
  except(1) { Counter += 6; }

  if (Counter != 10) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try/finally inside a try/except where an exception is raised in the
  // try/finally.
  //

  printf("    test65...");
  Counter = 0;
  try {
    try {
      Counter += 1;
    }
    finally {
      Counter += 3;
      *BlackHole += *BadAddress;
      Counter += 13;
    }
  }
  except(1) { Counter += 6; }

  if (Counter != 10) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try/finally inside a try/except where an exception is raised in the
  // in the try/except and the try/finally.
  //

  printf("    test66...");
  Counter = 0;
  try {
    try {
      Counter += 1;
      *BlackHole += *BadAddress;
      Counter += 13;
    }
    finally {
      Counter += 3;
      *BlackHole += *BadAddress;
      Counter += 13;
    }
  }
  except(1) { Counter += 6; }

  if (Counter != 10) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try/finally inside a try/finally inside a try/except where an
  // exception is raised in the in the try/except and in try/finally.
  //

  printf("    test67...");
  try {
    try {
      *BlackHole += *BadAddress;
    }
    finally {
      try {
        Counter = 0;
      }
      finally {
        if (Counter != 0) {
          Counter += 1;
        }
      }

      Counter += 1;
      *BlackHole += *BadAddress;
    }
  }
  except(1) { Counter += 1; }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // A try/finally inside a try/finally inside a try/except where an
  // exception is raised in the in the try/except and in try/finally.
  //

  printf("    test68...");
  try {
    try {
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
    finally {
      try {
        Counter = 0;
      }
      finally {
        if (Counter != 0) {
          Counter += 1;
        }
      }

      Counter += 1;
      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
    }
  }
  except(1) { Counter += 1; }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

//
// Patch guard test 69.
//

#if defined(_AMD64_) || defined(_X86_)

  printf("    test69...");
  Counter = 0;
  try {
    PgTest69(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test70...");
  Counter = 0;
  try {
    PgTest70(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 2) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test71...");
  Counter = 0;
  try {
    PgTest71(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 9) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test72...");
  Counter = 0;
  try {
    PgTest72(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 12) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test73...");
  Counter = 0;
  try {
    PgTest73(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 15) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test74...");
  Counter = 0;
  try {
    PgTest74(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 18) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test75...");
  Counter = 0;
  try {
    PgTest75(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 35) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test76...");
  Counter = 0;
  try {
    PgTest76(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 40) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test77...");
  Counter = 0;
  try {
    PgTest77(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 45) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test78...");
  Counter = 0;
  try {
    PgTest78(&Counter, BadAddress);
  }
  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }

  if (Counter != 50) {
    printf("failed, count = %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

#else
  printf("    test69...filter entered...succeeded\n");
  printf("    test70...filter entered...succeeded\n");
  printf("    test71...filter entered...succeeded\n");
  printf("    test72...filter entered...succeeded\n");
  printf("    test73...filter entered...succeeded\n");
  printf("    test74...filter entered...succeeded\n");
  printf("    test75...filter entered...succeeded\n");
  printf("    test76...filter entered...succeeded\n");
  printf("    test77...filter entered...succeeded\n");
  printf("    test78...filter entered...succeeded\n");
#endif

  if (LOBYTE(LOWORD(GetVersion())) < 6) {
    printf("    test79...");
    printf("filter 1...filter 2...finally 1...filter 1...filter 2...finally "
           "2...passed\n");
  } else {

    printf("    test79...");
    Counter = 0;
    try {
      Test79(&Counter, BadAddress);
    }
    except(printf("filter 2..."), EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }

    if (Counter == 3) {
      printf("passed\n");

    } else {
      printf("failed  %d \n", Counter);
    }
  }

  printf("    test80...");
  if (Test80() != 0) {
    printf("failed\n");

  } else {
    printf("passed\n");
  }

  printf("    test81...");
  Counter = 0;
  Test81(&Counter);
  if (Counter != 1) {
    printf("failed  %d \n", Counter);

  } else {
    printf("passed\n");
  }

  printf("    test82...");
  Counter = 1;
  Test82(&Counter);
  if (Counter != 0) {
    printf("failed\n");

  } else {
    printf("succeeded\n");
  }

  printf("    test83...");
  if (Test83() != 0) {
    printf("failed\n");

  } else {
    printf("succeeded\n");
  }

  printf("    test84...");
  Counter = 0;
  Test84(&Counter);
  if (Counter != 2) {
    printf("failed\n");

  } else {
    printf("succeeded\n");
  }

  printf("    test85...");
  Counter = 0;
  Test85(&Counter);
  if (Counter != 7) {
    printf("failed\n");

  } else {
    printf("succeeded\n");
  }

  printf("    test86...");
  Counter = 0;
  Test86(&Counter);
  if (Counter != 4) {
    printf("failed %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test87...");
  Counter = 0;
  Test87(&Counter);
  if (Counter != 104) {
    printf("failed %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  printf("    test88...");
  Counter = 0;
  Test88(&Counter);
  if (Counter != 6) {
    printf("failed %d\n", Counter);

  } else {
    printf("succeeded\n");
  }

  //
  // Announce end of exception test.
  //

  printf("End of exception test\n");
  return;
}

PgFilter()

DECLSPEC_NOINLINE ULONG PgFilter

(

VOID

)

Definition at line 111 of file xcpt4u.c.

{

  printf("filter entered...");
  return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by PgTest69(), PgTest70(), PgTest71(), PgTest72(), PgTest73(), PgTest74(), PgTest75(), PgTest76(), PgTest77(), and PgTest78().

PgTest69()

VOID PgTest69	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 122 of file xcpt4u.c.

{

  try {
    try {
      *Fault += 1;
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 1) {
          *State += 1;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 1) == 1) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
    if (*State != 2) {
      *Fault += 1;
    }
  }

  return;
}

Referenced by main().

PgTest70()

VOID PgTest70	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 150 of file xcpt4u.c.

{

  try {
    try {
      *Fault += 1;
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 2) {
          PgFilter();
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 2) == 2) ? EXCEPTION_EXECUTE_HANDLER
                              : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest71()

VOID PgTest71	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 178 of file xcpt4u.c.

{

  try {
    try {
      try {
        *Fault += 1;
      }
      finally {
        if (AbnormalTermination()) {
          if (*State == 3) {
            *State += 3;
            return;

          } else {
            *Fault += 1;
          }
        }
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 6) {
          *State += 3;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 3) == 3) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest72()

VOID PgTest72	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 217 of file xcpt4u.c.

{

  try {
    try {
      try {
        *Fault += 1;
      }
      finally {
        if (AbnormalTermination()) {
          if (*State == 4) {
            *State += 4;
            return;

          } else {
            *Fault += 1;
          }
        }
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 8) {
          *State += 4;
          PgFilter();

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 4) == 4) ? EXCEPTION_EXECUTE_HANDLER
                              : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest73()

VOID PgTest73	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 258 of file xcpt4u.c.

{

  try {
    try {
      try {
        *Fault += 1;
      }
      finally {
        if (AbnormalTermination()) {
          if (*State == 5) {
            *State += 5;

          } else {
            *Fault += 1;
          }
        }
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 10) {
          *State += 5;
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 5) == 5) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest74()

VOID PgTest74	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 297 of file xcpt4u.c.

{

  try {
    try {
      try {
        *Fault += 1;
      }
      finally {
        if (AbnormalTermination()) {
          if (*State == 6) {
            *State += 6;

          } else {
            *Fault += 1;
          }
        }
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 12) {
          *State += 6;
          PgFilter();
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 6) == 6) ? EXCEPTION_EXECUTE_HANDLER
                              : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest75()

VOID PgTest75	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 338 of file xcpt4u.c.

{

  try {
    try {
      try {
        try {
          *Fault += 1;
        }
        finally {
          if (AbnormalTermination()) {
            if (*State == 7) {
              *State += 7;
              *Fault += 1;

            } else {
              *State += 10;
            }
          }
        }
      }
      except(((*State += 7) == 7) ? EXCEPTION_EXECUTE_HANDLER
                                  : EXCEPTION_CONTINUE_SEARCH) {
        *Fault += 1;
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 28) {
          *State += 7;
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 7) == 28) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest76()

VOID PgTest76	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 384 of file xcpt4u.c.

{

  try {
    try {
      try {
        try {
          *Fault += 1;
        }
        finally {
          if (AbnormalTermination()) {
            if (*State == 8) {
              *State += 8;
              *Fault += 1;

            } else {
              *State += 10;
            }
          }
        }
      }
      except(((*State += 8) == 8) ? EXCEPTION_EXECUTE_HANDLER
                                  : EXCEPTION_CONTINUE_SEARCH) {
        *Fault += 1;
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 32) {
          *State += 8;
          PgFilter();
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 8) == 32) ? EXCEPTION_EXECUTE_HANDLER
                               : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest77()

VOID PgTest77	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 432 of file xcpt4u.c.

{

  try {
    try {
      try {
        try {
          *Fault += 1;
        }
        finally {
          if (AbnormalTermination()) {
            if (*State == 9) {
              *State += 9;
              *Fault += 1;

            } else {
              *State += 10;
            }
          }
        }
      }
      except(((*State += 9) == 9) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
        *Fault += 1;
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 36) {
          *State += 9;
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 9) == 36) ? EXCEPTION_EXECUTE_HANDLER
                               : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

PgTest78()

VOID PgTest78	(	IN PLONG	State,
		IN PLONG	Fault
	)

Definition at line 478 of file xcpt4u.c.

{

  try {
    try {
      try {
        try {
          *Fault += 1;
        }
        finally {
          if (AbnormalTermination()) {
            if (*State == 10) {
              *State += 10;
              PgFilter();
              *Fault += 1;

            } else {
              *State += 10;
            }
          }
        }
      }
      except(((*State += 10) == 10) ? EXCEPTION_EXECUTE_HANDLER
                                    : EXCEPTION_CONTINUE_SEARCH) {
        *Fault += 1;
      }
    }
    finally {
      if (AbnormalTermination()) {
        if (*State == 40) {
          *State += 10;
          return;

        } else {
          *Fault += 1;
        }
      }
    }
  }
  except(((*State += 10) == 40) ? EXCEPTION_EXECUTE_HANDLER
                                : EXCEPTION_CONTINUE_SEARCH) {
    *Fault += 1;
  }

  return;
}

Referenced by main().

SquareDouble()

double SquareDouble

(

IN double

op

)

Definition at line 3461 of file xcpt4u.c.

                                  {
  return exp(2.0 * log(op));
}

Referenced by main().

Test61Part2()

VOID Test61Part2

(

IN OUT PULONG

Counter

)

Referenced by main().

Test79()

VOID Test79	(	PLONG	Counter,
		PLONG	Fault
	)

Definition at line 528 of file xcpt4u.c.

{

  try {
    try {
      try {
        *Fault += 1;
      }
      finally {
        printf("finally 1...");
        *Fault += 1;
      }
    }
    finally { printf("finally 2..."); }
  }
  except(*Counter += 1, printf("filter 1..."), EXCEPTION_CONTINUE_SEARCH) {}

  return;
}

Referenced by main().

Test80()

ULONG Test80

(

VOID

)

Definition at line 552 of file xcpt4u.c.

{

  G = 1;
  try {
    while (G) {
      try {
        if (G == 10) {
          return 1;
        }

        if (G == 1) {
          continue;
        }
      }
      finally { G = 0; }
    }
  }
  finally { G = 10; }

  return 0;
}

Referenced by main().

Test81()

void Test81

(

int *

pCounter

)

Definition at line 576 of file xcpt4u.c.

                           {
  volatile char *AvPtr = NULL;

  __try {
    __try { *AvPtr = '\0'; }
    __except(EXCEPTION_EXECUTE_HANDLER) { __leave; }
  }
  __finally {
    printf("in finally ");
    *pCounter += 1;
  }
  return;
}

Referenced by main().

Test82()

VOID Test82

(

__inout PLONG

Counter

)

Definition at line 597 of file xcpt4u.c.

{

  int retval = 1;

  __try {
    __try { Test82Foo(); }
    __finally {
      switch (*Counter) {
      case 0:
        printf("something failed!\n");
        retval = 6;
        break;

      case 1:
        retval = 0;
        break;

      case 2:
        printf("how did you get here?\n");
        retval = 2;
        break;

      case 3:
        printf("what?!?\n");
        retval = 3;
        break;

      case 4:
        printf("not correct\n");
        retval = 4;
        break;

      case 5:
        printf("error!\n");
        retval = 5;
        break;
      }
    }
  }
  __except(1){}

  *Counter = retval;
  return;
}

Referenced by main().

Test82Foo()

DECLSPEC_NOINLINE VOID Test82Foo

(

VOID

)

Definition at line 591 of file xcpt4u.c.

{
  *(volatile int *)0 = 0;
}

Referenced by Test82().

Test83()

LONG Test83

(

VOID

)

Definition at line 644 of file xcpt4u.c.

{

  G = 1;
  try {
    try {
      while (G) {
        try {
          if (G == 10) {
            return 1;
          }

          if (G == 1) {
            continue;
          }
        }
        finally { G = 0; }
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
  }
  finally { G = 10; }

  return 0;
}

Referenced by main().

Test84()

DECLSPEC_NOINLINE VOID Test84

(

_Inout_ PLONG

Counter

)

Definition at line 672 of file xcpt4u.c.

{
  volatile int *Fault = 0;

  try {
    try {
      *Fault += 1;
    }
    except(EXCEPTION_EXECUTE_HANDLER) {
      try {
        return;
      }
      finally { *Counter += 1; }
    }
  }
  finally {

    if (AbnormalTermination()) {
      *Counter += 1;
    }
  }

  return;
}

Referenced by main().

Test85()

DECLSPEC_NOINLINE LONG Test85

(

_Inout_ PLONG

Counter

)

Definition at line 699 of file xcpt4u.c.

{
  volatile int *Fault = 0;

  G = 1;
  try {
    try {
      try {
        while (G) {
          try {
            try {
              if (G == 10) {
                return 1;
              }
              try {
                *Counter += 1;
              }
              except(EXCEPTION_EXECUTE_HANDLER) {}

              if (G == 1) {
                continue;
              }
            }
            finally {
              G = 0;
              *Counter += 1;
              *Fault += 1;
            }
          }
          except(EXCEPTION_EXECUTE_HANDLER) {
            *Counter += 1;
            leave;
          }
        }
      }
      finally {
        G = 10;
        *Counter += 1;
        *Fault += 1;
      }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { *Counter += 1; }
    *Counter += 1;
  }
  finally { *Counter += 1; }
  return 1;
}

Referenced by main().

Test86()

DECLSPEC_NOINLINE VOID Test86

(

_Inout_ PLONG

Counter

)

Definition at line 749 of file xcpt4u.c.

{
  volatile int *Fault = 0;

  try {
    try {
      try {
        try {
          try {
            try {
              *Fault += 1;
            }
            except(printf("Filter1 %d..", *Counter),
                   EXCEPTION_EXECUTE_HANDLER) {
              try {
                printf("Handler1 %d..", *Counter);
                return;
              }
              finally {
                printf("Finally1 %d..", *Counter);
                *Counter += 1;
              }
            }
          }
          finally {
            printf("Finally2 %d..", *Counter);
            *Counter += 1;
          }
        }
        except(EXCEPTION_EXECUTE_HANDLER) { leave; }
      }
      finally { *Counter += 1; }
    }
    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
  }
  finally { *Counter += 1; }

  return;
}

Referenced by main().

Test87()

VOID Test87

(

_Inout_ PLONG

Counter

)

Definition at line 790 of file xcpt4u.c.

{
  volatile int *Fault = 0;

//
// N.B.  Disabled on x86 due to failing test case with handling of returns
//       in nested termination handlers on x86.
//
//       Disabled on ARM due to failing test case with handling of abutting
//       termination handlers within an except handler.
//
//       Disabled on AMD64 due to failing test case with handling of
//       abutting termination handlers within an except handler when a
//       non-local goto is involved.
//

#if !defined(_X86_)
  try {
    try {
      try {
        try {
          try {
            *Fault += 1;

            try {
            }
            finally {
              if (AbnormalTermination()) {
                *Fault += 1;
              }
            }
          }
          finally {

            if (AbnormalTermination()) {
              if ((*Counter += 13) == 26) {
                return;

              } else {
                *Fault += 1;
              }
            }
          }
        }
        finally {
          if (AbnormalTermination()) {
            *Counter += 13;
            *Fault += 1;
          }
        }
      }
      except(((*Counter += 13) == 13) ? EXCEPTION_EXECUTE_HANDLER
                                      : EXCEPTION_CONTINUE_SEARCH) {
        *Fault += 1;
      }
    }
    except(((*Counter += 13) == 65) ? EXCEPTION_EXECUTE_HANDLER
                                    : EXCEPTION_CONTINUE_SEARCH) {
      try {
        *Counter += 13;
        return;
      }
      finally {
        if (AbnormalTermination()) {
          *Counter += 13;
          goto Finish;
        }
      }
    }
  }
  finally {

    if (AbnormalTermination()) {
      if ((*Counter += 13) == 104) {
        goto Finish;
      }
    }
  }

Finish:
#else
  *Counter = 104;
#endif

  return;
}

Referenced by main().

Test88()

VOID Test88

(

_Inout_ PLONG

Counter

)

Definition at line 893 of file xcpt4u.c.

{
  volatile int *Fault = 0;

  try {
    try {
      try {
        try {
          try {
            try {
              try {
                try {
                  *Fault += 1;
                }
                except(((*Counter += 1) == 1) ? *Fault
                                              : EXCEPTION_CONTINUE_SEARCH) {}
              }
              except(*Counter += 1, EXCEPTION_EXECUTE_HANDLER) { *Fault += 2; }
            }
            except(*Counter += 1, EXCEPTION_CONTINUE_SEARCH) { leave; }
          }
          except(*Counter += 1, EXCEPTION_CONTINUE_SEARCH) { leave; }
        }
        except(EXCEPTION_EXECUTE_HANDLER) {}
      }
      except(EXCEPTION_EXECUTE_HANDLER) {}
    }
    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
  }
  finally { *Counter += 1; }
}

Referenced by main().

Tkm()

BOOLEAN Tkm

(

VOID

)

Variable Documentation

G

ULONG G

Definition at line 549 of file xcpt4u.c.

Referenced by HLStoRGB(), IntSetDeviceGammaRamp(), Is24On(), monoPolyPart(), mp_exptmod(), mp_exptmod_fast(), Pc98VideoClearScreen(), Pc98VideoPutChar(), RtlSplay(), s_mp_exptmod(), Test80(), Test83(), and Test85().