contrib/tcsh/sh.init.c

   1 /*
   2  * $Header: /src/pub/tcsh/sh.init.c,v 3.49 2002/03/08 17:36:46 christos Exp $
   3  * $DragonFly: src/contrib/tcsh/Attic/sh.init.c,v 1.4 2003/10/24 17:14:14 dillon Exp $
   4  */
   5 /*
   6  * sh.init.c: Function and signal tables
   7  */
   8 /*-
   9  * Copyright (c) 1980, 1991 The Regents of the University of California.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36 #include "sh.h"
  37
  38 RCSID("$Id: sh.init.c,v 3.49 2002/03/08 17:36:46 christos Exp $")
  39
  40 #include "ed.h"
  41 #include "tw.h"
  42
  43 /*
  44  * C shell
  45  */
  46
  47 #define INF     0x7fffffff
  48
  49 struct  biltins bfunc[] = {
  50     { ":",              dozip,          0,      INF     },
  51     { "@",              dolet,          0,      INF     },
  52     { "alias",          doalias,        0,      INF     },
  53 #ifdef OBSOLETE
  54     { "aliases",        doaliases,      0,      1,      },
  55 #endif /* OBSOLETE */
  56     { "alloc",          showall,        0,      1       },
  57 #if defined(_CX_UX)
  58     { "att",            doatt,          0,      INF     },
  59 #endif /* _CX_UX */
  60     { "bg",             dobg,           0,      INF     },
  61 #ifdef OBSOLETE
  62     { "bind",           dobind,         0,      2       },
  63 #endif /* OBSOLETE */
  64     { "bindkey",        dobindkey,      0,      8       },
  65     { "break",          dobreak,        0,      0       },
  66     { "breaksw",        doswbrk,        0,      0       },
  67     { "builtins",       dobuiltins,     0,      0       },
  68 #ifdef KAI
  69     { "bye",            goodbye,        0,      0       },
  70 #endif /* KAI */
  71     { "case",           dozip,          0,      1       },
  72     { "cd",             dochngd,        0,      INF     },
  73     { "chdir",          dochngd,        0,      INF     },
  74     { "complete",       docomplete,     0,      INF     },
  75     { "continue",       docontin,       0,      0       },
  76     { "default",        dozip,          0,      0       },
  77     { "dirs",           dodirs,         0,      INF     },
  78 #if defined(_CRAY) && !defined(_CRAYMPP)
  79     { "dmmode",         dodmmode,       0,      1       },
  80 #endif /* _CRAY && !_CRAYMPP */
  81     { "echo",           doecho,         0,      INF     },
  82     { "echotc",         doechotc,       0,      INF     },
  83     { "else",           doelse,         0,      INF     },
  84     { "end",            doend,          0,      0       },
  85     { "endif",          dozip,          0,      0       },
  86     { "endsw",          dozip,          0,      0       },
  87     { "eval",           doeval,         0,      INF     },
  88     { "exec",           execash,        1,      INF     },
  89     { "exit",           doexit,         0,      INF     },
  90     { "fg",             dofg,           0,      INF     },
  91     { "filetest",       dofiletest,     2,      INF     },
  92     { "foreach",        doforeach,      3,      INF     },
  93 #ifdef TCF
  94     { "getspath",       dogetspath,     0,      0       },
  95     { "getxvers",       dogetxvers,     0,      0       },
  96 #endif /* TCF */
  97     { "glob",           doglob,         0,      INF     },
  98     { "goto",           dogoto,         1,      1       },
  99     { "hashstat",       hashstat,       0,      0       },
 100     { "history",        dohist,         0,      2       },
 101     { "hup",            dohup,          0,      INF     },
 102     { "if",             doif,           1,      INF     },
 103 #ifdef apollo
 104     { "inlib",          doinlib,        1,      INF     },
 105 #endif /* apollo */
 106     { "jobs",           dojobs,         0,      1       },
 107     { "kill",           dokill,         1,      INF     },
 108 #ifndef HAVENOLIMIT
 109     { "limit",          dolimit,        0,      3       },
 110 #endif /* !HAVENOLIMIT */
 111 #ifdef OBSOLETE
 112     { "linedit",        doecho,         0,      INF     },
 113 #endif /* OBSOLETE */
 114 #if !defined(HAVENOUTMP) && !defined(KAI)
 115     { "log",            dolog,          0,      0       },
 116 #endif /* !HAVENOUTMP && !KAI */
 117     { "login",          dologin,        0,      1       },
 118     { "logout",         dologout,       0,      0       },
 119     { "ls-F",           dolist,         0,      INF     },
 120 #ifdef TCF
 121     { "migrate",        domigrate,      1,      INF     },
 122 #endif /* TCF */
 123 #ifdef NEWGRP
 124     { "newgrp",         donewgrp,       1,      2       },
 125 #endif /* NEWGRP */
 126     { "nice",           donice,         0,      INF     },
 127     { "nohup",          donohup,        0,      INF     },
 128     { "notify",         donotify,       0,      INF     },
 129     { "onintr",         doonintr,       0,      2       },
 130     { "popd",           dopopd,         0,      INF     },
 131     { "printenv",       doprintenv,     0,      1       },
 132     { "pushd",          dopushd,        0,      INF     },
 133     { "rehash",         dohash,         0,      3       },
 134     { "repeat",         dorepeat,       2,      INF     },
 135 #ifdef apollo
 136     { "rootnode",       dorootnode,     1,      1       },
 137 #endif /* apollo */
 138     { "sched",          dosched,        0,      INF     },
 139     { "set",            doset,          0,      INF     },
 140     { "setenv",         dosetenv,       0,      2       },
 141 #ifdef MACH
 142     { "setpath",        dosetpath,      0,      INF     },
 143 #endif  /* MACH */
 144 #ifdef TCF
 145     { "setspath",       dosetspath,     1,      INF     },
 146 #endif /* TCF */
 147     { "settc",          dosettc,        2,      2       },
 148     { "setty",          dosetty,        0,      INF     },
 149 #ifdef TCF
 150     { "setxvers",       dosetxvers,     0,      1       },
 151 #endif /* TCF */
 152     { "shift",          shift,          0,      1       },
 153     { "source",         dosource,       1,      INF     },
 154     { "stop",           dostop,         1,      INF     },
 155     { "suspend",        dosuspend,      0,      0       },
 156     { "switch",         doswitch,       1,      INF     },
 157     { "telltc",         dotelltc,       0,      INF     },
 158     { "time",           dotime,         0,      INF     },
 159 #if defined(_CX_UX)
 160     { "ucb",            doucb,          0,      INF     },
 161 #endif /* _CX_UX */
 162     { "umask",          doumask,        0,      1       },
 163     { "unalias",        unalias,        1,      INF     },
 164     { "uncomplete",     douncomplete,   1,      INF     },
 165     { "unhash",         dounhash,       0,      0       },
 166 #if defined(masscomp) || defined(_CX_UX)
 167     { "universe",       douniverse,     0,      INF     },
 168 #endif /* masscomp || _CX_UX */
 169 #ifndef HAVENOLIMIT
 170     { "unlimit",        dounlimit,      0,      INF     },
 171 #endif /* !HAVENOLIMIT */
 172     { "unset",          unset,          1,      INF     },
 173     { "unsetenv",       dounsetenv,     1,      INF     },
 174 #ifdef apollo
 175     { "ver",            dover,          0,      INF     },
 176 #endif /* apollo */
 177     { "wait",           dowait,         0,      0       },
 178 #ifdef WARP
 179     { "warp",           dowarp,         0,      2       },
 180 #endif /* WARP */
 181 #if !defined(HAVENOUTMP) && defined(KAI)
 182     { "watchlog",       dolog,          0,      0       },
 183 #endif /* !HAVENOUTMP && KAI */
 184     { "where",          dowhere,        1,      INF     },
 185     { "which",          dowhich,        1,      INF     },
 186     { "while",          dowhile,        1,      INF     }
 187 };
 188 int nbfunc = sizeof bfunc / sizeof *bfunc;
 189
 190 struct srch srchn[] = {
 191     { "@",              TC_LET          },
 192     { "break",          TC_BREAK        },
 193     { "breaksw",        TC_BRKSW        },
 194     { "case",           TC_CASE         },
 195     { "default",        TC_DEFAULT      },
 196     { "else",           TC_ELSE         },
 197     { "end",            TC_END          },
 198     { "endif",          TC_ENDIF        },
 199     { "endsw",          TC_ENDSW        },
 200     { "exit",           TC_EXIT         },
 201     { "foreach",        TC_FOREACH      },
 202     { "goto",           TC_GOTO         },
 203     { "if",             TC_IF           },
 204     { "label",          TC_LABEL        },
 205     { "set",            TC_SET          },
 206     { "switch",         TC_SWITCH       },
 207     { "while",          TC_WHILE        }
 208 };
 209 int nsrchn = sizeof srchn / sizeof *srchn;
 210
 211
 212 /*
 213  * Note: For some machines, (hpux eg.)
 214  * NSIG = number of signals + 1...
 215  * so we define 33 or 65 (POSIX) signals for
 216  * everybody
 217  */
 218
 219 /* We define NUMSIG to avoid changing NSIG or MAXSIG */
 220 #ifdef POSIX
 221 # define NUMSIG 65
 222 #else /* !POSIX */
 223 # define NUMSIG 33
 224 #endif /* POSIX */
 225
 226 int     nsig = NUMSIG - 1;      /* This should be the number of real signals */
 227                                 /* not counting signal 0 */
 228 struct  mesg mesg[NUMSIG];      /* Arrays start at [0] so we initialize from */
 229                                 /* 0 to 32 or 64, the max real signal number */
 230
 231 void
 232 mesginit()
 233 {
 234
 235 #ifdef NLS_CATALOGS
 236     int i;
 237
 238     for (i = 0; i < NUMSIG; i++) {
 239         xfree((ptr_t) mesg[i].pname);
 240         mesg[i].pname = NULL;
 241     }
 242 #endif /* NLS_CATALOGS */
 243
 244 #if defined(SIGNULL) || defined(DECOSF1)
 245 # ifndef SIGNULL
 246 #  define SIGNULL 0
 247 # endif /* !SIGNULL */
 248     if (mesg[SIGNULL].pname == NULL) {
 249         mesg[SIGNULL].iname = "NULL";
 250         mesg[SIGNULL].pname = CSAVS(2, 1, "Null signal");
 251     }
 252 #endif /* SIGNULL || DECOSF1 */
 253
 254 #ifdef SIGHUP
 255     if (mesg[SIGHUP].pname == NULL) {
 256         mesg[SIGHUP].iname = "HUP";
 257         mesg[SIGHUP].pname = CSAVS(2, 2, "Hangup");
 258     }
 259 #endif /* SIGHUP */
 260
 261 #ifdef SIGINT
 262     if (mesg[SIGINT].pname == NULL) {
 263         mesg[SIGINT].iname = "INT";
 264         mesg[SIGINT].pname = CSAVS(2, 3, "Interrupt");
 265     }
 266 #endif /* SIGINT */
 267
 268 #ifdef SIGQUIT
 269     if (mesg[SIGQUIT].pname == NULL) {
 270         mesg[SIGQUIT].iname = "QUIT";
 271         mesg[SIGQUIT].pname = CSAVS(2, 4, "Quit");
 272     }
 273 #endif /* SIGQUIT */
 274
 275 #ifdef SIGILL
 276     if (mesg[SIGILL].pname == NULL) {
 277         mesg[SIGILL].iname = "ILL";
 278         mesg[SIGILL].pname = CSAVS(2, 5, "Illegal instruction");
 279     }
 280 #endif /* SIGILL */
 281
 282 #ifdef SIGTRAP
 283     if (mesg[SIGTRAP].pname == NULL) {
 284         mesg[SIGTRAP].iname = "TRAP";
 285         mesg[SIGTRAP].pname = CSAVS(2, 6, "Trace/BPT trap");
 286     }
 287 #endif /* SIGTRAP */
 288
 289 #ifdef SIGABRT
 290     if (mesg[SIGABRT].pname == NULL) {
 291         mesg[SIGABRT].iname = "ABRT";
 292         mesg[SIGABRT].pname = CSAVS(2, 7, "Abort");
 293     }
 294 #endif /* SIGABRT */
 295
 296 #ifdef SIGIOT
 297     if (mesg[SIGIOT].pname == NULL) {
 298         mesg[SIGIOT].iname = "IOT";
 299         mesg[SIGIOT].pname = CSAVS(2, 8, "IOT trap");
 300     }
 301 #endif /* SIGIOT */
 302
 303 #ifdef SIGDANGER
 304     /* aiws */
 305     if (mesg[SIGDANGER].pname == NULL) {
 306         mesg[SIGDANGER].iname = "DANGER";
 307         mesg[SIGDANGER].pname = CSAVS(2, 9, "System Crash Imminent");
 308     }
 309 #endif /* SIGDANGER */
 310
 311 #ifdef SIGERR
 312     /* _CRAY */
 313     if (mesg[SIGERR].pname == NULL) {
 314         mesg[SIGERR].iname = "ERR";
 315         mesg[SIGERR].pname = CSAVS(2, 10, "Error exit");
 316     }
 317 #endif /* SIGERR */
 318
 319 #ifdef SIGEMT
 320     if (mesg[SIGEMT].pname == NULL) {
 321         mesg[SIGEMT].iname = "EMT";
 322         mesg[SIGEMT].pname = CSAVS(2, 11, "EMT trap");
 323     }
 324 #endif /* SIGEMT */
 325
 326 #ifdef SIGFPE
 327     if (mesg[SIGFPE].pname == NULL) {
 328         mesg[SIGFPE].iname = "FPE";
 329         mesg[SIGFPE].pname = CSAVS(2, 12, "Floating exception");
 330     }
 331 #endif /* SIGFPE */
 332
 333 #ifdef SIGKILL
 334     if (mesg[SIGKILL].pname == NULL) {
 335         mesg[SIGKILL].iname = "KILL";
 336         mesg[SIGKILL].pname = CSAVS(2, 13, "Killed");
 337     }
 338 #endif /* SIGKILL */
 339
 340 #ifdef SIGUSR1
 341     if (mesg[SIGUSR1].pname == NULL) {
 342         mesg[SIGUSR1].iname = "USR1";
 343         mesg[SIGUSR1].pname = CSAVS(2, 14, "User signal 1");
 344     }
 345 #endif /* SIGUSR1 */
 346
 347 #ifdef SIGUSR2
 348     if (mesg[SIGUSR2].pname == NULL) {
 349         mesg[SIGUSR2].iname = "USR2";
 350         mesg[SIGUSR2].pname = CSAVS(2, 15, "User signal 2");
 351     }
 352 #endif /* SIGUSR2 */
 353
 354 #ifdef SIGSEGV
 355     if (mesg[SIGSEGV].pname == NULL) {
 356         mesg[SIGSEGV].iname = "SEGV";
 357         mesg[SIGSEGV].pname = CSAVS(2, 16, "Segmentation fault");
 358     }
 359 #endif /* SIGSEGV */
 360
 361 #ifdef SIGBUS
 362     if (mesg[SIGBUS].pname == NULL) {
 363         mesg[SIGBUS].iname = "BUS";
 364         mesg[SIGBUS].pname = CSAVS(2, 17, "Bus error");
 365     }
 366 #endif /* SIGBUS */
 367
 368 #ifdef SIGPRE
 369     /* _CRAY || IBMAIX */
 370     if (mesg[SIGPRE].pname == NULL) {
 371         mesg[SIGPRE].iname = "PRE";
 372         mesg[SIGPRE].pname = CSAVS(2, 18, "Program range error");
 373     }
 374 #endif /* SIGPRE */
 375
 376 #ifdef SIGORE
 377     /* _CRAY */
 378     if (mesg[SIGORE].pname == NULL) {
 379         mesg[SIGORE].iname = "ORE";
 380         mesg[SIGORE].pname = CSAVS(2, 19, "Operand range error");
 381     }
 382 #endif /* SIGORE */
 383
 384 #ifdef SIGSYS
 385     if (mesg[SIGSYS].pname == NULL) {
 386         mesg[SIGSYS].iname = "SYS";
 387         mesg[SIGSYS].pname = CSAVS(2, 20, "Bad system call");
 388     }
 389 #endif /* SIGSYS */
 390
 391 #ifdef SIGPIPE
 392     if (mesg[SIGPIPE].pname == NULL) {
 393         mesg[SIGPIPE].iname = "PIPE";
 394         mesg[SIGPIPE].pname = CSAVS(2, 21, "Broken pipe");
 395     }
 396 #endif /* SIGPIPE */
 397
 398 #ifdef SIGALRM
 399     if (mesg[SIGALRM].pname == NULL) {
 400         mesg[SIGALRM].iname = "ALRM";
 401         mesg[SIGALRM].pname = CSAVS(2, 22, "Alarm clock");
 402     }
 403 #endif /* SIGALRM */
 404
 405 #ifdef SIGTERM
 406     if (mesg[SIGTERM].pname == NULL) {
 407         mesg[SIGTERM].iname = "TERM";
 408         mesg[SIGTERM].pname = CSAVS(2, 23, "Terminated");
 409     }
 410 #endif /* SIGTERM */
 411
 412 /* SIGCLD vs SIGCHLD */
 413 #if !defined(SIGCHLD) || defined(SOLARIS2) || defined(apollo) || defined(__EMX__)
 414     /* If we don't define SIGCHLD, or our OS prefers SIGCLD to SIGCHLD, */
 415     /* check for SIGCLD */
 416 # ifdef SIGCLD
 417     if (mesg[SIGCLD].pname == NULL) {
 418         mesg[SIGCLD].iname = "CLD";
 419 #  ifdef BSDJOBS
 420         mesg[SIGCLD].pname = CSAVS(2, 24, "Child status change");
 421 #  else /* !BSDJOBS */
 422         mesg[SIGCLD].pname = CSAVS(2, 25, "Death of child");
 423 #  endif /* BSDJOBS */
 424     }
 425 # endif /* SIGCLD */
 426 #else /* !(!SIGCHLD || SOLARIS2 || apollo || __EMX__) */
 427     /* We probably define SIGCHLD */
 428 # ifdef SIGCHLD
 429     if (mesg[SIGCHLD].pname == NULL) {
 430         mesg[SIGCHLD].iname = "CHLD";
 431 #  ifdef BSDJOBS
 432         mesg[SIGCHLD].pname = CSAVS(2, 27, "Child stopped or exited");
 433 #  else /* !BSDJOBS */
 434         mesg[SIGCHLD].pname = CSAVS(2, 28, "Child exited");
 435 #  endif /* BSDJOBS */
 436     }
 437 # endif /* SIGCHLD */
 438 #endif /* !SIGCHLD || SOLARIS2 || apollo || __EMX__ */
 439
 440 #ifdef SIGAPOLLO
 441     /* apollo */
 442     if (mesg[SIGAPOLLO].pname == NULL) {
 443         mesg[SIGAPOLLO].iname = "APOLLO";
 444         mesg[SIGAPOLLO].pname = CSAVS(2, 26, "Apollo-specific fault");
 445     }
 446 #endif /* SIGAPOLLO */
 447
 448 #ifdef SIGPWR
 449     if (mesg[SIGPWR].pname == NULL) {
 450         mesg[SIGPWR].iname = "PWR";
 451         mesg[SIGPWR].pname = CSAVS(2, 29, "Power failure");
 452     }
 453 #endif /* SIGPWR */
 454
 455 #ifdef SIGLOST
 456     if (mesg[SIGLOST].pname == NULL) {
 457         mesg[SIGLOST].iname = "LOST";
 458         mesg[SIGLOST].pname = CSAVS(2, 30, "Resource Lost");
 459     }
 460 #endif /* SIGLOST */
 461
 462 #ifdef SIGBREAK
 463     /* __EMX__ */
 464     if (mesg[SIGBREAK].pname == NULL) {
 465         mesg[SIGBREAK].iname = "BREAK";
 466         mesg[SIGBREAK].pname = CSAVS(2, 31, "Break (Ctrl-Break)");
 467     }
 468 #endif /* SIGBREAK */
 469
 470 #ifdef SIGIO
 471 # if !defined(SIGPOLL) || SIGPOLL != SIGIO
 472     if (mesg[SIGIO].pname == NULL) {
 473         mesg[SIGIO].iname = "IO";
 474 #  ifdef cray
 475         mesg[SIGIO].pname = CSAVS(2, 32, "Input/output possible signal");
 476 #  else /* !cray */
 477         mesg[SIGIO].pname = CSAVS(2, 33, "Asynchronous I/O (select)");
 478 #  endif /* cray */
 479     }
 480 # endif /* !SIGPOLL || SIGPOLL != SIGIO */
 481 #endif /* SIGIO */
 482
 483 #ifdef SIGCKPT
 484     if (mesg[SIGCKPT].pname == NULL) {
 485         mesg[SIGCKPT].iname = "CKPT";
 486         mesg[SIGCKPT].pname = CSAVS(2, 34, "Checkpoint and continue");
 487     }
 488 #endif /* SIGCKPT */
 489
 490 #ifdef SIGCKPTEXIT
 491     if (mesg[SIGCKPTEXIT].pname == NULL) {
 492         mesg[SIGCKPTEXIT].iname = "CKPTEXIT";
 493         mesg[SIGCKPTEXIT].pname = CSAVS(2, 35, "Checkpoint and eXit");
 494     }
 495 #endif /* SIGCKPTEXIT */
 496
 497 #ifdef SIGURG
 498     if (mesg[SIGURG].pname == NULL) {
 499         mesg[SIGURG].iname = "URG";
 500         mesg[SIGURG].pname = CSAVS(2, 34, "Urgent condition on I/O channel");
 501     }
 502 #endif /* SIGURG */
 503
 504 #ifdef SIGMT
 505     /* cray */
 506     if (mesg[SIGMT].pname == NULL) {
 507         mesg[SIGMT].iname = "MT";
 508         mesg[SIGMT].pname = CSAVS(2, 35, "Multitasking wake-up");
 509     }
 510 #endif /* SIGMT */
 511
 512 #ifdef SIGMTKILL
 513     /* cray */
 514     if (mesg[SIGMTKILL].pname == NULL) {
 515         mesg[SIGMTKILL].iname = "MTKILL";
 516         mesg[SIGMTKILL].pname = CSAVS(2, 36, "Multitasking kill");
 517     }
 518 #endif /* SIGMTKILL */
 519
 520 #ifdef SIGBUFIO
 521     /* _CRAYCOM */
 522     if (mesg[SIGBUFIO].pname == NULL) {
 523         mesg[SIGBUFIO].iname = "BUFIO";
 524         mesg[SIGBUFIO].pname = CSAVS(2, 37,
 525                                     "Fortran asynchronous I/O completion");
 526     }
 527 #endif /* SIGBUFIO */
 528
 529 #ifdef SIGRECOVERY
 530     /* _CRAYCOM */
 531     if (mesg[SIGRECOVERY].pname == NULL) {
 532         mesg[SIGRECOVERY].iname = "RECOVERY";
 533         mesg[SIGRECOVERY].pname = CSAVS(2, 38, "Recovery");
 534     }
 535 #endif /* SIGRECOVERY */
 536
 537 #ifdef SIGUME
 538     /* _CRAYCOM */
 539     if (mesg[SIGUME].pname == NULL) {
 540         mesg[SIGUME].iname = "UME";
 541         mesg[SIGUME].pname = CSAVS(2, 39, "Uncorrectable memory error");
 542     }
 543 #endif /* SIGUME */
 544
 545 #ifdef SIGCPULIM
 546     /* _CRAYCOM */
 547     if (mesg[SIGCPULIM].pname == NULL) {
 548         mesg[SIGCPULIM].iname = "CPULIM";
 549         mesg[SIGCPULIM].pname = CSAVS(2, 40, "CPU time limit exceeded");
 550     }
 551 #endif /* SIGCPULIM */
 552
 553 #ifdef SIGSHUTDN
 554     /* _CRAYCOM */
 555     if (mesg[SIGSHUTDN].pname == NULL) {
 556         mesg[SIGSHUTDN].iname = "SHUTDN";
 557         mesg[SIGSHUTDN].pname = CSAVS(2, 41, "System shutdown imminent");
 558     }
 559 #endif /* SIGSHUTDN */
 560
 561 #ifdef SIGNOWAK
 562     /* _CRAYCOM */
 563     if (mesg[SIGNOWAK].pname == NULL) {
 564         mesg[SIGNOWAK].iname = "NOWAK";
 565         mesg[SIGNOWAK].pname = CSAVS(2, 42,
 566                                     "Micro-tasking group-no wakeup flag set");
 567     }
 568 #endif /* SIGNOWAK */
 569
 570 #ifdef SIGTHERR
 571     /* _CRAYCOM */
 572     if (mesg[SIGTHERR].pname == NULL) {
 573         mesg[SIGTHERR].iname = "THERR";
 574         mesg[SIGTHERR].pname = CSAVS(2, 43,
 575                             "Thread error - (use cord -T for detailed info)");
 576     }
 577 #endif /* SIGTHERR */
 578
 579 #ifdef SIGRPE
 580     /* cray */
 581     if (mesg[SIGRPE].pname == NULL) {
 582         mesg[SIGRPE].pname = CSAVS(2, 44, "CRAY Y-MP register parity error");
 583         mesg[SIGRPE].iname = "RPE";
 584     }
 585 #endif /* SIGRPE */
 586
 587 #ifdef SIGINFO
 588     if (mesg[SIGINFO].pname == NULL) {
 589         mesg[SIGINFO].iname = "INFO";
 590         mesg[SIGINFO].pname = CSAVS(2, 45, "Information request");
 591     }
 592 #endif /* SIGINFO */
 593
 594 #ifdef SIGSTOP
 595     if (mesg[SIGSTOP].pname == NULL) {
 596         mesg[SIGSTOP].iname = "STOP";
 597 # ifdef SUSPENDED
 598         mesg[SIGSTOP].pname = CSAVS(2, 46, "Suspended (signal)");
 599 # else /* !SUSPENDED */
 600         mesg[SIGSTOP].pname = CSAVS(2, 47, "Stopped (signal)");
 601 # endif /* SUSPENDED */
 602     }
 603 #endif /* SIGSTOP */
 604
 605 #ifdef SIGTSTP
 606     if (mesg[SIGTSTP].pname == NULL) {
 607         mesg[SIGTSTP].iname = "TSTP";
 608 # ifdef SUSPENDED
 609         mesg[SIGTSTP].pname = CSAVS(2, 48, "Suspended");
 610 # else /* !SUSPENDED */
 611         mesg[SIGTSTP].pname = CSAVS(2, 49, "Stopped");
 612 # endif /* SUSPENDED */
 613     }
 614 #endif /* SIGTSTP */
 615
 616 #ifdef SIGCONT
 617     if (mesg[SIGCONT].pname == NULL) {
 618         mesg[SIGCONT].iname = "CONT";
 619         mesg[SIGCONT].pname = CSAVS(2, 50, "Continued");
 620     }
 621 #endif /* SIGCONT */
 622
 623 #ifdef SIGTTIN
 624     if (mesg[SIGTTIN].pname == NULL) {
 625         mesg[SIGTTIN].iname = "TTIN";
 626 # ifdef SUSPENDED
 627         mesg[SIGTTIN].pname = CSAVS(2, 51, "Suspended (tty input)");
 628 # else /* !SUSPENDED */
 629         mesg[SIGTTIN].pname = CSAVS(2, 52, "Stopped (tty input)");
 630 # endif /* SUSPENDED */
 631     }
 632 #endif /* SIGTTIN */
 633
 634 #ifdef SIGTTOU
 635     if (mesg[SIGTTOU].pname == NULL) {
 636         mesg[SIGTTOU].iname = "TTOU";
 637 # ifdef SUSPENDED
 638         mesg[SIGTTOU].pname = CSAVS(2, 53, "Suspended (tty output)");
 639 # else /* SUSPENDED */
 640         mesg[SIGTTOU].pname = CSAVS(2, 54, "Stopped (tty output)");
 641 # endif /* SUSPENDED */
 642     }
 643 #endif /* SIGTTOU */
 644
 645 #ifdef SIGWIND
 646     /* UNIXPC */
 647     if (mesg[SIGWIND].pname == NULL) {
 648         mesg[SIGWIND].iname = "WIND";
 649         mesg[SIGWIND].pname = CSAVS(2, 55, "Window status changed");
 650     }
 651 #endif /* SIGWIND */
 652
 653 #ifdef SIGWINDOW
 654     if (mesg[SIGWINDOW].pname == NULL) {
 655         mesg[SIGWINDOW].iname = "WINDOW";
 656         mesg[SIGWINDOW].pname = CSAVS(2, 56, "Window size changed");
 657     }
 658 #endif /* SIGWINDOW */
 659
 660 #ifdef SIGWINCH
 661     if (mesg[SIGWINCH].pname == NULL) {
 662         mesg[SIGWINCH].iname = "WINCH";
 663         mesg[SIGWINCH].pname = CSAVS(2, 56, "Window size changed");
 664     }
 665 #endif /* SIGWINCH */
 666
 667 #ifdef SIGPHONE
 668     /* UNIXPC */
 669     if (mesg[SIGPHONE].pname == NULL) {
 670         mesg[SIGPHONE].iname = "PHONE";
 671         mesg[SIGPHONE].pname = CSAVS(2, 57, "Phone status changed");
 672     }
 673 # endif /* SIGPHONE */
 674
 675 #ifdef SIGXCPU
 676     if (mesg[SIGXCPU].pname == NULL) {
 677         mesg[SIGXCPU].iname = "XCPU";
 678         mesg[SIGXCPU].pname = CSAVS(2, 58, "Cputime limit exceeded");
 679     }
 680 #endif /* SIGXCPU */
 681
 682 #ifdef SIGXFSZ
 683     if (mesg[SIGXFSZ].pname == NULL) {
 684         mesg[SIGXFSZ].iname = "XFSZ";
 685         mesg[SIGXFSZ].pname = CSAVS(2, 59, "Filesize limit exceeded");
 686     }
 687 #endif /* SIGXFSZ */
 688
 689 #ifdef SIGVTALRM
 690     if (mesg[SIGVTALRM].pname == NULL) {
 691         mesg[SIGVTALRM].iname = "VTALRM";
 692         mesg[SIGVTALRM].pname = CSAVS(2, 60, "Virtual time alarm");
 693     }
 694 #endif /* SIGVTALRM */
 695
 696 #ifdef SIGPROF
 697     if (mesg[SIGPROF].pname == NULL) {
 698         mesg[SIGPROF].iname = "PROF";
 699         mesg[SIGPROF].pname = CSAVS(2, 61, "Profiling time alarm");
 700     }
 701 #endif /* SIGPROF */
 702
 703 #ifdef SIGDIL
 704     /* hpux */
 705     if (mesg[SIGDIL].pname == NULL) {
 706         mesg[SIGDIL].iname = "DIL";
 707         mesg[SIGDIL].pname = CSAVS(2, 62, "DIL signal");
 708     }
 709 #endif /* SIGDIL */
 710
 711 #ifdef SIGPOLL
 712     if (mesg[SIGPOLL].pname == NULL) {
 713         mesg[SIGPOLL].iname = "POLL";
 714         mesg[SIGPOLL].pname = CSAVS(2, 63, "Pollable event occured");
 715     }
 716 #endif /* SIGPOLL */
 717
 718 #ifdef SIGWAITING
 719     /* solaris */
 720     if (mesg[SIGWAITING].pname == NULL) {
 721         mesg[SIGWAITING].iname = "WAITING";
 722         mesg[SIGWAITING].pname = CSAVS(2, 64, "Process's lwps are blocked");
 723     }
 724 #endif /* SIGWAITING */
 725
 726 #ifdef SIGLWP
 727     /* solaris */
 728     if (mesg[SIGLWP].pname == NULL) {
 729         mesg[SIGLWP].iname = "LWP";
 730         mesg[SIGLWP].pname = CSAVS(2, 65, "Special LWP signal");
 731     }
 732 #endif /* SIGLWP */
 733
 734 #ifdef SIGFREEZE
 735     /* solaris */
 736     if (mesg[SIGFREEZE].pname == NULL) {
 737         mesg[SIGFREEZE].iname = "FREEZE";
 738         mesg[SIGFREEZE].pname = CSAVS(2, 66, "Special CPR Signal");
 739     }
 740 #endif /* SIGFREEZE */
 741
 742 #ifdef SIGTHAW
 743     /* solaris */
 744     if (mesg[SIGTHAW].pname == NULL) {
 745         mesg[SIGTHAW].iname = "THAW";
 746         mesg[SIGTHAW].pname = CSAVS(2, 67, "Special CPR Signal");
 747     }
 748 #endif /* SIGTHAW */
 749
 750 #ifdef SIGCANCEL
 751     /* solaris */
 752     if (mesg[SIGCANCEL].pname == NULL) {
 753         mesg[SIGCANCEL].iname = "CANCEL";
 754         mesg[SIGCANCEL].pname = CSAVS(2, 109,
 755             "Thread cancellation signal used by libthread");
 756     }
 757 #endif /* SIGCANCEL */
 758
 759 /*
 760  * Careful, some OS's (HP/UX 10.0) define these as -1
 761  */
 762 #ifdef SIGRTMIN
 763     /*
 764      * Cannot do this at compile time; Solaris2 uses _sysconf for these
 765      */
 766     if (SIGRTMIN > 0 && SIGRTMIN < NUMSIG) {
 767         if (mesg[SIGRTMIN].pname == NULL) {
 768             mesg[SIGRTMIN].iname = "RTMIN";
 769             mesg[SIGRTMIN].pname = CSAVS(2, 68, "First Realtime Signal");
 770         }
 771
 772         if (mesg[SIGRTMIN+1].pname == NULL) {
 773             mesg[SIGRTMIN+1].iname = "RTMIN+1";
 774             mesg[SIGRTMIN+1].pname = CSAVS(2, 69, "Second Realtime Signal");
 775         }
 776
 777         if (mesg[SIGRTMIN+2].pname == NULL) {
 778             mesg[SIGRTMIN+2].iname = "RTMIN+2";
 779             mesg[SIGRTMIN+2].pname = CSAVS(2, 70, "Third Realtime Signal");
 780         }
 781
 782         if (mesg[SIGRTMIN+3].pname == NULL) {
 783             mesg[SIGRTMIN+3].iname = "RTMIN+3";
 784             mesg[SIGRTMIN+3].pname = CSAVS(2, 71, "Fourth Realtime Signal");
 785         }
 786     }
 787 #endif /* SIGRTMIN */
 788
 789 #ifdef SIGRTMAX
 790     /*
 791      * Cannot do this at compile time; Solaris2 uses _sysconf for these
 792      */
 793     if (SIGRTMAX > 0 && SIGRTMAX < NUMSIG) {
 794         if (mesg[SIGRTMAX-3].pname == NULL) {
 795             mesg[SIGRTMAX-3].iname = "RTMAX-3";
 796             mesg[SIGRTMAX-3].pname = CSAVS(2, 72,
 797                                            "Fourth Last Realtime Signal");
 798         }
 799
 800         if (mesg[SIGRTMAX-2].pname == NULL) {
 801             mesg[SIGRTMAX-2].iname = "RTMAX-2";
 802             mesg[SIGRTMAX-2].pname = CSAVS(2, 73,
 803                                            "Third Last Realtime Signal");
 804         }
 805
 806         if (mesg[SIGRTMAX-1].pname == NULL) {
 807             mesg[SIGRTMAX-1].iname = "RTMAX-1";
 808             mesg[SIGRTMAX-1].pname = CSAVS(2, 74,
 809                                            "Second Last Realtime Signal");
 810         }
 811
 812         if (mesg[SIGRTMAX].pname == NULL) {
 813             mesg[SIGRTMAX].iname = "RTMAX";
 814             mesg[SIGRTMAX].pname = CSAVS(2, 75,
 815                                          "Last Realtime Signal");
 816         }
 817     }
 818 #endif /* SIGRTMAX */
 819
 820
 821 #ifdef SIGAIO
 822     /* aiws */
 823     if (mesg[SIGAIO].pname == NULL) {
 824         mesg[SIGAIO].iname = "AIO";
 825         mesg[SIGAIO].pname = CSAVS(2, 76, "LAN Asyncronous I/O");
 826     }
 827 #endif /* SIGAIO */
 828
 829 #ifdef SIGPTY
 830     /* aiws */
 831     if (mesg[SIGPTY].pname == NULL) {
 832         mesg[SIGPTY].iname = "PTY";
 833         mesg[SIGPTY].pname = CSAVS(2, 77, "PTY read/write availability");
 834     }
 835 #endif /* SIGPTY */
 836
 837 #ifdef SIGIOINT
 838     /* aiws */
 839     if (mesg[SIGIOINT].pname == NULL) {
 840         mesg[SIGIOINT].iname = "IOINT";
 841         mesg[SIGIOINT].pname = CSAVS(2, 78, "I/O intervention required");
 842     }
 843 #endif /* SIGIOINT */
 844
 845 #ifdef SIGGRANT
 846     /* aiws */
 847     if (mesg[SIGGRANT].pname == NULL) {
 848         mesg[SIGGRANT].iname = "GRANT";
 849         mesg[SIGGRANT].pname = CSAVS(2, 79, "HFT monitor mode granted");
 850     }
 851 #endif /* SIGGRANT */
 852
 853 #ifdef SIGRETRACT
 854     /* aiws */
 855     if (mesg[SIGRETRACT].pname == NULL) {
 856         mesg[SIGRETRACT].iname = "RETRACT";
 857         mesg[SIGRETRACT].pname = CSAVS(2, 80,
 858                                   "HFT monitor mode should be relinguished");
 859     }
 860 #endif /* SIGRETRACT */
 861
 862 #ifdef SIGSOUND
 863     /* aiws */
 864     if (mesg[SIGSOUND].pname == NULL) {
 865         mesg[SIGSOUND].iname = "SOUND";
 866         mesg[SIGSOUND].pname = CSAVS(2, 81, "HFT sound control has completed");
 867     }
 868 #endif /* SIGSOUND */
 869
 870 #ifdef SIGSMSG
 871     /* aiws */
 872     if (mesg[SIGSMSG].pname == NULL) {
 873         mesg[SIGSMSG].iname = "SMSG";
 874         mesg[SIGSMSG].pname = CSAVS(2, 82, "Data in HFT ring buffer");
 875     }
 876 #endif /* SIGMSG */
 877
 878 #ifdef SIGMIGRATE
 879     /* IBMAIX */
 880     if (mesg[SIGMIGRATE].pname == NULL) {
 881         mesg[SIGMIGRATE].iname = "MIGRATE";
 882         mesg[SIGMIGRATE].pname = CSAVS(2, 83, "Migrate process");
 883     }
 884 #endif /* SIGMIGRATE */
 885
 886 #ifdef SIGSAK
 887     /* IBMAIX */
 888     if (mesg[SIGSAK].pname == NULL) {
 889         mesg[SIGSAK].iname = "SAK";
 890         mesg[SIGSAK].pname = CSAVS(2, 84, "Secure attention key");
 891     }
 892 #endif /* SIGSAK */
 893
 894 #ifdef SIGRESCHED
 895     /* CX/UX */
 896     if (mesg[SIGRESCHED].pname == NULL) {
 897         mesg[SIGRESCHED].iname = "RESCHED";
 898         mesg[SIGRESCHED].pname = CSAVS(2, 85, "Reschedule");
 899     }
 900 #endif /* SIGRESCHED */
 901
 902 #ifdef SIGDEBUG
 903     /* VMS_POSIX */
 904     if (mesg[SIGDEBUG].pname == NULL) {
 905         mesg[SIGDEBUG].iname = "DEBUG";
 906         mesg[SIGDEBUG].pname = CSAVS(2, 86, "Signaling SS$_DEBUG");
 907     }
 908 #endif /* SIGDEBUG */
 909
 910 #ifdef SIGPRIO
 911     /* Lynx */
 912     if (mesg[SIGPRIO].pname == NULL) {
 913         mesg[SIGPRIO].iname = "PRIO";
 914         mesg[SIGPRIO].pname = CSAVS(2, 87, "Priority changed");
 915     }
 916 #endif /* SIGPRIO */
 917
 918 #ifdef SIGDLK
 919     /* cray */
 920     if (mesg[SIGDLK].pname == NULL) {
 921         mesg[SIGDLK].iname = "DLK";
 922         mesg[SIGDLK].pname = CSAVS(2, 88, "True deadlock detected");
 923     }
 924 #endif /* SIGDLK */
 925
 926 #ifdef SIGTINT
 927     /* masscomp */
 928     if (mesg[SIGTINT].pname == NULL) {
 929         mesg[SIGTINT].iname = "TINT";
 930         mesg[SIGTINT].pname = CSAVS(2, 89, "New input character");
 931     }
 932 #endif /* SIGTINT */
 933
 934 #ifdef SIGSTKFLT
 935     if (mesg[SIGSTKFLT].pname == NULL) {
 936         mesg[SIGSTKFLT].iname = "STKFLT";
 937         mesg[SIGSTKFLT].pname = CSAVS(2, 90, "Stack limit exceeded");
 938     }
 939 #endif /* SIGSTKFLT */
 940
 941 #ifdef SIGUNUSED
 942     if (mesg[SIGUNUSED].pname == NULL) {
 943         mesg[SIGUNUSED].iname = "UNUSED";
 944         mesg[SIGUNUSED].pname = CSAVS(2, 91, "Unused signal");
 945     }
 946 #endif /* SIGUNUSED */
 947
 948 #ifdef SIGOVLY
 949     /* SX-4 */
 950     if (mesg[SIGOVLY].pname == NULL) {
 951         mesg[SIGOVLY].iname = "OVLY";
 952         mesg[SIGOVLY].pname = CSAVS(2, 92, "LM overlay");
 953     }
 954 #endif /* SIGOVLY */
 955
 956 #ifdef SIGFRZ
 957     /* SX-4 */
 958     if (mesg[SIGFRZ].pname == NULL) {
 959         mesg[SIGFRZ].iname = "FRZ";
 960         mesg[SIGFRZ].pname = CSAVS(2, 93, "system freeze");
 961     }
 962 #endif /* SIGFRZ */
 963
 964 #ifdef SIGDFRZ
 965     /* SX-4 */
 966     if (mesg[SIGDFRZ].pname == NULL) {
 967         mesg[SIGDFRZ].iname = "DFRZ";
 968         mesg[SIGDFRZ].pname = CSAVS(2, 94, "system defreeze");
 969     }
 970 #endif /* SIGDFRZ */
 971
 972 #ifdef SIGDEAD
 973     /* SX-4 */
 974     if (mesg[SIGDEAD].pname == NULL) {
 975         mesg[SIGDEAD].iname = "DEAD";
 976         mesg[SIGDEAD].pname = CSAVS(2, 95, "dead lock");
 977     }
 978 #endif /* SIGDEAD */
 979
 980 #ifdef SIGXMEM
 981     /* SX-4 */
 982     if (mesg[SIGXMEM].pname == NULL) {
 983         mesg[SIGXMEM].iname = "XMEM";
 984         mesg[SIGXMEM].pname = CSAVS(2, 96, "exceeded memory size limit");
 985     }
 986 #endif /* SIGXMEM */
 987
 988 #ifdef SIGXDSZ
 989     /* SX-4 */
 990     if (mesg[SIGXDSZ].pname == NULL) {
 991         mesg[SIGXDSZ].iname = "XDSZ";
 992         mesg[SIGXDSZ].pname = CSAVS(2, 97, "exceeded data size limit");
 993     }
 994 #endif /* SIGXDSZ */
 995
 996 #ifdef SIGMEM32
 997     /* SX-4 */
 998     if (mesg[SIGMEM32].pname == NULL) {
 999         mesg[SIGMEM32].iname = "MEM32";
1000         mesg[SIGMEM32].pname = CSAVS(2, 98, "exceeded memory size limit of 32KB");
1001     }
1002 #endif /* SIGMEM32 */
1003
1004 #ifdef SIGNMEM
1005     /* SX-4 */
1006     if (mesg[SIGNMEM].pname == NULL) {
1007         mesg[SIGNMEM].iname = "NMEM";
1008         mesg[SIGNMEM].pname = CSAVS(2, 99, "exce error for no memory");
1009     }
1010 #endif /* SIGNMEM */
1011
1012 #ifdef SIGCHKP
1013     /* SX-4 */
1014     if (mesg[SIGCHKP].pname == NULL) {
1015         mesg[SIGCHKP].iname = "CHKP";
1016         mesg[SIGCHKP].pname = CSAVS(2, 100, "check point start");
1017     }
1018 #endif /* SIGCHKP */
1019
1020 #ifdef SIGKCHKP
1021 #if 0
1022     /* SX-4 */
1023     if (mesg[SIGKCHKP].pname == NULL) {
1024         mesg[SIGKCHKP].iname = "KCHKP";
1025         mesg[SIGKCHKP].pname = CSAVS(2, 101, "check point start of kernel");
1026     }
1027 #endif
1028 #endif /* SIGKCHKP */
1029
1030 #ifdef SIGRSTA
1031     /* SX-4 */
1032     if (mesg[SIGRSTA].pname == NULL) {
1033         mesg[SIGRSTA].iname = "RSTA";
1034         mesg[SIGRSTA].pname = CSAVS(2, 102, "restart start");
1035     }
1036 #endif /* SIGRSTA */
1037
1038 #ifdef SIGKRSTA
1039 #if 0
1040     /* SX-4 */
1041     if (mesg[SIGKRSTA].pname == NULL) {
1042         mesg[SIGKRSTA].iname = "KRSTA";
1043         mesg[SIGKRSTA].pname = CSAVS(2, 103, "restart of kernel");
1044     }
1045 #endif
1046 #endif /* SIGKRSTA */
1047
1048 #ifdef SIGXXMU
1049     /* SX-4 */
1050     if (mesg[SIGXXMU].pname == NULL) {
1051         mesg[SIGXXMU].iname = "XXMU";
1052         mesg[SIGXXMU].pname = CSAVS(2, 104, "exeeded XMU size limit");
1053     }
1054 #endif /* SIGXXMU */
1055
1056 #ifdef SIGXRLG0
1057     /* SX-4 */
1058     if (mesg[SIGXRLG0].pname == NULL) {
1059         mesg[SIGXRLG0].iname = "XRLG0";
1060         mesg[SIGXRLG0].pname = CSAVS(2, 105, "exeeded RLG0 limit");
1061     }
1062 #endif /* SIGXRLG0 */
1063
1064 #ifdef SIGXRLG1
1065     /* SX-4 */
1066     if (mesg[SIGXRLG1].pname == NULL) {
1067         mesg[SIGXRLG1].iname = "XRLG1";
1068         mesg[SIGXRLG1].pname = CSAVS(2, 106, "exeeded RLG1 limit");
1069     }
1070 #endif /* SIGXRLG1 */
1071
1072 #ifdef SIGXRLG2
1073     /* SX-4 */
1074     if (mesg[SIGXRLG2].pname == NULL) {
1075         mesg[SIGXRLG2].iname = "XRLG2";
1076         mesg[SIGXRLG2].pname = CSAVS(2, 107, "exeeded RLG2 limit");
1077     }
1078 #endif /* SIGXRLG2 */
1079
1080 #ifdef SIGXRLG3
1081     /* SX-4 */
1082     if (mesg[SIGXRLG3].pname == NULL) {
1083         mesg[SIGXRLG3].iname = "XRLG3";
1084         mesg[SIGXRLG3].pname = CSAVS(2, 108, "exeeded RLG3 limit");
1085     }
1086 #endif /* SIGXRLG3 */
1087
1088
1089 #ifdef SIGCKPT
1090     /* DragonFly BSD */
1091     if (mesg[SIGCKPT].pname == NULL) {
1092         mesg[SIGCKPT].iname = "CKPT";
1093         mesg[SIGCKPT].pname = CSAVS(2, 109, "CheckPoint");
1094     }
1095 #endif /* SIGCKPT */
1096
1097 #ifdef SIGCKPTEXIT
1098     /* DragonFly BSD */
1099     if (mesg[SIGCKPTEXIT].pname == NULL) {
1100         mesg[SIGCKPTEXIT].iname = "CKPTEXIT";
1101         mesg[SIGCKPTEXIT].pname = CSAVS(2, 110, "CheckPointExit");
1102     }
1103 #endif /* SIGCKPTEXIT */
1104 }