contrib/less/os.c

   1 /*
   2  * Copyright (C) 1984-2012  Mark Nudelman
   3  *
   4  * You may distribute under the terms of either the GNU General Public
   5  * License or the Less License, as specified in the README file.
   6  *
   7  * For more information, see the README file.
   8  */
   9
  10
  11 /*
  12  * Operating system dependent routines.
  13  *
  14  * Most of the stuff in here is based on Unix, but an attempt
  15  * has been made to make things work on other operating systems.
  16  * This will sometimes result in a loss of functionality, unless
  17  * someone rewrites code specifically for the new operating system.
  18  *
  19  * The makefile provides defines to decide whether various
  20  * Unix features are present.
  21  */
  22
  23 #include "less.h"
  24 #include <signal.h>
  25 #include <setjmp.h>
  26 #if HAVE_TIME_H
  27 #include <time.h>
  28 #endif
  29 #if HAVE_ERRNO_H
  30 #include <errno.h>
  31 #endif
  32 #if HAVE_VALUES_H
  33 #include <values.h>
  34 #endif
  35
  36 #if HAVE_TIME_T
  37 #define time_type       time_t
  38 #else
  39 #define time_type       long
  40 #endif
  41
  42 /*
  43  * BSD setjmp() saves (and longjmp() restores) the signal mask.
  44  * This costs a system call or two per setjmp(), so if possible we clear the
  45  * signal mask with sigsetmask(), and use _setjmp()/_longjmp() instead.
  46  * On other systems, setjmp() doesn't affect the signal mask and so
  47  * _setjmp() does not exist; we just use setjmp().
  48  */
  49 #if HAVE__SETJMP && HAVE_SIGSETMASK
  50 #define SET_JUMP        _setjmp
  51 #define LONG_JUMP       _longjmp
  52 #else
  53 #define SET_JUMP        setjmp
  54 #define LONG_JUMP       longjmp
  55 #endif
  56
  57 public int reading;
  58
  59 static jmp_buf read_label;
  60
  61 extern int sigs;
  62
  63 /*
  64  * Like read() system call, but is deliberately interruptible.
  65  * A call to intread() from a signal handler will interrupt
  66  * any pending iread().
  67  */
  68         public int
  69 iread(fd, buf, len)
  70         int fd;
  71         char *buf;
  72         unsigned int len;
  73 {
  74         register int n;
  75
  76 start:
  77 #if MSDOS_COMPILER==WIN32C
  78         if (ABORT_SIGS())
  79                 return (READ_INTR);
  80 #else
  81 #if MSDOS_COMPILER && MSDOS_COMPILER != DJGPPC
  82         if (kbhit())
  83         {
  84                 int c;
  85
  86                 c = getch();
  87                 if (c == '\003')
  88                         return (READ_INTR);
  89                 ungetch(c);
  90         }
  91 #endif
  92 #endif
  93         if (SET_JUMP(read_label))
  94         {
  95                 /*
  96                  * We jumped here from intread.
  97                  */
  98                 reading = 0;
  99 #if HAVE_SIGPROCMASK
 100                 {
 101                   sigset_t mask;
 102                   sigemptyset(&mask);
 103                   sigprocmask(SIG_SETMASK, &mask, NULL);
 104                 }
 105 #else
 106 #if HAVE_SIGSETMASK
 107                 sigsetmask(0);
 108 #else
 109 #ifdef _OSK
 110                 sigmask(~0);
 111 #endif
 112 #endif
 113 #endif
 114                 return (READ_INTR);
 115         }
 116
 117         flush();
 118         reading = 1;
 119 #if MSDOS_COMPILER==DJGPPC
 120         if (isatty(fd))
 121         {
 122                 /*
 123                  * Don't try reading from a TTY until a character is
 124                  * available, because that makes some background programs
 125                  * believe DOS is busy in a way that prevents those
 126                  * programs from working while "less" waits.
 127                  */
 128                 fd_set readfds;
 129
 130                 FD_ZERO(&readfds);
 131                 FD_SET(fd, &readfds);
 132                 if (select(fd+1, &readfds, 0, 0, 0) == -1)
 133                         return (-1);
 134         }
 135 #endif
 136         n = read(fd, buf, len);
 137 #if 1
 138         /*
 139          * This is a kludge to workaround a problem on some systems
 140          * where terminating a remote tty connection causes read() to
 141          * start returning 0 forever, instead of -1.
 142          */
 143         {
 144                 extern int ignore_eoi;
 145                 if (!ignore_eoi)
 146                 {
 147                         static int consecutive_nulls = 0;
 148                         if (n == 0)
 149                                 consecutive_nulls++;
 150                         else
 151                                 consecutive_nulls = 0;
 152                         if (consecutive_nulls > 20)
 153                                 quit(QUIT_ERROR);
 154                 }
 155         }
 156 #endif
 157         reading = 0;
 158         if (n < 0)
 159         {
 160 #if HAVE_ERRNO
 161                 /*
 162                  * Certain values of errno indicate we should just retry the read.
 163                  */
 164 #if MUST_DEFINE_ERRNO
 165                 extern int errno;
 166 #endif
 167 #ifdef EINTR
 168                 if (errno == EINTR)
 169                         goto start;
 170 #endif
 171 #ifdef EAGAIN
 172                 if (errno == EAGAIN)
 173                         goto start;
 174 #endif
 175 #endif
 176                 return (-1);
 177         }
 178         return (n);
 179 }
 180
 181 /*
 182  * Interrupt a pending iread().
 183  */
 184         public void
 185 intread()
 186 {
 187         LONG_JUMP(read_label, 1);
 188 }
 189
 190 /*
 191  * Return the current time.
 192  */
 193 #if HAVE_TIME
 194         public long
 195 get_time()
 196 {
 197         time_type t;
 198
 199         time(&t);
 200         return (t);
 201 }
 202 #endif
 203
 204
 205 #if !HAVE_STRERROR
 206 /*
 207  * Local version of strerror, if not available from the system.
 208  */
 209         static char *
 210 strerror(err)
 211         int err;
 212 {
 213 #if HAVE_SYS_ERRLIST
 214         static char buf[16];
 215         extern char *sys_errlist[];
 216         extern int sys_nerr;
 217
 218         if (err < sys_nerr)
 219                 return sys_errlist[err];
 220         sprintf(buf, "Error %d", err);
 221         return buf;
 222 #else
 223         return ("cannot open");
 224 #endif
 225 }
 226 #endif
 227
 228 /*
 229  * errno_message: Return an error message based on the value of "errno".
 230  */
 231         public char *
 232 errno_message(filename)
 233         char *filename;
 234 {
 235         register char *p;
 236         register char *m;
 237         int len;
 238 #if HAVE_ERRNO
 239 #if MUST_DEFINE_ERRNO
 240         extern int errno;
 241 #endif
 242         p = strerror(errno);
 243 #else
 244         p = "cannot open";
 245 #endif
 246         len = strlen(filename) + strlen(p) + 3;
 247         m = (char *) ecalloc(len, sizeof(char));
 248         SNPRINTF2(m, len, "%s: %s", filename, p);
 249         return (m);
 250 }
 251
 252 /* #define HAVE_FLOAT 0 */
 253
 254         static POSITION
 255 muldiv(val, num, den)
 256         POSITION val, num, den;
 257 {
 258 #if HAVE_FLOAT
 259         double v = (((double) val) * num) / den;
 260         return ((POSITION) (v + 0.5));
 261 #else
 262         POSITION v = ((POSITION) val) * num;
 263
 264         if (v / num == val)
 265                 /* No overflow */
 266                 return (POSITION) (v / den);
 267         else
 268                 /* Above calculation overflows;
 269                  * use a method that is less precise but won't overflow. */
 270                 return (POSITION) (val / (den / num));
 271 #endif
 272 }
 273
 274 /*
 275  * Return the ratio of two POSITIONS, as a percentage.
 276  * {{ Assumes a POSITION is a long int. }}
 277  */
 278         public int
 279 percentage(num, den)
 280         POSITION num, den;
 281 {
 282         return (int) muldiv(num,  (POSITION) 100, den);
 283 }
 284
 285 /*
 286  * Return the specified percentage of a POSITION.
 287  */
 288         public POSITION
 289 percent_pos(pos, percent, fraction)
 290         POSITION pos;
 291         int percent;
 292         long fraction;
 293 {
 294         /* Change percent (parts per 100) to perden (parts per NUM_FRAC_DENOM). */
 295         POSITION perden = (percent * (NUM_FRAC_DENOM / 100)) + (fraction / 100);
 296
 297         if (perden == 0)
 298                 return (0);
 299         return (POSITION) muldiv(pos, perden, (POSITION) NUM_FRAC_DENOM);
 300 }
 301
 302 #if !HAVE_STRCHR
 303 /*
 304  * strchr is used by regexp.c.
 305  */
 306         char *
 307 strchr(s, c)
 308         char *s;
 309         int c;
 310 {
 311         for ( ;  *s != '\0';  s++)
 312                 if (*s == c)
 313                         return (s);
 314         if (c == '\0')
 315                 return (s);
 316         return (NULL);
 317 }
 318 #endif
 319
 320 #if !HAVE_MEMCPY
 321         VOID_POINTER
 322 memcpy(dst, src, len)
 323         VOID_POINTER dst;
 324         VOID_POINTER src;
 325         int len;
 326 {
 327         char *dstp = (char *) dst;
 328         char *srcp = (char *) src;
 329         int i;
 330
 331         for (i = 0;  i < len;  i++)
 332                 dstp[i] = srcp[i];
 333         return (dst);
 334 }
 335 #endif
 336
 337 #ifdef _OSK_MWC32
 338
 339 /*
 340  * This implements an ANSI-style intercept setup for Microware C 3.2
 341  */
 342         public int
 343 os9_signal(type, handler)
 344         int type;
 345         RETSIGTYPE (*handler)();
 346 {
 347         intercept(handler);
 348 }
 349
 350 #include <sgstat.h>
 351
 352         int
 353 isatty(f)
 354         int f;
 355 {
 356         struct sgbuf sgbuf;
 357
 358         if (_gs_opt(f, &sgbuf) < 0)
 359                 return -1;
 360         return (sgbuf.sg_class == 0);
 361 }
 362
 363 #endif