gdb/testsuite/gdb.base/sigall.c

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