![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pad.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pads / x11|
Return to pad.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pads / x11 |
1.1 root 1: #include "univ.h"
2: Selection Selected;
3: Pad *Current;
4: long HostObject;
5: long HostParent;
6: short Scrolly;
7: Point Zpoint;
8: Rectangle ZRectangle;
9: Pad *DirtyPad;
10:
11: Pad Sentinel = { 0, 0, 0, 0, 0, &Sentinel, &Sentinel };
12: Rectangle PadSpace;
13: Rectangle KBDrect;
14: Attrib NewFold;
15:
16: #define ISPAD(p) ((p) != &Sentinel)
17: #define ISLINE(l,p) ((l) != &(p)->sentinel) /* used how much? */
18:
19: Point PickPoint(s)
20: char *s;
21: {
22: char *pick = "pick window: ";
23: Point p;
24: cursswitch(&Bullseye);
25: if( s ) InvertKBDrect( pick, s );
26: while( !button123() ) waitMOUSE();
27: p = (butts==BUTT2 || butts==BUTT3) ? mouse.xy: Zpoint;
28: cursswitch( Pcursor );
29: PaintKBD();
30: return p;
31: }
32:
33: #define MINWD 50
34: #define MINHT 50
35: PadSized( r )
36: Rectangle r;
37: {
38: return r.corner.x-r.origin.x > MINWD && r.corner.y-r.origin.y > MINHT;
39: }
40:
41: #define SWEEP 125
42: int SWEEPTIMEOUT = 1000*15;
43: Rectangle clipgetrect(s)
44: register char *s;
45: {
46: Rectangle r, r1;
47: register long start;
48: Point p1, p2;
49:
50: if( s ) InvertKBDrect( "sweep ", s );
51: for( start = realtime(); ; jnap(2) ){
52: if( ptinrect(mouse.xy, inset(PadSpace,-SWEEP)) )
53: break;
54: if( realtime()>start+SWEEPTIMEOUT ){
55: r = Drect;
56: while( PadSized(r1= inset(r,1)) )
57: r = r1;
58: goto TimedOut;
59: }
60: }
61: r = getrect23();
62: if( r.corner.x && r.corner.x-r.origin.x<=5 && r.corner.y-r.origin.y<=5 )
63: r = Drect; /* from jim */
64: TimedOut:
65: PaintKBD();
66: if( !rectclip( &r, PadSpace ) ) return ZRectangle;
67: return r;
68: }
69:
70: DelLine( l )
71: register Line *l;
72: {
73: assert( l && l->down && l->up );
74:
75: if( Selected.line == l ) Selected.line = 0;
76: l->down->up = l->up;
77: l->up->down = l->down;
78: gcfree( l->text );
79: free( l );
80: }
81:
82: Line *InsAbove(l, t)
83: register Line *l;
84: register Line *t;
85: {
86: register Line *n;
87:
88: assert( l && l->down && l->up );
89: if( !t->text ) return 0; /* || !t->text[0] allow */
90: n = salloc(Line);
91: *n = *t;
92: GCString(&n->text, t->text);
93: n->down = l;
94: n->up = l->up;
95: l->up->down = n;
96: l->up = n;
97: return n;
98: }
99:
100: Line *InsPos(p, tk)
101: register Pad *p;
102: register Line *tk;
103: {
104: register Line *l = &p->sentinel;
105:
106: assert( p && tk );
107: if( (p->attributes&SORTED) && tk->text ){
108: while( ISLINE(l->up,p) && !dictorder(l->up->text,tk->text) )
109: l = l->up;
110: } else {
111: while( ISLINE(l->up,p) && l->up->key > tk->key )
112: l = l->up;
113: }
114: return l;
115: }
116:
117: CreateLine(p)
118: register Pad *p;
119: {
120: register long lo, hi, k;
121: register Line *inspos, *l;
122: Line fake;
123: register char tilde;
124:
125: lo = RcvLong();
126: hi = RcvLong();
127: if( p->sentinel.key || p->attributes&SORTED ) return;
128: tilde = p->attributes&NO_TILDE ? 0 : '~';
129: for( k = lo; k <= hi; ++k ) if( k ){
130: fake.key = k;
131: fake.carte = 0;
132: fake.attributes = FAKELINE;
133: fake.text = itoa(k);
134: *fake.text = tilde;
135: inspos = InsPos(p, &fake);
136: if( inspos->up->key == k )
137: DelLine( inspos->up );
138: InsAbove(inspos, &fake);
139: p->attributes |= FAKELINE;
140: Dirty(p);
141: }
142: }
143:
144: PutLine(p,op)
145: register Pad *p;
146: Protocol op;
147: {
148: static Line prevrcvd;
149: Line rcvd;
150: char text[256]; /* 256 ? */
151: register Line *l, *inspos;
152:
153: rcvd = prevrcvd;
154: rcvd.object = RcvLong();
155: if( op == P_NEXTLINE )
156: rcvd.key = ++prevrcvd.key;
157: else {
158: rcvd.key = RcvLong();
159: rcvd.carte = RcvShort();
160: rcvd.attributes = RcvShort();
161: prevrcvd = rcvd;
162: }
163: RcvString(rcvd.text = text);
164: if( !p ) return;
165: if( p->sentinel.key && rcvd.key>p->sentinel.key ) return;
166: inspos = InsPos(p, &rcvd);
167: {
168: extern Script ObjScript;
169: rcvd.phit = ObjScript.prevhit;
170: rcvd.ptop = ObjScript.prevtop;
171: }
172: if( rcvd.attributes&SELECTLINE ) MakeCurrent(p);
173: for( l = p->sentinel.up; ISLINE(l,p); l = l->up ){
174: if( l->key == rcvd.key ){
175: if( l == Selected.line )
176: rcvd.attributes |= SELECTLINE;
177: if( !strcmp(rcvd.text, l->text)
178: && rcvd.object == l->object
179: && rcvd.carte == l->carte
180: && rcvd.attributes == l->attributes
181: && !(rcvd.attributes&SELECTLINE) )
182: return;
183: inspos = l->down;
184: if( NewFold = l->attributes & (FOLD|TRUNCATE) )
185: FoldToggle( &rcvd.attributes );
186: rcvd.phit = l->phit;
187: rcvd.ptop = l->ptop;
188: DelLine( l );
189: break;
190: }
191: }
192: l = InsAbove(inspos, &rcvd);
193: if( !(rcvd.attributes&DONT_DIRTY) ) Dirty(p);
194: if( l && rcvd.attributes&SELECTLINE ){ /* selected <= "" !! */
195: Selected.line = l;
196: Selected.pad = p;
197: Paint(p);
198: }
199: }
200:
201: SetCurrent( p )
202: register Pad *p;
203: {
204: if( Current ) HeavyBorder(Current);
205: if( Current = p ) HeavyBorder( p );
206: }
207:
208: PaintCurrent()
209: {
210: if( Current ) Paint(Current);
211: }
212:
213: LineXOR( l )
214: Line *l;
215: {
216: rectf( &display, l->rect, F_XOR );
217: }
218:
219: Cover Covered( p ) /* should be smarter */
220: register Pad *p;
221: {
222: register Pad *f;
223:
224: for( f = p->front; ISPAD(f); f = f->front )
225: if( rectinrect( p->rect, f->rect ) ) return COMPLETE;
226: for( f = p->front; ISPAD(f); f = f->front )
227: if( rectXrect( p->rect, f->rect ) ) return PARTIAL;
228: return CLEAR;
229: }
230:
231: Dirty(p)
232: Pad *p;
233: {
234: if( p == DirtyPad ) return;
235: if( DirtyPad && Covered(DirtyPad)!=COMPLETE )
236: if( !ClipPaint(DirtyPad->rect, DirtyPad) )
237: PaintForward( DirtyPad->rect, DirtyPad->front );
238: DirtyPad = p;
239: }
240:
241: Linkin(p)
242: register Pad *p;
243: {
244: SetCurrent( (Pad *) 0 );
245: p->back = Sentinel.back;
246: p->back->front = p;
247: p->front = &Sentinel;
248: Sentinel.back = p;
249: if( PadSized(p->rect) ) SetCurrent(p);
250: }
251:
252: Unlink(p)
253: register Pad *p;
254: {
255: if( p == Current ) SetCurrent( (Pad *) 0 );
256: p->back->front = p->front;
257: p->front->back = p->back;
258: p->front = p->back = 0; /* redundant - but caught an mcc bug! */
259: }
260:
261: FrontLink(p)
262: register Pad *p;
263: {
264: if( !p ) return;
265: Unlink(p);
266: Linkin(p);
267: }
268:
269: PaintForward( r, p )
270: Rectangle r;
271: register Pad *p;
272: {
273: for( ; p != &Sentinel; p = p->front ){
274: if( rectXrect(r, p->rect) && Covered(p)!=COMPLETE ){
275: if( !ClipPaint( r, p ) )
276: r = boundrect(r,p->rect);
277: }
278: jerqsync();
279: }
280: }
281:
282: Refresh( r )
283: Rectangle r;
284: {
285: rectf( &display, r, F_CLR );
286: PaintForward( r, Sentinel.front );
287: }
288:
289: char NewString[] = "<new>";
290:
291: void P_Define( p, o )
292: register Pad *p;
293: long o;
294: {
295: if( !p ){
296: p = salloc(Pad); /* zeros */
297: p->sentinel.up = p->sentinel.down = &p->sentinel;
298: p->sentinel.ptop = 255;
299: Linkin(p);
300: p->object = o;
301: p->name = NewString;
302: p->sentinel.text = NewString;
303: p->tabs = 8;
304: p->selkey = 0;
305: }
306: Dirty(p);
307: }
308:
309: void P_Carte(p)
310: register Pad *p;
311: {
312: register Index i = RcvShort();
313: if( p && p->object ) p->carte = i;
314: }
315:
316: void P_Lines(p)
317: register Pad *p;
318: {
319: register long k = RcvLong();
320: if( p ){
321: if( k < p->sentinel.key ) DelLines(p);
322: p->sentinel.key = k;
323: Dirty(p);
324: }
325: }
326:
327: void P_Banner(p)
328: register Pad *p;
329: {
330: char b[256];
331:
332: RcvString(b);
333: if( p ){
334: if( p->sentinel.text != NewString ) gcfree( p->sentinel.text );
335: GCString( &p->sentinel.text, b );
336: Dirty(p);
337: }
338: }
339:
340: void P_Name(p)
341: register Pad *p;
342: {
343: char n[256];
344:
345: RcvString(n);
346: if( p ){
347: if( p->name != NewString ) gcfree( p->name );
348: GCString( &p->name, n );
349: }
350: }
351:
352: void P_Attributes(p)
353: register Pad *p;
354: {
355: register Attrib a = RcvShort();
356: if( p ) p->attributes = a;
357: }
358:
359: void P_Tabs(p)
360: register Pad *p;
361: {
362: register short t = RcvShort();
363: if( p && t>0 && t<128 ) p->tabs = t;
364: Dirty(p);
365: }
366:
367: void P_RemoveLine(p)
368: register Pad *p;
369: {
370: register long k = RcvLong();
371: register Line *l;
372:
373: if( !p ) return;
374: for( l = p->sentinel.up; ISLINE(l,p); l = l->up ){
375: if( l->key == k ){
376: DelLine( l );
377: Dirty(p);
378: return;
379: }
380: }
381:
382: }
383:
384:
385: Pad *ObjToPad(o)
386: register long o;
387: {
388: register Pad *p;
389:
390: for( p = Sentinel.back; ISPAD(p); p = p->back )
391: if( p->object == o ) return p;
392: return 0;
393: }
394:
395: Cycle()
396: {
397: register Pad *p;
398: int active = 0;
399:
400: for( p = Sentinel.back; ISPAD(p); p = p->back ){
401: if( p->ticks>0 ){
402: active++;
403: if( --p->ticks == 0 ){
404: active--;
405: HostParent = HostObject = p->object;
406: ToHost( P_CYCLE /*, garbage */ );
407: }
408: }
409: }
410: return active;
411: }
412:
413: MakeGap(p)
414: Pad *p;
415: {
416: register Line *l, *lsent = &p->sentinel;
417: register long k = RcvLong();
418: register long gap = RcvLong();
419:
420: for( l = lsent->down; l!=lsent; l = l->down )
421: if( l->key >= k ) l->key += gap;
422: }
423:
424: PadOp(op)
425: Protocol op;
426: {
427: static long LINEobj;
428: register long obj;
429: register Pad *p;
430: register short t;
431:
432: obj = op == P_NEXTLINE ? LINEobj : RcvLong();
433: p = ObjToPad( obj );
434: switch( (int) op ){
435: case P_PADDEF:
436: P_Define(p,obj);
437: break;
438: case P_ATTRIBUTE:
439: P_Attributes(p);
440: break;
441: case P_REMOVELINE:
442: P_RemoveLine(p);
443: break;
444: case P_TABS:
445: P_Tabs(p);
446: break;
447: case P_BANNER:
448: P_Banner(p);
449: break;
450: case P_CARTE:
451: P_Carte(p);
452: break;
453: case P_LINES:
454: P_Lines(p);
455: break;
456: case P_NAME:
457: P_Name(p);
458: break;
459: case P_CLEAR:
460: DelLines(p);
461: Dirty(p);
462: break;
463: case P_MAKECURRENT:
464: MakeCurrent(p);
465: break;
466: case P_LINE:
467: LINEobj = obj;
468: case P_NEXTLINE:
469: PutLine(p,op);
470: break;
471: case P_CREATELINE:
472: CreateLine(p);
473: break;
474: case P_DELETE:
475: if( p ) p->attributes |= USERCLOSE;
476: DeletePad(p);
477: break;
478: case P_MAKEGAP:
479: MakeGap(p);
480: break;
481: case P_ALARM:
482: t = RcvShort();
483: if(p){
484: if( !(p->ticks = t) ){
485: HostParent = HostObject = p->object;
486: ToHost( P_CYCLE /*, garbage */ );
487: }
488: }
489: break;
490: default:
491: ProtoErr( "PadOp(): " );
492: }
493: }
494:
495: PickOp()
496: {
497: register Pad *p;
498: Index i;
499:
500: i = RcvShort();
501: p = PickPad(PickPoint(IndexToStr(i)));
502: MakeCurrent(p);
503: while( butts ) waitMOUSE();
504: if( p && (HostParent = HostObject = p->object) ){
505: FlashBorder(p);
506: PutRemote(P_PICK);
507: HostAction( &i );
508: }
509: }
510:
511: Pad *PickPad(pt)
512: Point pt;
513: {
514: register Pad *p;
515:
516: for( p = Sentinel.back; ISPAD(p); p = p->back )
517: if( PadSized(p->rect) && ptinrect(pt,p->rect) )
518: return p;
519: return 0;
520: }
521:
522: DeletePick()
523: {
524: DeletePad(PickPad(PickPoint(0L)));
525: }
526:
527: DelLines(p)
528: register Pad *p;
529: {
530: if( !p ) return;
531: while( ISLINE(p->sentinel.up,p) )
532: DelLine( p->sentinel.up );
533: }
534:
535: DeletePad(p)
536: register Pad *p;
537: {
538: Rectangle r;
539: register Line *l, *lu;
540:
541: if( !p ) return;
542: if( DirtyPad == p ) Dirty((Pad*) 0);
543: if( p->attributes&USERCLOSE ){
544: HostParent = HostObject = p->object;
545: ToHost( P_USERCLOSE /*, garbage */ );
546: if( p->attributes&DONT_CLOSE ) return;
547: DelLines( p );
548: Unlink( p );
549: if( p->sentinel.text != NewString ) gcfree( p->sentinel.text );
550: if( p->name != NewString ) gcfree( p->name );
551: free(p);
552: } else {
553: if( p->attributes&DONT_CLOSE ) return;
554: for( l = p->sentinel.up; ISLINE(l,p); l = lu ){
555: lu = l->up;
556: if( !(l->attributes&DONT_CUT) ) DelLine(l);
557: }
558: }
559: if( Current == p ) SetCurrent((Pad *) 0);
560: if( Selected.line && Selected.pad == p ) Selected.line = 0;
561: r = p->rect;
562: p->rect = ZRectangle;
563: Refresh( r );
564: }
565:
566: Select(l, p)
567: register Line *l;
568: register Pad *p;
569: {
570: if( Selected.line == l ) return;
571: if( Selected.line ){
572: if( Selected.pad != p )
573: Selected.pad->selkey = Selected.line->key;
574: switch( (int) Covered(Selected.pad) ){
575: case COMPLETE:
576: break;
577: case CLEAR:
578: LineXOR(Selected.line);
579: break;
580: case PARTIAL:
581: Selected.line = 0;
582: Refresh(Selected.pad->rect);
583: }
584: }
585: if( Selected.pad = p )
586: p->selkey = 0;
587: if( Selected.line = l )
588: LineXOR(l);
589: }
590:
591: MakeCurrent(p)
592: register Pad *p;
593: {
594: register paint;
595: register Line *l;
596:
597: if( !p ) return;
598: if( Selected.line && Selected.pad!=p ) Select((Line*)0, (Pad*)0);
599: paint = Covered(p) != CLEAR;
600: if( !PadSized(p->rect) ){
601: if( Selected.line ) Select((Line*)0, (Pad*)0);
602: if( !PadSized(p->rect = clipgetrect(p->sentinel.text))) return;
603: paint = 1;
604: }
605: if( p == Current ) return;
606: FrontLink(p);
607: if( paint ) Paint(p);
608: l = &p->sentinel;
609: if( p->selkey )
610: while( ISLINE(l->up, p) ){
611: l = l->up;
612: if( l->key == p->selkey ){
613: Select(l, p);
614: break;
615: }
616: }
617: }
618:
619: Relocate(p,r)
620: Pad *p;
621: Rectangle r;
622: {
623: Rectangle bounding;
624:
625: if( !PadSized(r) ) return;
626: MakeCurrent(p); /* bug - used to be FrontLink(p); */
627: bounding = boundrect( r, p->rect );
628: p->rect = r;
629: Refresh( bounding );
630: }
631:
632: Move(){
633: register Pad *p = PickPad(PickPoint(0L));
634:
635: if( !p ) return;
636: Relocate( p, moverect(p->rect, PadSpace) );
637: }
638:
639: Reshape()
640: {
641: register Pad *p = PickPad(PickPoint(0L));
642:
643: if( !p ) return;
644: while( button123() ) waitMOUSE();
645: Relocate( p, clipgetrect(0L) );
646: }
647:
648: Rectangle NewSpace;
649: Point Scale( p )
650: Point p;
651: {
652: #define fo PadSpace.origin
653: #define fc PadSpace.corner
654: #define to NewSpace.origin
655: #define tc NewSpace.corner
656: #define SCALE(xy) p.xy = to.xy + muldiv( p.xy-fo.xy, tc.xy-to.xy, fc.xy-fo.xy );
657:
658: SCALE(x);
659: SCALE(y);
660: return p;
661: }
662:
663: #define KBDLEN 90
664: char KBDStr[KBDLEN]= "\1";
665:
666: PadClip()
667: {
668: register Pad *p;
669:
670: KBDrect = NewSpace = display.rect;
671: KBDrect.origin.y = NewSpace.corner.y -= fontheight(&defont);
672: KBDrect.origin.x += 2;
673: for( p = Sentinel.back; ISPAD(p); p = p->back ){
674: p->rect.origin = Scale( p->rect.origin );
675: p->rect.corner = Scale( p->rect.corner );
676: if( !PadSized(p->rect) ){
677: p->rect = ZRectangle;
678: if( p == Selected.pad ){
679: Selected.pad = 0;
680: Selected.line = 0;
681: }
682: }
683: }
684: Refresh( PadSpace = NewSpace );
685: PaintKBD();
686: }
687:
688: InvertKBDrect(s1, s2)
689: char *s1, *s2;
690: {
691: char buf[300];
692:
693: strcpy( buf, s1 );
694: strcat( buf, s2 );
695: rectf( &display, KBDrect, F_CLR );
696: string(&defont, buf, &display, KBDrect.origin, F_XOR);
697: rectf( &display, KBDrect, F_XOR );
698: }
699:
700: PaintKBD()
701: {
702: rectf( &display, KBDrect, F_CLR );
703: string(&defont, KBDStr, &display, KBDrect.origin, F_XOR);
704: }
705:
706: #define PAD_TO_SH (1L)
707: #define LINE_TO_SH (2L)
708: CarriageReturn(obj)
709: register long obj;
710: {
711: register char *kbds = KBDStr;
712: register Line *l, *lsent;
713: register long ct;
714:
715: kbds[strlen(kbds)-1] = '\0';
716: if( obj == LINE_TO_SH ){
717: PutRemote(P_SHELL);
718: SendLong(0L); /* common protocol */
719: SendLong(0L);
720: SendString(kbds+1);
721: SendLong(1L);
722: SendString(Selected.line->text);
723: } else if( obj == PAD_TO_SH ){
724: PutRemote(P_SHELL);
725: SendLong(0L); /* common protocol */
726: SendLong(0L);
727: SendString(kbds+1);
728: lsent = &Current->sentinel;
729: ct = 0;
730: for(l = lsent->down; l != lsent; l = l->down)
731: ++ct;
732: SendLong(ct);
733: for(l = lsent->down; l != lsent; l = l->down)
734: SendString(l->text);
735: } else {
736: PutRemote(P_KBDSTR);
737: SendLong(Current->object);
738: SendLong(obj);
739: SendString(kbds);
740: }
741: kbds[0] = 001;
742: kbds[1] = 000;
743: }
744:
745: LayerReshaped()
746: {
747: if( P->state & (RESHAPED) ){
748: P->state &= ~(RESHAPED);
749: PadClip();
750: }
751: }
752:
753: long LiveKBD()
754: {
755: register Line *sel = Selected.line;
756: register Pad *cur = Current;
757:
758: if( KBDStr[0] == '>' && cur ){
759: if( sel ){
760: DoubleOutline(&display, sel->rect);
761: return LINE_TO_SH;
762: } else {
763: HeavyBorder(cur);
764: return PAD_TO_SH;
765: }
766: }
767: if( sel && (sel->attributes&ACCEPT_KBD) ){
768: DoubleOutline(&display, sel->rect);
769: return sel->object;
770: }
771: if( cur && (cur->attributes&ACCEPT_KBD) ){
772: HeavyBorder(cur);
773: return cur->object;
774: }
775: return 0L;
776: }
777:
778: #define CNTRL_U 025
779: KBDAppend(c)
780: register c;
781: {
782: register char *t;
783: register int len = strlen(t = KBDStr);
784:
785: if( c < 040 || (c&0200) || len >= KBDLEN ){
786: if( c == CNTRL_U ){
787: t[0] = 001;
788: t[1] = 000;
789: }
790: if( c != '\t' ) /* bug: \t when len >= KBDLEN !! */
791: return;
792: }
793: t[len-1] = c;
794: t[len] = 001;
795: t[len+1] = 000;
796: }
797:
798: typedef struct String{
799: char *s; /* pointer to string */
800: short n; /* number used, no terminal null */
801: short size; /* size of allocated area */
802: } String;
803:
804: MuxSnarf()
805: {
806: String hold;
807: register i, c;
808:
809: hold.s = 0;
810: hold.n = hold.size = 0;
811: getmuxbuf(&hold);
812: for( i = 0; i < hold.n; ++i ){
813: c = hold.s[i];
814: if( c == '\n' ) break;
815: KBDAppend(c);
816: }
817: }
818:
819: #define KBD_PAUSE 4
820: #define ESCAPE 033
821: KBDServe()
822: {
823: register char c, *t;
824: register live, lenmake, len;
825:
826: if( P->state & KBD ){
827: live = LiveKBD();
828: while( P->state & KBD ){
829: c = kbdchar();
830: if( c == ESCAPE ){
831: MuxSnarf();
832: break;
833: }
834: if( c == '\r' && live ){
835: CarriageReturn(live);
836: break;
837: }
838: len = strlen(t = KBDStr);
839: if( c == '\b' && len > 1 ){
840: t[len-2] = 001;
841: t[len-1] = 000;
842: continue;
843: }
844: KBDAppend(c);
845: }
846: PaintKBD();
847: LiveKBD();
848: }
849: }
850:
851: FoldToggle(a)
852: Attrib *a;
853: {
854: *a &= ~(TRUNCATE|FOLD);
855: *a |= NewFold;
856: Paint(Current);
857: }
858:
859: Entry *FoldEntry(a)
860: register Attrib *a;
861: {
862: static Entry e = { 0, FoldToggle, 0 };
863:
864: assert(Current);
865: if( ( (*a&(TRUNCATE|FOLD)) ? *a : Current->attributes )&TRUNCATE )
866: e.text = "fold", NewFold = FOLD;
867: else
868: e.text = "truncate", NewFold = TRUNCATE;
869: e.opand = (long) a;
870: return &e;
871: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.