?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement layout related interface.
[screen-lua.git] / src / process.c
blobaf554ce8c0b438e31581949a132d134a075a50bc
1 /* Copyright (c) 2008, 2009
2 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
3 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
4 * Micah Cowan (micah@cowan.name)
5 * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
6 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
7 * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
8 * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
9 * Copyright (c) 1987 Oliver Laumann
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 3, or (at your option)
14 * any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program (see the file COPYING); if not, see
23 * http://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
25 *
26 ****************************************************************
27 */
28
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <signal.h>
32 #include <fcntl.h>
33 #if !defined(sun) && !defined(B43) && !defined(ISC) && !defined(pyr) && !defined(_CX_UX)
34 # include <time.h>
35 #endif
36 #include <sys/time.h>
37 #ifndef sun
38 #include <sys/ioctl.h>
39 #endif
40
41
42 #include "config.h"
43
44 /* for solaris 2.1, Unixware (SVR4.2) and possibly others: */
45 #ifdef HAVE_STROPTS_H
46 # include <sys/stropts.h>
47 #endif
48
49 #include "screen.h"
50 #include "extern.h"
51 #include "logfile.h"
52
53 extern struct comm comms[];
54 extern char *rc_name;
55 extern char *RcFileName, *home;
56 extern char *BellString, *ActivityString, *ShellProg, *ShellArgs[];
57 extern char *hstatusstring, *captionstring, *timestring;
58 extern char *wliststr, *wlisttit;
59 extern int captionalways;
60 extern char *hardcopydir, *screenlogfile, *logtstamp_string;
61 extern int log_flush, logtstamp_on, logtstamp_after;
62 extern char *VisualBellString;
63 extern int VBellWait, MsgWait, MsgMinWait, SilenceWait;
64 extern char SockPath[], *SockName;
65 extern int TtyMode, auto_detach, use_altscreen;
66 extern int iflag, maxwin;
67 extern int focusminwidth, focusminheight;
68 extern int use_hardstatus, visual_bell;
69 #ifdef COLOR
70 extern int attr2color[][4];
71 extern int nattr2color;
72 #endif
73 extern int hardstatusemu;
74 extern char *printcmd;
75 extern int default_startup;
76 extern int defobuflimit;
77 extern int defnonblock;
78 extern int ZombieKey_destroy;
79 extern int ZombieKey_resurrect;
80 extern int ZombieKey_onerror;
81 #ifdef AUTO_NUKE
82 extern int defautonuke;
83 #endif
84 extern int separate_sids;
85 extern struct NewWindow nwin_default, nwin_undef;
86 #ifdef COPY_PASTE
87 extern int join_with_cr;
88 extern int compacthist;
89 extern int search_ic;
90 # ifdef FONT
91 extern int pastefont;
92 # endif
93 extern unsigned char mark_key_tab[];
94 extern char *BufferFile;
95 #endif
96 #ifdef POW_DETACH
97 extern char *BufferFile, *PowDetachString;
98 #endif
99 #ifdef MULTIUSER
100 extern struct acluser *EffectiveAclUser; /* acl.c */
101 #endif
102 extern struct term term[]; /* terminal capabilities */
103 #ifdef MAPKEYS
104 extern char *kmapdef[];
105 extern char *kmapadef[];
106 extern char *kmapmdef[];
107 #endif
108 extern struct mchar mchar_so, mchar_null;
109 extern int renditions[];
110 extern int VerboseCreate;
111 #ifdef UTF8
112 extern char *screenencodings;
113 #endif
114 #ifdef DW_CHARS
115 extern int cjkwidth;
116 #endif
117
118 static int CheckArgNum __P((int, char **));
119 static void ClearAction __P((struct action *));
120 static void SaveAction __P((struct action *, int, char **, int *));
121 static int NextWindow __P((void));
122 static int PreviousWindow __P((void));
123 static int MoreWindows __P((void));
124 static void LogToggle __P((int));
125 static void ShowInfo __P((void));
126 static void ShowDInfo __P((void));
127 static struct win *WindowByName __P((char *));
128 static int WindowByNumber __P((char *));
129 static int ParseOnOff __P((struct action *, int *));
130 static int ParseWinNum __P((struct action *, int *));
131 static int ParseBase __P((struct action *, char *, int *, int, char *));
132 static int ParseNum1000 __P((struct action *, int *));
133 static char **SaveArgs __P((char **));
134 static int IsNum __P((char *, int));
135 static void Colonfin __P((char *, int, char *));
136 static void InputSelect __P((void));
137 static void InputSetenv __P((char *));
138 static void InputAKA __P((void));
139 #ifdef MULTIUSER
140 static int InputSu __P((struct win *, struct acluser **, char *));
141 static void su_fin __P((char *, int, char *));
142 #endif
143 static void AKAfin __P((char *, int, char *));
144 #ifdef COPY_PASTE
145 static void copy_reg_fn __P((char *, int, char *));
146 static void ins_reg_fn __P((char *, int, char *));
147 #endif
148 static void process_fn __P((char *, int, char *));
149 #ifdef PASSWORD
150 static void pass1 __P((char *, int, char *));
151 static void pass2 __P((char *, int, char *));
152 #endif
153 #ifdef POW_DETACH
154 static void pow_detach_fn __P((char *, int, char *));
155 #endif
156 static void digraph_fn __P((char *, int, char *));
157 static int digraph_find __P((const char *buf));
158 static void confirm_fn __P((char *, int, char *));
159 static int IsOnDisplay __P((struct win *));
160 static void ResizeRegions __P((char *, int));
161 static void ResizeFin __P((char *, int, char *));
162 static struct action *FindKtab __P((char *, int));
163 static void SelectFin __P((char *, int, char *));
164 static void SelectLayoutFin __P((char *, int, char *));
165
166 /* Alias */
167 static void AddAlias __P((const char *name, const char *val , char **args, int *argl, int count));
168 static struct alias * FindAlias __P((const char *name));
169 static struct alias * FindAliasnr __P((int));
170 static void DelAlias __P((const char *name));
171 static int DoAlias __P((const char *, char **, int *));
172
173 extern struct layer *flayer;
174 extern struct display *display, *displays;
175 extern struct win *fore, *console_window, *windows;
176 extern struct acluser *users;
177 extern struct layout *layouts, *layout_attach, layout_last_marker;
178 extern struct layout *laytab[];
179
180 extern char screenterm[], HostName[], version[];
181 extern struct NewWindow nwin_undef, nwin_default;
182 extern struct LayFuncs WinLf, MarkLf;
183
184 extern int Z0width, Z1width;
185 extern int real_uid, real_gid;
186
187 #ifdef NETHACK
188 extern int nethackflag;
189 #endif
190
191
192 struct win *wtab[MAXWIN]; /* window table, should be dynamic */
193
194 #ifdef MULTIUSER
195 extern char *multi;
196 extern int maxusercount;
197 #endif
198 char NullStr[] = "";
199
200 struct plop plop_tab[MAX_PLOP_DEFS];
201
202 #ifndef PTYMODE
203 # define PTYMODE 0622
204 #endif
205
206 int TtyMode = PTYMODE;
207 int hardcopy_append = 0;
208 int all_norefresh = 0;
209 #ifdef ZMODEM
210 int zmodem_mode = 0;
211 char *zmodem_sendcmd;
212 char *zmodem_recvcmd;
213 static char *zmodes[4] = {"off", "auto", "catch", "pass"};
214 #endif
215
216 int idletimo;
217 struct action idleaction;
218 #ifdef BLANKER_PRG
219 char **blankerprg;
220 #endif
221
222 struct action ktab[256 + KMAP_KEYS]; /* command key translation table */
223 struct kclass {
224 struct kclass *next;
225 char *name;
226 struct action ktab[256 + KMAP_KEYS];
227 };
228 struct kclass *kclasses;
229
230 #ifdef MAPKEYS
231 struct action umtab[KMAP_KEYS+KMAP_AKEYS];
232 struct action dmtab[KMAP_KEYS+KMAP_AKEYS];
233 struct action mmtab[KMAP_KEYS+KMAP_AKEYS];
234 struct kmap_ext *kmap_exts;
235 int kmap_extn;
236 static int maptimeout = 300;
237 #endif
238
239 #ifndef MAX_DIGRAPH
240 #define MAX_DIGRAPH 512
241 #endif
242
243 struct digraph
244 {
245 unsigned char d[2];
246 int value;
247 };
248
249 /*
250 * Command aliases.
251 */
252 struct alias {
253 int nr;
254 char *name; /* Name of the alias */
255 int cmdnr; /* Number of the command this is alias for */
256 char **args; /* The argument list for the command */
257 int *argl;
258 struct alias *next;
259 };
260 struct alias *g_aliases_list = NULL;
261
262
263 /* digraph table taken from old vim and rfc1345 */
264 static struct digraph digraphs[MAX_DIGRAPH + 1] = {
265 {' ', ' ', 160}, /*   */
266 {'N', 'S', 160}, /*   */
267 {'~', '!', 161}, /* ¡ */
268 {'!', '!', 161}, /* ¡ */
269 {'!', 'I', 161}, /* ¡ */
270 {'c', '|', 162}, /* ¢ */
271 {'c', 't', 162}, /* ¢ */
272 {'$', '$', 163}, /* £ */
273 {'P', 'd', 163}, /* £ */
274 {'o', 'x', 164}, /* ¤ */
275 {'C', 'u', 164}, /* ¤ */
276 {'C', 'u', 164}, /* ¤ */
277 {'E', 'u', 164}, /* ¤ */
278 {'Y', '-', 165}, /* ¥ */
279 {'Y', 'e', 165}, /* ¥ */
280 {'|', '|', 166}, /* ¦ */
281 {'B', 'B', 166}, /* ¦ */
282 {'p', 'a', 167}, /* § */
283 {'S', 'E', 167}, /* § */
284 {'"', '"', 168}, /* ¨ */
285 {'\'', ':', 168}, /* ¨ */
286 {'c', 'O', 169}, /* © */
287 {'C', 'o', 169}, /* © */
288 {'a', '-', 170}, /* ª */
289 {'<', '<', 171}, /* « */
290 {'-', ',', 172}, /* ¬ */
291 {'N', 'O', 172}, /* ¬ */
292 {'-', '-', 173}, /* ­ */
293 {'r', 'O', 174}, /* ® */
294 {'R', 'g', 174}, /* ® */
295 {'-', '=', 175}, /* ¯ */
296 {'\'', 'm', 175}, /* ¯ */
297 {'~', 'o', 176}, /* ° */
298 {'D', 'G', 176}, /* ° */
299 {'+', '-', 177}, /* ± */
300 {'2', '2', 178}, /* ² */
301 {'2', 'S', 178}, /* ² */
302 {'3', '3', 179}, /* ³ */
303 {'3', 'S', 179}, /* ³ */
304 {'\'', '\'', 180}, /* ´ */
305 {'j', 'u', 181}, /* µ */
306 {'M', 'y', 181}, /* µ */
307 {'p', 'p', 182}, /* ¶ */
308 {'P', 'I', 182}, /* ¶ */
309 {'~', '.', 183}, /* · */
310 {'.', 'M', 183}, /* · */
311 {',', ',', 184}, /* ¸ */
312 {'\'', ',', 184}, /* ¸ */
313 {'1', '1', 185}, /* ¹ */
314 {'1', 'S', 185}, /* ¹ */
315 {'o', '-', 186}, /* º */
316 {'>', '>', 187}, /* » */
317 {'1', '4', 188}, /* ¼ */
318 {'1', '2', 189}, /* ½ */
319 {'3', '4', 190}, /* ¾ */
320 {'~', '?', 191}, /* ¿ */
321 {'?', '?', 191}, /* ¿ */
322 {'?', 'I', 191}, /* ¿ */
323 {'A', '`', 192}, /* À */
324 {'A', '!', 192}, /* À */
325 {'A', '\'', 193}, /* Á */
326 {'A', '^', 194}, /* Â */
327 {'A', '>', 194}, /* Â */
328 {'A', '~', 195}, /* Ã */
329 {'A', '?', 195}, /* Ã */
330 {'A', '"', 196}, /* Ä */
331 {'A', ':', 196}, /* Ä */
332 {'A', '@', 197}, /* Å */
333 {'A', 'A', 197}, /* Å */
334 {'A', 'E', 198}, /* Æ */
335 {'C', ',', 199}, /* Ç */
336 {'E', '`', 200}, /* È */
337 {'E', '!', 200}, /* È */
338 {'E', '\'', 201}, /* É */
339 {'E', '^', 202}, /* Ê */
340 {'E', '>', 202}, /* Ê */
341 {'E', '"', 203}, /* Ë */
342 {'E', ':', 203}, /* Ë */
343 {'I', '`', 204}, /* Ì */
344 {'I', '!', 204}, /* Ì */
345 {'I', '\'', 205}, /* Í */
346 {'I', '^', 206}, /* Î */
347 {'I', '>', 206}, /* Î */
348 {'I', '"', 207}, /* Ï */
349 {'I', ':', 207}, /* Ï */
350 {'D', '-', 208}, /* Ð */
351 {'N', '~', 209}, /* Ñ */
352 {'N', '?', 209}, /* Ñ */
353 {'O', '`', 210}, /* Ò */
354 {'O', '!', 210}, /* Ò */
355 {'O', '\'', 211}, /* Ó */
356 {'O', '^', 212}, /* Ô */
357 {'O', '>', 212}, /* Ô */
358 {'O', '~', 213}, /* Õ */
359 {'O', '?', 213}, /* Õ */
360 {'O', '"', 214}, /* Ö */
361 {'O', ':', 214}, /* Ö */
362 {'/', '\\', 215}, /* × */
363 {'*', 'x', 215}, /* × */
364 {'O', '/', 216}, /* Ø */
365 {'U', '`', 217}, /* Ù */
366 {'U', '!', 217}, /* Ù */
367 {'U', '\'', 218}, /* Ú */
368 {'U', '^', 219}, /* Û */
369 {'U', '>', 219}, /* Û */
370 {'U', '"', 220}, /* Ü */
371 {'U', ':', 220}, /* Ü */
372 {'Y', '\'', 221}, /* Ý */
373 {'I', 'p', 222}, /* Þ */
374 {'T', 'H', 222}, /* Þ */
375 {'s', 's', 223}, /* ß */
376 {'s', '"', 223}, /* ß */
377 {'a', '`', 224}, /* à */
378 {'a', '!', 224}, /* à */
379 {'a', '\'', 225}, /* á */
380 {'a', '^', 226}, /* â */
381 {'a', '>', 226}, /* â */
382 {'a', '~', 227}, /* ã */
383 {'a', '?', 227}, /* ã */
384 {'a', '"', 228}, /* ä */
385 {'a', ':', 228}, /* ä */
386 {'a', 'a', 229}, /* å */
387 {'a', 'e', 230}, /* æ */
388 {'c', ',', 231}, /* ç */
389 {'e', '`', 232}, /* è */
390 {'e', '!', 232}, /* è */
391 {'e', '\'', 233}, /* é */
392 {'e', '^', 234}, /* ê */
393 {'e', '>', 234}, /* ê */
394 {'e', '"', 235}, /* ë */
395 {'e', ':', 235}, /* ë */
396 {'i', '`', 236}, /* ì */
397 {'i', '!', 236}, /* ì */
398 {'i', '\'', 237}, /* í */
399 {'i', '^', 238}, /* î */
400 {'i', '>', 238}, /* î */
401 {'i', '"', 239}, /* ï */
402 {'i', ':', 239}, /* ï */
403 {'d', '-', 240}, /* ð */
404 {'n', '~', 241}, /* ñ */
405 {'n', '?', 241}, /* ñ */
406 {'o', '`', 242}, /* ò */
407 {'o', '!', 242}, /* ò */
408 {'o', '\'', 243}, /* ó */
409 {'o', '^', 244}, /* ô */
410 {'o', '>', 244}, /* ô */
411 {'o', '~', 245}, /* õ */
412 {'o', '?', 245}, /* õ */
413 {'o', '"', 246}, /* ö */
414 {'o', ':', 246}, /* ö */
415 {':', '-', 247}, /* ÷ */
416 {'o', '/', 248}, /* ø */
417 {'u', '`', 249}, /* ù */
418 {'u', '!', 249}, /* ù */
419 {'u', '\'', 250}, /* ú */
420 {'u', '^', 251}, /* û */
421 {'u', '>', 251}, /* û */
422 {'u', '"', 252}, /* ü */
423 {'u', ':', 252}, /* ü */
424 {'y', '\'', 253}, /* ý */
425 {'i', 'p', 254}, /* þ */
426 {'t', 'h', 254}, /* þ */
427 {'y', '"', 255}, /* ÿ */
428 {'y', ':', 255}, /* ÿ */
429 {'"', '[', 196}, /* Ä */
430 {'"', '\\', 214}, /* Ö */
431 {'"', ']', 220}, /* Ü */
432 {'"', '{', 228}, /* ä */
433 {'"', '|', 246}, /* ö */
434 {'"', '}', 252}, /* ü */
435 {'"', '~', 223} /* ß */
436 };
437
438 #define RESIZE_FLAG_H 1
439 #define RESIZE_FLAG_V 2
440 #define RESIZE_FLAG_L 4
441
442 static char *resizeprompts[] = {
443 "resize # lines: ",
444 "resize -h # lines: ",
445 "resize -v # lines: ",
446 "resize -b # lines: ",
447 "resize -l # lines: ",
448 "resize -l -h # lines: ",
449 "resize -l -v # lines: ",
450 "resize -l -b # lines: ",
451 };
452
453 static int
454 parse_input_int(buf, len, val)
455 const char *buf;
456 int len;
457 int *val;
458 {
459 int x = 0, i;
460 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
461 {
462 x = 0;
463 for (i = 2; i < len; i++)
464 {
465 if (buf[i] >= '0' && buf[i] <= '9')
466 x = x * 16 | (buf[i] - '0');
467 else if (buf[i] >= 'a' && buf[i] <= 'f')
468 x = x * 16 | (buf[i] - ('a' - 10));
469 else if (buf[i] >= 'A' && buf[i] <= 'F')
470 x = x * 16 | (buf[i] - ('A' - 10));
471 else
472 return 0;
473 }
474 }
475 else if (buf[0] == '0')
476 {
477 x = 0;
478 for (i = 1; i < len; i++)
479 {
480 if (buf[i] < '0' || buf[i] > '7')
481 return 0;
482 x = x * 8 | (buf[i] - '0');
483 }
484 }
485 else
486 return 0;
487 *val = x;
488 return 1;
489 }
490
491 char *noargs[1];
492
493 void
494 InitKeytab()
495 {
496 register unsigned int i;
497 #ifdef MAPKEYS
498 char *argarr[2];
499 #endif
500
501 for (i = 0; i < sizeof(ktab)/sizeof(*ktab); i++)
502 {
503 ktab[i].nr = RC_ILLEGAL;
504 ktab[i].args = noargs;
505 ktab[i].argl = 0;
506 }
507 #ifdef MAPKEYS
508 for (i = 0; i < KMAP_KEYS+KMAP_AKEYS; i++)
509 {
510 umtab[i].nr = RC_ILLEGAL;
511 umtab[i].args = noargs;
512 umtab[i].argl = 0;
513 dmtab[i].nr = RC_ILLEGAL;
514 dmtab[i].args = noargs;
515 dmtab[i].argl = 0;
516 mmtab[i].nr = RC_ILLEGAL;
517 mmtab[i].args = noargs;
518 mmtab[i].argl = 0;
519 }
520 argarr[1] = 0;
521 for (i = 0; i < NKMAPDEF; i++)
522 {
523 if (i + KMAPDEFSTART < T_CAPS)
524 continue;
525 if (i + KMAPDEFSTART >= T_CAPS + KMAP_KEYS)
526 continue;
527 if (kmapdef[i] == 0)
528 continue;
529 argarr[0] = kmapdef[i];
530 SaveAction(dmtab + i + (KMAPDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
531 }
532 for (i = 0; i < NKMAPADEF; i++)
533 {
534 if (i + KMAPADEFSTART < T_CURSOR)
535 continue;
536 if (i + KMAPADEFSTART >= T_CURSOR + KMAP_AKEYS)
537 continue;
538 if (kmapadef[i] == 0)
539 continue;
540 argarr[0] = kmapadef[i];
541 SaveAction(dmtab + i + (KMAPADEFSTART - T_CURSOR + KMAP_KEYS), RC_STUFF, argarr, 0);
542 }
543 for (i = 0; i < NKMAPMDEF; i++)
544 {
545 if (i + KMAPMDEFSTART < T_CAPS)
546 continue;
547 if (i + KMAPMDEFSTART >= T_CAPS + KMAP_KEYS)
548 continue;
549 if (kmapmdef[i] == 0)
550 continue;
551 argarr[0] = kmapmdef[i];
552 argarr[1] = 0;
553 SaveAction(mmtab + i + (KMAPMDEFSTART - T_CAPS), RC_STUFF, argarr, 0);
554 }
555 #endif
556
557 ktab['h'].nr = RC_HARDCOPY;
558 #ifdef BSDJOBS
559 ktab['z'].nr = ktab[Ctrl('z')].nr = RC_SUSPEND;
560 #endif
561 ktab['c'].nr = ktab[Ctrl('c')].nr = RC_SCREEN;
562 ktab[' '].nr = ktab[Ctrl(' ')].nr =
563 ktab['n'].nr = ktab[Ctrl('n')].nr = RC_NEXT;
564 ktab['N'].nr = RC_NUMBER;
565 ktab[Ctrl('h')].nr = ktab[0177].nr = ktab['p'].nr = ktab[Ctrl('p')].nr = RC_PREV;
566 ktab['k'].nr = ktab[Ctrl('k')].nr = RC_KILL;
567 ktab['l'].nr = ktab[Ctrl('l')].nr = RC_REDISPLAY;
568 ktab['w'].nr = ktab[Ctrl('w')].nr = RC_WINDOWS;
569 ktab['v'].nr = RC_VERSION;
570 ktab[Ctrl('v')].nr = RC_DIGRAPH;
571 ktab['q'].nr = ktab[Ctrl('q')].nr = RC_XON;
572 ktab['s'].nr = ktab[Ctrl('s')].nr = RC_XOFF;
573 ktab['t'].nr = ktab[Ctrl('t')].nr = RC_TIME;
574 ktab['i'].nr = ktab[Ctrl('i')].nr = RC_INFO;
575 ktab['m'].nr = ktab[Ctrl('m')].nr = RC_LASTMSG;
576 ktab['A'].nr = RC_TITLE;
577 #if defined(UTMPOK) && defined(LOGOUTOK)
578 ktab['L'].nr = RC_LOGIN;
579 #endif
580 ktab[','].nr = RC_LICENSE;
581 ktab['W'].nr = RC_WIDTH;
582 ktab['.'].nr = RC_DUMPTERMCAP;
583 ktab[Ctrl('\\')].nr = RC_QUIT;
584 #ifdef DETACH
585 ktab['d'].nr = ktab[Ctrl('d')].nr = RC_DETACH;
586 # ifdef POW_DETACH
587 ktab['D'].nr = RC_POW_DETACH;
588 # endif
589 #endif
590 ktab['r'].nr = ktab[Ctrl('r')].nr = RC_WRAP;
591 ktab['f'].nr = ktab[Ctrl('f')].nr = RC_FLOW;
592 ktab['C'].nr = RC_CLEAR;
593 ktab['Z'].nr = RC_RESET;
594 ktab['H'].nr = RC_LOG;
595 ktab['M'].nr = RC_MONITOR;
596 ktab['?'].nr = RC_HELP;
597 #ifdef MULTI
598 ktab['*'].nr = RC_DISPLAYS;
599 #endif
600 {
601 char *args[2];
602 args[0] = "-";
603 args[1] = NULL;
604 SaveAction(ktab + '-', RC_SELECT, args, 0);
605 }
606 for (i = 0; i < ((MAXWIN < 10) ? MAXWIN : 10); i++)
607 {
608 char *args[2], arg1[10];
609 args[0] = arg1;
610 args[1] = 0;
611 sprintf(arg1, "%d", i);
612 SaveAction(ktab + '0' + i, RC_SELECT, args, 0);
613 }
614 ktab['\''].nr = RC_SELECT; /* calling a window by name */
615 {
616 char *args[2];
617 args[0] = "-b";
618 args[1] = 0;
619 SaveAction(ktab + '"', RC_WINDOWLIST, args, 0);
620 }
621 ktab[Ctrl('G')].nr = RC_VBELL;
622 ktab[':'].nr = RC_COLON;
623 #ifdef COPY_PASTE
624 ktab['['].nr = ktab[Ctrl('[')].nr = RC_COPY;
625 {
626 char *args[2];
627 args[0] = ".";
628 args[1] = 0;
629 SaveAction(ktab + ']', RC_PASTE, args, 0);
630 SaveAction(ktab + Ctrl(']'), RC_PASTE, args, 0);
631 }
632 ktab['{'].nr = RC_HISTORY;
633 ktab['}'].nr = RC_HISTORY;
634 ktab['>'].nr = RC_WRITEBUF;
635 ktab['<'].nr = RC_READBUF;
636 ktab['='].nr = RC_REMOVEBUF;
637 #endif
638 #ifdef POW_DETACH
639 ktab['D'].nr = RC_POW_DETACH;
640 #endif
641 #ifdef LOCK
642 ktab['x'].nr = ktab[Ctrl('x')].nr = RC_LOCKSCREEN;
643 #endif
644 ktab['b'].nr = ktab[Ctrl('b')].nr = RC_BREAK;
645 ktab['B'].nr = RC_POW_BREAK;
646 ktab['_'].nr = RC_SILENCE;
647 ktab['S'].nr = RC_SPLIT;
648 ktab['Q'].nr = RC_ONLY;
649 ktab['X'].nr = RC_REMOVE;
650 ktab['F'].nr = RC_FIT;
651 ktab['\t'].nr = RC_FOCUS;
652 {
653 char *args[2];
654 args[0] = "up";
655 args[1] = 0;
656 SaveAction(ktab + T_BACKTAB - T_CAPS + 256, RC_FOCUS, args, 0);
657 }
658 {
659 char *args[2];
660 args[0] = "-v";
661 args[1] = 0;
662 SaveAction(ktab + '|', RC_SPLIT, args, 0);
663 }
664 /* These come last; they may want overwrite others: */
665 if (DefaultEsc >= 0)
666 {
667 ClearAction(&ktab[DefaultEsc]);
668 ktab[DefaultEsc].nr = RC_OTHER;
669 }
670 if (DefaultMetaEsc >= 0)
671 {
672 ClearAction(&ktab[DefaultMetaEsc]);
673 ktab[DefaultMetaEsc].nr = RC_META;
674 }
675
676 idleaction.nr = RC_BLANKER;
677 idleaction.args = noargs;
678 idleaction.argl = 0;
679 }
680
681 static struct action *
682 FindKtab(class, create)
683 char *class;
684 int create;
685 {
686 struct kclass *kp, **kpp;
687 int i;
688
689 if (class == 0)
690 return ktab;
691 for (kpp = &kclasses; (kp = *kpp) != 0; kpp = &kp->next)
692 if (!strcmp(kp->name, class))
693 break;
694 if (kp == 0)
695 {
696 if (!create)
697 return 0;
698 if (strlen(class) > 80)
699 {
700 Msg(0, "Command class name too long.");
701 return 0;
702 }
703 kp = malloc(sizeof(*kp));
704 if (kp == 0)
705 {
706 Msg(0, strnomem);
707 return 0;
708 }
709 kp->name = SaveStr(class);
710 for (i = 0; i < (int)(sizeof(kp->ktab)/sizeof(*kp->ktab)); i++)
711 {
712 kp->ktab[i].nr = RC_ILLEGAL;
713 kp->ktab[i].args = noargs;
714 }
715 kp->next = 0;
716 *kpp = kp;
717 }
718 return kp->ktab;
719 }
720
721 static void
722 ClearAction(act)
723 struct action *act;
724 {
725 char **p;
726
727 if (act->nr == RC_ILLEGAL)
728 return;
729 act->nr = RC_ILLEGAL;
730 if (act->args == noargs)
731 return;
732 for (p = act->args; *p; p++)
733 free(*p);
734 free((char *)act->args);
735 act->args = noargs;
736 act->argl = 0;
737 }
738
739 /*
740 * ProcessInput: process input from display and feed it into
741 * the layer on canvas D_forecv.
742 */
743
744 #ifdef MAPKEYS
745
746 /*
747 * This ProcessInput just does the keybindings and passes
748 * everything else on to ProcessInput2.
749 */
750
751 void
752 ProcessInput(ibuf, ilen)
753 char *ibuf;
754 int ilen;
755 {
756 int ch, slen;
757 unsigned char *s, *q;
758 int i, l;
759 char *p;
760
761 debug1("ProcessInput: %d bytes\n", ilen);
762 if (display == 0 || ilen == 0)
763 return;
764 if (D_seql)
765 evdeq(&D_mapev);
766 slen = ilen;
767 s = (unsigned char *)ibuf;
768 while (ilen-- > 0)
769 {
770 ch = *s++;
771 if (D_dontmap || !D_nseqs)
772 {
773 D_dontmap = 0;
774 continue;
775 }
776 for (;;)
777 {
778 debug3("cmp %c %c[%d]\n", ch, *D_seqp, D_seqp - D_kmaps);
779 if (*D_seqp != ch)
780 {
781 l = D_seqp[D_seqp[-D_seql-1] + 1];
782 if (l)
783 {
784 D_seqp += l * 2 + 4;
785 debug1("miss %d\n", D_seqp - D_kmaps);
786 continue;
787 }
788 debug("complete miss\n");
789 D_mapdefault = 0;
790 l = D_seql;
791 p = (char *)D_seqp - l;
792 D_seql = 0;
793 D_seqp = D_kmaps + 3;
794 if (l == 0)
795 break;
796 if ((q = D_seqh) != 0)
797 {
798 D_seqh = 0;
799 i = q[0] << 8 | q[1];
800 i &= ~KMAP_NOTIMEOUT;
801 debug1("Mapping former hit #%d - ", i);
802 debug2("%d(%s) - ", q[2], q + 3);
803 if (StuffKey(i))
804 ProcessInput2((char *)q + 3, q[2]);
805 if (display == 0)
806 return;
807 l -= q[2];
808 p += q[2];
809 }
810 else
811 D_dontmap = 1;
812 debug1("flush old %d\n", l);
813 ProcessInput(p, l);
814 if (display == 0)
815 return;
816 evdeq(&D_mapev);
817 continue;
818 }
819 if (D_seql++ == 0)
820 {
821 /* Finish old stuff */
822 slen -= ilen + 1;
823 debug1("finish old %d\n", slen);
824 if (slen)
825 ProcessInput2(ibuf, slen);
826 if (display == 0)
827 return;
828 D_seqh = 0;
829 }
830 ibuf = (char *)s;
831 slen = ilen;
832 D_seqp++;
833 l = D_seql;
834 debug2("length am %d, want %d\n", l, D_seqp[-l - 1]);
835 if (l == D_seqp[-l - 1])
836 {
837 if (D_seqp[l] != l)
838 {
839 q = D_seqp + 1 + l;
840 if (D_kmaps + D_nseqs > q && q[2] > l && !bcmp(D_seqp - l, q + 3, l))
841 {
842 debug1("have another mapping (%s), delay execution\n", q + 3);
843 D_seqh = D_seqp - 3 - l;
844 D_seqp = q + 3 + l;
845 break;
846 }
847 }
848 i = D_seqp[-l - 3] << 8 | D_seqp[-l - 2];
849 i &= ~KMAP_NOTIMEOUT;
850 debug1("Mapping #%d - ", i);
851 p = (char *)D_seqp - l;
852 debug2("%d(%s) - ", l, p);
853 D_seql = 0;
854 D_seqp = D_kmaps + 3;
855 D_seqh = 0;
856 if (StuffKey(i))
857 ProcessInput2(p, l);
858 if (display == 0)
859 return;
860 }
861 break;
862 }
863 }
864 if (D_seql)
865 {
866 debug("am in sequence -> check for timeout\n");
867 l = D_seql;
868 for (s = D_seqp; ; s += i * 2 + 4)
869 {
870 if (s[-l-3] & KMAP_NOTIMEOUT >> 8)
871 break;
872 if ((i = s[s[-l-1] + 1]) == 0)
873 {
874 SetTimeout(&D_mapev, maptimeout);
875 evenq(&D_mapev);
876 break;
877 }
878 }
879 }
880 ProcessInput2(ibuf, slen);
881 }
882
883 #else
884 # define ProcessInput2 ProcessInput
885 #endif
886
887
888 /*
889 * Here only the screen escape commands are handled.
890 */
891
892 void
893 ProcessInput2(ibuf, ilen)
894 char *ibuf;
895 int ilen;
896 {
897 char *s;
898 int ch, slen;
899 struct action *ktabp;
900
901 debug1("ProcessInput2: %d bytes\n", ilen);
902 while (ilen && display)
903 {
904 debug1(" - ilen now %d bytes\n", ilen);
905 flayer = D_forecv->c_layer;
906 fore = D_fore;
907 slen = ilen;
908 s = ibuf;
909 if (!D_ESCseen)
910 {
911 while (ilen > 0)
912 {
913 if ((unsigned char)*s++ == D_user->u_Esc)
914 break;
915 ilen--;
916 }
917 slen -= ilen;
918 if (slen)
919 DoProcess(fore, &ibuf, &slen, 0);
920 if (--ilen == 0)
921 D_ESCseen = ktab;
922 }
923 if (ilen <= 0)
924 return;
925 ktabp = D_ESCseen ? D_ESCseen : ktab;
926 D_ESCseen = 0;
927 ch = (unsigned char)*s;
928
929 /*
930 * As users have different esc characters, but a common ktab[],
931 * we fold back the users esc and meta-esc key to the Default keys
932 * that can be looked up in the ktab[]. grmbl. jw.
933 * XXX: make ktab[] a per user thing.
934 */
935 if (ch == D_user->u_Esc)
936 ch = DefaultEsc;
937 else if (ch == D_user->u_MetaEsc)
938 ch = DefaultMetaEsc;
939
940 if (ch >= 0)
941 DoAction(&ktabp[ch], ch);
942 ibuf = (char *)(s + 1);
943 ilen--;
944 }
945 }
946
947 void
948 DoProcess(p, bufp, lenp, pa)
949 struct win *p;
950 char **bufp;
951 int *lenp;
952 struct paster *pa;
953 {
954 int oldlen;
955 struct display *d = display;
956
957 #ifdef COPY_PASTE
958 /* XXX -> PasteStart */
959 if (pa && *lenp > 1 && p && p->w_slowpaste)
960 {
961 /* schedule slowpaste event */
962 SetTimeout(&p->w_paster.pa_slowev, p->w_slowpaste);
963 evenq(&p->w_paster.pa_slowev);
964 return;
965 }
966 #endif
967 while (flayer && *lenp)
968 {
969 #ifdef COPY_PASTE
970 if (!pa && p && p->w_paster.pa_pastelen && flayer == p->w_paster.pa_pastelayer)
971 {
972 debug("layer is busy - beep!\n");
973 WBell(p, visual_bell);
974 *bufp += *lenp;
975 *lenp = 0;
976 display = d;
977 return;
978 }
979 #endif
980 oldlen = *lenp;
981 LayProcess(bufp, lenp);
982 #ifdef COPY_PASTE
983 if (pa && !pa->pa_pastelayer)
984 break; /* flush rest of paste */
985 #endif
986 if (*lenp == oldlen)
987 {
988 if (pa)
989 {
990 display = d;
991 return;
992 }
993 /* We're full, let's beep */
994 debug("layer is full - beep!\n");
995 WBell(p, visual_bell);
996 break;
997 }
998 }
999 *bufp += *lenp;
1000 *lenp = 0;
1001 display = d;
1002 #ifdef COPY_PASTE
1003 if (pa && pa->pa_pastelen == 0)
1004 FreePaster(pa);
1005 #endif
1006 }
1007
1008 int
1009 FindCommnr(str)
1010 char *str;
1011 {
1012 int x, m, l = 0, r = RC_LAST;
1013 while (l <= r)
1014 {
1015 m = (l + r) / 2;
1016 x = strcmp(str, comms[m].name);
1017 if (x > 0)
1018 l = m + 1;
1019 else if (x < 0)
1020 r = m - 1;
1021 else
1022 return m;
1023 }
1024 return RC_ILLEGAL;
1025 }
1026
1027 static int
1028 CheckArgNum(nr, args)
1029 int nr;
1030 char **args;
1031 {
1032 int i, n;
1033 static char *argss[] = {"no", "one", "two", "three", "four", "OOPS"};
1034 static char *orformat[] =
1035 {
1036 "%s: %s: %s argument%s required",
1037 "%s: %s: %s or %s argument%s required",
1038 "%s: %s: %s, %s or %s argument%s required",
1039 "%s: %s: %s, %s, %s or %s argument%s required"
1040 };
1041
1042 n = comms[nr].flags & ARGS_MASK;
1043 for (i = 0; args[i]; i++)
1044 ;
1045 if (comms[nr].flags & ARGS_ORMORE)
1046 {
1047 if (i < n)
1048 {
1049 Msg(0, "%s: %s: at least %s argument%s required",
1050 rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1051 return -1;
1052 }
1053 }
1054 else if ((comms[nr].flags & ARGS_PLUS1) &&
1055 (comms[nr].flags & ARGS_PLUS2) &&
1056 (comms[nr].flags & ARGS_PLUS3))
1057 {
1058 if (i != n && i != n + 1 && i != n + 2 && i != n + 3)
1059 {
1060 Msg(0, orformat[3], rc_name, comms[nr].name, argss[n],
1061 argss[n + 1], argss[n + 2], argss[n + 3], "");
1062 return -1;
1063 }
1064 }
1065 else if ((comms[nr].flags & ARGS_PLUS1) &&
1066 (comms[nr].flags & ARGS_PLUS2))
1067 {
1068 if (i != n && i != n + 1 && i != n + 2)
1069 {
1070 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1071 argss[n + 1], argss[n + 2], "");
1072 return -1;
1073 }
1074 }
1075 else if ((comms[nr].flags & ARGS_PLUS1) &&
1076 (comms[nr].flags & ARGS_PLUS3))
1077 {
1078 if (i != n && i != n + 1 && i != n + 3)
1079 {
1080 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1081 argss[n + 1], argss[n + 3], "");
1082 return -1;
1083 }
1084 }
1085 else if ((comms[nr].flags & ARGS_PLUS2) &&
1086 (comms[nr].flags & ARGS_PLUS3))
1087 {
1088 if (i != n && i != n + 2 && i != n + 3)
1089 {
1090 Msg(0, orformat[2], rc_name, comms[nr].name, argss[n],
1091 argss[n + 2], argss[n + 3], "");
1092 return -1;
1093 }
1094 }
1095 else if (comms[nr].flags & ARGS_PLUS1)
1096 {
1097 if (i != n && i != n + 1)
1098 {
1099 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1100 argss[n + 1], n != 0 ? "s" : "");
1101 return -1;
1102 }
1103 }
1104 else if (comms[nr].flags & ARGS_PLUS2)
1105 {
1106 if (i != n && i != n + 2)
1107 {
1108 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1109 argss[n + 2], "s");
1110 return -1;
1111 }
1112 }
1113 else if (comms[nr].flags & ARGS_PLUS3)
1114 {
1115 if (i != n && i != n + 3)
1116 {
1117 Msg(0, orformat[1], rc_name, comms[nr].name, argss[n],
1118 argss[n + 3], "");
1119 return -1;
1120 }
1121 }
1122 else if (i != n)
1123 {
1124 Msg(0, orformat[0], rc_name, comms[nr].name, argss[n], n != 1 ? "s" : "");
1125 return -1;
1126 }
1127 return i;
1128 }
1129
1130 static void
1131 StuffFin(buf, len, data)
1132 char *buf;
1133 int len;
1134 char *data;
1135 {
1136 if (!flayer)
1137 return;
1138 while(len)
1139 LayProcess(&buf, &len);
1140 }
1141
1142 void
1143 ChangeWinNum(old, new)
1144 int old;
1145 int new;
1146 {
1147 struct win *pnew = wtab[new];
1148 struct win *pold = wtab[old];
1149 if (new < 0 || new >= maxwin)
1150 {
1151 Msg(0, "Given window position is invalid.");
1152 return;
1153 }
1154 wtab[new] = pold;
1155 pold->w_number = new;
1156 wtab[old] = pnew;
1157 if (pnew)
1158 pnew->w_number = old;
1159 #ifdef MULTIUSER
1160 /* exchange the acls for these windows. */
1161 AclWinSwap(old, new);
1162 #endif
1163 #ifdef UTMPOK
1164 /* exchange the utmp-slots for these windows */
1165 if ((pold->w_slot != (slot_t) -1) && (pold->w_slot != (slot_t) 0))
1166 {
1167 RemoveUtmp(pold);
1168 SetUtmp(pold);
1169 }
1170 if (pnew && (pnew->w_slot != (slot_t) -1) && (pnew->w_slot != (slot_t) 0))
1171 {
1172 /* XXX: first display wins? */
1173 display = pold->w_layer.l_cvlist ? pold->w_layer.l_cvlist->c_display : 0;
1174 RemoveUtmp(pnew);
1175 SetUtmp(pnew);
1176 }
1177 #endif
1178
1179 WindowChanged(pold, 'n');
1180 WindowChanged((struct win *)0, 'w');
1181 WindowChanged((struct win *)0, 'W');
1182 WindowChanged((struct win *)0, 0);
1183 }
1184
1185 void
1186 FocusCanvas(struct canvas *cv)
1187 {
1188 D_forecv = cv;
1189
1190 if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) ||
1191 (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight)))
1192 {
1193 ResizeCanvas(&D_canvas);
1194 RecreateCanvasChain();
1195 RethinkDisplayViewports();
1196 ResizeLayersToCanvases(); /* redisplays */
1197 }
1198 #ifdef SCRIPT
1199 {
1200 struct win *oldfore = D_fore;
1201 fore = D_fore = Layer2Window(D_forecv->c_layer);
1202 if (oldfore != fore)
1203 {
1204 if (oldfore)
1205 trigger_sevent(&oldfore->w_sev.onleave, display, oldfore);
1206 if (fore)
1207 trigger_sevent(&fore->w_sev.onfocus, display, oldfore);
1208 trigger_sevent(&globalevents.forechanged, display, display ? D_fore : fore);
1209 }
1210 }
1211 #else
1212 fore = D_fore = Layer2Window(D_forecv->c_layer);
1213 #endif
1214 if (D_other == fore)
1215 D_other = 0;
1216 flayer = D_forecv->c_layer;
1217 #ifdef RXVT_OSC
1218 if (D_xtermosc[2] || D_xtermosc[3])
1219 {
1220 Activate(-1);
1221 break;
1222 }
1223 #endif
1224 RefreshHStatus();
1225 #ifdef RXVT_OSC
1226 RefreshXtermOSC();
1227 #endif
1228 flayer = D_forecv->c_layer;
1229 CV_CALL(D_forecv, LayRestore();LaySetCursor());
1230 WindowChanged(0, 'F');
1231 }
1232
1233 void
1234 LayoutChangeNumber(struct layout *lay, int newnum)
1235 {
1236 struct layout *tmp;
1237 int old = lay->lay_number;
1238
1239 if (newnum < 0 || newnum >= MAXLAY)
1240 return;
1241 tmp = laytab[newnum];
1242 laytab[newnum] = lay;
1243 lay->lay_number = newnum;
1244 laytab[old] = tmp;
1245 if (tmp)
1246 tmp->lay_number = old;
1247 }
1248
1249 /*ARGSUSED*/
1250 void
1251 DoAction(act, key)
1252 struct action *act;
1253 int key;
1254 {
1255 int nr = act->nr;
1256 char **args = act->args;
1257 int *argl = act->argl;
1258 struct win *p;
1259 int argc, i, n, msgok;
1260 char *s;
1261 char ch;
1262 struct display *odisplay = display;
1263 struct acluser *user;
1264
1265 user = display ? D_user : users;
1266
1267 if (nr > RC_LAST)
1268 {
1269 struct alias *alias = FindAliasnr(nr);
1270 if (alias)
1271 {
1272 DoAlias(alias->name, act->args, act->argl);
1273 return;
1274 }
1275 nr = RC_ILLEGAL;
1276 }
1277
1278 if (nr == RC_ILLEGAL)
1279 {
1280 debug1("key '%c': No action\n", key);
1281 return;
1282 }
1283
1284 n = comms[nr].flags;
1285 if ((n & NEED_DISPLAY) && display == 0)
1286 {
1287 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
1288 return;
1289 }
1290 if ((n & NEED_FORE) && fore == 0)
1291 {
1292 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
1293 return;
1294 }
1295 if ((n & NEED_LAYER) && flayer == 0)
1296 {
1297 Msg(0, "%s: %s: display or window required", rc_name, comms[nr].name);
1298 return;
1299 }
1300 if ((argc = CheckArgNum(nr, args)) < 0)
1301 return;
1302 #ifdef MULTIUSER
1303 if (display)
1304 {
1305 if (AclCheckPermCmd(D_user, ACL_EXEC, &comms[nr]))
1306 {
1307 Msg(0, "%s: %s: permission denied (user %s)",
1308 rc_name, comms[nr].name, (EffectiveAclUser ? EffectiveAclUser : D_user)->u_name);
1309 return;
1310 }
1311 }
1312 #endif /* MULTIUSER */
1313
1314 msgok = display && !*rc_name;
1315 switch(nr)
1316 {
1317 case RC_SELECT:
1318 if (!*args)
1319 InputSelect();
1320 else if (args[0][0] == '-' && !args[0][1])
1321 {
1322 SetForeWindow((struct win *)0);
1323 Activate(0);
1324 }
1325 else if (args[0][0] == '.' && !args[0][1])
1326 {
1327 if (!fore)
1328 Msg(0, "select . needs a window");
1329 else
1330 {
1331 SetForeWindow(fore);
1332 Activate(0);
1333 }
1334 }
1335 else if (ParseWinNum(act, &n) == 0)
1336 SwitchWindow(n);
1337 break;
1338 #ifdef AUTO_NUKE
1339 case RC_DEFAUTONUKE:
1340 if (ParseOnOff(act, &defautonuke) == 0 && msgok)
1341 Msg(0, "Default autonuke turned %s", defautonuke ? "on" : "off");
1342 if (display && *rc_name)
1343 D_auto_nuke = defautonuke;
1344 break;
1345 case RC_AUTONUKE:
1346 if (ParseOnOff(act, &D_auto_nuke) == 0 && msgok)
1347 Msg(0, "Autonuke turned %s", D_auto_nuke ? "on" : "off");
1348 break;
1349 #endif
1350 case RC_DEFOBUFLIMIT:
1351 if (ParseNum(act, &defobuflimit) == 0 && msgok)
1352 Msg(0, "Default limit set to %d", defobuflimit);
1353 if (display && *rc_name)
1354 {
1355 D_obufmax = defobuflimit;
1356 D_obuflenmax = D_obuflen - D_obufmax;
1357 }
1358 break;
1359 case RC_OBUFLIMIT:
1360 if (*args == 0)
1361 Msg(0, "Limit is %d, current buffer size is %d", D_obufmax, D_obuflen);
1362 else if (ParseNum(act, &D_obufmax) == 0 && msgok)
1363 Msg(0, "Limit set to %d", D_obufmax);
1364 D_obuflenmax = D_obuflen - D_obufmax;
1365 break;
1366 case RC_DUMPTERMCAP:
1367 WriteFile(user, (char *)0, DUMP_TERMCAP);
1368 break;
1369 case RC_HARDCOPY:
1370 {
1371 int mode = DUMP_HARDCOPY;
1372
1373 if (argc > 1 && !strcmp(*args, "-h"))
1374 {
1375 mode = DUMP_SCROLLBACK;
1376 args++;
1377 argc--;
1378 }
1379 if (*args && args[1])
1380 {
1381 Msg(0, "%s: hardcopy: too many arguments", rc_name);
1382 break;
1383 }
1384 if (fore == 0 && *args == 0)
1385 Msg(0, "%s: hardcopy: window required", rc_name);
1386 else
1387 WriteFile(user, *args, mode);
1388 }
1389 break;
1390 case RC_DEFLOG:
1391 (void)ParseOnOff(act, &nwin_default.Lflag);
1392 break;
1393 case RC_LOG:
1394 n = fore->w_log ? 1 : 0;
1395 ParseSwitch(act, &n);
1396 LogToggle(n);
1397 break;
1398 #ifdef BSDJOBS
1399 case RC_SUSPEND:
1400 Detach(D_STOP);
1401 break;
1402 #endif
1403 case RC_NEXT:
1404 if (MoreWindows())
1405 SwitchWindow(NextWindow());
1406 break;
1407 case RC_PREV:
1408 if (MoreWindows())
1409 SwitchWindow(PreviousWindow());
1410 break;
1411 case RC_KILL:
1412 {
1413 char *name;
1414
1415 if (key >= 0)
1416 {
1417 #ifdef PSEUDOS
1418 Input(fore->w_pwin ? "Really kill this filter [y/n]" : "Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1419 #else
1420 Input("Really kill this window [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_KILL);
1421 #endif
1422 break;
1423 }
1424 n = fore->w_number;
1425 #ifdef PSEUDOS
1426 if (fore->w_pwin)
1427 {
1428 FreePseudowin(fore);
1429 Msg(0, "Filter removed.");
1430 break;
1431 }
1432 #endif
1433 name = SaveStr(fore->w_title);
1434 KillWindow(fore);
1435 Msg(0, "Window %d (%s) killed.", n, name);
1436 if (name)
1437 free(name);
1438 break;
1439 }
1440 case RC_QUIT:
1441 if (key >= 0)
1442 {
1443 Input("Really quit and kill all your windows [y/n]", 1, INP_RAW, confirm_fn, NULL, RC_QUIT);
1444 break;
1445 }
1446 Finit(0);
1447 /* NOTREACHED */
1448 #ifdef DETACH
1449 case RC_DETACH:
1450 if (*args && !strcmp(*args, "-h"))
1451 Hangup();
1452 else
1453 Detach(D_DETACH);
1454 break;
1455 # ifdef POW_DETACH
1456 case RC_POW_DETACH:
1457 if (key >= 0)
1458 {
1459 static char buf[2];
1460
1461 buf[0] = key;
1462 Input(buf, 1, INP_RAW, pow_detach_fn, NULL, 0);
1463 }
1464 else
1465 Detach(D_POWER); /* detach and kill Attacher's parent */
1466 break;
1467 # endif
1468 #endif
1469 case RC_DEBUG:
1470 #ifdef DEBUG
1471 if (!*args)
1472 {
1473 if (dfp)
1474 Msg(0, "debugging info is written to %s/", DEBUGDIR);
1475 else
1476 Msg(0, "debugging is currently off. Use 'debug on' to enable.");
1477 break;
1478 }
1479 if (dfp)
1480 {
1481 debug("debug: closing debug file.\n");
1482 fflush(dfp);
1483 fclose(dfp);
1484 dfp = NULL;
1485 }
1486 if (strcmp("off", *args))
1487 opendebug(0, 1);
1488 # ifdef SIG_NODEBUG
1489 else if (display)
1490 kill(D_userpid, SIG_NODEBUG); /* a one shot item, but hey... */
1491 # endif /* SIG_NODEBUG */
1492 #else
1493 if (*args == 0 || strcmp("off", *args))
1494 Msg(0, "Sorry, screen was compiled without -DDEBUG option.");
1495 #endif
1496 break;
1497 #ifdef ZMODEM
1498 case RC_ZMODEM:
1499 if (*args && !strcmp(*args, "sendcmd"))
1500 {
1501 if (args[1])
1502 {
1503 free(zmodem_sendcmd);
1504 zmodem_sendcmd = SaveStr(args[1]);
1505 }
1506 if (msgok)
1507 Msg(0, "zmodem sendcmd: %s", zmodem_sendcmd);
1508 break;
1509 }
1510 if (*args && !strcmp(*args, "recvcmd"))
1511 {
1512 if (args[1])
1513 {
1514 free(zmodem_recvcmd);
1515 zmodem_recvcmd = SaveStr(args[1]);
1516 }
1517 if (msgok)
1518 Msg(0, "zmodem recvcmd: %s", zmodem_recvcmd);
1519 break;
1520 }
1521 if (*args)
1522 {
1523 for (i = 0; i < 4; i++)
1524 if (!strcmp(zmodes[i], *args))
1525 break;
1526 if (i == 4 && !strcmp(*args, "on"))
1527 i = 1;
1528 if (i == 4)
1529 {
1530 Msg(0, "usage: zmodem off|auto|catch|pass");
1531 break;
1532 }
1533 zmodem_mode = i;
1534 }
1535 if (msgok)
1536 Msg(0, "zmodem mode is %s", zmodes[zmodem_mode]);
1537 break;
1538 #endif
1539 case RC_ZOMBIE:
1540 {
1541 if (!(s = *args))
1542 {
1543 ZombieKey_destroy = 0;
1544 break;
1545 }
1546 if (*argl == 0 || *argl > 2)
1547 {
1548 Msg(0, "%s:zombie: one or two characters expected.", rc_name);
1549 break;
1550 }
1551 if (args[1])
1552 {
1553 if (!strcmp(args[1], "onerror"))
1554 {
1555 ZombieKey_onerror = 1;
1556 } else {
1557 Msg(0, "usage: zombie [keys [onerror]]");
1558 break;
1559 }
1560 } else
1561 ZombieKey_onerror = 0;
1562 ZombieKey_destroy = args[0][0];
1563 ZombieKey_resurrect = *argl == 2 ? args[0][1] : 0;
1564 }
1565 break;
1566 case RC_WALL:
1567 #ifdef MULTIUSER
1568 s = D_user->u_name;
1569 #else
1570 s = D_usertty;
1571 #endif
1572 {
1573 struct display *olddisplay = display;
1574 display = 0; /* no display will cause a broadcast */
1575 Msg(0, "%s: %s", s, *args);
1576 display = olddisplay;
1577 }
1578 break;
1579 case RC_AT:
1580 /* where this AT command comes from: */
1581 #ifdef MULTIUSER
1582 s = SaveStr(D_user->u_name);
1583 /* DO NOT RETURN FROM HERE WITHOUT RESETTING THIS: */
1584 EffectiveAclUser = D_user;
1585 #else
1586 s = SaveStr(D_usertty);
1587 #endif
1588 n = strlen(args[0]);
1589 if (n) n--;
1590 /*
1591 * the windows/displays loops are quite dangerous here, take extra
1592 * care not to trigger landmines. Things may appear/disappear while
1593 * we are walking along.
1594 */
1595 switch (args[0][n])
1596 {
1597 case '*': /* user */
1598 {
1599 struct display *nd;
1600 struct acluser *u;
1601
1602 if (!n)
1603 u = D_user;
1604 else
1605 for (u = users; u; u = u->u_next)
1606 {
1607 debug3("strncmp('%s', '%s', %d)\n", *args, u->u_name, n);
1608 if (!strncmp(*args, u->u_name, n))
1609 break;
1610 }
1611 debug1("at all displays of user %s\n", u->u_name);
1612 for (display = displays; display; display = nd)
1613 {
1614 nd = display->d_next;
1615 if (D_forecv == 0)
1616 continue;
1617 flayer = D_forecv->c_layer;
1618 fore = D_fore;
1619 if (D_user != u)
1620 continue;
1621 debug1("AT display %s\n", D_usertty);
1622 DoCommand(args + 1, argl + 1);
1623 if (display)
1624 Msg(0, "command from %s: %s %s",
1625 s, args[1], args[2] ? args[2] : "");
1626 display = NULL;
1627 flayer = 0;
1628 fore = NULL;
1629 }
1630 break;
1631 }
1632 case '%': /* display */
1633 {
1634 struct display *nd;
1635
1636 debug1("at display matching '%s'\n", args[0]);
1637 for (display = displays; display; display = nd)
1638 {
1639 nd = display->d_next;
1640 if (D_forecv == 0)
1641 continue;
1642 fore = D_fore;
1643 flayer = D_forecv->c_layer;
1644 if (strncmp(args[0], D_usertty, n) &&
1645 (strncmp("/dev/", D_usertty, 5) ||
1646 strncmp(args[0], D_usertty + 5, n)) &&
1647 (strncmp("/dev/tty", D_usertty, 8) ||
1648 strncmp(args[0], D_usertty + 8, n)))
1649 continue;
1650 debug1("AT display %s\n", D_usertty);
1651 DoCommand(args + 1, argl + 1);
1652 if (display)
1653 Msg(0, "command from %s: %s %s",
1654 s, args[1], args[2] ? args[2] : "");
1655 display = NULL;
1656 fore = NULL;
1657 flayer = 0;
1658 }
1659 break;
1660 }
1661 case '#': /* window */
1662 n--;
1663 /* FALLTHROUGH */
1664 default:
1665 {
1666 struct win *nw;
1667 int ch;
1668
1669 n++;
1670 ch = args[0][n];
1671 args[0][n] = '\0';
1672 if (!*args[0] || (i = WindowByNumber(args[0])) < 0)
1673 {
1674 args[0][n] = ch; /* must restore string in case of bind */
1675 /* try looping over titles */
1676 for (fore = windows; fore; fore = nw)
1677 {
1678 nw = fore->w_next;
1679 if (strncmp(args[0], fore->w_title, n))
1680 continue;
1681 debug2("AT window %d(%s)\n", fore->w_number, fore->w_title);
1682 /*
1683 * consider this a bug or a feature:
1684 * while looping through windows, we have fore AND
1685 * display context. This will confuse users who try to
1686 * set up loops inside of loops, but often allows to do
1687 * what you mean, even when you adress your context wrong.
1688 */
1689 i = 0;
1690 /* XXX: other displays? */
1691 if (fore->w_layer.l_cvlist)
1692 display = fore->w_layer.l_cvlist->c_display;
1693 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1694 DoCommand(args + 1, argl + 1); /* may destroy our display */
1695 if (fore && fore->w_layer.l_cvlist)
1696 {
1697 display = fore->w_layer.l_cvlist->c_display;
1698 Msg(0, "command from %s: %s %s",
1699 s, args[1], args[2] ? args[2] : "");
1700 }
1701 }
1702 display = NULL;
1703 fore = NULL;
1704 if (i < 0)
1705 Msg(0, "%s: at '%s': no such window.\n", rc_name, args[0]);
1706 break;
1707 }
1708 else if (i < MAXWIN && (fore = wtab[i]))
1709 {
1710 args[0][n] = ch; /* must restore string in case of bind */
1711 debug2("AT window %d (%s)\n", fore->w_number, fore->w_title);
1712 if (fore->w_layer.l_cvlist)
1713 display = fore->w_layer.l_cvlist->c_display;
1714 flayer = fore->w_savelayer ? fore->w_savelayer : &fore->w_layer;
1715 DoCommand(args + 1, argl + 1);
1716 if (fore && fore->w_layer.l_cvlist)
1717 {
1718 display = fore->w_layer.l_cvlist->c_display;
1719 Msg(0, "command from %s: %s %s",
1720 s, args[1], args[2] ? args[2] : "");
1721 }
1722 display = NULL;
1723 fore = NULL;
1724 }
1725 else
1726 Msg(0, "%s: at [identifier][%%|*|#] command [args]", rc_name);
1727 break;
1728 }
1729 }
1730 free(s);
1731 #ifdef MULTIUSER
1732 EffectiveAclUser = NULL;
1733 #endif
1734 break;
1735
1736 #ifdef COPY_PASTE
1737 case RC_READREG:
1738 #ifdef ENCODINGS
1739 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1740 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1741 {
1742 i = FindEncoding(args[1]);
1743 if (i == -1)
1744 {
1745 Msg(0, "%s: readreg: unknown encoding", rc_name);
1746 break;
1747 }
1748 args += 2;
1749 }
1750 #endif
1751 /*
1752 * Without arguments we prompt for a destination register.
1753 * It will receive the copybuffer contents.
1754 * This is not done by RC_PASTE, as we prompt for source
1755 * (not dest) there.
1756 */
1757 if ((s = *args) == NULL)
1758 {
1759 Input("Copy to register:", 1, INP_RAW, copy_reg_fn, NULL, 0);
1760 break;
1761 }
1762 if (*argl != 1)
1763 {
1764 Msg(0, "%s: copyreg: character, ^x, or (octal) \\032 expected.", rc_name);
1765 break;
1766 }
1767 ch = args[0][0];
1768 /*
1769 * With two arguments we *really* read register contents from file
1770 */
1771 if (args[1])
1772 {
1773 if (args[2])
1774 {
1775 Msg(0, "%s: readreg: too many arguments", rc_name);
1776 break;
1777 }
1778 if ((s = ReadFile(args[1], &n)))
1779 {
1780 struct plop *pp = plop_tab + (int)(unsigned char)ch;
1781
1782 if (pp->buf)
1783 free(pp->buf);
1784 pp->buf = s;
1785 pp->len = n;
1786 #ifdef ENCODINGS
1787 pp->enc = i;
1788 #endif
1789 }
1790 }
1791 else
1792 /*
1793 * with one argument we copy the copybuffer into a specified register
1794 * This could be done with RC_PASTE too, but is here to be consistent
1795 * with the zero argument call.
1796 */
1797 copy_reg_fn(&ch, 0, NULL);
1798 break;
1799 #endif
1800 case RC_REGISTER:
1801 #ifdef ENCODINGS
1802 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
1803 if (args[0] && args[1] && !strcmp(args[0], "-e"))
1804 {
1805 i = FindEncoding(args[1]);
1806 if (i == -1)
1807 {
1808 Msg(0, "%s: register: unknown encoding", rc_name);
1809 break;
1810 }
1811 args += 2;
1812 argc -= 2;
1813 }
1814 #endif
1815 if (argc != 2)
1816 {
1817 Msg(0, "%s: register: illegal number of arguments.", rc_name);
1818 break;
1819 }
1820 if (*argl != 1)
1821 {
1822 Msg(0, "%s: register: character, ^x, or (octal) \\032 expected.", rc_name);
1823 break;
1824 }
1825 ch = args[0][0];
1826 #ifdef COPY_PASTE
1827 if (ch == '.')
1828 {
1829 if (user->u_plop.buf != NULL)
1830 UserFreeCopyBuffer(user);
1831 if (args[1] && args[1][0])
1832 {
1833 user->u_plop.buf = SaveStrn(args[1], argl[1]);
1834 user->u_plop.len = argl[1];
1835 #ifdef ENCODINGS
1836 user->u_plop.enc = i;
1837 #endif
1838 }
1839 }
1840 else
1841 #endif
1842 {
1843 struct plop *plp = plop_tab + (int)(unsigned char)ch;
1844
1845 if (plp->buf)
1846 free(plp->buf);
1847 plp->buf = SaveStrn(args[1], argl[1]);
1848 plp->len = argl[1];
1849 #ifdef ENCODINGS
1850 plp->enc = i;
1851 #endif
1852 }
1853 break;
1854 case RC_PROCESS:
1855 if ((s = *args) == NULL)
1856 {
1857 Input("Process register:", 1, INP_RAW, process_fn, NULL, 0);
1858 break;
1859 }
1860 if (*argl != 1)
1861 {
1862 Msg(0, "%s: process: character, ^x, or (octal) \\032 expected.", rc_name);
1863 break;
1864 }
1865 ch = args[0][0];
1866 process_fn(&ch, 0, NULL);
1867 break;
1868 case RC_STUFF:
1869 s = *args;
1870 if (!args[0])
1871 {
1872 Input("Stuff:", 100, INP_COOKED, StuffFin, NULL, 0);
1873 break;
1874 }
1875 n = *argl;
1876 if (args[1])
1877 {
1878 if (strcmp(s, "-k"))
1879 {
1880 Msg(0, "%s: stuff: invalid option %s", rc_name, s);
1881 break;
1882 }
1883 s = args[1];
1884 for (i = T_CAPS; i < T_OCAPS; i++)
1885 if (strcmp(term[i].tcname, s) == 0)
1886 break;
1887 if (i == T_OCAPS)
1888 {
1889 Msg(0, "%s: stuff: unknown key '%s'", rc_name, s);
1890 break;
1891 }
1892 #ifdef MAPKEYS
1893 if (StuffKey(i - T_CAPS) == 0)
1894 break;
1895 #endif
1896 s = display ? D_tcs[i].str : 0;
1897 if (s == 0)
1898 break;
1899 n = strlen(s);
1900 }
1901 while(n)
1902 LayProcess(&s, &n);
1903 break;
1904 case RC_REDISPLAY:
1905 Activate(-1);
1906 break;
1907 case RC_WINDOWS:
1908 ShowWindows(-1);
1909 break;
1910 case RC_VERSION:
1911 Msg(0, "screen %s", version);
1912 break;
1913 case RC_TIME:
1914 if (*args)
1915 {
1916 timestring = SaveStr(*args);
1917 break;
1918 }
1919 Msg(0, "%s", MakeWinMsg(timestring, fore, '%'));
1920 break;
1921 case RC_INFO:
1922 ShowInfo();
1923 break;
1924 case RC_DINFO:
1925 ShowDInfo();
1926 break;
1927 case RC_COMMAND:
1928 {
1929 struct action *ktabp = ktab;
1930 if (argc == 2 && !strcmp(*args, "-c"))
1931 {
1932 if ((ktabp = FindKtab(args[1], 0)) == 0)
1933 {
1934 Msg(0, "Unknown command class '%s'", args[1]);
1935 break;
1936 }
1937 }
1938 if (D_ESCseen != ktab || ktabp != ktab)
1939 {
1940 D_ESCseen = ktabp;
1941 break;
1942 }
1943 D_ESCseen = 0;
1944 }
1945 /* FALLTHROUGH */
1946 case RC_OTHER:
1947 if (MoreWindows())
1948 SwitchWindow(display && D_other ? D_other->w_number : NextWindow());
1949 break;
1950 case RC_META:
1951 if (user->u_Esc == -1)
1952 break;
1953 ch = user->u_Esc;
1954 s = &ch;
1955 n = 1;
1956 LayProcess(&s, &n);
1957 break;
1958 case RC_XON:
1959 ch = Ctrl('q');
1960 s = &ch;
1961 n = 1;
1962 LayProcess(&s, &n);
1963 break;
1964 case RC_XOFF:
1965 ch = Ctrl('s');
1966 s = &ch;
1967 n = 1;
1968 LayProcess(&s, &n);
1969 break;
1970 case RC_DEFBREAKTYPE:
1971 case RC_BREAKTYPE:
1972 {
1973 static char *types[] = { "TIOCSBRK", "TCSBRK", "tcsendbreak", NULL };
1974 extern int breaktype;
1975
1976 if (*args)
1977 {
1978 if (ParseNum(act, &n))
1979 for (n = 0; n < (int)(sizeof(types)/sizeof(*types)); n++)
1980 {
1981 for (i = 0; i < 4; i++)
1982 {
1983 ch = args[0][i];
1984 if (ch >= 'a' && ch <= 'z')
1985 ch -= 'a' - 'A';
1986 if (ch != types[n][i] && (ch + ('a' - 'A')) != types[n][i])
1987 break;
1988 }
1989 if (i == 4)
1990 break;
1991 }
1992 if (n < 0 || n >= (int)(sizeof(types)/sizeof(*types)))
1993 Msg(0, "%s invalid, chose one of %s, %s or %s", *args, types[0], types[1], types[2]);
1994 else
1995 {
1996 breaktype = n;
1997 Msg(0, "breaktype set to (%d) %s", n, types[n]);
1998 }
1999 }
2000 else
2001 Msg(0, "breaktype is (%d) %s", breaktype, types[breaktype]);
2002 }
2003 break;
2004 case RC_POW_BREAK:
2005 case RC_BREAK:
2006 n = 0;
2007 if (*args && ParseNum(act, &n))
2008 break;
2009 SendBreak(fore, n, nr == RC_POW_BREAK);
2010 break;
2011 #ifdef LOCK
2012 case RC_LOCKSCREEN:
2013 Detach(D_LOCK);
2014 break;
2015 #endif
2016 case RC_WIDTH:
2017 case RC_HEIGHT:
2018 {
2019 int w, h;
2020 int what = 0;
2021
2022 i = 1;
2023 if (*args && !strcmp(*args, "-w"))
2024 what = 1;
2025 else if (*args && !strcmp(*args, "-d"))
2026 what = 2;
2027 if (what)
2028 args++;
2029 if (what == 0 && flayer && !display)
2030 what = 1;
2031 if (what == 1)
2032 {
2033 if (!flayer)
2034 {
2035 Msg(0, "%s: %s: window required", rc_name, comms[nr].name);
2036 break;
2037 }
2038 w = flayer->l_width;
2039 h = flayer->l_height;
2040 }
2041 else
2042 {
2043 if (!display)
2044 {
2045 Msg(0, "%s: %s: display required", rc_name, comms[nr].name);
2046 break;
2047 }
2048 w = D_width;
2049 h = D_height;
2050 }
2051 if (*args && args[0][0] == '-')
2052 {
2053 Msg(0, "%s: %s: unknown option %s", rc_name, comms[nr].name, *args);
2054 break;
2055 }
2056 if (nr == RC_HEIGHT)
2057 {
2058 if (!*args)
2059 {
2060 #define H0height 42
2061 #define H1height 24
2062 if (h == H0height)
2063 h = H1height;
2064 else if (h == H1height)
2065 h = H0height;
2066 else if (h > (H0height + H1height) / 2)
2067 h = H0height;
2068 else
2069 h = H1height;
2070 }
2071 else
2072 {
2073 h = atoi(*args);
2074 if (args[1])
2075 w = atoi(args[1]);
2076 }
2077 }
2078 else
2079 {
2080 if (!*args)
2081 {
2082 if (w == Z0width)
2083 w = Z1width;
2084 else if (w == Z1width)
2085 w = Z0width;
2086 else if (w > (Z0width + Z1width) / 2)
2087 w = Z0width;
2088 else
2089 w = Z1width;
2090 }
2091 else
2092 {
2093 w = atoi(*args);
2094 if (args[1])
2095 h = atoi(args[1]);
2096 }
2097 }
2098 if (*args && args[1] && args[2])
2099 {
2100 Msg(0, "%s: %s: too many arguments", rc_name, comms[nr].name);
2101 break;
2102 }
2103 if (w <= 0)
2104 {
2105 Msg(0, "Illegal width");
2106 break;
2107 }
2108 if (h <= 0)
2109 {
2110 Msg(0, "Illegal height");
2111 break;
2112 }
2113 if (what == 1)
2114 {
2115 if (flayer->l_width == w && flayer->l_height == h)
2116 break;
2117 ResizeLayer(flayer, w, h, (struct display *)0);
2118 break;
2119 }
2120 if (D_width == w && D_height == h)
2121 break;
2122 if (what == 2)
2123 {
2124 ChangeScreenSize(w, h, 1);
2125 }
2126 else
2127 {
2128 if (ResizeDisplay(w, h) == 0)
2129 {
2130 Activate(D_fore ? D_fore->w_norefresh : 0);
2131 /* autofit */
2132 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
2133 break;
2134 }
2135 if (h == D_height)
2136 Msg(0, "Your termcap does not specify how to change the terminal's width to %d.", w);
2137 else if (w == D_width)
2138 Msg(0, "Your termcap does not specify how to change the terminal's height to %d.", h);
2139 else
2140 Msg(0, "Your termcap does not specify how to change the terminal's resolution to %dx%d.", w, h);
2141 }
2142 }
2143 break;
2144 case RC_TITLE:
2145 if (*args == 0)
2146 InputAKA();
2147 else
2148 ChangeAKA(fore, *args, strlen(*args));
2149 break;
2150 case RC_COLON:
2151 Input(":", 100, INP_EVERY, Colonfin, NULL, 0);
2152 if (*args && **args)
2153 {
2154 s = *args;
2155 n = strlen(s);
2156 LayProcess(&s, &n);
2157 }
2158 break;
2159 case RC_LASTMSG:
2160 if (D_status_lastmsg)
2161 Msg(0, "%s", D_status_lastmsg);
2162 break;
2163 case RC_SCREEN:
2164 DoScreen("key", args);
2165 break;
2166 case RC_WRAP:
2167 if (ParseSwitch(act, &fore->w_wrap) == 0 && msgok)
2168 Msg(0, "%cwrap", fore->w_wrap ? '+' : '-');
2169 break;
2170 case RC_FLOW:
2171 if (*args)
2172 {
2173 if (args[0][0] == 'a')
2174 {
2175 fore->w_flow = (fore->w_flow & FLOW_AUTO) ? FLOW_AUTOFLAG |FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2176 }
2177 else
2178 {
2179 if (ParseOnOff(act, &n))
2180 break;
2181 fore->w_flow = (fore->w_flow & FLOW_AUTO) | n;
2182 }
2183 }
2184 else
2185 {
2186 if (fore->w_flow & FLOW_AUTOFLAG)
2187 fore->w_flow = (fore->w_flow & FLOW_AUTO) | FLOW_NOW;
2188 else if (fore->w_flow & FLOW_NOW)
2189 fore->w_flow &= ~FLOW_NOW;
2190 else
2191 fore->w_flow = fore->w_flow ? FLOW_AUTOFLAG|FLOW_AUTO|FLOW_NOW : FLOW_AUTOFLAG;
2192 }
2193 SetFlow(fore->w_flow & FLOW_NOW);
2194 if (msgok)
2195 Msg(0, "%cflow%s", (fore->w_flow & FLOW_NOW) ? '+' : '-',
2196 (fore->w_flow & FLOW_AUTOFLAG) ? "(auto)" : "");
2197 break;
2198 #ifdef MULTIUSER
2199 case RC_DEFWRITELOCK:
2200 if (args[0][0] == 'a')
2201 nwin_default.wlock = WLOCK_AUTO;
2202 else
2203 {
2204 if (ParseOnOff(act, &n))
2205 break;
2206 nwin_default.wlock = n ? WLOCK_ON : WLOCK_OFF;
2207 }
2208 break;
2209 case RC_WRITELOCK:
2210 if (*args)
2211 {
2212 if (args[0][0] == 'a')
2213 {
2214 fore->w_wlock = WLOCK_AUTO;
2215 }
2216 else
2217 {
2218 if (ParseOnOff(act, &n))
2219 break;
2220 fore->w_wlock = n ? WLOCK_ON : WLOCK_OFF;
2221 }
2222 /*
2223 * user may have permission to change the writelock setting,
2224 * but he may never aquire the lock himself without write permission
2225 */
2226 if (!AclCheckPermWin(D_user, ACL_WRITE, fore))
2227 fore->w_wlockuser = D_user;
2228 }
2229 Msg(0, "writelock %s", (fore->w_wlock == WLOCK_AUTO) ? "auto" :
2230 ((fore->w_wlock == WLOCK_OFF) ? "off" : "on"));
2231 break;
2232 #endif
2233 case RC_CLEAR:
2234 ResetAnsiState(fore);
2235 WriteString(fore, "\033[H\033[J", 6);
2236 break;
2237 case RC_RESET:
2238 ResetAnsiState(fore);
2239 #ifdef ZMODEM
2240 if (fore->w_zdisplay)
2241 zmodem_abort(fore, fore->w_zdisplay);
2242 #endif
2243 WriteString(fore, "\033c", 2);
2244 break;
2245 case RC_MONITOR:
2246 n = fore->w_monitor != MON_OFF;
2247 #ifdef MULTIUSER
2248 if (display)
2249 n = n && (ACLBYTE(fore->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id));
2250 #endif
2251 if (ParseSwitch(act, &n))
2252 break;
2253 if (n)
2254 {
2255 #ifdef MULTIUSER
2256 if (display) /* we tell only this user */
2257 ACLBYTE(fore->w_mon_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
2258 else
2259 for (i = 0; i < maxusercount; i++)
2260 ACLBYTE(fore->w_mon_notify, i) |= ACLBIT(i);
2261 #endif
2262 if (fore->w_monitor == MON_OFF)
2263 fore->w_monitor = MON_ON;
2264 Msg(0, "Window %d (%s) is now being monitored for all activity.", fore->w_number, fore->w_title);
2265 }
2266 else
2267 {
2268 #ifdef MULTIUSER
2269 if (display) /* we remove only this user */
2270 ACLBYTE(fore->w_mon_notify, D_user->u_id)
2271 &= ~ACLBIT(D_user->u_id);
2272 else
2273 for (i = 0; i < maxusercount; i++)
2274 ACLBYTE(fore->w_mon_notify, i) &= ~ACLBIT(i);
2275 for (i = maxusercount - 1; i >= 0; i--)
2276 if (ACLBYTE(fore->w_mon_notify, i))
2277 break;
2278 if (i < 0)
2279 #endif
2280 fore->w_monitor = MON_OFF;
2281 Msg(0, "Window %d (%s) is no longer being monitored for activity.", fore->w_number, fore->w_title);
2282 }
2283 break;
2284 #ifdef MULTI
2285 case RC_DISPLAYS:
2286 display_displays();
2287 break;
2288 #endif
2289 case RC_WINDOWLIST:
2290 if (!*args)
2291 display_wlist(0, WLIST_NUM, (struct win *)0);
2292 else if (!strcmp(*args, "string"))
2293 {
2294 if (args[1])
2295 {
2296 if (wliststr)
2297 free(wliststr);
2298 wliststr = SaveStr(args[1]);
2299 }
2300 if (msgok)
2301 Msg(0, "windowlist string is '%s'", wliststr);
2302 }
2303 else if (!strcmp(*args, "title"))
2304 {
2305 if (args[1])
2306 {
2307 if (wlisttit)
2308 free(wlisttit);
2309 wlisttit = SaveStr(args[1]);
2310 }
2311 if (msgok)
2312 Msg(0, "windowlist title is '%s'", wlisttit);
2313 }
2314 else
2315 {
2316 int flag = 0;
2317 int blank = 0;
2318 for (i = 0; i < argc; i++)
2319 if (!args[i])
2320 continue;
2321 else if (!strcmp(args[i], "-m"))
2322 flag |= WLIST_MRU;
2323 else if (!strcmp(args[i], "-b"))
2324 blank = 1;
2325 else if (!strcmp(args[i], "-g"))
2326 flag |= WLIST_NESTED;
2327 else
2328 {
2329 Msg(0, "usage: windowlist [-b] [-g] [-m] [string [string] | title [title]]");
2330 break;
2331 }
2332 if (i == argc)
2333 display_wlist(blank, flag, (struct win *)0);
2334 }
2335 break;
2336 case RC_HELP:
2337 if (argc == 2 && !strcmp(*args, "-c"))
2338 {
2339 struct action *ktabp;
2340 if ((ktabp = FindKtab(args[1], 0)) == 0)
2341 {
2342 Msg(0, "Unknown command class '%s'", args[1]);
2343 break;
2344 }
2345 display_help(args[1], ktabp);
2346 }
2347 else
2348 display_help((char *)0, ktab);
2349 break;
2350 case RC_LICENSE:
2351 display_copyright();
2352 break;
2353 #ifdef COPY_PASTE
2354 case RC_COPY:
2355 if (flayer->l_layfn != &WinLf)
2356 {
2357 Msg(0, "Must be on a window layer");
2358 break;
2359 }
2360 MarkRoutine();
2361 break;
2362 case RC_HISTORY:
2363 {
2364 static char *pasteargs[] = {".", 0};
2365 static int pasteargl[] = {1};
2366
2367 if (flayer->l_layfn != &WinLf)
2368 {
2369 Msg(0, "Must be on a window layer");
2370 break;
2371 }
2372 if (GetHistory() == 0)
2373 break;
2374 if (user->u_plop.buf == NULL)
2375 break;
2376 args = pasteargs;
2377 argl = pasteargl;
2378 }
2379 /*FALLTHROUGH*/
2380 case RC_PASTE:
2381 {
2382 char *ss, *dbuf, dch;
2383 int l = 0;
2384 # ifdef ENCODINGS
2385 int enc = -1;
2386 # endif
2387
2388 /*
2389 * without args we prompt for one(!) register to be pasted in the window
2390 */
2391 if ((s = *args) == NULL)
2392 {
2393 Input("Paste from register:", 1, INP_RAW, ins_reg_fn, NULL, 0);
2394 break;
2395 }
2396 if (args[1] == 0 && !fore) /* no window? */
2397 break;
2398 /*
2399 * with two arguments we paste into a destination register
2400 * (no window needed here).
2401 */
2402 if (args[1] && argl[1] != 1)
2403 {
2404 Msg(0, "%s: paste destination: character, ^x, or (octal) \\032 expected.",
2405 rc_name);
2406 break;
2407 }
2408 # ifdef ENCODINGS
2409 else if (fore)
2410 enc = fore->w_encoding;
2411 # endif
2412
2413 /*
2414 * measure length of needed buffer
2415 */
2416 for (ss = s = *args; (ch = *ss); ss++)
2417 {
2418 if (ch == '.')
2419 {
2420 # ifdef ENCODINGS
2421 if (enc == -1)
2422 enc = user->u_plop.enc;
2423 if (enc != user->u_plop.enc)
2424 l += RecodeBuf((unsigned char *)user->u_plop.buf, user->u_plop.len, user->u_plop.enc, enc, (unsigned char *)0);
2425 else
2426 # endif
2427 l += user->u_plop.len;
2428 }
2429 else
2430 {
2431 # ifdef ENCODINGS
2432 if (enc == -1)
2433 enc = plop_tab[(int)(unsigned char)ch].enc;
2434 if (enc != plop_tab[(int)(unsigned char)ch].enc)
2435 l += RecodeBuf((unsigned char *)plop_tab[(int)(unsigned char)ch].buf, plop_tab[(int)(unsigned char)ch].len, plop_tab[(int)(unsigned char)ch].enc, enc, (unsigned char *)0);
2436 else
2437 # endif
2438 l += plop_tab[(int)(unsigned char)ch].len;
2439 }
2440 }
2441 if (l == 0)
2442 {
2443 Msg(0, "empty buffer");
2444 break;
2445 }
2446 /*
2447 * shortcut:
2448 * if there is only one source and the destination is a window, then
2449 * pass a pointer rather than duplicating the buffer.
2450 */
2451 if (s[1] == 0 && args[1] == 0)
2452 # ifdef ENCODINGS
2453 if (enc == (*s == '.' ? user->u_plop.enc : plop_tab[(int)(unsigned char)*s].enc))
2454 # endif
2455 {
2456 MakePaster(&fore->w_paster, *s == '.' ? user->u_plop.buf : plop_tab[(int)(unsigned char)*s].buf, l, 0);
2457 break;
2458 }
2459 /*
2460 * if no shortcut, we construct a buffer
2461 */
2462 if ((dbuf = (char *)malloc(l)) == 0)
2463 {
2464 Msg(0, strnomem);
2465 break;
2466 }
2467 l = 0;
2468 /*
2469 * concatenate all sources into our own buffer, copy buffer is
2470 * special and is skipped if no display exists.
2471 */
2472 for (ss = s; (ch = *ss); ss++)
2473 {
2474 struct plop *pp = (ch == '.' ? &user->u_plop : &plop_tab[(int)(unsigned char)ch]);
2475 #ifdef ENCODINGS
2476 if (pp->enc != enc)
2477 {
2478 l += RecodeBuf((unsigned char *)pp->buf, pp->len, pp->enc, enc, (unsigned char *)dbuf + l);
2479 continue;
2480 }
2481 #endif
2482 bcopy(pp->buf, dbuf + l, pp->len);
2483 l += pp->len;
2484 }
2485 /*
2486 * when called with one argument we paste our buffer into the window
2487 */
2488 if (args[1] == 0)
2489 {
2490 MakePaster(&fore->w_paster, dbuf, l, 1);
2491 }
2492 else
2493 {
2494 /*
2495 * we have two arguments, the second is already in dch.
2496 * use this as destination rather than the window.
2497 */
2498 dch = args[1][0];
2499 if (dch == '.')
2500 {
2501 if (user->u_plop.buf != NULL)
2502 UserFreeCopyBuffer(user);
2503 user->u_plop.buf = dbuf;
2504 user->u_plop.len = l;
2505 #ifdef ENCODINGS
2506 user->u_plop.enc = enc;
2507 #endif
2508 }
2509 else
2510 {
2511 struct plop *pp = plop_tab + (int)(unsigned char)dch;
2512 if (pp->buf)
2513 free(pp->buf);
2514 pp->buf = dbuf;
2515 pp->len = l;
2516 #ifdef ENCODINGS
2517 pp->enc = enc;
2518 #endif
2519 }
2520 }
2521 break;
2522 }
2523 case RC_WRITEBUF:
2524 if (!user->u_plop.buf)
2525 {
2526 Msg(0, "empty buffer");
2527 break;
2528 }
2529 #ifdef ENCODINGS
2530 {
2531 struct plop oldplop;
2532
2533 oldplop = user->u_plop;
2534 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2535 {
2536 int enc, l;
2537 char *newbuf;
2538
2539 enc = FindEncoding(args[1]);
2540 if (enc == -1)
2541 {
2542 Msg(0, "%s: writebuf: unknown encoding", rc_name);
2543 break;
2544 }
2545 if (enc != oldplop.enc)
2546 {
2547 l = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)0);
2548 newbuf = malloc(l + 1);
2549 if (!newbuf)
2550 {
2551 Msg(0, strnomem);
2552 break;
2553 }
2554 user->u_plop.len = RecodeBuf((unsigned char *)oldplop.buf, oldplop.len, oldplop.enc, enc, (unsigned char *)newbuf);
2555 user->u_plop.buf = newbuf;
2556 user->u_plop.enc = enc;
2557 }
2558 args += 2;
2559 }
2560 #endif
2561 if (args[0] && args[1])
2562 Msg(0, "%s: writebuf: too many arguments", rc_name);
2563 else
2564 WriteFile(user, args[0], DUMP_EXCHANGE);
2565 #ifdef ENCODINGS
2566 if (user->u_plop.buf != oldplop.buf)
2567 free(user->u_plop.buf);
2568 user->u_plop = oldplop;
2569 }
2570 #endif
2571 break;
2572 case RC_READBUF:
2573 #ifdef ENCODINGS
2574 i = fore ? fore->w_encoding : display ? display->d_encoding : 0;
2575 if (args[0] && args[1] && !strcmp(args[0], "-e"))
2576 {
2577 i = FindEncoding(args[1]);
2578 if (i == -1)
2579 {
2580 Msg(0, "%s: readbuf: unknown encoding", rc_name);
2581 break;
2582 }
2583 args += 2;
2584 }
2585 #endif
2586 if (args[0] && args[1])
2587 {
2588 Msg(0, "%s: readbuf: too many arguments", rc_name);
2589 break;
2590 }
2591 if ((s = ReadFile(args[0] ? args[0] : BufferFile, &n)))
2592 {
2593 if (user->u_plop.buf)
2594 UserFreeCopyBuffer(user);
2595 user->u_plop.len = n;
2596 user->u_plop.buf = s;
2597 #ifdef ENCODINGS
2598 user->u_plop.enc = i;
2599 #endif
2600 }
2601 break;
2602 case RC_REMOVEBUF:
2603 KillBuffers();
2604 break;
2605 case RC_IGNORECASE:
2606 (void)ParseSwitch(act, &search_ic);
2607 if (msgok)
2608 Msg(0, "Will %signore case in searches", search_ic ? "" : "not ");
2609 break;
2610 #endif /* COPY_PASTE */
2611 case RC_ESCAPE:
2612 if (*argl == 0)
2613 SetEscape(user, -1, -1);
2614 else if (*argl == 2)
2615 SetEscape(user, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2616 else
2617 {
2618 Msg(0, "%s: two characters required after escape.", rc_name);
2619 break;
2620 }
2621 /* Change defescape if master user. This is because we only
2622 * have one ktab.
2623 */
2624 if (display && user != users)
2625 break;
2626 /* FALLTHROUGH */
2627 case RC_DEFESCAPE:
2628 if (*argl == 0)
2629 SetEscape(NULL, -1, -1);
2630 else if (*argl == 2)
2631 SetEscape(NULL, (int)(unsigned char)args[0][0], (int)(unsigned char)args[0][1]);
2632 else
2633 {
2634 Msg(0, "%s: two characters required after defescape.", rc_name);
2635 break;
2636 }
2637 #ifdef MAPKEYS
2638 CheckEscape();
2639 #endif
2640 break;
2641 case RC_CHDIR:
2642 s = *args ? *args : home;
2643 if (chdir(s) == -1)
2644 Msg(errno, "%s", s);
2645 break;
2646 case RC_SHELL:
2647 case RC_DEFSHELL:
2648 if (ParseSaveStr(act, &ShellProg) == 0)
2649 ShellArgs[0] = ShellProg;
2650 break;
2651 case RC_HARDCOPYDIR:
2652 if (*args)
2653 (void)ParseSaveStr(act, &hardcopydir);
2654 if (msgok)
2655 Msg(0, "hardcopydir is %s\n", hardcopydir && *hardcopydir ? hardcopydir : "<cwd>");
2656 break;
2657 case RC_LOGFILE:
2658 if (*args)
2659 {
2660 if (args[1] && !(strcmp(*args, "flush")))
2661 {
2662 log_flush = atoi(args[1]);
2663 if (msgok)
2664 Msg(0, "log flush timeout set to %ds\n", log_flush);
2665 break;
2666 }
2667 if (ParseSaveStr(act, &screenlogfile) || !msgok)
2668 break;
2669 }
2670 Msg(0, "logfile is '%s'", screenlogfile);
2671 break;
2672 case RC_LOGTSTAMP:
2673 if (!*args || !strcmp(*args, "on") || !strcmp(*args, "off"))
2674 {
2675 if (ParseSwitch(act, &logtstamp_on) == 0 && msgok)
2676 Msg(0, "timestamps turned %s", logtstamp_on ? "on" : "off");
2677 }
2678 else if (!strcmp(*args, "string"))
2679 {
2680 if (args[1])
2681 {
2682 if (logtstamp_string)
2683 free(logtstamp_string);
2684 logtstamp_string = SaveStr(args[1]);
2685 }
2686 if (msgok)
2687 Msg(0, "logfile timestamp is '%s'", logtstamp_string);
2688 }
2689 else if (!strcmp(*args, "after"))
2690 {
2691 if (args[1])
2692 {
2693 logtstamp_after = atoi(args[1]);
2694 if (!msgok)
2695 break;
2696 }
2697 Msg(0, "timestamp printed after %ds\n", logtstamp_after);
2698 }
2699 else
2700 Msg(0, "usage: logtstamp [after [n]|string [str]|on|off]");
2701 break;
2702 case RC_SHELLTITLE:
2703 (void)ParseSaveStr(act, &nwin_default.aka);
2704 break;
2705 case RC_TERMCAP:
2706 case RC_TERMCAPINFO:
2707 case RC_TERMINFO:
2708 if (!rc_name || !*rc_name)
2709 Msg(0, "Sorry, too late now. Place that in your .screenrc file.");
2710 break;
2711 case RC_SLEEP:
2712 break; /* Already handled */
2713 case RC_ALIAS:
2714 if (argc == 1)
2715 DelAlias(args[0]);
2716 else
2717 AddAlias(args[0], args[1], args+1, argl+1, argc - 1);
2718 break;
2719 case RC_TERM:
2720 s = NULL;
2721 if (ParseSaveStr(act, &s))
2722 break;
2723 if (strlen(s) >= 20)
2724 {
2725 Msg(0, "%s: term: argument too long ( < 20)", rc_name);
2726 free(s);
2727 break;
2728 }
2729 strcpy(screenterm, s);
2730 free(s);
2731 debug1("screenterm set to %s\n", screenterm);
2732 MakeTermcap((display == 0));
2733 debug("new termcap made\n");
2734 break;
2735 case RC_ECHO:
2736 if (!msgok && (!rc_name || strcmp(rc_name, "-X")))
2737 break;
2738 /*
2739 * user typed ^A:echo... well, echo isn't FinishRc's job,
2740 * but as he wanted to test us, we show good will
2741 */
2742 if (argc > 1 && !strcmp(*args, "-n"))
2743 {
2744 args++;
2745 argc--;
2746 }
2747 s = *args;
2748 if (argc > 1 && !strcmp(*args, "-p"))
2749 {
2750 args++;
2751 argc--;
2752 s = *args;
2753 if (s)
2754 s = MakeWinMsg(s, fore, '%');
2755 }
2756 if (s)
2757 Msg(0, "%s", s);
2758 else
2759 Msg(0, "%s: 'echo [-n] [-p] \"string\"' expected.", rc_name);
2760 break;
2761 case RC_BELL:
2762 case RC_BELL_MSG:
2763 if (*args == 0)
2764 {
2765 char buf[256];
2766 AddXChars(buf, sizeof(buf), BellString);
2767 Msg(0, "bell_msg is '%s'", buf);
2768 break;
2769 }
2770 (void)ParseSaveStr(act, &BellString);
2771 break;
2772 #ifdef COPY_PASTE
2773 case RC_BUFFERFILE:
2774 if (*args == 0)
2775 BufferFile = SaveStr(DEFAULT_BUFFERFILE);
2776 else if (ParseSaveStr(act, &BufferFile))
2777 break;
2778 if (msgok)
2779 Msg(0, "Bufferfile is now '%s'", BufferFile);
2780 break;
2781 #endif
2782 case RC_ACTIVITY:
2783 (void)ParseSaveStr(act, &ActivityString);
2784 break;
2785 #if defined(DETACH) && defined(POW_DETACH)
2786 case RC_POW_DETACH_MSG:
2787 if (*args == 0)
2788 {
2789 char buf[256];
2790 AddXChars(buf, sizeof(buf), PowDetachString);
2791 Msg(0, "pow_detach_msg is '%s'", buf);
2792 break;
2793 }
2794 (void)ParseSaveStr(act, &PowDetachString);
2795 break;
2796 #endif
2797 #if defined(UTMPOK) && defined(LOGOUTOK)
2798 case RC_LOGIN:
2799 n = fore->w_slot != (slot_t)-1;
2800 if (*args && !strcmp(*args, "always"))
2801 {
2802 fore->w_lflag = 3;
2803 if (!displays && n)
2804 SlotToggle(n);
2805 break;
2806 }
2807 if (*args && !strcmp(*args, "attached"))
2808 {
2809 fore->w_lflag = 1;
2810 if (!displays && n)
2811 SlotToggle(0);
2812 break;
2813 }
2814 if (ParseSwitch(act, &n) == 0)
2815 SlotToggle(n);
2816 break;
2817 case RC_DEFLOGIN:
2818 if (!strcmp(*args, "always"))
2819 nwin_default.lflag |= 2;
2820 else if (!strcmp(*args, "attached"))
2821 nwin_default.lflag &= ~2;
2822 else
2823 (void)ParseOnOff(act, &nwin_default.lflag);
2824 break;
2825 #endif
2826 case RC_DEFFLOW:
2827 if (args[0] && args[1] && args[1][0] == 'i')
2828 {
2829 iflag = 1;
2830 for (display = displays; display; display = display->d_next)
2831 {
2832 if (!D_flow)
2833 continue;
2834 #if defined(TERMIO) || defined(POSIX)
2835 D_NewMode.tio.c_cc[VINTR] = D_OldMode.tio.c_cc[VINTR];
2836 D_NewMode.tio.c_lflag |= ISIG;
2837 #else /* TERMIO || POSIX */
2838 D_NewMode.m_tchars.t_intrc = D_OldMode.m_tchars.t_intrc;
2839 #endif /* TERMIO || POSIX */
2840 SetTTY(D_userfd, &D_NewMode);
2841 }
2842 }
2843 if (args[0] && args[0][0] == 'a')
2844 nwin_default.flowflag = FLOW_AUTOFLAG;
2845 else
2846 (void)ParseOnOff(act, &nwin_default.flowflag);
2847 break;
2848 case RC_DEFWRAP:
2849 (void)ParseOnOff(act, &nwin_default.wrap);
2850 break;
2851 case RC_DEFC1:
2852 (void)ParseOnOff(act, &nwin_default.c1);
2853 break;
2854 #ifdef COLOR
2855 case RC_DEFBCE:
2856 (void)ParseOnOff(act, &nwin_default.bce);
2857 break;
2858 #endif
2859 case RC_DEFGR:
2860 (void)ParseOnOff(act, &nwin_default.gr);
2861 break;
2862 case RC_DEFMONITOR:
2863 if (ParseOnOff(act, &n) == 0)
2864 nwin_default.monitor = (n == 0) ? MON_OFF : MON_ON;
2865 break;
2866 case RC_DEFSILENCE:
2867 if (ParseOnOff(act, &n) == 0)
2868 nwin_default.silence = (n == 0) ? SILENCE_OFF : SILENCE_ON;
2869 break;
2870 case RC_VERBOSE:
2871 if (!*args)
2872 Msg(0, "W%s echo command when creating windows.",
2873 VerboseCreate ? "ill" : "on't");
2874 else if (ParseOnOff(act, &n) == 0)
2875 VerboseCreate = n;
2876 break;
2877 case RC_HARDSTATUS:
2878 if (display)
2879 {
2880 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
2881 RemoveStatus();
2882 }
2883 if (args[0] && strcmp(args[0], "on") && strcmp(args[0], "off"))
2884 {
2885 struct display *olddisplay = display;
2886 int old_use, new_use = -1;
2887
2888 s = args[0];
2889 if (!strncmp(s, "always", 6))
2890 s += 6;
2891 if (!strcmp(s, "lastline"))
2892 new_use = HSTATUS_LASTLINE;
2893 else if (!strcmp(s, "ignore"))
2894 new_use = HSTATUS_IGNORE;
2895 else if (!strcmp(s, "message"))
2896 new_use = HSTATUS_MESSAGE;
2897 else if (!strcmp(args[0], "string"))
2898 {
2899 if (!args[1])
2900 {
2901 char buf[256];
2902 AddXChars(buf, sizeof(buf), hstatusstring);
2903 Msg(0, "hardstatus string is '%s'", buf);
2904 break;
2905 }
2906 }
2907 else
2908 {
2909 Msg(0, "%s: usage: hardstatus [always]lastline|ignore|message|string [string]", rc_name);
2910 break;
2911 }
2912 if (new_use != -1)
2913 {
2914 hardstatusemu = new_use | (s == args[0] ? 0 : HSTATUS_ALWAYS);
2915 for (display = displays; display; display = display->d_next)
2916 {
2917 RemoveStatus();
2918 new_use = hardstatusemu & ~HSTATUS_ALWAYS;
2919 if (D_HS && s == args[0])
2920 new_use = HSTATUS_HS;
2921 ShowHStatus((char *)0);
2922 old_use = D_has_hstatus;
2923 D_has_hstatus = new_use;
2924 if ((new_use == HSTATUS_LASTLINE && old_use != HSTATUS_LASTLINE) || (new_use != HSTATUS_LASTLINE && old_use == HSTATUS_LASTLINE))
2925 ChangeScreenSize(D_width, D_height, 1);
2926 RefreshHStatus();
2927 }
2928 }
2929 if (args[1])
2930 {
2931 if (hstatusstring)
2932 free(hstatusstring);
2933 hstatusstring = SaveStr(args[1]);
2934 for (display = displays; display; display = display->d_next)
2935 RefreshHStatus();
2936 }
2937 display = olddisplay;
2938 break;
2939 }
2940 (void)ParseSwitch(act, &use_hardstatus);
2941 if (msgok)
2942 Msg(0, "messages displayed on %s", use_hardstatus ? "hardstatus line" : "window");
2943 break;
2944 case RC_CAPTION:
2945 if (strcmp(args[0], "always") == 0 || strcmp(args[0], "splitonly") == 0)
2946 {
2947 struct display *olddisplay = display;
2948
2949 captionalways = args[0][0] == 'a';
2950 for (display = displays; display; display = display->d_next)
2951 ChangeScreenSize(D_width, D_height, 1);
2952 display = olddisplay;
2953 }
2954 else if (strcmp(args[0], "string") == 0)
2955 {
2956 if (!args[1])
2957 {
2958 char buf[256];
2959 AddXChars(buf, sizeof(buf), captionstring);
2960 Msg(0, "caption string is '%s'", buf);
2961 break;
2962 }
2963 }
2964 else
2965 {
2966 Msg(0, "%s: usage: caption always|splitonly|string <string>", rc_name);
2967 break;
2968 }
2969 if (!args[1])
2970 break;
2971 if (captionstring)
2972 free(captionstring);
2973 captionstring = SaveStr(args[1]);
2974 RedisplayDisplays(0);
2975 break;
2976 case RC_CONSOLE:
2977 n = (console_window != 0);
2978 if (ParseSwitch(act, &n))
2979 break;
2980 if (TtyGrabConsole(fore->w_ptyfd, n, rc_name))
2981 break;
2982 if (n == 0)
2983 Msg(0, "%s: releasing console %s", rc_name, HostName);
2984 else if (console_window)
2985 Msg(0, "%s: stealing console %s from window %d (%s)", rc_name,
2986 HostName, console_window->w_number, console_window->w_title);
2987 else
2988 Msg(0, "%s: grabbing console %s", rc_name, HostName);
2989 console_window = n ? fore : 0;
2990 break;
2991 case RC_ALLPARTIAL:
2992 if (ParseOnOff(act, &all_norefresh))
2993 break;
2994 if (!all_norefresh && fore)
2995 Activate(-1);
2996 if (msgok)
2997 Msg(0, all_norefresh ? "No refresh on window change!\n" :
2998 "Window specific refresh\n");
2999 break;
3000 case RC_PARTIAL:
3001 (void)ParseSwitch(act, &n);
3002 fore->w_norefresh = n;
3003 break;
3004 case RC_VBELL:
3005 if (ParseSwitch(act, &visual_bell) || !msgok)
3006 break;
3007 if (visual_bell == 0)
3008 Msg(0, "switched to audible bell.");
3009 else
3010 Msg(0, "switched to visual bell.");
3011 break;
3012 case RC_VBELLWAIT:
3013 if (ParseNum1000(act, &VBellWait) == 0 && msgok)
3014 Msg(0, "vbellwait set to %.10g seconds", VBellWait/1000.);
3015 break;
3016 case RC_MSGWAIT:
3017 if (ParseNum1000(act, &MsgWait) == 0 && msgok)
3018 Msg(0, "msgwait set to %.10g seconds", MsgWait/1000.);
3019 break;
3020 case RC_MSGMINWAIT:
3021 if (ParseNum1000(act, &MsgMinWait) == 0 && msgok)
3022 Msg(0, "msgminwait set to %.10g seconds", MsgMinWait/1000.);
3023 break;
3024 case RC_SILENCEWAIT:
3025 if (ParseNum(act, &SilenceWait))
3026 break;
3027 if (SilenceWait < 1)
3028 SilenceWait = 1;
3029 for (p = windows; p; p = p->w_next)
3030 p->w_silencewait = SilenceWait;
3031 if (msgok)
3032 Msg(0, "silencewait set to %d seconds", SilenceWait);
3033 break;
3034 case RC_NUMBER:
3035 if (*args == 0)
3036 Msg(0, "This is window %d (%s).\n", fore->w_number, fore->w_title);
3037 else
3038 {
3039 int old = fore->w_number;
3040 int rel = 0, parse;
3041 if (args[0][0] == '+')
3042 rel = 1;
3043 else if (args[0][0] == '-')
3044 rel = -1;
3045 if (rel)
3046 ++act->args[0];
3047 parse = ParseNum(act, &n);
3048 if (rel)
3049 --act->args[0];
3050 if (parse)
3051 break;
3052 if (rel > 0)
3053 n += old;
3054 else if (rel < 0)
3055 n = old - n;
3056 ChangeWinNum(old, n);
3057 }
3058 break;
3059 case RC_SILENCE:
3060 n = fore->w_silence != 0;
3061 i = fore->w_silencewait;
3062 if (args[0] && (args[0][0] == '-' || (args[0][0] >= '0' && args[0][0] <= '9')))
3063 {
3064 if (ParseNum(act, &i))
3065 break;
3066 n = i > 0;
3067 }
3068 else if (ParseSwitch(act, &n))
3069 break;
3070 if (n)
3071 {
3072 #ifdef MULTIUSER
3073 if (display) /* we tell only this user */
3074 ACLBYTE(fore->w_lio_notify, D_user->u_id) |= ACLBIT(D_user->u_id);
3075 else
3076 for (n = 0; n < maxusercount; n++)
3077 ACLBYTE(fore->w_lio_notify, n) |= ACLBIT(n);
3078 #endif
3079 fore->w_silencewait = i;
3080 fore->w_silence = SILENCE_ON;
3081 SetTimeout(&fore->w_silenceev, fore->w_silencewait * 1000);
3082 evenq(&fore->w_silenceev);
3083
3084 if (!msgok)
3085 break;
3086 Msg(0, "The window is now being monitored for %d sec. silence.", fore->w_silencewait);
3087 }
3088 else
3089 {
3090 #ifdef MULTIUSER
3091 if (display) /* we remove only this user */
3092 ACLBYTE(fore->w_lio_notify, D_user->u_id)
3093 &= ~ACLBIT(D_user->u_id);
3094 else
3095 for (n = 0; n < maxusercount; n++)
3096 ACLBYTE(fore->w_lio_notify, n) &= ~ACLBIT(n);
3097 for (i = maxusercount - 1; i >= 0; i--)
3098 if (ACLBYTE(fore->w_lio_notify, i))
3099 break;
3100 if (i < 0)
3101 #endif
3102 {
3103 fore->w_silence = SILENCE_OFF;
3104 evdeq(&fore->w_silenceev);
3105 }
3106 if (!msgok)
3107 break;
3108 Msg(0, "The window is no longer being monitored for silence.");
3109 }
3110 break;
3111 #ifdef COPY_PASTE
3112 case RC_DEFSCROLLBACK:
3113 (void)ParseNum(act, &nwin_default.histheight);
3114 break;
3115 case RC_SCROLLBACK:
3116 if (flayer->l_layfn == &MarkLf)
3117 {
3118 Msg(0, "Cannot resize scrollback buffer in copy/scrollback mode.");
3119 break;
3120 }
3121 (void)ParseNum(act, &n);
3122 ChangeWindowSize(fore, fore->w_width, fore->w_height, n);
3123 if (msgok)
3124 Msg(0, "scrollback set to %d", fore->w_histheight);
3125 break;
3126 #endif
3127 case RC_SESSIONNAME:
3128 if (*args == 0)
3129 Msg(0, "This session is named '%s'\n", SockName);
3130 else
3131 {
3132 char buf[MAXPATHLEN];
3133
3134 s = 0;
3135 if (ParseSaveStr(act, &s))
3136 break;
3137 if (!*s || strlen(s) + (SockName - SockPath) > MAXPATHLEN - 13 || index(s, '/'))
3138 {
3139 Msg(0, "%s: bad session name '%s'\n", rc_name, s);
3140 free(s);
3141 break;
3142 }
3143 strncpy(buf, SockPath, SockName - SockPath);
3144 sprintf(buf + (SockName - SockPath), "%d.%s", (int)getpid(), s);
3145 free(s);
3146 if ((access(buf, F_OK) == 0) || (errno != ENOENT))
3147 {
3148 Msg(0, "%s: inappropriate path: '%s'.", rc_name, buf);
3149 break;
3150 }
3151 if (rename(SockPath, buf))
3152 {
3153 Msg(errno, "%s: failed to rename(%s, %s)", rc_name, SockPath, buf);
3154 break;
3155 }
3156 debug2("rename(%s, %s) done\n", SockPath, buf);
3157 strcpy(SockPath, buf);
3158 MakeNewEnv();
3159 WindowChanged((struct win *)0, 'S');
3160 }
3161 break;
3162 case RC_SETENV:
3163 if (!args[0] || !args[1])
3164 {
3165 debug1("RC_SETENV arguments missing: %s\n", args[0] ? args[0] : "");
3166 InputSetenv(args[0]);
3167 }
3168 else
3169 {
3170 xsetenv(args[0], args[1]);
3171 MakeNewEnv();
3172 }
3173 break;
3174 case RC_UNSETENV:
3175 unsetenv(*args);
3176 MakeNewEnv();
3177 break;
3178 #ifdef COPY_PASTE
3179 case RC_DEFSLOWPASTE:
3180 (void)ParseNum(act, &nwin_default.slow);
3181 break;
3182 case RC_SLOWPASTE:
3183 if (*args == 0)
3184 Msg(0, fore->w_slowpaste ?
3185 "Slowpaste in window %d is %d milliseconds." :
3186 "Slowpaste in window %d is unset.",
3187 fore->w_number, fore->w_slowpaste);
3188 else if (ParseNum(act, &fore->w_slowpaste) == 0 && msgok)
3189 Msg(0, fore->w_slowpaste ?
3190 "Slowpaste in window %d set to %d milliseconds." :
3191 "Slowpaste in window %d now unset.",
3192 fore->w_number, fore->w_slowpaste);
3193 break;
3194 case RC_MARKKEYS:
3195 if (CompileKeys(*args, *argl, mark_key_tab))
3196 {
3197 Msg(0, "%s: markkeys: syntax error.", rc_name);
3198 break;
3199 }
3200 debug1("markkeys %s\n", *args);
3201 break;
3202 # ifdef FONT
3203 case RC_PASTEFONT:
3204 if (ParseSwitch(act, &pastefont) == 0 && msgok)
3205 Msg(0, "Will %spaste font settings", pastefont ? "" : "not ");
3206 break;
3207 # endif
3208 case RC_CRLF:
3209 (void)ParseSwitch(act, &join_with_cr);
3210 break;
3211 case RC_COMPACTHIST:
3212 if (ParseSwitch(act, &compacthist) == 0 && msgok)
3213 Msg(0, "%scompacting history lines", compacthist ? "" : "not ");
3214 break;
3215 #endif
3216 #ifdef NETHACK
3217 case RC_NETHACK:
3218 (void)ParseOnOff(act, &nethackflag);
3219 break;
3220 #endif
3221 case RC_HARDCOPY_APPEND:
3222 (void)ParseOnOff(act, &hardcopy_append);
3223 break;
3224 case RC_VBELL_MSG:
3225 if (*args == 0)
3226 {
3227 char buf[256];
3228 AddXChars(buf, sizeof(buf), VisualBellString);
3229 Msg(0, "vbell_msg is '%s'", buf);
3230 break;
3231 }
3232 (void)ParseSaveStr(act, &VisualBellString);
3233 debug1(" new vbellstr '%s'\n", VisualBellString);
3234 break;
3235 case RC_DEFMODE:
3236 if (ParseBase(act, *args, &n, 8, "octal"))
3237 break;
3238 if (n < 0 || n > 0777)
3239 {
3240 Msg(0, "%s: mode: Invalid tty mode %o", rc_name, n);
3241 break;
3242 }
3243 TtyMode = n;
3244 if (msgok)
3245 Msg(0, "Ttymode set to %03o", TtyMode);
3246 break;
3247 case RC_AUTODETACH:
3248 (void)ParseOnOff(act, &auto_detach);
3249 break;
3250 case RC_STARTUP_MESSAGE:
3251 (void)ParseOnOff(act, &default_startup);
3252 break;
3253 #ifdef PASSWORD
3254 case RC_PASSWORD:
3255 if (*args)
3256 {
3257 n = (*user->u_password) ? 1 : 0;
3258 if (user->u_password != NullStr) free((char *)user->u_password);
3259 user->u_password = SaveStr(*args);
3260 if (!strcmp(user->u_password, "none"))
3261 {
3262 if (n)
3263 Msg(0, "Password checking disabled");
3264 free(user->u_password);
3265 user->u_password = NullStr;
3266 }
3267 }
3268 else
3269 {
3270 if (!fore)
3271 {
3272 Msg(0, "%s: password: window required", rc_name);
3273 break;
3274 }
3275 Input("New screen password:", 100, INP_NOECHO, pass1, display ? (char *)D_user : (char *)users, 0);
3276 }
3277 break;
3278 #endif /* PASSWORD */
3279 case RC_BIND:
3280 {
3281 struct action *ktabp = ktab;
3282 int kflag = 0;
3283
3284 for (;;)
3285 {
3286 if (argc > 2 && !strcmp(*args, "-c"))
3287 {
3288 ktabp = FindKtab(args[1], 1);
3289 if (ktabp == 0)
3290 break;
3291 args += 2;
3292 argl += 2;
3293 argc -= 2;
3294 }
3295 else if (argc > 1 && !strcmp(*args, "-k"))
3296 {
3297 kflag = 1;
3298 args++;
3299 argl++;
3300 argc--;
3301 }
3302 else
3303 break;
3304 }
3305 #ifdef MAPKEYS
3306 if (kflag)
3307 {
3308 for (n = 0; n < KMAP_KEYS; n++)
3309 if (strcmp(term[n + T_CAPS].tcname, *args) == 0)
3310 break;
3311 if (n == KMAP_KEYS)
3312 {
3313 Msg(0, "%s: bind: unknown key '%s'", rc_name, *args);
3314 break;
3315 }
3316 n += 256;
3317 }
3318 else
3319 #endif
3320 if (*argl != 1)
3321 {
3322 Msg(0, "%s: bind: character, ^x, or (octal) \\032 expected.", rc_name);
3323 break;
3324 }
3325 else
3326 n = (unsigned char)args[0][0];
3327
3328 if (args[1])
3329 {
3330 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
3331 {
3332 struct alias *alias = FindAlias(args[1]);
3333 if (!alias)
3334 {
3335 Msg(0, "%s: bind: unknown command or alias '%s'", rc_name, args[1]);
3336 break;
3337 }
3338 i = alias->nr;
3339 }
3340 if (i <= RC_LAST && CheckArgNum(i, args + 2) < 0)
3341 break;
3342 ClearAction(&ktabp[n]);
3343 SaveAction(ktabp + n, i, args + 2, argl + 2);
3344 }
3345 else
3346 ClearAction(&ktabp[n]);
3347 }
3348 break;
3349 #ifdef MAPKEYS
3350 case RC_BINDKEY:
3351 {
3352 struct action *newact;
3353 int newnr, fl = 0, kf = 0, af = 0, df = 0, mf = 0;
3354 struct display *odisp = display;
3355 int used = 0;
3356 struct kmap_ext *kme;
3357
3358 for (; *args && **args == '-'; args++, argl++)
3359 {
3360 if (strcmp(*args, "-t") == 0)
3361 fl = KMAP_NOTIMEOUT;
3362 else if (strcmp(*args, "-k") == 0)
3363 kf = 1;
3364 else if (strcmp(*args, "-a") == 0)
3365 af = 1;
3366 else if (strcmp(*args, "-d") == 0)
3367 df = 1;
3368 else if (strcmp(*args, "-m") == 0)
3369 mf = 1;
3370 else if (strcmp(*args, "--") == 0)
3371 {
3372 args++;
3373 argl++;
3374 break;
3375 }
3376 else
3377 {
3378 Msg(0, "%s: bindkey: invalid option %s", rc_name, *args);
3379 return;
3380 }
3381 }
3382 if (df && mf)
3383 {
3384 Msg(0, "%s: bindkey: -d does not work with -m", rc_name);
3385 break;
3386 }
3387 if (*args == 0)
3388 {
3389 if (mf)
3390 display_bindkey("Edit mode", mmtab);
3391 else if (df)
3392 display_bindkey("Default", dmtab);
3393 else
3394 display_bindkey("User", umtab);
3395 break;
3396 }
3397 if (kf == 0)
3398 {
3399 if (af)
3400 {
3401 Msg(0, "%s: bindkey: -a only works with -k", rc_name);
3402 break;
3403 }
3404 if (*argl == 0)
3405 {
3406 Msg(0, "%s: bindkey: empty string makes no sense", rc_name);
3407 break;
3408 }
3409 for (i = 0, kme = kmap_exts; i < kmap_extn; i++, kme++)
3410 if (kme->str == 0)
3411 {
3412 if (args[1])
3413 break;
3414 }
3415 else
3416 if (*argl == (kme->fl & ~KMAP_NOTIMEOUT) && bcmp(kme->str, *args, *argl) == 0)
3417 break;
3418 if (i == kmap_extn)
3419 {
3420 if (!args[1])
3421 {
3422 Msg(0, "%s: bindkey: keybinding not found", rc_name);
3423 break;
3424 }
3425 kmap_extn += 8;
3426 kmap_exts = (struct kmap_ext *)xrealloc((char *)kmap_exts, kmap_extn * sizeof(*kmap_exts));
3427 kme = kmap_exts + i;
3428 bzero((char *)kme, 8 * sizeof(*kmap_exts));
3429 for (; i < kmap_extn; i++, kme++)
3430 {
3431 kme->str = 0;
3432 kme->dm.nr = kme->mm.nr = kme->um.nr = RC_ILLEGAL;
3433 kme->dm.args = kme->mm.args = kme->um.args = noargs;
3434 }
3435 i -= 8;
3436 kme -= 8;
3437 }
3438 if (df == 0 && kme->dm.nr != RC_ILLEGAL)
3439 used = 1;
3440 if (mf == 0 && kme->mm.nr != RC_ILLEGAL)
3441 used = 1;
3442 if ((df || mf) && kme->um.nr != RC_ILLEGAL)
3443 used = 1;
3444 i += KMAP_KEYS + KMAP_AKEYS;
3445 newact = df ? &kme->dm : mf ? &kme->mm : &kme->um;
3446 }
3447 else
3448 {
3449 for (i = T_CAPS; i < T_OCAPS; i++)
3450 if (strcmp(term[i].tcname, *args) == 0)
3451 break;
3452 if (i == T_OCAPS)
3453 {
3454 Msg(0, "%s: bindkey: unknown key '%s'", rc_name, *args);
3455 break;
3456 }
3457 if (af && i >= T_CURSOR && i < T_OCAPS)
3458 i -= T_CURSOR - KMAP_KEYS;
3459 else
3460 i -= T_CAPS;
3461 newact = df ? &dmtab[i] : mf ? &mmtab[i] : &umtab[i];
3462 }
3463 if (args[1])
3464 {
3465 if ((newnr = FindCommnr(args[1])) == RC_ILLEGAL)
3466 {
3467 struct alias *alias = FindAlias(args[1]);
3468 if (!alias)
3469 {
3470 Msg(0, "%s: bindkey: unknown command or alias '%s'", rc_name, args[1]);
3471 break;
3472 }
3473 newnr = alias->nr;
3474 }
3475 if (newnr <= RC_LAST && CheckArgNum(newnr, args + 2) < 0)
3476 break;
3477 ClearAction(newact);
3478 SaveAction(newact, newnr, args + 2, argl + 2);
3479 if (kf == 0 && args[1])
3480 {
3481 if (kme->str)
3482 free(kme->str);
3483 kme->str = SaveStrn(*args, *argl);
3484 kme->fl = fl | *argl;
3485 }
3486 }
3487 else
3488 ClearAction(newact);
3489 for (display = displays; display; display = display->d_next)
3490 remap(i, args[1] ? 1 : 0);
3491 if (kf == 0 && !args[1])
3492 {
3493 if (!used && kme->str)
3494 {
3495 free(kme->str);
3496 kme->str = 0;
3497 kme->fl = 0;
3498 }
3499 }
3500 display = odisp;
3501 }
3502 break;
3503 case RC_MAPTIMEOUT:
3504 if (*args)
3505 {
3506 if (ParseNum(act, &n))
3507 break;
3508 if (n < 0)
3509 {
3510 Msg(0, "%s: maptimeout: illegal time %d", rc_name, n);
3511 break;
3512 }
3513 maptimeout = n;
3514 }
3515 if (*args == 0 || msgok)
3516 Msg(0, "maptimeout is %dms", maptimeout);
3517 break;
3518 case RC_MAPNOTNEXT:
3519 D_dontmap = 1;
3520 break;
3521 case RC_MAPDEFAULT:
3522 D_mapdefault = 1;
3523 break;
3524 #endif
3525 #ifdef MULTIUSER
3526 case RC_ACLCHG:
3527 case RC_ACLADD:
3528 case RC_ADDACL:
3529 case RC_CHACL:
3530 UsersAcl(NULL, argc, args);
3531 break;
3532 case RC_ACLDEL:
3533 if (UserDel(args[0], NULL))
3534 break;
3535 if (msgok)
3536 Msg(0, "%s removed from acl database", args[0]);
3537 break;
3538 case RC_ACLGRP:
3539 /*
3540 * modify a user to gain or lose rights granted to a group.
3541 * This group is actually a normal user whose rights were defined
3542 * with chacl in the usual way.
3543 */
3544 if (args[1])
3545 {
3546 if (strcmp(args[1], "none")) /* link a user to another user */
3547 {
3548 if (AclLinkUser(args[0], args[1]))
3549 break;
3550 if (msgok)
3551 Msg(0, "User %s joined acl-group %s", args[0], args[1]);
3552 }
3553 else /* remove all groups from user */
3554 {
3555 struct acluser *u;
3556 struct aclusergroup *g;
3557
3558 if (!(u = *FindUserPtr(args[0])))
3559 break;
3560 while ((g = u->u_group))
3561 {
3562 u->u_group = g->next;
3563 free((char *)g);
3564 }
3565 }
3566 }
3567 else /* show all groups of user */
3568 {
3569 char buf[256], *p = buf;
3570 int ngroups = 0;
3571 struct acluser *u;
3572 struct aclusergroup *g;
3573
3574 if (!(u = *FindUserPtr(args[0])))
3575 {
3576 if (msgok)
3577 Msg(0, "User %s does not exist.", args[0]);
3578 break;
3579 }
3580 g = u->u_group;
3581 while (g)
3582 {
3583 ngroups++;
3584 sprintf(p, "%s ", g->u->u_name);
3585 p += strlen(p);
3586 if (p > buf+200)
3587 break;
3588 g = g->next;
3589 }
3590 if (ngroups)
3591 *(--p) = '\0';
3592 Msg(0, "%s's group%s: %s.", args[0], (ngroups == 1) ? "" : "s",
3593 (ngroups == 0) ? "none" : buf);
3594 }
3595 break;
3596 case RC_ACLUMASK:
3597 case RC_UMASK:
3598 while ((s = *args++))
3599 {
3600 char *err = 0;
3601
3602 if (AclUmask(display ? D_user : users, s, &err))
3603 Msg(0, "umask: %s\n", err);
3604 }
3605 break;
3606 case RC_MULTIUSER:
3607 if (ParseOnOff(act, &n))
3608 break;
3609 multi = n ? "" : 0;
3610 chsock();
3611 if (msgok)
3612 Msg(0, "Multiuser mode %s", multi ? "enabled" : "disabled");
3613 break;
3614 #endif /* MULTIUSER */
3615 #ifdef PSEUDOS
3616 case RC_EXEC:
3617 winexec(args);
3618 break;
3619 #endif
3620 #ifdef MULTI
3621 case RC_NONBLOCK:
3622 i = D_nonblock >= 0;
3623 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3624 {
3625 if (ParseNum1000(act, &i))
3626 break;
3627 }
3628 else if (!ParseSwitch(act, &i))
3629 i = i == 0 ? -1 : 1000;
3630 else
3631 break;
3632 if (msgok && i == -1)
3633 Msg(0, "display set to blocking mode");
3634 else if (msgok && i == 0)
3635 Msg(0, "display set to nonblocking mode, no timeout");
3636 else if (msgok)
3637 Msg(0, "display set to nonblocking mode, %.10gs timeout", i/1000.);
3638 D_nonblock = i;
3639 if (D_nonblock <= 0)
3640 evdeq(&D_blockedev);
3641 break;
3642 case RC_DEFNONBLOCK:
3643 if (*args && ((args[0][0] >= '0' && args[0][0] <= '9') || args[0][0] == '.'))
3644 {
3645 if (ParseNum1000(act, &defnonblock))
3646 break;
3647 }
3648 else if (!ParseOnOff(act, &defnonblock))
3649 defnonblock = defnonblock == 0 ? -1 : 1000;
3650 else
3651 break;
3652 if (display && *rc_name)
3653 {
3654 D_nonblock = defnonblock;
3655 if (D_nonblock <= 0)
3656 evdeq(&D_blockedev);
3657 }
3658 break;
3659 #endif
3660 case RC_GR:
3661 #ifdef ENCODINGS
3662 if (fore->w_gr == 2)
3663 fore->w_gr = 0;
3664 #endif
3665 if (ParseSwitch(act, &fore->w_gr) == 0 && msgok)
3666 Msg(0, "Will %suse GR", fore->w_gr ? "" : "not ");
3667 #ifdef ENCODINGS
3668 if (fore->w_gr == 0 && fore->w_FontE)
3669 fore->w_gr = 2;
3670 #endif
3671 break;
3672 case RC_C1:
3673 if (ParseSwitch(act, &fore->w_c1) == 0 && msgok)
3674 Msg(0, "Will %suse C1", fore->w_c1 ? "" : "not ");
3675 break;
3676 #ifdef COLOR
3677 case RC_BCE:
3678 if (ParseSwitch(act, &fore->w_bce) == 0 && msgok)
3679 Msg(0, "Will %serase with background color", fore->w_bce ? "" : "not ");
3680 break;
3681 #endif
3682 #ifdef ENCODINGS
3683 case RC_KANJI:
3684 case RC_ENCODING:
3685 #ifdef UTF8
3686 if (*args && !strcmp(args[0], "-d"))
3687 {
3688 if (!args[1])
3689 Msg(0, "encodings directory is %s", screenencodings ? screenencodings : "<unset>");
3690 else
3691 {
3692 free(screenencodings);
3693 screenencodings = SaveStr(args[1]);
3694 }
3695 break;
3696 }
3697 if (*args && !strcmp(args[0], "-l"))
3698 {
3699 if (!args[1])
3700 Msg(0, "encoding: -l: argument required");
3701 else if (LoadFontTranslation(-1, args[1]))
3702 Msg(0, "encoding: could not load utf8 encoding file");
3703 else if (msgok)
3704 Msg(0, "encoding: utf8 encoding file loaded");
3705 break;
3706 }
3707 #else
3708 if (*args && (!strcmp(args[0], "-l") || !strcmp(args[0], "-d")))
3709 {
3710 if (msgok)
3711 Msg(0, "encoding: screen is not compiled for UTF-8.");
3712 break;
3713 }
3714 #endif
3715 for (i = 0; i < 2; i++)
3716 {
3717 if (args[i] == 0)
3718 break;
3719 if (!strcmp(args[i], "."))
3720 continue;
3721 n = FindEncoding(args[i]);
3722 if (n == -1)
3723 {
3724 Msg(0, "encoding: unknown encoding '%s'", args[i]);
3725 break;
3726 }
3727 if (i == 0 && fore)
3728 {
3729 WinSwitchEncoding(fore, n);
3730 ResetCharsets(fore);
3731 }
3732 else if (i && display)
3733 D_encoding = n;
3734 }
3735 break;
3736 case RC_DEFKANJI:
3737 case RC_DEFENCODING:
3738 n = FindEncoding(*args);
3739 if (n == -1)
3740 {
3741 Msg(0, "defencoding: unknown encoding '%s'", *args);
3742 break;
3743 }
3744 nwin_default.encoding = n;
3745 break;
3746 #endif
3747
3748 #ifdef UTF8
3749 case RC_DEFUTF8:
3750 n = nwin_default.encoding == UTF8;
3751 if (ParseSwitch(act, &n) == 0)
3752 {
3753 nwin_default.encoding = n ? UTF8 : 0;
3754 if (msgok)
3755 Msg(0, "Will %suse UTF-8 encoding for new windows", n ? "" : "not ");
3756 }
3757 break;
3758 case RC_UTF8:
3759 for (i = 0; i < 2; i++)
3760 {
3761 if (i && args[i] == 0)
3762 break;
3763 if (args[i] == 0)
3764 n = fore->w_encoding != UTF8;
3765 else if (strcmp(args[i], "off") == 0)
3766 n = 0;
3767 else if (strcmp(args[i], "on") == 0)
3768 n = 1;
3769 else
3770 {
3771 Msg(0, "utf8: illegal argument (%s)", args[i]);
3772 break;
3773 }
3774 if (i == 0)
3775 {
3776 WinSwitchEncoding(fore, n ? UTF8 : 0);
3777 if (msgok)
3778 Msg(0, "Will %suse UTF-8 encoding", n ? "" : "not ");
3779 }
3780 else if (display)
3781 D_encoding = n ? UTF8 : 0;
3782 if (args[i] == 0)
3783 break;
3784 }
3785 break;
3786 #endif
3787
3788 case RC_PRINTCMD:
3789 if (*args)
3790 {
3791 if (printcmd)
3792 free(printcmd);
3793 printcmd = 0;
3794 if (**args)
3795 printcmd = SaveStr(*args);
3796 }
3797 if (*args == 0 || msgok)
3798 {
3799 if (printcmd)
3800 Msg(0, "using '%s' as print command", printcmd);
3801 else
3802 Msg(0, "using termcap entries for printing");
3803 break;
3804 }
3805 break;
3806
3807 case RC_DIGRAPH:
3808 if (argl && argl[0] > 0 && argl[1] > 0)
3809 {
3810 if (argl[0] != 2)
3811 {
3812 Msg(0, "Two characters expected to define a digraph");
3813 break;
3814 }
3815 i = digraph_find(args[0]);
3816 digraphs[i].d[0] = args[0][0];
3817 digraphs[i].d[1] = args[0][1];
3818 if (!parse_input_int(args[1], argl[1], &digraphs[i].value))
3819 {
3820 if (!(digraphs[i].value = atoi(args[1])))
3821 {
3822 if (!args[1][1])
3823 digraphs[i].value = (int)args[1][0];
3824 #ifdef UTF8
3825 else
3826 {
3827 int t;
3828 unsigned char *s = args[1];
3829 digraphs[i].value = 0;
3830 while (*s)
3831 {
3832 t = FromUtf8(*s++, &digraphs[i].value);
3833 if (t == -1)
3834 continue;
3835 if (t == -2)
3836 digraphs[i].value = 0;
3837 else
3838 digraphs[i].value = t;
3839 break;
3840 }
3841 }
3842 #endif
3843 }
3844 }
3845 break;
3846 }
3847 Input("Enter digraph: ", 10, INP_EVERY, digraph_fn, NULL, 0);
3848 if (*args && **args)
3849 {
3850 s = *args;
3851 n = strlen(s);
3852 LayProcess(&s, &n);
3853 }
3854 break;
3855
3856 case RC_DEFHSTATUS:
3857 if (*args == 0)
3858 {
3859 char buf[256];
3860 *buf = 0;
3861 if (nwin_default.hstatus)
3862 AddXChars(buf, sizeof(buf), nwin_default.hstatus);
3863 Msg(0, "default hstatus is '%s'", buf);
3864 break;
3865 }
3866 (void)ParseSaveStr(act, &nwin_default.hstatus);
3867 if (*nwin_default.hstatus == 0)
3868 {
3869 free(nwin_default.hstatus);
3870 nwin_default.hstatus = 0;
3871 }
3872 break;
3873 case RC_HSTATUS:
3874 (void)ParseSaveStr(act, &fore->w_hstatus);
3875 if (*fore->w_hstatus == 0)
3876 {
3877 free(fore->w_hstatus);
3878 fore->w_hstatus = 0;
3879 }
3880 WindowChanged(fore, 'h');
3881 break;
3882
3883 #ifdef FONT
3884 case RC_DEFCHARSET:
3885 case RC_CHARSET:
3886 if (*args == 0)
3887 {
3888 char buf[256];
3889 *buf = 0;
3890 if (nwin_default.charset)
3891 AddXChars(buf, sizeof(buf), nwin_default.charset);
3892 Msg(0, "default charset is '%s'", buf);
3893 break;
3894 }
3895 n = strlen(*args);
3896 if (n == 0 || n > 6)
3897 {
3898 Msg(0, "%s: %s: string has illegal size.", rc_name, comms[nr].name);
3899 break;
3900 }
3901 if (n > 4 && (
3902 ((args[0][4] < '0' || args[0][4] > '3') && args[0][4] != '.') ||
3903 ((args[0][5] < '0' || args[0][5] > '3') && args[0][5] && args[0][5] != '.')))
3904 {
3905 Msg(0, "%s: %s: illegal mapping number.", rc_name, comms[nr].name);
3906 break;
3907 }
3908 if (nr == RC_CHARSET)
3909 {
3910 SetCharsets(fore, *args);
3911 break;
3912 }
3913 if (nwin_default.charset)
3914 free(nwin_default.charset);
3915 nwin_default.charset = SaveStr(*args);
3916 break;
3917 #endif
3918 #ifdef COLOR
3919 case RC_ATTRCOLOR:
3920 s = args[0];
3921 if (*s >= '0' && *s <= '9')
3922 i = *s - '0';
3923 else
3924 for (i = 0; i < 8; i++)
3925 if (*s == "dubrsBiI"[i])
3926 break;
3927 s++;
3928 nr = 0;
3929 if (*s && s[1] && !s[2])
3930 {
3931 if (*s == 'd' && s[1] == 'd')
3932 nr = 3;
3933 else if (*s == '.' && s[1] == 'd')
3934 nr = 2;
3935 else if (*s == 'd' && s[1] == '.')
3936 nr = 1;
3937 else if (*s != '.' || s[1] != '.')
3938 s--;
3939 s += 2;
3940 }
3941 if (*s || i < 0 || i >= 8)
3942 {
3943 Msg(0, "%s: attrcolor: unknown attribute '%s'.", rc_name, args[0]);
3944 break;
3945 }
3946 n = 0;
3947 if (args[1])
3948 n = ParseAttrColor(args[1], args[2], 1);
3949 if (n == -1)
3950 break;
3951 attr2color[i][nr] = n;
3952 n = 0;
3953 for (i = 0; i < 8; i++)
3954 if (attr2color[i][0] || attr2color[i][1] || attr2color[i][2] || attr2color[i][3])
3955 n |= 1 << i;
3956 nattr2color = n;
3957 break;
3958 #endif
3959 case RC_RENDITION:
3960 i = -1;
3961 if (strcmp(args[0], "bell") == 0)
3962 {
3963 i = REND_BELL;
3964 }
3965 else if (strcmp(args[0], "monitor") == 0)
3966 {
3967 i = REND_MONITOR;
3968 }
3969 else if (strcmp(args[0], "so") != 0)
3970 {
3971 Msg(0, "Invalid option '%s' for rendition", args[0]);
3972 break;
3973 }
3974
3975 ++args;
3976 ++argl;
3977
3978 if (i != -1)
3979 {
3980 renditions[i] = ParseAttrColor(args[0], args[1], 1);
3981 WindowChanged((struct win *)0, 'w');
3982 WindowChanged((struct win *)0, 'W');
3983 WindowChanged((struct win *)0, 0);
3984 break;
3985 }
3986
3987 /* We are here, means we want to set the sorendition. */
3988 /* FALLTHROUGH*/
3989 case RC_SORENDITION:
3990 i = 0;
3991 if (*args)
3992 {
3993 i = ParseAttrColor(*args, args[1], 1);
3994 if (i == -1)
3995 break;
3996 ApplyAttrColor(i, &mchar_so);
3997 WindowChanged((struct win *)0, 0);
3998 debug2("--> %x %x\n", mchar_so.attr, mchar_so.color);
3999 }
4000 if (msgok)
4001 #ifdef COLOR
4002 Msg(0, "Standout attributes 0x%02x color 0x%02x", (unsigned char)mchar_so.attr, 0x99 ^ (unsigned char)mchar_so.color);
4003 #else
4004 Msg(0, "Standout attributes 0x%02x ", (unsigned char)mchar_so.attr);
4005 #endif
4006 break;
4007
4008 case RC_SOURCE:
4009 do_source(*args);
4010 break;
4011
4012 #ifdef SCRIPT
4013 case RC_SCRIPT:
4014 ScriptCmd(argc, (const char **) args);
4015 break;
4016 #endif
4017
4018 #ifdef MULTIUSER
4019 case RC_SU:
4020 s = NULL;
4021 if (!*args)
4022 {
4023 Msg(0, "%s:%s screen login", HostName, SockPath);
4024 InputSu(D_fore, &D_user, NULL);
4025 }
4026 else if (!args[1])
4027 InputSu(D_fore, &D_user, args[0]);
4028 else if (!args[2])
4029 s = DoSu(&D_user, args[0], args[1], "\377");
4030 else
4031 s = DoSu(&D_user, args[0], args[1], args[2]);
4032 if (s)
4033 Msg(0, "%s", s);
4034 break;
4035 #endif /* MULTIUSER */
4036 case RC_SPLIT:
4037 s = args[0];
4038 if (s && !strcmp(s, "-v"))
4039 AddCanvas(SLICE_HORI);
4040 else
4041 AddCanvas(SLICE_VERT);
4042 Activate(-1);
4043 break;
4044 case RC_REMOVE:
4045 RemCanvas();
4046 Activate(-1);
4047 break;
4048 case RC_ONLY:
4049 OneCanvas();
4050 Activate(-1);
4051 break;
4052 case RC_FIT:
4053 D_forecv->c_xoff = D_forecv->c_xs;
4054 D_forecv->c_yoff = D_forecv->c_ys;
4055 RethinkViewportOffsets(D_forecv);
4056 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
4057 flayer = D_forecv->c_layer;
4058 LaySetCursor();
4059 break;
4060 case RC_FOCUS:
4061 {
4062 struct canvas *n_forecv = NULL;
4063 if (!*args || !strcmp(*args, "down"))
4064 n_forecv = D_forecv->c_next ? D_forecv->c_next : D_cvlist;
4065 else if (!strcmp(*args, "up"))
4066 {
4067 struct canvas *cv;
4068 for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next)
4069 ;
4070 n_forecv = cv;
4071 }
4072 else if (!strcmp(*args, "top"))
4073 n_forecv = D_cvlist;
4074 else if (!strcmp(*args, "bottom"))
4075 {
4076 struct canvas *cv;
4077 for (cv = D_cvlist; cv->c_next; cv = cv->c_next)
4078 ;
4079 n_forecv = cv;
4080 }
4081 else
4082 {
4083 Msg(0, "%s: usage: focus [up|down|top|bottom]", rc_name);
4084 break;
4085 }
4086 FocusCanvas(n_forecv);
4087 }
4088 break;
4089 case RC_RESIZE:
4090 i = 0;
4091 if (D_forecv->c_slorient == SLICE_UNKN)
4092 {
4093 Msg(0, "resize: need more than one region");
4094 break;
4095 }
4096 for (; *args; args++)
4097 {
4098 if (!strcmp(*args, "-h"))
4099 i |= RESIZE_FLAG_H;
4100 else if (!strcmp(*args, "-v"))
4101 i |= RESIZE_FLAG_V;
4102 else if (!strcmp(*args, "-b"))
4103 i |= RESIZE_FLAG_H | RESIZE_FLAG_V;
4104 else if (!strcmp(*args, "-p"))
4105 i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
4106 else if (!strcmp(*args, "-l"))
4107 i |= RESIZE_FLAG_L;
4108 else
4109 break;
4110 }
4111 if (*args && args[1])
4112 {
4113 Msg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name);
4114 break;
4115 }
4116 if (*args)
4117 ResizeRegions(*args, i);
4118 else
4119 Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i);
4120 break;
4121 case RC_SETSID:
4122 (void)ParseSwitch(act, &separate_sids);
4123 break;
4124 case RC_EVAL:
4125 args = SaveArgs(args);
4126 for (i = 0; args[i]; i++)
4127 {
4128 if (args[i][0])
4129 Colonfin(args[i], strlen(args[i]), (char *)0);
4130 free(args[i]);
4131 }
4132 free(args);
4133 break;
4134 case RC_ALTSCREEN:
4135 (void)ParseSwitch(act, &use_altscreen);
4136 if (msgok)
4137 Msg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not ");
4138 break;
4139 case RC_MAXWIN:
4140 if (ParseNum(act, &n))
4141 break;
4142 if (n < 1)
4143 Msg(0, "illegal maxwin number specified");
4144 else if (n > maxwin)
4145 Msg(0, "may only decrease maxwin number");
4146 else
4147 maxwin = n;
4148 break;
4149 case RC_BACKTICK:
4150 if (ParseBase(act, *args, &n, 10, "decimal"))
4151 break;
4152 if (!args[1])
4153 setbacktick(n, 0, 0, (char **)0);
4154 else
4155 {
4156 int lifespan, tick;
4157 if (argc < 4)
4158 {
4159 Msg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name);
4160 break;
4161 }
4162 if (ParseBase(act, args[1], &lifespan, 10, "decimal"))
4163 break;
4164 if (ParseBase(act, args[2], &tick, 10, "decimal"))
4165 break;
4166 setbacktick(n, lifespan, tick, SaveArgs(args + 3));
4167 }
4168 WindowChanged(0, '`');
4169 break;
4170 case RC_BLANKER:
4171 #ifdef BLANKER_PRG
4172 if (blankerprg)
4173 {
4174 RunBlanker(blankerprg);
4175 break;
4176 }
4177 #endif
4178 ClearAll();
4179 CursorVisibility(-1);
4180 D_blocked = 4;
4181 break;
4182 #ifdef BLANKER_PRG
4183 case RC_BLANKERPRG:
4184 if (blankerprg)
4185 {
4186 char **pp;
4187 for (pp = blankerprg; *pp; pp++)
4188 free(*pp);
4189 free(blankerprg);
4190 blankerprg = 0;
4191 }
4192 if (args[0][0])
4193 blankerprg = SaveArgs(args);
4194 break;
4195 #endif
4196 case RC_IDLE:
4197 if (*args)
4198 {
4199 struct display *olddisplay = display;
4200 if (!strcmp(*args, "off"))
4201 idletimo = 0;
4202 else if (args[0][0])
4203 idletimo = atoi(*args) * 1000;
4204 if (argc > 1)
4205 {
4206 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
4207 {
4208 struct alias *alias = FindAlias(args[1]);
4209 if (!alias)
4210 {
4211 Msg(0, "%s: idle: unknown command or alias '%s'", rc_name, args[1]);
4212 break;
4213 }
4214 i = alias->nr;
4215 }
4216 if (i <= RC_LAST && CheckArgNum(i, args + 2) < 0)
4217 break;
4218 ClearAction(&idleaction);
4219 SaveAction(&idleaction, i, args + 2, argl + 2);
4220 }
4221 for (display = displays; display; display = display->d_next)
4222 ResetIdle();
4223 display = olddisplay;
4224 }
4225 if (msgok)
4226 {
4227 if (idletimo)
4228 Msg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name);
4229 else
4230 Msg(0, "idle off");
4231 }
4232 break;
4233 case RC_FOCUSMINSIZE:
4234 for (i = 0; i < 2 && args[i]; i++)
4235 {
4236 if (!strcmp(args[i], "max") || !strcmp(args[i], "_"))
4237 n = -1;
4238 else
4239 n = atoi(args[i]);
4240 if (i == 0)
4241 focusminwidth = n;
4242 else
4243 focusminheight = n;
4244 }
4245 if (msgok)
4246 {
4247 char b[2][20];
4248 for (i = 0; i < 2; i++)
4249 {
4250 n = i == 0 ? focusminwidth : focusminheight;
4251 if (n == -1)
4252 strcpy(b[i], "max");
4253 else
4254 sprintf(b[i], "%d", n);
4255 }
4256 Msg(0, "focus min size is %s %s\n", b[0], b[1]);
4257 }
4258 break;
4259 case RC_GROUP:
4260 if (*args)
4261 {
4262 fore->w_group = 0;
4263 if (args[0][0])
4264 {
4265 fore->w_group = WindowByName(*args);
4266 if (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)
4267 fore->w_group = 0;
4268 }
4269 WindowChanged((struct win *)0, 'w');
4270 WindowChanged((struct win *)0, 'W');
4271 WindowChanged((struct win *)0, 0);
4272 }
4273 if (msgok)
4274 {
4275 if (fore->w_group)
4276 Msg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title);
4277 else
4278 Msg(0, "window belongs to no group");
4279 }
4280 break;
4281 case RC_LAYOUT:
4282 if (!strcmp(args[0], "title"))
4283 {
4284 if (!D_layout)
4285 {
4286 Msg(0, "not on a layout");
4287 break;
4288 }
4289 if (!args[1])
4290 {
4291 Msg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title);
4292 break;
4293 }
4294 free(D_layout->lay_title);
4295 D_layout->lay_title= SaveStr(args[1]);
4296 }
4297 else if (!strcmp(args[0], "number"))
4298 {
4299 int old;
4300 struct layout *lay;
4301 if (!D_layout)
4302 {
4303 Msg(0, "not on a layout");
4304 break;
4305 }
4306 if (!args[1])
4307 {
4308 Msg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title);
4309 break;
4310 }
4311 LayoutChangeNumber(D_layout, atoi(args[1]));
4312 break;
4313 }
4314 else if (!strcmp(args[0], "autosave"))
4315 {
4316 if (!D_layout)
4317 {
4318 Msg(0, "not on a layout");
4319 break;
4320 }
4321 if (args[1])
4322 {
4323 if (!strcmp(args[1], "on"))
4324 D_layout->lay_autosave = 1;
4325 else if (!strcmp(args[1], "off"))
4326 D_layout->lay_autosave = 0;
4327 else
4328 {
4329 Msg(0, "invalid argument. Give 'on' or 'off");
4330 break;
4331 }
4332 }
4333 if (msgok)
4334 Msg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off");
4335 }
4336 else if (!strcmp(args[0], "new"))
4337 {
4338 char *t = args[1];
4339 n = 0;
4340 if (t)
4341 {
4342 while (*t >= '0' && *t <= '9')
4343 t++;
4344 if (t != args[1] && (!*t || *t == ':'))
4345 {
4346 n = atoi(args[1]);
4347 if (*t)
4348 t++;
4349 }
4350 else
4351 t = args[1];
4352 }
4353 if (!t || !*t)
4354 t = "layout";
4355 NewLayout(t, n);
4356 Activate(-1);
4357 }
4358 else if (!strcmp(args[0], "save"))
4359 {
4360 if (!args[1])
4361 {
4362 Msg(0, "usage: layout save <name>");
4363 break;
4364 }
4365 SaveLayout(args[1], &D_canvas);
4366 }
4367 else if (!strcmp(args[0], "select"))
4368 {
4369 if (!args[1])
4370 {
4371 Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0);
4372 break;
4373 }
4374 SelectLayoutFin(args[1], strlen(args[1]), (char *)0);
4375 }
4376 else if (!strcmp(args[0], "next"))
4377 {
4378 struct layout *lay = D_layout;
4379 if (lay)
4380 lay = lay->lay_next ? lay->lay_next : layouts;
4381 else
4382 lay = layouts;
4383 if (!lay)
4384 {
4385 Msg(0, "no layout defined");
4386 break;
4387 }
4388 if (lay == D_layout)
4389 break;
4390 LoadLayout(lay, &D_canvas);
4391 Activate(-1);
4392 }
4393 else if (!strcmp(args[0], "prev"))
4394 {
4395 struct layout *lay = D_layout;
4396 if (lay)
4397 {
4398 for (lay = layouts; lay->lay_next && lay->lay_next != D_layout; lay = lay->lay_next)
4399 ;
4400 }
4401 else
4402 lay = layouts;
4403 if (!lay)
4404 {
4405 Msg(0, "no layout defined");
4406 break;
4407 }
4408 if (lay == D_layout)
4409 break;
4410 LoadLayout(lay, &D_canvas);
4411 Activate(-1);
4412 }
4413 else if (!strcmp(args[0], "attach"))
4414 {
4415 if (!args[1])
4416 {
4417 if (!layout_attach)
4418 Msg(0, "no attach layout set");
4419 else if (layout_attach == &layout_last_marker)
4420 Msg(0, "will attach to last layout");
4421 else
4422 Msg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title);
4423 break;
4424 }
4425 if (!strcmp(args[1], ":last"))
4426 layout_attach = &layout_last_marker;
4427 else if (!args[1][0])
4428 layout_attach = 0;
4429 else
4430 {
4431 struct layout *lay;
4432 lay = FindLayout(args[1]);
4433 if (!lay)
4434 {
4435 Msg(0, "unknown layout '%s'", args[1]);
4436 break;
4437 }
4438 layout_attach = lay;
4439 }
4440 }
4441 else if (!strcmp(args[0], "show"))
4442 {
4443 ShowLayouts(-1);
4444 }
4445 else if (!strcmp(args[0], "remove"))
4446 {
4447 struct layout *lay = display ? D_layout : layouts;
4448 if (args[1])
4449 {
4450 lay = layouts ? FindLayout(args[1]) : (struct layout *)0;
4451 if (!lay)
4452 {
4453 Msg(0, "unknown layout '%s'", args[1]);
4454 break;
4455 }
4456 }
4457 if (lay)
4458 RemoveLayout(lay);
4459 }
4460 else
4461 Msg(0, "unknown layout subcommand");
4462 break;
4463 #ifdef DW_CHARS
4464 case RC_CJKWIDTH:
4465 if(ParseSwitch(act, &cjkwidth) == 0)
4466 {
4467 if(msgok)
4468 Msg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half");
4469 }
4470 break;
4471 #endif
4472 default:
4473 #ifdef HAVE_BRAILLE
4474 /* key == -2: input from braille keybord, msgok always 0 */
4475 DoBrailleAction(act, key == -2 ? 0 : msgok);
4476 #endif
4477 break;
4478 }
4479
4480 #ifdef SCRIPT
4481 if (nr < RC_LAST)
4482 trigger_sevent(&globalevents.cmdexecuted, comms[nr].name, args);
4483 #endif
4484
4485 if (display != odisplay)
4486 {
4487 for (display = displays; display; display = display->d_next)
4488 if (display == odisplay)
4489 break;
4490 }
4491 }
4492
4493 static int
4494 DoAlias(name, args, argl)
4495 const char *name;
4496 char **args;
4497 int *argl;
4498 {
4499 char **mergeds;
4500 int *mergedl;
4501 int count, i;
4502 struct alias *alias = FindAlias(name);
4503
4504 if (alias == NULL)
4505 return 0;
4506
4507 count = 0;
4508 for (; args && args[count]; count++)
4509 ;
4510 for (i = 0; alias->args && alias->args[i]; i++, count++)
4511 ;
4512 ++count;
4513
4514 if ((mergeds = malloc(count * sizeof(char *))) == 0)
4515 return 0;
4516 if ((mergedl = malloc(count * sizeof(int))) == 0)
4517 {
4518 free(mergeds);
4519 return 0;
4520 }
4521 for (count = 0; alias->args && alias->args[count]; count++)
4522 {
4523 mergeds[count] = alias->args[count];
4524 mergedl[count] = alias->argl[count];
4525 }
4526 for (i = 0; args && args[i]; i++, count++)
4527 {
4528 mergeds[count] = args[i];
4529 mergedl[count] = argl[i];
4530 }
4531 mergeds[count] = 0;
4532 mergedl[count] = 0 ;
4533
4534 DoCommand(mergeds, mergedl);
4535
4536 free(mergeds);
4537 free(mergedl);
4538 return 1;
4539 }
4540
4541 void
4542 DoCommand(argv, argl)
4543 char **argv;
4544 int *argl;
4545 {
4546 struct action act;
4547
4548 /* Alias? */
4549 if (DoAlias(*argv, argv + 1, argl + 1))
4550 return;
4551
4552 if ((act.nr = FindCommnr(*argv)) == RC_ILLEGAL)
4553 {
4554 Msg(0, "%s: unknown command '%s'", rc_name, *argv);
4555 return;
4556 }
4557 act.args = argv + 1;
4558 act.argl = argl + 1;
4559 DoAction(&act, -1);
4560 }
4561
4562 static void
4563 SaveAction(act, nr, args, argl)
4564 struct action *act;
4565 int nr;
4566 char **args;
4567 int *argl;
4568 {
4569 register int argc = 0;
4570 char **pp;
4571 int *lp;
4572
4573 if (args)
4574 while (args[argc])
4575 argc++;
4576 if (argc == 0)
4577 {
4578 act->nr = nr;
4579 act->args = noargs;
4580 act->argl = 0;
4581 return;
4582 }
4583 if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4584 Panic(0, strnomem);
4585 if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int *))) == 0)
4586 Panic(0, strnomem);
4587 act->nr = nr;
4588 act->args = pp;
4589 act->argl = lp;
4590 while (argc--)
4591 {
4592 *lp = argl ? *argl++ : (int)strlen(*args);
4593 *pp++ = SaveStrn(*args++, *lp++);
4594 }
4595 *pp = 0;
4596 }
4597
4598 static char **
4599 SaveArgs(args)
4600 char **args;
4601 {
4602 register char **ap, **pp;
4603 register int argc = 0;
4604
4605 while (args[argc])
4606 argc++;
4607 if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4608 Panic(0, strnomem);
4609 while (argc--)
4610 *pp++ = SaveStr(*args++);
4611 *pp = 0;
4612 return ap;
4613 }
4614
4615
4616 /*
4617 * buf is split into argument vector args.
4618 * leading whitespace is removed.
4619 * @!| abbreviations are expanded.
4620 * the end of buffer is recognized by '\0' or an un-escaped '#'.
4621 * " and ' are interpreted.
4622 *
4623 * argc is returned.
4624 */
4625 int
4626 Parse(buf, bufl, args, argl)
4627 char *buf, **args;
4628 int bufl, *argl;
4629 {
4630 register char *p = buf, **ap = args, *pp;
4631 register int delim, argc;
4632 int *lp = argl;
4633
4634 debug2("Parse %d %s\n", bufl, buf);
4635 argc = 0;
4636 pp = buf;
4637 delim = 0;
4638 for (;;)
4639 {
4640 while (*p && (*p == ' ' || *p == '\t'))
4641 ++p;
4642 #ifdef PSEUDOS
4643 if (argc == 0 && *p == '!')
4644 {
4645 *ap++ = "exec";
4646 *lp++ = 4;
4647 p++;
4648 argc++;
4649 continue;
4650 }
4651 #endif
4652 if (*p == '\0' || *p == '#' || *p == '\n')
4653 {
4654 *p = '\0';
4655 for (delim = 0; delim < argc; delim++)
4656 debug1("-- %s\n", args[delim]);
4657 args[argc] = 0;
4658 return argc;
4659 }
4660 if (++argc >= MAXARGS)
4661 {
4662 Msg(0, "%s: too many tokens.", rc_name);
4663 return 0;
4664 }
4665 *ap++ = pp;
4666
4667 debug1("- new arg %s\n", p);
4668 while (*p)
4669 {
4670 if (*p == delim)
4671 delim = 0;
4672 else if (delim != '\'' && *p == '\\' && (p[1] == 'n' || p[1] == 'r' || p[1] == 't' || p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7')))
4673 {
4674 p++;
4675 if (*p >= '0' && *p <= '7')
4676 {
4677 *pp = *p - '0';
4678 if (p[1] >= '0' && p[1] <= '7')
4679 {
4680 p++;
4681 *pp = (*pp << 3) | (*p - '0');
4682 if (p[1] >= '0' && p[1] <= '7')
4683 {
4684 p++;
4685 *pp = (*pp << 3) | (*p - '0');
4686 }
4687 }
4688 pp++;
4689 }
4690 else
4691 {
4692 switch (*p)
4693 {
4694 case 'n': *pp = '\n'; break;
4695 case 'r': *pp = '\r'; break;
4696 case 't': *pp = '\t'; break;
4697 default: *pp = *p; break;
4698 }
4699 pp++;
4700 }
4701 }
4702 else if (delim != '\'' && *p == '$' && (p[1] == '{' || p[1] == ':' || (p[1] >= 'a' && p[1] <= 'z') || (p[1] >= 'A' && p[1] <= 'Z') || (p[1] >= '0' && p[1] <= '9') || p[1] == '_'))
4703
4704 {
4705 char *ps, *pe, op, *v, xbuf[11];
4706 int vl;
4707
4708 ps = ++p;
4709 debug1("- var %s\n", ps);
4710 p++;
4711 while (*p)
4712 {
4713 if (*ps == '{' && *p == '}')
4714 break;
4715 if (*ps == ':' && *p == ':')
4716 break;
4717 if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_')
4718 break;
4719 p++;
4720 }
4721 pe = p;
4722 if (*ps == '{' || *ps == ':')
4723 {
4724 if (!*p)
4725 {
4726 Msg(0, "%s: bad variable name.", rc_name);
4727 return 0;
4728 }
4729 p++;
4730 }
4731 op = *pe;
4732 *pe = 0;
4733 debug1("- var is '%s'\n", ps);
4734 if (*ps == ':')
4735 v = gettermcapstring(ps + 1);
4736 else
4737 {
4738 if (*ps == '{')
4739 ps++;
4740 v = xbuf;
4741 if (!strcmp(ps, "TERM"))
4742 v = display ? D_termname : "unknown";
4743 else if (!strcmp(ps, "COLUMNS"))
4744 sprintf(xbuf, "%d", display ? D_width : -1);
4745 else if (!strcmp(ps, "LINES"))
4746 sprintf(xbuf, "%d", display ? D_height : -1);
4747 else
4748 v = getenv(ps);
4749 }
4750 *pe = op;
4751 vl = v ? strlen(v) : 0;
4752 if (vl)
4753 {
4754 debug1("- sub is '%s'\n", v);
4755 if (p - pp < vl)
4756 {
4757 int right = buf + bufl - (p + strlen(p) + 1);
4758 if (right > 0)
4759 {
4760 bcopy(p, p + right, strlen(p) + 1);
4761 p += right;
4762 }
4763 }
4764 if (p - pp < vl)
4765 {
4766 Msg(0, "%s: no space left for variable expansion.", rc_name);
4767 return 0;
4768 }
4769 bcopy(v, pp, vl);
4770 pp += vl;
4771 }
4772 continue;
4773 }
4774 else if (delim != '\'' && *p == '^' && p[1])
4775 {
4776 p++;
4777 *pp++ = *p == '?' ? '\177' : *p & 0x1f;
4778 }
4779 else if (delim == 0 && (*p == '\'' || *p == '"'))
4780 delim = *p;
4781 else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n'))
4782 break;
4783 else
4784 *pp++ = *p;
4785 p++;
4786 }
4787 if (delim)
4788 {
4789 Msg(0, "%s: Missing %c quote.", rc_name, delim);
4790 return 0;
4791 }
4792 if (*p)
4793 p++;
4794 *pp = 0;
4795 debug2("- arg done, '%s' rest %s\n", ap[-1], p);
4796 *lp++ = pp - ap[-1];
4797 pp++;
4798 }
4799 }
4800
4801 void
4802 SetEscape(u, e, me)
4803 struct acluser *u;
4804 int e, me;
4805 {
4806 if (u)
4807 {
4808 u->u_Esc = e;
4809 u->u_MetaEsc = me;
4810 }
4811 else
4812 {
4813 if (users)
4814 {
4815 if (DefaultEsc >= 0)
4816 ClearAction(&ktab[DefaultEsc]);
4817 if (DefaultMetaEsc >= 0)
4818 ClearAction(&ktab[DefaultMetaEsc]);
4819 }
4820 DefaultEsc = e;
4821 DefaultMetaEsc = me;
4822 if (users)
4823 {
4824 if (DefaultEsc >= 0)
4825 {
4826 ClearAction(&ktab[DefaultEsc]);
4827 ktab[DefaultEsc].nr = RC_OTHER;
4828 }
4829 if (DefaultMetaEsc >= 0)
4830 {
4831 ClearAction(&ktab[DefaultMetaEsc]);
4832 ktab[DefaultMetaEsc].nr = RC_META;
4833 }
4834 }
4835 }
4836 }
4837
4838 int
4839 ParseSwitch(act, var)
4840 struct action *act;
4841 int *var;
4842 {
4843 if (*act->args == 0)
4844 {
4845 *var ^= 1;
4846 return 0;
4847 }
4848 return ParseOnOff(act, var);
4849 }
4850
4851 static int
4852 ParseOnOff(act, var)
4853 struct action *act;
4854 int *var;
4855 {
4856 register int num = -1;
4857 char **args = act->args;
4858
4859 if (args[1] == 0)
4860 {
4861 if (strcmp(args[0], "on") == 0)
4862 num = 1;
4863 else if (strcmp(args[0], "off") == 0)
4864 num = 0;
4865 }
4866 if (num < 0)
4867 {
4868 Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name);
4869 return -1;
4870 }
4871 *var = num;
4872 return 0;
4873 }
4874
4875 int
4876 ParseSaveStr(act, var)
4877 struct action *act;
4878 char **var;
4879 {
4880 char **args = act->args;
4881 if (*args == 0 || args[1])
4882 {
4883 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4884 return -1;
4885 }
4886 if (*var)
4887 free(*var);
4888 *var = SaveStr(*args);
4889 return 0;
4890 }
4891
4892 int
4893 ParseNum(act, var)
4894 struct action *act;
4895 int *var;
4896 {
4897 int i;
4898 char *p, **args = act->args;
4899
4900 p = *args;
4901 if (p == 0 || *p == 0 || args[1])
4902 {
4903 Msg(0, "%s: %s: invalid argument. Give one argument.",
4904 rc_name, comms[act->nr].name);
4905 return -1;
4906 }
4907 i = 0;
4908 while (*p)
4909 {
4910 if (*p >= '0' && *p <= '9')
4911 i = 10 * i + (*p - '0');
4912 else
4913 {
4914 Msg(0, "%s: %s: invalid argument. Give numeric argument.",
4915 rc_name, comms[act->nr].name);
4916 return -1;
4917 }
4918 p++;
4919 }
4920 debug1("ParseNum got %d\n", i);
4921 *var = i;
4922 return 0;
4923 }
4924
4925 static int
4926 ParseNum1000(act, var)
4927 struct action *act;
4928 int *var;
4929 {
4930 int i;
4931 char *p, **args = act->args;
4932 int dig = 0;
4933
4934 p = *args;
4935 if (p == 0 || *p == 0 || args[1])
4936 {
4937 Msg(0, "%s: %s: invalid argument. Give one argument.",
4938 rc_name, comms[act->nr].name);
4939 return -1;
4940 }
4941 i = 0;
4942 while (*p)
4943 {
4944 if (*p >= '0' && *p <= '9')
4945 {
4946 if (dig < 4)
4947 i = 10 * i + (*p - '0');
4948 else if (dig == 4 && *p >= '5')
4949 i++;
4950 if (dig)
4951 dig++;
4952 }
4953 else if (*p == '.' && !dig)
4954 dig++;
4955 else
4956 {
4957 Msg(0, "%s: %s: invalid argument. Give floating point argument.",
4958 rc_name, comms[act->nr].name);
4959 return -1;
4960 }
4961 p++;
4962 }
4963 if (dig == 0)
4964 i *= 1000;
4965 else
4966 while (dig++ < 4)
4967 i *= 10;
4968 if (i < 0)
4969 i = (int)((unsigned int)~0 >> 1);
4970 debug1("ParseNum1000 got %d\n", i);
4971 *var = i;
4972 return 0;
4973 }
4974
4975 static struct win *
4976 WindowByName(s)
4977 char *s;
4978 {
4979 struct win *p;
4980
4981 for (p = windows; p; p = p->w_next)
4982 if (!strcmp(p->w_title, s))
4983 return p;
4984 for (p = windows; p; p = p->w_next)
4985 if (!strncmp(p->w_title, s, strlen(s)))
4986 return p;
4987 return 0;
4988 }
4989
4990 static int
4991 WindowByNumber(str)
4992 char *str;
4993 {
4994 int i;
4995 char *s;
4996
4997 for (i = 0, s = str; *s; s++)
4998 {
4999 if (*s < '0' || *s > '9')
5000 break;
5001 i = i * 10 + (*s - '0');
5002 }
5003 return *s ? -1 : i;
5004 }
5005
5006 /*
5007 * Get window number from Name or Number string.
5008 * Numbers are tried first, then names, a prefix match suffices.
5009 * Be careful when assigning numeric strings as WindowTitles.
5010 */
5011 int
5012 WindowByNoN(str)
5013 char *str;
5014 {
5015 int i;
5016 struct win *p;
5017
5018 if ((i = WindowByNumber(str)) < 0 || i >= MAXWIN)
5019 {
5020 if ((p = WindowByName(str)))
5021 return p->w_number;
5022 return -1;
5023 }
5024 return i;
5025 }
5026
5027 static int
5028 ParseWinNum(act, var)
5029 struct action *act;
5030 int *var;
5031 {
5032 char **args = act->args;
5033 int i = 0;
5034
5035 if (*args == 0 || args[1])
5036 {
5037 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
5038 return -1;
5039 }
5040
5041 i = WindowByNoN(*args);
5042 if (i < 0)
5043 {
5044 Msg(0, "%s: %s: invalid argument. Give window number or name.",
5045 rc_name, comms[act->nr].name);
5046 return -1;
5047 }
5048 debug1("ParseWinNum got %d\n", i);
5049 *var = i;
5050 return 0;
5051 }
5052
5053 static int
5054 ParseBase(act, p, var, base, bname)
5055 struct action *act;
5056 char *p;
5057 int *var;
5058 int base;
5059 char *bname;
5060 {
5061 int i = 0;
5062 int c;
5063
5064 if (*p == 0)
5065 {
5066 Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name);
5067 return -1;
5068 }
5069 while ((c = *p++))
5070 {
5071 if (c >= 'a' && c <= 'z')
5072 c -= 'a' - 'A';
5073 if (c >= 'A' && c <= 'Z')
5074 c -= 'A' - ('0' + 10);
5075 c -= '0';
5076 if (c < 0 || c >= base)
5077 {
5078 Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname);
5079 return -1;
5080 }
5081 i = base * i + c;
5082 }
5083 debug1("ParseBase got %d\n", i);
5084 *var = i;
5085 return 0;
5086 }
5087
5088 static int
5089 IsNum(s, base)
5090 register char *s;
5091 register int base;
5092 {
5093 for (base += '0'; *s; ++s)
5094 if (*s < '0' || *s > base)
5095 return 0;
5096 return 1;
5097 }
5098
5099 int
5100 IsNumColon(s, base, p, psize)
5101 int base, psize;
5102 char *s, *p;
5103 {
5104 char *q;
5105 if ((q = rindex(s, ':')) != 0)
5106 {
5107 strncpy(p, q + 1, psize - 1);
5108 p[psize - 1] = '\0';
5109 *q = '\0';
5110 }
5111 else
5112 *p = '\0';
5113 return IsNum(s, base);
5114 }
5115
5116 void
5117 SwitchWindow(n)
5118 int n;
5119 {
5120 struct win *p;
5121
5122 debug1("SwitchWindow %d\n", n);
5123 if (n < 0 || n >= MAXWIN)
5124 {
5125 ShowWindows(-1);
5126 return;
5127 }
5128 if ((p = wtab[n]) == 0)
5129 {
5130 ShowWindows(n);
5131 return;
5132 }
5133 if (display == 0)
5134 {
5135 fore = p;
5136 return;
5137 }
5138 if (p == D_fore)
5139 {
5140 Msg(0, "This IS window %d (%s).", n, p->w_title);
5141 return;
5142 }
5143 #ifdef MULTIUSER
5144 if (AclCheckPermWin(D_user, ACL_READ, p))
5145 {
5146 Msg(0, "Access to window %d denied.", p->w_number);
5147 return;
5148 }
5149 #endif
5150 SetForeWindow(p);
5151 Activate(fore->w_norefresh);
5152 }
5153
5154
5155 void
5156 SetCanvasWindow(cv, wi)
5157 struct canvas *cv;
5158 struct win *wi;
5159 {
5160 struct win *p = 0, **pp;
5161 struct layer *l;
5162 struct canvas *cvp, **cvpp;
5163
5164 l = cv->c_layer;
5165 display = cv->c_display;
5166
5167 if (l)
5168 {
5169 /* remove old layer */
5170 for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
5171 if (cvp == cv)
5172 break;
5173 ASSERT(cvp);
5174 *cvpp = cvp->c_lnext;
5175
5176 p = Layer2Window(l);
5177 l = cv->c_layer;
5178 cv->c_layer = 0;
5179
5180 if (p && cv == D_forecv)
5181 {
5182 #ifdef MULTIUSER
5183 ReleaseAutoWritelock(display, p);
5184 #endif
5185 if (p->w_silence)
5186 {
5187 SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
5188 evenq(&p->w_silenceev);
5189 }
5190 D_other = fore;
5191 D_fore = 0;
5192 #ifdef SCRIPT
5193 trigger_sevent(&fore->w_sev.onleave, display, fore);
5194 #endif
5195 }
5196 #ifdef SCRIPT
5197 if (p)
5198 {
5199 int hide = 1;
5200 /* Trigger window hide event if the last view on this display is
5201 * removed */
5202 for (cvp = l->l_cvlist; cvp; cvp = cvp->c_lnext)
5203 if (cvp->c_display == display)
5204 {
5205 hide = 0;
5206 break;
5207 }
5208 if (hide)
5209 trigger_sevent(&fore->w_sev.onhide, display, fore);
5210 }
5211 #endif
5212 if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
5213 KillLayerChain(l);
5214 }
5215
5216 /* find right layer to display on canvas */
5217 if (wi && wi->w_type != W_TYPE_GROUP)
5218 {
5219 l = &wi->w_layer;
5220 if (wi->w_savelayer && (wi->w_blocked || wi->w_savelayer->l_cvlist == 0))
5221 l = wi->w_savelayer;
5222 }
5223 else
5224 {
5225 l = &cv->c_blank;
5226 if (wi)
5227 l->l_data = (char *)wi;
5228 else
5229 l->l_data = 0;
5230 }
5231
5232 /* add our canvas to the layer's canvaslist */
5233 ASSERT(l->l_cvlist != cv);
5234 cv->c_lnext = l->l_cvlist;
5235 l->l_cvlist = cv;
5236 cv->c_layer = l;
5237 cv->c_xoff = cv->c_xs;
5238 cv->c_yoff = cv->c_ys;
5239 RethinkViewportOffsets(cv);
5240
5241 if (flayer == 0)
5242 flayer = l;
5243
5244 if (wi && wi->w_type == W_TYPE_GROUP)
5245 {
5246 /* auto-start windowlist on groups */
5247 struct display *d = display;
5248 struct layer *oldflayer = flayer;
5249 flayer = l;
5250 display_wlist(0, 0, wi);
5251 flayer = oldflayer;
5252 display = d;
5253 }
5254
5255 if (wi && D_other == wi)
5256 D_other = wi->w_next; /* Might be 0, but that's OK. */
5257 if (cv == D_forecv)
5258 {
5259 D_fore = wi;
5260 fore = D_fore; /* XXX ? */
5261 if (wi)
5262 {
5263 #ifdef MULTIUSER
5264 ObtainAutoWritelock(display, wi);
5265 #endif
5266 /*
5267 * Place the window at the head of the most-recently-used list
5268 */
5269 if (windows != wi)
5270 {
5271 for (pp = &windows; (p = *pp); pp = &p->w_next)
5272 if (p == wi)
5273 break;
5274 ASSERT(p);
5275 *pp = p->w_next;
5276 p->w_next = windows;
5277 windows = p;
5278 WListLinkChanged();
5279 }
5280 #ifdef SCRIPT
5281 trigger_sevent(&fore->w_sev.onfocus, display, fore);
5282 #endif
5283 }
5284 }
5285 #ifdef SCRIPT
5286 if (wi && Layer2Window(l) == wi)
5287 {
5288 int show = 0;
5289 /* Trigger window show event if the first view on this display is
5290 * removed */
5291 for (cvp = l->l_cvlist; cvp; cvp = cvp->c_lnext)
5292 if (cvp->c_display == display)
5293 show++;
5294 if (show == 1)
5295 trigger_sevent(&fore->w_sev.onshow, display, fore);
5296 }
5297 #endif
5298 }
5299
5300
5301 /*
5302 * SetForeWindow changes the window in the input focus of the display.
5303 * Puts window wi in canvas display->d_forecv.
5304 */
5305 void
5306 SetForeWindow(wi)
5307 struct win *wi;
5308 {
5309 struct win *p;
5310 if (display == 0)
5311 {
5312 fore = wi;
5313 return;
5314 }
5315 p = Layer2Window(D_forecv->c_layer);
5316 SetCanvasWindow(D_forecv, wi);
5317 if (p)
5318 WindowChanged(p, 'u');
5319 if (wi)
5320 WindowChanged(wi, 'u');
5321 flayer = D_forecv->c_layer;
5322 #ifdef SCRIPT
5323 trigger_sevent(&globalevents.forechanged, display, display ? D_fore : fore);
5324 #endif
5325 /* Activate called afterwards, so no RefreshHStatus needed */
5326 }
5327
5328
5329 /*****************************************************************/
5330
5331 /*
5332 * Activate - make fore window active
5333 * norefresh = -1 forces a refresh, disregard all_norefresh then.
5334 */
5335 void
5336 Activate(norefresh)
5337 int norefresh;
5338 {
5339 debug1("Activate(%d)\n", norefresh);
5340 if (display == 0)
5341 return;
5342 if (D_status)
5343 {
5344 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
5345 RemoveStatus();
5346 }
5347
5348 if (MayResizeLayer(D_forecv->c_layer))
5349 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display);
5350
5351 fore = D_fore;
5352 if (fore)
5353 {
5354 /* XXX ? */
5355 if (fore->w_monitor != MON_OFF)
5356 fore->w_monitor = MON_ON;
5357 fore->w_bell = BELL_ON;
5358 WindowChanged(fore, 'f');
5359
5360 #if 0
5361 if (ResizeDisplay(fore->w_width, fore->w_height))
5362 {
5363 debug2("Cannot resize from (%d,%d)", D_width, D_height);
5364 debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height);
5365 DoResize(D_width, D_height);
5366 }
5367 #endif
5368 }
5369 Redisplay(norefresh + all_norefresh);
5370 }
5371
5372
5373 static int
5374 NextWindow()
5375 {
5376 register struct win **pp;
5377 int n = fore ? fore->w_number : MAXWIN;
5378 struct win *group = fore ? fore->w_group : 0;
5379
5380 for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++)
5381 {
5382 if (pp == wtab + MAXWIN)
5383 pp = wtab;
5384 if (*pp)
5385 {
5386 if (!fore || group == (*pp)->w_group)
5387 break;
5388 }
5389 }
5390 if (pp == wtab + n)
5391 return -1;
5392 return pp - wtab;
5393 }
5394
5395 static int
5396 PreviousWindow()
5397 {
5398 register struct win **pp;
5399 int n = fore ? fore->w_number : -1;
5400 struct win *group = fore ? fore->w_group : 0;
5401
5402 for (pp = wtab + n - 1; pp != wtab + n; pp--)
5403 {
5404 if (pp == wtab - 1)
5405 pp = wtab + MAXWIN - 1;
5406 if (*pp)
5407 {
5408 if (!fore || group == (*pp)->w_group)
5409 break;
5410 }
5411 }
5412 if (pp == wtab + n)
5413 return -1;
5414 return pp - wtab;
5415 }
5416
5417 static int
5418 MoreWindows()
5419 {
5420 char *m = "No other window.";
5421 if (windows && (fore == 0 || windows->w_next))
5422 return 1;
5423 if (fore == 0)
5424 {
5425 Msg(0, "No window available");
5426 return 0;
5427 }
5428 Msg(0, m, fore->w_number); /* other arg for nethack */
5429 return 0;
5430 }
5431
5432 static void
5433 UpdateLayoutCanvas(cv, wi)
5434 struct canvas *cv;
5435 struct win *wi;
5436 {
5437 for (; cv; cv = cv->c_slnext)
5438 {
5439 if (cv->c_layer && Layer2Window(cv->c_layer) == wi)
5440 {
5441 /* A simplistic version of SetCanvasWindow(cv, 0) */
5442 struct layer *l = cv->c_layer;
5443 cv->c_layer = 0;
5444 if (l->l_cvlist == 0 && (wi == 0 || l != wi->w_savelayer))
5445 KillLayerChain(l);
5446 l = &cv->c_blank;
5447 l->l_data = 0;
5448 if (l->l_cvlist != cv)
5449 {
5450 cv->c_lnext = l->l_cvlist;
5451 l->l_cvlist = cv;
5452 }
5453 cv->c_layer = l;
5454 /* Do not end here. Multiple canvases can have the same window */
5455 }
5456
5457 if (cv->c_slperp)
5458 UpdateLayoutCanvas(cv->c_slperp, wi);
5459 }
5460 }
5461
5462 void
5463 KillWindow(wi)
5464 struct win *wi;
5465 {
5466 struct win **pp, *p;
5467 struct canvas *cv;
5468 int gotone;
5469 struct layout *lay;
5470
5471 /*
5472 * Remove window from linked list.
5473 */
5474 for (pp = &windows; (p = *pp); pp = &p->w_next)
5475 if (p == wi)
5476 break;
5477 ASSERT(p);
5478 *pp = p->w_next;
5479 wi->w_inlen = 0;
5480 wtab[wi->w_number] = 0;
5481
5482 if (windows == 0)
5483 {
5484 FreeWindow(wi);
5485 Finit(0);
5486 }
5487
5488 /*
5489 * switch to different window on all canvases
5490 */
5491 for (display = displays; display; display = display->d_next)
5492 {
5493 gotone = 0;
5494 for (cv = D_cvlist; cv; cv = cv->c_next)
5495 {
5496 if (Layer2Window(cv->c_layer) != wi)
5497 continue;
5498 /* switch to other window */
5499 SetCanvasWindow(cv, FindNiceWindow(D_other, 0));
5500 gotone = 1;
5501 }
5502 if (gotone)
5503 {
5504 #ifdef ZMODEM
5505 if (wi->w_zdisplay == display)
5506 {
5507 D_blocked = 0;
5508 D_readev.condpos = D_readev.condneg = 0;
5509 }
5510 #endif
5511 Activate(-1);
5512 }
5513 }
5514
5515 /* do the same for the layouts */
5516 for (lay = layouts; lay; lay = lay->lay_next)
5517 UpdateLayoutCanvas(&lay->lay_canvas, wi);
5518
5519 FreeWindow(wi);
5520 WindowChanged((struct win *)0, 'w');
5521 WindowChanged((struct win *)0, 'W');
5522 WindowChanged((struct win *)0, 0);
5523 }
5524
5525 static void
5526 LogToggle(on)
5527 int on;
5528 {
5529 char buf[1024];
5530
5531 if ((fore->w_log != 0) == on)
5532 {
5533 if (display && !*rc_name)
5534 Msg(0, "You are %s logging.", on ? "already" : "not");
5535 return;
5536 }
5537 if (fore->w_log != 0)
5538 {
5539 Msg(0, "Logfile \"%s\" closed.", fore->w_log->name);
5540 logfclose(fore->w_log);
5541 fore->w_log = 0;
5542 WindowChanged(fore, 'f');
5543 return;
5544 }
5545 if (DoStartLog(fore, buf, sizeof(buf)))
5546 {
5547 Msg(errno, "Error opening logfile \"%s\"", buf);
5548 return;
5549 }
5550 if (ftell(fore->w_log->fp) == 0)
5551 Msg(0, "Creating logfile \"%s\".", fore->w_log->name);
5552 else
5553 Msg(0, "Appending to logfile \"%s\".", fore->w_log->name);
5554 WindowChanged(fore, 'f');
5555 }
5556
5557 char *
5558 AddWindows(buf, len, flags, where)
5559 char *buf;
5560 int len;
5561 int flags;
5562 int where;
5563 {
5564 register char *s, *ss;
5565 register struct win **pp, *p;
5566 register char *cmd;
5567 int l;
5568
5569 s = ss = buf;
5570 if ((flags & 8) && where < 0)
5571 {
5572 *s = 0;
5573 return ss;
5574 }
5575 for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + MAXWIN; pp++)
5576 {
5577 int rend = -1;
5578 if (pp - wtab == where && ss == buf)
5579 ss = s;
5580 if ((p = *pp) == 0)
5581 continue;
5582 if ((flags & 1) && display && p == D_fore)
5583 continue;
5584 if (D_fore && D_fore->w_group != p->w_group)
5585 continue;
5586
5587 cmd = p->w_title;
5588 l = strlen(cmd);
5589 if (l > 20)
5590 l = 20;
5591 if (s - buf + l > len - 24)
5592 break;
5593 if (s > buf || (flags & 4))
5594 {
5595 *s++ = ' ';
5596 *s++ = ' ';
5597 }
5598 if (p->w_number == where)
5599 {
5600 ss = s;
5601 if (flags & 8)
5602 break;
5603 }
5604 if (!(flags & 4) || where < 0 || ((flags & 4) && where < p->w_number))
5605 {
5606 if (p->w_monitor == MON_DONE && renditions[REND_MONITOR] != -1)
5607 rend = renditions[REND_MONITOR];
5608 else if ((p->w_bell == BELL_DONE || p->w_bell == BELL_FOUND) && renditions[REND_BELL] != -1)
5609 rend = renditions[REND_BELL];
5610 }
5611 if (rend != -1)
5612 AddWinMsgRend(s, rend);
5613 sprintf(s, "%d", p->w_number);
5614 s += strlen(s);
5615 if (display && p == D_fore)
5616 *s++ = '*';
5617 if (!(flags & 2))
5618 {
5619 if (display && p == D_other)
5620 *s++ = '-';
5621 s = AddWindowFlags(s, len, p);
5622 }
5623 *s++ = ' ';
5624 strncpy(s, cmd, l);
5625 s += l;
5626 if (rend != -1)
5627 AddWinMsgRend(s, -1);
5628 }
5629 *s = 0;
5630 return ss;
5631 }
5632
5633 char *
5634 AddWindowFlags(buf, len, p)
5635 char *buf;
5636 int len;
5637 struct win *p;
5638 {
5639 char *s = buf;
5640 if (p == 0 || len < 12)
5641 {
5642 *s = 0;
5643 return s;
5644 }
5645 #if 0
5646 if (display && p == D_fore)
5647 *s++ = '*';
5648 if (display && p == D_other)
5649 *s++ = '-';
5650 #endif
5651 if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext)
5652 *s++ = '&';
5653 if (p->w_monitor == MON_DONE
5654 #ifdef MULTIUSER
5655 && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5656 #endif
5657 )
5658 *s++ = '@';
5659 if (p->w_bell == BELL_DONE)
5660 *s++ = '!';
5661 #ifdef UTMPOK
5662 if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1)
5663 *s++ = '$';
5664 #endif
5665 if (p->w_log != 0)
5666 {
5667 strcpy(s, "(L)");
5668 s += 3;
5669 }
5670 if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP)
5671 *s++ = 'Z';
5672 *s = 0;
5673 return s;
5674 }
5675
5676 char *
5677 AddOtherUsers(buf, len, p)
5678 char *buf;
5679 int len;
5680 struct win *p;
5681 {
5682 struct display *d, *olddisplay = display;
5683 struct canvas *cv;
5684 char *s;
5685 int l;
5686
5687 s = buf;
5688 for (display = displays; display; display = display->d_next)
5689 {
5690 if (olddisplay && D_user == olddisplay->d_user)
5691 continue;
5692 for (cv = D_cvlist; cv; cv = cv->c_next)
5693 if (Layer2Window(cv->c_layer) == p)
5694 break;
5695 if (!cv)
5696 continue;
5697 for (d = displays; d && d != display; d = d->d_next)
5698 if (D_user == d->d_user)
5699 break;
5700 if (d && d != display)
5701 continue;
5702 if (len > 1 && s != buf)
5703 {
5704 *s++ = ',';
5705 len--;
5706 }
5707 l = strlen(D_user->u_name);
5708 if (l + 1 > len)
5709 break;
5710 strcpy(s, D_user->u_name);
5711 s += l;
5712 len -= l;
5713 }
5714 *s = 0;
5715 display = olddisplay;
5716 return s;
5717 }
5718
5719 void
5720 ShowWindows(where)
5721 int where;
5722 {
5723 char buf[1024];
5724 char *s, *ss;
5725
5726 if (!display)
5727 return;
5728 if (where == -1 && D_fore)
5729 where = D_fore->w_number;
5730 ss = AddWindows(buf, sizeof(buf), 0, where);
5731 s = buf + strlen(buf);
5732 if (ss - buf > D_width / 2)
5733 {
5734 ss -= D_width / 2;
5735 if (s - ss < D_width)
5736 {
5737 ss = s - D_width;
5738 if (ss < buf)
5739 ss = buf;
5740 }
5741 }
5742 else
5743 ss = buf;
5744 Msg(0, "%s", ss);
5745 }
5746
5747 static void
5748 ShowInfo()
5749 {
5750 char buf[512], *p;
5751 register struct win *wp = fore;
5752 register int i;
5753
5754 if (wp == 0)
5755 {
5756 Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height);
5757 return;
5758 }
5759 p = buf;
5760 if (buf < (p += GetAnsiStatus(wp, p)))
5761 *p++ = ' ';
5762 sprintf(p, "(%d,%d)/(%d,%d)",
5763 wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height);
5764 #ifdef COPY_PASTE
5765 sprintf(p += strlen(p), "+%d", wp->w_histheight);
5766 #endif
5767 sprintf(p += strlen(p), " %c%sflow",
5768 (wp->w_flow & FLOW_NOW) ? '+' : '-',
5769 (wp->w_flow & FLOW_AUTOFLAG) ? "" :
5770 ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)"));
5771 if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap");
5772 if (wp->w_insert) sprintf(p += strlen(p), " ins");
5773 if (wp->w_origin) sprintf(p += strlen(p), " org");
5774 if (wp->w_keypad) sprintf(p += strlen(p), " app");
5775 if (wp->w_log) sprintf(p += strlen(p), " log");
5776 if (wp->w_monitor != MON_OFF
5777 #ifdef MULTIUSER
5778 && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5779 #endif
5780 )
5781 sprintf(p += strlen(p), " mon");
5782 if (wp->w_mouse) sprintf(p += strlen(p), " mouse");
5783 #ifdef COLOR
5784 if (wp->w_bce) sprintf(p += strlen(p), " bce");
5785 #endif
5786 if (!wp->w_c1) sprintf(p += strlen(p), " -c1");
5787 if (wp->w_norefresh) sprintf(p += strlen(p), " nored");
5788
5789 p += strlen(p);
5790 #ifdef FONT
5791 # ifdef ENCODINGS
5792 if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0))
5793 {
5794 *p++ = ' ';
5795 strcpy(p, EncodingName(wp->w_encoding));
5796 p += strlen(p);
5797 }
5798 # ifdef UTF8
5799 if (wp->w_encoding != UTF8)
5800 # endif
5801 # endif
5802 if (D_CC0 || (D_CS0 && *D_CS0))
5803 {
5804 if (wp->w_gr == 2)
5805 {
5806 sprintf(p, " G%c", wp->w_Charset + '0');
5807 if (wp->w_FontE >= ' ')
5808 p[3] = wp->w_FontE;
5809 else
5810 {
5811 p[3] = '^';
5812 p[4] = wp->w_FontE ^ 0x40;
5813 p++;
5814 }
5815 p[4] = '[';
5816 p++;
5817 }
5818 else if (wp->w_gr)
5819 sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0');
5820 else
5821 sprintf(p, " G%c[", wp->w_Charset + '0');
5822 p += 4;
5823 for (i = 0; i < 4; i++)
5824 {
5825 if (wp->w_charsets[i] == ASCII)
5826 *p++ = 'B';
5827 else if (wp->w_charsets[i] >= ' ')
5828 *p++ = wp->w_charsets[i];
5829 else
5830 {
5831 *p++ = '^';
5832 *p++ = wp->w_charsets[i] ^ 0x40;
5833 }
5834 }
5835 *p++ = ']';
5836 *p = 0;
5837 }
5838 #endif
5839
5840 if (wp->w_type == W_TYPE_PLAIN)
5841 {
5842 /* add info about modem control lines */
5843 *p++ = ' ';
5844 TtyGetModemStatus(wp->w_ptyfd, p);
5845 }
5846 #ifdef BUILTIN_TELNET
5847 else if (wp->w_type == W_TYPE_TELNET)
5848 {
5849 *p++ = ' ';
5850 TelStatus(wp, p, sizeof(buf) - 1 - (p - buf));
5851 }
5852 #endif
5853 Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title);
5854 }
5855
5856 static void
5857 ShowDInfo()
5858 {
5859 char buf[512], *p;
5860 if (display == 0)
5861 return;
5862 p = buf;
5863 sprintf(p, "(%d,%d)", D_width, D_height),
5864 p += strlen(p);
5865 #ifdef ENCODINGS
5866 if (D_encoding)
5867 {
5868 *p++ = ' ';
5869 strcpy(p, EncodingName(D_encoding));
5870 p += strlen(p);
5871 }
5872 #endif
5873 if (D_CXT)
5874 {
5875 strcpy(p, " xterm");
5876 p += strlen(p);
5877 }
5878 #ifdef COLOR
5879 if (D_hascolor)
5880 {
5881 strcpy(p, " color");
5882 p += strlen(p);
5883 }
5884 #endif
5885 #ifdef FONT
5886 if (D_CG0)
5887 {
5888 strcpy(p, " iso2022");
5889 p += strlen(p);
5890 }
5891 else if (D_CS0 && *D_CS0)
5892 {
5893 strcpy(p, " altchar");
5894 p += strlen(p);
5895 }
5896 #endif
5897 Msg(0, "%s", buf);
5898 }
5899
5900 static void
5901 AKAfin(buf, len, data)
5902 char *buf;
5903 int len;
5904 char *data; /* dummy */
5905 {
5906 ASSERT(display);
5907 if (len && fore)
5908 ChangeAKA(fore, buf, strlen(buf));
5909 }
5910
5911 static void
5912 InputAKA()
5913 {
5914 char *s, *ss;
5915 int n;
5916 Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0);
5917 s = fore->w_title;
5918 if (!s)
5919 return;
5920 for (; *s; s++)
5921 {
5922 if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f)
5923 continue;
5924 ss = s;
5925 n = 1;
5926 LayProcess(&ss, &n);
5927 }
5928 }
5929
5930 static void
5931 Colonfin(buf, len, data)
5932 char *buf;
5933 int len;
5934 char *data; /* dummy */
5935 {
5936 char mbuf[256];
5937
5938 RemoveStatus();
5939 if (buf[len] == '\t')
5940 {
5941 int m, x;
5942 int l = 0, r = RC_LAST;
5943 int showmessage = 0;
5944 char *s = buf;
5945
5946 while (*s && s - buf < len)
5947 if (*s++ == ' ')
5948 return;
5949
5950 /* Showing a message when there's no hardstatus or caption cancels the input */
5951 if (display &&
5952 (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)))
5953 showmessage = 1;
5954
5955 while (l <= r)
5956 {
5957 m = (l + r) / 2;
5958 x = strncmp(buf, comms[m].name, len);
5959 if (x > 0)
5960 l = m + 1;
5961 else if (x < 0)
5962 r = m - 1;
5963 else
5964 {
5965 s = mbuf;
5966 for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--)
5967 ;
5968 for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++)
5969 s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name);
5970 if (l < m - 1)
5971 {
5972 if (showmessage)
5973 Msg(0, "Possible commands:%s", mbuf);
5974 }
5975 else
5976 {
5977 s = mbuf;
5978 len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len);
5979 if (len > 0 && len < sizeof(mbuf))
5980 LayProcess(&s, &len);
5981 }
5982 break;
5983 }
5984 }
5985 if (l > r && showmessage)
5986 Msg(0, "No commands matching '%*s'", len, buf);
5987 return;
5988 }
5989
5990 if (!len || buf[len])
5991 return;
5992
5993 len = strlen(buf) + 1;
5994 if (len > (int)sizeof(mbuf))
5995 RcLine(buf, len);
5996 else
5997 {
5998 bcopy(buf, mbuf, len);
5999 RcLine(mbuf, sizeof mbuf);
6000 }
6001 }
6002
6003 static void
6004 SelectFin(buf, len, data)
6005 char *buf;
6006 int len;
6007 char *data; /* dummy */
6008 {
6009 int n;
6010
6011 if (!len || !display)
6012 return;
6013 if (len == 1 && *buf == '-')
6014 {
6015 SetForeWindow((struct win *)0);
6016 Activate(0);
6017 return;
6018 }
6019 if ((n = WindowByNoN(buf)) < 0)
6020 return;
6021 SwitchWindow(n);
6022 }
6023
6024 static void
6025 SelectLayoutFin(buf, len, data)
6026 char *buf;
6027 int len;
6028 char *data; /* dummy */
6029 {
6030 struct layout *lay;
6031
6032 if (!len || !display)
6033 return;
6034 if (len == 1 && *buf == '-')
6035 {
6036 LoadLayout((struct layout *)0, (struct canvas *)0);
6037 Activate(0);
6038 return;
6039 }
6040 lay = FindLayout(buf);
6041 if (!lay)
6042 Msg(0, "No such layout\n");
6043 else if (lay == D_layout)
6044 Msg(0, "This IS layout %d (%s).\n", lay->lay_number, lay->lay_title);
6045 else
6046 {
6047 LoadLayout(lay, &D_canvas);
6048 Activate(0);
6049 }
6050 }
6051
6052
6053 static void
6054 InputSelect()
6055 {
6056 Input("Switch to window: ", 20, INP_COOKED, SelectFin, NULL, 0);
6057 }
6058
6059 static char setenv_var[31];
6060
6061
6062 static void
6063 SetenvFin1(buf, len, data)
6064 char *buf;
6065 int len;
6066 char *data; /* dummy */
6067 {
6068 if (!len || !display)
6069 return;
6070 InputSetenv(buf);
6071 }
6072
6073 static void
6074 SetenvFin2(buf, len, data)
6075 char *buf;
6076 int len;
6077 char *data; /* dummy */
6078 {
6079 if (!len || !display)
6080 return;
6081 debug2("SetenvFin2: setenv '%s' '%s'\n", setenv_var, buf);
6082 xsetenv(setenv_var, buf);
6083 MakeNewEnv();
6084 }
6085
6086 static void
6087 InputSetenv(arg)
6088 char *arg;
6089 {
6090 static char setenv_buf[50 + sizeof(setenv_var)]; /* need to be static here, cannot be freed */
6091
6092 if (arg)
6093 {
6094 strncpy(setenv_var, arg, sizeof(setenv_var) - 1);
6095 sprintf(setenv_buf, "Enter value for %s: ", setenv_var);
6096 Input(setenv_buf, 30, INP_COOKED, SetenvFin2, NULL, 0);
6097 }
6098 else
6099 Input("Setenv: Enter variable name: ", 30, INP_COOKED, SetenvFin1, NULL, 0);
6100 }
6101
6102 /*
6103 * the following options are understood by this parser:
6104 * -f, -f0, -f1, -fy, -fa
6105 * -t title, -T terminal-type, -h height-of-scrollback,
6106 * -ln, -l0, -ly, -l1, -l
6107 * -a, -M, -L
6108 */
6109 void
6110 DoScreen(fn, av)
6111 char *fn, **av;
6112 {
6113 struct NewWindow nwin;
6114 register int num;
6115 char buf[20];
6116
6117 nwin = nwin_undef;
6118 while (av && *av && av[0][0] == '-')
6119 {
6120 if (av[0][1] == '-')
6121 {
6122 av++;
6123 break;
6124 }
6125 switch (av[0][1])
6126 {
6127 case 'f':
6128 switch (av[0][2])
6129 {
6130 case 'n':
6131 case '0':
6132 nwin.flowflag = FLOW_NOW * 0;
6133 break;
6134 case 'y':
6135 case '1':
6136 case '\0':
6137 nwin.flowflag = FLOW_NOW * 1;
6138 break;
6139 case 'a':
6140 nwin.flowflag = FLOW_AUTOFLAG;
6141 break;
6142 default:
6143 break;
6144 }
6145 break;
6146 case 't': /* no more -k */
6147 if (av[0][2])
6148 nwin.aka = &av[0][2];
6149 else if (*++av)
6150 nwin.aka = *av;
6151 else
6152 --av;
6153 break;
6154 case 'T':
6155 if (av[0][2])
6156 nwin.term = &av[0][2];
6157 else if (*++av)
6158 nwin.term = *av;
6159 else
6160 --av;
6161 break;
6162 case 'h':
6163 if (av[0][2])
6164 nwin.histheight = atoi(av[0] + 2);
6165 else if (*++av)
6166 nwin.histheight = atoi(*av);
6167 else
6168 --av;
6169 break;
6170 #ifdef LOGOUTOK
6171 case 'l':
6172 switch (av[0][2])
6173 {
6174 case 'n':
6175 case '0':
6176 nwin.lflag = 0;
6177 break;
6178 case 'y':
6179 case '1':
6180 case '\0':
6181 nwin.lflag = 1;
6182 break;
6183 case 'a':
6184 nwin.lflag = 3;
6185 break;
6186 default:
6187 break;
6188 }
6189 break;
6190 #endif
6191 case 'a':
6192 nwin.aflag = 1;
6193 break;
6194 case 'M':
6195 nwin.monitor = MON_ON;
6196 break;
6197 case 'L':
6198 nwin.Lflag = 1;
6199 break;
6200 default:
6201 Msg(0, "%s: screen: invalid option -%c.", fn, av[0][1]);
6202 break;
6203 }
6204 ++av;
6205 }
6206 num = 0;
6207 if (av && *av && IsNumColon(*av, 10, buf, sizeof(buf)))
6208 {
6209 if (*buf != '\0')
6210 nwin.aka = buf;
6211 num = atoi(*av);
6212 if (num < 0 || num > MAXWIN - 1)
6213 {
6214 Msg(0, "%s: illegal screen number %d.", fn, num);
6215 num = 0;
6216 }
6217 nwin.StartAt = num;
6218 ++av;
6219 }
6220 if (av && *av)
6221 {
6222 nwin.args = av;
6223 if (!nwin.aka)
6224 nwin.aka = Filename(*av);
6225 }
6226 MakeWindow(&nwin);
6227 }
6228
6229 #ifdef COPY_PASTE
6230 /*
6231 * CompileKeys must be called before Markroutine is first used.
6232 * to initialise the keys with defaults, call CompileKeys(NULL, mark_key_tab);
6233 *
6234 * s is an ascii string in a termcap-like syntax. It looks like
6235 * "j=u:k=d:l=r:h=l: =.:" and so on...
6236 * this example rebinds the cursormovement to the keys u (up), d (down),
6237 * l (left), r (right). placing a mark will now be done with ".".
6238 */
6239 int
6240 CompileKeys(s, sl, array)
6241 char *s;
6242 int sl;
6243 unsigned char *array;
6244 {
6245 int i;
6246 unsigned char key, value;
6247
6248 if (sl == 0)
6249 {
6250 for (i = 0; i < 256; i++)
6251 array[i] = i;
6252 return 0;
6253 }
6254 debug1("CompileKeys: '%s'\n", s);
6255 while (sl)
6256 {
6257 key = *(unsigned char *)s++;
6258 if (*s != '=' || sl < 3)
6259 return -1;
6260 sl--;
6261 do
6262 {
6263 s++;
6264 sl -= 2;
6265 value = *(unsigned char *)s++;
6266 array[value] = key;
6267 }
6268 while (*s == '=' && sl >= 2);
6269 if (sl == 0)
6270 break;
6271 if (*s++ != ':')
6272 return -1;
6273 sl--;
6274 }
6275 return 0;
6276 }
6277 #endif /* COPY_PASTE */
6278
6279 /*
6280 * Asynchronous input functions
6281 */
6282
6283 #if defined(DETACH) && defined(POW_DETACH)
6284 static void
6285 pow_detach_fn(buf, len, data)
6286 char *buf;
6287 int len;
6288 char *data; /* dummy */
6289 {
6290 debug("pow_detach_fn called\n");
6291 if (len)
6292 {
6293 *buf = 0;
6294 return;
6295 }
6296 if (ktab[(int)(unsigned char)*buf].nr != RC_POW_DETACH)
6297 {
6298 if (display)
6299 write(D_userfd, "\007", 1);
6300 Msg(0, "Detach aborted.");
6301 }
6302 else
6303 Detach(D_POWER);
6304 }
6305 #endif /* POW_DETACH */
6306
6307 #ifdef COPY_PASTE
6308 static void
6309 copy_reg_fn(buf, len, data)
6310 char *buf;
6311 int len;
6312 char *data; /* dummy */
6313 {
6314 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6315
6316 if (len)
6317 {
6318 *buf = 0;
6319 return;
6320 }
6321 if (pp->buf)
6322 free(pp->buf);
6323 pp->buf = 0;
6324 pp->len = 0;
6325 if (D_user->u_plop.len)
6326 {
6327 if ((pp->buf = (char *)malloc(D_user->u_plop.len)) == NULL)
6328 {
6329 Msg(0, strnomem);
6330 return;
6331 }
6332 bcopy(D_user->u_plop.buf, pp->buf, D_user->u_plop.len);
6333 }
6334 pp->len = D_user->u_plop.len;
6335 #ifdef ENCODINGS
6336 pp->enc = D_user->u_plop.enc;
6337 #endif
6338 Msg(0, "Copied %d characters into register %c", D_user->u_plop.len, *buf);
6339 }
6340
6341 static void
6342 ins_reg_fn(buf, len, data)
6343 char *buf;
6344 int len;
6345 char *data; /* dummy */
6346 {
6347 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6348
6349 if (len)
6350 {
6351 *buf = 0;
6352 return;
6353 }
6354 if (!fore)
6355 return; /* Input() should not call us w/o fore, but you never know... */
6356 if (*buf == '.')
6357 Msg(0, "ins_reg_fn: Warning: pasting real register '.'!");
6358 if (pp->buf)
6359 {
6360 MakePaster(&fore->w_paster, pp->buf, pp->len, 0);
6361 return;
6362 }
6363 Msg(0, "Empty register.");
6364 }
6365 #endif /* COPY_PASTE */
6366
6367 static void
6368 process_fn(buf, len, data)
6369 char *buf;
6370 int len;
6371 char *data; /* dummy */
6372 {
6373 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6374
6375 if (len)
6376 {
6377 *buf = 0;
6378 return;
6379 }
6380 if (pp->buf)
6381 {
6382 ProcessInput(pp->buf, pp->len);
6383 return;
6384 }
6385 Msg(0, "Empty register.");
6386 }
6387
6388 static void
6389 confirm_fn(buf, len, data)
6390 char *buf;
6391 int len;
6392 char *data;
6393 {
6394 struct action act;
6395
6396 if (len || (*buf != 'y' && *buf != 'Y'))
6397 {
6398 *buf = 0;
6399 return;
6400 }
6401 act.nr = *(int *)data;
6402 act.args = noargs;
6403 act.argl = 0;
6404 DoAction(&act, -1);
6405 }
6406
6407 #ifdef MULTIUSER
6408 struct inputsu
6409 {
6410 struct acluser **up;
6411 char name[24];
6412 char pw1[130]; /* FreeBSD crypts to 128 bytes */
6413 char pw2[130];
6414 };
6415
6416 static void
6417 su_fin(buf, len, data)
6418 char *buf;
6419 int len;
6420 char *data;
6421 {
6422 struct inputsu *i = (struct inputsu *)data;
6423 char *p;
6424 int l;
6425
6426 if (!*i->name)
6427 { p = i->name; l = sizeof(i->name) - 1; }
6428 else if (!*i->pw1)
6429 { strcpy(p = i->pw1, "\377"); l = sizeof(i->pw1) - 1; }
6430 else
6431 { strcpy(p = i->pw2, "\377"); l = sizeof(i->pw2) - 1; }
6432 if (buf && len)
6433 strncpy(p, buf, 1 + (l < len) ? l : len);
6434 if (!*i->name)
6435 Input("Screen User: ", sizeof(i->name) - 1, INP_COOKED, su_fin, (char *)i, 0);
6436 else if (!*i->pw1)
6437 Input("User's UNIX Password: ", sizeof(i->pw1)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6438 else if (!*i->pw2)
6439 Input("User's Screen Password: ", sizeof(i->pw2)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6440 else
6441 {
6442 if ((p = DoSu(i->up, i->name, i->pw2, i->pw1)))
6443 Msg(0, "%s", p);
6444 free((char *)i);
6445 }
6446 }
6447
6448 static int
6449 InputSu(w, up, name)
6450 struct win *w;
6451 struct acluser **up;
6452 char *name;
6453 {
6454 struct inputsu *i;
6455
6456 if (!(i = (struct inputsu *)calloc(1, sizeof(struct inputsu))))
6457 return -1;
6458
6459 i->up = up;
6460 if (name && *name)
6461 su_fin(name, (int)strlen(name), (char *)i); /* can also initialise stuff */
6462 else
6463 su_fin((char *)0, 0, (char *)i);
6464 return 0;
6465 }
6466 #endif /* MULTIUSER */
6467
6468 #ifdef PASSWORD
6469
6470 static void
6471 pass1(buf, len, data)
6472 char *buf;
6473 int len;
6474 char *data;
6475 {
6476 struct acluser *u = (struct acluser *)data;
6477
6478 if (!*buf)
6479 return;
6480 ASSERT(u);
6481 if (u->u_password != NullStr)
6482 free((char *)u->u_password);
6483 u->u_password = SaveStr(buf);
6484 bzero(buf, strlen(buf));
6485 Input("Retype new password:", 100, INP_NOECHO, pass2, data, 0);
6486 }
6487
6488 static void
6489 pass2(buf, len, data)
6490 char *buf;
6491 int len;
6492 char *data;
6493 {
6494 int st;
6495 char salt[3];
6496 struct acluser *u = (struct acluser *)data;
6497
6498 ASSERT(u);
6499 if (!buf || strcmp(u->u_password, buf))
6500 {
6501 Msg(0, "[ Passwords don't match - checking turned off ]");
6502 if (u->u_password != NullStr)
6503 {
6504 bzero(u->u_password, strlen(u->u_password));
6505 free((char *)u->u_password);
6506 }
6507 u->u_password = NullStr;
6508 }
6509 else if (u->u_password[0] == '\0')
6510 {
6511 Msg(0, "[ No password - no secure ]");
6512 if (buf)
6513 bzero(buf, strlen(buf));
6514 }
6515
6516 if (u->u_password != NullStr)
6517 {
6518 for (st = 0; st < 2; st++)
6519 salt[st] = 'A' + (int)((time(0) >> 6 * st) % 26);
6520 salt[2] = 0;
6521 buf = crypt(u->u_password, salt);
6522 bzero(u->u_password, strlen(u->u_password));
6523 free((char *)u->u_password);
6524 u->u_password = SaveStr(buf);
6525 bzero(buf, strlen(buf));
6526 #ifdef COPY_PASTE
6527 if (u->u_plop.buf)
6528 UserFreeCopyBuffer(u);
6529 u->u_plop.len = strlen(u->u_password);
6530 # ifdef ENCODINGS
6531 u->u_plop.enc = 0;
6532 #endif
6533 if (!(u->u_plop.buf = SaveStr(u->u_password)))
6534 {
6535 Msg(0, strnomem);
6536 D_user->u_plop.len = 0;
6537 }
6538 else
6539 Msg(0, "[ Password moved into copybuffer ]");
6540 #else /* COPY_PASTE */
6541 Msg(0, "[ Crypted password is \"%s\" ]", u->u_password);
6542 #endif /* COPY_PASTE */
6543 }
6544 }
6545 #endif /* PASSWORD */
6546
6547 static int
6548 digraph_find(buf)
6549 const char *buf;
6550 {
6551 int i;
6552 for (i = 0; i < MAX_DIGRAPH && digraphs[i].d[0]; i++)
6553 if ((digraphs[i].d[0] == (unsigned char)buf[0] && digraphs[i].d[1] == (unsigned char)buf[1]) ||
6554 (digraphs[i].d[0] == (unsigned char)buf[1] && digraphs[i].d[1] == (unsigned char)buf[0]))
6555 break;
6556 return i;
6557 }
6558
6559 static void
6560 digraph_fn(buf, len, data)
6561 char *buf;
6562 int len;
6563 char *data; /* dummy */
6564 {
6565 int ch, i, x;
6566
6567 ch = buf[len];
6568 if (ch)
6569 {
6570 buf[len + 1] = ch; /* so we can restore it later */
6571 if (ch < ' ' || ch == '\177')
6572 return;
6573 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
6574 {
6575 if (len == 1)
6576 return;
6577 if ((ch < '0' || ch > '9') && (ch < 'a' || ch > 'f') && (ch < 'A' || ch > 'F'))
6578 {
6579 buf[len] = '\034'; /* ^] is ignored by Input() */
6580 return;
6581 }
6582 if (len == (*buf == 'U' ? 5 : 3))
6583 buf[len] = '\n';
6584 return;
6585 }
6586 if (len && *buf == '0')
6587 {
6588 if (ch < '0' || ch > '7')
6589 {
6590 buf[len] = '\034'; /* ^] is ignored by Input() */
6591 return;
6592 }
6593 if (len == 3)
6594 buf[len] = '\n';
6595 return;
6596 }
6597 if (len == 1)
6598 buf[len] = '\n';
6599 return;
6600 }
6601 if (len < 1)
6602 return;
6603 if (buf[len + 1])
6604 {
6605 buf[len] = buf[len + 1]; /* stored above */
6606 len++;
6607 }
6608 if (len < 2)
6609 return;
6610 if (!parse_input_int(buf, len, &x))
6611 {
6612 i = digraph_find(buf);
6613 if ((x = digraphs[i].value) <= 0)
6614 {
6615 Msg(0, "Unknown digraph");
6616 return;
6617 }
6618 }
6619 i = 1;
6620 *buf = x;
6621 #ifdef UTF8
6622 if (flayer->l_encoding == UTF8)
6623 i = ToUtf8(buf, x); /* buf is big enough for all UTF-8 codes */
6624 #endif
6625 while(i)
6626 LayProcess(&buf, &i);
6627 }
6628
6629 #ifdef MAPKEYS
6630 int
6631 StuffKey(i)
6632 int i;
6633 {
6634 struct action *act;
6635 int discard = 0;
6636
6637 debug1("StuffKey #%d", i);
6638 #ifdef DEBUG
6639 if (i < KMAP_KEYS)
6640 debug1(" - %s", term[i + T_CAPS].tcname);
6641 #endif
6642
6643 if (i < KMAP_KEYS && D_ESCseen)
6644 {
6645 struct action *act = &D_ESCseen[i + 256];
6646 if (act->nr != RC_ILLEGAL)
6647 {
6648 D_ESCseen = 0;
6649 DoAction(act, i + 256);
6650 return 0;
6651 }
6652 discard = 1;
6653 }
6654
6655 if (i >= T_CURSOR - T_CAPS && i < T_KEYPAD - T_CAPS && D_cursorkeys)
6656 i += T_OCAPS - T_CURSOR;
6657 else if (i >= T_KEYPAD - T_CAPS && i < T_OCAPS - T_CAPS && D_keypad)
6658 i += T_OCAPS - T_CURSOR;
6659 debug1(" - action %d\n", i);
6660 flayer = D_forecv->c_layer;
6661 fore = D_fore;
6662 act = 0;
6663 #ifdef COPY_PASTE
6664 if (InMark() || InInput() || InWList())
6665 act = i < KMAP_KEYS+KMAP_AKEYS ? &mmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].mm;
6666 #endif
6667 if ((!act || act->nr == RC_ILLEGAL) && !D_mapdefault)
6668 act = i < KMAP_KEYS+KMAP_AKEYS ? &umtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].um;
6669 if (!act || act->nr == RC_ILLEGAL)
6670 act = i < KMAP_KEYS+KMAP_AKEYS ? &dmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].dm;
6671
6672 if (discard && (!act || act->nr != RC_COMMAND))
6673 {
6674 D_ESCseen = 0;
6675 return 0;
6676 }
6677 D_mapdefault = 0;
6678
6679 if (act == 0 || act->nr == RC_ILLEGAL)
6680 return -1;
6681 DoAction(act, 0);
6682 return 0;
6683 }
6684 #endif
6685
6686
6687 static int
6688 IsOnDisplay(wi)
6689 struct win *wi;
6690 {
6691 struct canvas *cv;
6692 ASSERT(display);
6693 for (cv = D_cvlist; cv; cv = cv->c_next)
6694 if (Layer2Window(cv->c_layer) == wi)
6695 return 1;
6696 return 0;
6697 }
6698
6699 struct win *
6700 FindNiceWindow(wi, presel)
6701 struct win *wi;
6702 char *presel;
6703 {
6704 int i;
6705
6706 debug2("FindNiceWindow %d %s\n", wi ? wi->w_number : -1 , presel ? presel : "NULL");
6707 if (presel)
6708 {
6709 i = WindowByNoN(presel);
6710 if (i >= 0)
6711 wi = wtab[i];
6712 }
6713 if (!display)
6714 return wi;
6715 #ifdef MULTIUSER
6716 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6717 wi = 0;
6718 #endif
6719 if (!wi || (IsOnDisplay(wi) && !presel))
6720 {
6721 /* try to get another window */
6722 wi = 0;
6723 #ifdef MULTIUSER
6724 for (wi = windows; wi; wi = wi->w_next)
6725 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6726 break;
6727 if (!wi)
6728 for (wi = windows; wi; wi = wi->w_next)
6729 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6730 break;
6731 if (!wi)
6732 for (wi = windows; wi; wi = wi->w_next)
6733 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_READ, wi))
6734 break;
6735 if (!wi)
6736 for (wi = windows; wi; wi = wi->w_next)
6737 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_READ, wi))
6738 break;
6739 #endif
6740 if (!wi)
6741 for (wi = windows; wi; wi = wi->w_next)
6742 if (!wi->w_layer.l_cvlist)
6743 break;
6744 if (!wi)
6745 for (wi = windows; wi; wi = wi->w_next)
6746 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi))
6747 break;
6748 }
6749 #ifdef MULTIUSER
6750 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6751 wi = 0;
6752 #endif
6753 return wi;
6754 }
6755
6756 /**
6757 * Add an alias
6758 */
6759 void
6760 AddAlias(name, value, args, argl, count)
6761 const char *name;
6762 const char *value;
6763 char **args;
6764 int *argl;
6765 int count;
6766 {
6767 struct alias *nalias = NULL;
6768 static next_command = RC_LAST;
6769 int nr;
6770
6771 /* Make sure we don't already have this alias name defined. */
6772 if (FindAlias(name) != NULL)
6773 {
6774 Msg(0, "alias already defined: %s", name);
6775 return;
6776 }
6777
6778 /* Make sure the alias maps to something */
6779 if ((nr = FindCommnr((char *)value)) == RC_ILLEGAL)
6780 {
6781 struct alias *alias = FindAlias(value);
6782 if (!alias)
6783 {
6784 Msg(0, "%s: could not find command or alias '%s'", rc_name, value);
6785 return;
6786 }
6787 nr = alias->nr;
6788 }
6789
6790 nalias = (struct alias *)calloc(1, sizeof(struct alias));
6791
6792 /* store it */
6793 nalias->next = NULL;
6794 nalias->name = SaveStr(name);
6795 nalias->cmdnr = nr;
6796 if (count > 0)
6797 {
6798 nalias->args = SaveArgs(args);
6799 nalias->argl = calloc(count + 1, sizeof(int));
6800 while (count--)
6801 nalias->argl[count] = argl[count];
6802 }
6803 nalias->nr = ++next_command;
6804
6805 /* Add to head */
6806 nalias->next = g_aliases_list;
6807 g_aliases_list = nalias;
6808 }
6809
6810
6811 /**
6812 * Find an alias by name.
6813 */
6814 static struct alias *
6815 FindAlias(name)
6816 const char *name;
6817 {
6818 struct alias *t = g_aliases_list;
6819
6820 while(t != NULL)
6821 {
6822 if ((t->name != NULL) &&
6823 (strcmp(t->name, name) == 0))
6824 return t;
6825
6826 t = t->next;
6827 }
6828
6829 return NULL;
6830 }
6831
6832 /**
6833 * Find an alias by number.
6834 */
6835 static struct alias *
6836 FindAliasnr(nr)
6837 int nr;
6838 {
6839 struct alias *t;
6840 for (t = g_aliases_list; t; t = t->next)
6841 {
6842 if (t->nr == nr)
6843 return t;
6844 }
6845
6846 return NULL;
6847 }
6848
6849 /**
6850 * Delete an alias
6851 */
6852 void
6853 DelAlias(name)
6854 const char *name;
6855 {
6856 /* Find the previous alias */
6857 struct alias *cur = g_aliases_list;
6858 struct alias **pcur = &g_aliases_list;
6859
6860 while (cur != NULL)
6861 {
6862 if ((cur->name != NULL) &&
6863 (strcmp(cur->name, name) == 0))
6864 {
6865 struct alias *found = cur;
6866 int c;
6867
6868 /* remove this one from the chain. */
6869 *pcur = found->next;
6870
6871 free(found->name);
6872 if (found->args)
6873 {
6874 for (c = 0; found->args[c]; c++)
6875 free(found->args[c]);
6876 free(found->args);
6877 free(found->argl);
6878 }
6879 free(found);
6880
6881 Msg(0, "alias %s removed", name);
6882 return;
6883 }
6884 pcur = &cur->next;
6885 cur = cur->next;
6886 }
6887
6888 Msg(0, "alias %s not found", name);
6889 }
6890
6891 #if 0
6892
6893 /* sorted list of all commands */
6894 static struct comm **commtab;
6895 static int ncommtab;
6896
6897 void
6898 AddComms(cos, hand)
6899 struct comm *cos;
6900 void (*hand) __P((struct comm *, char **, int));
6901 {
6902 int n, i, j, r;
6903 for (n = 0; cos[n].name; n++)
6904 ;
6905 if (n == 0)
6906 return;
6907 if (commtab)
6908 commtab = (struct commt *)realloc(commtab, sizeof(*commtab) * (ncommtab + n));
6909 else
6910 commtab = (struct commt *)malloc(sizeof(*commtab) * (ncommtab + n));
6911 if (!commtab)
6912 Panic(0, strnomem);
6913 for (i = 0; i < n; i++)
6914 {
6915 for (j = 0; j < ncommtab; j++)
6916 {
6917 r = strcmp(cos[i].name, commtab[j]->name);
6918 if (r == 0)
6919 Panic(0, "Duplicate command: %s\n", cos[i].name);
6920 if (r < 0)
6921 break;
6922 }
6923 for (r = ncommtab; r > j; r--)
6924 commtab[r] = commtab[r - 1];
6925 commtab[j] = cos + i;
6926 cos[i].handler = hand;
6927 bzero(cos[i].userbits, sizeof(cos[i].userbits));
6928 ncommtab++;
6929 }
6930 }
6931
6932 struct comm *
6933 FindComm(str)
6934 char *str;
6935 {
6936 int x, m, l = 0, r = ncommtab - 1;
6937 while (l <= r)
6938 {
6939 m = (l + r) / 2;
6940 x = strcmp(str, commtab[m]->name);
6941 if (x > 0)
6942 l = m + 1;
6943 else if (x < 0)
6944 r = m - 1;
6945 else
6946 return commtab[m];
6947 }
6948 return 0;
6949 }
6950
6951 #endif
6952
6953 static int
6954 CalcSlicePercent(cv, percent)
6955 struct canvas *cv;
6956 int percent;
6957 {
6958 int w, wsum, up;
6959 if (!cv || !cv->c_slback)
6960 return percent;
6961 up = CalcSlicePercent(cv->c_slback->c_slback, percent);
6962 w = cv->c_slweight;
6963 for (cv = cv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6964 wsum += cv->c_slweight;
6965 if (wsum == 0)
6966 return 0;
6967 return (up * w) / wsum;
6968 }
6969
6970 static int
6971 ChangeCanvasSize(fcv, abs, diff, gflag, percent)
6972 struct canvas *fcv; /* make this canvas bigger */
6973 int abs; /* mode: 0:rel 1:abs 2:max */
6974 int diff; /* change this much */
6975 int gflag; /* go up if neccessary */
6976 int percent;
6977 {
6978 struct canvas *cv;
6979 int done, have, m, dir;
6980
6981 debug3("ChangeCanvasSize abs %d diff %d percent=%d\n", abs, diff, percent);
6982 if (abs == 0 && diff == 0)
6983 return 0;
6984 if (abs == 2)
6985 {
6986 if (diff == 0)
6987 fcv->c_slweight = 0;
6988 else
6989 {
6990 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6991 cv->c_slweight = 0;
6992 fcv->c_slweight = 1;
6993 cv = fcv->c_slback->c_slback;
6994 if (gflag && cv && cv->c_slback)
6995 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6996 }
6997 return diff;
6998 }
6999 if (abs)
7000 {
7001 if (diff < 0)
7002 diff = 0;
7003 if (percent && diff > percent)
7004 diff = percent;
7005 }
7006 if (percent)
7007 {
7008 int wsum, up;
7009 for (cv = fcv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
7010 wsum += cv->c_slweight;
7011 if (wsum)
7012 {
7013 up = gflag ? CalcSlicePercent(fcv->c_slback->c_slback, percent) : percent;
7014 debug3("up=%d, wsum=%d percent=%d\n", up, wsum, percent);
7015 if (wsum < 1000)
7016 {
7017 int scale = wsum < 10 ? 1000 : 100;
7018 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
7019 cv->c_slweight *= scale;
7020 wsum *= scale;
7021 debug1("scaled wsum to %d\n", wsum);
7022 }
7023 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
7024 {
7025 if (cv->c_slweight)
7026 {
7027 cv->c_slweight = (cv->c_slweight * up) / percent;
7028 if (cv->c_slweight == 0)
7029 cv->c_slweight = 1;
7030 }
7031 debug1(" - weight %d\n", cv->c_slweight);
7032 }
7033 diff = (diff * wsum) / percent;
7034 percent = wsum;
7035 }
7036 }
7037 else
7038 {
7039 if (abs && diff == (fcv->c_slorient == SLICE_VERT ? fcv->c_ye - fcv->c_ys + 2 : fcv->c_xe - fcv->c_xs + 2))
7040 return 0;
7041 /* fix weights to real size (can't be helped, sorry) */
7042 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
7043 {
7044 cv->c_slweight = cv->c_slorient == SLICE_VERT ? cv->c_ye - cv->c_ys + 2 : cv->c_xe - cv->c_xs + 2;
7045 debug1(" - weight %d\n", cv->c_slweight);
7046 }
7047 }
7048 if (abs)
7049 diff = diff - fcv->c_slweight;
7050 debug1("diff = %d\n", diff);
7051 if (diff == 0)
7052 return 0;
7053 if (diff < 0)
7054 {
7055 cv = fcv->c_slnext ? fcv->c_slnext : fcv->c_slprev;
7056 fcv->c_slweight += diff;
7057 cv->c_slweight -= diff;
7058 return diff;
7059 }
7060 done = 0;
7061 dir = 1;
7062 for (cv = fcv->c_slnext; diff > 0; cv = dir > 0 ? cv->c_slnext : cv->c_slprev)
7063 {
7064 if (!cv)
7065 {
7066 debug1("reached end, dir is %d\n", dir);
7067 if (dir == -1)
7068 break;
7069 dir = -1;
7070 cv = fcv;
7071 continue;
7072 }
7073 if (percent)
7074 m = 1;
7075 else
7076 m = cv->c_slperp ? CountCanvasPerp(cv) * 2 : 2;
7077 debug2("min is %d, have %d\n", m, cv->c_slweight);
7078 if (cv->c_slweight > m)
7079 {
7080 have = cv->c_slweight - m;
7081 if (have > diff)
7082 have = diff;
7083 debug1("subtract %d\n", have);
7084 cv->c_slweight -= have;
7085 done += have;
7086 diff -= have;
7087 }
7088 }
7089 if (diff && gflag)
7090 {
7091 /* need more room! */
7092 cv = fcv->c_slback->c_slback;
7093 if (cv && cv->c_slback)
7094 done += ChangeCanvasSize(fcv->c_slback->c_slback, 0, diff, gflag, percent);
7095 }
7096 fcv->c_slweight += done;
7097 debug1("ChangeCanvasSize returns %d\n", done);
7098 return done;
7099 }
7100
7101 static void
7102 ResizeRegions(arg, flags)
7103 char *arg;
7104 int flags;
7105 {
7106 struct canvas *cv;
7107 int diff, l;
7108 int gflag = 0, abs = 0, percent = 0;
7109 int orient = 0;
7110
7111 ASSERT(display);
7112 if (!*arg)
7113 return;
7114 if (D_forecv->c_slorient == SLICE_UNKN)
7115 {
7116 Msg(0, "resize: need more than one region");
7117 return;
7118 }
7119 gflag = flags & RESIZE_FLAG_L ? 0 : 1;
7120 orient |= flags & RESIZE_FLAG_H ? SLICE_HORI : 0;
7121 orient |= flags & RESIZE_FLAG_V ? SLICE_VERT : 0;
7122 if (orient == 0)
7123 orient = D_forecv->c_slorient;
7124 l = strlen(arg);
7125 if (*arg == '=')
7126 {
7127 /* make all regions the same height */
7128 struct canvas *cv = gflag ? &D_canvas : D_forecv->c_slback;
7129 if (cv->c_slperp->c_slorient & orient)
7130 EqualizeCanvas(cv->c_slperp, gflag);
7131 /* can't use cv->c_slorient directly as it can be D_canvas */
7132 if ((cv->c_slperp->c_slorient ^ (SLICE_HORI ^ SLICE_VERT)) & orient)
7133 {
7134 if (cv->c_slback)
7135 {
7136 cv = cv->c_slback;
7137 EqualizeCanvas(cv->c_slperp, gflag);
7138 }
7139 else
7140 EqualizeCanvas(cv, gflag);
7141 }
7142 ResizeCanvas(cv);
7143 RecreateCanvasChain();
7144 RethinkDisplayViewports();
7145 ResizeLayersToCanvases();
7146 return;
7147 }
7148 if (!strcmp(arg, "min") || !strcmp(arg, "0"))
7149 {
7150 abs = 2;
7151 diff = 0;
7152 }
7153 else if (!strcmp(arg, "max") || !strcmp(arg, "_"))
7154 {
7155 abs = 2;
7156 diff = 1;
7157 }
7158 else
7159 {
7160 if (l > 0 && arg[l - 1] == '%')
7161 percent = 1000;
7162 if (*arg == '+')
7163 diff = atoi(arg + 1);
7164 else if (*arg == '-')
7165 diff = -atoi(arg + 1);
7166 else
7167 {
7168 diff = atoi(arg); /* +1 because of caption line */
7169 if (diff < 0)
7170 diff = 0;
7171 abs = diff == 0 ? 2 : 1;
7172 }
7173 }
7174 if (!abs && !diff)
7175 return;
7176 if (percent)
7177 diff = diff * percent / 100;
7178 cv = D_forecv;
7179 if (cv->c_slorient & orient)
7180 ChangeCanvasSize(cv, abs, diff, gflag, percent);
7181 if (cv->c_slback->c_slorient & orient)
7182 ChangeCanvasSize(cv->c_slback, abs, diff, gflag, percent);
7183
7184 ResizeCanvas(&D_canvas);
7185 RecreateCanvasChain();
7186 RethinkDisplayViewports();
7187 ResizeLayersToCanvases();
7188 return;
7189
7190 #if 0
7191
7192 if (siz + diff < 1)
7193 diff = 1 - siz;
7194 if (siz + diff > dsize - (nreg - 1) * 2 - 1)
7195 diff = dsize - (nreg - 1) * 2 - 1 - siz;
7196 if (diff == 0 || siz + diff < 1)
7197 return;
7198
7199 if (diff < 0)
7200 {
7201 if (D_forecv->c_next)
7202 {
7203 D_forecv->c_ye += diff;
7204 D_forecv->c_next->c_ys += diff;
7205 D_forecv->c_next->c_yoff += diff;
7206 }
7207 else
7208 {
7209 for (cv = D_cvlist; cv; cv = cv->c_next)
7210 if (cv->c_next == D_forecv)
7211 break;
7212 ASSERT(cv);
7213 cv->c_ye -= diff;
7214 D_forecv->c_ys -= diff;
7215 D_forecv->c_yoff -= diff;
7216 }
7217 }
7218 else
7219 {
7220 int s, i = 0, found = 0, di = diff, d2;
7221 s = dsize - (nreg - 1) * 2 - 1 - siz;
7222 for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next)
7223 {
7224 if (cv == D_forecv)
7225 {
7226 cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff;
7227 cv->c_yoff -= cv->c_ys - i;
7228 cv->c_ys = i;
7229 found = 1;
7230 continue;
7231 }
7232 s -= cv->c_ye - cv->c_ys;
7233 if (!found)
7234 {
7235 if (s >= di)
7236 continue;
7237 d2 = di - s;
7238 }
7239 else
7240 d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di;
7241 di -= d2;
7242 cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2;
7243 cv->c_yoff -= cv->c_ys - i;
7244 cv->c_ys = i;
7245 }
7246 }
7247 RethinkDisplayViewports();
7248 ResizeLayersToCanvases();
7249 #endif
7250 }
7251
7252 static void
7253 ResizeFin(buf, len, data)
7254 char *buf;
7255 int len;
7256 char *data;
7257 {
7258 int ch;
7259 int flags = *(int *)data;
7260 ch = ((unsigned char *)buf)[len];
7261 if (ch == 0)
7262 {
7263 ResizeRegions(buf, flags);
7264 return;
7265 }
7266 if (ch == 'h')
7267 flags ^= RESIZE_FLAG_H;
7268 else if (ch == 'v')
7269 flags ^= RESIZE_FLAG_V;
7270 else if (ch == 'b')
7271 flags |= RESIZE_FLAG_H|RESIZE_FLAG_V;
7272 else if (ch == 'p')
7273 flags ^= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
7274 else if (ch == 'l')
7275 flags ^= RESIZE_FLAG_L;
7276 else
7277 return;
7278 inp_setprompt(resizeprompts[flags], NULL);
7279 *(int *)data = flags;
7280 buf[len] = '\034';
7281 }
7282
7283 #ifdef RXVT_OSC
7284 void
7285 RefreshXtermOSC()
7286 {
7287 int i;
7288 struct win *p;
7289
7290 p = Layer2Window(D_forecv->c_layer);
7291 for (i = 3; i >=0; i--)
7292 SetXtermOSC(i, p ? p->w_xtermosc[i] : 0);
7293 }
7294 #endif
7295
7296 int
7297 ParseAttrColor(s1, s2, msgok)
7298 char *s1, *s2;
7299 int msgok;
7300 {
7301 int i, n;
7302 char *s, *ss;
7303 int r = 0;
7304
7305 s = s1;
7306 while (*s == ' ')
7307 s++;
7308 ss = s;
7309 while (*ss && *ss != ' ')
7310 ss++;
7311 while (*ss == ' ')
7312 ss++;
7313 if (*s && (s2 || *ss || !((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || *s == '.')))
7314 {
7315 int mode = 0, n = 0;
7316 if (*s == '+')
7317 {
7318 mode = 1;
7319 s++;
7320 }
7321 else if (*s == '-')
7322 {
7323 mode = -1;
7324 s++;
7325 }
7326 else if (*s == '!')
7327 {
7328 mode = 2;
7329 s++;
7330 }
7331 else if (*s == '=')
7332 s++;
7333 if (*s >= '0' && *s <= '9')
7334 {
7335 n = *s++ - '0';
7336 if (*s >= '0' && *s <= '9')
7337 n = n * 16 + (*s++ - '0');
7338 else if (*s >= 'a' && *s <= 'f')
7339 n = n * 16 + (*s++ - ('a' - 10));
7340 else if (*s >= 'A' && *s <= 'F')
7341 n = n * 16 + (*s++ - ('A' - 10));
7342 else if (*s && *s != ' ')
7343 {
7344 if (msgok)
7345 Msg(0, "Illegal attribute hexchar '%c'", *s);
7346 return -1;
7347 }
7348 }
7349 else
7350 {
7351 while (*s && *s != ' ')
7352 {
7353 if (*s == 'd')
7354 n |= A_DI;
7355 else if (*s == 'u')
7356 n |= A_US;
7357 else if (*s == 'b')
7358 n |= A_BD;
7359 else if (*s == 'r')
7360 n |= A_RV;
7361 else if (*s == 's')
7362 n |= A_SO;
7363 else if (*s == 'B')
7364 n |= A_BL;
7365 else
7366 {
7367 if (msgok)
7368 Msg(0, "Illegal attribute specifier '%c'", *s);
7369 return -1;
7370 }
7371 s++;
7372 }
7373 }
7374 if (*s && *s != ' ')
7375 {
7376 if (msgok)
7377 Msg(0, "junk after attribute description: '%c'", *s);
7378 return -1;
7379 }
7380 if (mode == -1)
7381 r = n << 8 | n;
7382 else if (mode == 1)
7383 r = n << 8;
7384 else if (mode == 2)
7385 r = n;
7386 else if (mode == 0)
7387 r = 0xffff ^ n;
7388 }
7389 while (*s && *s == ' ')
7390 s++;
7391
7392 if (s2)
7393 {
7394 if (*s)
7395 {
7396 if (msgok)
7397 Msg(0, "junk after description: '%c'", *s);
7398 return -1;
7399 }
7400 s = s2;
7401 while (*s && *s == ' ')
7402 s++;
7403 }
7404
7405 #ifdef COLOR
7406 if (*s)
7407 {
7408 static char costr[] = "krgybmcw d i.01234567 9 f FKRGYBMCW I ";
7409 int numco = 0, j;
7410
7411 n = 0;
7412 if (*s == '.')
7413 {
7414 numco++;
7415 n = 0x0f;
7416 s++;
7417 }
7418 for (j = 0; j < 2 && *s && *s != ' '; j++)
7419 {
7420 for (i = 0; costr[i]; i++)
7421 if (*s == costr[i])
7422 break;
7423 if (!costr[i])
7424 {
7425 if (msgok)
7426 Msg(0, "illegal color descriptor: '%c'", *s);
7427 return -1;
7428 }
7429 numco++;
7430 n = n << 4 | (i & 15);
7431 #ifdef COLORS16
7432 if (i >= 48)
7433 n = (n & 0x20ff) | 0x200;
7434 #endif
7435 s++;
7436 }
7437 if ((n & 0xf00) == 0xf00)
7438 n ^= 0xf00; /* clear superflous bits */
7439 #ifdef COLORS16
7440 if (n & 0x2000)
7441 n ^= 0x2400; /* shift bit into right position */
7442 #endif
7443 if (numco == 1)
7444 n |= 0xf0; /* don't change bg color */
7445 if (numco != 2 && n != 0xff)
7446 n |= 0x100; /* special invert mode */
7447 if (*s && *s != ' ')
7448 {
7449 if (msgok)
7450 Msg(0, "junk after color description: '%c'", *s);
7451 return -1;
7452 }
7453 n ^= 0xff;
7454 r |= n << 16;
7455 }
7456 #endif
7457
7458 while (*s && *s == ' ')
7459 s++;
7460 if (*s)
7461 {
7462 if (msgok)
7463 Msg(0, "junk after description: '%c'", *s);
7464 return -1;
7465 }
7466 debug1("ParseAttrColor %06x\n", r);
7467 return r;
7468 }
7469
7470 /*
7471 * Color coding:
7472 * 0-7 normal colors
7473 * 9 default color
7474 * e just set intensity
7475 * f don't change anything
7476 * Intensity is encoded into bits 17(fg) and 18(bg).
7477 */
7478 void
7479 ApplyAttrColor(i, mc)
7480 int i;
7481 struct mchar *mc;
7482 {
7483 debug1("ApplyAttrColor %06x\n", i);
7484 mc->attr |= i >> 8 & 255;
7485 mc->attr ^= i & 255;
7486 #ifdef COLOR
7487 i = (i >> 16) ^ 0xff;
7488 if ((i & 0x100) != 0)
7489 {
7490 i &= 0xeff;
7491 if (mc->attr & (A_SO|A_RV))
7492 # ifdef COLORS16
7493 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) | ((i & 0x200) << 1) | ((i & 0x400) >> 1);
7494 # else
7495 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4);
7496 # endif
7497 }
7498 # ifdef COLORS16
7499 if ((i & 0x0f) != 0x0f)
7500 mc->attr = (mc->attr & 0xbf) | ((i >> 3) & 0x40);
7501 if ((i & 0xf0) != 0xf0)
7502 mc->attr = (mc->attr & 0x7f) | ((i >> 3) & 0x80);
7503 # endif
7504 mc->color = 0x99 ^ mc->color;
7505 if ((i & 0x0e) == 0x0e)
7506 i = (i & 0xf0) | (mc->color & 0x0f);
7507 if ((i & 0xe0) == 0xe0)
7508 i = (i & 0x0f) | (mc->color & 0xf0);
7509 mc->color = 0x99 ^ i;
7510 debug2("ApplyAttrColor - %02x %02x\n", mc->attr, i);
7511 #endif
7512 }
Lua scripting support for GNU Screen