ReactOS  0.4.15-dev-3163-gf17c2c0
xcpt4u.c
Go to the documentation of this file.
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full
3 // license information.
4 
5 /*
6  * COMMAND LINE: -Ox -Gz -YX -UPROTOTYPES_REQUIRED
7  */
8 
9 #pragma warning(disable : 4532)
10 #pragma warning(disable : 4702)
11 
12 #if defined(_WIN32)
13 
14 #if defined(_M_SH)
15 #define WIN_CE
16 #endif
17 
18 #if defined(_M_AMD64)
19 #define NEST_IN_FINALLY /* allow when __try nested in __finally OK */
20 #endif
21 
22 #define NTSTATUS LONG
23 #define EXCEPTION_NESTED_CALL 0x10
24 #define RtlRaiseStatus(x) RaiseException((x), 0, 0, NULL)
25 #define RtlRaiseException(x) \
26  RaiseException((x)->ExceptionCode, (x)->ExceptionFlags, \
27  (x)->NumberParameters, (x)->ExceptionInformation)
28 #define IN
29 #define OUT
30 #if !(defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) || \
31  defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64))
32 #define i386 1
33 #endif
34 #define try __try
35 #define except __except
36 #define finally __finally
37 #define leave __leave
38 
39 #endif
40 
41 #define WIN32_LEAN_AND_MEAN
42 
43 #include "stdio.h"
44 #if defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) || \
45  defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64)
46 #include "setjmpex.h"
47 #else
48 #include "setjmp.h"
49 #endif
50 #include "float.h"
51 #include "windows.h"
52 #include "math.h"
53 
54 #if !defined(STATUS_SUCCESS)
55 #define STATUS_SUCCESS 0
56 #endif
57 #if !defined(STATUS_UNSUCCESSFUL)
58 #define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
59 #endif
60 
61 //
62 // Define switch constants.
63 //
64 
65 #define BLUE 0
66 #define RED 1
67 
68 //
69 // Define function prototypes.
70 //
71 
73 
75 
76 VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter);
77 
78 VOID dojump(IN jmp_buf JumpBuffer, IN PLONG Counter);
79 
81 
82 #if !defined(WIN_CE) // return through finally not allowed on WinCE
84 #endif
85 
87 
88 ULONG
89 except2(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter);
90 
91 ULONG
92 except3(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter);
93 
95 
96 VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress);
97 
98 #if !defined(WIN_CE) // return from finally not allowed on WinCE
100 #endif
101 
102 BOOLEAN
103 Tkm(VOID);
104 
106 
107 double SquareDouble(IN double op);
108 
110 ULONG
112 
113 {
114 
115  printf("filter entered...");
117 }
118 
119 #pragma warning(push)
120 #pragma warning(disable : 4532)
121 
123 
124 {
125 
126  try {
127  try {
128  *Fault += 1;
129  }
130  finally {
131  if (AbnormalTermination()) {
132  if (*State == 1) {
133  *State += 1;
134 
135  } else {
136  *Fault += 1;
137  }
138  }
139  }
140  }
141  except(((*State += 1) == 1) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
142  if (*State != 2) {
143  *Fault += 1;
144  }
145  }
146 
147  return;
148 }
149 
151 
152 {
153 
154  try {
155  try {
156  *Fault += 1;
157  }
158  finally {
159  if (AbnormalTermination()) {
160  if (*State == 2) {
161  PgFilter();
162  return;
163 
164  } else {
165  *Fault += 1;
166  }
167  }
168  }
169  }
170  except(((*State += 2) == 2) ? EXCEPTION_EXECUTE_HANDLER
172  *Fault += 1;
173  }
174 
175  return;
176 }
177 
179 
180 {
181 
182  try {
183  try {
184  try {
185  *Fault += 1;
186  }
187  finally {
188  if (AbnormalTermination()) {
189  if (*State == 3) {
190  *State += 3;
191  return;
192 
193  } else {
194  *Fault += 1;
195  }
196  }
197  }
198  }
199  finally {
200  if (AbnormalTermination()) {
201  if (*State == 6) {
202  *State += 3;
203 
204  } else {
205  *Fault += 1;
206  }
207  }
208  }
209  }
210  except(((*State += 3) == 3) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
211  *Fault += 1;
212  }
213 
214  return;
215 }
216 
218 
219 {
220 
221  try {
222  try {
223  try {
224  *Fault += 1;
225  }
226  finally {
227  if (AbnormalTermination()) {
228  if (*State == 4) {
229  *State += 4;
230  return;
231 
232  } else {
233  *Fault += 1;
234  }
235  }
236  }
237  }
238  finally {
239  if (AbnormalTermination()) {
240  if (*State == 8) {
241  *State += 4;
242  PgFilter();
243 
244  } else {
245  *Fault += 1;
246  }
247  }
248  }
249  }
250  except(((*State += 4) == 4) ? EXCEPTION_EXECUTE_HANDLER
252  *Fault += 1;
253  }
254 
255  return;
256 }
257 
259 
260 {
261 
262  try {
263  try {
264  try {
265  *Fault += 1;
266  }
267  finally {
268  if (AbnormalTermination()) {
269  if (*State == 5) {
270  *State += 5;
271 
272  } else {
273  *Fault += 1;
274  }
275  }
276  }
277  }
278  finally {
279  if (AbnormalTermination()) {
280  if (*State == 10) {
281  *State += 5;
282  return;
283 
284  } else {
285  *Fault += 1;
286  }
287  }
288  }
289  }
290  except(((*State += 5) == 5) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
291  *Fault += 1;
292  }
293 
294  return;
295 }
296 
298 
299 {
300 
301  try {
302  try {
303  try {
304  *Fault += 1;
305  }
306  finally {
307  if (AbnormalTermination()) {
308  if (*State == 6) {
309  *State += 6;
310 
311  } else {
312  *Fault += 1;
313  }
314  }
315  }
316  }
317  finally {
318  if (AbnormalTermination()) {
319  if (*State == 12) {
320  *State += 6;
321  PgFilter();
322  return;
323 
324  } else {
325  *Fault += 1;
326  }
327  }
328  }
329  }
330  except(((*State += 6) == 6) ? EXCEPTION_EXECUTE_HANDLER
332  *Fault += 1;
333  }
334 
335  return;
336 }
337 
339 
340 {
341 
342  try {
343  try {
344  try {
345  try {
346  *Fault += 1;
347  }
348  finally {
349  if (AbnormalTermination()) {
350  if (*State == 7) {
351  *State += 7;
352  *Fault += 1;
353 
354  } else {
355  *State += 10;
356  }
357  }
358  }
359  }
360  except(((*State += 7) == 7) ? EXCEPTION_EXECUTE_HANDLER
362  *Fault += 1;
363  }
364  }
365  finally {
366  if (AbnormalTermination()) {
367  if (*State == 28) {
368  *State += 7;
369  return;
370 
371  } else {
372  *Fault += 1;
373  }
374  }
375  }
376  }
377  except(((*State += 7) == 28) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
378  *Fault += 1;
379  }
380 
381  return;
382 }
383 
385 
386 {
387 
388  try {
389  try {
390  try {
391  try {
392  *Fault += 1;
393  }
394  finally {
395  if (AbnormalTermination()) {
396  if (*State == 8) {
397  *State += 8;
398  *Fault += 1;
399 
400  } else {
401  *State += 10;
402  }
403  }
404  }
405  }
406  except(((*State += 8) == 8) ? EXCEPTION_EXECUTE_HANDLER
408  *Fault += 1;
409  }
410  }
411  finally {
412  if (AbnormalTermination()) {
413  if (*State == 32) {
414  *State += 8;
415  PgFilter();
416  return;
417 
418  } else {
419  *Fault += 1;
420  }
421  }
422  }
423  }
424  except(((*State += 8) == 32) ? EXCEPTION_EXECUTE_HANDLER
426  *Fault += 1;
427  }
428 
429  return;
430 }
431 
433 
434 {
435 
436  try {
437  try {
438  try {
439  try {
440  *Fault += 1;
441  }
442  finally {
443  if (AbnormalTermination()) {
444  if (*State == 9) {
445  *State += 9;
446  *Fault += 1;
447 
448  } else {
449  *State += 10;
450  }
451  }
452  }
453  }
454  except(((*State += 9) == 9) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
455  *Fault += 1;
456  }
457  }
458  finally {
459  if (AbnormalTermination()) {
460  if (*State == 36) {
461  *State += 9;
462  return;
463 
464  } else {
465  *Fault += 1;
466  }
467  }
468  }
469  }
470  except(((*State += 9) == 36) ? EXCEPTION_EXECUTE_HANDLER
472  *Fault += 1;
473  }
474 
475  return;
476 }
477 
479 
480 {
481 
482  try {
483  try {
484  try {
485  try {
486  *Fault += 1;
487  }
488  finally {
489  if (AbnormalTermination()) {
490  if (*State == 10) {
491  *State += 10;
492  PgFilter();
493  *Fault += 1;
494 
495  } else {
496  *State += 10;
497  }
498  }
499  }
500  }
501  except(((*State += 10) == 10) ? EXCEPTION_EXECUTE_HANDLER
503  *Fault += 1;
504  }
505  }
506  finally {
507  if (AbnormalTermination()) {
508  if (*State == 40) {
509  *State += 10;
510  return;
511 
512  } else {
513  *Fault += 1;
514  }
515  }
516  }
517  }
518  except(((*State += 10) == 40) ? EXCEPTION_EXECUTE_HANDLER
520  *Fault += 1;
521  }
522 
523  return;
524 }
525 
526 #pragma warning(pop)
527 
529 
530 {
531 
532  try {
533  try {
534  try {
535  *Fault += 1;
536  }
537  finally {
538  printf("finally 1...");
539  *Fault += 1;
540  }
541  }
542  finally { printf("finally 2..."); }
543  }
544  except(*Counter += 1, printf("filter 1..."), EXCEPTION_CONTINUE_SEARCH) {}
545 
546  return;
547 }
548 
550 
551 ULONG
553 
554 {
555 
556  G = 1;
557  try {
558  while (G) {
559  try {
560  if (G == 10) {
561  return 1;
562  }
563 
564  if (G == 1) {
565  continue;
566  }
567  }
568  finally { G = 0; }
569  }
570  }
571  finally { G = 10; }
572 
573  return 0;
574 }
575 
576 void Test81(int *pCounter) {
577  volatile char *AvPtr = NULL;
578 
579  __try {
580  __try { *AvPtr = '\0'; }
581  __except(EXCEPTION_EXECUTE_HANDLER) { __leave; }
582  }
583  __finally {
584  printf("in finally ");
585  *pCounter += 1;
586  }
587  return;
588 }
589 
592 
593 {
594  *(volatile int *)0 = 0;
595 }
596 
598 
599 {
600 
601  int retval = 1;
602 
603  __try {
604  __try { Test82Foo(); }
605  __finally {
606  switch (*Counter) {
607  case 0:
608  printf("something failed!\n");
609  retval = 6;
610  break;
611 
612  case 1:
613  retval = 0;
614  break;
615 
616  case 2:
617  printf("how did you get here?\n");
618  retval = 2;
619  break;
620 
621  case 3:
622  printf("what?!?\n");
623  retval = 3;
624  break;
625 
626  case 4:
627  printf("not correct\n");
628  retval = 4;
629  break;
630 
631  case 5:
632  printf("error!\n");
633  retval = 5;
634  break;
635  }
636  }
637  }
638  __except(1){}
639 
640  *Counter = retval;
641  return;
642 }
643 
645 
646 {
647 
648  G = 1;
649  try {
650  try {
651  while (G) {
652  try {
653  if (G == 10) {
654  return 1;
655  }
656 
657  if (G == 1) {
658  continue;
659  }
660  }
661  finally { G = 0; }
662  }
663  }
665  }
666  finally { G = 10; }
667 
668  return 0;
669 }
670 
673 
674 {
675  volatile int *Fault = 0;
676 
677  try {
678  try {
679  *Fault += 1;
680  }
682  try {
683  return;
684  }
685  finally { *Counter += 1; }
686  }
687  }
688  finally {
689 
690  if (AbnormalTermination()) {
691  *Counter += 1;
692  }
693  }
694 
695  return;
696 }
697 
700 
701 {
702  volatile int *Fault = 0;
703 
704  G = 1;
705  try {
706  try {
707  try {
708  while (G) {
709  try {
710  try {
711  if (G == 10) {
712  return 1;
713  }
714  try {
715  *Counter += 1;
716  }
718 
719  if (G == 1) {
720  continue;
721  }
722  }
723  finally {
724  G = 0;
725  *Counter += 1;
726  *Fault += 1;
727  }
728  }
730  *Counter += 1;
731  leave;
732  }
733  }
734  }
735  finally {
736  G = 10;
737  *Counter += 1;
738  *Fault += 1;
739  }
740  }
742  *Counter += 1;
743  }
744  finally { *Counter += 1; }
745  return 1;
746 }
747 
750 
751 {
752  volatile int *Fault = 0;
753 
754  try {
755  try {
756  try {
757  try {
758  try {
759  try {
760  *Fault += 1;
761  }
762  except(printf("Filter1 %d..", *Counter),
764  try {
765  printf("Handler1 %d..", *Counter);
766  return;
767  }
768  finally {
769  printf("Finally1 %d..", *Counter);
770  *Counter += 1;
771  }
772  }
773  }
774  finally {
775  printf("Finally2 %d..", *Counter);
776  *Counter += 1;
777  }
778  }
780  }
781  finally { *Counter += 1; }
782  }
784  }
785  finally { *Counter += 1; }
786 
787  return;
788 }
789 
791 
792 /*++
793 
794 Routine Description:
795 
796  This function verifies the behavior of nested exception dispatching.
797 
798 Arguments:
799 
800  Counter - Supplies a pointer to the state counter.
801 
802 Return Value:
803  None.
804 
805 --*/
806 
807 {
808  volatile int *Fault = 0;
809 
810 //
811 // N.B. Disabled on x86 due to failing test case with handling of returns
812 // in nested termination handlers on x86.
813 //
814 // Disabled on ARM due to failing test case with handling of abutting
815 // termination handlers within an except handler.
816 //
817 // Disabled on AMD64 due to failing test case with handling of
818 // abutting termination handlers within an except handler when a
819 // non-local goto is involved.
820 //
821 
822 #if !defined(_X86_)
823  try {
824  try {
825  try {
826  try {
827  try {
828  *Fault += 1;
829 
830  try {
831  }
832  finally {
833  if (AbnormalTermination()) {
834  *Fault += 1;
835  }
836  }
837  }
838  finally {
839 
840  if (AbnormalTermination()) {
841  if ((*Counter += 13) == 26) {
842  return;
843 
844  } else {
845  *Fault += 1;
846  }
847  }
848  }
849  }
850  finally {
851  if (AbnormalTermination()) {
852  *Counter += 13;
853  *Fault += 1;
854  }
855  }
856  }
857  except(((*Counter += 13) == 13) ? EXCEPTION_EXECUTE_HANDLER
859  *Fault += 1;
860  }
861  }
862  except(((*Counter += 13) == 65) ? EXCEPTION_EXECUTE_HANDLER
864  try {
865  *Counter += 13;
866  return;
867  }
868  finally {
869  if (AbnormalTermination()) {
870  *Counter += 13;
871  goto Finish;
872  }
873  }
874  }
875  }
876  finally {
877 
878  if (AbnormalTermination()) {
879  if ((*Counter += 13) == 104) {
880  goto Finish;
881  }
882  }
883  }
884 
885 Finish:
886 #else
887  *Counter = 104;
888 #endif
889 
890  return;
891 }
892 
894 
895 {
896  volatile int *Fault = 0;
897 
898  try {
899  try {
900  try {
901  try {
902  try {
903  try {
904  try {
905  try {
906  *Fault += 1;
907  }
908  except(((*Counter += 1) == 1) ? *Fault
910  }
911  except(*Counter += 1, EXCEPTION_EXECUTE_HANDLER) { *Fault += 2; }
912  }
914  }
916  }
918  }
920  }
922  }
923  finally { *Counter += 1; }
924 }
925 
926 int main(int argc, char *argv[])
927 
928 {
929 
930  PLONG BadAddress;
931  PCHAR BadByte;
932  PLONG BlackHole;
933  ULONG Index1;
934  ULONG Index2 = RED;
935  jmp_buf JumpBuffer;
936  LONG Counter;
937  EXCEPTION_RECORD ExceptionRecord;
938  double doubleresult;
939 
940  //
941  // Announce start of exception test.
942  //
943 
944  printf("Start of exception test\n");
945 
946  //
947  // Initialize exception record.
948  //
949 
950  ExceptionRecord.ExceptionCode = STATUS_INTEGER_OVERFLOW;
951  ExceptionRecord.ExceptionFlags = 0;
952  ExceptionRecord.ExceptionRecord = NULL;
953  ExceptionRecord.NumberParameters = 0;
954 
955  //
956  // Initialize pointers.
957  //
958 
959  BadAddress = (PLONG)NULL;
960  BadByte = (PCHAR)NULL;
961  BadByte += 1;
962  BlackHole = &Counter;
963 
964  //
965  // Simply try statement with a finally clause that is entered sequentially.
966  //
967 
968  printf(" test1...");
969  Counter = 0;
970  try {
971  Counter += 1;
972  }
973  finally {
974  if (abnormal_termination() == FALSE) {
975  Counter += 1;
976  }
977  }
978 
979  if (Counter != 2) {
980  printf("failed, count = %d\n", Counter);
981 
982  } else {
983  printf("succeeded\n");
984  }
985 
986  //
987  // Simple try statement with an exception clause that is never executed
988  // because there is no exception raised in the try clause.
989  //
990 
991  printf(" test2...");
992  Counter = 0;
993  try {
994  Counter += 1;
995  }
996  except(Counter) { Counter += 1; }
997 
998  if (Counter != 1) {
999  printf("failed, count = %d\n", Counter);
1000 
1001  } else {
1002  printf("succeeded\n");
1003  }
1004 
1005  //
1006  // Simple try statement with an exception handler that is never executed
1007  // because the exception expression continues execution.
1008  //
1009 
1010  printf(" test3...");
1011  Counter = 0;
1012  try {
1013  Counter -= 1;
1014  RtlRaiseException(&ExceptionRecord);
1015  }
1016  except(Counter) { Counter -= 1; }
1017 
1018  if (Counter != -1) {
1019  printf("failed, count = %d\n", Counter);
1020 
1021  } else {
1022  printf("succeeded\n");
1023  }
1024 
1025  //
1026  // Simple try statement with an exception clause that is always executed.
1027  //
1028 
1029  printf(" test4...");
1030  Counter = 0;
1031  try {
1032  Counter += 1;
1034  }
1035  except(Counter) { Counter += 1; }
1036 
1037  if (Counter != 2) {
1038  printf("failed, count = %d\n", Counter);
1039 
1040  } else {
1041  printf("succeeded\n");
1042  }
1043 
1044  //
1045  // Simple try statement with an exception clause that is always executed.
1046  //
1047 
1048  printf(" test5...");
1049  Counter = 0;
1050  try {
1051  Counter += 1;
1052  *BlackHole += *BadAddress;
1053  }
1054  except(Counter) { Counter += 1; }
1055 
1056  if (Counter != 2) {
1057  printf("failed, count = %d\n", Counter);
1058 
1059  } else {
1060  printf("succeeded\n");
1061  }
1062 
1063  //
1064  // Simply try statement with a finally clause that is entered as the
1065  // result of an exception.
1066  //
1067 
1068  printf(" test6...");
1069  Counter = 0;
1070  try {
1071  try {
1072  Counter += 1;
1073  RtlRaiseException(&ExceptionRecord);
1074  }
1075  finally {
1076  if (abnormal_termination() != FALSE) {
1077  Counter += 1;
1078  }
1079  }
1080  }
1081  except(Counter) {
1082  if (Counter == 2) {
1083  Counter += 1;
1084  }
1085  }
1086 
1087  if (Counter != 3) {
1088  printf("failed, count = %d\n", Counter);
1089 
1090  } else {
1091  printf("succeeded\n");
1092  }
1093 
1094  //
1095  // Simply try statement with a finally clause that is entered as the
1096  // result of an exception.
1097  //
1098 
1099  printf(" test7...");
1100  Counter = 0;
1101  try {
1102  try {
1103  Counter += 1;
1104  *BlackHole += *BadAddress;
1105  }
1106  finally {
1107  if (abnormal_termination() != FALSE) {
1108  Counter += 1;
1109  }
1110  }
1111  }
1112  except(Counter) {
1113  if (Counter == 2) {
1114  Counter += 1;
1115  }
1116  }
1117 
1118  if (Counter != 3) {
1119  printf("failed, count = %d\n", Counter);
1120 
1121  } else {
1122  printf("succeeded\n");
1123  }
1124 
1125  //
1126  // Simple try that calls a function which raises an exception.
1127  //
1128 
1129  printf(" test8...");
1130  Counter = 0;
1131  try {
1132  Counter += 1;
1134  }
1138  Counter += 1;
1139  }
1140 
1141  if (Counter != 2) {
1142  printf("failed, count = %d\n", Counter);
1143 
1144  } else {
1145  printf("succeeded\n");
1146  }
1147 
1148  //
1149  // Simple try that calls a function which raises an exception.
1150  //
1151 
1152  printf(" test9...");
1153  Counter = 0;
1154  try {
1155  Counter += 1;
1156  foo2(BlackHole, BadAddress);
1157  }
1161  Counter += 1;
1162  }
1163 
1164  if (Counter != 2) {
1165  printf("failed, count = %d\n", Counter);
1166 
1167  } else {
1168  printf("succeeded\n");
1169  }
1170 
1171  //
1172  // Simple try that calls a function which calls a function that
1173  // raises an exception. The first function has a finally clause
1174  // that must be executed for this test to work.
1175  //
1176 
1177  printf(" test10...");
1178  Counter = 0;
1179  try {
1181  }
1185  Counter -= 1;
1186  }
1187 
1188  if (Counter != 98) {
1189  printf("failed, count = %d\n", Counter);
1190 
1191  } else {
1192  printf("succeeded\n");
1193  }
1194 
1195  //
1196  // Simple try that calls a function which calls a function that
1197  // raises an exception. The first function has a finally clause
1198  // that must be executed for this test to work.
1199  //
1200 
1201  printf(" test11...");
1202  Counter = 0;
1203  try {
1204  bar2(BlackHole, BadAddress, &Counter);
1205  }
1209  Counter -= 1;
1210  }
1211 
1212  if (Counter != 98) {
1213  printf("failed, count = %d\n", Counter);
1214 
1215  } else {
1216  printf("succeeded\n");
1217  }
1218 
1219  //
1220  // A try within an except
1221  //
1222 
1223  printf(" test12...");
1224  Counter = 0;
1225  try {
1227  }
1231  Counter += 1;
1232  try {
1234  }
1237  if (Counter != 1) {
1238  printf("failed, count = %d\n", Counter);
1239 
1240  } else {
1241  printf("succeeded...");
1242  }
1243 
1244  Counter += 1;
1245  }
1246  }
1247 
1248  if (Counter != 2) {
1249  printf("failed, count = %d\n", Counter);
1250 
1251  } else {
1252  printf("succeeded\n");
1253  }
1254 
1255  //
1256  // A try within an except
1257  //
1258 
1259  printf(" test13...");
1260  Counter = 0;
1261  try {
1262  foo2(BlackHole, BadAddress);
1263  }
1267  Counter += 1;
1268  try {
1270  }
1273  if (Counter != 1) {
1274  printf("failed, count = %d\n", Counter);
1275 
1276  } else {
1277  printf("succeeded...");
1278  }
1279 
1280  Counter += 1;
1281  }
1282  }
1283 
1284  if (Counter != 2) {
1285  printf("failed, count = %d\n", Counter);
1286 
1287  } else {
1288  printf("succeeded\n");
1289  }
1290 
1291 #if !defined(WIN_CE) // gotos from except/finally not allowed on WinCE
1292  //
1293  // A goto from an exception clause that needs to pass
1294  // through a finally
1295  //
1296 
1297  printf(" test14...");
1298  Counter = 0;
1299  try {
1300  try {
1302  }
1306  Counter += 1;
1307  goto t9;
1308  }
1309  }
1310  finally { Counter += 1; }
1311 
1312 t9:
1313  ;
1314  if (Counter != 2) {
1315  printf("failed, count = %d\n", Counter);
1316 
1317  } else {
1318  printf("succeeded\n");
1319  }
1320 
1321  //
1322  // A goto from an finally clause that needs to pass
1323  // through a finally
1324  //
1325 
1326  printf(" test15...");
1327  Counter = 0;
1328  try {
1329  try {
1330  Counter += 1;
1331  }
1332  finally {
1333  Counter += 1;
1334  goto t10;
1335  }
1336  }
1337  finally { Counter += 1; }
1338 
1339 t10:
1340  ;
1341  if (Counter != 3) {
1342  printf("failed, count = %d\n", Counter);
1343 
1344  } else {
1345  printf("succeeded\n");
1346  }
1347 
1348  //
1349  // A goto from an exception clause that needs to pass
1350  // through a finally into the outer finally clause.
1351  //
1352 
1353  printf(" test16...");
1354  Counter = 0;
1355  try {
1356  try {
1357  try {
1358  Counter += 1;
1360  }
1362  Counter += 1;
1363  goto t11;
1364  }
1365  }
1366  finally { Counter += 1; }
1367  t11:
1368  ;
1369  }
1370  finally { Counter += 1; }
1371 
1372  if (Counter != 4) {
1373  printf("failed, count = %d\n", Counter);
1374 
1375  } else {
1376  printf("succeeded\n");
1377  }
1378 
1379  //
1380  // A goto from an finally clause that needs to pass
1381  // through a finally into the outer finally clause.
1382  //
1383 
1384  printf(" test17...");
1385  Counter = 0;
1386  try {
1387  try {
1388  Counter += 1;
1389  }
1390  finally {
1391  Counter += 1;
1392  goto t12;
1393  }
1394  t12:
1395  ;
1396  }
1397  finally { Counter += 1; }
1398 
1399  if (Counter != 3) {
1400  printf("failed, count = %d\n", Counter);
1401 
1402  } else {
1403  printf("succeeded\n");
1404  }
1405 
1406  //
1407  // A return from an except clause
1408  //
1409 
1410  printf(" test18...");
1411  Counter = 0;
1412  try {
1413  Counter += 1;
1415  }
1416  finally { Counter += 1; }
1417 
1418  if (Counter != 4) {
1419  printf("failed, count = %d\n", Counter);
1420 
1421  } else {
1422  printf("succeeded\n");
1423  }
1424 
1425  //
1426  // A return from a finally clause
1427  //
1428 
1429  printf(" test19...");
1430  Counter = 0;
1431  try {
1432  Counter += 1;
1433  fret(&Counter);
1434  }
1435  finally { Counter += 1; }
1436 
1437  if (Counter != 5) {
1438  printf("failed, count = %d\n", Counter);
1439 
1440  } else {
1441  printf("succeeded\n");
1442  }
1443 #endif
1444 
1445  //
1446  // A simple set jump followed by a long jump.
1447  //
1448 
1449  printf(" test20...");
1450  Counter = 0;
1451  if (setjmp(JumpBuffer) == 0) {
1452  Counter += 1;
1453  longjmp(JumpBuffer, 1);
1454 
1455  } else {
1456  Counter += 1;
1457  }
1458 
1459  if (Counter != 2) {
1460  printf("failed, count = %d\n", Counter);
1461 
1462  } else {
1463  printf("succeeded\n");
1464  }
1465 
1466  //
1467  // A set jump followed by a long jump out of a finally clause that is
1468  // sequentially executed.
1469  //
1470 
1471  printf(" test21...");
1472  Counter = 0;
1473  if (setjmp(JumpBuffer) == 0) {
1474  try {
1475  Counter += 1;
1476  }
1477  finally {
1478  Counter += 1;
1479  longjmp(JumpBuffer, 1);
1480  }
1481 
1482  } else {
1483  Counter += 1;
1484  }
1485 
1486  if (Counter != 3) {
1487  printf("failed, count = %d\n", Counter);
1488 
1489  } else {
1490  printf("succeeded\n");
1491  }
1492 
1493  //
1494  // A set jump within a try clause followed by a long jump out of a
1495  // finally clause that is sequentially executed.
1496  //
1497 
1498  printf(" test22...");
1499  Counter = 0;
1500  try {
1501  if (setjmp(JumpBuffer) == 0) {
1502  Counter += 1;
1503 
1504  } else {
1505  Counter += 1;
1506  }
1507  }
1508  finally {
1509  Counter += 1;
1510  if (Counter == 2) {
1511  Counter += 1;
1512  longjmp(JumpBuffer, 1);
1513  }
1514  }
1515 
1516  if (Counter != 5) {
1517  printf("failed, count = %d\n", Counter);
1518 
1519  } else {
1520  printf("succeeded\n");
1521  }
1522 
1523  //
1524  // A set jump followed by a try/except, followed by a try/finally where
1525  // the try body of the try/finally raises an exception that is handled
1526  // by the try/excecpt which causes the try/finally to do a long jump out
1527  // of a finally clause. This will create a collided unwind.
1528  //
1529 
1530  printf(" test23...");
1531  Counter = 0;
1532  if (setjmp(JumpBuffer) == 0) {
1533  try {
1534  try {
1535  Counter += 1;
1537  }
1538  finally {
1539  Counter += 1;
1540  longjmp(JumpBuffer, 1);
1541  }
1542  }
1544 
1545  } else {
1546  Counter += 1;
1547  }
1548 
1549  if (Counter != 3) {
1550  printf("failed, count = %d\n", Counter);
1551 
1552  } else {
1553  printf("succeeded\n");
1554  }
1555 
1556  //
1557  // A set jump followed by a try/except, followed by a several nested
1558  // try/finally's where the inner try body of the try/finally raises an
1559  // exception that is handled by the try/except which causes the
1560  // try/finally to do a long jump out of a finally clause. This will
1561  // create a collided unwind.
1562  //
1563 
1564  printf(" test24...");
1565  Counter = 0;
1566  if (setjmp(JumpBuffer) == 0) {
1567  try {
1568  try {
1569  try {
1570  try {
1571  Counter += 1;
1573  }
1574  finally { Counter += 1; }
1575  }
1576  finally {
1577  Counter += 1;
1578  longjmp(JumpBuffer, 1);
1579  }
1580  }
1581  finally { Counter += 1; }
1582  }
1584 
1585  } else {
1586  Counter += 1;
1587  }
1588 
1589  if (Counter != 5) {
1590  printf("failed, count = %d\n", Counter);
1591 
1592  } else {
1593  printf("succeeded\n");
1594  }
1595 
1596  //
1597  // A set jump followed by a try/except, followed by a try/finally which
1598  // calls a subroutine which contains a try finally that raises an
1599  // exception that is handled to the try/except.
1600  //
1601 
1602  printf(" test25...");
1603  Counter = 0;
1604  if (setjmp(JumpBuffer) == 0) {
1605  try {
1606  try {
1607  try {
1608  Counter += 1;
1609  dojump(JumpBuffer, &Counter);
1610  }
1611  finally { Counter += 1; }
1612  }
1613  finally { Counter += 1; }
1614  }
1616 
1617  } else {
1618  Counter += 1;
1619  }
1620 
1621  if (Counter != 7) {
1622  printf("failed, count = %d\n", Counter);
1623 
1624  } else {
1625  printf("succeeded\n");
1626  }
1627 
1628  //
1629  // A set jump followed by a try/except, followed by a try/finally which
1630  // calls a subroutine which contains a try finally that raises an
1631  // exception that is handled to the try/except.
1632  //
1633 
1634  printf(" test26...");
1635  Counter = 0;
1636  if (setjmp(JumpBuffer) == 0) {
1637  try {
1638  try {
1639  try {
1640  try {
1641  Counter += 1;
1642  dojump(JumpBuffer, &Counter);
1643  }
1644  finally { Counter += 1; }
1645  }
1646  finally {
1647  Counter += 1;
1648  longjmp(JumpBuffer, 1);
1649  }
1650  }
1651  finally { Counter += 1; }
1652  }
1654 
1655  } else {
1656  Counter += 1;
1657  }
1658 
1659  if (Counter != 8) {
1660  printf("failed, count = %d\n", Counter);
1661 
1662  } else {
1663  printf("succeeded\n");
1664  }
1665 
1666  //
1667  // Test nested exceptions.
1668  //
1669 
1670  printf(" test27...");
1671  Counter = 0;
1672  try {
1673  try {
1674  Counter += 1;
1675  except1(&Counter);
1676  }
1678  }
1680 
1681  if (Counter != 55) {
1682  printf("failed, count = %d\n", Counter);
1683 
1684  } else {
1685  printf("succeeded\n");
1686  }
1687 
1688  //
1689  // Simple try that causes an integer overflow exception.
1690  //
1691 
1692  printf(" test28...");
1693  Counter = 0;
1694  try {
1695  Counter += 1;
1696  addtwo(0x7fff0000, 0x10000, &Counter);
1697  }
1701  Counter += 1;
1702  }
1703 
1704  if (Counter != 2) {
1705  printf("failed, count = %d\n", Counter);
1706 
1707  } else {
1708  printf("succeeded\n");
1709  }
1710 
1711 //
1712 // Simple try that raises an misaligned data exception.
1713 //
1714 #if !defined(i386) && !defined(_M_IA64) && !defined(_M_AMD64) && \
1715  !defined(_M_ARM) && !defined(_M_ARM64)
1716  printf(" test29...");
1717  Counter = 0;
1718  try {
1719  Counter += 1;
1720  foo2(BlackHole, (PLONG)BadByte);
1721  }
1725  Counter += 1;
1726  }
1727 
1728  if (Counter != 2) {
1729  printf("failed, count = %d\n", Counter);
1730 
1731  } else {
1732  printf("succeeded\n");
1733  }
1734 
1735 #endif
1736  //
1737  // Continue from a try body with an exception clause in a loop.
1738  //
1739 
1740  printf(" test30...");
1741  Counter = 0;
1742  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1743  try {
1744  if ((Index1 & 0x1) == 0) {
1745  continue;
1746 
1747  } else {
1748  Counter += 1;
1749  }
1750  }
1752 
1753  Counter += 2;
1754  }
1755 
1756  if (Counter != 15) {
1757  printf("failed, count = %d\n", Counter);
1758 
1759  } else {
1760  printf("succeeded\n");
1761  }
1762 
1763 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
1764  //
1765  // Continue from a try body with an finally clause in a loop.
1766  //
1767 
1768  printf(" test31...");
1769  Counter = 0;
1770  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1771  try {
1772  if ((Index1 & 0x1) == 0) {
1773  continue;
1774 
1775  } else {
1776  Counter += 1;
1777  }
1778  }
1779  finally { Counter += 2; }
1780 
1781  Counter += 3;
1782  }
1783 
1784  if (Counter != 40) {
1785  printf("failed, count = %d\n", Counter);
1786 
1787  } else {
1788  printf("succeeded\n");
1789  }
1790 #endif
1791 
1792  //
1793  // Continue from doubly nested try body with an exception clause in a
1794  // loop.
1795  //
1796 
1797  printf(" test32...");
1798  Counter = 0;
1799  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1800  try {
1801  try {
1802  if ((Index1 & 0x1) == 0) {
1803  continue;
1804 
1805  } else {
1806  Counter += 1;
1807  }
1808  }
1810 
1811  Counter += 2;
1812  }
1814 
1815  Counter += 3;
1816  }
1817 
1818  if (Counter != 30) {
1819  printf("failed, count = %d\n", Counter);
1820 
1821  } else {
1822  printf("succeeded\n");
1823  }
1824 
1825 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
1826  //
1827  // Continue from doubly nested try body with an finally clause in a loop.
1828  //
1829 
1830  printf(" test33...");
1831  Counter = 0;
1832  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1833  try {
1834  try {
1835  if ((Index1 & 0x1) == 0) {
1836  continue;
1837 
1838  } else {
1839  Counter += 1;
1840  }
1841  }
1842  finally { Counter += 2; }
1843 
1844  Counter += 3;
1845  }
1846  finally { Counter += 4; }
1847 
1848  Counter += 5;
1849  }
1850 
1851  if (Counter != 105) {
1852  printf("failed, count = %d\n", Counter);
1853 
1854  } else {
1855  printf("succeeded\n");
1856  }
1857 
1858  //
1859  // Continue from a finally clause in a loop.
1860  //
1861 
1862  printf(" test34...");
1863  Counter = 0;
1864  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1865  try {
1866  if ((Index1 & 0x1) == 0) {
1867  Counter += 1;
1868  }
1869  }
1870  finally {
1871  Counter += 2;
1872  continue;
1873  }
1874 
1875  Counter += 4;
1876  }
1877 
1878  if (Counter != 25) {
1879  printf("failed, count = %d\n", Counter);
1880 
1881  } else {
1882  printf("succeeded\n");
1883  }
1884 
1885  //
1886  // Continue from a doubly nested finally clause in a loop.
1887  //
1888 
1889  printf(" test35...");
1890  Counter = 0;
1891  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1892  try {
1893  try {
1894  if ((Index1 & 0x1) == 0) {
1895  Counter += 1;
1896  }
1897  }
1898  finally {
1899  Counter += 2;
1900  continue;
1901  }
1902 
1903  Counter += 4;
1904  }
1905  finally { Counter += 5; }
1906 
1907  Counter += 6;
1908  }
1909 
1910  if (Counter != 75) {
1911  printf("failed, count = %d\n", Counter);
1912 
1913  } else {
1914  printf("succeeded\n");
1915  }
1916 
1917  //
1918  // Continue from a doubly nested finally clause in a loop.
1919  //
1920 
1921  printf(" test36...");
1922  Counter = 0;
1923  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1924  try {
1925  try {
1926  if ((Index1 & 0x1) == 0) {
1927  Counter += 1;
1928  }
1929  }
1930  finally { Counter += 2; }
1931 
1932  Counter += 4;
1933  }
1934  finally {
1935  Counter += 5;
1936  continue;
1937  }
1938 
1939  Counter += 6;
1940  }
1941 
1942  if (Counter != 115) {
1943  printf("failed, count = %d\n", Counter);
1944 
1945  } else {
1946  printf("succeeded\n");
1947  }
1948 #endif
1949 
1950  //
1951  // Break from a try body with an exception clause in a loop.
1952  //
1953 
1954  printf(" test37...");
1955  Counter = 0;
1956  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1957  try {
1958  if ((Index1 & 0x1) == 1) {
1959  break;
1960 
1961  } else {
1962  Counter += 1;
1963  }
1964  }
1966 
1967  Counter += 2;
1968  }
1969 
1970  if (Counter != 3) {
1971  printf("failed, count = %d\n", Counter);
1972 
1973  } else {
1974  printf("succeeded\n");
1975  }
1976 
1977 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
1978  //
1979  // Break from a try body with an finally clause in a loop.
1980  //
1981 
1982  printf(" test38...");
1983  Counter = 0;
1984  for (Index1 = 0; Index1 < 10; Index1 += 1) {
1985  try {
1986  if ((Index1 & 0x1) == 1) {
1987  break;
1988 
1989  } else {
1990  Counter += 1;
1991  }
1992  }
1993  finally { Counter += 2; }
1994 
1995  Counter += 3;
1996  }
1997 
1998  if (Counter != 8) {
1999  printf("failed, count = %d\n", Counter);
2000 
2001  } else {
2002  printf("succeeded\n");
2003  }
2004 #endif
2005 
2006  //
2007  // Break from doubly nested try body with an exception clause in a
2008  // loop.
2009  //
2010 
2011  printf(" test39...");
2012  Counter = 0;
2013  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2014  try {
2015  try {
2016  if ((Index1 & 0x1) == 1) {
2017  break;
2018 
2019  } else {
2020  Counter += 1;
2021  }
2022  }
2024 
2025  Counter += 2;
2026  }
2028 
2029  Counter += 3;
2030  }
2031 
2032  if (Counter != 6) {
2033  printf("failed, count = %d\n", Counter);
2034 
2035  } else {
2036  printf("succeeded\n");
2037  }
2038 
2039 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
2040  //
2041  // Break from doubly nested try body with an finally clause in a loop.
2042  //
2043 
2044  printf(" test40...");
2045  Counter = 0;
2046  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2047  try {
2048  try {
2049  if ((Index1 & 0x1) == 1) {
2050  break;
2051 
2052  } else {
2053  Counter += 1;
2054  }
2055  }
2056  finally { Counter += 2; }
2057 
2058  Counter += 3;
2059  }
2060  finally { Counter += 4; }
2061 
2062  Counter += 5;
2063  }
2064 
2065  if (Counter != 21) {
2066  printf("failed, count = %d\n", Counter);
2067 
2068  } else {
2069  printf("succeeded\n");
2070  }
2071 
2072  //
2073  // Break from a finally clause in a loop.
2074  //
2075 
2076  printf(" test41...");
2077  Counter = 0;
2078  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2079  try {
2080  if ((Index1 & 0x1) == 1) {
2081  Counter += 1;
2082  }
2083  }
2084  finally {
2085  Counter += 2;
2086  break;
2087  }
2088 
2089  Counter += 4;
2090  }
2091 
2092  if (Counter != 2) {
2093  printf("failed, count = %d\n", Counter);
2094 
2095  } else {
2096  printf("succeeded\n");
2097  }
2098 
2099  //
2100  // Break from a doubly nested finally clause in a loop.
2101  //
2102 
2103  printf(" test42...");
2104  Counter = 0;
2105  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2106  try {
2107  try {
2108  if ((Index1 & 0x1) == 1) {
2109  Counter += 1;
2110  }
2111  }
2112  finally {
2113  Counter += 2;
2114  break;
2115  }
2116 
2117  Counter += 4;
2118  }
2119  finally { Counter += 5; }
2120 
2121  Counter += 6;
2122  }
2123 
2124  if (Counter != 7) {
2125  printf("failed, count = %d\n", Counter);
2126 
2127  } else {
2128  printf("succeeded\n");
2129  }
2130 
2131  //
2132  // Break from a doubly nested finally clause in a loop.
2133  //
2134 
2135  printf(" test43...");
2136  Counter = 0;
2137  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2138  try {
2139  try {
2140  if ((Index1 & 0x1) == 1) {
2141  Counter += 1;
2142  }
2143  }
2144  finally { Counter += 2; }
2145 
2146  Counter += 4;
2147  }
2148  finally {
2149  Counter += 5;
2150  break;
2151  }
2152 
2153  Counter += 6;
2154  }
2155 
2156  if (Counter != 11) {
2157  printf("failed, count = %d\n", Counter);
2158 
2159  } else {
2160  printf("succeeded\n");
2161  }
2162 #endif
2163 
2164  //
2165  // Break from a try body with an exception clause in a switch.
2166  //
2167 
2168  printf(" test44...");
2169  Counter = 0;
2170  Index1 = 1;
2171  switch (Index2) {
2172  case BLUE:
2173  Counter += 100;
2174  break;
2175 
2176  case RED:
2177  try {
2178  if ((Index1 & 0x1) == 1) {
2179  break;
2180 
2181  } else {
2182  Counter += 1;
2183  }
2184  }
2186 
2187  Counter += 2;
2188  break;
2189  }
2190 
2191  if (Counter != 0) {
2192  printf("failed, count = %d\n", Counter);
2193 
2194  } else {
2195  printf("succeeded\n");
2196  }
2197 
2198 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
2199  //
2200  // Break from a try body with an finally clause in a switch.
2201  //
2202 
2203  printf(" test45...");
2204  Counter = 0;
2205  Index1 = 1;
2206  switch (Index2) {
2207  case BLUE:
2208  Counter += 100;
2209  break;
2210 
2211  case RED:
2212  try {
2213  if ((Index1 & 0x1) == 1) {
2214  break;
2215 
2216  } else {
2217  Counter += 1;
2218  }
2219  }
2220  finally { Counter += 2; }
2221 
2222  Counter += 3;
2223  }
2224 
2225  if (Counter != 2) {
2226  printf("failed, count = %d\n", Counter);
2227 
2228  } else {
2229  printf("succeeded\n");
2230  }
2231 #endif
2232 
2233  //
2234  // Break from doubly nested try body with an exception clause in a
2235  // switch.
2236  //
2237 
2238  printf(" test46...");
2239  Counter = 0;
2240  Index1 = 1;
2241  switch (Index2) {
2242  case BLUE:
2243  Counter += 100;
2244  break;
2245 
2246  case RED:
2247  try {
2248  try {
2249  if ((Index1 & 0x1) == 1) {
2250  break;
2251 
2252  } else {
2253  Counter += 1;
2254  }
2255  }
2257 
2258  Counter += 2;
2259  }
2261 
2262  Counter += 3;
2263  }
2264 
2265  if (Counter != 0) {
2266  printf("failed, count = %d\n", Counter);
2267 
2268  } else {
2269  printf("succeeded\n");
2270  }
2271 
2272 #if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
2273  //
2274  // Break from doubly nested try body with an finally clause in a switch.
2275  //
2276 
2277  printf(" test47...");
2278  Counter = 0;
2279  Index1 = 1;
2280  switch (Index2) {
2281  case BLUE:
2282  Counter += 100;
2283  break;
2284 
2285  case RED:
2286  try {
2287  try {
2288  if ((Index1 & 0x1) == 1) {
2289  break;
2290 
2291  } else {
2292  Counter += 1;
2293  }
2294  }
2295  finally { Counter += 2; }
2296 
2297  Counter += 3;
2298  }
2299  finally { Counter += 4; }
2300 
2301  Counter += 5;
2302  }
2303 
2304  if (Counter != 6) {
2305  printf("failed, count = %d\n", Counter);
2306 
2307  } else {
2308  printf("succeeded\n");
2309  }
2310 
2311  //
2312  // Break from a finally clause in a switch.
2313  //
2314 
2315  printf(" test48...");
2316  Counter = 0;
2317  Index1 = 1;
2318  switch (Index2) {
2319  case BLUE:
2320  Counter += 100;
2321  break;
2322 
2323  case RED:
2324  try {
2325  if ((Index1 & 0x1) == 1) {
2326  Counter += 1;
2327  }
2328  }
2329  finally {
2330  Counter += 2;
2331  break;
2332  }
2333 
2334  Counter += 4;
2335  }
2336 
2337  if (Counter != 3) {
2338  printf("failed, count = %d\n", Counter);
2339 
2340  } else {
2341  printf("succeeded\n");
2342  }
2343 
2344  //
2345  // Break from a doubly nested finally clause in a switch.
2346  //
2347 
2348  printf(" test49...");
2349  Counter = 0;
2350  Index1 = 1;
2351  switch (Index2) {
2352  case BLUE:
2353  Counter += 100;
2354  break;
2355 
2356  case RED:
2357  try {
2358  try {
2359  if ((Index1 & 0x1) == 1) {
2360  Counter += 1;
2361  }
2362  }
2363  finally {
2364  Counter += 2;
2365  break;
2366  }
2367 
2368  Counter += 4;
2369  }
2370  finally { Counter += 5; }
2371 
2372  Counter += 6;
2373  }
2374 
2375  if (Counter != 8) {
2376  printf("failed, count = %d\n", Counter);
2377 
2378  } else {
2379  printf("succeeded\n");
2380  }
2381 
2382  //
2383  // Break from a doubly nested finally clause in a switch.
2384  //
2385 
2386  printf(" test50...");
2387  Counter = 0;
2388  Index1 = 1;
2389  switch (Index2) {
2390  case BLUE:
2391  Counter += 100;
2392  break;
2393 
2394  case RED:
2395  try {
2396  try {
2397  if ((Index1 & 0x1) == 1) {
2398  Counter += 1;
2399  }
2400  }
2401  finally { Counter += 2; }
2402 
2403  Counter += 4;
2404  }
2405  finally {
2406  Counter += 5;
2407  break;
2408  }
2409 
2410  Counter += 6;
2411  }
2412 
2413  if (Counter != 12) {
2414  printf("failed, count = %d\n", Counter);
2415 
2416  } else {
2417  printf("succeeded\n");
2418  }
2419 #endif
2420 
2421  //
2422  // Leave from an if in a simple try/finally.
2423  //
2424 
2425  printf(" test51...");
2426  Counter = 0;
2427  try {
2428  if (Echo(Counter) == Counter) {
2429  Counter += 3;
2430  leave;
2431 
2432  } else {
2433  Counter += 100;
2434  }
2435  }
2436  finally {
2437  if (abnormal_termination() == FALSE) {
2438  Counter += 5;
2439  }
2440  }
2441 
2442  if (Counter != 8) {
2443  printf("failed, count = %d\n", Counter);
2444 
2445  } else {
2446  printf("succeeded\n");
2447  }
2448 
2449  //
2450  // Leave from a loop in a simple try/finally.
2451  //
2452 
2453  printf(" test52...");
2454  Counter = 0;
2455  try {
2456  for (Index1 = 0; Index1 < 10; Index1 += 1) {
2457  if (Echo(Index1) == Index1) {
2458  Counter += 3;
2459  leave;
2460  }
2461 
2462  Counter += 100;
2463  }
2464  }
2465  finally {
2466  if (abnormal_termination() == FALSE) {
2467  Counter += 5;
2468  }
2469  }
2470 
2471  if (Counter != 8) {
2472  printf("failed, count = %d\n", Counter);
2473 
2474  } else {
2475  printf("succeeded\n");
2476  }
2477 
2478  //
2479  // Leave from a switch in a simple try/finally.
2480  //
2481 
2482  printf(" test53...");
2483  Counter = 0;
2484  try {
2485  switch (Index2) {
2486  case BLUE:
2487  break;
2488 
2489  case RED:
2490  Counter += 3;
2491  leave;
2492  }
2493 
2494  Counter += 100;
2495  }
2496  finally {
2497  if (abnormal_termination() == FALSE) {
2498  Counter += 5;
2499  }
2500  }
2501 
2502  if (Counter != 8) {
2503  printf("failed, count = %d\n", Counter);
2504 
2505  } else {
2506  printf("succeeded\n");
2507  }
2508 
2509  //
2510  // Leave from an if in doubly nested try/finally followed by a leave
2511  // from an if in the outer try/finally.
2512  //
2513 
2514  printf(" test54...");
2515  Counter = 0;
2516  try {
2517  try {
2518  if (Echo(Counter) == Counter) {
2519  Counter += 3;
2520  leave;
2521 
2522  } else {
2523  Counter += 100;
2524  }
2525  }
2526  finally {
2527  if (abnormal_termination() == FALSE) {
2528  Counter += 5;
2529  }
2530  }
2531 
2532  if (Echo(Counter) == Counter) {
2533  Counter += 3;
2534  leave;
2535 
2536  } else {
2537  Counter += 100;
2538  }
2539  }
2540  finally {
2541  if (abnormal_termination() == FALSE) {
2542  Counter += 5;
2543  }
2544  }
2545 
2546  if (Counter != 16) {
2547  printf("failed, count = %d\n", Counter);
2548 
2549  } else {
2550  printf("succeeded\n");
2551  }
2552 
2553 #if !defined(WIN_CE) // leave from finally not allowed on WinCE
2554  //
2555  // Leave from an if in doubly nested try/finally followed by a leave
2556  // from the finally of the outer try/finally.
2557  //
2558 
2559  printf(" test55...");
2560  Counter = 0;
2561  try {
2562  try {
2563  if (Echo(Counter) == Counter) {
2564  Counter += 3;
2565  leave;
2566 
2567  } else {
2568  Counter += 100;
2569  }
2570  }
2571  finally {
2572  if (abnormal_termination() == FALSE) {
2573  Counter += 5;
2574  leave;
2575  }
2576  }
2577 
2578  Counter += 100;
2579  }
2580  finally {
2581  if (abnormal_termination() == FALSE) {
2582  Counter += 5;
2583  }
2584  }
2585 
2586  if (Counter != 13) {
2587  printf("failed, count = %d\n", Counter);
2588 
2589  } else {
2590  printf("succeeded\n");
2591  }
2592 #endif
2593 
2594  //
2595  // Try/finally within the except clause of a try/except that is always
2596  // executed.
2597  //
2598 
2599  printf(" test56...");
2600  Counter = 0;
2601  try {
2602  Counter += 1;
2604  }
2605  except(Counter) {
2606  try {
2607  Counter += 3;
2608  }
2609  finally {
2610  if (abnormal_termination() == FALSE) {
2611  Counter += 5;
2612  }
2613  }
2614  }
2615 
2616  if (Counter != 9) {
2617  printf("failed, count = %d\n", Counter);
2618 
2619  } else {
2620  printf("succeeded\n");
2621  }
2622 
2623  //
2624  // Try/finally within the finally clause of a try/finally.
2625  //
2626 
2627  printf(" test57...");
2628  Counter = 0;
2629  try {
2630  Counter += 1;
2631  }
2632  finally {
2633  if (abnormal_termination() == FALSE) {
2634  try {
2635  Counter += 3;
2636  }
2637  finally {
2638  if (abnormal_termination() == FALSE) {
2639  Counter += 5;
2640  }
2641  }
2642  }
2643  }
2644 
2645  if (Counter != 9) {
2646  printf("failed, count = %d\n", Counter);
2647 
2648  } else {
2649  printf("succeeded\n");
2650  }
2651 
2652  //
2653  // Try/except within the finally clause of a try/finally.
2654  //
2655 
2656  printf(" test58...");
2657 #if !defined(NEST_IN_FINALLY)
2658  printf("skipped\n");
2659 #else
2660  Counter = 0;
2661  try {
2662  Counter -= 1;
2663  }
2664  finally {
2665  try {
2666  Counter += 2;
2668  }
2669  except(Counter) {
2670  try {
2671  Counter += 3;
2672  }
2673  finally {
2674  if (abnormal_termination() == FALSE) {
2675  Counter += 5;
2676  }
2677  }
2678  }
2679  }
2680 
2681  if (Counter != 9) {
2682  printf("failed, count = %d\n", Counter);
2683 
2684  } else {
2685  printf("succeeded\n");
2686  }
2687 #endif /* def(NEST_IN_FINALLY) */
2688 
2689  //
2690  // Try/except within the except clause of a try/except that is always
2691  // executed.
2692  //
2693 
2694  printf(" test59...");
2695  Counter = 0;
2696  try {
2697  Counter += 1;
2699  }
2700  except(Counter) {
2701  try {
2702  Counter += 3;
2704  }
2705  except(Counter - 3) { Counter += 5; }
2706  }
2707 
2708  if (Counter != 9) {
2709  printf("failed, count = %d\n", Counter);
2710 
2711  } else {
2712  printf("succeeded\n");
2713  }
2714 
2715  //
2716  // Try with a Try which exits the scope with a goto
2717  //
2718 
2719  printf(" test60...");
2720  Counter = 0;
2721  try {
2722  try {
2723  goto outside;
2724  }
2725  except(1) { Counter += 1; }
2726 
2727  outside:
2729  }
2730  except(1) { Counter += 3; }
2731 
2732  if (Counter != 3) {
2733  printf("failed, count = %d\n", Counter);
2734  } else {
2735  printf("succeeded\n");
2736  }
2737 
2738  //
2739  // Try/except which gets an exception from a subfunction within
2740  // a try/finally which has a try/except in the finally clause
2741  //
2742 
2743  printf(" test61...");
2744 #if !defined(NEST_IN_FINALLY)
2745  printf("skipped\n");
2746 #else
2747  Counter = 0;
2748  try {
2749  Test61Part2(&Counter);
2750  }
2752 
2753  if (Counter != 24) {
2754  printf("failed, count = %d\n", Counter);
2755 
2756  } else {
2757  printf("succeeded\n");
2758  }
2759 #endif /* def(NEST_IN_FINALLY) */
2760 
2761  //
2762  // Check for precision of exception on floating point
2763  //
2764 
2765  printf(" test62...");
2766 
2767 #if defined(i386) || defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_AMD64)
2768 
2769 /* enable floating point overflow */
2770 #if defined(i386)
2771  _control87(_control87(0, 0) & ~EM_OVERFLOW, _MCW_EM);
2772 #else
2773  //
2774  // use portable version of _control87
2775  //
2776  _controlfp(_controlfp(0, 0) & ~EM_OVERFLOW, _MCW_EM);
2777 #endif
2778 
2779  Counter = 0;
2780  try {
2781  doubleresult = SquareDouble(1.7e300);
2782 
2783  try {
2784  doubleresult = SquareDouble(1.0);
2785  }
2786  except(1) { Counter += 3; }
2787  }
2788  except(1) { Counter += 1; }
2789 
2790  if (Counter != 1) {
2791  printf("failed, count = %d\n", Counter);
2792 
2793  } else {
2794  printf("succeeded\n");
2795  }
2796 
2797 /* clear up pending unmasked exceptions and restore FP control registers */
2798 #if defined(i386)
2799  _clear87();
2800  _control87(_control87(0, 0) | EM_OVERFLOW, 0xfffff);
2801 #else
2802  _clearfp();
2803  _controlfp(_controlfp(0, 0) | EM_OVERFLOW, 0xfffff);
2804 #endif
2805 
2806 #else
2807  printf("skipped\n");
2808 #endif
2809 
2810  //
2811  // A try/finally inside a try/except where an exception is raised in the
2812  // try/finally.
2813  //
2814 
2815  printf(" test63...");
2816  Counter = 0;
2817  try {
2818  try {
2819  Counter += 1;
2820  }
2821  finally {
2822  Counter += 3;
2824  }
2825  }
2826  except(1) { Counter += 6; }
2827 
2828  if (Counter != 10) {
2829  printf("failed, count = %d\n", Counter);
2830 
2831  } else {
2832  printf("succeeded\n");
2833  }
2834 
2835  //
2836  // A try/finally inside a try/except where an exception is raised in the
2837  // in the try/except and the try/finally.
2838  //
2839 
2840  printf(" test64...");
2841  Counter = 0;
2842  try {
2843  try {
2844  Counter += 1;
2846  }
2847  finally {
2848  Counter += 3;
2850  }
2851  }
2852  except(1) { Counter += 6; }
2853 
2854  if (Counter != 10) {
2855  printf("failed, count = %d\n", Counter);
2856 
2857  } else {
2858  printf("succeeded\n");
2859  }
2860 
2861  //
2862  // A try/finally inside a try/except where an exception is raised in the
2863  // try/finally.
2864  //
2865 
2866  printf(" test65...");
2867  Counter = 0;
2868  try {
2869  try {
2870  Counter += 1;
2871  }
2872  finally {
2873  Counter += 3;
2874  *BlackHole += *BadAddress;
2875  Counter += 13;
2876  }
2877  }
2878  except(1) { Counter += 6; }
2879 
2880  if (Counter != 10) {
2881  printf("failed, count = %d\n", Counter);
2882 
2883  } else {
2884  printf("succeeded\n");
2885  }
2886 
2887  //
2888  // A try/finally inside a try/except where an exception is raised in the
2889  // in the try/except and the try/finally.
2890  //
2891 
2892  printf(" test66...");
2893  Counter = 0;
2894  try {
2895  try {
2896  Counter += 1;
2897  *BlackHole += *BadAddress;
2898  Counter += 13;
2899  }
2900  finally {
2901  Counter += 3;
2902  *BlackHole += *BadAddress;
2903  Counter += 13;
2904  }
2905  }
2906  except(1) { Counter += 6; }
2907 
2908  if (Counter != 10) {
2909  printf("failed, count = %d\n", Counter);
2910 
2911  } else {
2912  printf("succeeded\n");
2913  }
2914 
2915  //
2916  // A try/finally inside a try/finally inside a try/except where an
2917  // exception is raised in the in the try/except and in try/finally.
2918  //
2919 
2920  printf(" test67...");
2921  try {
2922  try {
2923  *BlackHole += *BadAddress;
2924  }
2925  finally {
2926  try {
2927  Counter = 0;
2928  }
2929  finally {
2930  if (Counter != 0) {
2931  Counter += 1;
2932  }
2933  }
2934 
2935  Counter += 1;
2936  *BlackHole += *BadAddress;
2937  }
2938  }
2939  except(1) { Counter += 1; }
2940 
2941  if (Counter != 2) {
2942  printf("failed, count = %d\n", Counter);
2943 
2944  } else {
2945  printf("succeeded\n");
2946  }
2947 
2948  //
2949  // A try/finally inside a try/finally inside a try/except where an
2950  // exception is raised in the in the try/except and in try/finally.
2951  //
2952 
2953  printf(" test68...");
2954  try {
2955  try {
2957  }
2958  finally {
2959  try {
2960  Counter = 0;
2961  }
2962  finally {
2963  if (Counter != 0) {
2964  Counter += 1;
2965  }
2966  }
2967 
2968  Counter += 1;
2970  }
2971  }
2972  except(1) { Counter += 1; }
2973 
2974  if (Counter != 2) {
2975  printf("failed, count = %d\n", Counter);
2976 
2977  } else {
2978  printf("succeeded\n");
2979  }
2980 
2981 //
2982 // Patch guard test 69.
2983 //
2984 
2985 #if defined(_AMD64_) || defined(_X86_)
2986 
2987  printf(" test69...");
2988  Counter = 0;
2989  try {
2990  PgTest69(&Counter, BadAddress);
2991  }
2992  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
2993 
2994  if (Counter != 2) {
2995  printf("failed, count = %d\n", Counter);
2996 
2997  } else {
2998  printf("succeeded\n");
2999  }
3000 
3001  printf(" test70...");
3002  Counter = 0;
3003  try {
3004  PgTest70(&Counter, BadAddress);
3005  }
3006  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3007 
3008  if (Counter != 2) {
3009  printf("failed, count = %d\n", Counter);
3010 
3011  } else {
3012  printf("succeeded\n");
3013  }
3014 
3015  printf(" test71...");
3016  Counter = 0;
3017  try {
3018  PgTest71(&Counter, BadAddress);
3019  }
3020  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3021 
3022  if (Counter != 9) {
3023  printf("failed, count = %d\n", Counter);
3024 
3025  } else {
3026  printf("succeeded\n");
3027  }
3028 
3029  printf(" test72...");
3030  Counter = 0;
3031  try {
3032  PgTest72(&Counter, BadAddress);
3033  }
3034  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3035 
3036  if (Counter != 12) {
3037  printf("failed, count = %d\n", Counter);
3038 
3039  } else {
3040  printf("succeeded\n");
3041  }
3042 
3043  printf(" test73...");
3044  Counter = 0;
3045  try {
3046  PgTest73(&Counter, BadAddress);
3047  }
3048  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3049 
3050  if (Counter != 15) {
3051  printf("failed, count = %d\n", Counter);
3052 
3053  } else {
3054  printf("succeeded\n");
3055  }
3056 
3057  printf(" test74...");
3058  Counter = 0;
3059  try {
3060  PgTest74(&Counter, BadAddress);
3061  }
3062  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3063 
3064  if (Counter != 18) {
3065  printf("failed, count = %d\n", Counter);
3066 
3067  } else {
3068  printf("succeeded\n");
3069  }
3070 
3071  printf(" test75...");
3072  Counter = 0;
3073  try {
3074  PgTest75(&Counter, BadAddress);
3075  }
3076  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3077 
3078  if (Counter != 35) {
3079  printf("failed, count = %d\n", Counter);
3080 
3081  } else {
3082  printf("succeeded\n");
3083  }
3084 
3085  printf(" test76...");
3086  Counter = 0;
3087  try {
3088  PgTest76(&Counter, BadAddress);
3089  }
3090  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3091 
3092  if (Counter != 40) {
3093  printf("failed, count = %d\n", Counter);
3094 
3095  } else {
3096  printf("succeeded\n");
3097  }
3098 
3099  printf(" test77...");
3100  Counter = 0;
3101  try {
3102  PgTest77(&Counter, BadAddress);
3103  }
3104  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3105 
3106  if (Counter != 45) {
3107  printf("failed, count = %d\n", Counter);
3108 
3109  } else {
3110  printf("succeeded\n");
3111  }
3112 
3113  printf(" test78...");
3114  Counter = 0;
3115  try {
3116  PgTest78(&Counter, BadAddress);
3117  }
3118  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
3119 
3120  if (Counter != 50) {
3121  printf("failed, count = %d\n", Counter);
3122 
3123  } else {
3124  printf("succeeded\n");
3125  }
3126 
3127 #else
3128  printf(" test69...filter entered...succeeded\n");
3129  printf(" test70...filter entered...succeeded\n");
3130  printf(" test71...filter entered...succeeded\n");
3131  printf(" test72...filter entered...succeeded\n");
3132  printf(" test73...filter entered...succeeded\n");
3133  printf(" test74...filter entered...succeeded\n");
3134  printf(" test75...filter entered...succeeded\n");
3135  printf(" test76...filter entered...succeeded\n");
3136  printf(" test77...filter entered...succeeded\n");
3137  printf(" test78...filter entered...succeeded\n");
3138 #endif
3139 
3140  if (LOBYTE(LOWORD(GetVersion())) < 6) {
3141  printf(" test79...");
3142  printf("filter 1...filter 2...finally 1...filter 1...filter 2...finally "
3143  "2...passed\n");
3144  } else {
3145 
3146  printf(" test79...");
3147  Counter = 0;
3148  try {
3149  Test79(&Counter, BadAddress);
3150  }
3151  except(printf("filter 2..."), EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
3152 
3153  if (Counter == 3) {
3154  printf("passed\n");
3155 
3156  } else {
3157  printf("failed %d \n", Counter);
3158  }
3159  }
3160 
3161  printf(" test80...");
3162  if (Test80() != 0) {
3163  printf("failed\n");
3164 
3165  } else {
3166  printf("passed\n");
3167  }
3168 
3169  printf(" test81...");
3170  Counter = 0;
3171  Test81(&Counter);
3172  if (Counter != 1) {
3173  printf("failed %d \n", Counter);
3174 
3175  } else {
3176  printf("passed\n");
3177  }
3178 
3179  printf(" test82...");
3180  Counter = 1;
3181  Test82(&Counter);
3182  if (Counter != 0) {
3183  printf("failed\n");
3184 
3185  } else {
3186  printf("succeeded\n");
3187  }
3188 
3189  printf(" test83...");
3190  if (Test83() != 0) {
3191  printf("failed\n");
3192 
3193  } else {
3194  printf("succeeded\n");
3195  }
3196 
3197  printf(" test84...");
3198  Counter = 0;
3199  Test84(&Counter);
3200  if (Counter != 2) {
3201  printf("failed\n");
3202 
3203  } else {
3204  printf("succeeded\n");
3205  }
3206 
3207  printf(" test85...");
3208  Counter = 0;
3209  Test85(&Counter);
3210  if (Counter != 7) {
3211  printf("failed\n");
3212 
3213  } else {
3214  printf("succeeded\n");
3215  }
3216 
3217  printf(" test86...");
3218  Counter = 0;
3219  Test86(&Counter);
3220  if (Counter != 4) {
3221  printf("failed %d\n", Counter);
3222 
3223  } else {
3224  printf("succeeded\n");
3225  }
3226 
3227  printf(" test87...");
3228  Counter = 0;
3229  Test87(&Counter);
3230  if (Counter != 104) {
3231  printf("failed %d\n", Counter);
3232 
3233  } else {
3234  printf("succeeded\n");
3235  }
3236 
3237  printf(" test88...");
3238  Counter = 0;
3239  Test88(&Counter);
3240  if (Counter != 6) {
3241  printf("failed %d\n", Counter);
3242 
3243  } else {
3244  printf("succeeded\n");
3245  }
3246 
3247  //
3248  // Announce end of exception test.
3249  //
3250 
3251  printf("End of exception test\n");
3252  return;
3253 }
3254 
3255 #pragma optimize("a", off)
3256 VOID addtwo(long First, long Second, long *Place)
3257 
3258 {
3259 
3261  *Place = First + Second;
3262  return;
3263 }
3264 #pragma optimize("", on)
3265 
3267 
3268  try {
3269  foo1(Status);
3270  }
3271  finally {
3272  if (abnormal_termination() != FALSE) {
3273  *Counter = 99;
3274 
3275  } else {
3276  *Counter = 100;
3277  }
3278  }
3279 
3280  return;
3281 }
3282 
3283 VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter) {
3284 
3285  try {
3286  foo2(BlackHole, BadAddress);
3287  }
3288  finally {
3289  if (abnormal_termination() != FALSE) {
3290  *Counter = 99;
3291 
3292  } else {
3293  *Counter = 100;
3294  }
3295  }
3296 
3297  return;
3298 }
3299 
3301 
3302 {
3303 
3304  try {
3305  try {
3306  *Counter += 1;
3308  }
3309  finally { *Counter += 1; }
3310  }
3311  finally {
3312  *Counter += 1;
3313  longjmp(JumpBuffer, 1);
3314  }
3315 }
3316 
3317 #if !defined(WIN_CE) // return through finally not allowed on WinCE
3319 
3320 {
3321 
3322  try {
3323  try {
3324  foo1(Status);
3325  }
3328  *Counter += 1;
3329  return;
3330  }
3331  }
3332  finally { *Counter += 1; }
3333 
3334  return;
3335 }
3336 #endif
3337 
3339 
3340 {
3341 
3342  try {
3343  *Counter += 5;
3345  }
3347 
3348  *Counter += 9;
3349  return;
3350 }
3351 
3352 ULONG
3354 
3355 {
3356 
3357  PEXCEPTION_RECORD ExceptionRecord;
3358 
3359  ExceptionRecord = ExceptionPointers->ExceptionRecord;
3360  if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
3361  ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
3362  *Counter += 11;
3364 
3365  } else {
3366  *Counter += 13;
3368  }
3369 }
3370 
3371 ULONG
3373 
3374 {
3375 
3376  PEXCEPTION_RECORD ExceptionRecord;
3377 
3378  ExceptionRecord = ExceptionPointers->ExceptionRecord;
3379  if ((ExceptionRecord->ExceptionCode == STATUS_INTEGER_OVERFLOW) &&
3380  ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
3381  *Counter += 17;
3383 
3384  } else if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
3385  ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) != 0)) {
3386  *Counter += 19;
3388  }
3389 
3390  *Counter += 23;
3392 }
3393 
3395 
3396 {
3397 
3398  //
3399  // Raise exception.
3400  //
3401 
3403  return;
3404 }
3405 
3406 VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress)
3407 
3408 {
3409 
3410  //
3411  // Raise exception.
3412  //
3413 
3414  *BlackHole += *BadAddress;
3415  return;
3416 }
3417 
3418 #if !defined(WIN_CE) // return from finally not allowed on WinCE
3420 
3421 {
3422 
3423  try {
3424  try {
3425  *Counter += 1;
3426  }
3427  finally {
3428  *Counter += 1;
3429  return;
3430  }
3431  }
3432  finally { *Counter += 1; }
3433 
3434  return;
3435 }
3436 #endif
3437 
3439 
3440 {
3441  return Value;
3442 }
3443 
3444 #if defined(NEST_IN_FINALLY)
3446  try {
3447  *Counter -= 1;
3449  }
3450  finally {
3451  try {
3452  *Counter += 2;
3454  }
3456  *Counter += 7;
3457  }
3458 }
3459 #endif /* def(NEST_IN_FINALLY) */
3460 
3461 double SquareDouble(IN double op) {
3462  return exp(2.0 * log(op));
3463 }
signed char * PCHAR
Definition: retypes.h:7
static int argc
Definition: ServiceArgs.c:12
#define IN
Definition: typedefs.h:39
DECLSPEC_NORETURN NTSYSAPI VOID NTAPI RtlRaiseStatus(_In_ NTSTATUS Status)
#define GetExceptionInformation()
Definition: seh.h:26
#define STATUS_SUCCESS
Definition: xcpt4u.c:55
#define _Inout_
Definition: ms_sal.h:378
VOID Test61Part2(IN OUT PULONG Counter)
VOID except1(IN PLONG Counter)
Definition: xcpt4u.c:3338
#define LOBYTE(W)
Definition: jmemdos.c:487
VOID PgTest77(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:432
WCHAR Second[]
Definition: FormatMessage.c:12
VOID foo1(IN NTSTATUS Status)
Definition: xcpt4u.c:3394
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG x1
Definition: winddi.h:3706
LONG NTSTATUS
Definition: precomp.h:26
VOID Test79(PLONG Counter, PLONG Fault)
Definition: xcpt4u.c:528
VOID PgTest76(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:384
__MINGW_NOTHROW _CRTIMP unsigned int __cdecl _clearfp(void)
Definition: _clearfp.c:10
unsigned int __cdecl _control87(unsigned int, unsigned int)
Definition: _controlfp.c:16
VOID PgTest74(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:297
int __MINGW_NOTHROW __cdecl setjmp(jmp_buf _Buf)
VOID Test82(__inout PLONG Counter)
Definition: xcpt4u.c:597
#define _MCW_EM
Definition: float.h:40
ULONG G
Definition: xcpt4u.c:549
ULONG except2(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
Definition: xcpt4u.c:3353
VOID PgTest78(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:478
NTSYSAPI VOID NTAPI RtlRaiseException(_In_ PEXCEPTION_RECORD ExceptionRecord)
#define argv
Definition: mplay32.c:18
LONG Echo(IN LONG Value)
Definition: xcpt4u.c:3438
LONG Test83(VOID)
Definition: xcpt4u.c:644
DECLSPEC_NOINLINE VOID Test84(_Inout_ PLONG Counter)
Definition: xcpt4u.c:672
DWORD WINAPI GetVersion(VOID)
Definition: version.c:22
#define _clear87
Definition: float.h:135
#define RED
Definition: xcpt4u.c:66
DWORD ExceptionCode
Definition: compat.h:208
WCHAR First[]
Definition: FormatMessage.c:11
VOID PgTest72(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:217
#define FALSE
Definition: types.h:117
#define STATUS_INTEGER_OVERFLOW
Definition: ntstatus.h:385
long LONG
Definition: pedump.c:60
DECLSPEC_NOINLINE VOID Test82Foo(VOID)
Definition: xcpt4u.c:591
unsigned char BOOLEAN
VOID PgTest75(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:338
#define leave
Definition: seh.h:23
VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress)
Definition: xcpt4u.c:3406
VOID PgTest70(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:150
#define PCHAR
Definition: match.c:90
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:406
Status
Definition: gdiplustypes.h:24
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
UINT op
Definition: effect.c:236
int main(int argc, char *argv[])
Definition: xcpt4u.c:926
BOOLEAN Tkm(VOID)
VOID bar1(IN NTSTATUS Status, IN PLONG Counter)
Definition: xcpt4u.c:3266
VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter)
Definition: xcpt4u.c:3283
#define except(x)
Definition: btrfs_drv.h:139
#define __inout
Definition: dbghelp.h:50
_JBTYPE jmp_buf[_JBLEN]
Definition: setjmp.h:160
ULONG Test80(VOID)
Definition: xcpt4u.c:552
struct _EXCEPTION_RECORD * ExceptionRecord
Definition: compat.h:210
#define EXCEPTION_NESTED_CALL
Definition: rtltypes.h:158
VOID PgTest71(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:178
#define AbnormalTermination()
Definition: seh.h:28
#define EXCEPTION_CONTINUE_SEARCH
Definition: excpt.h:86
ULONG except3(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
Definition: xcpt4u.c:3372
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
unsigned int * PULONG
Definition: retypes.h:1
VOID Test88(_Inout_ PLONG Counter)
Definition: xcpt4u.c:893
VOID dojump(IN jmp_buf JumpBuffer, IN PLONG Counter)
Definition: xcpt4u.c:3300
#define NULL
Definition: types.h:112
VOID addtwo(IN LONG First, IN LONG Second, IN PLONG Place)
DWORD exp
Definition: msg.c:16033
static LARGE_INTEGER Counter
Definition: clock.c:43
void Test81(int *pCounter)
Definition: xcpt4u.c:576
#define OUT
Definition: typedefs.h:40
#define STATUS_DATATYPE_MISALIGNMENT
Definition: ntstatus.h:183
VOID eret(IN NTSTATUS Status, IN PLONG Counter)
Definition: xcpt4u.c:3318
unsigned int ULONG
Definition: retypes.h:1
DWORD ExceptionFlags
Definition: compat.h:209
#define GetExceptionCode()
Definition: seh.h:27
DWORD NumberParameters
Definition: compat.h:212
VOID PgTest69(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:122
#define BLUE
Definition: xcpt4u.c:65
signed int * PLONG
Definition: retypes.h:5
DECLSPEC_NOINLINE VOID Test86(_Inout_ PLONG Counter)
Definition: xcpt4u.c:749
VOID PgTest73(IN PLONG State, IN PLONG Fault)
Definition: xcpt4u.c:258
#define DECLSPEC_NOINLINE
Definition: ntbasedef.h:225
DECLSPEC_NOINLINE LONG Test85(_Inout_ PLONG Counter)
Definition: xcpt4u.c:699
__MINGW_NOTHROW _CRTIMP unsigned int __cdecl _controlfp(_In_ unsigned int unNew, _In_ unsigned int unMask)
#define STATUS_UNSUCCESSFUL
Definition: xcpt4u.c:58
#define LOWORD(l)
Definition: pedump.c:82
VOID Test87(_Inout_ PLONG Counter)
Definition: xcpt4u.c:790
DECLSPEC_NOINLINE ULONG PgFilter(VOID)
Definition: xcpt4u.c:111
#define log(outFile, fmt,...)
Definition: util.h:15
VOID fret(IN PLONG Counter)
Definition: xcpt4u.c:3419
double SquareDouble(IN double op)
Definition: xcpt4u.c:3461
#define abnormal_termination
Definition: seh.h:25
#define printf
Definition: config.h:203