![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xterm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src|
Return to xterm.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / src |
1.1 root 1: /* X Communication module for terminals which understand the X protocol.
2: Copyright (C) 1985 Free Software Foundation, Inc.
3:
4: This file is part of GNU Emacs.
5:
6: GNU Emacs is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU Emacs General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU Emacs, but only under the conditions described in the
15: GNU Emacs General Public License. A copy of this license is
16: supposed to have been given to you along with GNU Emacs so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21: /* Written by Yakim Martillo. */
22:
23: /*
24: * $Source: /u1/third_party/gnuemacs.v17/src/RCS/xterm.c,v $
25: * $Author: rlk $
26: * $Locker: $
27: * $Header: xterm.c,v 1.13 86/02/17 12:24:48 rlk Exp $
28: */
29:
30: #ifndef lint
31: static char *rcsid_TrmXTERM_c = "$Header: xterm.c,v 1.13 86/02/17 12:24:48 rlk Exp $";
32: #endif lint
33:
34: #include "config.h"
35:
36: /* This includes sys/types.h, and that somehow loses
37: if this is not done before the other system files. */
38: #include "xterm.h"
39:
40: #include <sys/time.h>
41: #include <sys/ioctl.h>
42: #include <stdio.h>
43: #include <ctype.h>
44: #include <errno.h>
45: #include <signal.h>
46: #include <strings.h>
47: #include <sys/stat.h>
48:
49: #include "dispextern.h"
50: #include "termhooks.h"
51: #include "termopts.h"
52: #include "termchar.h"
53: #include "sink.h"
54: #include "sinkmask.h"
55: /*#include <X/Xproto.h> */
56:
57: #define min(a,b) ((a)<(b) ? (a) : (b))
58: #define sigunblockx(sig) sigblock (0)
59: #define sigblockx(sig) sigblock (1 << ((sig) - 1))
60: XREPBUFFER Xxrepbuffer;
61: int pixelwidth;
62: int pixelheight;
63: int PendingExposure;
64: int PendingIconExposure;
65: #define MAXICID 80
66: char iconidentity[MAXICID];
67: #define ICONTAG "emacs@"
68: #define METABIT 0x80
69: Window XXIconWindow;
70: Bitmap XXIconMask;
71:
72: char *XXcurrentfont;
73: char *default_window;
74: int informflag;
75: extern struct display_line *DesiredScreen[], *PhysScreen[];
76: extern int initialized;
77: int XXdebug;
78: int XXpid;
79: extern int screen_garbaged;
80: int XXxoffset, XXyoffset;
81: int IconWindow;
82:
83: int WindowMapped;
84: int CurHL;
85:
86: static int flexlines; /* last line affect by dellines or */
87: /* inslines functions */
88: extern int errno;
89: int VisibleX, VisibleY; /* genuine location of cursor on screen */
90: /* if it is there */
91: static int SavedX, SavedY; /* Where the cursor was before update */
92: /* started */
93:
94: int bitblt; /* Used to track bit blt events */
95: int CursorExists; /* during updates cursor is turned off */
96: static int InUpdate; /* many of functions here may be invoked */
97: /* even if no update in progress, when */
98: /* no update is in progress the action */
99: /* can be slightly different */
100: char MouseCursor[33] ="\000\000\002\000\006\000\016\000\036\000\076\000\
101: \176\000\376\000\376\001\076\000\066\000\142\000\140\000\300\000\300\000\000\
102: \000";
103:
104: char MouseMask[33] = "\003\000\007\000\017\000\037\000\077\000\177\000\
105: \377\000\377\001\377\003\377\003\177\000\367\000\363\000\340\001\340\001\
106: \300\000";
107:
108: Display *XXdisplay;
109: FontInfo *fontinfo;
110: Window XXwindow;
111: Cursor EmacsCursor;
112:
113: char *fore_color; /* Variables to store colors */
114: char *back_color;
115: char *brdr_color;
116: char *curs_color;
117: char *mous_color;
118:
119: int fore;
120: int back;
121: int brdr;
122: int curs;
123: int mous;
124:
125: static WindowInfo windowinfo;
126: WindowInfo rootwindowinfo;
127:
128:
129:
130: static XEvent XXEvent; /* as X messages are read in they are */
131: /* stored here */
132: static XREPBUFFER XXqueue;/* Used for storing up ExposeRegion */
133: /* replies, so that the SIGIO inter- */
134: /* rupt serving routines do almost */
135: /* no writes to the X socket */
136: /*int CurHL; /* Current Highlighting actually being */
137: /* being used for bold font right now*/
138:
139: int XXborder;
140:
141:
142: extern Display *XOpenDisplay ();
143: extern Window XCreateWindow ();
144: extern Cursor XDefineCursor ();
145: extern Cursor XCreateCursor ();
146: extern FontInfo *XOpenFont ();
147:
148:
149: /* HLmode -- Changes the GX function for output strings. Could be used to
150: * change font. Check an XText library function call.
151: */
152:
153: static
154: HLmode (new)
155: int new;
156: {
157: CurHL = new;
158: }
159:
160:
161: /* External interface to control of standout mode.
162: Call this when about to modify line at position VPOS
163: and not change whether it is highlighted. */
164:
165: XTreassert_line_highlight (highlight, vpos)
166: int highlight, vpos;
167: {
168: HLmode (highlight);
169: }
170:
171: /* Call this when about to modify line at position VPOS
172: and change whether it is highlighted. */
173:
174: static
175: XTchange_line_highlight (new_highlight, vpos, first_unused_hpos)
176: int new_highlight, vpos, first_unused_hpos;
177: {
178: HLmode (new_highlight);
179: XTtopos (vpos, 0);
180: XTclear_end_of_line (0);
181: }
182:
183:
184: /* Used for starting or restarting (after suspension) the X window. Puts the
185: * cursor in a known place, update does not begin with this routine but only
186: * with a call to DoDsp. The mouse cursor is warped into the window and then
187: * the cursor is turned on.
188: */
189:
190:
191:
192: static
193: XTset_terminal_modes ()
194: {
195: int stuffpending;
196: #ifdef XDEBUG
197: fprintf (stderr, "XTset_terminal_modes\n");
198: #endif
199: InUpdate = 0;
200: stuffpending = 0;
201: if (!initialized)
202: {
203: CursorExists = 0;
204: VisibleX = 0;
205: VisibleY = 0;
206: }
207: XTclear_screen ();
208: ioctl (0, FIONREAD, &stuffpending);
209: if (stuffpending)
210: kill (XXpid, SIGIO);
211: }
212:
213: /* XTtopos moves the cursor to the correct location and checks whether an update
214: * is in progress in order to toggle it on.
215: */
216:
217: static
218: XTtopos (row, col)
219: register int row, col;
220: {
221: #ifdef XDEBUG
222: fprintf (stderr, "XTtopos\n");
223: #endif
224: cursX = col;
225: cursY = row;
226: if (InUpdate)
227: {
228: if (CursorExists)
229: {
230: CursorToggle ();
231: }
232: return; /* Generally, XTtopos will be invoked */
233: /* when InUpdate with !CursorExists */
234: /* so that wasteful XFlush is not called */
235: }
236: if ((row == VisibleY) && (col == VisibleX))
237: {
238: if (!CursorExists)
239: {
240: CursorToggle ();
241: }
242: XFlush ();
243: return;
244: }
245: if (CursorExists) CursorToggle ();
246: VisibleX = col;
247: VisibleY = row;
248: if (!CursorExists) CursorToggle ();
249: XFlush ();
250: }
251:
252: /* Used to get the terminal back to a known state after resets. Usually
253: * used when restarting suspended or waiting emacs
254: */
255:
256: static
257: cleanup ()
258: {
259: inverse_video = 0;
260: HLmode (0);
261: }
262:
263: /* wipes out numcols columns starting a current column on the current line */
264:
265: static
266: XTclear_end_of_line (first_blank)
267: register int first_blank;
268: {
269: register int numcols;
270:
271: #ifdef XDEBUG
272: fprintf (stderr, "XTclear_end_of_line\n");
273:
274: #endif
275: if (cursY < 0 || cursY >= screen_height)
276: return;
277: if (first_blank >= screen_width)
278: return;
279:
280: if (first_blank < 0)
281: first_blank = 0;
282: numcols = screen_width - first_blank;
283: if (cursY == VisibleY && VisibleX >= first_blank)
284: {
285: if (CursorExists) CursorToggle ();
286: }
287: XPixSet (XXwindow,
288: first_blank * fontinfo->width,
289: cursY * fontinfo->height,
290: fontinfo->width * numcols,
291: fontinfo->height,
292: back);
293: XTtopos (cursY, first_blank);
294: }
295:
296: static
297: XTreset_terminal_modes ()
298: {
299: #ifdef XDEBUG
300: fprintf (stderr, "XTreset_terminal_modes\n");
301: #endif
302: XTclear_screen ();
303: }
304:
305: static
306: XTclear_screen ()
307: {
308: #ifdef XDEBUG
309: fprintf (stderr, "XTclear_screen\n");
310: #endif
311: HLmode (0);
312: CursorExists = 0;
313:
314: cursX = 0;
315: cursY = 0;
316: SavedX = 0;
317: SavedY = 0;
318: VisibleX = 0;
319: VisibleY = 0;
320: XClear (XXwindow);
321: CursorToggle ();
322: if (!InUpdate)
323: XFlush ();
324: }
325:
326: /* used by dumprectangle which is usually invoked upon ExposeRegion
327: * events which come from bit blt's or moving an obscuring opaque window
328: */
329:
330: static
331: dumpchars (ActiveScreen, numcols, tempX, tempY, tempHL)
332: register struct display_line **ActiveScreen;
333: register int numcols;
334: register int tempX, tempY, tempHL;
335: {
336: if (numcols <= 0) return;
337: if (((numcols - 1) + tempX) > screen_width)
338: {
339: numcols = (screen_width - tempX) + 1;
340: }
341: if ((tempX < 0) || (tempX >= screen_width) ||
342: (tempY < 0) || (tempY >= screen_height))
343: {
344: return;
345: }
346: XText (XXwindow,
347: (tempX * fontinfo->width),
348: (tempY * fontinfo->height),
349: &ActiveScreen[tempY + 1]->body[tempX],
350: numcols,
351: fontinfo->id,
352: (tempHL ? back : fore),
353: (tempHL ? fore : back));
354: }
355:
356: /* When a line has been changed this function is called. X is so fast
357: * that the actual sequence is ignore. Rather, the new version of the
358: * line is simply output if this function is invoked while in UpDate.
359: * Sometimes writechars can be invoked when not in update if text is to
360: * be output at the end of the line. In this case the whole line is not
361: * output. Simply the new text at the current cursor position given
362: * by VisibleX,Y. The cursor is moved to the end of the new text.
363: */
364: static
365: writechars (start, end)
366: register char *start, *end;
367: {
368: register int temp_length;
369:
370: if ((cursY < 0) || (cursY >= screen_height))
371: {
372: return;
373: }
374: if (CursorExists)
375: {
376: CursorToggle ();
377: }
378: if (InUpdate)
379: {
380: if (DesiredScreen && DesiredScreen[cursY + 1])
381: {
382: temp_length = DesiredScreen[cursY + 1]->length;
383: }
384: else
385: temp_length = 0;
386: if (temp_length > 0)
387: {
388: XText (XXwindow,
389: 0,
390: (cursY * fontinfo->height),
391: &DesiredScreen[cursY + 1]->body[0],
392: temp_length,
393: fontinfo->id,
394: (CurHL ? back : fore),
395: (CurHL ? fore : back));
396: if (temp_length < screen_width)
397: {
398: XTclear_end_of_line (temp_length);
399: }
400: XTtopos (cursY, temp_length);
401: }
402: else
403: {
404: XTclear_end_of_line (0);
405: XTtopos (cursY, 0);
406: }
407: }
408: else
409: {
410: if ((VisibleX < 0) || (VisibleX >= screen_width))
411: {
412: return;
413: }
414: if ((VisibleY < 0) || (VisibleY >= screen_height))
415: {
416: return;
417: }
418: if (((end - start) + VisibleX) >= screen_width)
419: {
420: end = start + (screen_width - (VisibleX + 1));
421: }
422: if(end >= start)
423: {
424: XText (XXwindow,
425: (VisibleX * fontinfo->width),
426: (VisibleY * fontinfo->height),
427: start,
428: ((end - start) + 1),
429: fontinfo->id,
430: (CurHL ? back : fore),
431: (CurHL ? fore : back));
432: VisibleX = VisibleX + (end - start) + 1;
433: }
434: if (!CursorExists) CursorToggle ();
435: }
436: }
437:
438:
439: static
440: XTwrite_chars (start, len)
441: register char *start;
442: register int len;
443: {
444: #ifdef XDEBUG
445: fprintf (stderr, "XTwrite_chars\n");
446: #endif
447: writechars (start, start + len - 1);
448: }
449:
450: /* The following routine is for the deaf or for the pervert who prefers
451: * that his terminal flashes at him rather than beep at him.
452: */
453:
454: static int flashedback;
455:
456: static
457: XTflash ()
458: {
459: struct itimerval itimer;
460: extern int flashback ();
461:
462: #ifdef XDEBUG
463: fprintf (stderr, "XTflash\n");
464: #endif
465:
466: signal (SIGALRM, flashback);
467: getitimer (ITIMER_REAL, &itimer);
468: itimer.it_value.tv_usec += 250000;
469: itimer.it_interval.tv_sec = 0;
470: itimer.it_interval.tv_usec = 0;
471: flashedback = 0;
472: setitimer (ITIMER_REAL, &itimer, 0);
473: XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
474: screen_height * fontinfo->height, WhitePixel, ClipModeClipped,
475: GXinvert, AllPlanes);
476: XFlush ();
477: while (!flashedback) pause ();
478: }
479:
480: static
481: flashback ()
482: {
483: signal (SIGALRM, SIG_IGN);
484: XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
485: screen_height * fontinfo->height, WhitePixel, ClipModeClipped,
486: GXinvert, AllPlanes);
487: XFlush ();
488: flashedback = 1;
489: }
490:
491: /* A kludge to get a bell */
492:
493: static
494: XTfeep ()
495: {
496: #ifdef XDEBUG
497: fprintf (stderr, "XTfeep\n");
498: #endif
499: XFeep (0);
500: }
501:
502: /* Artificially creating a cursor is hard, the actual position on the
503: * screen (either where it is or last was) is tracked with VisibleX,Y.
504: * Gnu Emacs code tends to assume a cursor exists in hardward at cursX,Y
505: * and that output text will appear there. During updates, the cursor is
506: * supposed to be blinked out and will only reappear after the update
507: * finishes.
508: */
509:
510: CursorToggle ()
511: {
512: register struct display_line **ActiveScreen;
513: if (!WindowMapped)
514: {
515: CursorExists = 0;
516: return 0;
517: }
518: if ((VisibleX < 0) || (VisibleX >= screen_width) ||
519: (VisibleY < 0) || (VisibleY >= screen_height))
520: { /* Current Cursor position trash */
521: /* Not much can be done */
522: XFlush ();
523: CursorExists = 0;
524: return 0; /* Currently the return values are not */
525: /* used, but I could anticipate using */
526: /* them in the future. */
527: }
528: /* if(InUpdate && DesiredScreen)
529: ActiveScreen = DesiredScreen;
530: else*/
531: ActiveScreen = PhysScreen;
532: if (ActiveScreen && ActiveScreen[VisibleY + 1] &&
533: (VisibleX < ActiveScreen[VisibleY + 1]->length))
534: {
535: if (CursorExists)
536: {
537: XText (XXwindow,
538: VisibleX * fontinfo->width,
539: VisibleY * fontinfo->height,
540: &ActiveScreen[VisibleY + 1]->body[VisibleX], 1,
541: fontinfo->id,
542: fore, back);
543: }
544: else
545: {
546: XText (XXwindow,
547: VisibleX * fontinfo->width,
548: VisibleY * fontinfo->height,
549: &ActiveScreen[VisibleY + 1]->body[VisibleX], 1,
550: fontinfo->id,
551: back, curs);
552: }
553: }
554: else if (CursorExists)
555: {
556: XPixSet (XXwindow,
557: VisibleX * fontinfo->width,
558: VisibleY * fontinfo->height,
559: fontinfo->width, fontinfo->height, back);
560: }
561: else
562: {
563: XPixSet (XXwindow,
564: VisibleX * fontinfo->width,
565: VisibleY * fontinfo->height,
566: fontinfo->width, fontinfo->height, curs);
567: }
568: CursorExists = !CursorExists;/* Cursor has either been blinked in */
569: /* or out */
570: if (!InUpdate)
571: {
572: XFlush ();
573: }
574: return 1;
575: }
576:
577: /* This routine is used by routines which are called to paint regions */
578: /* designated by ExposeRegion events. If the cursor may be in the exposed */
579: /* region, this routine makes sure it is gone so that dumprectangle can */
580: /* toggle it back into existance if dumprectangle is invoked when not in */
581: /* the midst of a screen update. */
582: static
583: ClearCursor ()
584: {
585: if (!WindowMapped)
586: {
587: CursorExists = 0;
588: return;
589: }
590: if ((VisibleX < 0) || (VisibleX >= screen_width)
591: || (VisibleY < 0) || (VisibleY >= screen_height))
592: { /* Current Cursor position trash */
593: /* Not much can be done */
594: CursorExists = 0;
595: return;
596: }
597: XPixSet (XXwindow,
598: VisibleX * fontinfo->width,
599: VisibleY * fontinfo->height,
600: fontinfo->width, fontinfo->height,
601: back);
602: CursorExists = 0;
603: }
604:
605: static
606: XTupdate_begin ()
607: {
608: #ifdef XDEBUG
609: fprintf (stderr, "XTupdate_begin\n");
610: #endif
611:
612: InUpdate = 1;
613: if (CursorExists)
614: {
615: CursorToggle ();
616: }
617: SavedX = cursX; /* The initial"hardware" cursor position is */
618: /* saved because that is where gnu emacs */
619: /* expects the cursor to be at the end of*/
620: /* the update */
621: SavedY = cursY;
622: dumpqueue();
623: }
624:
625:
626: static
627: XTupdate_end ()
628: {
629: #ifdef XDEBUG
630: fprintf (stderr, "XTupdate_end\n");
631: #endif
632: if (CursorExists)
633: CursorToggle ();
634: InUpdate = 0;
635: dumpqueue ();
636: XTtopos (SavedY, SavedX); /* XTtopos invokes cursor toggle */
637: }
638:
639: /* Used for expose region and expose copy events. Have to get the text
640: * back into the newly blank areas.
641: */
642:
643: dumprectangle (top, left, rows, cols)
644: register int top, left, rows, cols;
645: {
646: register struct display_line **ActiveScreen;
647: register int index;
648: int localX, localY, localHL;
649: rows += top;
650: cols += left;
651: top /= fontinfo->height; /* Get row and col containing up and */
652: /* left borders of exposed region -- */
653: /* round down here*/
654: left /= fontinfo->width;
655: rows += (fontinfo->height - 1);
656: cols += (fontinfo->width - 1);
657: rows /= fontinfo->height;/* Get row and col containing bottom and */
658: /* right borders -- round up here */
659: rows -= top;
660: cols /= fontinfo->width;
661: cols -= left;
662: if (rows < 0) return;
663: if (cols < 0) return;
664: if (top > (screen_height - 1)) return;
665: if (left > (screen_width - 1)) return;
666: if ((VisibleX >= left) && (VisibleX < (left + cols)) &&
667: (VisibleY >= top) && (VisibleY < (top + rows)))
668: {
669: ClearCursor ();
670: }
671: if (InUpdate && DesiredScreen)
672: ActiveScreen = PhysScreen;
673: else if (PhysScreen)
674: ActiveScreen = PhysScreen;/* When cue is dumped in update this */
675: else
676: return;
677: /* should perhaps be DesiredScreen */
678: /* but PhysScreen is guaranteed to contain*/
679: /* date which was good for every line on */
680: /* screen. For desired screen only for */
681: /* lines which are changing. Emacs does */
682: /* not consider a line within a newly */
683: /* exposed region necessarily to have */
684: /* been changed. Emacs knows nothing */
685: /* about ExposeRegion events.*/
686: for (localY = top, index = 0;
687: (index < rows) && (localY < screen_height);
688: ++index, ++localY)
689: {
690: if ((localY < 0) || (localY >= screen_height)) continue;
691: if (!ActiveScreen[localY + 1]) continue;
692: if ((left + 1) > ActiveScreen[localY + 1]->length) continue;
693: localX = left;
694: localHL = ActiveScreen[localY + 1]->highlighted;
695: dumpchars (ActiveScreen,
696: min (cols,
697: ActiveScreen[localY + 1]->length
698: - localX),
699: localX, localY, localHL);
700: }
701: if (!InUpdate && !CursorExists) CursorToggle ();
702: /* Routine usually called */
703: /* when not in update */
704: }
705:
706: /* What sections of the window will be modified from the UpdateDisplay
707: * routine is totally under software control. Any line with Y coordinate
708: * greater than flexlines will not change during an update. This is really
709: * used only during dellines and inslines routines (scraplines and stufflines)
710: */
711: static
712: XTset_terminal_window (n)
713: register int n;
714: {
715: #ifdef XDEBUG
716: fprintf (stderr, "XTset_terminal_window\n");
717: #endif
718: if ((n <= 0) || (n > screen_height))
719: flexlines = screen_height;
720: else
721: flexlines = n;
722: }
723:
724: XTins_del_lines (vpos, n)
725: int vpos, n;
726: {
727: #ifdef XDEBUG
728: fprintf (stderr, "XTins_del_lines\n");
729: #endif
730: XTtopos (vpos, 0);
731: if (n >= 0) stufflines (n);
732: else scraplines (-n);
733:
734: }
735:
736: static
737: XTinsert_chars (start, len)
738: register char *start;
739: register int len;
740: {
741: #ifdef XDEBUG
742: fprintf (stderr, "XTinsert_chars\n");
743: #endif
744: writechars (start, start + len - 1);
745: }
746:
747: static
748: XTdelete_chars (n)
749: register int n;
750: {
751: char *msg = "***Delete Chars Called Outside of Update!!!***";
752: #ifdef XDEBUG
753: fprintf (stderr, "XTdelete_chars\n");
754: #endif
755: writechars (msg, msg + strlen (msg) - 1);
756: }
757:
758: static
759: stufflines (n)
760: register int n;
761: {
762: register int topregion, bottomregion;
763: register int length, newtop;
764:
765: if (cursY >= flexlines)
766: return;
767:
768: if (!WindowMapped)
769: {
770: bitblt = 0;
771: return;
772: }
773: if (CursorExists) CursorToggle ();
774: dumpqueue ();
775: topregion = cursY;
776: bottomregion = flexlines - (n + 1);
777: newtop = cursY + n;
778: length = (bottomregion - topregion) + 1;
779: if ((length > 0) && (newtop <= flexlines))
780: {
781: /* Should already have cleared */
782: /* queue of events associated */
783: /* with old bitblts */
784: XMoveArea (XXwindow, 0,
785: topregion * fontinfo->height,
786: 0, newtop * fontinfo->height,
787: screen_width * fontinfo->width,
788: length * fontinfo->height);
789: if (WindowMapped)
790: bitblt = 1;
791: request_sigio ();
792: XFlush ();
793: while (bitblt)
794: {
795: kill (XXpid, SIGIO);
796: }
797: unrequest_sigio ();
798: XFlush ();
799: }
800: newtop = min (newtop, (flexlines - 1));
801: length = newtop - topregion;
802: if (length > 0)
803: {
804: XPixSet (XXwindow,
805: 0,
806: topregion * fontinfo->height,
807: screen_width * fontinfo->width,
808: n * fontinfo->height,
809: back);
810: }
811: /* if (!InUpdate) CursorToggle (); */
812: }
813:
814: static
815: scraplines (n)
816: register int n;
817: {
818: if (!WindowMapped)
819: {
820: bitblt = 0;
821: return;
822: }
823:
824: if (cursY >= flexlines)
825: return;
826: if (CursorExists) CursorToggle ();
827: dumpqueue ();
828: if ((cursY + n) >= flexlines)
829: {
830: if (flexlines >= (cursY + 1))
831: {
832: XPixSet (XXwindow,
833: 0, cursY * fontinfo->height,
834: screen_width * fontinfo->width,
835: (flexlines - cursY) * fontinfo->height,
836: back);
837: }
838: }
839: else
840: {
841: XMoveArea (XXwindow,
842: 0, (cursY + n) * fontinfo->height,
843: 0, cursY * fontinfo->height,
844: screen_width * fontinfo->width,
845: (flexlines - (cursY + n)) * fontinfo->height);
846: if (WindowMapped)
847: bitblt = 1;
848: request_sigio ();
849: XFlush ();
850: while (bitblt)
851: {
852: kill (XXpid, SIGIO);
853: }
854: unrequest_sigio ();
855: XFlush ();
856: XPixSet (XXwindow, 0, (flexlines - n) * fontinfo->height,
857: screen_width * fontinfo->width,
858: n * fontinfo->height, back);
859: }
860: /* if (!InUpdate) CursorToggle (); */
861: }
862:
863: /* Substitutes for standard read routine. Under X not interested in individual
864: * bytes but rather individual packets.
865: */
866:
867: XTread_socket (sd, bufp, numchars)
868: register int sd;
869: register char *bufp;
870: register int numchars;
871: {
872:
873: int count;
874: int stuffpending;
875: int temp_width, temp_height;
876: /* typedef struct reply {XEvent event; struct reply *next} Reply;
877: Reply *replies = NULL;*/
878:
879: count = 0;
880: if (numchars <= 0)
881: { /* To keep from overflowing read buffer */
882: numchars = 1;
883: --bufp;
884: }
885: while (bitblt || XPending () != 0)
886: {
887: /* while there are more events*/
888: XNextEvent (&XXEvent);
889: switch (XXEvent.type)
890: {
891: /* case X_Reply:
892: {
893: extern char *malloc();
894: Reply *reply = (Reply *) malloc (sizeof (Reply));
895: reply->next = replies;
896: reply->event = XXEvent;
897: replies = reply;
898: break;
899: }*/
900: default:
901: break;
902: case ExposeWindow:
903: if (((XExposeEvent *)&XXEvent)->window == XXIconWindow)
904: {
905: PendingIconExposure = 1;
906: }
907: else
908: PendingExposure = 1;/* No reason to repeat */
909: /* this if several */
910: /* ExposeWindow events */
911: /* come in quick succes-*/
912: /* ion */
913: break;
914: case ExposeRegion:
915: if (PendingExposure)
916: { /* Don't bother with */
917: /* region events when */
918: /* full window event */
919: /* is pending */
920: break;
921: }
922: loadxrepbuffer (&XXEvent, &XXqueue);
923: if (XXqueue.rindex == XXqueue.windex)
924: {
925: PendingExposure = 1;
926: }
927: if ((XXqueue.rindex > XXqueue.mindex) ||
928: (XXqueue.windex > XXqueue.mindex) ||
929: (XXqueue.rindex < 0) ||
930: (XXqueue.windex < 0))
931: {
932: PendingExposure = 1;
933: }
934: break;
935: case ExposeCopy: /* For ExposeCopy sync */
936: /* will block all outgoing */
937: /* requests until this is */
938: /* decremented */
939: if (WindowMapped) bitblt = 0;
940: break;
941: case KeyPressed:
942: if (Input (((XKeyPressedEvent *) &XXEvent)->detail, bufp))
943: {
944: ++bufp;
945: ++count;
946: --numchars;
947: }
948: break;
949: case ButtonPressed:
950: switch (spacecheck (Xxrepbuffer.mindex,
951: Xxrepbuffer.rindex,
952: Xxrepbuffer.windex, 0))
953: {
954: case 0:
955: loadxrepbuffer (&XXEvent,
956: &Xxrepbuffer);
957: if (informflag)
958: {
959: *bufp++ = (char) 003; /* C-c */
960: ++count;
961: --numchars;
962: *bufp++ = (char) '\r'; /* C-m */
963: ++count;
964: --numchars;
965: }
966: break;
967: case -1:
968: break;
969: case -2:
970: default:
971: fixxrepbuffer ();
972: break;
973: }
974: break;
975: }
976: }
977: /* while (replies) {
978: Reply *reply = replies;
979: XPutBackEvent (&reply->event);
980: replies = reply->next;
981: free (reply);
982: }*/
983: if (count < 0)
984: count = 0;
985: if (CursorExists)
986: xfixscreen ();
987: return count;
988: }
989:
990: /* refresh bitmap kitchen sink icon */
991: refreshicon ()
992: {
993: if (XXIconWindow)
994: XBitmapBitsPut (XXIconWindow, 0, 0, sink_width, sink_height,
995: sink_bits, BlackPixel, WhitePixel,
996: XXIconMask, GXcopy, AllPlanes);
997: XFlush ();
998: }
999:
1000: XBitmapIcon ()
1001: {
1002: if (!IconWindow)
1003: {
1004: XSetIconWindow (XXwindow,XXIconWindow);
1005: XSelectInput (XXIconWindow, ExposeWindow);
1006: IconWindow = !IconWindow;
1007: }
1008: }
1009:
1010: XTextIcon ()
1011: {
1012: if (IconWindow)
1013: {
1014: XClearIconWindow (XXwindow);
1015: XSelectInput (XXIconWindow, NoEvent);
1016: IconWindow = !IconWindow;
1017: }
1018: }
1019:
1020: /* Interpreting incoming keycodes. Should have table modifiable as needed
1021: * from elisp.
1022: */
1023:
1024: /* Exit gracefully from gnuemacs, doing an autosave and giving a status.
1025: */
1026:
1027: XExitGracefully ()
1028: {
1029: XAutoSave();
1030: exit(70);
1031: }
1032:
1033: xfixscreen ()
1034: {
1035: register int temp_width, temp_height;
1036: register int (*func) ();
1037: register int temp_x, temp_y;
1038: dumpqueue ();
1039: func = signal (SIGIO, SIG_IGN);
1040: /* Check that the connection is in fact open. This works by doing a nop */
1041: /* (well, almost) write operation. If there is an XIOerror or a */
1042: /* SIGPIPE, exit gracefully. This fixes the loop-on-logout bug.*/
1043: XIOErrorHandler (XExitGracefully);
1044: CursorToggle();
1045: CursorToggle();
1046: XFlush ();
1047: XIOErrorHandler (0);
1048: if (PendingIconExposure)
1049: {
1050: refreshicon ();
1051: PendingIconExposure = 0;
1052: }
1053: if (PendingExposure)
1054: {
1055: PendingExposure = 0;
1056: ClearCursor ();
1057: XXqueue.rindex = 0;
1058: XXqueue.windex = 0;
1059: XQueryWindow (XXwindow, &windowinfo); /* Dangerous to do */
1060: /* writes here but */
1061: /* otherwise would */
1062: /* have to alter */
1063: /* gnu emacs display */
1064: /* routines to query */
1065: /* when screen garbaged */
1066: temp_width = (windowinfo.width / fontinfo->width);
1067: temp_height = (windowinfo.height / fontinfo->height);
1068: if (temp_width != screen_width || temp_height != screen_height)
1069: change_screen_size (temp_height, temp_width);
1070: temp_x = windowinfo.x;
1071: temp_y = windowinfo.y;
1072: if (temp_x != XXxoffset || temp_y != XXyoffset)
1073: XSetOffset (temp_x, temp_y);
1074: dumprectangle (0, 0, screen_height * fontinfo->height,
1075: screen_width * fontinfo->width);
1076: }
1077: if (!InUpdate)
1078: if (!CursorExists)
1079: CursorToggle ();
1080: (void) signal (SIGIO, func);
1081: kill (XXpid, SIGIO);
1082: }
1083:
1084:
1085: static
1086: Input (keycode, buffer)
1087: register int keycode;
1088: register char *buffer;
1089: {
1090: register short c;
1091: register int offset;
1092: extern KeyMapEntry StdMap[];
1093: offset = KeyState (keycode); /* set SHIFT, CONTROL, META */
1094: c = StdMap [keycode & ValueMask] [offset];
1095: if ((keycode & ShiftLockMask) && (c >= 'a') && (c <= 'z'))
1096: {
1097: c += 'A' - 'a';
1098: }
1099: keycode &= ValueMask; /* no longer need shift bits for anything */
1100: if (! (c & ~377))
1101: {
1102: *buffer = c;
1103: return 1;
1104: }
1105: switch (c)
1106: {
1107: /* case '\007':
1108: kill(XXpid, SIGINT);
1109: break;*/
1110: case KEYPAD:
1111: case CURSOR:
1112: switch (keycode & ValueMask)
1113: {
1114: case 0247: /* left-arrow maps to C-B */
1115: c = 002 | ((keycode & MetaMask) ? METABIT : 0);
1116: *buffer = c;
1117: return(1);
1118: case 0250: /* right-arrow maps to C-F */
1119: c = 006 | ((keycode & MetaMask) ? METABIT : 0);
1120: *buffer = c;
1121: return(1);
1122: case 0252: /* up-arrow maps to C-P */
1123: c = 020 | ((keycode & MetaMask) ? METABIT : 0);
1124: *buffer = c;
1125: return(1);
1126: case 0251: /* down-arrow maps to C-N */
1127: c = 016 | ((keycode & MetaMask) ? METABIT : 0);
1128: *buffer = c;
1129: return(1);
1130: default:
1131: return(0);
1132: }
1133: case PFX:
1134: case (short) -1:
1135: case SHFT:
1136: case CNTL:
1137: case SYMBOL:
1138: case LOCK:
1139: case FUNC1:
1140: case FUNC2:
1141: case FUNC3:
1142: case FUNC4:
1143: case FUNC5:
1144: case FUNC6:
1145: case FUNC7:
1146: case FUNC8:
1147: case FUNC9:
1148: case FUNC10:
1149: case FUNC11:
1150: case FUNC12:
1151: case FUNC13:
1152: case FUNC14:
1153: case FUNC15:
1154: case FUNC16:
1155: case FUNC17:
1156: case FUNC18:
1157: case FUNC19:
1158: case FUNC20:
1159: case E1:
1160: case E2:
1161: case E3:
1162: case E4:
1163: case E5:
1164: case E6:
1165: return 0;
1166: default:
1167: *buffer = c;
1168: return 1;
1169: }
1170: }
1171:
1172:
1173: x_term_init ()
1174: {
1175: register char *vardisplay;
1176: register char *colonpointer;
1177: register int status;
1178: extern char *getenv ();
1179: register int scratchindex;
1180: extern XTinterrupt_signal ();
1181: extern char *malloc ();
1182:
1183: vardisplay = getenv ("DISPLAY");
1184: if (!vardisplay)
1185: {
1186: fprintf (stderr, "DISPLAY environment variable must be set\n");
1187: exit (-200);
1188: }
1189: XXdisplay = XOpenDisplay (vardisplay);
1190: if (XXdisplay == (Display *) 0)
1191: {
1192: fprintf (stderr, "No X.\n");
1193: exit (-99);
1194: }
1195: dup2 (dpyno (), 0);
1196: close (dpyno ());
1197: dpyno () = 0; /* Looks a little strange? */
1198: /* check the def of the */
1199: /* macro, it is a genuine */
1200: /* lvalue */
1201: Xxrepbuffer.mindex = XREPBUFSIZE - 1;
1202: Xxrepbuffer.windex = 0;
1203: Xxrepbuffer.rindex = 0;
1204: XXqueue.mindex = XREPBUFSIZE - 1;
1205: XXqueue.windex = 0;
1206: XXqueue.rindex = 0;
1207: WindowMapped = 0;
1208: baud_rate = 9600;
1209: min_padding_speed = 10000;
1210: must_write_spaces = 1;
1211: informflag = 1;
1212: MetaFlag = 1;
1213: visible_bell = 1;
1214: interrupt_input = 1;
1215: inverse_video = 1;
1216: bitblt = 0;
1217: PendingExposure = 0;
1218: IconWindow = 0;
1219:
1220: fix_screen_hook = xfixscreen;
1221: clear_screen_hook = XTclear_screen;
1222: clear_end_of_line_hook = XTclear_end_of_line;
1223: ins_del_lines_hook = XTins_del_lines;
1224: change_line_highlight_hook = XTchange_line_highlight;
1225: insert_chars_hook = XTinsert_chars;
1226: write_chars_hook = XTwrite_chars;
1227: delete_chars_hook = XTdelete_chars;
1228: ring_bell_hook = XTfeep;
1229: reset_terminal_modes_hook = XTreset_terminal_modes;
1230: set_terminal_modes_hook = XTset_terminal_modes;
1231: update_begin_hook = XTupdate_begin;
1232: update_end_hook = XTupdate_end;
1233: set_terminal_window_hook = XTset_terminal_window;
1234: read_socket_hook = XTread_socket;
1235: topos_hook = XTtopos;
1236: /* raw_topos_hook = XTraw_topos; */
1237: reassert_line_highlight_hook = XTreassert_line_highlight;
1238: scroll_region_ok = 1; /* we'll scroll partial screens */
1239: char_ins_del_ok = 0; /* just as fast to write the line */
1240: line_ins_del_ok = 1; /* we'll just blt 'em */
1241: fast_clear_end_of_line = 1; /* X does this well */
1242: memory_below_screen = 0; /* we don't remember what scrolls
1243: off the bottom */
1244: dont_calculate_costs = 1;
1245:
1246: fore = BlackPixel;
1247: back = WhitePixel;
1248: brdr = BlackPixel;
1249: mous = BlackPixel;
1250: curs = BlackPixel;
1251:
1252: fore_color = "black";
1253: back_color = "white";
1254: brdr_color = "black";
1255: mous_color = "black";
1256: curs_color = "black";
1257:
1258: XXpid = getpid ();
1259: XXcurrentfont = malloc (sizeof ("vtsingle") + 1);
1260: default_window = "=80x24+1+1";
1261: signal (SIGIO, XTread_socket);
1262: signal (SIGPIPE, XExitGracefully);
1263: if (XXcurrentfont == (char *) 0)
1264: {
1265: fprintf (stderr, "Memory allocation failure.\n");
1266: exit (-150);
1267: }
1268: strcpy (&XXcurrentfont[0], "vtsingle");
1269: XQueryWindow (RootWindow, &rootwindowinfo);
1270: strncpy (iconidentity, ICONTAG, MAXICID);
1271: XXborder = 1;
1272: screen_width = 80;
1273: screen_height = 66;
1274: XXxoffset = 0;
1275: XXyoffset = 0;
1276: XXdebug = 0;
1277: fontinfo = XOpenFont (&XXcurrentfont[0]);
1278: if (fontinfo == (FontInfo *) 0)
1279: {
1280: fprintf (stderr, "No font\n");
1281: exit (-98);
1282: }
1283: pixelwidth = screen_width * fontinfo->width + 1;
1284: pixelheight = screen_height * fontinfo->height + 1;
1285: XXwindow = XCreateWindow (RootWindow,
1286: XXxoffset /* Absolute horizontal offset */,
1287: XXyoffset /* Absolute Vertical offset */,
1288: pixelwidth, pixelheight,
1289: XXborder, BlackPixmap, WhitePixmap);
1290: if (!XXwindow)
1291: {
1292: fprintf (stderr, "Unable to create window.\n");
1293: exit (-97);
1294: }
1295:
1296: XXIconWindow = XCreateWindow (RootWindow, 0, 0, sink_width, sink_height,
1297: 2, WhitePixmap, (Pixmap) NULL);
1298:
1299: if (!XXIconWindow)
1300: {
1301: fprintf (stderr, "Unable to create icon window.\n");
1302: fflush (stderr);
1303: exit (-97);
1304: }
1305: XSelectInput (XXIconWindow, NoEvent);
1306: XXIconMask = XStoreBitmap(sink_mask_width, sink_mask_height, sink_mask_bits);
1307:
1308: XSelectInput (XXwindow, NoEvent);
1309: XSetResizeHint (XXwindow, fontinfo->width * 10, fontinfo->height *5,
1310: fontinfo->width, fontinfo->height);
1311:
1312: if (gethostname (&iconidentity[sizeof (ICONTAG) - 1],
1313: (MAXICID - 1) - sizeof (ICONTAG)))
1314: {
1315: iconidentity[sizeof (ICONTAG) - 2] = '\0';
1316: }
1317: XStoreName (XXwindow, &iconidentity[0]);
1318:
1319: EmacsCursor = XCreateCursor (16, 16, MouseCursor, MouseMask,
1320: 0, 0, BlackPixel, WhitePixel, GXcopy);
1321: XDefineCursor (XXwindow, EmacsCursor);
1322: /* Dirty kluge so maybe things will work right */
1323: XBitmapIcon();
1324: XTextIcon();
1325: flexlines = screen_height;
1326: if (!initialized)
1327: XPopUpWindow ();
1328: setxterm ();
1329: }
1330:
1331:
1332: /* Process all queued ExposeRegion events. */
1333: static
1334: dumpqueue ()
1335: {
1336: register int i;
1337: XExposeRegionEvent r;
1338: if ((XXqueue.rindex > XXqueue.mindex) ||
1339: (XXqueue.windex > XXqueue.mindex) ||
1340: (XXqueue.rindex < 0) ||
1341: (XXqueue.windex < 0))
1342: {
1343: PendingExposure = 1;
1344: }
1345: else
1346: while (XXqueue.rindex != XXqueue.windex)
1347: {
1348: if (CursorExists)
1349: CursorToggle ();
1350: unloadxrepbuffer (&r, &XXqueue);
1351: dumprectangle (r.y, r.x, r.height, r.width);
1352: }
1353: }
1354:
1355:
1356:
1357: XSetFlash ()
1358: {
1359: ring_bell_hook = XTflash;
1360: }
1361:
1362: XSetFeep ()
1363: {
1364: ring_bell_hook = XTfeep;
1365: }
1366:
1367:
1368: XNewFont (newname)
1369: register char *newname;
1370: {
1371: FontInfo *temp;
1372: int (*func) ();
1373: func = signal (SIGIO, SIG_IGN);
1374: XFlush ();
1375: if (XXdebug)
1376: fprintf (stderr, "Request id is %d\n", XXdisplay->request);
1377: temp = XOpenFont (newname);
1378: if (temp == (FontInfo *) 0)
1379: {
1380: (void) signal (SIGIO, func);
1381: if (QLength () > 0)
1382: {
1383: kill (XXpid, SIGIO);
1384: }
1385: return -1;
1386: }
1387: XCloseFont (fontinfo);
1388: fontinfo = temp;
1389: (void) signal (SIGIO, func);
1390: XSetResizeHint (XXwindow, fontinfo->width * 10, fontinfo->height *5,
1391: fontinfo->width, fontinfo->height);
1392: XSetWindowSize (screen_height, screen_width);
1393: if (QLength () > 0)
1394: {
1395: kill (XXpid, SIGIO);
1396: }
1397: return 0;
1398: }
1399:
1400: XFlipColor ()
1401: {
1402: Pixmap temp;
1403: int tempcolor;
1404: char *tempname;
1405: int (*func) ();
1406: Cursor temp_curs;
1407: CursorToggle ();
1408: func = signal (SIGIO, SIG_IGN);
1409: temp = XMakeTile(fore);
1410: XChangeBackground (XXwindow, temp);
1411: XFreePixmap (temp);
1412: temp = XMakeTile (back);
1413: if (XXborder)
1414: XChangeBorder (XXwindow, temp);
1415: XFreePixmap(temp);
1416: brdr = back;
1417: brdr_color = back_color;
1418: tempcolor = fore;
1419: fore = back;
1420: back = tempcolor;
1421: tempname = fore_color ;
1422: fore_color = back_color;
1423: back_color = tempname;
1424: /* XPixFill (XXwindow, 0, 0, screen_width * fontinfo->width,
1425: screen_height * fontinfo->height, back, ClipModeClipped,
1426: GXcopy, AllPlanes);
1427: dumprectangle(0, 0, screen_height * fontinfo->height,
1428: screen_width * fontinfo -> width);*/
1429: XRedrawDisplay();
1430: if (curs == WhitePixel)
1431: {
1432: curs = BlackPixel;
1433: curs_color = "black";
1434: }
1435: else if (curs == BlackPixel)
1436: {
1437: curs = WhitePixel;
1438: curs_color = "white";
1439: }
1440: if (mous == WhitePixel)
1441: {
1442: mous = BlackPixel;
1443: mous_color = "black";
1444: }
1445: else if (mous == BlackPixel)
1446: {
1447: mous = WhitePixel;
1448: mous_color = "white";
1449: }
1450: temp_curs = XCreateCursor(16, 16, MouseCursor, MouseMask, 0, 0,
1451: mous, back, GXcopy);
1452: XUndefineCursor (XXwindow);
1453: XDefineCursor (XXwindow, temp_curs);
1454: XFreeCursor (EmacsCursor);
1455: (void) signal (SIGIO, func);
1456: bcopy (&temp_curs, &EmacsCursor, sizeof (Cursor));
1457: CursorToggle ();
1458: XFlush ();
1459: }
1460:
1461: XSetOffset (xoff, yoff)
1462: register int xoff, yoff;
1463: {
1464: if (xoff < 0)
1465: {
1466: XXxoffset = rootwindowinfo.width + (++xoff) - pixelwidth - 4;
1467: }
1468: else
1469: {
1470: XXxoffset = xoff;
1471: }
1472: if (yoff < 0)
1473: {
1474: XXyoffset
1475: = rootwindowinfo.height + (++yoff) - pixelheight - 4;
1476: }
1477: else
1478: {
1479: XXyoffset = yoff;
1480: }
1481: XMoveWindow (XXwindow, XXxoffset, XXyoffset);
1482: /* XWarpMouse (XXwindow, pixelwidth >> 1, pixelheight >> 1); */
1483: }
1484:
1485: XSetWindowSize (rows, cols)
1486: register int rows, cols;
1487: {
1488: if (rows < 5) rows = 66;
1489: if (cols < 5) cols = 80;
1490: pixelwidth = cols * fontinfo->width + 1;
1491: pixelheight = rows * fontinfo->height + 1;
1492: XChangeWindow (XXwindow, pixelwidth, pixelheight);
1493: XFlush ();
1494: change_screen_size (rows, cols);
1495: PendingExposure = 0;
1496: }
1497:
1498: XPopUpWindow ()
1499: {
1500: if (WindowMapped)
1501: return;
1502: if(!x_edges_specified)
1503: Fx_rubber_band ();
1504: bitblt = 0;
1505: CursorExists = 0;
1506: VisibleX = 0;
1507: VisibleY = 0;
1508: WindowMapped = 1;
1509: XMapWindow (XXwindow);
1510: dumprectangle (0, 0, screen_height * fontinfo->height,
1511: screen_width * fontinfo->width);
1512: XSelectInput (XXwindow, KeyPressed | ExposeWindow |
1513: ButtonPressed | ExposeRegion | ExposeCopy);
1514: /* XWarpMouse(XXwindow, pixelwidth >> 1, pixelheight >> 1);*/
1515: XTtopos (0, 0);
1516: /* XRedrawDisplay();*/
1517: XFlush ();
1518: }
1519:
1520: spacecheck (mindex, rindex, windex, minfreespace)
1521: register int mindex, rindex, windex, minfreespace;
1522: {
1523: if ((rindex > mindex) || (windex > mindex))
1524: {
1525: fprintf (stderr, "Fatal Mouse Buffer Error.\n");
1526: fprintf (stderr, "%d = mindex, %d = rindex, %d = windex\n",
1527: mindex, rindex, windex);
1528: return -2;
1529: }
1530: if (windex >= rindex)
1531: {
1532: if ((mindex - (windex - rindex)) > minfreespace)
1533: return 0;
1534: }
1535: else
1536: {
1537: if (((rindex - windex) - 1) > minfreespace)
1538: return 0;
1539: }
1540: return -1;
1541: }
1542:
1543: loadxrepbuffer (p_xrep, p_buffer)
1544: register XEvent *p_xrep;
1545: register XREPBUFFER *p_buffer;
1546: {
1547: p_buffer->xrep[p_buffer->windex] = *p_xrep;
1548: if (p_buffer->windex == p_buffer->mindex)
1549: p_buffer->windex = 0;
1550: else
1551: p_buffer->windex++;
1552: }
1553:
1554: unloadxrepbuffer (p_xrep, p_buffer)
1555: register XEvent *p_xrep;
1556: register XREPBUFFER *p_buffer;
1557: {
1558: if (p_buffer->windex == p_buffer->rindex)
1559: return -1;
1560: *p_xrep = p_buffer->xrep[p_buffer->rindex];
1561: if (p_buffer->rindex == p_buffer->mindex)
1562: p_buffer->rindex = 0;
1563: else
1564: p_buffer->rindex++;
1565: return 0;
1566: }
1567:
1568: fixxrepbuffer ()
1569: {
1570: Xxrepbuffer.mindex = XREPBUFSIZE - 1;
1571: Xxrepbuffer.windex = 0;
1572: Xxrepbuffer.rindex = 0;
1573: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.