4.3BSD - /usr/src/new/apl/src/ah.c

   1: static char Sccsid[] = "ah.c @(#)ah.c	1.1	10/1/82 Berkeley ";
   2: #include "apl.h"
   3: 
   4: ex_immed()
   5: {
   6:     register i;
   7:     register struct item *p;
   8:     register struct nlist *n;
   9:     double f;
  10:     char fname[64];         /* Array for filename */
  11:     char *cp, *vfname();
  12:     int *ip;
  13: 
  14:     i = *pcp++;
  15:     switch(i) {
  16: 
  17:     default:
  18:         error("immed B");
  19: 
  20:     case SCRIPT:
  21:         if(protofile > 0)
  22:             CLOSEF(protofile);
  23:         protofile = 0;
  24:         cp = vfname(fname);
  25:         if(equal(cp, "off"))
  26:             return;
  27:         if((protofile = OPENF(cp, 1)) > 0){
  28:             SEEKF(protofile, 0L, 2);  /* append to existing file */
  29:             printf("[appending]\n");
  30:         } else {
  31:             /*
  32: 			 * create new file
  33: 			 */
  34:             protofile = opn(cp, 0644);
  35:             printf("[new file]\n");
  36:         }
  37:         WRITEF(protofile, "\t)script on\n", 12);
  38:         return;
  39: 
  40:     case DEBUG:
  41:         debug = ~debug;
  42:         return;
  43: 
  44:     case DIGITS:
  45:         i = topfix();
  46:         if(i < 1 || i > 20)
  47:             error("digits D");
  48:         printf("was %d\n",thread.digits);
  49:         thread.digits = i;
  50:         return;
  51:     case TRACE:
  52:         funtrace = 1;
  53:         return;
  54: 
  55:     case UNTRACE:
  56:         funtrace = 0;
  57:         return;
  58: 
  59:     case WRITE:
  60:         funwrite(0);
  61:         return;
  62: 
  63:     case DEL:
  64:     case EDITF:
  65:         *sp++ = sp[-1]; /* duplicate top of stack */
  66:         funwrite(scr_file);
  67:         funedit(scr_file, i);
  68:         unlink(scr_file);
  69:         return;
  70: 
  71: 
  72:     case EDIT:
  73:         funedit(0, i);
  74:         return;
  75: 
  76:     case FUZZ:
  77:         i = topfix();
  78:         if(i <= 0) {
  79:             thread.fuzz = 0.;
  80:             return;
  81:         }
  82:         f = i;
  83:         thread.fuzz = exp(-f*2.3025851);
  84:         return;
  85: 
  86:     case ORIGIN:
  87:         printf("was %d\n",thread.iorg);
  88:         thread.iorg = topfix();
  89:         return;
  90: 
  91:     case WIDTH:
  92:         i = topfix();
  93:         if(i < 1)
  94:             error("width D");
  95:         printf("was %d\n",thread.width);
  96:         thread.width = i;
  97:         return;
  98: 
  99:     case READ:
 100:         funread(0);
 101:         return;
 102: 
 103:     case ERASE:
 104:         p = sp[-1];
 105:         sp--;
 106:         erase(p);
 107:         return;
 108: 
 109:     case CONTIN:
 110:         i = opn("continue", 0644);
 111:         wssave(i);
 112:         printf(" continue");
 113: 
 114:     case OFF:
 115:         term(0);
 116: 
 117:     case VARS:
 118:         for(n=nlist; n->namep; n++)
 119:             if(n->itemp && n->use == DA && n->namep[0] != 'L') {
 120:                 if(column+8 >= thread.width)
 121:                     printf("\n\t");
 122:                 printf(n->namep);
 123:                 putchar('\t');
 124:             }
 125:         putchar('\n');
 126:         return;
 127: 
 128:     case FNS:
 129:         for(n=nlist; n->namep; n++)
 130:             if(n->use == DF || n->use == MF || n->use == NF) {
 131:                 if(column+8 >= thread.width)
 132:                     printf("\n\t");
 133:                 printf(n->namep);
 134:                 putchar('\t');
 135:             }
 136:         putchar('\n');
 137:         return;
 138: 
 139:     case CODE:
 140:         n = (struct nlist *)sp[-1];
 141:         sp--;
 142:         switch(n->use){
 143:         default:
 144:             error("not a fn");
 145:         case NF:
 146:         case MF:
 147:         case DF:
 148:             if(n->itemp == 0)
 149:                 funcomp(n);
 150:             ip = (int *)n->itemp;
 151:             for(i=0; i <= *ip; i++){
 152:                 printf(" [%d] ", i);
 153:                 dump(ip[i+1], 0);
 154:             }
 155:             putchar('\n');
 156:         }
 157:         return;
 158: 
 159:     case RESET:
 160:         while(gsip)
 161:             ex_ibr0();
 162:         error("");
 163: 
 164:     case SICOM:
 165:         tback(1);
 166:         return;
 167: 
 168:     case CLEAR:
 169:         clear();
 170:         printf("clear ws\n");
 171:         goto warp1;     /* four lines down, or so... */
 172: 
 173:     case LOAD:
 174:         i = opn(vfname(fname), 0);
 175:         clear();
 176:         wsload(i);
 177:         printf(" %s\n", fname);
 178:         evLlx();    /* possible latent expr evaluation */
 179: warp1:
 180:         /*
 181: 		 * this garbage is necessary because clear()
 182: 		 * does a brk(&end), and the normal return & cleanup
 183: 		 * procedures are guaranteed to fail (miserably).
 184: 		 *		--jjb 1/78
 185: 		 */
 186:         sp = stack;
 187:         reset();
 188: 
 189:     case LIB:
 190:         listdir();
 191:         return;
 192: 
 193:     case COPY:
 194:         if(gsip)
 195:             error("si damage -- type ')reset'");
 196:         wsload(opn(vfname(fname),0));
 197:         printf(" copy %s\n", fname);
 198:         return;
 199: 
 200:     case DROPC:
 201:         cp = vfname(fname);
 202:         if(unlink(cp) == -1)
 203:             printf("[can't remove %s]\n", cp);
 204:         return;
 205: 
 206:     case SAVE:
 207:         i = opn(vfname(fname), 0644);
 208:         wssave(i);
 209:         printf(" saved %s\n", fname);
 210:         return;
 211: 
 212:     case VSAVE:
 213:         i = opn(vfname(fname), 0644);
 214:         vsave(i);
 215:         putchar('\n');
 216:         return;
 217: 
 218: 
 219:     case SHELL:
 220:         ex_shell();
 221:         return;
 222: 
 223:     case LIST:
 224:         ex_list();
 225:         return;
 226: 
 227:     case PRWS:
 228:         ex_prws();
 229:         return;
 230: 
 231:     }
 232: }
 233: 
 234: char *
 235: vfname(array)
 236: char *array;
 237: {
 238:     register struct nlist *n;
 239:     register char *p;
 240: 
 241:     n = (struct nlist *)sp[-1];
 242:     sp--;
 243:     if(n->type != LV)
 244:         error("save B");
 245:     p = n->namep;
 246:     while(*array++ = *p++);
 247:     return(n->namep);
 248: 
 249: }
 250: 
 251: /*
 252:  * check for latent expr., and evaluate it if it is there:
 253:  */
 254: evLlx()
 255: {
 256:     register struct nlist *n;
 257:     register struct item *p;
 258: 
 259:     if((n=nlook("Llx")) && n->itemp->type == CH && n->itemp->size){
 260:         *sp++ = dupdat(n->itemp);
 261:         ex_meps();
 262:         p = sp[-1];
 263:         if(p->type != EL && p->type != DU)
 264:             ex_print();
 265:         pop();
 266: /*		error("");	*/
 267:     }
 268: }

Defined functions

Defined variables