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