home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / winbase / io / asyncio / pdc.h < prev    next >
C/C++ Source or Header  |  1997-10-05  |  7KB  |  376 lines
  1. /*++
  2.  
  3. Copyright (c) 1992-1997 Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     pdc.h
  8.  
  9. Abstract:
  10.  
  11.     This is the main source file for the Windows/NT PDC API demonstration
  12.     program.  This include file defines macros, data structures and procedure
  13.     prototypes for the code contained in the PDC.C source file.
  14.  
  15. --*/
  16.  
  17. //
  18. // Include file for using the Win32 API
  19. //
  20.  
  21. #include <windows.h>
  22.  
  23. //
  24. // C Runtime include files used by the program.
  25. //
  26.  
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <errno.h>
  30. #include <ctype.h>
  31. #include <string.h>
  32. #include <io.h>
  33. #include <fcntl.h>
  34. #include <malloc.h>
  35. #include <sys\types.h>
  36. #include <sys\stat.h>
  37.  
  38.  
  39. //
  40. // Macro definitions
  41. //
  42.  
  43. //
  44. // Useful rounding macros that the rounding amount is always a
  45. // power of two.
  46. //
  47.  
  48. #define ROUND_DOWN( Size, Amount ) ((DWORD)(Size) & ~((Amount) - 1))
  49. #define ROUND_UP( Size, Amount ) (((DWORD)(Size) + ((Amount) - 1)) & ~((Amount) - 1))
  50.  
  51. //
  52. // Pseudo keywords for documentation purposes.
  53. //
  54.  
  55. #define IN
  56. #define OUT
  57. #define OPTIONAL
  58.  
  59. //
  60. // Determine if an argument is present by testing a value of NULL
  61. //
  62.  
  63. #define ARGUMENT_PRESENT( ArgumentPointer )    (\
  64.     (LPSTR)(ArgumentPointer) != (LPSTR)(NULL) )
  65.  
  66.  
  67.  
  68. //
  69. // Calculate the address of the base of the structure given its type, and an
  70. // address of a field within the structure.
  71. //
  72.  
  73. #define CONTAINING_RECORD( address, type, field ) ((type *)( \
  74.                                                    (PCHAR)(address) - \
  75.                                                    (PCHAR)(&((type *)0)->field)))
  76.  
  77.  
  78. //
  79. // Virtual Buffer data structure and function prototypes.
  80. //
  81.  
  82. typedef struct _VIRTUAL_BUFFER {
  83.     LPVOID Base;
  84.     ULONG PageSize;
  85.     LPVOID CommitLimit;
  86.     LPVOID ReserveLimit;
  87. } VIRTUAL_BUFFER, *PVIRTUAL_BUFFER;
  88.  
  89. BOOL
  90. CreateVirtualBuffer(
  91.     OUT PVIRTUAL_BUFFER Buffer,
  92.     IN DWORD CommitSize,
  93.     IN DWORD ReserveSize OPTIONAL
  94.     );
  95.  
  96. BOOL
  97. ExtendVirtualBuffer(
  98.     IN PVIRTUAL_BUFFER Buffer,
  99.     IN LPVOID Address
  100.     );
  101.  
  102. BOOL
  103. TrimVirtualBuffer(
  104.     IN PVIRTUAL_BUFFER Buffer
  105.     );
  106.  
  107. BOOL
  108. FreeVirtualBuffer(
  109.     IN PVIRTUAL_BUFFER Buffer
  110.     );
  111.  
  112. int
  113. VirtualBufferExceptionFilter(
  114.     IN DWORD ExceptionCode,
  115.     IN PEXCEPTION_POINTERS ExceptionInfo,
  116.     IN OUT PVIRTUAL_BUFFER Buffer
  117.     );
  118.  
  119.  
  120. //
  121. // Directory enumeration and file notification definitions.
  122. //
  123.  
  124. typedef
  125. VOID (*PDIRECTORY_ENUMERATE_ROUTINE)(
  126.     LPSTR Path,
  127.     PWIN32_FIND_DATA FindFileData,
  128.     PVOID EnumerateParameter
  129.     );
  130.  
  131. BOOL
  132. EnumerateDirectoryTree(
  133.     LPSTR DirectoryPath,
  134.     PDIRECTORY_ENUMERATE_ROUTINE EnumerateRoutine,
  135.     PVOID EnumerateParameter
  136.     );
  137.  
  138. //
  139. // Data structures private to the EnumerateDirectoryTree function.
  140. //
  141.  
  142. typedef struct _ENUMERATE_DIRECTORY_STACK {
  143.     LPSTR PathEnd;
  144.     HANDLE FindHandle;
  145. } ENUMERATE_DIRECTORY_STACK, *PENUMERATE_DIRECTORY_STACK;
  146.  
  147. #define MAX_DEPTH 256
  148.  
  149. typedef struct _ENUMERATE_DIRECTORY_STATE {
  150.     DWORD Depth;
  151.     ENUMERATE_DIRECTORY_STACK Stack[ MAX_DEPTH ];
  152.     CHAR Path[ MAX_PATH ];
  153. } ENUMERATE_DIRECTORY_STATE, *PENUMERATE_DIRECTORY_STATE;
  154.  
  155.  
  156.  
  157. //
  158. //  Doubly-linked list manipulation routines.  Implemented as macros
  159. //  but logically these are procedures.
  160. //
  161.  
  162. //
  163. //  VOID
  164. //  InitializeListHead(
  165. //      PLIST_ENTRY ListHead
  166. //      );
  167. //
  168.  
  169. #define InitializeListHead(ListHead) (\
  170.     (ListHead)->Flink = (ListHead)->Blink = (ListHead) )
  171.  
  172. //
  173. //  BOOLEAN
  174. //  IsListEmpty(
  175. //      PLIST_ENTRY ListHead
  176. //      );
  177. //
  178.  
  179. #define IsListEmpty(ListHead) (\
  180.     ( ((ListHead)->Flink == (ListHead)) ? TRUE : FALSE ) )
  181.  
  182. //
  183. //  PLIST_ENTRY
  184. //  RemoveHeadList(
  185. //      PLIST_ENTRY ListHead
  186. //      );
  187. //
  188.  
  189. #define RemoveHeadList(ListHead) \
  190.     (ListHead)->Flink;\
  191.     {\
  192.         PLIST_ENTRY FirstEntry;\
  193.         FirstEntry = (ListHead)->Flink;\
  194.         FirstEntry->Flink->Blink = (ListHead);\
  195.         (ListHead)->Flink = FirstEntry->Flink;\
  196.     }
  197.  
  198. //
  199. //  VOID
  200. //  RemoveEntryList(
  201. //      PLIST_ENTRY Entry
  202. //      );
  203. //
  204.  
  205. #define RemoveEntryList(Entry) {\
  206.         PLIST_ENTRY _EX_Entry;\
  207.         _EX_Entry = (Entry);\
  208.         _EX_Entry->Blink->Flink = _EX_Entry->Flink;\
  209.         _EX_Entry->Flink->Blink = _EX_Entry->Blink;\
  210.         }
  211.  
  212. //
  213. //  VOID
  214. //  InsertTailList(
  215. //      PLIST_ENTRY ListHead,
  216. //      PLIST_ENTRY Entry
  217. //      );
  218. //
  219.  
  220. #define InsertTailList(ListHead,Entry) \
  221.     (Entry)->Flink = (ListHead);\
  222.     (Entry)->Blink = (ListHead)->Blink;\
  223.     (ListHead)->Blink->Flink = (Entry);\
  224.     (ListHead)->Blink = (Entry)
  225.  
  226. //
  227. //  VOID
  228. //  InsertHeadList(
  229. //      PLIST_ENTRY ListHead,
  230. //      PLIST_ENTRY Entry
  231. //      );
  232. //
  233.  
  234. #define InsertHeadList(ListHead,Entry) \
  235.     (Entry)->Flink = (ListHead)->Flink;\
  236.     (Entry)->Blink = (ListHead);\
  237.     (ListHead)->Flink->Blink = (Entry);\
  238.     (ListHead)->Flink = (Entry)
  239.  
  240.  
  241.  
  242. //
  243. // Worker thread definitions
  244. //
  245.  
  246. typedef
  247. VOID
  248. (*PWORKER_ROUTINE)(
  249.   //  IN PWORK_QUEUE_ITEM WorkItem
  250.     );
  251.  
  252. typedef struct _WORK_QUEUE {
  253.     CRITICAL_SECTION CriticalSection;
  254.     HANDLE Semaphore;
  255.     LIST_ENTRY Queue;
  256.     BOOL Terminating;
  257.     PWORKER_ROUTINE WorkerRoutine;
  258.     DWORD NumberOfWorkerThreads;
  259.     HANDLE WorkerThreads[ 1 ];      // Variable length array
  260. } WORK_QUEUE, *PWORK_QUEUE;
  261.  
  262. typedef struct _WORK_QUEUE_ITEM {
  263.     LIST_ENTRY List;
  264.     DWORD Reason;
  265.     PWORK_QUEUE WorkQueue;
  266. } WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM;
  267.  
  268. #define WORK_INITIALIZE_ITEM 0
  269. #define WORK_ITEM            1
  270. #define WORK_TERMINATE_ITEM  2
  271.  
  272. DWORD
  273. WorkerThread(
  274.     LPVOID lpThreadParameter
  275.     );
  276.  
  277. PWORK_QUEUE
  278. CreateWorkQueue(
  279.     IN DWORD NumberOfWorkerThreads,
  280.     IN PWORKER_ROUTINE WorkerRoutine
  281.     );
  282.  
  283. BOOL
  284. QueueWorkItem(
  285.     IN OUT PWORK_QUEUE WorkQueue,
  286.     IN PWORK_QUEUE_ITEM WorkItem
  287.     );
  288.  
  289. VOID
  290. DestroyWorkQueue(
  291.     IN OUT PWORK_QUEUE WorkQueue
  292.     );
  293.  
  294.  
  295. //
  296. // Main procedure prototypes
  297. //
  298.  
  299. BOOL
  300. ProcessCommandLineArguments(
  301.     int argc,
  302.     char *argv[]
  303.     );
  304.  
  305. VOID
  306. QueueSearchFile(
  307.     LPSTR Path,
  308.     PWIN32_FIND_DATA FindFileData,
  309.     PVOID EnumerateParameter
  310.     );
  311.  
  312. typedef struct _SEARCH_REQUEST_STATE {
  313.     VIRTUAL_BUFFER Buffer;
  314.     LPSTR CurrentOutput;
  315. } SEARCH_REQUEST_STATE, *PSEARCH_REQUEST_STATE;
  316.  
  317.  
  318. typedef struct _SEARCH_REQUEST {
  319.     WORK_QUEUE_ITEM WorkItem;
  320.     DWORD FileSize;
  321.     LPSTR FileData;
  322.     HANDLE File;
  323.     OVERLAPPED OverlappedIO;
  324.     CHAR FullPathName[ 1 ];         // Variable length array
  325. } SEARCH_REQUEST, *PSEARCH_REQUEST;
  326.  
  327.  
  328. VOID
  329. ProcessRequest(
  330.     IN PWORK_QUEUE_ITEM WorkItem
  331.     );
  332.  
  333. VOID
  334. ProcessReadFileCompletion(
  335.     DWORD dwErrorCode,
  336.     DWORD dwNumberOfBytesTransfered,
  337.     LPOVERLAPPED lpOverlapped
  338.     );
  339.  
  340. VOID
  341. ProcessSearchFile(
  342.     IN PSEARCH_REQUEST WorkerRequest,
  343.     IN PSEARCH_REQUEST_STATE State
  344.     );
  345.  
  346.  
  347. //
  348. // Global variables
  349. //
  350.  
  351. DWORD TlsIndex;
  352. INT NumberOfWorkerThreads;
  353. BOOL Verbose;
  354. BOOL IgnoreCase;
  355. BOOL MappedFileIO;
  356. BOOL ASyncIO;
  357. BOOL SyncIO;
  358. LPSTR DirectoryPath;
  359. LPSTR SearchString;
  360. DWORD SearchStringLength;
  361. DWORD SearchedFileCount;
  362. DWORD MatchedFileCount;
  363. DWORD MatchedLineCount;
  364. LONG  OutstandingIOOperations;
  365. HANDLE IoCompletedEvent;
  366.  
  367. typedef
  368. int
  369. (_CRTAPI1 *PCOMPARE_ROUTINE)(
  370.     IN const char *,
  371.     IN const char *,
  372.     IN size_t
  373.     );
  374.  
  375. PCOMPARE_ROUTINE SearchFunction;
  376.