gdb/testsuite/gdb.reverse/sigall-reverse.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2009-2013 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <signal.h>
  19 #include <unistd.h>
  20
  21
  22 /* Signal handlers, we set breakpoints in them to make sure that the
  23    signals really get delivered.  */
  24
  25 void
  26 handle_ABRT (int sig)
  27 {
  28 }
  29
  30 void
  31 handle_HUP (int sig)
  32 {
  33 }
  34
  35 void
  36 handle_QUIT (int sig)
  37 {
  38 }
  39
  40 void
  41 handle_ILL (int sig)
  42 {
  43 }
  44
  45 void
  46 handle_EMT (int sig)
  47 {
  48 }
  49
  50 void
  51 handle_FPE (int sig)
  52 {
  53 }
  54
  55 void
  56 handle_BUS (int sig)
  57 {
  58 }
  59
  60 void
  61 handle_SEGV (int sig)
  62 {
  63 }
  64
  65 void
  66 handle_SYS (int sig)
  67 {
  68 }
  69
  70 void
  71 handle_PIPE (int sig)
  72 {
  73 }
  74
  75 void
  76 handle_ALRM (int sig)
  77 {
  78 }
  79
  80 void
  81 handle_URG (int sig)
  82 {
  83 }
  84
  85 void
  86 handle_TSTP (int sig)
  87 {
  88 }
  89
  90 void
  91 handle_CONT (int sig)
  92 {
  93 }
  94
  95 void
  96 handle_CHLD (int sig)
  97 {
  98 }
  99
 100 void
 101 handle_TTIN (int sig)
 102 {
 103 }
 104
 105 void
 106 handle_TTOU (int sig)
 107 {
 108 }
 109
 110 void
 111 handle_IO (int sig)
 112 {
 113 }
 114
 115 void
 116 handle_XCPU (int sig)
 117 {
 118 }
 119
 120 void
 121 handle_XFSZ (int sig)
 122 {
 123 }
 124
 125 void
 126 handle_VTALRM (int sig)
 127 {
 128 }
 129
 130 void
 131 handle_PROF (int sig)
 132 {
 133 }
 134
 135 void
 136 handle_WINCH (int sig)
 137 {
 138 }
 139
 140 void
 141 handle_LOST (int sig)
 142 {
 143 }
 144
 145 void
 146 handle_USR1 (int sig)
 147 {
 148 }
 149
 150 void
 151 handle_USR2 (int sig)
 152 {
 153 }
 154
 155 void
 156 handle_PWR (int sig)
 157 {
 158 }
 159
 160 void
 161 handle_POLL (int sig)
 162 {
 163 }
 164
 165 void
 166 handle_WIND (int sig)
 167 {
 168 }
 169
 170 void
 171 handle_PHONE (int sig)
 172 {
 173 }
 174
 175 void
 176 handle_WAITING (int sig)
 177 {
 178 }
 179
 180 void
 181 handle_LWP (int sig)
 182 {
 183 }
 184
 185 void
 186 handle_DANGER (int sig)
 187 {
 188 }
 189
 190 void
 191 handle_GRANT (int sig)
 192 {
 193 }
 194
 195 void
 196 handle_RETRACT (int sig)
 197 {
 198 }
 199
 200 void
 201 handle_MSG (int sig)
 202 {
 203 }
 204
 205 void
 206 handle_SOUND (int sig)
 207 {
 208 }
 209
 210 void
 211 handle_SAK (int sig)
 212 {
 213 }
 214
 215 void
 216 handle_PRIO (int sig)
 217 {
 218 }
 219
 220 void
 221 handle_33 (int sig)
 222 {
 223 }
 224
 225 void
 226 handle_34 (int sig)
 227 {
 228 }
 229
 230 void
 231 handle_35 (int sig)
 232 {
 233 }
 234
 235 void
 236 handle_36 (int sig)
 237 {
 238 }
 239
 240 void
 241 handle_37 (int sig)
 242 {
 243 }
 244
 245 void
 246 handle_38 (int sig)
 247 {
 248 }
 249
 250 void
 251 handle_39 (int sig)
 252 {
 253 }
 254
 255 void
 256 handle_40 (int sig)
 257 {
 258 }
 259
 260 void
 261 handle_41 (int sig)
 262 {
 263 }
 264
 265 void
 266 handle_42 (int sig)
 267 {
 268 }
 269
 270 void
 271 handle_43 (int sig)
 272 {
 273 }
 274
 275 void
 276 handle_44 (int sig)
 277 {
 278 }
 279
 280 void
 281 handle_45 (int sig)
 282 {
 283 }
 284
 285 void
 286 handle_46 (int sig)
 287 {
 288 }
 289
 290 void
 291 handle_47 (int sig)
 292 {
 293 }
 294
 295 void
 296 handle_48 (int sig)
 297 {
 298 }
 299
 300 void
 301 handle_49 (int sig)
 302 {
 303 }
 304
 305 void
 306 handle_50 (int sig)
 307 {
 308 }
 309
 310 void
 311 handle_51 (int sig)
 312 {
 313 }
 314
 315 void
 316 handle_52 (int sig)
 317 {
 318 }
 319
 320 void
 321 handle_53 (int sig)
 322 {
 323 }
 324
 325 void
 326 handle_54 (int sig)
 327 {
 328 }
 329
 330 void
 331 handle_55 (int sig)
 332 {
 333 }
 334
 335 void
 336 handle_56 (int sig)
 337 {
 338 }
 339
 340 void
 341 handle_57 (int sig)
 342 {
 343 }
 344
 345 void
 346 handle_58 (int sig)
 347 {
 348 }
 349
 350 void
 351 handle_59 (int sig)
 352 {
 353 }
 354
 355 void
 356 handle_60 (int sig)
 357 {
 358 }
 359
 360 void
 361 handle_61 (int sig)
 362 {
 363 }
 364
 365 void
 366 handle_62 (int sig)
 367 {
 368 }
 369
 370 void
 371 handle_63 (int sig)
 372 {
 373 }
 374
 375 void
 376 handle_TERM (int sig)
 377 {
 378 }
 379 \f
 380 /* Functions to send signals.  These also serve as markers.  */
 381 int
 382 gen_ABRT (void)
 383 {
 384   kill (getpid (), SIGABRT);
 385   return 0;
 386 }
 387
 388 int
 389 gen_HUP (void)
 390 {
 391 #ifdef SIGHUP
 392   kill (getpid (), SIGHUP);
 393 #else
 394   handle_HUP (0);
 395 #endif
 396 return 0;
 397 }
 398
 399 int
 400 gen_QUIT (void)
 401 {
 402 #ifdef SIGQUIT
 403   kill (getpid (), SIGQUIT);
 404 #else
 405   handle_QUIT (0);
 406 #endif
 407 return 0;
 408 }
 409
 410 int
 411 gen_ILL (void)
 412 {
 413 #ifdef SIGILL
 414   kill (getpid (), SIGILL);
 415 #else
 416   handle_ILL (0);
 417 #endif
 418 return 0;
 419 }
 420
 421 int
 422 gen_EMT (void)
 423 {
 424 #ifdef SIGEMT
 425   kill (getpid (), SIGEMT);
 426 #else
 427   handle_EMT (0);
 428 #endif
 429 return 0;
 430 }
 431
 432 int x;
 433
 434 int
 435 gen_FPE (void)
 436 {
 437   /* The intent behind generating SIGFPE this way is to check the mapping
 438      from the CPU exception itself to the signals.  It would be nice to
 439      do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this
 440      test might turn out to be insufficiently portable.  */
 441
 442 #if 0
 443   /* Loses on the PA because after the signal handler executes we try to
 444      re-execute the failing instruction again.  Perhaps we could siglongjmp
 445      out of the signal handler?  */
 446   /* The expect script looks for the word "kill"; don't delete it.  */
 447   return 5 / x; /* and we both started jumping up and down yelling kill */
 448 #else
 449   kill (getpid (), SIGFPE);
 450 #endif
 451 return 0;
 452 }
 453
 454 int
 455 gen_BUS (void)
 456 {
 457 #ifdef SIGBUS
 458   kill (getpid (), SIGBUS);
 459 #else
 460   handle_BUS (0);
 461 #endif
 462 return 0;
 463 }
 464
 465 int
 466 gen_SEGV (void)
 467 {
 468 #ifdef SIGSEGV
 469   kill (getpid (), SIGSEGV);
 470 #else
 471   handle_SEGV (0);
 472 #endif
 473 return 0;
 474 }
 475
 476 int
 477 gen_SYS (void)
 478 {
 479 #ifdef SIGSYS
 480   kill (getpid (), SIGSYS);
 481 #else
 482   handle_SYS (0);
 483 #endif
 484 return 0;
 485 }
 486
 487 int
 488 gen_PIPE (void)
 489 {
 490 #ifdef SIGPIPE
 491   kill (getpid (), SIGPIPE);
 492 #else
 493   handle_PIPE (0);
 494 #endif
 495 return 0;
 496 }
 497
 498 int
 499 gen_ALRM (void)
 500 {
 501 #ifdef SIGALRM
 502   kill (getpid (), SIGALRM);
 503 #else
 504   handle_ALRM (0);
 505 #endif
 506 return 0;
 507 }
 508
 509 int
 510 gen_URG (void)
 511 {
 512 #ifdef SIGURG
 513   kill (getpid (), SIGURG);
 514 #else
 515   handle_URG (0);
 516 #endif
 517 return 0;
 518 }
 519
 520 int
 521 gen_TSTP (void)
 522 {
 523 #ifdef SIGTSTP
 524   kill (getpid (), SIGTSTP);
 525 #else
 526   handle_TSTP (0);
 527 #endif
 528 return 0;
 529 }
 530
 531 int
 532 gen_CONT (void)
 533 {
 534 #ifdef SIGCONT
 535   kill (getpid (), SIGCONT);
 536 #else
 537   handle_CONT (0);
 538 #endif
 539 return 0;
 540 }
 541
 542 int
 543 gen_CHLD (void)
 544 {
 545 #ifdef SIGCHLD
 546   kill (getpid (), SIGCHLD);
 547 #else
 548   handle_CHLD (0);
 549 #endif
 550 return 0;
 551 }
 552
 553 int
 554 gen_TTIN (void)
 555 {
 556 #ifdef SIGTTIN
 557   kill (getpid (), SIGTTIN);
 558 #else
 559   handle_TTIN (0);
 560 #endif
 561 return 0;
 562 }
 563
 564 int
 565 gen_TTOU (void)
 566 {
 567 #ifdef SIGTTOU
 568   kill (getpid (), SIGTTOU);
 569 #else
 570   handle_TTOU (0);
 571 #endif
 572 return 0;
 573 }
 574
 575 int
 576 gen_IO (void)
 577 {
 578 #ifdef SIGIO
 579   kill (getpid (), SIGIO);
 580 #else
 581   handle_IO (0);
 582 #endif
 583 return 0;
 584 }
 585
 586 int
 587 gen_XCPU (void)
 588 {
 589 #ifdef SIGXCPU
 590   kill (getpid (), SIGXCPU);
 591 #else
 592   handle_XCPU (0);
 593 #endif
 594 return 0;
 595 }
 596
 597 int
 598 gen_XFSZ (void)
 599 {
 600 #ifdef SIGXFSZ
 601   kill (getpid (), SIGXFSZ);
 602 #else
 603   handle_XFSZ (0);
 604 #endif
 605 return 0;
 606 }
 607
 608 int
 609 gen_VTALRM (void)
 610 {
 611 #ifdef SIGVTALRM
 612   kill (getpid (), SIGVTALRM);
 613 #else
 614   handle_VTALRM (0);
 615 #endif
 616 return 0;
 617 }
 618
 619 int
 620 gen_PROF (void)
 621 {
 622 #ifdef SIGPROF
 623   kill (getpid (), SIGPROF);
 624 #else
 625   handle_PROF (0);
 626 #endif
 627 return 0;
 628 }
 629
 630 int
 631 gen_WINCH (void)
 632 {
 633 #ifdef SIGWINCH
 634   kill (getpid (), SIGWINCH);
 635 #else
 636   handle_WINCH (0);
 637 #endif
 638 return 0;
 639 }
 640
 641 int
 642 gen_LOST (void)
 643 {
 644 #if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT)
 645   kill (getpid (), SIGLOST);
 646 #else
 647   handle_LOST (0);
 648 #endif
 649 return 0;
 650 }
 651
 652 int
 653 gen_USR1 (void)
 654 {
 655 #ifdef SIGUSR1
 656   kill (getpid (), SIGUSR1);
 657 #else
 658   handle_USR1 (0);
 659 #endif
 660 return 0;
 661 }
 662
 663 int
 664 gen_USR2 (void)
 665 {
 666 #ifdef SIGUSR2
 667   kill (getpid (), SIGUSR2);
 668 #else
 669   handle_USR2 (0);
 670 #endif
 671 return 0;
 672 }
 673
 674 int
 675 gen_PWR (void)
 676 {
 677 #ifdef SIGPWR
 678   kill (getpid (), SIGPWR);
 679 #else
 680   handle_PWR (0);
 681 #endif
 682 return 0;
 683 }
 684
 685 int
 686 gen_POLL (void)
 687 {
 688 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
 689   kill (getpid (), SIGPOLL);
 690 #else
 691   handle_POLL (0);
 692 #endif
 693 return 0;
 694 }
 695
 696 int
 697 gen_WIND (void)
 698 {
 699 #ifdef SIGWIND
 700   kill (getpid (), SIGWIND);
 701 #else
 702   handle_WIND (0);
 703 #endif
 704 return 0;
 705 }
 706
 707 int
 708 gen_PHONE (void)
 709 {
 710 #ifdef SIGPHONE
 711   kill (getpid (), SIGPHONE);
 712 #else
 713   handle_PHONE (0);
 714 #endif
 715 return 0;
 716 }
 717
 718 int
 719 gen_WAITING (void)
 720 {
 721 #ifdef SIGWAITING
 722   kill (getpid (), SIGWAITING);
 723 #else
 724   handle_WAITING (0);
 725 #endif
 726 return 0;
 727 }
 728
 729 int
 730 gen_LWP (void)
 731 {
 732 #ifdef SIGLWP
 733   kill (getpid (), SIGLWP);
 734 #else
 735   handle_LWP (0);
 736 #endif
 737 return 0;
 738 }
 739
 740 int
 741 gen_DANGER (void)
 742 {
 743 #ifdef SIGDANGER
 744   kill (getpid (), SIGDANGER);
 745 #else
 746   handle_DANGER (0);
 747 #endif
 748 return 0;
 749 }
 750
 751 int
 752 gen_GRANT (void)
 753 {
 754 #ifdef SIGGRANT
 755   kill (getpid (), SIGGRANT);
 756 #else
 757   handle_GRANT (0);
 758 #endif
 759 return 0;
 760 }
 761
 762 int
 763 gen_RETRACT (void)
 764 {
 765 #ifdef SIGRETRACT
 766   kill (getpid (), SIGRETRACT);
 767 #else
 768   handle_RETRACT (0);
 769 #endif
 770 return 0;
 771 }
 772
 773 int
 774 gen_MSG (void)
 775 {
 776 #ifdef SIGMSG
 777   kill (getpid (), SIGMSG);
 778 #else
 779   handle_MSG (0);
 780 #endif
 781 return 0;
 782 }
 783
 784 int
 785 gen_SOUND (void)
 786 {
 787 #ifdef SIGSOUND
 788   kill (getpid (), SIGSOUND);
 789 #else
 790   handle_SOUND (0);
 791 #endif
 792 return 0;
 793 }
 794
 795 int
 796 gen_SAK (void)
 797 {
 798 #ifdef SIGSAK
 799   kill (getpid (), SIGSAK);
 800 #else
 801   handle_SAK (0);
 802 #endif
 803 return 0;
 804 }
 805
 806 int
 807 gen_PRIO (void)
 808 {
 809 #ifdef SIGPRIO
 810   kill (getpid (), SIGPRIO);
 811 #else
 812   handle_PRIO (0);
 813 #endif
 814 return 0;
 815 }
 816
 817 int
 818 gen_33 (void)
 819 {
 820 #ifdef SIG33
 821   kill (getpid (), 33);
 822 #else
 823   handle_33 (0);
 824 #endif
 825 return 0;
 826 }
 827
 828 int
 829 gen_34 (void)
 830 {
 831 #ifdef SIG34
 832   kill (getpid (), 34);
 833 #else
 834   handle_34 (0);
 835 #endif
 836 return 0;
 837 }
 838
 839 int
 840 gen_35 (void)
 841 {
 842 #ifdef SIG35
 843   kill (getpid (), 35);
 844 #else
 845   handle_35 (0);
 846 #endif
 847 return 0;
 848 }
 849
 850 int
 851 gen_36 (void)
 852 {
 853 #ifdef SIG36
 854   kill (getpid (), 36);
 855 #else
 856   handle_36 (0);
 857 #endif
 858 return 0;
 859 }
 860
 861 int
 862 gen_37 (void)
 863 {
 864 #ifdef SIG37
 865   kill (getpid (), 37);
 866 #else
 867   handle_37 (0);
 868 #endif
 869 return 0;
 870 }
 871
 872 int
 873 gen_38 (void)
 874 {
 875 #ifdef SIG38
 876   kill (getpid (), 38);
 877 #else
 878   handle_38 (0);
 879 #endif
 880 return 0;
 881 }
 882
 883 int
 884 gen_39 (void)
 885 {
 886 #ifdef SIG39
 887   kill (getpid (), 39);
 888 #else
 889   handle_39 (0);
 890 #endif
 891 return 0;
 892 }
 893
 894 int
 895 gen_40 (void)
 896 {
 897 #ifdef SIG40
 898   kill (getpid (), 40);
 899 #else
 900   handle_40 (0);
 901 #endif
 902 return 0;
 903 }
 904
 905 int
 906 gen_41 (void)
 907 {
 908 #ifdef SIG41
 909   kill (getpid (), 41);
 910 #else
 911   handle_41 (0);
 912 #endif
 913 return 0;
 914 }
 915
 916 int
 917 gen_42 (void)
 918 {
 919 #ifdef SIG42
 920   kill (getpid (), 42);
 921 #else
 922   handle_42 (0);
 923 #endif
 924 return 0;
 925 }
 926
 927 int
 928 gen_43 (void)
 929 {
 930 #ifdef SIG43
 931   kill (getpid (), 43);
 932 #else
 933   handle_43 (0);
 934 #endif
 935 return 0;
 936 }
 937
 938 int
 939 gen_44 (void)
 940 {
 941 #ifdef SIG44
 942   kill (getpid (), 44);
 943 #else
 944   handle_44 (0);
 945 #endif
 946 return 0;
 947 }
 948
 949 int
 950 gen_45 (void)
 951 {
 952 #ifdef SIG45
 953   kill (getpid (), 45);
 954 #else
 955   handle_45 (0);
 956 #endif
 957 return 0;
 958 }
 959
 960 int
 961 gen_46 (void)
 962 {
 963 #ifdef SIG46
 964   kill (getpid (), 46);
 965 #else
 966   handle_46 (0);
 967 #endif
 968 return 0;
 969 }
 970
 971 int
 972 gen_47 (void)
 973 {
 974 #ifdef SIG47
 975   kill (getpid (), 47);
 976 #else
 977   handle_47 (0);
 978 #endif
 979 return 0;
 980 }
 981
 982 int
 983 gen_48 (void)
 984 {
 985 #ifdef SIG48
 986   kill (getpid (), 48);
 987 #else
 988   handle_48 (0);
 989 #endif
 990 return 0;
 991 }
 992
 993 int
 994 gen_49 (void)
 995 {
 996 #ifdef SIG49
 997   kill (getpid (), 49);
 998 #else
 999   handle_49 (0);
1000 #endif
1001 return 0;
1002 }
1003
1004 int
1005 gen_50 (void)
1006 {
1007 #ifdef SIG50
1008   kill (getpid (), 50);
1009 #else
1010   handle_50 (0);
1011 #endif
1012 return 0;
1013 }
1014
1015 int
1016 gen_51 (void)
1017 {
1018 #ifdef SIG51
1019   kill (getpid (), 51);
1020 #else
1021   handle_51 (0);
1022 #endif
1023 return 0;
1024 }
1025
1026 int
1027 gen_52 (void)
1028 {
1029 #ifdef SIG52
1030   kill (getpid (), 52);
1031 #else
1032   handle_52 (0);
1033 #endif
1034 return 0;
1035 }
1036
1037 int
1038 gen_53 (void)
1039 {
1040 #ifdef SIG53
1041   kill (getpid (), 53);
1042 #else
1043   handle_53 (0);
1044 #endif
1045 return 0;
1046 }
1047
1048 int
1049 gen_54 (void)
1050 {
1051 #ifdef SIG54
1052   kill (getpid (), 54);
1053 #else
1054   handle_54 (0);
1055 #endif
1056 return 0;
1057 }
1058
1059 int
1060 gen_55 (void)
1061 {
1062 #ifdef SIG55
1063   kill (getpid (), 55);
1064 #else
1065   handle_55 (0);
1066 #endif
1067 return 0;
1068 }
1069
1070 int
1071 gen_56 (void)
1072 {
1073 #ifdef SIG56
1074   kill (getpid (), 56);
1075 #else
1076   handle_56 (0);
1077 #endif
1078 return 0;
1079 }
1080
1081 int
1082 gen_57 (void)
1083 {
1084 #ifdef SIG57
1085   kill (getpid (), 57);
1086 #else
1087   handle_57 (0);
1088 #endif
1089 return 0;
1090 }
1091
1092 int
1093 gen_58 (void)
1094 {
1095 #ifdef SIG58
1096   kill (getpid (), 58);
1097 #else
1098   handle_58 (0);
1099 #endif
1100 return 0;
1101 }
1102
1103 int
1104 gen_59 (void)
1105 {
1106 #ifdef SIG59
1107   kill (getpid (), 59);
1108 #else
1109   handle_59 (0);
1110 #endif
1111 return 0;
1112 }
1113
1114 int
1115 gen_60 (void)
1116 {
1117 #ifdef SIG60
1118   kill (getpid (), 60);
1119 #else
1120   handle_60 (0);
1121 #endif
1122 return 0;
1123 }
1124
1125 int
1126 gen_61 (void)
1127 {
1128 #ifdef SIG61
1129   kill (getpid (), 61);
1130 #else
1131   handle_61 (0);
1132 #endif
1133 return 0;
1134 }
1135
1136 int
1137 gen_62 (void)
1138 {
1139 #ifdef SIG62
1140   kill (getpid (), 62);
1141 #else
1142   handle_62 (0);
1143 #endif
1144 return 0;
1145 }
1146
1147 int
1148 gen_63 (void)
1149 {
1150 #ifdef SIG63
1151   kill (getpid (), 63);
1152 #else
1153   handle_63 (0);
1154 #endif
1155 return 0;
1156 }
1157
1158 int
1159 gen_TERM (void)
1160 {
1161   kill (getpid (), SIGTERM);
1162 return 0;
1163 }
1164 \f
1165 int
1166 main ()
1167 {
1168 #ifdef SIG_SETMASK
1169   /* Ensure all the signals aren't blocked.
1170      The environment in which the testsuite is run may have blocked some
1171      for whatever reason.  */
1172   {
1173     sigset_t newset;
1174     sigemptyset (&newset);
1175     sigprocmask (SIG_SETMASK, &newset, NULL);
1176   }
1177 #endif
1178
1179   signal (SIGABRT, handle_ABRT);
1180 #ifdef SIGHUP
1181   signal (SIGHUP, handle_HUP);
1182 #endif
1183 #ifdef SIGQUIT
1184   signal (SIGQUIT, handle_QUIT);
1185 #endif
1186 #ifdef SIGILL
1187   signal (SIGILL, handle_ILL);
1188 #endif
1189 #ifdef SIGEMT
1190   signal (SIGEMT, handle_EMT);
1191 #endif
1192 #ifdef SIGFPE
1193   signal (SIGFPE, handle_FPE);
1194 #endif
1195 #ifdef SIGBUS
1196   signal (SIGBUS, handle_BUS);
1197 #endif
1198 #ifdef SIGSEGV
1199   signal (SIGSEGV, handle_SEGV);
1200 #endif
1201 #ifdef SIGSYS
1202   signal (SIGSYS, handle_SYS);
1203 #endif
1204 #ifdef SIGPIPE
1205   signal (SIGPIPE, handle_PIPE);
1206 #endif
1207 #ifdef SIGALRM
1208   signal (SIGALRM, handle_ALRM);
1209 #endif
1210 #ifdef SIGURG
1211   signal (SIGURG, handle_URG);
1212 #endif
1213 #ifdef SIGTSTP
1214   signal (SIGTSTP, handle_TSTP);
1215 #endif
1216 #ifdef SIGCONT
1217   signal (SIGCONT, handle_CONT);
1218 #endif
1219 #ifdef SIGCHLD
1220   signal (SIGCHLD, handle_CHLD);
1221 #endif
1222 #ifdef SIGTTIN
1223   signal (SIGTTIN, handle_TTIN);
1224 #endif
1225 #ifdef SIGTTOU
1226   signal (SIGTTOU, handle_TTOU);
1227 #endif
1228 #ifdef SIGIO
1229   signal (SIGIO, handle_IO);
1230 #endif
1231 #ifdef SIGXCPU
1232   signal (SIGXCPU, handle_XCPU);
1233 #endif
1234 #ifdef SIGXFSZ
1235   signal (SIGXFSZ, handle_XFSZ);
1236 #endif
1237 #ifdef SIGVTALRM
1238   signal (SIGVTALRM, handle_VTALRM);
1239 #endif
1240 #ifdef SIGPROF
1241   signal (SIGPROF, handle_PROF);
1242 #endif
1243 #ifdef SIGWINCH
1244   signal (SIGWINCH, handle_WINCH);
1245 #endif
1246 #if defined(SIGLOST) && (!defined(SIGABRT) || SIGLOST != SIGABRT)
1247   signal (SIGLOST, handle_LOST);
1248 #endif
1249 #ifdef SIGUSR1
1250   signal (SIGUSR1, handle_USR1);
1251 #endif
1252 #ifdef SIGUSR2
1253   signal (SIGUSR2, handle_USR2);
1254 #endif
1255 #ifdef SIGPWR
1256   signal (SIGPWR, handle_PWR);
1257 #endif
1258 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
1259   signal (SIGPOLL, handle_POLL);
1260 #endif
1261 #ifdef SIGWIND
1262   signal (SIGWIND, handle_WIND);
1263 #endif
1264 #ifdef SIGPHONE
1265   signal (SIGPHONE, handle_PHONE);
1266 #endif
1267 #ifdef SIGWAITING
1268   signal (SIGWAITING, handle_WAITING);
1269 #endif
1270 #ifdef SIGLWP
1271   signal (SIGLWP, handle_LWP);
1272 #endif
1273 #ifdef SIGDANGER
1274   signal (SIGDANGER, handle_DANGER);
1275 #endif
1276 #ifdef SIGGRANT
1277   signal (SIGGRANT, handle_GRANT);
1278 #endif
1279 #ifdef SIGRETRACT
1280   signal (SIGRETRACT, handle_RETRACT);
1281 #endif
1282 #ifdef SIGMSG
1283   signal (SIGMSG, handle_MSG);
1284 #endif
1285 #ifdef SIGSOUND
1286   signal (SIGSOUND, handle_SOUND);
1287 #endif
1288 #ifdef SIGSAK
1289   signal (SIGSAK, handle_SAK);
1290 #endif
1291 #ifdef SIGPRIO
1292   signal (SIGPRIO, handle_PRIO);
1293 #endif
1294 #ifdef __Lynx__
1295   /* Lynx doesn't seem to have anything in signal.h for this.  */
1296   signal (33, handle_33);
1297   signal (34, handle_34);
1298   signal (35, handle_35);
1299   signal (36, handle_36);
1300   signal (37, handle_37);
1301   signal (38, handle_38);
1302   signal (39, handle_39);
1303   signal (40, handle_40);
1304   signal (41, handle_41);
1305   signal (42, handle_42);
1306   signal (43, handle_43);
1307   signal (44, handle_44);
1308   signal (45, handle_45);
1309   signal (46, handle_46);
1310   signal (47, handle_47);
1311   signal (48, handle_48);
1312   signal (49, handle_49);
1313   signal (50, handle_50);
1314   signal (51, handle_51);
1315   signal (52, handle_52);
1316   signal (53, handle_53);
1317   signal (54, handle_54);
1318   signal (55, handle_55);
1319   signal (56, handle_56);
1320   signal (57, handle_57);
1321   signal (58, handle_58);
1322   signal (59, handle_59);
1323   signal (60, handle_60);
1324   signal (61, handle_61);
1325   signal (62, handle_62);
1326   signal (63, handle_63);
1327 #endif /* lynx */
1328   signal (SIGTERM, handle_TERM);
1329
1330   x = 0;
1331
1332   gen_ABRT ();
1333   gen_HUP ();
1334   gen_QUIT ();
1335   gen_ILL ();
1336   gen_EMT ();
1337   gen_FPE ();
1338   gen_BUS ();
1339   gen_SEGV ();
1340   gen_SYS ();
1341   gen_PIPE ();
1342   gen_ALRM ();
1343   gen_URG ();
1344   gen_TSTP ();
1345   gen_CONT ();
1346   gen_CHLD ();
1347   gen_TTIN ();
1348   gen_TTOU ();
1349   gen_IO ();
1350   gen_XCPU ();
1351   gen_XFSZ ();
1352   gen_VTALRM ();
1353   gen_PROF ();
1354   gen_WINCH ();
1355   gen_LOST ();
1356   gen_USR1 ();
1357   gen_USR2 ();
1358   gen_PWR ();
1359   gen_POLL ();
1360   gen_WIND ();
1361   gen_PHONE ();
1362   gen_WAITING ();
1363   gen_LWP ();
1364   gen_DANGER ();
1365   gen_GRANT ();
1366   gen_RETRACT ();
1367   gen_MSG ();
1368   gen_SOUND ();
1369   gen_SAK ();
1370   gen_PRIO ();
1371   gen_33 ();
1372   gen_34 ();
1373   gen_35 ();
1374   gen_36 ();
1375   gen_37 ();
1376   gen_38 ();
1377   gen_39 ();
1378   gen_40 ();
1379   gen_41 ();
1380   gen_42 ();
1381   gen_43 ();
1382   gen_44 ();
1383   gen_45 ();
1384   gen_46 ();
1385   gen_47 ();
1386   gen_48 ();
1387   gen_49 ();
1388   gen_50 ();
1389   gen_51 ();
1390   gen_52 ();
1391   gen_53 ();
1392   gen_54 ();
1393   gen_55 ();
1394   gen_56 ();
1395   gen_57 ();
1396   gen_58 ();
1397   gen_59 ();
1398   gen_60 ();
1399   gen_61 ();
1400   gen_62 ();
1401   gen_63 ();
1402   gen_TERM ();
1403
1404   return 0;     /* end of main */
1405 }