src/hacklib.c

   1 /*      SCCS Id: @(#)hacklib.c  3.4     2002/12/13      */
   2 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   3 /* Copyright (c) Robert Patrick Rankin, 1991              */
   4 /* NetHack may be freely redistributed.  See license for details. */
   5
   6 /* We could include only config.h, except for the overlay definitions... */
   7 #include "hack.h"
   8 /*=
   9     Assorted 'small' utility routines.  They're virtually independent of
  10 NetHack, except that rounddiv may call panic().
  11
  12       return type     routine name    argument type(s)
  13         boolean         digit           (char)
  14         boolean         letter          (char)
  15         char            highc           (char)
  16         char            lowc            (char)
  17         char *          lcase           (char *)
  18         char *          upstart         (char *)
  19         char *          mungspaces      (char *)
  20         char *          eos             (char *)
  21         char *          strkitten       (char *,char)
  22         char *          s_suffix        (const char *)
  23         char *          xcrypt          (const char *, char *)
  24         boolean         onlyspace       (const char *)
  25         char *          tabexpand       (char *)
  26         char *          visctrl         (char)
  27         const char *    ordin           (int)
  28         char *          sitoa           (int)
  29         int             sgn             (int)
  30         int             rounddiv        (long, int)
  31         int             distmin         (int, int, int, int)
  32         int             dist2           (int, int, int, int)
  33         boolean         online2         (int, int)
  34         boolean         pmatch          (const char *, const char *)
  35         int             strncmpi        (const char *, const char *, int)
  36         char *          strstri         (const char *, const char *)
  37         char *  reversestring   (char *)
  38         boolean         fuzzymatch      (const char *,const char *,const char *,boolean)
  39         void            setrandom       (void)
  40         int             getyear         (void)
  41         char *          yymmdd          (time_t)
  42         long            yyyymmdd        (time_t)
  43         int             phase_of_the_moon       (void)
  44         boolean         friday_13th     (void)
  45         int             night           (void)
  46         int             midnight        (void)
  47 =*/
  48 #ifdef LINT
  49 # define Static         /* pacify lint */
  50 #else
  51 # define Static static
  52 #endif
  53
  54 #ifdef OVLB
  55 boolean
  56 digit(c)                /* is 'c' a digit? */
  57     char c;
  58 {
  59     return((boolean)('0' <= c && c <= '9'));
  60 }
  61
  62 boolean
  63 letter(c)               /* is 'c' a letter?  note: '@' classed as letter */
  64     char c;
  65 {
  66     return((boolean)(('@' <= c && c <= 'Z') || ('a' <= c && c <= 'z')));
  67 }
  68 #endif /* OVLB */
  69
  70 #ifdef OVL1
  71 char
  72 highc(c)                        /* force 'c' into uppercase */
  73     char c;
  74 {
  75     return((char)(('a' <= c && c <= 'z') ? (c & ~040) : c));
  76 }
  77
  78 char
  79 lowc(c)                 /* force 'c' into lowercase */
  80     char c;
  81 {
  82     return((char)(('A' <= c && c <= 'Z') ? (c | 040) : c));
  83 }
  84 #endif /* OVL1 */
  85
  86 #ifdef OVLB
  87 char *
  88 lcase(s)                /* convert a string into all lowercase */
  89     char *s;
  90 {
  91     register char *p;
  92
  93     for (p = s; *p; p++)
  94         if ('A' <= *p && *p <= 'Z') *p |= 040;
  95     return s;
  96 }
  97
  98 char *
  99 upstart(s)              /* convert first character of a string to uppercase */
 100     char *s;
 101 {
 102     if (s) *s = highc(*s);
 103     return s;
 104 }
 105
 106 /* remove excess whitespace from a string buffer (in place) */
 107 char *
 108 mungspaces(bp)
 109 char *bp;
 110 {
 111     register char c, *p, *p2;
 112     boolean was_space = TRUE;
 113
 114     for (p = p2 = bp; (c = *p) != '\0'; p++) {
 115         if (c == '\t') c = ' ';
 116         if (c != ' ' || !was_space) *p2++ = c;
 117         was_space = (c == ' ');
 118     }
 119     if (was_space && p2 > bp) p2--;
 120     *p2 = '\0';
 121     return bp;
 122 }
 123
 124 #endif /* OVLB */
 125
 126 #ifdef OVL0
 127 char *
 128 eos(s)                  /* return the end of a string (pointing at '\0') */
 129     register char *s;
 130 {
 131     while (*s) s++;     /* s += strlen(s); */
 132     return s;
 133 }
 134
 135 /* strcat(s, {c,'\0'}); */
 136 char *
 137 strkitten(s, c)         /* append a character to a string (in place) */
 138     char *s;
 139     char c;
 140 {
 141     char *p = eos(s);
 142
 143     *p++ = c;
 144     *p = '\0';
 145     return s;
 146 }
 147
 148 char *
 149 reversestring(char *str)
 150 {
 151       char *p1, *p2;
 152
 153       if (!str || !*str)
 154             return str;
 155       for (p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2)
 156       {
 157             *p1 ^= *p2;
 158             *p2 ^= *p1;
 159             *p1 ^= *p2;
 160       }
 161       return str;
 162 }
 163
 164 char *
 165 s_suffix(s)             /* return a name converted to possessive */
 166     const char *s;
 167 {
 168     Static char buf[BUFSZ];
 169
 170     strcpy(buf, s);
 171     if(!strcmpi(buf, "it"))
 172         strcat(buf, "s");
 173     else if(*(eos(buf)-1) == 's')
 174         strcat(buf, "'");
 175     else
 176         strcat(buf, "'s");
 177     return buf;
 178 }
 179
 180 char *
 181 xcrypt(str, buf)        /* trivial text encryption routine (see makedefs) */
 182 const char *str;
 183 char *buf;
 184 {
 185     register const char *p;
 186     register char *q;
 187     register int bitmask;
 188
 189     for (bitmask = 1, p = str, q = buf; *p; q++) {
 190         *q = *p++;
 191         if (*q & (32|64)) *q ^= bitmask;
 192         if ((bitmask <<= 1) >= 32) bitmask = 1;
 193     }
 194     *q = '\0';
 195     return buf;
 196 }
 197 #endif /* OVL0 */
 198
 199 #ifdef OVL2
 200 boolean
 201 onlyspace(s)            /* is a string entirely whitespace? */
 202     const char *s;
 203 {
 204     for (; *s; s++)
 205         if (*s != ' ' && *s != '\t') return FALSE;
 206     return TRUE;
 207 }
 208 #endif /* OVL2 */
 209
 210 #ifdef OVLB
 211 char *
 212 tabexpand(sbuf)         /* expand tabs into proper number of spaces */
 213     char *sbuf;
 214 {
 215     char buf[BUFSZ];
 216     register char *bp, *s = sbuf;
 217     register int idx;
 218
 219     if (!*s) return sbuf;
 220
 221     /* warning: no bounds checking performed */
 222     for (bp = buf, idx = 0; *s; s++)
 223         if (*s == '\t') {
 224             do *bp++ = ' '; while (++idx % 8);
 225         } else {
 226             *bp++ = *s;
 227             idx++;
 228         }
 229     *bp = 0;
 230     return strcpy(sbuf, buf);
 231 }
 232
 233 char *
 234 visctrl(c)              /* make a displayable string from a character */
 235     char c;
 236 {
 237     Static char ccc[3];
 238
 239     c &= 0177;
 240
 241     ccc[2] = '\0';
 242     if (c < 040) {
 243         ccc[0] = '^';
 244         ccc[1] = c | 0100;      /* letter */
 245     } else if (c == 0177) {
 246         ccc[0] = '^';
 247         ccc[1] = c & ~0100;     /* '?' */
 248     } else {
 249         ccc[0] = c;             /* printable character */
 250         ccc[1] = '\0';
 251     }
 252     return ccc;
 253 }
 254 #endif /* OVLB */
 255
 256 #ifdef OVL2
 257 const char *
 258 ordin(n)                /* return the ordinal suffix of a number */
 259     int n;                      /* note: should be non-negative */
 260 {
 261     register int dd = n % 10;
 262
 263     return (dd == 0 || dd > 3 || (n % 100) / 10 == 1) ? "th" :
 264             (dd == 1) ? "st" : (dd == 2) ? "nd" : "rd";
 265 }
 266 #endif /* OVL2 */
 267
 268 #ifdef OVL1
 269 char *
 270 sitoa(n)                /* make a signed digit string from a number */
 271     int n;
 272 {
 273     Static char buf[13];
 274
 275     sprintf(buf, (n < 0) ? "%d" : "+%d", n);
 276     return buf;
 277 }
 278
 279 int
 280 sgn(n)                  /* return the sign of a number: -1, 0, or 1 */
 281     int n;
 282 {
 283     return (n < 0) ? -1 : (n != 0);
 284 }
 285 #endif /* OVL1 */
 286
 287 #ifdef OVLB
 288 int
 289 rounddiv(x, y)          /* calculate x/y, rounding as appropriate */
 290     long x;
 291     int  y;
 292 {
 293     int r, m;
 294     int divsgn = 1;
 295
 296     if (y == 0)
 297         panic("division by zero in rounddiv");
 298     else if (y < 0) {
 299         divsgn = -divsgn;  y = -y;
 300     }
 301     if (x < 0) {
 302         divsgn = -divsgn;  x = -x;
 303     }
 304     r = x / y;
 305     m = x % y;
 306     if (2*m >= y) r++;
 307
 308     return divsgn * r;
 309 }
 310 #endif /* OVLB */
 311
 312 #ifdef OVL0
 313 int
 314 distmin(x0, y0, x1, y1) /* distance between two points, in moves */
 315     int x0, y0, x1, y1;
 316 {
 317     register int dx = x0 - x1, dy = y0 - y1;
 318     if (dx < 0) dx = -dx;
 319     if (dy < 0) dy = -dy;
 320   /*  The minimum number of moves to get from (x0,y0) to (x1,y1) is the
 321    :  larger of the [absolute value of the] two deltas.
 322    */
 323     return (dx < dy) ? dy : dx;
 324 }
 325
 326 int
 327 dist2(x0, y0, x1, y1)   /* square of euclidean distance between pair of pts */
 328     int x0, y0, x1, y1;
 329 {
 330     register int dx = x0 - x1, dy = y0 - y1;
 331     return dx * dx + dy * dy;
 332 }
 333
 334 boolean
 335 online2(x0, y0, x1, y1) /* are two points lined up (on a straight line)? */
 336     int x0, y0, x1, y1;
 337 {
 338     int dx = x0 - x1, dy = y0 - y1;
 339     /*  If either delta is zero then they're on an orthogonal line,
 340      *  else if the deltas are equal (signs ignored) they're on a diagonal.
 341      */
 342     return((boolean)(!dy || !dx || (dy == dx) || (dy + dx == 0)));      /* (dy == -dx) */
 343 }
 344
 345 #endif /* OVL0 */
 346 #ifdef OVLB
 347
 348 boolean
 349 pmatch(patrn, strng)    /* match a string against a pattern */
 350     const char *patrn, *strng;
 351 {
 352     char s, p;
 353   /*
 354    :  Simple pattern matcher:  '*' matches 0 or more characters, '?' matches
 355    :  any single character.  Returns TRUE if 'strng' matches 'patrn'.
 356    */
 357 pmatch_top:
 358     s = *strng++;  p = *patrn++;        /* get next chars and pre-advance */
 359     if (!p)                     /* end of pattern */
 360         return((boolean)(s == '\0'));           /* matches iff end of string too */
 361     else if (p == '*')          /* wildcard reached */
 362         return((boolean)((!*patrn || pmatch(patrn, strng-1)) ? TRUE :
 363                 s ? pmatch(patrn-1, strng) : FALSE));
 364     else if (p != s && (p != '?' || !s))  /* check single character */
 365         return FALSE;           /* doesn't match */
 366     else                                /* return pmatch(patrn, strng); */
 367         goto pmatch_top;        /* optimize tail recursion */
 368 }
 369 #endif /* OVLB */
 370
 371 #ifdef OVL2
 372 #ifndef STRNCMPI
 373 int
 374 strncmpi(s1, s2, n)     /* case insensitive counted string comparison */
 375     register const char *s1, *s2;
 376     register int n; /*(should probably be size_t, which is usually unsigned)*/
 377 {                                       /*{ aka strncasecmp }*/
 378     register char t1, t2;
 379
 380     while (n--) {
 381         if (!*s2) return (*s1 != 0);    /* s1 >= s2 */
 382         else if (!*s1) return -1;       /* s1  < s2 */
 383         t1 = lowc(*s1++);
 384         t2 = lowc(*s2++);
 385         if (t1 != t2) return (t1 > t2) ? 1 : -1;
 386     }
 387     return 0;                           /* s1 == s2 */
 388 }
 389 #endif  /* STRNCMPI */
 390 #endif /* OVL2 */
 391
 392 #ifdef OVLB
 393 #ifndef STRSTRI
 394
 395 char *
 396 strstri(str, sub)       /* case insensitive substring search */
 397     const char *str;
 398     const char *sub;
 399 {
 400     register const char *s1, *s2;
 401     register int i, k;
 402 # define TABSIZ 0x20    /* 0x40 would be case-sensitive */
 403     char tstr[TABSIZ], tsub[TABSIZ];    /* nibble count tables */
 404 # if 0
 405     assert( (TABSIZ & ~(TABSIZ-1)) == TABSIZ ); /* must be exact power of 2 */
 406     assert( &lowc != 0 );                       /* can't be unsafe macro */
 407 # endif
 408
 409     /* special case: empty substring */
 410     if (!*sub)  return (char *) str;
 411
 412     /* do some useful work while determining relative lengths */
 413     for (i = 0; i < TABSIZ; i++)  tstr[i] = tsub[i] = 0;        /* init */
 414     for (k = 0, s1 = str; *s1; k++)  tstr[*s1++ & (TABSIZ-1)]++;
 415     for (       s2 = sub; *s2; --k)  tsub[*s2++ & (TABSIZ-1)]++;
 416
 417     /* evaluate the info we've collected */
 418     if (k < 0)  return (char *) 0;  /* sub longer than str, so can't match */
 419     for (i = 0; i < TABSIZ; i++)        /* does sub have more 'x's than str? */
 420         if (tsub[i] > tstr[i])  return (char *) 0;  /* match not possible */
 421
 422     /* now actually compare the substring repeatedly to parts of the string */
 423     for (i = 0; i <= k; i++) {
 424         s1 = &str[i];
 425         s2 = sub;
 426         while (lowc(*s1++) == lowc(*s2++))
 427             if (!*s2)  return (char *) &str[i];         /* full match */
 428     }
 429     return (char *) 0;  /* not found */
 430 }
 431 #endif  /* STRSTRI */
 432
 433 /* compare two strings for equality, ignoring the presence of specified
 434    characters (typically whitespace) and possibly ignoring case */
 435 boolean
 436 fuzzymatch(s1, s2, ignore_chars, caseblind)
 437     const char *s1, *s2;
 438     const char *ignore_chars;
 439     boolean caseblind;
 440 {
 441     register char c1, c2;
 442
 443     do {
 444         while ((c1 = *s1++) != '\0' && index(ignore_chars, c1) != 0) continue;
 445         while ((c2 = *s2++) != '\0' && index(ignore_chars, c2) != 0) continue;
 446         if (!c1 || !c2) break;  /* stop when end of either string is reached */
 447
 448         if (caseblind) {
 449             c1 = lowc(c1);
 450             c2 = lowc(c2);
 451         }
 452     } while (c1 == c2);
 453
 454     /* match occurs only when the end of both strings has been reached */
 455     return (boolean)(!c1 && !c2);
 456 }
 457
 458 #endif /* OVLB */
 459 #ifdef OVL2
 460
 461 /*
 462  * Time routines
 463  *
 464  * The time is used for:
 465  *      - seed for rand()
 466  *      - year on tombstone and yyyymmdd in record file
 467  *      - phase of the moon (various monsters react to NEW_MOON or FULL_MOON)
 468  *      - night and midnight (the undead are dangerous at midnight)
 469  *      - determination of what files are "very old"
 470  */
 471
 472 #if defined(AMIGA) && !defined(AZTEC_C) && !defined(__SASC_60) && !defined(_DCC) && !defined(__GNUC__)
 473 extern struct tm *localtime(time_t *);
 474 #endif
 475 struct tm *getlt(void);
 476
 477 void
 478 setrandom()
 479 {
 480         /* the types are different enough here that sweeping the different
 481          * routine names into one via #defines is even more confusing
 482          */
 483 #ifdef RANDOM   /* srandom() from sys/share/random.c */
 484         srandom((unsigned int) time((time_t *)0));
 485 #else
 486 # if defined(BSD) || defined(LINUX) || defined(ULTRIX) || defined(CYGWIN32) /* system srandom() */
 487 #  if defined(BSD) && !defined(POSIX_TYPES)
 488 #   if defined(SUNOS4)
 489         (void)
 490 #   endif
 491                 srandom((int) time((long *)0));
 492 #  else
 493                 srandom((int) time((time_t *)0));
 494 #  endif
 495 # else
 496 #  ifdef UNIX   /* system srand48() */
 497         srand48((long) time((time_t *)0));
 498 #  else         /* poor quality system routine */
 499         srand((int) time((time_t *)0));
 500 #  endif
 501 # endif
 502 #endif
 503 }
 504
 505 struct tm *
 506 getlt()
 507 {
 508         time_t date;
 509
 510 #if defined(BSD) && !defined(POSIX_TYPES)
 511         (void) time((long *)(&date));
 512 #else
 513         (void) time(&date);
 514 #endif
 515 #if (defined(ULTRIX) && !(defined(ULTRIX_PROTO) || defined(NHSTDC))) || (defined(BSD) && !defined(POSIX_TYPES))
 516         return(localtime((long *)(&date)));
 517 #else
 518         return(localtime(&date));
 519 #endif
 520 }
 521
 522 int
 523 getyear()
 524 {
 525         return(1900 + getlt()->tm_year);
 526 }
 527
 528 /* KMH -- Used by gypsies */
 529 int
 530 getmonth()
 531 {
 532         return (getlt()->tm_mon);
 533 }
 534
 535 #if 0
 536 /* This routine is no longer used since in 2000 it will yield "100mmdd". */
 537 char *
 538 yymmdd(date)
 539 time_t date;
 540 {
 541         Static char datestr[10];
 542         struct tm *lt;
 543
 544         if (date == 0)
 545                 lt = getlt();
 546         else
 547 #if (defined(ULTRIX) && !(defined(ULTRIX_PROTO) || defined(NHSTDC))) || defined(BSD)
 548                 lt = localtime((long *)(&date));
 549 #else
 550                 lt = localtime(&date);
 551 #endif
 552
 553         sprintf(datestr, "%02d%02d%02d",
 554                 lt->tm_year, lt->tm_mon + 1, lt->tm_mday);
 555         return(datestr);
 556 }
 557 #endif
 558
 559 long
 560 yyyymmdd(date)
 561 time_t date;
 562 {
 563         long datenum;
 564         struct tm *lt;
 565
 566         if (date == 0)
 567                 lt = getlt();
 568         else
 569 #if (defined(ULTRIX) && !(defined(ULTRIX_PROTO) || defined(NHSTDC))) || (defined(BSD) && !defined(POSIX_TYPES))
 570                 lt = localtime((long *)(&date));
 571 #else
 572                 lt = localtime(&date);
 573 #endif
 574
 575         /* just in case somebody's localtime supplies (year % 100)
 576            rather than the expected (year - 1900) */
 577         if (lt->tm_year < 70)
 578             datenum = (long)lt->tm_year + 2000L;
 579         else
 580             datenum = (long)lt->tm_year + 1900L;
 581         /* yyyy --> yyyymm */
 582         datenum = datenum * 100L + (long)(lt->tm_mon + 1);
 583         /* yyyymm --> yyyymmdd */
 584         datenum = datenum * 100L + (long)lt->tm_mday;
 585         return datenum;
 586 }
 587
 588 /*
 589  * moon period = 29.53058 days ~= 30, year = 365.2422 days
 590  * days moon phase advances on first day of year compared to preceding year
 591  *      = 365.2422 - 12*29.53058 ~= 11
 592  * years in Metonic cycle (time until same phases fall on the same days of
 593  *      the month) = 18.6 ~= 19
 594  * moon phase on first day of year (epact) ~= (11*(year%19) + 29) % 30
 595  *      (29 as initial condition)
 596  * current phase in days = first day phase + days elapsed in year
 597  * 6 moons ~= 177 days
 598  * 177 ~= 8 reported phases * 22
 599  * + 11/22 for rounding
 600  */
 601 int
 602 phase_of_the_moon()             /* 0-7, with 0: new, 4: full */
 603 {
 604         register struct tm *lt = getlt();
 605         register int epact, diy, goldn;
 606
 607         diy = lt->tm_yday;
 608         goldn = (lt->tm_year % 19) + 1;
 609         epact = (11 * goldn + 18) % 30;
 610         if ((epact == 25 && goldn > 11) || epact == 24)
 611                 epact++;
 612
 613         return( (((((diy + epact) * 6) + 11) % 177) / 22) & 7 );
 614 }
 615
 616 boolean
 617 friday_13th()
 618 {
 619         register struct tm *lt = getlt();
 620
 621         return((boolean)(lt->tm_wday == 5 /* friday */ && lt->tm_mday == 13));
 622 }
 623
 624 boolean
 625 groundhog_day()
 626 {
 627         register struct tm *lt = getlt();
 628
 629         /* KMH -- Groundhog Day is February 2 */
 630         return((boolean)(lt->tm_mon == 1 && lt->tm_mday == 2));
 631 }
 632
 633 int
 634 night()
 635 {
 636         register int hour = getlt()->tm_hour;
 637
 638         return(hour < 6 || hour > 21);
 639 }
 640
 641 int
 642 midnight()
 643 {
 644         return(getlt()->tm_hour == 0);
 645 }
 646 #endif /* OVL2 */
 647
 648 /*hacklib.c*/