toolchain/gcc/libiberty/mpw.c

   1 /* MPW-Unix compatibility library.
   2    Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
   3
   4 This file is part of the libiberty library.
   5 Libiberty is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public
   7 License as published by the Free Software Foundation; either
   8 version 2 of the License, or (at your option) any later version.
   9
  10 Libiberty 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 GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with libiberty; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.  */
  19
  20 /* This should only be compiled and linked under MPW. */
  21
  22 #include "mpw.h"
  23
  24 #include <stdlib.h>
  25
  26 #ifndef USE_MW_HEADERS
  27 #include <sys/time.h>
  28 #include <sys/resource.h>
  29 #endif
  30
  31 #include <Types.h>
  32 #include <Files.h>
  33
  34 #include <Timer.h>
  35
  36 /* Initialize to 0 at first, then set to errno_max() later.  */
  37
  38 int sys_nerr = 0;
  39
  40 /* Debug flag for pathname hacking.  Set this to one and rebuild. */
  41
  42 int DebugPI = -1;
  43
  44 void
  45 mpwify_filename(char *unixname, char *macname)
  46 {
  47   int i, j;
  48
  49   /* (should truncate 255 chars from end of name, not beginning) */
  50   if (strlen (unixname) > 255)
  51     {
  52       fprintf (stderr, "Pathname \"%s\" is too long for Macs, truncating\n",
  53                unixname);
  54     }
  55   j = 0;
  56   /* If you're going to end up with one or more colons in the middle of a
  57      path after an all-Unix relative path is translated, you must add a
  58      colon on the front, so that the first component is not thought to be
  59      a disk name.  */
  60   if (unixname[0] != '/' && ! strchr (unixname, ':') && strchr (unixname, '/'))
  61     {
  62       macname[j++] = ':';
  63     }
  64   for (i = 0; unixname[i] != '\0' && i < 255; ++i)
  65     {
  66       if (i == 0 && unixname[i] == '/')
  67         {
  68           if (strncmp (unixname, "/tmp/", 5) == 0)
  69             {
  70               /* A temporary name, make a more Mac-flavored tmpname. */
  71               /* A better choice would be {Boot}Trash:foo, but
  72                  that would require being able to identify the
  73                  boot disk's and trashcan's name.  Another option
  74                  would be to have an env var, so user can point it
  75                  at a ramdisk. */
  76               macname[j++] = ':';
  77               macname[j++] = 't';
  78               macname[j++] = 'm';
  79               macname[j++] = 'p';
  80               macname[j++] = '_';
  81               i += 4;
  82             }
  83           else
  84             {
  85               /* Don't copy the leading slash. */
  86             }
  87         }
  88       else if (unixname[i] == ':' && unixname[i+1] == '/')
  89         {
  90           macname[j++] = ':';
  91           i += 1;
  92         }
  93       else if (unixname[i] == '.' && unixname[i+1] == '/')
  94         {
  95           macname[j++] = ':';
  96           i += 1;
  97         }
  98       else if (unixname[i] == '.' && unixname[i+1] == '.' && unixname[i+2] == '/')
  99         {
 100           macname[j++] = ':';
 101           macname[j++] = ':';
 102           i += 2;
 103         }
 104       else if (unixname[i] == '/')
 105         {
 106           macname[j++] = ':';
 107         }
 108       else
 109         {
 110           macname[j++] = unixname[i];
 111         }
 112     }
 113   macname[j] = '\0';
 114   /* Allow for getting the debug flag from an env var; quite useful. */
 115   if (DebugPI < 0)
 116     DebugPI = (*(getenv ("DEBUG_PATHNAMES")) == '1' ? 1 : 0);
 117   if (DebugPI)
 118     {
 119       fprintf (stderr, "# Made \"%s\"\n", unixname);
 120       fprintf (stderr, "# into \"%s\"\n", macname);
 121     }
 122 }
 123
 124 /* MPW-flavored basename finder. */
 125
 126 char *
 127 mpw_basename (name)
 128   char *name;
 129 {
 130   char *base = name;
 131
 132   while (*name)
 133     {
 134       if (*name++ == ':')
 135         {
 136           base = name;
 137         }
 138     }
 139   return base;
 140 }
 141
 142 /* Mixed MPW/Unix basename finder.  This can be led astray by
 143    filenames with slashes in them and come up with a basename that
 144    either corresponds to no file or (worse) to some other file, so
 145    should only be tried if other methods of finding a file via a
 146    basename have failed.  */
 147
 148 char *
 149 mpw_mixed_basename (name)
 150   char *name;
 151 {
 152   char *base = name;
 153
 154   while (*name)
 155     {
 156       if (*name == '/' || *name == ':')
 157         {
 158           base = name + 1;
 159         }
 160       ++name;
 161     }
 162   return base;
 163 }
 164
 165 /* This function is fopen() modified to create files that are type TEXT
 166    or 'BIN ', and always of type 'MPS '.  */
 167
 168 FILE *
 169 mpw_fopen (char *name, char *mode)
 170 {
 171 #undef fopen
 172   int errnum;
 173   FILE *fp;
 174   char tmpname[256];
 175
 176   mpwify_filename (name, tmpname);
 177   PROGRESS (1);
 178   fp = fopen (tmpname, mode);
 179   errnum = errno;
 180
 181   /* If writing, need to set type and creator usefully. */
 182   if (strchr (mode, 'w'))
 183     {
 184       char *pname = (char *) malloc (strlen (tmpname) + 2);
 185       OSErr e;
 186       struct FInfo fi;
 187
 188       pname[0] = strlen (tmpname);
 189       strcpy (pname+1, tmpname);
 190
 191       e = GetFInfo ((ConstStr255Param) pname, 0, &fi);
 192       /* should do spiffier error handling */
 193       if (e != 0)
 194         fprintf(stderr, "GetFInfo returns %d\n", e);
 195       if (strchr (mode, 'b'))
 196         {
 197           fi.fdType = (OSType) 'BIN ';
 198         }
 199       else
 200         {
 201           fi.fdType = (OSType) 'TEXT';
 202         }
 203       fi.fdCreator = (OSType) 'MPS ';
 204       e = SetFInfo ((ConstStr255Param) pname, 0, &fi);
 205       if (e != 0)
 206         fprintf(stderr, "SetFInfo returns %d\n", e);
 207       free (pname);
 208     }
 209   if (fp == NULL)
 210     errno = errnum;
 211   return fp;
 212 }
 213
 214 /* This is a version of fseek() modified to fill the file with zeros
 215    if seeking past the end of it.  */
 216
 217 #define ZEROBLKSIZE 4096
 218
 219 char zeros[ZEROBLKSIZE];
 220
 221 int
 222 mpw_fseek (FILE *fp, int offset, int whence)
 223 {
 224 #undef fseek
 225   int cursize, numleft;
 226
 227   PROGRESS (1);
 228   if (whence == SEEK_SET)
 229     {
 230       fseek (fp, 0, SEEK_END);
 231       cursize = ftell (fp);
 232       if (offset > cursize)
 233         {
 234           numleft = offset - cursize;
 235           while (numleft > ZEROBLKSIZE)
 236             {
 237               /* This might fail, should check for that. */
 238               PROGRESS (1);
 239               fwrite (zeros, 1, ZEROBLKSIZE, fp);
 240               numleft -= ZEROBLKSIZE;
 241             }
 242           PROGRESS (1);
 243           fwrite (zeros, 1, numleft, fp);
 244           fflush (fp);
 245         }
 246     }
 247   return fseek (fp, offset, whence);
 248 }
 249
 250 int
 251 mpw_fread (char *ptr, int size, int nitems, FILE *stream)
 252 {
 253 #undef fread
 254   int rslt;
 255
 256   PROGRESS (1);
 257   rslt = fread (ptr, size, nitems, stream);
 258   PROGRESS (1);
 259   return rslt;
 260 }
 261
 262 int
 263 mpw_fwrite (char *ptr, int size, int nitems, FILE *stream)
 264 {
 265 #undef fwrite
 266   int rslt;
 267
 268   PROGRESS (1);
 269   rslt = fwrite (ptr, size, nitems, stream);
 270   PROGRESS (1);
 271   return rslt;
 272 }
 273
 274 int
 275 link ()
 276 {
 277   fprintf (stderr, "link not available!\n");
 278   mpw_abort ();
 279 }
 280
 281 int
 282 fork ()
 283 {
 284   fprintf (stderr, "fork not available!\n");
 285   mpw_abort ();
 286 }
 287
 288 int
 289 vfork ()
 290 {
 291   fprintf (stderr, "vfork not available!\n");
 292   mpw_abort ();
 293   return (-1);
 294 }
 295
 296 int
 297 pipe (int *fd)
 298 {
 299   fprintf (stderr, "pipe not available!\n");
 300   mpw_abort ();
 301   return (-1);
 302 }
 303
 304 #ifndef USE_MW_HEADERS
 305 int
 306 execvp (char *file, char **argv)
 307 {
 308   fprintf (stderr, "execvp not available!\n");
 309   mpw_abort ();
 310   return (-1);
 311 }
 312
 313 int
 314 execv (char *path, char **argv)
 315 {
 316   fprintf (stderr, "execv not available!\n");
 317   mpw_abort ();
 318   return (-1);
 319 }
 320 #endif
 321
 322 int
 323 kill (int pid, int sig)
 324 {
 325   fprintf (stderr, "kill not available!\n");
 326   mpw_abort ();
 327   return (-1);
 328 }
 329
 330 int
 331 wait (int *status)
 332 {
 333   *status = 0;
 334   return 0;
 335 }
 336
 337 #ifndef USE_MW_HEADERS
 338 int
 339 sleep (int seconds)
 340 {
 341   unsigned long start_time, now;
 342
 343   time (&start_time);
 344
 345   while (1)
 346     {
 347       PROGRESS (1);
 348       time (&now);
 349       if (now > start_time + seconds)
 350         return 0;
 351     }
 352 }
 353 #endif
 354
 355 void
 356 putenv (char *str)
 357 {
 358   /* The GCC driver calls this to do things for collect2, but we
 359      don't care about collect2. */
 360 }
 361
 362 int
 363 chmod (char *path, int mode)
 364 {
 365   /* Pretend it was all OK. */
 366   return 0;
 367 }
 368
 369 #ifndef USE_MW_HEADERS
 370 int
 371 getuid ()
 372 {
 373   /* One value is as good as another... */
 374   return 0;
 375 }
 376
 377 int
 378 getgid ()
 379 {
 380   /* One value is as good as another... */
 381   return 0;
 382 }
 383 #endif
 384
 385 /* Instead of coredumping, which is not a normal Mac facility, we
 386    drop into Macsbug.  If we then "g" from Macsbug, the program will
 387    exit cleanly. */
 388
 389 void
 390 mpw_abort ()
 391 {
 392   /* Make sure no output still buffered up, then zap into MacsBug. */
 393   fflush(stdout);
 394   fflush(stderr);
 395   printf("## Abort! ##\n");
 396 #ifdef MPW_SADE
 397   SysError(8005);
 398 #else
 399   Debugger();
 400 #endif
 401   /* "g" in MacsBug will then cause a regular error exit. */
 402   exit (1);
 403 }
 404
 405 /* Imitation getrusage based on the ANSI clock() function. */
 406
 407 int
 408 getrusage (int who, struct rusage *rusage)
 409 {
 410   int clk = clock ();
 411
 412 #if 0
 413   rusage->ru_utime.tv_sec = clk / CLOCKS_PER_SEC;
 414   rusage->ru_utime.tv_usec = ((clk * 1000) / CLOCKS_PER_SEC) * 1000;
 415   rusage->ru_stime.tv_sec = 0;
 416   rusage->ru_stime.tv_usec = 0;
 417 #endif
 418 }
 419
 420 int
 421 sbrk ()
 422 {
 423   return 0;
 424 }
 425
 426 #ifndef USE_MW_HEADERS
 427 int
 428 isatty (int fd)
 429 {
 430   return 0;
 431 }
 432
 433 /* This is inherited from Timothy Murray's Posix library. */
 434
 435 #include "utime.h"
 436
 437 int
 438 utime (char *filename, struct utimbuf *times)
 439 {
 440   CInfoPBRec cipbr;
 441   HFileInfo *fpb = (HFileInfo *) &cipbr;
 442   DirInfo *dpb = (DirInfo *) &cipbr;
 443   unsigned char pname[256];
 444   short err;
 445
 446   strcpy ((char *) pname, filename);
 447   c2pstr (pname);
 448
 449   dpb->ioDrDirID = 0L;
 450   fpb->ioNamePtr = pname;
 451   fpb->ioVRefNum = 0;
 452   fpb->ioFDirIndex = 0;
 453   fpb->ioFVersNum = 0;
 454   err = PBGetCatInfo (&cipbr, 0);
 455   if (err != noErr) {
 456     errno = ENOENT;
 457     return -1;
 458   }
 459   dpb->ioDrDirID = 0L;
 460   fpb->ioFlMdDat = times->modtime;
 461   fpb->ioFlCrDat = times->actime;
 462   err = PBSetCatInfo (&cipbr, 0);
 463   if (err != noErr) {
 464     errno = EACCES;
 465     return -1;
 466   }
 467   return 0;
 468 }
 469
 470 int
 471 mkdir (char *path, int mode)
 472 {
 473   errno = ENOSYS;
 474   return -1;
 475 }
 476
 477 int
 478 rmdir ()
 479 {
 480   errno = ENOSYS;
 481   return -1;
 482 }
 483 #endif
 484
 485 chown ()
 486 {
 487   errno = ENOSYS;
 488   return -1;
 489 }
 490
 491 char *myenviron[] = {NULL};
 492
 493 char **environ = myenviron;
 494
 495 #ifndef USE_MW_HEADERS
 496
 497 /* Minimal 'stat' emulation: tells directories from files and
 498    gives length and mtime.
 499
 500    Derived from code written by Guido van Rossum, CWI, Amsterdam
 501    and placed by him in the public domain.  */
 502
 503 extern int __uid, __gid;
 504
 505 int __uid = 0;
 506 int __gid = 0;
 507
 508 /* Bits in ioFlAttrib: */
 509 #define LOCKBIT (1<<0)          /* File locked */
 510 #define DIRBIT  (1<<4)          /* It's a directory */
 511
 512 /* Macified "stat" in which filename is given relative to a directory,
 513    specified by long DirID.  */
 514
 515 static int
 516 _stat (char *name, long dirid, struct stat *buf)
 517 {
 518   CInfoPBRec cipbr;
 519   HFileInfo *fpb = (HFileInfo*) &cipbr;
 520   DirInfo *dpb = (DirInfo*) &cipbr;
 521   Str255 pname;
 522   short err;
 523
 524   /* Make a temp copy of the name and pascalize. */
 525   strcpy ((char *) pname, name);
 526   c2pstr (pname);
 527
 528   cipbr.dirInfo.ioDrDirID = dirid;
 529   cipbr.hFileInfo.ioNamePtr = pname;
 530   cipbr.hFileInfo.ioVRefNum = 0;
 531   cipbr.hFileInfo.ioFDirIndex = 0;
 532   cipbr.hFileInfo.ioFVersNum = 0;
 533   err = PBGetCatInfo (&cipbr, 0);
 534   if (err != noErr)
 535     {
 536       errno = ENOENT;
 537       return -1;
 538     }
 539   /* Mac files are readable if they can be accessed at all. */
 540   buf->st_mode = 0444;
 541   /* Mark unlocked files as writeable. */
 542   if (!(fpb->ioFlAttrib & LOCKBIT))
 543     buf->st_mode |= 0222;
 544   if (fpb->ioFlAttrib & DIRBIT)
 545     {
 546       /* Mark directories as "executable". */
 547       buf->st_mode |= 0111 | S_IFDIR;
 548       buf->st_size = dpb->ioDrNmFls;
 549       buf->st_rsize = 0;
 550     }
 551   else
 552     {
 553       buf->st_mode |= S_IFREG;
 554       /* Mark apps as "executable". */
 555       if (fpb->ioFlFndrInfo.fdType == 'APPL')
 556         buf->st_mode |= 0111;
 557       /* Fill in the sizes of data and resource forks. */
 558       buf->st_size = fpb->ioFlLgLen;
 559       buf->st_rsize = fpb->ioFlRLgLen;
 560     }
 561   /* Fill in various times. */
 562   buf->st_atime = fpb->ioFlCrDat;
 563   buf->st_mtime = fpb->ioFlMdDat;
 564   buf->st_ctime = fpb->ioFlCrDat;
 565   /* Set up an imitation inode number. */
 566   buf->st_ino = (unsigned short) fpb->ioDirID;
 567   /* Set up an imitation device. */
 568   GetVRefNum (buf->st_ino, &buf->st_dev);
 569   buf->st_uid = __uid;
 570   buf->st_gid = __gid;
 571 /*  buf->st_FlFndrInfo = fpb->ioFlFndrInfo;  */
 572   return 0;
 573 }
 574
 575 /* stat() sets up an empty dirid. */
 576
 577 int
 578 stat (char *path, struct stat *buf)
 579 {
 580   long rslt, errnum;
 581   char tmpname[256];
 582
 583   mpwify_filename (path, tmpname);
 584   if (DebugPI)
 585     fprintf (stderr, "# stat (%s, %x)", tmpname, buf);
 586   PROGRESS (1);
 587   rslt = _stat (tmpname, 0L, buf);
 588   errnum = errno;
 589   if (DebugPI)
 590     {
 591       fprintf (stderr, " -> %d", rslt);
 592       if (rslt != 0)
 593         fprintf (stderr, " (errno is %d)", errnum);
 594       fprintf (stderr, "\n");
 595       fflush (stderr);
 596     }
 597   if (rslt != 0)
 598     errno = errnum;
 599   return rslt;
 600 }
 601
 602 int
 603 fstat (int fd, struct stat *buf)
 604 {
 605   FCBPBRec fcb;
 606   FILE *fp;
 607   Str255 pathname;
 608   long dirid = 0L, temp;
 609   long rslt, errnum;
 610   short err;
 611
 612   if (DebugPI < 0)
 613     DebugPI = (*(getenv ("DEBUG_PATHNAMES")) == '1' ? 1 : 0);
 614   if (DebugPI)
 615     fprintf (stderr, "# fstat (%d, %x)", fd, buf);
 616   PROGRESS (1);
 617   pathname[0] = 0;
 618 #ifdef FIOFNAME
 619   /* Use an MPW-specific ioctl to get the pathname associated with
 620      the file descriptor.  */
 621   ioctl (fd, FIOFNAME, (long *) pathname);
 622 #else
 623   you lose
 624 #endif
 625   if (DebugPI)
 626     fprintf (stderr, " (name is %s)", pathname);
 627   dirid = 0L /* fcb.ioFCBParID */ ;
 628   rslt = _stat ((char *) pathname, dirid, buf);
 629   errnum = errno;
 630   if (DebugPI)
 631     {
 632       fprintf (stderr, " -> %d", rslt);
 633       if (rslt != 0)
 634         fprintf (stderr, " (errno is %d)", errnum);
 635       fprintf (stderr, "\n");
 636       fflush (stderr);
 637     }
 638   if (rslt != 0)
 639     errno = errnum;
 640   return rslt;
 641 }
 642
 643 #endif /* n USE_MW_HEADERS */
 644
 645 chdir ()
 646 {
 647   errno = ENOSYS;
 648   return (-1);
 649 }
 650
 651 char *
 652 getcwd (char *buf, int size)
 653 {
 654   if (buf == NULL)
 655     buf = (char *) malloc (size);
 656   strcpy(buf, ":");
 657   return buf;
 658 }
 659
 660 /* This should probably be more elaborate for MPW. */
 661
 662 char *
 663 getpwd ()
 664 {
 665   return ":";
 666 }
 667
 668 int
 669 mpw_open (char *filename, int arg2, int arg3)
 670 {
 671 #undef open
 672   int fd, errnum = 0;
 673   char tmpname[256];
 674
 675   mpwify_filename (filename, tmpname);
 676   fd = open (tmpname, arg2);
 677   errnum = errno;
 678
 679   if (DebugPI)
 680     {
 681       fprintf (stderr, "# open (%s, %d, %d)", tmpname, arg2, arg3);
 682       fprintf (stderr, " -> %d", fd);
 683       if (fd == -1)
 684         fprintf (stderr, " (errno is %d)", errnum);
 685       fprintf (stderr, "\n");
 686     }
 687   if (fd == -1)
 688     errno = errnum;
 689   return fd;
 690 }
 691
 692 int
 693 mpw_access (char *filename, unsigned int cmd)
 694 {
 695 #undef access
 696
 697   int rslt, errnum = 0;
 698   struct stat st;
 699   char tmpname[256];
 700
 701   mpwify_filename (filename, tmpname);
 702   if (cmd & R_OK || cmd & X_OK)
 703     {
 704       rslt = stat (tmpname, &st);
 705       errnum = errno;
 706       if (rslt >= 0)
 707         {
 708           if ((((st.st_mode & 004) == 0) && (cmd & R_OK))
 709               || (((st.st_mode & 002) == 0) && (cmd & W_OK))
 710               || (((st.st_mode & 001) == 0) && (cmd & X_OK)))
 711             {
 712               rslt = -1;
 713               errnum = EACCES;
 714             }
 715         }
 716     }
 717   if (DebugPI)
 718     {
 719       fprintf (stderr, "# mpw_access (%s, %d)", tmpname, cmd);
 720       fprintf (stderr, " -> %d", rslt);
 721       if (rslt != 0)
 722         fprintf (stderr, " (errno is %d)", errnum);
 723       fprintf (stderr, "\n");
 724     }
 725   if (rslt != 0)
 726     errno = errnum;
 727   return rslt;
 728 }
 729
 730 /* The MPW library creat() has no mode argument. */
 731
 732 int
 733 mpw_creat (char *path, /* mode_t */ int mode)
 734 {
 735 #undef creat
 736
 737 #ifdef USE_MW_HEADERS
 738   return creat (path, mode);
 739 #else
 740   return creat (path);
 741 #endif
 742 }
 743
 744 /* This is a hack to get control in an MPW tool before it crashes the
 745    machine.  */
 746
 747 mpw_special_init (name)
 748      char *name;
 749 {
 750   if (strstr (name, "DEBUG"))
 751     DebugStr("\pat beginning of program");
 752 }
 753
 754 static int current_umask;
 755
 756 int
 757 umask(int mask)
 758 {
 759   int oldmask = current_umask;
 760
 761   current_umask = mask;
 762   return oldmask;
 763 }
 764
 765 /* Cursor-spinning stuff that includes metering of spin rate and delays.  */
 766
 767 /* Nonzero when cursor spinning has been set up properly.  */
 768
 769 int cursor_inited;
 770
 771 /* Nonzero if spin should be measured and excessive delays reported.  */
 772
 773 int measure_spin;
 774
 775 /* Nonzero if spin histogram and rate data should be written out.  */
 776
 777 int dump_spin_data;
 778
 779 long warning_threshold = 400000;
 780
 781 long bucket_size = 1024;
 782
 783 long bucket_power = 10;
 784
 785 long numbuckets = 300;
 786
 787 int *delay_counts;
 788
 789 int overflow_count;
 790
 791 char *current_progress;
 792
 793 static UnsignedWide last_microseconds;
 794
 795 static char *last_spin_file = "";
 796
 797 static int last_spin_line;
 798
 799 void
 800 warn_if_spin_delay (char *file, int line)
 801 {
 802   long diff, ix;
 803   UnsignedWide now;
 804
 805   Microseconds(&now);
 806
 807   diff = now.lo - last_microseconds.lo;
 808
 809   if (diff > warning_threshold)
 810     fprintf (stderr, "# %s: %ld.%06ld sec delay getting from %s:%d to %s:%d\n",
 811              (current_progress ? current_progress : ""),
 812              diff / 1000000, diff % 1000000,
 813              last_spin_file, last_spin_line, file, line);
 814   if (dump_spin_data)
 815     {
 816       if (diff >= 0)
 817         {
 818           ix = diff >> bucket_power;
 819           if (ix >= 0 && ix < numbuckets && delay_counts != NULL)
 820             ++delay_counts[ix];
 821           else
 822             ++overflow_count;
 823         }
 824       else
 825         fprintf (stderr, "raw diff is %ld (?)\n", diff);
 826     }
 827 }
 828
 829 void
 830 record_for_spin_delay (char *file, int line)
 831 {
 832   Microseconds (&last_microseconds);
 833   last_spin_file = file;
 834   last_spin_line = line;
 835 }
 836
 837 void
 838 mpw_start_progress (char *str, int n, char *file, int line)
 839 {
 840   int i;
 841   char *measure, *threshold;
 842
 843   if (!cursor_inited)
 844     {
 845       InitCursorCtl (nil);
 846       cursor_inited = 1;
 847       record_for_spin_delay (file, line);
 848       measure = getenv ("MEASURE_SPIN");
 849       if (measure != NULL && measure[0] != '\0')
 850         {
 851           measure_spin = 1;
 852           if (strcmp (measure, "all") == 0)
 853             dump_spin_data = 1;
 854         }
 855       threshold = getenv ("SPIN_WARN_THRESHOLD");
 856       if (threshold != NULL && threshold[0] != '\0')
 857         warning_threshold = atol (threshold);
 858       if (dump_spin_data)
 859         {
 860           if (delay_counts == NULL)
 861             delay_counts = (int *) malloc (numbuckets * sizeof (int));
 862           for (i = 0; i < numbuckets; ++i)
 863             delay_counts[i] = 0;
 864           overflow_count = 0;
 865         }
 866     }
 867   current_progress = str;
 868
 869   sys_nerr = errno_max ();
 870
 871   mpw_special_init (str);
 872 }
 873
 874 void
 875 mpw_progress (int n)
 876 {
 877   SpinCursor (32);
 878 }
 879
 880 void
 881 mpw_progress_measured (int n, char *file, int line)
 882 {
 883   if (measure_spin)
 884     warn_if_spin_delay (file, line);
 885   SpinCursor (32);
 886   if (measure_spin)
 887     record_for_spin_delay (file, line);
 888 }
 889
 890 void
 891 mpw_end_progress (char *str, char *file, int line)
 892 {
 893   long i, delay, count = 0, sum = 0, avgdelay, spinrate;
 894   long curpower = 0, curgroup = 0;
 895
 896   /* Warn if it's been a while since the last spin.  */
 897   if (measure_spin)
 898     warn_if_spin_delay (file, line);
 899
 900   /* Dump all the nonzero delay counts and an approximation of the delay.  */
 901   if (dump_spin_data && delay_counts != NULL)
 902     {
 903       for (i = 0; i < numbuckets; ++i)
 904         {
 905           delay = (i + 1) * bucket_size;
 906           sum += delay_counts[i] * (i + 1);
 907           count += delay_counts[i];
 908           if (delay <= (1 << curpower))
 909             {
 910               curgroup += delay_counts[i];
 911             }
 912           else
 913             {
 914               if (curgroup > 0)
 915                 fprintf (stderr,
 916                          "# %s: %d delays between %ld.%06ld and %ld.%06ld sec\n",
 917                          (str ? str : ""),
 918                          curgroup,
 919                          (1 << curpower) / 1000000,
 920                          (1 << curpower) % 1000000,
 921                          (1 << (curpower + 1)) / 1000000,
 922                          (1 << (curpower + 1)) % 1000000);
 923               ++curpower;
 924               curgroup = 0;
 925             }
 926         }
 927       if (count > 0)
 928         {
 929           avgdelay = (sum * bucket_size) / count;
 930           spinrate = 1000000 / avgdelay;
 931           fprintf (stderr, "# %s: Average spin rate is %d times/sec\n",
 932                    (str ? str : ""), spinrate);
 933         }
 934     }
 935 }
 936
 937 #ifdef PROGRESS_TEST
 938
 939 /* Test program.  */
 940
 941 main ()
 942 {
 943   int i, j;
 944   double x = 1.0, y = 2.4;
 945   long start = Microseconds (), tm;  FIXME
 946
 947   START_PROGRESS ("hi", 0);
 948
 949   for (i = 0; i < 1000; ++i)
 950     {
 951       PROGRESS (1);
 952
 953       for (j = 0; j < (i * 100); ++j)
 954         {
 955           x += (x * y) / j;
 956         }
 957     }
 958
 959   END_PROGRESS ("hi");
 960
 961   tm = Microseconds () - start;
 962
 963   printf ("Total time is %d.%d secs\n", tm / 1000000, tm % 1000000);
 964 }
 965
 966 #endif
 967
 968 #ifdef USE_MW_HEADERS
 969 /* Empty definitions for Metrowerks' SIOUX console library. */
 970
 971 #ifndef __CONSOLE__
 972 #include <console.h>
 973 #endif
 974
 975 short
 976 InstallConsole(short fd)
 977 {
 978 #pragma unused (fd)
 979         return 0;
 980 }
 981
 982 void
 983 RemoveConsole(void)
 984 {
 985 }
 986
 987 long
 988 WriteCharsToConsole(char *buf, long n)
 989 {
 990 #pragma unused (buf, n)
 991         return 0;
 992 }
 993
 994 long ReadCharsFromConsole(char *buf, long n)
 995 {
 996 #pragma unused (buf, n)
 997         return 0;
 998 }
 999
1000 extern char *
1001 __ttyname(long fd)
1002 {
1003         static char *__devicename = "null device";
1004
1005         if (fd >= 0 && fd <= 2)
1006           return (__devicename);
1007         return NULL;
1008 }
1009
1010 #endif