?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'cmd-alias' into lua-scripting
[screen-lua.git] / src / process.c
blobf53af2d3833889dca8faf11342ac5e9bafd9a484
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 case RC_LUA:
3821 LuaCall(args);
3822 break;
3823
3824 case RC_LUASOURCE:
3825 ScriptSource(*args);
3826 break;
3827
3828 #ifdef MULTIUSER
3829 case RC_SU:
3830 s = NULL;
3831 if (!*args)
3832 {
3833 Msg(0, "%s:%s screen login", HostName, SockPath);
3834 InputSu(D_fore, &D_user, NULL);
3835 }
3836 else if (!args[1])
3837 InputSu(D_fore, &D_user, args[0]);
3838 else if (!args[2])
3839 s = DoSu(&D_user, args[0], args[1], "\377");
3840 else
3841 s = DoSu(&D_user, args[0], args[1], args[2]);
3842 if (s)
3843 Msg(0, "%s", s);
3844 break;
3845 #endif /* MULTIUSER */
3846 case RC_SPLIT:
3847 s = args[0];
3848 if (s && !strcmp(s, "-v"))
3849 AddCanvas(SLICE_HORI);
3850 else
3851 AddCanvas(SLICE_VERT);
3852 Activate(-1);
3853 break;
3854 case RC_REMOVE:
3855 RemCanvas();
3856 Activate(-1);
3857 break;
3858 case RC_ONLY:
3859 OneCanvas();
3860 Activate(-1);
3861 break;
3862 case RC_FIT:
3863 D_forecv->c_xoff = D_forecv->c_xs;
3864 D_forecv->c_yoff = D_forecv->c_ys;
3865 RethinkViewportOffsets(D_forecv);
3866 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, 0);
3867 flayer = D_forecv->c_layer;
3868 LaySetCursor();
3869 break;
3870 case RC_FOCUS:
3871 if (!*args || !strcmp(*args, "down"))
3872 D_forecv = D_forecv->c_next ? D_forecv->c_next : D_cvlist;
3873 else if (!strcmp(*args, "up"))
3874 {
3875 struct canvas *cv;
3876 for (cv = D_cvlist; cv->c_next && cv->c_next != D_forecv; cv = cv->c_next)
3877 ;
3878 D_forecv = cv;
3879 }
3880 else if (!strcmp(*args, "top"))
3881 D_forecv = D_cvlist;
3882 else if (!strcmp(*args, "bottom"))
3883 {
3884 struct canvas *cv;
3885 for (cv = D_cvlist; cv->c_next; cv = cv->c_next)
3886 ;
3887 D_forecv = cv;
3888 }
3889 else
3890 {
3891 Msg(0, "%s: usage: focus [up|down|top|bottom]", rc_name);
3892 break;
3893 }
3894 if ((focusminwidth && (focusminwidth < 0 || D_forecv->c_xe - D_forecv->c_xs + 1 < focusminwidth)) ||
3895 (focusminheight && (focusminheight < 0 || D_forecv->c_ye - D_forecv->c_ys + 1 < focusminheight)))
3896 {
3897 ResizeCanvas(&D_canvas);
3898 RecreateCanvasChain();
3899 RethinkDisplayViewports();
3900 ResizeLayersToCanvases(); /* redisplays */
3901 }
3902 fore = D_fore = Layer2Window(D_forecv->c_layer);
3903 if (D_other == fore)
3904 D_other = 0;
3905 flayer = D_forecv->c_layer;
3906 #ifdef RXVT_OSC
3907 if (D_xtermosc[2] || D_xtermosc[3])
3908 {
3909 Activate(-1);
3910 break;
3911 }
3912 #endif
3913 RefreshHStatus();
3914 #ifdef RXVT_OSC
3915 RefreshXtermOSC();
3916 #endif
3917 flayer = D_forecv->c_layer;
3918 CV_CALL(D_forecv, LayRestore();LaySetCursor());
3919 WindowChanged(0, 'F');
3920 break;
3921 case RC_RESIZE:
3922 i = 0;
3923 if (D_forecv->c_slorient == SLICE_UNKN)
3924 {
3925 Msg(0, "resize: need more than one region");
3926 break;
3927 }
3928 for (; *args; args++)
3929 {
3930 if (!strcmp(*args, "-h"))
3931 i |= RESIZE_FLAG_H;
3932 else if (!strcmp(*args, "-v"))
3933 i |= RESIZE_FLAG_V;
3934 else if (!strcmp(*args, "-b"))
3935 i |= RESIZE_FLAG_H | RESIZE_FLAG_V;
3936 else if (!strcmp(*args, "-p"))
3937 i |= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
3938 else if (!strcmp(*args, "-l"))
3939 i |= RESIZE_FLAG_L;
3940 else
3941 break;
3942 }
3943 if (*args && args[1])
3944 {
3945 Msg(0, "%s: usage: resize [-h] [-v] [-l] [num]\n", rc_name);
3946 break;
3947 }
3948 if (*args)
3949 ResizeRegions(*args, i);
3950 else
3951 Input(resizeprompts[i], 20, INP_EVERY, ResizeFin, (char*)0, i);
3952 break;
3953 case RC_SETSID:
3954 (void)ParseSwitch(act, &separate_sids);
3955 break;
3956 case RC_EVAL:
3957 args = SaveArgs(args);
3958 for (i = 0; args[i]; i++)
3959 {
3960 if (args[i][0])
3961 Colonfin(args[i], strlen(args[i]), (char *)0);
3962 free(args[i]);
3963 }
3964 free(args);
3965 break;
3966 case RC_ALTSCREEN:
3967 (void)ParseSwitch(act, &use_altscreen);
3968 if (msgok)
3969 Msg(0, "Will %sdo alternate screen switching", use_altscreen ? "" : "not ");
3970 break;
3971 case RC_MAXWIN:
3972 if (ParseNum(act, &n))
3973 break;
3974 if (n < 1)
3975 Msg(0, "illegal maxwin number specified");
3976 else if (n > maxwin)
3977 Msg(0, "may only decrease maxwin number");
3978 else
3979 maxwin = n;
3980 break;
3981 case RC_BACKTICK:
3982 if (ParseBase(act, *args, &n, 10, "decimal"))
3983 break;
3984 if (!args[1])
3985 setbacktick(n, 0, 0, (char **)0);
3986 else
3987 {
3988 int lifespan, tick;
3989 if (argc < 4)
3990 {
3991 Msg(0, "%s: usage: backtick num [lifespan tick cmd args...]", rc_name);
3992 break;
3993 }
3994 if (ParseBase(act, args[1], &lifespan, 10, "decimal"))
3995 break;
3996 if (ParseBase(act, args[2], &tick, 10, "decimal"))
3997 break;
3998 setbacktick(n, lifespan, tick, SaveArgs(args + 3));
3999 }
4000 WindowChanged(0, '`');
4001 break;
4002 case RC_BLANKER:
4003 #ifdef BLANKER_PRG
4004 if (blankerprg)
4005 {
4006 RunBlanker(blankerprg);
4007 break;
4008 }
4009 #endif
4010 ClearAll();
4011 CursorVisibility(-1);
4012 D_blocked = 4;
4013 break;
4014 #ifdef BLANKER_PRG
4015 case RC_BLANKERPRG:
4016 if (blankerprg)
4017 {
4018 char **pp;
4019 for (pp = blankerprg; *pp; pp++)
4020 free(*pp);
4021 free(blankerprg);
4022 blankerprg = 0;
4023 }
4024 if (args[0][0])
4025 blankerprg = SaveArgs(args);
4026 break;
4027 #endif
4028 case RC_IDLE:
4029 if (*args)
4030 {
4031 struct display *olddisplay = display;
4032 if (!strcmp(*args, "off"))
4033 idletimo = 0;
4034 else if (args[0][0])
4035 idletimo = atoi(*args) * 1000;
4036 if (argc > 1)
4037 {
4038 if ((i = FindCommnr(args[1])) == RC_ILLEGAL)
4039 {
4040 struct alias *alias = FindAlias(args[1]);
4041 if (!alias)
4042 {
4043 Msg(0, "%s: idle: unknown command or alias '%s'", rc_name, args[1]);
4044 break;
4045 }
4046 i = alias->nr;
4047 }
4048 if (i <= RC_LAST && CheckArgNum(i, args + 2) < 0)
4049 break;
4050 ClearAction(&idleaction);
4051 SaveAction(&idleaction, i, args + 2, argl + 2);
4052 }
4053 for (display = displays; display; display = display->d_next)
4054 ResetIdle();
4055 display = olddisplay;
4056 }
4057 if (msgok)
4058 {
4059 if (idletimo)
4060 Msg(0, "idle timeout %ds, %s", idletimo / 1000, comms[idleaction.nr].name);
4061 else
4062 Msg(0, "idle off");
4063 }
4064 break;
4065 case RC_FOCUSMINSIZE:
4066 for (i = 0; i < 2 && args[i]; i++)
4067 {
4068 if (!strcmp(args[i], "max") || !strcmp(args[i], "_"))
4069 n = -1;
4070 else
4071 n = atoi(args[i]);
4072 if (i == 0)
4073 focusminwidth = n;
4074 else
4075 focusminheight = n;
4076 }
4077 if (msgok)
4078 {
4079 char b[2][20];
4080 for (i = 0; i < 2; i++)
4081 {
4082 n = i == 0 ? focusminwidth : focusminheight;
4083 if (n == -1)
4084 strcpy(b[i], "max");
4085 else
4086 sprintf(b[i], "%d", n);
4087 }
4088 Msg(0, "focus min size is %s %s\n", b[0], b[1]);
4089 }
4090 break;
4091 case RC_GROUP:
4092 if (*args)
4093 {
4094 fore->w_group = 0;
4095 if (args[0][0])
4096 {
4097 fore->w_group = WindowByName(*args);
4098 if (fore->w_group && fore->w_group->w_type != W_TYPE_GROUP)
4099 fore->w_group = 0;
4100 }
4101 WindowChanged((struct win *)0, 'w');
4102 WindowChanged((struct win *)0, 'W');
4103 WindowChanged((struct win *)0, 0);
4104 }
4105 if (msgok)
4106 {
4107 if (fore->w_group)
4108 Msg(0, "window group is %d (%s)\n", fore->w_group->w_number, fore->w_group->w_title);
4109 else
4110 Msg(0, "window belongs to no group");
4111 }
4112 break;
4113 case RC_LAYOUT:
4114 if (!strcmp(args[0], "title"))
4115 {
4116 if (!D_layout)
4117 {
4118 Msg(0, "not on a layout");
4119 break;
4120 }
4121 if (!args[1])
4122 {
4123 Msg(0, "current layout is %d (%s)", D_layout->lay_number, D_layout->lay_title);
4124 break;
4125 }
4126 free(D_layout->lay_title);
4127 D_layout->lay_title= SaveStr(args[1]);
4128 }
4129 else if (!strcmp(args[0], "number"))
4130 {
4131 int old;
4132 struct layout *lay;
4133 if (!args[1])
4134 {
4135 Msg(0, "This is layout %d (%s).\n", D_layout->lay_number, D_layout->lay_title);
4136 break;
4137 }
4138 old = D_layout->lay_number;
4139 n = atoi(args[1]);
4140 if (n < 0 || n >= MAXLAY)
4141 break;
4142 lay = laytab[n];
4143 laytab[n] = D_layout;
4144 D_layout->lay_number = n;
4145 laytab[old] = lay;
4146 if (lay)
4147 lay->lay_number = old;
4148 break;
4149 }
4150 else if (!strcmp(args[0], "autosave"))
4151 {
4152 if (!D_layout)
4153 {
4154 Msg(0, "not on a layout");
4155 break;
4156 }
4157 if (args[1])
4158 {
4159 if (!strcmp(args[1], "on"))
4160 D_layout->lay_autosave = 1;
4161 else if (!strcmp(args[1], "off"))
4162 D_layout->lay_autosave = 0;
4163 else
4164 {
4165 Msg(0, "invalid argument. Give 'on' or 'off");
4166 break;
4167 }
4168 }
4169 if (msgok)
4170 Msg(0, "autosave is %s", D_layout->lay_autosave ? "on" : "off");
4171 }
4172 else if (!strcmp(args[0], "new"))
4173 {
4174 char *t = args[1];
4175 n = 0;
4176 if (t)
4177 {
4178 while (*t >= '0' && *t <= '9')
4179 t++;
4180 if (t != args[1] && (!*t || *t == ':'))
4181 {
4182 n = atoi(args[1]);
4183 if (*t)
4184 t++;
4185 }
4186 else
4187 t = args[1];
4188 }
4189 if (!t || !*t)
4190 t = "layout";
4191 NewLayout(t, n);
4192 Activate(-1);
4193 }
4194 else if (!strcmp(args[0], "save"))
4195 {
4196 if (!args[1])
4197 {
4198 Msg(0, "usage: layout save <name>");
4199 break;
4200 }
4201 SaveLayout(args[1], &D_canvas);
4202 }
4203 else if (!strcmp(args[0], "select"))
4204 {
4205 if (!args[1])
4206 {
4207 Input("Switch to layout: ", 20, INP_COOKED, SelectLayoutFin, NULL, 0);
4208 break;
4209 }
4210 SelectLayoutFin(args[1], strlen(args[1]), (char *)0);
4211 }
4212 else if (!strcmp(args[0], "next"))
4213 {
4214 struct layout *lay = D_layout;
4215 if (lay)
4216 lay = lay->lay_next ? lay->lay_next : layouts;
4217 else
4218 lay = layouts;
4219 if (!lay)
4220 {
4221 Msg(0, "no layout defined");
4222 break;
4223 }
4224 if (lay == D_layout)
4225 break;
4226 LoadLayout(lay, &D_canvas);
4227 Activate(-1);
4228 }
4229 else if (!strcmp(args[0], "prev"))
4230 {
4231 struct layout *lay = D_layout;
4232 if (lay)
4233 {
4234 for (lay = layouts; lay->lay_next && lay->lay_next != D_layout; lay = lay->lay_next)
4235 ;
4236 }
4237 else
4238 lay = layouts;
4239 if (!lay)
4240 {
4241 Msg(0, "no layout defined");
4242 break;
4243 }
4244 if (lay == D_layout)
4245 break;
4246 LoadLayout(lay, &D_canvas);
4247 Activate(-1);
4248 }
4249 else if (!strcmp(args[0], "attach"))
4250 {
4251 if (!args[1])
4252 {
4253 if (!layout_attach)
4254 Msg(0, "no attach layout set");
4255 else if (layout_attach == &layout_last_marker)
4256 Msg(0, "will attach to last layout");
4257 else
4258 Msg(0, "will attach to layout %d (%s)", layout_attach->lay_number, layout_attach->lay_title);
4259 break;
4260 }
4261 if (!strcmp(args[1], ":last"))
4262 layout_attach = &layout_last_marker;
4263 else if (!args[1][0])
4264 layout_attach = 0;
4265 else
4266 {
4267 struct layout *lay;
4268 lay = FindLayout(args[1]);
4269 if (!lay)
4270 {
4271 Msg(0, "unknown layout '%s'", args[1]);
4272 break;
4273 }
4274 layout_attach = lay;
4275 }
4276 }
4277 else if (!strcmp(args[0], "show"))
4278 {
4279 ShowLayouts(-1);
4280 }
4281 else if (!strcmp(args[0], "remove"))
4282 {
4283 struct layout *lay = display ? D_layout : layouts;
4284 if (args[1])
4285 {
4286 lay = layouts ? FindLayout(args[1]) : (struct layout *)0;
4287 if (!lay)
4288 {
4289 Msg(0, "unknown layout '%s'", args[1]);
4290 break;
4291 }
4292 }
4293 if (lay)
4294 RemoveLayout(lay);
4295 }
4296 else
4297 Msg(0, "unknown layout subcommand");
4298 break;
4299 #ifdef DW_CHARS
4300 case RC_CJKWIDTH:
4301 if(ParseSwitch(act, &cjkwidth) == 0)
4302 {
4303 if(msgok)
4304 Msg(0, "Treat ambiguous width characters as %s width", cjkwidth ? "full" : "half");
4305 }
4306 break;
4307 #endif
4308 default:
4309 #ifdef HAVE_BRAILLE
4310 /* key == -2: input from braille keybord, msgok always 0 */
4311 DoBrailleAction(act, key == -2 ? 0 : msgok);
4312 #endif
4313 break;
4314 }
4315 if (display != odisplay)
4316 {
4317 for (display = displays; display; display = display->d_next)
4318 if (display == odisplay)
4319 break;
4320 }
4321 }
4322
4323 static int
4324 DoAlias(name, args, argl)
4325 const char *name;
4326 char **args;
4327 int *argl;
4328 {
4329 char **mergeds;
4330 int *mergedl;
4331 int count, i;
4332 struct alias *alias = FindAlias(name);
4333
4334 if (alias == NULL)
4335 return 0;
4336
4337 count = 0;
4338 for (; args && args[count]; count++)
4339 ;
4340 for (i = 0; alias->args && alias->args[i]; i++, count++)
4341 ;
4342 ++count;
4343
4344 if ((mergeds = malloc(count * sizeof(char *))) == 0)
4345 return 0;
4346 if ((mergedl = malloc(count * sizeof(int))) == 0)
4347 {
4348 free(mergeds);
4349 return 0;
4350 }
4351 for (count = 0; alias->args && alias->args[count]; count++)
4352 {
4353 mergeds[count] = alias->args[count];
4354 mergedl[count] = alias->argl[count];
4355 }
4356 for (i = 0; args && args[i]; i++, count++)
4357 {
4358 mergeds[count] = args[i];
4359 mergedl[count] = argl[i];
4360 }
4361 mergeds[count] = 0;
4362 mergedl[count] = 0 ;
4363
4364 DoCommand(mergeds, mergedl);
4365
4366 free(mergeds);
4367 free(mergedl);
4368 return 1;
4369 }
4370
4371 void
4372 DoCommand(argv, argl)
4373 char **argv;
4374 int *argl;
4375 {
4376 struct action act;
4377
4378 /* Alias? */
4379 if (DoAlias(*argv, argv + 1, argl + 1))
4380 return;
4381
4382 if ((act.nr = FindCommnr(*argv)) == RC_ILLEGAL)
4383 {
4384 Msg(0, "%s: unknown command '%s'", rc_name, *argv);
4385 return;
4386 }
4387 act.args = argv + 1;
4388 act.argl = argl + 1;
4389 DoAction(&act, -1);
4390 }
4391
4392 static void
4393 SaveAction(act, nr, args, argl)
4394 struct action *act;
4395 int nr;
4396 char **args;
4397 int *argl;
4398 {
4399 register int argc = 0;
4400 char **pp;
4401 int *lp;
4402
4403 if (args)
4404 while (args[argc])
4405 argc++;
4406 if (argc == 0)
4407 {
4408 act->nr = nr;
4409 act->args = noargs;
4410 act->argl = 0;
4411 return;
4412 }
4413 if ((pp = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4414 Panic(0, strnomem);
4415 if ((lp = (int *)malloc((unsigned)(argc) * sizeof(int *))) == 0)
4416 Panic(0, strnomem);
4417 act->nr = nr;
4418 act->args = pp;
4419 act->argl = lp;
4420 while (argc--)
4421 {
4422 *lp = argl ? *argl++ : (int)strlen(*args);
4423 *pp++ = SaveStrn(*args++, *lp++);
4424 }
4425 *pp = 0;
4426 }
4427
4428 static char **
4429 SaveArgs(args)
4430 char **args;
4431 {
4432 register char **ap, **pp;
4433 register int argc = 0;
4434
4435 while (args[argc])
4436 argc++;
4437 if ((pp = ap = (char **)malloc((unsigned)(argc + 1) * sizeof(char **))) == 0)
4438 Panic(0, strnomem);
4439 while (argc--)
4440 *pp++ = SaveStr(*args++);
4441 *pp = 0;
4442 return ap;
4443 }
4444
4445
4446 /*
4447 * buf is split into argument vector args.
4448 * leading whitespace is removed.
4449 * @!| abbreviations are expanded.
4450 * the end of buffer is recognized by '\0' or an un-escaped '#'.
4451 * " and ' are interpreted.
4452 *
4453 * argc is returned.
4454 */
4455 int
4456 Parse(buf, bufl, args, argl)
4457 char *buf, **args;
4458 int bufl, *argl;
4459 {
4460 register char *p = buf, **ap = args, *pp;
4461 register int delim, argc;
4462 int *lp = argl;
4463
4464 debug2("Parse %d %s\n", bufl, buf);
4465 argc = 0;
4466 pp = buf;
4467 delim = 0;
4468 for (;;)
4469 {
4470 while (*p && (*p == ' ' || *p == '\t'))
4471 ++p;
4472 #ifdef PSEUDOS
4473 if (argc == 0 && *p == '!')
4474 {
4475 *ap++ = "exec";
4476 *lp++ = 4;
4477 p++;
4478 argc++;
4479 continue;
4480 }
4481 #endif
4482 if (*p == '\0' || *p == '#' || *p == '\n')
4483 {
4484 *p = '\0';
4485 for (delim = 0; delim < argc; delim++)
4486 debug1("-- %s\n", args[delim]);
4487 args[argc] = 0;
4488 return argc;
4489 }
4490 if (++argc >= MAXARGS)
4491 {
4492 Msg(0, "%s: too many tokens.", rc_name);
4493 return 0;
4494 }
4495 *ap++ = pp;
4496
4497 debug1("- new arg %s\n", p);
4498 while (*p)
4499 {
4500 if (*p == delim)
4501 delim = 0;
4502 else if (delim != '\'' && *p == '\\' && (p[1] == '\'' || p[1] == '"' || p[1] == '\\' || p[1] == '$' || p[1] == '#' || p[1] == '^' || (p[1] >= '0' && p[1] <= '7')))
4503 {
4504 p++;
4505 if (*p >= '0' && *p <= '7')
4506 {
4507 *pp = *p - '0';
4508 if (p[1] >= '0' && p[1] <= '7')
4509 {
4510 p++;
4511 *pp = (*pp << 3) | (*p - '0');
4512 if (p[1] >= '0' && p[1] <= '7')
4513 {
4514 p++;
4515 *pp = (*pp << 3) | (*p - '0');
4516 }
4517 }
4518 pp++;
4519 }
4520 else
4521 *pp++ = *p;
4522 }
4523 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] == '_'))
4524
4525 {
4526 char *ps, *pe, op, *v, xbuf[11];
4527 int vl;
4528
4529 ps = ++p;
4530 debug1("- var %s\n", ps);
4531 p++;
4532 while (*p)
4533 {
4534 if (*ps == '{' && *p == '}')
4535 break;
4536 if (*ps == ':' && *p == ':')
4537 break;
4538 if (*ps != '{' && *ps != ':' && (*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9') && *p != '_')
4539 break;
4540 p++;
4541 }
4542 pe = p;
4543 if (*ps == '{' || *ps == ':')
4544 {
4545 if (!*p)
4546 {
4547 Msg(0, "%s: bad variable name.", rc_name);
4548 return 0;
4549 }
4550 p++;
4551 }
4552 op = *pe;
4553 *pe = 0;
4554 debug1("- var is '%s'\n", ps);
4555 if (*ps == ':')
4556 v = gettermcapstring(ps + 1);
4557 else
4558 {
4559 if (*ps == '{')
4560 ps++;
4561 v = xbuf;
4562 if (!strcmp(ps, "TERM"))
4563 v = display ? D_termname : "unknown";
4564 else if (!strcmp(ps, "COLUMNS"))
4565 sprintf(xbuf, "%d", display ? D_width : -1);
4566 else if (!strcmp(ps, "LINES"))
4567 sprintf(xbuf, "%d", display ? D_height : -1);
4568 else
4569 v = getenv(ps);
4570 }
4571 *pe = op;
4572 vl = v ? strlen(v) : 0;
4573 if (vl)
4574 {
4575 debug1("- sub is '%s'\n", v);
4576 if (p - pp < vl)
4577 {
4578 int right = buf + bufl - (p + strlen(p) + 1);
4579 if (right > 0)
4580 {
4581 bcopy(p, p + right, strlen(p) + 1);
4582 p += right;
4583 }
4584 }
4585 if (p - pp < vl)
4586 {
4587 Msg(0, "%s: no space left for variable expansion.", rc_name);
4588 return 0;
4589 }
4590 bcopy(v, pp, vl);
4591 pp += vl;
4592 }
4593 continue;
4594 }
4595 else if (delim != '\'' && *p == '^' && p[1])
4596 {
4597 p++;
4598 *pp++ = *p == '?' ? '\177' : *p & 0x1f;
4599 }
4600 else if (delim == 0 && (*p == '\'' || *p == '"'))
4601 delim = *p;
4602 else if (delim == 0 && (*p == ' ' || *p == '\t' || *p == '\n'))
4603 break;
4604 else
4605 *pp++ = *p;
4606 p++;
4607 }
4608 if (delim)
4609 {
4610 Msg(0, "%s: Missing %c quote.", rc_name, delim);
4611 return 0;
4612 }
4613 if (*p)
4614 p++;
4615 *pp = 0;
4616 debug2("- arg done, '%s' rest %s\n", ap[-1], p);
4617 *lp++ = pp - ap[-1];
4618 pp++;
4619 }
4620 }
4621
4622 void
4623 SetEscape(u, e, me)
4624 struct acluser *u;
4625 int e, me;
4626 {
4627 if (u)
4628 {
4629 u->u_Esc = e;
4630 u->u_MetaEsc = me;
4631 }
4632 else
4633 {
4634 if (users)
4635 {
4636 if (DefaultEsc >= 0)
4637 ClearAction(&ktab[DefaultEsc]);
4638 if (DefaultMetaEsc >= 0)
4639 ClearAction(&ktab[DefaultMetaEsc]);
4640 }
4641 DefaultEsc = e;
4642 DefaultMetaEsc = me;
4643 if (users)
4644 {
4645 if (DefaultEsc >= 0)
4646 {
4647 ClearAction(&ktab[DefaultEsc]);
4648 ktab[DefaultEsc].nr = RC_OTHER;
4649 }
4650 if (DefaultMetaEsc >= 0)
4651 {
4652 ClearAction(&ktab[DefaultMetaEsc]);
4653 ktab[DefaultMetaEsc].nr = RC_META;
4654 }
4655 }
4656 }
4657 }
4658
4659 int
4660 ParseSwitch(act, var)
4661 struct action *act;
4662 int *var;
4663 {
4664 if (*act->args == 0)
4665 {
4666 *var ^= 1;
4667 return 0;
4668 }
4669 return ParseOnOff(act, var);
4670 }
4671
4672 static int
4673 ParseOnOff(act, var)
4674 struct action *act;
4675 int *var;
4676 {
4677 register int num = -1;
4678 char **args = act->args;
4679
4680 if (args[1] == 0)
4681 {
4682 if (strcmp(args[0], "on") == 0)
4683 num = 1;
4684 else if (strcmp(args[0], "off") == 0)
4685 num = 0;
4686 }
4687 if (num < 0)
4688 {
4689 Msg(0, "%s: %s: invalid argument. Give 'on' or 'off'", rc_name, comms[act->nr].name);
4690 return -1;
4691 }
4692 *var = num;
4693 return 0;
4694 }
4695
4696 int
4697 ParseSaveStr(act, var)
4698 struct action *act;
4699 char **var;
4700 {
4701 char **args = act->args;
4702 if (*args == 0 || args[1])
4703 {
4704 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4705 return -1;
4706 }
4707 if (*var)
4708 free(*var);
4709 *var = SaveStr(*args);
4710 return 0;
4711 }
4712
4713 int
4714 ParseNum(act, var)
4715 struct action *act;
4716 int *var;
4717 {
4718 int i;
4719 char *p, **args = act->args;
4720
4721 p = *args;
4722 if (p == 0 || *p == 0 || args[1])
4723 {
4724 Msg(0, "%s: %s: invalid argument. Give one argument.",
4725 rc_name, comms[act->nr].name);
4726 return -1;
4727 }
4728 i = 0;
4729 while (*p)
4730 {
4731 if (*p >= '0' && *p <= '9')
4732 i = 10 * i + (*p - '0');
4733 else
4734 {
4735 Msg(0, "%s: %s: invalid argument. Give numeric argument.",
4736 rc_name, comms[act->nr].name);
4737 return -1;
4738 }
4739 p++;
4740 }
4741 debug1("ParseNum got %d\n", i);
4742 *var = i;
4743 return 0;
4744 }
4745
4746 static int
4747 ParseNum1000(act, var)
4748 struct action *act;
4749 int *var;
4750 {
4751 int i;
4752 char *p, **args = act->args;
4753 int dig = 0;
4754
4755 p = *args;
4756 if (p == 0 || *p == 0 || args[1])
4757 {
4758 Msg(0, "%s: %s: invalid argument. Give one argument.",
4759 rc_name, comms[act->nr].name);
4760 return -1;
4761 }
4762 i = 0;
4763 while (*p)
4764 {
4765 if (*p >= '0' && *p <= '9')
4766 {
4767 if (dig < 4)
4768 i = 10 * i + (*p - '0');
4769 else if (dig == 4 && *p >= '5')
4770 i++;
4771 if (dig)
4772 dig++;
4773 }
4774 else if (*p == '.' && !dig)
4775 dig++;
4776 else
4777 {
4778 Msg(0, "%s: %s: invalid argument. Give floating point argument.",
4779 rc_name, comms[act->nr].name);
4780 return -1;
4781 }
4782 p++;
4783 }
4784 if (dig == 0)
4785 i *= 1000;
4786 else
4787 while (dig++ < 4)
4788 i *= 10;
4789 if (i < 0)
4790 i = (int)((unsigned int)~0 >> 1);
4791 debug1("ParseNum1000 got %d\n", i);
4792 *var = i;
4793 return 0;
4794 }
4795
4796 static struct win *
4797 WindowByName(s)
4798 char *s;
4799 {
4800 struct win *p;
4801
4802 for (p = windows; p; p = p->w_next)
4803 if (!strcmp(p->w_title, s))
4804 return p;
4805 for (p = windows; p; p = p->w_next)
4806 if (!strncmp(p->w_title, s, strlen(s)))
4807 return p;
4808 return 0;
4809 }
4810
4811 static int
4812 WindowByNumber(str)
4813 char *str;
4814 {
4815 int i;
4816 char *s;
4817
4818 for (i = 0, s = str; *s; s++)
4819 {
4820 if (*s < '0' || *s > '9')
4821 break;
4822 i = i * 10 + (*s - '0');
4823 }
4824 return *s ? -1 : i;
4825 }
4826
4827 /*
4828 * Get window number from Name or Number string.
4829 * Numbers are tried first, then names, a prefix match suffices.
4830 * Be careful when assigning numeric strings as WindowTitles.
4831 */
4832 int
4833 WindowByNoN(str)
4834 char *str;
4835 {
4836 int i;
4837 struct win *p;
4838
4839 if ((i = WindowByNumber(str)) < 0 || i >= MAXWIN)
4840 {
4841 if ((p = WindowByName(str)))
4842 return p->w_number;
4843 return -1;
4844 }
4845 return i;
4846 }
4847
4848 static int
4849 ParseWinNum(act, var)
4850 struct action *act;
4851 int *var;
4852 {
4853 char **args = act->args;
4854 int i = 0;
4855
4856 if (*args == 0 || args[1])
4857 {
4858 Msg(0, "%s: %s: one argument required.", rc_name, comms[act->nr].name);
4859 return -1;
4860 }
4861
4862 i = WindowByNoN(*args);
4863 if (i < 0)
4864 {
4865 Msg(0, "%s: %s: invalid argument. Give window number or name.",
4866 rc_name, comms[act->nr].name);
4867 return -1;
4868 }
4869 debug1("ParseWinNum got %d\n", i);
4870 *var = i;
4871 return 0;
4872 }
4873
4874 static int
4875 ParseBase(act, p, var, base, bname)
4876 struct action *act;
4877 char *p;
4878 int *var;
4879 int base;
4880 char *bname;
4881 {
4882 int i = 0;
4883 int c;
4884
4885 if (*p == 0)
4886 {
4887 Msg(0, "%s: %s: empty argument.", rc_name, comms[act->nr].name);
4888 return -1;
4889 }
4890 while ((c = *p++))
4891 {
4892 if (c >= 'a' && c <= 'z')
4893 c -= 'a' - 'A';
4894 if (c >= 'A' && c <= 'Z')
4895 c -= 'A' - ('0' + 10);
4896 c -= '0';
4897 if (c < 0 || c >= base)
4898 {
4899 Msg(0, "%s: %s: argument is not %s.", rc_name, comms[act->nr].name, bname);
4900 return -1;
4901 }
4902 i = base * i + c;
4903 }
4904 debug1("ParseBase got %d\n", i);
4905 *var = i;
4906 return 0;
4907 }
4908
4909 static int
4910 IsNum(s, base)
4911 register char *s;
4912 register int base;
4913 {
4914 for (base += '0'; *s; ++s)
4915 if (*s < '0' || *s > base)
4916 return 0;
4917 return 1;
4918 }
4919
4920 int
4921 IsNumColon(s, base, p, psize)
4922 int base, psize;
4923 char *s, *p;
4924 {
4925 char *q;
4926 if ((q = rindex(s, ':')) != 0)
4927 {
4928 strncpy(p, q + 1, psize - 1);
4929 p[psize - 1] = '\0';
4930 *q = '\0';
4931 }
4932 else
4933 *p = '\0';
4934 return IsNum(s, base);
4935 }
4936
4937 void
4938 SwitchWindow(n)
4939 int n;
4940 {
4941 struct win *p;
4942
4943 debug1("SwitchWindow %d\n", n);
4944 if (n < 0 || n >= MAXWIN)
4945 {
4946 ShowWindows(-1);
4947 return;
4948 }
4949 if ((p = wtab[n]) == 0)
4950 {
4951 ShowWindows(n);
4952 return;
4953 }
4954 if (display == 0)
4955 {
4956 fore = p;
4957 return;
4958 }
4959 if (p == D_fore)
4960 {
4961 Msg(0, "This IS window %d (%s).", n, p->w_title);
4962 return;
4963 }
4964 #ifdef MULTIUSER
4965 if (AclCheckPermWin(D_user, ACL_READ, p))
4966 {
4967 Msg(0, "Access to window %d denied.", p->w_number);
4968 return;
4969 }
4970 #endif
4971 SetForeWindow(p);
4972 Activate(fore->w_norefresh);
4973 }
4974
4975
4976 void
4977 SetCanvasWindow(cv, wi)
4978 struct canvas *cv;
4979 struct win *wi;
4980 {
4981 struct win *p = 0, **pp;
4982 struct layer *l;
4983 struct canvas *cvp, **cvpp;
4984
4985 l = cv->c_layer;
4986 display = cv->c_display;
4987
4988 if (l)
4989 {
4990 /* remove old layer */
4991 for (cvpp = &l->l_cvlist; (cvp = *cvpp); cvpp = &cvp->c_lnext)
4992 if (cvp == cv)
4993 break;
4994 ASSERT(cvp);
4995 *cvpp = cvp->c_lnext;
4996
4997 p = Layer2Window(l);
4998 l = cv->c_layer;
4999 cv->c_layer = 0;
5000
5001 if (p && cv == D_forecv)
5002 {
5003 #ifdef MULTIUSER
5004 ReleaseAutoWritelock(display, p);
5005 #endif
5006 if (p->w_silence)
5007 {
5008 SetTimeout(&p->w_silenceev, p->w_silencewait * 1000);
5009 evenq(&p->w_silenceev);
5010 }
5011 D_other = fore;
5012 D_fore = 0;
5013 }
5014 if (l->l_cvlist == 0 && (p == 0 || l != p->w_savelayer))
5015 KillLayerChain(l);
5016 }
5017
5018 /* find right layer to display on canvas */
5019 if (wi && wi->w_type != W_TYPE_GROUP)
5020 {
5021 l = &wi->w_layer;
5022 if (wi->w_savelayer && (wi->w_blocked || wi->w_savelayer->l_cvlist == 0))
5023 l = wi->w_savelayer;
5024 }
5025 else
5026 {
5027 l = &cv->c_blank;
5028 if (wi)
5029 l->l_data = (char *)wi;
5030 else
5031 l->l_data = 0;
5032 }
5033
5034 /* add our canvas to the layer's canvaslist */
5035 ASSERT(l->l_cvlist != cv);
5036 cv->c_lnext = l->l_cvlist;
5037 l->l_cvlist = cv;
5038 cv->c_layer = l;
5039 cv->c_xoff = cv->c_xs;
5040 cv->c_yoff = cv->c_ys;
5041 RethinkViewportOffsets(cv);
5042
5043 if (flayer == 0)
5044 flayer = l;
5045
5046 if (wi && wi->w_type == W_TYPE_GROUP)
5047 {
5048 /* auto-start windowlist on groups */
5049 struct display *d = display;
5050 struct layer *oldflayer = flayer;
5051 flayer = l;
5052 display_wlist(0, 0, wi);
5053 flayer = oldflayer;
5054 display = d;
5055 }
5056
5057 if (wi && D_other == wi)
5058 D_other = wi->w_next; /* Might be 0, but that's OK. */
5059 if (cv == D_forecv)
5060 {
5061 D_fore = wi;
5062 fore = D_fore; /* XXX ? */
5063 if (wi)
5064 {
5065 #ifdef MULTIUSER
5066 ObtainAutoWritelock(display, wi);
5067 #endif
5068 /*
5069 * Place the window at the head of the most-recently-used list
5070 */
5071 if (windows != wi)
5072 {
5073 for (pp = &windows; (p = *pp); pp = &p->w_next)
5074 if (p == wi)
5075 break;
5076 ASSERT(p);
5077 *pp = p->w_next;
5078 p->w_next = windows;
5079 windows = p;
5080 WListLinkChanged();
5081 }
5082 }
5083 }
5084 }
5085
5086
5087 /*
5088 * SetForeWindow changes the window in the input focus of the display.
5089 * Puts window wi in canvas display->d_forecv.
5090 */
5091 void
5092 SetForeWindow(wi)
5093 struct win *wi;
5094 {
5095 struct win *p;
5096 if (display == 0)
5097 {
5098 fore = wi;
5099 return;
5100 }
5101 p = Layer2Window(D_forecv->c_layer);
5102 SetCanvasWindow(D_forecv, wi);
5103 if (p)
5104 WindowChanged(p, 'u');
5105 if (wi)
5106 WindowChanged(wi, 'u');
5107 flayer = D_forecv->c_layer;
5108 ScriptForeWindowChanged();
5109 /* Activate called afterwards, so no RefreshHStatus needed */
5110 }
5111
5112
5113 /*****************************************************************/
5114
5115 /*
5116 * Activate - make fore window active
5117 * norefresh = -1 forces a refresh, disregard all_norefresh then.
5118 */
5119 void
5120 Activate(norefresh)
5121 int norefresh;
5122 {
5123 debug1("Activate(%d)\n", norefresh);
5124 if (display == 0)
5125 return;
5126 if (D_status)
5127 {
5128 Msg(0, "%s", ""); /* wait till mintime (keep gcc quiet) */
5129 RemoveStatus();
5130 }
5131
5132 if (MayResizeLayer(D_forecv->c_layer))
5133 ResizeLayer(D_forecv->c_layer, D_forecv->c_xe - D_forecv->c_xs + 1, D_forecv->c_ye - D_forecv->c_ys + 1, display);
5134
5135 fore = D_fore;
5136 if (fore)
5137 {
5138 /* XXX ? */
5139 if (fore->w_monitor != MON_OFF)
5140 fore->w_monitor = MON_ON;
5141 fore->w_bell = BELL_ON;
5142 WindowChanged(fore, 'f');
5143
5144 #if 0
5145 if (ResizeDisplay(fore->w_width, fore->w_height))
5146 {
5147 debug2("Cannot resize from (%d,%d)", D_width, D_height);
5148 debug2(" to (%d,%d) -> resize window\n", fore->w_width, fore->w_height);
5149 DoResize(D_width, D_height);
5150 }
5151 #endif
5152 }
5153 Redisplay(norefresh + all_norefresh);
5154 }
5155
5156
5157 static int
5158 NextWindow()
5159 {
5160 register struct win **pp;
5161 int n = fore ? fore->w_number : MAXWIN;
5162 struct win *group = fore ? fore->w_group : 0;
5163
5164 for (pp = fore ? wtab + n + 1 : wtab; pp != wtab + n; pp++)
5165 {
5166 if (pp == wtab + MAXWIN)
5167 pp = wtab;
5168 if (*pp)
5169 {
5170 if (!fore || group == (*pp)->w_group)
5171 break;
5172 }
5173 }
5174 if (pp == wtab + n)
5175 return -1;
5176 return pp - wtab;
5177 }
5178
5179 static int
5180 PreviousWindow()
5181 {
5182 register struct win **pp;
5183 int n = fore ? fore->w_number : -1;
5184 struct win *group = fore ? fore->w_group : 0;
5185
5186 for (pp = wtab + n - 1; pp != wtab + n; pp--)
5187 {
5188 if (pp == wtab - 1)
5189 pp = wtab + MAXWIN - 1;
5190 if (*pp)
5191 {
5192 if (!fore || group == (*pp)->w_group)
5193 break;
5194 }
5195 }
5196 if (pp == wtab + n)
5197 return -1;
5198 return pp - wtab;
5199 }
5200
5201 static int
5202 MoreWindows()
5203 {
5204 char *m = "No other window.";
5205 if (windows && (fore == 0 || windows->w_next))
5206 return 1;
5207 if (fore == 0)
5208 {
5209 Msg(0, "No window available");
5210 return 0;
5211 }
5212 Msg(0, m, fore->w_number); /* other arg for nethack */
5213 return 0;
5214 }
5215
5216 static void
5217 UpdateLayoutCanvas(cv, wi)
5218 struct canvas *cv;
5219 struct win *wi;
5220 {
5221 for (; cv; cv = cv->c_slnext)
5222 {
5223 if (cv->c_layer && Layer2Window(cv->c_layer) == wi)
5224 {
5225 /* A simplistic version of SetCanvasWindow(cv, 0) */
5226 struct layer *l = cv->c_layer;
5227 cv->c_layer = 0;
5228 if (l->l_cvlist == 0 && (wi == 0 || l != wi->w_savelayer))
5229 KillLayerChain(l);
5230 l = &cv->c_blank;
5231 l->l_data = 0;
5232 if (l->l_cvlist != cv)
5233 {
5234 cv->c_lnext = l->l_cvlist;
5235 l->l_cvlist = cv;
5236 }
5237 cv->c_layer = l;
5238 /* Do not end here. Multiple canvases can have the same window */
5239 }
5240
5241 if (cv->c_slperp)
5242 UpdateLayoutCanvas(cv->c_slperp, wi);
5243 }
5244 }
5245
5246 void
5247 KillWindow(wi)
5248 struct win *wi;
5249 {
5250 struct win **pp, *p;
5251 struct canvas *cv;
5252 int gotone;
5253 struct layout *lay;
5254
5255 /*
5256 * Remove window from linked list.
5257 */
5258 for (pp = &windows; (p = *pp); pp = &p->w_next)
5259 if (p == wi)
5260 break;
5261 ASSERT(p);
5262 *pp = p->w_next;
5263 wi->w_inlen = 0;
5264 wtab[wi->w_number] = 0;
5265
5266 if (windows == 0)
5267 {
5268 FreeWindow(wi);
5269 Finit(0);
5270 }
5271
5272 /*
5273 * switch to different window on all canvases
5274 */
5275 for (display = displays; display; display = display->d_next)
5276 {
5277 gotone = 0;
5278 for (cv = D_cvlist; cv; cv = cv->c_next)
5279 {
5280 if (Layer2Window(cv->c_layer) != wi)
5281 continue;
5282 /* switch to other window */
5283 SetCanvasWindow(cv, FindNiceWindow(D_other, 0));
5284 gotone = 1;
5285 }
5286 if (gotone)
5287 {
5288 #ifdef ZMODEM
5289 if (wi->w_zdisplay == display)
5290 {
5291 D_blocked = 0;
5292 D_readev.condpos = D_readev.condneg = 0;
5293 }
5294 #endif
5295 Activate(-1);
5296 }
5297 }
5298
5299 /* do the same for the layouts */
5300 for (lay = layouts; lay; lay = lay->lay_next)
5301 UpdateLayoutCanvas(&lay->lay_canvas, wi);
5302
5303 FreeWindow(wi);
5304 WindowChanged((struct win *)0, 'w');
5305 WindowChanged((struct win *)0, 'W');
5306 WindowChanged((struct win *)0, 0);
5307 }
5308
5309 static void
5310 LogToggle(on)
5311 int on;
5312 {
5313 char buf[1024];
5314
5315 if ((fore->w_log != 0) == on)
5316 {
5317 if (display && !*rc_name)
5318 Msg(0, "You are %s logging.", on ? "already" : "not");
5319 return;
5320 }
5321 if (fore->w_log != 0)
5322 {
5323 Msg(0, "Logfile \"%s\" closed.", fore->w_log->name);
5324 logfclose(fore->w_log);
5325 fore->w_log = 0;
5326 WindowChanged(fore, 'f');
5327 return;
5328 }
5329 if (DoStartLog(fore, buf, sizeof(buf)))
5330 {
5331 Msg(errno, "Error opening logfile \"%s\"", buf);
5332 return;
5333 }
5334 if (ftell(fore->w_log->fp) == 0)
5335 Msg(0, "Creating logfile \"%s\".", fore->w_log->name);
5336 else
5337 Msg(0, "Appending to logfile \"%s\".", fore->w_log->name);
5338 WindowChanged(fore, 'f');
5339 }
5340
5341 char *
5342 AddWindows(buf, len, flags, where)
5343 char *buf;
5344 int len;
5345 int flags;
5346 int where;
5347 {
5348 register char *s, *ss;
5349 register struct win **pp, *p;
5350 register char *cmd;
5351 int l;
5352
5353 s = ss = buf;
5354 for (pp = ((flags & 4) && where >= 0) ? wtab + where + 1: wtab; pp < wtab + MAXWIN; pp++)
5355 {
5356 if (pp - wtab == where && ss == buf)
5357 ss = s;
5358 if ((p = *pp) == 0)
5359 continue;
5360 if ((flags & 1) && display && p == D_fore)
5361 continue;
5362 if (D_fore && D_fore->w_group != p->w_group)
5363 continue;
5364
5365 cmd = p->w_title;
5366 l = strlen(cmd);
5367 if (l > 20)
5368 l = 20;
5369 if (s - buf + l > len - 24)
5370 break;
5371 if (s > buf || (flags & 4))
5372 {
5373 *s++ = ' ';
5374 *s++ = ' ';
5375 }
5376 sprintf(s, "%d", p->w_number);
5377 if (p->w_number == where)
5378 ss = s;
5379 s += strlen(s);
5380 if (display && p == D_fore)
5381 *s++ = '*';
5382 if (!(flags & 2))
5383 {
5384 if (display && p == D_other)
5385 *s++ = '-';
5386 s = AddWindowFlags(s, len, p);
5387 }
5388 *s++ = ' ';
5389 strncpy(s, cmd, l);
5390 s += l;
5391 }
5392 *s = 0;
5393 return ss;
5394 }
5395
5396 char *
5397 AddWindowFlags(buf, len, p)
5398 char *buf;
5399 int len;
5400 struct win *p;
5401 {
5402 char *s = buf;
5403 if (p == 0 || len < 12)
5404 {
5405 *s = 0;
5406 return s;
5407 }
5408 #if 0
5409 if (display && p == D_fore)
5410 *s++ = '*';
5411 if (display && p == D_other)
5412 *s++ = '-';
5413 #endif
5414 if (p->w_layer.l_cvlist && p->w_layer.l_cvlist->c_lnext)
5415 *s++ = '&';
5416 if (p->w_monitor == MON_DONE
5417 #ifdef MULTIUSER
5418 && (ACLBYTE(p->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5419 #endif
5420 )
5421 *s++ = '@';
5422 if (p->w_bell == BELL_DONE)
5423 *s++ = '!';
5424 #ifdef UTMPOK
5425 if (p->w_slot != (slot_t) 0 && p->w_slot != (slot_t) -1)
5426 *s++ = '$';
5427 #endif
5428 if (p->w_log != 0)
5429 {
5430 strcpy(s, "(L)");
5431 s += 3;
5432 }
5433 if (p->w_ptyfd < 0 && p->w_type != W_TYPE_GROUP)
5434 *s++ = 'Z';
5435 *s = 0;
5436 return s;
5437 }
5438
5439 char *
5440 AddOtherUsers(buf, len, p)
5441 char *buf;
5442 int len;
5443 struct win *p;
5444 {
5445 struct display *d, *olddisplay = display;
5446 struct canvas *cv;
5447 char *s;
5448 int l;
5449
5450 s = buf;
5451 for (display = displays; display; display = display->d_next)
5452 {
5453 if (olddisplay && D_user == olddisplay->d_user)
5454 continue;
5455 for (cv = D_cvlist; cv; cv = cv->c_next)
5456 if (Layer2Window(cv->c_layer) == p)
5457 break;
5458 if (!cv)
5459 continue;
5460 for (d = displays; d && d != display; d = d->d_next)
5461 if (D_user == d->d_user)
5462 break;
5463 if (d && d != display)
5464 continue;
5465 if (len > 1 && s != buf)
5466 {
5467 *s++ = ',';
5468 len--;
5469 }
5470 l = strlen(D_user->u_name);
5471 if (l + 1 > len)
5472 break;
5473 strcpy(s, D_user->u_name);
5474 s += l;
5475 len -= l;
5476 }
5477 *s = 0;
5478 display = olddisplay;
5479 return s;
5480 }
5481
5482 void
5483 ShowWindows(where)
5484 int where;
5485 {
5486 char buf[1024];
5487 char *s, *ss;
5488
5489 if (!display)
5490 return;
5491 if (where == -1 && D_fore)
5492 where = D_fore->w_number;
5493 ss = AddWindows(buf, sizeof(buf), 0, where);
5494 s = buf + strlen(buf);
5495 if (ss - buf > D_width / 2)
5496 {
5497 ss -= D_width / 2;
5498 if (s - ss < D_width)
5499 {
5500 ss = s - D_width;
5501 if (ss < buf)
5502 ss = buf;
5503 }
5504 }
5505 else
5506 ss = buf;
5507 Msg(0, "%s", ss);
5508 }
5509
5510 static void
5511 ShowInfo()
5512 {
5513 char buf[512], *p;
5514 register struct win *wp = fore;
5515 register int i;
5516
5517 if (wp == 0)
5518 {
5519 Msg(0, "(%d,%d)/(%d,%d) no window", D_x + 1, D_y + 1, D_width, D_height);
5520 return;
5521 }
5522 p = buf;
5523 if (buf < (p += GetAnsiStatus(wp, p)))
5524 *p++ = ' ';
5525 sprintf(p, "(%d,%d)/(%d,%d)",
5526 wp->w_x + 1, wp->w_y + 1, wp->w_width, wp->w_height);
5527 #ifdef COPY_PASTE
5528 sprintf(p += strlen(p), "+%d", wp->w_histheight);
5529 #endif
5530 sprintf(p += strlen(p), " %c%sflow",
5531 (wp->w_flow & FLOW_NOW) ? '+' : '-',
5532 (wp->w_flow & FLOW_AUTOFLAG) ? "" :
5533 ((wp->w_flow & FLOW_AUTO) ? "(+)" : "(-)"));
5534 if (!wp->w_wrap) sprintf(p += strlen(p), " -wrap");
5535 if (wp->w_insert) sprintf(p += strlen(p), " ins");
5536 if (wp->w_origin) sprintf(p += strlen(p), " org");
5537 if (wp->w_keypad) sprintf(p += strlen(p), " app");
5538 if (wp->w_log) sprintf(p += strlen(p), " log");
5539 if (wp->w_monitor != MON_OFF
5540 #ifdef MULTIUSER
5541 && (ACLBYTE(wp->w_mon_notify, D_user->u_id) & ACLBIT(D_user->u_id))
5542 #endif
5543 )
5544 sprintf(p += strlen(p), " mon");
5545 if (wp->w_mouse) sprintf(p += strlen(p), " mouse");
5546 #ifdef COLOR
5547 if (wp->w_bce) sprintf(p += strlen(p), " bce");
5548 #endif
5549 if (!wp->w_c1) sprintf(p += strlen(p), " -c1");
5550 if (wp->w_norefresh) sprintf(p += strlen(p), " nored");
5551
5552 p += strlen(p);
5553 #ifdef FONT
5554 # ifdef ENCODINGS
5555 if (wp->w_encoding && (display == 0 || D_encoding != wp->w_encoding || EncodingDefFont(wp->w_encoding) <= 0))
5556 {
5557 *p++ = ' ';
5558 strcpy(p, EncodingName(wp->w_encoding));
5559 p += strlen(p);
5560 }
5561 # ifdef UTF8
5562 if (wp->w_encoding != UTF8)
5563 # endif
5564 # endif
5565 if (D_CC0 || (D_CS0 && *D_CS0))
5566 {
5567 if (wp->w_gr == 2)
5568 {
5569 sprintf(p, " G%c", wp->w_Charset + '0');
5570 if (wp->w_FontE >= ' ')
5571 p[3] = wp->w_FontE;
5572 else
5573 {
5574 p[3] = '^';
5575 p[4] = wp->w_FontE ^ 0x40;
5576 p++;
5577 }
5578 p[4] = '[';
5579 p++;
5580 }
5581 else if (wp->w_gr)
5582 sprintf(p++, " G%c%c[", wp->w_Charset + '0', wp->w_CharsetR + '0');
5583 else
5584 sprintf(p, " G%c[", wp->w_Charset + '0');
5585 p += 4;
5586 for (i = 0; i < 4; i++)
5587 {
5588 if (wp->w_charsets[i] == ASCII)
5589 *p++ = 'B';
5590 else if (wp->w_charsets[i] >= ' ')
5591 *p++ = wp->w_charsets[i];
5592 else
5593 {
5594 *p++ = '^';
5595 *p++ = wp->w_charsets[i] ^ 0x40;
5596 }
5597 }
5598 *p++ = ']';
5599 *p = 0;
5600 }
5601 #endif
5602
5603 if (wp->w_type == W_TYPE_PLAIN)
5604 {
5605 /* add info about modem control lines */
5606 *p++ = ' ';
5607 TtyGetModemStatus(wp->w_ptyfd, p);
5608 }
5609 #ifdef BUILTIN_TELNET
5610 else if (wp->w_type == W_TYPE_TELNET)
5611 {
5612 *p++ = ' ';
5613 TelStatus(wp, p, sizeof(buf) - 1 - (p - buf));
5614 }
5615 #endif
5616 Msg(0, "%s %d(%s)", buf, wp->w_number, wp->w_title);
5617 }
5618
5619 static void
5620 ShowDInfo()
5621 {
5622 char buf[512], *p;
5623 if (display == 0)
5624 return;
5625 p = buf;
5626 sprintf(p, "(%d,%d)", D_width, D_height),
5627 p += strlen(p);
5628 #ifdef ENCODINGS
5629 if (D_encoding)
5630 {
5631 *p++ = ' ';
5632 strcpy(p, EncodingName(D_encoding));
5633 p += strlen(p);
5634 }
5635 #endif
5636 if (D_CXT)
5637 {
5638 strcpy(p, " xterm");
5639 p += strlen(p);
5640 }
5641 #ifdef COLOR
5642 if (D_hascolor)
5643 {
5644 strcpy(p, " color");
5645 p += strlen(p);
5646 }
5647 #endif
5648 #ifdef FONT
5649 if (D_CG0)
5650 {
5651 strcpy(p, " iso2022");
5652 p += strlen(p);
5653 }
5654 else if (D_CS0 && *D_CS0)
5655 {
5656 strcpy(p, " altchar");
5657 p += strlen(p);
5658 }
5659 #endif
5660 Msg(0, "%s", buf);
5661 }
5662
5663 static void
5664 AKAfin(buf, len, data)
5665 char *buf;
5666 int len;
5667 char *data; /* dummy */
5668 {
5669 ASSERT(display);
5670 if (len && fore)
5671 ChangeAKA(fore, buf, strlen(buf));
5672 }
5673
5674 static void
5675 InputAKA()
5676 {
5677 char *s, *ss;
5678 int n;
5679 Input("Set window's title to: ", sizeof(fore->w_akabuf) - 1, INP_COOKED, AKAfin, NULL, 0);
5680 s = fore->w_title;
5681 if (!s)
5682 return;
5683 for (; *s; s++)
5684 {
5685 if ((*(unsigned char *)s & 0x7f) < 0x20 || *s == 0x7f)
5686 continue;
5687 ss = s;
5688 n = 1;
5689 LayProcess(&ss, &n);
5690 }
5691 }
5692
5693 static void
5694 Colonfin(buf, len, data)
5695 char *buf;
5696 int len;
5697 char *data; /* dummy */
5698 {
5699 char mbuf[256];
5700
5701 RemoveStatus();
5702 if (buf[len] == '\t')
5703 {
5704 int m, x;
5705 int l = 0, r = RC_LAST;
5706 int showmessage = 0;
5707 char *s = buf;
5708
5709 while (*s && s - buf < len)
5710 if (*s++ == ' ')
5711 return;
5712
5713 /* Showing a message when there's no hardstatus or caption cancels the input */
5714 if (display &&
5715 (captionalways || D_has_hstatus == HSTATUS_LASTLINE || (D_canvas.c_slperp && D_canvas.c_slperp->c_slnext)))
5716 showmessage = 1;
5717
5718 while (l <= r)
5719 {
5720 m = (l + r) / 2;
5721 x = strncmp(buf, comms[m].name, len);
5722 if (x > 0)
5723 l = m + 1;
5724 else if (x < 0)
5725 r = m - 1;
5726 else
5727 {
5728 s = mbuf;
5729 for (l = m - 1; l >= 0 && strncmp(buf, comms[l].name, len) == 0; l--)
5730 ;
5731 for (m = ++l; m <= r && strncmp(buf, comms[m].name, len) == 0 && s - mbuf < sizeof(mbuf); m++)
5732 s += snprintf(s, sizeof(mbuf) - (s - mbuf), " %s", comms[m].name);
5733 if (l < m - 1)
5734 {
5735 if (showmessage)
5736 Msg(0, "Possible commands:%s", mbuf);
5737 }
5738 else
5739 {
5740 s = mbuf;
5741 len = snprintf(mbuf, sizeof(mbuf), "%s \t", comms[l].name + len);
5742 if (len > 0 && len < sizeof(mbuf))
5743 LayProcess(&s, &len);
5744 }
5745 break;
5746 }
5747 }
5748 if (l > r && showmessage)
5749 Msg(0, "No commands matching '%*s'", len, buf);
5750 return;
5751 }
5752
5753 if (!len || buf[len])
5754 return;
5755
5756 len = strlen(buf) + 1;
5757 if (len > (int)sizeof(mbuf))
5758 RcLine(buf, len);
5759 else
5760 {
5761 bcopy(buf, mbuf, len);
5762 RcLine(mbuf, sizeof mbuf);
5763 }
5764 }
5765
5766 static void
5767 SelectFin(buf, len, data)
5768 char *buf;
5769 int len;
5770 char *data; /* dummy */
5771 {
5772 int n;
5773
5774 if (!len || !display)
5775 return;
5776 if (len == 1 && *buf == '-')
5777 {
5778 SetForeWindow((struct win *)0);
5779 Activate(0);
5780 return;
5781 }
5782 if ((n = WindowByNoN(buf)) < 0)
5783 return;
5784 SwitchWindow(n);
5785 }
5786
5787 static void
5788 SelectLayoutFin(buf, len, data)
5789 char *buf;
5790 int len;
5791 char *data; /* dummy */
5792 {
5793 struct layout *lay;
5794
5795 if (!len || !display)
5796 return;
5797 if (len == 1 && *buf == '-')
5798 {
5799 LoadLayout((struct layout *)0, (struct canvas *)0);
5800 Activate(0);
5801 return;
5802 }
5803 lay = FindLayout(buf);
5804 if (!lay)
5805 Msg(0, "No such layout\n");
5806 else if (lay == D_layout)
5807 Msg(0, "This IS layout %d (%s).\n", lay->lay_number, lay->lay_title);
5808 else
5809 {
5810 LoadLayout(lay, &D_canvas);
5811 Activate(0);
5812 }
5813 }
5814
5815
5816 static void
5817 InputSelect()
5818 {
5819 Input("Switch to window: ", 20, INP_COOKED, SelectFin, NULL, 0);
5820 }
5821
5822 static char setenv_var[31];
5823
5824
5825 static void
5826 SetenvFin1(buf, len, data)
5827 char *buf;
5828 int len;
5829 char *data; /* dummy */
5830 {
5831 if (!len || !display)
5832 return;
5833 InputSetenv(buf);
5834 }
5835
5836 static void
5837 SetenvFin2(buf, len, data)
5838 char *buf;
5839 int len;
5840 char *data; /* dummy */
5841 {
5842 if (!len || !display)
5843 return;
5844 debug2("SetenvFin2: setenv '%s' '%s'\n", setenv_var, buf);
5845 xsetenv(setenv_var, buf);
5846 MakeNewEnv();
5847 }
5848
5849 static void
5850 InputSetenv(arg)
5851 char *arg;
5852 {
5853 static char setenv_buf[50 + sizeof(setenv_var)]; /* need to be static here, cannot be freed */
5854
5855 if (arg)
5856 {
5857 strncpy(setenv_var, arg, sizeof(setenv_var) - 1);
5858 sprintf(setenv_buf, "Enter value for %s: ", setenv_var);
5859 Input(setenv_buf, 30, INP_COOKED, SetenvFin2, NULL, 0);
5860 }
5861 else
5862 Input("Setenv: Enter variable name: ", 30, INP_COOKED, SetenvFin1, NULL, 0);
5863 }
5864
5865 /*
5866 * the following options are understood by this parser:
5867 * -f, -f0, -f1, -fy, -fa
5868 * -t title, -T terminal-type, -h height-of-scrollback,
5869 * -ln, -l0, -ly, -l1, -l
5870 * -a, -M, -L
5871 */
5872 void
5873 DoScreen(fn, av)
5874 char *fn, **av;
5875 {
5876 struct NewWindow nwin;
5877 register int num;
5878 char buf[20];
5879
5880 nwin = nwin_undef;
5881 while (av && *av && av[0][0] == '-')
5882 {
5883 if (av[0][1] == '-')
5884 {
5885 av++;
5886 break;
5887 }
5888 switch (av[0][1])
5889 {
5890 case 'f':
5891 switch (av[0][2])
5892 {
5893 case 'n':
5894 case '0':
5895 nwin.flowflag = FLOW_NOW * 0;
5896 break;
5897 case 'y':
5898 case '1':
5899 case '\0':
5900 nwin.flowflag = FLOW_NOW * 1;
5901 break;
5902 case 'a':
5903 nwin.flowflag = FLOW_AUTOFLAG;
5904 break;
5905 default:
5906 break;
5907 }
5908 break;
5909 case 't': /* no more -k */
5910 if (av[0][2])
5911 nwin.aka = &av[0][2];
5912 else if (*++av)
5913 nwin.aka = *av;
5914 else
5915 --av;
5916 break;
5917 case 'T':
5918 if (av[0][2])
5919 nwin.term = &av[0][2];
5920 else if (*++av)
5921 nwin.term = *av;
5922 else
5923 --av;
5924 break;
5925 case 'h':
5926 if (av[0][2])
5927 nwin.histheight = atoi(av[0] + 2);
5928 else if (*++av)
5929 nwin.histheight = atoi(*av);
5930 else
5931 --av;
5932 break;
5933 #ifdef LOGOUTOK
5934 case 'l':
5935 switch (av[0][2])
5936 {
5937 case 'n':
5938 case '0':
5939 nwin.lflag = 0;
5940 break;
5941 case 'y':
5942 case '1':
5943 case '\0':
5944 nwin.lflag = 1;
5945 break;
5946 case 'a':
5947 nwin.lflag = 3;
5948 break;
5949 default:
5950 break;
5951 }
5952 break;
5953 #endif
5954 case 'a':
5955 nwin.aflag = 1;
5956 break;
5957 case 'M':
5958 nwin.monitor = MON_ON;
5959 break;
5960 case 'L':
5961 nwin.Lflag = 1;
5962 break;
5963 default:
5964 Msg(0, "%s: screen: invalid option -%c.", fn, av[0][1]);
5965 break;
5966 }
5967 ++av;
5968 }
5969 num = 0;
5970 if (av && *av && IsNumColon(*av, 10, buf, sizeof(buf)))
5971 {
5972 if (*buf != '\0')
5973 nwin.aka = buf;
5974 num = atoi(*av);
5975 if (num < 0 || num > MAXWIN - 1)
5976 {
5977 Msg(0, "%s: illegal screen number %d.", fn, num);
5978 num = 0;
5979 }
5980 nwin.StartAt = num;
5981 ++av;
5982 }
5983 if (av && *av)
5984 {
5985 nwin.args = av;
5986 if (!nwin.aka)
5987 nwin.aka = Filename(*av);
5988 }
5989 MakeWindow(&nwin);
5990 }
5991
5992 #ifdef COPY_PASTE
5993 /*
5994 * CompileKeys must be called before Markroutine is first used.
5995 * to initialise the keys with defaults, call CompileKeys(NULL, mark_key_tab);
5996 *
5997 * s is an ascii string in a termcap-like syntax. It looks like
5998 * "j=u:k=d:l=r:h=l: =.:" and so on...
5999 * this example rebinds the cursormovement to the keys u (up), d (down),
6000 * l (left), r (right). placing a mark will now be done with ".".
6001 */
6002 int
6003 CompileKeys(s, sl, array)
6004 char *s;
6005 int sl;
6006 unsigned char *array;
6007 {
6008 int i;
6009 unsigned char key, value;
6010
6011 if (sl == 0)
6012 {
6013 for (i = 0; i < 256; i++)
6014 array[i] = i;
6015 return 0;
6016 }
6017 debug1("CompileKeys: '%s'\n", s);
6018 while (sl)
6019 {
6020 key = *(unsigned char *)s++;
6021 if (*s != '=' || sl < 3)
6022 return -1;
6023 sl--;
6024 do
6025 {
6026 s++;
6027 sl -= 2;
6028 value = *(unsigned char *)s++;
6029 array[value] = key;
6030 }
6031 while (*s == '=' && sl >= 2);
6032 if (sl == 0)
6033 break;
6034 if (*s++ != ':')
6035 return -1;
6036 sl--;
6037 }
6038 return 0;
6039 }
6040 #endif /* COPY_PASTE */
6041
6042 /*
6043 * Asynchronous input functions
6044 */
6045
6046 #if defined(DETACH) && defined(POW_DETACH)
6047 static void
6048 pow_detach_fn(buf, len, data)
6049 char *buf;
6050 int len;
6051 char *data; /* dummy */
6052 {
6053 debug("pow_detach_fn called\n");
6054 if (len)
6055 {
6056 *buf = 0;
6057 return;
6058 }
6059 if (ktab[(int)(unsigned char)*buf].nr != RC_POW_DETACH)
6060 {
6061 if (display)
6062 write(D_userfd, "\007", 1);
6063 Msg(0, "Detach aborted.");
6064 }
6065 else
6066 Detach(D_POWER);
6067 }
6068 #endif /* POW_DETACH */
6069
6070 #ifdef COPY_PASTE
6071 static void
6072 copy_reg_fn(buf, len, data)
6073 char *buf;
6074 int len;
6075 char *data; /* dummy */
6076 {
6077 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6078
6079 if (len)
6080 {
6081 *buf = 0;
6082 return;
6083 }
6084 if (pp->buf)
6085 free(pp->buf);
6086 pp->buf = 0;
6087 pp->len = 0;
6088 if (D_user->u_plop.len)
6089 {
6090 if ((pp->buf = (char *)malloc(D_user->u_plop.len)) == NULL)
6091 {
6092 Msg(0, strnomem);
6093 return;
6094 }
6095 bcopy(D_user->u_plop.buf, pp->buf, D_user->u_plop.len);
6096 }
6097 pp->len = D_user->u_plop.len;
6098 #ifdef ENCODINGS
6099 pp->enc = D_user->u_plop.enc;
6100 #endif
6101 Msg(0, "Copied %d characters into register %c", D_user->u_plop.len, *buf);
6102 }
6103
6104 static void
6105 ins_reg_fn(buf, len, data)
6106 char *buf;
6107 int len;
6108 char *data; /* dummy */
6109 {
6110 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6111
6112 if (len)
6113 {
6114 *buf = 0;
6115 return;
6116 }
6117 if (!fore)
6118 return; /* Input() should not call us w/o fore, but you never know... */
6119 if (*buf == '.')
6120 Msg(0, "ins_reg_fn: Warning: pasting real register '.'!");
6121 if (pp->buf)
6122 {
6123 MakePaster(&fore->w_paster, pp->buf, pp->len, 0);
6124 return;
6125 }
6126 Msg(0, "Empty register.");
6127 }
6128 #endif /* COPY_PASTE */
6129
6130 static void
6131 process_fn(buf, len, data)
6132 char *buf;
6133 int len;
6134 char *data; /* dummy */
6135 {
6136 struct plop *pp = plop_tab + (int)(unsigned char)*buf;
6137
6138 if (len)
6139 {
6140 *buf = 0;
6141 return;
6142 }
6143 if (pp->buf)
6144 {
6145 ProcessInput(pp->buf, pp->len);
6146 return;
6147 }
6148 Msg(0, "Empty register.");
6149 }
6150
6151 static void
6152 confirm_fn(buf, len, data)
6153 char *buf;
6154 int len;
6155 char *data;
6156 {
6157 struct action act;
6158
6159 if (len || (*buf != 'y' && *buf != 'Y'))
6160 {
6161 *buf = 0;
6162 return;
6163 }
6164 act.nr = *(int *)data;
6165 act.args = noargs;
6166 act.argl = 0;
6167 DoAction(&act, -1);
6168 }
6169
6170 #ifdef MULTIUSER
6171 struct inputsu
6172 {
6173 struct acluser **up;
6174 char name[24];
6175 char pw1[130]; /* FreeBSD crypts to 128 bytes */
6176 char pw2[130];
6177 };
6178
6179 static void
6180 su_fin(buf, len, data)
6181 char *buf;
6182 int len;
6183 char *data;
6184 {
6185 struct inputsu *i = (struct inputsu *)data;
6186 char *p;
6187 int l;
6188
6189 if (!*i->name)
6190 { p = i->name; l = sizeof(i->name) - 1; }
6191 else if (!*i->pw1)
6192 { strcpy(p = i->pw1, "\377"); l = sizeof(i->pw1) - 1; }
6193 else
6194 { strcpy(p = i->pw2, "\377"); l = sizeof(i->pw2) - 1; }
6195 if (buf && len)
6196 strncpy(p, buf, 1 + (l < len) ? l : len);
6197 if (!*i->name)
6198 Input("Screen User: ", sizeof(i->name) - 1, INP_COOKED, su_fin, (char *)i, 0);
6199 else if (!*i->pw1)
6200 Input("User's UNIX Password: ", sizeof(i->pw1)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6201 else if (!*i->pw2)
6202 Input("User's Screen Password: ", sizeof(i->pw2)-1, INP_COOKED|INP_NOECHO, su_fin, (char *)i, 0);
6203 else
6204 {
6205 if ((p = DoSu(i->up, i->name, i->pw2, i->pw1)))
6206 Msg(0, "%s", p);
6207 free((char *)i);
6208 }
6209 }
6210
6211 static int
6212 InputSu(w, up, name)
6213 struct win *w;
6214 struct acluser **up;
6215 char *name;
6216 {
6217 struct inputsu *i;
6218
6219 if (!(i = (struct inputsu *)calloc(1, sizeof(struct inputsu))))
6220 return -1;
6221
6222 i->up = up;
6223 if (name && *name)
6224 su_fin(name, (int)strlen(name), (char *)i); /* can also initialise stuff */
6225 else
6226 su_fin((char *)0, 0, (char *)i);
6227 return 0;
6228 }
6229 #endif /* MULTIUSER */
6230
6231 #ifdef PASSWORD
6232
6233 static void
6234 pass1(buf, len, data)
6235 char *buf;
6236 int len;
6237 char *data;
6238 {
6239 struct acluser *u = (struct acluser *)data;
6240
6241 if (!*buf)
6242 return;
6243 ASSERT(u);
6244 if (u->u_password != NullStr)
6245 free((char *)u->u_password);
6246 u->u_password = SaveStr(buf);
6247 bzero(buf, strlen(buf));
6248 Input("Retype new password:", 100, INP_NOECHO, pass2, data, 0);
6249 }
6250
6251 static void
6252 pass2(buf, len, data)
6253 char *buf;
6254 int len;
6255 char *data;
6256 {
6257 int st;
6258 char salt[3];
6259 struct acluser *u = (struct acluser *)data;
6260
6261 ASSERT(u);
6262 if (!buf || strcmp(u->u_password, buf))
6263 {
6264 Msg(0, "[ Passwords don't match - checking turned off ]");
6265 if (u->u_password != NullStr)
6266 {
6267 bzero(u->u_password, strlen(u->u_password));
6268 free((char *)u->u_password);
6269 }
6270 u->u_password = NullStr;
6271 }
6272 else if (u->u_password[0] == '\0')
6273 {
6274 Msg(0, "[ No password - no secure ]");
6275 if (buf)
6276 bzero(buf, strlen(buf));
6277 }
6278
6279 if (u->u_password != NullStr)
6280 {
6281 for (st = 0; st < 2; st++)
6282 salt[st] = 'A' + (int)((time(0) >> 6 * st) % 26);
6283 salt[2] = 0;
6284 buf = crypt(u->u_password, salt);
6285 bzero(u->u_password, strlen(u->u_password));
6286 free((char *)u->u_password);
6287 u->u_password = SaveStr(buf);
6288 bzero(buf, strlen(buf));
6289 #ifdef COPY_PASTE
6290 if (u->u_plop.buf)
6291 UserFreeCopyBuffer(u);
6292 u->u_plop.len = strlen(u->u_password);
6293 # ifdef ENCODINGS
6294 u->u_plop.enc = 0;
6295 #endif
6296 if (!(u->u_plop.buf = SaveStr(u->u_password)))
6297 {
6298 Msg(0, strnomem);
6299 D_user->u_plop.len = 0;
6300 }
6301 else
6302 Msg(0, "[ Password moved into copybuffer ]");
6303 #else /* COPY_PASTE */
6304 Msg(0, "[ Crypted password is \"%s\" ]", u->u_password);
6305 #endif /* COPY_PASTE */
6306 }
6307 }
6308 #endif /* PASSWORD */
6309
6310 static void
6311 digraph_fn(buf, len, data)
6312 char *buf;
6313 int len;
6314 char *data; /* dummy */
6315 {
6316 int ch, i, x;
6317
6318 ch = buf[len];
6319 if (ch)
6320 {
6321 buf[len + 1] = ch; /* so we can restore it later */
6322 if (ch < ' ' || ch == '\177')
6323 return;
6324 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
6325 {
6326 if (len == 1)
6327 return;
6328 if ((ch < '0' || ch > '9') && (ch < 'a' || ch > 'f') && (ch < 'A' || ch > 'F'))
6329 {
6330 buf[len] = '\034'; /* ^] is ignored by Input() */
6331 return;
6332 }
6333 if (len == (*buf == 'U' ? 5 : 3))
6334 buf[len] = '\n';
6335 return;
6336 }
6337 if (len && *buf == '0')
6338 {
6339 if (ch < '0' || ch > '7')
6340 {
6341 buf[len] = '\034'; /* ^] is ignored by Input() */
6342 return;
6343 }
6344 if (len == 3)
6345 buf[len] = '\n';
6346 return;
6347 }
6348 if (len == 1)
6349 buf[len] = '\n';
6350 return;
6351 }
6352 if (len < 1)
6353 return;
6354 if (buf[len + 1])
6355 {
6356 buf[len] = buf[len + 1]; /* stored above */
6357 len++;
6358 }
6359 if (len < 2)
6360 return;
6361 if (len >= 1 && ((*buf == 'U' && buf[1] == '+') || (*buf == '0' && (buf[1] == 'x' || buf[1] == 'X'))))
6362 {
6363 x = 0;
6364 for (i = 2; i < len; i++)
6365 {
6366 if (buf[i] >= '0' && buf[i] <= '9')
6367 x = x * 16 | (buf[i] - '0');
6368 else if (buf[i] >= 'a' && buf[i] <= 'f')
6369 x = x * 16 | (buf[i] - ('a' - 10));
6370 else if (buf[i] >= 'A' && buf[i] <= 'F')
6371 x = x * 16 | (buf[i] - ('A' - 10));
6372 else
6373 break;
6374 }
6375 }
6376 else if (buf[0] == '0')
6377 {
6378 x = 0;
6379 for (i = 1; i < len; i++)
6380 {
6381 if (buf[i] < '0' || buf[i] > '7')
6382 break;
6383 x = x * 8 | (buf[i] - '0');
6384 }
6385 }
6386 else
6387 {
6388 for (i = 0; i < (int)(sizeof(digraphs)/sizeof(*digraphs)); i++)
6389 if ((digraphs[i][0] == (unsigned char)buf[0] && digraphs[i][1] == (unsigned char)buf[1]) ||
6390 (digraphs[i][0] == (unsigned char)buf[1] && digraphs[i][1] == (unsigned char)buf[0]))
6391 break;
6392 if (i == (int)(sizeof(digraphs)/sizeof(*digraphs)))
6393 {
6394 Msg(0, "Unknown digraph");
6395 return;
6396 }
6397 x = digraphs[i][2];
6398 }
6399 i = 1;
6400 *buf = x;
6401 #ifdef UTF8
6402 if (flayer->l_encoding == UTF8)
6403 i = ToUtf8(buf, x); /* buf is big enough for all UTF-8 codes */
6404 #endif
6405 while(i)
6406 LayProcess(&buf, &i);
6407 }
6408
6409 #ifdef MAPKEYS
6410 int
6411 StuffKey(i)
6412 int i;
6413 {
6414 struct action *act;
6415 int discard = 0;
6416
6417 debug1("StuffKey #%d", i);
6418 #ifdef DEBUG
6419 if (i < KMAP_KEYS)
6420 debug1(" - %s", term[i + T_CAPS].tcname);
6421 #endif
6422
6423 if (i < KMAP_KEYS && D_ESCseen)
6424 {
6425 struct action *act = &D_ESCseen[i + 256];
6426 if (act->nr != RC_ILLEGAL)
6427 {
6428 D_ESCseen = 0;
6429 DoAction(act, i + 256);
6430 return 0;
6431 }
6432 discard = 1;
6433 }
6434
6435 if (i >= T_CURSOR - T_CAPS && i < T_KEYPAD - T_CAPS && D_cursorkeys)
6436 i += T_OCAPS - T_CURSOR;
6437 else if (i >= T_KEYPAD - T_CAPS && i < T_OCAPS - T_CAPS && D_keypad)
6438 i += T_OCAPS - T_CURSOR;
6439 debug1(" - action %d\n", i);
6440 flayer = D_forecv->c_layer;
6441 fore = D_fore;
6442 act = 0;
6443 #ifdef COPY_PASTE
6444 if (InMark() || InInput() || InWList())
6445 act = i < KMAP_KEYS+KMAP_AKEYS ? &mmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].mm;
6446 #endif
6447 if ((!act || act->nr == RC_ILLEGAL) && !D_mapdefault)
6448 act = i < KMAP_KEYS+KMAP_AKEYS ? &umtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].um;
6449 if (!act || act->nr == RC_ILLEGAL)
6450 act = i < KMAP_KEYS+KMAP_AKEYS ? &dmtab[i] : &kmap_exts[i - (KMAP_KEYS+KMAP_AKEYS)].dm;
6451
6452 if (discard && (!act || act->nr != RC_COMMAND))
6453 {
6454 D_ESCseen = 0;
6455 return 0;
6456 }
6457 D_mapdefault = 0;
6458
6459 if (act == 0 || act->nr == RC_ILLEGAL)
6460 return -1;
6461 DoAction(act, 0);
6462 return 0;
6463 }
6464 #endif
6465
6466
6467 static int
6468 IsOnDisplay(wi)
6469 struct win *wi;
6470 {
6471 struct canvas *cv;
6472 ASSERT(display);
6473 for (cv = D_cvlist; cv; cv = cv->c_next)
6474 if (Layer2Window(cv->c_layer) == wi)
6475 return 1;
6476 return 0;
6477 }
6478
6479 struct win *
6480 FindNiceWindow(wi, presel)
6481 struct win *wi;
6482 char *presel;
6483 {
6484 int i;
6485
6486 debug2("FindNiceWindow %d %s\n", wi ? wi->w_number : -1 , presel ? presel : "NULL");
6487 if (presel)
6488 {
6489 i = WindowByNoN(presel);
6490 if (i >= 0)
6491 wi = wtab[i];
6492 }
6493 if (!display)
6494 return wi;
6495 #ifdef MULTIUSER
6496 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6497 wi = 0;
6498 #endif
6499 if (!wi || (IsOnDisplay(wi) && !presel))
6500 {
6501 /* try to get another window */
6502 wi = 0;
6503 #ifdef MULTIUSER
6504 for (wi = windows; wi; wi = wi->w_next)
6505 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6506 break;
6507 if (!wi)
6508 for (wi = windows; wi; wi = wi->w_next)
6509 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_WRITE, wi))
6510 break;
6511 if (!wi)
6512 for (wi = windows; wi; wi = wi->w_next)
6513 if (!wi->w_layer.l_cvlist && !AclCheckPermWin(D_user, ACL_READ, wi))
6514 break;
6515 if (!wi)
6516 for (wi = windows; wi; wi = wi->w_next)
6517 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi) && !AclCheckPermWin(D_user, ACL_READ, wi))
6518 break;
6519 #endif
6520 if (!wi)
6521 for (wi = windows; wi; wi = wi->w_next)
6522 if (!wi->w_layer.l_cvlist)
6523 break;
6524 if (!wi)
6525 for (wi = windows; wi; wi = wi->w_next)
6526 if (wi->w_layer.l_cvlist && !IsOnDisplay(wi))
6527 break;
6528 }
6529 #ifdef MULTIUSER
6530 if (wi && AclCheckPermWin(D_user, ACL_READ, wi))
6531 wi = 0;
6532 #endif
6533 return wi;
6534 }
6535
6536 /**
6537 * Add an alias
6538 */
6539 void
6540 AddAlias(name, value, args, argl, count)
6541 const char *name;
6542 const char *value;
6543 char **args;
6544 int *argl;
6545 int count;
6546 {
6547 struct alias *nalias = NULL;
6548 static next_command = RC_LAST;
6549 int nr;
6550
6551 /* Make sure we don't already have this alias name defined. */
6552 if (FindAlias(name) != NULL)
6553 {
6554 Msg(0, "alias already defined: %s", name);
6555 return;
6556 }
6557
6558 /* Make sure the alias maps to something */
6559 if ((nr = FindCommnr((char *)value)) == RC_ILLEGAL)
6560 {
6561 struct alias *alias = FindAlias(value);
6562 if (!alias)
6563 {
6564 Msg(0, "%s: could not find command or alias '%s'", rc_name, value);
6565 return;
6566 }
6567 nr = alias->nr;
6568 }
6569
6570 nalias = (struct alias *)calloc(1, sizeof(struct alias));
6571
6572 /* store it */
6573 nalias->next = NULL;
6574 nalias->name = SaveStr(name);
6575 nalias->cmdnr = nr;
6576 if (count > 0)
6577 {
6578 nalias->args = SaveArgs(args);
6579 nalias->argl = calloc(count + 1, sizeof(int));
6580 while (count--)
6581 nalias->argl[count] = argl[count];
6582 }
6583 nalias->nr = ++next_command;
6584
6585 /* Add to head */
6586 nalias->next = g_aliases_list;
6587 g_aliases_list = nalias;
6588 }
6589
6590
6591 /**
6592 * Find an alias by name.
6593 */
6594 static struct alias *
6595 FindAlias(name)
6596 const char *name;
6597 {
6598 struct alias *t = g_aliases_list;
6599
6600 while(t != NULL)
6601 {
6602 if ((t->name != NULL) &&
6603 (strcmp(t->name, name) == 0))
6604 return t;
6605
6606 t = t->next;
6607 }
6608
6609 return NULL;
6610 }
6611
6612 /**
6613 * Find an alias by number.
6614 */
6615 static struct alias *
6616 FindAliasnr(nr)
6617 int nr;
6618 {
6619 struct alias *t;
6620 for (t = g_aliases_list; t; t = t->next)
6621 {
6622 if (t->nr == nr)
6623 return t;
6624 }
6625
6626 return NULL;
6627 }
6628
6629 /**
6630 * Delete an alias
6631 */
6632 void
6633 DelAlias(name)
6634 const char *name;
6635 {
6636 /* Find the previous alias */
6637 struct alias *cur = g_aliases_list;
6638 struct alias **pcur = &g_aliases_list;
6639
6640 while (cur != NULL)
6641 {
6642 if ((cur->name != NULL) &&
6643 (strcmp(cur->name, name) == 0))
6644 {
6645 struct alias *found = cur;
6646 int c;
6647
6648 /* remove this one from the chain. */
6649 *pcur = found->next;
6650
6651 free(found->name);
6652 if (found->args)
6653 {
6654 for (c = 0; found->args[c]; c++)
6655 free(found->args[c]);
6656 free(found->args);
6657 free(found->argl);
6658 }
6659 free(found);
6660
6661 Msg(0, "alias %s removed", name);
6662 return;
6663 }
6664 pcur = &cur->next;
6665 cur = cur->next;
6666 }
6667
6668 Msg(0, "alias %s not found", name);
6669 }
6670
6671 #if 0
6672
6673 /* sorted list of all commands */
6674 static struct comm **commtab;
6675 static int ncommtab;
6676
6677 void
6678 AddComms(cos, hand)
6679 struct comm *cos;
6680 void (*hand) __P((struct comm *, char **, int));
6681 {
6682 int n, i, j, r;
6683 for (n = 0; cos[n].name; n++)
6684 ;
6685 if (n == 0)
6686 return;
6687 if (commtab)
6688 commtab = (struct commt *)realloc(commtab, sizeof(*commtab) * (ncommtab + n));
6689 else
6690 commtab = (struct commt *)malloc(sizeof(*commtab) * (ncommtab + n));
6691 if (!commtab)
6692 Panic(0, strnomem);
6693 for (i = 0; i < n; i++)
6694 {
6695 for (j = 0; j < ncommtab; j++)
6696 {
6697 r = strcmp(cos[i].name, commtab[j]->name);
6698 if (r == 0)
6699 Panic(0, "Duplicate command: %s\n", cos[i].name);
6700 if (r < 0)
6701 break;
6702 }
6703 for (r = ncommtab; r > j; r--)
6704 commtab[r] = commtab[r - 1];
6705 commtab[j] = cos + i;
6706 cos[i].handler = hand;
6707 bzero(cos[i].userbits, sizeof(cos[i].userbits));
6708 ncommtab++;
6709 }
6710 }
6711
6712 struct comm *
6713 FindComm(str)
6714 char *str;
6715 {
6716 int x, m, l = 0, r = ncommtab - 1;
6717 while (l <= r)
6718 {
6719 m = (l + r) / 2;
6720 x = strcmp(str, commtab[m]->name);
6721 if (x > 0)
6722 l = m + 1;
6723 else if (x < 0)
6724 r = m - 1;
6725 else
6726 return commtab[m];
6727 }
6728 return 0;
6729 }
6730
6731 #endif
6732
6733 static int
6734 CalcSlicePercent(cv, percent)
6735 struct canvas *cv;
6736 int percent;
6737 {
6738 int w, wsum, up;
6739 if (!cv || !cv->c_slback)
6740 return percent;
6741 up = CalcSlicePercent(cv->c_slback->c_slback, percent);
6742 w = cv->c_slweight;
6743 for (cv = cv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6744 wsum += cv->c_slweight;
6745 if (wsum == 0)
6746 return 0;
6747 return (up * w) / wsum;
6748 }
6749
6750 static int
6751 ChangeCanvasSize(fcv, abs, diff, gflag, percent)
6752 struct canvas *fcv; /* make this canvas bigger */
6753 int abs; /* mode: 0:rel 1:abs 2:max */
6754 int diff; /* change this much */
6755 int gflag; /* go up if neccessary */
6756 int percent;
6757 {
6758 struct canvas *cv;
6759 int done, have, m, dir;
6760
6761 debug3("ChangeCanvasSize abs %d diff %d percent=%d\n", abs, diff, percent);
6762 if (abs == 0 && diff == 0)
6763 return 0;
6764 if (abs == 2)
6765 {
6766 if (diff == 0)
6767 fcv->c_slweight = 0;
6768 else
6769 {
6770 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6771 cv->c_slweight = 0;
6772 fcv->c_slweight = 1;
6773 cv = fcv->c_slback->c_slback;
6774 if (gflag && cv && cv->c_slback)
6775 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6776 }
6777 return diff;
6778 }
6779 if (abs)
6780 {
6781 if (diff < 0)
6782 diff = 0;
6783 if (percent && diff > percent)
6784 diff = percent;
6785 }
6786 if (percent)
6787 {
6788 int wsum, up;
6789 for (cv = fcv->c_slback->c_slperp, wsum = 0; cv; cv = cv->c_slnext)
6790 wsum += cv->c_slweight;
6791 if (wsum)
6792 {
6793 up = gflag ? CalcSlicePercent(fcv->c_slback->c_slback, percent) : percent;
6794 debug3("up=%d, wsum=%d percent=%d\n", up, wsum, percent);
6795 if (wsum < 1000)
6796 {
6797 int scale = wsum < 10 ? 1000 : 100;
6798 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6799 cv->c_slweight *= scale;
6800 wsum *= scale;
6801 debug1("scaled wsum to %d\n", wsum);
6802 }
6803 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6804 {
6805 if (cv->c_slweight)
6806 {
6807 cv->c_slweight = (cv->c_slweight * up) / percent;
6808 if (cv->c_slweight == 0)
6809 cv->c_slweight = 1;
6810 }
6811 debug1(" - weight %d\n", cv->c_slweight);
6812 }
6813 diff = (diff * wsum) / percent;
6814 percent = wsum;
6815 }
6816 }
6817 else
6818 {
6819 if (abs && diff == (fcv->c_slorient == SLICE_VERT ? fcv->c_ye - fcv->c_ys + 2 : fcv->c_xe - fcv->c_xs + 2))
6820 return 0;
6821 /* fix weights to real size (can't be helped, sorry) */
6822 for (cv = fcv->c_slback->c_slperp; cv; cv = cv->c_slnext)
6823 {
6824 cv->c_slweight = cv->c_slorient == SLICE_VERT ? cv->c_ye - cv->c_ys + 2 : cv->c_xe - cv->c_xs + 2;
6825 debug1(" - weight %d\n", cv->c_slweight);
6826 }
6827 }
6828 if (abs)
6829 diff = diff - fcv->c_slweight;
6830 debug1("diff = %d\n", diff);
6831 if (diff == 0)
6832 return 0;
6833 if (diff < 0)
6834 {
6835 cv = fcv->c_slnext ? fcv->c_slnext : fcv->c_slprev;
6836 fcv->c_slweight += diff;
6837 cv->c_slweight -= diff;
6838 return diff;
6839 }
6840 done = 0;
6841 dir = 1;
6842 for (cv = fcv->c_slnext; diff > 0; cv = dir > 0 ? cv->c_slnext : cv->c_slprev)
6843 {
6844 if (!cv)
6845 {
6846 debug1("reached end, dir is %d\n", dir);
6847 if (dir == -1)
6848 break;
6849 dir = -1;
6850 cv = fcv;
6851 continue;
6852 }
6853 if (percent)
6854 m = 1;
6855 else
6856 m = cv->c_slperp ? CountCanvasPerp(cv) * 2 : 2;
6857 debug2("min is %d, have %d\n", m, cv->c_slweight);
6858 if (cv->c_slweight > m)
6859 {
6860 have = cv->c_slweight - m;
6861 if (have > diff)
6862 have = diff;
6863 debug1("subtract %d\n", have);
6864 cv->c_slweight -= have;
6865 done += have;
6866 diff -= have;
6867 }
6868 }
6869 if (diff && gflag)
6870 {
6871 /* need more room! */
6872 cv = fcv->c_slback->c_slback;
6873 if (cv && cv->c_slback)
6874 done += ChangeCanvasSize(fcv->c_slback->c_slback, 0, diff, gflag, percent);
6875 }
6876 fcv->c_slweight += done;
6877 debug1("ChangeCanvasSize returns %d\n", done);
6878 return done;
6879 }
6880
6881 static void
6882 ResizeRegions(arg, flags)
6883 char *arg;
6884 int flags;
6885 {
6886 struct canvas *cv;
6887 int diff, l;
6888 int gflag = 0, abs = 0, percent = 0;
6889 int orient = 0;
6890
6891 ASSERT(display);
6892 if (!*arg)
6893 return;
6894 if (D_forecv->c_slorient == SLICE_UNKN)
6895 {
6896 Msg(0, "resize: need more than one region");
6897 return;
6898 }
6899 gflag = flags & RESIZE_FLAG_L ? 0 : 1;
6900 orient |= flags & RESIZE_FLAG_H ? SLICE_HORI : 0;
6901 orient |= flags & RESIZE_FLAG_V ? SLICE_VERT : 0;
6902 if (orient == 0)
6903 orient = D_forecv->c_slorient;
6904 l = strlen(arg);
6905 if (*arg == '=')
6906 {
6907 /* make all regions the same height */
6908 struct canvas *cv = gflag ? &D_canvas : D_forecv->c_slback;
6909 if (cv->c_slperp->c_slorient & orient)
6910 EqualizeCanvas(cv->c_slperp, gflag);
6911 /* can't use cv->c_slorient directly as it can be D_canvas */
6912 if ((cv->c_slperp->c_slorient ^ (SLICE_HORI ^ SLICE_VERT)) & orient)
6913 {
6914 if (cv->c_slback)
6915 {
6916 cv = cv->c_slback;
6917 EqualizeCanvas(cv->c_slperp, gflag);
6918 }
6919 else
6920 EqualizeCanvas(cv, gflag);
6921 }
6922 ResizeCanvas(cv);
6923 RecreateCanvasChain();
6924 RethinkDisplayViewports();
6925 ResizeLayersToCanvases();
6926 return;
6927 }
6928 if (!strcmp(arg, "min") || !strcmp(arg, "0"))
6929 {
6930 abs = 2;
6931 diff = 0;
6932 }
6933 else if (!strcmp(arg, "max") || !strcmp(arg, "_"))
6934 {
6935 abs = 2;
6936 diff = 1;
6937 }
6938 else
6939 {
6940 if (l > 0 && arg[l - 1] == '%')
6941 percent = 1000;
6942 if (*arg == '+')
6943 diff = atoi(arg + 1);
6944 else if (*arg == '-')
6945 diff = -atoi(arg + 1);
6946 else
6947 {
6948 diff = atoi(arg); /* +1 because of caption line */
6949 if (diff < 0)
6950 diff = 0;
6951 abs = diff == 0 ? 2 : 1;
6952 }
6953 }
6954 if (!abs && !diff)
6955 return;
6956 if (percent)
6957 diff = diff * percent / 100;
6958 cv = D_forecv;
6959 if (cv->c_slorient & orient)
6960 ChangeCanvasSize(cv, abs, diff, gflag, percent);
6961 if (cv->c_slback->c_slorient & orient)
6962 ChangeCanvasSize(cv->c_slback, abs, diff, gflag, percent);
6963
6964 ResizeCanvas(&D_canvas);
6965 RecreateCanvasChain();
6966 RethinkDisplayViewports();
6967 ResizeLayersToCanvases();
6968 return;
6969
6970 #if 0
6971
6972 if (siz + diff < 1)
6973 diff = 1 - siz;
6974 if (siz + diff > dsize - (nreg - 1) * 2 - 1)
6975 diff = dsize - (nreg - 1) * 2 - 1 - siz;
6976 if (diff == 0 || siz + diff < 1)
6977 return;
6978
6979 if (diff < 0)
6980 {
6981 if (D_forecv->c_next)
6982 {
6983 D_forecv->c_ye += diff;
6984 D_forecv->c_next->c_ys += diff;
6985 D_forecv->c_next->c_yoff += diff;
6986 }
6987 else
6988 {
6989 for (cv = D_cvlist; cv; cv = cv->c_next)
6990 if (cv->c_next == D_forecv)
6991 break;
6992 ASSERT(cv);
6993 cv->c_ye -= diff;
6994 D_forecv->c_ys -= diff;
6995 D_forecv->c_yoff -= diff;
6996 }
6997 }
6998 else
6999 {
7000 int s, i = 0, found = 0, di = diff, d2;
7001 s = dsize - (nreg - 1) * 2 - 1 - siz;
7002 for (cv = D_cvlist; cv; i = cv->c_ye + 2, cv = cv->c_next)
7003 {
7004 if (cv == D_forecv)
7005 {
7006 cv->c_ye = i + (cv->c_ye - cv->c_ys) + diff;
7007 cv->c_yoff -= cv->c_ys - i;
7008 cv->c_ys = i;
7009 found = 1;
7010 continue;
7011 }
7012 s -= cv->c_ye - cv->c_ys;
7013 if (!found)
7014 {
7015 if (s >= di)
7016 continue;
7017 d2 = di - s;
7018 }
7019 else
7020 d2 = di > cv->c_ye - cv->c_ys ? cv->c_ye - cv->c_ys : di;
7021 di -= d2;
7022 cv->c_ye = i + (cv->c_ye - cv->c_ys) - d2;
7023 cv->c_yoff -= cv->c_ys - i;
7024 cv->c_ys = i;
7025 }
7026 }
7027 RethinkDisplayViewports();
7028 ResizeLayersToCanvases();
7029 #endif
7030 }
7031
7032 static void
7033 ResizeFin(buf, len, data)
7034 char *buf;
7035 int len;
7036 char *data;
7037 {
7038 int ch;
7039 int flags = *(int *)data;
7040 ch = ((unsigned char *)buf)[len];
7041 if (ch == 0)
7042 {
7043 ResizeRegions(buf, flags);
7044 return;
7045 }
7046 if (ch == 'h')
7047 flags ^= RESIZE_FLAG_H;
7048 else if (ch == 'v')
7049 flags ^= RESIZE_FLAG_V;
7050 else if (ch == 'b')
7051 flags |= RESIZE_FLAG_H|RESIZE_FLAG_V;
7052 else if (ch == 'p')
7053 flags ^= D_forecv->c_slorient == SLICE_VERT ? RESIZE_FLAG_H : RESIZE_FLAG_V;
7054 else if (ch == 'l')
7055 flags ^= RESIZE_FLAG_L;
7056 else
7057 return;
7058 inp_setprompt(resizeprompts[flags], NULL);
7059 *(int *)data = flags;
7060 buf[len] = '\034';
7061 }
7062
7063 #ifdef RXVT_OSC
7064 void
7065 RefreshXtermOSC()
7066 {
7067 int i;
7068 struct win *p;
7069
7070 p = Layer2Window(D_forecv->c_layer);
7071 for (i = 3; i >=0; i--)
7072 SetXtermOSC(i, p ? p->w_xtermosc[i] : 0);
7073 }
7074 #endif
7075
7076 int
7077 ParseAttrColor(s1, s2, msgok)
7078 char *s1, *s2;
7079 int msgok;
7080 {
7081 int i, n;
7082 char *s, *ss;
7083 int r = 0;
7084
7085 s = s1;
7086 while (*s == ' ')
7087 s++;
7088 ss = s;
7089 while (*ss && *ss != ' ')
7090 ss++;
7091 while (*ss == ' ')
7092 ss++;
7093 if (*s && (s2 || *ss || !((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || *s == '.')))
7094 {
7095 int mode = 0, n = 0;
7096 if (*s == '+')
7097 {
7098 mode = 1;
7099 s++;
7100 }
7101 else if (*s == '-')
7102 {
7103 mode = -1;
7104 s++;
7105 }
7106 else if (*s == '!')
7107 {
7108 mode = 2;
7109 s++;
7110 }
7111 else if (*s == '=')
7112 s++;
7113 if (*s >= '0' && *s <= '9')
7114 {
7115 n = *s++ - '0';
7116 if (*s >= '0' && *s <= '9')
7117 n = n * 16 + (*s++ - '0');
7118 else if (*s >= 'a' && *s <= 'f')
7119 n = n * 16 + (*s++ - ('a' - 10));
7120 else if (*s >= 'A' && *s <= 'F')
7121 n = n * 16 + (*s++ - ('A' - 10));
7122 else if (*s && *s != ' ')
7123 {
7124 if (msgok)
7125 Msg(0, "Illegal attribute hexchar '%c'", *s);
7126 return -1;
7127 }
7128 }
7129 else
7130 {
7131 while (*s && *s != ' ')
7132 {
7133 if (*s == 'd')
7134 n |= A_DI;
7135 else if (*s == 'u')
7136 n |= A_US;
7137 else if (*s == 'b')
7138 n |= A_BD;
7139 else if (*s == 'r')
7140 n |= A_RV;
7141 else if (*s == 's')
7142 n |= A_SO;
7143 else if (*s == 'B')
7144 n |= A_BL;
7145 else
7146 {
7147 if (msgok)
7148 Msg(0, "Illegal attribute specifier '%c'", *s);
7149 return -1;
7150 }
7151 s++;
7152 }
7153 }
7154 if (*s && *s != ' ')
7155 {
7156 if (msgok)
7157 Msg(0, "junk after attribute description: '%c'", *s);
7158 return -1;
7159 }
7160 if (mode == -1)
7161 r = n << 8 | n;
7162 else if (mode == 1)
7163 r = n << 8;
7164 else if (mode == 2)
7165 r = n;
7166 else if (mode == 0)
7167 r = 0xffff ^ n;
7168 }
7169 while (*s && *s == ' ')
7170 s++;
7171
7172 if (s2)
7173 {
7174 if (*s)
7175 {
7176 if (msgok)
7177 Msg(0, "junk after description: '%c'", *s);
7178 return -1;
7179 }
7180 s = s2;
7181 while (*s && *s == ' ')
7182 s++;
7183 }
7184
7185 #ifdef COLOR
7186 if (*s)
7187 {
7188 static char costr[] = "krgybmcw d i.01234567 9 f FKRGYBMCW I ";
7189 int numco = 0, j;
7190
7191 n = 0;
7192 if (*s == '.')
7193 {
7194 numco++;
7195 n = 0x0f;
7196 s++;
7197 }
7198 for (j = 0; j < 2 && *s && *s != ' '; j++)
7199 {
7200 for (i = 0; costr[i]; i++)
7201 if (*s == costr[i])
7202 break;
7203 if (!costr[i])
7204 {
7205 if (msgok)
7206 Msg(0, "illegal color descriptor: '%c'", *s);
7207 return -1;
7208 }
7209 numco++;
7210 n = n << 4 | (i & 15);
7211 #ifdef COLORS16
7212 if (i >= 48)
7213 n = (n & 0x20ff) | 0x200;
7214 #endif
7215 s++;
7216 }
7217 if ((n & 0xf00) == 0xf00)
7218 n ^= 0xf00; /* clear superflous bits */
7219 #ifdef COLORS16
7220 if (n & 0x2000)
7221 n ^= 0x2400; /* shift bit into right position */
7222 #endif
7223 if (numco == 1)
7224 n |= 0xf0; /* don't change bg color */
7225 if (numco != 2 && n != 0xff)
7226 n |= 0x100; /* special invert mode */
7227 if (*s && *s != ' ')
7228 {
7229 if (msgok)
7230 Msg(0, "junk after color description: '%c'", *s);
7231 return -1;
7232 }
7233 n ^= 0xff;
7234 r |= n << 16;
7235 }
7236 #endif
7237
7238 while (*s && *s == ' ')
7239 s++;
7240 if (*s)
7241 {
7242 if (msgok)
7243 Msg(0, "junk after description: '%c'", *s);
7244 return -1;
7245 }
7246 debug1("ParseAttrColor %06x\n", r);
7247 return r;
7248 }
7249
7250 /*
7251 * Color coding:
7252 * 0-7 normal colors
7253 * 9 default color
7254 * e just set intensity
7255 * f don't change anything
7256 * Intensity is encoded into bits 17(fg) and 18(bg).
7257 */
7258 void
7259 ApplyAttrColor(i, mc)
7260 int i;
7261 struct mchar *mc;
7262 {
7263 debug1("ApplyAttrColor %06x\n", i);
7264 mc->attr |= i >> 8 & 255;
7265 mc->attr ^= i & 255;
7266 #ifdef COLOR
7267 i = (i >> 16) ^ 0xff;
7268 if ((i & 0x100) != 0)
7269 {
7270 i &= 0xeff;
7271 if (mc->attr & (A_SO|A_RV))
7272 # ifdef COLORS16
7273 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4) | ((i & 0x200) << 1) | ((i & 0x400) >> 1);
7274 # else
7275 i = ((i & 0x0f) << 4) | ((i & 0xf0) >> 4);
7276 # endif
7277 }
7278 # ifdef COLORS16
7279 if ((i & 0x0f) != 0x0f)
7280 mc->attr = (mc->attr & 0xbf) | ((i >> 3) & 0x40);
7281 if ((i & 0xf0) != 0xf0)
7282 mc->attr = (mc->attr & 0x7f) | ((i >> 3) & 0x80);
7283 # endif
7284 mc->color = 0x99 ^ mc->color;
7285 if ((i & 0x0e) == 0x0e)
7286 i = (i & 0xf0) | (mc->color & 0x0f);
7287 if ((i & 0xe0) == 0xe0)
7288 i = (i & 0x0f) | (mc->color & 0xf0);
7289 mc->color = 0x99 ^ i;
7290 debug2("ApplyAttrColor - %02x %02x\n", mc->attr, i);
7291 #endif
7292 }
Lua scripting support for GNU Screen