git.oblomov.eu Git - wine/blob - dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     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                    ofs;            /* offset for cursor in current line */
  57     WCHAR*                      yanked;         /* yanked line */
  58     unsigned                    mark;           /* marked point (emacs mode only) */
  59     CONSOLE_SCREEN_BUFFER_INFO  csbi;           /* current state (initial cursor, window size, attribute) */
  60     HANDLE                      hConIn;
  61     HANDLE                      hConOut;
  62     unsigned                    done : 1,       /* to 1 when we're done with editing */
  63                                 error : 1,      /* to 1 when an error occurred in the editing */
  64                                 can_wrap : 1;   /* to 1 when multi-line edition can take place */
  65     unsigned                    histSize;
  66     unsigned                    histPos;
  67     WCHAR*                      histCurr;
  68 } WCEL_Context;
  69
  70 #if 0
  71 static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
  72 {
  73     MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c%c]\n"
  74             "\t\thist=(size=%u pos=%u curr=%s)\n"
  75             "\t\tyanked=%s\n",
  76             pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
  77             ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
  78             ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e', ctx->can_wrap ? 'W' : 'w',
  79             ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr),
  80             debugstr_w(ctx->yanked));
  81 }
  82 #endif
  83
  84 /* ====================================================================
  85  *
  86  * Console helper functions
  87  *
  88  * ====================================================================*/
  89
  90 static BOOL WCEL_Get(WCEL_Context* ctx, INPUT_RECORD* ir)
  91 {
  92     if (ReadConsoleInputW(ctx->hConIn, ir, 1, NULL)) return TRUE;
  93     ERR("hmm bad situation\n");
  94     ctx->error = 1;
  95     return FALSE;
  96 }
  97
  98 static inline void WCEL_Beep(WCEL_Context* ctx)
  99 {
 100     Beep(400, 300);
 101 }
 102
 103 static inline BOOL WCEL_IsSingleLine(WCEL_Context* ctx, size_t len)
 104 {
 105     return ctx->csbi.dwCursorPosition.X + ctx->len + len <= ctx->csbi.dwSize.X;
 106 }
 107
 108 static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int ofs)
 109 {
 110     COORD       c;
 111     int         len = ctx->csbi.dwSize.X - ctx->csbi.dwCursorPosition.X;
 112
 113     c.Y = ctx->csbi.dwCursorPosition.Y;
 114     if (ofs >= len)
 115     {
 116         ofs -= len;
 117         c.X = ofs % ctx->csbi.dwSize.X;
 118         c.Y += 1 + ofs / ctx->csbi.dwSize.X;
 119     }
 120     else c.X = ctx->csbi.dwCursorPosition.X + ofs;
 121     return c;
 122 }
 123
 124 static inline void WCEL_Update(WCEL_Context* ctx, int beg, int len)
 125 {
 126     WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[beg], len,
 127                                  WCEL_GetCoord(ctx, beg), NULL);
 128     FillConsoleOutputAttribute(ctx->hConOut, ctx->csbi.wAttributes, len,
 129                                WCEL_GetCoord(ctx, beg), NULL);
 130 }
 131
 132 /* ====================================================================
 133  *
 134  * context manipulation functions
 135  *
 136  * ====================================================================*/
 137
 138 static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
 139 {
 140     if (!WCEL_IsSingleLine(ctx, len) && !ctx->can_wrap)
 141     {
 142         FIXME("Mode doesn't allow to wrap. However, we should allow to overwrite current string\n");
 143         return FALSE;
 144     }
 145
 146     if (ctx->len + len >= ctx->alloc)
 147     {
 148         WCHAR*  newline;
 149         size_t  newsize;
 150
 151         /* round up size to 32 byte-WCHAR boundary */
 152         newsize = (ctx->len + len + 1 + 31) & ~31;
 153
 154         if (ctx->line)
 155             newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * newsize);
 156         else
 157             newline = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * newsize);
 158
 159         if (!newline) return FALSE;
 160         ctx->line = newline;
 161         ctx->alloc = newsize;
 162     }
 163     return TRUE;
 164 }
 165
 166 static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
 167 {
 168     unsigned    str_len = end - beg;
 169     COORD       cbeg = WCEL_GetCoord(ctx, ctx->len - str_len);
 170     COORD       cend = WCEL_GetCoord(ctx, ctx->len);
 171     CHAR_INFO   ci;
 172
 173     if (end < ctx->len)
 174         memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
 175     /* we need to clean from ctx->len - str_len to ctx->len */
 176
 177     ci.Char.UnicodeChar = ' ';
 178     ci.Attributes = ctx->csbi.wAttributes;
 179
 180     if (cbeg.Y == cend.Y)
 181     {
 182         /* partial erase of sole line */
 183         CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
 184                                 cend.X - cbeg.X, &ci);
 185     }
 186     else
 187     {
 188         int         i;
 189         /* erase til eol on first line */
 190         CONSOLE_FillLineUniform(ctx->hConOut, cbeg.X, cbeg.Y,
 191                                 ctx->csbi.dwSize.X - cbeg.X, &ci);
 192         /* completely erase all the others (full lines) */
 193         for (i = cbeg.Y + 1; i < cend.Y; i++)
 194             CONSOLE_FillLineUniform(ctx->hConOut, 0, i, ctx->csbi.dwSize.X, &ci);
 195         /* erase from begining of line until last pos on last line */
 196         CONSOLE_FillLineUniform(ctx->hConOut, 0, cend.Y, cend.X, &ci);
 197     }
 198     ctx->len -= str_len;
 199     WCEL_Update(ctx, 0, ctx->len);
 200     ctx->line[ctx->len] = 0;
 201 }
 202
 203 static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
 204 {
 205     size_t      len = lstrlenW(str);
 206
 207     if (!len || !WCEL_Grow(ctx, len)) return;
 208     if (ctx->len > ctx->ofs)
 209         memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
 210     memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
 211     ctx->len += len;
 212     ctx->line[ctx->len] = 0;
 213     WCEL_Update(ctx, ctx->ofs, ctx->len - ctx->ofs);
 214
 215     ctx->ofs += len;
 216 }
 217
 218 static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
 219 {
 220     WCHAR       buffer[2];
 221
 222     /* do not insert 0..31 control characters */
 223     if (c < ' ' && c != '\t') return;
 224
 225     buffer[0] = c;
 226     buffer[1] = 0;
 227     WCEL_InsertString(ctx, buffer);
 228 }
 229
 230 static void WCEL_FreeYank(WCEL_Context* ctx)
 231 {
 232     if (ctx->yanked)
 233     {
 234         HeapFree(GetProcessHeap(), 0, ctx->yanked);
 235         ctx->yanked = NULL;
 236     }
 237 }
 238
 239 static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
 240 {
 241     int len = end - beg;
 242     if (len <= 0) return;
 243
 244     WCEL_FreeYank(ctx);
 245     /* After WCEL_FreeYank ctx->yanked is empty */
 246     ctx->yanked = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 247     if (!ctx->yanked) return;
 248     memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
 249     ctx->yanked[len] = 0;
 250 }
 251
 252 /* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
 253  * of the data lay in unicode lib
 254  */
 255 static inline BOOL WCEL_iswalnum(WCHAR wc)
 256 {
 257     return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
 258 }
 259
 260 static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
 261 {
 262     ofs--;
 263     while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
 264     while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
 265     if (ofs >= 0) ofs++;
 266     return max(ofs, 0);
 267 }
 268
 269 static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
 270 {
 271     ofs++;
 272     while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
 273     while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
 274     return min(ofs, ctx->len);
 275 }
 276
 277 static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
 278 {
 279     WCHAR*      ptr;
 280
 281     if (idx == ctx->histSize - 1)
 282     {
 283         ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
 284         lstrcpyW(ptr, ctx->histCurr);
 285     }
 286     else
 287     {
 288         int     len = CONSOLE_GetHistory(idx, NULL, 0);
 289
 290         if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 291         {
 292             CONSOLE_GetHistory(idx, ptr, len);
 293         }
 294     }
 295     return ptr;
 296 }
 297
 298 static void     WCEL_HistoryInit(WCEL_Context* ctx)
 299 {
 300     ctx->histPos  = CONSOLE_GetNumHistoryEntries();
 301     ctx->histSize = ctx->histPos + 1;
 302     ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
 303 }
 304
 305 static void    WCEL_MoveToHist(WCEL_Context* ctx, int idx)
 306 {
 307     WCHAR*      data = WCEL_GetHistory(ctx, idx);
 308     int         len = lstrlenW(data) + 1;
 309
 310     /* save current line edition for recall when needed (FIXME seems broken to me) */
 311     if (ctx->histPos == ctx->histSize - 1)
 312     {
 313         if (ctx->histCurr) HeapFree(GetProcessHeap(), 0, ctx->histCurr);
 314         ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
 315         memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
 316     }
 317     /* need to clean also the screen if new string is shorter than old one */
 318     WCEL_DeleteString(ctx, 0, ctx->len);
 319     ctx->ofs = 0;
 320     /* insert new string */
 321     if (WCEL_Grow(ctx, len))
 322     {
 323         WCEL_InsertString(ctx, data);
 324         HeapFree(GetProcessHeap(), 0, data);
 325         ctx->histPos = idx;
 326     }
 327 }
 328
 329 static void    WCEL_FindPrevInHist(WCEL_Context* ctx)
 330 {
 331     int startPos = ctx->histPos;
 332     WCHAR*      data;
 333     unsigned int    len, oldofs;
 334
 335     if (ctx->histPos && ctx->histPos == ctx->histSize) {
 336         startPos--;
 337         ctx->histPos--;
 338     }
 339
 340     do {
 341        data = WCEL_GetHistory(ctx, ctx->histPos);
 342
 343        if (ctx->histPos) ctx->histPos--;
 344        else ctx->histPos = (ctx->histSize-1);
 345
 346        len = lstrlenW(data) + 1;
 347        if ((len >= ctx->ofs) &&
 348            (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
 349
 350            /* need to clean also the screen if new string is shorter than old one */
 351            WCEL_DeleteString(ctx, 0, ctx->len);
 352
 353            if (WCEL_Grow(ctx, len))
 354            {
 355               oldofs = ctx->ofs;
 356               ctx->ofs = 0;
 357               WCEL_InsertString(ctx, data);
 358               ctx->ofs = oldofs;
 359               SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
 360               HeapFree(GetProcessHeap(), 0, data);
 361               return;
 362            }
 363        }
 364     } while (ctx->histPos != startPos);
 365
 366     return;
 367 }
 368
 369 /* ====================================================================
 370  *
 371  * basic edition functions
 372  *
 373  * ====================================================================*/
 374
 375 static void WCEL_Done(WCEL_Context* ctx)
 376 {
 377     WCHAR       nl = '\n';
 378     if (!WCEL_Grow(ctx, 1)) return;
 379     ctx->line[ctx->len++] = '\n';
 380     ctx->line[ctx->len] = 0;
 381     WriteConsoleW(ctx->hConOut, &nl, 1, NULL, NULL);
 382     ctx->done = 1;
 383 }
 384
 385 static void WCEL_MoveLeft(WCEL_Context* ctx)
 386 {
 387     if (ctx->ofs > 0) ctx->ofs--;
 388 }
 389
 390 static void WCEL_MoveRight(WCEL_Context* ctx)
 391 {
 392     if (ctx->ofs < ctx->len) ctx->ofs++;
 393 }
 394
 395 static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
 396 {
 397     unsigned int        new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 398     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 399 }
 400
 401 static void WCEL_MoveToRightWord(WCEL_Context* ctx)
 402 {
 403     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 404     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 405 }
 406
 407 static void WCEL_MoveToBeg(WCEL_Context* ctx)
 408 {
 409     ctx->ofs = 0;
 410 }
 411
 412 static void WCEL_MoveToEnd(WCEL_Context* ctx)
 413 {
 414     ctx->ofs = ctx->len;
 415 }
 416
 417 static void WCEL_SetMark(WCEL_Context* ctx)
 418 {
 419     ctx->mark = ctx->ofs;
 420 }
 421
 422 static void WCEL_ExchangeMark(WCEL_Context* ctx)
 423 {
 424     unsigned tmp;
 425
 426     if (ctx->mark > ctx->len) return;
 427     tmp = ctx->ofs;
 428     ctx->ofs = ctx->mark;
 429     ctx->mark = tmp;
 430 }
 431
 432 static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
 433 {
 434     unsigned beg, end;
 435
 436     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 437     if (ctx->mark > ctx->ofs)
 438     {
 439         beg = ctx->ofs;         end = ctx->mark;
 440     }
 441     else
 442     {
 443         beg = ctx->mark;        end = ctx->ofs;
 444     }
 445     WCEL_SaveYank(ctx, beg, end);
 446 }
 447
 448 static void WCEL_TransposeChar(WCEL_Context* ctx)
 449 {
 450     WCHAR       c;
 451
 452     if (!ctx->ofs || ctx->ofs == ctx->len) return;
 453
 454     c = ctx->line[ctx->ofs];
 455     ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
 456     ctx->line[ctx->ofs - 1] = c;
 457
 458     WCEL_Update(ctx, ctx->ofs - 1, 2);
 459     ctx->ofs++;
 460 }
 461
 462 static void WCEL_TransposeWords(WCEL_Context* ctx)
 463 {
 464     unsigned int        left_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs),
 465         right_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 466     if (left_ofs < ctx->ofs && right_ofs > ctx->ofs)
 467     {
 468         unsigned len_r = right_ofs - ctx->ofs;
 469         unsigned len_l = ctx->ofs - left_ofs;
 470
 471         char*   tmp = HeapAlloc(GetProcessHeap(), 0, len_r * sizeof(WCHAR));
 472         if (!tmp) return;
 473
 474         memcpy(tmp, &ctx->line[ctx->ofs], len_r * sizeof(WCHAR));
 475         memmove(&ctx->line[left_ofs + len_r], &ctx->line[left_ofs], len_l * sizeof(WCHAR));
 476         memcpy(&ctx->line[left_ofs], tmp, len_r * sizeof(WCHAR));
 477
 478         HeapFree(GetProcessHeap(), 0, tmp);
 479         WCEL_Update(ctx, left_ofs, len_l + len_r);
 480         ctx->ofs = right_ofs;
 481     }
 482 }
 483
 484 static void WCEL_LowerCaseWord(WCEL_Context* ctx)
 485 {
 486     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 487     if (new_ofs != ctx->ofs)
 488     {
 489         unsigned int    i;
 490         for (i = ctx->ofs; i <= new_ofs; i++)
 491             ctx->line[i] = tolowerW(ctx->line[i]);
 492         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 493         ctx->ofs = new_ofs;
 494     }
 495 }
 496
 497 static void WCEL_UpperCaseWord(WCEL_Context* ctx)
 498 {
 499     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 500     if (new_ofs != ctx->ofs)
 501     {
 502         unsigned int    i;
 503         for (i = ctx->ofs; i <= new_ofs; i++)
 504             ctx->line[i] = toupperW(ctx->line[i]);
 505         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 506         ctx->ofs = new_ofs;
 507     }
 508 }
 509
 510 static void WCEL_CapitalizeWord(WCEL_Context* ctx)
 511 {
 512     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 513     if (new_ofs != ctx->ofs)
 514     {
 515         unsigned int    i;
 516
 517         ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
 518         for (i = ctx->ofs + 1; i <= new_ofs; i++)
 519             ctx->line[i] = tolowerW(ctx->line[i]);
 520         WCEL_Update(ctx, ctx->ofs, new_ofs - ctx->ofs + 1);
 521         ctx->ofs = new_ofs;
 522     }
 523 }
 524
 525 static void WCEL_Yank(WCEL_Context* ctx)
 526 {
 527     WCEL_InsertString(ctx, ctx->yanked);
 528 }
 529
 530 static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
 531 {
 532     WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
 533     WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
 534 }
 535
 536 static void WCEL_KillMarkedZone(WCEL_Context* ctx)
 537 {
 538     unsigned beg, end;
 539
 540     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 541     if (ctx->mark > ctx->ofs)
 542     {
 543         beg = ctx->ofs;         end = ctx->mark;
 544     }
 545     else
 546     {
 547         beg = ctx->mark;        end = ctx->ofs;
 548     }
 549     WCEL_SaveYank(ctx, beg, end);
 550     WCEL_DeleteString(ctx, beg, end);
 551     ctx->ofs = beg;
 552 }
 553
 554 static void WCEL_DeletePrevChar(WCEL_Context* ctx)
 555 {
 556     if (ctx->ofs)
 557     {
 558         WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
 559         ctx->ofs--;
 560     }
 561 }
 562
 563 static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
 564 {
 565     if (ctx->ofs < ctx->len)
 566         WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
 567 }
 568
 569 static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
 570 {
 571     unsigned int        new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 572     if (new_ofs != ctx->ofs)
 573     {
 574         WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
 575         ctx->ofs = new_ofs;
 576     }
 577 }
 578
 579 static void WCEL_DeleteRightWord(WCEL_Context* ctx)
 580 {
 581     unsigned int        new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 582     if (new_ofs != ctx->ofs)
 583     {
 584         WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
 585     }
 586 }
 587
 588 static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
 589 {
 590     if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
 591 }
 592
 593 static void WCEL_MoveToNextHist(WCEL_Context* ctx)
 594 {
 595     if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
 596 }
 597
 598 static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
 599 {
 600     if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
 601 }
 602
 603 static void WCEL_MoveToLastHist(WCEL_Context* ctx)
 604 {
 605     if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
 606 }
 607
 608 static void WCEL_Redraw(WCEL_Context* ctx)
 609 {
 610     COORD       c = WCEL_GetCoord(ctx, ctx->len);
 611     CHAR_INFO   ci;
 612
 613     WCEL_Update(ctx, 0, ctx->len);
 614
 615     ci.Char.UnicodeChar = ' ';
 616     ci.Attributes = ctx->csbi.wAttributes;
 617
 618     CONSOLE_FillLineUniform(ctx->hConOut, c.X, c.Y, ctx->csbi.dwSize.X - c.X, &ci);
 619 }
 620
 621 static void WCEL_RepeatCount(WCEL_Context* ctx)
 622 {
 623 #if 0
 624 /* FIXME: wait until all console code is in kernel32 */
 625     INPUT_RECORD        ir;
 626     unsigned            repeat = 0;
 627
 628     while (WCEL_Get(ctx, &ir, FALSE))
 629     {
 630         if (ir.EventType != KEY_EVENT) break;
 631         if (ir.Event.KeyEvent.bKeyDown)
 632         {
 633             if ((ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON)) != 0)
 634                 break;
 635             if (ir.Event.KeyEvent.uChar.UnicodeChar < '0' ||
 636                 ir.Event.KeyEvent.uChar.UnicodeChar > '9')
 637                 break;
 638             repeat = repeat * 10 + ir.Event.KeyEvent.uChar.UnicodeChar - '0';
 639         }
 640         WCEL_Get(ctx, &ir, TRUE);
 641     }
 642     FIXME("=> %u\n", repeat);
 643 #endif
 644 }
 645
 646 /* ====================================================================
 647  *
 648  *              Key Maps
 649  *
 650  * ====================================================================*/
 651
 652 #define CTRL(x) ((x) - '@')
 653 static KeyEntry StdKeyMap[] =
 654 {
 655     {/*BACK*/0x08,      WCEL_DeletePrevChar     },
 656     {/*RETURN*/0x0d,    WCEL_Done               },
 657     {/*DEL*/127,        WCEL_DeleteCurrChar     },
 658     {   0,              NULL                    }
 659 };
 660
 661 static KeyEntry Win32ExtraStdKeyMap[] =
 662 {
 663     {/*VK_F8*/   0x77,  WCEL_FindPrevInHist     },
 664     {   0,              NULL                    }
 665 };
 666
 667
 668 static  KeyEntry EmacsKeyMapCtrl[] =
 669 {
 670     {   CTRL('@'),      WCEL_SetMark            },
 671     {   CTRL('A'),      WCEL_MoveToBeg          },
 672     {   CTRL('B'),      WCEL_MoveLeft           },
 673     /* C: done in server */
 674     {   CTRL('D'),      WCEL_DeleteCurrChar     },
 675     {   CTRL('E'),      WCEL_MoveToEnd          },
 676     {   CTRL('F'),      WCEL_MoveRight          },
 677     {   CTRL('G'),      WCEL_Beep               },
 678     {   CTRL('H'),      WCEL_DeletePrevChar     },
 679     /* I: meaningless (or tab ???) */
 680     {   CTRL('J'),      WCEL_Done               },
 681     {   CTRL('K'),      WCEL_KillToEndOfLine    },
 682     {   CTRL('L'),      WCEL_Redraw             },
 683     {   CTRL('M'),      WCEL_Done               },
 684     {   CTRL('N'),      WCEL_MoveToNextHist     },
 685     /* O; insert line... meaningless */
 686     {   CTRL('P'),      WCEL_MoveToPrevHist     },
 687     /* Q: [NIY] quoting... */
 688     /* R: [NIY] search backwards... */
 689     /* S: [NIY] search forwards... */
 690     {   CTRL('T'),      WCEL_TransposeChar      },
 691     {   CTRL('U'),      WCEL_RepeatCount        },
 692     /* V: paragraph down... meaningless */
 693     {   CTRL('W'),      WCEL_KillMarkedZone     },
 694     {   CTRL('X'),      WCEL_ExchangeMark       },
 695     {   CTRL('Y'),      WCEL_Yank               },
 696     /* Z: meaningless */
 697     {   0,              NULL                    }
 698 };
 699
 700 static KeyEntry EmacsKeyMapAlt[] =
 701 {
 702     {/*DEL*/127,        WCEL_DeleteLeftWord     },
 703     {   '<',            WCEL_MoveToFirstHist    },
 704     {   '>',            WCEL_MoveToLastHist     },
 705     {   '?',            WCEL_Beep               },
 706     {   'b',            WCEL_MoveToLeftWord     },
 707     {   'c',            WCEL_CapitalizeWord     },
 708     {   'd',            WCEL_DeleteRightWord    },
 709     {   'f',            WCEL_MoveToRightWord    },
 710     {   'l',            WCEL_LowerCaseWord      },
 711     {   't',            WCEL_TransposeWords     },
 712     {   'u',            WCEL_UpperCaseWord      },
 713     {   'w',            WCEL_CopyMarkedZone     },
 714     {   0,              NULL                    }
 715 };
 716
 717 static KeyEntry EmacsKeyMapExtended[] =
 718 {
 719     {/*RETURN*/  0x0d,  WCEL_Done },
 720     {/*VK_PRIOR*/0x21,  WCEL_MoveToPrevHist     },
 721     {/*VK_NEXT*/ 0x22,  WCEL_MoveToNextHist     },
 722     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 723     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 724     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 725     {/*VK_LEFT*/ 0x25,  WCEL_MoveLeft           },
 726     {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
 727     {   0,              NULL                    }
 728 };
 729
 730 static KeyMap   EmacsKeyMap[] =
 731 {
 732     {0x00000000, 1, StdKeyMap},
 733     {0x00000001, 1, EmacsKeyMapAlt},    /* left  alt  */
 734     {0x00000002, 1, EmacsKeyMapAlt},    /* right alt  */
 735     {0x00000004, 1, EmacsKeyMapCtrl},   /* left  ctrl */
 736     {0x00000008, 1, EmacsKeyMapCtrl},   /* right ctrl */
 737     {0x00000100, 0, EmacsKeyMapExtended},
 738     {0,          0, 0}
 739 };
 740
 741 static  KeyEntry Win32KeyMapExtended[] =
 742 {
 743     {/*VK_LEFT*/ 0x25,  WCEL_MoveLeft           },
 744     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 745     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 746     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 747     {/*VK_UP*/   0x26,  WCEL_MoveToPrevHist     },
 748     {/*VK_DOWN*/ 0x28,  WCEL_MoveToNextHist     },
 749     {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
 750     {   0,              NULL                    }
 751 };
 752
 753 static  KeyEntry Win32KeyMapCtrlExtended[] =
 754 {
 755     {/*VK_LEFT*/ 0x25,  WCEL_MoveToLeftWord     },
 756     {/*VK_RIGHT*/0x27,  WCEL_MoveToRightWord    },
 757     {/*VK_END*/  0x23,  WCEL_KillToEndOfLine    },
 758     {   0,              NULL                    }
 759 };
 760
 761 KeyMap  Win32KeyMap[] =
 762 {
 763     {0x00000000, 1, StdKeyMap},
 764     {0x00000000, 0, Win32ExtraStdKeyMap},
 765     {0x00000100, 0, Win32KeyMapExtended},
 766     {0x00000104, 0, Win32KeyMapCtrlExtended},
 767     {0x00000108, 0, Win32KeyMapCtrlExtended},
 768     {0,          0, 0}
 769 };
 770 #undef CTRL
 771
 772 /* ====================================================================
 773  *
 774  *              Read line master function
 775  *
 776  * ====================================================================*/
 777
 778 WCHAR* CONSOLE_Readline(HANDLE hConsoleIn)
 779 {
 780     WCEL_Context        ctx;
 781     INPUT_RECORD        ir;
 782     KeyMap*             km;
 783     KeyEntry*           ke;
 784     unsigned            ofs;
 785     void                (*func)(struct WCEL_Context* ctx);
 786     DWORD               ks;
 787     int                 use_emacs;
 788
 789     memset(&ctx, 0, sizeof(ctx));
 790     ctx.hConIn = hConsoleIn;
 791     WCEL_HistoryInit(&ctx);
 792
 793     if (!CONSOLE_GetEditionMode(hConsoleIn, &use_emacs))
 794         use_emacs = 0;
 795
 796     if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
 797                                     OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
 798         !GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
 799         return NULL;
 800     ctx.can_wrap = (GetConsoleMode(ctx.hConOut, &ks) && (ks & ENABLE_WRAP_AT_EOL_OUTPUT)) ? 1 : 0;
 801
 802     if (!WCEL_Grow(&ctx, 1))
 803     {
 804         CloseHandle(ctx.hConOut);
 805         return NULL;
 806     }
 807     ctx.line[0] = 0;
 808
 809 /* EPP     WCEL_Dump(&ctx, "init"); */
 810
 811     while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
 812     {
 813         if (ir.EventType != KEY_EVENT) continue;
 814         TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
 815               ir.Event.KeyEvent.bKeyDown ? "Down" : "Up  ", ir.Event.KeyEvent.wRepeatCount,
 816               ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
 817               ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
 818         if (!ir.Event.KeyEvent.bKeyDown) continue;
 819
 820 /* EPP          WCEL_Dump(&ctx, "before func"); */
 821         ofs = ctx.ofs;
 822         /* mask out some bits which don't interest us */
 823         ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON);
 824
 825         func = NULL;
 826         for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
 827         {
 828             if (km->keyState != ks)
 829                 continue;
 830             if (km->chkChar)
 831             {
 832                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 833                     if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
 834             }
 835             else
 836             {
 837                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 838                     if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
 839
 840             }
 841             if (ke->func)
 842             {
 843                 func = ke->func;
 844                 break;
 845             }
 846         }
 847
 848         if (func)
 849             (func)(&ctx);
 850         else if (!(ir.Event.KeyEvent.dwControlKeyState & (ENHANCED_KEY|LEFT_ALT_PRESSED)))
 851             WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
 852         else TRACE("Dropped event\n");
 853
 854 /* EPP         WCEL_Dump(&ctx, "after func"); */
 855         if (ctx.ofs != ofs)
 856             SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
 857     }
 858     if (ctx.error)
 859     {
 860         HeapFree(GetProcessHeap(), 0, ctx.line);
 861         ctx.line = NULL;
 862     }
 863     WCEL_FreeYank(&ctx);
 864     if (ctx.line)
 865         CONSOLE_AppendHistory(ctx.line);
 866
 867     CloseHandle(ctx.hConOut);
 868     if (ctx.histCurr) HeapFree(GetProcessHeap(), 0, ctx.histCurr);
 869     return ctx.line;
 870 }