git.oblomov.eu Git - wine/blob - dlls/kernel32/editline.c

   1 /*
   2  * line edition function for Win32 console
   3  *
   4  * Copyright 2001 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <string.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wincon.h"
  30 #include "wine/unicode.h"
  31 #include "winnls.h"
  32 #include "wine/debug.h"
  33 #include "console_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(console);
  36
  37 struct WCEL_Context;
  38
  39 typedef struct
  40 {
  41     WCHAR                       val;            /* vk or unicode char */
  42     void                        (*func)(struct WCEL_Context* ctx);
  43 } KeyEntry;
  44
  45 typedef struct
  46 {
  47     DWORD                       keyState;       /* keyState (from INPUT_RECORD) to match */
  48     BOOL                        chkChar;        /* check vk or char */
  49     const KeyEntry*             entries;        /* array of entries */
  50 } KeyMap;
  51
  52 typedef struct WCEL_Context {
  53     WCHAR*                      line;           /* the line being edited */
  54     size_t                      alloc;          /* number of WCHAR in line */
  55     unsigned                    len;            /* number of chars in line */
  56     unsigned                    last_rub;       /* number of chars to rub to get to start
  57                                                    (for consoles that can't change cursor pos) */
  58     unsigned                    last_max;       /* max number of chars written
  59                                                    (for consoles that can't change cursor pos) */
  60     unsigned                    ofs;            /* offset for cursor in current line */
  61     WCHAR*                      yanked;         /* yanked line */
  62     unsigned                    mark;           /* marked point (emacs mode only) */
  63     CONSOLE_SCREEN_BUFFER_INFO  csbi;           /* current state (initial cursor, window size, attribute) */
  64     HANDLE                      hConIn;
  65     HANDLE                      hConOut;
  66     unsigned                    done : 1,       /* to 1 when we're done with editing */
  67                                 error : 1,      /* to 1 when an error occurred in the editing */
  68                                 can_wrap : 1,   /* to 1 when multi-line edition can take place */
  69                                 shall_echo : 1, /* to 1 when characters should be echo:ed when keyed-in */
  70                                 insert : 1,     /* to 1 when new characters are inserted (otherwise overwrite) */
  71                                 can_pos_cursor : 1; /* to 1 when console can (re)position cursor */
  72     unsigned                    histSize;
  73     unsigned                    histPos;
  74     WCHAR*                      histCurr;
  75 } WCEL_Context;
  76
  77 #if 0
  78 static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
  79 {
  80     MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c%c]\n"
  81             "\t\thist=(size=%u pos=%u curr=%s)\n"
  82             "\t\tyanked=%s\n",
  83             pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
  84             ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
  85             ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e', ctx->can_wrap ? 'W' : 'w',
  86             ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr),
  87             debugstr_w(ctx->yanked));
  88 }
  89 #endif
  90
  91 /* ====================================================================
  92  *
  93  * Console helper functions
  94  *
  95  * ====================================================================*/
  96
  97 static BOOL WCEL_Get(WCEL_Context* ctx, INPUT_RECORD* ir)
  98 {
  99     if (ReadConsoleInputW(ctx->hConIn, ir, 1, NULL)) return TRUE;
 100     ctx->error = 1;
 101     return FALSE;
 102 }
 103
 104 static inline void WCEL_Beep(WCEL_Context* ctx)
 105 {
 106     Beep(400, 300);
 107 }
 108
 109 static inline BOOL WCEL_IsSingleLine(WCEL_Context* ctx, size_t len)
 110 {
 111     return ctx->csbi.dwCursorPosition.X + ctx->len + len <= ctx->csbi.dwSize.X;
 112 }
 113
 114 static inline int WCEL_CharWidth(WCHAR wch)
 115 {
 116     return wch < ' ' ? 2 : 1;
 117 }
 118
 119 static inline int WCEL_StringWidth(const WCHAR* str, int beg, int len)
 120 {
 121     int         i, ofs;
 122
 123     for (i = 0, ofs = 0; i < len; i++)
 124         ofs += WCEL_CharWidth(str[beg + i]);
 125     return ofs;
 126 }
 127
 128 static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int strofs)
 129 {
 130     COORD       c;
 131     int         len = ctx->csbi.dwSize.X - ctx->csbi.dwCursorPosition.X;
 132     int         ofs;
 133
 134     ofs = WCEL_StringWidth(ctx->line, 0, strofs);
 135
 136     c.Y = ctx->csbi.dwCursorPosition.Y;
 137     if (ofs >= len)
 138     {
 139         ofs -= len;
 140         c.X = ofs % ctx->csbi.dwSize.X;
 141         c.Y += 1 + ofs / ctx->csbi.dwSize.X;
 142     }
 143     else c.X = ctx->csbi.dwCursorPosition.X + ofs;
 144     return c;
 145 }
 146
 147 static DWORD WCEL_WriteConsole(WCEL_Context* ctx, DWORD beg, DWORD len)
 148 {
 149     DWORD i, last, dw, ret = 0;
 150     WCHAR tmp[2];
 151
 152     for (i = last = 0; i < len; i++)
 153     {
 154         if (ctx->line[beg + i] < ' ')
 155         {
 156             if (last != i)
 157             {
 158                 WriteConsoleW(ctx->hConOut, &ctx->line[beg + last], i - last, &dw, NULL);
 159                 ret += dw;
 160             }
 161             tmp[0] = '^';
 162             tmp[1] = '@' + ctx->line[beg + i];
 163             WriteConsoleW(ctx->hConOut, tmp, 2, &dw, NULL);
 164             last = i + 1;
 165             ret += dw;
 166         }
 167     }
 168     if (last != len)
 169     {
 170         WriteConsoleW(ctx->hConOut, &ctx->line[beg + last], len - last, &dw, NULL);
 171         ret += dw;
 172     }
 173     return ret;
 174 }
 175
 176 static inline void WCEL_WriteNChars(WCEL_Context* ctx, char ch, int count)
 177 {
 178     DWORD       dw;
 179
 180     if (count > 0)
 181     {
 182         while (count--) WriteFile(ctx->hConOut, &ch, 1, &dw, NULL);
 183     }
 184 }
 185
 186 static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
 187 {
 188     int         i, last;
 189     DWORD       count;
 190     WCHAR       tmp[2];
 191
 192     /* bare console case is handled in CONSOLE_ReadLine (we always reprint the whole string) */
 193     if (!ctx->shall_echo || !ctx->can_pos_cursor) return;
 194
 195     for (i = last = beg; i < beg + len; i++)
 196     {
 197         if (ctx->line[i] < ' ')
 198         {
 199             if (last != i)
 200             {
 201                 WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[last], i - last,
 202                                              WCEL_GetCoord(ctx, last), &count);
 203                 FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, i - last,
 204                                            WCEL_GetCoord(ctx, last), &count);
 205             }
 206             tmp[0] = '^';
 207             tmp[1] = '@' + ctx->line[i];
 208             WriteConsoleOutputCharacterW(ctx->hConOut, tmp, 2,
 209                                          WCEL_GetCoord(ctx, i), &count);
 210             FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, 2,
 211                                        WCEL_GetCoord(ctx, i), &count);
 212             last = i + 1;
 213         }
 214     }
 215     if (last != beg + len)
 216     {
 217         WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[last], i - last,
 218                                      WCEL_GetCoord(ctx, last), &count);
 219         FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, i - last,
 220                                    WCEL_GetCoord(ctx, last), &count);
 221     }
 222 }
 223
 224 /* ====================================================================
 225  *
 226  * context manipulation functions
 227  *
 228  * ====================================================================*/
 229
 230 static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
 231 {
 232     if (!WCEL_IsSingleLine(ctx, len) && !ctx->can_wrap)
 233     {
 234         FIXME("Mode doesn't allow to wrap. However, we should allow to overwrite current string\n");
 235         return FALSE;
 236     }
 237
 238     if (ctx->len + len >= ctx->alloc)
 239     {
 240         WCHAR*  newline;
 241         size_t  newsize;
 242
 243         /* round up size to 32 byte-WCHAR boundary */
 244         newsize = (ctx->len + len + 1 + 31) & ~31;
 245
 246         if (ctx->line)
 247             newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * newsize);
 248         else
 249             newline = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * newsize);
 250
 251         if (!newline) return FALSE;
 252         ctx->line = newline;
 253         ctx->alloc = newsize;
 254     }
 255     return TRUE;
 256 }
 257
 258 static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
 259 {
 260     unsigned    str_len = end - beg;
 261
 262     if (end < ctx->len)
 263         memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
 264     /* we need to clean from ctx->len - str_len to ctx->len */
 265
 266     if (ctx->shall_echo)
 267     {
 268         COORD       cbeg = WCEL_GetCoord(ctx, ctx->len - str_len);
 269         COORD       cend = WCEL_GetCoord(ctx, ctx->len);
 270         CHAR_INFO   ci;
 271
 272         ci.Char.UnicodeChar = ' ';
 273         ci.Attributes = ctx->csbi.wAttributes;
 274
 275         if (cbeg.Y == cend.Y)
 276         {
 277             /* partial erase of sole line */
 278             CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
 279                                     cend.X - cbeg.X, &ci);
 280         }
 281         else
 282         {
 283             int         i;
 284             /* erase til eol on first line */
 285             CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
 286                                     ctx->csbi.dwSize.X - cbeg.X, &ci);
 287             /* completely erase all the others (full lines) */
 288             for (i = cbeg.Y + 1; i < cend.Y; i++)
 289                 CONSOLE_FillLineUniform(ctx->hConOut, 0, i, ctx->csbi.dwSize.X, &ci);
 290             /* erase from beginning of line until last pos on last line */
 291             CONSOLE_FillLineUniform(ctx->hConOut, 0, cend.Y, cend.X, &ci);
 292         }
 293     }
 294     ctx->len -= str_len;
 295     WCEL_Update(ctx, 0, ctx->len);
 296     ctx->line[ctx->len] = 0;
 297 }
 298
 299 static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
 300 {
 301     size_t      len = lstrlenW(str), updtlen;
 302
 303     if (!len) return;
 304     if (ctx->insert)
 305     {
 306         if (!WCEL_Grow(ctx, len)) return;
 307         if (ctx->len > ctx->ofs)
 308             memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
 309         ctx->len += len;
 310         updtlen = ctx->len - ctx->ofs;
 311     }
 312     else
 313     {
 314         if (ctx->ofs + len > ctx->len)
 315         {
 316             if (!WCEL_Grow(ctx, (ctx->ofs + len) - ctx->len)) return;
 317             ctx->len = ctx->ofs + len;
 318         }
 319         updtlen = len;
 320     }
 321     memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
 322     ctx->line[ctx->len] = 0;
 323     WCEL_Update(ctx, ctx->ofs, updtlen);
 324     ctx->ofs += len;
 325 }
 326
 327 static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
 328 {
 329     WCHAR       buffer[2];
 330
 331     buffer[0] = c;
 332     buffer[1] = 0;
 333     WCEL_InsertString(ctx, buffer);
 334 }
 335
 336 static void WCEL_FreeYank(WCEL_Context* ctx)
 337 {
 338     HeapFree(GetProcessHeap(), 0, ctx->yanked);
 339     ctx->yanked = NULL;
 340 }
 341
 342 static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
 343 {
 344     int len = end - beg;
 345     if (len <= 0) return;
 346
 347     WCEL_FreeYank(ctx);
 348     /* After WCEL_FreeYank ctx->yanked is empty */
 349     ctx->yanked = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 350     if (!ctx->yanked) return;
 351     memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
 352     ctx->yanked[len] = 0;
 353 }
 354
 355 /* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
 356  * of the data lay in unicode lib
 357  */
 358 static inline BOOL WCEL_iswalnum(WCHAR wc)
 359 {
 360     return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
 361 }
 362
 363 static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
 364 {
 365     ofs--;
 366     while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
 367     while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
 368     if (ofs >= 0) ofs++;
 369     return max(ofs, 0);
 370 }
 371
 372 static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
 373 {
 374     ofs++;
 375     while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
 376     while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
 377     return min(ofs, ctx->len);
 378 }
 379
 380 static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
 381 {
 382     WCHAR*      ptr;
 383
 384     if (idx == ctx->histSize - 1)
 385     {
 386         ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
 387         lstrcpyW(ptr, ctx->histCurr);
 388     }
 389     else
 390     {
 391         int     len = CONSOLE_GetHistory(idx, NULL, 0);
 392
 393         if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 394         {
 395             CONSOLE_GetHistory(idx, ptr, len);
 396         }
 397     }
 398     return ptr;
 399 }
 400
 401 static void     WCEL_HistoryInit(WCEL_Context* ctx)
 402 {
 403     ctx->histPos  = CONSOLE_GetNumHistoryEntries();
 404     ctx->histSize = ctx->histPos + 1;
 405     ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
 406 }
 407
 408 static void    WCEL_MoveToHist(WCEL_Context* ctx, int idx)
 409 {
 410     WCHAR*      data = WCEL_GetHistory(ctx, idx);
 411     int         len = lstrlenW(data) + 1;
 412
 413     /* save current line edition for recall when needed (FIXME seems broken to me) */
 414     if (ctx->histPos == ctx->histSize - 1)
 415     {
 416         HeapFree(GetProcessHeap(), 0, ctx->histCurr);
 417         ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
 418         memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
 419     }
 420     /* need to clean also the screen if new string is shorter than old one */
 421     WCEL_DeleteString(ctx, 0, ctx->len);
 422     ctx->ofs = 0;
 423     /* insert new string */
 424     if (WCEL_Grow(ctx, len))
 425     {
 426         WCEL_InsertString(ctx, data);
 427         HeapFree(GetProcessHeap(), 0, data);
 428         ctx->histPos = idx;
 429     }
 430 }
 431
 432 static void    WCEL_FindPrevInHist(WCEL_Context* ctx)
 433 {
 434     int startPos = ctx->histPos;
 435     WCHAR*      data;
 436     unsigned int    len, oldofs;
 437
 438     if (ctx->histPos && ctx->histPos == ctx->histSize) {
 439         startPos--;
 440         ctx->histPos--;
 441     }
 442
 443     do {
 444        data = WCEL_GetHistory(ctx, ctx->histPos);
 445
 446        if (ctx->histPos) ctx->histPos--;
 447        else ctx->histPos = (ctx->histSize-1);
 448
 449        len = lstrlenW(data) + 1;
 450        if ((len >= ctx->ofs) &&
 451            (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
 452
 453            /* need to clean also the screen if new string is shorter than old one */
 454            WCEL_DeleteString(ctx, 0, ctx->len);
 455
 456            if (WCEL_Grow(ctx, len))
 457            {
 458               oldofs = ctx->ofs;
 459               ctx->ofs = 0;
 460               WCEL_InsertString(ctx, data);
 461               ctx->ofs = oldofs;
 462               if (ctx->shall_echo)
 463                   SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
 464               HeapFree(GetProcessHeap(), 0, data);
 465               return;
 466            }
 467        }
 468     } while (ctx->histPos != startPos);
 469
 470     return;
 471 }
 472
 473 /* ====================================================================
 474  *
 475  * basic edition functions
 476  *
 477  * ====================================================================*/
 478
 479 static void WCEL_Done(WCEL_Context* ctx)
 480 {
 481     WCHAR       nl = '\n';
 482     if (!WCEL_Grow(ctx, 2)) return;
 483     ctx->line[ctx->len++] = '\r';
 484     ctx->line[ctx->len++] = '\n';
 485     ctx->line[ctx->len] = 0;
 486     WriteConsoleW(ctx->hConOut, &nl, 1, NULL, NULL);
 487     ctx->done = 1;
 488 }
 489
 490 static void WCEL_MoveLeft(WCEL_Context* ctx)
 491 {
 492     if (ctx->ofs > 0) ctx->ofs--;
 493 }
 494
 495 static void WCEL_MoveRight(WCEL_Context* ctx)
 496 {
 497     if (ctx->ofs < ctx->len) ctx->ofs++;
 498 }
 499
 500 static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
 501 {
 502     unsigned int        new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 503     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 504 }
 505
 506 static void WCEL_MoveToRightWord(WCEL_Context* ctx)
 507 {
 508     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 509     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 510 }
 511
 512 static void WCEL_MoveToBeg(WCEL_Context* ctx)
 513 {
 514     ctx->ofs = 0;
 515 }
 516
 517 static void WCEL_MoveToEnd(WCEL_Context* ctx)
 518 {
 519     ctx->ofs = ctx->len;
 520 }
 521
 522 static void WCEL_SetMark(WCEL_Context* ctx)
 523 {
 524     ctx->mark = ctx->ofs;
 525 }
 526
 527 static void WCEL_ExchangeMark(WCEL_Context* ctx)
 528 {
 529     unsigned tmp;
 530
 531     if (ctx->mark > ctx->len) return;
 532     tmp = ctx->ofs;
 533     ctx->ofs = ctx->mark;
 534     ctx->mark = tmp;
 535 }
 536
 537 static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
 538 {
 539     unsigned beg, end;
 540
 541     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 542     if (ctx->mark > ctx->ofs)
 543     {
 544         beg = ctx->ofs;         end = ctx->mark;
 545     }
 546     else
 547     {
 548         beg = ctx->mark;        end = ctx->ofs;
 549     }
 550     WCEL_SaveYank(ctx, beg, end);
 551 }
 552
 553 static void WCEL_TransposeChar(WCEL_Context* ctx)
 554 {
 555     WCHAR       c;
 556
 557     if (!ctx->ofs || ctx->ofs == ctx->len) return;
 558
 559     c = ctx->line[ctx->ofs];
 560     ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
 561     ctx->line[ctx->ofs - 1] = c;
 562
 563     WCEL_Update(ctx, ctx->ofs - 1, 2);
 564     ctx->ofs++;
 565 }
 566
 567 static void WCEL_TransposeWords(WCEL_Context* ctx)
 568 {
 569     unsigned int        left_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs),
 570         right_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 571     if (left_ofs < ctx->ofs && right_ofs > ctx->ofs)
 572     {
 573         unsigned len_r = right_ofs - ctx->ofs;
 574         unsigned len_l = ctx->ofs - left_ofs;
 575
 576         char*   tmp = HeapAlloc(GetProcessHeap(), 0, len_r * sizeof(WCHAR));
 577         if (!tmp) return;
 578
 579         memcpy(tmp, &ctx->line[ctx->ofs], len_r * sizeof(WCHAR));
 580         memmove(&ctx->line[left_ofs + len_r], &ctx->line[left_ofs], len_l * sizeof(WCHAR));
 581         memcpy(&ctx->line[left_ofs], tmp, len_r * sizeof(WCHAR));
 582
 583         HeapFree(GetProcessHeap(), 0, tmp);
 584         WCEL_Update(ctx, left_ofs, len_l + len_r);
 585         ctx->ofs = right_ofs;
 586     }
 587 }
 588
 589 static void WCEL_LowerCaseWord(WCEL_Context* ctx)
 590 {
 591     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 592     if (new_ofs != ctx->ofs)
 593     {
 594         unsigned int    i;
 595         for (i = ctx->ofs; i <= new_ofs; i++)
 596             ctx->line[i] = tolowerW(ctx->line[i]);
 597         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 598         ctx->ofs = new_ofs;
 599     }
 600 }
 601
 602 static void WCEL_UpperCaseWord(WCEL_Context* ctx)
 603 {
 604     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 605     if (new_ofs != ctx->ofs)
 606     {
 607         unsigned int    i;
 608         for (i = ctx->ofs; i <= new_ofs; i++)
 609             ctx->line[i] = toupperW(ctx->line[i]);
 610         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 611         ctx->ofs = new_ofs;
 612     }
 613 }
 614
 615 static void WCEL_CapitalizeWord(WCEL_Context* ctx)
 616 {
 617     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 618     if (new_ofs != ctx->ofs)
 619     {
 620         unsigned int    i;
 621
 622         ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
 623         for (i = ctx->ofs + 1; i <= new_ofs; i++)
 624             ctx->line[i] = tolowerW(ctx->line[i]);
 625         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 626         ctx->ofs = new_ofs;
 627     }
 628 }
 629
 630 static void WCEL_Yank(WCEL_Context* ctx)
 631 {
 632     WCEL_InsertString(ctx, ctx->yanked);
 633 }
 634
 635 static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
 636 {
 637     WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
 638     WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
 639 }
 640
 641 static void WCEL_KillFromBegOfLine(WCEL_Context* ctx)
 642 {
 643     if (ctx->ofs)
 644     {
 645         WCEL_SaveYank(ctx, 0, ctx->ofs);
 646         WCEL_DeleteString(ctx, 0, ctx->ofs);
 647         ctx->ofs = 0;
 648     }
 649 }
 650
 651 static void WCEL_KillMarkedZone(WCEL_Context* ctx)
 652 {
 653     unsigned beg, end;
 654
 655     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 656     if (ctx->mark > ctx->ofs)
 657     {
 658         beg = ctx->ofs;         end = ctx->mark;
 659     }
 660     else
 661     {
 662         beg = ctx->mark;        end = ctx->ofs;
 663     }
 664     WCEL_SaveYank(ctx, beg, end);
 665     WCEL_DeleteString(ctx, beg, end);
 666     ctx->ofs = beg;
 667 }
 668
 669 static void WCEL_DeletePrevChar(WCEL_Context* ctx)
 670 {
 671     if (ctx->ofs)
 672     {
 673         WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
 674         ctx->ofs--;
 675     }
 676 }
 677
 678 static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
 679 {
 680     if (ctx->ofs < ctx->len)
 681         WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
 682 }
 683
 684 static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
 685 {
 686     unsigned int        new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 687     if (new_ofs != ctx->ofs)
 688     {
 689         WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
 690         ctx->ofs = new_ofs;
 691     }
 692 }
 693
 694 static void WCEL_DeleteRightWord(WCEL_Context* ctx)
 695 {
 696     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 697     if (new_ofs != ctx->ofs)
 698     {
 699         WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
 700     }
 701 }
 702
 703 static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
 704 {
 705     if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
 706 }
 707
 708 static void WCEL_MoveToNextHist(WCEL_Context* ctx)
 709 {
 710     if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
 711 }
 712
 713 static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
 714 {
 715     if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
 716 }
 717
 718 static void WCEL_MoveToLastHist(WCEL_Context* ctx)
 719 {
 720     if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
 721 }
 722
 723 static void WCEL_Redraw(WCEL_Context* ctx)
 724 {
 725     if (ctx->shall_echo)
 726     {
 727         COORD       c = WCEL_GetCoord(ctx, ctx->len);
 728         CHAR_INFO   ci;
 729
 730         WCEL_Update(ctx, 0, ctx->len);
 731
 732         ci.Char.UnicodeChar = ' ';
 733         ci.Attributes = ctx->csbi.wAttributes;
 734
 735         CONSOLE_FillLineUniform(ctx->hConOut, c.X, c.Y, ctx->csbi.dwSize.X - c.X, &ci);
 736     }
 737 }
 738
 739 static void WCEL_RepeatCount(WCEL_Context* ctx)
 740 {
 741 #if 0
 742 /* FIXME: wait until all console code is in kernel32 */
 743     INPUT_RECORD        ir;
 744     unsigned            repeat = 0;
 745
 746     while (WCEL_Get(ctx, &ir, FALSE))
 747     {
 748         if (ir.EventType != KEY_EVENT) break;
 749         if (ir.Event.KeyEvent.bKeyDown)
 750         {
 751             if ((ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON)) != 0)
 752                 break;
 753             if (ir.Event.KeyEvent.uChar.UnicodeChar < '0' ||
 754                 ir.Event.KeyEvent.uChar.UnicodeChar > '9')
 755                 break;
 756             repeat = repeat * 10 + ir.Event.KeyEvent.uChar.UnicodeChar - '0';
 757         }
 758         WCEL_Get(ctx, &ir, TRUE);
 759     }
 760     FIXME("=> %u\n", repeat);
 761 #endif
 762 }
 763
 764 static void WCEL_ToggleInsert(WCEL_Context* ctx)
 765 {
 766     DWORD               mode;
 767     CONSOLE_CURSOR_INFO cinfo;
 768
 769     if (GetConsoleMode(ctx->hConIn, &mode) && GetConsoleCursorInfo(ctx->hConOut, &cinfo))
 770     {
 771         if ((mode & (ENABLE_INSERT_MODE|ENABLE_EXTENDED_FLAGS)) == (ENABLE_INSERT_MODE|ENABLE_EXTENDED_FLAGS))
 772         {
 773             mode &= ~ENABLE_INSERT_MODE;
 774             cinfo.dwSize = 100;
 775             ctx->insert = FALSE;
 776         }
 777         else
 778         {
 779             mode |= ENABLE_INSERT_MODE | ENABLE_EXTENDED_FLAGS;
 780             cinfo.dwSize = 25;
 781             ctx->insert = TRUE;
 782         }
 783         SetConsoleMode(ctx->hConIn, mode);
 784         SetConsoleCursorInfo(ctx->hConOut, &cinfo);
 785     }
 786 }
 787
 788 /* ====================================================================
 789  *
 790  *              Key Maps
 791  *
 792  * ====================================================================*/
 793
 794 #define CTRL(x) ((x) - '@')
 795 static const KeyEntry StdKeyMap[] =
 796 {
 797     {/*BACK*/0x08,      WCEL_DeletePrevChar     },
 798     {/*RETURN*/0x0d,    WCEL_Done               },
 799     {/*DEL*/127,        WCEL_DeleteCurrChar     },
 800     {   0,              NULL                    }
 801 };
 802
 803 static const KeyEntry EmacsKeyMapCtrl[] =
 804 {
 805     {   CTRL('@'),      WCEL_SetMark            },
 806     {   CTRL('A'),      WCEL_MoveToBeg          },
 807     {   CTRL('B'),      WCEL_MoveLeft           },
 808     /* C: done in server */
 809     {   CTRL('D'),      WCEL_DeleteCurrChar     },
 810     {   CTRL('E'),      WCEL_MoveToEnd          },
 811     {   CTRL('F'),      WCEL_MoveRight          },
 812     {   CTRL('G'),      WCEL_Beep               },
 813     {   CTRL('H'),      WCEL_DeletePrevChar     },
 814     /* I: meaningless (or tab ???) */
 815     {   CTRL('J'),      WCEL_Done               },
 816     {   CTRL('K'),      WCEL_KillToEndOfLine    },
 817     {   CTRL('L'),      WCEL_Redraw             },
 818     {   CTRL('M'),      WCEL_Done               },
 819     {   CTRL('N'),      WCEL_MoveToNextHist     },
 820     /* O; insert line... meaningless */
 821     {   CTRL('P'),      WCEL_MoveToPrevHist     },
 822     /* Q: [NIY] quoting... */
 823     /* R: [NIY] search backwards... */
 824     /* S: [NIY] search forwards... */
 825     {   CTRL('T'),      WCEL_TransposeChar      },
 826     {   CTRL('U'),      WCEL_RepeatCount        },
 827     /* V: paragraph down... meaningless */
 828     {   CTRL('W'),      WCEL_KillMarkedZone     },
 829     {   CTRL('X'),      WCEL_ExchangeMark       },
 830     {   CTRL('Y'),      WCEL_Yank               },
 831     /* Z: meaningless */
 832     {   0,              NULL                    }
 833 };
 834
 835 static const KeyEntry EmacsKeyMapAlt[] =
 836 {
 837     {/*DEL*/127,        WCEL_DeleteLeftWord     },
 838     {   '<',            WCEL_MoveToFirstHist    },
 839     {   '>',            WCEL_MoveToLastHist     },
 840     {   '?',            WCEL_Beep               },
 841     {   'b',            WCEL_MoveToLeftWord     },
 842     {   'c',            WCEL_CapitalizeWord     },
 843     {   'd',            WCEL_DeleteRightWord    },
 844     {   'f',            WCEL_MoveToRightWord    },
 845     {   'l',            WCEL_LowerCaseWord      },
 846     {   't',            WCEL_TransposeWords     },
 847     {   'u',            WCEL_UpperCaseWord      },
 848     {   'w',            WCEL_CopyMarkedZone     },
 849     {   0,              NULL                    }
 850 };
 851
 852 static const KeyEntry EmacsStdKeyMap[] =
 853 {
 854     {/*VK_PRIOR*/0x21,  WCEL_MoveToPrevHist     },
 855     {/*VK_NEXT*/ 0x22,  WCEL_MoveToNextHist     },
 856     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 857     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 858     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 859     {/*VK_LEFT*/ 0x25,  WCEL_MoveLeft           },
 860     {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
 861     {/*VK_INSERT*/0x2d, WCEL_ToggleInsert       },
 862     {   0,              NULL                    }
 863 };
 864
 865 static const KeyMap EmacsKeyMap[] =
 866 {
 867     {0,                  1, StdKeyMap},
 868     {0,                  0, EmacsStdKeyMap},
 869     {RIGHT_ALT_PRESSED,  1, EmacsKeyMapAlt},    /* right alt  */
 870     {LEFT_ALT_PRESSED,   1, EmacsKeyMapAlt},    /* left  alt  */
 871     {RIGHT_CTRL_PRESSED, 1, EmacsKeyMapCtrl},   /* right ctrl */
 872     {LEFT_CTRL_PRESSED,  1, EmacsKeyMapCtrl},   /* left  ctrl */
 873     {0,                  0, NULL}
 874 };
 875
 876 static const KeyEntry Win32StdKeyMap[] =
 877 {
 878     {/*VK_LEFT*/ 0x25,  WCEL_MoveLeft           },
 879     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 880     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 881     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 882     {/*VK_UP*/   0x26,  WCEL_MoveToPrevHist     },
 883     {/*VK_DOWN*/ 0x28,  WCEL_MoveToNextHist     },
 884     {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
 885     {/*VK_INSERT*/0x2d, WCEL_ToggleInsert       },
 886     {/*VK_F8*/   0x77,  WCEL_FindPrevInHist     },
 887     {   0,              NULL                    }
 888 };
 889
 890 static const KeyEntry Win32KeyMapCtrl[] =
 891 {
 892     {/*VK_LEFT*/ 0x25,  WCEL_MoveToLeftWord     },
 893     {/*VK_RIGHT*/0x27,  WCEL_MoveToRightWord    },
 894     {/*VK_END*/  0x23,  WCEL_KillToEndOfLine    },
 895     {/*VK_HOME*/ 0x24,  WCEL_KillFromBegOfLine  },
 896     {   0,              NULL                    }
 897 };
 898
 899 static const KeyMap Win32KeyMap[] =
 900 {
 901     {0,                  1, StdKeyMap},
 902     {0,                  0, Win32StdKeyMap},
 903     {RIGHT_CTRL_PRESSED, 0, Win32KeyMapCtrl},
 904     {LEFT_CTRL_PRESSED,  0, Win32KeyMapCtrl},
 905     {0,                  0, NULL}
 906 };
 907 #undef CTRL
 908
 909 /* ====================================================================
 910  *
 911  *              Read line master function
 912  *
 913  * ====================================================================*/
 914
 915 WCHAR* CONSOLE_Readline(HANDLE hConsoleIn, BOOL can_pos_cursor)
 916 {
 917     WCEL_Context        ctx;
 918     INPUT_RECORD        ir;
 919     const KeyMap*       km;
 920     const KeyEntry*     ke;
 921     unsigned            ofs;
 922     void                (*func)(struct WCEL_Context* ctx);
 923     DWORD               mode, ks;
 924     int                 use_emacs;
 925
 926     memset(&ctx, 0, sizeof(ctx));
 927     ctx.hConIn = hConsoleIn;
 928     WCEL_HistoryInit(&ctx);
 929
 930     if (!CONSOLE_GetEditionMode(hConsoleIn, &use_emacs))
 931         use_emacs = 0;
 932
 933     if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
 934                                     OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
 935         !GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
 936         return NULL;
 937     if (!GetConsoleMode(hConsoleIn, &mode)) mode = 0;
 938     ctx.shall_echo = (mode & ENABLE_ECHO_INPUT) ? 1 : 0;
 939     ctx.insert = (mode & (ENABLE_INSERT_MODE|ENABLE_EXTENDED_FLAGS)) == (ENABLE_INSERT_MODE|ENABLE_EXTENDED_FLAGS) ? 1 : 0;
 940     if (!GetConsoleMode(ctx.hConOut, &mode)) mode = 0;
 941     ctx.can_wrap = (mode & ENABLE_WRAP_AT_EOL_OUTPUT) ? 1 : 0;
 942     ctx.can_pos_cursor = can_pos_cursor;
 943
 944     if (!WCEL_Grow(&ctx, 1))
 945     {
 946         CloseHandle(ctx.hConOut);
 947         return NULL;
 948     }
 949     ctx.line[0] = 0;
 950
 951 /* EPP     WCEL_Dump(&ctx, "init"); */
 952
 953     while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
 954     {
 955         if (ir.EventType != KEY_EVENT) continue;
 956         TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08x\n",
 957               ir.Event.KeyEvent.bKeyDown ? "Down" : "Up  ", ir.Event.KeyEvent.wRepeatCount,
 958               ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
 959               ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
 960         if (!ir.Event.KeyEvent.bKeyDown) continue;
 961
 962 /* EPP          WCEL_Dump(&ctx, "before func"); */
 963         ofs = ctx.ofs;
 964         /* mask out some bits which don't interest us */
 965         ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON|ENHANCED_KEY);
 966
 967         func = NULL;
 968         for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
 969         {
 970             if (km->keyState != ks)
 971                 continue;
 972             if (km->chkChar)
 973             {
 974                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 975                     if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
 976             }
 977             else
 978             {
 979                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 980                     if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
 981
 982             }
 983             if (ke->func)
 984             {
 985                 func = ke->func;
 986                 break;
 987             }
 988         }
 989
 990         if (func)
 991             (func)(&ctx);
 992         else if (!(ir.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED))
 993             WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
 994         else TRACE("Dropped event\n");
 995
 996 /* EPP         WCEL_Dump(&ctx, "after func"); */
 997         if (!ctx.shall_echo) continue;
 998         if (ctx.can_pos_cursor)
 999         {
1000             if (ctx.ofs != ofs)
1001                 SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
1002         }
1003         else if (!ctx.done && !ctx.error)
1004         {
1005             DWORD last;
1006             /* erase previous chars */
1007             WCEL_WriteNChars(&ctx, '\b', ctx.last_rub);
1008
1009             /* write chars up to cursor */
1010             ctx.last_rub = WCEL_WriteConsole(&ctx, 0, ctx.ofs);
1011             /* write chars past cursor */
1012             last = ctx.last_rub + WCEL_WriteConsole(&ctx, ctx.ofs, ctx.len - ctx.ofs);
1013             if (last < ctx.last_max) /* ctx.line has been shortened, erase */
1014             {
1015                 WCEL_WriteNChars(&ctx, ' ', ctx.last_max - last);
1016                 WCEL_WriteNChars(&ctx, '\b', ctx.last_max - last);
1017                 ctx.last_max = last;
1018             }
1019             else ctx.last_max = last;
1020             /* reposition at cursor */
1021             WCEL_WriteNChars(&ctx, '\b', last - ctx.last_rub);
1022         }
1023     }
1024     if (ctx.error)
1025     {
1026         HeapFree(GetProcessHeap(), 0, ctx.line);
1027         ctx.line = NULL;
1028     }
1029     WCEL_FreeYank(&ctx);
1030     if (ctx.line)
1031         CONSOLE_AppendHistory(ctx.line);
1032
1033     CloseHandle(ctx.hConOut);
1034     HeapFree(GetProcessHeap(), 0, ctx.histCurr);
1035     return ctx.line;
1036 }