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