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