![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to indent.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src|
Return to indent.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / src |
1.1 root 1: /* Indentation functions.
2: Copyright (C) 1985, 1986, 1987, 1988 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:
22: #include "config.h"
23: #include "lisp.h"
24: #include "buffer.h"
25: #include "indent.h"
26: #include "window.h"
27: #include "termchar.h"
28: #include "termopts.h"
29:
30: #define CR '\015'
31:
32: /* Indentation can insert tabs if this is non-zero;
33: otherwise always uses spaces */
34: int indent_tabs_mode;
35:
36: #define min(a, b) ((a) < (b) ? (a) : (b))
37: #define max(a, b) ((a) > (b) ? (a) : (b))
38:
39: /* These three values memoize the current column to avoid recalculation */
40: /* Some things in set last_known_column_point to -1
41: to mark the memoized value as invalid */
42: /* Last value returned by current_column */
43: int last_known_column;
44: /* Value of point when current_column was called */
45: int last_known_column_point;
46: /* Value of bf_modified when current_column was called */
47: int last_known_column_modified;
48:
49: extern int minibuf_prompt_width;
50:
51: DEFSIMPLE ("current-column", Fcurrent_column, Scurrent_column,
52: "Return the horizontal position of point. Beginning of line is column 0.\n\
53: This is calculated by adding together the widths of all the displayed\n\
54: representations of the character between the start of the previous line\n\
55: and point. (eg control characters will have a width of 2 or 4, tabs\n\
56: will have a variable width)\n\
57: Ignores finite width of screen, which means that this function may return\n\
58: values greater than (screen-width).\n\
59: Whether the line is visible (if `selective-display' is t) has no effect.",
60: Lisp_Int, XSETINT, current_column ())
61:
62: int
63: current_column ()
64: {
65: register int col;
66: register unsigned char *ptr, *stop, c;
67: register int tab_seen;
68: register int post_tab;
69: register int tab_width = XINT (bf_cur->tab_width);
70: int ctl_arrow = !NULL (bf_cur->ctl_arrow);
71:
72: if (point == last_known_column_point
73: && bf_modified == last_known_column_modified)
74: return last_known_column;
75:
76: ptr = &CharAt (point - 1) + 1;
77: stop = point <= bf_s1 + 1 ? bf_p1 + 1 : bf_p2 + bf_s1 + 1;
78: if (tab_width <= 0 || tab_width > 20) tab_width = 8;
79:
80: col = 0, tab_seen = 0, post_tab = 0;
81:
82: while (1)
83: {
84: if (ptr == stop)
85: {
86: if (ptr == bf_p1 + 1)
87: break;
88: stop = bf_p1 + 1;
89: ptr = stop + bf_s1;
90: if (!bf_s1) break;
91: }
92:
93: c = *--ptr;
94: if (c >= 040 && c < 0177)
95: {
96: col++;
97: }
98: else if (c == '\n')
99: break;
100: else if (c == '\r' && EQ (bf_cur->selective_display, Qt))
101: break;
102: else if (c == '\t')
103: {
104: if (tab_seen)
105: col = ((col + tab_width) / tab_width) * tab_width;
106:
107: post_tab += col;
108: col = 0;
109: tab_seen = 1;
110: }
111: else
112: col += (ctl_arrow && c < 0200) ? 2 : 4;
113: }
114:
115: if (tab_seen)
116: {
117: col = ((col + tab_width) / tab_width) * tab_width;
118: col += post_tab;
119: }
120:
121: last_known_column = col;
122: last_known_column_point = point;
123: last_known_column_modified = bf_modified;
124:
125: return col;
126: }
127:
128: ToCol (col)
129: int col;
130: {
131: register int fromcol = current_column ();
132: register int n;
133: register int tab_width = XINT (bf_cur->tab_width);
134:
135: if (fromcol > col)
136: return;
137:
138: if (tab_width <= 0 || tab_width > 20) tab_width = 8;
139:
140: if (indent_tabs_mode)
141: {
142: n = col / tab_width - fromcol / tab_width;
143: if (n)
144: {
145: while (n-- > 0)
146: InsCStr ("\t", 1);
147:
148: fromcol = (col / tab_width) * tab_width;
149: }
150: }
151:
152: while (fromcol < col)
153: {
154: InsCStr (" ", min (8, col - fromcol));
155: fromcol += min (8, col - fromcol);
156: }
157:
158: last_known_column = col;
159: last_known_column_point = point;
160: last_known_column_modified = bf_modified;
161: }
162:
163: DEFUN ("indent-to", Findent_to, Sindent_to, 1, 2, "NIndent to column: ",
164: "Indent from point with tabs and spaces until COLUMN is reached.\n\
165: Always do at least MIN spaces even if that goes past COLUMN;\n\
166: by default, MIN is zero.")
167: (col, minimum)
168: Lisp_Object col, minimum;
169: {
170: int mincol;
171:
172: CHECK_NUMBER (col, 0);
173: if (NULL (minimum))
174: XFASTINT (minimum) = 0;
175: CHECK_NUMBER (minimum, 1);
176:
177: mincol = current_column () + XINT (minimum);
178: if (mincol < XINT (col)) mincol = XINT (col);
179:
180: ToCol (mincol);
181:
182: XSETINT (col, mincol);
183: return col;
184: }
185:
186: DEFUN ("current-indentation", Fcurrent_indentation, Scurrent_indentation,
187: 0, 0, 0,
188: "Return the indentation of the current line.\n\
189: This is the horizontal position of the character\n\
190: following any initial whitespace.")
191: ()
192: {
193: Lisp_Object val;
194:
195: XFASTINT (val) = position_indentation (find_next_newline (point, -1));
196: return val;
197: }
198:
199: position_indentation (pos)
200: register int pos;
201: {
202: register int col = 0;
203: register int c;
204: register int end = NumCharacters + 1;
205: register int tab_width = XINT (bf_cur->tab_width);
206:
207: if (tab_width <= 0 || tab_width > 20) tab_width = 8;
208:
209: while (pos < end &&
210: (c = CharAt (pos),
211: c == '\t' ? (col += tab_width - col % tab_width)
212: : (c == ' ' ? ++col : 0)))
213: pos++;
214:
215: return col;
216: }
217:
218: DEFUN ("move-to-column", Fmove_to_column, Smove_to_column, 1, 1, 0,
219: "Move point to column COLUMN in the current line.\n\
220: COLUMN is calculated by adding together the widths of all the displayed\n\
221: representations of the character between the start of the previous line\n\
222: and point. (eg control characters will have a width of 2 or 4, tabs\n\
223: will have a variable width)\n\
224: Ignores finite width of screen, which means that this function may be\n\
225: passed values greater than (screen-width)")
226: (column)
227: Lisp_Object column;
228: {
229: register int pos = point;
230: register int col = current_column ();
231: register int goal;
232: register int end = NumCharacters;
233: register int tab_width = XINT (bf_cur->tab_width);
234: register int ctl_arrow = !NULL (bf_cur->ctl_arrow);
235:
236: Lisp_Object val;
237:
238: if (tab_width <= 0 || tab_width > 20) tab_width = 8;
239: CHECK_NUMBER (column, 0);
240: goal = XINT (column);
241: if (col > goal)
242: {
243: pos = find_next_newline (pos, -1);
244: col = 0;
245: }
246:
247: while (col < goal && pos <= end)
248: {
249: int c = CharAt (pos);
250: if (c == '\n')
251: break;
252: if (c == '\r' && EQ (bf_cur->selective_display, Qt))
253: break;
254: pos++;
255: col++;
256: if (c == '\t')
257: {
258: col += tab_width - 1;
259: col = col / tab_width * tab_width;
260: }
261: else if (ctl_arrow && (c < 040 || c == 0177))
262: col++;
263: else if (c < 040 || c >= 0177)
264: col += 3;
265: }
266:
267: SetPoint (pos);
268:
269: last_known_column = col;
270: last_known_column_point = point;
271: last_known_column_modified = bf_modified;
272:
273: XFASTINT (val) = col;
274: return val;
275: }
276:
277: struct position val_compute_motion;
278:
279: struct position *
280: compute_motion (from, fromvpos, fromhpos, to, tovpos, tohpos, width, hscroll, tab_offset)
281: int from, fromvpos, fromhpos, to, tovpos, tohpos;
282: register int width;
283: int hscroll, tab_offset;
284: {
285: /* Note that `cpos' is CURRENT_VPOS << SHORTBITS + CURRENT_HPOS,
286: and that CURRENT_HPOS may be negative. Use these macros
287: to extract the hpos or the vpos from cpos or anything like it.
288: */
289: #ifndef SHORT_CAST_BUG
290: #define HPOS(VAR) (short) (VAR)
291: #else
292: #define HPOS(VAR) (((VAR) & (1 << (SHORTBITS - 1)) \
293: ? ~((1 << SHORTBITS) - 1) : 0) \
294: | (VAR) & ((1 << SHORTBITS) - 1))
295: /* #define HPOS(VAR) (((VAR) & 0x8000 ? 0xffff0000 : 0) | ((VAR) & 0xffff)) */
296: #endif /* SHORT_CAST_BUG */
297:
298: #define VPOS(VAR) (((VAR) >> SHORTBITS) + (HPOS (VAR) < 0))
299:
300:
301: #ifndef TAHOE_REGISTER_BUG
302: register
303: #endif /* TAHOE_REGISTER_BUG */
304: int cpos = fromhpos + (fromvpos << SHORTBITS);
305: register int target = tohpos + (tovpos << SHORTBITS);
306: register int pos;
307: register int c;
308: register int tab_width = XFASTINT (bf_cur->tab_width);
309: register int ctl_arrow = !NULL (bf_cur->ctl_arrow);
310: int selective
311: = XTYPE (bf_cur->selective_display) == Lisp_Int
312: ? XINT (bf_cur->selective_display)
313: : !NULL (bf_cur->selective_display) ? -1 : 0;
314: int prevpos;
315:
316: if (tab_width <= 0 || tab_width > 20) tab_width = 8;
317: for (pos = from; pos < to && cpos < target; pos++)
318: {
319: prevpos = cpos;
320: c = CharAt (pos);
321: if (c >= 040 && c < 0177)
322: cpos++;
323: else if (c == '\t')
324: {
325: cpos += tab_width
326: - HPOS (cpos + tab_offset + hscroll - (hscroll > 0)
327: /* Add tab_width here to make sure positive.
328: cpos can be negative after continuation
329: but can't be less than -tab_width. */
330: + tab_width)
331: % tab_width;
332: }
333: else if (c == '\n')
334: {
335: if (selective > 0 && position_indentation (pos + 1) >= selective)
336: {
337: /* Skip any number of invisible lines all at once */
338: do
339: {
340: while (++pos < to && CharAt(pos) != '\n');
341: }
342: while (selective > 0 && position_indentation (pos + 1) >= selective);
343: pos--;
344: /* Allow for the " ..." that is displayed for them. */
345: if (!NULL (bf_cur->selective_display_ellipses))
346: {
347: cpos += 4;
348: if (HPOS (cpos) >= width)
349: cpos -= HPOS (cpos) - width;
350: }
351: }
352: else
353: cpos += (1 << SHORTBITS) - HPOS (cpos);
354: cpos -= hscroll;
355: if (hscroll > 0) cpos++; /* Count the ! on column 0 */
356: tab_offset = 0;
357: }
358: else if (c == CR && selective < 0)
359: {
360: /* In selective display mode,
361: everything from a ^M to the end of the line is invisible */
362: while (pos < to && CharAt(pos) != '\n') pos++;
363: pos--;
364: /* Allow for the " ..." that is displayed for them. */
365: if (!NULL (bf_cur->selective_display_ellipses))
366: {
367: cpos += 4;
368: if (HPOS (cpos) >= width)
369: cpos -= HPOS (cpos) - width;
370: }
371: }
372: else
373: cpos += (ctl_arrow && c < 0200) ? 2 : 4;
374:
375: if (HPOS (cpos) >= width
376: && (HPOS (cpos) > width
377: || (pos < NumCharacters
378: && CharAt (pos + 1) != '\n')))
379: {
380: if (cpos >= target)
381: break;
382: if (hscroll
383: || (truncate_partial_width_windows
384: && width + 1 < screen_width)
385: || !NULL (bf_cur->truncate_lines))
386: {
387: while (pos < to && CharAt(pos) != '\n') pos++;
388: pos--;
389: }
390: else
391: {
392: cpos += (1 << SHORTBITS) - width;
393: tab_offset += width;
394: }
395:
396: }
397: }
398:
399: val_compute_motion.bufpos = pos;
400: val_compute_motion.hpos = HPOS (cpos);
401: val_compute_motion.vpos = VPOS (cpos);
402: val_compute_motion.prevhpos = HPOS (prevpos);
403:
404: /* Nonzero if have just continued a line */
405: val_compute_motion.contin
406: = pos != from
407: && (val_compute_motion.vpos != VPOS (prevpos))
408: && c != '\n';
409:
410: return &val_compute_motion;
411: }
412: #undef HPOS
413: #undef VPOS
414:
415:
416: pos_tab_offset (w, pos)
417: struct window *w;
418: register int pos;
419: {
420: int opoint = point;
421: int col;
422:
423: if (pos == FirstCharacter || CharAt (pos - 1) == '\n')
424: return 0;
425: SetPoint (pos);
426: col = current_column ();
427: SetPoint (opoint);
428: return col - (col % (XFASTINT (w->width) - 1));
429: }
430:
431: /* start_hpos is the hpos of the first character of the buffer:
432: zero except for the minibuffer window,
433: where it is the width of the prompt. */
434:
435: struct position val_vmotion;
436:
437: struct position *
438: vmotion (from, vtarget, width, hscroll, window)
439: register int from, vtarget, width;
440: int hscroll;
441: Lisp_Object window;
442: {
443: struct position pos;
444: /* vpos is cumulative vertical position, changed as from is changed */
445: register int vpos = 0;
446: register int prevline;
447: register int first;
448: int lmargin = hscroll > 0 ? 1 - hscroll : 0;
449: int selective
450: = XTYPE (bf_cur->selective_display) == Lisp_Int
451: ? XINT (bf_cur->selective_display)
452: : !NULL (bf_cur->selective_display) ? -1 : 0;
453: int start_hpos = (EQ (window, minibuf_window) ? minibuf_prompt_width : 0);
454:
455: retry:
456: if (vtarget > vpos)
457: {
458: /* Moving downward is simple, but must calculate from beg of line
459: to determine hpos of starting point */
460: if (from > FirstCharacter && CharAt (from - 1) != '\n')
461: {
462: prevline = find_next_newline (from, -1);
463: while (selective > 0
464: && prevline > FirstCharacter
465: && position_indentation (prevline) >= selective)
466: prevline = find_next_newline (prevline - 1, -1);
467: pos = *compute_motion (prevline, 0,
468: lmargin + (prevline == 1 ? start_hpos : 0),
469: from, 10000, 10000,
470: width, hscroll, 0);
471: }
472: else
473: {
474: pos.hpos = lmargin + (from == 1 ? start_hpos : 0);
475: pos.vpos = 0;
476: }
477: return compute_motion (from, vpos, pos.hpos,
478: 1 + NumCharacters, vtarget, - (1 << (SHORTBITS - 1)),
479: width, hscroll, pos.vpos * width);
480: }
481:
482: /* To move upward, go a line at a time until
483: we have gone at least far enough */
484:
485: first = 1;
486:
487: while ((vpos > vtarget || first) && from > FirstCharacter)
488: {
489: prevline = from;
490: while (1)
491: {
492: prevline = find_next_newline (prevline - 1, -1);
493: if (prevline == FirstCharacter
494: || selective <= 0
495: || position_indentation (prevline) < selective)
496: break;
497: }
498: pos = *compute_motion (prevline, 0,
499: lmargin + (prevline == 1 ? start_hpos : 0),
500: from, 10000, 10000,
501: width, hscroll, 0);
502: vpos -= pos.vpos;
503: first = 0;
504: from = prevline;
505: }
506:
507: /* If we made exactly the desired vertical distance,
508: or if we hit beginning of buffer,
509: return point found */
510: if (vpos >= vtarget)
511: {
512: val_vmotion.bufpos = from;
513: val_vmotion.vpos = vpos;
514: val_vmotion.hpos = lmargin;
515: val_vmotion.contin = 0;
516: val_vmotion.prevhpos = 0;
517: return &val_vmotion;
518: }
519:
520: /* Otherwise find the correct spot by moving down */
521: goto retry;
522: }
523:
524: DEFUN ("vertical-motion", Fvertical_motion, Svertical_motion, 1, 1, 0,
525: "Move to start of screen line LINES lines down.\n\
526: If LINES is negative, this is moving up.\n\
527: Sets point to position found; this may be start of line\n\
528: or just the start of a continuation line.\n\
529: Returns number of lines moved; may be closer to zero than LINES\n\
530: if beginning or end of buffer was reached.")
531: (lines)
532: Lisp_Object lines;
533: {
534: struct position pos;
535: register struct window *w = XWINDOW (selected_window);
536:
537: CHECK_NUMBER (lines, 0);
538:
539: pos = *vmotion (point, XINT (lines),
540: XFASTINT (w->width) - 1
541: - (XFASTINT (w->width) + XFASTINT (w->left)
542: != XFASTINT (XWINDOW (minibuf_window)->width)),
543: /* Not XFASTINT since perhaps could be negative */
544: XINT (w->hscroll), selected_window);
545:
546: SetPoint (pos.bufpos);
547: return make_number (pos.vpos);
548: }
549:
550: syms_of_indent ()
551: {
552: DEFVAR_BOOL ("indent-tabs-mode", &indent_tabs_mode,
553: "*Indentation can insert tabs if this is non-nil.\n\
554: Setting this variable automatically makes it local to the current buffer.");
555: indent_tabs_mode = 1;
556:
557: defsubr (&Scurrent_indentation);
558: defsubr (&Sindent_to);
559: defsubr (&Scurrent_column);
560: defsubr (&Smove_to_column);
561: defsubr (&Svertical_motion);
562: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.