?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

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