contrib/less/os.c

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