source: trunk/src/kernel32/stubs.cpp@ 2280

Last change on this file since 2280 was 2280, checked in by sandervl, 26 years ago

EB's debug support added
File size: 125.8 KB
Line 
1/* $Id: stubs.cpp,v 1.17 1999-12-31 10:47:11 sandervl Exp $ */
2
3/*
4 * Win32 KERNEL32 Subsystem for OS/2
5 *
6 * 1998/05/19 PH Patrick Haller (haller@zebra.fh-weingarten.de)
7 *
8 * @(#) Stubs.H 1.0.0 1998/05/19 PH start
9 *
10 * Project Odin Software License can be found in LICENSE.TXT
11 *
12 */
13
14/*****************************************************************************
15 * Includes *
16 *****************************************************************************/
17#include <os2win.h>
18#include <winnls.h>
19#include "unicode.h"
20#include <builtin.h>
21#include "handlemanager.h"
22#include <string.h>
23
24#include "stubs.h"
25
26
27/*****************************************************************************
28 * Defines *
29 *****************************************************************************/
30
31
32// For DefineDosDevice
33
34#define DDD_RAW_TARGET_PATH 0x00000001
35#define DDD_REMOVE_DEFINITION 0x00000002
36#define DDD_EXACT_MATCH_ON_REMOVE 0x00000004
37#define DDD_NO_BROADCAST_SYSTEM 0x00000008
38
39
40// For Backup functions
41
42//
43// Stream Ids
44//
45
46#define BACKUP_INVALID 0x00000000
47#define BACKUP_DATA 0x00000001
48#define BACKUP_EA_DATA 0x00000002
49#define BACKUP_SECURITY_DATA 0x00000003
50#define BACKUP_ALTERNATE_DATA 0x00000004
51#define BACKUP_LINK 0x00000005
52#define BACKUP_PROPERTY_DATA 0x00000006
53
54//
55// Stream Attributes
56//
57
58#define STREAM_NORMAL_ATTRIBUTE 0x00000000
59#define STREAM_MODIFIED_WHEN_READ 0x00000001
60#define STREAM_CONTAINS_SECURITY 0x00000002
61#define STREAM_CONTAINS_PROPERTIES 0x00000004
62
63// Named Pipes
64
65#define NMPWAIT_WAIT_FOREVER 0xffffffff
66#define NMPWAIT_NOWAIT 0x00000001
67#define NMPWAIT_USE_DEFAULT_WAIT 0x00000000
68
69
70// Locale
71#define LCID DWORD
72
73/*
74 * Locale Dependent Mapping Flags.
75 */
76
77#define LCMAP_LOWERCASE 0x00000100 /* lower case letters */
78#define LCMAP_UPPERCASE 0x00000200 /* upper case letters */
79#define LCMAP_SORTKEY 0x00000400 /* WC sort key (normalize) */
80#define LCMAP_BYTEREV 0x00000800 /* byte reversal */
81
82#define LCMAP_HIRAGANA 0x00100000 /* map katakana to hiragana */
83#define LCMAP_KATAKANA 0x00200000 /* map hiragana to katakana */
84#define LCMAP_HALFWIDTH 0x00400000 /* map double byte to single byte */
85#define LCMAP_FULLWIDTH 0x00800000 /* map single byte to double byte */
86
87#define LCMAP_LINGUISTIC_CASING 0x01000000 /* use linguistic rules for casing */
88
89#define LCMAP_SIMPLIFIED_CHINESE 0x02000000 /* map traditional chinese to simplified chinese */
90#define LCMAP_TRADITIONAL_CHINESE 0x04000000 /* map simplified chinese to traditional chinese */
91
92
93
94/*
95 * Locale Enumeration Flags.
96 */
97#define LCID_INSTALLED 0x00000001 /* installed locale ids */
98#define LCID_SUPPORTED 0x00000002 /* supported locale ids */
99
100
101
102// For FindFirstFileEx
103
104#define FIND_FIRST_EX_CASE_SENSITIVE 0x00000001
105
106/*****************************************************************************
107 * Structures *
108 *****************************************************************************/
109
110 // For FindFirstFileEx
111
112typedef enum _FINDEX_INFO_LEVELS {
113 FindExInfoStandard,
114 FindExInfoMaxInfoLevel
115} FINDEX_INFO_LEVELS;
116
117typedef enum _FINDEX_SEARCH_OPS {
118 FindExSearchNameMatch,
119 FindExSearchLimitToDirectories,
120 FindExSearchLimitToDevices,
121 FindExSearchMaxSearchOp
122} FINDEX_SEARCH_OPS;
123
124 // For Backup funtions
125
126typedef struct _WIN32_STREAM_ID {
127
128 DWORD dwStreamId;
129 DWORD dwStreamAttributes;
130 LARGE_INTEGER Size;
131 DWORD dwStreamNameSize;
132// WCHAR cStreamName[ ] ; /* @@@PH */
133 WCHAR cStreamName[1] ;
134} WIN32_STREAM_ID;
135
136
137//
138// File structures
139//
140
141//typedef struct _OVERLAPPED {
142// DWORD Internal;
143// DWORD InternalHigh;
144// DWORD Offset;
145// DWORD OffsetHigh;
146// HANDLE hEvent;
147//} OVERLAPPED, *LPOVERLAPPED;
148
149//typedef struct _SECURITY_ATTRIBUTES {
150// DWORD nLength;
151// LPVOID lpSecurityDescriptor;
152// BOOL bInheritHandle;
153//} SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
154
155//typedef struct _PROCESS_INFORMATION {
156// HANDLE hProcess;
157// HANDLE hThread;
158// DWORD dwProcessId;
159// DWORD dwThreadId;
160//} PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
161
162// For Fiber functions
163
164typedef VOID (WINAPI *PFIBER_START_ROUTINE)(
165 LPVOID lpFiberParameter
166 );
167typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE;
168
169// For Enum CalendarInfo & EnumSystemCodePages see winnls.h
170
171/*
172 * Calendar type constant.
173 */
174typedef DWORD CALTYPE;
175
176/*
177 * Calendar ID.
178 */
179typedef DWORD CALID;
180
181
182/*****************************************************************************
183 * Prototypes *
184 *****************************************************************************/
185
186
187/*****************************************************************************
188 * Name : BOOL WIN32API AreFileApisANSI (VOID)
189 * Purpose : The AreFileApisANSI function determines whether a set of Win32
190 * file functions is using the ANSI or OEM character set code page.
191 * This function is useful for 8-bit console input and output
192 * operations.
193 * Parameters: NONE
194 * Variables :
195 * Result : If the set of Win32 file functions is using the ANSI code page,
196 * the return value is nonzero.
197 * If the set of Win32 file functions is using the OEM code page,
198 * the return value is zero.
199 * Remark :
200 * Status : UNTESTED STUB
201 *
202 * Author : Markus Montkowski [Thu, 1998/02/19 11:46]
203 *****************************************************************************/
204
205BOOL WIN32API AreFileApisANSI (VOID)
206{
207
208 dprintf(("KERNEL32:AreFileApisANSI() not implemented - TRUE\n"
209 ));
210
211 return (TRUE);
212}
213
214/*****************************************************************************
215 * Name : BOOL WIN32API BackupRead(
216 * Purpose : The BackupRead function reads data associated with a specified
217 * file or directory into a buffer. You use this function to back
218 * up a file or directory.
219 * Parameters: HANDLE hFile handle to file or directory
220 * LPBYTE lpBuffer pointer to buffer to read to
221 * DWORD nNumberOfBytesToRead number of bytes to read
222 * LPDWORD lpNumberOfBytesRead pointer to variable to receive
223 * number of bytes read
224 * BOOL bAbort termination type
225 * BOOL bProcessSecurity process security flag
226 * LPVOID *lpContext pointer to pointer to internal
227 * context information
228 * Variables :
229 * Result : 0 on Error Nonzero if OK
230 * Remark : BackupRead processes all of the data pertaining to an opened
231 * object as a series of discrete byte streams. Each stream is
232 * preceded by a 32-bit aligned WIN32_STREAM_ID structure.
233 * Streams must be processed in the same order in which they were
234 * written to the tape. This ordering enables applications to
235 * compare the data backed up against the data on the source device.
236 * The data returned by BackupRead is to be used only as input to
237 * the BackupWrite function. This data is returned as one large data
238 * stream divided into substreams. The substreams are separated
239 * by WIN32_STREAM_ID headers.
240 *
241 * If an error occurs while BackupRead is reading, the calling
242 * process can skip the bad data by calling the BackupSeek function.
243 * Status : UNTESTED STUB
244 *
245 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
246 *****************************************************************************/
247
248BOOL WIN32API BackupRead(
249 HANDLE hFile, // handle to file or directory
250 LPBYTE lpBuffer, // pointer to buffer to read to
251 DWORD nNumberOfBytesToRead, // number of bytes to read
252 LPDWORD lpNumberOfBytesRead, // pointer to variable to receive number of bytes read
253 BOOL bAbort, // termination type
254 BOOL bProcessSecurity, // process security flag
255 LPVOID *lpContext // pointer to pointer to internal context information
256)
257{
258
259 dprintf(("KERNEL32:BackupRead(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
260 hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead,
261 bAbort, bProcessSecurity, lpContext
262 ));
263
264 return (FALSE);
265}
266/*****************************************************************************
267 * Name : BOOL WIN32API BackupSeek()
268 * Purpose : The BackupSeek function seeks forward in a data stream initially
269 * accessed by using the BackupRead or BackupWrite function.
270 * Parameters: HANDLE hFile handle to open file
271 * DWORD dwLowBytesToSeek low-order 32 bits of number of bytes
272 * DWORD dwHighBytesToSeek high-order 32 bits of number of bytes
273 * LPDWORD lpdwLowByteSeeked pointer to number of bytes function seeks
274 * LPDWORD lpdwHighByteSeeked pointer to number of bytes function seeks
275 * LPVOID *lpContext pointer to internal context information
276 *
277 * Variables :
278 * Result : If the function could seek the requested amount, the function
279 * returns nonzero.
280 * If the function could not seek the requested amount, the function
281 * returns zero.
282 * Remark : Applications use the BackUpSeek function to skip portions of a
283 * data stream that cause errors. This function does not seek across
284 * stream headers. If an application attempts to seek past the end
285 * of a substream, the function fails, the lpdwLowByteSeeked and
286 * lpdwHighByteSeeked parameters indicate the actual number of bytes
287 * the function seeks, and the file position is placed at the start
288 * of the next stream header.
289 * Status : UNTESTED STUB
290 *
291 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
292 *****************************************************************************/
293
294BOOL WIN32API BackupSeek( HANDLE hFile, DWORD dwLowBytesToSeek,
295 DWORD dwHighBytesToSeek,
296 LPDWORD lpdwLowByteSeeked,
297 LPDWORD lpdwHighByteSeeked,LPVOID *lpContext)
298{
299
300 dprintf(("KERNEL32:BackupSeek(%08x,%08x,%08x,%08x,%08x,08x) not implemented\n",
301 hFile, dwLowBytesToSeek,dwHighBytesToSeek,
302 lpdwLowByteSeeked, lpdwHighByteSeeked, lpContext));
303
304 return (FALSE);
305}
306
307/*****************************************************************************
308 * Name : BOOL WIN32API BackupWrite
309 * Purpose : The BackupWrite function writes a stream of data from a buffer to
310 * a specified file or directory. The data must be divided into
311 * substreams separated by WIN32_STREAM_ID structures. You use this
312 * function to restore a file or directory that has been backed up.
313 * Parameters: HANDLE hFile handle to file or directory
314 * LPBYTE lpBuffer pointer to buffer containing data
315 * to write
316 * DWORD nNumberOfBytesToWrite number of bytes to write
317 * LPDWORD lpNumberOfBytesWritten pointer to variable to receive
318 * number of bytes written
319 * BOOL bAbort termination type
320 * BOOL bProcessSecurity process security
321 * LPVOID *lpContext pointer to pointer to internal
322 * context information
323 *
324 * Variables :
325 * Result : If the function succeeds, the return value is nonzero.
326 * If the function fails, the return value is zero,
327 * indicating that an I/O error occurred.
328 * To get extended error information, call GetLastError.
329 * Remark :
330 * Status : UNTESTED STUB
331 *
332 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
333 *****************************************************************************/
334
335BOOL WIN32API BackupWrite( HANDLE hFile, LPBYTE lpBuffer,
336 DWORD nNumberOfBytesToWrite,
337 LPDWORD lpNumberOfBytesWritten,
338 BOOL bAbort, BOOL bProcessSecurity,
339 LPVOID *lpContext)
340{
341
342 dprintf(("KERNEL32:BackupWrite(%08x,%0x8,%08x,%08x,%08x,%08x,%08x) not implemented\n",
343 hFile, lpBuffer, nNumberOfBytesToWrite,
344 lpNumberOfBytesWritten, bAbort, bProcessSecurity, lpContext));
345
346 return (FALSE);
347}
348
349/*****************************************************************************
350 * Name : HANDLE WIN32API BeginUpdateResourceA
351 * Purpose : The BeginUpdateResource function returns a handle that can be
352 * used by the UpdateResource function to add, delete, or replace
353 * resources in an executable file.
354 * Parameters: LPCSTR pFileName pointer to file in which to
355 * update resources
356 * BOOL bDeleteExistingResources deletion option
357 *
358 * Variables :
359 * Result : If the function succeeds, the return value is a handle that can
360 * be used by the UpdateResource and EndUpdateResource functions.
361 * The return value is NULL if the specified file is not an
362 * executable file, the executable file is already loaded,
363 * the file does not exist, or the file cannot be opened for writing.
364 * To get extended error information, call GetLastError
365 * Remark :
366 * Status : UNTESTED STUB
367 *
368 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
369 *****************************************************************************/
370
371HANDLE WIN32API BeginUpdateResourceA( LPCSTR pFileName,
372 BOOL bDeleteExistingResources)
373{
374
375 dprintf(("KERNEL32: BeginUpdateResource(%08x,%08x) not implemented\n",
376 pFileName, bDeleteExistingResources
377 ));
378
379 return (NULL);
380}
381
382/*****************************************************************************
383 * Name : HANDLE WIN32API BeginUpdateResourceW
384 * Purpose : The BeginUpdateResource function returns a handle that can be
385 * used by the UpdateResource function to add, delete, or replace
386 * resources in an executable file.
387 * Parameters: LPCWSTR pFileName pointer to file in which to
388 * update resources
389 * BOOL bDeleteExistingResources deletion option
390 *
391 * Variables :
392 * Result : If the function succeeds, the return value is a handle that can
393 * be used by the UpdateResource and EndUpdateResource functions.
394 * The return value is NULL if the specified file is not an
395 * executable file, the executable file is already loaded,
396 * the file does not exist, or the file cannot be opened for writing.
397 * To get extended error information, call GetLastError
398 * Remark :
399 * Status : UNTESTED STUB
400 *
401 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
402 *****************************************************************************/
403
404HANDLE WIN32API BeginUpdateResourceW( LPCWSTR pFileName,
405 BOOL bDeleteExistingResources)
406{
407
408 dprintf(("KERNEL32: BeginUpdateResource(%08x,%08x) not implemented\n",
409 pFileName, bDeleteExistingResources
410 ));
411
412 return (NULL);
413}
414
415/*****************************************************************************
416 * Name : BOOL WIN32AOI CallNamedPipeA
417 * Purpose : The CallNamedPipe function connects to a message-type pipe
418 * (and waits if an instance of the pipe is not available),
419 * writes to and reads from the pipe, and then closes the pipe.
420 * Parameters: LPCSTR lpNamedPipeName pointer to pipe name
421 * LPVOID lpInBuffer pointer to write buffer
422 * DWORD nInBufferSize size, in bytes, of write buffer
423 * LPVOID lpOutBuffer pointer to read buffer
424 * DWORD nOutBufferSize size, in bytes, of read buffer
425 * LPDWORD lpBytesRead pointer to number of bytes read
426 * DWORD nTimeOut time-out time, in milliseconds
427 * Variables :
428 * Result : If the function succeeds, the return value is nonzero.
429 * If the function fails, the return value is zero.
430 * To get extended error information, call GetLastError.
431 * Remark : Calling CallNamedPipe is equivalent to calling the CreateFile
432 * (or WaitNamedPipe, if CreateFile cannot open the pipe immediately),
433 * TransactNamedPipe, and CloseHandle functions. CreateFile is called
434 * with an access flag of GENERIC_READ | GENERIC_WRITE, an inherit
435 * handle flag of FALSE, and a share mode of zero (indicating no
436 * sharing of this pipe instance).
437 * If the message written to the pipe by the server process is
438 * longer than nOutBufferSize, CallNamedPipe returns FALSE, and
439 * GetLastError returns ERROR_MORE_DATA. The remainder of the
440 * message is discarded, because CallNamedPipe closes the handle
441 * to the pipe before returning.
442 *
443 * CallNamedPipe fails if the pipe is a byte-type pipe.
444 * Status : UNTESTED STUB
445 *
446 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
447 *****************************************************************************/
448
449BOOL WIN32API CallNamedPipeA( LPCSTR lpNamedPipeName,
450 LPVOID lpInBuffer, DWORD nInBufferSize,
451 LPVOID lpOutBuffer, DWORD nOutBufferSize,
452 LPDWORD lpBytesRead, DWORD nTimeOut)
453{
454
455 dprintf(("KERNEL32: CallNamedPipeA(%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
456 lpNamedPipeName, lpInBuffer, nInBufferSize,
457 lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut
458 ));
459
460 return (FALSE);
461}
462
463/*****************************************************************************
464 * Name : BOOL WIN32AOI CallNamedPipeA
465 * Purpose : The CallNamedPipe function connects to a message-type pipe
466 * (and waits if an instance of the pipe is not available),
467 * writes to and reads from the pipe, and then closes the pipe.
468 * Parameters: LPCWSTR lpNamedPipeName pointer to pipe name
469 * LPVOID lpInBuffer pointer to write buffer
470 * DWORD nInBufferSize size, in bytes, of write buffer
471 * LPVOID lpOutBuffer pointer to read buffer
472 * DWORD nOutBufferSize size, in bytes, of read buffer
473 * LPDWORD lpBytesRead pointer to number of bytes read
474 * DWORD nTimeOut time-out time, in milliseconds
475 * Variables :
476 * Result : If the function succeeds, the return value is nonzero.
477 * If the function fails, the return value is zero.
478 * To get extended error information, call GetLastError.
479 * Remark : Calling CallNamedPipe is equivalent to calling the CreateFile
480 * (or WaitNamedPipe, if CreateFile cannot open the pipe immediately),
481 * TransactNamedPipe, and CloseHandle functions. CreateFile is called
482 * with an access flag of GENERIC_READ | GENERIC_WRITE, an inherit
483 * handle flag of FALSE, and a share mode of zero (indicating no
484 * sharing of this pipe instance).
485 * If the message written to the pipe by the server process is
486 * longer than nOutBufferSize, CallNamedPipe returns FALSE, and
487 * GetLastError returns ERROR_MORE_DATA. The remainder of the
488 * message is discarded, because CallNamedPipe closes the handle
489 * to the pipe before returning.
490 *
491 * CallNamedPipe fails if the pipe is a byte-type pipe.
492 * Status : UNTESTED STUB
493 *
494 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
495 *****************************************************************************/
496
497BOOL WIN32API CallNamedPipeW( LPCWSTR lpNamedPipeName,
498 LPVOID lpInBuffer, DWORD nInBufferSize,
499 LPVOID lpOutBuffer, DWORD nOutBufferSize,
500 LPDWORD lpBytesRead, DWORD nTimeOut)
501{
502
503 dprintf(("KERNEL32: CallNamedPipeA(%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
504 lpNamedPipeName, lpInBuffer, nInBufferSize,
505 lpOutBuffer, nOutBufferSize, lpBytesRead, nTimeOut
506 ));
507
508 return (FALSE);
509}
510/*****************************************************************************
511 * Name : BOOL WIN32API CancelIo
512 * Purpose : The CancelIO function cancels all pending input and output
513 * (I/O) operations that were issued by the calling thread for
514 * the specified file handle. The function does not cancel
515 * I/O operations issued for the file handle by other threads.
516 * Parameters: HANDLE hFile file handle for which to cancel I/O
517 * Variables :
518 * Result : If the function succeeds, the return value is nonzero All pending
519 * I/O operations issued by the calling thread for the file handle
520 * were successfully canceled.
521 * If the function fails, the return value is zero.
522 * To get extended error information, call GetLastError.
523 * Remark : If there are any I/O operations in progress for the specified
524 * file handle, and they were issued by the calling thread, the
525 * CancelIO function cancels them.
526 * Note that the I/O operations must have been issued as
527 * overlapped I/O. If they were not, the I/O operations would not
528 * have returned to allow the thread to call the CancelIO function.
529 * Calling the CancelIO function with a file handle that was not
530 * opened with FILE_FLAG_OVERLAPPED does nothing.
531 * All I/O operations that are canceled will complete with the
532 * error ERROR_OPERATION_ABORTED. All completion notifications
533 * for the I/O operations will occur normally.
534 * Status : UNTESTED STUB
535 *
536 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
537 *****************************************************************************/
538
539BOOL WIN32API CancelIo(HANDLE hFile)
540{
541
542 dprintf(("KERNEL32:CancelIo(%08x) not implemented\n",
543 hFile
544 ));
545
546 return (FALSE);
547}
548
549/*****************************************************************************
550 * Name : BOOL CancelWaitableTimer
551 * Purpose : The CancelWaitableTimer function sets the specified "waitable"
552 * timer to the inactive state.
553 * Parameters: HANDLE hTimer handle to a timer object
554 * Variables :
555 * Result : If the function succeeds, the return value is nonzero.
556 * If the function fails, the return value is zero.
557 * To get extended error information, call GetLastError.
558 * Remark : The CancelWaitableTimer function does not change the signaled
559 * state of the timer. It stops the timer before it can be set to
560 * the signaled state. Therefore, threads performing a wait
561 * operation on the timer remain waiting until they time out or
562 * the timer is reactivated and its state is set to signaled.
563 *
564 * To reactivate the timer, call the SetWaitableTimer function.
565 * Status : UNTESTED STUB
566 *
567 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
568 *****************************************************************************/
569
570BOOL WIN32API CancelWaitableTimer(HANDLE hTimer)
571{
572
573 dprintf(("KERNEL32:CancelWaitableTimer(%08x) not implemented\n",
574 hTimer
575 ));
576
577 return (FALSE);
578}
579
580/*****************************************************************************
581 * Name : BOOL WIN32API ConnectNamedPipe
582 * Purpose : The ConnectNamedPipe function enables a named pipe server process
583 * to wait for a client process to connect to an instance of a
584 * named pipe. A client process connects by calling either the
585 * CreateFile or CallNamedPipe function.
586 * Parameters: HANDLE hNamedPipe handle to named pipe to connect
587 * LPOVERLAPPED lpOverlapped pointer to overlapped structure
588 * Variables :
589 * Result : If the function succeeds, the return value is nonzero.
590 * If the function fails, the return value is zero.
591 * To get extended error information, call GetLastError.
592 * Remark :
593 * Status : UNTESTED STUB
594 *
595 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
596 *****************************************************************************/
597
598BOOL WIN32API ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)
599{
600
601 dprintf(("KERNEL32: ConnectNamedPipe(%08x,%08x) not implemented\n",
602 hNamedPipe, lpOverlapped
603 ));
604
605 return (FALSE);
606}
607
608
609
610/*****************************************************************************
611 * Name : LCID WIN32API ConvertDefaultLocale
612 * Purpose : The ConvertDefaultLocale function converts a special default
613 * locale value to an actual locale identifier.
614 * Parameters: LCID Locale special default locale value to be converted
615 * Value Description
616 * LOCALE_SYSTEM_DEFAULT The system's default locale.
617 * LOCALE_USER_DEFAULT The current user's default locale.
618 * zero The language-neutral default locale.
619 * This is equivalent to the locale identifier
620 * created by calling the MAKELCID macro
621 * with a language identifier consisting
622 * of the LANG_NEUTRAL and SUBLANG_NEUTRAL
623 * values.
624 * Any sublanguage neutral default locale
625 * A locale identifier constructed by
626 * calling MAKELCID with a language
627 * identifier consisting of a primary
628 * language value, such as LANG_ENGLISH,
629 * and the SUBLANG_NEUTRAL value.
630 *
631 * Variables :
632 * Result : If the function succeeds, the return value is the appropriate
633 * actual locale identifier.
634 * If the function fails, the return value is the Locale parameter.
635 * The function fails when Locale is not one of the special
636 * default locale values listed above.
637 * Remark : A call to ConvertDefaultLocale(LOCALE_SYSTEM_DEFAULT)
638 * is equivalent to a call to GetSystemDefaultLCID.
639 * A call to ConvertDefaultLocale(LOCALE_USER_DEFAULT)
640 * is equivalent to a call to GetUserDefaultLCID.
641 * Status : UNTESTED STUB
642 *
643 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
644 *****************************************************************************/
645
646LCID WIN32API ConvertDefaultLocale(LCID Locale)
647{
648
649 dprintf(("KERNEL32: ConvertDefaultLocale(%08x) partly implmented - returns input\n",
650 Locale
651 ));
652
653 return (Locale);
654}
655
656/*****************************************************************************
657 * Name : BOOL WIN32API CopyFileExA
658 * Purpose : The CopyFileExA function copies an existing file to a new file.
659 * This function preserves extended attributes, OLE structured
660 * storage, NTFS alternate data streams, and file attributes.
661 * Security attributes for the existing file are not copied to
662 * the new file.
663 * Parameters: LPCSTR lpExistingFileName pointer to name of an existing file
664 * LPCSTR lpNewFileName pointer to filename to copy to
665 * LPPROGRESS_ROUTINE lpProgressRoutine pointer to the callback function
666 * LPVOID lpData to be passed to the callback function
667 * LPBOOL pbCancel flag that can be used to cancel the operation
668 * DWORD dwCopyFlags flags that specify how the file is copied
669 * Variables :
670 * Result : f the function succeeds, the return value is nonzero.
671 * If the function fails, the return value is zero.
672 * To get extended error information call GetLastError.
673 * Remark :
674 * Status : UNTESTED STUB
675 *
676 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
677 *****************************************************************************/
678
679BOOL WIN32API CopyFileExA( LPCSTR lpExistingFileName,
680 LPCSTR lpNewFileName,
681 LPPROGRESS_ROUTINE lpProgressRoutine,
682 LPVOID lpData,
683 LPBOOL pbCancel,
684 DWORD dwCopyFlags)
685{
686
687 dprintf(("KERNEL32: CopyFileExA(%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
688 lpExistingFileName,
689 lpNewFileName,
690 lpProgressRoutine,
691 lpData,
692 pbCancel,
693 dwCopyFlags
694 ));
695
696 return (FALSE);
697}
698
699
700/*****************************************************************************
701 * Name : BOOL WIN32API CopyFileExW
702 * Purpose : The CopyFileExW function copies an existing file to a new file.
703 * This function preserves extended attributes, OLE structured
704 * storage, NTFS alternate data streams, and file attributes.
705 * Security attributes for the existing file are not copied to
706 * the new file.
707 * Parameters: LPCWSTR lpExistingFileName pointer to name of an existing file
708 * LPCWSTR lpNewFileName pointer to filename to copy to
709 * LPPROGRESS_ROUTINE lpProgressRoutine pointer to the callback function
710 * LPVOID lpData to be passed to the callback function
711 * LPBOOL pbCancel flag that can be used to cancel the operation
712 * DWORD dwCopyFlags flags that specify how the file is copied
713 * Variables :
714 * Result : f the function succeeds, the return value is nonzero.
715 * If the function fails, the return value is zero.
716 * To get extended error information call GetLastError.
717 * Remark :
718 * Status : UNTESTED STUB
719 *
720 * Author : Markus Montkowski [Thu, 1998/05/19 11:46]
721 *****************************************************************************/
722
723BOOL WIN32API CopyFileExW( LPCWSTR lpExistingFileName,
724 LPCWSTR lpNewFileName,
725 LPPROGRESS_ROUTINE lpProgressRoutine,
726 LPVOID lpData,
727 LPBOOL pbCancel,
728 DWORD dwCopyFlags)
729{
730
731 dprintf(("KERNEL32: CopyFileExW(%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
732 lpExistingFileName,
733 lpNewFileName,
734 lpProgressRoutine,
735 lpData,
736 pbCancel,
737 dwCopyFlags
738 ));
739
740 return (FALSE);
741}
742
743/*****************************************************************************
744 * Name : BOOL WIN32API CreateDirectoryExA
745 * Purpose : The CreateDirectoryExA function creates a new directory with a
746 * specified path that retains the attributes of a specified
747 * template directory. If the underlying file system supports
748 * security on files and directories, the function applies a
749 * specified security descriptor to the new directory.
750 * The new directory retains the other attributes of the specified
751 * template directory. Note that CreateDirectoryEx has a template
752 * parameter, while CreateDirectory does not.
753 * Parameters: LPCSTR lpTemplateDirectory pointer to path string of template
754 * directory
755 * LPCSTR lpNewDirectory pointer to path string of directory
756 * to create
757 * LPSECURITY_ATTRIBUTES lpSecurityAttributes pointer to security
758 * descriptor
759 *
760 * Variables :
761 * Result : If the function succeeds, the return value is nonzero.
762 * If the function fails, the return value is zero.
763 * To get extended error information, call GetLastError.
764 * Remark :
765 * Status : UNTESTED STUB
766 *
767 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
768 *****************************************************************************/
769
770BOOL WIN32API CreateDirectoryExA( LPCSTR lpTemplateDirectory,
771 LPCSTR lpNewDirectory,
772 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
773{
774
775 dprintf(("KERNEL32:CreateDirectoryExA(%08x,%08x,%08x) not implemented\n",
776 lpTemplateDirectory,lpNewDirectory,lpSecurityAttributes
777 ));
778
779 return (FALSE);
780}
781
782/*****************************************************************************
783 * Name : BOOL WIN32API CreateDirectoryExW
784 * Purpose : The CreateDirectoryExW function creates a new directory with a
785 * specified path that retains the attributes of a specified
786 * template directory. If the underlying file system supports
787 * security on files and directories, the function applies a
788 * specified security descriptor to the new directory.
789 * The new directory retains the other attributes of the specified
790 * template directory. Note that CreateDirectoryEx has a template
791 * parameter, while CreateDirectory does not.
792 * Parameters: LPCWSTR lpTemplateDirectory pointer to path string of template
793 * directory
794 * LPCWSTR lpNewDirectory pointer to path string of directory
795 * to create
796 * LPSECURITY_ATTRIBUTES lpSecurityAttributes pointer to security
797 * descriptor
798 *
799 * Variables :
800 * Result : If the function succeeds, the return value is nonzero.
801 * If the function fails, the return value is zero.
802 * To get extended error information, call GetLastError.
803 * Remark :
804 * Status : UNTESTED STUB
805 *
806 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
807 *****************************************************************************/
808
809BOOL WIN32API CreateDirectoryExW( LPCWSTR lpTemplateDirectory,
810 LPCWSTR lpNewDirectory,
811 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
812{
813
814 dprintf(("KERNEL32:CreateDirectoryExW(%08x,%08x,%08x) not implemented\n",
815 lpTemplateDirectory,lpNewDirectory,lpSecurityAttributes
816 ));
817
818 return (FALSE);
819}
820
821/*****************************************************************************
822 * Name : LPVOID WIN32API CreateFiber
823 * Purpose : The CreateFiber function allocates a fiber object, assigns it a
824 * stack, and sets up execution to begin at the specified
825 * start address, typically the fiber function.
826 * This function does not schedule the fiber.
827 * Parameters: DWORD dwStackSize initial thread stack size, in bytes
828 * LPFIBER_START_ROUTINE lpStartAddress pointer to fiber function
829 * LPVOID lpParameter argument for new fiber
830 * Variables :
831 * Result : If the function succeeds, the return value is the address of
832 * the fiber.
833 * If the function fails, the return value is NULL.
834 * Remark : Before a thread can schedule a fiber using the SwitchToFiber
835 * function, it must call the ConvertThreadToFiber function so there
836 * is a fiber associated with the thread.
837 * The fiber function is of type FIBER_START_ROUTINE.
838 * It accepts a single value of type PVOID (fiber data) and does not
839 * return a value. The prototype for this function is as follows:
840 *
841 * VOID WINAPI FiberFunc( PVOID lpParameter );
842 *
843 * Status : UNTESTED STUB
844 *
845 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
846 *****************************************************************************/
847
848LPVOID WIN32API CreateFiber( DWORD dwStackSize,
849 LPFIBER_START_ROUTINE lpStartAddress,
850 LPVOID lpParameter)
851{
852
853 dprintf(("KERNEL32:CreateFiber(%08x,%08x,%08x) not implemented\n",
854 dwStackSize, lpStartAddress,lpParameter
855 ));
856
857 return (NULL);
858}
859
860
861/*****************************************************************************
862 * Name : HANDLE WIN32API CreateIoCompletionPort
863 * Purpose : The CreateIoCompletionPort function can associate an instance of
864 * an opened file with a newly created or an existing input/output
865 * completion port; or it can create an input/output completion port
866 * without associating it with a file.
867 * Associating an instance of an opened file with an input/output
868 * completion port lets an application receive notification of the
869 * completion of asynchronous input/output operations involving that
870 * file.
871 * Parameters: HANDLE FileHandle file handle to associate with I/O
872 * completion port. Must be created
873 * with flag FILE_FLAG_OVERLAPPED !
874 * HANDLE ExistingCompletionPort optional handle to existing
875 * I/O completion port
876 * DWORD CompletionKey per-file completion key for
877 * I/O completion packets
878 * DWORD NumberOfConcurrentThreads number of threads allowed to
879 * execute concurrently
880 * Variables :
881 * Result : If the function succeeds, the return value is the handle to the
882 * I/O completion port that is associated with the specified file.
883 * This return value is not NULL.
884 * If the function fails, the return value is NULL.
885 * Remark : The Win32 I/O system can be instructed to send I/O completion
886 * notification packets to input/output completion ports, where they
887 * are queued up. The CreateIoCompletionPort function provides a
888 * mechanism for this.
889 * When you perform an input/output operation with a file handle
890 * that has an associated input/output completion port, the
891 * I/O system sends a completion notification packet to the
892 * completion port when the I/O operation completes.
893 * The I/O completion port places the completion packet in a
894 * first-in-first-out queue.
895 * Use the GetQueuedCompletionStatus function to retrieve these
896 * queued I/O completion packets.
897 * Threads in the same process can use the PostQueuedCompletionStatus
898 * function to place I/O completion notification packets in a
899 * completion port's queue. This allows you to use the port to
900 * receive communications from other threads of the process,
901 * in addition to receiving I/O completion notification packets
902 * from the Win32 I/O system.
903 * Status : UNTESTED STUB
904 *
905 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
906 *****************************************************************************/
907
908HANDLE WIN32API CreateIoCompletionPort( HANDLE FileHandle,
909 HANDLE ExistingCompletionPort,
910 DWORD CompletionKey,
911 DWORD NumberOfConcurrentThreads)
912{
913
914 dprintf(("KERNEL32: CreateIoCompletionPort(%08x,%08x,%08x,%08x) not implemented\n",
915 FileHandle, ExistingCompletionPort, CompletionKey,
916 NumberOfConcurrentThreads
917 ));
918
919 return (NULL);
920}
921/*****************************************************************************
922 * Name : HANDLE WIN32API CreateMailslotA
923 * Purpose : The CreateMailslot function creates a mailslot with the specified
924 * name and returns a handle that a mailslot server can use to
925 * perform operations on the mailslot. The mailslot is local to the
926 * computer that creates it. An error occurs if a mailslot with
927 * the specified name already exists.
928 * Parameters: LPCSTR lpName pointer to string for mailslot name
929 * DWORD nMaxMessageSize maximum message size
930 * DWORD lReadTimeout milliseconds before read time-out
931 * LPSECURITY_ATTRIBUTES lpSecurityAttributes pointer to security structure
932 * Variables :
933 * Result : If the function succeeds, the return value is a handle to
934 * the mailslot, for use in server mailslot operations.
935 * If the function fails, the return value is INVALID_HANDLE_VALUE.
936 * Remark :
937 * Status : UNTESTED STUB
938 *
939 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
940 *****************************************************************************/
941
942HANDLE WIN32API CreateMailslotA(LPCSTR lpName, DWORD nMaxMessageSize,
943 DWORD lReadTimeout,
944 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
945{
946
947 dprintf(("KERNEL32: CreateMailslotA(%08x,%08x,%08x,%08x) not implemented - INVALID_HANDLE_VALUE\n",
948 lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes
949 ));
950
951 return (INVALID_HANDLE_VALUE);
952}
953
954/*****************************************************************************
955 * Name : HANDLE WIN32API CreateMailslotW
956 * Purpose : The CreateMailslot function creates a mailslot with the specified
957 * name and returns a handle that a mailslot server can use to
958 * perform operations on the mailslot. The mailslot is local to the
959 * computer that creates it. An error occurs if a mailslot with
960 * the specified name already exists.
961 * Parameters: LPCWSTR lpName pointer to string for mailslot name
962 * DWORD nMaxMessageSize maximum message size
963 * DWORD lReadTimeout milliseconds before read time-out
964 * LPSECURITY_ATTRIBUTES lpSecurityAttributes pointer to security
965 * structure
966 * Variables :
967 * Result : If the function succeeds, the return value is a handle to
968 * the mailslot, for use in server mailslot operations.
969 * If the function fails, the return value is INVALID_HANDLE_VALUE.
970 * Remark :
971 * Status : UNTESTED STUB
972 *
973 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
974 *****************************************************************************/
975
976HANDLE WIN32API CreateMailslotW(LPCWSTR lpName, DWORD nMaxMessageSize,
977 DWORD lReadTimeout,
978 LPSECURITY_ATTRIBUTES lpSecurityAttributes)
979{
980
981 dprintf(("KERNEL32: CreateMailslotW(%08x,%08x,%08x,%08x) not implemented - INVALID_HANDLE_VALUE\n",
982 lpName, nMaxMessageSize, lReadTimeout, lpSecurityAttributes
983 ));
984
985 return (INVALID_HANDLE_VALUE);
986}
987
988/*****************************************************************************
989 * Name : HANDLE WIN32API CreateRemoteThread
990 * Purpose : The CreateRemoteThread function creates a thread that runs in
991 * the address space of another process.
992 * Parameters: HANDLE hProcess handle to process to create thread in
993 * LPSECURITY_ATTRIBUTES lpThreadAttributes pointer to thread
994 * security attributes
995 * DWORD dwStackSize initial thread stack size, in bytes
996 * LPTHREAD_START_ROUTINE lpStartAddress pointer to thread function
997 * LPVOID lpParameter pointer to argument for new thread
998 * DWORD dwCreationFlags creation flags
999 * LPDWORD lpThreadId pointer to returned thread identifier
1000 * Variables :
1001 * Result : If the function succeeds, the return value is a handle to
1002 * the new thread.
1003 * If the function fails, the return value is NULL.
1004 * Remark :
1005 * Status : UNTESTED STUB
1006 *
1007 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1008 *****************************************************************************/
1009
1010HANDLE WIN32API CreateRemoteThread( HANDLE hProcess,
1011 LPSECURITY_ATTRIBUTES lpThreadAttributes,
1012 DWORD dwStackSize,
1013 LPTHREAD_START_ROUTINE lpStartAddress,
1014 LPVOID lpParameter,DWORD dwCreationFlags,
1015 LPDWORD lpThreadId )
1016{
1017
1018 dprintf(("KERNEL32: CreateRemoteThread(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented\n",
1019 hProcess, lpThreadAttributes, dwStackSize, lpStartAddress,
1020 lpParameter, dwCreationFlags, lpThreadId
1021 ));
1022
1023 return (NULL);
1024}
1025/*****************************************************************************
1026 * Name : DWORD WIN32API CreateTapePartition
1027 * Purpose : The CreateTapePartition function reformats a tape.
1028 * Parameters: HANDLE hDevice handle to open device
1029 * DWORD dwPartitionMethode type of new partition
1030 * DWORD dwCount number of new partitions to create
1031 * DWORD dwSize size of new partition, in megabytes
1032 * Variables :
1033 * Result : If the function succeeds, the return value is NO_ERROR.
1034 * If the function fails, it may return one of the following
1035 * error codes:
1036 * Error Description
1037 * ERROR_BEGINNING_OF_MEDIA An attempt to access data before
1038 * the beginning-of-medium marker failed.
1039 * ERROR_BUS_RESET A reset condition was detected on the bus.
1040 * ERROR_END_OF_MEDIA The end-of-tape marker was reached
1041 * during an operation.
1042 * ERROR_FILEMARK_DETECTED A filemark was reached during an operation.
1043 * ERROR_SETMARK_DETECTED A setmark was reached during an operation.
1044 * ERROR_NO_DATA_DETECTED The end-of-data marker was reached
1045 * during an operation.
1046 * ERROR_PARTITION_FAILURE The tape could not be partitioned.
1047 * ERROR_INVALID_BLOCK_LENGTH The block size is incorrect on a
1048 * new tape in a multivolume partition.
1049 * ERROR_DEVICE_NOT_PARTITIONED The partition information could not
1050 * be found when a tape was being loaded.
1051 * ERROR_MEDIA_CHANGED The tape that was in the drive has
1052 * been replaced or removed.
1053 * ERROR_NO_MEDIA_IN_DRIVE There is no media in the drive.
1054 * ERROR_NOT_SUPPORTED The tape driver does not support a
1055 * requested function.
1056 * ERROR_UNABLE_TO_LOCK_MEDIA An attempt to lock the ejection
1057 * mechanism failed.
1058 * ERROR_UNABLE_TO_UNLOAD_MEDIA An attempt to unload the tape failed.
1059 * ERROR_WRITE_PROTECT The media is write protected.
1060 * Remark : Creating partitions reformats the tape. All previous information
1061 * recorded on the tape is destroyed.
1062 * Errorcodes are defined in winerror.h
1063 * Status : UNTESTED STUB
1064 *
1065 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1066 *****************************************************************************/
1067
1068DWORD WIN32API CreateTapePartition( HANDLE hDevice, DWORD dwPartitionMethod,
1069 DWORD dwCount, DWORD dwSize)
1070{
1071
1072 dprintf(("KERNEL32: CreateTapePartition(%08x,%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
1073 hDevice, dwPartitionMethod, dwCount, dwSize
1074 ));
1075
1076 return (ERROR_NOT_SUPPORTED);
1077}
1078/*****************************************************************************
1079 * Name : HANDLE WIN23API CreateWaitableTimerA
1080 * Purpose : The CreateWaitableTimerA function creates a "waitable" timer object.
1081 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
1082 * BOOL bManualReset flag for manual reset state
1083 * LPCTSTR lpTimerName pointer to timer object name
1084 * Variables :
1085 * Result : If the function succeeds, the return value is a handle to the
1086 * timer object. If the named timer object exists before the
1087 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
1088 * Otherwise, GetLastError returns zero.
1089 * If the function fails, the return value is NULL
1090 * Remark :
1091 * Status : UNTESTED STUB
1092 *
1093 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1094 *****************************************************************************/
1095
1096HANDLE WIN32API CreateWaitableTimerA( LPSECURITY_ATTRIBUTES lpTimerAttributes,
1097 BOOL bManualReset, LPCSTR lpTimerName)
1098{
1099
1100 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
1101 lpTimerAttributes, bManualReset, lpTimerName
1102 ));
1103
1104 return (NULL);
1105}
1106
1107/*****************************************************************************
1108 * Name : HANDLE WIN23API CreateWaitableTimerW
1109 * Purpose : The CreateWaitableTimerW function creates a "waitable" timer object.
1110 * Parameters: LPSECURITY_ATTRIBUTES lpTimerAttributes pointer to security attributes
1111 * BOOL bManualReset flag for manual reset state
1112 * LPCTSTR lpTimerName pointer to timer object name
1113 * Variables :
1114 * Result : If the function succeeds, the return value is a handle to the
1115 * timer object. If the named timer object exists before the
1116 * function call, GetLastError returns ERROR_ALREADY_EXISTS.
1117 * Otherwise, GetLastError returns zero.
1118 * If the function fails, the return value is NULL
1119 * Remark :
1120 * Status : UNTESTED STUB
1121 *
1122 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1123 *****************************************************************************/
1124
1125HANDLE WIN32API CreateWaitableTimerW( LPSECURITY_ATTRIBUTES lpTimerAttributes,
1126 BOOL bManualReset, LPCWSTR lpTimerName)
1127{
1128
1129 dprintf(("KERNEL32: CreateWaitableTimer(%08x,%08x,%08x) not implemented\n",
1130 lpTimerAttributes, bManualReset, lpTimerName
1131 ));
1132
1133 return (NULL);
1134}
1135
1136/*****************************************************************************
1137 * Name : BOOL WIN32API DebugActiveProcess
1138 * Purpose : The DebugActiveProcess function allows a debugger to attach to
1139 * an active process and then debug it.
1140 * Parameters: DWORD dwProcessId process to be debugged
1141 * Variables :
1142 * Result : If the function succeeds, the return value is nonzero.
1143 * If the function fails, the return value is zero
1144 * Remark :
1145 * Status : UNTESTED STUB
1146 *
1147 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1148 *****************************************************************************/
1149
1150BOOL WIN32API DebugActiveProcess(DWORD dwProcessId)
1151{
1152
1153 dprintf(("KERNEL32:DebugActiveProcess(%08x) not implemented\n",
1154 dwProcessId
1155 ));
1156
1157 return (FALSE);
1158}
1159
1160/*****************************************************************************
1161 * Name : BOOL WIN32API DefineDosDeviceA
1162 * Purpose : The DefineDosDeviceA function lets an application define,
1163 * redefine, or delete MS-DOS device names.
1164 * MS-DOS device names are stored as symbolic links in the object
1165 * name space in 32-bit versions of Windows. The code that converts
1166 * an MS-DOS path into a corresponding path in 32-bit versions of
1167 * Windows uses these symbolic links to map MS-DOS devices and drive
1168 * letters. The DefineDosDevice function provides a mechanism
1169 * whereby a Win32-based application can modify the symbolic links
1170 * used to implement the MS-DOS device name space.
1171 * Parameters: DWORD dwFlags flags specifying aspects of device definition
1172 * LPCSTR lpDeviceName pointer to MS-DOS device name string
1173 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
1174 * 32-bit Windows
1175 * Variables :
1176 * Result : If the function succeeds, the return value is nonzero.
1177 * If the function fails, the return value is zero
1178 * Remark :
1179 * Status : UNTESTED STUB
1180 *
1181 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1182 *****************************************************************************/
1183
1184BOOL WIN32API DefineDosDeviceA( DWORD dwFlags, LPCSTR lpDeviceName,
1185 LPCSTR lpTargetPath )
1186{
1187
1188 dprintf(("KERNEL32: DefineDosDeviceA(%08x,%08x,%08x) not implemented\n",
1189 dwFlags, lpDeviceName, lpTargetPath
1190 ));
1191
1192 return (FALSE);
1193}
1194
1195/*****************************************************************************
1196 * Name : BOOL WIN32API DefineDosDeviceW
1197 * Purpose : UNICODE version of DefineDosDeviceA
1198 * Parameters: DWORD dwFlags flags specifying aspects of device definition
1199 * LPCSTR lpDeviceName pointer to MS-DOS device name string
1200 * LPCSTR lpTargetPath pointer to MS-DOS or path string for
1201 * 32-bit Windows
1202 * Variables :
1203 * Result : If the function succeeds, the return value is nonzero.
1204 * If the function fails, the return value is zero
1205 * Remark :
1206 * Status : UNTESTED STUB
1207 *
1208 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1209 *****************************************************************************/
1210
1211BOOL WIN32API DefineDosDeviceW( DWORD dwFlags, LPCWSTR lpDeviceName,
1212 LPCWSTR lpTargetPath )
1213{
1214
1215 dprintf(("KERNEL32: DefineDosDeviceW(%08x,%08x,%08x) not implemented\n",
1216 dwFlags, lpDeviceName, lpTargetPath
1217 ));
1218
1219 return (FALSE);
1220}
1221
1222/*****************************************************************************
1223 * Name : VOID WIN32API DeleteFiber
1224 * Purpose : The DeleteFiber function deletes an existing fiber
1225 * Parameters: LPVOID lpFiber pointer to the fiber to delete
1226 * Variables :
1227 * Result : No returnvalue
1228 * Remark : The DeleteFiber function deletes all data associated with the
1229 * fiber. This data includes the stack, a subset of the registers,
1230 * and the fiber data. If the currently running fiber calls
1231 * DeleteFiber, the ExitThread function is called and the thread
1232 * terminates. If the currently running fiber is deleted by another
1233 * thread, the thread associated with the fiber is likely to
1234 * terminate abnormally because the fiber stack has been freed.
1235 * Status : UNTESTED STUB
1236 *
1237 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1238 *****************************************************************************/
1239
1240VOID WIN32API DeleteFiber(LPVOID lpFiber)
1241{
1242
1243 dprintf(("KERNEL32: DeleteFiber(%08x) not implemented\n",
1244 lpFiber
1245 ));
1246}
1247/*****************************************************************************
1248 * Name : BOOL WIN32API DisconnectNamedPipe
1249 * Purpose : The DisconnectNamedPipe function disconnects the server end
1250 * of a named pipe instance from a client process.
1251 * Parameters: HANDLE hNamedPipe handle to named pipe
1252 * Variables :
1253 * Result : If the function succeeds, the return value is nonzero.
1254 * If the function fails, the return value is zero
1255 * Remark :
1256 * Status : UNTESTED STUB
1257 *
1258 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1259 *****************************************************************************/
1260
1261BOOL WIN32API DisconnectNamedPipe(HANDLE hNamedPipe)
1262{
1263
1264 dprintf(("KERNEL32: DisconnectNamedPipe(%08x) not implemented\n",
1265 hNamedPipe
1266 ));
1267
1268 return (FALSE);
1269}
1270
1271/*****************************************************************************
1272 * Name : BOOL WIN3API EndUpdateResourceA
1273 * Purpose : The EndUpdateResourceA function ends a resource update
1274 * in an executable file.
1275 * Parameters: HANDLE hUpdate update-file handle
1276 * BOOL fDiscard write flag
1277 * Variables :
1278 * Result : If the function succeeds and the accumulated resource
1279 * modifications specified by calls to the UpdateResource function
1280 * are written to the specified executable file,
1281 * the return value is nonzero.
1282 * If the function fails, the return value is zero
1283 * Remark :
1284 * Status : UNTESTED STUB
1285 *
1286 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1287 *****************************************************************************/
1288
1289BOOL WIN32API EndUpdateResourceA(HANDLE hUpdate,BOOL fDiscard)
1290{
1291
1292 dprintf(("KERNEL32:EndUpdateResourceA(%08x,%08x)not implemented\n",
1293 hUpdate, fDiscard
1294 ));
1295
1296 return (FALSE);
1297}
1298
1299/*****************************************************************************
1300 * Name : BOOL WIN3API EndUpdateResourceW
1301 * Purpose : The EndUpdateResourceW function ends a resource update
1302 * in an executable file.
1303 * Parameters: HANDLE hUpdate update-file handle
1304 * BOOL fDiscard write flag
1305 * Variables :
1306 * Result : If the function succeeds and the accumulated resource
1307 * modifications specified by calls to the UpdateResource function
1308 * are written to the specified executable file,
1309 * the return value is nonzero.
1310 * If the function fails, the return value is zero
1311 * Remark :
1312 * Status : UNTESTED STUB
1313 *
1314 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1315 *****************************************************************************/
1316
1317BOOL WIN32API EndUpdateResourceW(HANDLE hUpdate,BOOL fDiscard)
1318{
1319
1320 dprintf(("KERNEL32:EndUpdateResourceW(%08x,%08x) not implemented\n",
1321 hUpdate, fDiscard
1322 ));
1323
1324 return (FALSE);
1325}
1326
1327/*****************************************************************************
1328 * Name : BOOL WIN32API EnumCalendarInfoA
1329 * Purpose : The EnumCalendarInfoA function enumerates calendar information
1330 * for a specified locale. The CalType parameter specifies the type
1331 * of calendar information to enumerate. The function returns the
1332 * specified calendar information for all applicable calendars for
1333 * the locale, or for a single requested calendar, depending on the
1334 * value of the Calendar parameter.
1335 * The EnumCalendarInfo function enumerates the calendar information
1336 * by calling an application-defined callback function. It passes
1337 * the callback function a pointer to a string buffer containing
1338 * the requested calendar information. This continues until either
1339 * the last applicable calendar is found or the callback function
1340 * returns FALSE.
1341 * Parameters: CALINFO_ENUMPROCA lpCalInfoEnumProc pointer to enumeration
1342 * callback function
1343 * LCID Locale locale whose calendar information is of interest
1344 * CALID Calendar calendar whose information is of interest
1345 * CALTYPE CalType type of calendar information of interest
1346 * Variables :
1347 * Result : If the function succeeds, the return value is nonzero.
1348 * If the function fails, the return value is zero
1349 * Remark :
1350 * Status : UNTESTED STUB
1351 *
1352 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1353 *****************************************************************************/
1354
1355BOOL WIN32API EnumCalendarInfoA(CALINFO_ENUMPROCA lpCalInfoEnumProc,
1356 LCID Locale,
1357 CALID Calendar,
1358 CALTYPE CalType)
1359{
1360
1361 dprintf(("KERNEL32: EnumCalendarInfoA(%08x,%08x,%08x,%08x)not implemented\n",
1362 lpCalInfoEnumProc,
1363 Locale,
1364 Calendar,
1365 CalType
1366 ));
1367
1368 return (FALSE);
1369}
1370
1371/*****************************************************************************
1372 * Name : BOOL WIN32API EnumCalendarInfoW
1373 * Purpose : The EnumCalendarInfoW function enumerates calendar information
1374 * for a specified locale. The CalType parameter specifies the type
1375 * of calendar information to enumerate. The function returns the
1376 * specified calendar information for all applicable calendars for
1377 * the locale, or for a single requested calendar, depending on the
1378 * value of the Calendar parameter.
1379 * The EnumCalendarInfo function enumerates the calendar information
1380 * by calling an application-defined callback function. It passes
1381 * the callback function a pointer to a string buffer containing
1382 * the requested calendar information. This continues until either
1383 * the last applicable calendar is found or the callback function
1384 * returns FALSE.
1385 * Parameters: CALINFO_ENUMPROCW lpCalInfoEnumProc pointer to enumeration
1386 * callback function
1387 * LCID Locale locale whose calendar information is of interest
1388 * CALID Calendar calendar whose information is of interest
1389 * CALTYPE CalType type of calendar information of interest
1390 * Variables :
1391 * Result : If the function succeeds, the return value is nonzero.
1392 * If the function fails, the return value is zero
1393 * Remark :
1394 * Status : UNTESTED STUB
1395 *
1396 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1397 *****************************************************************************/
1398
1399BOOL WIN32API EnumCalendarInfoW(CALINFO_ENUMPROCW lpCalInfoEnumProc,
1400 LCID Locale,
1401 CALID Calendar,
1402 CALTYPE CalType)
1403{
1404
1405 dprintf(("KERNEL32: EnumCalendarInfoW(%08x,%08x,%08x,%08x)not implemented\n",
1406 lpCalInfoEnumProc,
1407 Locale,
1408 Calendar,
1409 CalType
1410 ));
1411
1412 return (FALSE);
1413}
1414
1415/*****************************************************************************
1416 * Name : BOOL WIN32API EnumSystemCodePagesA
1417 * Purpose : The EnumSystemCodePagesA function enumerates the code pages that
1418 * are either installed on or supported by a system. The dwFlags
1419 * parameter determines whether the function enumerates installed
1420 * or supported code pages. The function enumerates the code pages
1421 * by passing code page identifiers, one at a time, to the specified
1422 * application-defined callback function. This continues until all
1423 * of the installed or supported code page identifiers have been
1424 * passed to the callback function, or the callback function
1425 * returns FALSE
1426 * Parameters: CODEPAGE_ENUMPROCA lpCodePageEnumProc pointer to enumeration
1427 * callback function
1428 * DWORD dwFlags indicates which code pages
1429 * to enumerate
1430 * Variables :
1431 * Result : If the function succeeds, the return value is nonzero.
1432 * If the function fails, the return value is zero
1433 * Remark :
1434 * Status : UNTESTED STUB
1435 *
1436 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1437 *****************************************************************************/
1438
1439BOOL WIN32API EnumSystemCodePagesA(CODEPAGE_ENUMPROCA lpCodePageEnumProc,
1440 DWORD dwFlags)
1441{
1442
1443 dprintf(("KERNEL32: EnumSystemCodePagesA(%08x,%08x) not implemented\n",
1444 lpCodePageEnumProc, dwFlags
1445 ));
1446
1447 return (FALSE);
1448}
1449
1450/*****************************************************************************
1451 * Name : BOOL WIN32API EnumSystemCodePagesW
1452 * Purpose : The EnumSystemCodePagesW function enumerates the code pages that
1453 * are either installed on or supported by a system. The dwFlags
1454 * parameter determines whether the function enumerates installed
1455 * or supported code pages. The function enumerates the code pages
1456 * by passing code page identifiers, one at a time, to the specified
1457 * application-defined callback function. This continues until all
1458 * of the installed or supported code page identifiers have been
1459 * passed to the callback function, or the callback function
1460 * returns FALSE
1461 * Parameters: CODEPAGE_ENUMPROCW lpCodePageEnumProc pointer to enumeration
1462 * callback function
1463 * DWORD dwFlags indicates which code pages
1464 * to enumerate
1465 * Variables :
1466 * Result : If the function succeeds, the return value is nonzero.
1467 * If the function fails, the return value is zero
1468 * Remark :
1469 * Status : UNTESTED STUB
1470 *
1471 * Author : Markus Montkowski [Tha, 1998/05/21 17:46]
1472 *****************************************************************************/
1473
1474BOOL WIN32API EnumSystemCodePagesW(CODEPAGE_ENUMPROCW lpCodePageEnumProc,
1475 DWORD dwFlags)
1476{
1477
1478 dprintf(("KERNEL32: EnumSystemCodePagesA(%08x,%08x) not implemented\n",
1479 lpCodePageEnumProc, dwFlags
1480 ));
1481
1482 return (FALSE);
1483}
1484
1485/*****************************************************************************
1486 * Name : DWORD WIN32API EraseTape
1487 * Purpose : The EraseTape function erases all or part of a tape.
1488 * Parameters: HANDLE hDevice handle to open device
1489 * DWORD dwEraseType type of erasure to perform
1490 * BOOL bImmediate return after erase operation begins
1491 * Variables :
1492 * Result : If the function succeeds, the return value is NO_ERROR.
1493 * If the function fails, the return value is like in
1494 * CreateTapePartition
1495 * Remark : Some tape devices do not support certain tape operations. To de
1496 * termine your tape device's capabilities, see your tape device
1497 * documentation and use the GetTapeParameters function
1498 * Status : UNTESTED STUB
1499 *
1500 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1501 *****************************************************************************/
1502
1503DWORD WIN32API EraseTape( HANDLE hDevice, DWORD dwEraseType, BOOL bImmediate)
1504{
1505
1506 dprintf(("KERNEL32: EraseTape(%08x,%08x,%08x) not implemented - ERROR_NOT_SUPPORTED\n",
1507 hDevice, dwEraseType, bImmediate
1508 ));
1509
1510 return (ERROR_NOT_SUPPORTED);
1511}
1512
1513
1514/*****************************************************************************
1515 * Name : HANDLE WIN32API FindFirstChangeNotificationW
1516 * Purpose : The FindFirstChangeNotification function creates a change
1517 * notification handle and sets up initial change notification
1518 * filter conditions. A wait on a notification handle succeeds when
1519 * a change matching the filter conditions occurs in the specified
1520 * directory or subtree.
1521 * Parameters: LPCWSTR lpPathName pointer to name of directory to watch
1522 * BOOL bWatchSubtree flag for monitoring directory or
1523 * directory tree
1524 * DWORD dwNotifyFilter filter conditions to watch for
1525 * Variables :
1526 * Result : If the function succeeds, the return value is a handle to a find
1527 * change notification object.
1528 * If the function fails, the return value is INVALID_HANDLE_VALUE
1529 * Remark :
1530 * Status : UNTESTED STUB
1531 *
1532 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1533 *****************************************************************************/
1534
1535HANDLE WIN32API FindFirstChangeNotificationW( LPCWSTR lpPathName,
1536 BOOL bWatchSubtree,
1537 DWORD dwNotifyFilter)
1538{
1539
1540 dprintf(("KERNEL32: FindFirstChangeNotificationW(%08x,%08x,%08x) not implemented - INVALID_HANDLE_VALUE\n",
1541 lpPathName, bWatchSubtree, dwNotifyFilter
1542 ));
1543
1544 return (INVALID_HANDLE_VALUE);
1545}
1546
1547/*****************************************************************************
1548 * Name : HANDLE WIN32API FindFirstFileExA
1549 * Purpose : The FindFirstFileExA function searches a directory for a file
1550 * whose name and attributes match those specified in the
1551 * function call.
1552 * Parameters: LPCSTR lpFileName pointer to the name of the file
1553 * to search for
1554 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
1555 * LPVOID lpFindFileData pointer to the returned information
1556 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
1557 * LPVOID lpSearchFilter pointer to search criteria
1558 * DWORD dwAdditionalFlags additional search control flags
1559 * Variables :
1560 * Result : If the function succeeds, the return value is a search handle
1561 * that can be used in a subsequent call to the FindNextFile or
1562 * FindClose functions.
1563 * If the function fails, the return value is INVALID_HANDLE_VALUE
1564 * Remark :
1565 * Status : UNTESTED STUB
1566 *
1567 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1568 *****************************************************************************/
1569
1570HANDLE WIN32API FindFirstFileExA( LPCSTR lpFileName,
1571 FINDEX_INFO_LEVELS fInfoLevelId,
1572 LPVOID lpFindFileData,
1573 FINDEX_SEARCH_OPS fSearchOp,
1574 LPVOID lpSearchFilter,
1575 DWORD dwAdditionalFlags)
1576{
1577
1578 dprintf(("KERNEL32: FindFirstFileExA(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
1579 lpFileName,
1580 fInfoLevelId,
1581 lpFindFileData,
1582 fSearchOp,
1583 lpSearchFilter,
1584 dwAdditionalFlags
1585 ));
1586
1587 return (INVALID_HANDLE_VALUE);
1588}
1589
1590/*****************************************************************************
1591 * Name : HANDLE WIN32API FindFirstFileExW
1592 * Purpose : The FindFirstFileExW function searches a directory for a file
1593 * whose name and attributes match those specified in the
1594 * function call.
1595 * Parameters: LPCWSTR lpFileName pointer to the name of the file
1596 * to search for
1597 * FINDEX_INFO_LEVELS fInfoLevelId information level of the returned data
1598 * LPVOID lpFindFileData pointer to the returned information
1599 * FINDEX_SEARCH_OPS fSearchOp type of filtering to perform
1600 * LPVOID lpSearchFilter pointer to search criteria
1601 * DWORD dwAdditionalFlags additional search control flags
1602 * Variables :
1603 * Result : If the function succeeds, the return value is a search handle
1604 * that can be used in a subsequent call to the FindNextFile or
1605 * FindClose functions.
1606 * If the function fails, the return value is INVALID_HANDLE_VALUE
1607 * Remark :
1608 * Status : UNTESTED STUB
1609 *
1610 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1611 *****************************************************************************/
1612
1613HANDLE WIN32API FindFirstFileExW( LPCWSTR lpFileName,
1614 FINDEX_INFO_LEVELS fInfoLevelId,
1615 LPVOID lpFindFileData,
1616 FINDEX_SEARCH_OPS fSearchOp,
1617 LPVOID lpSearchFilter,
1618 DWORD dwAdditionalFlags)
1619{
1620
1621 dprintf(("KERNEL32: FindFirstFileExW(%08x,%08x,%08x,%08x,%08x,%08x)not implemented - INVALID_HANDLE_VALUE\n",
1622 lpFileName,
1623 fInfoLevelId,
1624 lpFindFileData,
1625 fSearchOp,
1626 lpSearchFilter,
1627 dwAdditionalFlags
1628 ));
1629
1630 return (INVALID_HANDLE_VALUE);
1631}
1632
1633/*****************************************************************************
1634 * Name : int WIN32API FoldStringA
1635 * Purpose : The FoldStringW function maps one string to another, performing
1636 * a specified transformation option.
1637 * Parameters: DWORD dwMapFlags, // mapping transformation options
1638 * LPCSTR lpSrcStr, // pointer to source string
1639 * int cchSrc, // size of source string, in bytes or characters
1640 * LPSTR lpDestStr, // pointer to destination buffer
1641 * int cchDest // size of destination buffer, in bytes or characters
1642 * Variables :
1643 * Result : If the function succeeds, the return value is the number of bytes
1644 * (ANSI version) or characters (Unicode version) written to the
1645 * destination buffer, or if the cchDest parameter is zero,
1646 * the number of bytes or characters required to hold the mapped
1647 * string.
1648 * If the function fails, the return value is zero
1649 * Remark :
1650 * Status : UNTESTED STUB
1651 *
1652 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1653 *****************************************************************************/
1654
1655int WIN32API FoldStringA( DWORD dwMapFlags, LPCSTR lpSrcStr,
1656 int cchSrc, LPSTR lpDestStr, int cchDest)
1657{
1658
1659 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1660 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1661 ));
1662
1663 return (0);
1664}
1665
1666/*****************************************************************************
1667 * Name : int WIN32API FoldStringW
1668 * Purpose : The FoldStringW function maps one string to another, performing
1669 * a specified transformation option.
1670 * Parameters: DWORD dwMapFlags, // mapping transformation options
1671 * LPCSTR lpSrcStr, // pointer to source string
1672 * int cchSrc, // size of source string, in bytes or characters
1673 * LPSTR lpDestStr, // pointer to destination buffer
1674 * int cchDest // size of destination buffer, in bytes or characters
1675 * Variables :
1676 * Result : If the function succeeds, the return value is the number of bytes
1677 * (ANSI version) or characters (Unicode version) written to the
1678 * destination buffer, or if the cchDest parameter is zero,
1679 * the number of bytes or characters required to hold the mapped
1680 * string.
1681 * If the function fails, the return value is zero
1682 * Remark :
1683 * Status : UNTESTED STUB
1684 *
1685 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1686 *****************************************************************************/
1687
1688int WIN32API FoldStringW( DWORD dwMapFlags, LPCWSTR lpSrcStr,
1689 int cchSrc, LPWSTR lpDestStr, int cchDest)
1690{
1691
1692 dprintf(("KERNEL32: FoldStringA(%08x,%08x,%08x,%08x,%08x) not implemented\n",
1693 dwMapFlags, lpSrcStr, cchSrc, lpDestStr, cchDest
1694 ));
1695
1696 return (0);
1697}
1698
1699
1700/*****************************************************************************
1701 * Name : VOID WIN32API FreeLibraryAndExitThread
1702 * Purpose : The FreeLibraryAndExitThread function decrements the reference
1703 * count of a loaded dynamic-link library (DLL) by one, and then
1704 * calls ExitThread to terminate the calling thread.
1705 * The function does not return.
1706 *
1707 * The FreeLibraryAndExitThread function gives threads that are
1708 * created and executed within a dynamic-link library an opportunity
1709 * to safely unload the DLL and terminate themselves.
1710 * Parameters:
1711 * Variables :
1712 * Result :
1713 * Remark :
1714 * Status : UNTESTED STUB
1715 *
1716 * Author : Markus Montkowski [Tha, 1998/05/21 20:57]
1717 *****************************************************************************/
1718
1719VOID WIN32API FreeLibraryAndExitThread( HMODULE hLibModule, DWORD dwExitCode)
1720{
1721
1722 dprintf(("KERNEL32: FreeLibraryAndExitThread(%08x,%08x) not implemented\n",
1723 hLibModule, dwExitCode
1724 ));
1725
1726}
1727
1728
1729/*****************************************************************************
1730 * Name : int GetCurrencyFormatA
1731 * Purpose : The GetCurrencyFormatA function formats a number string as a
1732 * currency string for a specified locale.
1733 * Parameters: LCID Locale locale for which currency string is to be formatted
1734 * DWORD dwFlags bit flag that controls the function's operation
1735 * LPCTSTR lpValue pointer to input number string
1736 * CONST CURRENCYFMT *lpFormat pointer to a formatting information structure
1737 * LPTSTR lpCurrencyStr pointer to output buffer
1738 * int cchCurrency size of output buffer
1739 * Variables :
1740 * Result : number of bytes written to buffer
1741 * Remark :
1742 * Status : UNTESTED STUB
1743 *
1744 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1745 *****************************************************************************/
1746
1747int WIN32API GetCurrencyFormatA(LCID Locale,
1748 DWORD dwFlags,
1749 LPCTSTR lpValue,
1750 CONST CURRENCYFMTA *lpFormat,
1751 LPTSTR lpCurrencyStr,
1752 int cchCurrency)
1753{
1754 dprintf(("KERNEL32: GetCurrencyFormatA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1755 Locale,
1756 dwFlags,
1757 lpValue,
1758 lpFormat,
1759 lpCurrencyStr,
1760 cchCurrency));
1761
1762 if(lpValue && lpCurrencyStr) {
1763 lstrcpyA(lpCurrencyStr, lpValue);
1764 return lstrlenA(lpCurrencyStr);
1765 }
1766 return (0);
1767}
1768
1769
1770/*****************************************************************************
1771 * Name : int GetCurrencyFormatW
1772 * Purpose : The GetCurrencyFormatW function formats a number string as a
1773 * currency string for a specified locale.
1774 * Parameters: LCID Locale locale for which currency string is to be formatted
1775 * DWORD dwFlags bit flag that controls the function's operation
1776 * LPCWSTR lpValue pointer to input number string
1777 * CONST CURRENCYFMT *lpFormat pointer to a formatting information structure
1778 * LPWSTR lpCurrencyStr pointer to output buffer
1779 * int cchCurrency size of output buffer
1780 * Variables :
1781 * Result : number of bytes written to buffer
1782 * Remark :
1783 * Status : UNTESTED STUB
1784 *
1785 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1786 *****************************************************************************/
1787
1788int WIN32API GetCurrencyFormatW(LCID Locale,
1789 DWORD dwFlags,
1790 LPCWSTR lpValue,
1791 CONST CURRENCYFMTW *lpFormat,
1792 LPWSTR lpCurrencyStr,
1793 int cchCurrency)
1794{
1795 dprintf(("KERNEL32: GetCurrencyFormatW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1796 Locale,
1797 dwFlags,
1798 lpValue,
1799 lpFormat,
1800 lpCurrencyStr,
1801 cchCurrency));
1802
1803 if(lpValue && lpCurrencyStr) {
1804 lstrcpyW(lpCurrencyStr, lpValue);
1805 return lstrlenW(lpCurrencyStr);
1806 }
1807
1808 return (0);
1809}
1810
1811
1812/*****************************************************************************
1813 * Name : DWORD GetHandleInformation
1814 * Purpose : The GetHandleInformation function obtains information about certain
1815 * properties of an object handle. The information is obtained as a set of bit flags.
1816 * Parameters: HANDLE hObject
1817 * LPDWORD lpdwFlags
1818 * Variables :
1819 * Result : TRUE / FALSE
1820 * Remark :
1821 * Status : UNTESTED STUB
1822 *
1823 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1824 *****************************************************************************/
1825
1826BOOL WIN32API GetHandleInformation(HANDLE hObject,
1827 LPDWORD lpdwFlags)
1828{
1829 dprintf(("KERNEL32: GetHandleInformation (%08xh, %08xh) not implemented\n",
1830 hObject,
1831 lpdwFlags));
1832
1833 return (FALSE);
1834}
1835
1836
1837/*****************************************************************************
1838 * Name : BOOL GetMailslotInfo
1839 * Purpose : The GetMailslotInfo function retrieves information about the
1840 * specified mailslot.
1841 * Parameters: HANDLE hMailslot mailslot handle
1842 * LPDWORD lpMaxMessageSize address of maximum message size
1843 * LPDWORD lpNextSize address of size of next message
1844 * LPDWORD lpMessageCount address of number of messages
1845 * LPDWORD lpReadTimeout address of read time-out
1846 * Variables :
1847 * Result : TRUE / FALSE
1848 * Remark :
1849 * Status : UNTESTED STUB
1850 *
1851 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1852 *****************************************************************************/
1853
1854BOOL WIN32API GetMailslotInfo(HANDLE hMailslot,
1855 LPDWORD lpMaxMessageSize,
1856 LPDWORD lpNextSize,
1857 LPDWORD lpMessageCount,
1858 LPDWORD lpReadTimeout)
1859{
1860 dprintf(("KERNEL32: GetMailslotInfo(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1861 hMailslot,
1862 lpMaxMessageSize,
1863 lpNextSize,
1864 lpMessageCount,
1865 lpReadTimeout));
1866
1867 return (FALSE);
1868}
1869
1870
1871/*****************************************************************************
1872 * Name : BOOL GetNamedPipeHandleStateA
1873 * Purpose : The GetNamedPipeHandleStateA function retrieves information about
1874 * a specified named pipe. The information returned can vary during
1875 * the lifetime of an instance of the named pipe.
1876 * Parameters: HANDLE hNamedPipe handle of named pipe
1877 * LPDWORD lpState address of flags indicating pipe state
1878 * LPDWORD lpCurInstances address of number of current pipe instances
1879 * LPDWORD lpMaxCollectionCount address of max. bytes before remote transmission
1880 * LPDWORD lpCollectDataTimeout address of max. time before remote transmission
1881 * LPTSTR lpUserName address of user name of client process
1882 * DWORD nMaxUserNameSize size, in characters, of user name buffer
1883 * Variables :
1884 * Result : TRUE / FALSE
1885 * Remark :
1886 * Status : UNTESTED STUB
1887 *
1888 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1889 *****************************************************************************/
1890
1891BOOL WIN32API GetNamedPipeHandleStateA(HANDLE hNamedPipe,
1892 LPDWORD lpState,
1893 LPDWORD lpCurInstances,
1894 LPDWORD lpMaxCollectionCount,
1895 LPDWORD lpCollectDataTimeout,
1896 LPTSTR lpUserName,
1897 DWORD nMaxUserNameSize)
1898{
1899 dprintf(("KERNEL32: GetNamedPipeHandleStateA(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1900 hNamedPipe,
1901 lpState,
1902 lpCurInstances,
1903 lpMaxCollectionCount,
1904 lpCollectDataTimeout,
1905 lpUserName,
1906 nMaxUserNameSize));
1907
1908 return (FALSE);
1909}
1910
1911
1912/*****************************************************************************
1913 * Name : BOOL GetNamedPipeHandleStateW
1914 * Purpose : The GetNamedPipeHandleStateW function retrieves information about
1915 * a specified named pipe. The information returned can vary during
1916 * the lifetime of an instance of the named pipe.
1917 * Parameters: HANDLE hNamedPipe handle of named pipe
1918 * LPDWORD lpState address of flags indicating pipe state
1919 * LPDWORD lpCurInstances address of number of current pipe instances
1920 * LPDWORD lpMaxCollectionCount address of max. bytes before remote transmission
1921 * LPDWORD lpCollectDataTimeout address of max. time before remote transmission
1922 * LPWSTR lpUserName address of user name of client process
1923 * DWORD nMaxUserNameSize size, in characters, of user name buffer
1924 * Variables :
1925 * Result : TRUE / FALSE
1926 * Remark :
1927 * Status : UNTESTED STUB
1928 *
1929 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1930 *****************************************************************************/
1931
1932BOOL WIN32API GetNamedPipeHandleStateW(HANDLE hNamedPipe,
1933 LPDWORD lpState,
1934 LPDWORD lpCurInstances,
1935 LPDWORD lpMaxCollectionCount,
1936 LPDWORD lpCollectDataTimeout,
1937 LPWSTR lpUserName,
1938 DWORD nMaxUserNameSize)
1939{
1940 dprintf(("KERNEL32: GetNamedPipeHandleStateW(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1941 hNamedPipe,
1942 lpState,
1943 lpCurInstances,
1944 lpMaxCollectionCount,
1945 lpCollectDataTimeout,
1946 lpUserName,
1947 nMaxUserNameSize));
1948
1949 return (FALSE);
1950}
1951
1952
1953/*****************************************************************************
1954 * Name : BOOL GetNamedPipeInfo
1955 * Purpose : The GetNamedPipeInfo function retrieves information about the specified named pipe.
1956 * Parameters: HANDLE hNamedPipe handle of named pipe
1957 * LPDWORD lpFlags address of flags indicating type of pipe
1958 * LPDWORD lpOutBufferSize address of size, in bytes, of pipe's output buffer
1959 * LPDWORD lpInBufferSize address of size, in bytes, of pipe's input buffer
1960 * LPDWORD lpMaxInstances address of max. number of pipe instances
1961 * Variables :
1962 * Result : TRUE / FALSE
1963 * Remark :
1964 * Status : UNTESTED STUB
1965 *
1966 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
1967 *****************************************************************************/
1968
1969BOOL WIN32API GetNamedPipeInfo(HANDLE hNamedPipe,
1970 LPDWORD lpFlags,
1971 LPDWORD lpOutBufferSize,
1972 LPDWORD lpInBufferSize,
1973 LPDWORD lpMaxInstances)
1974{
1975 dprintf(("KERNEL32: GetNamedPipeInfo(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented\n",
1976 hNamedPipe,
1977 lpFlags,
1978 lpOutBufferSize,
1979 lpInBufferSize,
1980 lpMaxInstances));
1981
1982 return (FALSE);
1983}
1984
1985
1986
1987/*****************************************************************************
1988 * Name : BOOL GetQueuedCompletionStatus
1989 * Purpose : The GetQueuedCompletionStatus function attempts to dequeue an
1990 * I/O completion packet from a specified input/output completion
1991 * port. If there is no completion packet queued, the function waits
1992 * for a pending input/output operation associated with the completion
1993 * port to complete. The function returns when it can dequeue a
1994 * completion packet, or optionally when the function times out. If
1995 * the function returns because of an I/O operation completion, it
1996 * sets several variables that provide information about the operation.
1997 * Parameters: HANDLE CompletionPort the I/O completion port of interest
1998 * LPDWORD lpNumberOfBytesTransferred to receive number of bytes transferred during I/O
1999 * LPDWORD lpCompletionKey to receive file's completion key
2000 * LPOVERLAPPED * lpOverlapped to receive pointer to OVERLAPPED structure
2001 * DWORD dwMilliseconds optional timeout value
2002 * Variables :
2003 * Result : TRUE / FALSE
2004 * Remark :
2005 * Status : UNTESTED STUB
2006 *
2007 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2008 *****************************************************************************/
2009
2010BOOL WIN32API GetQueuedCompletionStatus(HANDLE CompletionPort,
2011 LPDWORD lpNumberOfBytesTransferred,
2012 LPDWORD lpCompletionKey,
2013 LPOVERLAPPED *lpOverlapped,
2014 DWORD dwMilliseconds)
2015{
2016 dprintf(("Kernel32: GetQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.",
2017 CompletionPort,
2018 lpNumberOfBytesTransferred,
2019 lpCompletionKey,
2020 lpOverlapped,
2021 dwMilliseconds));
2022
2023 return (FALSE);
2024}
2025
2026
2027
2028/*****************************************************************************
2029 * Name : BOOL GetSystemTimeAdjustment
2030 * Purpose : The GetSystemTimeAdjustment function determines whether the system
2031 * is applying periodic time adjustments to its time-of-day clock
2032 * at each clock interrupt, along with the value and period of any
2033 * such adjustments. Note that the period of such adjustments is
2034 * equivalent to the time period between clock interrupts.
2035 * Parameters: PDWORD lpTimeAdjustment
2036 * size, in 100-nanosecond units, of a periodic time adjustment
2037 * PDWORD lpTimeIncrement
2038 * time, in 100-nanosecond units, between periodic time adjustments
2039 * PBOOL lpTimeAdjustmentDisabled
2040 * whether periodic time adjustment is disabled or enabled
2041 * Variables :
2042 * Result : TRUE / FALSE
2043 * Remark :
2044 * Status : UNTESTED STUB
2045 *
2046 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2047 *****************************************************************************/
2048
2049BOOL WIN32API GetSystemTimeAdjustment(PDWORD lpTimeAdjustment,
2050 PDWORD lpTimeIncrement,
2051 PBOOL lpTimeAdjustmentDisabled)
2052{
2053 dprintf(("KERNEL32: GetSystemTimeAdjustment(%08xh,%08xh,%08xh) not implemented.\n",
2054 lpTimeAdjustment,
2055 lpTimeIncrement,
2056 lpTimeAdjustmentDisabled));
2057
2058 return (FALSE);
2059}
2060
2061
2062/*****************************************************************************
2063 * Name : BOOL GetTapeParameters
2064 * Purpose : The GetTapeParameters function retrieves information that
2065 * describes the tape or the tape drive.
2066 * Parameters: HANDLE hDevice handle of open device
2067 * DWORD dwOperation type of information requested
2068 * LPDWORD lpdwSize address of returned information
2069 * LPVOID lpTapeInformation tape media or drive information
2070 * Variables :
2071 * Result : API returncode
2072 * Remark :
2073 * Status : UNTESTED STUB
2074 *
2075 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2076 *****************************************************************************/
2077
2078DWORD WIN32API GetTapeParameters(HANDLE hDevice,
2079 DWORD dwOperation,
2080 LPDWORD lpdwSize,
2081 LPVOID lpTapeInformation)
2082{
2083 dprintf(("KERNEL32: GetTapeParameters(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2084 hDevice,
2085 dwOperation,
2086 lpdwSize,
2087 lpTapeInformation));
2088
2089 return (ERROR_NOT_SUPPORTED);
2090}
2091
2092
2093/*****************************************************************************
2094 * Name : BOOL GetTapePosition
2095 * Purpose : The GetTapePosition function retrieves the current address of
2096 * the tape, in logical or absolute blocks.
2097 * Parameters: HANDLE hDevice handle of open device
2098 * DWORD dwPositionType type of address to obtain
2099 * LPDWORD lpdwPartition address of current tape partition
2100 * LPDWORD lpdwOffsetLow address of low-order 32 bits of tape position
2101 * LPDWORD lpdwOffsetHigh address of high-order 32 bits of tape position
2102 * Variables :
2103 * Result : TRUE / FALSE
2104 * Remark :
2105 * Status : UNTESTED STUB
2106 *
2107 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2108 *****************************************************************************/
2109
2110DWORD WIN32API GetTapePosition(HANDLE hDevice,
2111 DWORD dwPositionType,
2112 LPDWORD lpdwPartition,
2113 LPDWORD lpdwOffsetLow,
2114 LPDWORD lpdwOffsetHigh)
2115{
2116 dprintf(("KERNEL32: OS2GetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2117 hDevice,
2118 dwPositionType,
2119 lpdwPartition,
2120 lpdwOffsetLow,
2121 lpdwOffsetHigh));
2122
2123 return (ERROR_NOT_SUPPORTED);
2124}
2125
2126
2127/*****************************************************************************
2128 * Name : BOOL GetTapeStatus
2129 * Purpose : The GetTapeStatus function indicates whether the tape device is
2130 * ready to process tape commands.
2131 * Parameters: HANDLE hDevice handle of open device
2132 * Variables :
2133 * Result : API returncode
2134 * Remark :
2135 * Status : UNTESTED STUB
2136 *
2137 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2138 *****************************************************************************/
2139
2140DWORD WIN32API GetTapeStatus(HANDLE hDevice)
2141{
2142 dprintf(("KERNEL32: OS2GetTapeStatus(%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2143 hDevice));
2144
2145 return (ERROR_NOT_SUPPORTED);
2146}
2147
2148
2149/*****************************************************************************
2150 * Name : BOOL GetThreadSelectorEntry
2151 * Purpose : The GetThreadSelectorEntry function retrieves a descriptor table
2152 * entry for the specified selector and thread.
2153 * Parameters: HANDLE hThread handle of thread that contains selector
2154 * DWORD dwSelector number of selector value to look up
2155 * LPLDT_ENTRY lpSelectorEntry address of selector entry structure
2156 * Variables :
2157 * Result : TRUE / FALSE
2158 * Remark :
2159 * Status : UNTESTED STUB
2160 *
2161 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2162 *****************************************************************************/
2163
2164BOOL WIN32API GetThreadSelectorEntry(HANDLE hThread,
2165 DWORD dwSelector,
2166 LPLDT_ENTRY lpSelectorEntry)
2167{
2168 dprintf(("KERNEL32: GetThreadSelectorEntry(%08xh,%08xh,%08xh) not implemented.\n",
2169 hThread,
2170 dwSelector,
2171 lpSelectorEntry));
2172
2173 return (FALSE);
2174}
2175
2176
2177/*****************************************************************************
2178 * Name : BOOL GetThreadTimes
2179 * Purpose : The GetThreadTimes function obtains timing information about a specified thread.
2180 * Parameters: HANDLE hThread specifies the thread of interest
2181 * LPFILETIME lpCreationTime when the thread was created
2182 * LPFILETIME lpExitTime when the thread exited
2183 * LPFILETIME lpKernelTime time the thread has spent in kernel mode
2184 * LPFILETIME lpUserTime time the thread has spent in user mode
2185 * Variables :
2186 * Result : TRUE / FALSE
2187 * Remark :
2188 * Status : UNTESTED STUB
2189 *
2190 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2191 *****************************************************************************/
2192
2193BOOL WIN32API GetThreadTimes(HANDLE hThread,
2194 LPFILETIME lpCreationTime,
2195 LPFILETIME lpExitTime,
2196 LPFILETIME lpKernelTime,
2197 LPFILETIME lpUserTime)
2198{
2199 dprintf(("Kernel32: GetThreadTimes(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2200 hThread,
2201 lpCreationTime,
2202 lpExitTime,
2203 lpKernelTime,
2204 lpUserTime));
2205
2206 return (FALSE);
2207}
2208
2209
2210
2211/*****************************************************************************
2212 * Name : BOOL PostQueuedCompletionStatus
2213 * Purpose : The PostQueuedCompletionStatus function lets you post an I/O
2214 * completion packet to an I/O completion port. The I/O completion
2215 * packet will satisfy an outstanding call to the GetQueuedCompletionStatus
2216 * function. The GetQueuedCompletionStatus function returns with the three
2217 * values passed as the second, third, and fourth parameters of the call
2218 * to PostQueuedCompletionStatus.
2219 * Parameters: HANDLE CompletionPort handle to an I/O completion port
2220 * DWORD dwNumberOfBytesTransferred
2221 * DWORD dwCompletionKey
2222 * LPOVERLAPPED lpOverlapped
2223 * Variables :
2224 * Result : TRUE / FALSE
2225 * Remark :
2226 * Status : UNTESTED STUB
2227 *
2228 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2229 *****************************************************************************/
2230
2231BOOL WIN32API PostQueuedCompletionStatus(HANDLE CompletionPort,
2232 DWORD dwNumberOfBytesTransferred,
2233 DWORD dwCompletionKey,
2234 LPOVERLAPPED lpOverlapped)
2235{
2236 dprintf(("Kernel32: PostQueuedCompletionStatus(%08xh,%08xh,%08xh,%08xh) not implemented.",
2237 CompletionPort,
2238 dwNumberOfBytesTransferred,
2239 dwCompletionKey,
2240 lpOverlapped));
2241
2242 return (FALSE);
2243}
2244
2245
2246/*****************************************************************************
2247 * Name : DWORD PrepareTape
2248 * Purpose : The PrepareTape function prepares the tape to be accessed or removed.
2249 * Parameters: HANDLE hDevice handle of open device
2250 * DWORD dwOperation preparation method
2251 * BOOL bImmediate return after operation begins
2252 * Variables :
2253 * Result : API returncode
2254 * Remark :
2255 * Status : UNTESTED STUB
2256 *
2257 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2258 *****************************************************************************/
2259
2260DWORD WIN32API PrepareTape(HANDLE hDevice,
2261 DWORD dwOperation,
2262 BOOL bImmediate)
2263{
2264 dprintf(("Kernel32: PrepareTape(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2265 hDevice,
2266 dwOperation,
2267 bImmediate));
2268
2269 return (ERROR_NOT_SUPPORTED);
2270}
2271
2272
2273/*****************************************************************************
2274 * Name : DWORD QueryDosDeviceA
2275 * Purpose : The QueryDosDevice function lets an application obtain information
2276 * about MS-DOS device names. The function can obtain the current
2277 * mapping for a particular MS-DOS device name. The function can also
2278 * obtain a list of all existing MS-DOS device names.
2279 * MS-DOS device names are stored as symbolic links in the Windows NT
2280 * object name space. The code that converts an MS-DOS path into a
2281 * corresponding Windows NT path uses these symbolic links to map
2282 * MS-DOS devices and drive letters. The QueryDosDevice function
2283 * provides a mechanism whereby a Win32-based application can query
2284 * the names of the symbolic links used to implement the MS-DOS device
2285 * namespace as well as the value of each specific symbolic link.
2286 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
2287 * LPTSTR lpTargetPath ddress of buffer for storing query results
2288 * DWORD ucchMax maximum storage capacity of buffer
2289 * Variables :
2290 * Result : pointer to lpTargetPath
2291 * Remark :
2292 * Status : UNTESTED STUB
2293 *
2294 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2295 *****************************************************************************/
2296
2297DWORD WIN32API QueryDosDeviceA(LPCTSTR lpDeviceName,
2298 LPTSTR lpTargetPath,
2299 DWORD ucchMax)
2300{
2301 dprintf(("Kernel32: QueryDosDeviceA(%s,%08xh,%08xh) not implemented.\n",
2302 lpDeviceName,
2303 lpTargetPath,
2304 ucchMax));
2305
2306 return (0);
2307}
2308
2309
2310/*****************************************************************************
2311 * Name : DWORD QueryDosDeviceW
2312 * Purpose : The QueryDosDevice function lets an application obtain information
2313 * about MS-DOS device names. The function can obtain the current
2314 * mapping for a particular MS-DOS device name. The function can also
2315 * obtain a list of all existing MS-DOS device names.
2316 * MS-DOS device names are stored as symbolic links in the Windows NT
2317 * object name space. The code that converts an MS-DOS path into a
2318 * corresponding Windows NT path uses these symbolic links to map
2319 * MS-DOS devices and drive letters. The QueryDosDevice function
2320 * provides a mechanism whereby a Win32-based application can query
2321 * the names of the symbolic links used to implement the MS-DOS device
2322 * namespace as well as the value of each specific symbolic link.
2323 * Parameters: LPCTSTR lpDeviceName address of MS-DOS device name string
2324 * LPTSTR lpTargetPath ddress of buffer for storing query results
2325 * DWORD ucchMax maximum storage capacity of buffer
2326 * Variables :
2327 * Result : pointer to lpTargetPath
2328 * Remark :
2329 * Status : UNTESTED STUB
2330 *
2331 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2332 *****************************************************************************/
2333
2334DWORD WIN32API QueryDosDeviceW(LPCWSTR lpDeviceName,
2335 LPWSTR lpTargetPath,
2336 DWORD ucchMax)
2337{
2338 dprintf(("Kernel32: QueryDosDeviceW(%s,%08xh,%08xh) not implemented.\n",
2339 lpDeviceName,
2340 lpTargetPath,
2341 ucchMax));
2342
2343 return (0);
2344}
2345
2346
2347/*****************************************************************************
2348 * Name : DWORD ReadProcessMemory
2349 * Purpose : The ReadProcessMemory function reads memory in a specified process.
2350 * The entire area to be read must be accessible, or the operation fails.
2351 * Parameters: HANDLE hProcess handle of the process whose memory is read
2352 * LPCVOID lpBaseAddress address to start reading
2353 * LPVOID lpBuffer address of buffer to place read data
2354 * DWORD cbRead number of bytes to read
2355 * LPDWORD lpNumberOfBytesRead address of number of bytes read
2356 * Variables :
2357 * Result : TRUE / FALSE
2358 * Remark :
2359 * Status : UNTESTED STUB
2360 *
2361 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2362 *****************************************************************************/
2363
2364DWORD WIN32API ReadProcessMemory(HANDLE hProcess,
2365 LPCVOID lpBaseAddress,
2366 LPVOID lpBuffer,
2367 DWORD cbRead,
2368 LPDWORD lpNumberOfBytesRead)
2369{
2370 dprintf(("Kernel32: ReadProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2371 hProcess,
2372 lpBaseAddress,
2373 lpBuffer,
2374 cbRead,
2375 lpNumberOfBytesRead));
2376 // FIXME: check this, if we ever run win32 binaries in different addressspaces
2377 // ... and add a sizecheck
2378 memcpy(lpBuffer,lpBaseAddress,cbRead);
2379 if (lpNumberOfBytesRead) *lpNumberOfBytesRead = cbRead;
2380 return TRUE;
2381}
2382
2383/*****************************************************************************
2384 * Name : DWORD WriteProcessMemory
2385 * Purpose : The WriteProcessMemory function writes memory in a specified
2386 * process. The entire area to be written to must be accessible,
2387 * or the operation fails.
2388 * Parameters: HANDLE hProcess handle of process whose memory is written to
2389 * LPVOID lpBaseAddress address to start writing to
2390 * LPVOID lpBuffer address of buffer to write data to
2391 * DWORD cbWrite number of bytes to write
2392 * LPDWORD lpNumberOfBytesWritten actual number of bytes written
2393 * Variables :
2394 * Result : TRUE / FALSE
2395 * Remark :
2396 * Status : UNTESTED STUB
2397 *
2398 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2399 *****************************************************************************/
2400
2401DWORD WIN32API WriteProcessMemory(HANDLE hProcess,
2402 LPCVOID lpBaseAddress,
2403 LPVOID lpBuffer,
2404 DWORD cbWrite,
2405 LPDWORD lpNumberOfBytesWritten)
2406{
2407 dprintf(("Kernel32: WriteProcessMemory(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2408 hProcess,
2409 lpBaseAddress,
2410 lpBuffer,
2411 cbWrite,
2412 lpNumberOfBytesWritten));
2413
2414 // FIXME: check this, if we ever run win32 binaries in different addressspaces
2415 // ... and add a sizecheck
2416 memcpy((void*)lpBaseAddress,lpBuffer,cbWrite);
2417 if (lpNumberOfBytesWritten) *lpNumberOfBytesWritten = cbWrite;
2418 return TRUE;
2419}
2420
2421
2422/*****************************************************************************
2423 * Name : BOOL SetComputerNameA
2424 * Purpose : The SetComputerNameA function sets the computer name to be used
2425 * the next time the system is restarted.
2426 * Parameters: LPCTSTR lpszName address of new computer name
2427 * Variables :
2428 * Result : TRUE / FALSE
2429 * Remark :
2430 * Status : UNTESTED STUB
2431 *
2432 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2433 *****************************************************************************/
2434
2435BOOL WIN32API SetComputerNameA(LPCTSTR lpszName)
2436{
2437 dprintf(("Kernel32: SetComputerNameA(%s) not implemented.\n",
2438 lpszName));
2439
2440 return (FALSE);
2441}
2442
2443
2444/*****************************************************************************
2445 * Name : BOOL SetComputerNameW
2446 * Purpose : The SetComputerNameW function sets the computer name to be used
2447 * the next time the system is restarted.
2448 * Parameters: LPCTSTR lpszName address of new computer name
2449 * Variables :
2450 * Result : TRUE / FALSE
2451 * Remark :
2452 * Status : UNTESTED STUB
2453 *
2454 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2455 *****************************************************************************/
2456
2457BOOL WIN32API SetComputerNameW(LPCWSTR lpszName)
2458{
2459 dprintf(("Kernel32: SetComputerNameW(%s) not implemented.\n",
2460 lpszName));
2461
2462 return (FALSE);
2463}
2464
2465
2466/*****************************************************************************
2467 * Name : VOID SetFileApisToOEM
2468 * Purpose : The SetFileApisToOEM function causes a set of Win32 file functions
2469 * to use the OEM character set code page. This function is useful
2470 * for 8-bit console input and output operations.
2471 * Parameters: VOID
2472 * Variables :
2473 * Result :
2474 * Remark :
2475 * Status : UNTESTED STUB
2476 *
2477 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2478 *****************************************************************************/
2479
2480VOID WIN32API SetFileApisToOEM(VOID)
2481{
2482 dprintf(("Kernel32: SetFileApisToOEM() not implemented.\n"));
2483}
2484
2485
2486/*****************************************************************************
2487 * Name : BOOL SetHandleInformation
2488 * Purpose : The SetHandleInformation function sets certain properties of an
2489 * object handle. The information is specified as a set of bit flags.
2490 * Parameters: HANDLE hObject handle to an object
2491 * DWORD dwMask specifies flags to change
2492 * DWORD dwFlags specifies new values for flags
2493 * Variables :
2494 * Result : TRUE / FALSE
2495 * Remark :
2496 * Status : UNTESTED STUB
2497 *
2498 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2499 *****************************************************************************/
2500
2501BOOL WIN32API SetHandleInformation(HANDLE hObject,
2502 DWORD dwMask,
2503 DWORD dwFlags)
2504{
2505 dprintf(("KERNEL32: SetHandleInformation(%08xh,%08xh,%08xh) not implemented.\n",
2506 hObject,
2507 dwMask,
2508 dwFlags));
2509
2510 return (FALSE);
2511}
2512
2513
2514/*****************************************************************************
2515 * Name : BOOL SetMailslotInfo
2516 * Purpose : The SetMailslotInfo function sets the time-out value used by the
2517 * specified mailslot for a read operation.
2518 * Parameters: HANDLE hObject handle to a mailslot object
2519 * DWORD dwReadTimeout read time-out
2520 * Variables :
2521 * Result : TRUE / FALSE
2522 * Remark :
2523 * Status : UNTESTED STUB
2524 *
2525 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2526 *****************************************************************************/
2527
2528BOOL WIN32API SetMailslotInfo(HANDLE hObject,
2529 DWORD dwReadTimeout)
2530{
2531 dprintf(("KERNEL32: SetMailslotInfo(%08xh,%08xh) not implemented.\n",
2532 hObject,
2533 dwReadTimeout));
2534
2535 return (FALSE);
2536}
2537
2538
2539/*****************************************************************************
2540 * Name : BOOL SetNamedPipeHandleState
2541 * Purpose : The SetNamedPipeHandleState function sets the read mode and the
2542 * blocking mode of the specified named pipe. If the specified handle
2543 * is to the client end of a named pipe and if the named pipe server
2544 * process is on a remote computer, the function can also be used to
2545 * control local buffering.
2546 * Parameters: HANDLE hNamedPipe handle of named pipe
2547 * LPDWORD lpdwMode address of new pipe mode
2548 * LPDWORD lpcbMaxCollect address of max. bytes before remote transmission
2549 * LPDWORD lpdwCollectDataTimeout address of max. time before remote transmission
2550 * Variables :
2551 * Result : TRUE / FALSE
2552 * Remark :
2553 * Status : UNTESTED STUB
2554 *
2555 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2556 *****************************************************************************/
2557
2558BOOL WIN32API SetNamedPipeHandleState(HANDLE hNamedPipe,
2559 LPDWORD lpdwMode,
2560 LPDWORD lpcbMaxCollect,
2561 LPDWORD lpdwCollectDataTimeout)
2562{
2563 dprintf(("KERNEL32: SetNamedPipeHandleState(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
2564 hNamedPipe,
2565 lpdwMode,
2566 lpcbMaxCollect,
2567 lpdwCollectDataTimeout));
2568
2569 return (FALSE);
2570}
2571
2572/*****************************************************************************
2573 * Name : BOOL SetSystemPowerState
2574 * Purpose : The SetSystemPowerState function suspends the system by shutting
2575 * power down. Depending on the ForceFlag parameter, the function
2576 * either suspends operation immediately or requests permission from
2577 * all applications and device drivers before doing so.
2578 * Parameters: BOOL fSuspend
2579 * BOOL fForce
2580 * Variables :
2581 * Result : TRUE / FALSE
2582 * Remark :
2583 * Status : UNTESTED STUB
2584 *
2585 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2586 *****************************************************************************/
2587
2588BOOL WIN32API SetSystemPowerState(BOOL fSuspend,
2589 BOOL fForce)
2590{
2591 dprintf(("KERNEL32: SetSystemPowerState(%08xh,%08xh) not implemented.\n",
2592 fSuspend,
2593 fForce));
2594
2595 return (FALSE);
2596}
2597
2598
2599/*****************************************************************************
2600 * Name : BOOL SetSystemTimeAdjustment
2601 * Purpose : The SetSystemTimeAdjustment function tells the system to enable
2602 * or disable periodic time adjustments to its time of day clock.
2603 * Such time adjustments are used to synchronize the time of day
2604 * with some other source of time information. When periodic time
2605 * adjustments are enabled, they are applied at each clock interrupt.
2606 * Parameters: DWORD dwTimeAdjustment
2607 * BOOL bTimeAdjustmentDisabled
2608 * Variables :
2609 * Result : TRUE / FALSE
2610 * Remark :
2611 * Status : UNTESTED STUB
2612 *
2613 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2614 *****************************************************************************/
2615
2616BOOL WIN32API SetSystemTimeAdjustment(DWORD dwTimeAdjustment,
2617 BOOL bTimeAdjustmentDisabled)
2618{
2619 dprintf(("KERNEL32: SetSystemTimeAdjustment(%08xh,%08xh) not implemented.\n",
2620 dwTimeAdjustment,
2621 bTimeAdjustmentDisabled));
2622
2623 return (FALSE);
2624}
2625
2626
2627/*****************************************************************************
2628 * Name : DWORD SetTapeParameters
2629 * Purpose : The SetTapeParameters function either specifies the block size
2630 * of a tape or configures the tape device.
2631 * Parameters: HANDLE hDevice handle of open device
2632 * DWORD dwOperation type of information to set
2633 * LPVOID lpTapeInformation address of buffer with information to set
2634 * Variables :
2635 * Result : API returncode
2636 * Remark :
2637 * Status : UNTESTED STUB
2638 *
2639 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2640 *****************************************************************************/
2641
2642BOOL WIN32API SetTapeParameters(HANDLE hDevice,
2643 DWORD dwOperation,
2644 LPVOID lpTapeInformation)
2645{
2646 dprintf(("KERNEL32: SetTapeParameters(%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2647 hDevice,
2648 dwOperation,
2649 lpTapeInformation));
2650
2651 return (ERROR_NOT_SUPPORTED);
2652}
2653
2654
2655/*****************************************************************************
2656 * Name : DWORD SetTapePosition
2657 * Purpose : The SetTapePosition sets the tape position on the specified device.
2658 * Parameters: HANDLE hDevice handle of open device
2659 * DWORD dwPositionMethod type of positioning to perform
2660 * DWORD dwPartition new tape partition
2661 * DWORD dwOffsetLow low-order 32 bits of tape position
2662 * DWORD dwOffsetHigh high-order 32 bits of tape position
2663 * BOOL bImmediate return after operation begins
2664 * Variables :
2665 * Result : API returncode
2666 * Remark :
2667 * Status : UNTESTED STUB
2668 *
2669 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2670 *****************************************************************************/
2671
2672BOOL WIN32API SetTapePosition(HANDLE hDevice,
2673 DWORD dwPositionMethod,
2674 DWORD dwPartition,
2675 DWORD dwOffsetLow,
2676 DWORD dwOffsetHigh,
2677 BOOL bImmediate)
2678{
2679 dprintf(("KERNEL32: SetTapePosition(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2680 hDevice,
2681 dwPositionMethod,
2682 dwPartition,
2683 dwOffsetLow,
2684 dwOffsetHigh,
2685 bImmediate));
2686
2687 return (ERROR_NOT_SUPPORTED);
2688}
2689
2690
2691/*****************************************************************************
2692 * Name : DWORD SetThreadAffinityMask
2693 * Purpose : The SetThreadAffinityMask function sets a processor affinity
2694 * mask for a specified thread.
2695 * A thread affinity mask is a bit vector in which each bit
2696 * represents the processors that a thread is allowed to run on.
2697 * A thread affinity mask must be a proper subset of the process
2698 * affinity mask for the containing process of a thread. A thread
2699 * is only allowed to run on the processors its process is allowed to run on.
2700 * Parameters: HANDLE hThread handle to the thread of interest
2701 * DWORD dwThreadAffinityMask a thread affinity mask
2702 * Variables :
2703 * Result : TRUE / FALSE
2704 * Remark :
2705 * Status : UNTESTED STUB
2706 *
2707 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2708 *****************************************************************************/
2709
2710DWORD WIN32API SetThreadAffinityMask(HANDLE hThread,
2711 DWORD dwThreadAffinityMask)
2712{
2713 dprintf(("KERNEL32: SetThreadAffinityMask(%08xh,%08xh) not implemented.\n",
2714 hThread,
2715 dwThreadAffinityMask));
2716
2717 return (0);
2718}
2719
2720
2721/*****************************************************************************
2722 * Name : DWORD TransactNamedPipe
2723 * Purpose : The TransactNamedPipe function combines into a single network
2724 * operation the functions that write a message to and read a
2725 * message from the specified named pipe.
2726 * Parameters: HANDLE hNamedPipe handle of named pipe
2727 * LPVOID lpvWriteBuf address of write buffer
2728 * DWORD cbWriteBuf size of the write buffer, in bytes
2729 * LPVOID lpvReadBuf address of read buffer
2730 * DWORD cbReadBuf size of read buffer, in bytes
2731 * LPDWORD lpcbRead address of variable for bytes actually read
2732 * LPOVERLAPPED lpo address of overlapped structure
2733 * Variables :
2734 * Result : TRUE / FALSE
2735 * Remark :
2736 * Status : UNTESTED STUB
2737 *
2738 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2739 *****************************************************************************/
2740
2741DWORD WIN32API TransactNamedPipe(HANDLE hNamedPipe,
2742 LPVOID lpvWriteBuf,
2743 DWORD cbWriteBuf,
2744 LPVOID lpvReadBuf,
2745 DWORD cbReadBuf,
2746 LPDWORD lpcbRead,
2747 LPOVERLAPPED lpo)
2748{
2749 dprintf(("KERNEL32: TransactNamedPipe(%08x,%08x,%08x,%08x,%08x,%08x,%08x) not implemented.\n",
2750 hNamedPipe,
2751 lpvWriteBuf,
2752 cbWriteBuf,
2753 lpvReadBuf,
2754 cbReadBuf,
2755 lpcbRead,
2756 lpo));
2757
2758 return (FALSE);
2759}
2760
2761
2762/*****************************************************************************
2763 * Name : BOOL UpdateResourceA
2764 * Purpose : The UpdateResourceA function adds, deletes, or replaces a resource
2765 * in an executable file.
2766 * Parameters: HANDLE hUpdateFile update-file handle
2767 * LPCTSTR lpszType address of resource type to update
2768 * LPCTSTR lpszName address of resource name to update
2769 * WORD IDLanguage language identifier of resource
2770 * LPVOID lpvData address of resource data
2771 * DWORD cbData length of resource data, in bytes
2772 * Variables :
2773 * Result : TRUE / FALSE
2774 * Remark :
2775 * Status : UNTESTED STUB
2776 *
2777 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2778 *****************************************************************************/
2779
2780BOOL WIN32API UpdateResourceA(HANDLE hUpdateFile,
2781 LPCTSTR lpszType,
2782 LPCTSTR lpszName,
2783 WORD IDLanguage,
2784 LPVOID lpvData,
2785 DWORD cbData)
2786{
2787 dprintf(("KERNEL32: UpdateResourceA(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2788 hUpdateFile,
2789 lpszType,
2790 lpszName,
2791 IDLanguage,
2792 lpvData,
2793 cbData));
2794
2795 return (FALSE);
2796}
2797
2798
2799/*****************************************************************************
2800 * Name : BOOL UpdateResourceW
2801 * Purpose : The UpdateResourceW function adds, deletes, or replaces a resource
2802 * in an executable file.
2803 * Parameters: HANDLE hUpdateFile update-file handle
2804 * LPCTSTR lpszType address of resource type to update
2805 * LPCTSTR lpszName address of resource name to update
2806 * WORD IDLanguage language identifier of resource
2807 * LPVOID lpvData address of resource data
2808 * DWORD cbData length of resource data, in bytes
2809 * Variables :
2810 * Result : TRUE / FALSE
2811 * Remark :
2812 * Status : UNTESTED STUB
2813 *
2814 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2815 *****************************************************************************/
2816
2817BOOL WIN32API UpdateResourceW(HANDLE hUpdateFile,
2818 LPCWSTR lpszType,
2819 LPCWSTR lpszName,
2820 WORD IDLanguage,
2821 LPVOID lpvData,
2822 DWORD cbData)
2823{
2824 dprintf(("KERNEL32: UpdateResourceW(%08xh,%s,%s,%08xh,%08xh,%08xh) not implemented.\n",
2825 hUpdateFile,
2826 lpszType,
2827 lpszName,
2828 IDLanguage,
2829 lpvData,
2830 cbData));
2831
2832 return (FALSE);
2833}
2834
2835/*****************************************************************************
2836 * Name : BOOL WaitNamedPipeA
2837 * Purpose : The WaitNamedPipe function waits until either a time-out interval
2838 * elapses or an instance of the specified named pipe is available
2839 * to be connected to (that is, the pipe's server process has a
2840 * pending ConnectNamedPipe operation on the pipe).
2841 * Parameters: LPCTSTR lpszNamedPipeName
2842 * DWORD dwTimeout
2843 * Variables :
2844 * Result : TRUE / FALSE
2845 * Remark :
2846 * Status : UNTESTED STUB
2847 *
2848 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2849 *****************************************************************************/
2850
2851BOOL WIN32API WaitNamedPipeA(LPCTSTR lpszNamedPipeName,
2852 DWORD dwTimeout)
2853{
2854 dprintf(("KERNEL32: WaitNamedPipeA(%s, %u) not implemented.\n",
2855 lpszNamedPipeName,
2856 dwTimeout));
2857
2858 return (FALSE);
2859}
2860
2861
2862/*****************************************************************************
2863 * Name : BOOL WaitNamedPipeW
2864 * Purpose : The WaitNamedPipe function waits until either a time-out interval
2865 * elapses or an instance of the specified named pipe is available
2866 * to be connected to (that is, the pipe's server process has a
2867 * pending ConnectNamedPipe operation on the pipe).
2868 * Parameters: LPCWSTR lpszNamedPipeName
2869 * DWORD dwTimeout
2870 * Variables :
2871 * Result : TRUE / FALSE
2872 * Remark :
2873 * Status : UNTESTED STUB
2874 *
2875 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2876 *****************************************************************************/
2877
2878BOOL WIN32API WaitNamedPipeW(LPCWSTR lpszNamedPipeName,
2879 DWORD dwTimeout)
2880{
2881 dprintf(("KERNEL32: WaitNamedPipeW(%s, %u) not implemented.\n",
2882 lpszNamedPipeName,
2883 dwTimeout));
2884
2885 return (FALSE);
2886}
2887
2888
2889
2890
2891/*****************************************************************************
2892 * Name : BOOL WriteTapemark
2893 * Purpose : The WriteTapemark function writes a specified number of filemarks,
2894 * setmarks, short filemarks, or long filemarks to a tape device.
2895 * These tapemarks divide a tape partition into smaller areas.
2896 * Parameters: HANDLE hDevice handle of open device
2897 * DWORD dwTapemarkType type of tapemarks to write
2898 * DWORD dwTapemarkCount number of tapemarks to write
2899 * BOOL bImmediate return after write begins
2900 * Variables :
2901 * Result : API returncode
2902 * Remark :
2903 * Status : UNTESTED STUB
2904 *
2905 * Author : Patrick Haller [Mon, 1998/06/15 08:00]
2906 *****************************************************************************/
2907
2908DWORD WIN32API WriteTapemark(HANDLE hDevice,
2909 DWORD dwTapemarkType,
2910 DWORD dwTapemarkCount,
2911 BOOL bImmediate)
2912{
2913 dprintf(("KERNEL32: WriteTapemark(%08xh,%08xh,%08xh,%08xh) not implemented - ERROR_NOT_SUPPORTED.\n",
2914 hDevice,
2915 dwTapemarkType,
2916 dwTapemarkCount,
2917 bImmediate));
2918
2919 return (ERROR_NOT_SUPPORTED);
2920}
2921
2922
2923/*****************************************************************************
2924 * Name : DWORD CmdBatNotification
2925 * Purpose : Unknown, used by /winnt/cmd.exe
2926 * Parameters: Unknown (wrong)
2927 * Variables :
2928 * Result : Unknown
2929 * Remark :
2930 * Status : UNTESTED STUB
2931 *
2932 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
2933 *****************************************************************************/
2934
2935DWORD WIN32API CmdBatNotification(DWORD x1)
2936{
2937 dprintf(("KERNEL32: CmdBatNotification(%08xh) not implemented\n",
2938 x1));
2939
2940 return (0);
2941}
2942
2943
2944/*****************************************************************************
2945 * Name : DWORD GetVDMCurrentDirectories
2946 * Purpose : Unknown, used by /winnt/cmd.exe
2947 * Parameters: Unknown (wrong)
2948 * Variables :
2949 * Result : Unknown
2950 * Remark :
2951 * Status : UNTESTED STUB
2952 *
2953 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
2954 *****************************************************************************/
2955
2956DWORD WIN32API GetVDMCurrentDirectories(DWORD x1)
2957{
2958 dprintf(("KERNEL32: GetVDMCurrentDirectories(%08xh) not implemented\n",
2959 x1));
2960
2961 return (0);
2962}
2963
2964
2965/*****************************************************************************
2966 * Name : DWORD SetThreadPriorityBoost
2967 * Purpose : Unknown
2968 * Parameters: Unknown (wrong)
2969 * Variables :
2970 * Result : Unknown
2971 * Remark :
2972 * Status : UNTESTED STUB
2973 *
2974 * Author : Patrick Haller [Tue, 1999/06/08 21:44]
2975 *****************************************************************************/
2976
2977DWORD WIN32API SetThreadPriorityBoost(DWORD x1,
2978 DWORD x2)
2979{
2980 dprintf(("KERNEL32: SetThreadPriorityBoost(%08xh, %08xh) not implemented\n",
2981 x1,
2982 x2));
2983
2984 return (0);
2985}
2986
2987
Note: See TracBrowser for help on using the repository browser.