edit.c

/*
  edit.c - Enhanced command line editing for CMD.EXE.

  Jason Hood, 24 October to 21 November, 2005 and 19 to 23 December, 2006.

  API hooking derived from ANSI.xs by Jean-Louis Morel, from his Perl package
  Win32::Console::ANSI.  Keyboard hooking based on the hook tutorial sample
  code by RattleSnake: Systemwide Windows Hooks without external DLL.

  v1.02, 23 July, 2010:
  - better handling of control characters;
  - fixed alternative directory association in the root;
  - LSTK was listing Shift+Control for Control keys;
  - tweaks to completion;
  + read options from HKLM if they don't exist in HKCU.

  v2.00, 22 July to 8 August, 2011:
  * compile cleanly with GCC 4;
  - fixed file name completion with leading/trailing dot;
  + new function Execute to prevent adding the line to history;
  - ensure input is from the console (prevents "set/p <nul" from crashing);
  - ignore input from non-commands (at least "set/p");
  - find imports by name (fixes ANSICON issue);
  * improved prompt handling for macros & multiple commands;
  + new function CopyFromPrev, similar to the original F3;
  + save history on exit, read on install, but only for the "primary" instance;
  - macros will not take arguments after a pipe, ampersand or redirection;
  + new functions SwapWords & SwapArgs;
  - piping internal commands will also use the pipe options;
  - fixed colouring a redisplayed multiline prompt at the end of the buffer;
  - ignore ^C generated by Ctrl+Break;
  + new function UnderToggle to change underscore behaviour;
  + new functions Select, Cut & Paste, to provide a mini-clipboard;
  + new functions EndWordLeft & EndWordRight, to move past the end of a word;
  * show the file name and line number of a config file error;
  * auto-recall continues after a single failure; DelLeft does not delete;
    don't continue after DelRight;
  + new functions FindBack & FindForw do an incremental search;
  + custom configuration based on initial directory;
  + copy the history from the parent instance (if not loading it);
  * config file will be read as UTF-8, if the BOM is present;
  + new functions Undo, Redo & Revert;
  - read the options even if not installed (to preserve for the install);
  * treat a hex keypad number < 256 as Unicode;
  - fixed substituting empty macro argument;
  * expand multiline macros using the command separator;
  * LSTH uses ESCAPE to find numbers and search for the redirection symbols;
  * delimit internal commands the same as a definition;
  - fixed initial install.

  16 September, 2011:
  + new functions UpdateEnter & UpdateErase to replace history lines.

  15 November, 2011:
  * go back to calling the normal import (explicitly require ANSICON to be
    installed after CMDread).

  v2.01, 8 December, 2011:
  * copy CMD.EXE's imports into edit.dll (finally work with ANSICON).

  14 & 15 June, 2012:
  * if there's no parent, copy history from primary.

  21 May, 2013:
  - fix file name completion testing for directory on an empty name.

  v2.10, 28 May to 21 June, 2013:
  * set locale code page and use wprintf for slightly better output;
  + DBCS (double-width characters) support;
  + Windows 8 support (use API-MS-Win-Core-Console-* import library);
  - 64-bit: fix copying history;
  * use Unicode;
  - use the code page for the custom history file from the config file;
  - fixed bug with internal command redirection when redirection wasn't used;
  * list completed file names using minimal lines;
  - in testing DBCS double-width wrapping, just realised dispbeg was always 0!
  - fixed redefining a keyboard macro;
  - fixed listing a single-character keyboard macro;
  + new functions Hidden & HiddenEx to wipe the command and prompt, and remove
    it from history; defk '-' prefix for HiddenEx shorthand;
  * make use of the other buffer to determine the size of the prompt;
  - fixed wiping a wrapped command;
  - fixed user scrolling issues;
  - fixed mixing environment variables with symbols;
  + expand %CD% and recognise the other CMD.EXE dynamic variables;
  - recognise, but don't expand, environment variable substitution.

  v2.11, 4 July, 2013:
  * increase maximum file line length to 2046 (2048 - LF - NUL);
  - prevent crash when reading an invalid file.

  v2.12, 10 July, 2013:
  * read options from CMDread, not here;
  - fix saving to the history file specified from the command line.
*/

#include "CMDread.h"
#include "version.h"
#include <commdlg.h>
#include <shellapi.h>
#include <ImageHlp.h>

#ifndef ENABLE_INSERT_MODE
#define ENABLE_INSERT_MODE     0x20
#define ENABLE_QUICK_EDIT_MODE 0x40
#endif


// ========== Auxiliary debug function

#define MYDEBUG 0

#if (MYDEBUG > 0)
void DEBUGSTR( LPCWSTR szFormat, ... ) // sort of OutputDebugStringf
{
  WCHAR szBuffer[1024];
  va_list pArgList;
  va_start( pArgList, szFormat );
  _vsnwprintf( szBuffer, lenof(szBuffer), szFormat, pArgList );
  va_end( pArgList );
  OutputDebugString( szBuffer );
}
#elif defined(__GNUC__)
#define DEBUGSTR( ... )
#else
#define DEBUGSTR
#endif


// ========== Global variables and constants

#ifdef __GNUC__
#define SHARED __attribute__((dllexport, shared, section(".share")))
#else
#pragma data_seg(".share", "read,write,shared")
#pragma data_seg()
#define SHARED __declspec(dllexport allocate(".share"))
#endif



SHARED DWORD primary_id = 0;
SHARED DWORD parent_pid = 0;

SHARED Option option = {
  { 25, 50 },			// insert & overwrite cursor sizes
  0,				// default insert mode
  0,				// beep on errors
  0,				// don't auto-recall commands
  0,				// enable macro & symbol translation
  0,				// enable CMDread
  0,				// append backslash on completed dirs
  0,				// empty match remains at start
  ' ',                          // old prefix character to disable translation
  1,				// minimum line length to store in history
  50,				// number of commands to store in history
  0,				// enable colouring
  31,				// command line,	bright white  on blue
  27,				// recording,		bright cyan   on blue
  27,				// drive and colon,	bright cyan   on blue
  30,				// directory separator, bright yellow on blue
  26,				// directory,		bright green  on blue
  30,				// greater than sign,	bright yellow on blue
  26,				// base directory,	bright green  on blue
  121,				// selection,		bright blue   on grey
  1,				// underscore is part of a word
  ' ',                          // prefix character to disable translation
  '+',                          // prefix character to update history line
};

SHARED WCHAR cfgname[MAX_PATH] = { 0 }; // configuration file
SHARED WCHAR hstname[MAX_PATH] = { 0 }; // history file
SHARED BOOL  cmd_history = FALSE;	// read command line history file


// Structure to hold a line.
typedef struct
{
  PWSTR txt;			// text of the line
  DWORD len;			// length of the line
} Line, *PLine;


// Structure to search for functions, keys & internal commands.
typedef struct
{
  PCWSTR name;			// function/key/internal command name
  int	 func;			// function/VK/function ptr
} Cfg;


// Structure to store the character and function assigned to a key.
typedef struct
{
  WCHAR ch;			// character
  char	fn;			// function
  char	filler; 		// ensure alignment as a single DWORD
} Key, *PKey;


// Type of keyboard macro.
enum { MAC_FUNC, MAC_LINE, MAC_HIDDEN };

// Structure for keyboard macros.
typedef struct macro_s
{
  struct macro_s* next;
  char*  key;			// pointer into appropriate key array
  int	 type;
  DWORD  len;
  union
  {
    PWSTR line; 		// for type == MAC_LINE or MAC_HIDDEN
    PKey  func; 		// for type == MAC_FUNC
    Key   chfn; 		// for len == 1
  };
} Macro, *PMacro;


// Structure to hold lines for macros, symbols and associations.
typedef struct linelist_s
{
  struct linelist_s* next;
  DWORD  len;
  WCHAR  line[0];
} LineList, *PLineList;


// Structure for a definition (macro, symbol or association).
typedef struct define_s
{
  struct define_s* next;
  PLineList line;
  DWORD     len;
  WCHAR     name[0];
} Define, *PDefine;


// Structure for the history and completed filenames.
typedef struct history_s
{
  struct history_s* prev;
  struct history_s* next;
  union
  {
    DWORD  len; 		// history line length
    struct
    {
      WORD flen;		// file name length
      WORD dlen;		// displayed length
    };
  };
  WCHAR  line[0];
} History, *PHistory;


// Function prototype for an internal command.
typedef void (*IntFunc)( DWORD );


// Structure for undo/redo.
typedef struct undo_s
{
  struct undo_s* prev;
  struct undo_s* next;
  int	 type;			// the operation to perform
  int	 pos;			// where to perform it
  DWORD  len;			// how much to undo
  DWORD  max;			// capacity of txt
  PWSTR  txt;			// the text to restore
} UndoInfo, *PUndoInfo;

enum { UNDOGROUP, UNDOINSERT, UNDODELETE };	// how to undo


BOOL	primary;		// are we the primary instance?
BOOL	save_history;		// preserve history?

__declspec(dllexport)
Status	local = {
  PVERX,
  TRUE, 			// we are active
  { 0 },			// history file
};

static DWORD conwr;		// dummy variable for API functions
#define WriteCon( h, t, l )	  WriteConsole( h, t, l, &conwr, NULL )
#define FillConChar( h, c, l, p ) FillConsoleOutputCharacter( h,c,l,p,&conwr )
#define FillConAttr( h, a, l, p ) FillConsoleOutputAttribute( h,a,l,p,&conwr )

HANDLE	hConIn, hConOut;	// handles to keyboard input and screen output
HANDLE	hConWid, hConWid1;	// output handles to determine character width
CONSOLE_SCREEN_BUFFER_INFO screen; // current screen info
Line	prompt = { L"", 0 };    // pointer to the prompt
WORD	p_attr[MAX_PATH+2];	// buffer to store prompt's attributes
DWORD	p_attr_len;		// length of above
BOOL	show_prompt;		// should we redisplay the prompt?
int	erase_prompt;		// remove the prompt for a multi-cmd?
BOOL	hidden_cmd;		// prevent writing newline for Hidden/HiddenEx

Line	line;			// line being edited
DWORD	max;			// maximum size of above
DWORD	dispbeg, dispend;	// beginning and ending position to display
DWORD	cellend;		// ending character cell position
Line	selected;		// the selection text

BOOL	kbd;			// is input from the keyboard?
BOOL	def_macro;		// defining a macro?
Line	mcmd;			// buffer for multiple commands
int	lastm;			// previous macro listed was multi-line
COORD	lastc;			// cursor position of previous command

BOOL	found_quote;		// true if get_string found a quote

FILE*	file;			// file containing commands
UINT	filecp; 		// code page of the file
PCWSTR	file_name;		// name of the file for the error display
int	line_no;		// line number of current command
BOOL	seen_error;		// has an error already been shown?

int	check_break;		// Control+Break received?
BOOL	trap_break;		// pass it on?

Line	envvar; 		// buffer for environment variable


#define ESCAPE		'^'     // character to treat next character literally
#define CMDSEP		19	// character used to separate multiple commands
#define VARIABLE	'%'     // character used for symbol and variable subst

#define FEXEC		L".exe.com.bat.cmd"         // default executable list
#define FIGNORE 	L".exe.com.dll.obj.o.bak"   // default ignore list

#define INVALID_FNAME	L"=,;+<|>&@"            // "invalid" filename characters
#define QUOTE_FNAME	L" &()[]{}^=;!%'+,`~"   // quoted filename characters
						//  (same as CMD.EXE)
#define BRACE_TERM	L" \t,;+"               // brace expansion separators
#define BRACE_STOP	L"<|>&"                 // brace expansion terminators
#define BRACE_ESCAPE	L"{},^"                 // escaped brace exp. characters

#define DEF_TERM	L" \t<|>&/"             // definition delimiter

#define VAR_ESCAPE	L"%^"                   // escaped variable characters
#define ARG_ESCAPE	L"%*^"                  // escaped argument characters

// CMD.EXE dynamic variables - these are recognised, but not expanded (except
// for %CD%).
const LPCWSTR cmd_vars[] =
{
//L"CD",        // handled separately
  L"DATE",
  L"TIME",
  L"RANDOM",
  L"ERRORLEVEL",
  L"CMDEXTVERSION",
  L"CMDCMDLINE",
  L"HIGHESTNUMANODENUMBER",
};


// Map control characters using the CP437 glyphs as Unicode codepoints.
const WCHAR ControlChar[] = {  ' ',           //  0
			      L'\x263A',      //  1 White Smiling Face
			      L'\x263B',      //  2 Black Smiling Face
			      L'\x2665',      //  3 Black Heart Suit
			      L'\x2666',      //  4 Black Diamond Suit
			      L'\x2663',      //  5 Black Club Suit
			      L'\x2660',      //  6 Black Spade Suit
			      L'\x2022',      //  7 Bullet
			      L'\x25D8',      //  8 Inverse Bullet
			      L'\x25CB',      //  9 White Circle
			      L'\x25D9',      // 10 Inverse White Circle
			      L'\x2642',      // 11 Male Sign
			      L'\x2640',      // 12 Female Sign
			      L'\x266A',      // 13 Eigth Note
			      L'\x266B',      // 14 Beamed Eigth Notes
			      L'\x263C',      // 15 White Sun With Rays
			      L'\x25BA',      // 16 Black Right-Pointing Pointer
			      L'\x25C4',      // 17 Black Left-Pointing Pointer
			      L'\x2195',      // 18 Up Down Arrow
			      L'\x203C',      // 19 Double Exclamation Mark
			      L'\x00B6',      // 20 Pilcrow Sign
			      L'\x00A7',      // 21 Section Sign
			      L'\x25AC',      // 22 Black Rectangle
			      L'\x21A8',      // 23 Up Down Arrow With Base
			      L'\x2191',      // 24 Upwards Arrow
			      L'\x2193',      // 25 Downwards Arrow
			      L'\x2192',      // 26 Rightwards Arrow
			      L'\x2190',      // 27 Leftwards Arrow
			      L'\x221F',      // 28 Right Angle
			      L'\x2194',      // 29 Left Right Arrow
			      L'\x25B2',      // 30 Black Up-Pointing Pointer
			      L'\x25BC'       // 31 Black Down-Pointing Pointer
			    };

// Functions
enum
{
  Default,		// just place the character in the buffer
  Ignore,		// totally ignore the key
  Quote,		// the next key will not be interpreted as a command
  CharLeft,		// cursor one character to the left
  CharRight,		// cursor one character to the right
  WordLeft,		// cursor to the start of the current/previous word
  WordRight,		// cursor to the start of the next word
  EndWordLeft,		// cursor to the end of the previous word
  EndWordRight, 	// cursor to the end of the current/next word
  StringLeft,		// cursor to the start of the current/previous string
  StringRight,		// cursor to the start of the next string
  BegLine,		// cursor to the beginning of the line
  EndLine,		// cursor to the end of the line
  Select,		// select text
  Cut,			// cut selected text or current argument
  Paste,		// paste cut text
  PrevLine,		// previous command in history buffer
  NextLine,		// next command in history buffer
  SearchBack,		// search the history backwards
  SearchForw,		// search the history forwards
  FindBack,		// incrementally search the history backwards
  FindForw,		// incrementally search the history forwards
  FirstLine,		// first command in history
  LastLine,		// last command in history
  CopyFromPrev, 	// copy remainder of line from the previous command
  List, 		// filename completion list
  ListDir,		// directory completion list
  Cycle,		// filename completion cycle
  CycleBack,		// filename completion cycle backwards
  CycleDir,		// directory completion cycle
  CycleDirBack, 	// directory completion cycle backwards
  SelectFiles,		// select files from the Open dialog
  DelLeft,		// delete character to the left of the cursor
  DelRight,		// delete character under the cursor
  DelWordLeft,		// delete word at left of cursor
  DelWordRight, 	// delete word at right of cursor
  DelArg,		// delete argument at or left of cursor
  DelBegLine,		// delete to the beginning of the line
  DelEndLine,		// delete to the end of the line
  DelEndExec,		// delete to the end of the line and execute the line
  Erase,		// erase line
  StoreErase,		// erase the line but put it in the history
  CmdSep,		// command separator
  Transpose,		// transpose (swap characters)
  SwapWords,		// swap the current word with the previous
  SwapArgs,		// swap the current argument with the previous
  AutoRecall,		// toggle auto-recall
  MacroToggle,		// macro/symbol/brace toggling
  UnderToggle,		// change behaviour of underscore
  VarSubst,		// inline var. substitution/brace expansion/association
  Enter,		// accept line
  Execute,		// execute the line without adding it to the history
  Wipe, 		// execute the line without history & remove its display
  Hidden,		// execute the line & remove it and the prompt
  HiddenEx,		// as above and don't add to history
  InsOvr,		// insert/overwrite toggle
  Play, 		// play back a series of keys
  Record,		// record a series of keys
  Undo, 		// undo previous function(s)
  Redo, 		// undo the undo
  Revert,		// undo/redo everything
  UpdateEnter,		// accept line, replacing the existing one in history
  UpdateErase,		// erase line but replace the existing one in history
  LastFunc
};


// Function names for lstk.
const LPCWSTR func_str[] =
{
  L"Default",      L"Ignore",      L"Quote",        L"CharLeft",
  L"CharRight",    L"WordLeft",    L"WordRight",    L"EndWordLeft",
  L"EndWordRight", L"StringLeft",  L"StringRight",  L"BegLine",
  L"EndLine",      L"Select",      L"Cut",          L"Paste",
  L"PrevLine",     L"NextLine",    L"SearchBack",   L"SearchForw",
  L"FindBack",     L"FindForw",    L"FirstLine",    L"LastLine",
  L"CopyFromPrev", L"List",        L"ListDir",      L"Cycle",
  L"CycleBack",    L"CycleDir",    L"CycleDirBack", L"SelectFiles",
  L"DelLeft",      L"DelRight",    L"DelWordLeft",  L"DelWordRight",
  L"DelArg",       L"DelBegLine",  L"DelEndLine",   L"DelEndExec",
  L"Erase",        L"StoreErase",  L"CmdSep",       L"Transpose",
  L"SwapWords",    L"SwapArgs",    L"AutoRecall",   L"MacroToggle",
  L"UnderToggle",  L"VarSubst",    L"Enter",        L"Execute",
  L"Wipe",         L"Hidden",      L"HiddenEx",     L"InsOvr",
  L"Play",         L"Record",      L"Undo",         L"Redo",
  L"Revert",       L"UpdateEnter", L"UpdateErase"
};


#define f( name ) { L###name, name },	// simplify function config definitions

// Function strings
const Cfg cfg[] = {
  f( AutoRecall   )
  f( BegLine	  )
  f( CharLeft	  )
  f( CharRight	  )
  f( CmdSep	  )
  f( CopyFromPrev )
  f( Cut	  )
  f( Cycle	  )
  f( CycleBack	  )
  f( CycleDir	  )
  f( CycleDirBack )
  f( Default	  )
  f( DelArg	  )
  f( DelBegLine   )
  f( DelEndExec   )
  f( DelEndLine   )
  f( DelLeft	  )
  f( DelRight	  )
  f( DelWordLeft  )
  f( DelWordRight )
  f( EndLine	  )
  f( EndWordLeft  )
  f( EndWordRight )
  f( Enter	  )
  f( Erase	  )
  f( Execute	  )
  f( FindBack	  )
  f( FindForw	  )
  f( FirstLine	  )
  f( Hidden	  )
  f( HiddenEx	  )
  f( Ignore	  )
  f( InsOvr	  )
  f( LastLine	  )
  f( List	  )
  f( ListDir	  )
  f( MacroToggle  )
  f( NextLine	  )
  f( Paste	  )
  f( Play	  )
  f( PrevLine	  )
  f( Quote	  )
  f( Record	  )
  f( Redo	  )
  f( Revert	  )
  f( SearchBack   )
  f( SearchForw   )
  f( Select	  )
  f( SelectFiles  )
  f( StoreErase   )
  f( StringLeft   )
  f( StringRight  )
  f( SwapArgs	  )
  f( SwapWords	  )
  f( Transpose	  )
  f( UnderToggle  )
  f( Undo	  )
  f( UpdateEnter  )
  f( UpdateErase  )
  f( VarSubst	  )
  f( Wipe	  )
  f( WordLeft	  )
  f( WordRight	  )
};


// Key strings
const Cfg cfgkey[] = {
  { L"Bksp",    VK_DOWN+1 },
  { L"Del",     VK_DELETE },
  { L"Down",    VK_DOWN   },
  { L"End",     VK_END    },
  { L"Enter",   VK_DOWN+3 },
  { L"Esc",     VK_DOWN+4 },
  { L"Home",    VK_HOME   },
  { L"Ins",     VK_INSERT },
  { L"Left",    VK_LEFT   },
  { L"PgDn",    VK_NEXT   },
  { L"PgUp",    VK_PRIOR  },
  { L"Right",   VK_RIGHT  },
  { L"Tab",     VK_DOWN+2 },
  { L"Up",      VK_UP     },
};

#define CFGKEYS (lenof(cfgkey))


// Key names for lstk.

const LPCWSTR key_str[] =
{
  L"PgUp", L"PgDn", L"End", L"Home",  L"Left", L"Up",  L"Right",
  L"Down", L"Bksp", L"Tab", L"Enter", L"Esc",  L"Ins", L"Del",
};


// Keymaps

char key_table[][4] = { 	// VK_PRIOR to VK_DELETE
  // plain	shift		control 	alt
  { FirstLine,	Ignore, 	Ignore, 	Ignore, 	},// PageUp
  { LastLine,	Ignore, 	Ignore, 	Ignore, 	},// PageDn
  { EndLine,	Ignore, 	DelEndLine,	Ignore, 	},// End
  { BegLine,	Ignore, 	DelBegLine,	Ignore, 	},// Home
  { CharLeft,	EndWordLeft,	WordLeft,	StringLeft,	},// Left
  { PrevLine,	Ignore, 	FindBack,	Ignore, 	},// Up
  { CharRight,	EndWordRight,	WordRight,	StringRight,	},// Right
  { NextLine,	Ignore, 	FindForw,	Ignore, 	},// Down

  // plain	shift		control 	shift+control
  { DelLeft,	DelLeft,	DelWordLeft,	DelArg, 	},// Backspace
  { Cycle,	CycleBack,	List,		ListDir,	},// Tab
  { Enter,	UpdateEnter,	Execute,	Hidden, 	},// Enter
  { Erase,	Erase,		Ignore, 	Ignore, 	},// Escape

  // plain	shift		control 	alt
  { InsOvr,	Paste,		Ignore, 	Ignore, 	},// Insert
  { DelRight,	Cut,		DelWordRight,	Ignore, 	},// Delete
};

char fkey_table[][4] = {	// VK_F1 to VK_F12
  // plain	  shift 	control 	alt
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F1
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F2
  { CopyFromPrev, Ignore,	Ignore, 	Ignore, 	},// F3
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F4
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F5
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F6
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F7
  { SearchBack,   SearchForw,	Ignore, 	Ignore, 	},// F8
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F9
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F10
  { Ignore,	  Ignore,	Ignore, 	Ignore, 	},// F11
  { Record,	  Ignore,	Ignore, 	Ignore, 	},// F12
};

char ctrl_key_table[][2] = {
  // plain		// shift
  { Ignore,		Ignore, 	}, // ^@
  { BegLine,		SwapArgs,	}, // ^A
  { CharLeft,		Ignore, 	}, // ^B
  { Cut,		Ignore, 	}, // ^C
  { DelRight,		ListDir,	}, // ^D
  { EndLine,		Ignore, 	}, // ^E
  { CharRight,		List,		}, // ^F
  { StoreErase, 	UpdateErase,	}, // ^G
  { DelLeft,		Ignore, 	}, // ^H
  { Cycle,		CycleBack,	}, // ^I
  { VarSubst,		Ignore, 	}, // ^J
  { DelEndLine, 	Ignore, 	}, // ^K
  { DelWordLeft,	Ignore, 	}, // ^L
  { Select,		Ignore, 	}, // ^M
  { NextLine,		Ignore, 	}, // ^N
  { DelEndExec, 	Ignore, 	}, // ^O
  { PrevLine,		Paste,		}, // ^P
  { Quote,		Ignore, 	}, // ^Q
  { SearchBack, 	FindBack,	}, // ^R
  { CmdSep,		SelectFiles,	}, // ^S
  { Transpose,		SwapWords,	}, // ^T
  { PrevLine,		Revert, 	}, // ^U
  { SearchForw, 	FindForw,	}, // ^V
  { DelWordRight,	Ignore, 	}, // ^W
  { DelBegLine, 	Ignore, 	}, // ^X
  { AutoRecall, 	Ignore, 	}, // ^Y
  { Undo,		Redo,		}, // ^Z
  { Erase,		Ignore, 	}, // ^[
  { CycleDir,		CycleDirBack,	}, // ^\  (can't end line w/ backslash)
  { CmdSep,		Ignore, 	}, // ^]
  { Wipe,		HiddenEx,	}, // ^^
  { MacroToggle,	UnderToggle,	}, // ^_
};


// Keyboard macros

PMacro macro_head, macro_prev;		// head of the list, previous macro

PMacro find_macro( char* );		// search macro list for key
PMacro add_macro(  char* );		// add or clear macro for key
void   end_macro(  PMacro );		// finish off a macro
void   del_macro(  char* );		// delete the macro for key


// Internal commands

FILE* lstout;				// list output file
BOOL  lstpipe;				// outputting to a pipe?
int   old_mode; 			// current stdout file mode
BOOL  redirect( DWORD );		// check for redirection
void  end_redirect( void );		// close the file
void  list_key( char* );		// show the assignment of a key

void execute_defa( DWORD );
void execute_defk( DWORD );
void execute_defm( DWORD );
void execute_defs( DWORD );
void execute_dela( DWORD );
void execute_delh( DWORD );
void execute_delk( DWORD );
void execute_delm( DWORD );
void execute_dels( DWORD );
void execute_lsta( DWORD );
void execute_lsth( DWORD );
void execute_lstk( DWORD );
void execute_lstm( DWORD );
void execute_lsts( DWORD );
void execute_rsta( DWORD );
void execute_rsth( DWORD );
void execute_rstm( DWORD );
void execute_rsts( DWORD );

#ifndef _WIN64
const Cfg internal[] = {
  { L"defa",    (int)execute_defa },    // define association
  { L"defk",    (int)execute_defk },    // define key
  { L"defm",    (int)execute_defm },    // define macro
  { L"defs",    (int)execute_defs },    // define symbol
  { L"dela",    (int)execute_dela },    // delete association(s)
  { L"delh",    (int)execute_delh },    // delete history line(s)
  { L"delk",    (int)execute_delk },    // delete key(s)
  { L"delm",    (int)execute_delm },    // delete macro(s)
  { L"dels",    (int)execute_dels },    // delete symbol(s)
  { L"lsta",    (int)execute_lsta },    // list associations
  { L"lsth",    (int)execute_lsth },    // list history
  { L"lstk",    (int)execute_lstk },    // list keys
  { L"lstm",    (int)execute_lstm },    // list macros
  { L"lsts",    (int)execute_lsts },    // list symbols
  { L"rsta",    (int)execute_rsta },    // reset associations
  { L"rsth",    (int)execute_rsth },    // reset history
  { L"rstm",    (int)execute_rstm },    // reset macros
  { L"rsts",    (int)execute_rsts },    // reset symbols
};
#else
const IntFunc internal_funcs[] = {
  execute_defa,
  execute_defk,
  execute_defm,
  execute_defs,
  execute_dela,
  execute_delh,
  execute_delk,
  execute_delm,
  execute_dels,
  execute_lsta,
  execute_lsth,
  execute_lstk,
  execute_lstm,
  execute_lsts,
  execute_rsta,
  execute_rsth,
  execute_rstm,
  execute_rsts,
};

const Cfg internal[] = {
  { L"defa",     0 },
  { L"defk",     1 },
  { L"defm",     2 },
  { L"defs",     3 },
  { L"dela",     4 },
  { L"delh",     5 },
  { L"delk",     6 },
  { L"delm",     7 },
  { L"dels",     8 },
  { L"lsta",     9 },
  { L"lsth",    10 },
  { L"lstk",    11 },
  { L"lstm",    12 },
  { L"lsts",    13 },
  { L"rsta",    14 },
  { L"rsth",    15 },
  { L"rstm",    16 },
  { L"rsts",    17 },
};
#endif

//#define MIN_CMD_LEN 4
//#define MAX_CMD_LEN 4
#define CMD_LEN 4
#define INTERNAL_CMDS (lenof(internal))

#define DEFM	 L"DEFM> "              // prompt for defining a macro
#define DEFM_LEN 6
const WCHAR ENDM[] = L"endm";           // string used to end macro definition
#define ENDM_LEN 4


// Line manipulation

COORD line_to_scr( DWORD );		// convert line position to screen
void  set_display_marks( DWORD, DWORD ); // indicate positions to display
void  copy_chars( PCWSTR, DWORD );	// set line to string
void  remove_chars( DWORD, DWORD );	// remove characters from line
DWORD insert_chars( DWORD, PCWSTR, DWORD );	    // add string to line
DWORD replace_chars( DWORD, DWORD, PCWSTR, DWORD ); // replace string w/ another
char* get_key( PKey );			// read a key
WCHAR process_keypad( WORD );		// translate Alt+Keypad to character
void  edit_line( void );		// read and edit line from the keyboard
void  display_prompt( void );		// re-display the original prompt
void  remove_prompt( DWORD );		// wipe out the prompt


// Undo

UndoInfo  undo, redo;			// fixed head of each list
PUndoInfo undoing;			// pointer to the current list

void reset_undo( void );		// "erase" both lists
void add_to_undo( int, DWORD, DWORD );	// add an operation to the current list
BOOL undo_redo( PUndoInfo, int* );	// undo/redo a group


// Definitions (macro, symbol and association)

PDefine sym_head, mac_head, assoc_head; 	// heads of the various lists
PDefine macro_stk;				// stack of executing macros

PDefine add_define( PDefine*, DWORD, DWORD );	// add definition to list
PDefine find_define( PDefine*, DWORD, DWORD );	// find definition in list
PDefine find_assoc( PCWSTR, DWORD );		// find extension in list
void	del_define( PDefine* ); 		// delete definition from list
void	delete_define( PDefine*, DWORD );	// delete list of definitions
void	reset_define( PDefine* );		// wipe all definitions
void	list_define( PDefine, WCHAR );		// display a definition
void	list_defines( PDefine*, DWORD );	// display a list of definitions
PLineList add_line( DWORD );			// add a line to the line list
void	free_linelist( PLineList );		// free memory used by line list


// Line input

BOOL read_cmdfile( PCWSTR );		// read the file
BOOL get_file_line( BOOL );		// read the line from file
void get_next_line( void );		// get next line of input
void get_macro_line( BOOL );		// input coming from a macro
void pop_macro( void ); 		// macro finished, remove it from stack


// Line output

void multi_cmd( void ); 		// separate multiple commands
void dosify( void );			// convert UNIX-style command to Windows
BOOL brace_expansion( void );		// expand the first set of braces
void expand_braces( void );		// perform brace expansion
BOOL associate( void ); 		// perform filename association
BOOL expand_symbol( void );		// expand a symbol to its definition
BOOL expand_macro( void );		// expand a macro to its definition
BOOL internal_cmd( void );		// process internal command
void expand_vars( BOOL );		// expand environment vars and symbols


// History

History  history = { &history, &history, { 0 } }; // constant empty line
int	 histsize;				// number of lines in history
#define  HISTSIZE 1000				// restrict the file to this

PHistory new_history( PCWSTR, DWORD );		// allocate new history item
void	 remove_from_history( PHistory );	// remove item from history
void	 add_to_history( BOOL );		// add current line to history
PHistory search_history( PHistory, DWORD, BOOL ); // search history for match
PHistory find_history( PHistory, int*, DWORD, BOOL );
void	 copy_parent_history( void );		// initial history from parent


// Filename completion

PHistory fname; 		// list of found filenames and initial pattern
DWORD	 fname_pos, path_pos;	// position in line of start of filename/path
WCHAR	 dirchar = '\\';        // character to use for directory indicator
int	 fname_max, fname_cnt;	// longest name and number of names found
DWORD	 assoc_pos;		// position of the association within the list
PWCHAR	 flist; 		// open dialog filenames
#define  FLIST_LEN 2048 	// size of flist

BOOL match_file( PCWSTR, PCWSTR, DWORD, BOOL, BOOL, PHANDLE, PWIN32_FIND_DATA );
				// find a file, possibly matching its extension
int   find_files( int*, int );	// find matching files and common prefix
void  list_files( void );	// list all files
int   calc_lines( void );	// determine number of lines for the listing
BOOL  check_name_count( int );	// determine action to take for many files
BOOL  quote_needed( PCWSTR, int ); // should filename be quoted?
PWSTR make_filter( BOOL );	// make the open dialog filter string
void  make_relative( PWSTR, PWSTR ); // make an absolute path relative


// Utility

#define isword(  ch ) (IsCharAlphaNumeric( ch ) || \
		       (ch == '_' && option.underscore))
#define isblank( ch ) (ch == ' ' || ch == '\t')

int   search_cfg( PCWSTR, DWORD, const Cfg [], int ); // find config string
char* find_key( DWORD, DWORD ); 	// find the position of a key
PWSTR new_txt( PCWSTR, DWORD ); 	// make a copy of a string
BOOL  make_line( DWORD );		// ensure line is a particular length
BOOL  make_length( PWSTR*, DWORD*, DWORD );
void  bell( void );			// audible alert
DWORD skip_blank( DWORD );		// skip over spaces and tabs
DWORD skip_nonblank( DWORD );		// skip over everything not space/tab
DWORD skip_nondelim( DWORD );		// skip over everything not a delimiter
BOOL  is_quote( int );			// quote character?
DWORD get_string( DWORD, LPDWORD, BOOL ); // retrieve argument
void  un_escape( PCWSTR );		// remove the escape character
BOOL  match_ext( PCWSTR, DWORD, PCWSTR, DWORD ); // match extension in list
DWORD get_env_var( PCWSTR, PCWSTR );	// get environment variable
void  show_error( PCWSTR, DWORD, DWORD ); // show an internal command error
void  set_codepage( void );		// set output code page (for printf)
DWORD display_length( PCWSTR, DWORD, DWORD ); // get the display length for DBCS

UINT  codepage; 			// the output code page
BOOL  dbcs;				// is it DBCS?


// -------------------------   Line Manipulation   ---------------------------


// Convert line position to cursor position.
COORD line_to_scr( DWORD pos )
{
  COORD c;

  if (dbcs)
    pos = display_length( line.txt, line.len, pos );

  pos += screen.dwCursorPosition.X;
  c.X  = pos % screen.dwSize.X;
  c.Y  = pos / screen.dwSize.X + screen.dwCursorPosition.Y;

  return c;
}


// Set the beginning and ending positions to be displayed; end is after the
// position (ie. end - beg == number of characters).
void set_display_marks( DWORD beg, DWORD end )
{
  DWORD cell;

  if (beg < dispbeg)
    dispbeg = beg;
  if (end > dispend)
    dispend = end;

  if (dbcs)
  {
    if (end > line.len) // for the recording prompt
      cell = display_length( line.txt, line.len, beg ) + end - beg;
    else
      cell = display_length( line.txt, line.len, dispend );
    if (cell > cellend)
      cellend = cell;
  }
}


// Set the line to str, which is cnt characters.
void copy_chars( PCWSTR str, DWORD cnt )
{
  set_display_marks( 0, line.len );
  if (cnt > max)
  {
    bell();
    cnt = max;
  }
  memcpy( line.txt, str, WSZ(cnt) );
  line.len = cnt;
  set_display_marks( 0, line.len );
  reset_undo();
}


// Remove cnt characters starting from pos.
void remove_chars( DWORD pos, DWORD cnt )
{
  // Set the display mark for DBCS to the previous character, in order to
  // handle the possible case of a wrapped double-width character.
  set_display_marks( (dbcs && pos != 0) ? pos - 1 : pos, line.len );
  add_to_undo( UNDOINSERT, pos, cnt );
  memcpy( line.txt + pos, line.txt + pos + cnt, WSZ(line.len - pos - cnt) );
  line.len -= cnt;
}


// Insert string of cnt characters at pos.
DWORD insert_chars( DWORD pos, PCWSTR str, DWORD cnt )
{
  if (line.len + cnt > max)
  {
    bell();
    cnt = max - line.len;
  }
  memmove( line.txt + pos + cnt, line.txt + pos, WSZ(line.len - pos) );
  memcpy( line.txt + pos, str, WSZ(cnt) );
  line.len += cnt;
  set_display_marks( pos, line.len );
  add_to_undo( UNDODELETE, pos, cnt );
  return cnt;
}


// Replace old characters at pos with string of cnt characters.
DWORD replace_chars( DWORD pos, DWORD old, PCWSTR str, DWORD cnt )
{
  if (old >= cnt)
  {
    set_display_marks( pos, pos + cnt );
    if (old != cnt)
      remove_chars( pos + cnt, old - cnt );
    add_to_undo( UNDOINSERT, pos, cnt );
    memcpy( line.txt + pos, str, WSZ(cnt) );
    add_to_undo( UNDODELETE, pos, cnt );
  }
  else
  {
    set_display_marks( pos, pos + old );
    add_to_undo( UNDOINSERT, pos, old );
    add_to_undo( UNDODELETE, pos, old );
    memcpy( line.txt + pos, str, WSZ(old) );
    cnt = old + insert_chars( pos + old, str + old, cnt - old );
  }
  return cnt;
}


// Reset the undo/redo pointers, making empty lists.
void reset_undo()
{
  undo.prev = &undo;
  redo.prev = &redo;
  undoing = &undo;
}


// Add an operation to the current list, consolidating where possible.
void add_to_undo( int type, DWORD pos, DWORD len )
{
  PUndoInfo u;

  if (!undoing)
    return;

  u = undoing->prev;

  if (type == UNDOGROUP)
  {
    // UNDOGROUP is used to store the cursor position, so since movement is
    // not undone, the item can be reused.
    if (u->type == UNDOGROUP && u->prev != u)
    {
      u->pos = pos;
      return;
    }
  }
  else
  {
    if (len == 0)
      return;
    switch (u->type)
    {
      case UNDODELETE:
	switch (type)
	{
	  case UNDODELETE:
	    // Deleting after a previous delete increases it.  E.g.: typing the
	    // three characters "abc" combines to one three-character delete.
	    if (u->pos + u->len == pos)
	    {
	      u->len += len;
	      return;
	    }
	  break;

	  case UNDOINSERT:
	    // Inserting characters that just get deleted can be removed.  This
	    // occurs with file name completion.  E.g.: start with nothing and
	    // complete "123" (so undo deletes 3), then replace with "abc".
	    // Replace is insert (to restore "123") and delete (to remove
	    // "abc").  The first delete and second insert cancel each other
	    // out, leaving the second delete (delete "abc" to nothing).
	    if (pos == u->pos && len <= u->len)
	    {
	      u->len -= len;
	      if (u->len == 0)
		undoing->prev = u->prev;
	      return;
	    }
	    // Overwrite is insert+delete, so go back an extra one to increase
	    // the insert.  E.g.: overwrite "ab" with "12" - insert "a", delete
	    // "1", insert "b", delete "2".  Insert "a" becomes insert "ab" and
	    // then the two deletes combine as above to delete "12".
	    if (u->pos + u->len == pos && u->prev->type == UNDOINSERT &&
		u->prev->pos + u->prev->len == pos)
	    {
	      u = u->prev;
	      if (!make_length( &u->txt, &u->max, u->len + len ))
		return;
	      memcpy( u->txt + u->len, line.txt + pos, WSZ(len) );
	      u->len += len;
	      return;
	    }
	  break;
	}
      break;

      case UNDOINSERT:
	switch (type)
	{
	  case UNDOINSERT:
	    // Inserting at the same position (deleting "abc" from the front)
	    // combines into a single insert.
	    if (u->pos == pos)
	    {
	      if (!make_length( &u->txt, &u->max, u->len + len ))
		return;
	      memcpy( u->txt + u->len, line.txt + pos, WSZ(len) );
	      u->len += len;
	      return;
	    }
	    // Inserting before an insert (deleting "abc" from the end) shifts
	    // the insert to the new position and extends it.
	    if (pos + len == u->pos)
	    {
	      if (!make_length( &u->txt, &u->max, u->len + len ))
		return;
	      memmove( u->txt + len, u->txt, WSZ(u->len) );
	      memcpy( u->txt, line.txt + pos, WSZ(len) );
	      u->pos = pos;
	      u->len += len;
	      return;
	    }
	  break;
	}
      break;
    }
  }

  if (u->next == NULL)
  {
    PUndoInfo t = malloc( sizeof(UndoInfo) );
    if (t == NULL)
      return;
    t->txt = NULL;
    t->max = 0;
    t->prev = u;
    t->next = NULL;
    u->next = t;
  }
  undoing->prev = u = u->next;

  u->type = type;
  u->pos  = pos;
  u->len  = len;

  if (type == UNDOINSERT)
  {
    if (!make_length( &u->txt, &u->max, len ))
    {
      undoing->prev = u->prev;
      return;
    }
    memcpy( u->txt, line.txt + pos, WSZ(len) );
  }
}


// Perform a group of undo/redo operations, remembering the current position in
// pos and updating it.
BOOL undo_redo( PUndoInfo list, int* pos )
{
  PUndoInfo u = list->prev;

  if (u->prev == u)
    return FALSE;

  // If undoing, use the redo list to store the new undo operations.
  if (list == &undo)
    undoing = &redo;

  add_to_undo( UNDOGROUP, *pos, 0 );

  while (u->type != UNDOGROUP)
  {
    switch (u->type)
    {
      case UNDOINSERT:
	insert_chars( u->pos, u->txt, u->len );
      break;

      case UNDODELETE:
	if (u->prev->type == UNDOINSERT && u->prev->pos == u->pos)
	{
	  u = u->prev;
	  replace_chars( u->pos, u->next->len, u->txt, u->len );
	}
	else
	  remove_chars( u->pos, u->len );
      break;
    }
    u = u->prev;
  }
  *pos = u->pos;

  if (list == &undo)
    undoing = &undo;

  list->prev = u->prev;
  return TRUE;
}


#define VK rec.Event.KeyEvent.wVirtualKeyCode	// damn long identifiers


// Read a key from the keyboard, returning its keymap position and setting chfn
// to its character and function.
char* get_key( PKey chfn )
{
  static INPUT_RECORD rec;
  DWORD  read;
  int	 shift, ctrl, alt;
  char*  key = NULL;

  if (rec.Event.KeyEvent.wRepeatCount == 0)
  {
    do
    {
      ReadConsoleInput( hConIn, &rec, 1, &read );
      if (check_break > 1)
      {
	// Ignore the ^C that precedes it.
	--rec.Event.KeyEvent.wRepeatCount;
	check_break = 1;
	chfn->fn = Erase;
	return key;
      }
    } while (rec.EventType != KEY_EVENT || !rec.Event.KeyEvent.bKeyDown ||
	     VK == VK_SHIFT || VK == VK_CONTROL || VK == VK_MENU);
  }
  --rec.Event.KeyEvent.wRepeatCount;

  chfn->ch = rec.Event.KeyEvent.uChar.UnicodeChar;
  chfn->fn = Default;
  shift = !!(rec.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED);
  ctrl	= (rec.Event.KeyEvent.dwControlKeyState &
	   (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED));
  alt	= (rec.Event.KeyEvent.dwControlKeyState &
	   (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED));

  // Remap these keys to a more convenient location and use Shift+Ctrl instead
  // of Alt, due to Windows itself using that combination.
  switch (VK)
  {
    case VK_BACK:   VK = VK_DOWN+1; alt = (shift && ctrl); break;
    case VK_TAB:    VK = VK_DOWN+2; alt = (shift && ctrl); break;
    case VK_RETURN: VK = VK_DOWN+3; alt = (shift && ctrl); break;
    case VK_ESCAPE: VK = VK_DOWN+4; alt = (shift && ctrl); break;
  }

  if (VK >= VK_PRIOR && VK <= VK_DELETE)
  {
    alt = (alt) ? 3 : (ctrl) ? 2 : shift;
    key = &key_table[VK - VK_PRIOR][alt];
  }
  else if (VK >= VK_F1 && VK <= VK_F12)
  {
    alt = (alt) ? 3 : (ctrl) ? 2 : shift;
    key = &fkey_table[VK - VK_F1][alt];
  }
  else if (alt)
  {
    if (VK >= VK_NUMPAD0 && VK <= VK_NUMPAD9)
    {
      chfn->ch = process_keypad( VK );
    }
    else
    {
      WPARAM id = 0;
      switch (VK)
      {
	case 'C': id = 0xFFF2; break;  // Mark
	case 'F': id = 0xFFF4; break;  // Find...
	case 'S': id = 0xFFF3; break;  // Scroll
	case 'V': id = 0xFFF1; break;  // Paste
      }
      if (id)
      {
	SendMessage( GetForegroundWindow(), WM_COMMAND, id, 0 );
	chfn->fn = Ignore;
      }
    }
  }
  else if (chfn->ch == 0)
  {
    if (ctrl)
    {
      switch (VK)
      {
	case '2':                    break;     //       Ctrl+2 = ^@
	case 219: chfn->ch = 27;     break;	// Shift+Ctrl+[ = #^[
	case 220: chfn->ch = 28;     break;	// Shift+Ctrl+\ = #^\  //
	case 221: chfn->ch = 29;     break;	// Shift+Ctrl+] = #^]
	case '6': chfn->ch = 30;     break;     //       Ctrl+6 = ^^
	case 189: chfn->ch = 31;     break;	//	 Ctrl+- = ^_
	default:  chfn->fn = Ignore; break;
      }
      if (chfn->fn == Default)
	key = &ctrl_key_table[chfn->ch][shift];
    }
    else
      chfn->fn = Ignore;
  }
  else if (chfn->ch < 32)
  {
    key = &ctrl_key_table[chfn->ch][shift];
  }

  if (key)
    chfn->fn = *key;

  return key;
}


// Hook the keyboard to bypass Windows handling of Alt+Enter.

HHOOK  hKeyHook;
HANDLE event;

LRESULT CALLBACK KeyEvent( int nCode, WPARAM wParam, LPARAM lParam )
{
  if (nCode == HC_ACTION && wParam == WM_SYSKEYDOWN &&
      *(DWORD*)lParam == VK_RETURN)
  {
    // Signal the input loop we've found Alt+Enter and discard it.
    SetEvent( event );
    return 1;
  }

  return CallNextHookEx( hKeyHook, nCode, wParam, lParam );
}

DWORD msgloop( LPVOID param )
{
  MSG message;

  hKeyHook = SetWindowsHookEx( WH_KEYBOARD_LL, (HOOKPROC)KeyEvent,
			       GetModuleHandle( NULL ), 0 );
  GetMessage( &message, NULL, 0, 0 );
  UnhookWindowsHookEx( hKeyHook );

  return 0;
}


// Translate an Alt+Keypad sequence to a character.  If first is 0 treat the
// number as hexadecimal, using Divide, Multiply, Minus, Plus, Enter and Point
// as the hex digits A to F.  A decimal number below 256 will be taken as an
// OEM char, otherwise treat it as Unicode.
WCHAR process_keypad( WORD first )
{
  INPUT_RECORD rec;
  CHAR	 ch;
  WCHAR  wch;
  int	 num, base;
  HANDLE thread;
  DWORD  id;
  HANDLE objs[2];
  static const int vkdigit[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
				 0xB, 0xD, 0xE, 0xC, 0xF, 0xA };

  num  = first - VK_NUMPAD0;
  base = (num == 0) ? 16 : 10;
  if (base == 16)
  {
    thread = CreateThread( NULL, 4096, (LPTHREAD_START_ROUTINE)msgloop,
			   0, 0, &id );
    event = CreateEvent( NULL, FALSE, FALSE, L"jmhConsoleEvent" );
    objs[0] = hConIn;
    objs[1] = event;
  }
  else
    thread = 0; // just to quieten gcc

  for (;;)
  {
    if (base == 16)
    {
      DWORD obj = WaitForMultipleObjects( 2, objs, FALSE, INFINITE);
      if (obj == 1)
      {
	rec.EventType = KEY_EVENT;
	rec.Event.KeyEvent.bKeyDown = TRUE;
	VK = VK_SEPARATOR;
      }
      else
	ReadConsoleInput( hConIn, &rec, 1, &conwr );
    }
    else
      ReadConsoleInput( hConIn, &rec, 1, &conwr );
    if (rec.EventType == KEY_EVENT)
    {
      if (rec.Event.KeyEvent.bKeyDown == FALSE)
      {
	if (VK == VK_MENU)
	  break;
      }
      else if (VK >= VK_NUMPAD0 && VK <= VK_DIVIDE)
	num = num * base + vkdigit[VK - VK_NUMPAD0];
    }
  }
  if (base == 16)
  {
    PostThreadMessage( id, WM_USER, 0, 0 );
    WaitForSingleObject( thread, INFINITE );
    CloseHandle( thread );
    CloseHandle( event );
  }

  if (num < 256 && base == 10)
  {
    ch = num;
    MultiByteToWideChar( codepage, 0, &ch, 1, &wch, 1 );
  }
  else
    wch = num;

  return wch;
}


// Read and edit a line of input from the keyboard.
void edit_line( void )
{
  DWORD  imode, omode;			// original input & output modes
  CONSOLE_CURSOR_INFO cci, org_cci;	// current and original cursor size
  Key	 chfn, prev;			// character and function read
  PUndoInfo undo_here;			// to test if the line was modified
  char*  key;				// key read
  BOOL	 recording = FALSE;		// recording a keyboard macro?
  PMacro mac = NULL,  rec_mac = NULL;	// macro playing and recording
  DWORD  mac_pos = 0, rec_len = 0;	// position of playback, recording
  BOOL	 done = FALSE;			// done editing?
  int	 ovr = option.overwrite;	// insert/overwrite flag
  int	 pos = 0;			// position within the line
  int	 spos = 0, slen = 0;		// search prefix, find length
  int	 empty = 0;			// searching an empty line?
  int	 find = 0;			// incremental search direction
  int	 recall = option.auto_recall;	// is auto-recall active?
  int	 cont_recall = 1;		// should auto-recall remain active?
  BOOL	 failed = FALSE;		// did auto-recall fail to match?
  PHistory hist, shist; 		// position within history, of match
  PHistory fnp = NULL;			// list of completed filenames
  PWSTR  fnm;				// current filename
  int	 compl = 0, name = 0;		// filename completion flags
  BOOL	 quote, fnoq = FALSE, pq = FALSE; // filename quoting flags
  BOOL	 dir;				// filename is a directory
  DWORD  start, end, cnt;		// scratch variables
  int	 start1, cnt1;
  DWORD  markpos = ~0, markbeg = 0, markend = 0; // the selection positions
  BOOL	 keep_mark;
  DWORD  hlen;				// length of old command to hide

  GetConsoleScreenBufferInfo( hConOut, &screen );
  if (show_prompt)
    display_prompt();
  else
    show_prompt = TRUE;

  GetConsoleMode( hConIn,  &imode );
  GetConsoleMode( hConOut, &omode );
  SetConsoleMode( hConIn,  imode & ~0x1F );	// just keep the extended flags
  SetConsoleMode( hConOut, ENABLE_WRAP_AT_EOL_OUTPUT );

  GetConsoleCursorInfo( hConOut, &org_cci );
  cci.bVisible = TRUE;
  cci.dwSize   = option.cursor_size[ovr];
  SetConsoleCursorInfo( hConOut, &cci );

  hist = &history;
  done = FALSE;
  prev.ch = 0;
  prev.fn = Ignore;
  reset_undo();
  while (!done)
  {
    if (mac)
    {
      chfn = (mac->len == 1) ? mac->chfn : mac->func[mac_pos];
      if (++mac_pos == mac->len)
      {
	mac = NULL;
	mac_pos = 0;
      }
      key = NULL;
    }
    else
      key = get_key( &chfn );

    dispbeg = ~0;			// nothing to display
    dispend = cellend = hlen = 0;
    compl >>= 1;			// update state of completion
    name  >>= 1;
    empty >>= 1;			// update state of "empty" search
    if (!cont_recall)			// update state of incremental search
      find = slen = 0;
    recall &= cont_recall;		// update state of auto-recall
    cont_recall = 0;			//  and assume it shouldn't continue
    keep_mark = FALSE;			// remove the mark on non-movement

    // Undo repeated functions as one, but separate typed-in words.
    if (!(chfn.fn == prev.fn ||
	  (prev.fn == Cycle &&
	   (chfn.fn == CycleBack || chfn.fn == CycleDir ||
	    chfn.fn == CycleDirBack))) ||
	(chfn.fn == Default && isword( chfn.ch ) && !isword( prev.ch )))
      add_to_undo( UNDOGROUP, pos, 0 );
    undo_here = undo.prev;

    switch (chfn.fn)
    {
      case Ignore:
	cont_recall = 1;
	keep_mark = TRUE;
      break;

      case Quote:
	get_key( &chfn );
	chfn.fn = Default;

      case Default:
	if (chfn.ch == 0)		// disallow NULs
	{
	  bell();
	  chfn.fn = Ignore;
	}
      break;

      case CharLeft:
	if (pos > 0)
	  --pos;
	keep_mark = TRUE;
      break;

      case CharRight:
	if (pos < line.len)
	  ++pos;
	keep_mark = TRUE;
      break;

      case WordLeft:
	keep_mark = TRUE;

      case DelWordLeft:
	if (pos > 0)
	{
	  start = pos;
	  while (--pos >= 0 && !isword( line.txt[pos] )) ;
	  while (pos >= 0 && isword( line.txt[pos] ))
	    --pos;
	  ++pos;
	  if (chfn.fn == DelWordLeft)
	    remove_chars( pos, start - pos );
	}
      break;

      case WordRight:
	keep_mark = TRUE;

      case DelWordRight:
	if (pos < line.len)
	{
	  start = pos;
	  while (pos < line.len && isword( line.txt[pos] ))
	    ++pos;
	  while (pos < line.len && !isword( line.txt[pos] ))
	    ++pos;
	  if (chfn.fn == DelWordRight)
	  {
	    remove_chars( start, pos - start );
	    pos = start;
	  }
	}
      break;

      case EndWordLeft:
	keep_mark = TRUE;
	if (pos > 0)
	{
	  while (--pos >= 0 && isword( line.txt[pos] )) ;
	  if (pos < 0)
	  {
	    pos = 0;
	    break;
	  }
	  while (--pos >= 0 && !isword( line.txt[pos] )) ;
	  ++pos;
	}
      break;

      case EndWordRight:
	keep_mark = TRUE;
	if (pos < line.len)
	{
	  while (!isword( line.txt[pos] ) && ++pos < line.len) ;
	  if (pos == line.len)
	    break;
	  while (++pos < line.len && isword( line.txt[pos] )) ;
	}
      break;

      case StringLeft:
	if (pos > 0)
	{
	  while (--pos >= 0 && isblank( line.txt[pos] )) ;
	  while (pos >= 0 && !isblank( line.txt[pos] ))
	    --pos;
	  ++pos;
	}
	keep_mark = TRUE;
      break;

      case StringRight:
	pos = skip_nonblank( pos );
	pos = skip_blank( pos );
	keep_mark = TRUE;
      break;

      case BegLine:
	pos = 0;
	keep_mark = TRUE;
      break;

      case EndLine:
	pos = line.len;
	keep_mark = TRUE;
      break;

      case Select:
	if (markpos != ~0)
	{
	  set_display_marks( markbeg, markend );
	  break;
	}
	if (line.len == 0)
	  break;
	if (pos == line.len)
	  --pos;
	markpos = pos;
	keep_mark = TRUE;
      break;

      case DelLeft:
	if (markpos != ~0)
	{
	  remove_chars( pos = markbeg, markend - markbeg );
	  break;
	}
	if (pos > 0)
	{
	  --pos;
	  if (find && slen)
	  {
	    if (--slen == 0)
	      break;
	  }
	  else
	  {
	    if (!recall || failed)
	      remove_chars( pos, 1 );
	    else if (pos == 0)
	    {
	      set_display_marks( 0, line.len );
	      line.len = 0;
	    }
	    if (pos == 0)
	      failed = FALSE;
	  }
	}
	cont_recall = 1;
      break;

      case DelRight:
	if (markpos != ~0)
	{
	  remove_chars( pos = markbeg, markend - markbeg );
	  break;
	}
	if (pos < line.len)
	  remove_chars( pos, 1 );
      break;

      case Cut:
	if (markpos != ~0)
	{
	  start = markbeg;
	  end	= markend;
	  goto do_cut;
	}

      case DelArg:
	end = 0;
	do
	{
	  start = get_string( end, &cnt, TRUE );
	  end	= skip_blank( start + cnt );
	} while (end <= pos && end < line.len);

	if (chfn.fn == Cut)
	{
      do_cut:
	  if (selected.txt)
	    free( selected.txt );
	  selected.len = end - start;
	  selected.txt = new_txt( line.txt + start, selected.len );
	  if (selected.txt == NULL)
	    selected.len = 0;
	}
	remove_chars( pos = start, end - start );
      break;

      case DelBegLine:
	remove_chars( 0, pos );
	pos = 0;
      break;

      case DelEndLine:
	remove_chars( pos, line.len - pos );
      break;

      case UpdateErase:
	if ((line.len == 0 || *line.txt != option.update_char) &&
	    hist != &history)
	  remove_from_history( hist );
	goto store_erase;

      case StoreErase:
	if (line.len != 0 && *line.txt == option.update_char &&
	    hist != &history)
	  remove_from_history( hist );
      store_erase:
	add_to_history( TRUE );
	hist = &history;

      case Erase:
	set_display_marks( 0, line.len );
	pos = line.len = 0;
	cont_recall = 1;
	find = slen = 0;
	hist = &history;
	reset_undo();
      break;

      case DelEndExec:
	remove_chars( pos, line.len - pos );
	goto accept_line;

      case UpdateEnter:
	if ((line.len == 0 || *line.txt != option.update_char) &&
	    hist != &history)
	  remove_from_history( hist );
	goto accept_line;

      case Enter:
	if (line.len != 0 && *line.txt == option.update_char &&
	    hist != &history)
	  remove_from_history( hist );
      accept_line:
	add_to_history( TRUE );
	done = TRUE;
      break;

      case Execute:
	// If editing a previous line, move that to the front.
	if (hist != &history)
	{
	  Line temp = line;
	  line.txt = hist->line;
	  line.len = hist->len;
	  add_to_history( TRUE );
	  line = temp;
	}
	done = TRUE;
      break;

      case Hidden:
	if (line.len != 0 && *line.txt == option.update_char &&
	    hist != &history)
	  remove_from_history( hist );
	add_to_history( TRUE );

      case HiddenEx:
	hidden_cmd = TRUE;

      case Wipe:
      {
	DWORD len = display_length( line.txt, line.len, line.len );
	FillConChar( hConOut, ' ', len, screen.dwCursorPosition );
	if (!option.nocolour)
	  FillConAttr( hConOut,screen.wAttributes,len,screen.dwCursorPosition );
	done = TRUE;
      }
      break;

      case Transpose:
	if (line.len >= 2)
	{
	  WCHAR tmp[2];
	  start = (pos == 0) ? 0 : (pos == line.len) ? pos - 2 : pos - 1;
	  tmp[0] = line.txt[start+1];
	  tmp[1] = line.txt[start];
	  replace_chars( start, 2, tmp, 2 );
	}
      break;

      case SwapWords:
	cnt = pos;
	if (cnt < line.len && isword( line.txt[cnt] ))
	{
	  start = pos;
	  while (++cnt < line.len && isword( line.txt[cnt] )) ;
	}
	else
	{
	  while ((int)--cnt >= 0 && !isword( line.txt[cnt] )) ;
	  start = ++cnt;
	}
	while ((int)--start >= 0 && isword( line.txt[start] )) ;
	++start;
	cnt1 = start;
	while (--cnt1 >= 0 && !isword( line.txt[cnt1] )) ;
	if (++cnt1 == 0)
	{
	  start1 = start;
	  cnt1 = cnt;
	  start = cnt;
	  while (++start < line.len && !isword( line.txt[start] )) ;
	  if (start >= line.len)
	    break;
	  cnt = start;
	  while (++cnt < line.len && isword( line.txt[cnt] )) ;
	}
	else
	{
	  start1 = cnt1;
	  while (--start1 >= 0 && isword( line.txt[start1] )) ;
	  ++start1;
	}
	cnt1 -= start1;
	cnt -= start;
	goto do_swap;

      case SwapArgs:
	end = 0;
	start = ~0;
	do
	{
	  start1 = start;
	  cnt1	= cnt;
	  start = get_string( end, &cnt, TRUE );
	  end	= skip_blank( start + cnt );
	} while (end < line.len && (end <= pos || start1 == ~0));
	if (start1 == ~0 || start >= line.len)
	  break;
      do_swap:
	fnm = new_txt( line.txt + start, cnt );
	if (!fnm)
	  break;
	replace_chars( start, cnt, line.txt + start1, cnt1 );
	replace_chars( start1, cnt1, fnm, cnt );
	free( fnm );
	// Maintain the same relative position.
	if (pos == start1 || pos >= start + cnt - 1)
	{
	  // At the start of the first, or at or beyond the end of the second -
	  // no change.
	}
	else if (pos >= start1 + cnt1 - 1 && pos <= start)
	{
	  // Between the end of the first and start of the second - point to
	  // the same character.
	  pos += cnt - cnt1;
	}
	else if (pos > start)
	{
	  // Within the second - find same position within the first.
	  pos = start + cnt - cnt1 + cnt1 * (pos - start) / cnt;
	}
	else
	{
	  // Within the first - find same position within the second.
	  pos = start1 + cnt * (pos - start1) / cnt1;
	}
      break;

      case Undo:
	// If we haven't done anything yet, ignore the group.
	if (undo.prev->type == UNDOGROUP)
	  undo.prev = undo.prev->prev;
	if (!undo_redo( &undo, &pos ))
	  bell();
      break;

      case Redo:
	if (!undo_redo( &redo, &pos ))
	  bell();
      break;

      case Revert:
	if ((prev.fn == Revert && undo.prev == &undo) || prev.fn == Undo)
	  while (undo_redo( &redo, &pos )) ;
	else
	  while (undo_redo( &undo, &pos )) ;
      break;

      case FirstLine:
	hist = history.next;
	goto hist_line;

      case LastLine:
	hist = history.prev;
	goto hist_line;

      case PrevLine:
	hist = hist->prev;
	goto hist_line;

      case NextLine:
	hist = hist->next;
	goto hist_line;

      case SearchBack:
      case SearchForw:
	if (option.empty_hist)
	{
	  empty |= 2;
	  if (empty == 2)
	    spos = pos;
	  else
	    pos = spos;
	}
	shist = search_history( hist, pos, (chfn.fn == SearchBack) );
	if (shist == NULL)
	{
	  bell();
	  break;
	}
	hist = shist;
	recall = option.auto_recall;
	cont_recall = 1;

      hist_line:
	copy_chars( hist->line, hist->len );
	if ((chfn.fn != SearchBack && chfn.fn != SearchForw) || (empty & 2))
	  pos = line.len;
      break;

      case FindBack:
      case FindForw:
	find = (chfn.fn == FindBack) ? -1 : 1;
	if (slen == 0)
	  slen = pos;
	if (slen)
	{
	  shist = find_history( (find == -1) ? hist->prev : hist->next,
				&pos, slen, (find == -1) );
	  if (shist == NULL)
	    bell();
	  else
	  {
	    hist = shist;
	    copy_chars( hist->line, hist->len );
	  }
	}
	cont_recall = 1;
      break;

      case CopyFromPrev:
	if (history.prev->len > pos)
	{
	  replace_chars( pos, line.len - pos,
			 history.prev->line + pos, history.prev->len - pos );
	}
      break;

      case List:		// name is  2 for new name completion
      case Cycle:		//	    3 for continuing name
      case CycleBack:		//	    0 for new & continuing directory
	name |= 2;		//	    1 for directory after name
				//	    2 for name after directory
      case ListDir:
      case CycleDir:		// compl is 2 for for new completion
      case CycleDirBack:	//	    3 for continuing it
	compl |= 2;
	start = -1;		// assume no prefix
	if (compl == 2 || name == 1 || name == 2)
	{
	  start = pos;		// prefix was added if pos moves
	  if ((end = find_files( &pos, !(name & 2) )) == -1)
	  {
	    compl = 0;
	    bell();
	    break;
	  }
	  fnoq = pq = FALSE;
	  if (found_quote)
	    fnoq = pq = TRUE, --path_pos;
	  else
	  {
	    // Check if one of the characters after the prefix needs quoting.
	    for (fnp = fname->next; fnp != fname; fnp = fnp->next)
	    {
	      if (fnp->flen > end && quote_needed( fnp->line + end, 1 ))
	      {
		pq = TRUE;
		break;
	      }
	    }
	  }
	  fnp = fname;
	  fnm = fname->next->line;
	  if (fname_cnt == 1 || end == -2 ||
	      chfn.fn == CycleBack || chfn.fn == CycleDirBack)
	  {
	    if (fname_cnt == 1)
	      compl = 0;
	    else if (chfn.fn == List || chfn.fn == ListDir)
	    {
	      list_files();
	      break;
	    }
	    if (chfn.fn == CycleBack || chfn.fn == CycleDirBack)
	    {
	      fnp = fname->prev;
	      fnm = fnp->line;
	    }
	    else
	      fnp = fname->next;
	    end = fnp->flen;
	    start = -1; 		// no prefix when immediately completed
	  }
	}
	else if (chfn.fn == List || chfn.fn == ListDir)
	{
	  list_files();
	  break;
	}
	else
	{
	  if (chfn.fn == Cycle || chfn.fn == CycleDir)
	    fnp = fnp->next;
	  else // (chfn.fn == CycleBack || chfn.fn == CycleDirBack)
	    fnp = fnp->prev;
	  if (fnp == fname)
	    bell();
	  fnm = fnp->line;
	  end = fnp->flen;
	}
	quote = (pq || quote_needed( fnm, end ));
	if (quote && !fnoq)
	{
	  pos += insert_chars( path_pos, L"\"", 1 );
	  ++fname_pos;
	  fnoq = TRUE;
	}
	else if (!quote && fnoq)
	{
	  remove_chars( path_pos, 1 );
	  --fname_pos;
	  --pos;
	  fnoq = FALSE;
	}
	dir = (end != 0 && fnm[end-1] == dirchar);
	if (dir && option.no_slash)
	  --end;
	pos = fname_pos + replace_chars( fname_pos, pos - fname_pos, fnm, end );
	if (!dir && fnp != fname)
	  pos += insert_chars( pos, L"\" " + 1 - quote, quote + 1 );
	// Create a separate group for the prefix.
	if (compl == 2 && start != -1 && start != pos)
	  add_to_undo( UNDOGROUP, pos, 0 );
      break;

      case SelectFiles:
	flist = malloc( FLIST_LEN*2 );
	if (flist == NULL)
	  break;
	if (find_files( &pos, -1 ))
	{
	  PWCHAR p = flist + fname_pos;
	  WCHAR  path[MAX_PATH];
	  int	 d, dq, f, q;
	  if (found_quote)
	    --path_pos;
	  remove_chars( path_pos, pos - path_pos );
	  pos = path_pos;
	  make_relative( flist, path );
	  d = wcslen( path );
	  dq = q = quote_needed( path, d );
	  while (*p)
	  {
	    f = wcslen( p );
	    if (dq || (q = quote_needed( p, f )))
	      insert_chars( pos++, L"\"", 1 );
	    pos += insert_chars( pos, path, d );
	    pos += insert_chars( pos, p, f );
	    pos += insert_chars( pos, L"\" " + 1 - q, q + 1 );
	    p += f + 1;
	  }
	}
	free( flist );
      break;

      case CmdSep:
	chfn.ch = CMDSEP;
	chfn.fn = Default;
      break;

      case AutoRecall:
	option.auto_recall ^= 1;
	recall = option.auto_recall;
	cont_recall = 1;
      break;

      case MacroToggle:
	option.disable_macro ^= 1;
      break;

      case UnderToggle:
	option.underscore ^= 1;
	keep_mark = TRUE;
      break;

      case InsOvr:
	ovr ^= 1;
	cci.dwSize = option.cursor_size[ovr];
	SetConsoleCursorInfo( hConOut, &cci );
	keep_mark = TRUE;
      break;

      case Play:
	mac = find_macro( key );
	if (mac && mac->type != MAC_FUNC)
	{
	  // If it's hidden, remove the old line, without displaying the new.
	  if (mac->type == MAC_HIDDEN)
	    hlen = display_length( line.txt, line.len, line.len );
	  copy_chars( (mac->len == 1) ? &mac->chfn.ch : mac->line, mac->len );
	  if (mac->type == MAC_HIDDEN)
	  {
	    hidden_cmd = TRUE;
	    dispbeg = dispend = 0;
	  }
	  done = TRUE;
	}
      break;

      case Record:
	if (recording)
	  break;
	if (!option.nocolour)
	  SetConsoleTextAttribute( hConOut, option.rec_col );
	set_display_marks( pos,
			   pos + wprintf( L" * Press key for recording * " ) );
	if (!option.nocolour)
	  SetConsoleTextAttribute( hConOut, screen.wAttributes );
	key = get_key( &chfn );
	chfn.fn = Ignore;
	if (key != NULL && *key != Erase && *key != Enter && *key != Record)
	{
	  rec_mac = add_macro( key );
	  if (rec_mac)
	  {
	    recording = TRUE;
	    rec_len = 0;
	    *key = Record;
	    set_display_marks( 0, line.len );
	  }
	}
      break;

      case Paste:
	if (selected.len)
	{
	  if (markpos != ~0)
	  {
	    pos = markbeg + replace_chars( markbeg, markend - markbeg,
					   selected.txt, selected.len );
	  }
	  else if (ovr)
	  {
	    cnt = selected.len;
	    if (pos + cnt > line.len)
	      cnt = line.len - pos;
	    pos += replace_chars( pos, cnt, selected.txt, selected.len );
	  }
	  else
	    pos += insert_chars( pos, selected.txt, selected.len );
	}
      break;

      case VarSubst:
	expand_braces();
	expand_vars( TRUE );
	associate();
	if (expand_macro())
	  while (macro_stk)
	    get_macro_line( FALSE );
	expand_symbol();
	pop_macro();
	pos = line.len;
      break;
    }
    prev = chfn;
    // These are the same as far as undo is concerned.
    if (chfn.fn == CycleBack || chfn.fn == CycleDir || chfn.fn == CycleDirBack)
      prev.fn = Cycle;

    if (recording)
    {
      if (chfn.fn == Record)
      {
	recording = FALSE;
      }
      else if (chfn.fn == DelLeft && rec_mac->len > 0 &&
	       rec_mac->func[rec_mac->len-1].fn == Default)
      {
	--rec_mac->len;
      }
      else if (chfn.fn != Ignore)
      {
	if (rec_mac->len == rec_len)
	{
	  PKey k = realloc( rec_mac->func, (rec_len + 10) * sizeof(Key) );
	  if (k == NULL)
	    recording = FALSE;
	  else
	  {
	    rec_mac->func = k;
	    rec_len += 10;
	  }
	}
	if (recording)
	{
	  rec_mac->func[rec_mac->len++] = chfn;
	  if (done)
	    recording = FALSE;
	}
      }
      if (!recording)
      {
	end_macro( rec_mac );
	set_display_marks( 0, line.len );
      }
    }

    if (chfn.fn == Default)
    {
      if (ovr || recall || find)
      {
	if (pos != max)
	{
	  set_display_marks( pos, pos + 1 );
	  if (pos == line.len)
	  {
	    ++line.len;
	    add_to_undo( UNDODELETE, pos, 1 );
	  }
	  else
	  {
	    add_to_undo( UNDOINSERT, pos, 1 );
	    add_to_undo( UNDODELETE, pos, 1 );
	  }
	}
      }
      else if (line.len < max)
      {
	memmove( line.txt + pos + 1, line.txt + pos, WSZ(line.len - pos) );
	set_display_marks( pos, ++line.len );
	add_to_undo( UNDODELETE, pos, 1 );
      }
      if (dispend)
      {
	line.txt[pos++] = chfn.ch;
	slen++;
	if (find)
	{
	  shist = find_history( hist, &pos, slen, (find == -1) );
	  if (shist == NULL)
	  {
	    --pos;
	    --slen;
	    if (pos < hist->len)
	      line.txt[pos] = hist->line[pos];
	    bell();
	  }
	  else
	  {
	    hist = shist;
	    copy_chars( hist->line, hist->len );
	  }
	  cont_recall = 1;
	}
	else if (recall)
	{
	  shist = search_history( hist->next, pos, TRUE );
	  if (shist == NULL)
	  {
	    set_display_marks( pos, line.len );
	    line.len = pos;
	    if (!failed)
	    {
	      failed = TRUE;
	      cont_recall = 1;
	    }
	    else
	      failed = FALSE;
	  }
	  else
	  {
	    hist = shist;
	    copy_chars( hist->line, hist->len );
	    cont_recall = 1;
	    failed = FALSE;
	  }
	}
      }
      else
	bell();
    }
    // Reset the redo if the line was modified normally.
    if (undo.prev != undo_here &&
	chfn.fn != Undo && chfn.fn != Redo && chfn.fn != Revert)
      redo.prev = &redo;

    if (!keep_mark)
      markpos = ~0;
    else if (markpos != ~0)
    {
      if (pos == markpos)
      {
	markbeg = pos;
	markend = pos + 1;
      }
      else if (pos < markpos)
      {
	markbeg = pos;
	markend = markpos + 1;
      }
      else
      {
	markbeg = markpos;
	markend = pos;
      }
      set_display_marks( markbeg, markend );
    }
    if (dispbeg == ~0)
      dispbeg = 0;

    cnt = dispend - dispbeg;
    if (cnt)
    {
      COORD c, e;
      int len = line.len - dispbeg;
      if (len > 0)
      {
	// Force a scroll if the line extends beyond the console buffer.
	e = line_to_scr( dispbeg + len );
	if (e.Y >= screen.dwSize.Y)
	{
	  SMALL_RECT src;
	  COORD dst;
	  CHAR_INFO fill;
	  src.Top = e.Y - screen.dwSize.Y + 1;
	  src.Bottom = screen.dwSize.Y - 1;
	  src.Left = 0;
	  src.Right = screen.dwSize.X - 1;
	  dst.X = dst.Y = 0;
	  fill.Char.UnicodeChar = ' ';
	  fill.Attributes = screen.wAttributes;
	  ScrollConsoleScreenBuffer( hConOut, &src, NULL, dst, &fill );
	  screen.dwCursorPosition.Y -= src.Top;
	  e.Y = screen.dwSize.Y - 1;
	}
	else if (e.Y != screen.dwCursorPosition.Y)
	{
	  CONSOLE_SCREEN_BUFFER_INFO csbi;
	  GetConsoleScreenBufferInfo( hConOut, &csbi );
	  if (e.Y > csbi.srWindow.Bottom)
	  {
	    screen.srWindow = csbi.srWindow;
	    screen.srWindow.Top    += e.Y - screen.srWindow.Bottom;
	    screen.srWindow.Bottom += e.Y - screen.srWindow.Bottom;
	    SetConsoleWindowInfo( hConOut, TRUE, &screen.srWindow );
	  }
	}

	c = line_to_scr( dispbeg );
	SetConsoleCursorPosition( hConOut, c );
	// The Unicode version will not write control characters using a
	// TrueType font, so remap them to their Unicode code point.
	// However, it seems DBCS will write control characters using either
	// font, but the raster font will not write the Unicode glyphs.
	if (dbcs)
	{
	  // If the line wraps, place a space at each edge, on the odd chance
	  // a double-width character gets shifted.  I would have thought
	  // console output itself did this, but apparently not.
	  if (e.Y > c.Y)
	  {
	    e.X = screen.dwSize.X - 1;
	    do
	    {
	      --e.Y;
	      FillConChar( hConOut, ' ', 1, e );
	    } while (e.Y != c.Y);
	  }
	  WriteCon( hConOut, line.txt + dispbeg, len );
	}
	else
	{
	  for (start = end = 0; end < len; ++end)
	  {
	    if (line.txt[dispbeg+end] < 32)
	    {
	      if (end > start)
		WriteCon( hConOut, line.txt + dispbeg + start, end - start );
	      start = end + 1;
	      WriteCon( hConOut, ControlChar + line.txt[dispbeg+end], 1 );
	    }
	  }
	  WriteCon( hConOut, line.txt + dispbeg + start, end - start );
	  cnt -= len;
	}
	if (!option.nocolour)
	{
	  FillConAttr( hConOut, (WORD)((recording) ? option.rec_col
						   : option.cmd_col),
		       (dbcs) ? display_length( line.txt, line.len, line.len )
				- display_length( line.txt, line.len, dispbeg )
			      : len, c );
	  if (markpos != ~0)
	  {
	    FillConAttr( hConOut, option.sel_col,
			 (dbcs) ? display_length( line.txt, line.len, markend )
				  - display_length( line.txt,line.len,markbeg )
				: markend - markbeg, line_to_scr( markbeg ) );
	  }
	}
      }
      if (dbcs)
      {
	cnt = cellend - display_length( line.txt, line.len, line.len );
	if ((int)cnt < 0)
	  cnt = 0;
      }
      if (cnt)
      {
	c = line_to_scr( line.len );
	FillConChar( hConOut, ' ', cnt, c );
	if (!option.nocolour)
	  FillConAttr( hConOut, screen.wAttributes, cnt, c );
      }
    }

    if (!hidden_cmd)
      SetConsoleCursorPosition( hConOut,
				(chfn.fn == Wipe) ? screen.dwCursorPosition
				: line_to_scr( (done) ? line.len : pos ) );
  }
  undoing = NULL;

  SetConsoleCursorInfo( hConOut, &org_cci );
  SetConsoleMode( hConOut, omode );
  // See if the user has changed QuickEdit or Insert modes.
  GetConsoleMode( hConIn,  &omode );
  if ((omode & ENABLE_QUICK_EDIT_MODE) ^ (imode & ENABLE_QUICK_EDIT_MODE))
    imode ^= ENABLE_QUICK_EDIT_MODE;
  if ((omode & ENABLE_INSERT_MODE) ^ (imode & ENABLE_INSERT_MODE))
    imode ^= ENABLE_INSERT_MODE;
  SetConsoleMode( hConIn,  imode );

  if (hidden_cmd)
  {
    remove_prompt( hlen );
  }
  else if ((display_length( line.txt, line.len, line.len )
	    + screen.dwCursorPosition.X) % screen.dwSize.X)
  {
    WriteCon( hConOut, L"\n", 1 );
  }

  if (line.len != 0 && *line.txt == option.update_char)
    remove_chars( 0, 1 );
}


// Display the user's prompt.
void display_prompt( void )
{
  if (kbd)
  {
    WriteCon( hConOut, L"\n", 1 );
    WriteCon( hConOut, prompt.txt, prompt.len );
    GetConsoleScreenBufferInfo( hConOut, &screen );
    if (p_attr_len != 0)
    {
      COORD c;
      c.X = 0;
      c.Y = screen.dwCursorPosition.Y - p_attr_len / screen.dwSize.X;
      WriteConsoleOutputAttribute( hConOut, p_attr, p_attr_len, c, &conwr );
    }
  }
}


// Remove the user's prompt (and command).
void remove_prompt( DWORD extra )
{
  if (erase_prompt == 2)
  {
    DWORD erase_len;			// how much to remove
    COORD erase_coord;			// where the prompt starts
    CONSOLE_SCREEN_BUFFER_INFO csbi;

    if (p_attr_len != 0)
      erase_len = p_attr_len;
    else
    {
      // Output the prompt on the other buffer to see how long it is.
      if (dbcs)
	SetConsoleMode( hConWid, ENABLE_PROCESSED_OUTPUT |
				 ENABLE_WRAP_AT_EOL_OUTPUT );
      erase_coord.X = erase_coord.Y = 0;
      SetConsoleCursorPosition( hConWid, erase_coord );
      WriteCon( hConWid, prompt.txt, prompt.len );
      if (dbcs)
	SetConsoleMode( hConWid, ENABLE_WRAP_AT_EOL_OUTPUT );
      GetConsoleScreenBufferInfo( hConWid, &csbi );
      erase_len = csbi.dwCursorPosition.Y * csbi.dwSize.X
		  + csbi.dwCursorPosition.X;
    }
    erase_coord.X = 0;
    erase_coord.Y = screen.dwCursorPosition.Y - erase_len / screen.dwSize.X;
    erase_len += extra;
    FillConChar( hConOut, ' ', erase_len, erase_coord );
    FillConAttr( hConOut, screen.wAttributes, erase_len, erase_coord );

    // Restore the position prior to writing it.
    lastc.Y = erase_coord.Y - 1;
    SetConsoleCursorPosition( hConOut, (hidden_cmd) ? erase_coord : lastc );

    erase_prompt = 0;
  }
}


// ------------------------------   History   --------------------------------


// Allocate a new history line (does not set the previous and next pointers).
PHistory new_history( PCWSTR txt, DWORD len )
{
  PHistory h;

  h = malloc( sizeof(History) + WSZ(len) );
  if (h)
  {
    memcpy( h->line, txt, WSZ(len) );
    h->len = len;
  }

  return h;
}


// Remove the item from the history.  Should not be the history itself.
void remove_from_history( PHistory h )
{
  h->prev->next = h->next;
  h->next->prev = h->prev;
  free( h );
  --histsize;
}


// Add the line to the history.  If search is true and the line already exists
// (matched case sensitively), just move it to the front.
void add_to_history( BOOL search )
{
  PHistory h;

  if (line.len < option.min_length)	// line is too small to be remembered
    return;

  h = &history;
  if (search)
    while ((h = h->prev) != &history)
      if (h->len == line.len && memcmp( h->line, line.txt, WSZ(line.len) ) == 0)
	break;

  if (h == &history)			// not already present
  {
    if (option.histsize && histsize == option.histsize)
      remove_from_history( history.next ); // too many lines, remove the first
    h = new_history( line.txt, line.len );
    if (!h)
      return;
    ++histsize;
  }
  else
  {
    h->prev->next = h->next;		// found it, so relocate it
    h->next->prev = h->prev;
  }
  h->prev = history.prev;		// make it the last line
  h->next = &history;
  history.prev->next = h;
  history.prev = h;
}


// Find the first len characters of the line in the history (ignoring case).
// back is TRUE to search backwards (most recent lines first).	Search starts
// from the line /after/ hist.	Return a pointer to the matching history, or
// NULL if not found.
PHistory search_history( PHistory hist, DWORD len, BOOL back )
{
  PHistory h;
  BOOL	 fnd;

  h = hist;
  do
  {
    h	= (back) ? h->prev : h->next;
    fnd = (h->len >= len && _wcsnicmp( h->line, line.txt, len ) == 0);
  } while (!fnd && h != hist);

  return (fnd) ? h : NULL;
}


// Find the len characters before pos of the line in the history (ignoring
// case).  back is TRUE to search backwards (most recent lines first).	Search
// starts from hist.  Return a pointer to the matching history, setting pos to
// the position in the new line, or NULL if not found.
PHistory find_history( PHistory hist, int* pos, DWORD len, BOOL back )
{
  PHistory h;
  PCWSTR txt;
  WCHAR  c;
  DWORD  p;

  p = *pos - len;
  txt = line.txt + p;
  c = towlower( *txt );
  h = hist;
  for (;;)
  {
    for (p = 0; p + len <= h->len; ++p)
    {
      if (c == towlower( h->line[p] ) &&
	  _wcsnicmp( txt + 1, h->line + p + 1, len - 1 ) == 0)
      {
	*pos = p + len;
	return h;
      }
    }
    h = (back) ? h->prev : h->next;
    if (h == hist)
      return NULL;
  }
}


// Create the initial history from the parent or primary process' history.
void copy_parent_history( void )
{
  HANDLE   parent;
  int	   version;
  History  hist;
  PHistory cur;

  parent = OpenProcess( PROCESS_VM_READ, FALSE, parent_pid );
  if (!parent ||
      !ReadProcessMemory( parent, &local, &version, sizeof(int), NULL ) ||
      version != PVERX)
  {
    CloseHandle( parent );
    parent = OpenProcess( PROCESS_VM_READ, FALSE, primary_id );
    if (!parent)
      return;
    if (!ReadProcessMemory( parent, &local, &version, sizeof(int), NULL ) ||
	version != PVERX)
    {
      CloseHandle( parent );
      return;
    }
  }

  make_line( 0 );
  ReadProcessMemory( parent, &history, &hist, sizeof(History), NULL );
  while (hist.next != &history)
  {
    cur = hist.next;
    ReadProcessMemory( parent, cur, &hist, sizeof(History), NULL );
    if (!make_line( hist.len ))
      break;
    ReadProcessMemory( parent, &cur->line, line.txt, WSZ(line.len), NULL );
    add_to_history( FALSE );
  }
  make_line( ~0 );

  CloseHandle( parent );
}


// Write the history to file.  Since editing this file is not really needed,
// keep it simple and write it as binary.
void write_history( void )
{
  PHistory h;

  FILE* file = _wfopen( local.hstname, L"wb" );
  if (file == NULL)
    return;

  for (h = history.next; h != &history; h = h->next)
  {
    if (--histsize < HISTSIZE)
    {
      fwrite( &h->len, 2, 1, file );
      fwrite( h->line, WSZ(h->len), 1, file );
    }
  }
  fclose( file );
}


void read_history( void )
{
  FILE* file = _wfopen( local.hstname, L"rb" );
  if (file == NULL)
    return;

  make_line( 0 );
  while (fread( &line.len, 2, 1, file ) == 1)
  {
    if (!make_line( line.len ))
      break;
    fread( line.txt, WSZ(line.len), 1, file );
    add_to_history( FALSE );
  }
  make_line( ~0 );

  fclose( file );
}


void check_history( void )
{
  if (*hstname)
  {
    if (*hstname == '-' && hstname[1] == '\0')
    {
      *local.hstname = '\0';
      save_history = FALSE;
    }
    else
    {
      wcscpy( local.hstname, hstname );
      save_history = TRUE;
    }
    *hstname = '\0';
  }
}


// ------------------------   Filename Completion   --------------------------


// Find the files matching name (using NULL to continue), testing against the
// extensions in extlist (if extlen is not zero; if exe is TRUE the extension
// must be in the list, otherwise it must NOT be in the list).	If dirs is TRUE
// only directories will be matched; if exe is TRUE only executables and assoc-
// iated files.  The find handle is returned in fh, with fd containing the file
// information.  Returns FALSE if no (more) names matched, TRUE otherwise.
BOOL match_file( PCWSTR name, PCWSTR extlist, DWORD extlen, BOOL dirs, BOOL exe,
		 PHANDLE fh, PWIN32_FIND_DATA fd )
{
  static const WCHAR DOT[] = L".";
  PCWSTR dot;
  WCHAR  path[MAX_PATH], buf[MAX_PATH];

  if (name)
  {
    *fh = FindFirstFile( name, fd );
    if (*fh == INVALID_HANDLE_VALUE)
      return FALSE;
  }
  else if (!FindNextFile( *fh, fd ))
  {
    FindClose( *fh );
    return FALSE;
  }

  do
  {
    if (fd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    {
      // Directory always succeeds, but ignore "." and "..".
      if (fd->cFileName[0] == '.' &&
	  (fd->cFileName[1] == '\0' ||
	   (fd->cFileName[1] == '.' && fd->cFileName[2] == '\0')))
	continue;
      return TRUE;
    }
    else if (dirs)			// not a directory, but only dirs wanted
      continue;
    if (extlen == 0)			// not matching extension
      return TRUE;
    for (dot = NULL, name = fd->cFileName; *name; ++name)
      if (*name == '.')
	dot = name;
    if (!dot)				// there's no extension, but pretend
    {					//  there is so extensionless matching
      dot  = DOT;			//  can work
      name = dot + 1;
    }
    if (exe)
    {
      if (match_ext( dot, name - dot, extlist, extlen ) ||
	  find_assoc( dot, name - dot ))
      {
	if (dot == DOT) 		// the dot is needed for association
	  wcscat( fd->cFileName, dot );
	return TRUE;
      }
      // Didn't find the extension in our lists, so try Windows'.
      if (dot != DOT)
      {
	memcpy( path, line.txt + path_pos, WSZ(fname_pos - path_pos) );
	wcscpy( path + fname_pos - path_pos, fd->cFileName );
	if (FindExecutable( path, NULL, buf ) > (HINSTANCE)32)
	  return TRUE;
      }
    }
    else if (!match_ext( dot, name - dot, extlist, extlen ))
      return TRUE;
  } while (FindNextFile( *fh, fd ));

  FindClose( *fh );
  return FALSE;
}


// The first time the open dialog is used it puts the window behind all other
// console windows (seems to be something to do with ReadConsoleInput).  Use
// the hook to move it back to the front.
UINT_PTR CALLBACK OpenHook( HWND dlg, UINT msg, WPARAM wParam, LPARAM lParam )
{
  if (msg == WM_INITDIALOG)
    SetForegroundWindow( dlg );
  return 0;
}


// Find the files matching the path up to pos.	If dirs is TRUE only find
// directories; if -1, use the open dialog.  Returns -1 if no files matched;
// -2 if wildcards were explicitly given; otherwise the length of the
// portion common to all files; the dialog returns TRUE if any files were
// selected, FALSE otherwise.  path_pos is set to the start of the path (if
// found_quote is TRUE there is a quote before it); fname_pos to the start
// of the filename; fname_cnt has the number of matching files; and
// fname_max is the length of the longest.
int find_files( int* pos, int dirs )
{
  HANDLE   fh;
  WIN32_FIND_DATA fd;
  OPENFILENAME ofn;
  PHistory f, p;
  int	   beg, start;
  DWORD    end, dend;
  BOOL	   wild, exe;
  WCHAR    wch[2];
  int	   prefix;
  DWORD    extlen;
  BOOL	   match;
  DWORD    quote;
  WCHAR    dir[MAX_PATH];
  static int openinit = FALSE;

  // Free the names from the previous completion.
  if (fname)
  {
    f = fname;
    do
    {
      p = f->next;
      free( f );
      f = p;
    } while (f != fname);
    fname = NULL;
  }

  // Find the start of the path - either the first non-terminated quote or
  // an appropriate delimiter.
  found_quote = quote = FALSE;
  start = (line.len != 0 && *line.txt == option.update_char) ? 1 : 0;
  for (path_pos = beg = start; beg < *pos; ++beg)
  {
    if (quote)
    {
      if (is_quote( beg ))
	quote = FALSE;
    }
    else if (is_quote( beg ))
      quote = TRUE;
    else if (line.txt[beg] <= ' ' || wcschr( INVALID_FNAME, line.txt[beg] ))
      path_pos = beg + 1;
  }
  // Remove all quotes...
  for (beg = path_pos; beg < *pos; ++beg)
  {
    if (is_quote( beg ))
    {
      found_quote = TRUE;
      remove_chars( beg--, 1 );
      --*pos;
    }
  }
  // ...but still keep the opening quote.
  if (found_quote)
  {
    insert_chars( path_pos++, L"\"", 1 );
    ++*pos;
  }

  // If the path starts at the very beginning of the line, only complete
  // executable files.
  exe = (path_pos == start + found_quote);

  // Now find the filename position within the path and check for wildcards.
  wild = FALSE;
  for (fname_pos = beg = path_pos; beg < *pos; ++beg)
  {
    switch (line.txt[beg])
    {
      case '*' :                                // assume they're in the name
      case '?' : wild = TRUE; break;
      case '/' :
      case '\\': dirchar   = line.txt[beg];     // use the same separator
      case ':' : fname_pos = beg + 1;
    }
  }

  // Add the wildcard if not already present and NUL-terminate the line for the
  // API call (there's always room for it due to max being two less).
  wch[0] = line.txt[*pos];
  wch[1] = line.txt[*pos+1];
  if (wild)
    line.txt[*pos] = '\0';
  else
  {
    line.txt[*pos]   = '*';
    line.txt[*pos+1] = '\0';
  }

  if (dirs < 0)
  {
    ZeroMemory( &ofn, sizeof(ofn) );
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner   = GetForegroundWindow();
    ofn.lpstrFile   = flist;
    ofn.nMaxFile    = FLIST_LEN;
    ofn.lpstrFilter = make_filter( exe );
    if (path_pos == fname_pos)
      ofn.lpstrInitialDir = L".";
    else
    {
      wcsncpy( fd.cFileName, line.txt + path_pos, fname_pos - path_pos );
      fd.cFileName[fname_pos-path_pos] = '\0';
      // Open dialog doesn't like using other drives.
      GetFullPathName( fd.cFileName, MAX_PATH, dir, NULL );
      ofn.lpstrInitialDir = dir;
    }
    ofn.lpstrTitle  = (exe) ? L"Select Executable" : L"Select Files";
    ofn.Flags	    = OFN_ALLOWMULTISELECT | OFN_EXPLORER | OFN_HIDEREADONLY
			| OFN_NOCHANGEDIR | OFN_NODEREFERENCELINKS;
    if (!openinit)
    {
      openinit = TRUE;
      ofn.lpfnHook = OpenHook;
      ofn.Flags |= OFN_ENABLEHOOK;
    }
    *flist = '\0';
    ofn.nFileExtension = ~0;
    prefix = GetOpenFileName( &ofn );
    fname_pos = ofn.nFileOffset;
    if (ofn.nFileExtension != (WORD)~0)
      flist[fname_pos-1] = '\0';
    if (ofn.lpstrFilter)
      free( (char*)ofn.lpstrFilter );
  }
  else
  {
    // Store the original completion name as the first entry.
    fname = new_history( line.txt + fname_pos, *pos - fname_pos );
    if (!fname)
      return -1;
    fname->next = fname->prev = fname;

    if (exe)
    {
      extlen = get_env_var( L"FEXEC", NULL );
      if (extlen == 0)
	extlen = get_env_var( L"PATHEXT", FEXEC );
    }
    else
      extlen = get_env_var( L"FIGNORE", FIGNORE );

    match = match_file( line.txt+path_pos, envvar.txt, extlen, dirs, exe,
			&fh, &fd );
    // If nothing was found try again without the ignore list.
    if (!match && !exe && !dirs)
      match = match_file( line.txt+path_pos, NULL, extlen = 0, FALSE, FALSE,
			  &fh, &fd );
    prefix = (!match || !wild) ? -1 : -2;
    fname_max = fname_cnt = 0;
    while (match)
    {
      if (!wild)
      {
	// Ensure the name matches what was typed, to overcome Windows foibles
	// (like "file." matching "file" and ".f" matching "f").
	if (_wcsnicmp( fd.cFileName, line.txt+fname_pos, *pos-fname_pos ) != 0)
	  goto next;
      }

      ++fname_cnt;
      end = wcslen( fd.cFileName );
      if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
	fd.cFileName[end++] = dirchar;
      dend = display_length( fd.cFileName, 0, end );
      if (dend > fname_max)
	fname_max = dend;
      f = new_history( fd.cFileName, end );
      if (!f)
	return -1;
      f->dlen = dend;

      if (!wild)
      {
	// Find the portion common to all the names.
	if (prefix < 0)
	  prefix = end;
	else
	{
	  for (beg = 0; beg < prefix; ++beg)
	    if (towlower( f->line[beg] ) != towlower( fname->next->line[beg] ))
	      break;
	  prefix = beg;
	}
      }

      // Find where to insert the new name to sort the list.  Work backwards,
      // since NTFS maintains a sorted list, anyway.
      for (p = fname->prev; p != fname; p = p->prev)
      {
	if (CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE,
			   f->line, f->flen,
			   p->line, p->flen ) == CSTR_GREATER_THAN)
	  break;
      }
      f->prev = p;
      f->next = p->next;
      p->next->prev = f;
      p->next = f;

    next:
      match = match_file( NULL, envvar.txt, extlen, dirs, exe, &fh, &fd );
    }
  }

  line.txt[*pos]   = wch[0];
  line.txt[*pos+1] = wch[1];

  return prefix;
}


// List all the files found by the completion.	If there are too many lines for
// the buffer, refuse to list any; prompt if there are too many for the window.
// Assumes more than one name.
void list_files( void )
{
  PHistory f;
  int	   lines, row, next_col;
  CONSOLE_SCREEN_BUFFER_INFO csbi;

  SetConsoleMode( hConOut, ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT );
  WriteCon( hConOut, L"\n", 1 );

  lines = calc_lines();

  // Are the names too long for column output?
  if (lines == fname_cnt)
  {
    if (check_name_count( fname_cnt ))
    {
      for (f = fname->next; f != fname; f = f->next)
      {
	WriteCon( hConOut, f->line, f->flen );
	if (f->dlen % screen.dwSize.X)
	  WriteCon( hConOut, L"\n", 1 );
      }
    }
  }
  else
  {
    if (check_name_count( lines ))
    {
      SetConsoleMode( hConOut, ENABLE_PROCESSED_OUTPUT ); // don't wrap at EOL
      GetConsoleScreenBufferInfo( hConOut, &screen );
      row = next_col = 0;
      for (f = fname->next; f != fname; f = f->next)
      {
	SetConsoleCursorPosition( hConOut, screen.dwCursorPosition );
	WriteCon( hConOut, f->line, f->flen );
	GetConsoleScreenBufferInfo( hConOut, &csbi );
	if (csbi.dwCursorPosition.X > next_col)
	  next_col = csbi.dwCursorPosition.X;
	if (++row == lines)
	{
	  screen.dwCursorPosition.X  = next_col + 2;
	  screen.dwCursorPosition.Y -= lines - 1;
	  row = 0;
	}
	else if (++screen.dwCursorPosition.Y == screen.dwSize.Y)
	{
	  WriteCon( hConOut, L"\n", 1 );
	  --screen.dwCursorPosition.Y;
	}
      }
      if (row)
      {
	screen.dwCursorPosition.Y += lines - row - 1;
	SetConsoleCursorPosition( hConOut, screen.dwCursorPosition );
      }
      WriteCon( hConOut, L"\n", 1 );
      SetConsoleMode(hConOut,ENABLE_PROCESSED_OUTPUT|ENABLE_WRAP_AT_EOL_OUTPUT);
    }
  }

  display_prompt();
  set_display_marks( 0, line.len );

  SetConsoleMode( hConOut, ENABLE_WRAP_AT_EOL_OUTPUT );
}


// Determine the lines required to fit the names.
int calc_lines( void )
{
  int	   lines, line, cols, col;
  DWORD    max;
  PHistory f;

  cols = screen.dwSize.X / fname_max;
  if ((cols - 1) * 2 > screen.dwSize.X % fname_max)
    --cols;
  lines = fname_cnt / cols;
  if (fname_cnt % cols)
    ++lines;

  // We now have the maximum number of lines based on the longest name.  Keep
  // reducing the lines to see how the actual names fit the columns.
  while (TRUE)
  {
    if (--lines == 0)
      return 1;
    col = line = max = 0;
    for (f = fname->next; f != fname; f = f->next)
    {
      if (f->dlen > max)
      {
	if (col + f->dlen > screen.dwSize.X)
	  return lines + 1;
	max = f->dlen;
      }
      if (++line == lines)
      {
	col += max + 2;
	line = max = 0;
      }
    }
  }
}


// Return TRUE if the names should be displayed, FALSE if not.
BOOL check_name_count( int lines )
{
  Key yn;

  if (lines > screen.dwSize.Y - 2)
  {
    wprintf( L"Too many names to display (%d)!\n", fname_cnt );
    return FALSE;
  }

  if (lines > screen.srWindow.Bottom - screen.srWindow.Top - 1)
  {
    wprintf( L"Display all %d possibilities? ", fname_cnt );
    get_key( &yn );
    if (yn.ch == 'y' || yn.ch == 'Y')
    {
      _putws( L"Yes" );
      return TRUE;
    }
    _putws( L"No" );
    return FALSE;
  }

  return TRUE;
}


// Return TRUE if str should be quoted.
BOOL quote_needed( PCWSTR str, int cnt )
{
  while (--cnt >= 0)
    if (wcschr( QUOTE_FNAME, str[cnt] ))
      return TRUE;

  return FALSE;
}


// Make a filter string for the open dialog.
PWSTR make_filter( BOOL exe )
{
  PWSTR f;
  WCHAR buf[2048];
  int	len, extlen;

  *buf = '\0';
  len = wcslen( line.txt+fname_pos );
  if (exe && line.txt[fname_pos+len-1] == '*')
  {
    extlen = get_env_var( L"FEXEC", NULL );
    if (extlen == 0)
      extlen = get_env_var( L"PATHEXT", FEXEC );
    if (extlen)
    {
      PWSTR e = envvar.txt;
      int   d = 0, cnt = lenof(buf), sz;
      f = buf;
      while (*e)
      {
	while (e[++d] != '.' && e[d] != ';' && e[d] != ':' && e[d] != '\0') ;
	sz = _snwprintf( f, cnt, L"%s%.*s;", line.txt+fname_pos, d, e );
	f += sz;
	cnt -= sz;
	if (e[d] == ';' || e[d] == ':')
	  ++d;
	e += d;
	d = 0;
      }
      f[-1] = '\0';
    }
  }
  if (!*buf)
    wcscpy( buf, line.txt+fname_pos );

  len += 1 + wcslen( buf ) + 1 + 13;
  f = malloc( WSZ(len) );
  if (f)
  {
    _snwprintf( f, len, L"%s%c%s%cAll files%c*%c",
		line.txt+fname_pos, 0, buf, 0, 0, 0 );
  }
  return f;
}


// Make an absolute path a relative path and ensure it ends with a backslash.
// If path starts with the current directory remove that portion.  If the cwd
// is one or two levels below path, use the shortcuts.	Otherwise keep the
// complete path.
void make_relative( PWSTR path, PWSTR rel )
{
  WCHAR buf[MAX_PATH];
  PWSTR cwd = buf, dir, root;

  GetCurrentDirectory( MAX_PATH, cwd );
  if (*cwd == *path)
  {
    *rel = '\0';
  }
  else
  {
    rel[0] = *path;
    rel[1] = ':';
    rel[2] = '\0';
    GetFullPathName( rel, MAX_PATH, cwd, NULL );
    rel += 2;
  }
  cwd  += 2;
  path += 2;
  root	= path;

  // Root current directory is always relative.
  if (cwd[1] == '\0')
  {
    if (*path != '\0')
    {
      wcscpy( rel, path+1 );
      wcscat( rel, L"\\" );
    }
    return;
  }

  // Root path is always absolute.
  if (*path == '\0')
  {
    wcscat( rel, L"\\" );
    return;
  }

  // Skip over the common directories.
  dir = cwd;
  while (*++path == *++cwd && *path)
  {
    if (*cwd == '\\')
      dir = cwd;
  }

  // In the current directory.
  if (*cwd == '\0' && *path == '\0')
    return;

  // Below the current directory.
  if (*cwd == '\0' && *path == '\\')
  {
    root = path + 1;
  }
  else
  {
    if (*cwd == '\\' && *path == '\0')
      dir = cwd;
    else
      path -= cwd - dir;

    // One level above, use parent shortcut.
    dir = wcschr( dir+1, '\\' );
    if (dir == NULL)
    {
      wcscpy( rel, L".." );
      rel += 2;
      root = path;
    }
    else
    {
      // Two levels above, use two parent shortcuts.
      dir = wcschr( dir+1, '\\' );
      if (dir == NULL)
      {
	wcscpy( rel, L"..\\.." );
	rel += 5;
	root = path;
      }
    }
  }

  wcscpy( rel, root );
  wcscat( rel, L"\\" );
}


// ------------------------------   Line Input	 -----------------------------


// Read the file.  Internal commands will be processed as usual; anything else
// will be added to the history.
BOOL read_cmdfile( PCWSTR name )
{
  BOOL	rc = FALSE;
  BOOL	skip, cond;
  WCHAR cwd[MAX_PATH];

  kbd = FALSE;
  file = _wfopen( name, L"r" );
  if (file != NULL)
  {
    // Check for the UTF-8 byte-order mark.
    if (getc( file ) == 0xEF && getc( file ) == 0xBB && getc( file ) == 0xBF)
      filecp = CP_UTF8;
    else
    {
      rewind( file );
      filecp = CP_OEMCP;
    }
    file_name = name;
    make_line( 0 );
    skip = cond = FALSE;
    GetCurrentDirectory( MAX_PATH, cwd );
    while (get_file_line( skip ))
    {
      if (*line.txt == '#')
      {
	if (cond)
	  break;
	line.txt[line.len] = '\0';
	skip = (_wcsicmp( line.txt + 1, cwd ) != 0);
	if (!skip)
	{
	  int c = getc( file );
	  // Put it back again, to ensure get_file_line reads what comes after.
	  ungetc( c, file );
	  if (c == '=')
	  {
	    WCHAR  path[MAX_PATH*2];
	    LPWSTR tmp;
	    get_file_line( FALSE );
	    tmp = line.txt + 1;
	    // Use the directory of the config file, if necessary.
	    if (*tmp != '\\' && *tmp != '/' && tmp[1] != ':')
	    {
	      LPWSTR bs = wcsrchr( name, '\\' );
	      if (bs != NULL)
	      {
		_snwprintf( path, lenof(path), L"%.*s%.*s",
			    bs - name + 1, name, line.len - 1, tmp );
		tmp = path;
	      }
	    }
	    GetFullPathName( tmp, lenof(local.hstname), local.hstname, NULL );
	    execute_rsth( 0 );
	    read_history();
	    save_history = TRUE;
	    // Loading a specific history precludes being primary.
	    if (primary)
	    {
	      primary = FALSE;
	      primary_id = 0;
	    }
	  }
	  cond = TRUE;
	}
	continue;
      }
      if (!internal_cmd())
	add_to_history( TRUE );
    }
    if (seen_error)
    {
      kbd = TRUE;
      display_prompt();
    }
    line_no = 0;
    seen_error = FALSE;
    fclose( file );
    file = NULL;
    rc = TRUE;
  }

  return rc;
}


// Read a line from the file.  Blank lines and lines starting with '-' are
// ignored.  If skip is TRUE, lines are skipped until the next '#'.
BOOL get_file_line( BOOL skip )
{
  char buf[2048];

  do
  {
    ++line_no;
    if (fgets( buf, sizeof(buf), file ) == NULL)
    {
      if (line.txt && line.txt != ENDM)
	free( line.txt );
      if (def_macro)
      {
	line.txt = (PWSTR)ENDM;
	line.len = ENDM_LEN;
	return TRUE;
      }
      line.txt = NULL;
      line.len = 0;
      return FALSE;
    }
  } while (*buf == '\n' || *buf == '-' || (skip && *buf != '#')
	   || *buf == '\0' || buf[1] == '\0');

  line.len = MultiByteToWideChar( filecp, 0, buf, -1, NULL, 0 );
  if (!make_line( line.len ))
  {
    make_line( ~0 );
    return FALSE;
  }
  MultiByteToWideChar( filecp, 0, buf, -1, line.txt, line.len );

  line.len -= 2;			// discount LF and NUL
  return TRUE;
}


// Read the next line from the appropriate source.
void get_next_line( void )
{
  line.len = 0;
  kbd = FALSE;
  if (file)
    get_file_line( FALSE );
  else if (macro_stk)
    get_macro_line( TRUE );
  else if (mcmd.txt)
  {
    if (mcmd.len)
    {
      copy_chars( mcmd.txt, mcmd.len );
      free( mcmd.txt );
    }
    mcmd.txt = NULL;
  }
  else
  {
    kbd = TRUE;
    edit_line();
  }
}


// Retrieve a line from a macro, replacing "%n" with the nth argument (0 to 9),
// "%*" with all arguments, or "%n*" with all arguments from the nth.  Use the
// escape character to treat the '%' or '*' literally.
void get_macro_line( BOOL first )
{
  DWORD pos, arg, cnt;
  int	argnum, var;
  Line	temp;

  if (first)
  {
    // Use this rather than copy_chars so undoing the expansion will work.
    replace_chars( 0, line.len, macro_stk->line->line, macro_stk->line->len );
  }
  else
  {
    WCHAR sep = CMDSEP;
    insert_chars( line.len, &sep, 1 );
    insert_chars( line.len, macro_stk->line->line, macro_stk->line->len );
  }
  for (pos = 0; pos < line.len; ++pos)
  {
    if (line.txt[pos] == ESCAPE)
      ++pos;
    else if (line.txt[pos] == VARIABLE && pos+1 < line.len &&
	     (line.txt[pos+1] == '*' ||
	      (line.txt[pos+1] >= '0' && line.txt[pos+1] <= '9')))
    {
      ++pos;
      argnum   = (line.txt[pos] == '*') ? 2 : line.txt[pos] - '0' + 1;
      temp     = line;
      line.txt = macro_stk->name;
      line.len = LOWORD(macro_stk->len);
      arg = cnt = 0;
      do
      {
	arg = get_string( arg + cnt, &cnt, TRUE );
      } while (--argnum);
      line = temp;
      var  = 2;
      if (line.txt[pos] != '*' && pos+1 < line.len && line.txt[pos+1] == '*')
      {
	++pos;
	var = 3;
      }
      if (line.txt[pos] == '*')
	cnt = LOWORD(macro_stk->len) - arg;
      pos -= var;
      pos += replace_chars( pos + 1, var, macro_stk->name + arg, cnt );
    }
  }
  if (first)
  {
    cnt = HIWORD(macro_stk->len) - LOWORD(macro_stk->len);
    if (cnt)
      insert_chars( pos, macro_stk->name + LOWORD(macro_stk->len), cnt );
  }
  un_escape( ARG_ESCAPE );

  macro_stk->line = macro_stk->line->next;
  if (macro_stk->line == NULL)
    pop_macro();
}


// Finished with a macro, remove its line from the stack.
void pop_macro( void )
{
  if (macro_stk)
  {
    PDefine m = macro_stk;
    macro_stk = macro_stk->next;
    free( m );
  }
}


// ----------------------------   Line Output	------------------------------


// If the line contains an unquoted/unescaped CMDSEP, make a copy of everything
// after it and chop the line at it.
void multi_cmd( void )
{
  DWORD pos;
  BOOL	quote;

  // Do a quick scan to see if it's worthwhile continuing.
  if (!memchr( line.txt, CMDSEP, WSZ(line.len) ))
    return;

  for (quote = FALSE, pos = 0; pos < line.len; ++pos)
  {
    if (quote)
    {
      if (is_quote( pos ))
	quote = FALSE;
    }
    else if (is_quote( pos ))
      quote = TRUE;
    else if (line.txt[pos] == ESCAPE)
      ++pos;
    else if (line.txt[pos] == CMDSEP)
    {
      ++pos;
      mcmd.len = line.len - pos;
      if (mcmd.len == 0)
	mcmd.txt = (PWSTR)1;
      else
      {
	mcmd.txt = new_txt( line.txt + pos, mcmd.len );
	if (!mcmd.txt)
	  return;
      }
      line.len = pos - 1;
      return;
    }
  }
}


// Convert '/' to '\', leading '-' to '/' and strip trailing '\'.
void dosify( void )
{
  DWORD pos;

  for (pos = 0; pos < line.len; ++pos)
  {
    if (line.txt[pos] == '/' || line.txt[pos] == '\\')
    {
      line.txt[pos] = '\\';
      if ((pos+1 == line.len || isblank( line.txt[pos+1] )) &&
	  pos > 0 && line.txt[pos-1] != ':' && !isblank( line.txt[pos-1] ))
	line.txt[pos] = ' ';
    }
    else if (line.txt[pos] == '-' && pos > 0 && isblank( line.txt[pos-1] ))
      line.txt[pos] = '/';
  }
}


// Perform brace expansion.  Brace expansion will duplicate what comes before
// (prepend) and after (postpend) the braces, with a comma-separated list of
// items inside the braces.  Use the escape character to treat braces and commas
// literally.  If the prepend has an unterminated quote, there must be no
// quotes inside the braces and the postpend must have the closing quote.  The
// pends will be terminated and separated by the CMD.EXE delimiter list; if the
// prepend terminator is a space, the postpend terminator will be used.
// eg: a;b{1,2}c,d ==> a;b1c;b2c,d
//     a b{1,2}c,d ==> a b1c,b2c,d
BOOL brace_expansion( void )
{
  int	count;				// keep track of nested braces
  int	pos;
  int	prepos,  prelen;		// position and length of the prepend
  int	postpos, postlen;		// position and length of the postpend
  WCHAR term;				// character used to separate items
  PWSTR pend;				// copy of the postpend
  BOOL	quote, q1;			// keep track of quotes
  BOOL	comma;				// must be at least two items

  prepos = pos = 0;
  term	 = ' ';
  quote  = FALSE;
  comma  = FALSE;
  while (!comma)
  {
    // Do a quick scan to see if it's worthwhile continuing.
    if (!memchr( line.txt + pos, '{', WSZ(line.len) )) // } (maintain balance)
      return FALSE;

    // Find the opening brace and the start of the prepend.
    for (; pos < line.len; ++pos)
    {
      if (is_quote( pos ))
	quote ^= TRUE;
      if (line.txt[pos] == ESCAPE)
	++pos;
      else if (line.txt[pos] == '{')    // }
	break;
      else if (!quote)
      {
	if (wcschr( BRACE_TERM, line.txt[pos] ))
	{
	  term	 = line.txt[pos];
	  prepos = pos + 1;
	}
	else if (wcschr( BRACE_STOP, line.txt[pos] ))
	  prepos = pos + 1;
      }
    }
    if (pos >= line.len)		// no opening brace
      return FALSE;
    prelen = pos - prepos;

    // Find the closing brace, checking for at least two items.
    q1 = FALSE;
    count = 1;
    for (postpos = ++pos; postpos < line.len; ++postpos)
    {
      if (q1)
      {
	if (is_quote( postpos ))
	  q1 = FALSE;
      }
      else if (is_quote( postpos ))
      {
	if (quote)
	  return FALSE; 		// quoted item with quoted prepend
	q1 = TRUE;
      }
      else if (line.txt[postpos] == ESCAPE)
      {
	if (postpos+1 < line.len)
	  ++postpos;
      }
      else if (line.txt[postpos] == '{')
	++count;
      else if (line.txt[postpos] == '}')
      {
	if (--count == 0)
	  break;
      }
      else if (line.txt[postpos] == ',' && count == 1)
	comma = TRUE;
    }
    if (count)				// unbalanced braces
      return FALSE;
  }

  // Find the end of the postpend.  Made awkward by the use of quotes and
  // braces being used as part of the postpend.
  for (postlen = ++postpos; postlen < line.len; ++postlen)
  {
    if (count)				// skip over quotes inside braces
    {
      if (q1)
      {
	if (is_quote( postlen ))
	  q1 = FALSE;
      }
      else if (is_quote( postlen ))
	q1 = TRUE;
      else if (line.txt[postlen] == ESCAPE)
      {
	if (postlen+1 < line.len)
	  ++postlen;
      }
      else if (line.txt[postlen] == '{')
	++count;
      else if (line.txt[postlen] == '}')
	--count;
    }
    else
    {
      if (is_quote( postlen ))
	quote ^= TRUE;
      if (line.txt[postlen] == ESCAPE)
      {
	if (postlen+1 < line.len)
	  ++postlen;
      }
      else if (line.txt[postlen] == '{') // }
	++count;
      else if (!quote)
      {
	if (wcschr( BRACE_TERM, line.txt[postlen] ))
	{
	  if (term == ' ')
	    term = line.txt[postlen];
	  break;
	}
	if (wcschr( BRACE_STOP, line.txt[postlen] ))
	  break;
      }
    }
  }
  if (quote || count)			// unbalanced quotes, braces
    return FALSE;
  postlen -= postpos;
  if (postlen < 0)
    postlen = 0;

  // Make a copy of the postpend, including the terminator.
  pend = new_txt( line.txt + postpos, postlen + 1 );
  if (!pend)
    return FALSE;
  pend[postlen++] = term;

  // Remove the opening brace, thus generating the first prepend.
  pos = prepos + prelen;
  remove_chars( pos, 1 );
  // Now add the postpend and prepend to all subsequent items.
  for (; count >= 0; ++pos)
  {
    if (quote)
    {
      if (is_quote( pos ))
	quote = FALSE;
    }
    else if (is_quote( pos ))
      quote = TRUE;
    else if (line.txt[pos] == ESCAPE)
    {
      if (pos+1 < line.len)
	++pos;
    }
    else if (line.txt[pos] == '{')
      ++count;
    else if (line.txt[pos] == '}')
      --count;
    else if (line.txt[pos] == ',' && count == 0)
    {
      pos += replace_chars( pos, 1, pend, postlen );
      pos += insert_chars( pos, line.txt + prepos, prelen ) - 1;
    }
  }
  // Remove the closing brace, thus generating the last postpend.
  remove_chars( pos - 1, 1 );

  free( pend );

  return TRUE;
}


// Keep expanding braces until no more, then replace escaped characters.
void expand_braces( void )
{
  while (brace_expansion()) ;
  un_escape( BRACE_ESCAPE );
}


// If the first word has an extension in the association list, insert its
// definition at the start of the line.
BOOL associate( void )
{
  PDefine a;
  DWORD   ext, beg, cnt;
  int	  alt = 0;

  beg = get_string( 0, &cnt, FALSE );
  if (cnt == 0)
    return FALSE;

  ext = beg + cnt - 1;
  if (cnt > 1 && line.txt[ext] == '=')
  {
    alt = 1;
    --ext;
    --cnt;
  }

  if (line.txt[ext] == '/' || line.txt[ext] == '\\')
  {
    line.txt[ext] = '\\';
    a = find_define( &assoc_head, ext, 1 + alt );
    if (!a)
      return FALSE;
    if (cnt > 1 && line.txt[ext-1] != ':')
    {
      remove_chars( ext, 1 + alt );	// include the alternative indicator
      alt = 0;				//  and don't remove it again
    }
    else
      cnt = 1;
  }
  // Don't match a dot by itself, or consecutive dots.
  else if (line.txt[ext] == '.' && (ext == beg || line.txt[ext-1] == '.'))
    return FALSE;
  else
  {
    for (cnt = 1; line.txt[ext] != '.'; ++cnt, --ext)
      if (ext == beg || line.txt[ext] == '/' || line.txt[ext] == '\\'
		     || line.txt[ext] == ':')
	return FALSE;
    a = find_assoc( line.txt + ext, cnt + alt );
    if (!a)
      return FALSE;
  }

  if (alt)
    remove_chars( ext + cnt, 1 );
  insert_chars( 0, a->line->line, a->line->len );
  insert_chars( a->line->len, L" ", 1 );

  return TRUE;
}


// If the first word is a symbol, replace it with its definition.
BOOL expand_symbol( void )
{
  PDefine s;
  DWORD   sym, end;
  BOOL	  sp;

  sym = skip_blank( 0 );
  end = skip_nondelim( sym );

  s = find_define( &sym_head, sym, end - sym );
  if (!s)
    return FALSE;

  sp = (end < line.len && !isblank( line.txt[end] ));

  replace_chars( sym, end - sym, s->line->line, s->line->len );
  if (sp)
    insert_chars( sym + s->line->len, L" ", 1 );

  return TRUE;
}


// If the first word is a macro, replace the line with its definition.
BOOL expand_macro( void )
{
  PDefine m;
  DWORD   mac, end;
  BOOL	  quote;

  mac = skip_blank( 0 );
  end = skip_nondelim( mac );

  m = find_define( &mac_head, mac, end - mac );
  if (!m)
    return FALSE;

  // Make a copy of the line in order to remember the arguments.
  if (!add_define( &macro_stk, 0, line.len ))
    return FALSE;

  // Separate secondary commands and redirection.  For example, given the def-
  // inition "defm ut unzip %* -dtemp", the command "ut zip |dnd" should expand
  // to "unzip zip -dtemp |dnd" rather than "unzip zip |dnd -dtemp".
  quote = FALSE;
  for (; end < line.len; ++end)
  {
    if (quote)
    {
      if (is_quote( end ))
	quote = FALSE;
    }
    else if (is_quote( end ))
      quote = TRUE;
    else if (line.txt[end] == ESCAPE)
    {
      if (end+1 < line.len)
	++end;
    }
    else if (wcschr( BRACE_STOP, line.txt[end] ) ||
	     (line.txt[end] == '2' && end+1 < line.len
				   && line.txt[end+1] == '>'))
    {
      if (line.txt[end-1] == ' ')
	--end;
      break;
    }
  }
  macro_stk->len = (line.len << 16) | end;

  macro_stk->line = m->line;
  get_macro_line( TRUE );

  return TRUE;
}


// Determine if the first word is meant for CMDread and execute it if so.
BOOL internal_cmd( void )
{
  DWORD pos, cnt;
  int	func;

  // Treat Control+Break as internal.
  if (check_break > 1)
  {
    check_break = 1;
    while (macro_stk)
      pop_macro();
    return TRUE;
  }

  pos = skip_blank( 0 );
  cnt = skip_nondelim( pos ) - pos;
  //if (cnt < MIN_CMD_LEN || cnt > MAX_CMD_LEN)
  if (cnt != CMD_LEN)
    return FALSE;

  func = search_cfg( line.txt + pos, cnt, internal, INTERNAL_CMDS - 1 );
  if (func == -1)
    return FALSE;

#ifndef _WIN64
  if (kbd && func != (int)execute_lsth)
#else
  if (kbd && internal_funcs[func] != execute_lsth)
#endif
    un_escape( NULL );

  pos = skip_blank( pos + cnt );
#ifndef _WIN64
  ((IntFunc)func)( pos );
#else
  (internal_funcs[func])( pos );
#endif

  return TRUE;
}


// Search for a word between two VARIABLE characters.  If the word exists in
// the environment (and env is true) or it's a symbol, replace it.  Use the
// escape character to treat VARIABLE as a normal character.
//
// Eg: defs sym -expansion-
//     %a%sym%	  --> %a-expansion- [if a is not defined]
//     %sym%sym%  --> -expansion-sym%
//     ^%sym%sym% --> ^%sym-expansion-
//     %sym^%sym% --> %sym^%sym%

void expand_vars( BOOL env )
{
  Line	  var = { NULL, 0 };
  PDefine d;
  DWORD   pos, cnt, start, end;
  WCHAR   ch, cd[MAX_PATH];
  BOOL	  fndenv;
  int	  j;

  start = ~0;
  for (pos = 0; pos < line.len; ++pos)
  {
    if (line.txt[pos] == ESCAPE)
      ++pos;
    else if (line.txt[pos] == VARIABLE)
    {
      if (start == ~0)
	start = pos + 1;
      else
      {
	// See if there's a substitution.
	for (end = start; end < pos; ++end)
	{
	  if (line.txt[end] == ':')
	    break;
	}
	fndenv = TRUE;
	cnt = end - start;
	ch = line.txt[end];
	line.txt[end] = '\0';
	var.len = get_env_var( line.txt + start, NULL );
	var.txt = envvar.txt;
	if (!var.len)
	{
	  // Check for a CMD.EXE dynamic variable.
	  if (cnt == 2 && _wcsicmp( line.txt + start, L"CD" ) == 0)
	  {
	    if (env && end == pos)
	    {
	      var.len = GetCurrentDirectory( MAX_PATH, cd );
	      var.txt = cd;
	    }
	  }
	  else
	  {
	    fndenv = FALSE;
	    for (j = 0; j < lenof(cmd_vars); ++j)
	    {
	      if (_wcsicmp( line.txt + start, cmd_vars[j] ) == 0)
	      {
		fndenv = TRUE;
		break;
	      }
	    }
	  }
	}
	line.txt[end] = ch;
	if (!fndenv && end == pos)
	{
	  d = find_define( &sym_head, start, cnt );
	  if (d)
	  {
	    var.txt = d->line->line;
	    var.len = d->line->len;
	  }
	}
	if (var.len || fndenv)
	{
	  if (var.len && end == pos)
	    replace_chars( start - 1, cnt + 2, var.txt, var.len );
	  start = ~0;
	}
	else
	  start = pos + 1;
      }
    }
  }
  un_escape( VAR_ESCAPE );
}


// --------------------------	Internal Commands   --------------------------


// Define an association.
void execute_defa( DWORD pos )
{
  PDefine a;
  DWORD   end, def;

  if (pos == line.len)
    return;

  execute_dela( pos );			// remove any previous association

  end = skip_nonblank( pos );
  def = skip_blank( end );
  if (def == line.len)
    return;

  a = add_define( &assoc_head, pos, end - pos );
  if (a)
    a->line = add_line( def );
}


// Define a key.  This can be a function, a command or a macro.
void execute_defk( DWORD pos )
{
  DWORD  end, cnt;
  char*  key;
  int	 func;
  PMacro m;

  if (pos == line.len)
    return;

  end = skip_nonblank( pos );
  cnt = end - pos;
  key = find_key( pos, cnt );
  if (key == NULL)
  {
    show_error( L"unrecognised key", pos, cnt );
    return;
  }

  pos = skip_blank( end );
  if (pos == line.len)			// not defining it to anything
  {					//  so wipe it
    if (*key == Play)
      del_macro( key );
    *key = Ignore;
    return;
  }

  if (line.txt[pos] == '=' ||           // a command - replace the line with
      line.txt[pos] == '-')             //  the definition and execute it
  {
    ++pos;
    m = add_macro( key );
    if (!m)
      return;
    m->type = (line.txt[pos-1] == '=') ? MAC_LINE : MAC_HIDDEN;
    m->len = line.len - pos;
    if (m->len == 1)
      m->chfn.ch = line.txt[pos];
    else if (m->len != 0)
    {
      m->line = new_txt( line.txt + pos, m->len );
      if (!m->line)
      {
	del_macro( key );
	return;
      }
    }
    *key = Play;
    return;
  }

  pos = get_string( pos, &cnt, FALSE );
  end = skip_blank( pos + cnt );
  if (end == line.len && !found_quote)
  {
    // A single word - change the keymap.
    func = search_cfg( line.txt + pos, cnt, cfg, LastFunc - 1 );
    if (func == -1)
    {
      show_error( L"unrecognised function", pos, cnt );
      return;
    }
    if (*key == Play)
      del_macro( key );
    *key = func;
  }
  else					// a macro - a series of functions
  {					//  and/or characters
    m = add_macro( key );
    if (!m)
      return;
    m->func = malloc( (line.len - pos) * sizeof(Key) );
    if (!m->func)
    {
      del_macro( key );
      return;
    }
    do
    {
      if (found_quote)			// add each character in the string
      {
	while (cnt--)
	{
	  if (line.txt[pos] == '"')
	  {
	    for (end = pos - 1; line.txt[end] == '\\'; --end) ;
	    m->len -= (pos - end) / 2;
	  }
	  m->func[m->len].ch = line.txt[pos++];
	  m->func[m->len].fn = Default;
	  ++m->len;
	}
	if (pos < line.len) // && line.txt[pos] == '"')
	{
	  for (end = pos - 1; line.txt[end] == '\\'; --end) ;
	  m->len -= (pos - end) / 2;
	  ++pos;			// jump over the closing quote
	}
      }
      else				// add a function
      {
	func = search_cfg( line.txt + pos, cnt, cfg, LastFunc - 1 );
	if (func == -1)
	{
	  show_error( L"unrecognised function", pos, cnt );
	  del_macro( key );
	  return;
	}
	m->func[m->len].ch = 0;
	m->func[m->len].fn = func;
	++m->len;
	pos += cnt;
      }
      pos = get_string( pos, &cnt, FALSE );
    } while (cnt);
    end_macro( m );
  }
}


// Define a macro.  If the macro already exists as a symbol, delete it; if it's
// already a macro, redefine it.
void execute_defm( DWORD pos )
{
  PDefine   mac;
  PLineList ll;
  DWORD     end, def, cnt;

  if (def_macro)			// can't define a macro within a macro
    return;
  def_macro = TRUE;

  end = skip_nondelim( pos );
  if (end < line.len && !isblank( line.txt[end] ))
  {
    end = skip_nonblank( end );
    show_error( L"invalid macro name", pos, end - pos );
    goto ret;
  }
  cnt = end - pos;

  mac = find_define( &sym_head, pos, cnt );
  if (mac)
    del_define( &sym_head );

  mac = find_define( &mac_head, pos, cnt );
  if (mac)
  {
    free_linelist( mac->line );
    mac->line = NULL;
  }
  else
  {
    mac = add_define( &mac_head, pos, cnt );
    if (!mac)
      goto ret;
  }

  def = skip_blank( end );
  if (def != line.len)			// single-line definition
  {
    mac->line = add_line( def );
    if (!mac->line)
      del_define( &mac_head );
    goto ret;
  }

  for (ll = NULL;;)			// multi-line definition
  {
    if (kbd)
    {
      WriteCon( hConOut, DEFM, DEFM_LEN );
      show_prompt = FALSE;
    }
    get_next_line();
    pos = skip_blank( 0 );
    end = skip_nonblank( pos );
    if (end - pos == ENDM_LEN && _wcsnicmp( line.txt+pos, ENDM, ENDM_LEN ) == 0)
      break;
    if (!ll)
      ll = mac->line = add_line( 0 );
    else
      ll = ll->next = add_line( 0 );
    if (!ll)
      break;
  }
  if (!ll)
    del_define( &mac_head );

ret:
  def_macro = FALSE;
}


// Define a symbol.  If the name already exists as a macro, delete it; if it's
// already a symbol, redefine it.
void execute_defs( DWORD pos )
{
  PDefine sym;
  DWORD   end, def, cnt;

  if (pos == line.len)
    return;

  end = skip_nondelim( pos );
  if (end < line.len && !isblank( line.txt[end] ))
  {
    end = skip_nonblank( end );
    show_error( L"invalid symbol name", pos, end - pos );
    return;
  }
  cnt = end - pos;

  sym = find_define( &mac_head, pos, cnt );
  if (sym)
    del_define( &mac_head );

  sym = find_define( &sym_head, pos, cnt );
  if (sym && sym->line)
  {
    free( sym->line );
    sym->line = NULL;
  }

  def = skip_blank( end );
  if (def == line.len)			// defining to nothing
  {					//  so wipe it
    if (sym)
      del_define( &sym_head );
    return;
  }

  if (!sym)
  {
    sym = add_define( &sym_head, pos, cnt );
    if (!sym)
      return;
  }
  sym->line = add_line( def );
  if (!sym->line)
    del_define( &sym_head );
}


// Delete one or more associations.  This should be exactly as defined, or
// separated by spaces.  Eg: "dela .c.h" will delete exactly ".c.h", whereas
// "dela .c .h" will delete them even if they're part of a list.
void execute_dela( DWORD pos )
{
  PDefine a;
  DWORD   end, cnt;

  while (pos < line.len)
  {
    end = skip_nonblank( pos );
    cnt = end - pos;
    a	= find_define( &assoc_head, pos, cnt );
    if (a)
      del_define( &assoc_head );
    else
    {
      a = find_assoc( line.txt + pos, cnt );
      if (a)
      {
	if (a->len == cnt)
	  del_define( &assoc_head );
	else
	{
	  if (assoc_pos + cnt < a->len &&
	      (a->name[assoc_pos+cnt] == ';' ||
	       a->name[assoc_pos+cnt] == ':'))
	    ++cnt;
	  memmove( a->name + assoc_pos, a->name + assoc_pos + cnt,
		   WSZ(a->len - assoc_pos - cnt) );
	  a->len -= cnt;
	}
      }
    }
    pos = skip_blank( end );
  }
}


// Delete history lines containing text, including the DELH line itself.
void execute_delh( DWORD pos )
{
  PHistory h, n;
  int end;

  remove_from_history( history.prev );	// the DELH line

  // Use RSTH to delete everything, not empty text.
  if (pos == line.len)
    return;

  for (h = history.next; h != &history; h = n)
  {
    n = h->next;
    for (end = h->len - (line.len - pos); end >= 0; --end)
    {
      if (_wcsnicmp( h->line + end, line.txt + pos, line.len - pos ) == 0)
      {
	remove_from_history( h );
	break;
      }
    }
  }
}


// Delete (ignore) one or more keys.
void execute_delk( DWORD pos )
{
  DWORD end;
  char* key;

  while (pos < line.len)
  {
    end = skip_nonblank( pos );
    key = find_key( pos, end - pos );
    if (key)
    {
      if (*key == Play)
	del_macro( key );
      *key = Ignore;
    }
    pos = skip_blank( end );
  }
}


// Delete one or more macros.
void execute_delm( DWORD pos )
{
  delete_define( &mac_head, pos );
}


// Delete one or more symbols.
void execute_dels( DWORD pos )
{
  delete_define( &sym_head, pos );
}


// List the associations - either all of them or just those specified (as
// individual extensions, not as its list).
void execute_lsta( DWORD pos )
{
  PDefine a;
  DWORD   end, cnt;

  if (!redirect( pos ))
    return;

  if (pos == line.len)
  {
    for (a = assoc_head; a; a = a->next)
      list_define( a, 'a' );
  }
  else
  {
    while (pos < line.len)
    {
      end = skip_nonblank( pos );
      cnt = end - pos;
      a   = find_assoc( line.txt + pos, cnt );
      if (a)
	fwprintf( lstout, L"defa %-3.*s\t%.*s\n", (int)cnt, line.txt + pos,
		 (int)a->line->len, a->line->line );
      pos = skip_blank( end );
    }
  }

  end_redirect();
}


// List all the lines in the history, or the last N lines, or the first N lines
// if N is negative, or the lines containing the text.	The most recent line is
// always displayed last.
// Eg: lsth 5	- show the last five commands;
//     lsth ^5	- show the commands containing 5;
//     lsth "5" - show the commands containing "5";
//     lsth "  >quote - write commands containing a quote followed by a space to
//			the file called quote
void execute_lsth( DWORD pos )
{
  PHistory h;
  DWORD    cnt;
  BOOL	   back, find;
  int	   end;

  // Unescape manually, to allow for escaped redirection characters.
  find = FALSE;
  for (end = pos; end < line.len; ++end)
  {
    if (line.txt[end] == ESCAPE && end+1 < line.len)
    {
      if (end == pos)
	find = TRUE;
      remove_chars( end, 1 );
    }
    else if (line.txt[end] == '>' || line.txt[end] == '|')
    {
      if (line.txt[end-1] == ' ')
	remove_chars( --end, 1 );
      break;
    }
  }
  if (!redirect( end ))
    return;

  if (pos >= line.len)
  {
    for (h = history.next; h != &history; h = h->next)
      fwprintf( lstout, L"%.*s\n", (int)h->len, h->line );
  }
  else
  {
    cnt = 0;
    back = TRUE;
    if (!find)
    {
      end = pos;
      if (line.txt[end] == '-')
      {
	back = FALSE;
	++end;
      }
      while (end < line.len && '0' <= line.txt[end] && line.txt[end] <= '9')
      {
	cnt = cnt * 10 + line.txt[end] - '0';
	++end;
      }
      if (end != line.len)		// there's more after the number
	find = TRUE;			//  so treat it as text
      else if (cnt > histsize - 1)
	cnt = histsize - 1;
    }
    if (!find)
    {
      if (cnt)
      {
	if (back)
	{
	  // List the last cnt commands, excluding this one (assuming it's
	  // not a keyboard macro).
	  h = history.prev;
	  end = cnt;
	  do
	    h = h->prev;
	  while (--end);
	}
	else
	  h = history.next;
	do
	{
	  fwprintf( lstout, L"%.*s\n", (int)h->len, h->line );
	  h = h->next;
	} while (--cnt);
      }
    }
    else				// list commands containing text,
    {					//  excluding this command
      for (h = history.next; h != history.prev; h = h->next)
      {
	for (end = h->len - (line.len - pos); end >= 0; --end)
	{
	  if (_wcsnicmp( h->line + end, line.txt + pos, line.len - pos ) == 0)
	  {
	    fwprintf( lstout, L"%.*s\n", (int)h->len, h->line );
	    break;
	  }
	}
      }
    }
  }

  end_redirect();
}


// List all keys or just those specified.  When listing all keys, list all the
// plain keys, but exclude modified keys that are ignored.
void execute_lstk( DWORD pos )
{
  int	end, cnt;
  char* key;
  static const LPCWSTR state[5] = { L"  ", L" #", L" ^", L" @", L"#^" };

  if (!redirect( pos ))
    return;

  if (pos == line.len)
  {
    // Control keys.
    for (cnt = 0; cnt < 32; ++cnt)
    {
      for (end = 0; end < 2; ++end)
      {
	if (end == 0 || ctrl_key_table[cnt][end] != Ignore)
	{
	  fwprintf( lstout, L"defk %s%c\t", state[end*2+2], cnt + '@' );
	  list_key( &ctrl_key_table[cnt][end] );
	}
      }
    }
    fputwc( '\n', lstout );

    // Editing keys.
    for (cnt = 0; cnt < CFGKEYS; ++cnt)
    {
      for (end = 0; end < 4; ++end)
      {
	if (end == 0 || key_table[cnt][end] != Ignore)
	{
	  fwprintf( lstout, L"defk %s%s\t",
		    (end == 3 && 8 <= cnt && cnt <= 11) ? state[4] : state[end],
		    key_str[cnt] );
	  list_key( &key_table[cnt][end] );
	}
      }
    }
    fputwc( '\n', lstout );

    // Function keys.
    for (cnt = 0; cnt < 12; ++cnt)
    {
      for (end = 0; end < 4; ++end)
      {
	if (end == 0 || fkey_table[cnt][end] != Ignore)
	{
	  fwprintf( lstout, L"defk %sF%d\t", state[end], cnt + 1 );
	  list_key( &fkey_table[cnt][end] );
	}
      }
    }
  }
  else
  {
    while (pos < line.len)
    {
      end = skip_nonblank( pos );
      cnt = end - pos;
      key = find_key( pos, cnt );
      if (key)
      {
	fwprintf( lstout, L"defk %-3.*s\t", cnt, line.txt + pos );
	list_key( key );
      }
      pos = skip_blank( end );
    }
  }

  end_redirect();
}


// List macros.
void execute_lstm( DWORD pos )
{
  list_defines( &mac_head, pos );
}


// List symbols.
void execute_lsts( DWORD pos )
{
  list_defines( &sym_head, pos );
}


// Delete every association.
void execute_rsta( DWORD pos )
{
  reset_define( &assoc_head );
}


// Delete the history.
void execute_rsth( DWORD pos )
{
  PHistory h, p;

  for (h = history.prev; h != &history; h = p)
  {
    p = h->prev;
    free( h );
  }
  history.prev = history.next = &history;
  histsize = 0;
}


// Delete every macro.
void execute_rstm( DWORD pos )
{
  reset_define( &mac_head );
}


// Delete every symbol.
void execute_rsts( DWORD pos )
{
  reset_define( &sym_head );
}


// Handle redirection for the list commands.
BOOL redirect( DWORD pos )
{
  DWORD  beg = 0, end = 0;
  PCWSTR mode;
  PCWSTR err = NULL;
  DWORD  append;

  lstpipe = FALSE;
  lstout  = stdout;
  append  = 0;
  for (; pos < line.len; ++pos)
  {
    // No real need to test the quoting of these.
    if (line.txt[pos] == '>' || line.txt[pos] == '|')
    {
      mode = L"w";
      if (line.txt[pos] == '>')
      {
	if (pos+1 < line.len && line.txt[pos+1] == '>')
	  append = 1, mode = L"a";
	beg = get_string( pos + 1 + append, &end, FALSE );
      }
      else
      {
	beg = pos + 1;
	end = line.len - beg;
      }
      if (end == 0)
      {
	_putws( L"CMDread: syntax error." );
	return FALSE;
      }
      line.txt[beg+end] = '\0';
      if (line.txt[pos] == '|')
      {
	lstpipe = TRUE;
	lstout	= _wpopen( line.txt + beg, mode );
	err	= L"execute";
      }
      else
      {
	lstout	= _wfopen( line.txt + beg, mode );
	err	= (append) ? L"open" : L"create";
      }
      break;
    }
  }
  if (!lstout)
  {
    wprintf( L"CMDread: unable to %s \"%s\".\n", err, line.txt + beg );
    return FALSE;
  }
  if (lstout == stdout && _isatty( 1 ))
    old_mode = _setmode( 1, _O_U16TEXT );

  if (end != 0)
  {
    end = skip_blank( beg + end + 1 );
    if (end > line.len)
      end = line.len;
    remove_chars( pos, end - pos );
  }

  if (append)
    lastm = TRUE;
  else if (lstout != stdout || kbd)
    lastm = EOF;

  return TRUE;
}


// Close the file used by redirection.
void end_redirect( void )
{
  if (lstpipe)
    _pclose( lstout );
  else if (lstout != stdout)
    fclose( lstout );
  else if (_isatty( 1 ))
    _setmode( 1, old_mode );
}


// Show the assignment of a key.
void list_key( char* key )
{
  PMacro m;
  BOOL	 quote;
  int	 pos, bs;

  if (*key != Play)
  {
    fwprintf( lstout, L"%s\n", func_str[(int)*key] );
    return;
  }

  m = find_macro( key );
  if (!m)
  {
    fwprintf( lstout, L"%s\n", func_str[Ignore] );
    return;
  }

  if (m->type != MAC_FUNC)
  {
    fwprintf( lstout, L"%c%.*s\n",
	      (m->type == MAC_LINE) ? '=' : '-', m->len,
	      (m->len == 1) ? &m->chfn.ch : m->line );
    return;
  }

  if (m->len == 1)
  {
    if (m->chfn.ch == '"')              // why would you bother?
      fwprintf( lstout, L"\"\\\"\"\n" );
    else
      fwprintf( lstout, L"\"%c\"\n", m->chfn.ch );
    return;
  }

  quote = FALSE;
  for (pos = 0; pos < m->len; ++pos)
  {
    if (m->func[pos].ch == 0)
    {
      if (quote)
      {
	fwprintf( lstout, L"\" " );
	quote = FALSE;
      }
      fwprintf( lstout, L"%s ", func_str[(int)m->func[pos].fn] );
    }
    else
    {
      if (!quote)
      {
	fputwc( '"', lstout );
	quote = TRUE;
      }
      if (m->func[pos].ch == '"')
      {
	for (bs = pos; --bs >= 0 && m->func[bs].ch == '\\';)
	  fputwc( '\\', lstout );
	fputwc( '\\', lstout );
      }
      fputwc( m->func[pos].ch, lstout );
    }
  }
  if (quote)
  {
    while (--pos >= 0 && m->func[pos].ch == '\\')
      fputwc( '\\', lstout );
    fputwc( '"', lstout );
  }
  fputwc( '\n', lstout );
}


// --------------------------	Keyboard Macros   ----------------------------


// Find the keyboard macro given a keymap location, or NULL if it is not
// defined.  Sets macro_prev to the macro before the one found.
PMacro find_macro( char* key )
{
  PMacro m;

  for (macro_prev = NULL, m = macro_head; m; macro_prev = m, m = m->next)
  {
    if (m->key == key)
      return m;
    if (m->key > key)
      break;
  }

  return NULL;
}


// Add key to the keyboard macro list.	If it is already defined, reset it.
PMacro add_macro( char* key )
{
  PMacro m;

  m = find_macro( key );
  if (!m)
  {
    m = malloc( sizeof(Macro) );
    if (!m)
      return m;
    m->key = key;
    if (macro_prev)
    {
      m->next = macro_prev->next;
      macro_prev->next = m;
    }
    else
    {
      m->next = macro_head;
      macro_head = m;
    }
  }
  else if (m->len > 1)
    free( m->line );

  m->type = MAC_FUNC;
  m->len  = 0;
  m->line = NULL;

  return m;
}


// Finish a keyboard macro definition.
void end_macro( PMacro m )
{
  if (m->len == 0)			// nothing was defined
  {					//  so remove it
    if (m->func)
      free( m->func );
    del_macro( m->key );
    return;
  }
  else if (m->len == 1) 		// a single key is stored directly
  {
    Key k = m->func[0];
    free( m->func );
    if (k.ch == 0)
    {
      char* key = m->key;
      del_macro( m->key );
      *key = k.fn;
      return;
    }
    m->chfn = k;
  }
  else					// reduce memory to actual length
    m->func = realloc( m->func, m->len * sizeof(Key) );

  *m->key = Play;			// successfully assigned
}


// Remove the keyboard macro assigned to key.
void del_macro( char* key )
{
  PMacro m;

  m = find_macro( key );
  if (m)
  {
    if (m->len > 1)
      free( m->line );
    if (macro_prev)
      macro_prev->next = m->next;
    else
      macro_head = m->next;
    free( m );
    *key = Ignore;
  }
}


// ----------------------------   Definitions	------------------------------


// Add a definition to the list.  The new definition becomes the head.
PDefine add_define( PDefine* head, DWORD pos, DWORD cnt )
{
  PDefine d;

  d = malloc( sizeof(Define) + WSZ(cnt) );
  if (d)
  {
    memcpy( d->name, line.txt + pos, WSZ(cnt) );
    d->len  = cnt;
    d->line = NULL;
    d->next = *head;
    *head   = d;
  }

  return d;
}


// Find the definition in the list.  Returns NULL if not found; otherwise moves
// the definition to the head and returns it.
PDefine find_define( PDefine* head, DWORD pos, DWORD cnt )
{
  PDefine d, p;

  for (p = NULL, d = *head; d; p = d, d = d->next)
  {
    if (d->len == cnt && _wcsnicmp( d->name, line.txt + pos, cnt ) == 0)
    {
      if (p)
      {
	p->next = d->next;
	d->next = *head;
	*head	= d;
      }
      break;
    }
  }

  return d;
}


// Search the list of associations for ext.  Return pointer to definition if
// found and move it to the head; otherwise NULL.
PDefine find_assoc( PCWSTR ext, DWORD cnt )
{
  PDefine a, p;

  for (p = NULL, a = assoc_head; a; p = a, a = a->next)
  {
    if (match_ext( ext, cnt, a->name, a->len ))
    {
      if (p)
      {
	p->next = a->next;
	a->next = assoc_head;
	assoc_head = a;
      }
      break;
    }
  }

  return a;
}


// Remove the head of the list.
void del_define( PDefine* head )
{
  PDefine d;

  d = *head;
  *head = d->next;
  free_linelist( d->line );
  free( d );
}


// Delete a list of definitions.
void delete_define( PDefine* head, DWORD pos )
{
  DWORD   end;
  PDefine d;

  while (pos < line.len)
  {
    end = skip_nonblank( pos );
    d = find_define( head, pos, end - pos );
    if (d)
      del_define( head );
    pos = skip_blank( end );
  }
}


// Delete every definition in the list.
void reset_define( PDefine* head )
{
  PDefine p;

  while (*head)
  {
    p = (*head)->next;
    free_linelist( (*head)->line );
    free( *head );
    *head = p;
  }
}


// List a definition.
void list_define( PDefine d, WCHAR t )
{
  PLineList ll;

  // If the last definition was a multi-line macro, or the next one is,
  // add a blank line.
  if (lastm == TRUE || (lastm == FALSE && d->line->next))
    fputwc( '\n', lstout );

  fwprintf( lstout, L"def%c %-3.*s%c", t, (int)d->len, d->name,
				       (d->line->next) ? '\n' : '\t' );
  for (ll = d->line; ll; ll = ll->next)
    fwprintf( lstout, L"%.*s\n", (int)ll->len, ll->line );

  if (d->line->next)
  {
    fwprintf( lstout, L"%s\n", ENDM );
    lastm = TRUE;
  }
  else
    lastm = FALSE;
}


// List all macros or symbols, or just those specified.
void list_defines( PDefine* head, DWORD pos )
{
  PDefine d;
  DWORD   end, cnt;
  WCHAR   t;

  if (!redirect( pos ))
    return;

  t = (head == &mac_head) ? 'm' : 's';

  if (pos == line.len)
  {
    for (d = *head; d; d = d->next)
      list_define( d, t );
  }
  else
  {
    while (pos < line.len)
    {
      end = skip_nonblank( pos );
      cnt = end - pos;
      d = find_define( head, pos, cnt );
      if (d)
	list_define( d, t );
      pos = skip_blank( end );
    }
  }

  end_redirect();
}


// Take a copy of the line from pos.
PLineList add_line( DWORD pos )
{
  PLineList ll;

  ll = malloc( sizeof(LineList) + WSZ(line.len - pos) );
  if (ll)
  {
    memcpy( ll->line, line.txt + pos, WSZ(line.len - pos) );
    ll->len  = line.len - pos;
    ll->next = NULL;
  }

  return ll;
}


// Free the memory used by a line list.
void free_linelist( PLineList ll )
{
  PLineList nxt;

  while (ll)
  {
    nxt = ll->next;
    free( ll );
    ll = nxt;
  }
}


// ------------------------------   Utility   --------------------------------


// Perform a binary search of cfg[] for name.  end is the index of the last
// item, NOT the number of items.  Return -1 if not found, otherwise the value
// appropriate to name.
int search_cfg( PCWSTR name, DWORD cnt, const Cfg cfg[], int end )
{
  int rc;
  int beg = 0, mid;

  while (end >= beg)
  {
    mid = (beg + end) / 2;
    rc	= _wcsnicmp( cfg[mid].name, name, cnt );
    if (rc == 0 && cfg[mid].name[cnt] == '\0')
      return cfg[mid].func;
    if (rc >= 0)
      end = mid - 1;
    else
      beg = mid + 1;
  }
  return -1;
}


// Return the keymap position of a key, or NULL if it is not recognised.
char* find_key( DWORD pos, DWORD cnt )
{
  PWSTR name = line.txt + pos;
  char* key  = NULL;
  int	state;
  int	ch;

  if (cnt < 2)
    return NULL;

  if ((cnt == 2 && *name == '^') ||
      (cnt == 3 && *name == '#' && name[1] == '^'))
  {
    state = (*name == '^') ? 0 : 1;
    ch = (name[state+1] | 0x20) - 0x60;
    if ((unsigned)ch < 32)
      key = &ctrl_key_table[ch][state];
  }
  else
  {
    state = 0;
    switch (*name)
    {
      case '@': ++state;        // alt
      case '^': ++state;        // ctrl
      case '#': ++state;        // shift
		++name;
		--cnt;
    }
    if (*name == 'f' || *name == 'F')
    {
      if (cnt == 2 && name[1] >= '1' && name[1] <= '9')
	key = &fkey_table[name[1] - '1'][state];
      else if (cnt == 3 && name[1] == '1' && name[2] >= '0' && name[2] <= '2')
	key = &fkey_table[9 + name[2] - '0'][state];
    }
    else  // no key happens to start with 'F'
    {
      if (*name == '^' && state == 1)
      {
	state = 3;		// shift+ctrl
	++name;
	--cnt;
      }
      ch = search_cfg( name, cnt, cfgkey, CFGKEYS - 1 );
      if (ch != -1)
	key = &key_table[ch - VK_PRIOR][state];
    }
  }

  return key;
}


// Make a copy of txt, returning a pointer to the copy.
PWSTR new_txt( PCWSTR txt, DWORD len )
{
  PWSTR t;

  t = malloc( WSZ(len) );
  if (t)
    memcpy( t, txt, WSZ(len) );

  return t;
}


// Ensure the line is long enough for the length.  If len is 0, initialise; if
// ~0, clean up.
BOOL make_line( DWORD len )
{
  if (len == 0)
  {
    line.txt = NULL;
    max = 0;
  }
  else if (len == ~0)
  {
    if (line.txt != NULL)
    {
      free( line.txt );
      line.txt = NULL;
    }
    len = 0;
  }
  else if (len > max)
  {
    PWSTR tmp = realloc( line.txt, WSZ(len) );
    if (tmp == NULL)
      return FALSE;
    line.txt = tmp;
    max = len;
  }
  line.len = len;
  return TRUE;
}


// Ensure txt of len is long enough for new_len.
BOOL make_length( PWSTR* txt, DWORD* len, DWORD new_len )
{
  PWSTR tmp;

  if (*len < new_len)
  {
    new_len += *len;
    tmp = realloc( *txt, WSZ(new_len) );
    if (tmp == NULL)
	return FALSE;
    *txt = tmp;
    *len = new_len;
  }
  return TRUE;
}


// Make a sound if it's not in silent mode.
void bell( void )
{
  if (!option.silent)
    MessageBeep( ~0 );			// standard beep
}


// Return the position of the first non-blank from pos.
DWORD skip_blank( DWORD pos )
{
  while (pos < line.len && isblank( line.txt[pos] ))
    ++pos;

  return pos;
}


// Return the position of the first blank from pos.
DWORD skip_nonblank( DWORD pos )
{
  while (pos < line.len && !isblank( line.txt[pos] ))
    ++pos;

  return pos;
}


// Return the position of the first delimiter from pos.
DWORD skip_nondelim( DWORD pos )
{
  while (pos < line.len && !wcschr( DEF_TERM, line.txt[pos] ))
    ++pos;

  return pos;
}


// Determine if a character is the beginning or end of a quoted string.
// An odd number of backslashes before the quote will treat it literally.
BOOL is_quote( int pos )
{
  BOOL lit;

  lit = FALSE;
  if (pos < line.len && line.txt[pos] == '"')
  {
    lit = TRUE;
    while (--pos >= 0 && line.txt[pos] == '\\')
      lit ^= TRUE;
  }

  return lit;
}


// Get the string starting from pos.  Returns the start position of it and sets
// cnt to its length.  If keep is true quotes are preserved; otherwise embedded
// quotes are made surrounding and the quotes are excluded from the string.
DWORD get_string( DWORD pos, LPDWORD cnt, BOOL keep )
{
  DWORD start;
  BOOL	quote, oq;		// has the open quote been added?
  DWORD cq = ~0;		// position of the close quote

  found_quote = quote = oq = FALSE;
  for (start = pos = skip_blank( pos ); pos < line.len; ++pos)
  {
    if (quote)
    {
      if (is_quote( pos ))
      {
	quote = FALSE;
	if (!keep)
	{
	  if (cq != ~0)
	  {
	    remove_chars( cq, 1 );
	    --pos;
	  }
	  cq = pos;
	}
      }
    }
    else if (is_quote( pos ))
    {
      found_quote = quote = TRUE;
      if (!keep)
      {
	if (oq)
	  remove_chars( pos--, 1 );
	else
	{
	  oq = TRUE;
	  if (pos != start)
	  {
	    memmove( line.txt + start + 1, line.txt + start, WSZ(pos - start) );
	    line.txt[start] = '"';
	    set_display_marks( start, pos + 1 );
	  }
	}
      }
    }
    else if (isblank( line.txt[pos] ))
      break;
  }
  if (!keep)
  {
    if (oq)
      ++start;
    if (cq != ~0)
    {
      if (cq != --pos)
      {
	memcpy( line.txt + cq, line.txt + cq + 1, WSZ(pos - cq) );
	line.txt[pos] = '"';
	set_display_marks( cq, pos + 1 );
      }
    }
  }

  *cnt = pos - start;
  return start;
}


// If unq is NULL, remove all non-quoted escape characters; otherwise only
// remove the escaped characters present in unq, inside quotes (let CMD.EXE
// handle those outside quotes).
void un_escape( PCWSTR unq )
{
  DWORD pos;
  BOOL	quote;

  if (!memchr( line.txt, ESCAPE, WSZ( line.len) ))
    return;

  quote = FALSE;
  for (pos = 0; pos < line.len; ++pos)
  {
    if (quote)
    {
      if (is_quote( pos ))
	quote = FALSE;
      else if (unq && line.txt[pos] == ESCAPE && pos+1 < line.len &&
	       wcschr( unq, line.txt[pos+1] ))
	remove_chars( pos, 1 );
    }
    else if (is_quote( pos ))
      quote = TRUE;
    else if (!unq && line.txt[pos] == ESCAPE && pos+1 < line.len)
      remove_chars( pos, 1 );
  }
}


// Determine if ext, of cnt characters, is a substring of extlist, which is a
// list of extensions, including dot, possibly separated by (semi)colon (eg:
// ".exe.com", ".exe;.com" or ".exe:.com").
BOOL match_ext( PCWSTR ext, DWORD cnt, PCWSTR extlist, DWORD extlen )
{
  DWORD pos, end;

  for (pos = 0; pos < extlen; pos = end)
  {
    for (end = pos; ++end < extlen && extlist[end] != '.' &&
				      extlist[end] != ';' &&
				      extlist[end] != ':';) ;
    if (end - pos == cnt && _wcsnicmp( extlist + pos, ext, cnt ) == 0)
    {
      assoc_pos = pos;
      return TRUE;
    }
    if (end == extlen)
      break;
    if (extlist[end] != '.')
      ++end;
  }

  return FALSE;
}


// Get an environment variable; if it doesn't exist use def, if it exists.
// The variable is stored in the global envvar buffer; its length is returned.
DWORD get_env_var( PCWSTR var, PCWSTR def )
{
  DWORD varlen;
  PWSTR v;
  BOOL	exist;

  varlen = GetEnvironmentVariable( var, envvar.txt, envvar.len );
  if (varlen == 0 && def && *def)
  {
    exist  = FALSE;
    varlen = wcslen( def );
    if (varlen <= envvar.len)
      memcpy( envvar.txt, def, WSZ(varlen) );
  }
  else
    exist = TRUE;

  if (varlen && varlen > envvar.len)
  {
    v = realloc( envvar.txt, WSZ(varlen) );
    if (!v)
      return 0;
    envvar.txt = v;
    envvar.len = varlen;
    if (exist)
      varlen = GetEnvironmentVariable( var, envvar.txt, envvar.len );
    else
      memcpy( envvar.txt, def, WSZ(varlen) );
  }

  return varlen;
}


// Show an internal command error.  If reading a file, remove the prompt and
// show the line number.
void show_error( PCWSTR err, DWORD pos, DWORD len )
{
  if (line_no && !seen_error)
  {
    remove_prompt( 0 );
    seen_error = TRUE;
  }
  fputws( L"CMDread: ", stdout );
  if (line_no)
    wprintf( L"%s:%d: ", file_name, line_no );
  wprintf( L"%s: %.*s.\n", err, (int)len, line.txt + pos );
}


// Set the locale code page, so printf outputs wide strings correctly.
void set_codepage( void )
{
  char cp[16];
  CPINFO cpi;

  sprintf( cp, ".%u", codepage = GetConsoleOutputCP() );
  setlocale( LC_CTYPE, cp );

  GetCPInfo( codepage, &cpi );
  dbcs = (cpi.LeadByte[0] != 0);
}


// Most double-byte characters also occupy two character cells, so need to
// translate the text position to a display position.  The only method I came
// across was to use the multibyte conversion, but that doesn't always work
// (e.g. in CP936, U+00B4 is one cell, but the conversion is double; perhaps
// using no best fit may have solved that, though).  The only other thing that
// seems to work is actually writing the string and seeing where the cursor
// ends up.  However, that only works in DBCS code pages; in SBCS, there doesn't
// seem any way to test for double-width chars (using the ReadConsoleOutput
// functions doesn't work - you just get the characters, not the cells).
DWORD display_length( PCWSTR txt, DWORD len, DWORD pos )
{
  if (dbcs)
  {
    HANDLE hCon;
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    COORD c;

    c.Y = 0;
    c.X = (len == 0) ? 0 : screen.dwCursorPosition.X;
    hCon = (len == 0) ? hConWid1 : hConWid;
    SetConsoleCursorPosition( hCon, c );
    WriteCon( hCon, txt, pos );
    GetConsoleScreenBufferInfo( hCon, &csbi );
    if (len == 0)
      return csbi.dwCursorPosition.X;

    // If we're at the edge of the screen and the next character is double-
    // width, add another space to account for it moving to the next line.
    if (csbi.dwCursorPosition.X == screen.dwSize.X - 1 && pos < len)
    {
      CONSOLE_SCREEN_BUFFER_INFO csbi1;
      WriteCon( hConWid, txt + pos, 1 );
      GetConsoleScreenBufferInfo( hConWid, &csbi1 );
      if (csbi1.dwCursorPosition.X == 2)
	++csbi.dwCursorPosition.X;
    }
    return csbi.dwCursorPosition.Y * csbi.dwSize.X
	   + csbi.dwCursorPosition.X - screen.dwCursorPosition.X;
  }

  return pos;
}


//-----------------------------------------------------------------------------
//   MyReadConsoleW
// It is the new function that must replace the original ReadConsoleW function.
// This function have exactly the same signature as the original one.
//-----------------------------------------------------------------------------

BOOL
WINAPI MyReadConsoleW( HANDLE hConsoleInput, LPVOID lpBuffer,
		       DWORD nNumberOfCharsToRead,
		       LPDWORD lpNumberOfCharsRead, LPVOID lpReserved )
{
  COORD c;
  int	j;
  DWORD mode;
  SMALL_RECT sr;
  CONSOLE_CURSOR_INFO cci;

  if (option.disable_CMDread)
  {
    local.enabled ^= TRUE;		// only disable this instance
    option.disable_CMDread = 0;
  }

  hConIn  = hConsoleInput;
  hConOut = GetStdHandle( STD_OUTPUT_HANDLE );
  if (local.enabled && nNumberOfCharsToRead > 1 &&
      GetConsoleMode( hConIn, &mode ) &&
      HIWORD( &lpBuffer ) != HIWORD( lpBuffer ) &&	// avoid SET /P
      GetConsoleScreenBufferInfo( hConOut, &screen ))
  {
    trap_break = TRUE;
    if (check_break)
    {
      while (macro_stk)
	pop_macro();
      if (mcmd.txt)
      {
	if (mcmd.len)
	  free( mcmd.txt );
	mcmd.txt = NULL;
      }
    }
    check_break = 1;

    set_codepage();

    // Create a buffer to determine the size of the prompt and the width of
    // DBCS double-width strings.
    hConWid = CreateConsoleScreenBuffer( GENERIC_READ | GENERIC_WRITE, 0, NULL,
					 CONSOLE_TEXTMODE_BUFFER, NULL );
    // Turn off processed output.
    if (dbcs)
      SetConsoleMode( hConWid, ENABLE_WRAP_AT_EOL_OUTPUT );
    // Create a buffer the same size as the current one and as many lines as
    // necessary to handle the double-width characters.
    c.X = screen.dwSize.X;
    c.Y = nNumberOfCharsToRead * 2 / c.X + 1;
    SetConsoleScreenBufferSize( hConWid, c );
    // Even though the cursor is on a different buffer, it still shows up on
    // the normal one.
    cci.dwSize = 1;
    cci.bVisible = FALSE;
    SetConsoleCursorInfo( hConWid, &cci );
    if (dbcs)
    {
      // Create another buffer to get the length of file names for the list.
      hConWid1 = CreateConsoleScreenBuffer( GENERIC_READ|GENERIC_WRITE, 0, NULL,
					    CONSOLE_TEXTMODE_BUFFER, NULL );
      SetConsoleMode( hConWid1, ENABLE_WRAP_AT_EOL_OUTPUT );
      // Create a single-line window, in order to create a single-line buffer.
      sr.Left = sr.Top = sr.Bottom = 0;
      sr.Right = screen.srWindow.Right - screen.srWindow.Left;
      SetConsoleWindowInfo( hConWid1, TRUE, &sr );
      // Create a sufficiently long single-line buffer to avoid wrap.
      c.X = nNumberOfCharsToRead * 2;
      c.Y = 1;
      SetConsoleScreenBufferSize( hConWid1, c );
      SetConsoleCursorInfo( hConWid1, &cci );
    }

    if (macro_stk || mcmd.txt)
      remove_prompt( 0 );
    else
    {
      if (!option.nocolour && prompt.len > 3 &&
	  prompt.txt[1] == ':' && prompt.txt[2] == '\\' &&
	  prompt.txt[prompt.len-1] == '>')
      {
	// Assume $P$G and colour it appropriately.
	WORD dir_col = option.base_col;
	p_attr[0] = p_attr[1] = option.drv_col;
	p_attr[2] = (prompt.txt[3] == '>') ? dir_col : option.sep_col;
	if (dbcs)
	{
	  DWORD dbcs_col;
	  DWORD last_sep = prompt.len;
	  // For DBCS, need to process forwards to find the double-width
	  // characters, so find the base directory now.
	  if (option.base_col != option.dir_col)
	  {
	    while (prompt.txt[--last_sep] != '\\') ;
	    if (last_sep != 2)
	      dir_col = option.dir_col;
	  }
	  j = p_attr_len = dbcs_col = 3;
	  while (j < prompt.len - 1)
	  {
	    if (prompt.txt[j] == '\\')
	    {
	      p_attr[p_attr_len++] = option.sep_col;
	      if (j == last_sep)
		dir_col = option.base_col;
	      ++dbcs_col;
	    }
	    else
	    {
	      p_attr[p_attr_len++] = dir_col;
	      ++dbcs_col;
	      if (prompt.txt[j] >= 0x80)
	      {
		if (display_length( prompt.txt + j, 0, 1 ) > 1)
		{
		  p_attr[p_attr_len++] = dir_col;
		  // High-level console output adds an extra space to prevent
		  // splitting a DBCS character.
		  if (++dbcs_col == screen.dwSize.X + 1)
		  {
		    p_attr[p_attr_len++] = dir_col;
		    dbcs_col = 2;
		  }
		}
	      }
	    }
	    if (dbcs_col >= screen.dwSize.X)
	      dbcs_col = 0;
	    ++j;
	  }
	  p_attr[p_attr_len++] = option.gt_col;
	}
	else
	{
	  p_attr_len = prompt.len;
	  j = prompt.len - 1;
	  p_attr[j] = option.gt_col;
	  while (--j > 2)
	  {
	    if (prompt.txt[j] == '\\')
	    {
	      p_attr[j] = option.sep_col;
	      dir_col = option.dir_col;
	    }
	    else
	      p_attr[j] = dir_col;
	  }
	}
	c.X = 0;
	c.Y = screen.dwCursorPosition.Y - p_attr_len / screen.dwSize.X;
	WriteConsoleOutputAttribute( hConOut, p_attr, p_attr_len, c, &conwr );
      }
      else
	p_attr_len = 0;
    }

    if (*cfgname)
    {
      read_cmdfile( cfgname );
      *cfgname = 0;
    }

    check_history();

    line.txt = lpBuffer;
    max = nNumberOfCharsToRead - 2;	// leave room for CRLF
    show_prompt = FALSE;
    if (option.disable_macro)
      get_next_line();
    else
    {
      do
      {
	get_next_line();
	multi_cmd();
	do
	{
	  if (check_break > 1)
	    break;
	  if (line.len != 0 && *line.txt == '@')
	  {
	    remove_chars( 0, 1 );
	    dosify();
	  }
	  if (line.len != 0 && *line.txt == option.ignore_char)
	  {
	    remove_chars( 0, 1 );
	    break;
	  }
	  expand_braces();
	} while (associate() || expand_symbol() || expand_macro());
      } while (internal_cmd());
      expand_vars( FALSE );
    }

    line.txt[line.len++] = '\r';
    line.txt[line.len++] = '\n';
    *lpNumberOfCharsRead = line.len;

    CloseHandle( hConWid );
    if (dbcs)
      CloseHandle( hConWid1 );
    prompt.len	= 0;
    trap_break	= FALSE;
    check_break = 0;
    return TRUE;
  }

  return ReadConsoleW( hConsoleInput, lpBuffer, nNumberOfCharsToRead,
		       lpNumberOfCharsRead, lpReserved );
}


// Indicate Control+Break was received.
BOOL ctrl_break( DWORD type )
{
  if (type == CTRL_BREAK_EVENT)
  {
    ++check_break;
    return trap_break;
  }
  return FALSE;
}


// Assume the output prior to input is the prompt.
BOOL
WINAPI MyWriteConsoleW( HANDLE hConsoleOutput, CONST VOID* lpBuffer,
			DWORD nNumberOfCharsToWrite,
			LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved )
{
  if (nNumberOfCharsToWrite == 2 && memcmp( lpBuffer, L"\r\n", 4 ) == 0)
  {
    // Remember where the previous command finished, so we can restore it.
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo( hConsoleOutput, &csbi );
    lastc = csbi.dwCursorPosition;
    erase_prompt = 1;

    if (hidden_cmd)
    {
      // For a command with no output, we want to prevent this being written,
      // so the prompt remains where it is.  However, if there was output, we
      // still want to separate the output from the new prompt.  If the cursor
      // is not at the start of the line, it's safe to assume output; otherwise
      // see if the previous line is blank (no real need to add a second blank).
      if (lastc.X != 0)
	hidden_cmd = FALSE;
      else
      {
	WCHAR blank[80];	// the first 80 chars should be enough
	DWORD sz = min( csbi.dwSize.X, 80 );
	--csbi.dwCursorPosition.Y;
	ReadConsoleOutputCharacter( hConsoleOutput, blank, sz,
				    csbi.dwCursorPosition, &conwr );
	for (sz = 0; sz < conwr; ++sz)
	{
	  if (blank[sz] != ' ')
	  {
	    hidden_cmd = FALSE;
	    break;
	  }
	}
      }
      if (hidden_cmd)
      {
	hidden_cmd = FALSE;
	if (lpNumberOfCharsWritten)
	  *lpNumberOfCharsWritten = nNumberOfCharsToWrite;
	return TRUE;
      }
    }
  }
  else
  {
    prompt.txt = (PWSTR)lpBuffer;
    prompt.len = nNumberOfCharsToWrite;
    erase_prompt = 2;
  }
  hidden_cmd = FALSE;

  return WriteConsoleW( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite,
			lpNumberOfCharsWritten, lpReserved );
}


// ========== Hooking API functions
//
// References about API hooking (and dll injection):
// - Matt Pietrek ~ Windows 95 System Programming Secrets.
// - Jeffrey Richter ~ Programming Applications for Microsoft Windows 4th ed.

// Macro for adding pointers/DWORDs together without C arithmetic interfering
#define MakeVA( cast, addValue ) \
  (cast)((DWORD_PTR)pDosHeader + (DWORD_PTR)(addValue))

typedef struct
{
  PSTR	name;
  DWORD_PTR newfunc;
  DWORD_PTR oldfunc;
} HookFn, *PHookFn;


//-----------------------------------------------------------------------------
//   HookAPIOneMod
// Substitute a new function in the Import Address Table (IAT) of the
// specified module.
// Return FALSE on error and TRUE on success.
//-----------------------------------------------------------------------------

BOOL HookAPIOneMod(
    HMODULE hFromModule,	// Handle of the module to intercept calls from
    PHookFn Hooks		// Functions to replace
    )
{
  PIMAGE_DOS_HEADER	   pDosHeader;
  PIMAGE_NT_HEADERS	   pNTHeader;
  PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
  PIMAGE_THUNK_DATA	   pThunk, pNameThunk;
  PHookFn		   hook;

  // Tests to make sure we're looking at a module image (the 'MZ' header)
  pDosHeader = (PIMAGE_DOS_HEADER)hFromModule;
  if (IsBadReadPtr( pDosHeader, sizeof(IMAGE_DOS_HEADER) ))
  {
    DEBUGSTR( L"error: %S(%d)", __FILE__, __LINE__ );
    return FALSE;
  }
  if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE)
  {
    DEBUGSTR( L"error: %S(%d)", __FILE__, __LINE__ );
    return FALSE;
  }

  // The MZ header has a pointer to the PE header
  pNTHeader = MakeVA( PIMAGE_NT_HEADERS, pDosHeader->e_lfanew );

  // More tests to make sure we're looking at a "PE" image
  if (IsBadReadPtr( pNTHeader, sizeof(IMAGE_NT_HEADERS) ))
  {
    DEBUGSTR( L"error: %S(%d)", __FILE__, __LINE__ );
    return FALSE;
  }
  if (pNTHeader->Signature != IMAGE_NT_SIGNATURE)
  {
    DEBUGSTR( L"error: %S(%d)", __FILE__, __LINE__ );
    return FALSE;
  }

  // We now have a valid pointer to the module's PE header.
  // Get a pointer to its imports section
  pImportDesc = MakeVA( PIMAGE_IMPORT_DESCRIPTOR,
			pNTHeader->OptionalHeader.
			 DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].
			  VirtualAddress );

  // Bail out if the RVA of the imports section is 0 (it doesn't exist)
  if (pImportDesc == (PIMAGE_IMPORT_DESCRIPTOR)pNTHeader)
  {
    return TRUE;
  }

  // Iterate through the array of imported module descriptors, looking
  // for the module whose name matches the pszFunctionModule parameter
  for (;; pImportDesc++)
  {
    PSTR pszModName = MakeVA( PSTR, pImportDesc->Name );

    // Bail out if we didn't find the import module descriptor for the
    // specified module (Name will be 0).
    if (pszModName == (PSTR)pDosHeader)
      return TRUE;

    if (_stricmp( pszModName, "kernel32.dll" ) == 0 ||
	_strnicmp( pszModName, "API-MS-Win-Core-Console-", 24 ) == 0)
      break;
  }

  // Get a pointer to the found module's import address table (IAT)
  pThunk = MakeVA( PIMAGE_THUNK_DATA, pImportDesc->FirstThunk );
  pNameThunk = MakeVA( PIMAGE_THUNK_DATA, pImportDesc->OriginalFirstThunk );

  // Blast through the table of import names
  while (pNameThunk->u1.AddressOfData)
  {
    PIMAGE_IMPORT_BY_NAME pName = MakeVA( PIMAGE_IMPORT_BY_NAME,
					  pNameThunk->u1.AddressOfData );
    LPCSTR name = (LPCSTR)pName->Name;
    for (hook = Hooks; hook->name; ++hook)
    {
      if (strcmp( name, hook->name ) == 0) // We found it!
      {
	DWORD flOldProtect, flDummy;

	// Change the access protection on the region of committed pages in the
	// virtual address space of the current process
	VirtualProtect( &pThunk->u1.Function, sizeof(PVOID),
			PAGE_READWRITE, &flOldProtect );

	// Overwrite the original address with the address of the new function
	if (hook->oldfunc)
	{
	  pThunk->u1.Function = hook->oldfunc;
	}
	else
	{
	  hook->oldfunc = pThunk->u1.Function;
	  pThunk->u1.Function = hook->newfunc;
	}

	// Put the page attributes back the way they were.
	VirtualProtect( &pThunk->u1.Function, sizeof(PVOID),
			flOldProtect, &flDummy );
      }
    }
    pThunk++;	// Advance to next imported function address
    pNameThunk++;
  }
  return TRUE;	// Function not found
}


// ========== Initialisation

HookFn Hooks[] = {
  { "ReadConsoleW",  (DWORD_PTR)MyReadConsoleW,  0 },
  { "WriteConsoleW", (DWORD_PTR)MyWriteConsoleW, 0 },
  { NULL, 0, 0 }
};


//-----------------------------------------------------------------------------
//   DllMain()
// Function called by the system when processes and threads are initialized
// and terminated.
//-----------------------------------------------------------------------------

BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved )
{
  switch (dwReason)
  {
    case DLL_PROCESS_ATTACH:
      // Don't bother hooking into CMDread.
      if (lpReserved)			// static initialisation
	break;

      if (HookAPIOneMod( GetModuleHandle( NULL ), Hooks ))
      {
	HookAPIOneMod( hInstance, Hooks );

	if (primary_id == 0 || cmd_history)
	{
	  check_history();
	  read_history();
	  if (primary_id == 0)
	  {
	    primary = TRUE;
	    primary_id = GetCurrentProcessId();
	  }
	}
	else
	{
	  *hstname = '\0';
	  copy_parent_history();
	}
	SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ctrl_break, TRUE );
      }
    break;

    case DLL_PROCESS_DETACH:
      if (save_history)
	write_history();
      if (primary)
	primary_id = 0;
    break;
  }

  return TRUE;
}