~ubuntu-branches/ubuntu/feisty/fpc/feisty

« back to all changes in this revision

Viewing changes to packages/extra/winunits/jwawincon.pas

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-01-27 20:08:50 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070127200850-9mrptaqqjsx9nwa7
Tags: 2.0.4-5
* Fixed Build-Depends.
* Add myself to Uploaders in debian/control.
* Make sure that the sources are really patched before building them.
* Build unit 'libc' on powerpc too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
{******************************************************************************}
2
 
{                                                                              }
3
 
{ Console Applications API interface Unit for Object Pascal                    }
4
 
{                                                                              }
5
 
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
6
 
{ Corporation. All Rights Reserved.                                            }
7
 
{                                                                              }
8
 
{ The original file is: wincon.h, released June 2000. The original Pascal      }
9
 
{ code is: WinCon.pas, released December 2000. The initial developer of the    }
10
 
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
11
 
{                                                                              }
12
 
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
13
 
{ Marcel van Brakel. All Rights Reserved.                                      }
14
 
{                                                                              }
15
 
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
16
 
{                                                                              }
17
 
{ You may retrieve the latest version of this file at the Project JEDI         }
18
 
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
19
 
{                                                                              }
20
 
{ The contents of this file are used with permission, subject to the Mozilla   }
21
 
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
 
{ in compliance with the License. You may obtain a copy of the License at      }
23
 
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
24
 
{                                                                              }
25
 
{ Software distributed under the License is distributed on an "AS IS" basis,   }
26
 
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
 
{ the specific language governing rights and limitations under the License.    }
28
 
{                                                                              }
29
 
{ Alternatively, the contents of this file may be used under the terms of the  }
30
 
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
31
 
{ provisions of the LGPL License are applicable instead of those above.        }
32
 
{ If you wish to allow use of your version of this file only under the terms   }
33
 
{ of the LGPL License and not to allow others to use your version of this file }
34
 
{ under the MPL, indicate your decision by deleting  the provisions above and  }
35
 
{ replace  them with the notice and other provisions required by the LGPL      }
36
 
{ License.  If you do not delete the provisions above, a recipient may use     }
37
 
{ your version of this file under either the MPL or the LGPL License.          }
38
 
{                                                                              }
39
 
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40
 
{                                                                              }
41
 
{******************************************************************************}
42
 
 
43
 
// $Id: jwawincon.pas,v 1.1 2005/04/04 07:56:11 marco Exp $
44
 
 
45
 
unit JwaWinCon;
46
 
 
47
 
{$WEAKPACKAGEUNIT}
48
 
 
49
 
{$HPPEMIT ''}
50
 
{$HPPEMIT '#include "WinCon.h"'}
51
 
{$HPPEMIT ''}
52
 
 
53
 
{$I jediapilib.inc}
54
 
 
55
 
interface
56
 
 
57
 
uses
58
 
  JwaWinBase, JwaWinType;
59
 
 
60
 
type
61
 
  PCOORD = ^COORD;
62
 
  {$EXTERNALSYM PCOORD}
63
 
  _COORD = record
64
 
    X: SHORT;
65
 
    Y: SHORT;
66
 
  end;
67
 
  {$EXTERNALSYM _COORD}
68
 
  COORD = _COORD;
69
 
  {$EXTERNALSYM COORD}
70
 
  TCoord = _COORD;
71
 
 
72
 
  PSMALL_RECT = ^SMALL_RECT;
73
 
  {$EXTERNALSYM PSMALL_RECT}
74
 
  _SMALL_RECT = record
75
 
    Left: SHORT;
76
 
    Top: SHORT;
77
 
    Right: SHORT;
78
 
    Bottom: SHORT;
79
 
  end;
80
 
  {$EXTERNALSYM _SMALL_RECT}
81
 
  SMALL_RECT = _SMALL_RECT;
82
 
  {$EXTERNALSYM SMALL_RECT}
83
 
  TSmallRect = SMALL_RECT;
84
 
  PSmallRect = PSMALL_RECT;
85
 
 
86
 
  TCharUnion = record
87
 
    case Integer of
88
 
      0: (UnicodeChar: WCHAR);
89
 
      1: (AsciiChar: CHAR);
90
 
  end;
91
 
 
92
 
  PKEY_EVENT_RECORD = ^KEY_EVENT_RECORD;
93
 
  {$EXTERNALSYM PKEY_EVENT_RECORD}
94
 
  _KEY_EVENT_RECORD = record
95
 
    bKeyDown: BOOL;
96
 
    wRepeatCount: WORD;
97
 
    wVirtualKeyCode: WORD;
98
 
    wVirtualScanCode: WORD;
99
 
    uChar: TCharUnion;
100
 
    dwControlKeyState: DWORD;
101
 
  end;
102
 
  {$EXTERNALSYM _KEY_EVENT_RECORD}
103
 
  KEY_EVENT_RECORD = _KEY_EVENT_RECORD;
104
 
  {$EXTERNALSYM KEY_EVENT_RECORD}
105
 
  TKeyEventRecord = KEY_EVENT_RECORD;
106
 
  PKeyEventRecord = PKEY_EVENT_RECORD;
107
 
 
108
 
//
109
 
// ControlKeyState flags
110
 
//
111
 
 
112
 
const
113
 
  RIGHT_ALT_PRESSED  = $0001; // the right alt key is pressed.
114
 
  {$EXTERNALSYM RIGHT_ALT_PRESSED}
115
 
  LEFT_ALT_PRESSED   = $0002; // the left alt key is pressed.
116
 
  {$EXTERNALSYM LEFT_ALT_PRESSED}
117
 
  RIGHT_CTRL_PRESSED = $0004; // the right ctrl key is pressed.
118
 
  {$EXTERNALSYM RIGHT_CTRL_PRESSED}
119
 
  LEFT_CTRL_PRESSED  = $0008; // the left ctrl key is pressed.
120
 
  {$EXTERNALSYM LEFT_CTRL_PRESSED}
121
 
  SHIFT_PRESSED      = $0010; // the shift key is pressed.
122
 
  {$EXTERNALSYM SHIFT_PRESSED}
123
 
  NUMLOCK_ON         = $0020; // the numlock light is on.
124
 
  {$EXTERNALSYM NUMLOCK_ON}
125
 
  SCROLLLOCK_ON      = $0040; // the scrolllock light is on.
126
 
  {$EXTERNALSYM SCROLLLOCK_ON}
127
 
  CAPSLOCK_ON        = $0080; // the capslock light is on.
128
 
  {$EXTERNALSYM CAPSLOCK_ON}
129
 
  ENHANCED_KEY       = $0100; // the key is enhanced.
130
 
  {$EXTERNALSYM ENHANCED_KEY}
131
 
  NLS_DBCSCHAR       = $00010000; // DBCS for JPN: SBCS/DBCS mode.
132
 
  {$EXTERNALSYM NLS_DBCSCHAR}
133
 
  NLS_ALPHANUMERIC   = $00000000; // DBCS for JPN: Alphanumeric mode.
134
 
  {$EXTERNALSYM NLS_ALPHANUMERIC}
135
 
  NLS_KATAKANA       = $00020000; // DBCS for JPN: Katakana mode.
136
 
  {$EXTERNALSYM NLS_KATAKANA}
137
 
  NLS_HIRAGANA       = $00040000; // DBCS for JPN: Hiragana mode.
138
 
  {$EXTERNALSYM NLS_HIRAGANA}
139
 
  NLS_ROMAN          = $00400000; // DBCS for JPN: Roman/Noroman mode.
140
 
  {$EXTERNALSYM NLS_ROMAN}
141
 
  NLS_IME_CONVERSION = $00800000; // DBCS for JPN: IME conversion.
142
 
  {$EXTERNALSYM NLS_IME_CONVERSION}
143
 
  NLS_IME_DISABLE    = $20000000; // DBCS for JPN: IME enable/disable.
144
 
  {$EXTERNALSYM NLS_IME_DISABLE}
145
 
 
146
 
type
147
 
  PMOUSE_EVENT_RECORD = ^MOUSE_EVENT_RECORD;
148
 
  {$EXTERNALSYM PMOUSE_EVENT_RECORD}
149
 
  _MOUSE_EVENT_RECORD = record
150
 
    dwMousePosition: COORD;
151
 
    dwButtonState: DWORD;
152
 
    dwControlKeyState: DWORD;
153
 
    dwEventFlags: DWORD;
154
 
  end;
155
 
  {$EXTERNALSYM _MOUSE_EVENT_RECORD}
156
 
  MOUSE_EVENT_RECORD = _MOUSE_EVENT_RECORD;
157
 
  {$EXTERNALSYM MOUSE_EVENT_RECORD}
158
 
  TMouseEventRecord = MOUSE_EVENT_RECORD;
159
 
  PMouseEventRecord = PMOUSE_EVENT_RECORD;
160
 
 
161
 
//
162
 
// ButtonState flags
163
 
//
164
 
 
165
 
const
166
 
  FROM_LEFT_1ST_BUTTON_PRESSED = $0001;
167
 
  {$EXTERNALSYM FROM_LEFT_1ST_BUTTON_PRESSED}
168
 
  RIGHTMOST_BUTTON_PRESSED     = $0002;
169
 
  {$EXTERNALSYM RIGHTMOST_BUTTON_PRESSED}
170
 
  FROM_LEFT_2ND_BUTTON_PRESSED = $0004;
171
 
  {$EXTERNALSYM FROM_LEFT_2ND_BUTTON_PRESSED}
172
 
  FROM_LEFT_3RD_BUTTON_PRESSED = $0008;
173
 
  {$EXTERNALSYM FROM_LEFT_3RD_BUTTON_PRESSED}
174
 
  FROM_LEFT_4TH_BUTTON_PRESSED = $0010;
175
 
  {$EXTERNALSYM FROM_LEFT_4TH_BUTTON_PRESSED}
176
 
 
177
 
//
178
 
// EventFlags
179
 
//
180
 
 
181
 
  MOUSE_MOVED   = $0001;
182
 
  {$EXTERNALSYM MOUSE_MOVED}
183
 
  DOUBLE_CLICK  = $0002;
184
 
  {$EXTERNALSYM DOUBLE_CLICK}
185
 
  MOUSE_WHEELED = $0004;
186
 
  {$EXTERNALSYM MOUSE_WHEELED}
187
 
 
188
 
type
189
 
  PWINDOW_BUFFER_SIZE_RECORD = ^WINDOW_BUFFER_SIZE_RECORD;
190
 
  {$EXTERNALSYM PWINDOW_BUFFER_SIZE_RECORD}
191
 
  _WINDOW_BUFFER_SIZE_RECORD = record
192
 
    dwSize: COORD;
193
 
  end;
194
 
  {$EXTERNALSYM _WINDOW_BUFFER_SIZE_RECORD}
195
 
  WINDOW_BUFFER_SIZE_RECORD = _WINDOW_BUFFER_SIZE_RECORD;
196
 
  {$EXTERNALSYM WINDOW_BUFFER_SIZE_RECORD}
197
 
  TWindowBufferSizeRecord = WINDOW_BUFFER_SIZE_RECORD;
198
 
  PWindowBufferSizeRecord = PWINDOW_BUFFER_SIZE_RECORD;
199
 
 
200
 
  PMENU_EVENT_RECORD = ^MENU_EVENT_RECORD;
201
 
  {$EXTERNALSYM PMENU_EVENT_RECORD}
202
 
  _MENU_EVENT_RECORD = record
203
 
    dwCommandId: UINT;
204
 
  end;
205
 
  {$EXTERNALSYM _MENU_EVENT_RECORD}
206
 
  MENU_EVENT_RECORD = _MENU_EVENT_RECORD;
207
 
  {$EXTERNALSYM MENU_EVENT_RECORD}
208
 
  TMenuEventRecord = MENU_EVENT_RECORD;
209
 
  PMenuEventRecord = PMENU_EVENT_RECORD;
210
 
 
211
 
  PFOCUS_EVENT_RECORD = ^FOCUS_EVENT_RECORD;
212
 
  {$EXTERNALSYM PFOCUS_EVENT_RECORD}
213
 
  _FOCUS_EVENT_RECORD = record
214
 
    bSetFocus: BOOL;
215
 
  end;
216
 
  {$EXTERNALSYM _FOCUS_EVENT_RECORD}
217
 
  FOCUS_EVENT_RECORD = _FOCUS_EVENT_RECORD;
218
 
  {$EXTERNALSYM FOCUS_EVENT_RECORD}
219
 
  TFocusEventRecord = FOCUS_EVENT_RECORD;
220
 
  PFocusEventRecord = PFOCUS_EVENT_RECORD;
221
 
 
222
 
  PINPUT_RECORD = ^INPUT_RECORD;
223
 
  {$EXTERNALSYM PINPUT_RECORD}
224
 
  _INPUT_RECORD = record
225
 
    EventType: WORD;
226
 
    case Integer of
227
 
      0: (KeyEvent: KEY_EVENT_RECORD);
228
 
      1: (MouseEvent: MOUSE_EVENT_RECORD);
229
 
      2: (WindowBufferSizeEvent: WINDOW_BUFFER_SIZE_RECORD);
230
 
      3: (MenuEvent: MENU_EVENT_RECORD);
231
 
      4: (FocusEvent: FOCUS_EVENT_RECORD);
232
 
  end;
233
 
  {$EXTERNALSYM _INPUT_RECORD}
234
 
  INPUT_RECORD = _INPUT_RECORD;
235
 
  {$EXTERNALSYM INPUT_RECORD}
236
 
  TInputRecord = INPUT_RECORD;
237
 
  PInputRecord = PINPUT_RECORD;
238
 
 
239
 
//
240
 
//  EventType flags:
241
 
//
242
 
 
243
 
const
244
 
  KEY_EVENT                = $0001; // Event contains key event record
245
 
  {$EXTERNALSYM KEY_EVENT}
246
 
  MOUSE_EVENT              = $0002; // Event contains mouse event record
247
 
  {$EXTERNALSYM MOUSE_EVENT}
248
 
  WINDOW_BUFFER_SIZE_EVENT = $0004; // Event contains window change event record
249
 
  {$EXTERNALSYM WINDOW_BUFFER_SIZE_EVENT}
250
 
  MENU_EVENT               = $0008; // Event contains menu event record
251
 
  {$EXTERNALSYM MENU_EVENT}
252
 
  FOCUS_EVENT              = $0010; // event contains focus change
253
 
  {$EXTERNALSYM FOCUS_EVENT}
254
 
 
255
 
type
256
 
  PCHAR_INFO = ^CHAR_INFO;
257
 
  {$EXTERNALSYM PCHAR_INFO}
258
 
  _CHAR_INFO = record
259
 
    uChar: TCharUnion;
260
 
    Attributes: WORD;
261
 
  end;
262
 
  {$EXTERNALSYM _CHAR_INFO}
263
 
  CHAR_INFO = _CHAR_INFO;
264
 
  {$EXTERNALSYM CHAR_INFO}
265
 
  TCharInfo = CHAR_INFO;
266
 
  PCharInfo = PCHAR_INFO;
267
 
 
268
 
//
269
 
// Attributes flags:
270
 
//
271
 
 
272
 
const
273
 
  FOREGROUND_BLUE            = $0001; // text color contains blue.
274
 
  {$EXTERNALSYM FOREGROUND_BLUE}
275
 
  FOREGROUND_GREEN           = $0002; // text color contains green.
276
 
  {$EXTERNALSYM FOREGROUND_GREEN}
277
 
  FOREGROUND_RED             = $0004; // text color contains red.
278
 
  {$EXTERNALSYM FOREGROUND_RED}
279
 
  FOREGROUND_INTENSITY       = $0008; // text color is intensified.
280
 
  {$EXTERNALSYM FOREGROUND_INTENSITY}
281
 
  BACKGROUND_BLUE            = $0010; // background color contains blue.
282
 
  {$EXTERNALSYM BACKGROUND_BLUE}
283
 
  BACKGROUND_GREEN           = $0020; // background color contains green.
284
 
  {$EXTERNALSYM BACKGROUND_GREEN}
285
 
  BACKGROUND_RED             = $0040; // background color contains red.
286
 
  {$EXTERNALSYM BACKGROUND_RED}
287
 
  BACKGROUND_INTENSITY       = $0080; // background color is intensified.
288
 
  {$EXTERNALSYM BACKGROUND_INTENSITY}
289
 
  COMMON_LVB_LEADING_BYTE    = $0100; // Leading Byte of DBCS
290
 
  {$EXTERNALSYM COMMON_LVB_LEADING_BYTE}
291
 
  COMMON_LVB_TRAILING_BYTE   = $0200; // Trailing Byte of DBCS
292
 
  {$EXTERNALSYM COMMON_LVB_TRAILING_BYTE}
293
 
  COMMON_LVB_GRID_HORIZONTAL = $0400; // DBCS: Grid attribute: top horizontal.
294
 
  {$EXTERNALSYM COMMON_LVB_GRID_HORIZONTAL}
295
 
  COMMON_LVB_GRID_LVERTICAL  = $0800; // DBCS: Grid attribute: left vertical.
296
 
  {$EXTERNALSYM COMMON_LVB_GRID_LVERTICAL}
297
 
  COMMON_LVB_GRID_RVERTICAL  = $1000; // DBCS: Grid attribute: right vertical.
298
 
  {$EXTERNALSYM COMMON_LVB_GRID_RVERTICAL}
299
 
  COMMON_LVB_REVERSE_VIDEO   = $4000; // DBCS: Reverse fore/back ground attribute.
300
 
  {$EXTERNALSYM COMMON_LVB_REVERSE_VIDEO}
301
 
  COMMON_LVB_UNDERSCORE      = $8000; // DBCS: Underscore.
302
 
  {$EXTERNALSYM COMMON_LVB_UNDERSCORE}
303
 
 
304
 
  COMMON_LVB_SBCSDBCS        = $0300; // SBCS or DBCS flag.
305
 
  {$EXTERNALSYM COMMON_LVB_SBCSDBCS}
306
 
 
307
 
type
308
 
  PCONSOLE_SCREEN_BUFFER_INFO = ^CONSOLE_SCREEN_BUFFER_INFO;
309
 
  {$EXTERNALSYM PCONSOLE_SCREEN_BUFFER_INFO}
310
 
  _CONSOLE_SCREEN_BUFFER_INFO = record
311
 
    dwSize: COORD;
312
 
    dwCursorPosition: COORD;
313
 
    wAttributes: WORD;
314
 
    srWindow: SMALL_RECT;
315
 
    dwMaximumWindowSize: COORD;
316
 
  end;
317
 
  {$EXTERNALSYM _CONSOLE_SCREEN_BUFFER_INFO}
318
 
  CONSOLE_SCREEN_BUFFER_INFO = _CONSOLE_SCREEN_BUFFER_INFO;
319
 
  {$EXTERNALSYM CONSOLE_SCREEN_BUFFER_INFO}
320
 
  TConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO;
321
 
  PConsoleScreenBufferInfo = PCONSOLE_SCREEN_BUFFER_INFO;
322
 
 
323
 
  PCONSOLE_CURSOR_INFO = ^CONSOLE_CURSOR_INFO;
324
 
  {$EXTERNALSYM PCONSOLE_CURSOR_INFO}
325
 
  _CONSOLE_CURSOR_INFO = record
326
 
    dwSize: DWORD;
327
 
    bVisible: BOOL;
328
 
  end;
329
 
  {$EXTERNALSYM _CONSOLE_CURSOR_INFO}
330
 
  CONSOLE_CURSOR_INFO = _CONSOLE_CURSOR_INFO;
331
 
  {$EXTERNALSYM CONSOLE_CURSOR_INFO}
332
 
  TConsoleCursorInfo = CONSOLE_CURSOR_INFO;
333
 
  PConsoleCursorInfo = PCONSOLE_CURSOR_INFO;
334
 
 
335
 
  _CONSOLE_FONT_INFO = record
336
 
    nFont: DWORD;
337
 
    dwFontSize: COORD;
338
 
  end;
339
 
  {$EXTERNALSYM _CONSOLE_FONT_INFO}
340
 
  CONSOLE_FONT_INFO = _CONSOLE_FONT_INFO;
341
 
  {$EXTERNALSYM CONSOLE_FONT_INFO}
342
 
  PCONSOLE_FONT_INFO = ^CONSOLE_FONT_INFO;
343
 
  {$EXTERNALSYM PCONSOLE_FONT_INFO}
344
 
  TConsoleFontInfo = CONSOLE_FONT_INFO;
345
 
  PConsoleFontInfo = PCONSOLE_FONT_INFO;
346
 
 
347
 
  _CONSOLE_SELECTION_INFO = record
348
 
    dwFlags: DWORD;
349
 
    dwSelectionAnchor: COORD;
350
 
    srSelection: SMALL_RECT;
351
 
  end;
352
 
  {$EXTERNALSYM _CONSOLE_SELECTION_INFO}
353
 
  CONSOLE_SELECTION_INFO = _CONSOLE_SELECTION_INFO;
354
 
  {$EXTERNALSYM CONSOLE_SELECTION_INFO}
355
 
  PCONSOLE_SELECTION_INFO = ^CONSOLE_SELECTION_INFO;
356
 
  {$EXTERNALSYM PCONSOLE_SELECTION_INFO}
357
 
  TConsoleSelectionInfo = CONSOLE_SELECTION_INFO;
358
 
  PConsoleSelectionInfo = PCONSOLE_SELECTION_INFO;  
359
 
 
360
 
//
361
 
// Selection flags
362
 
//
363
 
 
364
 
const
365
 
  CONSOLE_NO_SELECTION          = $0000;
366
 
  {$EXTERNALSYM CONSOLE_NO_SELECTION}
367
 
  CONSOLE_SELECTION_IN_PROGRESS = $0001;   // selection has begun
368
 
  {$EXTERNALSYM CONSOLE_SELECTION_IN_PROGRESS}
369
 
  CONSOLE_SELECTION_NOT_EMPTY   = $0002;   // non-null select rectangle
370
 
  {$EXTERNALSYM CONSOLE_SELECTION_NOT_EMPTY}
371
 
  CONSOLE_MOUSE_SELECTION       = $0004;   // selecting with mouse
372
 
  {$EXTERNALSYM CONSOLE_MOUSE_SELECTION}
373
 
  CONSOLE_MOUSE_DOWN            = $0008;   // mouse is down
374
 
  {$EXTERNALSYM CONSOLE_MOUSE_DOWN}
375
 
 
376
 
//
377
 
// typedef for ctrl-c handler routines
378
 
//
379
 
 
380
 
type
381
 
  PHANDLER_ROUTINE = function(CtrlType: DWORD): BOOL; stdcall;
382
 
  {$EXTERNALSYM PHANDLER_ROUTINE}
383
 
  THandlerRoutine = PHANDLER_ROUTINE;
384
 
 
385
 
const
386
 
  CTRL_C_EVENT        = 0;
387
 
  {$EXTERNALSYM CTRL_C_EVENT}
388
 
  CTRL_BREAK_EVENT    = 1;
389
 
  {$EXTERNALSYM CTRL_BREAK_EVENT}
390
 
  CTRL_CLOSE_EVENT    = 2;
391
 
  {$EXTERNALSYM CTRL_CLOSE_EVENT}
392
 
  // 3 is reserved!
393
 
  // 4 is reserved!
394
 
  CTRL_LOGOFF_EVENT   = 5;
395
 
  {$EXTERNALSYM CTRL_LOGOFF_EVENT}
396
 
  CTRL_SHUTDOWN_EVENT = 6;
397
 
  {$EXTERNALSYM CTRL_SHUTDOWN_EVENT}
398
 
 
399
 
//
400
 
//  Input Mode flags:
401
 
//
402
 
 
403
 
  ENABLE_PROCESSED_INPUT = $0001;
404
 
  {$EXTERNALSYM ENABLE_PROCESSED_INPUT}
405
 
  ENABLE_LINE_INPUT      = $0002;
406
 
  {$EXTERNALSYM ENABLE_LINE_INPUT}
407
 
  ENABLE_ECHO_INPUT      = $0004;
408
 
  {$EXTERNALSYM ENABLE_ECHO_INPUT}
409
 
  ENABLE_WINDOW_INPUT    = $0008;
410
 
  {$EXTERNALSYM ENABLE_WINDOW_INPUT}
411
 
  ENABLE_MOUSE_INPUT     = $0010;
412
 
  {$EXTERNALSYM ENABLE_MOUSE_INPUT}
413
 
 
414
 
//
415
 
// Output Mode flags:
416
 
//
417
 
 
418
 
  ENABLE_PROCESSED_OUTPUT   = $0001;
419
 
  {$EXTERNALSYM ENABLE_PROCESSED_OUTPUT}
420
 
  ENABLE_WRAP_AT_EOL_OUTPUT = $0002;
421
 
  {$EXTERNALSYM ENABLE_WRAP_AT_EOL_OUTPUT}
422
 
 
423
 
//
424
 
// direct API definitions.
425
 
//
426
 
 
427
 
function PeekConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
428
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
429
 
{$EXTERNALSYM PeekConsoleInputA}
430
 
function PeekConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
431
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
432
 
{$EXTERNALSYM PeekConsoleInputW}
433
 
function PeekConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
434
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
435
 
{$EXTERNALSYM PeekConsoleInput}
436
 
 
437
 
function ReadConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
438
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
439
 
{$EXTERNALSYM ReadConsoleInputA}
440
 
function ReadConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
441
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
442
 
{$EXTERNALSYM ReadConsoleInputW}
443
 
function ReadConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
444
 
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
445
 
{$EXTERNALSYM ReadConsoleInput}
446
 
 
447
 
function WriteConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
448
 
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
449
 
{$EXTERNALSYM WriteConsoleInputA}
450
 
function WriteConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
451
 
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
452
 
{$EXTERNALSYM WriteConsoleInputW}
453
 
function WriteConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
454
 
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
455
 
{$EXTERNALSYM WriteConsoleInput}
456
 
 
457
 
function ReadConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
458
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
459
 
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
460
 
{$EXTERNALSYM ReadConsoleOutputA}
461
 
function ReadConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
462
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
463
 
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
464
 
{$EXTERNALSYM ReadConsoleOutputW}
465
 
function ReadConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
466
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
467
 
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
468
 
{$EXTERNALSYM ReadConsoleOutput}
469
 
 
470
 
function WriteConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
471
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
472
 
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
473
 
{$EXTERNALSYM WriteConsoleOutputA}
474
 
function WriteConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
475
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
476
 
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
477
 
{$EXTERNALSYM WriteConsoleOutputW}
478
 
function WriteConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
479
 
  dwBufferSize: COORD; dwBufferCoord: COORD;
480
 
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
481
 
{$EXTERNALSYM WriteConsoleOutput}
482
 
 
483
 
function ReadConsoleOutputCharacterA(hConsoleOutput: HANDLE; lpCharacter: LPSTR;
484
 
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
485
 
{$EXTERNALSYM ReadConsoleOutputCharacterA}
486
 
function ReadConsoleOutputCharacterW(hConsoleOutput: HANDLE; lpCharacter: LPWSTR;
487
 
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
488
 
{$EXTERNALSYM ReadConsoleOutputCharacterW}
489
 
function ReadConsoleOutputCharacter(hConsoleOutput: HANDLE; lpCharacter: LPTSTR;
490
 
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
491
 
{$EXTERNALSYM ReadConsoleOutputCharacter}
492
 
 
493
 
function ReadConsoleOutputAttribute(hConsoleOutput: HANDLE;
494
 
  var lpAttribute: DWORD; nLength: DWORD; dwReadCoord: COORD;
495
 
  var lpNumberOfAttrsRead: DWORD): BOOL; stdcall;
496
 
{$EXTERNALSYM ReadConsoleOutputAttribute}
497
 
 
498
 
function WriteConsoleOutputCharacterA(hConsoleOutput: HANDLE;
499
 
  lpCharacter: LPCSTR; nLength: DWORD; dwWriteCoord: COORD;
500
 
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
501
 
{$EXTERNALSYM WriteConsoleOutputCharacterA}
502
 
function WriteConsoleOutputCharacterW(hConsoleOutput: HANDLE;
503
 
  lpCharacter: LPCWSTR; nLength: DWORD; dwWriteCoord: COORD;
504
 
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
505
 
{$EXTERNALSYM WriteConsoleOutputCharacterW}
506
 
function WriteConsoleOutputCharacter(hConsoleOutput: HANDLE;
507
 
  lpCharacter: LPCTSTR; nLength: DWORD; dwWriteCoord: COORD;
508
 
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
509
 
{$EXTERNALSYM WriteConsoleOutputCharacter}
510
 
 
511
 
function WriteConsoleOutputAttribute(hConsoleOutput: HANDLE; lpAttribute: PWORD;
512
 
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
513
 
{$EXTERNALSYM WriteConsoleOutputAttribute}
514
 
 
515
 
function FillConsoleOutputCharacterA(hConsoleOutput: HANDLE; cCharacter: CHAR;
516
 
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
517
 
{$EXTERNALSYM FillConsoleOutputCharacterA}
518
 
function FillConsoleOutputCharacterW(hConsoleOutput: HANDLE; cCharacter: WCHAR;
519
 
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
520
 
{$EXTERNALSYM FillConsoleOutputCharacterW}
521
 
function FillConsoleOutputCharacter(hConsoleOutput: HANDLE; cCharacter: TCHAR;
522
 
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
523
 
{$EXTERNALSYM FillConsoleOutputCharacter}
524
 
 
525
 
function FillConsoleOutputAttribute(hConsoleOutput: HANDLE; wAttribute: WORD;
526
 
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
527
 
{$EXTERNALSYM FillConsoleOutputAttribute}
528
 
function GetConsoleMode(hConsoleHandle: HANDLE; var lpMode: DWORD): BOOL; stdcall;
529
 
{$EXTERNALSYM GetConsoleMode}
530
 
function GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE;
531
 
  var lpNumberOfEvents: DWORD): BOOL; stdcall;
532
 
{$EXTERNALSYM GetNumberOfConsoleInputEvents}
533
 
function GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE;
534
 
  var lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO): BOOL; stdcall;
535
 
{$EXTERNALSYM GetConsoleScreenBufferInfo}
536
 
function GetLargestConsoleWindowSize(hConsoleOutput: HANDLE): COORD; stdcall;
537
 
{$EXTERNALSYM GetLargestConsoleWindowSize}
538
 
function GetConsoleCursorInfo(hConsoleOutput: HANDLE;
539
 
  var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
540
 
function GetCurrentConsoleFont(hConsoleOutput: HANDLE; bMaximumWindow: BOOL;
541
 
  var lpConsoleCurrentFont: CONSOLE_FONT_INFO): BOOL; stdcall;
542
 
{$EXTERNALSYM GetCurrentConsoleFont}
543
 
function GetConsoleFontSize(hConsoleOutput: HANDLE; nFont: DWORD): COORD; stdcall;
544
 
{$EXTERNALSYM GetConsoleFontSize}
545
 
function GetConsoleSelectionInfo(var lpConsoleSelectionInfo: CONSOLE_SELECTION_INFO): BOOL; stdcall;
546
 
{$EXTERNALSYM GetConsoleSelectionInfo}
547
 
{$EXTERNALSYM GetConsoleCursorInfo}
548
 
function GetNumberOfConsoleMouseButtons(var lpNumberOfMouseButtons: DWORD): BOOL; stdcall;
549
 
{$EXTERNALSYM GetNumberOfConsoleMouseButtons}
550
 
function SetConsoleMode(hConsoleHandle: HANDLE; dwMode: DWORD): BOOL; stdcall;
551
 
{$EXTERNALSYM SetConsoleMode}
552
 
function SetConsoleActiveScreenBuffer(hConsoleOutput: HANDLE): BOOL; stdcall;
553
 
{$EXTERNALSYM SetConsoleActiveScreenBuffer}
554
 
function FlushConsoleInputBuffer(hConsoleInput: HANDLE): BOOL; stdcall;
555
 
{$EXTERNALSYM FlushConsoleInputBuffer}
556
 
function SetConsoleScreenBufferSize(hConsoleOutput: HANDLE; dwSize: COORD): BOOL; stdcall;
557
 
{$EXTERNALSYM SetConsoleScreenBufferSize}
558
 
function SetConsoleCursorPosition(hConsoleOutput: HANDLE; dwCursorPosition: COORD): BOOL; stdcall;
559
 
{$EXTERNALSYM SetConsoleCursorPosition}
560
 
function SetConsoleCursorInfo(hConsoleOutput: HANDLE;
561
 
  var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
562
 
{$EXTERNALSYM SetConsoleCursorInfo}
563
 
 
564
 
function ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE;
565
 
  const lpScrollRectangle: SMALL_RECT; lpClipRectangle: PSMALL_RECT;
566
 
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
567
 
{$EXTERNALSYM ScrollConsoleScreenBufferA}
568
 
function ScrollConsoleScreenBufferW(hConsoleOutput: HANDLE;
569
 
  const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
570
 
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
571
 
{$EXTERNALSYM ScrollConsoleScreenBufferW}
572
 
function ScrollConsoleScreenBuffer(hConsoleOutput: HANDLE;
573
 
  const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
574
 
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
575
 
{$EXTERNALSYM ScrollConsoleScreenBuffer}
576
 
 
577
 
function SetConsoleWindowInfo(hConsoleOutput: HANDLE; bAbsolute: BOOL;
578
 
  const lpConsoleWindow: SMALL_RECT): BOOL; stdcall;
579
 
{$EXTERNALSYM SetConsoleWindowInfo}
580
 
function SetConsoleTextAttribute(hConsoleOutput: HANDLE; wAttributes: WORD): BOOL; stdcall;
581
 
{$EXTERNALSYM SetConsoleTextAttribute}
582
 
function SetConsoleCtrlHandler(HandlerRoutine: PHANDLER_ROUTINE; Add: BOOL): BOOL; stdcall;
583
 
{$EXTERNALSYM SetConsoleCtrlHandler}
584
 
function GenerateConsoleCtrlEvent(dwCtrlEvent: DWORD; dwProcessGroupId: DWORD): BOOL; stdcall;
585
 
{$EXTERNALSYM GenerateConsoleCtrlEvent}
586
 
function AllocConsole: BOOL; stdcall;
587
 
{$EXTERNALSYM AllocConsole}
588
 
function FreeConsole: BOOL; stdcall;
589
 
{$EXTERNALSYM FreeConsole}
590
 
function AttachConsole(dwProcessId: DWORD): BOOL; stdcall;
591
 
{$EXTERNALSYM AttachConsole}
592
 
 
593
 
const
594
 
  ATTACH_PARENT_PROCESS = DWORD(-1);
595
 
  {$EXTERNALSYM ATTACH_PARENT_PROCESS}
596
 
 
597
 
function GetConsoleTitleA(lpConsoleTitle: LPSTR; nSize: DWORD): DWORD; stdcall;
598
 
{$EXTERNALSYM GetConsoleTitleA}
599
 
function GetConsoleTitleW(lpConsoleTitle: LPWSTR; nSize: DWORD): DWORD; stdcall;
600
 
{$EXTERNALSYM GetConsoleTitleW}
601
 
function GetConsoleTitle(lpConsoleTitle: LPTSTR; nSize: DWORD): DWORD; stdcall;
602
 
{$EXTERNALSYM GetConsoleTitle}
603
 
 
604
 
function SetConsoleTitleA(lpConsoleTitle: LPCSTR): BOOL; stdcall;
605
 
{$EXTERNALSYM SetConsoleTitleA}
606
 
function SetConsoleTitleW(lpConsoleTitle: LPCWSTR): BOOL; stdcall;
607
 
{$EXTERNALSYM SetConsoleTitleW}
608
 
function SetConsoleTitle(lpConsoleTitle: LPCTSTR): BOOL; stdcall;
609
 
{$EXTERNALSYM SetConsoleTitle}
610
 
 
611
 
function ReadConsoleA(hConsoleInput: HANDLE; lpBuffer: LPVOID;
612
 
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
613
 
  lpReserved: LPVOID): BOOL; stdcall;
614
 
{$EXTERNALSYM ReadConsoleA}
615
 
function ReadConsoleW(hConsoleInput: HANDLE; lpBuffer: LPVOID;
616
 
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
617
 
  lpReserved: LPVOID): BOOL; stdcall;
618
 
{$EXTERNALSYM ReadConsoleW}
619
 
function ReadConsole(hConsoleInput: HANDLE; lpBuffer: LPVOID;
620
 
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
621
 
  lpReserved: LPVOID): BOOL; stdcall;
622
 
{$EXTERNALSYM ReadConsole}
623
 
 
624
 
function WriteConsoleA(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
625
 
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
626
 
  lpReserved: LPVOID): BOOL; stdcall;
627
 
{$EXTERNALSYM WriteConsoleA}
628
 
function WriteConsoleW(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
629
 
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
630
 
  lpReserved: LPVOID): BOOL; stdcall;
631
 
{$EXTERNALSYM WriteConsoleW}
632
 
function WriteConsole(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
633
 
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
634
 
  lpReserved: LPVOID): BOOL; stdcall;
635
 
{$EXTERNALSYM WriteConsole}
636
 
 
637
 
const
638
 
  CONSOLE_TEXTMODE_BUFFER = 1;
639
 
  {$EXTERNALSYM CONSOLE_TEXTMODE_BUFFER}
640
 
 
641
 
function CreateConsoleScreenBuffer(dwDesiredAccess: DWORD; dwShareMode: DWORD;
642
 
  lpSecurityAttributes: PSECURITY_ATTRIBUTES; dwFlags: DWORD;
643
 
  lpScreenBufferData: LPVOID): HANDLE; stdcall;
644
 
{$EXTERNALSYM CreateConsoleScreenBuffer}
645
 
function GetConsoleCP: UINT; stdcall;
646
 
{$EXTERNALSYM GetConsoleCP}
647
 
function SetConsoleCP(wCodePageID: UINT): BOOL; stdcall;
648
 
{$EXTERNALSYM SetConsoleCP}
649
 
function GetConsoleOutputCP: UINT; stdcall;
650
 
{$EXTERNALSYM GetConsoleOutputCP}
651
 
function SetConsoleOutputCP(wCodePageID: UINT): BOOL; stdcall;
652
 
{$EXTERNALSYM SetConsoleOutputCP}
653
 
 
654
 
const
655
 
  CONSOLE_FULLSCREEN = 1;            // fullscreen console
656
 
  {$EXTERNALSYM CONSOLE_FULLSCREEN}
657
 
  CONSOLE_FULLSCREEN_HARDWARE = 2;   // console owns the hardware
658
 
  {$EXTERNALSYM CONSOLE_FULLSCREEN_HARDWARE}
659
 
 
660
 
function GetConsoleDisplayMode(var lpModeFlags: DWORD): BOOL; stdcall;
661
 
{$EXTERNALSYM GetConsoleDisplayMode}
662
 
 
663
 
function GetConsoleWindow: HWND; stdcall;
664
 
{$EXTERNALSYM GetConsoleWindow}
665
 
 
666
 
function GetConsoleProcessList(var lpdwProcessList: LPDWORD; dwProcessCount: DWORD): DWORD; stdcall;
667
 
{$EXTERNALSYM GetConsoleProcessList}
668
 
 
669
 
//
670
 
// Aliasing apis.
671
 
//
672
 
 
673
 
function AddConsoleAliasA(Source, Target, ExeName: LPSTR): BOOL; stdcall;
674
 
{$EXTERNALSYM AddConsoleAliasA}
675
 
function AddConsoleAliasW(Source, Target, ExeName: LPWSTR): BOOL; stdcall;
676
 
{$EXTERNALSYM AddConsoleAliasW}
677
 
function AddConsoleAlias(Source, Target, ExeName: LPTSTR): BOOL; stdcall;
678
 
{$EXTERNALSYM AddConsoleAlias}
679
 
 
680
 
function GetConsoleAliasA(Source, TargetBuffer: LPSTR; TargetBufferLength: DWORD; ExeName: LPSTR): DWORD; stdcall;
681
 
{$EXTERNALSYM GetConsoleAliasA}
682
 
function GetConsoleAliasW(Source, TargetBuffer: LPWSTR; TargetBufferLength: DWORD; ExeName: LPWSTR): DWORD; stdcall;
683
 
{$EXTERNALSYM GetConsoleAliasW}
684
 
function GetConsoleAlias(Source, TargetBuffer: LPTSTR; TargetBufferLength: DWORD; ExeName: LPTSTR): DWORD; stdcall;
685
 
{$EXTERNALSYM GetConsoleAlias}
686
 
 
687
 
function GetConsoleAliasesLengthA(ExeName: LPSTR): DWORD; stdcall;
688
 
{$EXTERNALSYM GetConsoleAliasesLengthA}
689
 
function GetConsoleAliasesLengthW(ExeName: LPWSTR): DWORD; stdcall;
690
 
{$EXTERNALSYM GetConsoleAliasesLengthW}
691
 
function GetConsoleAliasesLength(ExeName: LPTSTR): DWORD; stdcall;
692
 
{$EXTERNALSYM GetConsoleAliasesLength}
693
 
 
694
 
function GetConsoleAliasExesLengthA: DWORD; stdcall;
695
 
{$EXTERNALSYM GetConsoleAliasExesLengthA}
696
 
function GetConsoleAliasExesLengthW: DWORD; stdcall;
697
 
{$EXTERNALSYM GetConsoleAliasExesLengthW}
698
 
function GetConsoleAliasExesLength: DWORD; stdcall;
699
 
{$EXTERNALSYM GetConsoleAliasExesLength}
700
 
 
701
 
function GetConsoleAliasesA(AliasBuffer: LPSTR; AliasBufferLength: DWORD; ExeName: LPSTR): DWORD; stdcall;
702
 
{$EXTERNALSYM GetConsoleAliasesA}
703
 
function GetConsoleAliasesW(AliasBuffer: LPWSTR; AliasBufferLength: DWORD; ExeName: LPWSTR): DWORD; stdcall;
704
 
{$EXTERNALSYM GetConsoleAliasesW}
705
 
function GetConsoleAliases(AliasBuffer: LPTSTR; AliasBufferLength: DWORD; ExeName: LPTSTR): DWORD; stdcall;
706
 
{$EXTERNALSYM GetConsoleAliases}
707
 
 
708
 
function GetConsoleAliasExesA(ExeNameBuffer: LPSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
709
 
{$EXTERNALSYM GetConsoleAliasExesA}
710
 
function GetConsoleAliasExesW(ExeNameBuffer: LPWSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
711
 
{$EXTERNALSYM GetConsoleAliasExesW}
712
 
function GetConsoleAliasExes(ExeNameBuffer: LPTSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
713
 
{$EXTERNALSYM GetConsoleAliasExes}
714
 
 
715
 
implementation
716
 
 
717
 
const
718
 
  kernel32 = 'kernel32.dll';
719
 
  {$IFDEF UNICODE}
720
 
  AWSuffix = 'W';
721
 
  {$ELSE}
722
 
  AWSuffix = 'A';
723
 
  {$ENDIF UNICODE}
724
 
 
725
 
{$IFDEF DYNAMIC_LINK}
726
 
 
727
 
var
728
 
  _PeekConsoleInputA: Pointer;
729
 
 
730
 
function PeekConsoleInputA;
731
 
begin
732
 
  GetProcedureAddress(_PeekConsoleInputA, kernel32, 'PeekConsoleInputA');
733
 
  asm
734
 
        MOV     ESP, EBP
735
 
        POP     EBP
736
 
        JMP     [_PeekConsoleInputA]
737
 
  end;
738
 
end;
739
 
 
740
 
var
741
 
  _PeekConsoleInputW: Pointer;
742
 
 
743
 
function PeekConsoleInputW;
744
 
begin
745
 
  GetProcedureAddress(_PeekConsoleInputW, kernel32, 'PeekConsoleInputW');
746
 
  asm
747
 
        MOV     ESP, EBP
748
 
        POP     EBP
749
 
        JMP     [_PeekConsoleInputW]
750
 
  end;
751
 
end;
752
 
 
753
 
var
754
 
  _PeekConsoleInput: Pointer;
755
 
 
756
 
function PeekConsoleInput;
757
 
begin
758
 
  GetProcedureAddress(_PeekConsoleInput, kernel32, 'PeekConsoleInput' + AWSuffix);
759
 
  asm
760
 
        MOV     ESP, EBP
761
 
        POP     EBP
762
 
        JMP     [_PeekConsoleInput]
763
 
  end;
764
 
end;
765
 
 
766
 
var
767
 
  _ReadConsoleInputA: Pointer;
768
 
 
769
 
function ReadConsoleInputA;
770
 
begin
771
 
  GetProcedureAddress(_ReadConsoleInputA, kernel32, 'ReadConsoleInputA');
772
 
  asm
773
 
        MOV     ESP, EBP
774
 
        POP     EBP
775
 
        JMP     [_ReadConsoleInputA]
776
 
  end;
777
 
end;
778
 
 
779
 
var
780
 
  _ReadConsoleInputW: Pointer;
781
 
 
782
 
function ReadConsoleInputW;
783
 
begin
784
 
  GetProcedureAddress(_ReadConsoleInputW, kernel32, 'ReadConsoleInputW');
785
 
  asm
786
 
        MOV     ESP, EBP
787
 
        POP     EBP
788
 
        JMP     [_ReadConsoleInputW]
789
 
  end;
790
 
end;
791
 
 
792
 
var
793
 
  _ReadConsoleInput: Pointer;
794
 
 
795
 
function ReadConsoleInput;
796
 
begin
797
 
  GetProcedureAddress(_ReadConsoleInput, kernel32, 'ReadConsoleInput' + AWSuffix);
798
 
  asm
799
 
        MOV     ESP, EBP
800
 
        POP     EBP
801
 
        JMP     [_ReadConsoleInput]
802
 
  end;
803
 
end;
804
 
 
805
 
var
806
 
  _WriteConsoleInputA: Pointer;
807
 
 
808
 
function WriteConsoleInputA;
809
 
begin
810
 
  GetProcedureAddress(_WriteConsoleInputA, kernel32, 'WriteConsoleInputA');
811
 
  asm
812
 
        MOV     ESP, EBP
813
 
        POP     EBP
814
 
        JMP     [_WriteConsoleInputA]
815
 
  end;
816
 
end;
817
 
 
818
 
var
819
 
  _WriteConsoleInputW: Pointer;
820
 
 
821
 
function WriteConsoleInputW;
822
 
begin
823
 
  GetProcedureAddress(_WriteConsoleInputW, kernel32, 'WriteConsoleInputW');
824
 
  asm
825
 
        MOV     ESP, EBP
826
 
        POP     EBP
827
 
        JMP     [_WriteConsoleInputW]
828
 
  end;
829
 
end;
830
 
 
831
 
var
832
 
  _WriteConsoleInput: Pointer;
833
 
 
834
 
function WriteConsoleInput;
835
 
begin
836
 
  GetProcedureAddress(_WriteConsoleInput, kernel32, 'WriteConsoleInput' + AWSuffix);
837
 
  asm
838
 
        MOV     ESP, EBP
839
 
        POP     EBP
840
 
        JMP     [_WriteConsoleInput]
841
 
  end;
842
 
end;
843
 
 
844
 
var
845
 
  _ReadConsoleOutputA: Pointer;
846
 
 
847
 
function ReadConsoleOutputA;
848
 
begin
849
 
  GetProcedureAddress(_ReadConsoleOutputA, kernel32, 'ReadConsoleOutputA');
850
 
  asm
851
 
        MOV     ESP, EBP
852
 
        POP     EBP
853
 
        JMP     [_ReadConsoleOutputA]
854
 
  end;
855
 
end;
856
 
 
857
 
var
858
 
  _ReadConsoleOutputW: Pointer;
859
 
 
860
 
function ReadConsoleOutputW;
861
 
begin
862
 
  GetProcedureAddress(_ReadConsoleOutputW, kernel32, 'ReadConsoleOutputW');
863
 
  asm
864
 
        MOV     ESP, EBP
865
 
        POP     EBP
866
 
        JMP     [_ReadConsoleOutputW]
867
 
  end;
868
 
end;
869
 
 
870
 
var
871
 
  _ReadConsoleOutput: Pointer;
872
 
 
873
 
function ReadConsoleOutput;
874
 
begin
875
 
  GetProcedureAddress(_ReadConsoleOutput, kernel32, 'ReadConsoleOutput' + AWSuffix);
876
 
  asm
877
 
        MOV     ESP, EBP
878
 
        POP     EBP
879
 
        JMP     [_ReadConsoleOutput]
880
 
  end;
881
 
end;
882
 
 
883
 
var
884
 
  _WriteConsoleOutputA: Pointer;
885
 
 
886
 
function WriteConsoleOutputA;
887
 
begin
888
 
  GetProcedureAddress(_WriteConsoleOutputA, kernel32, 'WriteConsoleOutputA');
889
 
  asm
890
 
        MOV     ESP, EBP
891
 
        POP     EBP
892
 
        JMP     [_WriteConsoleOutputA]
893
 
  end;
894
 
end;
895
 
 
896
 
var
897
 
  _WriteConsoleOutputW: Pointer;
898
 
 
899
 
function WriteConsoleOutputW;
900
 
begin
901
 
  GetProcedureAddress(_WriteConsoleOutputW, kernel32, 'WriteConsoleOutputW');
902
 
  asm
903
 
        MOV     ESP, EBP
904
 
        POP     EBP
905
 
        JMP     [_WriteConsoleOutputW]
906
 
  end;
907
 
end;
908
 
 
909
 
var
910
 
  _WriteConsoleOutput: Pointer;
911
 
 
912
 
function WriteConsoleOutput;
913
 
begin
914
 
  GetProcedureAddress(_WriteConsoleOutput, kernel32, 'WriteConsoleOutput' + AWSuffix);
915
 
  asm
916
 
        MOV     ESP, EBP
917
 
        POP     EBP
918
 
        JMP     [_WriteConsoleOutput]
919
 
  end;
920
 
end;
921
 
 
922
 
var
923
 
  _ReadConsoleOutputCharacterA: Pointer;
924
 
 
925
 
function ReadConsoleOutputCharacterA;
926
 
begin
927
 
  GetProcedureAddress(_ReadConsoleOutputCharacterA, kernel32, 'ReadConsoleOutputCharacterA');
928
 
  asm
929
 
        MOV     ESP, EBP
930
 
        POP     EBP
931
 
        JMP     [_ReadConsoleOutputCharacterA]
932
 
  end;
933
 
end;
934
 
 
935
 
var
936
 
  _ReadConsoleOutputCharacterW: Pointer;
937
 
 
938
 
function ReadConsoleOutputCharacterW;
939
 
begin
940
 
  GetProcedureAddress(_ReadConsoleOutputCharacterW, kernel32, 'ReadConsoleOutputCharacterW');
941
 
  asm
942
 
        MOV     ESP, EBP
943
 
        POP     EBP
944
 
        JMP     [_ReadConsoleOutputCharacterW]
945
 
  end;
946
 
end;
947
 
 
948
 
var
949
 
  _ReadConsoleOutputCharacter: Pointer;
950
 
 
951
 
function ReadConsoleOutputCharacter;
952
 
begin
953
 
  GetProcedureAddress(_ReadConsoleOutputCharacter, kernel32, 'ReadConsoleOutputCharacter' + AWSuffix);
954
 
  asm
955
 
        MOV     ESP, EBP
956
 
        POP     EBP
957
 
        JMP     [_ReadConsoleOutputCharacter]
958
 
  end;
959
 
end;
960
 
 
961
 
var
962
 
  _ReadConsoleOutputAttribute: Pointer;
963
 
 
964
 
function ReadConsoleOutputAttribute;
965
 
begin
966
 
  GetProcedureAddress(_ReadConsoleOutputAttribute, kernel32, 'ReadConsoleOutputAttribute');
967
 
  asm
968
 
        MOV     ESP, EBP
969
 
        POP     EBP
970
 
        JMP     [_ReadConsoleOutputAttribute]
971
 
  end;
972
 
end;
973
 
 
974
 
var
975
 
  _WriteConsoleOutputCharacterA: Pointer;
976
 
 
977
 
function WriteConsoleOutputCharacterA;
978
 
begin
979
 
  GetProcedureAddress(_WriteConsoleOutputCharacterA, kernel32, 'WriteConsoleOutputCharacterA');
980
 
  asm
981
 
        MOV     ESP, EBP
982
 
        POP     EBP
983
 
        JMP     [_WriteConsoleOutputCharacterA]
984
 
  end;
985
 
end;
986
 
 
987
 
var
988
 
  _WriteConsoleOutputCharacterW: Pointer;
989
 
 
990
 
function WriteConsoleOutputCharacterW;
991
 
begin
992
 
  GetProcedureAddress(_WriteConsoleOutputCharacterW, kernel32, 'WriteConsoleOutputCharacterW');
993
 
  asm
994
 
        MOV     ESP, EBP
995
 
        POP     EBP
996
 
        JMP     [_WriteConsoleOutputCharacterW]
997
 
  end;
998
 
end;
999
 
 
1000
 
var
1001
 
  _WriteConsoleOutputCharacter: Pointer;
1002
 
 
1003
 
function WriteConsoleOutputCharacter;
1004
 
begin
1005
 
  GetProcedureAddress(_WriteConsoleOutputCharacter, kernel32, 'WriteConsoleOutputCharacter' + AWSuffix);
1006
 
  asm
1007
 
        MOV     ESP, EBP
1008
 
        POP     EBP
1009
 
        JMP     [_WriteConsoleOutputCharacter]
1010
 
  end;
1011
 
end;
1012
 
 
1013
 
var
1014
 
  _WriteConsoleOutputAttribute: Pointer;
1015
 
 
1016
 
function WriteConsoleOutputAttribute;
1017
 
begin
1018
 
  GetProcedureAddress(_WriteConsoleOutputAttribute, kernel32, 'WriteConsoleOutputAttribute');
1019
 
  asm
1020
 
        MOV     ESP, EBP
1021
 
        POP     EBP
1022
 
        JMP     [_WriteConsoleOutputAttribute]
1023
 
  end;
1024
 
end;
1025
 
 
1026
 
var
1027
 
  _FillConsoleOutputCharacterA: Pointer;
1028
 
 
1029
 
function FillConsoleOutputCharacterA;
1030
 
begin
1031
 
  GetProcedureAddress(_FillConsoleOutputCharacterA, kernel32, 'FillConsoleOutputCharacterA');
1032
 
  asm
1033
 
        MOV     ESP, EBP
1034
 
        POP     EBP
1035
 
        JMP     [_FillConsoleOutputCharacterA]
1036
 
  end;
1037
 
end;
1038
 
 
1039
 
var
1040
 
  _FillConsoleOutputCharacterW: Pointer;
1041
 
 
1042
 
function FillConsoleOutputCharacterW;
1043
 
begin
1044
 
  GetProcedureAddress(_FillConsoleOutputCharacterW, kernel32, 'FillConsoleOutputCharacterW');
1045
 
  asm
1046
 
        MOV     ESP, EBP
1047
 
        POP     EBP
1048
 
        JMP     [_FillConsoleOutputCharacterW]
1049
 
  end;
1050
 
end;
1051
 
 
1052
 
var
1053
 
  _FillConsoleOutputCharacter: Pointer;
1054
 
 
1055
 
function FillConsoleOutputCharacter;
1056
 
begin
1057
 
  GetProcedureAddress(_FillConsoleOutputCharacter, kernel32, 'FillConsoleOutputCharacter' + AWSuffix);
1058
 
  asm
1059
 
        MOV     ESP, EBP
1060
 
        POP     EBP
1061
 
        JMP     [_FillConsoleOutputCharacter]
1062
 
  end;
1063
 
end;
1064
 
 
1065
 
var
1066
 
  _FillConsoleOutputAttribute: Pointer;
1067
 
 
1068
 
function FillConsoleOutputAttribute;
1069
 
begin
1070
 
  GetProcedureAddress(_FillConsoleOutputAttribute, kernel32, 'FillConsoleOutputAttribute');
1071
 
  asm
1072
 
        MOV     ESP, EBP
1073
 
        POP     EBP
1074
 
        JMP     [_FillConsoleOutputAttribute]
1075
 
  end;
1076
 
end;
1077
 
 
1078
 
var
1079
 
  _GetConsoleMode: Pointer;
1080
 
 
1081
 
function GetConsoleMode;
1082
 
begin
1083
 
  GetProcedureAddress(_GetConsoleMode, kernel32, 'GetConsoleMode');
1084
 
  asm
1085
 
        MOV     ESP, EBP
1086
 
        POP     EBP
1087
 
        JMP     [_GetConsoleMode]
1088
 
  end;
1089
 
end;
1090
 
 
1091
 
var
1092
 
  _GetNumberOfConsoleInputEvents: Pointer;
1093
 
 
1094
 
function GetNumberOfConsoleInputEvents;
1095
 
begin
1096
 
  GetProcedureAddress(_GetNumberOfConsoleInputEvents, kernel32, 'GetNumberOfConsoleInputEvents');
1097
 
  asm
1098
 
        MOV     ESP, EBP
1099
 
        POP     EBP
1100
 
        JMP     [_GetNumberOfConsoleInputEvents]
1101
 
  end;
1102
 
end;
1103
 
 
1104
 
var
1105
 
  _GetConsoleScreenBufferInfo: Pointer;
1106
 
 
1107
 
function GetConsoleScreenBufferInfo;
1108
 
begin
1109
 
  GetProcedureAddress(_GetConsoleScreenBufferInfo, kernel32, 'GetConsoleScreenBufferInfo');
1110
 
  asm
1111
 
        MOV     ESP, EBP
1112
 
        POP     EBP
1113
 
        JMP     [_GetConsoleScreenBufferInfo]
1114
 
  end;
1115
 
end;
1116
 
 
1117
 
var
1118
 
  _GetLargestConsoleWindowSize: Pointer;
1119
 
 
1120
 
function GetLargestConsoleWindowSize;
1121
 
begin
1122
 
  GetProcedureAddress(_GetLargestConsoleWindowSize, kernel32, 'GetLargestConsoleWindowSize');
1123
 
  asm
1124
 
        MOV     ESP, EBP
1125
 
        POP     EBP
1126
 
        JMP     [_GetLargestConsoleWindowSize]
1127
 
  end;
1128
 
end;
1129
 
 
1130
 
var
1131
 
  _GetConsoleCursorInfo: Pointer;
1132
 
 
1133
 
function GetConsoleCursorInfo;
1134
 
begin
1135
 
  GetProcedureAddress(_GetConsoleCursorInfo, kernel32, 'GetConsoleCursorInfo');
1136
 
  asm
1137
 
        MOV     ESP, EBP
1138
 
        POP     EBP
1139
 
        JMP     [_GetConsoleCursorInfo]
1140
 
  end;
1141
 
end;
1142
 
 
1143
 
var
1144
 
  _GetCurrentConsoleFont: Pointer;
1145
 
 
1146
 
function GetCurrentConsoleFont;
1147
 
begin
1148
 
  GetProcedureAddress(_GetCurrentConsoleFont, kernel32, 'GetCurrentConsoleFont');
1149
 
  asm
1150
 
        MOV     ESP, EBP
1151
 
        POP     EBP
1152
 
        JMP     [_GetCurrentConsoleFont]
1153
 
  end;
1154
 
end;
1155
 
 
1156
 
var
1157
 
  _GetConsoleFontSize: Pointer;
1158
 
 
1159
 
function GetConsoleFontSize;
1160
 
begin
1161
 
  GetProcedureAddress(_GetConsoleFontSize, kernel32, 'GetConsoleFontSize');
1162
 
  asm
1163
 
        MOV     ESP, EBP
1164
 
        POP     EBP
1165
 
        JMP     [_GetConsoleFontSize]
1166
 
  end;
1167
 
end;
1168
 
 
1169
 
var
1170
 
  _GetConsoleSelectionInfo: Pointer;
1171
 
 
1172
 
function GetConsoleSelectionInfo;
1173
 
begin
1174
 
  GetProcedureAddress(_GetConsoleSelectionInfo, kernel32, 'GetConsoleSelectionInfo');
1175
 
  asm
1176
 
        MOV     ESP, EBP
1177
 
        POP     EBP
1178
 
        JMP     [_GetConsoleSelectionInfo]
1179
 
  end;
1180
 
end;
1181
 
 
1182
 
var
1183
 
  _GetNumberOfConsoleMouseButtons: Pointer;
1184
 
 
1185
 
function GetNumberOfConsoleMouseButtons;
1186
 
begin
1187
 
  GetProcedureAddress(_GetNumberOfConsoleMouseButtons, kernel32, 'GetNumberOfConsoleMouseButtons');
1188
 
  asm
1189
 
        MOV     ESP, EBP
1190
 
        POP     EBP
1191
 
        JMP     [_GetNumberOfConsoleMouseButtons]
1192
 
  end;
1193
 
end;
1194
 
 
1195
 
var
1196
 
  _SetConsoleMode: Pointer;
1197
 
 
1198
 
function SetConsoleMode;
1199
 
begin
1200
 
  GetProcedureAddress(_SetConsoleMode, kernel32, 'SetConsoleMode');
1201
 
  asm
1202
 
        MOV     ESP, EBP
1203
 
        POP     EBP
1204
 
        JMP     [_SetConsoleMode]
1205
 
  end;
1206
 
end;
1207
 
 
1208
 
var
1209
 
  _SetConsoleActiveScreenBuffer: Pointer;
1210
 
 
1211
 
function SetConsoleActiveScreenBuffer;
1212
 
begin
1213
 
  GetProcedureAddress(_SetConsoleActiveScreenBuffer, kernel32, 'SetConsoleActiveScreenBuffer');
1214
 
  asm
1215
 
        MOV     ESP, EBP
1216
 
        POP     EBP
1217
 
        JMP     [_SetConsoleActiveScreenBuffer]
1218
 
  end;
1219
 
end;
1220
 
 
1221
 
var
1222
 
  _FlushConsoleInputBuffer: Pointer;
1223
 
 
1224
 
function FlushConsoleInputBuffer;
1225
 
begin
1226
 
  GetProcedureAddress(_FlushConsoleInputBuffer, kernel32, 'FlushConsoleInputBuffer');
1227
 
  asm
1228
 
        MOV     ESP, EBP
1229
 
        POP     EBP
1230
 
        JMP     [_FlushConsoleInputBuffer]
1231
 
  end;
1232
 
end;
1233
 
 
1234
 
var
1235
 
  _SetConsoleScreenBufferSize: Pointer;
1236
 
 
1237
 
function SetConsoleScreenBufferSize;
1238
 
begin
1239
 
  GetProcedureAddress(_SetConsoleScreenBufferSize, kernel32, 'SetConsoleScreenBufferSize');
1240
 
  asm
1241
 
        MOV     ESP, EBP
1242
 
        POP     EBP
1243
 
        JMP     [_SetConsoleScreenBufferSize]
1244
 
  end;
1245
 
end;
1246
 
 
1247
 
var
1248
 
  _SetConsoleCursorPosition: Pointer;
1249
 
 
1250
 
function SetConsoleCursorPosition;
1251
 
begin
1252
 
  GetProcedureAddress(_SetConsoleCursorPosition, kernel32, 'SetConsoleCursorPosition');
1253
 
  asm
1254
 
        MOV     ESP, EBP
1255
 
        POP     EBP
1256
 
        JMP     [_SetConsoleCursorPosition]
1257
 
  end;
1258
 
end;
1259
 
 
1260
 
var
1261
 
  _SetConsoleCursorInfo: Pointer;
1262
 
 
1263
 
function SetConsoleCursorInfo;
1264
 
begin
1265
 
  GetProcedureAddress(_SetConsoleCursorInfo, kernel32, 'SetConsoleCursorInfo');
1266
 
  asm
1267
 
        MOV     ESP, EBP
1268
 
        POP     EBP
1269
 
        JMP     [_SetConsoleCursorInfo]
1270
 
  end;
1271
 
end;
1272
 
 
1273
 
var
1274
 
  _ScrollConsoleScreenBufferA: Pointer;
1275
 
 
1276
 
function ScrollConsoleScreenBufferA;
1277
 
begin
1278
 
  GetProcedureAddress(_ScrollConsoleScreenBufferA, kernel32, 'ScrollConsoleScreenBufferA');
1279
 
  asm
1280
 
        MOV     ESP, EBP
1281
 
        POP     EBP
1282
 
        JMP     [_ScrollConsoleScreenBufferA]
1283
 
  end;
1284
 
end;
1285
 
 
1286
 
var
1287
 
  _ScrollConsoleScreenBufferW: Pointer;
1288
 
 
1289
 
function ScrollConsoleScreenBufferW;
1290
 
begin
1291
 
  GetProcedureAddress(_ScrollConsoleScreenBufferW, kernel32, 'ScrollConsoleScreenBufferW');
1292
 
  asm
1293
 
        MOV     ESP, EBP
1294
 
        POP     EBP
1295
 
        JMP     [_ScrollConsoleScreenBufferW]
1296
 
  end;
1297
 
end;
1298
 
 
1299
 
var
1300
 
  _ScrollConsoleScreenBuffer: Pointer;
1301
 
 
1302
 
function ScrollConsoleScreenBuffer;
1303
 
begin
1304
 
  GetProcedureAddress(_ScrollConsoleScreenBuffer, kernel32, 'ScrollConsoleScreenBuffer' + AWSuffix);
1305
 
  asm
1306
 
        MOV     ESP, EBP
1307
 
        POP     EBP
1308
 
        JMP     [_ScrollConsoleScreenBuffer]
1309
 
  end;
1310
 
end;
1311
 
 
1312
 
var
1313
 
  _SetConsoleWindowInfo: Pointer;
1314
 
 
1315
 
function SetConsoleWindowInfo;
1316
 
begin
1317
 
  GetProcedureAddress(_SetConsoleWindowInfo, kernel32, 'SetConsoleWindowInfo');
1318
 
  asm
1319
 
        MOV     ESP, EBP
1320
 
        POP     EBP
1321
 
        JMP     [_SetConsoleWindowInfo]
1322
 
  end;
1323
 
end;
1324
 
 
1325
 
var
1326
 
  _SetConsoleTextAttribute: Pointer;
1327
 
 
1328
 
function SetConsoleTextAttribute;
1329
 
begin
1330
 
  GetProcedureAddress(_SetConsoleTextAttribute, kernel32, 'SetConsoleTextAttribute');
1331
 
  asm
1332
 
        MOV     ESP, EBP
1333
 
        POP     EBP
1334
 
        JMP     [_SetConsoleTextAttribute]
1335
 
  end;
1336
 
end;
1337
 
 
1338
 
var
1339
 
  _SetConsoleCtrlHandler: Pointer;
1340
 
 
1341
 
function SetConsoleCtrlHandler;
1342
 
begin
1343
 
  GetProcedureAddress(_SetConsoleCtrlHandler, kernel32, 'SetConsoleCtrlHandler');
1344
 
  asm
1345
 
        MOV     ESP, EBP
1346
 
        POP     EBP
1347
 
        JMP     [_SetConsoleCtrlHandler]
1348
 
  end;
1349
 
end;
1350
 
 
1351
 
var
1352
 
  _GenerateConsoleCtrlEvent: Pointer;
1353
 
 
1354
 
function GenerateConsoleCtrlEvent;
1355
 
begin
1356
 
  GetProcedureAddress(_GenerateConsoleCtrlEvent, kernel32, 'GenerateConsoleCtrlEvent');
1357
 
  asm
1358
 
        MOV     ESP, EBP
1359
 
        POP     EBP
1360
 
        JMP     [_GenerateConsoleCtrlEvent]
1361
 
  end;
1362
 
end;
1363
 
 
1364
 
var
1365
 
  _AllocConsole: Pointer;
1366
 
 
1367
 
function AllocConsole;
1368
 
begin
1369
 
  GetProcedureAddress(_AllocConsole, kernel32, 'AllocConsole');
1370
 
  asm
1371
 
        MOV     ESP, EBP
1372
 
        POP     EBP
1373
 
        JMP     [_AllocConsole]
1374
 
  end;
1375
 
end;
1376
 
 
1377
 
var
1378
 
  _FreeConsole: Pointer;
1379
 
 
1380
 
function FreeConsole;
1381
 
begin
1382
 
  GetProcedureAddress(_FreeConsole, kernel32, 'FreeConsole');
1383
 
  asm
1384
 
        MOV     ESP, EBP
1385
 
        POP     EBP
1386
 
        JMP     [_FreeConsole]
1387
 
  end;
1388
 
end;
1389
 
 
1390
 
var
1391
 
  _AttachConsole: Pointer;
1392
 
 
1393
 
function AttachConsole;
1394
 
begin
1395
 
  GetProcedureAddress(_AttachConsole, kernel32, 'AttachConsole');
1396
 
  asm
1397
 
        MOV     ESP, EBP
1398
 
        POP     EBP
1399
 
        JMP     [_AttachConsole]
1400
 
  end;
1401
 
end;
1402
 
 
1403
 
var
1404
 
  _GetConsoleTitleA: Pointer;
1405
 
 
1406
 
function GetConsoleTitleA;
1407
 
begin
1408
 
  GetProcedureAddress(_GetConsoleTitleA, kernel32, 'GetConsoleTitleA');
1409
 
  asm
1410
 
        MOV     ESP, EBP
1411
 
        POP     EBP
1412
 
        JMP     [_GetConsoleTitleA]
1413
 
  end;
1414
 
end;
1415
 
 
1416
 
var
1417
 
  _GetConsoleTitleW: Pointer;
1418
 
 
1419
 
function GetConsoleTitleW;
1420
 
begin
1421
 
  GetProcedureAddress(_GetConsoleTitleW, kernel32, 'GetConsoleTitleW');
1422
 
  asm
1423
 
        MOV     ESP, EBP
1424
 
        POP     EBP
1425
 
        JMP     [_GetConsoleTitleW]
1426
 
  end;
1427
 
end;
1428
 
 
1429
 
var
1430
 
  _GetConsoleTitle: Pointer;
1431
 
 
1432
 
function GetConsoleTitle;
1433
 
begin
1434
 
  GetProcedureAddress(_GetConsoleTitle, kernel32, 'GetConsoleTitle' + AWSuffix);
1435
 
  asm
1436
 
        MOV     ESP, EBP
1437
 
        POP     EBP
1438
 
        JMP     [_GetConsoleTitle]
1439
 
  end;
1440
 
end;
1441
 
 
1442
 
var
1443
 
  _SetConsoleTitleA: Pointer;
1444
 
 
1445
 
function SetConsoleTitleA;
1446
 
begin
1447
 
  GetProcedureAddress(_SetConsoleTitleA, kernel32, 'SetConsoleTitleA');
1448
 
  asm
1449
 
        MOV     ESP, EBP
1450
 
        POP     EBP
1451
 
        JMP     [_SetConsoleTitleA]
1452
 
  end;
1453
 
end;
1454
 
 
1455
 
var
1456
 
  _SetConsoleTitleW: Pointer;
1457
 
 
1458
 
function SetConsoleTitleW;
1459
 
begin
1460
 
  GetProcedureAddress(_SetConsoleTitleW, kernel32, 'SetConsoleTitleW');
1461
 
  asm
1462
 
        MOV     ESP, EBP
1463
 
        POP     EBP
1464
 
        JMP     [_SetConsoleTitleW]
1465
 
  end;
1466
 
end;
1467
 
 
1468
 
var
1469
 
  _SetConsoleTitle: Pointer;
1470
 
 
1471
 
function SetConsoleTitle;
1472
 
begin
1473
 
  GetProcedureAddress(_SetConsoleTitle, kernel32, 'SetConsoleTitle' + AWSuffix);
1474
 
  asm
1475
 
        MOV     ESP, EBP
1476
 
        POP     EBP
1477
 
        JMP     [_SetConsoleTitle]
1478
 
  end;
1479
 
end;
1480
 
 
1481
 
var
1482
 
  _ReadConsoleA: Pointer;
1483
 
 
1484
 
function ReadConsoleA;
1485
 
begin
1486
 
  GetProcedureAddress(_ReadConsoleA, kernel32, 'ReadConsoleA');
1487
 
  asm
1488
 
        MOV     ESP, EBP
1489
 
        POP     EBP
1490
 
        JMP     [_ReadConsoleA]
1491
 
  end;
1492
 
end;
1493
 
 
1494
 
var
1495
 
  _ReadConsoleW: Pointer;
1496
 
 
1497
 
function ReadConsoleW;
1498
 
begin
1499
 
  GetProcedureAddress(_ReadConsoleW, kernel32, 'ReadConsoleW');
1500
 
  asm
1501
 
        MOV     ESP, EBP
1502
 
        POP     EBP
1503
 
        JMP     [_ReadConsoleW]
1504
 
  end;
1505
 
end;
1506
 
 
1507
 
var
1508
 
  _ReadConsole: Pointer;
1509
 
 
1510
 
function ReadConsole;
1511
 
begin
1512
 
  GetProcedureAddress(_ReadConsole, kernel32, 'ReadConsole' + AWSuffix);
1513
 
  asm
1514
 
        MOV     ESP, EBP
1515
 
        POP     EBP
1516
 
        JMP     [_ReadConsole]
1517
 
  end;
1518
 
end;
1519
 
 
1520
 
var
1521
 
  _WriteConsoleA: Pointer;
1522
 
 
1523
 
function WriteConsoleA;
1524
 
begin
1525
 
  GetProcedureAddress(_WriteConsoleA, kernel32, 'WriteConsoleA');
1526
 
  asm
1527
 
        MOV     ESP, EBP
1528
 
        POP     EBP
1529
 
        JMP     [_WriteConsoleA]
1530
 
  end;
1531
 
end;
1532
 
 
1533
 
var
1534
 
  _WriteConsoleW: Pointer;
1535
 
 
1536
 
function WriteConsoleW;
1537
 
begin
1538
 
  GetProcedureAddress(_WriteConsoleW, kernel32, 'WriteConsoleW');
1539
 
  asm
1540
 
        MOV     ESP, EBP
1541
 
        POP     EBP
1542
 
        JMP     [_WriteConsoleW]
1543
 
  end;
1544
 
end;
1545
 
 
1546
 
var
1547
 
  _WriteConsole: Pointer;
1548
 
 
1549
 
function WriteConsole;
1550
 
begin
1551
 
  GetProcedureAddress(_WriteConsole, kernel32, 'WriteConsole' + AWSuffix);
1552
 
  asm
1553
 
        MOV     ESP, EBP
1554
 
        POP     EBP
1555
 
        JMP     [_WriteConsole]
1556
 
  end;
1557
 
end;
1558
 
 
1559
 
var
1560
 
  _CreateConsoleScreenBuffer: Pointer;
1561
 
 
1562
 
function CreateConsoleScreenBuffer;
1563
 
begin
1564
 
  GetProcedureAddress(_CreateConsoleScreenBuffer, kernel32, 'CreateConsoleScreenBuffer');
1565
 
  asm
1566
 
        MOV     ESP, EBP
1567
 
        POP     EBP
1568
 
        JMP     [_CreateConsoleScreenBuffer]
1569
 
  end;
1570
 
end;
1571
 
 
1572
 
var
1573
 
  _GetConsoleCP: Pointer;
1574
 
 
1575
 
function GetConsoleCP;
1576
 
begin
1577
 
  GetProcedureAddress(_GetConsoleCP, kernel32, 'GetConsoleCP');
1578
 
  asm
1579
 
        MOV     ESP, EBP
1580
 
        POP     EBP
1581
 
        JMP     [_GetConsoleCP]
1582
 
  end;
1583
 
end;
1584
 
 
1585
 
var
1586
 
  _SetConsoleCP: Pointer;
1587
 
 
1588
 
function SetConsoleCP;
1589
 
begin
1590
 
  GetProcedureAddress(_SetConsoleCP, kernel32, 'SetConsoleCP');
1591
 
  asm
1592
 
        MOV     ESP, EBP
1593
 
        POP     EBP
1594
 
        JMP     [_SetConsoleCP]
1595
 
  end;
1596
 
end;
1597
 
 
1598
 
var
1599
 
  _GetConsoleOutputCP: Pointer;
1600
 
 
1601
 
function GetConsoleOutputCP;
1602
 
begin
1603
 
  GetProcedureAddress(_GetConsoleOutputCP, kernel32, 'GetConsoleOutputCP');
1604
 
  asm
1605
 
        MOV     ESP, EBP
1606
 
        POP     EBP
1607
 
        JMP     [_GetConsoleOutputCP]
1608
 
  end;
1609
 
end;
1610
 
 
1611
 
var
1612
 
  _SetConsoleOutputCP: Pointer;
1613
 
 
1614
 
function SetConsoleOutputCP;
1615
 
begin
1616
 
  GetProcedureAddress(_SetConsoleOutputCP, kernel32, 'SetConsoleOutputCP');
1617
 
  asm
1618
 
        MOV     ESP, EBP
1619
 
        POP     EBP
1620
 
        JMP     [_SetConsoleOutputCP]
1621
 
  end;
1622
 
end;
1623
 
 
1624
 
var
1625
 
  _GetConsoleDisplayMode: Pointer;
1626
 
 
1627
 
function GetConsoleDisplayMode;
1628
 
begin
1629
 
  GetProcedureAddress(_GetConsoleDisplayMode, kernel32, 'GetConsoleDisplayMode');
1630
 
  asm
1631
 
        MOV     ESP, EBP
1632
 
        POP     EBP
1633
 
        JMP     [_GetConsoleDisplayMode]
1634
 
  end;
1635
 
end;
1636
 
 
1637
 
var
1638
 
  _GetConsoleWindow: Pointer;
1639
 
 
1640
 
function GetConsoleWindow;
1641
 
begin
1642
 
  GetProcedureAddress(_GetConsoleWindow, kernel32, 'GetConsoleWindow');
1643
 
  asm
1644
 
        MOV     ESP, EBP
1645
 
        POP     EBP
1646
 
        JMP     [_GetConsoleWindow]
1647
 
  end;
1648
 
end;
1649
 
 
1650
 
var
1651
 
  _GetConsoleProcessList: Pointer;
1652
 
 
1653
 
function GetConsoleProcessList;
1654
 
begin
1655
 
  GetProcedureAddress(_GetConsoleProcessList, kernel32, 'GetConsoleProcessList');
1656
 
  asm
1657
 
        MOV     ESP, EBP
1658
 
        POP     EBP
1659
 
        JMP     [_GetConsoleProcessList]
1660
 
  end;
1661
 
end;
1662
 
 
1663
 
var
1664
 
  _AddConsoleAliasA: Pointer;
1665
 
 
1666
 
function AddConsoleAliasA;
1667
 
begin
1668
 
  GetProcedureAddress(_AddConsoleAliasA, kernel32, 'AddConsoleAliasA');
1669
 
  asm
1670
 
        MOV     ESP, EBP
1671
 
        POP     EBP
1672
 
        JMP     [_AddConsoleAliasA]
1673
 
  end;
1674
 
end;
1675
 
 
1676
 
var
1677
 
  _AddConsoleAliasW: Pointer;
1678
 
 
1679
 
function AddConsoleAliasW;
1680
 
begin
1681
 
  GetProcedureAddress(_AddConsoleAliasW, kernel32, 'AddConsoleAliasW');
1682
 
  asm
1683
 
        MOV     ESP, EBP
1684
 
        POP     EBP
1685
 
        JMP     [_AddConsoleAliasW]
1686
 
  end;
1687
 
end;
1688
 
 
1689
 
var
1690
 
  _AddConsoleAlias: Pointer;
1691
 
 
1692
 
function AddConsoleAlias;
1693
 
begin
1694
 
  GetProcedureAddress(_AddConsoleAlias, kernel32, 'AddConsoleAlias' + AWSuffix);
1695
 
  asm
1696
 
        MOV     ESP, EBP
1697
 
        POP     EBP
1698
 
        JMP     [_AddConsoleAlias]
1699
 
  end;
1700
 
end;
1701
 
 
1702
 
var
1703
 
  _GetConsoleAliasA: Pointer;
1704
 
 
1705
 
function GetConsoleAliasA;
1706
 
begin
1707
 
  GetProcedureAddress(_GetConsoleAliasA, kernel32, 'GetConsoleAliasA');
1708
 
  asm
1709
 
        MOV     ESP, EBP
1710
 
        POP     EBP
1711
 
        JMP     [_GetConsoleAliasA]
1712
 
  end;
1713
 
end;
1714
 
 
1715
 
var
1716
 
  _GetConsoleAliasW: Pointer;
1717
 
 
1718
 
function GetConsoleAliasW;
1719
 
begin
1720
 
  GetProcedureAddress(_GetConsoleAliasW, kernel32, 'GetConsoleAliasW');
1721
 
  asm
1722
 
        MOV     ESP, EBP
1723
 
        POP     EBP
1724
 
        JMP     [_GetConsoleAliasW]
1725
 
  end;
1726
 
end;
1727
 
 
1728
 
var
1729
 
  _GetConsoleAlias: Pointer;
1730
 
 
1731
 
function GetConsoleAlias;
1732
 
begin
1733
 
  GetProcedureAddress(_GetConsoleAlias, kernel32, 'GetConsoleAlias' + AWSuffix);
1734
 
  asm
1735
 
        MOV     ESP, EBP
1736
 
        POP     EBP
1737
 
        JMP     [_GetConsoleAlias]
1738
 
  end;
1739
 
end;
1740
 
 
1741
 
var
1742
 
  _GetConsoleAliasesLengthA: Pointer;
1743
 
 
1744
 
function GetConsoleAliasesLengthA;
1745
 
begin
1746
 
  GetProcedureAddress(_GetConsoleAliasesLengthA, kernel32, 'GetConsoleAliasesLengthA');
1747
 
  asm
1748
 
        MOV     ESP, EBP
1749
 
        POP     EBP
1750
 
        JMP     [_GetConsoleAliasesLengthA]
1751
 
  end;
1752
 
end;
1753
 
 
1754
 
var
1755
 
  _GetConsoleAliasesLengthW: Pointer;
1756
 
 
1757
 
function GetConsoleAliasesLengthW;
1758
 
begin
1759
 
  GetProcedureAddress(_GetConsoleAliasesLengthW, kernel32, 'GetConsoleAliasesLengthW');
1760
 
  asm
1761
 
        MOV     ESP, EBP
1762
 
        POP     EBP
1763
 
        JMP     [_GetConsoleAliasesLengthW]
1764
 
  end;
1765
 
end;
1766
 
 
1767
 
var
1768
 
  _GetConsoleAliasesLength: Pointer;
1769
 
 
1770
 
function GetConsoleAliasesLength;
1771
 
begin
1772
 
  GetProcedureAddress(_GetConsoleAliasesLength, kernel32, 'GetConsoleAliasesLength' + AWSuffix);
1773
 
  asm
1774
 
        MOV     ESP, EBP
1775
 
        POP     EBP
1776
 
        JMP     [_GetConsoleAliasesLength]
1777
 
  end;
1778
 
end;
1779
 
 
1780
 
var
1781
 
  _GetConsoleAliasExesLengthA: Pointer;
1782
 
 
1783
 
function GetConsoleAliasExesLengthA;
1784
 
begin
1785
 
  GetProcedureAddress(_GetConsoleAliasExesLengthA, kernel32, 'GetConsoleAliasExesLengthA');
1786
 
  asm
1787
 
        MOV     ESP, EBP
1788
 
        POP     EBP
1789
 
        JMP     [_GetConsoleAliasExesLengthA]
1790
 
  end;
1791
 
end;
1792
 
 
1793
 
var
1794
 
  _GetConsoleAliasExesLengthW: Pointer;
1795
 
 
1796
 
function GetConsoleAliasExesLengthW;
1797
 
begin
1798
 
  GetProcedureAddress(_GetConsoleAliasExesLengthW, kernel32, 'GetConsoleAliasExesLengthW');
1799
 
  asm
1800
 
        MOV     ESP, EBP
1801
 
        POP     EBP
1802
 
        JMP     [_GetConsoleAliasExesLengthW]
1803
 
  end;
1804
 
end;
1805
 
 
1806
 
var
1807
 
  _GetConsoleAliasExesLength: Pointer;
1808
 
 
1809
 
function GetConsoleAliasExesLength;
1810
 
begin
1811
 
  GetProcedureAddress(_GetConsoleAliasExesLength, kernel32, 'GetConsoleAliasExesLength' + AWSuffix);
1812
 
  asm
1813
 
        MOV     ESP, EBP
1814
 
        POP     EBP
1815
 
        JMP     [_GetConsoleAliasExesLength]
1816
 
  end;
1817
 
end;
1818
 
 
1819
 
var
1820
 
  _GetConsoleAliasesA: Pointer;
1821
 
 
1822
 
function GetConsoleAliasesA;
1823
 
begin
1824
 
  GetProcedureAddress(_GetConsoleAliasesA, kernel32, 'GetConsoleAliasesA');
1825
 
  asm
1826
 
        MOV     ESP, EBP
1827
 
        POP     EBP
1828
 
        JMP     [_GetConsoleAliasesA]
1829
 
  end;
1830
 
end;
1831
 
 
1832
 
var
1833
 
  _GetConsoleAliasesW: Pointer;
1834
 
 
1835
 
function GetConsoleAliasesW;
1836
 
begin
1837
 
  GetProcedureAddress(_GetConsoleAliasesW, kernel32, 'GetConsoleAliasesW');
1838
 
  asm
1839
 
        MOV     ESP, EBP
1840
 
        POP     EBP
1841
 
        JMP     [_GetConsoleAliasesW]
1842
 
  end;
1843
 
end;
1844
 
 
1845
 
var
1846
 
  _GetConsoleAliases: Pointer;
1847
 
 
1848
 
function GetConsoleAliases;
1849
 
begin
1850
 
  GetProcedureAddress(_GetConsoleAliases, kernel32, 'GetConsoleAliases' + AWSuffix);
1851
 
  asm
1852
 
        MOV     ESP, EBP
1853
 
        POP     EBP
1854
 
        JMP     [_GetConsoleAliases]
1855
 
  end;
1856
 
end;
1857
 
 
1858
 
var
1859
 
  _GetConsoleAliasExesA: Pointer;
1860
 
 
1861
 
function GetConsoleAliasExesA;
1862
 
begin
1863
 
  GetProcedureAddress(_GetConsoleAliasExesA, kernel32, 'GetConsoleAliasExesA');
1864
 
  asm
1865
 
        MOV     ESP, EBP
1866
 
        POP     EBP
1867
 
        JMP     [_GetConsoleAliasExesA]
1868
 
  end;
1869
 
end;
1870
 
 
1871
 
var
1872
 
  _GetConsoleAliasExesW: Pointer;
1873
 
 
1874
 
function GetConsoleAliasExesW;
1875
 
begin
1876
 
  GetProcedureAddress(_GetConsoleAliasExesW, kernel32, 'GetConsoleAliasExesW');
1877
 
  asm
1878
 
        MOV     ESP, EBP
1879
 
        POP     EBP
1880
 
        JMP     [_GetConsoleAliasExesW]
1881
 
  end;
1882
 
end;
1883
 
 
1884
 
var
1885
 
  _GetConsoleAliasExes: Pointer;
1886
 
 
1887
 
function GetConsoleAliasExes;
1888
 
begin
1889
 
  GetProcedureAddress(_GetConsoleAliasExes, kernel32, 'GetConsoleAliasExes' + AWSuffix);
1890
 
  asm
1891
 
        MOV     ESP, EBP
1892
 
        POP     EBP
1893
 
        JMP     [_GetConsoleAliasExes]
1894
 
  end;
1895
 
end;
1896
 
 
1897
 
{$ELSE}
1898
 
 
1899
 
function PeekConsoleInputA; external kernel32 name 'PeekConsoleInputA';
1900
 
function PeekConsoleInputW; external kernel32 name 'PeekConsoleInputW';
1901
 
function PeekConsoleInput; external kernel32 name 'PeekConsoleInput' + AWSuffix;
1902
 
function ReadConsoleInputA; external kernel32 name 'ReadConsoleInputA';
1903
 
function ReadConsoleInputW; external kernel32 name 'ReadConsoleInputW';
1904
 
function ReadConsoleInput; external kernel32 name 'ReadConsoleInput' + AWSuffix;
1905
 
function WriteConsoleInputA; external kernel32 name 'WriteConsoleInputA';
1906
 
function WriteConsoleInputW; external kernel32 name 'WriteConsoleInputW';
1907
 
function WriteConsoleInput; external kernel32 name 'WriteConsoleInput' + AWSuffix;
1908
 
function ReadConsoleOutputA; external kernel32 name 'ReadConsoleOutputA';
1909
 
function ReadConsoleOutputW; external kernel32 name 'ReadConsoleOutputW';
1910
 
function ReadConsoleOutput; external kernel32 name 'ReadConsoleOutput' + AWSuffix;
1911
 
function WriteConsoleOutputA; external kernel32 name 'WriteConsoleOutputA';
1912
 
function WriteConsoleOutputW; external kernel32 name 'WriteConsoleOutputW';
1913
 
function WriteConsoleOutput; external kernel32 name 'WriteConsoleOutput' + AWSuffix;
1914
 
function ReadConsoleOutputCharacterA; external kernel32 name 'ReadConsoleOutputCharacterA';
1915
 
function ReadConsoleOutputCharacterW; external kernel32 name 'ReadConsoleOutputCharacterW';
1916
 
function ReadConsoleOutputCharacter; external kernel32 name 'ReadConsoleOutputCharacter' + AWSuffix;
1917
 
function ReadConsoleOutputAttribute; external kernel32 name 'ReadConsoleOutputAttribute';
1918
 
function WriteConsoleOutputCharacterA; external kernel32 name 'WriteConsoleOutputCharacterA';
1919
 
function WriteConsoleOutputCharacterW; external kernel32 name 'WriteConsoleOutputCharacterW';
1920
 
function WriteConsoleOutputCharacter; external kernel32 name 'WriteConsoleOutputCharacter' + AWSuffix;
1921
 
function WriteConsoleOutputAttribute; external kernel32 name 'WriteConsoleOutputAttribute';
1922
 
function FillConsoleOutputCharacterA; external kernel32 name 'FillConsoleOutputCharacterA';
1923
 
function FillConsoleOutputCharacterW; external kernel32 name 'FillConsoleOutputCharacterW';
1924
 
function FillConsoleOutputCharacter; external kernel32 name 'FillConsoleOutputCharacter' + AWSuffix;
1925
 
function FillConsoleOutputAttribute; external kernel32 name 'FillConsoleOutputAttribute';
1926
 
function GetConsoleMode; external kernel32 name 'GetConsoleMode';
1927
 
function GetNumberOfConsoleInputEvents; external kernel32 name 'GetNumberOfConsoleInputEvents';
1928
 
function GetConsoleScreenBufferInfo; external kernel32 name 'GetConsoleScreenBufferInfo';
1929
 
function GetLargestConsoleWindowSize; external kernel32 name 'GetLargestConsoleWindowSize';
1930
 
function GetConsoleCursorInfo; external kernel32 name 'GetConsoleCursorInfo';
1931
 
function GetCurrentConsoleFont; external kernel32 name 'GetCurrentConsoleFont';
1932
 
function GetConsoleFontSize; external kernel32 name 'GetConsoleFontSize';
1933
 
function GetConsoleSelectionInfo; external kernel32 name 'GetConsoleSelectionInfo';
1934
 
function GetNumberOfConsoleMouseButtons; external kernel32 name 'GetNumberOfConsoleMouseButtons';
1935
 
function SetConsoleMode; external kernel32 name 'SetConsoleMode';
1936
 
function SetConsoleActiveScreenBuffer; external kernel32 name 'SetConsoleActiveScreenBuffer';
1937
 
function FlushConsoleInputBuffer; external kernel32 name 'FlushConsoleInputBuffer';
1938
 
function SetConsoleScreenBufferSize; external kernel32 name 'SetConsoleScreenBufferSize';
1939
 
function SetConsoleCursorPosition; external kernel32 name 'SetConsoleCursorPosition';
1940
 
function SetConsoleCursorInfo; external kernel32 name 'SetConsoleCursorInfo';
1941
 
function ScrollConsoleScreenBufferA; external kernel32 name 'ScrollConsoleScreenBufferA';
1942
 
function ScrollConsoleScreenBufferW; external kernel32 name 'ScrollConsoleScreenBufferW';
1943
 
function ScrollConsoleScreenBuffer; external kernel32 name 'ScrollConsoleScreenBuffer' + AWSuffix;
1944
 
function SetConsoleWindowInfo; external kernel32 name 'SetConsoleWindowInfo';
1945
 
function SetConsoleTextAttribute; external kernel32 name 'SetConsoleTextAttribute';
1946
 
function SetConsoleCtrlHandler; external kernel32 name 'SetConsoleCtrlHandler';
1947
 
function GenerateConsoleCtrlEvent; external kernel32 name 'GenerateConsoleCtrlEvent';
1948
 
function AllocConsole; external kernel32 name 'AllocConsole';
1949
 
function FreeConsole; external kernel32 name 'FreeConsole';
1950
 
function AttachConsole; external kernel32 name 'AttachConsole';
1951
 
function GetConsoleTitleA; external kernel32 name 'GetConsoleTitleA';
1952
 
function GetConsoleTitleW; external kernel32 name 'GetConsoleTitleW';
1953
 
function GetConsoleTitle; external kernel32 name 'GetConsoleTitle' + AWSuffix;
1954
 
function SetConsoleTitleA; external kernel32 name 'SetConsoleTitleA';
1955
 
function SetConsoleTitleW; external kernel32 name 'SetConsoleTitleW';
1956
 
function SetConsoleTitle; external kernel32 name 'SetConsoleTitle' + AWSuffix;
1957
 
function ReadConsoleA; external kernel32 name 'ReadConsoleA';
1958
 
function ReadConsoleW; external kernel32 name 'ReadConsoleW';
1959
 
function ReadConsole; external kernel32 name 'ReadConsole' + AWSuffix;
1960
 
function WriteConsoleA; external kernel32 name 'WriteConsoleA';
1961
 
function WriteConsoleW; external kernel32 name 'WriteConsoleW';
1962
 
function WriteConsole; external kernel32 name 'WriteConsole' + AWSuffix;
1963
 
function CreateConsoleScreenBuffer; external kernel32 name 'CreateConsoleScreenBuffer';
1964
 
function GetConsoleCP; external kernel32 name 'GetConsoleCP';
1965
 
function SetConsoleCP; external kernel32 name 'SetConsoleCP';
1966
 
function GetConsoleOutputCP; external kernel32 name 'GetConsoleOutputCP';
1967
 
function SetConsoleOutputCP; external kernel32 name 'SetConsoleOutputCP';
1968
 
function GetConsoleDisplayMode; external kernel32 name 'GetConsoleDisplayMode';
1969
 
function GetConsoleWindow; external kernel32 name 'GetConsoleWindow';
1970
 
function GetConsoleProcessList; external kernel32 name 'GetConsoleProcessList';
1971
 
function AddConsoleAliasA; external kernel32 name 'AddConsoleAliasA';
1972
 
function AddConsoleAliasW; external kernel32 name 'AddConsoleAliasW';
1973
 
function AddConsoleAlias; external kernel32 name 'AddConsoleAlias' + AWSuffix;
1974
 
function GetConsoleAliasA; external kernel32 name 'GetConsoleAliasA';
1975
 
function GetConsoleAliasW; external kernel32 name 'GetConsoleAliasW';
1976
 
function GetConsoleAlias; external kernel32 name 'GetConsoleAlias' + AWSuffix;
1977
 
function GetConsoleAliasesLengthA; external kernel32 name 'GetConsoleAliasesLengthA';
1978
 
function GetConsoleAliasesLengthW; external kernel32 name 'GetConsoleAliasesLengthW';
1979
 
function GetConsoleAliasesLength; external kernel32 name 'GetConsoleAliasesLength' + AWSuffix;
1980
 
function GetConsoleAliasExesLengthA; external kernel32 name 'GetConsoleAliasExesLengthA';
1981
 
function GetConsoleAliasExesLengthW; external kernel32 name 'GetConsoleAliasExesLengthW';
1982
 
function GetConsoleAliasExesLength; external kernel32 name 'GetConsoleAliasExesLength' + AWSuffix;
1983
 
function GetConsoleAliasesA; external kernel32 name 'GetConsoleAliasesA';
1984
 
function GetConsoleAliasesW; external kernel32 name 'GetConsoleAliasesW';
1985
 
function GetConsoleAliases; external kernel32 name 'GetConsoleAliases' + AWSuffix;
1986
 
function GetConsoleAliasExesA; external kernel32 name 'GetConsoleAliasExesA';
1987
 
function GetConsoleAliasExesW; external kernel32 name 'GetConsoleAliasExesW';
1988
 
function GetConsoleAliasExes; external kernel32 name 'GetConsoleAliasExes' + AWSuffix;
1989
 
 
1990
 
{$ENDIF DYNAMIC_LINK}
1991
 
 
1992
 
end.
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ Console Applications API interface Unit for Object Pascal                    }
 
4
{                                                                              }
 
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
 
6
{ Corporation. All Rights Reserved.                                            }
 
7
{                                                                              }
 
8
{ The original file is: wincon.h, released June 2000. The original Pascal      }
 
9
{ code is: WinCon.pas, released December 2000. The initial developer of the    }
 
10
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
 
11
{                                                                              }
 
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
 
13
{ Marcel van Brakel. All Rights Reserved.                                      }
 
14
{                                                                              }
 
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
 
16
{                                                                              }
 
17
{ You may retrieve the latest version of this file at the Project JEDI         }
 
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
 
19
{                                                                              }
 
20
{ The contents of this file are used with permission, subject to the Mozilla   }
 
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
 
22
{ in compliance with the License. You may obtain a copy of the License at      }
 
23
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
 
24
{                                                                              }
 
25
{ Software distributed under the License is distributed on an "AS IS" basis,   }
 
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
 
27
{ the specific language governing rights and limitations under the License.    }
 
28
{                                                                              }
 
29
{ Alternatively, the contents of this file may be used under the terms of the  }
 
30
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
 
31
{ provisions of the LGPL License are applicable instead of those above.        }
 
32
{ If you wish to allow use of your version of this file only under the terms   }
 
33
{ of the LGPL License and not to allow others to use your version of this file }
 
34
{ under the MPL, indicate your decision by deleting  the provisions above and  }
 
35
{ replace  them with the notice and other provisions required by the LGPL      }
 
36
{ License.  If you do not delete the provisions above, a recipient may use     }
 
37
{ your version of this file under either the MPL or the LGPL License.          }
 
38
{                                                                              }
 
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
 
40
{                                                                              }
 
41
{******************************************************************************}
 
42
 
 
43
 
 
44
unit JwaWinCon;
 
45
 
 
46
{$WEAKPACKAGEUNIT}
 
47
 
 
48
{$HPPEMIT ''}
 
49
{$HPPEMIT '#include "WinCon.h"'}
 
50
{$HPPEMIT ''}
 
51
 
 
52
{$I jediapilib.inc}
 
53
 
 
54
interface
 
55
 
 
56
uses
 
57
  JwaWinBase, JwaWinType;
 
58
 
 
59
type
 
60
  PCOORD = ^COORD;
 
61
  {$EXTERNALSYM PCOORD}
 
62
  _COORD = record
 
63
    X: SHORT;
 
64
    Y: SHORT;
 
65
  end;
 
66
  {$EXTERNALSYM _COORD}
 
67
  COORD = _COORD;
 
68
  {$EXTERNALSYM COORD}
 
69
  TCoord = _COORD;
 
70
 
 
71
  PSMALL_RECT = ^SMALL_RECT;
 
72
  {$EXTERNALSYM PSMALL_RECT}
 
73
  _SMALL_RECT = record
 
74
    Left: SHORT;
 
75
    Top: SHORT;
 
76
    Right: SHORT;
 
77
    Bottom: SHORT;
 
78
  end;
 
79
  {$EXTERNALSYM _SMALL_RECT}
 
80
  SMALL_RECT = _SMALL_RECT;
 
81
  {$EXTERNALSYM SMALL_RECT}
 
82
  TSmallRect = SMALL_RECT;
 
83
  PSmallRect = PSMALL_RECT;
 
84
 
 
85
  TCharUnion = record
 
86
    case Integer of
 
87
      0: (UnicodeChar: WCHAR);
 
88
      1: (AsciiChar: CHAR);
 
89
  end;
 
90
 
 
91
  PKEY_EVENT_RECORD = ^KEY_EVENT_RECORD;
 
92
  {$EXTERNALSYM PKEY_EVENT_RECORD}
 
93
  _KEY_EVENT_RECORD = record
 
94
    bKeyDown: BOOL;
 
95
    wRepeatCount: WORD;
 
96
    wVirtualKeyCode: WORD;
 
97
    wVirtualScanCode: WORD;
 
98
    uChar: TCharUnion;
 
99
    dwControlKeyState: DWORD;
 
100
  end;
 
101
  {$EXTERNALSYM _KEY_EVENT_RECORD}
 
102
  KEY_EVENT_RECORD = _KEY_EVENT_RECORD;
 
103
  {$EXTERNALSYM KEY_EVENT_RECORD}
 
104
  TKeyEventRecord = KEY_EVENT_RECORD;
 
105
  PKeyEventRecord = PKEY_EVENT_RECORD;
 
106
 
 
107
//
 
108
// ControlKeyState flags
 
109
//
 
110
 
 
111
const
 
112
  RIGHT_ALT_PRESSED  = $0001; // the right alt key is pressed.
 
113
  {$EXTERNALSYM RIGHT_ALT_PRESSED}
 
114
  LEFT_ALT_PRESSED   = $0002; // the left alt key is pressed.
 
115
  {$EXTERNALSYM LEFT_ALT_PRESSED}
 
116
  RIGHT_CTRL_PRESSED = $0004; // the right ctrl key is pressed.
 
117
  {$EXTERNALSYM RIGHT_CTRL_PRESSED}
 
118
  LEFT_CTRL_PRESSED  = $0008; // the left ctrl key is pressed.
 
119
  {$EXTERNALSYM LEFT_CTRL_PRESSED}
 
120
  SHIFT_PRESSED      = $0010; // the shift key is pressed.
 
121
  {$EXTERNALSYM SHIFT_PRESSED}
 
122
  NUMLOCK_ON         = $0020; // the numlock light is on.
 
123
  {$EXTERNALSYM NUMLOCK_ON}
 
124
  SCROLLLOCK_ON      = $0040; // the scrolllock light is on.
 
125
  {$EXTERNALSYM SCROLLLOCK_ON}
 
126
  CAPSLOCK_ON        = $0080; // the capslock light is on.
 
127
  {$EXTERNALSYM CAPSLOCK_ON}
 
128
  ENHANCED_KEY       = $0100; // the key is enhanced.
 
129
  {$EXTERNALSYM ENHANCED_KEY}
 
130
  NLS_DBCSCHAR       = $00010000; // DBCS for JPN: SBCS/DBCS mode.
 
131
  {$EXTERNALSYM NLS_DBCSCHAR}
 
132
  NLS_ALPHANUMERIC   = $00000000; // DBCS for JPN: Alphanumeric mode.
 
133
  {$EXTERNALSYM NLS_ALPHANUMERIC}
 
134
  NLS_KATAKANA       = $00020000; // DBCS for JPN: Katakana mode.
 
135
  {$EXTERNALSYM NLS_KATAKANA}
 
136
  NLS_HIRAGANA       = $00040000; // DBCS for JPN: Hiragana mode.
 
137
  {$EXTERNALSYM NLS_HIRAGANA}
 
138
  NLS_ROMAN          = $00400000; // DBCS for JPN: Roman/Noroman mode.
 
139
  {$EXTERNALSYM NLS_ROMAN}
 
140
  NLS_IME_CONVERSION = $00800000; // DBCS for JPN: IME conversion.
 
141
  {$EXTERNALSYM NLS_IME_CONVERSION}
 
142
  NLS_IME_DISABLE    = $20000000; // DBCS for JPN: IME enable/disable.
 
143
  {$EXTERNALSYM NLS_IME_DISABLE}
 
144
 
 
145
type
 
146
  PMOUSE_EVENT_RECORD = ^MOUSE_EVENT_RECORD;
 
147
  {$EXTERNALSYM PMOUSE_EVENT_RECORD}
 
148
  _MOUSE_EVENT_RECORD = record
 
149
    dwMousePosition: COORD;
 
150
    dwButtonState: DWORD;
 
151
    dwControlKeyState: DWORD;
 
152
    dwEventFlags: DWORD;
 
153
  end;
 
154
  {$EXTERNALSYM _MOUSE_EVENT_RECORD}
 
155
  MOUSE_EVENT_RECORD = _MOUSE_EVENT_RECORD;
 
156
  {$EXTERNALSYM MOUSE_EVENT_RECORD}
 
157
  TMouseEventRecord = MOUSE_EVENT_RECORD;
 
158
  PMouseEventRecord = PMOUSE_EVENT_RECORD;
 
159
 
 
160
//
 
161
// ButtonState flags
 
162
//
 
163
 
 
164
const
 
165
  FROM_LEFT_1ST_BUTTON_PRESSED = $0001;
 
166
  {$EXTERNALSYM FROM_LEFT_1ST_BUTTON_PRESSED}
 
167
  RIGHTMOST_BUTTON_PRESSED     = $0002;
 
168
  {$EXTERNALSYM RIGHTMOST_BUTTON_PRESSED}
 
169
  FROM_LEFT_2ND_BUTTON_PRESSED = $0004;
 
170
  {$EXTERNALSYM FROM_LEFT_2ND_BUTTON_PRESSED}
 
171
  FROM_LEFT_3RD_BUTTON_PRESSED = $0008;
 
172
  {$EXTERNALSYM FROM_LEFT_3RD_BUTTON_PRESSED}
 
173
  FROM_LEFT_4TH_BUTTON_PRESSED = $0010;
 
174
  {$EXTERNALSYM FROM_LEFT_4TH_BUTTON_PRESSED}
 
175
 
 
176
//
 
177
// EventFlags
 
178
//
 
179
 
 
180
  MOUSE_MOVED   = $0001;
 
181
  {$EXTERNALSYM MOUSE_MOVED}
 
182
  DOUBLE_CLICK  = $0002;
 
183
  {$EXTERNALSYM DOUBLE_CLICK}
 
184
  MOUSE_WHEELED = $0004;
 
185
  {$EXTERNALSYM MOUSE_WHEELED}
 
186
 
 
187
type
 
188
  PWINDOW_BUFFER_SIZE_RECORD = ^WINDOW_BUFFER_SIZE_RECORD;
 
189
  {$EXTERNALSYM PWINDOW_BUFFER_SIZE_RECORD}
 
190
  _WINDOW_BUFFER_SIZE_RECORD = record
 
191
    dwSize: COORD;
 
192
  end;
 
193
  {$EXTERNALSYM _WINDOW_BUFFER_SIZE_RECORD}
 
194
  WINDOW_BUFFER_SIZE_RECORD = _WINDOW_BUFFER_SIZE_RECORD;
 
195
  {$EXTERNALSYM WINDOW_BUFFER_SIZE_RECORD}
 
196
  TWindowBufferSizeRecord = WINDOW_BUFFER_SIZE_RECORD;
 
197
  PWindowBufferSizeRecord = PWINDOW_BUFFER_SIZE_RECORD;
 
198
 
 
199
  PMENU_EVENT_RECORD = ^MENU_EVENT_RECORD;
 
200
  {$EXTERNALSYM PMENU_EVENT_RECORD}
 
201
  _MENU_EVENT_RECORD = record
 
202
    dwCommandId: UINT;
 
203
  end;
 
204
  {$EXTERNALSYM _MENU_EVENT_RECORD}
 
205
  MENU_EVENT_RECORD = _MENU_EVENT_RECORD;
 
206
  {$EXTERNALSYM MENU_EVENT_RECORD}
 
207
  TMenuEventRecord = MENU_EVENT_RECORD;
 
208
  PMenuEventRecord = PMENU_EVENT_RECORD;
 
209
 
 
210
  PFOCUS_EVENT_RECORD = ^FOCUS_EVENT_RECORD;
 
211
  {$EXTERNALSYM PFOCUS_EVENT_RECORD}
 
212
  _FOCUS_EVENT_RECORD = record
 
213
    bSetFocus: BOOL;
 
214
  end;
 
215
  {$EXTERNALSYM _FOCUS_EVENT_RECORD}
 
216
  FOCUS_EVENT_RECORD = _FOCUS_EVENT_RECORD;
 
217
  {$EXTERNALSYM FOCUS_EVENT_RECORD}
 
218
  TFocusEventRecord = FOCUS_EVENT_RECORD;
 
219
  PFocusEventRecord = PFOCUS_EVENT_RECORD;
 
220
 
 
221
  PINPUT_RECORD = ^INPUT_RECORD;
 
222
  {$EXTERNALSYM PINPUT_RECORD}
 
223
  _INPUT_RECORD = record
 
224
    EventType: WORD;
 
225
    case Integer of
 
226
      0: (KeyEvent: KEY_EVENT_RECORD);
 
227
      1: (MouseEvent: MOUSE_EVENT_RECORD);
 
228
      2: (WindowBufferSizeEvent: WINDOW_BUFFER_SIZE_RECORD);
 
229
      3: (MenuEvent: MENU_EVENT_RECORD);
 
230
      4: (FocusEvent: FOCUS_EVENT_RECORD);
 
231
  end;
 
232
  {$EXTERNALSYM _INPUT_RECORD}
 
233
  INPUT_RECORD = _INPUT_RECORD;
 
234
  {$EXTERNALSYM INPUT_RECORD}
 
235
  TInputRecord = INPUT_RECORD;
 
236
  PInputRecord = PINPUT_RECORD;
 
237
 
 
238
//
 
239
//  EventType flags:
 
240
//
 
241
 
 
242
const
 
243
  KEY_EVENT                = $0001; // Event contains key event record
 
244
  {$EXTERNALSYM KEY_EVENT}
 
245
  MOUSE_EVENT              = $0002; // Event contains mouse event record
 
246
  {$EXTERNALSYM MOUSE_EVENT}
 
247
  WINDOW_BUFFER_SIZE_EVENT = $0004; // Event contains window change event record
 
248
  {$EXTERNALSYM WINDOW_BUFFER_SIZE_EVENT}
 
249
  MENU_EVENT               = $0008; // Event contains menu event record
 
250
  {$EXTERNALSYM MENU_EVENT}
 
251
  FOCUS_EVENT              = $0010; // event contains focus change
 
252
  {$EXTERNALSYM FOCUS_EVENT}
 
253
 
 
254
type
 
255
  PCHAR_INFO = ^CHAR_INFO;
 
256
  {$EXTERNALSYM PCHAR_INFO}
 
257
  _CHAR_INFO = record
 
258
    uChar: TCharUnion;
 
259
    Attributes: WORD;
 
260
  end;
 
261
  {$EXTERNALSYM _CHAR_INFO}
 
262
  CHAR_INFO = _CHAR_INFO;
 
263
  {$EXTERNALSYM CHAR_INFO}
 
264
  TCharInfo = CHAR_INFO;
 
265
  PCharInfo = PCHAR_INFO;
 
266
 
 
267
//
 
268
// Attributes flags:
 
269
//
 
270
 
 
271
const
 
272
  FOREGROUND_BLUE            = $0001; // text color contains blue.
 
273
  {$EXTERNALSYM FOREGROUND_BLUE}
 
274
  FOREGROUND_GREEN           = $0002; // text color contains green.
 
275
  {$EXTERNALSYM FOREGROUND_GREEN}
 
276
  FOREGROUND_RED             = $0004; // text color contains red.
 
277
  {$EXTERNALSYM FOREGROUND_RED}
 
278
  FOREGROUND_INTENSITY       = $0008; // text color is intensified.
 
279
  {$EXTERNALSYM FOREGROUND_INTENSITY}
 
280
  BACKGROUND_BLUE            = $0010; // background color contains blue.
 
281
  {$EXTERNALSYM BACKGROUND_BLUE}
 
282
  BACKGROUND_GREEN           = $0020; // background color contains green.
 
283
  {$EXTERNALSYM BACKGROUND_GREEN}
 
284
  BACKGROUND_RED             = $0040; // background color contains red.
 
285
  {$EXTERNALSYM BACKGROUND_RED}
 
286
  BACKGROUND_INTENSITY       = $0080; // background color is intensified.
 
287
  {$EXTERNALSYM BACKGROUND_INTENSITY}
 
288
  COMMON_LVB_LEADING_BYTE    = $0100; // Leading Byte of DBCS
 
289
  {$EXTERNALSYM COMMON_LVB_LEADING_BYTE}
 
290
  COMMON_LVB_TRAILING_BYTE   = $0200; // Trailing Byte of DBCS
 
291
  {$EXTERNALSYM COMMON_LVB_TRAILING_BYTE}
 
292
  COMMON_LVB_GRID_HORIZONTAL = $0400; // DBCS: Grid attribute: top horizontal.
 
293
  {$EXTERNALSYM COMMON_LVB_GRID_HORIZONTAL}
 
294
  COMMON_LVB_GRID_LVERTICAL  = $0800; // DBCS: Grid attribute: left vertical.
 
295
  {$EXTERNALSYM COMMON_LVB_GRID_LVERTICAL}
 
296
  COMMON_LVB_GRID_RVERTICAL  = $1000; // DBCS: Grid attribute: right vertical.
 
297
  {$EXTERNALSYM COMMON_LVB_GRID_RVERTICAL}
 
298
  COMMON_LVB_REVERSE_VIDEO   = $4000; // DBCS: Reverse fore/back ground attribute.
 
299
  {$EXTERNALSYM COMMON_LVB_REVERSE_VIDEO}
 
300
  COMMON_LVB_UNDERSCORE      = $8000; // DBCS: Underscore.
 
301
  {$EXTERNALSYM COMMON_LVB_UNDERSCORE}
 
302
 
 
303
  COMMON_LVB_SBCSDBCS        = $0300; // SBCS or DBCS flag.
 
304
  {$EXTERNALSYM COMMON_LVB_SBCSDBCS}
 
305
 
 
306
type
 
307
  PCONSOLE_SCREEN_BUFFER_INFO = ^CONSOLE_SCREEN_BUFFER_INFO;
 
308
  {$EXTERNALSYM PCONSOLE_SCREEN_BUFFER_INFO}
 
309
  _CONSOLE_SCREEN_BUFFER_INFO = record
 
310
    dwSize: COORD;
 
311
    dwCursorPosition: COORD;
 
312
    wAttributes: WORD;
 
313
    srWindow: SMALL_RECT;
 
314
    dwMaximumWindowSize: COORD;
 
315
  end;
 
316
  {$EXTERNALSYM _CONSOLE_SCREEN_BUFFER_INFO}
 
317
  CONSOLE_SCREEN_BUFFER_INFO = _CONSOLE_SCREEN_BUFFER_INFO;
 
318
  {$EXTERNALSYM CONSOLE_SCREEN_BUFFER_INFO}
 
319
  TConsoleScreenBufferInfo = CONSOLE_SCREEN_BUFFER_INFO;
 
320
  PConsoleScreenBufferInfo = PCONSOLE_SCREEN_BUFFER_INFO;
 
321
 
 
322
  PCONSOLE_CURSOR_INFO = ^CONSOLE_CURSOR_INFO;
 
323
  {$EXTERNALSYM PCONSOLE_CURSOR_INFO}
 
324
  _CONSOLE_CURSOR_INFO = record
 
325
    dwSize: DWORD;
 
326
    bVisible: BOOL;
 
327
  end;
 
328
  {$EXTERNALSYM _CONSOLE_CURSOR_INFO}
 
329
  CONSOLE_CURSOR_INFO = _CONSOLE_CURSOR_INFO;
 
330
  {$EXTERNALSYM CONSOLE_CURSOR_INFO}
 
331
  TConsoleCursorInfo = CONSOLE_CURSOR_INFO;
 
332
  PConsoleCursorInfo = PCONSOLE_CURSOR_INFO;
 
333
 
 
334
  _CONSOLE_FONT_INFO = record
 
335
    nFont: DWORD;
 
336
    dwFontSize: COORD;
 
337
  end;
 
338
  {$EXTERNALSYM _CONSOLE_FONT_INFO}
 
339
  CONSOLE_FONT_INFO = _CONSOLE_FONT_INFO;
 
340
  {$EXTERNALSYM CONSOLE_FONT_INFO}
 
341
  PCONSOLE_FONT_INFO = ^CONSOLE_FONT_INFO;
 
342
  {$EXTERNALSYM PCONSOLE_FONT_INFO}
 
343
  TConsoleFontInfo = CONSOLE_FONT_INFO;
 
344
  PConsoleFontInfo = PCONSOLE_FONT_INFO;
 
345
 
 
346
  _CONSOLE_SELECTION_INFO = record
 
347
    dwFlags: DWORD;
 
348
    dwSelectionAnchor: COORD;
 
349
    srSelection: SMALL_RECT;
 
350
  end;
 
351
  {$EXTERNALSYM _CONSOLE_SELECTION_INFO}
 
352
  CONSOLE_SELECTION_INFO = _CONSOLE_SELECTION_INFO;
 
353
  {$EXTERNALSYM CONSOLE_SELECTION_INFO}
 
354
  PCONSOLE_SELECTION_INFO = ^CONSOLE_SELECTION_INFO;
 
355
  {$EXTERNALSYM PCONSOLE_SELECTION_INFO}
 
356
  TConsoleSelectionInfo = CONSOLE_SELECTION_INFO;
 
357
  PConsoleSelectionInfo = PCONSOLE_SELECTION_INFO;  
 
358
 
 
359
//
 
360
// Selection flags
 
361
//
 
362
 
 
363
const
 
364
  CONSOLE_NO_SELECTION          = $0000;
 
365
  {$EXTERNALSYM CONSOLE_NO_SELECTION}
 
366
  CONSOLE_SELECTION_IN_PROGRESS = $0001;   // selection has begun
 
367
  {$EXTERNALSYM CONSOLE_SELECTION_IN_PROGRESS}
 
368
  CONSOLE_SELECTION_NOT_EMPTY   = $0002;   // non-null select rectangle
 
369
  {$EXTERNALSYM CONSOLE_SELECTION_NOT_EMPTY}
 
370
  CONSOLE_MOUSE_SELECTION       = $0004;   // selecting with mouse
 
371
  {$EXTERNALSYM CONSOLE_MOUSE_SELECTION}
 
372
  CONSOLE_MOUSE_DOWN            = $0008;   // mouse is down
 
373
  {$EXTERNALSYM CONSOLE_MOUSE_DOWN}
 
374
 
 
375
//
 
376
// typedef for ctrl-c handler routines
 
377
//
 
378
 
 
379
type
 
380
  PHANDLER_ROUTINE = function(CtrlType: DWORD): BOOL; stdcall;
 
381
  {$EXTERNALSYM PHANDLER_ROUTINE}
 
382
  THandlerRoutine = PHANDLER_ROUTINE;
 
383
 
 
384
const
 
385
  CTRL_C_EVENT        = 0;
 
386
  {$EXTERNALSYM CTRL_C_EVENT}
 
387
  CTRL_BREAK_EVENT    = 1;
 
388
  {$EXTERNALSYM CTRL_BREAK_EVENT}
 
389
  CTRL_CLOSE_EVENT    = 2;
 
390
  {$EXTERNALSYM CTRL_CLOSE_EVENT}
 
391
  // 3 is reserved!
 
392
  // 4 is reserved!
 
393
  CTRL_LOGOFF_EVENT   = 5;
 
394
  {$EXTERNALSYM CTRL_LOGOFF_EVENT}
 
395
  CTRL_SHUTDOWN_EVENT = 6;
 
396
  {$EXTERNALSYM CTRL_SHUTDOWN_EVENT}
 
397
 
 
398
//
 
399
//  Input Mode flags:
 
400
//
 
401
 
 
402
  ENABLE_PROCESSED_INPUT = $0001;
 
403
  {$EXTERNALSYM ENABLE_PROCESSED_INPUT}
 
404
  ENABLE_LINE_INPUT      = $0002;
 
405
  {$EXTERNALSYM ENABLE_LINE_INPUT}
 
406
  ENABLE_ECHO_INPUT      = $0004;
 
407
  {$EXTERNALSYM ENABLE_ECHO_INPUT}
 
408
  ENABLE_WINDOW_INPUT    = $0008;
 
409
  {$EXTERNALSYM ENABLE_WINDOW_INPUT}
 
410
  ENABLE_MOUSE_INPUT     = $0010;
 
411
  {$EXTERNALSYM ENABLE_MOUSE_INPUT}
 
412
 
 
413
//
 
414
// Output Mode flags:
 
415
//
 
416
 
 
417
  ENABLE_PROCESSED_OUTPUT   = $0001;
 
418
  {$EXTERNALSYM ENABLE_PROCESSED_OUTPUT}
 
419
  ENABLE_WRAP_AT_EOL_OUTPUT = $0002;
 
420
  {$EXTERNALSYM ENABLE_WRAP_AT_EOL_OUTPUT}
 
421
 
 
422
//
 
423
// direct API definitions.
 
424
//
 
425
 
 
426
function PeekConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
427
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
428
{$EXTERNALSYM PeekConsoleInputA}
 
429
function PeekConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
430
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
431
{$EXTERNALSYM PeekConsoleInputW}
 
432
function PeekConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
433
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
434
{$EXTERNALSYM PeekConsoleInput}
 
435
 
 
436
function ReadConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
437
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
438
{$EXTERNALSYM ReadConsoleInputA}
 
439
function ReadConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
440
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
441
{$EXTERNALSYM ReadConsoleInputW}
 
442
function ReadConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
443
  nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; stdcall;
 
444
{$EXTERNALSYM ReadConsoleInput}
 
445
 
 
446
function WriteConsoleInputA(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
447
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
 
448
{$EXTERNALSYM WriteConsoleInputA}
 
449
function WriteConsoleInputW(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
450
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
 
451
{$EXTERNALSYM WriteConsoleInputW}
 
452
function WriteConsoleInput(hConsoleInput: HANDLE; lpBuffer: PINPUT_RECORD;
 
453
  nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; stdcall;
 
454
{$EXTERNALSYM WriteConsoleInput}
 
455
 
 
456
function ReadConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
457
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
458
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
 
459
{$EXTERNALSYM ReadConsoleOutputA}
 
460
function ReadConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
461
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
462
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
 
463
{$EXTERNALSYM ReadConsoleOutputW}
 
464
function ReadConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
465
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
466
  var lpReadRegion: SMALL_RECT): BOOL; stdcall;
 
467
{$EXTERNALSYM ReadConsoleOutput}
 
468
 
 
469
function WriteConsoleOutputA(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
470
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
471
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
 
472
{$EXTERNALSYM WriteConsoleOutputA}
 
473
function WriteConsoleOutputW(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
474
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
475
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
 
476
{$EXTERNALSYM WriteConsoleOutputW}
 
477
function WriteConsoleOutput(hConsoleOutput: HANDLE; lpBuffer: PCHAR_INFO;
 
478
  dwBufferSize: COORD; dwBufferCoord: COORD;
 
479
  var lpWriteRegion: SMALL_RECT): BOOL; stdcall;
 
480
{$EXTERNALSYM WriteConsoleOutput}
 
481
 
 
482
function ReadConsoleOutputCharacterA(hConsoleOutput: HANDLE; lpCharacter: LPSTR;
 
483
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
 
484
{$EXTERNALSYM ReadConsoleOutputCharacterA}
 
485
function ReadConsoleOutputCharacterW(hConsoleOutput: HANDLE; lpCharacter: LPWSTR;
 
486
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
 
487
{$EXTERNALSYM ReadConsoleOutputCharacterW}
 
488
function ReadConsoleOutputCharacter(hConsoleOutput: HANDLE; lpCharacter: LPTSTR;
 
489
  nLength: DWORD; dwReadCoord: COORD; var lpNumberOfCharsRead: DWORD): BOOL; stdcall;
 
490
{$EXTERNALSYM ReadConsoleOutputCharacter}
 
491
 
 
492
function ReadConsoleOutputAttribute(hConsoleOutput: HANDLE;
 
493
  var lpAttribute: DWORD; nLength: DWORD; dwReadCoord: COORD;
 
494
  var lpNumberOfAttrsRead: DWORD): BOOL; stdcall;
 
495
{$EXTERNALSYM ReadConsoleOutputAttribute}
 
496
 
 
497
function WriteConsoleOutputCharacterA(hConsoleOutput: HANDLE;
 
498
  lpCharacter: LPCSTR; nLength: DWORD; dwWriteCoord: COORD;
 
499
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
500
{$EXTERNALSYM WriteConsoleOutputCharacterA}
 
501
function WriteConsoleOutputCharacterW(hConsoleOutput: HANDLE;
 
502
  lpCharacter: LPCWSTR; nLength: DWORD; dwWriteCoord: COORD;
 
503
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
504
{$EXTERNALSYM WriteConsoleOutputCharacterW}
 
505
function WriteConsoleOutputCharacter(hConsoleOutput: HANDLE;
 
506
  lpCharacter: LPCTSTR; nLength: DWORD; dwWriteCoord: COORD;
 
507
  var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
508
{$EXTERNALSYM WriteConsoleOutputCharacter}
 
509
 
 
510
function WriteConsoleOutputAttribute(hConsoleOutput: HANDLE; lpAttribute: PWORD;
 
511
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
 
512
{$EXTERNALSYM WriteConsoleOutputAttribute}
 
513
 
 
514
function FillConsoleOutputCharacterA(hConsoleOutput: HANDLE; cCharacter: CHAR;
 
515
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
516
{$EXTERNALSYM FillConsoleOutputCharacterA}
 
517
function FillConsoleOutputCharacterW(hConsoleOutput: HANDLE; cCharacter: WCHAR;
 
518
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
519
{$EXTERNALSYM FillConsoleOutputCharacterW}
 
520
function FillConsoleOutputCharacter(hConsoleOutput: HANDLE; cCharacter: TCHAR;
 
521
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfCharsWritten: DWORD): BOOL; stdcall;
 
522
{$EXTERNALSYM FillConsoleOutputCharacter}
 
523
 
 
524
function FillConsoleOutputAttribute(hConsoleOutput: HANDLE; wAttribute: WORD;
 
525
  nLength: DWORD; dwWriteCoord: COORD; var lpNumberOfAttrsWritten: DWORD): BOOL; stdcall;
 
526
{$EXTERNALSYM FillConsoleOutputAttribute}
 
527
function GetConsoleMode(hConsoleHandle: HANDLE; var lpMode: DWORD): BOOL; stdcall;
 
528
{$EXTERNALSYM GetConsoleMode}
 
529
function GetNumberOfConsoleInputEvents(hConsoleInput: HANDLE;
 
530
  var lpNumberOfEvents: DWORD): BOOL; stdcall;
 
531
{$EXTERNALSYM GetNumberOfConsoleInputEvents}
 
532
function GetConsoleScreenBufferInfo(hConsoleOutput: HANDLE;
 
533
  var lpConsoleScreenBufferInfo: CONSOLE_SCREEN_BUFFER_INFO): BOOL; stdcall;
 
534
{$EXTERNALSYM GetConsoleScreenBufferInfo}
 
535
function GetLargestConsoleWindowSize(hConsoleOutput: HANDLE): COORD; stdcall;
 
536
{$EXTERNALSYM GetLargestConsoleWindowSize}
 
537
function GetConsoleCursorInfo(hConsoleOutput: HANDLE;
 
538
  var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
 
539
function GetCurrentConsoleFont(hConsoleOutput: HANDLE; bMaximumWindow: BOOL;
 
540
  var lpConsoleCurrentFont: CONSOLE_FONT_INFO): BOOL; stdcall;
 
541
{$EXTERNALSYM GetCurrentConsoleFont}
 
542
function GetConsoleFontSize(hConsoleOutput: HANDLE; nFont: DWORD): COORD; stdcall;
 
543
{$EXTERNALSYM GetConsoleFontSize}
 
544
function GetConsoleSelectionInfo(var lpConsoleSelectionInfo: CONSOLE_SELECTION_INFO): BOOL; stdcall;
 
545
{$EXTERNALSYM GetConsoleSelectionInfo}
 
546
{$EXTERNALSYM GetConsoleCursorInfo}
 
547
function GetNumberOfConsoleMouseButtons(var lpNumberOfMouseButtons: DWORD): BOOL; stdcall;
 
548
{$EXTERNALSYM GetNumberOfConsoleMouseButtons}
 
549
function SetConsoleMode(hConsoleHandle: HANDLE; dwMode: DWORD): BOOL; stdcall;
 
550
{$EXTERNALSYM SetConsoleMode}
 
551
function SetConsoleActiveScreenBuffer(hConsoleOutput: HANDLE): BOOL; stdcall;
 
552
{$EXTERNALSYM SetConsoleActiveScreenBuffer}
 
553
function FlushConsoleInputBuffer(hConsoleInput: HANDLE): BOOL; stdcall;
 
554
{$EXTERNALSYM FlushConsoleInputBuffer}
 
555
function SetConsoleScreenBufferSize(hConsoleOutput: HANDLE; dwSize: COORD): BOOL; stdcall;
 
556
{$EXTERNALSYM SetConsoleScreenBufferSize}
 
557
function SetConsoleCursorPosition(hConsoleOutput: HANDLE; dwCursorPosition: COORD): BOOL; stdcall;
 
558
{$EXTERNALSYM SetConsoleCursorPosition}
 
559
function SetConsoleCursorInfo(hConsoleOutput: HANDLE;
 
560
  var lpConsoleCursorInfo: CONSOLE_CURSOR_INFO): BOOL; stdcall;
 
561
{$EXTERNALSYM SetConsoleCursorInfo}
 
562
 
 
563
function ScrollConsoleScreenBufferA(hConsoleOutput: HANDLE;
 
564
  const lpScrollRectangle: SMALL_RECT; lpClipRectangle: PSMALL_RECT;
 
565
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
 
566
{$EXTERNALSYM ScrollConsoleScreenBufferA}
 
567
function ScrollConsoleScreenBufferW(hConsoleOutput: HANDLE;
 
568
  const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
 
569
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
 
570
{$EXTERNALSYM ScrollConsoleScreenBufferW}
 
571
function ScrollConsoleScreenBuffer(hConsoleOutput: HANDLE;
 
572
  const lpScrollRectangle: PSMALL_RECT; lpClipRectangle: PSMALL_RECT;
 
573
  dwDestinationOrigin: COORD; const lpFill: CHAR_INFO): BOOL; stdcall;
 
574
{$EXTERNALSYM ScrollConsoleScreenBuffer}
 
575
 
 
576
function SetConsoleWindowInfo(hConsoleOutput: HANDLE; bAbsolute: BOOL;
 
577
  const lpConsoleWindow: SMALL_RECT): BOOL; stdcall;
 
578
{$EXTERNALSYM SetConsoleWindowInfo}
 
579
function SetConsoleTextAttribute(hConsoleOutput: HANDLE; wAttributes: WORD): BOOL; stdcall;
 
580
{$EXTERNALSYM SetConsoleTextAttribute}
 
581
function SetConsoleCtrlHandler(HandlerRoutine: PHANDLER_ROUTINE; Add: BOOL): BOOL; stdcall;
 
582
{$EXTERNALSYM SetConsoleCtrlHandler}
 
583
function GenerateConsoleCtrlEvent(dwCtrlEvent: DWORD; dwProcessGroupId: DWORD): BOOL; stdcall;
 
584
{$EXTERNALSYM GenerateConsoleCtrlEvent}
 
585
function AllocConsole: BOOL; stdcall;
 
586
{$EXTERNALSYM AllocConsole}
 
587
function FreeConsole: BOOL; stdcall;
 
588
{$EXTERNALSYM FreeConsole}
 
589
function AttachConsole(dwProcessId: DWORD): BOOL; stdcall;
 
590
{$EXTERNALSYM AttachConsole}
 
591
 
 
592
const
 
593
  ATTACH_PARENT_PROCESS = DWORD(-1);
 
594
  {$EXTERNALSYM ATTACH_PARENT_PROCESS}
 
595
 
 
596
function GetConsoleTitleA(lpConsoleTitle: LPSTR; nSize: DWORD): DWORD; stdcall;
 
597
{$EXTERNALSYM GetConsoleTitleA}
 
598
function GetConsoleTitleW(lpConsoleTitle: LPWSTR; nSize: DWORD): DWORD; stdcall;
 
599
{$EXTERNALSYM GetConsoleTitleW}
 
600
function GetConsoleTitle(lpConsoleTitle: LPTSTR; nSize: DWORD): DWORD; stdcall;
 
601
{$EXTERNALSYM GetConsoleTitle}
 
602
 
 
603
function SetConsoleTitleA(lpConsoleTitle: LPCSTR): BOOL; stdcall;
 
604
{$EXTERNALSYM SetConsoleTitleA}
 
605
function SetConsoleTitleW(lpConsoleTitle: LPCWSTR): BOOL; stdcall;
 
606
{$EXTERNALSYM SetConsoleTitleW}
 
607
function SetConsoleTitle(lpConsoleTitle: LPCTSTR): BOOL; stdcall;
 
608
{$EXTERNALSYM SetConsoleTitle}
 
609
 
 
610
function ReadConsoleA(hConsoleInput: HANDLE; lpBuffer: LPVOID;
 
611
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
 
612
  lpReserved: LPVOID): BOOL; stdcall;
 
613
{$EXTERNALSYM ReadConsoleA}
 
614
function ReadConsoleW(hConsoleInput: HANDLE; lpBuffer: LPVOID;
 
615
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
 
616
  lpReserved: LPVOID): BOOL; stdcall;
 
617
{$EXTERNALSYM ReadConsoleW}
 
618
function ReadConsole(hConsoleInput: HANDLE; lpBuffer: LPVOID;
 
619
  nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD;
 
620
  lpReserved: LPVOID): BOOL; stdcall;
 
621
{$EXTERNALSYM ReadConsole}
 
622
 
 
623
function WriteConsoleA(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
 
624
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
 
625
  lpReserved: LPVOID): BOOL; stdcall;
 
626
{$EXTERNALSYM WriteConsoleA}
 
627
function WriteConsoleW(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
 
628
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
 
629
  lpReserved: LPVOID): BOOL; stdcall;
 
630
{$EXTERNALSYM WriteConsoleW}
 
631
function WriteConsole(hConsoleOutput: HANDLE; lpBuffer: LPVOID;
 
632
  nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD;
 
633
  lpReserved: LPVOID): BOOL; stdcall;
 
634
{$EXTERNALSYM WriteConsole}
 
635
 
 
636
const
 
637
  CONSOLE_TEXTMODE_BUFFER = 1;
 
638
  {$EXTERNALSYM CONSOLE_TEXTMODE_BUFFER}
 
639
 
 
640
function CreateConsoleScreenBuffer(dwDesiredAccess: DWORD; dwShareMode: DWORD;
 
641
  lpSecurityAttributes: PSECURITY_ATTRIBUTES; dwFlags: DWORD;
 
642
  lpScreenBufferData: LPVOID): HANDLE; stdcall;
 
643
{$EXTERNALSYM CreateConsoleScreenBuffer}
 
644
function GetConsoleCP: UINT; stdcall;
 
645
{$EXTERNALSYM GetConsoleCP}
 
646
function SetConsoleCP(wCodePageID: UINT): BOOL; stdcall;
 
647
{$EXTERNALSYM SetConsoleCP}
 
648
function GetConsoleOutputCP: UINT; stdcall;
 
649
{$EXTERNALSYM GetConsoleOutputCP}
 
650
function SetConsoleOutputCP(wCodePageID: UINT): BOOL; stdcall;
 
651
{$EXTERNALSYM SetConsoleOutputCP}
 
652
 
 
653
const
 
654
  CONSOLE_FULLSCREEN = 1;            // fullscreen console
 
655
  {$EXTERNALSYM CONSOLE_FULLSCREEN}
 
656
  CONSOLE_FULLSCREEN_HARDWARE = 2;   // console owns the hardware
 
657
  {$EXTERNALSYM CONSOLE_FULLSCREEN_HARDWARE}
 
658
 
 
659
function GetConsoleDisplayMode(var lpModeFlags: DWORD): BOOL; stdcall;
 
660
{$EXTERNALSYM GetConsoleDisplayMode}
 
661
 
 
662
function GetConsoleWindow: HWND; stdcall;
 
663
{$EXTERNALSYM GetConsoleWindow}
 
664
 
 
665
function GetConsoleProcessList(var lpdwProcessList: LPDWORD; dwProcessCount: DWORD): DWORD; stdcall;
 
666
{$EXTERNALSYM GetConsoleProcessList}
 
667
 
 
668
//
 
669
// Aliasing apis.
 
670
//
 
671
 
 
672
function AddConsoleAliasA(Source, Target, ExeName: LPSTR): BOOL; stdcall;
 
673
{$EXTERNALSYM AddConsoleAliasA}
 
674
function AddConsoleAliasW(Source, Target, ExeName: LPWSTR): BOOL; stdcall;
 
675
{$EXTERNALSYM AddConsoleAliasW}
 
676
function AddConsoleAlias(Source, Target, ExeName: LPTSTR): BOOL; stdcall;
 
677
{$EXTERNALSYM AddConsoleAlias}
 
678
 
 
679
function GetConsoleAliasA(Source, TargetBuffer: LPSTR; TargetBufferLength: DWORD; ExeName: LPSTR): DWORD; stdcall;
 
680
{$EXTERNALSYM GetConsoleAliasA}
 
681
function GetConsoleAliasW(Source, TargetBuffer: LPWSTR; TargetBufferLength: DWORD; ExeName: LPWSTR): DWORD; stdcall;
 
682
{$EXTERNALSYM GetConsoleAliasW}
 
683
function GetConsoleAlias(Source, TargetBuffer: LPTSTR; TargetBufferLength: DWORD; ExeName: LPTSTR): DWORD; stdcall;
 
684
{$EXTERNALSYM GetConsoleAlias}
 
685
 
 
686
function GetConsoleAliasesLengthA(ExeName: LPSTR): DWORD; stdcall;
 
687
{$EXTERNALSYM GetConsoleAliasesLengthA}
 
688
function GetConsoleAliasesLengthW(ExeName: LPWSTR): DWORD; stdcall;
 
689
{$EXTERNALSYM GetConsoleAliasesLengthW}
 
690
function GetConsoleAliasesLength(ExeName: LPTSTR): DWORD; stdcall;
 
691
{$EXTERNALSYM GetConsoleAliasesLength}
 
692
 
 
693
function GetConsoleAliasExesLengthA: DWORD; stdcall;
 
694
{$EXTERNALSYM GetConsoleAliasExesLengthA}
 
695
function GetConsoleAliasExesLengthW: DWORD; stdcall;
 
696
{$EXTERNALSYM GetConsoleAliasExesLengthW}
 
697
function GetConsoleAliasExesLength: DWORD; stdcall;
 
698
{$EXTERNALSYM GetConsoleAliasExesLength}
 
699
 
 
700
function GetConsoleAliasesA(AliasBuffer: LPSTR; AliasBufferLength: DWORD; ExeName: LPSTR): DWORD; stdcall;
 
701
{$EXTERNALSYM GetConsoleAliasesA}
 
702
function GetConsoleAliasesW(AliasBuffer: LPWSTR; AliasBufferLength: DWORD; ExeName: LPWSTR): DWORD; stdcall;
 
703
{$EXTERNALSYM GetConsoleAliasesW}
 
704
function GetConsoleAliases(AliasBuffer: LPTSTR; AliasBufferLength: DWORD; ExeName: LPTSTR): DWORD; stdcall;
 
705
{$EXTERNALSYM GetConsoleAliases}
 
706
 
 
707
function GetConsoleAliasExesA(ExeNameBuffer: LPSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
 
708
{$EXTERNALSYM GetConsoleAliasExesA}
 
709
function GetConsoleAliasExesW(ExeNameBuffer: LPWSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
 
710
{$EXTERNALSYM GetConsoleAliasExesW}
 
711
function GetConsoleAliasExes(ExeNameBuffer: LPTSTR; ExeNameBufferLength: DWORD): DWORD; stdcall;
 
712
{$EXTERNALSYM GetConsoleAliasExes}
 
713
 
 
714
implementation
 
715
 
 
716
const
 
717
  kernel32 = 'kernel32.dll';
 
718
  {$IFDEF UNICODE}
 
719
  AWSuffix = 'W';
 
720
  {$ELSE}
 
721
  AWSuffix = 'A';
 
722
  {$ENDIF UNICODE}
 
723
 
 
724
{$IFDEF DYNAMIC_LINK}
 
725
 
 
726
var
 
727
  _PeekConsoleInputA: Pointer;
 
728
 
 
729
function PeekConsoleInputA;
 
730
begin
 
731
  GetProcedureAddress(_PeekConsoleInputA, kernel32, 'PeekConsoleInputA');
 
732
  asm
 
733
        MOV     ESP, EBP
 
734
        POP     EBP
 
735
        JMP     [_PeekConsoleInputA]
 
736
  end;
 
737
end;
 
738
 
 
739
var
 
740
  _PeekConsoleInputW: Pointer;
 
741
 
 
742
function PeekConsoleInputW;
 
743
begin
 
744
  GetProcedureAddress(_PeekConsoleInputW, kernel32, 'PeekConsoleInputW');
 
745
  asm
 
746
        MOV     ESP, EBP
 
747
        POP     EBP
 
748
        JMP     [_PeekConsoleInputW]
 
749
  end;
 
750
end;
 
751
 
 
752
var
 
753
  _PeekConsoleInput: Pointer;
 
754
 
 
755
function PeekConsoleInput;
 
756
begin
 
757
  GetProcedureAddress(_PeekConsoleInput, kernel32, 'PeekConsoleInput' + AWSuffix);
 
758
  asm
 
759
        MOV     ESP, EBP
 
760
        POP     EBP
 
761
        JMP     [_PeekConsoleInput]
 
762
  end;
 
763
end;
 
764
 
 
765
var
 
766
  _ReadConsoleInputA: Pointer;
 
767
 
 
768
function ReadConsoleInputA;
 
769
begin
 
770
  GetProcedureAddress(_ReadConsoleInputA, kernel32, 'ReadConsoleInputA');
 
771
  asm
 
772
        MOV     ESP, EBP
 
773
        POP     EBP
 
774
        JMP     [_ReadConsoleInputA]
 
775
  end;
 
776
end;
 
777
 
 
778
var
 
779
  _ReadConsoleInputW: Pointer;
 
780
 
 
781
function ReadConsoleInputW;
 
782
begin
 
783
  GetProcedureAddress(_ReadConsoleInputW, kernel32, 'ReadConsoleInputW');
 
784
  asm
 
785
        MOV     ESP, EBP
 
786
        POP     EBP
 
787
        JMP     [_ReadConsoleInputW]
 
788
  end;
 
789
end;
 
790
 
 
791
var
 
792
  _ReadConsoleInput: Pointer;
 
793
 
 
794
function ReadConsoleInput;
 
795
begin
 
796
  GetProcedureAddress(_ReadConsoleInput, kernel32, 'ReadConsoleInput' + AWSuffix);
 
797
  asm
 
798
        MOV     ESP, EBP
 
799
        POP     EBP
 
800
        JMP     [_ReadConsoleInput]
 
801
  end;
 
802
end;
 
803
 
 
804
var
 
805
  _WriteConsoleInputA: Pointer;
 
806
 
 
807
function WriteConsoleInputA;
 
808
begin
 
809
  GetProcedureAddress(_WriteConsoleInputA, kernel32, 'WriteConsoleInputA');
 
810
  asm
 
811
        MOV     ESP, EBP
 
812
        POP     EBP
 
813
        JMP     [_WriteConsoleInputA]
 
814
  end;
 
815
end;
 
816
 
 
817
var
 
818
  _WriteConsoleInputW: Pointer;
 
819
 
 
820
function WriteConsoleInputW;
 
821
begin
 
822
  GetProcedureAddress(_WriteConsoleInputW, kernel32, 'WriteConsoleInputW');
 
823
  asm
 
824
        MOV     ESP, EBP
 
825
        POP     EBP
 
826
        JMP     [_WriteConsoleInputW]
 
827
  end;
 
828
end;
 
829
 
 
830
var
 
831
  _WriteConsoleInput: Pointer;
 
832
 
 
833
function WriteConsoleInput;
 
834
begin
 
835
  GetProcedureAddress(_WriteConsoleInput, kernel32, 'WriteConsoleInput' + AWSuffix);
 
836
  asm
 
837
        MOV     ESP, EBP
 
838
        POP     EBP
 
839
        JMP     [_WriteConsoleInput]
 
840
  end;
 
841
end;
 
842
 
 
843
var
 
844
  _ReadConsoleOutputA: Pointer;
 
845
 
 
846
function ReadConsoleOutputA;
 
847
begin
 
848
  GetProcedureAddress(_ReadConsoleOutputA, kernel32, 'ReadConsoleOutputA');
 
849
  asm
 
850
        MOV     ESP, EBP
 
851
        POP     EBP
 
852
        JMP     [_ReadConsoleOutputA]
 
853
  end;
 
854
end;
 
855
 
 
856
var
 
857
  _ReadConsoleOutputW: Pointer;
 
858
 
 
859
function ReadConsoleOutputW;
 
860
begin
 
861
  GetProcedureAddress(_ReadConsoleOutputW, kernel32, 'ReadConsoleOutputW');
 
862
  asm
 
863
        MOV     ESP, EBP
 
864
        POP     EBP
 
865
        JMP     [_ReadConsoleOutputW]
 
866
  end;
 
867
end;
 
868
 
 
869
var
 
870
  _ReadConsoleOutput: Pointer;
 
871
 
 
872
function ReadConsoleOutput;
 
873
begin
 
874
  GetProcedureAddress(_ReadConsoleOutput, kernel32, 'ReadConsoleOutput' + AWSuffix);
 
875
  asm
 
876
        MOV     ESP, EBP
 
877
        POP     EBP
 
878
        JMP     [_ReadConsoleOutput]
 
879
  end;
 
880
end;
 
881
 
 
882
var
 
883
  _WriteConsoleOutputA: Pointer;
 
884
 
 
885
function WriteConsoleOutputA;
 
886
begin
 
887
  GetProcedureAddress(_WriteConsoleOutputA, kernel32, 'WriteConsoleOutputA');
 
888
  asm
 
889
        MOV     ESP, EBP
 
890
        POP     EBP
 
891
        JMP     [_WriteConsoleOutputA]
 
892
  end;
 
893
end;
 
894
 
 
895
var
 
896
  _WriteConsoleOutputW: Pointer;
 
897
 
 
898
function WriteConsoleOutputW;
 
899
begin
 
900
  GetProcedureAddress(_WriteConsoleOutputW, kernel32, 'WriteConsoleOutputW');
 
901
  asm
 
902
        MOV     ESP, EBP
 
903
        POP     EBP
 
904
        JMP     [_WriteConsoleOutputW]
 
905
  end;
 
906
end;
 
907
 
 
908
var
 
909
  _WriteConsoleOutput: Pointer;
 
910
 
 
911
function WriteConsoleOutput;
 
912
begin
 
913
  GetProcedureAddress(_WriteConsoleOutput, kernel32, 'WriteConsoleOutput' + AWSuffix);
 
914
  asm
 
915
        MOV     ESP, EBP
 
916
        POP     EBP
 
917
        JMP     [_WriteConsoleOutput]
 
918
  end;
 
919
end;
 
920
 
 
921
var
 
922
  _ReadConsoleOutputCharacterA: Pointer;
 
923
 
 
924
function ReadConsoleOutputCharacterA;
 
925
begin
 
926
  GetProcedureAddress(_ReadConsoleOutputCharacterA, kernel32, 'ReadConsoleOutputCharacterA');
 
927
  asm
 
928
        MOV     ESP, EBP
 
929
        POP     EBP
 
930
        JMP     [_ReadConsoleOutputCharacterA]
 
931
  end;
 
932
end;
 
933
 
 
934
var
 
935
  _ReadConsoleOutputCharacterW: Pointer;
 
936
 
 
937
function ReadConsoleOutputCharacterW;
 
938
begin
 
939
  GetProcedureAddress(_ReadConsoleOutputCharacterW, kernel32, 'ReadConsoleOutputCharacterW');
 
940
  asm
 
941
        MOV     ESP, EBP
 
942
        POP     EBP
 
943
        JMP     [_ReadConsoleOutputCharacterW]
 
944
  end;
 
945
end;
 
946
 
 
947
var
 
948
  _ReadConsoleOutputCharacter: Pointer;
 
949
 
 
950
function ReadConsoleOutputCharacter;
 
951
begin
 
952
  GetProcedureAddress(_ReadConsoleOutputCharacter, kernel32, 'ReadConsoleOutputCharacter' + AWSuffix);
 
953
  asm
 
954
        MOV     ESP, EBP
 
955
        POP     EBP
 
956
        JMP     [_ReadConsoleOutputCharacter]
 
957
  end;
 
958
end;
 
959
 
 
960
var
 
961
  _ReadConsoleOutputAttribute: Pointer;
 
962
 
 
963
function ReadConsoleOutputAttribute;
 
964
begin
 
965
  GetProcedureAddress(_ReadConsoleOutputAttribute, kernel32, 'ReadConsoleOutputAttribute');
 
966
  asm
 
967
        MOV     ESP, EBP
 
968
        POP     EBP
 
969
        JMP     [_ReadConsoleOutputAttribute]
 
970
  end;
 
971
end;
 
972
 
 
973
var
 
974
  _WriteConsoleOutputCharacterA: Pointer;
 
975
 
 
976
function WriteConsoleOutputCharacterA;
 
977
begin
 
978
  GetProcedureAddress(_WriteConsoleOutputCharacterA, kernel32, 'WriteConsoleOutputCharacterA');
 
979
  asm
 
980
        MOV     ESP, EBP
 
981
        POP     EBP
 
982
        JMP     [_WriteConsoleOutputCharacterA]
 
983
  end;
 
984
end;
 
985
 
 
986
var
 
987
  _WriteConsoleOutputCharacterW: Pointer;
 
988
 
 
989
function WriteConsoleOutputCharacterW;
 
990
begin
 
991
  GetProcedureAddress(_WriteConsoleOutputCharacterW, kernel32, 'WriteConsoleOutputCharacterW');
 
992
  asm
 
993
        MOV     ESP, EBP
 
994
        POP     EBP
 
995
        JMP     [_WriteConsoleOutputCharacterW]
 
996
  end;
 
997
end;
 
998
 
 
999
var
 
1000
  _WriteConsoleOutputCharacter: Pointer;
 
1001
 
 
1002
function WriteConsoleOutputCharacter;
 
1003
begin
 
1004
  GetProcedureAddress(_WriteConsoleOutputCharacter, kernel32, 'WriteConsoleOutputCharacter' + AWSuffix);
 
1005
  asm
 
1006
        MOV     ESP, EBP
 
1007
        POP     EBP
 
1008
        JMP     [_WriteConsoleOutputCharacter]
 
1009
  end;
 
1010
end;
 
1011
 
 
1012
var
 
1013
  _WriteConsoleOutputAttribute: Pointer;
 
1014
 
 
1015
function WriteConsoleOutputAttribute;
 
1016
begin
 
1017
  GetProcedureAddress(_WriteConsoleOutputAttribute, kernel32, 'WriteConsoleOutputAttribute');
 
1018
  asm
 
1019
        MOV     ESP, EBP
 
1020
        POP     EBP
 
1021
        JMP     [_WriteConsoleOutputAttribute]
 
1022
  end;
 
1023
end;
 
1024
 
 
1025
var
 
1026
  _FillConsoleOutputCharacterA: Pointer;
 
1027
 
 
1028
function FillConsoleOutputCharacterA;
 
1029
begin
 
1030
  GetProcedureAddress(_FillConsoleOutputCharacterA, kernel32, 'FillConsoleOutputCharacterA');
 
1031
  asm
 
1032
        MOV     ESP, EBP
 
1033
        POP     EBP
 
1034
        JMP     [_FillConsoleOutputCharacterA]
 
1035
  end;
 
1036
end;
 
1037
 
 
1038
var
 
1039
  _FillConsoleOutputCharacterW: Pointer;
 
1040
 
 
1041
function FillConsoleOutputCharacterW;
 
1042
begin
 
1043
  GetProcedureAddress(_FillConsoleOutputCharacterW, kernel32, 'FillConsoleOutputCharacterW');
 
1044
  asm
 
1045
        MOV     ESP, EBP
 
1046
        POP     EBP
 
1047
        JMP     [_FillConsoleOutputCharacterW]
 
1048
  end;
 
1049
end;
 
1050
 
 
1051
var
 
1052
  _FillConsoleOutputCharacter: Pointer;
 
1053
 
 
1054
function FillConsoleOutputCharacter;
 
1055
begin
 
1056
  GetProcedureAddress(_FillConsoleOutputCharacter, kernel32, 'FillConsoleOutputCharacter' + AWSuffix);
 
1057
  asm
 
1058
        MOV     ESP, EBP
 
1059
        POP     EBP
 
1060
        JMP     [_FillConsoleOutputCharacter]
 
1061
  end;
 
1062
end;
 
1063
 
 
1064
var
 
1065
  _FillConsoleOutputAttribute: Pointer;
 
1066
 
 
1067
function FillConsoleOutputAttribute;
 
1068
begin
 
1069
  GetProcedureAddress(_FillConsoleOutputAttribute, kernel32, 'FillConsoleOutputAttribute');
 
1070
  asm
 
1071
        MOV     ESP, EBP
 
1072
        POP     EBP
 
1073
        JMP     [_FillConsoleOutputAttribute]
 
1074
  end;
 
1075
end;
 
1076
 
 
1077
var
 
1078
  _GetConsoleMode: Pointer;
 
1079
 
 
1080
function GetConsoleMode;
 
1081
begin
 
1082
  GetProcedureAddress(_GetConsoleMode, kernel32, 'GetConsoleMode');
 
1083
  asm
 
1084
        MOV     ESP, EBP
 
1085
        POP     EBP
 
1086
        JMP     [_GetConsoleMode]
 
1087
  end;
 
1088
end;
 
1089
 
 
1090
var
 
1091
  _GetNumberOfConsoleInputEvents: Pointer;
 
1092
 
 
1093
function GetNumberOfConsoleInputEvents;
 
1094
begin
 
1095
  GetProcedureAddress(_GetNumberOfConsoleInputEvents, kernel32, 'GetNumberOfConsoleInputEvents');
 
1096
  asm
 
1097
        MOV     ESP, EBP
 
1098
        POP     EBP
 
1099
        JMP     [_GetNumberOfConsoleInputEvents]
 
1100
  end;
 
1101
end;
 
1102
 
 
1103
var
 
1104
  _GetConsoleScreenBufferInfo: Pointer;
 
1105
 
 
1106
function GetConsoleScreenBufferInfo;
 
1107
begin
 
1108
  GetProcedureAddress(_GetConsoleScreenBufferInfo, kernel32, 'GetConsoleScreenBufferInfo');
 
1109
  asm
 
1110
        MOV     ESP, EBP
 
1111
        POP     EBP
 
1112
        JMP     [_GetConsoleScreenBufferInfo]
 
1113
  end;
 
1114
end;
 
1115
 
 
1116
var
 
1117
  _GetLargestConsoleWindowSize: Pointer;
 
1118
 
 
1119
function GetLargestConsoleWindowSize;
 
1120
begin
 
1121
  GetProcedureAddress(_GetLargestConsoleWindowSize, kernel32, 'GetLargestConsoleWindowSize');
 
1122
  asm
 
1123
        MOV     ESP, EBP
 
1124
        POP     EBP
 
1125
        JMP     [_GetLargestConsoleWindowSize]
 
1126
  end;
 
1127
end;
 
1128
 
 
1129
var
 
1130
  _GetConsoleCursorInfo: Pointer;
 
1131
 
 
1132
function GetConsoleCursorInfo;
 
1133
begin
 
1134
  GetProcedureAddress(_GetConsoleCursorInfo, kernel32, 'GetConsoleCursorInfo');
 
1135
  asm
 
1136
        MOV     ESP, EBP
 
1137
        POP     EBP
 
1138
        JMP     [_GetConsoleCursorInfo]
 
1139
  end;
 
1140
end;
 
1141
 
 
1142
var
 
1143
  _GetCurrentConsoleFont: Pointer;
 
1144
 
 
1145
function GetCurrentConsoleFont;
 
1146
begin
 
1147
  GetProcedureAddress(_GetCurrentConsoleFont, kernel32, 'GetCurrentConsoleFont');
 
1148
  asm
 
1149
        MOV     ESP, EBP
 
1150
        POP     EBP
 
1151
        JMP     [_GetCurrentConsoleFont]
 
1152
  end;
 
1153
end;
 
1154
 
 
1155
var
 
1156
  _GetConsoleFontSize: Pointer;
 
1157
 
 
1158
function GetConsoleFontSize;
 
1159
begin
 
1160
  GetProcedureAddress(_GetConsoleFontSize, kernel32, 'GetConsoleFontSize');
 
1161
  asm
 
1162
        MOV     ESP, EBP
 
1163
        POP     EBP
 
1164
        JMP     [_GetConsoleFontSize]
 
1165
  end;
 
1166
end;
 
1167
 
 
1168
var
 
1169
  _GetConsoleSelectionInfo: Pointer;
 
1170
 
 
1171
function GetConsoleSelectionInfo;
 
1172
begin
 
1173
  GetProcedureAddress(_GetConsoleSelectionInfo, kernel32, 'GetConsoleSelectionInfo');
 
1174
  asm
 
1175
        MOV     ESP, EBP
 
1176
        POP     EBP
 
1177
        JMP     [_GetConsoleSelectionInfo]
 
1178
  end;
 
1179
end;
 
1180
 
 
1181
var
 
1182
  _GetNumberOfConsoleMouseButtons: Pointer;
 
1183
 
 
1184
function GetNumberOfConsoleMouseButtons;
 
1185
begin
 
1186
  GetProcedureAddress(_GetNumberOfConsoleMouseButtons, kernel32, 'GetNumberOfConsoleMouseButtons');
 
1187
  asm
 
1188
        MOV     ESP, EBP
 
1189
        POP     EBP
 
1190
        JMP     [_GetNumberOfConsoleMouseButtons]
 
1191
  end;
 
1192
end;
 
1193
 
 
1194
var
 
1195
  _SetConsoleMode: Pointer;
 
1196
 
 
1197
function SetConsoleMode;
 
1198
begin
 
1199
  GetProcedureAddress(_SetConsoleMode, kernel32, 'SetConsoleMode');
 
1200
  asm
 
1201
        MOV     ESP, EBP
 
1202
        POP     EBP
 
1203
        JMP     [_SetConsoleMode]
 
1204
  end;
 
1205
end;
 
1206
 
 
1207
var
 
1208
  _SetConsoleActiveScreenBuffer: Pointer;
 
1209
 
 
1210
function SetConsoleActiveScreenBuffer;
 
1211
begin
 
1212
  GetProcedureAddress(_SetConsoleActiveScreenBuffer, kernel32, 'SetConsoleActiveScreenBuffer');
 
1213
  asm
 
1214
        MOV     ESP, EBP
 
1215
        POP     EBP
 
1216
        JMP     [_SetConsoleActiveScreenBuffer]
 
1217
  end;
 
1218
end;
 
1219
 
 
1220
var
 
1221
  _FlushConsoleInputBuffer: Pointer;
 
1222
 
 
1223
function FlushConsoleInputBuffer;
 
1224
begin
 
1225
  GetProcedureAddress(_FlushConsoleInputBuffer, kernel32, 'FlushConsoleInputBuffer');
 
1226
  asm
 
1227
        MOV     ESP, EBP
 
1228
        POP     EBP
 
1229
        JMP     [_FlushConsoleInputBuffer]
 
1230
  end;
 
1231
end;
 
1232
 
 
1233
var
 
1234
  _SetConsoleScreenBufferSize: Pointer;
 
1235
 
 
1236
function SetConsoleScreenBufferSize;
 
1237
begin
 
1238
  GetProcedureAddress(_SetConsoleScreenBufferSize, kernel32, 'SetConsoleScreenBufferSize');
 
1239
  asm
 
1240
        MOV     ESP, EBP
 
1241
        POP     EBP
 
1242
        JMP     [_SetConsoleScreenBufferSize]
 
1243
  end;
 
1244
end;
 
1245
 
 
1246
var
 
1247
  _SetConsoleCursorPosition: Pointer;
 
1248
 
 
1249
function SetConsoleCursorPosition;
 
1250
begin
 
1251
  GetProcedureAddress(_SetConsoleCursorPosition, kernel32, 'SetConsoleCursorPosition');
 
1252
  asm
 
1253
        MOV     ESP, EBP
 
1254
        POP     EBP
 
1255
        JMP     [_SetConsoleCursorPosition]
 
1256
  end;
 
1257
end;
 
1258
 
 
1259
var
 
1260
  _SetConsoleCursorInfo: Pointer;
 
1261
 
 
1262
function SetConsoleCursorInfo;
 
1263
begin
 
1264
  GetProcedureAddress(_SetConsoleCursorInfo, kernel32, 'SetConsoleCursorInfo');
 
1265
  asm
 
1266
        MOV     ESP, EBP
 
1267
        POP     EBP
 
1268
        JMP     [_SetConsoleCursorInfo]
 
1269
  end;
 
1270
end;
 
1271
 
 
1272
var
 
1273
  _ScrollConsoleScreenBufferA: Pointer;
 
1274
 
 
1275
function ScrollConsoleScreenBufferA;
 
1276
begin
 
1277
  GetProcedureAddress(_ScrollConsoleScreenBufferA, kernel32, 'ScrollConsoleScreenBufferA');
 
1278
  asm
 
1279
        MOV     ESP, EBP
 
1280
        POP     EBP
 
1281
        JMP     [_ScrollConsoleScreenBufferA]
 
1282
  end;
 
1283
end;
 
1284
 
 
1285
var
 
1286
  _ScrollConsoleScreenBufferW: Pointer;
 
1287
 
 
1288
function ScrollConsoleScreenBufferW;
 
1289
begin
 
1290
  GetProcedureAddress(_ScrollConsoleScreenBufferW, kernel32, 'ScrollConsoleScreenBufferW');
 
1291
  asm
 
1292
        MOV     ESP, EBP
 
1293
        POP     EBP
 
1294
        JMP     [_ScrollConsoleScreenBufferW]
 
1295
  end;
 
1296
end;
 
1297
 
 
1298
var
 
1299
  _ScrollConsoleScreenBuffer: Pointer;
 
1300
 
 
1301
function ScrollConsoleScreenBuffer;
 
1302
begin
 
1303
  GetProcedureAddress(_ScrollConsoleScreenBuffer, kernel32, 'ScrollConsoleScreenBuffer' + AWSuffix);
 
1304
  asm
 
1305
        MOV     ESP, EBP
 
1306
        POP     EBP
 
1307
        JMP     [_ScrollConsoleScreenBuffer]
 
1308
  end;
 
1309
end;
 
1310
 
 
1311
var
 
1312
  _SetConsoleWindowInfo: Pointer;
 
1313
 
 
1314
function SetConsoleWindowInfo;
 
1315
begin
 
1316
  GetProcedureAddress(_SetConsoleWindowInfo, kernel32, 'SetConsoleWindowInfo');
 
1317
  asm
 
1318
        MOV     ESP, EBP
 
1319
        POP     EBP
 
1320
        JMP     [_SetConsoleWindowInfo]
 
1321
  end;
 
1322
end;
 
1323
 
 
1324
var
 
1325
  _SetConsoleTextAttribute: Pointer;
 
1326
 
 
1327
function SetConsoleTextAttribute;
 
1328
begin
 
1329
  GetProcedureAddress(_SetConsoleTextAttribute, kernel32, 'SetConsoleTextAttribute');
 
1330
  asm
 
1331
        MOV     ESP, EBP
 
1332
        POP     EBP
 
1333
        JMP     [_SetConsoleTextAttribute]
 
1334
  end;
 
1335
end;
 
1336
 
 
1337
var
 
1338
  _SetConsoleCtrlHandler: Pointer;
 
1339
 
 
1340
function SetConsoleCtrlHandler;
 
1341
begin
 
1342
  GetProcedureAddress(_SetConsoleCtrlHandler, kernel32, 'SetConsoleCtrlHandler');
 
1343
  asm
 
1344
        MOV     ESP, EBP
 
1345
        POP     EBP
 
1346
        JMP     [_SetConsoleCtrlHandler]
 
1347
  end;
 
1348
end;
 
1349
 
 
1350
var
 
1351
  _GenerateConsoleCtrlEvent: Pointer;
 
1352
 
 
1353
function GenerateConsoleCtrlEvent;
 
1354
begin
 
1355
  GetProcedureAddress(_GenerateConsoleCtrlEvent, kernel32, 'GenerateConsoleCtrlEvent');
 
1356
  asm
 
1357
        MOV     ESP, EBP
 
1358
        POP     EBP
 
1359
        JMP     [_GenerateConsoleCtrlEvent]
 
1360
  end;
 
1361
end;
 
1362
 
 
1363
var
 
1364
  _AllocConsole: Pointer;
 
1365
 
 
1366
function AllocConsole;
 
1367
begin
 
1368
  GetProcedureAddress(_AllocConsole, kernel32, 'AllocConsole');
 
1369
  asm
 
1370
        MOV     ESP, EBP
 
1371
        POP     EBP
 
1372
        JMP     [_AllocConsole]
 
1373
  end;
 
1374
end;
 
1375
 
 
1376
var
 
1377
  _FreeConsole: Pointer;
 
1378
 
 
1379
function FreeConsole;
 
1380
begin
 
1381
  GetProcedureAddress(_FreeConsole, kernel32, 'FreeConsole');
 
1382
  asm
 
1383
        MOV     ESP, EBP
 
1384
        POP     EBP
 
1385
        JMP     [_FreeConsole]
 
1386
  end;
 
1387
end;
 
1388
 
 
1389
var
 
1390
  _AttachConsole: Pointer;
 
1391
 
 
1392
function AttachConsole;
 
1393
begin
 
1394
  GetProcedureAddress(_AttachConsole, kernel32, 'AttachConsole');
 
1395
  asm
 
1396
        MOV     ESP, EBP
 
1397
        POP     EBP
 
1398
        JMP     [_AttachConsole]
 
1399
  end;
 
1400
end;
 
1401
 
 
1402
var
 
1403
  _GetConsoleTitleA: Pointer;
 
1404
 
 
1405
function GetConsoleTitleA;
 
1406
begin
 
1407
  GetProcedureAddress(_GetConsoleTitleA, kernel32, 'GetConsoleTitleA');
 
1408
  asm
 
1409
        MOV     ESP, EBP
 
1410
        POP     EBP
 
1411
        JMP     [_GetConsoleTitleA]
 
1412
  end;
 
1413
end;
 
1414
 
 
1415
var
 
1416
  _GetConsoleTitleW: Pointer;
 
1417
 
 
1418
function GetConsoleTitleW;
 
1419
begin
 
1420
  GetProcedureAddress(_GetConsoleTitleW, kernel32, 'GetConsoleTitleW');
 
1421
  asm
 
1422
        MOV     ESP, EBP
 
1423
        POP     EBP
 
1424
        JMP     [_GetConsoleTitleW]
 
1425
  end;
 
1426
end;
 
1427
 
 
1428
var
 
1429
  _GetConsoleTitle: Pointer;
 
1430
 
 
1431
function GetConsoleTitle;
 
1432
begin
 
1433
  GetProcedureAddress(_GetConsoleTitle, kernel32, 'GetConsoleTitle' + AWSuffix);
 
1434
  asm
 
1435
        MOV     ESP, EBP
 
1436
        POP     EBP
 
1437
        JMP     [_GetConsoleTitle]
 
1438
  end;
 
1439
end;
 
1440
 
 
1441
var
 
1442
  _SetConsoleTitleA: Pointer;
 
1443
 
 
1444
function SetConsoleTitleA;
 
1445
begin
 
1446
  GetProcedureAddress(_SetConsoleTitleA, kernel32, 'SetConsoleTitleA');
 
1447
  asm
 
1448
        MOV     ESP, EBP
 
1449
        POP     EBP
 
1450
        JMP     [_SetConsoleTitleA]
 
1451
  end;
 
1452
end;
 
1453
 
 
1454
var
 
1455
  _SetConsoleTitleW: Pointer;
 
1456
 
 
1457
function SetConsoleTitleW;
 
1458
begin
 
1459
  GetProcedureAddress(_SetConsoleTitleW, kernel32, 'SetConsoleTitleW');
 
1460
  asm
 
1461
        MOV     ESP, EBP
 
1462
        POP     EBP
 
1463
        JMP     [_SetConsoleTitleW]
 
1464
  end;
 
1465
end;
 
1466
 
 
1467
var
 
1468
  _SetConsoleTitle: Pointer;
 
1469
 
 
1470
function SetConsoleTitle;
 
1471
begin
 
1472
  GetProcedureAddress(_SetConsoleTitle, kernel32, 'SetConsoleTitle' + AWSuffix);
 
1473
  asm
 
1474
        MOV     ESP, EBP
 
1475
        POP     EBP
 
1476
        JMP     [_SetConsoleTitle]
 
1477
  end;
 
1478
end;
 
1479
 
 
1480
var
 
1481
  _ReadConsoleA: Pointer;
 
1482
 
 
1483
function ReadConsoleA;
 
1484
begin
 
1485
  GetProcedureAddress(_ReadConsoleA, kernel32, 'ReadConsoleA');
 
1486
  asm
 
1487
        MOV     ESP, EBP
 
1488
        POP     EBP
 
1489
        JMP     [_ReadConsoleA]
 
1490
  end;
 
1491
end;
 
1492
 
 
1493
var
 
1494
  _ReadConsoleW: Pointer;
 
1495
 
 
1496
function ReadConsoleW;
 
1497
begin
 
1498
  GetProcedureAddress(_ReadConsoleW, kernel32, 'ReadConsoleW');
 
1499
  asm
 
1500
        MOV     ESP, EBP
 
1501
        POP     EBP
 
1502
        JMP     [_ReadConsoleW]
 
1503
  end;
 
1504
end;
 
1505
 
 
1506
var
 
1507
  _ReadConsole: Pointer;
 
1508
 
 
1509
function ReadConsole;
 
1510
begin
 
1511
  GetProcedureAddress(_ReadConsole, kernel32, 'ReadConsole' + AWSuffix);
 
1512
  asm
 
1513
        MOV     ESP, EBP
 
1514
        POP     EBP
 
1515
        JMP     [_ReadConsole]
 
1516
  end;
 
1517
end;
 
1518
 
 
1519
var
 
1520
  _WriteConsoleA: Pointer;
 
1521
 
 
1522
function WriteConsoleA;
 
1523
begin
 
1524
  GetProcedureAddress(_WriteConsoleA, kernel32, 'WriteConsoleA');
 
1525
  asm
 
1526
        MOV     ESP, EBP
 
1527
        POP     EBP
 
1528
        JMP     [_WriteConsoleA]
 
1529
  end;
 
1530
end;
 
1531
 
 
1532
var
 
1533
  _WriteConsoleW: Pointer;
 
1534
 
 
1535
function WriteConsoleW;
 
1536
begin
 
1537
  GetProcedureAddress(_WriteConsoleW, kernel32, 'WriteConsoleW');
 
1538
  asm
 
1539
        MOV     ESP, EBP
 
1540
        POP     EBP
 
1541
        JMP     [_WriteConsoleW]
 
1542
  end;
 
1543
end;
 
1544
 
 
1545
var
 
1546
  _WriteConsole: Pointer;
 
1547
 
 
1548
function WriteConsole;
 
1549
begin
 
1550
  GetProcedureAddress(_WriteConsole, kernel32, 'WriteConsole' + AWSuffix);
 
1551
  asm
 
1552
        MOV     ESP, EBP
 
1553
        POP     EBP
 
1554
        JMP     [_WriteConsole]
 
1555
  end;
 
1556
end;
 
1557
 
 
1558
var
 
1559
  _CreateConsoleScreenBuffer: Pointer;
 
1560
 
 
1561
function CreateConsoleScreenBuffer;
 
1562
begin
 
1563
  GetProcedureAddress(_CreateConsoleScreenBuffer, kernel32, 'CreateConsoleScreenBuffer');
 
1564
  asm
 
1565
        MOV     ESP, EBP
 
1566
        POP     EBP
 
1567
        JMP     [_CreateConsoleScreenBuffer]
 
1568
  end;
 
1569
end;
 
1570
 
 
1571
var
 
1572
  _GetConsoleCP: Pointer;
 
1573
 
 
1574
function GetConsoleCP;
 
1575
begin
 
1576
  GetProcedureAddress(_GetConsoleCP, kernel32, 'GetConsoleCP');
 
1577
  asm
 
1578
        MOV     ESP, EBP
 
1579
        POP     EBP
 
1580
        JMP     [_GetConsoleCP]
 
1581
  end;
 
1582
end;
 
1583
 
 
1584
var
 
1585
  _SetConsoleCP: Pointer;
 
1586
 
 
1587
function SetConsoleCP;
 
1588
begin
 
1589
  GetProcedureAddress(_SetConsoleCP, kernel32, 'SetConsoleCP');
 
1590
  asm
 
1591
        MOV     ESP, EBP
 
1592
        POP     EBP
 
1593
        JMP     [_SetConsoleCP]
 
1594
  end;
 
1595
end;
 
1596
 
 
1597
var
 
1598
  _GetConsoleOutputCP: Pointer;
 
1599
 
 
1600
function GetConsoleOutputCP;
 
1601
begin
 
1602
  GetProcedureAddress(_GetConsoleOutputCP, kernel32, 'GetConsoleOutputCP');
 
1603
  asm
 
1604
        MOV     ESP, EBP
 
1605
        POP     EBP
 
1606
        JMP     [_GetConsoleOutputCP]
 
1607
  end;
 
1608
end;
 
1609
 
 
1610
var
 
1611
  _SetConsoleOutputCP: Pointer;
 
1612
 
 
1613
function SetConsoleOutputCP;
 
1614
begin
 
1615
  GetProcedureAddress(_SetConsoleOutputCP, kernel32, 'SetConsoleOutputCP');
 
1616
  asm
 
1617
        MOV     ESP, EBP
 
1618
        POP     EBP
 
1619
        JMP     [_SetConsoleOutputCP]
 
1620
  end;
 
1621
end;
 
1622
 
 
1623
var
 
1624
  _GetConsoleDisplayMode: Pointer;
 
1625
 
 
1626
function GetConsoleDisplayMode;
 
1627
begin
 
1628
  GetProcedureAddress(_GetConsoleDisplayMode, kernel32, 'GetConsoleDisplayMode');
 
1629
  asm
 
1630
        MOV     ESP, EBP
 
1631
        POP     EBP
 
1632
        JMP     [_GetConsoleDisplayMode]
 
1633
  end;
 
1634
end;
 
1635
 
 
1636
var
 
1637
  _GetConsoleWindow: Pointer;
 
1638
 
 
1639
function GetConsoleWindow;
 
1640
begin
 
1641
  GetProcedureAddress(_GetConsoleWindow, kernel32, 'GetConsoleWindow');
 
1642
  asm
 
1643
        MOV     ESP, EBP
 
1644
        POP     EBP
 
1645
        JMP     [_GetConsoleWindow]
 
1646
  end;
 
1647
end;
 
1648
 
 
1649
var
 
1650
  _GetConsoleProcessList: Pointer;
 
1651
 
 
1652
function GetConsoleProcessList;
 
1653
begin
 
1654
  GetProcedureAddress(_GetConsoleProcessList, kernel32, 'GetConsoleProcessList');
 
1655
  asm
 
1656
        MOV     ESP, EBP
 
1657
        POP     EBP
 
1658
        JMP     [_GetConsoleProcessList]
 
1659
  end;
 
1660
end;
 
1661
 
 
1662
var
 
1663
  _AddConsoleAliasA: Pointer;
 
1664
 
 
1665
function AddConsoleAliasA;
 
1666
begin
 
1667
  GetProcedureAddress(_AddConsoleAliasA, kernel32, 'AddConsoleAliasA');
 
1668
  asm
 
1669
        MOV     ESP, EBP
 
1670
        POP     EBP
 
1671
        JMP     [_AddConsoleAliasA]
 
1672
  end;
 
1673
end;
 
1674
 
 
1675
var
 
1676
  _AddConsoleAliasW: Pointer;
 
1677
 
 
1678
function AddConsoleAliasW;
 
1679
begin
 
1680
  GetProcedureAddress(_AddConsoleAliasW, kernel32, 'AddConsoleAliasW');
 
1681
  asm
 
1682
        MOV     ESP, EBP
 
1683
        POP     EBP
 
1684
        JMP     [_AddConsoleAliasW]
 
1685
  end;
 
1686
end;
 
1687
 
 
1688
var
 
1689
  _AddConsoleAlias: Pointer;
 
1690
 
 
1691
function AddConsoleAlias;
 
1692
begin
 
1693
  GetProcedureAddress(_AddConsoleAlias, kernel32, 'AddConsoleAlias' + AWSuffix);
 
1694
  asm
 
1695
        MOV     ESP, EBP
 
1696
        POP     EBP
 
1697
        JMP     [_AddConsoleAlias]
 
1698
  end;
 
1699
end;
 
1700
 
 
1701
var
 
1702
  _GetConsoleAliasA: Pointer;
 
1703
 
 
1704
function GetConsoleAliasA;
 
1705
begin
 
1706
  GetProcedureAddress(_GetConsoleAliasA, kernel32, 'GetConsoleAliasA');
 
1707
  asm
 
1708
        MOV     ESP, EBP
 
1709
        POP     EBP
 
1710
        JMP     [_GetConsoleAliasA]
 
1711
  end;
 
1712
end;
 
1713
 
 
1714
var
 
1715
  _GetConsoleAliasW: Pointer;
 
1716
 
 
1717
function GetConsoleAliasW;
 
1718
begin
 
1719
  GetProcedureAddress(_GetConsoleAliasW, kernel32, 'GetConsoleAliasW');
 
1720
  asm
 
1721
        MOV     ESP, EBP
 
1722
        POP     EBP
 
1723
        JMP     [_GetConsoleAliasW]
 
1724
  end;
 
1725
end;
 
1726
 
 
1727
var
 
1728
  _GetConsoleAlias: Pointer;
 
1729
 
 
1730
function GetConsoleAlias;
 
1731
begin
 
1732
  GetProcedureAddress(_GetConsoleAlias, kernel32, 'GetConsoleAlias' + AWSuffix);
 
1733
  asm
 
1734
        MOV     ESP, EBP
 
1735
        POP     EBP
 
1736
        JMP     [_GetConsoleAlias]
 
1737
  end;
 
1738
end;
 
1739
 
 
1740
var
 
1741
  _GetConsoleAliasesLengthA: Pointer;
 
1742
 
 
1743
function GetConsoleAliasesLengthA;
 
1744
begin
 
1745
  GetProcedureAddress(_GetConsoleAliasesLengthA, kernel32, 'GetConsoleAliasesLengthA');
 
1746
  asm
 
1747
        MOV     ESP, EBP
 
1748
        POP     EBP
 
1749
        JMP     [_GetConsoleAliasesLengthA]
 
1750
  end;
 
1751
end;
 
1752
 
 
1753
var
 
1754
  _GetConsoleAliasesLengthW: Pointer;
 
1755
 
 
1756
function GetConsoleAliasesLengthW;
 
1757
begin
 
1758
  GetProcedureAddress(_GetConsoleAliasesLengthW, kernel32, 'GetConsoleAliasesLengthW');
 
1759
  asm
 
1760
        MOV     ESP, EBP
 
1761
        POP     EBP
 
1762
        JMP     [_GetConsoleAliasesLengthW]
 
1763
  end;
 
1764
end;
 
1765
 
 
1766
var
 
1767
  _GetConsoleAliasesLength: Pointer;
 
1768
 
 
1769
function GetConsoleAliasesLength;
 
1770
begin
 
1771
  GetProcedureAddress(_GetConsoleAliasesLength, kernel32, 'GetConsoleAliasesLength' + AWSuffix);
 
1772
  asm
 
1773
        MOV     ESP, EBP
 
1774
        POP     EBP
 
1775
        JMP     [_GetConsoleAliasesLength]
 
1776
  end;
 
1777
end;
 
1778
 
 
1779
var
 
1780
  _GetConsoleAliasExesLengthA: Pointer;
 
1781
 
 
1782
function GetConsoleAliasExesLengthA;
 
1783
begin
 
1784
  GetProcedureAddress(_GetConsoleAliasExesLengthA, kernel32, 'GetConsoleAliasExesLengthA');
 
1785
  asm
 
1786
        MOV     ESP, EBP
 
1787
        POP     EBP
 
1788
        JMP     [_GetConsoleAliasExesLengthA]
 
1789
  end;
 
1790
end;
 
1791
 
 
1792
var
 
1793
  _GetConsoleAliasExesLengthW: Pointer;
 
1794
 
 
1795
function GetConsoleAliasExesLengthW;
 
1796
begin
 
1797
  GetProcedureAddress(_GetConsoleAliasExesLengthW, kernel32, 'GetConsoleAliasExesLengthW');
 
1798
  asm
 
1799
        MOV     ESP, EBP
 
1800
        POP     EBP
 
1801
        JMP     [_GetConsoleAliasExesLengthW]
 
1802
  end;
 
1803
end;
 
1804
 
 
1805
var
 
1806
  _GetConsoleAliasExesLength: Pointer;
 
1807
 
 
1808
function GetConsoleAliasExesLength;
 
1809
begin
 
1810
  GetProcedureAddress(_GetConsoleAliasExesLength, kernel32, 'GetConsoleAliasExesLength' + AWSuffix);
 
1811
  asm
 
1812
        MOV     ESP, EBP
 
1813
        POP     EBP
 
1814
        JMP     [_GetConsoleAliasExesLength]
 
1815
  end;
 
1816
end;
 
1817
 
 
1818
var
 
1819
  _GetConsoleAliasesA: Pointer;
 
1820
 
 
1821
function GetConsoleAliasesA;
 
1822
begin
 
1823
  GetProcedureAddress(_GetConsoleAliasesA, kernel32, 'GetConsoleAliasesA');
 
1824
  asm
 
1825
        MOV     ESP, EBP
 
1826
        POP     EBP
 
1827
        JMP     [_GetConsoleAliasesA]
 
1828
  end;
 
1829
end;
 
1830
 
 
1831
var
 
1832
  _GetConsoleAliasesW: Pointer;
 
1833
 
 
1834
function GetConsoleAliasesW;
 
1835
begin
 
1836
  GetProcedureAddress(_GetConsoleAliasesW, kernel32, 'GetConsoleAliasesW');
 
1837
  asm
 
1838
        MOV     ESP, EBP
 
1839
        POP     EBP
 
1840
        JMP     [_GetConsoleAliasesW]
 
1841
  end;
 
1842
end;
 
1843
 
 
1844
var
 
1845
  _GetConsoleAliases: Pointer;
 
1846
 
 
1847
function GetConsoleAliases;
 
1848
begin
 
1849
  GetProcedureAddress(_GetConsoleAliases, kernel32, 'GetConsoleAliases' + AWSuffix);
 
1850
  asm
 
1851
        MOV     ESP, EBP
 
1852
        POP     EBP
 
1853
        JMP     [_GetConsoleAliases]
 
1854
  end;
 
1855
end;
 
1856
 
 
1857
var
 
1858
  _GetConsoleAliasExesA: Pointer;
 
1859
 
 
1860
function GetConsoleAliasExesA;
 
1861
begin
 
1862
  GetProcedureAddress(_GetConsoleAliasExesA, kernel32, 'GetConsoleAliasExesA');
 
1863
  asm
 
1864
        MOV     ESP, EBP
 
1865
        POP     EBP
 
1866
        JMP     [_GetConsoleAliasExesA]
 
1867
  end;
 
1868
end;
 
1869
 
 
1870
var
 
1871
  _GetConsoleAliasExesW: Pointer;
 
1872
 
 
1873
function GetConsoleAliasExesW;
 
1874
begin
 
1875
  GetProcedureAddress(_GetConsoleAliasExesW, kernel32, 'GetConsoleAliasExesW');
 
1876
  asm
 
1877
        MOV     ESP, EBP
 
1878
        POP     EBP
 
1879
        JMP     [_GetConsoleAliasExesW]
 
1880
  end;
 
1881
end;
 
1882
 
 
1883
var
 
1884
  _GetConsoleAliasExes: Pointer;
 
1885
 
 
1886
function GetConsoleAliasExes;
 
1887
begin
 
1888
  GetProcedureAddress(_GetConsoleAliasExes, kernel32, 'GetConsoleAliasExes' + AWSuffix);
 
1889
  asm
 
1890
        MOV     ESP, EBP
 
1891
        POP     EBP
 
1892
        JMP     [_GetConsoleAliasExes]
 
1893
  end;
 
1894
end;
 
1895
 
 
1896
{$ELSE}
 
1897
 
 
1898
function PeekConsoleInputA; external kernel32 name 'PeekConsoleInputA';
 
1899
function PeekConsoleInputW; external kernel32 name 'PeekConsoleInputW';
 
1900
function PeekConsoleInput; external kernel32 name 'PeekConsoleInput' + AWSuffix;
 
1901
function ReadConsoleInputA; external kernel32 name 'ReadConsoleInputA';
 
1902
function ReadConsoleInputW; external kernel32 name 'ReadConsoleInputW';
 
1903
function ReadConsoleInput; external kernel32 name 'ReadConsoleInput' + AWSuffix;
 
1904
function WriteConsoleInputA; external kernel32 name 'WriteConsoleInputA';
 
1905
function WriteConsoleInputW; external kernel32 name 'WriteConsoleInputW';
 
1906
function WriteConsoleInput; external kernel32 name 'WriteConsoleInput' + AWSuffix;
 
1907
function ReadConsoleOutputA; external kernel32 name 'ReadConsoleOutputA';
 
1908
function ReadConsoleOutputW; external kernel32 name 'ReadConsoleOutputW';
 
1909
function ReadConsoleOutput; external kernel32 name 'ReadConsoleOutput' + AWSuffix;
 
1910
function WriteConsoleOutputA; external kernel32 name 'WriteConsoleOutputA';
 
1911
function WriteConsoleOutputW; external kernel32 name 'WriteConsoleOutputW';
 
1912
function WriteConsoleOutput; external kernel32 name 'WriteConsoleOutput' + AWSuffix;
 
1913
function ReadConsoleOutputCharacterA; external kernel32 name 'ReadConsoleOutputCharacterA';
 
1914
function ReadConsoleOutputCharacterW; external kernel32 name 'ReadConsoleOutputCharacterW';
 
1915
function ReadConsoleOutputCharacter; external kernel32 name 'ReadConsoleOutputCharacter' + AWSuffix;
 
1916
function ReadConsoleOutputAttribute; external kernel32 name 'ReadConsoleOutputAttribute';
 
1917
function WriteConsoleOutputCharacterA; external kernel32 name 'WriteConsoleOutputCharacterA';
 
1918
function WriteConsoleOutputCharacterW; external kernel32 name 'WriteConsoleOutputCharacterW';
 
1919
function WriteConsoleOutputCharacter; external kernel32 name 'WriteConsoleOutputCharacter' + AWSuffix;
 
1920
function WriteConsoleOutputAttribute; external kernel32 name 'WriteConsoleOutputAttribute';
 
1921
function FillConsoleOutputCharacterA; external kernel32 name 'FillConsoleOutputCharacterA';
 
1922
function FillConsoleOutputCharacterW; external kernel32 name 'FillConsoleOutputCharacterW';
 
1923
function FillConsoleOutputCharacter; external kernel32 name 'FillConsoleOutputCharacter' + AWSuffix;
 
1924
function FillConsoleOutputAttribute; external kernel32 name 'FillConsoleOutputAttribute';
 
1925
function GetConsoleMode; external kernel32 name 'GetConsoleMode';
 
1926
function GetNumberOfConsoleInputEvents; external kernel32 name 'GetNumberOfConsoleInputEvents';
 
1927
function GetConsoleScreenBufferInfo; external kernel32 name 'GetConsoleScreenBufferInfo';
 
1928
function GetLargestConsoleWindowSize; external kernel32 name 'GetLargestConsoleWindowSize';
 
1929
function GetConsoleCursorInfo; external kernel32 name 'GetConsoleCursorInfo';
 
1930
function GetCurrentConsoleFont; external kernel32 name 'GetCurrentConsoleFont';
 
1931
function GetConsoleFontSize; external kernel32 name 'GetConsoleFontSize';
 
1932
function GetConsoleSelectionInfo; external kernel32 name 'GetConsoleSelectionInfo';
 
1933
function GetNumberOfConsoleMouseButtons; external kernel32 name 'GetNumberOfConsoleMouseButtons';
 
1934
function SetConsoleMode; external kernel32 name 'SetConsoleMode';
 
1935
function SetConsoleActiveScreenBuffer; external kernel32 name 'SetConsoleActiveScreenBuffer';
 
1936
function FlushConsoleInputBuffer; external kernel32 name 'FlushConsoleInputBuffer';
 
1937
function SetConsoleScreenBufferSize; external kernel32 name 'SetConsoleScreenBufferSize';
 
1938
function SetConsoleCursorPosition; external kernel32 name 'SetConsoleCursorPosition';
 
1939
function SetConsoleCursorInfo; external kernel32 name 'SetConsoleCursorInfo';
 
1940
function ScrollConsoleScreenBufferA; external kernel32 name 'ScrollConsoleScreenBufferA';
 
1941
function ScrollConsoleScreenBufferW; external kernel32 name 'ScrollConsoleScreenBufferW';
 
1942
function ScrollConsoleScreenBuffer; external kernel32 name 'ScrollConsoleScreenBuffer' + AWSuffix;
 
1943
function SetConsoleWindowInfo; external kernel32 name 'SetConsoleWindowInfo';
 
1944
function SetConsoleTextAttribute; external kernel32 name 'SetConsoleTextAttribute';
 
1945
function SetConsoleCtrlHandler; external kernel32 name 'SetConsoleCtrlHandler';
 
1946
function GenerateConsoleCtrlEvent; external kernel32 name 'GenerateConsoleCtrlEvent';
 
1947
function AllocConsole; external kernel32 name 'AllocConsole';
 
1948
function FreeConsole; external kernel32 name 'FreeConsole';
 
1949
function AttachConsole; external kernel32 name 'AttachConsole';
 
1950
function GetConsoleTitleA; external kernel32 name 'GetConsoleTitleA';
 
1951
function GetConsoleTitleW; external kernel32 name 'GetConsoleTitleW';
 
1952
function GetConsoleTitle; external kernel32 name 'GetConsoleTitle' + AWSuffix;
 
1953
function SetConsoleTitleA; external kernel32 name 'SetConsoleTitleA';
 
1954
function SetConsoleTitleW; external kernel32 name 'SetConsoleTitleW';
 
1955
function SetConsoleTitle; external kernel32 name 'SetConsoleTitle' + AWSuffix;
 
1956
function ReadConsoleA; external kernel32 name 'ReadConsoleA';
 
1957
function ReadConsoleW; external kernel32 name 'ReadConsoleW';
 
1958
function ReadConsole; external kernel32 name 'ReadConsole' + AWSuffix;
 
1959
function WriteConsoleA; external kernel32 name 'WriteConsoleA';
 
1960
function WriteConsoleW; external kernel32 name 'WriteConsoleW';
 
1961
function WriteConsole; external kernel32 name 'WriteConsole' + AWSuffix;
 
1962
function CreateConsoleScreenBuffer; external kernel32 name 'CreateConsoleScreenBuffer';
 
1963
function GetConsoleCP; external kernel32 name 'GetConsoleCP';
 
1964
function SetConsoleCP; external kernel32 name 'SetConsoleCP';
 
1965
function GetConsoleOutputCP; external kernel32 name 'GetConsoleOutputCP';
 
1966
function SetConsoleOutputCP; external kernel32 name 'SetConsoleOutputCP';
 
1967
function GetConsoleDisplayMode; external kernel32 name 'GetConsoleDisplayMode';
 
1968
function GetConsoleWindow; external kernel32 name 'GetConsoleWindow';
 
1969
function GetConsoleProcessList; external kernel32 name 'GetConsoleProcessList';
 
1970
function AddConsoleAliasA; external kernel32 name 'AddConsoleAliasA';
 
1971
function AddConsoleAliasW; external kernel32 name 'AddConsoleAliasW';
 
1972
function AddConsoleAlias; external kernel32 name 'AddConsoleAlias' + AWSuffix;
 
1973
function GetConsoleAliasA; external kernel32 name 'GetConsoleAliasA';
 
1974
function GetConsoleAliasW; external kernel32 name 'GetConsoleAliasW';
 
1975
function GetConsoleAlias; external kernel32 name 'GetConsoleAlias' + AWSuffix;
 
1976
function GetConsoleAliasesLengthA; external kernel32 name 'GetConsoleAliasesLengthA';
 
1977
function GetConsoleAliasesLengthW; external kernel32 name 'GetConsoleAliasesLengthW';
 
1978
function GetConsoleAliasesLength; external kernel32 name 'GetConsoleAliasesLength' + AWSuffix;
 
1979
function GetConsoleAliasExesLengthA; external kernel32 name 'GetConsoleAliasExesLengthA';
 
1980
function GetConsoleAliasExesLengthW; external kernel32 name 'GetConsoleAliasExesLengthW';
 
1981
function GetConsoleAliasExesLength; external kernel32 name 'GetConsoleAliasExesLength' + AWSuffix;
 
1982
function GetConsoleAliasesA; external kernel32 name 'GetConsoleAliasesA';
 
1983
function GetConsoleAliasesW; external kernel32 name 'GetConsoleAliasesW';
 
1984
function GetConsoleAliases; external kernel32 name 'GetConsoleAliases' + AWSuffix;
 
1985
function GetConsoleAliasExesA; external kernel32 name 'GetConsoleAliasExesA';
 
1986
function GetConsoleAliasExesW; external kernel32 name 'GetConsoleAliasExesW';
 
1987
function GetConsoleAliasExes; external kernel32 name 'GetConsoleAliasExes' + AWSuffix;
 
1988
 
 
1989
{$ENDIF DYNAMIC_LINK}
 
1990
 
 
1991
end.