uedit.c

   1 /* $MirOS: contrib/code/jupp/uedit.c,v 1.17 2017/03/19 19:19:51 tg Exp $ */
   2 /*
   3  *      Basic user edit functions
   4  *      Copyright
   5  *              (C) 1992 Joseph H. Allen
   6  *
   7  *      This file is part of JOE (Joe's Own Editor)
   8  */
   9 #include "config.h"
  10 #include "types.h"
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 #ifdef HAVE_BSD_STRING_H
  16 #include <bsd/string.h>
  17 #endif
  18
  19 #include "b.h"
  20 #include "bw.h"
  21 #include "macro.h"
  22 #include "main.h"
  23 #include "pw.h"
  24 #include "qw.h"
  25 #include "scrn.h"
  26 #include "ublock.h"
  27 #include "uformat.h"
  28 #include "umath.h"
  29 #include "utils.h"
  30 #include "vs.h"
  31 #include "utf8.h"
  32 #include "charmap.h"
  33 #include "w.h"
  34
  35 /***************/
  36 /* Global options */
  37 int pgamnt = -1;                /* No. of PgUp/PgDn lines to keep */
  38
  39 /******** i don't like global var ******/
  40
  41 /*
  42  * Move cursor to beginning of line
  43  */
  44 int u_goto_bol(BW *bw)
  45 {
  46         if (bw->o.hex) {
  47                 pbkwd(bw->cursor,bw->cursor->byte%16);
  48         } else {
  49                 p_goto_bol(bw->cursor);
  50         }
  51         return 0;
  52 }
  53
  54 /*
  55  * Move cursor to first non-whitespace character, unless it is
  56  * already there, in which case move it to beginning of line
  57  */
  58 int uhome(BW *bw)
  59 {
  60         P *p;
  61
  62         if (bw->o.hex) {
  63                 return u_goto_bol(bw);
  64         }
  65
  66         p = pdup(bw->cursor);
  67
  68         if (bw->o.indentfirst) {
  69                 if ((bw->o.smarthome) && (piscol(p) > pisindent(p))) {
  70                         p_goto_bol(p);
  71                         while (joe_isblank(p->b->o.charmap,brc(p)))
  72                                 pgetc(p);
  73                 } else
  74                         p_goto_bol(p);
  75         } else {
  76                 if (bw->o.smarthome && piscol(p)==0 && pisindent(p)) {
  77                         while (joe_isblank(p->b->o.charmap,brc(p)))
  78                                 pgetc(p);
  79                 } else
  80                         p_goto_bol(p);
  81         }
  82
  83         pset(bw->cursor, p);
  84         prm(p);
  85         return 0;
  86 }
  87
  88 /*
  89  * Move cursor to end of line
  90  */
  91 int u_goto_eol(BW *bw)
  92 {
  93         if (bw->o.hex) {
  94                 if (bw->cursor->byte + 15 - bw->cursor->byte%16 > bw->b->eof->byte)
  95                         pset(bw->cursor,bw->b->eof);
  96                 else
  97                         pfwrd(bw->cursor, 15 - bw->cursor->byte%16);
  98         } else
  99                 p_goto_eol(bw->cursor);
 100         return 0;
 101 }
 102
 103 /*
 104  * Move cursor to beginning of file
 105  */
 106 int u_goto_bof(BW *bw)
 107 {
 108         p_goto_bof(bw->cursor);
 109         return 0;
 110 }
 111
 112 /*
 113  * Move cursor to end of file
 114  */
 115 int u_goto_eof(BW *bw)
 116 {
 117         p_goto_eof(bw->cursor);
 118         return 0;
 119 }
 120
 121 /*
 122  * Move cursor left
 123  */
 124 int u_goto_left(BW *bw)
 125 {
 126         if (bw->o.hex) {
 127                 if (prgetb(bw->cursor) != NO_MORE_DATA) {
 128                         return 0;
 129                 } else {
 130                         return -1;
 131                 }
 132         }
 133         if (bw->o.picture) {
 134                 if (bw->cursor->xcol) {
 135                         --bw->cursor->xcol;
 136                         pcol(bw->cursor,bw->cursor->xcol);
 137                         return 0;
 138                 }
 139         } else {
 140                 /* Have to do ECHKXCOL here because of picture mode */
 141                 if (bw->cursor->xcol != piscol(bw->cursor)) {
 142                         bw->cursor->xcol = piscol(bw->cursor);
 143                         return 0;
 144                 } else if (prgetc(bw->cursor) != NO_MORE_DATA) {
 145                         bw->cursor->xcol = piscol(bw->cursor);
 146                         return 0;
 147                 }
 148         }
 149         return -1;
 150 }
 151
 152 /*
 153  * Move cursor right
 154  */
 155 int u_goto_right(BW *bw)
 156 {
 157         if (bw->o.hex) {
 158                 if (pgetb(bw->cursor) != NO_MORE_DATA) {
 159                         return 0;
 160                 } else {
 161                         return -1;
 162                 }
 163         }
 164         if (bw->o.picture) {
 165                 ++bw->cursor->xcol;
 166                 pcol(bw->cursor,bw->cursor->xcol);
 167                 return 0;
 168         } else {
 169                 int rtn;
 170                 if (pgetc(bw->cursor) != NO_MORE_DATA) {
 171                         bw->cursor->xcol = piscol(bw->cursor);
 172                         rtn = 0;
 173                 } else {
 174                         rtn = -1;
 175                 }
 176                 /* Have to do EFIXXCOL here because of picture mode */
 177                 if (bw->cursor->xcol != piscol(bw->cursor))
 178                         bw->cursor->xcol = piscol(bw->cursor);
 179                 return rtn;
 180         }
 181 }
 182
 183 /*
 184  * Move cursor to beginning of previous word or if there isn't
 185  * previous word then go to beginning of the file
 186  *
 187  * WORD is a sequence non-white-space characters
 188  */
 189 int u_goto_prev(BW *bw)
 190 {
 191         P *p = pdup(bw->cursor);
 192         struct charmap *map=bw->b->o.charmap;
 193         int c = prgetc(p);
 194
 195         if (joe_isalnum_(map,c)) {
 196                 while (joe_isalnum_(map,(c=prgetc(p))))
 197                         /* Do nothing */;
 198                 if (c != NO_MORE_DATA)
 199                         pgetc(p);
 200         } else if (joe_isspace(map,c) || joe_ispunct(map,c)) {
 201                 while ((c=prgetc(p)), (joe_isspace(map,c) || joe_ispunct(map,c)))
 202                         /* Do nothing */;
 203                 while(joe_isalnum_(map,(c=prgetc(p))))
 204                         /* Do nothing */;
 205                 if (c != NO_MORE_DATA)
 206                         pgetc(p);
 207         }
 208 /*
 209         if (p->byte == bw->cursor->byte) {
 210                 prm(p);
 211                 return -1;
 212         }
 213 */
 214         pset(bw->cursor, p);
 215         prm(p);
 216         return 0;
 217 }
 218
 219 /*
 220  * Move cursor to end of next word or if there isn't
 221  * next word then go to end of the file
 222  *
 223  * WORD is a sequence non-white-space characters
 224  */
 225 int u_goto_next(BW *bw)
 226 {
 227         P *p = pdup(bw->cursor);
 228         struct charmap *map=bw->b->o.charmap;
 229         int c = brch(p);
 230         int rtn = -1;
 231
 232         if (joe_isalnum_(map,c)) {
 233                 rtn = 0;
 234                 while (joe_isalnum_(map,(c = brch(p))))
 235                         pgetc(p);
 236         } else if (joe_isspace(map,c) || joe_ispunct(map,c)) {
 237                 while (joe_isspace(map, (c = brch(p))) || joe_ispunct(map,c))
 238                         pgetc(p);
 239                 while (joe_isalnum_(map,(c = brch(p)))) {
 240                         rtn = 0;
 241                         pgetc(p);
 242                 }
 243         } else
 244                 pgetc(p);
 245         pset(bw->cursor, p);
 246         prm(p);
 247         return rtn;
 248 }
 249
 250 static P *pboi(P *p)
 251 {
 252         p_goto_bol(p);
 253         while (joe_isblank(p->b->o.charmap,brch(p)))
 254                 pgetc(p);
 255         return p;
 256 }
 257
 258 static int pisedge(P *p)
 259 {
 260         P *q;
 261         int c;
 262
 263         if (pisbol(p))
 264                 return -1;
 265         if (piseol(p))
 266                 return 1;
 267         q = pdup(p);
 268         pboi(q);
 269         if (q->byte == p->byte)
 270                 goto left;
 271         if (joe_isblank(p->b->o.charmap,(c = brch(p)))) {
 272                 pset(q, p);
 273                 if (joe_isblank(p->b->o.charmap,prgetc(q)))
 274                         goto no;
 275                 if (c == '\t')
 276                         goto right;
 277                 pset(q, p);
 278                 pgetc(q);
 279                 if (pgetc(q) == ' ')
 280                         goto right;
 281                 goto no;
 282         } else {
 283                 pset(q, p);
 284                 c = prgetc(q);
 285                 if (c == '\t')
 286                         goto left;
 287                 if (c != ' ')
 288                         goto no;
 289                 if (prgetc(q) == ' ')
 290                         goto left;
 291                 goto no;
 292         }
 293
 294       right:prm(q);
 295         return 1;
 296       left:prm(q);
 297         return -1;
 298       no:prm(q);
 299         return 0;
 300 }
 301
 302 int upedge(BW *bw)
 303 {
 304         if (prgetc(bw->cursor) == NO_MORE_DATA)
 305                 return -1;
 306         while (pisedge(bw->cursor) != -1)
 307                 prgetc(bw->cursor);
 308         return 0;
 309 }
 310
 311 int unedge(BW *bw)
 312 {
 313         if (pgetc(bw->cursor) == NO_MORE_DATA)
 314                 return -1;
 315         while (pisedge(bw->cursor) != 1)
 316                 pgetc(bw->cursor);
 317         return 0;
 318 }
 319
 320 /* Move cursor to matching delimiter */
 321
 322 static int
 323 utomatch_i(BW *bw, int dir)
 324 {
 325         int d;
 326         int c;                  /* character under cursor */
 327         int f;                  /* character to find */
 328         P *p;
 329         int cnt = 0;            /* delimiter depth */
 330
 331         switch (c = brch(bw->cursor)) {
 332         case '(':
 333                 f = ')';
 334                 dir = 1;
 335                 break;
 336         case '[':
 337                 f = ']';
 338                 dir = 1;
 339                 break;
 340         case '{':
 341                 f = '}';
 342                 dir = 1;
 343                 break;
 344         case '<':
 345                 f = '>';
 346                 dir = 1;
 347                 break;
 348         case ')':
 349                 f = '(';
 350                 dir = -1;
 351                 break;
 352         case ']':
 353                 f = '[';
 354                 dir = -1;
 355                 break;
 356         case '}':
 357                 f = '{';
 358                 dir = -1;
 359                 break;
 360         case '>':
 361                 f = '<';
 362                 dir = -1;
 363                 break;
 364         case '"':
 365         case '\'':
 366         case '`':
 367                 f = c;
 368                 break;
 369         default:
 370                 return -1;
 371         }
 372
 373         p = pdup(bw->cursor);
 374         if (dir == 1) {
 375                 while ((d = pgetc(p)) != NO_MORE_DATA) {
 376                         if (d == f && f != c && !--cnt) {
 377                                 prgetc(p);
 378                                 goto match_found;
 379                         } else if (d == c) {
 380                                 ++cnt;
 381                                 if (f == c)
 382                                         c = NO_MORE_DATA;
 383                         }
 384                 }
 385         } else {
 386                 while ((d = prgetc(p)) != NO_MORE_DATA) {
 387                         if (d == f && !cnt--)
 388                                 goto match_found;
 389                         else if (d == c)
 390                                 ++cnt;
 391                 }
 392         }
 393         if (/* CONSTCOND */ 0) {
 394  match_found:
 395                 pset(bw->cursor, p);
 396         }
 397         prm(p);
 398         return ((d == NO_MORE_DATA) ? -1 : 0);
 399 }
 400
 401 int utomatch(BW *bw)
 402 {
 403         return (utomatch_i(bw, 1));
 404 }
 405
 406 int urvmatch(BW *bw)
 407 {
 408         return (utomatch_i(bw, -1));
 409 }
 410
 411 /* Move cursor up */
 412
 413 int uuparw(BW *bw)
 414 {
 415         if (bw->o.hex) {
 416                 if (bw->cursor->byte<16)
 417                         return -1;
 418                 else {
 419                         pbkwd(bw->cursor, 16);
 420                         return 0;
 421                 }
 422         }
 423         if (bw->cursor->line) {
 424                 pprevl(bw->cursor);
 425                 pcol(bw->cursor, bw->cursor->xcol);
 426                 return 0;
 427         } else
 428                 return -1;
 429 }
 430
 431 /* Move cursor down */
 432
 433 int udnarw(BW *bw)
 434 {
 435         if (bw->o.hex) {
 436                 if (bw->cursor->byte+16 <= bw->b->eof->byte) {
 437                         pfwrd(bw->cursor, 16);
 438                         return 0;
 439                 } else if (bw->cursor->byte != bw->b->eof->byte) {
 440                         pset(bw->cursor, bw->b->eof);
 441                         return 0;
 442                 } else {
 443                         return -1;
 444                 }
 445         }
 446         if (bw->cursor->line != bw->b->eof->line) {
 447                 pnextl(bw->cursor);
 448                 pcol(bw->cursor, bw->cursor->xcol);
 449                 return 0;
 450         } else if(bw->o.picture) {
 451                 p_goto_eol(bw->cursor);
 452                 binsc(bw->cursor,'\n');
 453                 pgetc(bw->cursor);
 454                 pcol(bw->cursor, bw->cursor->xcol);
 455                 return 0;
 456         } else
 457                 return -1;
 458 }
 459
 460 /* Move cursor to top of window */
 461
 462 int utos(BW *bw)
 463 {
 464         long col = bw->cursor->xcol;
 465
 466         pset(bw->cursor, bw->top);
 467         pcol(bw->cursor, col);
 468         bw->cursor->xcol = col;
 469         return 0;
 470 }
 471
 472 /* Move cursor to bottom of window */
 473
 474 int ubos(BW *bw)
 475 {
 476         long col = bw->cursor->xcol;
 477
 478         pline(bw->cursor, bw->top->line + bw->h - 1);
 479         pcol(bw->cursor, col);
 480         bw->cursor->xcol = col;
 481         return 0;
 482 }
 483
 484 /* Scroll buffer window up n lines
 485  * If beginning of file is close, scrolls as much as it can
 486  * If beginning of file is on-screen, cursor jumps to beginning of file
 487  *
 488  * If flg is set: cursor stays fixed relative to screen edge
 489  * If flg is clr: cursor stays fixed on the buffer line
 490  */
 491
 492 void scrup(BW *bw, int n, int flg)
 493 {
 494         int scrollamnt = 0;
 495         int cursoramnt = 0;
 496         int x;
 497
 498         /* Decide number of lines we're really going to scroll */
 499
 500         if (bw->o.hex) {
 501                 if (bw->top->byte/16 >= n)
 502                         scrollamnt = cursoramnt = n;
 503                 else if (bw->top->byte/16)
 504                         scrollamnt = cursoramnt = bw->top->byte/16;
 505                 else if (flg)
 506                         cursoramnt = bw->cursor->byte/16;
 507                 else if (bw->cursor->byte/16 >= n)
 508                         cursoramnt = n;
 509         } else {
 510                 if (bw->top->line >= n)
 511                         scrollamnt = cursoramnt = n;
 512                 else if (bw->top->line)
 513                         scrollamnt = cursoramnt = bw->top->line;
 514                 else if (flg)
 515                         cursoramnt = bw->cursor->line;
 516                 else if (bw->cursor->line >= n)
 517                         cursoramnt = n;
 518         }
 519
 520         if (bw->o.hex) {
 521                 /* Move top-of-window pointer */
 522                 pbkwd(bw->top,scrollamnt*16);
 523                 /* Move cursor */
 524                 pbkwd(bw->cursor,cursoramnt*16);
 525                 /* If window is on the screen, give (buffered) scrolling command */
 526                 if (bw->parent->y != -1)
 527                         nscrldn(bw->parent->t->t, bw->y, bw->y + bw->h, scrollamnt);
 528         } else {
 529                 /* Move top-of-window pointer */
 530                 for (x = 0; x != scrollamnt; ++x)
 531                         pprevl(bw->top);
 532                 p_goto_bol(bw->top);
 533
 534                 /* Move cursor */
 535                 for (x = 0; x != cursoramnt; ++x)
 536                         pprevl(bw->cursor);
 537                 p_goto_bol(bw->cursor);
 538                 pcol(bw->cursor, bw->cursor->xcol);
 539
 540                 /* If window is on the screen, give (buffered) scrolling command */
 541                 if (bw->parent->y != -1)
 542                         nscrldn(bw->parent->t->t, bw->y, bw->y + bw->h, scrollamnt);
 543         }
 544 }
 545
 546 /* Scroll buffer window down n lines
 547  * If end of file is close, scrolls as much as possible
 548  * If end of file is on-screen, cursor jumps to end of file
 549  *
 550  * If flg is set: cursor stays fixed relative to screen edge
 551  * If flg is clr: cursor stays fixed on the buffer line
 552  */
 553
 554 void scrdn(BW *bw, int n, int flg)
 555 {
 556         int scrollamnt = 0;
 557         int cursoramnt = 0;
 558         int x;
 559
 560         /* How much we're really going to scroll... */
 561         if (bw->o.hex) {
 562                 if (bw->top->b->eof->byte/16 < bw->top->byte/16 + bw->h) {
 563                         cursoramnt = bw->top->b->eof->byte/16 - bw->cursor->byte/16;
 564                         if (!flg && cursoramnt > n)
 565                                 cursoramnt = n;
 566                 } else if (bw->top->b->eof->byte/16 - (bw->top->byte/16 + bw->h) >= n)
 567                         cursoramnt = scrollamnt = n;
 568                 else
 569                         cursoramnt = scrollamnt = bw->top->b->eof->byte/16 - (bw->top->byte/16 + bw->h) + 1;
 570         } else {
 571                 if (bw->top->b->eof->line < bw->top->line + bw->h) {
 572                         cursoramnt = bw->top->b->eof->line - bw->cursor->line;
 573                         if (!flg && cursoramnt > n)
 574                                 cursoramnt = n;
 575                 } else if (bw->top->b->eof->line - (bw->top->line + bw->h) >= n)
 576                         cursoramnt = scrollamnt = n;
 577                 else
 578                         cursoramnt = scrollamnt = bw->top->b->eof->line - (bw->top->line + bw->h) + 1;
 579         }
 580
 581         if (bw->o.hex) {
 582                 /* Move top-of-window pointer */
 583                 pfwrd(bw->top,16*scrollamnt);
 584                 /* Move cursor */
 585                 pfwrd(bw->cursor,16*cursoramnt);
 586                 /* If window is on screen, give (buffered) scrolling command to terminal */
 587                 if (bw->parent->y != -1)
 588                         nscrlup(bw->parent->t->t, bw->y, bw->y + bw->h, scrollamnt);
 589         } else {
 590                 /* Move top-of-window pointer */
 591                 for (x = 0; x != scrollamnt; ++x)
 592                         pnextl(bw->top);
 593
 594                 /* Move cursor */
 595                 for (x = 0; x != cursoramnt; ++x)
 596                         pnextl(bw->cursor);
 597                 pcol(bw->cursor, bw->cursor->xcol);
 598
 599                 /* If window is on screen, give (buffered) scrolling command to terminal */
 600                 if (bw->parent->y != -1)
 601                         nscrlup(bw->parent->t->t, bw->y, bw->y + bw->h, scrollamnt);
 602         }
 603 }
 604
 605 /* Page up */
 606
 607 int upgup(BW *bw)
 608 {
 609         bw = (BW *) bw->parent->main->object;
 610         if (bw->o.hex ? bw->cursor->byte < 16 : !bw->cursor->line)
 611                 return -1;
 612         if (pgamnt < 0)
 613                 scrup(bw, bw->h / 2 + bw->h % 2, 1);
 614         else if (pgamnt < bw->h)
 615                 scrup(bw, bw->h - pgamnt, 1);
 616         else
 617                 scrup(bw, 1, 1);
 618         return 0;
 619 }
 620
 621 /* Page down */
 622
 623 int upgdn(BW *bw)
 624 {
 625         bw = (BW *) bw->parent->main->object;
 626         if (bw->o.hex ? bw->cursor->byte/16 == bw->b->eof->byte/16 : bw->cursor->line == bw->b->eof->line)
 627                 return -1;
 628         if (pgamnt < 0)
 629                 scrdn(bw, bw->h / 2 + bw->h % 2, 1);
 630         else if (pgamnt < bw->h)
 631                 scrdn(bw, bw->h - pgamnt, 1);
 632         else
 633                 scrdn(bw, 1, 1);
 634         return 0;
 635 }
 636
 637 /* Scroll by a single line.  The cursor moves with the scroll */
 638
 639 int uupslide(BW *bw)
 640 {
 641         bw = (BW *) bw->parent->main->object;
 642         if (bw->o.hex ? bw->top->byte/16 : bw->top->line) {
 643                 if (bw->o.hex ? bw->top->byte/16 + bw->h -1 != bw->cursor->byte/16 : bw->top->line + bw->h - 1 != bw->cursor->line)
 644                         udnarw(bw);
 645                 scrup(bw, 1, 0);
 646                 return 0;
 647         } else
 648                 return -1;
 649 }
 650
 651 int udnslide(BW *bw)
 652 {
 653         bw = (BW *) bw->parent->main->object;
 654         if (bw->o.hex ? bw->top->line/16 + bw->h <= bw->top->b->eof->byte/16 : bw->top->line + bw->h <= bw->top->b->eof->line) {
 655                 if (bw->o.hex ? bw->top->byte/16 != bw->cursor->byte/16 : bw->top->line != bw->cursor->line)
 656                         uuparw(bw);
 657                 scrdn(bw, 1, 0);
 658                 return 0;
 659         } else
 660                 return -1;
 661 }
 662
 663 /* Move cursor to specified line number */
 664
 665 static B *linehist = NULL;      /* History of previously entered line numbers */
 666
 667 static int doline(BW *bw, unsigned char *s, void *object, int *notify)
 668 {
 669         long num = calc(bw, s);
 670
 671         if (notify)
 672                 *notify = 1;
 673         vsrm(s);
 674         if (num >= 1 && !merrf) {
 675                 int tmp = mid;
 676
 677                 if (num > bw->b->eof->line)
 678                         num = bw->b->eof->line + 1;
 679                 pline(bw->cursor, num - 1), bw->cursor->xcol = piscol(bw->cursor);
 680                 mid = 1;
 681                 dofollows();
 682                 mid = tmp;
 683                 return 0;
 684         } else {
 685                 if (merrf)
 686                         msgnw(bw->parent, merrt);
 687                 else
 688                         msgnw(bw->parent, US "Invalid line number");
 689                 return -1;
 690         }
 691 }
 692
 693 int uline(BW *bw)
 694 {
 695         if (wmkpw(bw->parent, US "Go to line (^C to abort): ", &linehist, doline, NULL, NULL, NULL, NULL, NULL, locale_map))
 696                 return 0;
 697         else
 698                 return -1;
 699 }
 700
 701 /* Move cursor to specified column number */
 702
 703 static B *colhist = NULL;       /* History of previously entered column numbers */
 704
 705 static int docol(BW *bw, unsigned char *s, void *object, int *notify)
 706 {
 707         long num = calc(bw, s);
 708
 709         if (notify)
 710                 *notify = 1;
 711         vsrm(s);
 712         if (num >= 1 && !merrf) {
 713                 int tmp = mid;
 714
 715                 pcol(bw->cursor, num - 1), bw->cursor->xcol = piscol(bw->cursor);
 716                 mid = 1;
 717                 dofollows();
 718                 mid = tmp;
 719                 return 0;
 720         } else {
 721                 if (merrf)
 722                         msgnw(bw->parent, merrt);
 723                 else
 724                         msgnw(bw->parent, US "Invalid column number");
 725                 return -1;
 726         }
 727 }
 728
 729 int ucol(BW *bw)
 730 {
 731         if (wmkpw(bw->parent, US "Go to column (^C to abort): ", &colhist, docol, NULL, NULL, NULL, NULL, NULL, locale_map))
 732                 return 0;
 733         else
 734                 return -1;
 735 }
 736
 737 /* Move cursor to specified byte number */
 738
 739 static B *bytehist = NULL;      /* History of previously entered byte numbers */
 740
 741 static int dobyte(BW *bw, unsigned char *s, void *object, int *notify)
 742 {
 743         long num = calc(bw, s);
 744
 745         if (notify)
 746                 *notify = 1;
 747         vsrm(s);
 748         if (num >= 0 && !merrf) {
 749                 int tmp = mid;
 750
 751                 pgoto(bw->cursor, num), bw->cursor->xcol = piscol(bw->cursor);
 752                 mid = 1;
 753                 dofollows();
 754                 mid = tmp;
 755                 return 0;
 756         } else {
 757                 if (merrf)
 758                         msgnw(bw->parent, merrt);
 759                 else
 760                         msgnw(bw->parent, US "Invalid byte number");
 761                 return -1;
 762         }
 763 }
 764
 765 int ubyte(BW *bw)
 766 {
 767         if (wmkpw(bw->parent, US "Go to byte (^C to abort): ", &bytehist, dobyte, NULL, NULL, NULL, NULL, NULL, locale_map))
 768                 return 0;
 769         else
 770                 return -1;
 771 }
 772
 773 /* Delete character under cursor
 774  * or write ^D to process if we're at end of file in a shell window
 775  */
 776
 777 int udelch(BW *bw)
 778 {
 779         P *p;
 780
 781         if (piseof(bw->cursor))
 782                 return -1;
 783         pgetc(p = pdup(bw->cursor));
 784         bdel(bw->cursor, p);
 785         prm(p);
 786         return 0;
 787 }
 788
 789 /* Backspace */
 790
 791 int ubacks(BW *bw, int k)
 792 {
 793         /* Don't backspace when at beginning of line in prompt windows */
 794         if (bw->parent->watom->what == TYPETW || !pisbol(bw->cursor)) {
 795                 int c;
 796                 int indent;
 797                 int col;
 798                 int indwid;
 799                 int wid;
 800
 801                 if (pisbof(bw->cursor))
 802                         return -1;
 803
 804                 /* Indentation point of this line */
 805                 indent = pisindent(bw->cursor);
 806
 807                 /* Column position of cursor */
 808                 col = piscol(bw->cursor);
 809
 810                 /* Indentation step in columns */
 811                 if (bw->o.indentc=='\t')
 812                         wid = bw->o.tab;
 813                 else
 814                         wid = 1;
 815
 816                 indwid = (bw->o.istep*wid);
 817
 818                 /* Smart backspace when: cursor is at indentation point, indentation point
 819                    is a multiple of indentation width, we're not at beginning of line,
 820                    'smarthome' option is enabled, and indentation is purely made out of
 821                    indent characters (or purify indents is enabled). */
 822
 823                 /* Ignore purify for backspace */
 824                 if (col == indent && (col%indwid)==0 && col!=0 && bw->o.smartbacks) {
 825                         P *p;
 826
 827                         /* Delete all indentation */
 828                         p = pdup(bw->cursor);
 829                         p_goto_bol(p);
 830                         bdel(p,bw->cursor);
 831                         prm(p);
 832
 833                         /* Indent to new position */
 834                         pfill(bw->cursor,col-indwid,bw->o.indentc);
 835                 } else if (col<indent && !pisbol(bw->cursor) && bw->o.smartbacks) {
 836                         /* We're before indent point: delete indwid worth of space but do not
 837                            cross line boundary.  We could probably replace the above with this. */
 838                         int cw=0;
 839                         P *p = pdup(bw->cursor);
 840                         do {
 841                                 c = prgetc(bw->cursor);
 842                                 if(c=='\t') cw += bw->o.tab;
 843                                 else cw += 1;
 844                                 bdel(bw->cursor, p);
 845                         } while(!pisbol(bw->cursor) && cw<indwid);
 846                         prm(p);
 847                 } else {
 848                         /* Regular backspace */
 849                         P *p = pdup(bw->cursor);
 850                         if ((c = prgetc(bw->cursor)) != NO_MORE_DATA)
 851                                 if (!bw->o.overtype || c == '\t' || pisbol(p) || piseol(p))
 852                                         bdel(bw->cursor, p);
 853                         prm(p);
 854                 }
 855                 return 0;
 856         } else
 857                 return -1;
 858 }
 859
 860 /*
 861  * Delete sequence of characters (alphabetic, numeric) or (white-space)
 862  *      if cursor is on the white-space it will delete all white-spaces
 863  *              until alphanumeric character
 864  *      if cursor is on the alphanumeric it will delete all alphanumeric
 865  *              characters until character that is not alphanumeric
 866  */
 867 int u_word_delete(BW *bw)
 868 {
 869         P *p = pdup(bw->cursor);
 870         struct charmap *map=bw->b->o.charmap;
 871         int c = brch(p);
 872
 873         if (joe_isalnum_(map,c))
 874                 while (joe_isalnum_(map,(c = brch(p))))
 875                         pgetc(p);
 876         else if (joe_isspace(map,c))
 877                 while (joe_isspace(map,(c = brch(p))))
 878                         pgetc(p);
 879         else
 880                 pgetc(p);
 881
 882         if (p->byte == bw->cursor->byte) {
 883                 prm(p);
 884                 return -1;
 885         }
 886         bdel(bw->cursor, p);
 887         prm(p);
 888         return 0;
 889 }
 890
 891 /* Delete from cursor to beginning of word it's in or immediately after,
 892  * to start of whitespace, or a single character
 893  */
 894
 895 int ubackw(BW *bw)
 896 {
 897         P *p = pdup(bw->cursor);
 898         int c = prgetc(bw->cursor);
 899         struct charmap *map=bw->b->o.charmap;
 900
 901         if (joe_isalnum_(map,c)) {
 902                 while (joe_isalnum_(map,(c = prgetc(bw->cursor))))
 903                         /* do nothing */;
 904                 if (c != NO_MORE_DATA)
 905                         pgetc(bw->cursor);
 906         } else if (joe_isspace(map,c)) {
 907                 while (joe_isspace(map,(c = prgetc(bw->cursor))))
 908                         /* do nothing */;
 909                 if (c != NO_MORE_DATA)
 910                         pgetc(bw->cursor);
 911         }
 912         if (bw->cursor->byte == p->byte) {
 913                 prm(p);
 914                 return -1;
 915         }
 916         bdel(bw->cursor, p);
 917         prm(p);
 918         return 0;
 919 }
 920
 921 /* Delete from cursor to end of line, or if there's nothing to delete,
 922  * delete the line-break
 923  */
 924
 925 int udelel(BW *bw)
 926 {
 927         P *p = p_goto_eol(pdup(bw->cursor));
 928
 929         if (bw->cursor->byte == p->byte) {
 930                 prm(p);
 931                 return udelch(bw);
 932         } else
 933                 bdel(bw->cursor, p);
 934         prm(p);
 935         return 0;
 936 }
 937
 938 /* Delete to beginning of line, or if there's nothing to delete,
 939  * delete the line-break
 940  */
 941
 942 int udelbl(BW *bw)
 943 {
 944         P *p = p_goto_bol(pdup(bw->cursor));
 945
 946         if (p->byte == bw->cursor->byte) {
 947                 prm(p);
 948                 return ubacks(bw, 8);   /* The 8 goes to the process if we're at EOF of shell window */
 949         } else
 950                 bdel(p, bw->cursor);
 951         prm(p);
 952         return 0;
 953 }
 954
 955 /* Delete entire line */
 956
 957 int udelln(BW *bw)
 958 {
 959         P *p = pdup(bw->cursor);
 960
 961         p_goto_bol(bw->cursor);
 962         pnextl(p);
 963         if (bw->cursor->byte == p->byte) {
 964                 prm(p);
 965                 return -1;
 966         }
 967         bdel(bw->cursor, p);
 968         prm(p);
 969         return 0;
 970 }
 971
 972 /* Insert a space */
 973
 974 int uinsc(BW *bw)
 975 {
 976         binsc(bw->cursor, ' ');
 977         return 0;
 978 }
 979
 980 /* Move p backwards to first non-blank line and return its indentation */
 981
 982 int find_indent(P *p)
 983 {
 984         int x;
 985         for (x=0; x != 10; ++x) {
 986                 if (!pprevl(p)) return -1;
 987                 p_goto_bol(p);
 988                 if (!pisblank(p)) break;
 989         }
 990         if (x==10)
 991                 return -1;
 992         else
 993                 return pisindent(p);
 994 }
 995
 996 /* Type a character into the buffer (deal with left margin, overtype mode and
 997  * word-wrap), if cursor is at end of shell window buffer, just send character
 998  * to process.
 999  */
1000
1001 struct utf8_sm utype_utf8_sm;
1002
1003 int utypebw_raw(BW *bw, int k, int no_decode)
1004 {
1005         struct charmap *map=bw->b->o.charmap;
1006
1007         /* Hex mode overtype is real simple */
1008         if (bw->o.hex && bw->o.overtype) {
1009                 P *p;
1010                 unsigned char c = k;
1011                 binsm(bw->cursor, &c, 1);
1012                 pgetb(bw->cursor);
1013                 if (piseof(bw->cursor))
1014                         return 0;
1015                 pgetb(p = pdup(bw->cursor));
1016                 bdel(bw->cursor, p);
1017                 prm(p);
1018                 return 0;
1019         }
1020
1021         if (k == '\t' && bw->o.overtype && !piseol(bw->cursor)) { /* TAB in overtype mode is supposed to be just cursor motion */
1022                 int col = bw->cursor->xcol;             /* Current cursor column */
1023                 col = col + bw->o.tab - (col%bw->o.tab);/* Move to next tab stop */
1024                 pcol(bw->cursor,col);                   /* Try to position cursor there */
1025                 if (!bw->o.picture && piseol(bw->cursor) && piscol(bw->cursor)<col) {   /* We moved past end of line, insert a tab (unless in picture mode) */
1026                         if (bw->o.spaces)
1027                                 pfill(bw->cursor,col,' ');
1028                         else
1029                                 pfill(bw->cursor,col,'\t');
1030                 }
1031                 bw->cursor->xcol = col;                 /* Put cursor there even if we can't really go there */
1032         } else if (k == '\t' && bw->o.smartbacks && bw->o.autoindent && pisindent(bw->cursor)>=piscol(bw->cursor)) {
1033                 P *p = pdup(bw->cursor);
1034                 int n = find_indent(p);
1035                 if (n != -1 && pisindent(bw->cursor)==piscol(bw->cursor) && n > pisindent(bw->cursor)) {
1036                         if (!pisbol(bw->cursor))
1037                                 udelbl(bw);
1038                         while (joe_isspace(map,(k = pgetc(p))) && k != '\n') {
1039                                 binsc(bw->cursor, k);
1040                                 pgetc(bw->cursor);
1041                         }
1042                 } else {
1043                         int x;
1044                         for (x=0;x<bw->o.istep;++x) {
1045                                 binsc(bw->cursor,bw->o.indentc);
1046                                 pgetc(bw->cursor);
1047                         }
1048                 }
1049                 bw->cursor->xcol = piscol(bw->cursor);
1050                 prm (p);
1051         } else if (k == '\t' && bw->o.spaces) {
1052                 long n;
1053
1054                 if (bw->o.picture)
1055                         n = bw->cursor->xcol;
1056                 else
1057                         n = piscol(bw->cursor);
1058
1059                 utype_utf8_sm.state = 0;
1060                 utype_utf8_sm.ptr = 0;
1061
1062                 n = bw->o.tab - n % bw->o.tab;
1063                 while (n--)
1064                         utypebw_raw(bw, ' ', 0);
1065         } else {
1066                 int upd;
1067                 int simple;
1068                 int x;
1069
1070                 /* Picture mode */
1071                 if (bw->o.picture && bw->cursor->xcol!=piscol(bw->cursor))
1072                         pfill(bw->cursor,bw->cursor->xcol,' '); /* Why no tabs? */
1073
1074                 /* UTF8 decoder */
1075                 if(locale_map->type && !no_decode) {
1076                         int utf8_char = utf8_decode(&utype_utf8_sm,k);
1077
1078                         if(utf8_char >= 0)
1079                                 k = utf8_char;
1080                         else
1081                                 return 0;
1082                 }
1083
1084                 upd = bw->parent->t->t->updtab[bw->y + bw->cursor->line - bw->top->line];
1085                 simple = 1;
1086
1087                 if (pisblank(bw->cursor))
1088                         while (piscol(bw->cursor) < bw->o.lmargin) {
1089                                 binsc(bw->cursor, ' ');
1090                                 pgetc(bw->cursor);
1091                         }
1092
1093                 if (no_decode == 2) {
1094                         unsigned char ch = k;
1095
1096                         binsm(bw->cursor, &ch, 1);
1097                         if (!bw->b->o.charmap->type)
1098                                 no_decode = 1;
1099                 } else {
1100                         if (!no_decode) {
1101                                 if(locale_map->type && !bw->b->o.charmap->type) {
1102                                         unsigned char buf[10];
1103                                         utf8_encode(buf,k);
1104                                         k = from_utf8(bw->b->o.charmap,buf);
1105                                 } else if(!locale_map->type && bw->b->o.charmap->type) {
1106                                         unsigned char buf[10];
1107                                         to_utf8(locale_map,buf,k);
1108                                         k = utf8_decode_string(buf);
1109                                 }
1110                         }
1111
1112                         binsc(bw->cursor, k);
1113                 }
1114
1115                 /* We need x position before we move cursor */
1116                 x = piscol(bw->cursor) - bw->offset;
1117                 pgetc(bw->cursor);
1118
1119                 /* Tabs are weird here... */
1120                 if (bw->o.overtype && !piseol(bw->cursor) && k != '\t')
1121                         udelch(bw);
1122
1123                 /* Not sure if we're in right position for wordwrap when we're in overtype mode */
1124                 if (bw->o.wordwrap && piscol(bw->cursor) > bw->o.rmargin && !joe_isblank(map,k)) {
1125                         wrapword(bw->cursor, (long) bw->o.lmargin, bw->o.french, NULL);
1126                         simple = 0;
1127                 }
1128
1129                 bw->cursor->xcol = piscol(bw->cursor);
1130 #ifndef __MSDOS__
1131                 if (x < 0 || x >= bw->w)
1132                         simple = 0;
1133                 if (bw->cursor->line < bw->top->line || bw->cursor->line >= bw->top->line + bw->h)
1134                         simple = 0;
1135                 if (simple && bw->parent->t->t->sary[bw->y + bw->cursor->line - bw->top->line])
1136                         simple = 0;
1137                 else if (simple)
1138                         switch (k) {
1139                         case ' ':
1140                                 if (bw->o.vispace)
1141                                         /* FALLTHROUGH */
1142                         case '\t':
1143                         case '\n':
1144                                   simple = 0;
1145                                 break;
1146                         }
1147                 if (simple && !curmacro) {
1148                         int atr = 0;
1149                         SCRN *t = bw->parent->t->t;
1150                         int y = bw->y + bw->cursor->line - bw->top->line;
1151                         int *screen = t->scrn + y * t->co;
1152                         int *attr = t->attr + y * t->co;
1153                         x += bw->x;
1154
1155                         if (!upd && piseol(bw->cursor) && !bw->o.highlight)
1156                                 t->updtab[y] = 0;
1157                         if (markb &&
1158                             markk &&
1159                             markb->b == bw->b &&
1160                             markk->b == bw->b &&
1161                            ((!square && bw->cursor->byte >= markb->byte && bw->cursor->byte < markk->byte) ||
1162                             ( square && bw->cursor->line >= markb->line && bw->cursor->line <= markk->line && piscol(bw->cursor) >= markb->xcol && piscol(bw->cursor) < markk->xcol)))
1163                                 atr = INVERSE;
1164                         outatr(bw->b->o.charmap, t, screen + x, attr + x, x, y, no_decode == 2 ? 0xFFFD : k, atr);
1165                 }
1166 #endif
1167         }
1168         return 0;
1169 }
1170
1171 int utypebw(BW *bw, int k)
1172 {
1173         return utypebw_raw(bw, k, 0);
1174 }
1175
1176 /* Quoting */
1177
1178 static B *unicodehist = NULL;   /* History of previously entered unicode characters */
1179
1180 static int dounicode(BW *bw, unsigned char *s, void *object, int *notify)
1181 {
1182         int num;
1183
1184         sscanf((char *)s,"%x",&num);
1185         if (notify)
1186                 *notify = 1;
1187         vsrm(s);
1188         if (bw->b->o.charmap->type)
1189                 utypebw_raw(bw, num, 1);
1190         else {
1191                 unsigned char buf[8];
1192                 int x;
1193
1194                 utf8_encode(buf,num);
1195                 for(x=0;buf[x];++x)
1196                         utypebw_raw(bw, buf[x], 1);
1197         }
1198         bw->cursor->xcol = piscol(bw->cursor);
1199         return 0;
1200 }
1201
1202 int quotestate;
1203 int quoteval;
1204
1205 static int doquote(BW *bw, int c, void *object, int *notify)
1206 {
1207         unsigned char buf[40];
1208
1209         if (c < 0 || c >= 256) {
1210                 nungetc(c);
1211                 return -1;
1212         }
1213         switch (quotestate) {
1214         case 0:
1215                 if (c >= '0' && c <= '9') {
1216                         quoteval = c - '0';
1217                         quotestate = 1;
1218                         joe_snprintf_1((char *)buf, sizeof(buf), "ASCII %c--", c);
1219                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1220                                 return -1;
1221                         else
1222                                 return 0;
1223                 } else if (c == 'u' || c == 'U') {
1224                         if (bw->b->o.charmap->type)
1225                                 goto unopoo;
1226  uhex_uni:
1227                         if (!wmkpw(bw->parent, US "Unicode (ISO-10646) character in hex (^C to abort): ", &unicodehist, dounicode,
1228                                    NULL, NULL, NULL, NULL, NULL, locale_map))
1229                                 return 0;
1230                         else
1231                                 return -1;
1232                 } else if (c == 'r' || c == 'R') {
1233                         if (!bw->b->o.charmap->type)
1234                                 goto unopoo;
1235  uhex_raw:
1236                         quotestate = 3;
1237                         if (!mkqwna(bw->parent, sc("ASCII 0x--"), doquote, NULL, NULL, notify))
1238                                 return -1;
1239                         else
1240                                 return 0;
1241                 } else if (c == 'x' || c == 'X') {
1242                         if (bw->b->o.charmap->type)
1243                                 goto uhex_uni;
1244                         else
1245                                 goto uhex_raw;
1246                 } else if (c == 'o' || c == 'O') {
1247                         quotestate = 5;
1248                         if (!mkqwna(bw->parent, sc("ASCII 0---"), doquote, NULL, NULL, notify))
1249                                 return -1;
1250                         else
1251                                 return 0;
1252                 } else {
1253  unopoo:
1254                         if ((c >= 0x40 && c <= 0x5F) || (c >= 'a' && c <= 'z'))
1255                                 c &= 0x1F;
1256                         if (c == '?')
1257                                 c = 127;
1258                         utypebw_raw(bw, c, 1);
1259                         bw->cursor->xcol = piscol(bw->cursor);
1260                 }
1261                 break;
1262         case 1:
1263                 if (c >= '0' && c <= '9') {
1264                         joe_snprintf_2((char *)buf, sizeof(buf), "ASCII %c%c-", quoteval + '0', c);
1265                         quoteval = quoteval * 10 + c - '0';
1266                         quotestate = 2;
1267                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1268                                 return -1;
1269                         else
1270                                 return 0;
1271                 }
1272                 break;
1273         case 2:
1274                 if (c >= '0' && c <= '9') {
1275                         quoteval = quoteval * 10 + c - '0';
1276                         utypebw_raw(bw, quoteval, 1);
1277                         bw->cursor->xcol = piscol(bw->cursor);
1278                 }
1279                 break;
1280         case 3:
1281                 if (c >= '0' && c <= '9') {
1282                         joe_snprintf_1((char *)buf, sizeof(buf), "ASCII 0x%c-", c);
1283                         quoteval = c - '0';
1284                         quotestate = 4;
1285                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1286                                 return -1;
1287                         else
1288                                 return 0;
1289                 } else if (c >= 'a' && c <= 'f') {
1290                         joe_snprintf_1((char *)buf, sizeof(buf), "ASCII 0x%c-", c + 'A' - 'a');
1291                         quoteval = c - 'a' + 10;
1292                         quotestate = 4;
1293                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1294                                 return -1;
1295                         else
1296                                 return 0;
1297                 } else if (c >= 'A' && c <= 'F') {
1298                         joe_snprintf_1((char *)buf, sizeof(buf), "ASCII 0x%c-", c);
1299                         quoteval = c - 'A' + 10;
1300                         quotestate = 4;
1301                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1302                                 return -1;
1303                         else
1304                                 return 0;
1305                 }
1306                 break;
1307         case 4:
1308                 if (c >= '0' && c <= '9') {
1309                         quoteval = quoteval * 16 + c - '0';
1310  u4out:
1311                         utypebw_raw(bw, quoteval, 2);
1312                         bw->cursor->xcol = piscol(bw->cursor);
1313                 } else if (c >= 'a' && c <= 'f') {
1314                         quoteval = quoteval * 16 + c - 'a' + 10;
1315                         goto u4out;
1316                 } else if (c >= 'A' && c <= 'F') {
1317                         quoteval = quoteval * 16 + c - 'A' + 10;
1318                         goto u4out;
1319                 }
1320                 break;
1321         case 5:
1322                 if (c >= '0' && c <= '7') {
1323                         joe_snprintf_1((char *)buf, sizeof(buf), "ASCII 0%c--", c);
1324                         quoteval = c - '0';
1325                         quotestate = 6;
1326                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1327                                 return -1;
1328                         else
1329                                 return 0;
1330                 }
1331                 break;
1332         case 6:
1333                 if (c >= '0' && c <= '7') {
1334                         joe_snprintf_2((char *)buf, sizeof(buf), "ASCII 0%c%c-", quoteval + '0', c);
1335                         quoteval = quoteval * 8 + c - '0';
1336                         quotestate = 7;
1337                         if (!mkqwna(bw->parent, sz(buf), doquote, NULL, NULL, notify))
1338                                 return -1;
1339                         else
1340                                 return 0;
1341                 }
1342                 break;
1343         case 7:
1344                 if (c >= '0' && c <= '7') {
1345                         quoteval = quoteval * 8 + c - '0';
1346                         utypebw_raw(bw, quoteval, 1);
1347                         bw->cursor->xcol = piscol(bw->cursor);
1348                 }
1349                 break;
1350         }
1351         if (notify)
1352                 *notify = 1;
1353         return 0;
1354 }
1355
1356 int uquote(BW *bw)
1357 {
1358         const char *qs;
1359
1360         if (bw->b->o.charmap->type)
1361                 qs = "Ctrl- (or 0-9 for dec. r for hex, o for octal ASCII, x for hex UTF-8)";
1362         else
1363                 qs = "Ctrl- (or 0-9 for dec. x for hex, o for octal ASCII, u for hex UTF-8)";
1364         quotestate = 0;
1365         if (mkqwna(bw->parent, US qs, strlen(qs), doquote, NULL, NULL, NULL))
1366                 return 0;
1367         else
1368                 return -1;
1369 }
1370
1371 static int doquote9(BW *bw, int c, void *object, int *notify)
1372 {
1373         if (notify)
1374                 *notify = 1;
1375         if ((c >= 0x40 && c <= 0x5F) || (c >= 'a' && c <= 'z'))
1376                 c &= 0x1F;
1377         if (c == '?')
1378                 c = 127;
1379         c |= 128;
1380         utypebw_raw(bw, c, 1);
1381         bw->cursor->xcol = piscol(bw->cursor);
1382         return 0;
1383 }
1384
1385 static int doquote8(BW *bw, int c, void *object, int *notify)
1386 {
1387         if (c == '`') {
1388                 if (mkqwna(bw->parent, sc("Meta-Ctrl-"), doquote9, NULL, NULL, notify))
1389                         return 0;
1390                 else
1391                         return -1;
1392         }
1393         if (notify)
1394                 *notify = 1;
1395         c |= 128;
1396         utypebw_raw(bw, c, 1);
1397         bw->cursor->xcol = piscol(bw->cursor);
1398         return 0;
1399 }
1400
1401 int uquote8(BW *bw)
1402 {
1403         if (mkqwna(bw->parent, sc("Meta-"), doquote8, NULL, NULL, NULL))
1404                 return 0;
1405         else
1406                 return -1;
1407 }
1408
1409 extern const unsigned char srchstr[];
1410
1411 static int doctrl(BW *bw, int c, void *object, int *notify)
1412 {
1413         int org = bw->o.overtype;
1414
1415         if (notify)
1416                 *notify = 1;
1417         bw->o.overtype = 0;
1418         if (bw->parent->huh == srchstr && c == '\n') {
1419                 utypebw(bw, '\\');
1420                 utypebw(bw, 'n');
1421         } else
1422                 utypebw_raw(bw, c, 1);
1423         bw->o.overtype = org;
1424         bw->cursor->xcol = piscol(bw->cursor);
1425         return 0;
1426 }
1427
1428 int uctrl(BW *bw)
1429 {
1430         if (mkqwna(bw->parent, sc("Quote"), doctrl, NULL, NULL, NULL))
1431                 return 0;
1432         else
1433                 return -1;
1434 }
1435
1436 /* User hit Return.  Deal with autoindent.
1437  */
1438
1439 int rtntw(BW *bw)
1440 {
1441         if (bw->o.overtype) {
1442                 p_goto_eol(bw->cursor);
1443                 if (piseof(bw->cursor))
1444                         binsc(bw->cursor, '\n');
1445                 pgetc(bw->cursor);
1446                 bw->cursor->xcol = piscol(bw->cursor);
1447         } else {
1448                 P *p = pdup(bw->cursor);
1449                 unsigned char c;
1450
1451                 binsc(bw->cursor, '\n'), pgetc(bw->cursor);
1452                 /* Suppress autoindent if we're on a space or tab... */
1453                 if (bw->o.autoindent && (brch(bw->cursor)!=' ' && brch(bw->cursor)!='\t')) {
1454                         p_goto_bol(p);
1455                         while (joe_isspace(bw->b->o.charmap,(c = pgetc(p))) && c != '\n') {
1456                                 binsc(bw->cursor, c);
1457                                 pgetc(bw->cursor);
1458                         }
1459                 }
1460                 prm(p);
1461                 bw->cursor->xcol = piscol(bw->cursor);
1462         }
1463         return 0;
1464 }
1465
1466 /* Open a line */
1467
1468 int uopen(BW *bw)
1469 {
1470         binsc(bw->cursor,'\n');
1471         return 0;
1472 }
1473
1474 /* Set book-mark */
1475
1476 static int dosetmark(BW *bw, int c, void *object, int *notify)
1477 {
1478         if (notify)
1479                 *notify = 1;
1480         if (c >= '0' && c <= ':') {
1481                 pdupown(bw->cursor, bw->b->marks + c - '0');
1482                 poffline(bw->b->marks[c - '0']);
1483                 if (c!=':') {
1484                         joe_snprintf_1((char *)msgbuf, JOE_MSGBUFSIZE, "Mark %d set", c - '0');
1485                         msgnw(bw->parent, msgbuf);
1486                 }
1487                 return 0;
1488         } else {
1489                 nungetc(c);
1490                 return -1;
1491         }
1492 }
1493
1494 int usetmark(BW *bw, int c)
1495 {
1496         if (c >= '0' && c <= ':')
1497                 return dosetmark(bw, c, NULL, NULL);
1498         else if (mkqwna(bw->parent, sc("Set mark (0-9):"), dosetmark, NULL, NULL, NULL))
1499                 return 0;
1500         else
1501                 return -1;
1502 }
1503
1504 /* Goto book-mark */
1505
1506 static int dogomark(BW *bw, int c, void *object, int *notify)
1507 {
1508         if (notify)
1509                 *notify = 1;
1510         if (c >= '0' && c <= ':')
1511                 if (bw->b->marks[c - '0']) {
1512                         pset(bw->cursor, bw->b->marks[c - '0']);
1513                         bw->cursor->xcol = piscol(bw->cursor);
1514                         return 0;
1515                 } else {
1516                         joe_snprintf_1((char *)msgbuf, JOE_MSGBUFSIZE, "Mark %d not set", c - '0');
1517                         msgnw(bw->parent, msgbuf);
1518                         return -1;
1519         } else {
1520                 nungetc(c);
1521                 return -1;
1522         }
1523 }
1524
1525 int ugomark(BW *bw, int c)
1526 {
1527         if (c >= '0' && c <= '9')
1528                 return dogomark(bw, c, NULL, NULL);
1529         else if (mkqwna(bw->parent, sc("Goto bookmark (0-9):"), dogomark, NULL, NULL, NULL))
1530                 return 0;
1531         else
1532                 return -1;
1533 }
1534
1535 /* Goto next instance of character */
1536
1537 static int dobkwdc;
1538
1539 static int dofwrdc(BW *bw, int k, void *object, int *notify)
1540 {
1541         int c;
1542         P *q;
1543
1544         if (notify)
1545                 *notify = 1;
1546         if (k < 0 || k >= 256) {
1547                 nungetc(k);
1548                 return -1;
1549         }
1550         q = pdup(bw->cursor);
1551         if (dobkwdc) {
1552                 while ((c = prgetc(q)) != NO_MORE_DATA)
1553                         if (c == k)
1554                                 break;
1555         } else {
1556                 while ((c = pgetc(q)) != NO_MORE_DATA)
1557                         if (c == k)
1558                                 break;
1559         }
1560         if (c == NO_MORE_DATA) {
1561                 msgnw(bw->parent, US "Not found");
1562                 prm(q);
1563                 return -1;
1564         } else {
1565                 pset(bw->cursor, q);
1566                 bw->cursor->xcol = piscol(bw->cursor);
1567                 prm(q);
1568                 return 0;
1569         }
1570 }
1571
1572 int ufwrdc(BW *bw, int k)
1573 {
1574         dobkwdc = 0;
1575         if (k >= 0 && k < 256)
1576                 return dofwrdc(bw, k, NULL, NULL);
1577         else if (mkqw(bw->parent, sc("Fwrd to char: "), dofwrdc, NULL, NULL, NULL))
1578                 return 0;
1579         else
1580                 return -1;
1581 }
1582
1583 int ubkwdc(BW *bw, int k)
1584 {
1585         dobkwdc = 1;
1586         if (k >= 0 && k < 256)
1587                 return dofwrdc(bw, k, NULL, NULL);
1588         else if (mkqw(bw->parent, sc("Bkwd to char: "), dofwrdc, NULL, NULL, NULL))
1589                 return 0;
1590         else
1591                 return -1;
1592 }
1593
1594 /* Display a message */
1595
1596 static int domsg(BASE *b, unsigned char *s, void *object, int *notify)
1597 {
1598         if (notify)
1599                 *notify = 1;
1600         strlcpy((char *)msgbuf, (char *)s, JOE_MSGBUFSIZE);
1601         vsrm(s);
1602         msgnw(b->parent, *msgbuf ? msgbuf : NULL);
1603         return 0;
1604 }
1605
1606 int umsg(BASE *b)
1607 {
1608         if (wmkpw(b->parent, US "Msg (^C to abort): ", NULL, domsg, NULL, NULL, NULL, NULL, NULL, locale_map))
1609                 return 0;
1610         else
1611                 return -1;
1612 }
1613
1614 /* Insert text */
1615
1616 static int dotxt(BW *bw, unsigned char *s, void *object, int *notify)
1617 {
1618         int x;
1619
1620         if (notify)
1621                 *notify = 1;
1622         for (x = 0; x != sLEN(s); ++x)
1623                 utypebw(bw, s[x]);
1624         vsrm(s);
1625         return 0;
1626 }
1627
1628 int utxt(BW *bw)
1629 {
1630         if (wmkpw(bw->parent, US "Insert (^C to abort): ", NULL, dotxt, NULL, NULL, utypebw, NULL, NULL, bw->b->o.charmap))
1631                 return 0;
1632         else
1633                 return -1;
1634 }