![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to line.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / miscellany / less|
Return to line.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / miscellany / less |
1.1 root 1: /*
2: * Routines to manipulate the "line buffer".
3: * The line buffer holds a line of output as it is being built
4: * in preparation for output to the screen.
5: * We keep track of the PRINTABLE length of the line as it is being built.
6: */
7:
8: #include "less.h"
9:
10: static char linebuf[1024]; /* Buffer which holds the current output line */
11: static char *curr; /* Pointer into linebuf */
12: static int column; /* Printable length, accounting for
13: backspaces, etc. */
14: /*
15: * A ridiculously complex state machine takes care of backspaces
16: * when in BS_UNDERLINE mode. The complexity arises from the attempt
17: * to deal with all cases, especially involving long lines with underlining.
18: * There are still some cases which will break it.
19: *
20: * There are four states:
21: * UL_NORMAL is the normal state (not in underline mode).
22: * UL_YES means we are in underline mode. We expect to get
23: * either a sequence like "_\bX" or "X\b_" to continue
24: * underline mode, or just some ordinary characters
25: * (no backspaces) to end underline mode.
26: * UL_X means we are one character after UL_YES
27: * (we have gotten the '_' in "_\bX" or the 'X' in "X\b_").
28: * UL_XB means we are one character after UL_X
29: * (we have gotten the backspace in "_\bX" or "X\b_";
30: * we expect one more ordinary character,
31: * which will put us back in state UL_YES).
32: */
33: static int ul_state; /* Currently in underline mode? */
34: #define UL_NORMAL 0 /* Not in underline mode */
35: #define UL_YES 1 /* In underline, need next char */
36: #define UL_X 2 /* In underline, got char, need \b */
37: #define UL_XB 3 /* In underline, got char & \b, need one more */
38:
39: public char *line; /* Pointer to the current line.
40: Usually points to linebuf. */
41:
42: extern int bs_mode;
43: extern int tabstop;
44: extern int ul_width, ue_width;
45: extern int sc_width, sc_height;
46:
47: /*
48: * Rewind the line buffer.
49: */
50: public void
51: prewind()
52: {
53: line = curr = linebuf;
54: ul_state = UL_NORMAL;
55: column = 0;
56: }
57:
58: /*
59: * Append a character to the line buffer.
60: * Expand tabs into spaces, handle underlining.
61: * Returns 0 if ok, 1 if couldn't fit in buffer.
62: */
63:
64: #define NEW_COLUMN(newcol) if ((newcol) + ((ul_state)?ue_width:0) > sc_width) \
65: return (1); else column = (newcol)
66:
67: public int
68: pappend(c)
69: int c;
70: {
71: if (c == '\0')
72: {
73: /*
74: * Terminate underline mode, if necessary.
75: * Append a '\0' to the end of the line.
76: */
77: switch (ul_state)
78: {
79: case UL_X:
80: curr[0] = curr[-1];
81: curr[-1] = UE_CHAR;
82: curr++;
83: break;
84: case UL_XB:
85: case UL_YES:
86: *curr++ = UE_CHAR;
87: break;
88: }
89: ul_state = UL_NORMAL;
90: *curr = '\0';
91: return (0);
92: }
93:
94: if (curr > linebuf + sizeof(linebuf) - 12)
95: /*
96: * Almost out of room in the line buffer.
97: * Don't take any chances.
98: * {{ Linebuf is supposed to be big enough that this
99: * will never happen, but may need to be made
100: * bigger for wide screens or lots of backspaces. }}
101: */
102: return (1);
103:
104: if (bs_mode == BS_UNDERLINE)
105: {
106: /*
107: * Advance the state machine.
108: */
109: switch (ul_state)
110: {
111: case UL_NORMAL:
112: if (curr <= linebuf + 1 || curr[-1] != '\b')
113: break;
114: if (c != '_' && curr[-2] != '_')
115: {
116: curr -= 2;
117: break;
118: }
119:
120: /*
121: * We have either "_\bX" or "X\b_" (including
122: * the current char). Switch into underline mode.
123: */
124: if (column + ul_width + ue_width + 1 >= sc_width)
125: /*
126: * Not enough room left on the screen to
127: * enter and exit underline mode.
128: */
129: return (1);
130:
131: if (ul_width > 0 &&
132: curr > linebuf + 2 && curr[-3] == ' ')
133: {
134: /*
135: * Special case for magic cookie terminals:
136: * if the previous char was a space, replace
137: * it with the "enter underline" sequence.
138: */
139: curr[-3] = UL_CHAR;
140: column += ul_width-1;
141: } else
142: {
143: curr[-1] = curr[-2];
144: curr[-2] = UL_CHAR;
145: column += ul_width;
146: curr++;
147: }
148: /* Fall thru */
149: case UL_XB:
150: /*
151: * Termination of a sequnce "_\bX" or "X\b_".
152: */
153: if (c == '_')
154: c = curr[-2];
155: curr -= 2;
156: ul_state = UL_YES;
157: break;
158: case UL_YES:
159: if (column + ue_width + 1 >= sc_width)
160: /*
161: * We have just barely enough room to
162: * exit underline mode.
163: */
164: return (1);
165: ul_state = UL_X;
166: break;
167: case UL_X:
168: if (c == '\b')
169: ul_state = UL_XB;
170: else
171: {
172: /*
173: * Exit underline mode.
174: * We have to shuffle the chars a bit
175: * to make this work.
176: */
177: curr[0] = curr[-1];
178: curr[-1] = UE_CHAR;
179: column += ue_width;
180: if (ul_width > 0 && curr[0] == ' ')
181: /*
182: * Another special case for magic
183: * cookie terminals: if the next
184: * char is a space, replace it
185: * with the "exit underline" sequence.
186: */
187: column--;
188: else
189: curr++;
190: ul_state = UL_NORMAL;
191: }
192: break;
193: }
194: }
195:
196: if (c == '\t')
197: {
198: /*
199: * Expand a tab into spaces.
200: */
201: do
202: {
203: NEW_COLUMN(column+1);
204: } while ((column % tabstop) != 0);
205: *curr++ = '\t';
206: return (0);
207: }
208:
209: if (c == '\b')
210: {
211: if (bs_mode == BS_CONTROL)
212: {
213: /*
214: * Treat backspace as a control char: output "^H".
215: */
216: NEW_COLUMN(column+2);
217: *curr++ = ('H' | 0200);
218: } else
219: {
220: /*
221: * Output a real backspace.
222: */
223: column--;
224: *curr++ = '\b';
225: }
226: return (0);
227: }
228:
229: if (control_char(c))
230: {
231: /*
232: * Put a "^X" into the buffer.
233: * The 0200 bit is used to tell put_line() to prefix
234: * the char with a ^. We don't actually put the ^
235: * in the buffer because we sometimes need to move
236: * chars around, and such movement might separate
237: * the ^ from its following character.
238: */
239: NEW_COLUMN(column+2);
240: *curr++ = (carat_char(c) | 0200);
241: return (0);
242: }
243:
244: /*
245: * Ordinary character. Just put it in the buffer.
246: */
247: NEW_COLUMN(column+1);
248: *curr++ = c;
249: return (0);
250: }
251:
252: /*
253: * Analogous to forw_line(), but deals with "raw lines":
254: * lines which are not split for screen width.
255: * {{ This is supposed to be more efficient than forw_line(). }}
256: */
257: public POSITION
258: forw_raw_line(curr_pos)
259: POSITION curr_pos;
260: {
261: register char *p;
262: register int c;
263: POSITION new_pos;
264:
265: if (curr_pos == NULL_POSITION || ch_seek(curr_pos) ||
266: (c = ch_forw_get()) == EOF)
267: return (NULL_POSITION);
268:
269: p = linebuf;
270:
271: for (;;)
272: {
273: if (c == '\n' || c == EOF)
274: {
275: new_pos = ch_tell();
276: break;
277: }
278: if (p >= &linebuf[sizeof(linebuf)-1])
279: {
280: /*
281: * Overflowed the input buffer.
282: * Pretend the line ended here.
283: * {{ The line buffer is supposed to be big
284: * enough that this never happens. }}
285: */
286: new_pos = ch_tell() - 1;
287: break;
288: }
289: *p++ = c;
290: c = ch_forw_get();
291: }
292: *p = '\0';
293: line = linebuf;
294: return (new_pos);
295: }
296:
297: /*
298: * Analogous to back_line(), but deals with "raw lines".
299: * {{ This is supposed to be more efficient than back_line(). }}
300: */
301: public POSITION
302: back_raw_line(curr_pos)
303: POSITION curr_pos;
304: {
305: register char *p;
306: register int c;
307: POSITION new_pos;
308:
309: if (curr_pos == NULL_POSITION || curr_pos <= (POSITION)0 ||
310: ch_seek(curr_pos-1))
311: return (NULL_POSITION);
312:
313: p = &linebuf[sizeof(linebuf)];
314: *--p = '\0';
315:
316: for (;;)
317: {
318: c = ch_back_get();
319: if (c == '\n')
320: {
321: /*
322: * This is the newline ending the previous line.
323: * We have hit the beginning of the line.
324: */
325: new_pos = ch_tell() + 1;
326: break;
327: }
328: if (c == EOF)
329: {
330: /*
331: * We have hit the beginning of the file.
332: * This must be the first line in the file.
333: * This must, of course, be the beginning of the line.
334: */
335: new_pos = (POSITION)0;
336: break;
337: }
338: if (p <= linebuf)
339: {
340: /*
341: * Overflowed the input buffer.
342: * Pretend the line ended here.
343: */
344: new_pos = ch_tell() + 1;
345: break;
346: }
347: *--p = c;
348: }
349: line = p;
350: return (new_pos);
351: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.