4.3BSD - /usr/src/ucb/window/lcmd2.c

   1: #ifndef lint
   2: static char sccsid[] = "@(#)lcmd2.c	3.11 4/24/85";
   3: #endif
   4: 
   5: /*
   6:  * Copyright (c) 1983 Regents of the University of California,
   7:  * All rights reserved.  Redistribution permitted subject to
   8:  * the terms of the Berkeley Software License Agreement.
   9:  */
  10: 
  11: #include "defs.h"
  12: #include "string.h"
  13: #include "value.h"
  14: #include "var.h"
  15: #include "lcmd.h"
  16: #include <sys/resource.h>
  17: #include "alias.h"
  18: 
  19: /*ARGSUSED*/
  20: l_iostat(v, a)
  21: struct value *v, *a;
  22: {
  23:     register struct ww *w;
  24: 
  25:     if ((w = openiwin(14, "IO Statistics")) == 0) {
  26:         error("Can't open statistics window: %s.", wwerror());
  27:         return;
  28:     }
  29:     wwprintf(w, "ttflush\twrite\terror\tzero\tchar\n");
  30:     wwprintf(w, "%d\t%d\t%d\t%d\t%d\n",
  31:         wwnflush, wwnwr, wwnwre, wwnwrz, wwnwrc);
  32:     wwprintf(w, "wwwrite\tattempt\tchar\n");
  33:     wwprintf(w, "%d\t%d\t%d\n",
  34:         wwnwwr, wwnwwra, wwnwwrc);
  35:     wwprintf(w, "wwupdat\tline\tmiss\tmajor\tmiss\n");
  36:     wwprintf(w, "%d\t%d\t%d\t%d\t%d\n",
  37:         wwnupdate, wwnupdline, wwnupdmiss, wwnmajline, wwnmajmiss);
  38:     wwprintf(w, "select\terror\tzero\n");
  39:     wwprintf(w, "%d\t%d\t%d\n",
  40:         wwnselect, wwnselecte, wwnselectz);
  41:     wwprintf(w, "read\terror\tzero\tchar\n");
  42:     wwprintf(w, "%d\t%d\t%d\t%d\n",
  43:         wwnread, wwnreade, wwnreadz, wwnreadc);
  44:     wwprintf(w, "ptyread\terror\tzero\tcontrol\tdata\tchar\n");
  45:     wwprintf(w, "%d\t%d\t%d\t%d\t%d\t%d\n",
  46:         wwnwread, wwnwreade, wwnwreadz,
  47:         wwnwreadp, wwnwreadd, wwnwreadc);
  48:     waitnl(w);
  49:     closeiwin(w);
  50: }
  51: 
  52: struct lcmd_arg arg_time[] = {
  53:     { "who",    1,  ARG_STR },
  54:     0
  55: };
  56: 
  57: /*ARGSUSED*/
  58: l_time(v, a)
  59: struct value *v;
  60: register struct value *a;
  61: {
  62:     register struct ww *w;
  63:     struct rusage rusage;
  64:     struct timeval timeval;
  65:     char *strtime();
  66: 
  67:     if ((w = openiwin(6, "Timing and Resource Usage")) == 0) {
  68:         error("Can't open time window: %s.", wwerror());
  69:         return;
  70:     }
  71: 
  72:     (void) gettimeofday(&timeval, (struct timezone *)0);
  73:     timeval.tv_sec -= starttime.tv_sec;
  74:     if ((timeval.tv_usec -= starttime.tv_usec) < 0) {
  75:         timeval.tv_sec--;
  76:         timeval.tv_usec += 1000000;
  77:     }
  78:     (void) getrusage(a->v_type == V_STR
  79:             && str_match(a->v_str, "children", 1)
  80:         ? RUSAGE_CHILDREN : RUSAGE_SELF, &rusage);
  81: 
  82:     wwprintf(w, "time\t\tutime\t\tstime\t\tmaxrss\tixrss\tidrss\tisrss\n");
  83:     wwprintf(w, "%-16s", strtime(&timeval));
  84:     wwprintf(w, "%-16s", strtime(&rusage.ru_utime));
  85:     wwprintf(w, "%-16s", strtime(&rusage.ru_stime));
  86:     wwprintf(w, "%D\t%D\t%D\t%D\n",
  87:         rusage.ru_maxrss, rusage.ru_ixrss,
  88:         rusage.ru_idrss, rusage.ru_isrss);
  89:     wwprintf(w, "minflt\tmajflt\tnswap\tinblk\toublk\tmsgsnd\tmsgrcv\tnsigs\tnvcsw\tnivcsw\n");
  90:     wwprintf(w, "%D\t%D\t%D\t%D\t%D\t%D\t%D\t%D\t%D\t%D\n",
  91:         rusage.ru_minflt, rusage.ru_majflt, rusage.ru_nswap,
  92:         rusage.ru_inblock, rusage.ru_oublock,
  93:         rusage.ru_msgsnd, rusage.ru_msgrcv, rusage.ru_nsignals,
  94:         rusage.ru_nvcsw, rusage.ru_nivcsw);
  95: 
  96:     waitnl(w);
  97:     closeiwin(w);
  98: }
  99: 
 100: char *
 101: strtime(t)
 102: register struct timeval *t;
 103: {
 104:     char fill = 0;
 105:     static char buf[20];
 106:     register char *p = buf;
 107: 
 108:     if (t->tv_sec > 60*60) {
 109:         (void) sprintf(p, "%D:", t->tv_sec / (60*60));
 110:         while (*p++)
 111:             ;
 112:         p--;
 113:         t->tv_sec %= 60*60;
 114:         fill++;
 115:     }
 116:     if (t->tv_sec > 60) {
 117:         (void) sprintf(p, fill ? "%02D:" : "%D:", t->tv_sec / 60);
 118:         while (*p++)
 119:             ;
 120:         p--;
 121:         t->tv_sec %= 60;
 122:         fill++;
 123:     }
 124:     (void) sprintf(p, fill ? "%02D.%02d" : "%D.%02D",
 125:         t->tv_sec, t->tv_usec / 10000);
 126:     return buf;
 127: }
 128: 
 129: /*ARGSUSED*/
 130: l_list(v, a)
 131: struct value *v, *a;
 132: {
 133:     register struct ww *w, *wp;
 134:     register i;
 135:     int n;
 136: 
 137:     for (n = 0, i = 0; i < NWINDOW; i++)
 138:         if (window[i] != 0)
 139:             n++;
 140:     if (n == 0) {
 141:         error("No windows.");
 142:         return;
 143:     }
 144:     if ((w = openiwin(n + 2, "Windows")) == 0) {
 145:         error("Can't open listing window: %s.", wwerror());
 146:         return;
 147:     }
 148:     for (i = 0; i < NWINDOW; i++) {
 149:         if ((wp = window[i]) == 0)
 150:             continue;
 151:         wwprintf(w, "%c %c %-13s %-.*s\n",
 152:             wp == selwin ? '*' : ' ',
 153:             i + '1',
 154:             wp->ww_state == WWS_HASPROC ? "" : "(No process)",
 155:             wwncol - 20,
 156:             wp->ww_label ? wp->ww_label : "(No label)");
 157:     }
 158:     waitnl(w);
 159:     closeiwin(w);
 160: }
 161: 
 162: /*ARGSUSED*/
 163: l_variable(v, a)
 164: struct value *v, *a;
 165: {
 166:     register struct ww *w;
 167:     int printvar();
 168: 
 169:     if ((w = openiwin(wwnrow - 3, "Variables")) == 0) {
 170:         error("Can't open variable window: %s.", wwerror());
 171:         return;
 172:     }
 173:     if (var_walk(printvar, (int)w) >= 0)
 174:         waitnl(w);
 175:     closeiwin(w);
 176: }
 177: 
 178: printvar(w, r)
 179: register struct ww *w;
 180: register struct var *r;
 181: {
 182:     if (more(w, 0) == 2)
 183:         return -1;
 184:     wwprintf(w, "%16s    ", r->r_name);
 185:     switch (r->r_val.v_type) {
 186:     case V_STR:
 187:         wwprintf(w, "%s\n", r->r_val.v_str);
 188:         break;
 189:     case V_NUM:
 190:         wwprintf(w, "%d\n", r->r_val.v_num);
 191:         break;
 192:     case V_ERR:
 193:         wwprintf(w, "ERROR\n");
 194:         break;
 195:     }
 196:     return 0;
 197: }
 198: 
 199: struct lcmd_arg arg_shell[] = {
 200:     { "",   0,      ARG_ANY|ARG_LIST },
 201:     0
 202: };
 203: 
 204: l_shell(v, a)
 205:     struct value *v, *a;
 206: {
 207:     register char **pp;
 208:     register struct value *vp;
 209: 
 210:     if (a->v_type == V_ERR) {
 211:         if ((v->v_str = str_cpy(shellfile)) != 0)
 212:             v->v_type = V_STR;
 213:         return;
 214:     }
 215:     if (v->v_str = shellfile) {
 216:         v->v_type = V_STR;
 217:         for (pp = shell + 1; *pp; pp++) {
 218:             str_free(*pp);
 219:             *pp = 0;
 220:         }
 221:     }
 222:     for (pp = shell, vp = a;
 223:          vp->v_type != V_ERR && pp < &shell[sizeof shell/sizeof *shell-1];
 224:          pp++, vp++)
 225:         if ((*pp = vp->v_type == V_STR ?
 226:              str_cpy(vp->v_str) : str_itoa(vp->v_num)) == 0) {
 227:             /* just leave shell[] the way it is */
 228:             p_memerror();
 229:             break;
 230:         }
 231:     if (shellfile = *shell)
 232:         if (*shell = rindex(shellfile, '/'))
 233:             (*shell)++;
 234:         else
 235:             *shell = shellfile;
 236: }
 237: 
 238: struct lcmd_arg arg_alias[] = {
 239:     { "",   0,      ARG_STR },
 240:     { "",   0,      ARG_STR|ARG_LIST },
 241:     0
 242: };
 243: 
 244: l_alias(v, a)
 245:     struct value *v, *a;
 246: {
 247:     if (a->v_type == V_ERR) {
 248:         register struct ww *w;
 249:         int printalias();
 250: 
 251:         if ((w = openiwin(wwnrow - 3, "Aliases")) == 0) {
 252:             error("Can't open alias window: %s.", wwerror());
 253:             return;
 254:         }
 255:         if (alias_walk(printalias, (int)w) >= 0)
 256:             waitnl(w);
 257:         closeiwin(w);
 258:     } else {
 259:         register struct alias *ap = 0;
 260: 
 261:         if (ap = alias_lookup(a->v_str)) {
 262:             if ((v->v_str = str_cpy(ap->a_buf)) == 0) {
 263:                 p_memerror();
 264:                 return;
 265:             }
 266:             v->v_type = V_STR;
 267:         }
 268:         if (a[1].v_type == V_STR) {
 269:             register struct value *vp;
 270:             register char *p, *q;
 271:             char *str;
 272:             register n;
 273: 
 274:             for (n = 0, vp = a + 1; vp->v_type != V_ERR; vp++, n++)
 275:                 for (p = vp->v_str; *p; p++, n++)
 276:                     ;
 277:             if ((str = str_alloc(n)) == 0) {
 278:                 p_memerror();
 279:                 return;
 280:             }
 281:             for (q = str, vp = a + 1; vp->v_type != V_ERR;
 282:                  vp++, q[-1] = ' ')
 283:                 for (p = vp->v_str; *q++ = *p++;)
 284:                     ;
 285:             q[-1] = 0;
 286:             if ((ap = alias_set(a[0].v_str, (char *)0)) == 0) {
 287:                 p_memerror();
 288:                 str_free(str);
 289:                 return;
 290:             }
 291:             ap->a_buf = str;
 292:         }
 293:     }
 294: }
 295: 
 296: printalias(w, a)
 297: register struct ww *w;
 298: register struct alias *a;
 299: {
 300:     if (more(w, 0) == 2)
 301:         return -1;
 302:     wwprintf(w, "%16s    %s\n", a->a_name, a->a_buf);
 303:     return 0;
 304: }
 305: 
 306: struct lcmd_arg arg_unalias[] = {
 307:     { "alias",  1,  ARG_STR },
 308:     0
 309: };
 310: 
 311: l_unalias(v, a)
 312: struct value *v, *a;
 313: {
 314:     if (a->v_type == ARG_STR)
 315:         v->v_num = alias_unset(a->v_str);
 316:     v->v_type = V_NUM;
 317: }
 318: 
 319: struct lcmd_arg arg_echo[] = {
 320:     { "window", 1,  ARG_NUM },
 321:     { "",       0,  ARG_ANY|ARG_LIST },
 322:     0
 323: };
 324: 
 325: /*ARGSUSED*/
 326: l_echo(v, a)
 327: struct value *v;
 328: register struct value *a;
 329: {
 330:     char buf[20];
 331:     struct ww *w;
 332: 
 333:     if ((w = vtowin(a++, selwin)) == 0)
 334:         return;
 335:     while (a->v_type != V_ERR) {
 336:         if (a->v_type == V_NUM) {
 337:             (void) sprintf(buf, "%d", a->v_num);
 338:             (void) wwwrite(w, buf, strlen(buf));
 339:         } else
 340:             (void) wwwrite(w, a->v_str, strlen(a->v_str));
 341:         if ((++a)->v_type != V_ERR)
 342:             (void) wwwrite(w, " ", 1);
 343:     }
 344:     (void) wwwrite(w, "\r\n", 2);
 345: }

Defined functions

Defined variables