![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ah.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src|
Return to ah.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.