![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pdc.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / pdc|
Return to pdc.h CVS log | Up to [WindowsNT SDKs] / mstools / samples / pdc |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 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 struct _WORK_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:
263: typedef struct _WORK_QUEUE_ITEM {
264: LIST_ENTRY List;
265: DWORD Reason;
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: PWORK_QUEUE WorkQueue;
352: DWORD TlsIndex;
353: INT NumberOfWorkerThreads;
354: BOOL Verbose;
355: BOOL IgnoreCase;
356: BOOL MappedFileIO;
357: BOOL ASyncIO;
358: BOOL SyncIO;
359: LPSTR DirectoryPath;
360: LPSTR SearchString;
361: DWORD SearchStringLength;
362: DWORD SearchedFileCount;
363: DWORD MatchedFileCount;
364: DWORD MatchedLineCount;
365: DWORD OutstandingIOOperations;
366: HANDLE IoCompletedEvent;
367:
368: typedef
369: int
370: (*PCOMPARE_ROUTINE)(
371: IN const char *,
372: IN const char *,
373: IN size_t
374: );
375:
376: PCOMPARE_ROUTINE SearchFunction;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.