1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Edward Wang at The University of California, Berkeley. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)lcmd1.c 8.1 (Berkeley) 6/6/93 37 * $FreeBSD: src/usr.bin/window/lcmd1.c,v 1.2.6.2 2001/05/17 09:45:00 obrien Exp $ 38 * $DragonFly: src/usr.bin/window/lcmd1.c,v 1.4 2005/04/15 17:55:29 drhodus Exp $ 39 */ 40 41 #include "defs.h" 42 #include <string.h> /* System string definitions. */ 43 #include "mystring.h" /* Local string definitions. */ 44 #include "value.h" 45 #include "lcmd.h" 46 #include "var.h" 47 48 struct lcmd_arg arg_window[] = { 49 { "row", 1, ARG_NUM }, 50 { "column", 1, ARG_NUM }, 51 { "nrows", 2, ARG_NUM }, 52 { "ncols", 2, ARG_NUM }, 53 { "nlines", 2, ARG_NUM }, 54 { "label", 1, ARG_STR }, 55 { "pty", 1, ARG_ANY }, 56 { "frame", 1, ARG_ANY }, 57 { "mapnl", 1, ARG_ANY }, 58 { "keepopen", 1, ARG_ANY }, 59 { "smooth", 1, ARG_ANY }, 60 { "shell", 1, ARG_STR|ARG_LIST }, 61 0 62 }; 63 64 l_window(v, a) 65 struct value *v; 66 struct value *a; 67 { 68 struct ww *w; 69 int col, row, ncol, nrow, id, nline; 70 char *label; 71 char haspty, hasframe, mapnl, keepopen, smooth; 72 char *shf, **sh; 73 char *argv[sizeof default_shell / sizeof *default_shell]; 74 char **pp; 75 76 if ((id = findid()) < 0) 77 return; 78 row = a->v_type == V_ERR ? 1 : a->v_num; 79 a++; 80 col = a->v_type == V_ERR ? 0 : a->v_num; 81 a++; 82 nrow = a->v_type == V_ERR ? wwnrow - row : a->v_num; 83 a++; 84 ncol = a->v_type == V_ERR ? wwncol - col : a->v_num; 85 a++; 86 nline = a->v_type == V_ERR ? default_nline : a->v_num; 87 a++; 88 label = a->v_type == V_ERR ? 0 : a->v_str; 89 if ((haspty = vtobool(++a, 1, -1)) < 0) 90 return; 91 if ((hasframe = vtobool(++a, 1, -1)) < 0) 92 return; 93 if ((mapnl = vtobool(++a, !haspty, -1)) < 0) 94 return; 95 if ((keepopen = vtobool(++a, 0, -1)) < 0) 96 return; 97 if ((smooth = vtobool(++a, default_smooth, -1)) < 0) 98 return; 99 if ((++a)->v_type != V_ERR) { 100 for (pp = argv; a->v_type != V_ERR && 101 pp < &argv[sizeof argv/sizeof *argv-1]; pp++, a++) 102 *pp = a->v_str; 103 *pp = 0; 104 shf = *(sh = argv); 105 if (*sh = strrchr(shf, '/')) 106 (*sh)++; 107 else 108 *sh = shf; 109 } else { 110 sh = default_shell; 111 shf = default_shellfile; 112 } 113 if ((w = openwin(id, row, col, nrow, ncol, nline, label, haspty, 114 hasframe, shf, sh)) == 0) 115 return; 116 w->ww_mapnl = mapnl; 117 w->ww_keepopen = keepopen; 118 w->ww_noupdate = !smooth; 119 v->v_type = V_NUM; 120 v->v_num = id + 1; 121 } 122 123 struct lcmd_arg arg_def_nline[] = { 124 { "nlines", 1, ARG_NUM }, 125 0 126 }; 127 128 l_def_nline(v, a) 129 struct value *v, *a; 130 { 131 v->v_num = default_nline; 132 v->v_type = V_NUM; 133 if (a->v_type != V_ERR) 134 default_nline = a->v_num; 135 } 136 137 struct lcmd_arg arg_smooth[] = { 138 { "window", 1, ARG_NUM }, 139 { "flag", 1, ARG_ANY }, 140 0 141 }; 142 143 l_smooth(v, a) 144 struct value *v, *a; 145 { 146 struct ww *w; 147 148 v->v_type = V_NUM; 149 v->v_num = 0; 150 if ((w = vtowin(a++, selwin)) == 0) 151 return; 152 v->v_num = !w->ww_noupdate; 153 w->ww_noupdate = !vtobool(a, v->v_num, v->v_num); 154 } 155 156 struct lcmd_arg arg_def_smooth[] = { 157 { "flag", 1, ARG_ANY }, 158 0 159 }; 160 161 l_def_smooth(v, a) 162 struct value *v, *a; 163 { 164 v->v_type = V_NUM; 165 v->v_num = default_smooth; 166 default_smooth = vtobool(a, v->v_num, v->v_num); 167 } 168 169 struct lcmd_arg arg_select[] = { 170 { "window", 1, ARG_NUM }, 171 0 172 }; 173 174 l_select(v, a) 175 struct value *v, *a; 176 { 177 struct ww *w; 178 179 v->v_type = V_NUM; 180 v->v_num = selwin ? selwin->ww_id + 1 : -1; 181 if (a->v_type == V_ERR) 182 return; 183 if ((w = vtowin(a, (struct ww *)0)) == 0) 184 return; 185 setselwin(w); 186 } 187 188 struct lcmd_arg arg_debug[] = { 189 { "flag", 1, ARG_ANY }, 190 0 191 }; 192 193 l_debug(v, a) 194 struct value *v, *a; 195 { 196 v->v_type = V_NUM; 197 v->v_num = debug; 198 debug = vtobool(a, debug, debug); 199 } 200 201 struct lcmd_arg arg_escape[] = { 202 { "escapec", 1, ARG_STR }, 203 0 204 }; 205 206 l_escape(v, a) 207 struct value *v, *a; 208 { 209 char buf[2]; 210 211 buf[0] = escapec; 212 buf[1] = 0; 213 if ((v->v_str = str_cpy(buf)) == 0) { 214 error("Out of memory."); 215 return; 216 } 217 v->v_type = V_STR; 218 if (a->v_type != V_ERR) 219 setescape(a->v_str); 220 } 221 222 struct lcmd_arg arg_label[] = { 223 { "window", 1, ARG_NUM }, 224 { "label", 1, ARG_STR }, 225 0 226 }; 227 228 /*ARGSUSED*/ 229 l_label(v, a) 230 struct value *v; 231 struct value *a; 232 { 233 struct ww *w; 234 235 if ((w = vtowin(a, selwin)) == 0) 236 return; 237 if ((++a)->v_type != V_ERR && setlabel(w, a->v_str) < 0) 238 error("Out of memory."); 239 reframe(); 240 } 241 242 struct lcmd_arg arg_foreground[] = { 243 { "window", 1, ARG_NUM }, 244 { "flag", 1, ARG_ANY }, 245 0 246 }; 247 248 l_foreground(v, a) 249 struct value *v, *a; 250 { 251 struct ww *w; 252 char flag; 253 254 if ((w = vtowin(a, selwin)) == 0) 255 return; 256 v->v_type = V_NUM; 257 v->v_num = isfg(w); 258 flag = vtobool(++a, v->v_num, v->v_num); 259 if (flag == v->v_num) 260 return; 261 deletewin(w); 262 addwin(w, flag); 263 reframe(); 264 } 265 266 struct lcmd_arg arg_terse[] = { 267 { "flag", 1, ARG_ANY }, 268 0 269 }; 270 271 l_terse(v, a) 272 struct value *v, *a; 273 { 274 v->v_type = V_NUM; 275 v->v_num = terse; 276 setterse(vtobool(a, terse, terse)); 277 } 278 279 struct lcmd_arg arg_source[] = { 280 { "filename", 1, ARG_STR }, 281 0 282 }; 283 284 l_source(v, a) 285 struct value *v, *a; 286 { 287 v->v_type = V_NUM; 288 if (a->v_type != V_ERR && dosource(a->v_str) < 0) { 289 error("Can't open %s.", a->v_str); 290 v->v_num = -1; 291 } else 292 v->v_num = 0; 293 } 294 295 struct lcmd_arg arg_write[] = { 296 { "window", 1, ARG_NUM }, 297 { "", 0, ARG_ANY|ARG_LIST }, 298 0 299 }; 300 301 /*ARGSUSED*/ 302 l_write(v, a) 303 struct value *v; 304 struct value *a; 305 { 306 char buf[20]; 307 struct ww *w; 308 309 if ((w = vtowin(a++, selwin)) == 0) 310 return; 311 while (a->v_type != V_ERR) { 312 if (a->v_type == V_NUM) { 313 (void) sprintf(buf, "%d", a->v_num); 314 (void) write(w->ww_pty, buf, strlen(buf)); 315 } else 316 (void) write(w->ww_pty, a->v_str, strlen(a->v_str)); 317 if ((++a)->v_type != V_ERR) 318 (void) write(w->ww_pty, " ", 1); 319 } 320 } 321 322 struct lcmd_arg arg_close[] = { 323 { "window", 1, ARG_ANY|ARG_LIST }, 324 0 325 }; 326 327 /*ARGSUSED*/ 328 l_close(v, a) 329 struct value *v; 330 struct value *a; 331 { 332 struct ww *w; 333 334 if (a->v_type == V_STR && str_match(a->v_str, "all", 3)) 335 closewin((struct ww *)0); 336 else 337 for (; a->v_type != V_ERR; a++) 338 if ((w = vtowin(a, (struct ww *)0)) != 0) 339 closewin(w); 340 } 341 342 struct lcmd_arg arg_cursormodes[] = { 343 { "modes", 1, ARG_NUM }, 344 0 345 }; 346 347 l_cursormodes(v, a) 348 struct value *v, *a; 349 { 350 351 v->v_type = V_NUM; 352 v->v_num = wwcursormodes; 353 if (a->v_type != V_ERR) 354 wwsetcursormodes(a->v_num); 355 } 356 357 struct lcmd_arg arg_unset[] = { 358 { "variable", 1, ARG_ANY }, 359 0 360 }; 361 362 l_unset(v, a) 363 struct value *v, *a; 364 { 365 v->v_type = V_NUM; 366 switch (a->v_type) { 367 case V_ERR: 368 v->v_num = -1; 369 return; 370 case V_NUM: 371 if ((a->v_str = str_itoa(a->v_num)) == 0) { 372 error("Out of memory."); 373 v->v_num = -1; 374 return; 375 } 376 a->v_type = V_STR; 377 break; 378 } 379 v->v_num = var_unset(a->v_str); 380 } 381 382 struct ww * 383 vtowin(v, w) 384 struct value *v; 385 struct ww *w; 386 { 387 switch (v->v_type) { 388 case V_ERR: 389 if (w != 0) 390 return w; 391 error("No window specified."); 392 return 0; 393 case V_STR: 394 error("%s: No such window.", v->v_str); 395 return 0; 396 } 397 if (v->v_num < 1 || v->v_num > NWINDOW 398 || (w = window[v->v_num - 1]) == 0) { 399 error("%d: No such window.", v->v_num); 400 return 0; 401 } 402 return w; 403 } 404 405 vtobool(v, def, err) 406 struct value *v; 407 char def, err; 408 { 409 switch (v->v_type) { 410 case V_NUM: 411 return v->v_num != 0; 412 case V_STR: 413 if (str_match(v->v_str, "true", 1) 414 || str_match(v->v_str, "on", 2) 415 || str_match(v->v_str, "yes", 1)) 416 return 1; 417 else if (str_match(v->v_str, "false", 1) 418 || str_match(v->v_str, "off", 2) 419 || str_match(v->v_str, "no", 1)) 420 return 0; 421 else { 422 error("%s: Illegal boolean value.", v->v_str); 423 return err; 424 } 425 /*NOTREACHED*/ 426 case V_ERR: 427 return def; 428 } 429 /*NOTREACHED*/ 430 } 431