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: }

Defined functions

AnsiCodes defined in line 329; used 2 times
ChrToOct defined in line 21; used 4 times
GoLine defined in line 291; used 4 times
HandlePref defined in line 194; used 5 times
KillBos defined in line 143; used 4 times
KillEOL defined in line 110; used 5 times
KillEos defined in line 152; used 5 times
KillExpr defined in line 164; used 4 times
Leave defined in line 99; used 7 times
MoveToCursor defined in line 314; used 1 times
NotModified defined in line 508; used 4 times
SetLMargin defined in line 514; used 4 times
SetRMargin defined in line 520; used 4 times
StrLength defined in line 33; used 4 times
TransChar defined in line 65; used 4 times
TransLines defined in line 82; used 4 times
WtModBuf defined in line 238; used 6 times
Yank defined in line 220; used 5 times
prCTIME defined in line 15; used 4 times
put_bufs defined in line 247; used 5 times
Last modified: 1988-04-07
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 702
Valid CSS Valid XHTML 1.0 Strict