lib/interestingtimes.c

   1 /* interestingtimes.c - cursor control
   2  *
   3  * Copyright 2015 Rob Landley <rob@landley.net>
   4  */
   5
   6 #include "toys.h"
   7
   8 int xgettty(void)
   9 {
  10   int i, j;
  11
  12   for (i = 0; i<3; i++) if (isatty(j = (i+1)%3)) return j;
  13
  14   return xopen("/dev/tty", O_RDWR);
  15 }
  16
  17 // Quick and dirty query size of terminal, doesn't do ANSI probe fallback.
  18 // set x=80 y=25 before calling to provide defaults. Returns 0 if couldn't
  19 // determine size.
  20
  21 int terminal_size(unsigned *xx, unsigned *yy)
  22 {
  23   struct winsize ws;
  24   unsigned i, x = 0, y = 0;
  25   char *s;
  26
  27   // stdin, stdout, stderr
  28   for (i=0; i<3; i++) {
  29     memset(&ws, 0, sizeof(ws));
  30     if (!ioctl(i, TIOCGWINSZ, &ws)) {
  31       if (ws.ws_col) x = ws.ws_col;
  32       if (ws.ws_row) y = ws.ws_row;
  33
  34       break;
  35     }
  36   }
  37   s = getenv("COLUMNS");
  38   if (s) sscanf(s, "%u", &x);
  39   s = getenv("LINES");
  40   if (s) sscanf(s, "%u", &y);
  41
  42   // Never return 0 for either value, leave it at default instead.
  43   if (xx && x) *xx = x;
  44   if (yy && y) *yy = y;
  45
  46   return x || y;
  47 }
  48
  49 // Query terminal size, sending ANSI probe if necesary. (Probe queries xterm
  50 // size through serial connection, when local TTY doesn't know but remote does.)
  51 // Returns 0 if ANSI probe sent, 1 if size determined from tty or environment
  52
  53 int terminal_probesize(unsigned *xx, unsigned *yy)
  54 {
  55   if (terminal_size(xx, yy) && (!xx || *xx) && (!yy || *yy)) return 1;
  56
  57   // Send probe: bookmark cursor position, jump to bottom right,
  58   // query position, return cursor to bookmarked position.
  59   xprintf("\e[s\e[999C\e[999B\e[6n\e[u");
  60
  61   return 0;
  62 }
  63
  64 // Wrapper that parses results from ANSI probe to update screensize.
  65 // Otherwise acts like scan_key()
  66 int scan_key_getsize(char *scratch, int miliwait, unsigned *xx, unsigned *yy)
  67 {
  68   int key;
  69
  70   if (512&(key = scan_key(scratch, miliwait))) {
  71     if (key>0) {
  72       if (xx) *xx = (key>>10)&1023;
  73       if (yy) *yy = (key>>20)&1023;
  74       toys.signal = SIGWINCH;
  75
  76       return -3;
  77     }
  78   }
  79
  80   return key;
  81 }
  82
  83 // Reset terminal to known state, saving copy of old state if old != NULL.
  84 int set_terminal(int fd, int raw, struct termios *old)
  85 {
  86   struct termios termio;
  87
  88   // Fetch local copy of old terminfo, and copy struct contents to *old if set
  89   if (!tcgetattr(fd, &termio) && old) *old = termio;
  90
  91   // the following are the bits set for an xterm. Linux text mode TTYs by
  92   // default add two additional bits that only matter for serial processing
  93   // (turn serial line break into an interrupt, and XON/XOFF flow control)
  94
  95   // Any key unblocks output, swap CR and NL on input
  96   termio.c_iflag = IXANY|ICRNL|INLCR;
  97   if (toys.which->flags & TOYFLAG_LOCALE) termio.c_iflag |= IUTF8;
  98
  99   // Output appends CR to NL, does magic undocumented postprocessing
 100   termio.c_oflag = ONLCR|OPOST;
 101
 102   // Leave serial port speed alone
 103   // termio.c_cflag = C_READ|CS8|EXTB;
 104
 105   // Generate signals, input entire line at once, echo output
 106   // erase, line kill, escape control characters with ^
 107   // erase line char at a time
 108   // "extended" behavior: ctrl-V quotes next char, ctrl-R reprints unread chars,
 109   // ctrl-W erases word
 110   termio.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
 111
 112   if (raw) cfmakeraw(&termio);
 113
 114   return tcsetattr(fd, TCSANOW, &termio);
 115 }
 116
 117 void xset_terminal(int fd, int raw, struct termios *old)
 118 {
 119   if (-1 == set_terminal(fd, raw, old)) perror_exit("bad tty fd#%d", fd);
 120 }
 121
 122 struct scan_key_list {
 123   char *name, *seq;
 124 } static const scan_key_list[] = TAGGED_ARRAY(KEY,
 125   // up down right left pgup pgdn home end ins
 126   {"UP", "\033[A"}, {"DOWN", "\033[B"}, {"RIGHT", "\033[C"}, {"LEFT", "\033[D"},
 127   {"PGUP", "\033[5~"}, {"PGDN", "\033[6~"}, {"HOME", "\033OH"},
 128   {"END", "\033OF"}, {"INSERT", "\033[2~"},
 129
 130   {"F1", "\033OP"}, {"F2", "\033OQ"}, {"F3", "\033OR"}, {"F4", "\033OS"},
 131   {"F5", "\033[15~"}, {"F6", "\033[17~"}, {"F7", "\033[18~"},
 132   {"F8", "\033[19~"}, {"F9", "\033[20~"},
 133
 134   {"SUP", "\033[1;2A"}, {"AUP", "\033[1;3A"}, {"CUP", "\033[1;5A"},
 135   {"SDOWN", "\033[1;2B"}, {"ADOWN", "\033[1;3B"}, {"CDOWN", "\033[1;5B"},
 136   {"SRIGHT", "\033[1;2C"}, {"ARIGHT", "\033[1;3C"}, {"CRIGHT", "\033[1;5C"},
 137   {"SLEFT", "\033[1;2D"}, {"ALEFT", "\033[1;3D"}, {"CLEFT", "\033[1;5D"},
 138
 139   {"SF1", "\033O1;2P"}, {"AF1", "\033O1;3P"}, {"CF1", "\033[1;5P"}
 140 );
 141
 142 // Scan stdin for a keypress, parsing known escape sequences
 143 // Blocks for miliwait miliseconds, none 0, forever if -1
 144 // Returns: 0-255=literal, -1=EOF, -2=NONE, 256-...=index into scan_key_list
 145 // >512 is x<<9+y<<21
 146 // scratch space is necessary because last char of !seq could start new seq
 147 // Zero out first byte of scratch before first call to scan_key
 148 // block=0 allows fetching multiple characters before updating display
 149 int scan_key(char *scratch, int miliwait)
 150 {
 151   struct pollfd pfd;
 152   int maybe, i, j;
 153   char *test;
 154
 155   for (;;) {
 156     pfd.fd = 0;
 157     pfd.events = POLLIN;
 158     pfd.revents = 0;
 159
 160     maybe = 0;
 161     if (*scratch) {
 162       int pos[6];
 163       unsigned x, y;
 164
 165       // Check for return from terminal size probe
 166       memset(pos, 0, 6*sizeof(int));
 167       scratch[(1+*scratch)&15] = 0;
 168       sscanf(scratch+1, "\033%n[%n%3u%n;%n%3u%nR%n", pos, pos+1, &y,
 169              pos+2, pos+3, &x, pos+4, pos+5);
 170       if (pos[5]) {
 171         // Recognized X/Y position, consume and return
 172         *scratch = 0;
 173         return 512+(x<<10)+(y<<20);
 174       } else for (i=0; i<6; i++) if (pos[i]==*scratch) maybe = 1;
 175
 176       // Check sequences
 177       for (i = 0; i<ARRAY_LEN(scan_key_list); i++) {
 178         test = scan_key_list[i].seq;
 179         for (j = 0; j<*scratch; j++) if (scratch[j+1] != test[j]) break;
 180         if (j == *scratch) {
 181           maybe = 1;
 182           if (!test[j]) {
 183             // We recognized current sequence: consume and return
 184             *scratch = 0;
 185             return 256+i;
 186           }
 187         }
 188       }
 189
 190       // If current data can't be a known sequence, return next raw char
 191       if (!maybe) break;
 192     }
 193
 194     // Need more data to decide
 195
 196     // 30 miliseconds is about the gap between characters at 300 baud
 197     if (maybe || miliwait != -1)
 198       if (!xpoll(&pfd, 1, maybe ? 30 : miliwait)) break;
 199
 200     // Read 1 byte so we don't overshoot sequence match. (We can deviate
 201     // and fail to match, but match consumes entire buffer.)
 202     if (toys.signal || 1 != read(0, scratch+1+*scratch, 1))
 203       return toys.signal ? -3 : -1;
 204     ++*scratch;
 205   }
 206
 207   // Was not a sequence
 208   if (!*scratch) return -2;
 209   i = scratch[1];
 210   if (--*scratch) memmove(scratch+1, scratch+2, *scratch);
 211
 212   return i;
 213 }
 214
 215 void tty_esc(char *s)
 216 {
 217   printf("\033[%s", s);
 218 }
 219
 220 void tty_jump(int x, int y)
 221 {
 222   char s[32];
 223
 224   sprintf(s, "%d;%dH", y+1, x+1);
 225   tty_esc(s);
 226 }
 227
 228 void tty_reset(void)
 229 {
 230   set_terminal(0, 0, 0);
 231   tty_esc("?25h");
 232   tty_esc("0m");
 233   tty_jump(0, 999);
 234   tty_esc("K");
 235   fflush(0);
 236 }
 237
 238 // If you call set_terminal(), use sigatexit(tty_sigreset);
 239 void tty_sigreset(int i)
 240 {
 241   tty_reset();
 242   _exit(i ? 128+i : 0);
 243 }