home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_0399 / 93 / mlib28d.zoo / diffc next >
Encoding:
Text File  |  1993-02-19  |  29.4 KB  |  1,099 lines
  1. diff -c ../mntlib27/a64l.c ./a64l.c
  2. *** ../mntlib27/a64l.c    Thu Jan 14 10:37:02 1993
  3. --- ./a64l.c    Sat Feb 13 03:45:54 1993
  4. ***************
  5. *** 14,19 ****
  6. --- 14,20 ----
  7.       a64l, l64a - convert between long integer and base-64 ASCII string
  8.   
  9.   SYNOPSIS
  10. +     #include <support.h>
  11.       long a64l(const char *s);
  12.       char *l64a(long l);
  13.   
  14. diff -c ../mntlib27/access.c ./access.c
  15. *** ../mntlib27/access.c    Sat Sep  5 07:03:50 1992
  16. --- ./access.c    Sat Feb 13 10:17:54 1993
  17. ***************
  18. *** 20,29 ****
  19.       if (mode == F_OK)
  20.           return 0;    /* existence test succeeded */
  21.   
  22.   /* somewhat crufty code -- relies on R_OK, etc. matching the bits in the
  23.      file mode, but what the heck, we can do this
  24.    */
  25. !     if (__mint < 9 || ( geteuid() == sb.st_uid ) ) {
  26.           if ( ((sb.st_mode >> 6) & mode) == mode )
  27.               return 0;
  28.           else
  29. --- 20,31 ----
  30.       if (mode == F_OK)
  31.           return 0;    /* existence test succeeded */
  32.   
  33. +     if (getuid() == 0) return 0; /* super user can access anything */
  34. + 
  35.   /* somewhat crufty code -- relies on R_OK, etc. matching the bits in the
  36.      file mode, but what the heck, we can do this
  37.    */
  38. !     if (__mint < 9 || ( getuid() == sb.st_uid ) ) {
  39.           if ( ((sb.st_mode >> 6) & mode) == mode )
  40.               return 0;
  41.           else
  42. ***************
  43. *** 30,36 ****
  44.               goto accdn;
  45.       }
  46.   
  47. !     if ( getegid() == sb.st_gid ) {
  48.           if ( ((sb.st_mode >> 3) & mode) == mode )
  49.               return 0;
  50.           else
  51. --- 32,38 ----
  52.               goto accdn;
  53.       }
  54.   
  55. !     if ( getgid() == sb.st_gid ) {
  56.           if ( ((sb.st_mode >> 3) & mode) == mode )
  57.               return 0;
  58.           else
  59. diff -c ../mntlib27/alarm.c ./alarm.c
  60. *** ../mntlib27/alarm.c    Sat Sep  5 07:11:32 1992
  61. --- ./alarm.c    Fri Feb 19 09:25:30 1993
  62. ***************
  63. *** 4,9 ****
  64. --- 4,10 ----
  65.   
  66.   #include <errno.h>
  67.   #include <mintbind.h>
  68. + #include <limits.h>
  69.   
  70.   extern int __mint;
  71.   
  72. ***************
  73. *** 14,26 ****
  74.       long r;
  75.   
  76.       if (__mint == 0)
  77. !         r = -EINVAL;
  78. !     else
  79. !         r = Talarm((long)secs);
  80.   
  81. -     if (r < 0) {
  82. -         errno = - (int)r;
  83. -         r = -1;
  84. -     }
  85.       return (unsigned int) r;
  86.   }
  87. --- 15,26 ----
  88.       long r;
  89.   
  90.       if (__mint == 0)
  91. !         return 0;
  92. ! #ifndef __MSHORT__
  93. !     if (secs > ((unsigned int) (LONG_MAX/1000)))
  94. !         secs = ((unsigned int) (LONG_MAX/1000));
  95. ! #endif
  96. !     r = Talarm((long) secs);
  97.   
  98.       return (unsigned int) r;
  99.   }
  100. diff -c ../mntlib27/bugs ./bugs
  101. *** ../mntlib27/bugs    Wed Feb 10 07:11:42 1993
  102. --- ./bugs    Fri Feb 19 09:18:44 1993
  103. ***************
  104. *** 18,74 ****
  105.     up at some time, i.e. do we stop supporting MiNT before 0.8 or 0.9?
  106.     Some obvious candidates are killpg.c and unx2dos.c.
  107.   
  108. ! a64l.c: ++boender
  109. !   Include `#include <support.h>' in the man page, just above the 
  110. !   prototype. I know few people will notice, but I try to keep
  111. !   things in sync with my Pure-C helpfile.
  112. ! 
  113. ! access.c: ++boender
  114. !   My System V.3 manpages state `access checks for accessibility, using
  115. !   the real user ID in place of the effective user ID and the real group
  116. !   ID in place of the effective group ID.'.
  117. !   The access() in the mintlibs uses the effective user ID and the
  118. !   effective group ID. Could you check your UN*X manpages to see
  119. !   whether this is a BSD vs. AT&T difference or if the mintlibs
  120. !   got it wrong? Fixing this would of course be trivial.
  121. ! 
  122. ! alarm.c: ++boender
  123. !   This call will fail when used in 32-bit mode (gcc -mlong) with a
  124. !   value >= 2^31, since this will result in an `enquire' call to
  125. !   Talarm(). I think these calls should be filtered out. Just
  126. !   checking "if ((long)secs < 0) {return _EINVAL;}" should do the trick.
  127. !   Dynix manual pages also state that "the largest allowed value is
  128. !   2^31".
  129.   
  130.   bsearch.c: ++entropy
  131.     Someone on the net said the args were wrong; it looks right to me.
  132.     What's the problem?
  133.   
  134. ! clock.c: ++boender
  135. !   This function is hopelessly different from the UNIX version, since
  136. !   it returns time elapsed since the program started, and not the CPU
  137. !   time used by the process and its children that have terminated so
  138. !   far.  Also, the time units used are different.  This may be hard to
  139. !   fix...
  140. ! 
  141. ! getcwd.c: ++boender
  142. !   This function would be easier to implement using the Dgetcwd() call
  143. !   available since MiNT 0.96. Since that function does better checking
  144. !   anyway (it will not overflow the buffer if the path doesn't fit),
  145. !   testing "if (__mint <= 95) {old-code} else {Dgetcwd()}" would be
  146. !   a Good Thing.
  147.   
  148.   getopt.c, unistd.h: ++boender
  149.     The three externally usable variables defined in getopt.c should be
  150.     included in <unistd.h>, where getopt() is declared too.  These
  151.     are: 'extern char *optarg', 'extern int opterr' and 'extern int optind'.
  152.   
  153. -   Not really a bug.  Leave it this way because UNIX doesn't have these
  154. -   vars in any headers either.
  155. - 
  156. - getpass.c: ++entropy
  157. -   getpass() reads from stdin, should read /dev/tty like UNIX.
  158. - 
  159.   getuid.c: ++boender, ++entropy
  160.     Under UNIX Sys VR3 (didn't check SunOS), setpgrp() takes no parameters
  161.     and sets the process group ID of the calling process to its own process
  162. --- 18,55 ----
  163.     up at some time, i.e. do we stop supporting MiNT before 0.8 or 0.9?
  164.     Some obvious candidates are killpg.c and unx2dos.c.
  165.   
  166. ! alarm.c: ++entropy
  167. !   alarm() will silently "round down" any requested time greater than 2
  168. !   million "or so" seconds.  Most UNIXes allow much larger maximum values
  169. !   (usually LONG_MAX).  MiNT needs this extremely small maximum value because
  170. !   wakeup scheduling is calculated in milliseconds by the kernel.  This
  171. !   cannot be fixed without changing MiNT.  alarm() does not work at all under
  172. !   TOS.
  173.   
  174.   bsearch.c: ++entropy
  175.     Someone on the net said the args were wrong; it looks right to me.
  176.     What's the problem?
  177.   
  178. ! clock.c: ++boender, ++entropy
  179. !   clock() is currently implemented as an alias for _clock(), which makes it
  180. !   hopelessly different from the UNIX version, since it returns time elapsed
  181. !   since the program started, and not the CPU time used by the process and
  182. !   its children that have terminated so far.  Also, the time units used are
  183. !   different (200 Hz ticks instead of microseconds).  When clock() is fixed,
  184. !   CLOCKS_PER_SEC in time.h will need to be changed, as ANSI specifies that
  185. !   clock()/CLOCKS_PER_SEC gives the CPU time used, in seconds, since the
  186. !   beginning of execution.  It may be a good idea to change CLK_TCK to agree,
  187. !   or maybe CLK_TCK should be used for the actual 200 Hz hardware tick, and
  188. !   change only CLOCKS_PER_SEC.  CLK_TCK is used in times.c.  CLOCKS_PER_SEC
  189. !   is used in sleep.c.
  190.   
  191.   getopt.c, unistd.h: ++boender
  192.     The three externally usable variables defined in getopt.c should be
  193.     included in <unistd.h>, where getopt() is declared too.  These
  194.     are: 'extern char *optarg', 'extern int opterr' and 'extern int optind'.
  195. +   [Not really a bug.  Leave it this way because UNIX doesn't have these
  196. +   vars in any headers either. -entropy]
  197.   
  198.   getuid.c: ++boender, ++entropy
  199.     Under UNIX Sys VR3 (didn't check SunOS), setpgrp() takes no parameters
  200.     and sets the process group ID of the calling process to its own process
  201. ***************
  202. *** 113,129 ****
  203.     Could test for (r != x) instead of (r < 0) just to be safe, in setuid() and
  204.     setgid().
  205.   
  206. ! kill.c: ++boender, ++entropy
  207.     On UNIX (SysV), system processes (PID 0 and 1) are treated specially.
  208. !   This is somewhat different under MiNT, where init(1), if run at all,
  209. !   need not have PID 1.  PID 0 is already treated in the correct manner by
  210. !   Pkill().    
  211. ! and 1 definitely deserve special treatment
  212. !   under MiNT in any case, because killing MiNT is a bad idea, and shooting
  213. !   signals at MiNT's child process (be it init(1), or some shell, or whatever)
  214. !   isn't likely to 
  215.   
  216. !   Check behavior against UNIX (SysV).
  217.   
  218.     The man page for the MiNT call Pkill() forgets to mention that
  219.     either the effective user ID of the caller must be zero (super-user) or
  220. --- 94,109 ----
  221.     Could test for (r != x) instead of (r < 0) just to be safe, in setuid() and
  222.     setgid().
  223.   
  224. ! kill.c: ++boender, ++entropy 
  225.     On UNIX (SysV), system processes (PID 0 and 1) are treated specially.
  226. !   This is somewhat different under MiNT, where init(1), if run at all, need
  227. !   not have PID 1.  PID 0 is already treated in the correct manner by
  228. !   Pkill().  PID 1 really deserves special treatment under MiNT in any case,
  229. !   because shooting signals at MiNT's child process (be it init(1), or some
  230. !   shell, or whatever) isn't likely to have the expected results.  I'm not
  231. !   sure if this can reasonably be resolved in the library alone.
  232.   
  233. !   [Check behavior against UNIX (SysV). -entropy]
  234.   
  235.     The man page for the MiNT call Pkill() forgets to mention that
  236.     either the effective user ID of the caller must be zero (super-user) or
  237. ***************
  238. *** 159,181 ****
  239.     - void pause(void)
  240.     - void sigpause(long mask)
  241.   
  242. ! sleep.c: ++boender
  243. !   The TOS version of these routine uses clock(). This may cause
  244. !   trouble is clock() is ever repaired.
  245. !   The MiNT version of these routines repeatedly calls Fselect().
  246. !   This had better be re-implemented using Psigpause(), since
  247. !   on UN*X, any caught signal causes sleep() to be stopped early,
  248. !   with the "unslept" amount of time as return value.
  249. !   Currently, the mintlibs sleep() the full amount of time, then
  250. !   return zero. This is a bug.
  251. !   usleep() is of type void. This may not be correct: it is
  252. !   of type unsigned on UN*X, and should be of type unsigned
  253. !   long in the mintlibs.
  254. !   I'll rewrite these functions if you feel they should be changed.
  255. ! 
  256. ! support.h: ++boender
  257. !   Would it be possible to define link(), symlink(), etc. to take
  258. !   `const char *' parameters, or will MiNT need to be changed for that?
  259.   
  260.   system.c: ++boender
  261.     Currently, this function emulates the UN*X function, including
  262. --- 139,149 ----
  263.     - void pause(void)
  264.     - void sigpause(long mask)
  265.   
  266. ! sleep.c: ++boender, ++entropy
  267. !   usleep() is of type void.  This may not be correct:  it is of type
  268. !   unsigned on UN*X, and should be of type unsigned long in the mintlibs.
  269. !   usleep() is not interruptable by signals (is it on UNIX?).  sleep() is
  270. !   only interruptable with 1-second granularity.
  271.   
  272.   system.c: ++boender
  273.     Currently, this function emulates the UN*X function, including
  274. ***************
  275. *** 187,195 ****
  276.     out what a user means by "/bin" on a tos file system, and so on.  The
  277.     current scheme is more likely to work for more users more of the time...
  278.     -entropy]
  279. - 
  280. - times.c: ++entropy
  281. -   Also uses clock().  (See clock.c, sleep.c).
  282.   
  283.   utime.c: ++boender
  284.     stime(): My System V.3 manual state that `The stime() call will
  285. --- 155,160 ----
  286. diff -c ../mntlib27/changes ./changes
  287. *** ../mntlib27/changes    Thu Feb 11 11:54:28 1993
  288. --- ./changes    Fri Feb 19 09:22:34 1993
  289. ***************
  290. *** 4,9 ****
  291. --- 4,62 ----
  292.   Changes are listed in *reverse* order, most recent changes being
  293.   first.
  294.   
  295. + PATCHLEVEL28::
  296. + 
  297. + a64l.c: ++boender@dutiws.twi.tudelft.nl
  298. +     Add to comments a note that prototypes are in support.h.
  299. + alarm.c: ++boender, ++entropy
  300. +     If requested time is greater than MiNT can handle, "round down" to
  301. +     (LONG_MAX/1000) seconds, to prevent unexpected "inquiry" calls to
  302. +     Talarm() (or even possible crashes).  This is only relevant if long
  303. +     integers are used, since (USHRT_MAX < (LONG_MAX/1000)).  Do NOT set
  304. +     errno if an error results (the only error that can be recognized,
  305. +     anyway, is that alarm() was called when MiNT was not active.  In
  306. +     this case, 0 is returned and no alarm is set.)
  307. + getpass.c:
  308. +     Read password from /dev/tty, instead of stdin, if MiNT is active.
  309. + link.c, symlink.c, support.h:
  310. +     Functions link(), symlink() now take "const char *" instead of
  311. +     "char *" parmeters.
  312. + getcwd.c: ++boender, ++entropy
  313. +     Use Dgetcwd() when running on MiNT 0.96 or newer.
  314. + limits.h: ++jrb (bammi@cadence.com)
  315. +     Fix definition of INT_MIN, evidently casting it to float didn't work
  316. +     with the old (equivalent) value.
  317. + stdlib.h: ++jrb
  318. +     Changed alloca macro for better parameter checking.
  319. + eprintf.c: ++jrb
  320. +     Make _say() a function instead of a macro.
  321. + fwrite.c, linea.c: ++jrb
  322. +     Some stuff I missed in patchlevel 26.
  323. + vdiesc1.h: ++jrb
  324. +     DELETED file, seems this was some leftover temp file, everything in
  325. +     it is already in vdibind.h.
  326. + access.c: ++boender, ++entropy
  327. +     Use real, not effective, user id's for access() checks.
  328. +     Fix so access() always returns success on existing files if real
  329. +     user id is 0 (root), regardless of file mode.
  330. + stat.c: ++ers
  331. +     Fix so stat("foo\\") is equivalent to stat("foo"), under TOS.
  332. + unx2dos.c: ++hohmuth
  333. +     Support unx2dos() and dos2unx() on non-GCC compilers (to the minimal
  334. +     extent to which they are supported on GCC).
  335. + sleep.c: ++entropy, ++boender
  336. +     Allow sleep() to be interrupted by signals under MiNT (0.95 or
  337. +     greater) by re-implementing with Psigpause() etc.
  338. + clock.c, getrusag.c, sleep.c, thread.c, times.c, time.h: ++boender, ++entropy
  339. +     Replace all occurrences of clock() with _clock(), temporarily
  340. +     alias clock() to call _clock() until we have something better.
  341. + times.c:
  342. +     Set errno and return -1 on error.
  343. + mintbind.h:
  344. +     Add new GEMDOS functions (macros) Dgetcwd() and Salert().
  345. + errno.h: ++boender
  346. +     Define ENODEV as alias for EUKDEV/EUNDEV.
  347. + 
  348.   PATCHLEVEL27::
  349.   
  350.   isatty.c:
  351. diff -c ../mntlib27/clock.c ./clock.c
  352. *** ../mntlib27/clock.c    Tue Jun 23 17:10:44 1992
  353. --- ./clock.c    Wed Feb 17 14:23:24 1993
  354. ***************
  355. *** 1,4 ****
  356. ! /* clock -- return process time used so far, in units of CLK_TCK ticks
  357.      per second (under TOS, 200 per second) */
  358.   /* written by ERS */
  359.   
  360. --- 1,4 ----
  361. ! /* _clock -- return process time used so far, in units of CLK_TCK ticks
  362.      per second (under TOS, 200 per second) */
  363.   /* written by ERS */
  364.   
  365. ***************
  366. *** 16,23 ****
  367.   static void getnow() { now = *((unsigned long *) 0x4baL); }
  368.   
  369.   clock_t
  370. ! clock()
  371.   {
  372.       (void)Supexec(getnow);
  373.       return (now - _starttime);
  374.   }
  375. --- 16,35 ----
  376.   static void getnow() { now = *((unsigned long *) 0x4baL); }
  377.   
  378.   clock_t
  379. ! _clock()
  380.   {
  381.       (void)Supexec(getnow);
  382.       return (now - _starttime);
  383.   }
  384. + 
  385. + /* This next bit of nonsense is temporary...clock() should be fixed! */
  386. + 
  387. + #ifdef __GNUC__
  388. + asm(".stabs \"_clock\",5,0,0,__clock"); /* dept of clean tricks */
  389. + #else /* ! __GNUC__ */
  390. + clock_t
  391. + clock()
  392. + {
  393. +   return _clock();
  394. + }
  395. + #endif /* ! __GNUC__ */
  396. diff -c ../mntlib27/eprintf.c ./eprintf.c
  397. *** ../mntlib27/eprintf.c    Sat Sep  5 19:20:08 1992
  398. --- ./eprintf.c    Sat Feb 13 07:23:24 1993
  399. ***************
  400. *** 14,22 ****
  401.      Modified to do its own work rather than call fprintf().
  402.   */
  403.   
  404. - #define _say(s) _write(2,s,(long)strlen(s))
  405.   
  406.   static char buf[20];    /* big enough for any value of a long */
  407.   
  408.   /* This is used by the `assert' macro.  */
  409.   void __eprintf (expression, line, filename)
  410. --- 14,27 ----
  411.      Modified to do its own work rather than call fprintf().
  412.   */
  413.   
  414.   
  415.   static char buf[20];    /* big enough for any value of a long */
  416. + 
  417. + static void _say(s)
  418. + char *s;
  419. + {
  420. +     _write(2,s,(long)(strlen(s)));
  421. + }
  422.   
  423.   /* This is used by the `assert' macro.  */
  424.   void __eprintf (expression, line, filename)
  425. diff -c ../mntlib27/fwrite.c ./fwrite.c
  426. *** ../mntlib27/fwrite.c    Thu Jan 21 16:16:00 1993
  427. --- ./fwrite.c    Sat Feb 13 07:23:38 1993
  428. ***************
  429. *** 8,14 ****
  430.   #include <string.h>
  431.   #include "lib.h"
  432.   
  433. ! extern short __FRW_BIN__;
  434.   
  435.   size_t    fwrite(_data, size, count, fp)
  436.   const void *_data;
  437. --- 8,14 ----
  438.   #include <string.h>
  439.   #include "lib.h"
  440.   
  441. ! extern short  __FRW_BIN__;
  442.   
  443.   size_t    fwrite(_data, size, count, fp)
  444.   const void *_data;
  445. ***************
  446. *** 26,32 ****
  447.       int wrote_cr;
  448.       int line_flush;
  449.   
  450. !     if( (f & _IORW) || __FRW_BIN__ )
  451.       {
  452.           fp->_flag |= _IOWRT;
  453.           f = (fp->_flag &= ~(_IOREAD | _IOEOF));
  454. --- 26,32 ----
  455.       int wrote_cr;
  456.       int line_flush;
  457.   
  458. !     if(f & _IORW)
  459.       {
  460.           fp->_flag |= _IOWRT;
  461.           f = (fp->_flag &= ~(_IOREAD | _IOEOF));
  462. ***************
  463. *** 41,47 ****
  464.       n =  count * size;
  465.       assert ( n <= (size_t)LONG_MAX);  /* otherwise impl will not work */
  466.   
  467. !     if( f&_IOBIN ) {
  468.         space = fp->_bsiz - fp->_cnt;
  469.         while(n > 0)
  470.         {
  471. --- 41,47 ----
  472.       n =  count * size;
  473.       assert ( n <= (size_t)LONG_MAX);  /* otherwise impl will not work */
  474.   
  475. !     if( (f&_IOBIN) || __FRW_BIN__ ) {
  476.         space = fp->_bsiz - fp->_cnt;
  477.         while(n > 0)
  478.         {
  479. diff -c ../mntlib27/getcwd.c ./getcwd.c
  480. *** ../mntlib27/getcwd.c    Sat Sep  5 19:57:32 1992
  481. --- ./getcwd.c    Fri Feb 19 06:24:12 1993
  482. ***************
  483. *** 4,9 ****
  484. --- 4,10 ----
  485.   #include <limits.h>
  486.   #include <errno.h>
  487.   #include <osbind.h>
  488. + #include <mintbind.h>
  489.   #include "lib.h"
  490.   
  491.   /*******************************************************************
  492. ***************
  493. *** 29,38 ****
  494.       char *path;
  495.   #endif
  496.       char drv;
  497.   
  498. !     if (!buf)
  499.           if ((buf = (char *) malloc((size_t)size)) == 0)
  500.               return NULL;
  501.   
  502.       drv = Dgetdrv() + 'a';
  503.       _path[0] = drv;
  504. --- 30,43 ----
  505.       char *path;
  506.   #endif
  507.       char drv;
  508. +     int buf_malloced = 0;
  509. +     int r;
  510.   
  511. !     if (!buf) {
  512.           if ((buf = (char *) malloc((size_t)size)) == 0)
  513.               return NULL;
  514. +         buf_malloced = 1;
  515. +     }
  516.   
  517.       drv = Dgetdrv() + 'a';
  518.       _path[0] = drv;
  519. ***************
  520. *** 39,45 ****
  521.       _path[1] = ':';
  522.       _path[2] = '\0';
  523.       path = _path + 2;
  524. !     (void)Dgetpath(path, 0);
  525.   
  526.       if (_rootdir && drv == _rootdir) {
  527.           if (!*path) {
  528. --- 44,59 ----
  529.       _path[1] = ':';
  530.       _path[2] = '\0';
  531.       path = _path + 2;
  532. !     if (__mint >= 96) {
  533. !         if ((r = Dgetcwd(path, 0, size - 2)) != 0) {
  534. !             if (buf_malloced)
  535. !                 free(buf);
  536. !             errno = -r;
  537. !             return NULL;
  538. !         }
  539. !     } else {
  540. !         (void)Dgetpath(path, 0);
  541. !     }
  542.   
  543.       if (_rootdir && drv == _rootdir) {
  544.           if (!*path) {
  545. diff -c ../mntlib27/getpass.c ./getpass.c
  546. *** ../mntlib27/getpass.c    Fri Jan 15 04:26:10 1993
  547. --- ./getpass.c    Wed Feb 17 18:34:56 1993
  548. ***************
  549. *** 4,9 ****
  550. --- 4,11 ----
  551.   #include <string.h>
  552.   #include <limits.h>
  553.   
  554. + extern int __mint;
  555. + 
  556.   char *
  557.   getpass(prompt)
  558.       const char *prompt;
  559. ***************
  560. *** 11,30 ****
  561.       static char buf[PASS_MAX + 1];
  562.           char *ret;
  563.       struct sgttyb oldsb, newsb;
  564.   
  565.       fflush(stdin);
  566. !     gtty(0, &oldsb);
  567.       newsb = oldsb;
  568.       newsb.sg_flags &= ~ECHO;
  569. !     stty(0, &newsb);
  570.       fputs(prompt, stderr);
  571.       fflush(stderr);
  572. !     if ((ret = fgets(buf, PASS_MAX + 1, stdin)) != 0)
  573.       {
  574.         /* zap the newline */
  575.         if (buf[strlen(buf) - 1] == '\n')
  576.           buf[strlen(buf) - 1] = 0;
  577.       }
  578. !     stty(0, &oldsb);
  579.       return ret;
  580.   }
  581. --- 13,43 ----
  582.       static char buf[PASS_MAX + 1];
  583.           char *ret;
  584.       struct sgttyb oldsb, newsb;
  585. +     FILE *tty;
  586. +     int ttyfd = 0;
  587.   
  588.       fflush(stdin);
  589. !     tty = stdin;
  590. !     if (__mint) {
  591. !         if ((tty = fopen("U:\\DEV\\TTY", "r")) == NULL)
  592. !             return NULL;
  593. !     }
  594. !     ttyfd = fileno(tty);
  595. !     fflush(tty);
  596. !     gtty(ttyfd, &oldsb);
  597.       newsb = oldsb;
  598.       newsb.sg_flags &= ~ECHO;
  599. !     stty(ttyfd, &newsb);
  600.       fputs(prompt, stderr);
  601.       fflush(stderr);
  602. !     if ((ret = fgets(buf, PASS_MAX + 1, tty)) != 0)
  603.       {
  604.         /* zap the newline */
  605.         if (buf[strlen(buf) - 1] == '\n')
  606.           buf[strlen(buf) - 1] = 0;
  607.       }
  608. !     stty(ttyfd, &oldsb);
  609. !     if (__mint)
  610. !         (void) fclose(tty);
  611.       return ret;
  612.   }
  613. diff -c ../mntlib27/getrusag.c ./getrusag.c
  614. *** ../mntlib27/getrusag.c    Sat Sep  5 20:06:44 1992
  615. --- ./getrusag.c    Wed Feb 17 14:09:36 1993
  616. ***************
  617. *** 52,58 ****
  618.           }
  619.       } else {
  620.           usage[0] = usage[2] = 0;
  621. !         usage[1] = clock() - _childtime;
  622.           usage[3] = _childtime;
  623.       }
  624.   
  625. --- 52,58 ----
  626.           }
  627.       } else {
  628.           usage[0] = usage[2] = 0;
  629. !         usage[1] = _clock() - _childtime;
  630.           usage[3] = _childtime;
  631.       }
  632.   
  633. diff -c ../mntlib27/linea.c ./linea.c
  634. *** ../mntlib27/linea.c    Thu Oct  1 14:41:22 1992
  635. --- ./linea.c    Sat Feb 13 07:23:50 1993
  636. ***************
  637. *** 94,108 ****
  638.   
  639.   void linea7(BBPB *P)                             
  640.   {                                    
  641.       __asm__ volatile                        
  642.       ("
  643.           movml    d2/a2/a6, sp@-;
  644.            movl    %0,a6;  
  645.           .word   0xA007;
  646. !         movml    sp@+,d2/a2/a6"
  647.       :                           /* outputs */    
  648.       : "r"(P)                      /* inputs  */    
  649. !     : "d0", "d1", "a0", "a1"           /* clobbered regs */
  650.       );                                
  651.   }
  652.   
  653. --- 94,109 ----
  654.   
  655.   void linea7(BBPB *P)                             
  656.   {                                    
  657. +                                         
  658.       __asm__ volatile                        
  659.       ("
  660.           movml    d2/a2/a6, sp@-;
  661.            movl    %0,a6;  
  662.           .word   0xA007;
  663. !         movml    sp@+, d2/a2/a6"
  664.       :                           /* outputs */    
  665.       : "r"(P)                      /* inputs  */    
  666. !     : "d0", "d1", "a0", "a1"          /* clobbered regs */    \
  667.       );                                
  668.   }
  669.   
  670. ***************
  671. *** 160,171 ****
  672.       __asm__ volatile                        
  673.       ("
  674.            movl    %0,a2;  
  675. !         movl    a6,sp@-;
  676. !         .word   0xA00C;
  677. !         movl    sp@+,a6"
  678.       :                           /* outputs */    
  679. !     : "g"(P)                       /* inputs  */    
  680. !     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  681.       );                                
  682.   }
  683.   
  684. --- 161,170 ----
  685.       __asm__ volatile                        
  686.       ("
  687.            movl    %0,a2;  
  688. !         .word   0xA00C" 
  689.       :                           /* outputs */    
  690. !     : "r"(P)                      /* inputs  */    
  691. !     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  692.       );                                
  693.   }
  694.   
  695. ***************
  696. *** 178,189 ****
  697.            movw    %1,d1;  
  698.            movl    %2,a0;  
  699.            movl    %3,a2;  
  700. !         movl    a6,sp@-;
  701. !         .word   0xA00D;
  702. !         movl    sp@+,a6"
  703.       :                           /* outputs */    
  704. !     : "g"((short)x), "g"((short)y), "g"(sd), "g"(ss)  /* inputs  */    
  705. !     : "d0", "d1", "d2", "a0", "a1", "a2"       /* clobbered regs */    
  706.       );                                
  707.   }
  708.   
  709. --- 177,186 ----
  710.            movw    %1,d1;  
  711.            movl    %2,a0;  
  712.            movl    %3,a2;  
  713. !         .word   0xA00D" 
  714.       :                           /* outputs */    
  715. !     : "r"((short)x), "r"((short)y), "r"(sd), "r"(ss)  /* inputs  */    
  716. !     : "d0", "d1", "d2", "a0", "a1", "a2", "a6" /* clobbered regs */    
  717.       );                                
  718.   }
  719.   
  720. diff -c ../mntlib27/link.c ./link.c
  721. *** ../mntlib27/link.c    Sat Sep  5 20:59:16 1992
  722. --- ./link.c    Sat Feb 13 05:57:28 1993
  723. ***************
  724. *** 3,8 ****
  725. --- 3,9 ----
  726.   #include <errno.h>
  727.   #include <mintbind.h>
  728.   #include <param.h>
  729. + #include <support.h>
  730.   #include "lib.h"
  731.   
  732.   extern int __mint;
  733. ***************
  734. *** 13,19 ****
  735.   
  736.   int
  737.   link(_old, _new)
  738. !     char *_old, *_new;
  739.   {
  740.       long r;
  741.       char old[MAXPATHLEN], new[MAXPATHLEN];
  742. --- 14,20 ----
  743.   
  744.   int
  745.   link(_old, _new)
  746. !     const char *_old, *_new;
  747.   {
  748.       long r;
  749.       char old[MAXPATHLEN], new[MAXPATHLEN];
  750. diff -c ../mntlib27/makefile ./makefile
  751. *** ../mntlib27/makefile    Thu Jan 21 15:21:38 1993
  752. --- ./makefile    Sat Feb 13 09:25:56 1993
  753. ***************
  754. *** 50,56 ****
  755.   # This reflects my setup, your mileage may vary.
  756.   
  757.   AR    := ar
  758. ! LIB    := newlib
  759.   
  760.   endif
  761.   
  762. --- 50,56 ----
  763.   # This reflects my setup, your mileage may vary.
  764.   
  765.   AR    := ar
  766. ! LIB    := /src/newlib
  767.   
  768.   endif
  769.   
  770. diff -c ../mntlib27/patchlev.h ./patchlev.h
  771. *** ../mntlib27/patchlev.h    Sun Jan 17 08:54:30 1993
  772. --- ./patchlev.h    Sat Feb 13 03:24:10 1993
  773. ***************
  774. *** 3,6 ****
  775.    *    directory.
  776.    */
  777.   
  778. ! #define PatchLevel "27"
  779. --- 3,6 ----
  780.    *    directory.
  781.    */
  782.   
  783. ! #define PatchLevel "28"
  784. diff -c ../mntlib27/sleep.c ./sleep.c
  785. *** ../mntlib27/sleep.c    Sat Sep  5 21:28:48 1992
  786. --- ./sleep.c    Wed Feb 17 14:10:08 1993
  787. ***************
  788. *** 1,15 ****
  789.   /* sleep -- sleep for a specified number of seconds */
  790.   /* usleep -- sleep for a specified number of microSecond */
  791.   /* written by Eric R. Smith and placed in the public domain */
  792.   
  793.   #include <time.h>
  794.   #include <mintbind.h>
  795.   
  796. ! /* clock() has a rez of CLOCKS_PER_SEC ticks/sec */
  797.   
  798.   #define USEC_PER_TICK (1000000L / ((unsigned long)CLOCKS_PER_SEC))
  799.   #define    USEC_TO_CLOCK_TICKS(us)    ((us) / USEC_PER_TICK )
  800.   
  801.   unsigned int
  802.   sleep(n)
  803.       unsigned int n;
  804. --- 1,30 ----
  805.   /* sleep -- sleep for a specified number of seconds */
  806.   /* usleep -- sleep for a specified number of microSecond */
  807.   /* written by Eric R. Smith and placed in the public domain */
  808. + /* extensively rehacked by entropy for mint >= 0.95, still public domain */
  809.   
  810.   #include <time.h>
  811.   #include <mintbind.h>
  812. + #include <signal.h>
  813.   
  814. ! #ifndef sigmask /* will not be defined if __STRICT_ANSI__ or not __MINT__ */
  815. ! #define sigmask(sig) (1L << (sig))
  816. ! #endif
  817.   
  818. + /* _clock() has a rez of CLOCKS_PER_SEC ticks/sec */
  819. + 
  820.   #define USEC_PER_TICK (1000000L / ((unsigned long)CLOCKS_PER_SEC))
  821.   #define    USEC_TO_CLOCK_TICKS(us)    ((us) / USEC_PER_TICK )
  822.   
  823. + static void alarm_catch __PROTO((int signum));
  824. + 
  825. + static void
  826. + alarm_catch(signum)
  827. +     int signum;
  828. + {
  829. +     return;
  830. + }
  831. + 
  832.   unsigned int
  833.   sleep(n)
  834.       unsigned int n;
  835. ***************
  836. *** 16,32 ****
  837.   {
  838.       unsigned long    stop;
  839.       extern int __mint;
  840.   
  841.       if (__mint) {
  842. !         while (n > 32) {
  843. !             (void)Fselect(32000, 0L, 0L, 0L);
  844. !             n -= 32;
  845.           }
  846. !         (void)Fselect(1000*n, 0L, 0L, 0L);
  847.       }
  848.       else {
  849. !         stop = clock() + n * CLOCKS_PER_SEC;
  850. !         while (clock() < stop)
  851.               ;
  852.       }
  853.       return 0;
  854. --- 31,87 ----
  855.   {
  856.       unsigned long    stop;
  857.       extern int __mint;
  858. +     __Sigfunc old_alarm_func;
  859. +     long old_sigmask;
  860. +     long alarm_sec;
  861. +     long unslept = 0L;
  862. +     long remain;
  863.   
  864.       if (__mint) {
  865. !         if (__mint < 95) {
  866. !             while (n > 32) {
  867. !                 (void)Fselect(32000, 0L, 0L, 0L);
  868. !                 n -= 32;
  869. !             }
  870. !             (void)Fselect(1000*n, 0L, 0L, 0L);
  871. !             return 0;
  872. !         }
  873. !         if (n == 0)
  874. !             return 0;
  875. !         alarm_sec = Talarm(0L);
  876. !         if (alarm_sec && (alarm_sec < n)) {
  877. !             unslept = n - alarm_sec;
  878. !             n = alarm_sec;
  879. !         }
  880. !         stop = _clock() + n * CLOCKS_PER_SEC;
  881. !         old_sigmask = Psigblock(~0L);
  882. !         old_alarm_func = (__Sigfunc) Psignal(SIGALRM, alarm_catch);
  883. !         (void) Psigblock(~0L);
  884. !         while ((_clock() < stop) && !(Psigpending() 
  885. !                          & ~old_sigmask 
  886. !                          & ~sigmask(SIGALRM))) {
  887. !             Talarm(1L);
  888. !             Psigpause(~sigmask(SIGALRM));
  889. !         }
  890. !         remain = ((long) stop - (long) _clock()) 
  891. !               / (long) CLOCKS_PER_SEC;
  892. !         (void) Talarm(0L);
  893. !         (void) Psignal(SIGALRM, old_alarm_func);        
  894. !         (void) Psigblock(~0L);
  895. !         if (alarm_sec > 0) {
  896. !             alarm_sec -= (n - remain);
  897. !             if (alarm_sec <= 0)
  898. !                 (void) Pkill(Pgetpid(), SIGALRM);
  899. !             else
  900. !                 (void) Talarm(alarm_sec);
  901.           }
  902. !         (void) Psigsetmask(old_sigmask);
  903. !         unslept += remain;
  904. !         return ((unslept > 0) ? (unsigned) unslept : 0);
  905.       }
  906.       else {
  907. !         stop = _clock() + n * CLOCKS_PER_SEC;
  908. !         while (_clock() < stop)
  909.               ;
  910.       }
  911.       return 0;
  912. ***************
  913. *** 48,55 ****
  914.           (void)Fselect((unsigned)(usec/1000), 0L, 0L, 0L);
  915.       }
  916.       else {
  917. !         stop = clock() + USEC_TO_CLOCK_TICKS(usec);
  918. !         while (clock() < stop)
  919.               ;
  920.       }
  921.   }
  922. --- 103,110 ----
  923.           (void)Fselect((unsigned)(usec/1000), 0L, 0L, 0L);
  924.       }
  925.       else {
  926. !         stop = _clock() + USEC_TO_CLOCK_TICKS(usec);
  927. !         while (_clock() < stop)
  928.               ;
  929.       }
  930.   }
  931. diff -c ../mntlib27/stat.c ./stat.c
  932. *** ../mntlib27/stat.c    Sat Sep  5 21:00:48 1992
  933. --- ./stat.c    Wed Feb 17 06:32:56 1993
  934. ***************
  935. *** 133,138 ****
  936. --- 133,140 ----
  937.    * so we kludge around this by using the fact that Fsfirst(".\*.*"
  938.    * or "..\*.*" will return the correct file first (except, of course,
  939.    * in root directories :-( ).
  940. +  * NOTE2: Some versions of TOS don't like Fsfirst("RCS\\", -1) either,
  941. +  * so we do the same thing if the path ends in '\\'.
  942.    */
  943.   
  944.   /* find the end of the string */
  945. ***************
  946. *** 142,147 ****
  947. --- 144,152 ----
  948.       if (*ext == '.' && (ext == path || ext[-1] == '\\' || ext[-1] == '.')) {
  949.           isdot = 1;
  950.           strcat(path, "\\*.*");
  951. +     } else if (*ext == '\\') {
  952. +         isdot = 1;
  953. +         strcat(path, "*.*");
  954.       }
  955.       olddta = Fgetdta();
  956.       Fsetdta(&d);
  957. diff -c ../mntlib27/symlink.c ./symlink.c
  958. *** ../mntlib27/symlink.c    Sat Sep  5 21:01:12 1992
  959. --- ./symlink.c    Sat Feb 13 05:58:42 1993
  960. ***************
  961. *** 16,22 ****
  962.   
  963.   int
  964.   symlink(old, new)
  965. !     char *old, *new;
  966.   {
  967.       char linkname[PATH_MAX];
  968.       char path[PATH_MAX];
  969. --- 16,22 ----
  970.   
  971.   int
  972.   symlink(old, new)
  973. !     const char *old, *new;
  974.   {
  975.       char linkname[PATH_MAX];
  976.       char path[PATH_MAX];
  977. diff -c ../mntlib27/thread.c ./thread.c
  978. *** ../mntlib27/thread.c    Sat Sep  5 21:01:20 1992
  979. --- ./thread.c    Wed Feb 17 14:10:52 1993
  980. ***************
  981. *** 91,97 ****
  982.           savbase = _base;
  983.           _base = b;
  984.   
  985. !         now = clock();
  986.           pid = Pexec(4, 0L, b, 0L);
  987.           (void)Mfree(b->p_env);    /* free the memory */
  988.           (void)Mfree(b);
  989. --- 91,97 ----
  990.           savbase = _base;
  991.           _base = b;
  992.   
  993. !         now = _clock();
  994.           pid = Pexec(4, 0L, b, 0L);
  995.           (void)Mfree(b->p_env);    /* free the memory */
  996.           (void)Mfree(b);
  997. ***************
  998. *** 109,115 ****
  999.               pid = ((long)b) >> 8;
  1000.               __waitval = (pid << 16) | retval;
  1001.               raise(SIGCHLD);
  1002. !             __waittime = clock() - now;
  1003.               _childtime += __waittime;
  1004.           }
  1005.       }
  1006. --- 109,115 ----
  1007.               pid = ((long)b) >> 8;
  1008.               __waitval = (pid << 16) | retval;
  1009.               raise(SIGCHLD);
  1010. !             __waittime = _clock() - now;
  1011.               _childtime += __waittime;
  1012.           }
  1013.       }
  1014. diff -c ../mntlib27/times.c ./times.c
  1015. *** ../mntlib27/times.c    Wed Feb 10 06:56:00 1993
  1016. --- ./times.c    Wed Feb 17 15:21:26 1993
  1017. ***************
  1018. *** 5,10 ****
  1019. --- 5,11 ----
  1020.   #endif
  1021.   #include <time.h>
  1022.   #include <mintbind.h>
  1023. + #include <errno.h>
  1024.   
  1025.   extern int __mint;
  1026.   extern long _childtime;
  1027. ***************
  1028. *** 18,24 ****
  1029.   {
  1030.       long usage[8], r, real_time;
  1031.   
  1032. !     real_time = clock();
  1033.   
  1034.       if (__mint) {
  1035.           r = Prusage(usage);
  1036. --- 19,25 ----
  1037.   {
  1038.       long usage[8], r, real_time;
  1039.   
  1040. !     real_time = _clock();
  1041.   
  1042.       if (__mint) {
  1043.           r = Prusage(usage);
  1044. ***************
  1045. *** 29,34 ****
  1046. --- 30,39 ----
  1047.               buffer->tms_stime = CVRT(usage[0]);
  1048.               return real_time;
  1049.           }
  1050. +         if (!buffer)
  1051. +             errno = EFAULT;
  1052. +         errno = -r;
  1053. +         return -1;
  1054.       }
  1055.   
  1056.       if (buffer) {
  1057. diff -c ../mntlib27/unx2dos.c ./unx2dos.c
  1058. *** ../mntlib27/unx2dos.c    Mon Jun  8 05:22:24 1992
  1059. --- ./unx2dos.c    Wed Feb 17 06:36:28 1993
  1060. ***************
  1061. *** 3,8 ****
  1062. --- 3,9 ----
  1063.   #include <ctype.h>
  1064.   #include <osbind.h>
  1065.   #include <types.h>
  1066. + #include <support.h>
  1067.   
  1068.   extern int __mint;
  1069.   extern char _rootdir;    /* in main.c: user's preferred root directory */
  1070. ***************
  1071. *** 98,103 ****
  1072. --- 99,124 ----
  1073.   }
  1074.   
  1075.   #ifdef __GNUC__
  1076. + 
  1077.   asm(".stabs \"_unx2dos\",5,0,0,__unx2dos"); /* dept of clean tricks */
  1078.   asm(".stabs \"_dos2unx\",5,0,0,__dos2unx"); /* dept of clean tricks */
  1079. + 
  1080. + #else /* ! __GNUC__ */
  1081. + 
  1082. + int
  1083. + unx2dos(unx, dos)
  1084. +         const char *unx;
  1085. +         char *dos;
  1086. + {
  1087. +     return _unx2dos(unx, dos);
  1088. + }
  1089. + 
  1090. + int
  1091. + dos2unx(dos, unx)
  1092. +         const char *dos;
  1093. +         char *unx;
  1094. + {
  1095. +     return _dos2unx(dos, unx);
  1096. + }
  1097. + 
  1098.   #endif
  1099.