![[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] / 43BSD / contrib / jove|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / jove |
1.1 root 1: /*************************************************************************
2: * This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
3: * provided to you without charge for use only on a licensed Unix *
4: * system. You may copy JOVE provided that this notice is included with *
5: * the copy. You may not sell copies of this program or versions *
6: * modified for use on microcomputer systems, unless the copies are *
7: * included with a Unix system distribution and the source is provided. *
8: *************************************************************************/
9:
10: #include "jove.h"
11: #include "ctype.h"
12: #include <signal.h>
13: #ifdef ANSICODES
14: #include "termcap.h"
15: #endif
16:
17: Digit()
18: {
19: GetExp(LastKeyStruck);
20: }
21:
22: Digit0()
23: {
24: GetExp('0');
25: }
26:
27: Digit1()
28: {
29: GetExp('1');
30: }
31:
32: Digit2()
33: {
34: GetExp('2');
35: }
36:
37: Digit3()
38: {
39: GetExp('3');
40: }
41:
42: Digit4()
43: {
44: GetExp('4');
45: }
46:
47: Digit5()
48: {
49: GetExp('5');
50: }
51:
52: Digit6()
53: {
54: GetExp('6');
55: }
56:
57: Digit7()
58: {
59: GetExp('7');
60: }
61:
62: Digit8()
63: {
64: GetExp('8');
65: }
66:
67: Digit9()
68: {
69: GetExp('9');
70: }
71:
72: prCTIME()
73: {
74: s_mess(": %f %s", get_time((long *) 0, (char *) 0, 0, -1));
75: }
76:
77: extern int alarmed;
78:
79: FourTime()
80: {
81: int oldc = LastKeyStruck,
82: newc;
83: int nexp;
84:
85: alarmed = 0;
86: exp_p = 1;
87: this_cmd = ARG_CMD;
88: do {
89: if ((nexp = exp * 4) != 0)
90: exp = nexp;
91: if (!alarmed)
92: newc = waitchar();
93: else
94: newc = getch();
95: if (alarmed)
96: message(key_strokes);
97: } while (newc == oldc);
98: Ungetc(newc);
99: }
100:
101: int exp_p,
102: exp;
103:
104: GetExp(c)
105: {
106: int sign = 1,
107: i,
108: digited = 0;
109:
110: if (!isdigit(c) && c != '-')
111: complain((char *) 0);
112: if (exp_p)
113: i = exp;
114: else
115: i = 0;
116: if (c == '-') {
117: sign = -1;
118: goto goread;
119: }
120: for (;;) {
121: if (alarmed)
122: message(key_strokes);
123: if (isdigit(c)) {
124: i = i * 10 + (c - '0');
125: digited++;
126: } else {
127: if (digited)
128: exp_p = 1;
129: else
130: i = 1;
131: exp = i * sign;
132: this_cmd = ARG_CMD;
133: Ungetc(c);
134: return;
135: }
136: goread: if (!alarmed)
137: c = waitchar();
138: else {
139: add_mess(NullStr);
140: c = getch();
141: }
142: }
143: }
144:
145: ChrToOct()
146: {
147: int c;
148:
149: c = waitchar();
150: if (alarmed)
151: message(key_strokes);
152: ins_str(sprint("\\%03o", c), NO);
153: }
154:
155: StrLength()
156: {
157: static char inquotes[] = "Where are the quotes?";
158: char *first = StrIndex(-1, linebuf, curchar, '"'),
159: *last = StrIndex(1, linebuf, curchar + 1, '"'),
160: c;
161: int numchars = 0;
162:
163: if (first == 0 || last == 0)
164: complain(inquotes);
165: first++;
166: while (first < last) {
167: c = *first++;
168: if (c == '\\') {
169: int num;
170:
171: if (!isdigit(*first))
172: ++first;
173: else {
174: num = 3;
175: while (num-- && isdigit(*first++) && first < last)
176: ;
177: }
178: }
179: numchars++;
180: }
181: s_mess("%d characters", numchars);
182: }
183:
184: /* Transpos cur_char with cur_char - 1 */
185:
186: TransChar()
187: {
188: char before;
189:
190: if (curchar == 0 || (eolp() && curchar == 1))
191: complain((char *) 0); /* BEEP */
192: exp = 1;
193: if (eolp())
194: BackChar();
195: before = linebuf[curchar - 1];
196: DelPChar();
197: ForChar();
198: Insert(before);
199: }
200:
201: /* Switch current line with previous one */
202:
203: TransLines()
204: {
205: disk_line old_prev;
206:
207: if (firstp(curline))
208: return;
209: exp = 1;
210: lsave();
211: old_prev = curline->l_prev->l_dline;
212: curline->l_prev->l_dline = curline->l_dline;
213: curline->l_dline = old_prev;
214: getDOT();
215: if (!lastp(curline))
216: line_move(FORWARD, NO);
217: modify();
218: }
219:
220: Leave()
221: {
222: longjmp(mainjmp, QUIT);
223: }
224:
225: /* If argument is specified, kill that many lines down. Otherwise,
226: if we "appear" to be at the end of a line, i.e. everything to the
227: right of the cursor is white space, we delete the line separator
228: as if we were at the end of the line. */
229:
230: KillEOL()
231: {
232: Line *line2;
233: int char2;
234:
235: if (exp_p) {
236: if (exp == 0) { /* Kill to beginning of line */
237: line2 = curline;
238: char2 = 0;
239: } else {
240: line2 = next_line(curline, exp);
241: if ((LineDist(curline, line2) < exp) || (line2 == curline))
242: char2 = length(line2);
243: else
244: char2 = 0;
245: }
246: } else if (blnkp(&linebuf[curchar])) {
247: line2 = next_line(curline, 1);
248: if (line2 == curline)
249: char2 = length(curline);
250: else
251: char2 = 0;
252: } else {
253: line2 = curline;
254: char2 = length(curline);
255: }
256: reg_kill(line2, char2, 0);
257: }
258:
259: /* Kill to beginning of sentence */
260:
261: KillBos()
262: {
263: exp = -exp;
264: KillEos();
265: }
266:
267: /* Kill to end of sentence */
268:
269: KillEos()
270: {
271: Line *line1;
272: int char1;
273:
274: line1 = curline;
275: char1 = curchar;
276: Eos();
277: reg_kill(line1, char1, 1);
278: }
279:
280: KillExpr()
281: {
282: Line *line1;
283: int char1;
284:
285: line1 = curline;
286: char1 = curchar;
287: FSexpr();
288: reg_kill(line1, char1, 1);
289: }
290:
291: EscPrefix()
292: {
293: HandlePref(pref1map);
294: }
295:
296: CtlxPrefix()
297: {
298: HandlePref(pref2map);
299: }
300:
301: MiscPrefix()
302: {
303: HandlePref(miscmap);
304: }
305:
306: HandlePref(map)
307: data_obj **map;
308: {
309: register data_obj *cp;
310: register int c;
311:
312: c = waitchar();
313: if (c == CTL(G)) {
314: message("[Aborted]");
315: rbell();
316: return;
317: }
318:
319: if (alarmed)
320: message(key_strokes);
321:
322: cp = map[c];
323: if (cp == 0) {
324: s_mess("[%sunbound]", key_strokes);
325: rbell();
326: } else
327: ExecCmd(cp);
328: }
329:
330: Yank()
331: {
332: Line *line,
333: *lp;
334: Bufpos *dot;
335:
336: if (killbuf[killptr] == 0)
337: complain("[Nothing to yank!]");
338: lsave();
339: this_cmd = YANKCMD;
340: line = killbuf[killptr];
341: lp = lastline(line);
342: dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
343: SetMark();
344: SetDot(dot);
345: }
346:
347: WtModBuf()
348: {
349: if (!ModBufs(NO))
350: message("[No buffers need saving]");
351: else
352: put_bufs(exp_p);
353: }
354:
355: put_bufs(askp)
356: {
357: register Buffer *oldb = curbuf,
358: *b;
359:
360: for (b = world; b != 0; b = b->b_next) {
361: if (!IsModified(b) || b->b_type != B_FILE)
362: continue;
363: SetBuf(b); /* Make this current Buffer */
364: if (curbuf->b_fname == 0) {
365: char *newname;
366:
367: newname = ask(NullStr, "Buffer \"%s\" needs a file name; type Return to skip: ", b->b_name);
368: if (*newname == 0)
369: continue;
370: setfname(b, newname);
371: }
372: if (SaveBuf(askp))
373: unmodify();
374: }
375: SetBuf(oldb);
376: }
377:
378: SaveBuf(askp)
379: {
380: char *yorn;
381:
382: if (askp) {
383: yorn = ask((char *) 0, "Write %s? ", curbuf->b_fname);
384: if (*yorn != 'Y' && *yorn != 'y')
385: return 0;
386: }
387: file_write(curbuf->b_fname, 0);
388: return 1;
389: }
390:
391: DOTsave(buf)
392: Bufpos *buf;
393: {
394: buf->p_line = curline;
395: buf->p_char = curchar;
396: }
397:
398: ToIndent()
399: {
400: register char *cp,
401: c;
402:
403: for (cp = linebuf; c = *cp; cp++)
404: if (c != ' ' && c != '\t')
405: break;
406: curchar = cp - linebuf;
407: }
408:
409: GoLine()
410: {
411: Line *newline;
412:
413: #ifndef ANSICODES
414: if (exp_p == 0)
415: return;
416: #else
417: if (exp_p == 0 || exp <= 0) {
418: if (SP)
419: putpad(SP, 1); /* Ask for cursor position */
420: return;
421: }
422: #endif
423: newline = next_line(curbuf->b_first, exp - 1);
424: PushPntp(newline);
425: SetLine(newline);
426: }
427:
428: #ifdef ANSICODES
429: MoveToCursor(line, col)
430: {
431: register struct scrimage *sp = &PhysScreen[line];
432:
433: while (sp->s_id == NULL)
434: sp = &PhysScreen[--line];
435: if (sp->s_flags & MODELINE)
436: complain((char *) 0);
437: if (curwind != sp->s_window)
438: SetWind(sp->s_window);
439: SetLine(sp->s_lp);
440: curchar = how_far(sp->s_lp, col);
441: }
442:
443: AnsiCodes()
444: {
445: int c;
446: int num1 = 0;
447: int num2;
448: static char *unsupported = "[Unsupported ANSI code received]";
449:
450: while (isdigit(c = getch()))
451: num1 = (num1*10) + (c - '0');
452:
453: switch (c) {
454: case ';':
455: num2 = 0;
456: while (isdigit(c = getch()))
457: num2 = (num2*10) + (c - '0');
458: switch (c) {
459: case 'R':
460: MoveToCursor(--num1, --num2);
461: break;
462: case 'H':
463: Eow(); Bol();
464: break;
465: default:
466: complain(unsupported);
467: }
468: break;
469: case 'A':
470: line_move(BACKWARD, NO);
471: break;
472: case 'B':
473: line_move(FORWARD, NO);
474: break;
475: case 'C':
476: ForChar();
477: break;
478: case 'D':
479: BackChar();
480: break;
481: case 'H':
482: Bow();
483: break;
484: case 'J':
485: if (num1 == 2) {
486: ClAndRedraw();
487: break;
488: }
489: /* FALL THROUGH */
490: default:
491: complain(unsupported);
492: }
493: }
494: #endif ANSICODES
495:
496: NotModified()
497: {
498: unmodify();
499: }
500:
501: SetLMargin()
502: {
503: LMargin = calc_pos(linebuf, curchar);
504: }
505:
506: SetRMargin()
507: {
508: RMargin = calc_pos(linebuf, curchar);
509: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.