![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to c.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: /* Contains commands for C mode. Paren matching routines are in here. */
9:
10: #include "jove.h"
11: #include "re.h"
12: #include "ctype.h"
13: #include "disp.h"
14:
15: private int
16: backslashed proto((char *, int));
17: private void
18: #if defined(CMT_FMT)
19: FillComment proto((char *format)),
20: #endif
21: do_expr proto((int, int)),
22: FindMatch proto((int)),
23: parse_cmt_fmt proto((char *)),
24: strip_c proto((char *, char *));
25:
26: extern void
27: FSexpr(),
28: FList(),
29: BSexpr(),
30: BList();
31:
32: private int
33: backslashed(lp, cpos)
34: register char *lp;
35: register int cpos;
36: {
37: register int cnt = 0;
38:
39: while (cpos > 0 && lp[--cpos] == '\\')
40: cnt += 1;
41: return (cnt % 2);
42: }
43:
44: private char *p_types = "(){}[]";
45: private int mp_kind;
46: #define MP_OKAY 0
47: #define MP_MISMATCH 1
48: #define MP_UNBALANCED 2
49: #define MP_INCOMMENT 3
50:
51: void
52: mp_error()
53: {
54: switch (mp_kind) {
55: case MP_MISMATCH:
56: message("[Mismatched parentheses]");
57: break;
58:
59: case MP_UNBALANCED:
60: message("[Unbalanced parenthesis]");
61: break;
62:
63: case MP_INCOMMENT:
64: message("[Inside a comment]");
65: break;
66:
67: case MP_OKAY:
68: default:
69: return;
70: }
71: rbell();
72: }
73:
74: /* Search from the current position for the paren that matches p_type.
75: Search in the direction dir. If can_mismatch is YES then it is okay
76: to have mismatched parens. If stop_early is YES then when an open
77: paren is found at the beginning of a line, it is assumed that there
78: is no point in backing up further. This is so when you hit tab or
79: LineFeed outside, in-between procedure/function definitions, it won't
80: sit there searching all the way to the beginning of the file for a
81: match that doesn't exist. {forward,backward}-s-expression are the
82: only ones that insist on getting the "true" story. */
83:
84: Bufpos *
85: m_paren(p_type, dir, can_mismatch, can_stop)
86: int p_type;
87: register int dir;
88: int can_mismatch;
89: int can_stop;
90: {
91: static Bufpos ret;
92: Bufpos savedot,
93: *sp;
94: struct RE_block re_blk;
95: int count = 0;
96: register char *lp,
97: c;
98: char p_match,
99: re_str[128],
100: *cp,
101: quote_c = 0;
102: register int c_char;
103: int in_comment = -1,
104: stopped = NO;
105:
106: swritef(re_str, "[(){}[\\]%s]", (MajorMode(CMODE)) ? "/\"'" : "\"");
107: REcompile(re_str, 1, &re_blk);
108: if ((cp = strchr(p_types, p_type)) != NIL)
109: p_match = cp[dir];
110: else
111: complain("[Cannot match %c's]", p_type);
112: DOTsave(&savedot);
113:
114: /* To make things a little faster I avoid copying lines into
115: linebuf by setting curline and curchar by hand. Warning:
116: this is slightly to very risky. When I did this there were
117: lots of problems with procedures that expect the contents of
118: curline to be in linebuf. */
119: while (count >= 0) {
120: sp = docompiled(dir, &re_blk);
121: if (sp == 0)
122: break;
123: lp = lbptr(sp->p_line);
124:
125: curline = sp->p_line;
126: curchar = sp->p_char; /* here's where I cheat */
127:
128: c_char = curchar;
129: if (dir == FORWARD)
130: c_char -= 1;
131: if (backslashed(lp, c_char))
132: continue;
133: c = lp[c_char];
134: /* check if this is a comment (if we're not inside quotes) */
135: if (quote_c == 0 && c == '/') {
136: int new_ic = in_comment;
137:
138: /* close comment */
139: if ((c_char != 0) && lp[c_char - 1] == '*') {
140: new_ic = (dir == FORWARD) ? NO : YES;
141: if (new_ic == NO && in_comment == -1) {
142: count = 0;
143: quote_c = 0;
144: }
145: } else if (lp[c_char + 1] == '*') {
146: new_ic = (dir == FORWARD) ? YES : NO;
147: if (new_ic == NO && in_comment == -1) {
148: count = 0;
149: quote_c = 0;
150: }
151: }
152: in_comment = new_ic;
153: }
154: if (in_comment == YES)
155: continue;
156: if (c == '"' || c == '\'') {
157: if (quote_c == c)
158: quote_c = 0;
159: else if (quote_c == 0)
160: quote_c = c;
161: }
162: if (quote_c != 0)
163: continue;
164: if (isopenp(c)) {
165: count += dir;
166: if (c_char == 0 && can_stop == YES && count >= 0) {
167: stopped = YES;
168: break;
169: }
170: } else if (isclosep(c))
171: count -= dir;
172: }
173:
174: ret.p_line = curline;
175: ret.p_char = curchar;
176:
177: curline = savedot.p_line;
178: curchar = savedot.p_char; /* here's where I undo it */
179:
180: if (count >= 0)
181: mp_kind = MP_UNBALANCED;
182: else if (c != p_match)
183: mp_kind = MP_MISMATCH;
184: else
185: mp_kind = MP_OKAY;
186:
187: /* If we stopped (which means we were allowed to stop) and there
188: was an error, we clear the error so no error message is printed.
189: An error should be printed ONLY when we are sure about the fact,
190: namely we didn't stop prematurely HOPING that it was the right
191: answer. */
192: if (stopped && mp_kind != MP_OKAY) {
193: mp_kind = MP_OKAY;
194: return 0;
195: }
196: if (mp_kind == MP_OKAY || (mp_kind == MP_MISMATCH && can_mismatch == YES))
197: return &ret;
198: return 0;
199: }
200:
201: private void
202: do_expr(dir, skip_words)
203: register int dir;
204: int skip_words;
205: {
206: register char c,
207: syntax = (dir == FORWARD) ? _Op : _Cl;
208:
209: if (dir == BACKWARD)
210: b_char(1);
211: c = linebuf[curchar];
212: for (;;) {
213: if (!skip_words && ismword(c)) {
214: WITH_TABLE(curbuf->b_major)
215: if (dir == FORWARD)
216: f_word(1);
217: else
218: b_word(1);
219: END_TABLE();
220: break;
221: } else if (has_syntax(c, syntax)) {
222: FindMatch(dir);
223: break;
224: }
225: f_char(dir);
226: if (eobp() || bobp())
227: return;
228: c = linebuf[curchar];
229: }
230: }
231:
232: void
233: FSexpr()
234: {
235: register int num = arg_value();
236:
237: if (num < 0) {
238: set_arg_value(-num);
239: BSexpr();
240: }
241: while (--num >= 0)
242: do_expr(FORWARD, NO);
243: }
244:
245: void
246: FList()
247: {
248: register int num = arg_value();
249:
250: if (num < 0) {
251: set_arg_value(-num);
252: BList();
253: }
254: while (--num >= 0)
255: do_expr(FORWARD, YES);
256: }
257:
258: void
259: BSexpr()
260: {
261: register int num = arg_value();
262:
263: if (num < 0) {
264: negate_arg_value();
265: FSexpr();
266: }
267: while (--num >= 0)
268: do_expr(BACKWARD, NO);
269: }
270:
271: void
272: BList()
273: {
274: register int num = arg_value();
275:
276: if (num < 0) {
277: negate_arg_value();
278: FList();
279: }
280: while (--num >= 0)
281: do_expr(BACKWARD, YES);
282: }
283:
284: void
285: BUpList()
286: {
287: Bufpos *mp;
288: char c = (MajorMode(CMODE) ? '}' : ')');
289:
290: mp = m_paren(c, BACKWARD, NO, YES);
291: if (mp == 0)
292: mp_error();
293: else
294: SetDot(mp);
295: }
296:
297: void
298: FDownList()
299: {
300: Bufpos *sp;
301: char *sstr = (MajorMode(CMODE) ? "[{([\\])}]" : "[()]"),
302: *lp;
303:
304: sp = dosearch(sstr, FORWARD, YES);
305: if (sp != 0)
306: lp = lcontents(sp->p_line);
307: if (sp == 0 || has_syntax(lp[sp->p_char - 1], _Cl))
308: complain("[No contained expression]");
309: SetDot(sp);
310: }
311:
312: /* Move to the matching brace or paren depending on the current position
313: in the buffer. */
314:
315: private void
316: FindMatch(dir)
317: int dir;
318: {
319: register Bufpos *bp;
320: register char c = linebuf[curchar];
321:
322: if ((strchr(p_types, c) == 0) ||
323: (backslashed(linebuf, curchar)))
324: complain((char *) 0);
325: if (dir == FORWARD)
326: f_char(1);
327: bp = m_paren(c, dir, YES, NO);
328: if (dir == FORWARD)
329: b_char(1);
330: if (bp != 0)
331: SetDot(bp);
332: mp_error(); /* if there is an error the user wants to
333: know about it */
334: }
335:
336: #define ALIGN_ARGS (-1)
337:
338: /* If CArgIndent == ALIGN_ARGS then the indentation routine will
339: indent a continued line by lining it up with the first argument.
340: Otherwise, it will indent CArgIndent characters past the indent
341: of the first line of the procedure call. */
342:
343: int CArgIndent = ALIGN_ARGS;
344:
345: /* indent for C code */
346: Bufpos *
347: c_indent(brace)
348: int brace;
349: {
350: Bufpos *bp;
351: int new_indent = 0,
352: current_indent,
353: increment;
354:
355: if (brace == NO)
356: increment = CIndIncrmt;
357: else
358: increment = 0;
359: /* Find matching paren, which may be a mismatch now. If it
360: is not a matching curly brace then it is a paren (most likely).
361: In that case we try to line up the arguments to a procedure
362: or inside an of statement. */
363: if ((bp = m_paren('}', BACKWARD, YES, YES)) != NIL) {
364: Bufpos save;
365: int matching_indent;
366:
367: DOTsave(&save);
368: SetDot(bp); /* go to matching paren */
369: ToIndent();
370: matching_indent = calc_pos(linebuf, curchar);
371: SetDot(bp);
372: switch (linebuf[curchar]) {
373: case '{':
374: new_indent = matching_indent;
375: if (!bolp()) {
376: b_char(1);
377: /* If we're not within the indent then we
378: can assume that there is either a C keyword
379: line DO on the line before the brace, or
380: there is a parenthesized expression. If
381: that's the case we want to go backward
382: over that to the beginning of the expression
383: so that we can get the correct indent for
384: this matching brace. This handles wrapped
385: if statements, etc. */
386: if (!within_indent()) {
387: Bufpos savematch;
388:
389: savematch = *bp;
390:
391: do_expr(BACKWARD, NO);
392: ToIndent();
393: new_indent = calc_pos(linebuf, curchar);
394:
395: /* do_expr() calls b_paren, which
396: returns a pointer to a structure,
397: and that pointer is in BP so we
398: have to save away the matching
399: paren and restore it in the
400: following line ... sigh */
401: *bp = savematch;
402: }
403: }
404: if (brace == NO)
405: new_indent += (increment - (new_indent % increment));
406: break;
407:
408: case '(':
409: if (CArgIndent == ALIGN_ARGS) {
410: f_char(1);
411: new_indent = calc_pos(linebuf, curchar);
412: } else
413: new_indent = matching_indent + CArgIndent;
414: break;
415: }
416: SetDot(&save);
417: }
418:
419: /* new_indent is the "correct" place to indent. Now we check to
420: see if what we consider as the correct place to indent is to
421: the LEFT of where we already are. If it is, and we are NOT
422: handling a brace, then we assume that the person wants to tab
423: in further than what we think is right (for some reason) and
424: so we allow that. */
425:
426: ToIndent();
427: current_indent = calc_pos(linebuf, curchar);
428: if (brace == NO && new_indent <= current_indent)
429: new_indent = current_indent + (increment - (current_indent % increment));
430: Bol();
431: DelWtSpace(); /* nice uniform Tabs*Space* */
432: n_indent(new_indent);
433:
434: return bp;
435: }
436:
437: static void
438: re_indent(incr)
439: int incr;
440: {
441: Line *l1, *l2, *lp;
442: int c1, c2;
443: Mark *m = CurMark();
444: Bufpos savedot;
445:
446: DOTsave(&savedot);
447: l1 = curline;
448: c1 = curchar;
449: l2 = m->m_line;
450: c2 = m->m_char;
451: (void) fixorder(&l1, &c1, &l2, &c2);
452: for (lp = l1; lp != l2->l_next; lp = lp->l_next) {
453: int indent;
454:
455: SetLine(lp);
456: ToIndent();
457: indent = calc_pos(linebuf, curchar);
458: if (indent != 0 || linebuf[0] != '\0')
459: n_indent(indent + incr);
460: }
461: SetDot(&savedot);
462: }
463:
464: void
465: LRShift()
466: {
467: int amnt;
468:
469: if (is_an_arg())
470: amnt = arg_value();
471: else
472: amnt = CIndIncrmt;
473: re_indent(-amnt);
474: }
475:
476: void
477: RRShift()
478: {
479: int amnt;
480:
481: if (is_an_arg())
482: amnt = arg_value();
483: else
484: amnt = CIndIncrmt;
485: re_indent(amnt);
486: }
487:
488: #if defined(CMT_FMT)
489:
490: char CmtFmt[80] = "/*%n%! * %c%!%n */";
491:
492: void
493: Comment()
494: {
495: FillComment(CmtFmt);
496: }
497:
498: /* Strip leading and trailing white space. Skip over any imbedded '\r's. */
499:
500: private void
501: strip_c(from, to)
502: char *from,
503: *to;
504: {
505: register char *fr_p = from,
506: *to_p = to,
507: c;
508:
509: while ((c = *fr_p) != '\0') {
510: if (c == ' ' || c == '\t' || c == '\r')
511: fr_p += 1;
512: else
513: break;
514: }
515: while ((c = *fr_p) != '\0') {
516: if (c != '\r')
517: *to_p++ = c;
518: fr_p += 1;
519: }
520: while (--to_p >= to)
521: if (*to_p != ' ' && *to_p != '\t')
522: break;
523: *++to_p = '\0';
524: }
525:
526: private char open_c[20], /* the open comment format string */
527: open_pat[20], /* the search pattern for open comment */
528: l_header[20], /* the prefix for each comment line */
529: l_trailer[20], /* the suffix ... */
530: close_c[20],
531: close_pat[20];
532:
533: private char *const comment_body[] = {
534: open_c,
535: l_header,
536: l_trailer,
537: close_c
538: };
539:
540: private int nlflags;
541:
542: /* Fill in the data structures above from the format string. Don't return
543: if there's trouble. */
544:
545: private void
546: parse_cmt_fmt(str)
547: char *str;
548: {
549: register char *fmtp = str;
550: register char *const *c_body = comment_body,
551: *body_p = *c_body;
552: int c,
553: newlines = 1;
554:
555: /* pick apart the comment string */
556: while ((c = *fmtp++) != '\0') {
557: if (c != '%') {
558: *body_p++ = c;
559: continue;
560: }
561: switch(c = *fmtp++) {
562: case 'n':
563: if (newlines == 2 || newlines == 3)
564: complain("%n not allowed in line header or trailer: %s",
565: fmtp - 2);
566: nlflags += newlines;
567: *body_p++ = '\r';
568: break;
569: case 't':
570: *body_p++ = '\t';
571: break;
572: case '%':
573: *body_p++ = '%';
574: break;
575: case '!':
576: case 'c':
577: newlines += 1;
578: *body_p++ = '\0';
579: body_p = *++c_body;
580: break;
581: default:
582: complain("[Unknown comment escape: %%%c]", c);
583: break;
584: }
585: }
586: *body_p = '\0';
587: /* make search patterns */
588: strip_c(open_c, open_pat);
589: strip_c(close_c, close_pat);
590: }
591:
592: #define NL_IN_OPEN_C ((nlflags % 4) == 1)
593: #define NL_IN_CLOSE_C (nlflags >= 4)
594:
595: private void
596: FillComment(format)
597: char *format;
598: {
599: int saveRMargin,
600: indent_pos,
601: close_at_dot = NO;
602: size_t header_len,
603: trailer_len;
604: register char *cp;
605: static char inside_err[] = "[Must be between %s and %s to re-format]";
606: Bufpos open_c_pt,
607: close_c_pt,
608: tmp_bp,
609: *match_o,
610: *match_c;
611: Mark *entry_mark,
612: *open_c_mark,
613: *savedot;
614:
615: parse_cmt_fmt(format);
616: /* figure out if we're "inside" a comment */
617: if ((match_o = dosearch(open_pat, BACKWARD, 0)) == 0)
618: complain("No opening %s to match to.", open_pat);
619: open_c_pt = *match_o;
620: if ((match_c = dosearch(close_pat, BACKWARD, NO)) != 0 &&
621: inorder(open_c_pt.p_line, open_c_pt.p_char,
622: match_c->p_line, match_c->p_char))
623: complain(inside_err, open_pat, close_pat);
624: if ((match_o = dosearch(open_pat, FORWARD, NO)) != 0) {
625: tmp_bp = *match_o;
626: match_o = &tmp_bp;
627: }
628: if ((match_c = dosearch(close_pat, FORWARD, 0)) != (Bufpos *) 0)
629: close_c_pt = *match_c;
630:
631: /* Here's where we figure out whether to format from dot or from
632: the close comment. Note that we've already searched backwards to
633: find the open comment symbol for the comment we are formatting.
634: The open symbol mentioned below refers to the possible existence
635: of the next comment. There are 5 cases:
636: 1) no open or close symbol ==> dot
637: 2) open, but no close symbol ==> dot
638: 3) close, but no open ==> close
639: 4) open, close are inorder ==> dot
640: 5) open, close are not inorder ==> close */
641:
642:
643: if (match_o == (Bufpos *) 0) {
644: if (match_c == (Bufpos *) 0)
645: close_at_dot = YES;
646: } else if (match_c == (Bufpos *) 0)
647: close_at_dot = YES;
648: else if (inorder(match_o->p_line, match_o->p_char,
649: match_c->p_line, match_c->p_char))
650: close_at_dot = YES;
651: if (close_at_dot) {
652: close_c_pt.p_line = curline;
653: close_c_pt.p_char = curchar;
654: } else {
655: SetDot(match_c);
656: }
657: SetDot(&open_c_pt);
658: open_c_mark = MakeMark(curline, curchar, M_FLOATER);
659: indent_pos = calc_pos(linebuf, curchar);
660: /* search for a close comment; delete it if it exits */
661: SetDot(&close_c_pt);
662: if (close_at_dot == 0)
663: del_char(BACKWARD, (int)strlen(close_pat), NO);
664: entry_mark = MakeMark(curline, curchar, M_FLOATER);
665: ToMark(open_c_mark);
666: /* always separate the comment body from anything preceeding it */
667: LineInsert(1);
668: DelWtSpace();
669: Bol();
670: for (cp = open_c; *cp; cp++) {
671: if (*cp == '\r') {
672: if (!eolp())
673: LineInsert(1);
674: else
675: line_move(FORWARD, 1, NO);
676: } else if (*cp == ' ' || *cp == '\t') {
677: if (linebuf[curchar] != *cp)
678: insert_c(*cp, 1);
679: } else
680: /* Since we matched the open comment string on this
681: line, we don't need to worry about crossing line
682: boundaries. */
683: curchar += 1;
684: }
685: savedot = MakeMark(curline, curchar, M_FLOATER);
686:
687: /* We need to strip the line header pattern of leading white space
688: since we need to match the line after all of its leading
689: whitespace is gone. */
690: for (cp = l_header; *cp && (isspace(*cp)); cp++)
691: ;
692: header_len = strlen(cp);
693: trailer_len = strlen(l_trailer);
694:
695: /* Strip each comment line of the open and close comment strings
696: before reformatting it. */
697:
698: do {
699: Bol();
700: DelWtSpace();
701: if (header_len && strncmp(linebuf, cp, header_len)==0)
702: del_char(FORWARD, (int)header_len, NO);
703: if (trailer_len) {
704: Eol();
705: if (((size_t)curchar > trailer_len) &&
706: (strncmp(&linebuf[curchar - trailer_len],
707: l_trailer, trailer_len)==0))
708: del_char(BACKWARD, (int)trailer_len, NO);
709: }
710: if (curline->l_next != 0)
711: line_move(FORWARD, 1, NO);
712: else
713: break;
714: } while (curline != entry_mark->m_line->l_next);
715:
716: do_set_mark(savedot->m_line, savedot->m_char);
717: ToMark(entry_mark);
718: saveRMargin = RMargin;
719: RMargin = saveRMargin - strlen(l_header) -
720: strlen(l_trailer) - indent_pos + 2;
721: do_rfill(NO);
722: RMargin = saveRMargin;
723: /* get back to the start of the comment */
724: PopMark();
725: do {
726: if (curline == open_c_mark->m_line->l_next) {
727: ;
728: } else {
729: Bol();
730: n_indent(indent_pos);
731: ins_str(l_header, NO);
732: }
733: Eol();
734: if (!NL_IN_CLOSE_C && (curline == entry_mark->m_line))
735: ;
736: else
737: ins_str(l_trailer, NO);
738: if (curline->l_next != 0)
739: line_move(FORWARD, 1, NO);
740: else
741: break;
742: } while (curline != entry_mark->m_line->l_next);
743: /* handle the close comment symbol */
744: if (curline == entry_mark->m_line->l_next) {
745: line_move(BACKWARD, 1, NO);
746: Eol();
747: }
748: DelWtSpace();
749: /* if the addition of the close symbol would cause the line to be
750: too long, put the close symbol on the next line. */
751: if (!(NL_IN_CLOSE_C) &&
752: (int)strlen(close_c) + calc_pos(linebuf, curchar) > RMargin) {
753: LineInsert(1);
754: n_indent(indent_pos);
755: }
756: for (cp = close_c; *cp; cp++) {
757: if (*cp == '\r') {
758: LineInsert(1);
759: n_indent(indent_pos);
760: } else
761: insert_c(*cp, 1);
762: }
763: ToMark(open_c_mark);
764: Eol();
765: del_char(FORWARD, 1, NO);
766: }
767:
768: #endif /* CMT_FMT */
769:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.