![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / 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: #include "jove.h"
9: #include "ctype.h"
10: #include <signal.h>
11: #ifdef ANSICODES
12: # include "termcap.h"
13: #endif
14:
15: void
16: prCTIME()
17: {
18: s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
19: }
20:
21: void
22: ChrToOct()
23: {
24: int c,
25: slow;
26:
27: c = waitchar(&slow);
28: if (slow)
29: message(key_strokes);
30: ins_str(sprint("\\%03o", c), NO);
31: }
32:
33: void
34: StrLength()
35: {
36: static char inquotes[] = "Where are the quotes?";
37: char *first = StrIndex(-1, linebuf, curchar, '"'),
38: *last = StrIndex(1, linebuf, curchar + 1, '"'),
39: c;
40: int numchars = 0;
41:
42: if (first == 0 || last == 0)
43: complain(inquotes);
44: first += 1;
45: while (first < last) {
46: c = *first++;
47: if (c == '\\') {
48: int num;
49:
50: if (!isdigit(*first))
51: first += 1;
52: else {
53: num = 3;
54: while (num-- && isdigit(*first++) && first < last)
55: ;
56: }
57: }
58: numchars += 1;
59: }
60: s_mess("%d characters", numchars);
61: }
62:
63: /* Transpos cur_char with cur_char - 1 */
64:
65: void
66: TransChar()
67: {
68: char before;
69:
70: if (curchar == 0 || (eolp() && curchar == 1))
71: complain((char *) 0); /* BEEP */
72: if (eolp())
73: b_char(1);
74: before = linebuf[curchar - 1];
75: del_char(BACKWARD, 1);
76: f_char(1);
77: insert_c(before, 1);
78: }
79:
80: /* Switch current line with previous one */
81:
82: void
83: TransLines()
84: {
85: disk_line old_prev;
86:
87: if (firstp(curline))
88: return;
89: lsave();
90: old_prev = curline->l_prev->l_dline;
91: curline->l_prev->l_dline = curline->l_dline;
92: curline->l_dline = old_prev;
93: getDOT();
94: if (!lastp(curline))
95: line_move(FORWARD, 1, NO);
96: modify();
97: }
98:
99: void
100: Leave()
101: {
102: longjmp(mainjmp, QUIT);
103: }
104:
105: /* If argument is specified, kill that many lines down. Otherwise,
106: if we "appear" to be at the end of a line, i.e. everything to the
107: right of the cursor is white space, we delete the line separator
108: as if we were at the end of the line. */
109:
110: void
111: KillEOL()
112: {
113: Line *line2;
114: int char2;
115: int num = arg_value();
116:
117: if (is_an_arg()) {
118: if (num == 0) { /* Kill to beginning of line */
119: line2 = curline;
120: char2 = 0;
121: } else {
122: line2 = next_line(curline, num);
123: if ((LineDist(curline, line2) < num) || (line2 == curline))
124: char2 = length(line2);
125: else
126: char2 = 0;
127: }
128: } else if (blnkp(&linebuf[curchar])) {
129: line2 = next_line(curline, 1);
130: if (line2 == curline)
131: char2 = length(curline);
132: else
133: char2 = 0;
134: } else {
135: line2 = curline;
136: char2 = length(curline);
137: }
138: reg_kill(line2, char2, 0);
139: }
140:
141: /* kill to beginning of sentence */
142:
143: void
144: KillBos()
145: {
146: negate_arg_value();
147: KillEos();
148: }
149:
150: /* Kill to end of sentence */
151:
152: void
153: KillEos()
154: {
155: Line *line1;
156: int char1;
157:
158: line1 = curline;
159: char1 = curchar;
160: Eos();
161: reg_kill(line1, char1, 1);
162: }
163:
164: void
165: KillExpr()
166: {
167: Line *line1;
168: int char1;
169:
170: line1 = curline;
171: char1 = curchar;
172: FSexpr();
173: reg_kill(line1, char1, 1);
174: }
175:
176: void
177: EscPrefix()
178: {
179: HandlePref(pref1map);
180: }
181:
182: void
183: CtlxPrefix()
184: {
185: HandlePref(pref2map);
186: }
187:
188: void
189: MiscPrefix()
190: {
191: HandlePref(miscmap);
192: }
193:
194: void
195: HandlePref(map)
196: data_obj **map;
197: {
198: register data_obj *cp;
199: register int c;
200: int slow;
201:
202: c = waitchar(&slow);
203: if (c == AbortChar) {
204: message("[Aborted]");
205: rbell();
206: return;
207: }
208:
209: if (slow)
210: message(key_strokes);
211:
212: cp = map[c];
213: if (cp == 0) {
214: s_mess("[%sunbound]", key_strokes);
215: rbell();
216: } else
217: ExecCmd(cp);
218: }
219:
220: void
221: Yank()
222: {
223: Line *line,
224: *lp;
225: Bufpos *dot;
226:
227: if (killbuf[killptr] == 0)
228: complain("[Nothing to yank!]");
229: lsave();
230: this_cmd = YANKCMD;
231: line = killbuf[killptr];
232: lp = lastline(line);
233: dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
234: set_mark();
235: SetDot(dot);
236: }
237:
238: void
239: WtModBuf()
240: {
241: if (!ModBufs(NO))
242: message("[No buffers need saving]");
243: else
244: put_bufs(is_an_arg());
245: }
246:
247: void
248: put_bufs(askp)
249: {
250: register Buffer *oldb = curbuf,
251: *b;
252:
253: for (b = world; b != 0; b = b->b_next) {
254: if (!IsModified(b) || b->b_type != B_FILE)
255: continue;
256: SetBuf(b); /* Make this current Buffer */
257: if (curbuf->b_fname == 0) {
258: char *newname;
259:
260: newname = ask(NullStr, "Buffer \"%s\" needs a file name; type Return to skip: ", b->b_name);
261: if (*newname == 0)
262: continue;
263: setfname(b, newname);
264: }
265: if (askp && (yes_or_no_p("Write %s? ", curbuf->b_fname) == NO))
266: continue;
267: filemunge(curbuf->b_fname);
268: #if !(defined(MSDOS) || defined(MAC))
269: chk_mtime(curbuf, curbuf->b_fname, "save");
270: #endif
271: file_write(curbuf->b_fname, 0);
272: unmodify();
273: }
274: SetBuf(oldb);
275: }
276:
277: void
278: ToIndent()
279: {
280: register char *cp,
281: c;
282:
283: for (cp = linebuf; c = *cp; cp++)
284: if (c != ' ' && c != '\t')
285: break;
286: curchar = cp - linebuf;
287: }
288:
289: /* GoLine -- go to a line, usually wired to goto-line, ESC g or ESC G.
290: If no argument is specified it asks for a line number. */
291: void
292: GoLine()
293: {
294: Line *newline;
295:
296: #ifndef ANSICODES
297: if (!is_an_arg())
298: set_arg_value(ask_int("Line: ",10));
299: #else /* not ANSICODES */
300: if (!is_an_arg() || arg_value() <= 0) {
301: if (SP) {
302: putpad(SP, 1); /* Ask for cursor position */
303: return;
304: }
305: set_arg_value(ask_int("Line: ", 10));
306: }
307: #endif /* ANSICODES */
308: newline = next_line(curbuf->b_first, arg_value() - 1);
309: PushPntp(newline);
310: SetLine(newline);
311: }
312:
313: #ifdef ANSICODES
314: void
315: MoveToCursor(line, col)
316: {
317: register struct scrimage *sp = &PhysScreen[line];
318:
319: while (sp->s_id == 0)
320: sp = &PhysScreen[--line];
321: if (sp->s_flags & MODELINE)
322: complain((char *) 0);
323: if (curwind != sp->s_window)
324: SetWind(sp->s_window);
325: SetLine(sp->s_lp);
326: curchar = how_far(sp->s_lp, col);
327: }
328:
329: void
330: AnsiCodes()
331: {
332: int c;
333: int num1 = 0;
334: int num2;
335: static char *unsupported = "[Unsupported ANSI code received]";
336:
337: while (isdigit(c = getch()))
338: num1 = (num1 * 10) + (c - '0');
339:
340: switch (c) {
341: case ';':
342: num2 = 0;
343: while (isdigit(c = getch()))
344: num2 = (num2 * 10) + (c - '0');
345: switch (c) {
346: case 'R':
347: MoveToCursor(--num1, --num2);
348: break;
349: case 'H':
350: Eow();
351: Bol();
352: break;
353: default:
354: complain(unsupported);
355: }
356: break;
357: case 'A':
358: PrevLine();
359: break;
360: case 'B':
361: NextLine();
362: break;
363: case 'C':
364: ForChar();
365: break;
366: case 'D':
367: BackChar();
368: break;
369: case 'H':
370: Bow();
371: break;
372: case 'J':
373: if (num1 == 2) {
374: ClAndRedraw();
375: break;
376: }
377: case 'M': /* Enter */
378: PopMark();
379: break;
380: case 'P': /* PF1 */
381: ExecCmd((data_obj *) FindCmd(IncFSearch));
382: break;
383: case 'Q': /* PF2 */
384: ExecCmd((data_obj *) FindCmd(QRepSearch));
385: break;
386: case 'R': /* PF3 */
387: WtModBuf();
388: Leave();
389: break;
390: case 'S': /* PF4 */
391: KillEOL();
392: break;
393: case 'l': /* , */
394: DelNChar();
395: break;
396: case 'm': /* - */
397: DelNWord();
398: break;
399: case 'n': /* . */
400: SetMark();
401: break;
402: case 'p': /* 0 */
403: Bol();
404: NextLine();
405: break;
406: case 'q': /* 1 */
407: ForWord();
408: break;
409: case 'r': /* 2 */
410: ForChar();
411: Eol();
412: break;
413: case 's': /* 3 */
414: Yank();
415: break;
416: case 't': /* 4 */
417: ExecCmd((data_obj *) FindCmd(ForSearch));
418: break;
419: case 'u': /* 5 */
420: ExecCmd((data_obj *) FindCmd(RevSearch));
421: break;
422: case 'v': /* 6 */
423: DelReg();
424: break;
425: case 'w': /* 7 */
426: PrevPage();
427: break;
428: case 'x': /* 8 */
429: NextPage();
430: break;
431: case 'y': /* 9 */
432: DelPWord();
433: break;
434: case 'z': /* Sun function keys send <esc>[Nz */
435: switch(num1) {
436: case 193: /* L2 */
437: SetMark();
438: break;
439: case 194: /* L3 */
440: PopMark();
441: break;
442: case 195: /* L4 */
443: DelReg();
444: break;
445: case 208: /* R1 */
446: ExecCmd((data_obj *) FindCmd(QRepSearch));
447: break;
448: case 209: /* R2 */
449: ExecCmd((data_obj *) FindCmd(IncFSearch));
450: break;
451: case 210: /* R3 */
452: WtModBuf();
453: break;
454: case 211: /* R4 */
455: ExecCmd((data_obj *) FindCmd(RepSearch));
456: break;
457: case 212: /* R5 */
458: ExecCmd((data_obj *) FindCmd(IncRSearch));
459: break;
460: case 213: /* R6 */
461: Leave();
462: break;
463: case 214: /* R7 */
464: BackWord();
465: break;
466: case 215: /* R8 == UpArrow */
467: break;
468: case 216: /* R9 */
469: ForWord();
470: break;
471: case 217: /* R10 == LeftArrow */
472: break;
473: case 218: /* R11 */
474: NextWindow();
475: break;
476: case 219: /* R12 == RightArrow */
477: break;
478: case 220: /* R13 */
479: case 221: /* R14 == DownArrow */
480: break;
481: case 222: /* R15 */
482: case 225: /* F2 */
483: case 226: /* F3 */
484: case 227: /* F4 */
485: break;
486: case 228: /* F5 */
487: break;
488: case 229: /* F6 */
489: break;
490: case 230: /* F7 */
491: break;
492: case 231: /* F8 */
493: break;
494: case 232: /* F9 */
495: break;
496: default:
497: num1 = -1; /* Hack flags failure */
498: break;
499: }
500: if (num1 >= 0)
501: break;
502: default:
503: complain(unsupported);
504: }
505: }
506: #endif /* ANSICODES */
507:
508: void
509: NotModified()
510: {
511: unmodify();
512: }
513:
514: void
515: SetLMargin()
516: {
517: LMargin = calc_pos(linebuf, curchar);
518: }
519:
520: void
521: SetRMargin()
522: {
523: RMargin = calc_pos(linebuf, curchar);
524: }
525:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.