win32/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 <string.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wincon.h"
  29 #include "wine/unicode.h"
  30 #include "winnls.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(console);
  34
  35 /* console.c */
  36 extern int CONSOLE_GetHistory(int idx, WCHAR* buf, int buf_len);
  37 extern BOOL CONSOLE_AppendHistory(const WCHAR *p);
  38 extern unsigned int CONSOLE_GetNumHistoryEntries(void);
  39
  40 struct WCEL_Context;
  41
  42 typedef struct
  43 {
  44     WCHAR                       val;            /* vk or unicode char */
  45     void                        (*func)(struct WCEL_Context* ctx);
  46 } KeyEntry;
  47
  48 typedef struct
  49 {
  50     DWORD                       keyState;       /* keyState (from INPUT_RECORD) to match */
  51     BOOL                        chkChar;        /* check vk or char */
  52     KeyEntry*                   entries;        /* array of entries */
  53 } KeyMap;
  54
  55 typedef struct WCEL_Context {
  56     WCHAR*                      line;           /* the line being edited */
  57     size_t                      alloc;          /* number of WCHAR in line */
  58     unsigned                    len;            /* number of chars in line */
  59     unsigned                    ofs;            /* offset for cursor in current line */
  60     WCHAR*                      yanked;         /* yanked line */
  61     unsigned                    mark;           /* marked point (emacs mode only) */
  62     CONSOLE_SCREEN_BUFFER_INFO  csbi;           /* current state (initial cursor, window size, attribute) */
  63     HANDLE                      hConIn;
  64     HANDLE                      hConOut;
  65     unsigned                    done : 1,       /* to 1 when we're done with editing */
  66                                 error : 1;      /* to 1 when an error occurred in the editing */
  67     unsigned                    histSize;
  68     unsigned                    histPos;
  69     WCHAR*                      histCurr;
  70 } WCEL_Context;
  71
  72 #if 0
  73 static void WCEL_Dump(WCEL_Context* ctx, const char* pfx)
  74 {
  75     MESSAGE("%s: [line=%s[alloc=%u] ofs=%u len=%u start=(%d,%d) mask=%c%c\n"
  76             "\t\thist=(size=%u pos=%u curr=%s)\n",
  77             pfx, debugstr_w(ctx->line), ctx->alloc, ctx->ofs, ctx->len,
  78             ctx->csbi.dwCursorPosition.X, ctx->csbi.dwCursorPosition.Y,
  79             ctx->done ? 'D' : 'd', ctx->error ? 'E' : 'e',
  80             ctx->histSize, ctx->histPos, debugstr_w(ctx->histCurr));
  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     DWORD               retv;
  93
  94     for (;;)
  95     {
  96         /* data available ? */
  97         if (ReadConsoleInputW(ctx->hConIn, ir, 1, &retv) && retv == 1)
  98             return TRUE;
  99         /* then wait... */
 100         switch (WaitForSingleObject(ctx->hConIn, INFINITE))
 101         {
 102         case WAIT_OBJECT_0:
 103             break;
 104         default:
 105             /* we have checked that hConIn was a console handle (could be sb) */
 106             ERR("Shouldn't happen\n");
 107             /* fall thru */
 108         case WAIT_ABANDONED:
 109         case WAIT_TIMEOUT:
 110             ctx->error = 1;
 111             ERR("hmm bad situation\n");
 112             return FALSE;
 113         }
 114     }
 115 }
 116
 117 static inline void WCEL_Beep(WCEL_Context* ctx)
 118 {
 119     Beep(400, 300);
 120 }
 121
 122 static inline COORD WCEL_GetCoord(WCEL_Context* ctx, int ofs)
 123 {
 124     COORD c;
 125     c.X = ctx->csbi.dwCursorPosition.X + ofs;
 126     c.Y = ctx->csbi.dwCursorPosition.Y;
 127     return c;
 128 }
 129
 130 static inline void WCEL_GetRect(WCEL_Context* ctx, LPSMALL_RECT sr, int beg, int end)
 131 {
 132     sr->Left = ctx->csbi.dwCursorPosition.X + beg;
 133     sr->Top = ctx->csbi.dwCursorPosition.Y;
 134     sr->Right = ctx->csbi.dwCursorPosition.X + end;
 135     sr->Bottom = ctx->csbi.dwCursorPosition.Y;
 136 }
 137
 138 /* ====================================================================
 139  *
 140  * context manipulation functions
 141  *
 142  * ====================================================================*/
 143
 144 static BOOL WCEL_Grow(WCEL_Context* ctx, size_t len)
 145 {
 146     if (ctx->csbi.dwCursorPosition.X + ctx->ofs + len >= ctx->csbi.dwSize.X)
 147     {
 148         FIXME("Current implementation doesn't allow edition to spray across several lines\n");
 149         return FALSE;
 150     }
 151
 152     if (ctx->len + len >= ctx->alloc)
 153     {
 154         WCHAR*  newline;
 155         newline = HeapReAlloc(GetProcessHeap(), 0, ctx->line, sizeof(WCHAR) * (ctx->alloc + 32));
 156         if (!newline) return FALSE;
 157         ctx->line = newline;
 158         ctx->alloc += 32;
 159     }
 160     return TRUE;
 161 }
 162
 163 static void WCEL_DeleteString(WCEL_Context* ctx, int beg, int end)
 164 {
 165     SMALL_RECT  scl, clp;
 166     CHAR_INFO   ci;
 167
 168     if (end < ctx->len)
 169         memmove(&ctx->line[beg], &ctx->line[end], (ctx->len - end) * sizeof(WCHAR));
 170     /* make the source rect bigger than the actual rect to that the part outside the clip
 171      * rect (before the scroll) will get redrawn after the scroll
 172      */
 173     WCEL_GetRect(ctx, &scl, end, ctx->len + end - beg);
 174     WCEL_GetRect(ctx, &clp, beg, ctx->len);
 175
 176     ci.Char.UnicodeChar = ' ';
 177     ci.Attributes = ctx->csbi.wAttributes;
 178     ScrollConsoleScreenBufferW(ctx->hConOut, &scl, &clp, WCEL_GetCoord(ctx, beg), &ci);
 179
 180     ctx->len -= end - beg;
 181     ctx->line[ctx->len] = 0;
 182 }
 183
 184 static void WCEL_InsertString(WCEL_Context* ctx, const WCHAR* str)
 185 {
 186     size_t      len = lstrlenW(str);
 187
 188     if (!len || !WCEL_Grow(ctx, len)) return;
 189     if (ctx->len > ctx->ofs)
 190         memmove(&ctx->line[ctx->ofs + len], &ctx->line[ctx->ofs], (ctx->len - ctx->ofs) * sizeof(WCHAR));
 191     memcpy(&ctx->line[ctx->ofs], str, len * sizeof(WCHAR));
 192     ctx->len += len;
 193     ctx->line[ctx->len] = 0;
 194     SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
 195     WriteConsoleW(ctx->hConOut, &ctx->line[ctx->ofs], ctx->len - ctx->ofs, NULL, NULL);
 196     ctx->ofs += len;
 197 }
 198
 199 static void WCEL_InsertChar(WCEL_Context* ctx, WCHAR c)
 200 {
 201     WCHAR       buffer[2];
 202
 203     /* do not insert 0..31 control characters */
 204     if (c < ' ')
 205     {
 206         if (c != '\t') return;
 207     }
 208     buffer[0] = c;
 209     buffer[1] = 0;
 210     WCEL_InsertString(ctx, buffer);
 211 }
 212
 213 static void WCEL_SaveYank(WCEL_Context* ctx, int beg, int end)
 214 {
 215     int len = end - beg;
 216     ctx->yanked = HeapReAlloc(GetProcessHeap(), 0, ctx->yanked, (len + 1) * sizeof(WCHAR));
 217     if (!ctx->yanked) return;
 218     memcpy(ctx->yanked, &ctx->line[beg], len * sizeof(WCHAR));
 219     ctx->yanked[len] = 0;
 220 }
 221
 222 /* FIXME NTDLL doesn't export iswalnum, and I don't want to link in msvcrt when most
 223  * of the data lay in unicode lib
 224  */
 225 static inline BOOL WCEL_iswalnum(WCHAR wc)
 226 {
 227     return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
 228 }
 229
 230 static int WCEL_GetLeftWordTransition(WCEL_Context* ctx, int ofs)
 231 {
 232     ofs--;
 233     while (ofs >= 0 && !WCEL_iswalnum(ctx->line[ofs])) ofs--;
 234     while (ofs >= 0 && WCEL_iswalnum(ctx->line[ofs])) ofs--;
 235     if (ofs >= 0) ofs++;
 236     return max(ofs, 0);
 237 }
 238
 239 static int WCEL_GetRightWordTransition(WCEL_Context* ctx, int ofs)
 240 {
 241     ofs++;
 242     while (ofs <= ctx->len && WCEL_iswalnum(ctx->line[ofs])) ofs++;
 243     while (ofs <= ctx->len && !WCEL_iswalnum(ctx->line[ofs])) ofs++;
 244     return min(ofs, ctx->len);
 245 }
 246
 247 static WCHAR* WCEL_GetHistory(WCEL_Context* ctx, int idx)
 248 {
 249     WCHAR*      ptr;
 250
 251     if (idx == ctx->histSize - 1)
 252     {
 253         ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(ctx->histCurr) + 1) * sizeof(WCHAR));
 254         lstrcpyW(ptr, ctx->histCurr);
 255     }
 256     else
 257     {
 258         int     len = CONSOLE_GetHistory(idx, NULL, 0);
 259
 260         if ((ptr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 261         {
 262             CONSOLE_GetHistory(idx, ptr, len);
 263         }
 264     }
 265     return ptr;
 266 }
 267
 268 static void     WCEL_HistoryInit(WCEL_Context* ctx)
 269 {
 270     ctx->histPos = CONSOLE_GetNumHistoryEntries();
 271     ctx->histSize = ctx->histPos + 1;
 272     ctx->histCurr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WCHAR));
 273 }
 274
 275 static void    WCEL_MoveToHist(WCEL_Context* ctx, int idx)
 276 {
 277     WCHAR*      data = WCEL_GetHistory(ctx, idx);
 278     int         len = lstrlenW(data) + 1;
 279
 280     /* save current line edition for recall when needed (FIXME seems broken to me) */
 281     if (ctx->histPos == ctx->histSize - 1)
 282     {
 283         if (ctx->histCurr) HeapFree(GetProcessHeap(), 0, ctx->histCurr);
 284         ctx->histCurr = HeapAlloc(GetProcessHeap(), 0, (ctx->len + 1) * sizeof(WCHAR));
 285         memcpy(ctx->histCurr, ctx->line, (ctx->len + 1) * sizeof(WCHAR));
 286     }
 287     /* need to clean also the screen if new string is shorter than old one */
 288     WCEL_DeleteString(ctx, 0, ctx->len);
 289     ctx->ofs = 0;
 290     /* insert new string */
 291     if (WCEL_Grow(ctx, len))
 292     {
 293         WCEL_InsertString(ctx, data);
 294         HeapFree(GetProcessHeap(), 0, data);
 295         ctx->histPos = idx;
 296     }
 297 }
 298
 299 static void    WCEL_FindPrevInHist(WCEL_Context* ctx)
 300 {
 301     int startPos = ctx->histPos;
 302     WCHAR*      data;
 303     int         len, oldofs;
 304
 305     if (ctx->histPos && ctx->histPos == ctx->histSize) {
 306         startPos--;
 307         ctx->histPos--;
 308     }
 309
 310     do {
 311        data = WCEL_GetHistory(ctx, ctx->histPos);
 312
 313        if (ctx->histPos) ctx->histPos--;
 314        else ctx->histPos = (ctx->histSize-1);
 315
 316        len = lstrlenW(data) + 1;
 317        if ((len >= ctx->ofs) &&
 318            (memcmp(ctx->line, data, ctx->ofs * sizeof(WCHAR)) == 0)) {
 319
 320            /* need to clean also the screen if new string is shorter than old one */
 321            WCEL_DeleteString(ctx, 0, ctx->len);
 322
 323            if (WCEL_Grow(ctx, len))
 324            {
 325               oldofs = ctx->ofs;
 326               ctx->ofs = 0;
 327               WCEL_InsertString(ctx, data);
 328               ctx->ofs = oldofs;
 329               SetConsoleCursorPosition(ctx->hConOut, WCEL_GetCoord(ctx, ctx->ofs));
 330               HeapFree(GetProcessHeap(), 0, data);
 331               return;
 332            }
 333        }
 334     } while (ctx->histPos != startPos);
 335
 336     return;
 337 }
 338
 339 /* ====================================================================
 340  *
 341  * basic edition functions
 342  *
 343  * ====================================================================*/
 344
 345 static void WCEL_Done(WCEL_Context* ctx)
 346 {
 347     if (!WCEL_Grow(ctx, 1)) return;
 348     ctx->line[ctx->len++] = '\n';
 349     ctx->line[ctx->len] = 0;
 350     WriteConsoleA(ctx->hConOut, "\n", 1, NULL, NULL);
 351     ctx->done = 1;
 352 }
 353
 354 static void WCEL_MoveLeft(WCEL_Context* ctx)
 355 {
 356     if (ctx->ofs > 0) ctx->ofs--;
 357 }
 358
 359 static void WCEL_MoveRight(WCEL_Context* ctx)
 360 {
 361     if (ctx->ofs < ctx->len) ctx->ofs++;
 362 }
 363
 364 static void WCEL_MoveToLeftWord(WCEL_Context* ctx)
 365 {
 366     int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 367     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 368 }
 369
 370 static void WCEL_MoveToRightWord(WCEL_Context* ctx)
 371 {
 372     int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 373     if (new_ofs != ctx->ofs) ctx->ofs = new_ofs;
 374 }
 375
 376 static void WCEL_MoveToBeg(WCEL_Context* ctx)
 377 {
 378     ctx->ofs = 0;
 379 }
 380
 381 static void WCEL_MoveToEnd(WCEL_Context* ctx)
 382 {
 383     ctx->ofs = ctx->len;
 384 }
 385
 386 static void WCEL_SetMark(WCEL_Context* ctx)
 387 {
 388     ctx->mark = ctx->ofs;
 389 }
 390
 391 static void WCEL_ExchangeMark(WCEL_Context* ctx)
 392 {
 393     unsigned tmp;
 394
 395     if (ctx->mark > ctx->len) return;
 396     tmp = ctx->ofs;
 397     ctx->ofs = ctx->mark;
 398     ctx->mark = tmp;
 399 }
 400
 401 static void WCEL_CopyMarkedZone(WCEL_Context* ctx)
 402 {
 403     unsigned beg, end;
 404
 405     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 406     if (ctx->mark > ctx->ofs)
 407     {
 408         beg = ctx->ofs;         end = ctx->mark;
 409     }
 410     else
 411     {
 412         beg = ctx->mark;        end = ctx->ofs;
 413     }
 414     WCEL_SaveYank(ctx, beg, end);
 415 }
 416
 417 static void WCEL_TransposeChar(WCEL_Context* ctx)
 418 {
 419     WCHAR       c;
 420
 421     if (!ctx->ofs || ctx->ofs == ctx->len) return;
 422
 423     c = ctx->line[ctx->ofs];
 424     ctx->line[ctx->ofs] = ctx->line[ctx->ofs - 1];
 425     ctx->line[ctx->ofs - 1] = c;
 426
 427     WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[ctx->ofs - 1], 2, WCEL_GetCoord(ctx, ctx->ofs - 1), NULL);
 428     ctx->ofs++;
 429 }
 430
 431 static void WCEL_TransposeWords(WCEL_Context* ctx)
 432 {
 433     FIXME("NIY\n");
 434 }
 435
 436 static void WCEL_LowerCaseWord(WCEL_Context* ctx)
 437 {
 438     int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 439     if (new_ofs != ctx->ofs)
 440     {
 441         int     i;
 442         for (i = ctx->ofs; i <= new_ofs; i++)
 443             ctx->line[i] = tolowerW(ctx->line[i]);
 444         WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[ctx->ofs], new_ofs - ctx->ofs + 1,
 445                                      WCEL_GetCoord(ctx, ctx->ofs), NULL);
 446         ctx->ofs = new_ofs;
 447     }
 448 }
 449
 450 static void WCEL_UpperCaseWord(WCEL_Context* ctx)
 451 {
 452     int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 453     if (new_ofs != ctx->ofs)
 454     {
 455         int     i;
 456         for (i = ctx->ofs; i <= new_ofs; i++)
 457             ctx->line[i] = toupperW(ctx->line[i]);
 458         WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[ctx->ofs], new_ofs - ctx->ofs + 1,
 459                                      WCEL_GetCoord(ctx, ctx->ofs), NULL);
 460         ctx->ofs = new_ofs;
 461     }
 462 }
 463
 464 static void WCEL_CapitalizeWord(WCEL_Context* ctx)
 465 {
 466     int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 467     if (new_ofs != ctx->ofs)
 468     {
 469         int     i;
 470
 471         ctx->line[ctx->ofs] = toupperW(ctx->line[ctx->ofs]);
 472         for (i = ctx->ofs + 1; i <= new_ofs; i++)
 473             ctx->line[i] = tolowerW(ctx->line[i]);
 474         WriteConsoleOutputCharacterW(ctx->hConOut, &ctx->line[ctx->ofs], new_ofs - ctx->ofs + 1,
 475                                      WCEL_GetCoord(ctx, ctx->ofs), NULL);
 476         ctx->ofs = new_ofs;
 477     }
 478 }
 479
 480 static void WCEL_Yank(WCEL_Context* ctx)
 481 {
 482     WCEL_InsertString(ctx, ctx->yanked);
 483     HeapFree(GetProcessHeap(), 0, ctx->yanked);
 484     ctx->yanked = NULL;
 485 }
 486
 487 static void WCEL_KillToEndOfLine(WCEL_Context* ctx)
 488 {
 489     WCEL_SaveYank(ctx, ctx->ofs, ctx->len);
 490     WCEL_DeleteString(ctx, ctx->ofs, ctx->len);
 491 }
 492
 493 static void WCEL_KillMarkedZone(WCEL_Context* ctx)
 494 {
 495     unsigned beg, end;
 496
 497     if (ctx->mark > ctx->len || ctx->mark == ctx->ofs) return;
 498     if (ctx->mark > ctx->ofs)
 499     {
 500         beg = ctx->ofs;         end = ctx->mark;
 501     }
 502     else
 503     {
 504         beg = ctx->mark;        end = ctx->ofs;
 505     }
 506     WCEL_SaveYank(ctx, beg, end);
 507     WCEL_DeleteString(ctx, beg, end);
 508     ctx->ofs = beg;
 509 }
 510
 511 static void WCEL_DeletePrevChar(WCEL_Context* ctx)
 512 {
 513     if (ctx->ofs)
 514     {
 515         WCEL_DeleteString(ctx, ctx->ofs - 1, ctx->ofs);
 516         ctx->ofs--;
 517     }
 518 }
 519
 520 static void WCEL_DeleteCurrChar(WCEL_Context* ctx)
 521 {
 522     if (ctx->ofs < ctx->len)
 523         WCEL_DeleteString(ctx, ctx->ofs, ctx->ofs + 1);
 524 }
 525
 526 static void WCEL_DeleteLeftWord(WCEL_Context* ctx)
 527 {
 528     int new_ofs = WCEL_GetLeftWordTransition(ctx, ctx->ofs);
 529     if (new_ofs != ctx->ofs)
 530     {
 531         WCEL_DeleteString(ctx, new_ofs, ctx->ofs);
 532         ctx->ofs = new_ofs;
 533     }
 534 }
 535
 536 static void WCEL_DeleteRightWord(WCEL_Context* ctx)
 537 {
 538     int new_ofs = WCEL_GetRightWordTransition(ctx, ctx->ofs);
 539     if (new_ofs != ctx->ofs)
 540     {
 541         WCEL_DeleteString(ctx, ctx->ofs, new_ofs);
 542     }
 543 }
 544
 545 static void WCEL_MoveToPrevHist(WCEL_Context* ctx)
 546 {
 547     if (ctx->histPos) WCEL_MoveToHist(ctx, ctx->histPos - 1);
 548 }
 549
 550 static void WCEL_MoveToNextHist(WCEL_Context* ctx)
 551 {
 552     if (ctx->histPos < ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histPos + 1);
 553 }
 554
 555 static void WCEL_MoveToFirstHist(WCEL_Context* ctx)
 556 {
 557     if (ctx->histPos != 0) WCEL_MoveToHist(ctx, 0);
 558 }
 559
 560 static void WCEL_MoveToLastHist(WCEL_Context* ctx)
 561 {
 562     if (ctx->histPos != ctx->histSize - 1) WCEL_MoveToHist(ctx, ctx->histSize - 1);
 563 }
 564
 565 /* ====================================================================
 566  *
 567  *              Key Maps
 568  *
 569  * ====================================================================*/
 570
 571 #define CTRL(x) ((x) - '@')
 572 static KeyEntry StdKeyMap[] =
 573 {
 574     {/*BACK*/0x08,      WCEL_DeletePrevChar     },
 575     {/*RETURN*/0x0d,    WCEL_Done               },
 576     {/*DEL*/127,        WCEL_DeleteCurrChar     },
 577     {   0,              NULL                    }
 578 };
 579
 580 static KeyEntry Win32ExtraStdKeyMap[] =
 581 {
 582     {/*VK_F8*/   0x77,  WCEL_FindPrevInHist     },
 583     {   0,              NULL                    }
 584 };
 585
 586
 587 static  KeyEntry EmacsKeyMapCtrl[] =
 588 {
 589     {   CTRL('@'),      WCEL_SetMark            },
 590     {   CTRL('A'),      WCEL_MoveToBeg          },
 591     {   CTRL('B'),      WCEL_MoveLeft           },
 592     /* C */
 593     {   CTRL('D'),      WCEL_DeleteCurrChar     },
 594     {   CTRL('E'),      WCEL_MoveToEnd          },
 595     {   CTRL('F'),      WCEL_MoveRight          },
 596     {   CTRL('G'),      WCEL_Beep               },
 597     {   CTRL('H'),      WCEL_DeletePrevChar     },
 598     /* I: meaningless (or tab ???) */
 599     {   CTRL('J'),      WCEL_Done               },
 600     {   CTRL('K'),      WCEL_KillToEndOfLine    },
 601     /* L: [NIY] redraw the whole stuff */
 602     {   CTRL('M'),      WCEL_Done               },
 603     {   CTRL('N'),      WCEL_MoveToNextHist     },
 604     /* O; insert line... meaningless */
 605     {   CTRL('P'),      WCEL_MoveToPrevHist     },
 606     /* Q: [NIY] quoting... */
 607     /* R: [NIY] search backwards... */
 608     /* S: [NIY] search forwards... */
 609     {   CTRL('T'),      WCEL_TransposeChar      },
 610     /* U: [NIY] set repeat count... */
 611     /* V: paragraph down... meaningless */
 612     {   CTRL('W'),      WCEL_KillMarkedZone     },
 613     {   CTRL('X'),      WCEL_ExchangeMark       },
 614     {   CTRL('Y'),      WCEL_Yank               },
 615     /* Z: meaningless */
 616     {   0,              NULL                    }
 617 };
 618
 619 static KeyEntry EmacsKeyMapAlt[] =
 620 {
 621     {/*DEL*/127,        WCEL_DeleteLeftWord     },
 622     {   '<',            WCEL_MoveToFirstHist    },
 623     {   '>',            WCEL_MoveToLastHist     },
 624     {   '?',            WCEL_Beep               },
 625     {   'b',            WCEL_MoveToLeftWord     },
 626     {   'c',            WCEL_CapitalizeWord     },
 627     {   'd',            WCEL_DeleteRightWord    },
 628     {   'f',            WCEL_MoveToRightWord    },
 629     {   'l',            WCEL_LowerCaseWord      },
 630     {   't',            WCEL_TransposeWords     },
 631     {   'u',            WCEL_UpperCaseWord      },
 632     {   'w',            WCEL_CopyMarkedZone     },
 633     {   0,              NULL                    }
 634 };
 635
 636 static KeyEntry EmacsKeyMapExtended[] =
 637 {
 638     {/*RETURN*/  0x0d,  WCEL_Done },
 639     {/*VK_PRIOR*/0x21,  WCEL_MoveToPrevHist     },
 640     {/*VK_NEXT*/0x22,   WCEL_MoveToNextHist     },
 641     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 642     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 643     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 644     {/*VK_LEFT*/0x25,   WCEL_MoveLeft           },
 645     {   0,              NULL                    }
 646 };
 647
 648 static KeyMap   EmacsKeyMap[] =
 649 {
 650     {0x00000000, 1, StdKeyMap},
 651     {0x00000001, 1, EmacsKeyMapAlt},    /* left  alt  */
 652     {0x00000002, 1, EmacsKeyMapAlt},    /* right alt  */
 653     {0x00000004, 1, EmacsKeyMapCtrl},   /* left  ctrl */
 654     {0x00000008, 1, EmacsKeyMapCtrl},   /* right ctrl */
 655     {0x00000100, 0, EmacsKeyMapExtended},
 656     {0,          0, 0}
 657 };
 658
 659 static  KeyEntry Win32KeyMapExtended[] =
 660 {
 661     {/*VK_LEFT*/ 0x25,  WCEL_MoveLeft           },
 662     {/*VK_RIGHT*/0x27,  WCEL_MoveRight          },
 663     {/*VK_HOME*/ 0x24,  WCEL_MoveToBeg          },
 664     {/*VK_END*/  0x23,  WCEL_MoveToEnd          },
 665     {/*VK_UP*/   0x26,  WCEL_MoveToPrevHist     },
 666     {/*VK_DOWN*/ 0x28,  WCEL_MoveToNextHist     },
 667     {/*VK_DEL*/  0x2e,  WCEL_DeleteCurrChar     },
 668     {   0,              NULL                    }
 669 };
 670
 671 static  KeyEntry Win32KeyMapCtrlExtended[] =
 672 {
 673     {/*VK_LEFT*/ 0x25,  WCEL_MoveToLeftWord     },
 674     {/*VK_RIGHT*/0x27,  WCEL_MoveToRightWord    },
 675     {/*VK_END*/  0x23,  WCEL_KillToEndOfLine    },
 676     {   0,              NULL                    }
 677 };
 678
 679 KeyMap  Win32KeyMap[] =
 680 {
 681     {0x00000000, 1, StdKeyMap},
 682     {0x00000000, 0, Win32ExtraStdKeyMap},
 683     {0x00000100, 0, Win32KeyMapExtended},
 684     {0x00000104, 0, Win32KeyMapCtrlExtended},
 685     {0x00000108, 0, Win32KeyMapCtrlExtended},
 686     {0,          0, 0}
 687 };
 688 #undef CTRL
 689
 690 /* ====================================================================
 691  *
 692  *              Read line master function
 693  *
 694  * ====================================================================*/
 695
 696 WCHAR* CONSOLE_Readline(HANDLE hConsoleIn, int use_emacs)
 697 {
 698     WCEL_Context        ctx;
 699     INPUT_RECORD        ir;
 700     KeyMap*             km;
 701     KeyEntry*           ke;
 702     unsigned            ofs;
 703     void                (*func)(struct WCEL_Context* ctx);
 704     DWORD               ks;
 705
 706     memset(&ctx, 0, sizeof(ctx));
 707     ctx.hConIn = hConsoleIn;
 708     WCEL_HistoryInit(&ctx);
 709     if ((ctx.hConOut = CreateFileA("CONOUT$", GENERIC_READ|GENERIC_WRITE, 0, NULL,
 710                                     OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE ||
 711         !GetConsoleScreenBufferInfo(ctx.hConOut, &ctx.csbi))
 712         return NULL;
 713     if (!WCEL_Grow(&ctx, 1))
 714     {
 715         CloseHandle(ctx.hConOut);
 716         return NULL;
 717     }
 718     ctx.line[0] = 0;
 719
 720 /* EPP     WCEL_Dump(&ctx, "init"); */
 721
 722     while (!ctx.done && !ctx.error && WCEL_Get(&ctx, &ir))
 723     {
 724         if (ir.EventType != KEY_EVENT || !ir.Event.KeyEvent.bKeyDown) continue;
 725         TRACE("key%s repeatCount=%u, keyCode=%02x scanCode=%02x char=%02x keyState=%08lx\n",
 726               ir.Event.KeyEvent.bKeyDown ? "Down" : "Up  ", ir.Event.KeyEvent.wRepeatCount,
 727               ir.Event.KeyEvent.wVirtualKeyCode, ir.Event.KeyEvent.wVirtualScanCode,
 728               ir.Event.KeyEvent.uChar.UnicodeChar, ir.Event.KeyEvent.dwControlKeyState);
 729
 730 /* EPP  WCEL_Dump(&ctx, "before func"); */
 731         ofs = ctx.ofs;
 732         /* mask out some bits which don't interest us */
 733         ks = ir.Event.KeyEvent.dwControlKeyState & ~(NUMLOCK_ON|SCROLLLOCK_ON|CAPSLOCK_ON);
 734
 735         func = NULL;
 736         for (km = (use_emacs) ? EmacsKeyMap : Win32KeyMap; km->entries != NULL; km++)
 737         {
 738             if (km->keyState != ks)
 739                 continue;
 740             if (km->chkChar)
 741             {
 742                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 743                     if (ke->val == ir.Event.KeyEvent.uChar.UnicodeChar) break;
 744             }
 745             else
 746             {
 747                 for (ke = &km->entries[0]; ke->func != 0; ke++)
 748                     if (ke->val == ir.Event.KeyEvent.wVirtualKeyCode) break;
 749
 750             }
 751             if (ke->func)
 752             {
 753                 func = ke->func;
 754                 break;
 755             }
 756         }
 757
 758         if (func)
 759             (func)(&ctx);
 760         else if (!(ir.Event.KeyEvent.dwControlKeyState & (ENHANCED_KEY|LEFT_ALT_PRESSED)))
 761             WCEL_InsertChar(&ctx, ir.Event.KeyEvent.uChar.UnicodeChar);
 762         else TRACE("Dropped event\n");
 763
 764 /* EPP  WCEL_Dump(&ctx, "after func"); */
 765         if (ctx.ofs != ofs)
 766             SetConsoleCursorPosition(ctx.hConOut, WCEL_GetCoord(&ctx, ctx.ofs));
 767     }
 768     if (ctx.error)
 769     {
 770         HeapFree(GetProcessHeap(), 0, ctx.line);
 771         ctx.line = NULL;
 772     }
 773     if (ctx.line)
 774         CONSOLE_AppendHistory(ctx.line);
 775
 776     CloseHandle(ctx.hConOut);
 777     if (ctx.histCurr) HeapFree(GetProcessHeap(), 0, ctx.histCurr);
 778     return ctx.line;
 779 }
 780