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

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2009-2014 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   kill (getpid (), SIGILL);
 414 return 0;
 415 }
 416
 417 int
 418 gen_EMT (void)
 419 {
 420 #ifdef SIGEMT
 421   kill (getpid (), SIGEMT);
 422 #else
 423   handle_EMT (0);
 424 #endif
 425 return 0;
 426 }
 427
 428 int x;
 429
 430 int
 431 gen_FPE (void)
 432 {
 433   /* The intent behind generating SIGFPE this way is to check the mapping
 434      from the CPU exception itself to the signals.  It would be nice to
 435      do the same for SIGBUS, SIGSEGV, etc., but I suspect that even this
 436      test might turn out to be insufficiently portable.  */
 437
 438 #if 0
 439   /* Loses on the PA because after the signal handler executes we try to
 440      re-execute the failing instruction again.  Perhaps we could siglongjmp
 441      out of the signal handler?  */
 442   /* The expect script looks for the word "kill"; don't delete it.  */
 443   return 5 / x; /* and we both started jumping up and down yelling kill */
 444 #else
 445   kill (getpid (), SIGFPE);
 446 #endif
 447 return 0;
 448 }
 449
 450 int
 451 gen_BUS (void)
 452 {
 453 #ifdef SIGBUS
 454   kill (getpid (), SIGBUS);
 455 #else
 456   handle_BUS (0);
 457 #endif
 458 return 0;
 459 }
 460
 461 int
 462 gen_SEGV (void)
 463 {
 464   kill (getpid (), SIGSEGV);
 465 return 0;
 466 }
 467
 468 int
 469 gen_SYS (void)
 470 {
 471 #ifdef SIGSYS
 472   kill (getpid (), SIGSYS);
 473 #else
 474   handle_SYS (0);
 475 #endif
 476 return 0;
 477 }
 478
 479 int
 480 gen_PIPE (void)
 481 {
 482 #ifdef SIGPIPE
 483   kill (getpid (), SIGPIPE);
 484 #else
 485   handle_PIPE (0);
 486 #endif
 487 return 0;
 488 }
 489
 490 int
 491 gen_ALRM (void)
 492 {
 493 #ifdef SIGALRM
 494   kill (getpid (), SIGALRM);
 495 #else
 496   handle_ALRM (0);
 497 #endif
 498 return 0;
 499 }
 500
 501 int
 502 gen_URG (void)
 503 {
 504 #ifdef SIGURG
 505   kill (getpid (), SIGURG);
 506 #else
 507   handle_URG (0);
 508 #endif
 509 return 0;
 510 }
 511
 512 int
 513 gen_TSTP (void)
 514 {
 515 #ifdef SIGTSTP
 516   kill (getpid (), SIGTSTP);
 517 #else
 518   handle_TSTP (0);
 519 #endif
 520 return 0;
 521 }
 522
 523 int
 524 gen_CONT (void)
 525 {
 526 #ifdef SIGCONT
 527   kill (getpid (), SIGCONT);
 528 #else
 529   handle_CONT (0);
 530 #endif
 531 return 0;
 532 }
 533
 534 int
 535 gen_CHLD (void)
 536 {
 537 #ifdef SIGCHLD
 538   kill (getpid (), SIGCHLD);
 539 #else
 540   handle_CHLD (0);
 541 #endif
 542 return 0;
 543 }
 544
 545 int
 546 gen_TTIN (void)
 547 {
 548 #ifdef SIGTTIN
 549   kill (getpid (), SIGTTIN);
 550 #else
 551   handle_TTIN (0);
 552 #endif
 553 return 0;
 554 }
 555
 556 int
 557 gen_TTOU (void)
 558 {
 559 #ifdef SIGTTOU
 560   kill (getpid (), SIGTTOU);
 561 #else
 562   handle_TTOU (0);
 563 #endif
 564 return 0;
 565 }
 566
 567 int
 568 gen_IO (void)
 569 {
 570 #ifdef SIGIO
 571   kill (getpid (), SIGIO);
 572 #else
 573   handle_IO (0);
 574 #endif
 575 return 0;
 576 }
 577
 578 int
 579 gen_XCPU (void)
 580 {
 581 #ifdef SIGXCPU
 582   kill (getpid (), SIGXCPU);
 583 #else
 584   handle_XCPU (0);
 585 #endif
 586 return 0;
 587 }
 588
 589 int
 590 gen_XFSZ (void)
 591 {
 592 #ifdef SIGXFSZ
 593   kill (getpid (), SIGXFSZ);
 594 #else
 595   handle_XFSZ (0);
 596 #endif
 597 return 0;
 598 }
 599
 600 int
 601 gen_VTALRM (void)
 602 {
 603 #ifdef SIGVTALRM
 604   kill (getpid (), SIGVTALRM);
 605 #else
 606   handle_VTALRM (0);
 607 #endif
 608 return 0;
 609 }
 610
 611 int
 612 gen_PROF (void)
 613 {
 614 #ifdef SIGPROF
 615   kill (getpid (), SIGPROF);
 616 #else
 617   handle_PROF (0);
 618 #endif
 619 return 0;
 620 }
 621
 622 int
 623 gen_WINCH (void)
 624 {
 625 #ifdef SIGWINCH
 626   kill (getpid (), SIGWINCH);
 627 #else
 628   handle_WINCH (0);
 629 #endif
 630 return 0;
 631 }
 632
 633 int
 634 gen_LOST (void)
 635 {
 636 #if defined(SIGLOST) && SIGLOST != SIGABRT
 637   kill (getpid (), SIGLOST);
 638 #else
 639   handle_LOST (0);
 640 #endif
 641 return 0;
 642 }
 643
 644 int
 645 gen_USR1 (void)
 646 {
 647 #ifdef SIGUSR1
 648   kill (getpid (), SIGUSR1);
 649 #else
 650   handle_USR1 (0);
 651 #endif
 652 return 0;
 653 }
 654
 655 int
 656 gen_USR2 (void)
 657 {
 658 #ifdef SIGUSR2
 659   kill (getpid (), SIGUSR2);
 660 #else
 661   handle_USR2 (0);
 662 #endif
 663 return 0;
 664 }
 665
 666 int
 667 gen_PWR (void)
 668 {
 669 #ifdef SIGPWR
 670   kill (getpid (), SIGPWR);
 671 #else
 672   handle_PWR (0);
 673 #endif
 674 return 0;
 675 }
 676
 677 int
 678 gen_POLL (void)
 679 {
 680 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
 681   kill (getpid (), SIGPOLL);
 682 #else
 683   handle_POLL (0);
 684 #endif
 685 return 0;
 686 }
 687
 688 int
 689 gen_WIND (void)
 690 {
 691 #ifdef SIGWIND
 692   kill (getpid (), SIGWIND);
 693 #else
 694   handle_WIND (0);
 695 #endif
 696 return 0;
 697 }
 698
 699 int
 700 gen_PHONE (void)
 701 {
 702 #ifdef SIGPHONE
 703   kill (getpid (), SIGPHONE);
 704 #else
 705   handle_PHONE (0);
 706 #endif
 707 return 0;
 708 }
 709
 710 int
 711 gen_WAITING (void)
 712 {
 713 #ifdef SIGWAITING
 714   kill (getpid (), SIGWAITING);
 715 #else
 716   handle_WAITING (0);
 717 #endif
 718 return 0;
 719 }
 720
 721 int
 722 gen_LWP (void)
 723 {
 724 #ifdef SIGLWP
 725   kill (getpid (), SIGLWP);
 726 #else
 727   handle_LWP (0);
 728 #endif
 729 return 0;
 730 }
 731
 732 int
 733 gen_DANGER (void)
 734 {
 735 #ifdef SIGDANGER
 736   kill (getpid (), SIGDANGER);
 737 #else
 738   handle_DANGER (0);
 739 #endif
 740 return 0;
 741 }
 742
 743 int
 744 gen_GRANT (void)
 745 {
 746 #ifdef SIGGRANT
 747   kill (getpid (), SIGGRANT);
 748 #else
 749   handle_GRANT (0);
 750 #endif
 751 return 0;
 752 }
 753
 754 int
 755 gen_RETRACT (void)
 756 {
 757 #ifdef SIGRETRACT
 758   kill (getpid (), SIGRETRACT);
 759 #else
 760   handle_RETRACT (0);
 761 #endif
 762 return 0;
 763 }
 764
 765 int
 766 gen_MSG (void)
 767 {
 768 #ifdef SIGMSG
 769   kill (getpid (), SIGMSG);
 770 #else
 771   handle_MSG (0);
 772 #endif
 773 return 0;
 774 }
 775
 776 int
 777 gen_SOUND (void)
 778 {
 779 #ifdef SIGSOUND
 780   kill (getpid (), SIGSOUND);
 781 #else
 782   handle_SOUND (0);
 783 #endif
 784 return 0;
 785 }
 786
 787 int
 788 gen_SAK (void)
 789 {
 790 #ifdef SIGSAK
 791   kill (getpid (), SIGSAK);
 792 #else
 793   handle_SAK (0);
 794 #endif
 795 return 0;
 796 }
 797
 798 int
 799 gen_PRIO (void)
 800 {
 801 #ifdef SIGPRIO
 802   kill (getpid (), SIGPRIO);
 803 #else
 804   handle_PRIO (0);
 805 #endif
 806 return 0;
 807 }
 808
 809 int
 810 gen_33 (void)
 811 {
 812 #ifdef SIG33
 813   kill (getpid (), 33);
 814 #else
 815   handle_33 (0);
 816 #endif
 817 return 0;
 818 }
 819
 820 int
 821 gen_34 (void)
 822 {
 823 #ifdef SIG34
 824   kill (getpid (), 34);
 825 #else
 826   handle_34 (0);
 827 #endif
 828 return 0;
 829 }
 830
 831 int
 832 gen_35 (void)
 833 {
 834 #ifdef SIG35
 835   kill (getpid (), 35);
 836 #else
 837   handle_35 (0);
 838 #endif
 839 return 0;
 840 }
 841
 842 int
 843 gen_36 (void)
 844 {
 845 #ifdef SIG36
 846   kill (getpid (), 36);
 847 #else
 848   handle_36 (0);
 849 #endif
 850 return 0;
 851 }
 852
 853 int
 854 gen_37 (void)
 855 {
 856 #ifdef SIG37
 857   kill (getpid (), 37);
 858 #else
 859   handle_37 (0);
 860 #endif
 861 return 0;
 862 }
 863
 864 int
 865 gen_38 (void)
 866 {
 867 #ifdef SIG38
 868   kill (getpid (), 38);
 869 #else
 870   handle_38 (0);
 871 #endif
 872 return 0;
 873 }
 874
 875 int
 876 gen_39 (void)
 877 {
 878 #ifdef SIG39
 879   kill (getpid (), 39);
 880 #else
 881   handle_39 (0);
 882 #endif
 883 return 0;
 884 }
 885
 886 int
 887 gen_40 (void)
 888 {
 889 #ifdef SIG40
 890   kill (getpid (), 40);
 891 #else
 892   handle_40 (0);
 893 #endif
 894 return 0;
 895 }
 896
 897 int
 898 gen_41 (void)
 899 {
 900 #ifdef SIG41
 901   kill (getpid (), 41);
 902 #else
 903   handle_41 (0);
 904 #endif
 905 return 0;
 906 }
 907
 908 int
 909 gen_42 (void)
 910 {
 911 #ifdef SIG42
 912   kill (getpid (), 42);
 913 #else
 914   handle_42 (0);
 915 #endif
 916 return 0;
 917 }
 918
 919 int
 920 gen_43 (void)
 921 {
 922 #ifdef SIG43
 923   kill (getpid (), 43);
 924 #else
 925   handle_43 (0);
 926 #endif
 927 return 0;
 928 }
 929
 930 int
 931 gen_44 (void)
 932 {
 933 #ifdef SIG44
 934   kill (getpid (), 44);
 935 #else
 936   handle_44 (0);
 937 #endif
 938 return 0;
 939 }
 940
 941 int
 942 gen_45 (void)
 943 {
 944 #ifdef SIG45
 945   kill (getpid (), 45);
 946 #else
 947   handle_45 (0);
 948 #endif
 949 return 0;
 950 }
 951
 952 int
 953 gen_46 (void)
 954 {
 955 #ifdef SIG46
 956   kill (getpid (), 46);
 957 #else
 958   handle_46 (0);
 959 #endif
 960 return 0;
 961 }
 962
 963 int
 964 gen_47 (void)
 965 {
 966 #ifdef SIG47
 967   kill (getpid (), 47);
 968 #else
 969   handle_47 (0);
 970 #endif
 971 return 0;
 972 }
 973
 974 int
 975 gen_48 (void)
 976 {
 977 #ifdef SIG48
 978   kill (getpid (), 48);
 979 #else
 980   handle_48 (0);
 981 #endif
 982 return 0;
 983 }
 984
 985 int
 986 gen_49 (void)
 987 {
 988 #ifdef SIG49
 989   kill (getpid (), 49);
 990 #else
 991   handle_49 (0);
 992 #endif
 993 return 0;
 994 }
 995
 996 int
 997 gen_50 (void)
 998 {
 999 #ifdef SIG50
1000   kill (getpid (), 50);
1001 #else
1002   handle_50 (0);
1003 #endif
1004 return 0;
1005 }
1006
1007 int
1008 gen_51 (void)
1009 {
1010 #ifdef SIG51
1011   kill (getpid (), 51);
1012 #else
1013   handle_51 (0);
1014 #endif
1015 return 0;
1016 }
1017
1018 int
1019 gen_52 (void)
1020 {
1021 #ifdef SIG52
1022   kill (getpid (), 52);
1023 #else
1024   handle_52 (0);
1025 #endif
1026 return 0;
1027 }
1028
1029 int
1030 gen_53 (void)
1031 {
1032 #ifdef SIG53
1033   kill (getpid (), 53);
1034 #else
1035   handle_53 (0);
1036 #endif
1037 return 0;
1038 }
1039
1040 int
1041 gen_54 (void)
1042 {
1043 #ifdef SIG54
1044   kill (getpid (), 54);
1045 #else
1046   handle_54 (0);
1047 #endif
1048 return 0;
1049 }
1050
1051 int
1052 gen_55 (void)
1053 {
1054 #ifdef SIG55
1055   kill (getpid (), 55);
1056 #else
1057   handle_55 (0);
1058 #endif
1059 return 0;
1060 }
1061
1062 int
1063 gen_56 (void)
1064 {
1065 #ifdef SIG56
1066   kill (getpid (), 56);
1067 #else
1068   handle_56 (0);
1069 #endif
1070 return 0;
1071 }
1072
1073 int
1074 gen_57 (void)
1075 {
1076 #ifdef SIG57
1077   kill (getpid (), 57);
1078 #else
1079   handle_57 (0);
1080 #endif
1081 return 0;
1082 }
1083
1084 int
1085 gen_58 (void)
1086 {
1087 #ifdef SIG58
1088   kill (getpid (), 58);
1089 #else
1090   handle_58 (0);
1091 #endif
1092 return 0;
1093 }
1094
1095 int
1096 gen_59 (void)
1097 {
1098 #ifdef SIG59
1099   kill (getpid (), 59);
1100 #else
1101   handle_59 (0);
1102 #endif
1103 return 0;
1104 }
1105
1106 int
1107 gen_60 (void)
1108 {
1109 #ifdef SIG60
1110   kill (getpid (), 60);
1111 #else
1112   handle_60 (0);
1113 #endif
1114 return 0;
1115 }
1116
1117 int
1118 gen_61 (void)
1119 {
1120 #ifdef SIG61
1121   kill (getpid (), 61);
1122 #else
1123   handle_61 (0);
1124 #endif
1125 return 0;
1126 }
1127
1128 int
1129 gen_62 (void)
1130 {
1131 #ifdef SIG62
1132   kill (getpid (), 62);
1133 #else
1134   handle_62 (0);
1135 #endif
1136 return 0;
1137 }
1138
1139 int
1140 gen_63 (void)
1141 {
1142 #ifdef SIG63
1143   kill (getpid (), 63);
1144 #else
1145   handle_63 (0);
1146 #endif
1147 return 0;
1148 }
1149
1150 int
1151 gen_TERM (void)
1152 {
1153   kill (getpid (), SIGTERM);
1154 return 0;
1155 }
1156 \f
1157 int
1158 main ()
1159 {
1160 #ifdef SIG_SETMASK
1161   /* Ensure all the signals aren't blocked.
1162      The environment in which the testsuite is run may have blocked some
1163      for whatever reason.  */
1164   {
1165     sigset_t newset;
1166     sigemptyset (&newset);
1167     sigprocmask (SIG_SETMASK, &newset, NULL);
1168   }
1169 #endif
1170
1171   signal (SIGABRT, handle_ABRT);
1172 #ifdef SIGHUP
1173   signal (SIGHUP, handle_HUP);
1174 #endif
1175 #ifdef SIGQUIT
1176   signal (SIGQUIT, handle_QUIT);
1177 #endif
1178   signal (SIGILL, handle_ILL);
1179 #ifdef SIGEMT
1180   signal (SIGEMT, handle_EMT);
1181 #endif
1182   signal (SIGFPE, handle_FPE);
1183 #ifdef SIGBUS
1184   signal (SIGBUS, handle_BUS);
1185 #endif
1186   signal (SIGSEGV, handle_SEGV);
1187 #ifdef SIGSYS
1188   signal (SIGSYS, handle_SYS);
1189 #endif
1190 #ifdef SIGPIPE
1191   signal (SIGPIPE, handle_PIPE);
1192 #endif
1193 #ifdef SIGALRM
1194   signal (SIGALRM, handle_ALRM);
1195 #endif
1196 #ifdef SIGURG
1197   signal (SIGURG, handle_URG);
1198 #endif
1199 #ifdef SIGTSTP
1200   signal (SIGTSTP, handle_TSTP);
1201 #endif
1202 #ifdef SIGCONT
1203   signal (SIGCONT, handle_CONT);
1204 #endif
1205 #ifdef SIGCHLD
1206   signal (SIGCHLD, handle_CHLD);
1207 #endif
1208 #ifdef SIGTTIN
1209   signal (SIGTTIN, handle_TTIN);
1210 #endif
1211 #ifdef SIGTTOU
1212   signal (SIGTTOU, handle_TTOU);
1213 #endif
1214 #ifdef SIGIO
1215   signal (SIGIO, handle_IO);
1216 #endif
1217 #ifdef SIGXCPU
1218   signal (SIGXCPU, handle_XCPU);
1219 #endif
1220 #ifdef SIGXFSZ
1221   signal (SIGXFSZ, handle_XFSZ);
1222 #endif
1223 #ifdef SIGVTALRM
1224   signal (SIGVTALRM, handle_VTALRM);
1225 #endif
1226 #ifdef SIGPROF
1227   signal (SIGPROF, handle_PROF);
1228 #endif
1229 #ifdef SIGWINCH
1230   signal (SIGWINCH, handle_WINCH);
1231 #endif
1232 #if defined(SIGLOST) && SIGLOST != SIGABRT
1233   signal (SIGLOST, handle_LOST);
1234 #endif
1235 #ifdef SIGUSR1
1236   signal (SIGUSR1, handle_USR1);
1237 #endif
1238 #ifdef SIGUSR2
1239   signal (SIGUSR2, handle_USR2);
1240 #endif
1241 #ifdef SIGPWR
1242   signal (SIGPWR, handle_PWR);
1243 #endif
1244 #if defined (SIGPOLL) && (!defined (SIGIO) || SIGPOLL != SIGIO)
1245   signal (SIGPOLL, handle_POLL);
1246 #endif
1247 #ifdef SIGWIND
1248   signal (SIGWIND, handle_WIND);
1249 #endif
1250 #ifdef SIGPHONE
1251   signal (SIGPHONE, handle_PHONE);
1252 #endif
1253 #ifdef SIGWAITING
1254   signal (SIGWAITING, handle_WAITING);
1255 #endif
1256 #ifdef SIGLWP
1257   signal (SIGLWP, handle_LWP);
1258 #endif
1259 #ifdef SIGDANGER
1260   signal (SIGDANGER, handle_DANGER);
1261 #endif
1262 #ifdef SIGGRANT
1263   signal (SIGGRANT, handle_GRANT);
1264 #endif
1265 #ifdef SIGRETRACT
1266   signal (SIGRETRACT, handle_RETRACT);
1267 #endif
1268 #ifdef SIGMSG
1269   signal (SIGMSG, handle_MSG);
1270 #endif
1271 #ifdef SIGSOUND
1272   signal (SIGSOUND, handle_SOUND);
1273 #endif
1274 #ifdef SIGSAK
1275   signal (SIGSAK, handle_SAK);
1276 #endif
1277 #ifdef SIGPRIO
1278   signal (SIGPRIO, handle_PRIO);
1279 #endif
1280 #ifdef __Lynx__
1281   /* Lynx doesn't seem to have anything in signal.h for this.  */
1282   signal (33, handle_33);
1283   signal (34, handle_34);
1284   signal (35, handle_35);
1285   signal (36, handle_36);
1286   signal (37, handle_37);
1287   signal (38, handle_38);
1288   signal (39, handle_39);
1289   signal (40, handle_40);
1290   signal (41, handle_41);
1291   signal (42, handle_42);
1292   signal (43, handle_43);
1293   signal (44, handle_44);
1294   signal (45, handle_45);
1295   signal (46, handle_46);
1296   signal (47, handle_47);
1297   signal (48, handle_48);
1298   signal (49, handle_49);
1299   signal (50, handle_50);
1300   signal (51, handle_51);
1301   signal (52, handle_52);
1302   signal (53, handle_53);
1303   signal (54, handle_54);
1304   signal (55, handle_55);
1305   signal (56, handle_56);
1306   signal (57, handle_57);
1307   signal (58, handle_58);
1308   signal (59, handle_59);
1309   signal (60, handle_60);
1310   signal (61, handle_61);
1311   signal (62, handle_62);
1312   signal (63, handle_63);
1313 #endif /* lynx */
1314   signal (SIGTERM, handle_TERM);
1315
1316   x = 0;
1317
1318   gen_ABRT ();
1319   gen_HUP ();
1320   gen_QUIT ();
1321   gen_ILL ();
1322   gen_EMT ();
1323   gen_FPE ();
1324   gen_BUS ();
1325   gen_SEGV ();
1326   gen_SYS ();
1327   gen_PIPE ();
1328   gen_ALRM ();
1329   gen_URG ();
1330   gen_TSTP ();
1331   gen_CONT ();
1332   gen_CHLD ();
1333   gen_TTIN ();
1334   gen_TTOU ();
1335   gen_IO ();
1336   gen_XCPU ();
1337   gen_XFSZ ();
1338   gen_VTALRM ();
1339   gen_PROF ();
1340   gen_WINCH ();
1341   gen_LOST ();
1342   gen_USR1 ();
1343   gen_USR2 ();
1344   gen_PWR ();
1345   gen_POLL ();
1346   gen_WIND ();
1347   gen_PHONE ();
1348   gen_WAITING ();
1349   gen_LWP ();
1350   gen_DANGER ();
1351   gen_GRANT ();
1352   gen_RETRACT ();
1353   gen_MSG ();
1354   gen_SOUND ();
1355   gen_SAK ();
1356   gen_PRIO ();
1357   gen_33 ();
1358   gen_34 ();
1359   gen_35 ();
1360   gen_36 ();
1361   gen_37 ();
1362   gen_38 ();
1363   gen_39 ();
1364   gen_40 ();
1365   gen_41 ();
1366   gen_42 ();
1367   gen_43 ();
1368   gen_44 ();
1369   gen_45 ();
1370   gen_46 ();
1371   gen_47 ();
1372   gen_48 ();
1373   gen_49 ();
1374   gen_50 ();
1375   gen_51 ();
1376   gen_52 ();
1377   gen_53 ();
1378   gen_54 ();
1379   gen_55 ();
1380   gen_56 ();
1381   gen_57 ();
1382   gen_58 ();
1383   gen_59 ();
1384   gen_60 ();
1385   gen_61 ();
1386   gen_62 ();
1387   gen_63 ();
1388   gen_TERM ();
1389
1390   return 0;     /* end of main */
1391 }