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