![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sam.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / sam|
Return to sam.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / sam |
1.1 root 1: #include "sam.h"
2: #include <setjmp.h>
3: #include <signal.h>
4:
5: typedef struct Patlist{
6: int nalloc;
7: int nused;
8: String **ptr;
9: }Patlist;
10:
11: uchar genbuf[BLOCKSIZE];
12: char *home;
13: int io;
14: int panicking;
15: int rescuing;
16: Mod modnum;
17: String genstr;
18: String rhs;
19: String wd;
20: String cmdstr;
21: int intr();
22: int rescue();
23: char *getenv();
24: File *current();
25: File *tofile();
26: File *getfile();
27: File *curfile;
28: File *flist;
29: File *cmd;
30: jmp_buf mainloop;
31: Filelist tempfile;
32: int quitok=TRUE;
33: Patlist globstr;
34: Patlist pattern;
35: int downloaded;
36: int dflag;
37: int Rflag;
38: int zflag;
39: char *machine;
40: int dounlock;
41:
42: main(argc, argv)
43: uchar *argv[];
44: {
45: register i;
46: int (*onintr)();
47: while(argc>1 && argv[1][0]=='-'){
48: switch(argv[1][1]){
49: case 'd':
50: dflag++;
51: break;
52: case 'r':
53: --argc, argv++;
54: if(argc==1){
55: dprint("usage: sam [-d] -r machine\n");
56: return 1;
57: }
58: machine=(char *)argv[1];
59: break;
60: case 'z':
61: zflag++;
62: break;
63: case 'R':
64: Rflag++;
65: break;
66: #ifdef SUN
67: case 't':
68: case 'x':
69: case '=':
70: case 'W':
71: sunarg(&argv, &argc);
72: break;
73: #endif
74: default:
75: dprint("sam: unknown flag %c\n", argv[1][1]);
76: return 1;
77: }
78: --argc, argv++;
79: }
80: allocinit();
81: Fstart();
82: strinit(&cmdstr);
83: strinit(&lastpat);
84: strinit(&lastregexp);
85: strinit(&genstr);
86: strinit(&rhs);
87: strinit(&wd);
88: gcnew(tempfile.ptr, 0);
89: strinit(&unixcmd);
90: straddc(&unixcmd, '\0');
91: home=getenv("HOME");
92: if(home==0)
93: home="/tmp";
94: if(!dflag){
95: if(machine)
96: #ifdef SUN
97: connectboot(machine,zflag); /* doesn't return */
98: #else
99: connectto(machine);
100: #endif
101: if(!Rflag){
102: if(!bootterm(zflag))
103: return 1;
104: }
105: rawmode(1);
106: if(machine)
107: join();
108: downloaded=1;
109: }
110: if(argc>1){
111: for(i=1; i<argc; i++)
112: if(!setjmp(mainloop)){
113: strdup(&genstr, argv[i]);
114: Fsetname(newfile());
115: }
116: }else if(!downloaded)
117: newfile()->state=Clean;
118: modnum++;
119: onintr=signal(SIGINT, intr);
120: if(onintr)
121: signal(SIGINT, onintr);
122: onintr=signal(SIGHUP, rescue);
123: if(onintr)
124: signal(SIGHUP, onintr);
125: if(file.nused)
126: current(file.ptr[0]);
127: (void)setjmp(mainloop);
128: cmdloop();
129: trytoquit(); /* if we already q'ed, quitok will be TRUE */
130: if(downloaded)
131: rawmode(0);
132: return 0;
133: }
134: panic(s)
135: char *s;
136: {
137: if(!panicking++ && !setjmp(mainloop)){
138: dprint("sam: panic: %s\n", s);
139: rescue();
140: }
141: abort();
142: }
143: rescue(){
144: register i, nblank=0;
145: register File *f;
146: uchar buf[128];
147: signal(SIGHUP, SIG_IGN);
148: if(rescuing++)
149: exit(1);
150: io= -1;
151: for(i=0; i<file.nused; i++){
152: f=file.ptr[i];
153: if(f==cmd || f->nbytes==0 || f->state!=Dirty)
154: continue;
155: if(io==-1){
156: strcpy(buf, (uchar *)home);
157: strcpy(buf+strlen(buf), (uchar *)"/sam.save");
158: io=creat((char *)buf, 0777);
159: if(io<0)
160: return;
161: }
162: strcpy(buf, f->name.s);
163: if(buf[0]==0)
164: sprint(buf, "nameless.%d", nblank++);
165: fprint(io, "/usr/jerq/lib/samsave '%s' $* <<'---%s'\n",
166: (char *)buf, (char *)buf);
167: addr.r.p1=0, addr.r.p2=f->nbytes;
168: writeio(f);
169: fprint(io, "\n---%s\n", (char *)buf);
170: }
171: if(panicking)
172: abort();
173: exit(0);
174: }
175: hiccough(s)
176: char *s;
177: {
178: if(rescuing)
179: exit(1);
180: if(s)
181: dprint("%s\n", s);
182: resetcmd();
183: resetxec();
184: compactok();
185: if(io>0)
186: close(io);
187: if(undobuf->nbytes)
188: Bdelete(undobuf, (Posn)0, undobuf->nbytes);
189: update();
190: if(curfile && curfile->state==Unread)
191: curfile->state=Clean;
192: dounlock=TRUE;
193: if(downloaded && curfile && curfile->state!=Unread)
194: outTs(Hcurrent, curfile->tag);
195: longjmp(mainloop, 1);
196: }
197: intr(){
198: signal(SIGINT, intr);
199: error(Eintr);
200: }
201: trytoclose(f)
202: register File *f;
203: {
204: if(f==cmd) /* possible? */
205: return;
206: if(f->state==Dirty && !f->closeok){
207: f->closeok=TRUE;
208: error_s(Emodified,
209: f->name.s[0]?(char *)f->name.s : "nameless file");
210: }
211: if(downloaded && f->rasp)
212: outTs(Hclose, f->tag);
213: delfile(f);
214: if(f==curfile)
215: current((File *)0);
216: }
217: trytoquit(){
218: register c;
219: register File *f;
220: extern int eof;
221: if(!quitok)
222: for(c=0; c<file.nused; c++){
223: f=file.ptr[c];
224: if(f!=cmd && f->state==Dirty){
225: quitok=TRUE;
226: eof=FALSE;
227: error(Echanges);
228: }
229: }
230: }
231: load(f)
232: register File *f;
233: {
234: Address saveaddr;
235: strdupstr(&genstr, &f->name);
236: filename(f);
237: if(f->name.s[0]){
238: saveaddr=addr;
239: edit(f, 'I');
240: addr=saveaddr;
241: }else
242: f->state=Clean;
243: Fupdate(f, FALSE, TRUE);
244: }
245: update(){
246: register i, anymod;
247: register File *f;
248: settempfile();
249: for(anymod=i=0; i<tempfile.nused; i++){
250: f=tempfile.ptr[i];
251: if(f==cmd) /* cmd gets done in main() */
252: continue;
253: if(f->mod==modnum && Fupdate(f, FALSE, downloaded))
254: anymod++;
255: if(f->rasp)
256: telldot(f);
257: }
258: if(anymod)
259: modnum++;
260: }
261: File *
262: current(f)
263: register File *f;
264: {
265: return curfile=f;
266: }
267: edit(f, cmd)
268: register File *f;
269: {
270: register empty=TRUE;
271: Posn p;
272: int nonascii;
273: if(cmd=='r')
274: Fdelete(f, addr.r.p1, addr.r.p2);
275: if(cmd=='e' || cmd=='I'){
276: Fdelete(f, (Posn)0, f->nbytes);
277: addr.r.p2=f->nbytes;
278: }else if(f->nbytes!=0 || (f->name.s[0] && strcmp(genstr.s, f->name.s)!=0))
279: empty=FALSE;
280: if((io=open((char *)genstr.s, 0))<0)
281: error_s(Eopen, (char *)genstr.s);
282: p=readio(f, &nonascii, empty);
283: closeio((cmd=='e' || cmd=='I')? -1 : p);
284: if(cmd=='r')
285: f->dot.r.p1=addr.r.p2, f->dot.r.p2=addr.r.p2+p;
286: else
287: f->dot.r.p1=f->dot.r.p2=0;
288: quitok=f->closeok=empty;
289: state(f, empty && !nonascii? Clean : Dirty);
290: if(cmd=='e')
291: filename(f);
292: }
293: getname(f, s, save)
294: register File *f;
295: register String *s;
296: {
297: register c, i;
298: strzero(&genstr);
299: if(s==0 || (c=s->s[0])==0){ /* no name provided */
300: if(f)
301: strdupstr(&genstr, &f->name);
302: else
303: straddc(&genstr, '\0');
304: goto Return;
305: }
306: if(c!=' ' && c!='\t')
307: error(Eblank);
308: for(i=0; (c=s->s[i])==' ' || c=='\t'; i++)
309: ;
310: while(s->s[i]>' ')
311: straddc(&genstr, s->s[i++]);
312: if(s->s[i])
313: error(Enewline);
314: straddc(&genstr, '\0');
315: if(f && (save || f->name.s[0]==0)){
316: Fsetname(f);
317: if(strcmp(f->name.s, genstr.s)){
318: quitok=f->closeok=FALSE;
319: f->inumber=0;
320: f->date=0;
321: state(f, Dirty); /* if it's 'e', fix later */
322: }
323: }
324: Return:
325: return genstr.n-1; /* strlen(name) */
326: }
327: filename(f)
328: register File *f;
329: {
330: dprint("%c%c%c %s\n", " '"[f->state==Dirty],
331: "-+"[f->rasp!=0], " ."[f==curfile], genstr.s);
332: }
333: undo()
334: {
335: register File *f;
336: register i;
337: Mod max;
338: if((max=curfile->mod)==0)
339: return;
340: settempfile();
341: for(i=0; i<tempfile.nused; i++){
342: f=tempfile.ptr[i];
343: if(f!=cmd && f->mod==max)
344: undostep(f);
345: }
346: }
347: undostep(f)
348: register File *f;
349: {
350: register Buffer *t;
351: register changes;
352: Mark mark;
353: t=f->transcript;
354: changes=Fupdate(f, TRUE, TRUE);
355: Bread(t, (uchar *)&mark, sizeof mark, f->markp);
356: Bdelete(t, f->markp, t->nbytes);
357: f->markp=mark.p;
358: f->dot.r=mark.dot;
359: f->mark=mark.mark;
360: f->mod=mark.m;
361: f->closeok=mark.s1!=Dirty;
362: if(mark.s1==Dirty)
363: quitok=FALSE;
364: if(f->state==Clean && mark.s1==Clean && changes)
365: state(f, Dirty);
366: else
367: state(f, mark.s1);
368: }
369: cd(str)
370: String *str;
371: {
372: register i;
373: register File *f;
374: readcmd(tempstr((uchar *)"/bin/pwd", 9));
375: strdupstr(&wd, &genstr);
376: if(wd.s[0]==0){
377: wd.n=0;
378: warn(Wpwd);
379: }else if(wd.s[wd.n-2]=='\n'){
380: --wd.n;
381: wd.s[wd.n-1]='/';
382: }
383: if(chdir(getname((File *)0, str, FALSE)? (char *)genstr.s : home))
384: syserror("chdir");
385: settempfile();
386: for(i=0; i<tempfile.nused; i++){
387: f=tempfile.ptr[i];
388: if(f!=cmd && f->name.s[0]!='/' && f->name.s[0]!=0){
389: strinsert(&f->name, &wd, (Posn)0);
390: sortname(f);
391: }
392: }
393: }
394: readcmd(s)
395: String *s;
396: {
397: if(flist==0)
398: (flist=Fopen())->state=Clean;
399: addr.r.p1=0, addr.r.p2=flist->nbytes;
400: Unix(flist, '<', s, FALSE);
401: Fupdate(flist, FALSE, FALSE);
402: flist->mod=0;
403: strzero(&genstr);
404: strinsure(&genstr, flist->nbytes);
405: Fchars(flist, genstr.s, (Posn)0, flist->nbytes);
406: genstr.n=flist->nbytes;
407: straddc(&genstr, '\0');
408: }
409: loadflist(s)
410: register String *s;
411: {
412: register c, i;
413: c=s->s[0];
414: for(i=0; s->s[i]==' ' || s->s[i]=='\t'; i++)
415: ;
416: if((c==' ' || c=='\t') && s->s[i]!='\n'){
417: if(s->s[i]=='<'){
418: strdelete(s, 0L, (long)i+1);
419: readcmd(s);
420: }else{
421: strzero(&genstr);
422: while((c=s->s[i++]) && c!='\n')
423: straddc(&genstr, c);
424: straddc(&genstr, '\0');
425: }
426: }else{
427: if(c!='\n')
428: error(Eblank);
429: strdup(&genstr, (uchar *)"");
430: }
431: return genstr.s[0];
432: }
433: File *
434: readflist(readall, delete)
435: {
436: register Posn i;
437: register c;
438: register File *f;
439: for(i=0,f=0; f==0 || readall || delete; ){
440: strdelete(&genstr, (Posn)0, i);
441: for(i=0; (c=genstr.s[i])==' ' || c=='\t' || c=='\n'; i++)
442: ;
443: if(i>=genstr.n)
444: break;
445: strdelete(&genstr, (Posn)0, i);
446: for(i=0; (c=genstr.s[i]) && c!=' ' && c!='\t' && c!='\n'; i++)
447: ;
448: if(i==0)
449: break;
450: genstr.s[i++]=0;
451: f=lookfile();
452: if(delete){
453: if(f==0)
454: warn_s(Wfile, (char *)genstr.s);
455: else
456: trytoclose(f);
457: }else if(f==0 && readall)
458: Fsetname(f=newfile());
459: }
460: return f;
461: }
462: File *
463: tofile(s)
464: String *s;
465: {
466: register File *f;
467: if(s->s[0]!=' ')
468: error(Eblank);
469: if(loadflist(s)==0)
470: f=lookfile(); /* empty string ==> nameless file */
471: else if((f=readflist(FALSE, FALSE))==0)
472: error_s(Emenu, (char *)genstr.s);
473: return current(f);
474: }
475: File *
476: getfile(s)
477: String *s;
478: {
479: register File *f;
480: if(loadflist(s)==0)
481: Fsetname(f=newfile());
482: else if((f=readflist(TRUE, FALSE))==0)
483: error(Eblank);
484: return current(f);
485: }
486: closefiles(f, s)
487: File *f;
488: register String *s;
489: {
490: if(s->s[0]==0){
491: if(f==0)
492: error(Enofile);
493: trytoclose(f);
494: return;
495: }
496: if(s->s[0]!=' ')
497: error(Eblank);
498: if(loadflist(s)==0)
499: error(Enewline);
500: readflist(FALSE, TRUE);
501: }
502: move(f, addr2)
503: register File *f;
504: Address addr2;
505: {
506: if(addr.r.p2<=addr2.r.p2){
507: Fdelete(f, addr.r.p1, addr.r.p2);
508: copy(f, addr2);
509: }else if(addr.r.p1>=addr2.r.p2){
510: copy(f, addr2);
511: Fdelete(f, addr.r.p1, addr.r.p2);
512: }else
513: error(Eoverlap);
514: }
515: copy(f, addr2)
516: register File *f;
517: Address addr2;
518: {
519: register Posn p;
520: register ni;
521: for(p=addr.r.p1; p<addr.r.p2; p+=ni){
522: ni=addr.r.p2-p;
523: if(ni>BLOCKSIZE)
524: ni=BLOCKSIZE;
525: Fchars(f, genbuf, p, p+ni);
526: Finsert(addr2.f, tempstr(genbuf, ni), addr2.r.p2);
527: }
528: addr2.f->dot.r.p2=addr2.r.p2+(f->dot.r.p2-f->dot.r.p1);
529: addr2.f->dot.r.p1=addr2.r.p2;
530: }
531: Posn
532: nlcount(f, p0, p1)
533: register File *f;
534: register Posn p0, p1;
535: {
536: register Posn nl=0;
537: Fgetcset(f, p0);
538: while(p0++<p1)
539: if(Fgetc(f)=='\n')
540: nl++;
541: return nl;
542: }
543: printposn(f, charsonly)
544: register File *f;
545: {
546: register Posn l1, l2;
547: if(!charsonly){
548: l1=1+nlcount(f, (Posn)0, addr.r.p1);
549: l2=l1+nlcount(f, addr.r.p1, addr.r.p2);
550: /* check if addr ends with '\n' */
551: if(addr.r.p2>0 && addr.r.p2>addr.r.p1 && (Fgetcset(f, addr.r.p2-1),Fgetc(f)=='\n'))
552: --l2;
553: dprint("%lud", l1);
554: if(l2!=l1)
555: dprint(",%lud", l2);
556: dprint("; ");
557: }
558: dprint("#%lud", addr.r.p1);
559: if(addr.r.p2!=addr.r.p1)
560: dprint(",#%lud", addr.r.p2);
561: dprint("\n");
562: }
563: settempfile(){
564: if(tempfile.nalloc<file.nused){
565: gcfree((uchar *)tempfile.ptr);
566: gcnew(tempfile.ptr, file.nused);
567: tempfile.nalloc=file.nused;
568: }
569: tempfile.nused=file.nused;
570: bcopy((uchar *)&file.ptr[0], (uchar *)&file.ptr[file.nused],
571: (uchar *)&tempfile.ptr[0], 1);
572: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.