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