Return to pdc.h CVS log

Up to [WindowsNT SDKs] / mstools / samples / pdc

Annotation of mstools/samples/pdc/pdc.h, revision 1.1

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.