|
@@ -1,3463 +0,0 @@
|
|
|
-// Copyright (c) Microsoft. All rights reserved.
|
|
|
-// Licensed under the MIT license. See LICENSE file in the project root for full
|
|
|
-// license information.
|
|
|
-
|
|
|
-/*
|
|
|
- * COMMAND LINE: -Ox -Gz -YX -UPROTOTYPES_REQUIRED
|
|
|
- */
|
|
|
-
|
|
|
-#pragma warning(disable : 4532)
|
|
|
-#pragma warning(disable : 4702)
|
|
|
-
|
|
|
-#if defined(_WIN32)
|
|
|
-
|
|
|
-#if defined(_M_SH)
|
|
|
-#define WIN_CE
|
|
|
-#endif
|
|
|
-
|
|
|
-#if defined(_M_AMD64)
|
|
|
-#define NEST_IN_FINALLY /* allow when __try nested in __finally OK */
|
|
|
-#endif
|
|
|
-
|
|
|
-#define NTSTATUS LONG
|
|
|
-#define EXCEPTION_NESTED_CALL 0x10
|
|
|
-#define RtlRaiseStatus(x) RaiseException((x), 0, 0, NULL)
|
|
|
-#define RtlRaiseException(x) \
|
|
|
- RaiseException((x)->ExceptionCode, (x)->ExceptionFlags, \
|
|
|
- (x)->NumberParameters, (x)->ExceptionInformation)
|
|
|
-#define IN
|
|
|
-#define OUT
|
|
|
-#if !(defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) || \
|
|
|
- defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64))
|
|
|
-#define i386 1
|
|
|
-#endif
|
|
|
-#define try __try
|
|
|
-#define except __except
|
|
|
-#define finally __finally
|
|
|
-#define leave __leave
|
|
|
-
|
|
|
-#endif
|
|
|
-
|
|
|
-#define WIN32_LEAN_AND_MEAN
|
|
|
-
|
|
|
-#include "stdio.h"
|
|
|
-#if defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) || \
|
|
|
- defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64)
|
|
|
-#include "setjmpex.h"
|
|
|
-#else
|
|
|
-#include "setjmp.h"
|
|
|
-#endif
|
|
|
-#include "float.h"
|
|
|
-#include "windows.h"
|
|
|
-#include "math.h"
|
|
|
-
|
|
|
-#if !defined(STATUS_SUCCESS)
|
|
|
-#define STATUS_SUCCESS 0
|
|
|
-#endif
|
|
|
-#if !defined(STATUS_UNSUCCESSFUL)
|
|
|
-#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
|
|
|
-#endif
|
|
|
-
|
|
|
-//
|
|
|
-// Define switch constants.
|
|
|
-//
|
|
|
-
|
|
|
-#define BLUE 0
|
|
|
-#define RED 1
|
|
|
-
|
|
|
-//
|
|
|
-// Define function prototypes.
|
|
|
-//
|
|
|
-
|
|
|
-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);
|
|
|
-
|
|
|
-#if !defined(WIN_CE) // return through finally not allowed on WinCE
|
|
|
-VOID eret(IN NTSTATUS Status, IN PLONG Counter);
|
|
|
-#endif
|
|
|
-
|
|
|
-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);
|
|
|
-
|
|
|
-#if !defined(WIN_CE) // return from finally not allowed on WinCE
|
|
|
-VOID fret(IN PLONG Counter);
|
|
|
-#endif
|
|
|
-
|
|
|
-BOOLEAN
|
|
|
-Tkm(VOID);
|
|
|
-
|
|
|
-VOID Test61Part2(IN OUT PULONG Counter);
|
|
|
-
|
|
|
-double SquareDouble(IN double op);
|
|
|
-
|
|
|
-DECLSPEC_NOINLINE
|
|
|
-ULONG
|
|
|
-PgFilter(VOID)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- printf("filter entered...");
|
|
|
- return EXCEPTION_EXECUTE_HANDLER;
|
|
|
-}
|
|
|
-
|
|
|
-#pragma warning(push)
|
|
|
-#pragma warning(disable : 4532)
|
|
|
-
|
|
|
-VOID PgTest69(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest70(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest71(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest72(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest73(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest74(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest75(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest76(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest77(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID PgTest78(IN PLONG State, IN PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-#pragma warning(pop)
|
|
|
-
|
|
|
-VOID Test79(PLONG Counter, PLONG Fault)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-ULONG G;
|
|
|
-
|
|
|
-ULONG
|
|
|
-Test80(VOID)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- G = 1;
|
|
|
- try {
|
|
|
- while (G) {
|
|
|
- try {
|
|
|
- if (G == 10) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
-
|
|
|
- if (G == 1) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- finally { G = 0; }
|
|
|
- }
|
|
|
- }
|
|
|
- finally { G = 10; }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-void Test81(int *pCounter) {
|
|
|
- volatile char *AvPtr = NULL;
|
|
|
-
|
|
|
- __try {
|
|
|
- __try { *AvPtr = '\0'; }
|
|
|
- __except(EXCEPTION_EXECUTE_HANDLER) { __leave; }
|
|
|
- }
|
|
|
- __finally {
|
|
|
- printf("in finally ");
|
|
|
- *pCounter += 1;
|
|
|
- }
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-DECLSPEC_NOINLINE
|
|
|
-VOID Test82Foo(VOID)
|
|
|
-
|
|
|
-{
|
|
|
- *(volatile int *)0 = 0;
|
|
|
-}
|
|
|
-
|
|
|
-VOID Test82(__inout PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-LONG Test83(VOID)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-DECLSPEC_NOINLINE
|
|
|
-VOID Test84(_Inout_ PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
- volatile int *Fault = 0;
|
|
|
-
|
|
|
- try {
|
|
|
- try {
|
|
|
- *Fault += 1;
|
|
|
- }
|
|
|
- except(EXCEPTION_EXECUTE_HANDLER) {
|
|
|
- try {
|
|
|
- return;
|
|
|
- }
|
|
|
- finally { *Counter += 1; }
|
|
|
- }
|
|
|
- }
|
|
|
- finally {
|
|
|
-
|
|
|
- if (AbnormalTermination()) {
|
|
|
- *Counter += 1;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-DECLSPEC_NOINLINE
|
|
|
-LONG Test85(_Inout_ PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-DECLSPEC_NOINLINE
|
|
|
-VOID Test86(_Inout_ PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID Test87(_Inout_ PLONG Counter)
|
|
|
-
|
|
|
-/*++
|
|
|
-
|
|
|
-Routine Description:
|
|
|
-
|
|
|
- This function verifies the behavior of nested exception dispatching.
|
|
|
-
|
|
|
-Arguments:
|
|
|
-
|
|
|
- Counter - Supplies a pointer to the state counter.
|
|
|
-
|
|
|
-Return Value:
|
|
|
- None.
|
|
|
-
|
|
|
---*/
|
|
|
-
|
|
|
-{
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID Test88(_Inout_ PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
- 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; }
|
|
|
-}
|
|
|
-
|
|
|
-int main(int argc, char *argv[])
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-#pragma optimize("a", off)
|
|
|
-VOID addtwo(long First, long Second, long *Place)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
|
|
|
- *Place = First + Second;
|
|
|
- return;
|
|
|
-}
|
|
|
-#pragma optimize("", on)
|
|
|
-
|
|
|
-VOID bar1(IN NTSTATUS Status, IN PLONG Counter) {
|
|
|
-
|
|
|
- try {
|
|
|
- foo1(Status);
|
|
|
- }
|
|
|
- finally {
|
|
|
- if (abnormal_termination() != FALSE) {
|
|
|
- *Counter = 99;
|
|
|
-
|
|
|
- } else {
|
|
|
- *Counter = 100;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter) {
|
|
|
-
|
|
|
- try {
|
|
|
- foo2(BlackHole, BadAddress);
|
|
|
- }
|
|
|
- finally {
|
|
|
- if (abnormal_termination() != FALSE) {
|
|
|
- *Counter = 99;
|
|
|
-
|
|
|
- } else {
|
|
|
- *Counter = 100;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-VOID dojump(IN jmp_buf JumpBuffer, IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- try {
|
|
|
- try {
|
|
|
- *Counter += 1;
|
|
|
- RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
|
|
|
- }
|
|
|
- finally { *Counter += 1; }
|
|
|
- }
|
|
|
- finally {
|
|
|
- *Counter += 1;
|
|
|
- longjmp(JumpBuffer, 1);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-#if !defined(WIN_CE) // return through finally not allowed on WinCE
|
|
|
-VOID eret(IN NTSTATUS Status, IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- try {
|
|
|
- try {
|
|
|
- foo1(Status);
|
|
|
- }
|
|
|
- except((GetExceptionCode() == Status) ? EXCEPTION_EXECUTE_HANDLER
|
|
|
- : EXCEPTION_CONTINUE_SEARCH) {
|
|
|
- *Counter += 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- finally { *Counter += 1; }
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-VOID except1(IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- try {
|
|
|
- *Counter += 5;
|
|
|
- RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
|
|
|
- }
|
|
|
- except(except3(GetExceptionInformation(), Counter)) { *Counter += 7; }
|
|
|
-
|
|
|
- *Counter += 9;
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-ULONG
|
|
|
-except2(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-ULONG
|
|
|
-except3(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- 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;
|
|
|
-}
|
|
|
-
|
|
|
-VOID foo1(IN NTSTATUS Status)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- //
|
|
|
- // Raise exception.
|
|
|
- //
|
|
|
-
|
|
|
- RtlRaiseStatus(Status);
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- //
|
|
|
- // Raise exception.
|
|
|
- //
|
|
|
-
|
|
|
- *BlackHole += *BadAddress;
|
|
|
- return;
|
|
|
-}
|
|
|
-
|
|
|
-#if !defined(WIN_CE) // return from finally not allowed on WinCE
|
|
|
-VOID fret(IN PLONG Counter)
|
|
|
-
|
|
|
-{
|
|
|
-
|
|
|
- try {
|
|
|
- try {
|
|
|
- *Counter += 1;
|
|
|
- }
|
|
|
- finally {
|
|
|
- *Counter += 1;
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- finally { *Counter += 1; }
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-LONG Echo(IN LONG Value)
|
|
|
-
|
|
|
-{
|
|
|
- return Value;
|
|
|
-}
|
|
|
-
|
|
|
-#if defined(NEST_IN_FINALLY)
|
|
|
-VOID Test61Part2(IN OUT PULONG Counter) {
|
|
|
- try {
|
|
|
- *Counter -= 1;
|
|
|
- RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
|
|
|
- }
|
|
|
- finally {
|
|
|
- try {
|
|
|
- *Counter += 2;
|
|
|
- RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
|
|
|
- }
|
|
|
- except(EXCEPTION_EXECUTE_HANDLER) { *Counter += 5; }
|
|
|
- *Counter += 7;
|
|
|
- }
|
|
|
-}
|
|
|
-#endif /* def(NEST_IN_FINALLY) */
|
|
|
-
|
|
|
-double SquareDouble(IN double op) {
|
|
|
- return exp(2.0 * log(op));
|
|
|
-}
|