r7051: remove an unused file
authorAndrew Tridgell <tridge@samba.org>
Sat, 28 May 2005 07:41:20 +0000 (07:41 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:17:09 +0000 (13:17 -0500)
source/web_server/ejs/mpr.h [deleted file]

diff --git a/source/web_server/ejs/mpr.h b/source/web_server/ejs/mpr.h
deleted file mode 100644 (file)
index 848518b..0000000
+++ /dev/null
@@ -1,2259 +0,0 @@
-///
-///    @file   mpr.h
-/// @brief     Header for the Mbedthis Portable Runtime (MPR)
-//     @copy   default
-//     
-//     Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
-//     
-//     This software is distributed under commercial and open source licenses.
-//     You may use the GPL open source license described below or you may acquire 
-//     a commercial license from Mbedthis Software. You agree to be fully bound 
-//     by the terms of either license. Consult the LICENSE.TXT distributed with 
-//     this software for full details.
-//     
-//     This software is open source; you can redistribute it and/or modify it 
-//     under the terms of the GNU General Public License as published by the 
-//     Free Software Foundation; either version 2 of the License, or (at your 
-//     option) any later version. See the GNU General Public License for more 
-//     details at: http://www.mbedthis.com/downloads/gplLicense.html
-//     
-//     This program is distributed WITHOUT ANY WARRANTY; without even the 
-//     implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
-//     
-//     This GPL license does NOT permit incorporating this software into 
-//     proprietary programs. If you are unable to comply with the GPL, you must
-//     acquire a commercial license to use this software. Commercial licenses 
-//     for this software and support services are available from Mbedthis 
-//     Software at http://www.mbedthis.com 
-//     
-//     @end
-//////////////////////////////// Documentation /////////////////////////////////
-//
-//     See mpr.dox for additional documentation.
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#error foo
-
-#ifndef _h_MPR
-#define _h_MPR 1
-/////////////////////////////////// Includes ///////////////////////////////////
-
-#include "web_server/ejs/config.h"
-#include "web_server/ejs/mprOs.h"
-
-////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////// C API ////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#ifdef __cplusplus
-extern "C" {
-#else
-typedef int bool;
-#endif
-
-extern void mprBreakpoint(const char *file, int line, const char *msg);
-
-#if BLD_FEATURE_ASSERT
-#define mprAssert(C)  \
-       if (C) ; else mprError(MPR_L, MPR_TRAP, "%s", #C)
-#define inlineAssert(C) \
-       if (C) ; else mprBreakpoint(MPR_L, #C)
-#else
-       #define mprAssert(C)            if (1) ; else
-       #define inlineAssert(C)         if (1) ; else
-#endif
-
-/////////////////////////////////// Constants //////////////////////////////////
-
-#if BLD_FEATURE_SQUEEZE
-///
-///    Maximum length of a file path name. Reduced from the system maximum to 
-///    save memory space.
-///
-#define MPR_MAX_PATH                   256             ///< Reasonable max path name
-#else
-#define MPR_MAX_PATH                   1024
-#endif
-
-#if BLD_FEATURE_SQUEEZE
-///
-///    Reasonable length of a file name used by the product. Use where you know
-///    the expected file name and it is certain to be less than this limit.
-///
-#define MPR_MAX_FNAME                  128                     ///< Reasonable size of a file name
-#define MPR_DEFAULT_ALLOC              64                      // Default small alloc size 
-#define MPR_DEFAULT_HASH_SIZE  23                      // Default size of hash table index 
-#define MPR_DEFAULT_STACK              (32 * 1024)     // Default stack size
-#else
-#define MPR_MAX_FNAME                  256
-#define MPR_DEFAULT_ALLOC              128                     // Default small alloc size 
-#define MPR_DEFAULT_HASH_SIZE  43                      // Default size of hash table index 
-#define MPR_DEFAULT_STACK              (64 * 1024)     // Default stack size
-#endif
-
-#if BLD_FEATURE_SQUEEZE
-#define MPR_MAX_ARGC                   32                      // Reasonable max of args
-#define MPR_MAX_STRING                 512                     // Maximum string size 
-#define MPR_MAX_LOG_STRING             512                     // Maximum log message
-#define MPR_MAX_URL                            256                     ///< Reasonable size of a URL
-#define MPR_BUFSIZE                            512                     ///< Reasonable size for buffers
-//     FUTURE -- could be named better
-#define MPR_MAX_HEAP_SIZE              (32 * 1024)     // Maximum heap allocation size
-#else
-#define MPR_MAX_ARGC                   128                     // Reasonable max of args
-#define MPR_MAX_STRING                 4096            ///< Maximum string size 
-#define MPR_MAX_LOG_STRING             8192            // Maximum log message
-#define MPR_MAX_URL                            1024            ///< Reasonable size of a URL
-#define MPR_BUFSIZE                            1024            // Reasonable size for buffers
-#define MPR_MAX_HEAP_SIZE              (64 * 1024)     // Maximum heap allocation size
-#endif
-
-#define MPR_DEFAULT_BREAK_PORT 9473
-#define MPR_TIMEOUT_LOG_STAMP  3600000         // Time between log time stamps
-#define MPR_TIMEOUT_PRUNER             60000           // Time between pruner runs
-#define MPR_TIMEOUT_STOP_TASK  10000           // Timeout to stop running tasks
-#define MPR_TIMEOUT_STOP_THREAD        10000           // Timeout to stop running threads
-#define MPR_TIMEOUT_CMD_WAIT   50                      // Poll for cmd processes
-#define MPR_TIMEOUT_STOP               5000            // Wait when stopping resources
-#define MPR_NUM_DIALOG                 5                       // Maximum number of user dialogs 
-#define MPR_MAX_LOG_SIZE               5                       // Default size of a log file (MB)
-#define MPR_MAX_IP_NAME                        128                     // Max size of an IP name
-#define MPR_MAX_IP_ADDR                        16                      // Max size of an IP string addr
-#define MPR_MAX_IP_ADDR_PORT   32                      // Max size of IP with port
-
-#define        MPR_TEST_TIMEOUT                10000           // Ten seconds 
-#define MPR_TEST_LONG_TIMEOUT  300000          // 5 minutes 
-#define MPR_TEST_SHORT_TIMEOUT 200                     // 1/5 sec
-#define        MPR_TEST_NAP                    50                      // When we must not block 
-
-#if BLD_FEATURE_MULTITHREAD
-#define MPR_DEFAULT_MIN_THREADS        0                       // Default min threads (0)
-#define MPR_DEFAULT_MAX_THREADS        10                      // Default max threads (10)
-#else
-#define MPR_DEFAULT_MIN_THREADS        0                       // Default min threads
-#define MPR_DEFAULT_MAX_THREADS        0                       // Default max threads 
-#endif
-
-//
-//     MPR priorities (0 to 99)
-//
-#define MPR_BACKGROUND_PRIORITY        15                      // May only get CPU if idle
-#define MPR_LOW_PRIORITY               25
-#define MPR_NORMAL_PRIORITY            50
-#define MPR_HIGH_PRIORITY              75
-#define MPR_CRITICAL_PRIORITY  99                      // May not yield
-
-#define MPR_SELECT_PRIORITY            75                      // Run select at higher priority
-#define MPR_POOL_PRIORITY              50                      // Normal
-
-//
-//     Debug control
-//
-#define MPR_MAX_BLOCKED_LOCKS  100                     // Max threads blocked on lock 
-#define MPR_MAX_RECURSION              15                      // Max recursion with one thread 
-#define MPR_MAX_LOCKS                  512                     // Total lock count max 
-#define MPR_MAX_LOCK_TIME              (60 * 1000)     // Time in millisecs to hold a lock 
-
-//
-//     Service / daemon control
-//
-#define MPR_INSTALL_SERVICE            1
-#define MPR_UNINSTALL_SERVICE  2
-#define MPR_GO_SERVICE                 3
-#define MPR_STOP_SERVICE               4
-
-//
-//     Parameter values for serviceEvents(loopOnce)
-//
-#define MPR_LOOP_ONCE                  1
-#define MPR_LOOP_FOREVER               0
-
-//
-//     Select service flags
-//
-#define MPR_ASYNC_SELECT               0x1             // Using async select in windows
-#define MPR_BREAK_REQUESTED            0x2             // Breakout of a select wait
-#define MPR_WAITING_FOR_SELECT 0x4             // Waiting for select to complete
-
-///////////////////////////////// Error Codes //////////////////////////////////
-
-//
-//     Standard MPR return and error codes 
-//
-
-///    Base error code
-#define MPR_ERR_BASE                                   (-200)                          
-///    General error
-#define MPR_ERR_GENERAL                                        (MPR_ERR_BASE - 1)      
-///    Action aborted
-#define MPR_ERR_ABORTED                                        (MPR_ERR_BASE - 2)      
-///    Item already exists
-#define MPR_ERR_ALREADY_EXISTS                 (MPR_ERR_BASE - 3)      
-///    Bad arguments or paramaeters
-#define MPR_ERR_BAD_ARGS                               (MPR_ERR_BASE - 4)      
-///    Bad input format
-#define MPR_ERR_BAD_FORMAT                             (MPR_ERR_BASE - 5)      
-#define MPR_ERR_BAD_HANDLE                             (MPR_ERR_BASE - 6)      
-///    Module is in a bad state
-#define MPR_ERR_BAD_STATE                              (MPR_ERR_BASE - 7)      
-///    Input has bad syntax
-#define MPR_ERR_BAD_SYNTAX                             (MPR_ERR_BASE - 8)      
-#define MPR_ERR_BAD_TYPE                               (MPR_ERR_BASE - 9)      
-#define MPR_ERR_BAD_VALUE                              (MPR_ERR_BASE - 10)     
-#define MPR_ERR_BUSY                                   (MPR_ERR_BASE - 11)     
-///    Cant access the file or resource
-#define MPR_ERR_CANT_ACCESS                            (MPR_ERR_BASE - 12)     
-#define MPR_ERR_CANT_COMPLETE                  (MPR_ERR_BASE - 13)     
-///    Cant create the file or resource
-#define MPR_ERR_CANT_CREATE                            (MPR_ERR_BASE - 14)     
-#define MPR_ERR_CANT_INITIALIZE                        (MPR_ERR_BASE - 15)     
-///    Cant open the file or resource
-#define MPR_ERR_CANT_OPEN                              (MPR_ERR_BASE - 16)     
-///    Cant read from the file or resource
-#define MPR_ERR_CANT_READ                              (MPR_ERR_BASE - 17)     
-///    Cant write to the file or resource
-#define MPR_ERR_CANT_WRITE                             (MPR_ERR_BASE - 18)     
-#define MPR_ERR_DELETED                                        (MPR_ERR_BASE - 19)     
-#define MPR_ERR_NETWORK                                        (MPR_ERR_BASE - 20)     
-#define MPR_ERR_NOT_FOUND                              (MPR_ERR_BASE - 21)     
-///    Module or resource is not initialized
-#define MPR_ERR_NOT_INITIALIZED                        (MPR_ERR_BASE - 22)     
-#define MPR_ERR_NOT_READY                              (MPR_ERR_BASE - 23)     
-#define MPR_ERR_READ_ONLY                              (MPR_ERR_BASE - 24)     
-///    The operation timed out
-#define MPR_ERR_NOT_INITIALIZED                        (MPR_ERR_BASE - 22)     
-#define MPR_ERR_TIMEOUT                                        (MPR_ERR_BASE - 25)     
-#define MPR_ERR_TOO_MANY                               (MPR_ERR_BASE - 26)     
-#define MPR_ERR_WONT_FIT                               (MPR_ERR_BASE - 27)     
-#define MPR_ERR_WOULD_BLOCK                            (MPR_ERR_BASE - 28)     
-#define MPR_ERR_CANT_ALLOCATE                  (MPR_ERR_BASE - 29)     
-#define MPR_ERR_MAX                                            (MPR_ERR_BASE - 30)     
-
-//
-//     Standard error severity and trace levels. These are ored with the error 
-//     severities below. The MPR_LOG_MASK is used to extract the trace level 
-//     from a flags word. We expect most apps to run with level 2 trace.
-//
-#define        MPR_FATAL               0               ///< Fatal error trace level. Cant continue.
-#define        MPR_ERROR               1               ///< Hard error trace level
-#define MPR_WARN               2               ///< Soft warning trace level
-#define        MPR_CONFIG              2               ///< Configuration settings trace level.
-#define MPR_INFO               3               ///< Informational trace only 
-#define MPR_DEBUG              4               ///< Debug information trace level
-#define MPR_VERBOSE            9               ///< Highest level of trace 
-#define MPR_LOG_MASK   0xf             ///< Level mask 
-
-//
-//     Error flags. Specify where the error should be sent to. Note that the 
-//     product.xml setting "headless" will modify how errors are reported.
-//     Assert errors are trapped when in DEV mode. Otherwise ignored.
-//
-#define        MPR_TRAP                0x10    // Assert mprError flags -- trap in debugger 
-#define        MPR_LOG                 0x20    ///< Log to the O/S event log mprError flag
-#define        MPR_USER                0x40    ///< Display to the user mprError flag
-#define        MPR_ALERT               0x80    // Send a management alert 
-#define        MPR_TRACE               0x100   // Trace
-
-//
-//     Error format flags
-//
-#define MPR_RAW                        0x200                   // Raw trace output
-
-//
-//     Error line number information
-//
-#define MPR_L          __FILE__, __LINE__
-
-////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////// Function Remappings ////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-//
-//     Unsafe functions that should not be used. Define UNSAFE_STRINGS_OK before
-//     including mpr.h if you really want to use these functions. A better approach
-//     is to undefine them just prior to using them in your C/C++ source file.
-//
-#if BLD_FEATURE_SAFE_STRINGS
-
-#if BLD_FEATURE_PHP4_MODULE || BLD_FEATURE_PHP5_MODULE
-#ifndef UNSAFE_FUNCTIONS_OK
-#define UNSAFE_FUNCTIONS_OK 1
-#endif
-#endif
-
-#ifndef UNSAFE_FUNCTIONS_OK
-#define sprintf                        UseMprSprintfInstead
-#define printf                 UseMprPrintfInstead
-#define fprintf                        UseMprFprintfInstead
-#define vsprintf               UseMprVsprintfInstead
-#define strtok                 UseMprStrTokInstead
-#define gethostbyname  UseMprGetHostByNameInstead
-#define ctime                  UseMprCtimeInstead
-#define asctime                        UseMprAsctimeInstead
-#define localtime              UseMprLocaltimeInstead
-#define gmtime                 UseMprGmtimeInstead
-#define malloc                 UseMprMallocInstead
-#define free                   UseMprFreeInstead
-#define realloc                        UseMprReallocInstead
-#define calloc                 UseMprCallocInstead
-#define strncpy                        UseMprStrcpyInstead
-#define inet_ntoa              UseMprInetNtoaInstead
-
-//
-//     FUTURE -- to the whole way
-//
-//#define strlen               UseMprStrlenInstead
-//#define strcpy               UseMprStrcpyInstead
-
-#endif // UNSAFE_FUNCTIONS_OK
-#endif // BLD_FEATURE_SAFE_STRINGS
-
-//
-//     File information structure
-//
-struct MprFileInfo {
-       uint                    size;                                   // File length 
-       uint                    mtime;                                  // Modified time 
-       uint                    inode;                                  // Inode number
-       bool                    isDir;                                  // Set if directory 
-       bool                    isReg;                                  // Set if a regular file 
-};
-
-//
-//     Mpr time structure. Used for mprGetTime(). Matches requirements of select().
-//
-struct MprTime {
-       long                    sec;                                    // Seconds 
-       long                    usec;                                   // Microseconds (NOT milliseconds)
-};
-typedef struct MprTime MprTime;
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////// C++ APIs ///////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#if __cplusplus
-
-class  MprBuf;
-class  MprFile;
-class  MprFileSystem;
-class  MprHashTable;
-class  MprLink;
-class  MprList;
-class  MprPoolService;
-class  MprPoolThread;
-class  MprSelectService;
-class  MprSelectHandler;
-class  MprSocket;
-class  MprSocketService;
-class  MprStringData;
-class  MprStringList;
-class  MprTask;
-class  MprTimerService;
-class  MprTimer;
-
-#if BLD_FEATURE_LOG
-class  MprLogModule;
-class  MprLogService;
-class  MprLogListener;
-class  MprLogToFile;
-class  MprLogToWindow;
-#endif
-
-#if BLD_FEATURE_CGI_MODULE
-class  MprCmd;
-class  MprCmdFiles;
-class  MprCmdService;
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
-class  MprCond;
-class  MprMutex;
-class  MprThreadService;
-class  MprThread;
-#else
-typedef void *MprMutex;
-#endif
-
-#if BLD_FEATURE_RUN_AS_SERVICE && WIN
-class  MprWinService;
-#endif
-
-/////////////////////////////////// MprLink ////////////////////////////////////
-
-//
-//     This define is used by classes that include a Link field member, to get
-//     the base class pointer
-//
-#define MPR_GET_BASE(type, ptr, field) \
-       ((type) ((int) ptr - ((int) &(((type) 1)->field) - (int) ((type) 1))))
-
-//
-//     The MprLink class enables subclassed objects to be inserted in a MprList. It
-//     provides forward and back links for fast insertion, removal and iteration.
-//     To use MprLink, subclasses must inherit MprLink as a base class. Use 
-//     MprList for the dummy list header and MprLink for the list members.
-//     This class is NOT thread-safe. Callers must do their own thread
-//     synchronization. It is designed to be "inline", very fast and no-frills.
-//
-
-class MprLink {
-  // FUTURE -- revert to protected
-  public:
-       MprLink                 *next;                                          // Ptr to next member in list
-       MprLink                 *prev;                                          // Ptr to prev member in list
-       MprList                 *head;                                          // Ptr to the list head
-
-  public:
-                                       MprLink() {                             ///< Constructor
-                                               next = prev = this; 
-                                               head = 0;
-                                       };
-                                       ~MprLink() {};                          ///< Destructor
-       MprList                 *getList() { return head; };///< Return the owning list
-
-       inline void             insertAfter(MprLink *item);     ///< Insert after this member
-       inline void             insertPrior(MprLink *item);     ///< Insert prior to this member
-};
-
-/////////////////////////////////// MprList ////////////////////////////////////
-//
-//     The MprList class defines the list (dummy) header for doubly linked objects.
-//     It provides forward and back links for fast insertion, removal and 
-//     iteration. To use MprLink, subclasses must inherit MprLink as a base class. 
-//     Use MprList for the dummy list header and MprLink for the list members.
-//     This class is NOT thread-safe. Callers must do their own thread
-//     synchronization. It is designed to be "inline", very fast and no-frills.
-//
-
-class MprList : public MprLink {
-  protected:
-       int                             numItems;                                       // Number of items in the list
-
-  public:
-                                       MprList() { 
-                                               numItems = 0; 
-                                               head = this;
-                                               next = prev = this;
-                                       };
-                                       ~MprList() {
-                                       };
-       inline void     insert(MprLink *item) {                 /// Add to the end of the list
-                                               inlineAssert(item->head == 0);
-                                               if (item->head == 0) {
-                                                       numItems++;
-                                               }
-                                               item->head = this;
-                                               item->next = head;
-                                               item->prev = head->prev;
-                                               prev->next = item;
-                                               prev = item;
-                                       };
-       inline MprLink  *remove(MprLink *item) {        /// Remove this item
-                                               inlineAssert(item->head == this);
-                                               item->next->prev = item->prev;
-                                               item->prev->next = item->next;
-                                               item->prev = 0;
-                                               item->next = 0;
-                                               inlineAssert(numItems > 0);
-                                               if (item->head == head) {
-                                                       numItems--;
-                                               }
-                                               item->head = 0;
-                                               return next;
-                                       };
-       inline MprLink  *getFirst() {                           /// Get first item
-                                               return (next == head) ? 0 : next;
-                                       };
-       inline MprLink  *getLast() {                            /// Get last item
-                                               return (next == head) ? 0 : prev;
-                                       };
-       inline MprLink  *getNext(MprLink *item) {       /// Get next item
-                                               inlineAssert(item->head == this);
-                                               return (item->next == head) ? 0 : item->next;
-                                       };
-       inline MprLink  *getPrev(MprLink *item) {       /// Get previous item
-                                               inlineAssert(item->head == this);
-                                               return (item->prev == head) ? 0 : item->prev;
-                                       };
-       int                             getNumItems() {                         /// Get number of items.
-                                               return numItems; 
-                                       };
-       bool                    emptyOk() { 
-                                               if ((head == this) && (next == head) && 
-                                                       (prev == head) && (numItems == 0)) {
-                                                       return 1;
-                                               } else {
-                                                       return 0;
-                                               }
-                                       };
-       
-       friend class    MprLink;
-};
-
-//
-//     Inline methods for MprLink
-//
-inline void    MprLink::insertAfter(MprLink *item) {
-                                       inlineAssert(item->head == 0);
-                                       item->head = head;
-                                       next->prev = item;
-                                       item->prev = this;
-                                       item->next = next;
-                                       next = item;
-                                       head->numItems++;
-                               };
-inline void    MprLink::insertPrior(MprLink *item) {
-                                       inlineAssert(item->head == 0);
-                                       item->head = head;
-                                       prev->next = item;
-                                       item->next = this;
-                                       item->prev = prev;
-                                       prev = item;
-                                       head->numItems++;
-                               };
-
-//////////////////////////////// MprStringList /////////////////////////////////
-
-class MprStringData : public MprLink {
-  public:
-       MprStr                  string;
-
-  public:
-                                       MprStringData(char *s);
-                                       ~MprStringData();
-       inline char             *getValue() { return string; };
-};
-
-class MprStringList : public MprList {
-  public:
-                                       MprStringList(char *str);
-                                       MprStringList();
-                                       ~MprStringList();
-       void                    insert(char *str);
-       void                    parse(char *str);
-};
-
-////////////////////////////////// MprCmdLine //////////////////////////////////
-
-class MprCmdLine {
-  private:
-       int                             argc;
-       char                    **argv;                         // Not duped
-       void                    *argvBuf;                       // Storage for argv and args
-       bool                    inSwitch;
-       int                             optc;
-       int                             optind;
-       char                    *switches;                      // Not duped
-
-  public:
-                                       MprCmdLine(int argc, char **argv, char *switches);
-                                       MprCmdLine(char *args, char *switches);
-                                       ~MprCmdLine();
-       char                    **getArgv() { return argv; };
-       int                             getArgc() { return argc; };
-       int                             next(char **argp = 0);
-       int                             firstArg();
-};
-
-/////////////////////////////////// MprCond ////////////////////////////////////
-#if BLD_FEATURE_MULTITHREAD
-
-//
-//     Condition variable for multi-thread synchronization
-//
-//     Condition variables can be used to coordinate threads when running in a
-//     multi-threaded mode. These condition variables are level triggered in that
-//     a condition can be signalled prior to another thread waiting. That thread
-//     will then not block if it calls waitForCond().
-//
-
-class MprCond {
-  private:
-       #if BLD_DEBUG
-               //
-               //      This must be the first item in the class
-               //
-               MprLink         link;                           // Cond-var leak monitoring
-       #endif
-       #if LINUX || MACOSX || SOLARIS
-               pthread_cond_t 
-                                       cv;                                     // Pthreads condition variable 
-       #endif
-       #if WIN
-               HANDLE          cv;                                     // Windows event handle
-               int                     numWaiting;                     // Number waiting to be signalled
-       #endif
-       #if VXWORKS
-               SEM_ID          cv;                                     // Condition variable
-       #endif
-               MprMutex        *mutex;                         // Thread sync
-               int                     triggered;                      // Value of the condition
-
-#if UNUSED
-               int                     wakeAll;                        // Wake all waiters on signalCond()
-#endif
-
-  public:
-                                       MprCond();
-                                       ~MprCond();
-               int                     waitForCond(long timeout = -1);
-               void            signalCond();
-
-#if UNUSED
-               int                     multiWait(MprMutex *externalMutex, long timeout = -1);
-               void            reset();
-               void            signalAll();
-#endif
-};
-
-#endif // BLD_FEATURE_MULTITHREAD
-/////////////////////////////////// MprDebug ///////////////////////////////////
-#if BLD_DEBUG
-
-class MprDebug {
-  public:
-#if BLD_FEATURE_MULTITHREAD
-       int                             getMutexNum();
-#endif 
-};
-
-#endif
-/////////////////////////////////// MprFile ////////////////////////////////////
-
-class MprFile {
-  private:
-       MprBuf                  *inBuf;
-       int                             fd;
-  public:
-                                       MprFile();
-       virtual                 ~MprFile();
-       virtual int     open(char* path, int flags, int mode);
-       virtual void    close();
-       virtual char    *gets(char *buf, int len);
-       virtual int             read(void* buf, int len);
-       virtual int             write(void* buf, int len);
-       virtual long    lseek(long offset, int origin);
-};
-
-//////////////////////////////// MprFileSystem /////////////////////////////////
-
-class MprFileSystem {
-  private:
-  public:
-                                       MprFileSystem();
-       virtual                 ~MprFileSystem();
-       virtual MprFile *newFile();
-       virtual int     stat(char* path, MprFileInfo* info);
-       virtual bool    isDir(char* path);
-       virtual void    setRoot(char* path);
-};
-
-/////////////////////////////////// MprMutex ///////////////////////////////////
-#if BLD_FEATURE_MULTITHREAD
-
-//
-//     Mutual exclusion locks
-//
-class MprMutex {
-  public:
-       #if BLD_DEBUG
-               MprLink         link;                           // Must be the first in the class
-       #endif
-       #if WIN
-               CRITICAL_SECTION cs;                    // O/S critical section
-       #endif
-       #if LINUX || MACOSX || SOLARIS
-               pthread_mutex_t  cs;                    // O/S critical section
-       #endif
-       #if VXWORKS
-               SEM_ID          cs;                                     // Semaphore
-       #endif
-
-  public:
-                                       MprMutex();
-                                       ~MprMutex();
-       int                             tryLock();
-
-       //      FUTURE -- should do Windows inline also.
-
-       #if LINUX || MACOSX || SOLARIS
-               inline void     lock() { pthread_mutex_lock(&cs); };
-               inline void     unlock() { pthread_mutex_unlock(&cs); };
-       #elif VXWORKS && 0
-               inline void     lock() { semTake(cs, WAIT_FOREVER); };
-               inline void     unlock() { semGive(cs); };
-       #else
-               void            lock();
-               void            unlock();
-       #endif
-
-       friend class    MprCond;
-};
-
-#endif // BLD_FEATURE_MULTITHREAD
-////////////////////////////////////// Mpr /////////////////////////////////////
-//
-//     Mpr flags
-//
-#define MPR_EXITING                            0x1             // Mpr is exiting
-#define MPR_ASYNC_SELECTING            0x2             // Using async select
-#define MPR_HEADLESS                   0x4             // No user interface
-#define MPR_SERVICE_THREAD             0x10    // Using a service thread for events
-#define MPR_IS_DAEMON                  0x20    // Is a daemon / service
-#define MPR_STOPPED                            0x40    // Mpr services stopped
-#define MPR_STARTED                            0x80    // Mpr services started
-#define MPR_KILLABLE                   0x100   // MPR can be killed (need a pid file)
-#define MPR_USER_START_FLAGS   (MPR_SERVICE_THREAD | MPR_KILLABLE)
-
-typedef int            (*MprDllEntryProc)(void *arg);
-
-//
-//     The Mbedthis Portable Runtime (MPR) internal state class.
-//     
-class Mpr {
-  private:
-       MprStr                  appName;                        // One word name of the application 
-       MprStr                  appTitle;                       // Displayable name of the product 
-       int                             buildNumber;            // Build number 
-       MprStr                  buildType;                      // Build type 
-       MprHashTable    *configSettings;        // Configuration settings for app
-       MprStr                  cpu;                            // Procesor 
-       MprStr                  domainName;                     // Domain portion
-       MprStr                  hostName;                       // Host name (fully qualified name)
-       MprStr                  installDir;                     // Installation directory (!= cwd)
-       MprStr                  os;                                     // Operating system
-       MprStr                  serverName;                     // Server name portion (no domain)
-       MprStr                  version;                        // Application version number (x.y.z)
-
-       //
-       //      FUTURE -- Convert to flags
-       //
-       int                             flags;                          // Processing state
-       int                             headless;                       // Run headless
-       bool                    runAsService;           // Running as a service (daemon)
-       bool                    eventsThread;           // Running an events thread
-
-#if WIN
-       long                    appInstance;            // Application instance (windows)
-       HWND                    hwnd;                           // Window handle
-#endif
-
-#if BLD_FEATURE_LOG
-       MprLogModule    *defaultLog;            // Default log module
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *mutex;                         // Thread synchronization 
-       MprMutex                *timeMutex;                     // Thread sync for mprGetTime 
-       MprMutex                *eventsMutex;           // Thread sync for serviceEvents 
-#endif
-
-  public:
-#if BLD_FEATURE_LOG
-       MprLogService           *logService;    // Log service object
-#endif
-       MprPoolService          *poolService;   // Pool service object
-       MprSelectService        *selectService; // Select service object
-       MprSocketService        *socketService; // MprSocket service object
-       MprTimerService         *timerService;  // Timer service object
-       MprList                         modules;                // List of modules
-
-#if BLD_FEATURE_CGI_MODULE
-       MprCmdService           *cmdService;    // Run command service object
-#endif
-#if BLD_FEATURE_MULTITHREAD
-       MprThreadService        *threadService; // Thread service object
-#endif
-
-  public:
-       //
-       //      Published API
-       //
-                                       Mpr(char *appName);
-                                       ~Mpr();
-#if BLD_FEATURE_LOG
-       void                    addListener(MprLogListener *lp);
-#endif
-       bool                    getAsyncSelectMode();
-       int                             getIdleTime();
-       bool                    isExiting(void);
-       int                             runTasks();
-       int                             runTimers();
-       void                    serviceEvents(bool loopOnce, int maxTimeout);
-       void                    setAsyncSelectMode(bool on);
-       int                             setLogSpec(char *spec);
-       int                             start(int startFlags = 0);
-       int                             stop(bool immediateStop);
-       void                    terminate(bool graceful = 1);
-#if WIN
-       void                    setHwnd(HWND appHwnd);
-       void                    setSocketHwnd(HWND socketHwnd);
-       void                    setSocketMessage(int msgId);
-#endif
-
-       //
-       //      Unpublished API
-       //
-
-       int                             configure(char *configFile);
-       char                    *getAppName(void);
-       char                    *getAppTitle(void);
-       int                             getBuildNumber(void);
-       char                    *getBuildType(void);
-       char                    *getCpu(void);
-       char                    *getDomainName(void);
-       int                             getFds(fd_set *readInterest, fd_set *writeInterest, 
-                                               fd_set *exceptInterest, int *maxFd, int *lastGet);
-       int                             getHeadless(void);
-       char                    *getHostName(void);
-       char                    *getInstallDir(void);
-       char                    *getOs(void);
-       char                    *getServerName(void);
-       char                    *getVersion(void);
-       bool                    isRunningEventsThread() { return eventsThread; };
-       bool                    isService();
-       int                             killMpr();
-       int                             makeDaemon(int parentExit);
-       void                    serviceIO(int readyFds, fd_set *readFds, fd_set *writeFds, 
-                                               fd_set *exceptFds);
-       void                    serviceIO(int sockFd, int winMask);
-       void                    setAppName(char *name);
-       void                    setAppTitle(char *name);
-       void                    setBuildNumber(int buildNumber);
-       void                    setBuildType(char *type);
-       void                    setCpu(char *cpu);
-       void                    setDomainName(char *host);
-       void                    setHeadless(int headless);
-       void                    setHostName(char *host);
-       void                    setInstallDir(char *dir);
-       void                    setOs(char *os);
-       void                    setPriority(int pri);
-       void                    setServerName(char *host);
-       void                    setService(bool service);
-       void                    setVersion(char *version);
-       void                    setWebServerAddress(char *path);
-       void                    writeToOsLog(char *msg, int etype);
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    startEventsThread();
-       void                    setMinPoolThreads(int n);
-       void                    setMaxPoolThreads(int n);
-       int                             getMinPoolThreads();
-       int                             getMaxPoolThreads();
-       int                             getNextThreadNum();
-       MprThread               *getCurrentThread();
-       inline void     lock() { 
-                                               if (mutex) {
-                                                       mutex->lock(); 
-                                               }
-                                       };
-       inline void             unlock() { 
-                                               if (mutex) {
-                                                       mutex->unlock(); 
-                                               }
-                                       };
-       void                    timeLock() { timeMutex->lock(); };
-       void                    timeUnlock() { timeMutex->unlock(); };
-#else
-       int                             getMaxPoolThreads() { return 0; };
-       inline void             lock() {};
-       inline void             unlock() {};
-       inline void             timeLock() {};
-       inline void             timeUnlock() {};
-#endif
-
-#if WIN
-       HWND                    getHwnd();
-       long                    getInst();
-       void                    setInst(long inst);
-#endif
-
-#if BLD_FEATURE_DLL
-       int                             loadDll(char *path, char *fnName, void *arg, void **handle);
-       void                    unloadDll(void *handle);
-#endif
-
-#if BLD_FEATURE_XML_CONFIG
-       int                             openConfigFile(char *path);
-       int                             openXmlFile(char *path);
-       int                             readXmlInt(MprHashTable *symTab, char *key, int *value);
-       int                             readXmlStr(MprHashTable *symTab, char *key, char **value);
-#endif
-       char                    *getConfigStr(char *key, char *defaultValue);
-       int                             getConfigInt(char *key, int defaultValue);
-
-#if BLD_FEATURE_CGI_MODULE
-       MprCmdService   *getCmdService() { return cmdService; };
-#endif
-
-  private:
-       int                             platformInitialize();
-       int                             platformTerminate();
-       int                             platformStart(int startFlags);
-       int                             platformStop();
-};
-
-#if MPR_IN_MPR
-extern Mpr                     *mpr;                                   // Default global Mpr class
-#endif
-
-extern Mpr                     *mprGetMpr();
-
-//////////////////////////////// MprHashEntry //////////////////////////////////
-//
-//     Master hash entry type. Not thread safe.
-//
-
-class MprHashEntry : public MprLink {
-  private:
-       MprStr                  key;
-       MprList                 *bucket;
-
-  public:
-                                       MprHashEntry();
-                                       MprHashEntry(char *key);
-       virtual                 ~MprHashEntry();
-       char                    *getKey();
-       void                    setKey(char *key);
-       friend class    MprHashTable;
-};
-
-//
-//     String entry type
-//
-class MprStringHashEntry : public MprHashEntry {
-  private:
-       MprStr                  value;
-  public:
-                                       MprStringHashEntry(char *key, char *str);
-       virtual                 ~MprStringHashEntry();
-       char                    *getValue() { return value; };
-};
-
-//
-//     Static string (not duplicated)
-//
-class MprStaticHashEntry : public MprHashEntry {
-  private:
-       char                    *value;
-  public:
-                                       MprStaticHashEntry(char *key, char *str);
-       virtual                 ~MprStaticHashEntry();
-       char                    *getValue() { return value; };
-};
-
-#if PERHAPS
-//
-//     Object string (not duplicated)
-//
-class MprObjectHashEntry : public MprHashEntry {
-  private:
-       char                    *value;
-  public:
-                                       MprObjectHashEntry(char *key, char *str);
-       virtual                 ~MprObjectHashEntry();
-       char                    *getValue() { return value; };
-};
-#endif
-
-///////////////////////////////// MprHashTable /////////////////////////////////
-
-class MprHashTable {
-  private:
-       MprList                 *buckets;
-       int                             size;
-       int                             count;
-
-  public:
-                                       MprHashTable(int hash_size = MPR_DEFAULT_HASH_SIZE);
-                                       ~MprHashTable();
-       MprHashEntry    *getFirst();
-       MprHashEntry    *getNext(MprHashEntry *ep);
-       int                             getNumItems() { return count; };
-       int                             insert(MprHashEntry *entry);
-       MprHashEntry    *lookup(char *key);
-       int                             remove(char *key);
-       int                             remove(MprHashEntry *entry);
-       int                             removeAll();
-
-  private:
-       MprHashEntry    *lookupInner(char *key, MprList **bucket);
-       int                             hashIndex(char *key);
-       int                             getNextPrime(int size);
-};
-
-//////////////////////////////// MprLogService /////////////////////////////////
-#if BLD_FEATURE_LOG
-
-class MprLogListener : public MprLink {
-  private:
-       int                             maxSize;                                // Max size of log
-  public:
-       //
-       //      Published API
-       //
-                                       MprLogListener();               ///< Constructor
-       virtual                 ~MprLogListener();              ///< Destructor
-       virtual void    logEvent(char *module, int flags, int level, char *thread, 
-               char *msg);
-       virtual int             start();
-
-       //
-       //      Unpublished API
-       //
-       virtual void    shuttingDown();
-       virtual int             setLogSpec(char *path, int maxSize);
-       virtual void    stop();
-};
-
-
-class MprLogToFile : public MprLogListener {
-  private:
-       int                             logFd;                          // MprLogService file handle 
-       MprStr                  logFileName;            // Current name of log file
-       bool                    timeStamps;                     // Output high res time stamps
-       uint                    maxSize;                        // Maximum extent of trace file 
-       int                             rotationCount;          // Number of times logs rotated
-       MprTimer                *timer;                         // Log file time stamp timer
-  public:
-                                       MprLogToFile();         ///< Constructor
-                                       ~MprLogToFile();        ///< Destructor
-       void                    logEvent(char *module, int flags, int level, char *thread, 
-                                               char *msg);
-       void                    enableTimeStamps(bool on);
-       void                    logConfig();
-       void                    rotate();
-       void                    shuttingDown();
-       int                             setLogSpec(char *path, int maxSize);
-       int                             start();
-       void                    stop();
-       void                    writeTimeStamp();
-};
-
-
-class MprLogToWindow : public MprLogListener {
-  private:
-  public:
-                                       MprLogToWindow();               ///< Constructor
-                                       ~MprLogToWindow();              ///< Destructor
-       void                    logEvent(char *module, int flags, int level, char *thread, 
-                                               char *msg);
-};
-
-
-//
-//     Overall logging service
-//
-class MprLogService {
-  private:
-       MprList                 listeners;                      // Users registered for output
-       uint                    defaultLevel;           // Default level for modules
-       MprLogModule    *defaultModule;         // Default log module for this log
-       MprList                 moduleList;                     // List of modules to trace 
-       char                    *moduleSpecs;           // Module level spec string
-       char                    *logSpec;                       // Saved logging spec string
-       bool                    logging;                        // Logging is enabled
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *mutex;                         // Mutex lock 
-#endif
-
-  public:
-                                       MprLogService();
-                                       ~MprLogService(void);
-       void                    addListener(MprLogListener *lp);
-       void                    insertModule(MprLogModule *module);
-       void                    error(char *file, int line, int flags, char *fmt, 
-                                               va_list args);
-       MprLogModule    *getDefaultModule() { return defaultModule; }; 
-       int                             getDefaultLevel() { return defaultLevel; };
-       char                    *getLogSpec() { return logSpec; };
-       char                    *getModuleSpecs();
-       bool                    isLogging();
-       void                    removeListener(MprLogListener *lp);
-       void                    removeModule(MprLogModule *module);
-       void                    setDefaultLevel(int l);
-       void                    setDefaultModule(MprLogModule *m) { defaultModule = m; };
-       int                             setLogSpec(char *fileSpec);
-       void                    shuttingDown();
-       void                    start();
-       void                    stop();
-       void                    traceCore(int level, int flags, MprLogModule *module, 
-                                               char *fmt, va_list ap);
-       void                    writeHeader();
-       void                    writeLogStamp();
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { 
-                                               if (mutex) {
-                                                       mutex->lock(); 
-                                               }
-                                       };
-       void                    unlock() { 
-                                               if (mutex) {
-                                                       mutex->unlock(); 
-                                               }
-                                       };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-  private:
-       void                    output(MprLogModule *module, int flags, int level, 
-                                               char *msg);
-       void                    breakpoint(char *file, int line);
-};
-
-extern void            mprLog(int level, MprLogModule *module, char *fmt, ...);
-extern void            mprLog(int level, int flags, MprLogModule *module, 
-                                       char *fmt, ...);
-extern void            mprLog(char *fmt, ...);
-
-#else // !BLD_FEATURE_LOG
-//
-//     If logging is not enabled, we inline these functions to nothing
-//
-class MprLogModule { 
-       void *x; 
-  public:
-       MprLogModule(char *name) {}
-};
-inline void            mprLog(int level, MprLogModule *module, char *fmt, ...) {};
-inline void            mprLog(char *fmt, ...) {}
-extern "C" void                mprLog(int level, char *fmt, ...);
-#endif
-
-///////////////////////////////// MprLogModule /////////////////////////////////
-#if BLD_FEATURE_LOG
-//
-//     Class to describe a trace log module
-//
-
-class MprLogModule : public MprLink {
-  private:
-       MprStr                  name;
-       int                             level;                          // Current trace output level 
-       bool                    enabled;
-
-  public:
-                                       MprLogModule(char *name);
-                                       ~MprLogModule();
-       void                    innerMprLogModule(char *name);
-       int                             getLevel(void) { return level; };
-       void                    disable() { enabled = 0; };
-       void                    enable() { enabled = 1; };
-       int                             getEnabled() { return enabled; };
-       char                    *getName() { return name; };
-       void                    setLevel(int l) { level = l; };
-};
-
-#endif // BLD_FEATURE_LOG
-//////////////////////////////////// MprBuf ////////////////////////////////////
-
-typedef int                    (*MprBufProc)(MprBuf* bp, void *arg);
-
-class MprBuf {
-  private:
-       uchar                   *buf;                           // Actual buffer for data 
-       uchar                   *endbuf;                        // Pointer one past the end of buffer 
-       uchar                   *start;                         // Pointer to next data char 
-       uchar                   *end;                           // Pointer one past the last data char 
-       int                             buflen;                         // Current size of buffer 
-       int                             maxsize;                        // Max size the buffer can ever grow 
-       int                             growBy;                         // Next growth increment to use 
-       MprBufProc              refillProc;                     // Function to refill the buffer
-       void                    *refillArg;                     // Arg to refill proc
-
-  public:
-                                       MprBuf();
-                                       MprBuf(int initialSize, int maxsize = -1);
-                                       ~MprBuf();
-       inline void             addNull() {
-                                               *((char*) end) = (char) '\0';
-                                       };
-       void                    adjustStart(int size);
-       void                    adjustEnd(int size);
-       void                    copyDown();
-       inline void             flush() {
-                                               start = buf;
-                                               end = buf;
-                                       };
-       inline int              get() {
-                                               if (start == end) {
-                                                       return -1;
-                                               }
-                                               int     c = (uchar) *start++;
-                                               if (start >= endbuf) {
-                                                       start = buf;
-                                               }
-                                               return c;
-                                       };
-       int                             get(uchar *buf, int len);
-       inline char             *getBuf() { return (char*) buf; };
-       inline char             *getEnd() { return (char*) end; };
-       inline char             *getEndBuf() { return (char*) endbuf; };
-       inline int              getLength() {
-                                               return ((start > end) ? 
-                                                       (buflen + (end - start)) : (end - start));
-                                       };
-       inline int              getLinearData() {
-                                               return min((endbuf - start), getLength());
-                                       }
-       inline int              getLinearSpace() {
-                                               int len = getLength();
-                                               int space = buflen - len - 1;
-                                               return min((endbuf - end), space);
-                                       }
-       inline int              getSpace() {
-                                               return buflen - getLength() - 1;
-                                       };
-       inline char             *getStart() { return (char*) start; };
-       inline int              getSize() { return buflen; };
-       int                             insert(char c);
-       inline int              look() {
-                                               if (start == end) {
-                                                       return -1;
-                                               }
-                                               return* start;
-                                       }
-       int                             lookLast();
-       int                             put(char c);
-       int                             put(char *str);
-       int                             putInt(int i);
-       int                             putFmt(char *fmt, ...);
-       int                             put(uchar *buf, int len);
-       inline int              refill() { 
-                                               return (refillProc) ? 
-                                                       (refillProc)(this, refillArg) : 0; 
-                                       };
-       inline void             resetIfEmpty() {
-                                               if (getLength() == 0) {
-                                                       flush();
-                                               }
-                                       };
-       void                    setBuf(uchar *userBuf, int size);
-       void                    setBuf(int initialSize, int maxSize);
-       void                    setRefillProc(MprBufProc fn, void *arg) { 
-                                               refillProc = fn; 
-                                               refillArg = arg; 
-                                       };
-       uchar                   *takeBuffer();
-  private:
-       int                             grow();
-};
-
-//////////////////////////////// MprCmdService /////////////////////////////////
-#if BLD_FEATURE_CGI_MODULE
-//
-//     Flags for MprCmd
-//
-#define MPR_CMD_BACKGROUND     0x1                     // Continue running if MPR exits 
-#define MPR_CMD_REAP_MAX       24
-
-//
-//     Cmd service control
-//
-
-class MprCmdService {
-  private:
-       MprList                 cmdList;                        // List of commands
-       MprMutex                *mutex;                         // Multi-thread sync
-       ulong                   completedCmds[MPR_CMD_REAP_MAX];
-       int                             exitStatus[MPR_CMD_REAP_MAX];
-       MprTimer                *timer;                         // Timer to poll for child completion
-
-  public:
-                                       MprCmdService();
-                                       ~MprCmdService();
-       void                    cmdWatcher();
-       void                    cmdWatcherTimer(MprTimer *tp);
-       void                    insertCmd(MprCmd* rp);
-       void                    removeCmd(MprCmd* rp);
-       int                             start();
-       void                    startWatcher();
-       int                             stop();
-
-#if LINUX || SOLARIS || VXWORKS
-       void                    processStatus(int pid, int status);
-       void                    initSignals();
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { mutex->lock(); };
-       void                    unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-};
-
-//////////////////////////////////// MprCmd ////////////////////////////////////
-
-//
-//     Cmd procs must return the number of bytes read or -1 for errors.
-//
-typedef void   (*MprCmdProc)(MprCmd* rp, void *data);
-
-#define MPR_CMD_EOF                    -1                      // EOF return value
-
-//
-//     Flags
-//
-#define MPR_CMD_DETACHED       0x1
-#define MPR_CMD_NEW_SESSION    0x2
-#define MPR_CMD_CHDIR          0x4
-#define MPR_CMD_WAIT           0x8
-#define MPR_CMD_SHOW           0x10
-#define MPR_CMD_USER_FLAGS     0x1f
-
-#define MPR_CMD_COMPLETE       0x40
-#define MPR_CMD_DISPOSED       0x80
-#define MPR_CMD_STDIO_MADE     0x100
-
-//
-//     Indicies for clientFd and serverFd
-//
-#define MPR_CMD_IN                     0                       // Stdin for the server
-#define MPR_CMD_OUT                    1                       // Stdout for the server
-#define MPR_CMD_MAX_FD         2
-
-#define MPR_CMD_WATCHER_NAP            100             // Timeout for watcher while polling
-#define MPR_CMD_WATCHER_TIMEOUT        5000    // Timeout for child to start
-
-class MprCmdFiles {
-  public:
-       MprStr                  name[MPR_CMD_MAX_FD];
-       int                             fd[MPR_CMD_MAX_FD];
-       int                             clientFd[MPR_CMD_MAX_FD];
-  public:
-                                       MprCmdFiles();
-                                       ~MprCmdFiles();
-};
-
-//
-//     MprCmd class
-//
-class MprCmd : public MprLink {
-  private:
-       MprStr                  cwd;                            // Current working dir for the process
-       void                    *data;                          // Callback user data
-       int                             exitStatus;                     // Command exit status
-       int                             flags;                          // Control flags (userFlags not here)
-       MprCmdFiles             files;                          // Stdin, stdout for the command
-       int                             inUse;                          // Used by dispose()
-       MprLogModule    *log;
-       MprCmdProc              cmdDoneProc;            // Handler for client completion
-
-#if VXWORKS
-       MprSelectHandler        
-                                       *handler;
-       int                             waitFd;                         // Pipe to await child exit
-#endif
-       ulong                   process;                        // Id/handle of the created process
-
-#if BLD_FEATURE_MULTITHREAD
-#if VXWORKS
-       MprCond                 *startCond;
-       MprCond                 *exitCond;
-#endif
-       MprMutex                *mutex;
-#endif
-
-  public:
-                                       MprCmd();
-                                       ~MprCmd();
-       void                    closeWriteFd();
-       int                             dispose();
-       int                             getExitCode(int *code = 0);
-       int                             getWriteFd();
-       int                             getReadFd();
-       void                    invokeCallback(MprMutex *callerMutex);
-       bool                    isRunning();
-       int                             makeStdio();
-       void                    setCwd(char *dir);
-       int                             setInuse();
-       int                             start(char *cmd, int flags);
-       int                             start(char *cmd, char **argv, char **envp, 
-                                               MprCmdProc completionProc, void *data, int flags);
-       void                    stop();
-
-       //
-       //      Internal API
-       //
-       ulong                   getProcess() { return process; };
-       void                    reset();
-       void                    resetFiles();
-       void                    setExitStatus(int status);
-
-  private:
-       int                             waitForChild(int timeout);
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { mutex->lock(); };
-       void                    unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-       friend class    MprCmdService;
-};
-
-#endif // BLD_FEATURE_CGI_MODULE
-////////////////////////////// MprSelectService ////////////////////////////////
-//
-//     Standard select bit mask options
-//
-#define MPR_READABLE                   0x2
-#define MPR_WRITEABLE                  0x4
-#define MPR_EXCEPTION                  0x8
-
-typedef void           (*MprSelectProc)(void *data, int mask, int isMprPoolThread);
-
-class MprSelectService {
-  private:
-       struct sockaddr_in 
-                                       breakAddress;           // Breakout port socket address
-       int                             breakSock;                      // MprSocket to wakeup select service
-       int                             breakPort;                      // Port to talk to the select service
-       int                             breakRetries;           // Retry attempts to open breakout port
-       MprList                 list;                           // List of select handlers
-       int                             flags;                          // State flags
-       int                             maskGeneration;         // Generation number for mask changes
-       int                             listGeneration;         // Generation number for list changes
-       MprLogModule    *log;
-       int                             rebuildMasks;           // Complete select mask rebuild required
-       int                             delayedFds[FD_SETSIZE];
-       int                             maxDelayedFd;
-#if WIN
-       int                             sockMessage;            // MprSocket message for AsyncSelect
-       HWND                    hwnd;                           // Window handle to use for AsyncSelect
-#endif
-
-#if BLD_FEATURE_MULTITHREAD
-       MprCond                 *cond;                          // Wait for select to breakout
-       MprMutex                *mutex;                         // General multi-thread synchronization
-#endif
-
-  public:
-       //
-       //      Published API
-       //
-                                       MprSelectService();
-                                       ~MprSelectService();
-       int                             getFds(fd_set *readInterest, fd_set *writeInterest, 
-                                               fd_set *exceptInterest, int *maxFd, int *lastGet);
-       void                    serviceIO(int readyFds, fd_set *readFds, fd_set *writeFds, 
-                                               fd_set *exceptFds);
-       void                    serviceIO(int sockFd, int winMask);
-
-       //
-       //      Unpublished API
-       //
-       int                             insertHandler(MprSelectHandler *sp);
-       void                    awaken(int wait = 0);
-       void                    delayedClose(int fd);
-       bool                    getAsyncSelectMode();
-       int                             getFlags() { return flags; };
-       int                             modifyHandler(MprSelectHandler *sp, bool wakeUp);
-       void                    removeHandler(MprSelectHandler *sp);
-       MprLogModule    *getLog() { return log; };
-       int                             openBreakoutPort();
-       void                    setPort(int n);
-       int                             start();
-       int                             stop();
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { mutex->lock(); };
-       void                    unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-#if WIN
-       HWND                    getHwnd() { return hwnd; };
-       int                             getMessage() { return sockMessage; };
-       void                    setHwnd(HWND h) { hwnd = (HWND) h; };
-       void                    setMessage(int m) { sockMessage = m; };
-       void                    setAsyncSelectMode(bool asyncSelect);
-#endif
-};
-
-////////////////////////////// MprSelectHandler ////////////////////////////////
-//
-//     Flags
-//
-#define MPR_SELECT_DISPOSED                    0x1
-#define MPR_SELECT_RUNNING                     0x2
-#define MPR_SELECT_CLOSEFD                     0x4
-#define MPR_SELECT_CLIENT_CLOSED       0x8     // Client disconnection received
-
-class MprSelectHandler : public MprLink {
-  private:
-       int                             desiredMask;            // Mask of desired events 
-       int                             disableMask;            // Mask of disabled events 
-       int                             fd;                                     // O/S File descriptor (sp->sock) 
-       int                             flags;                          // Control flags
-       void                    *handlerData;           // Argument to pass to proc. 
-       int                             inUse;                          // Used by dispose()
-       MprLogModule    *log;
-       int                             presentMask;            // Mask of events that have been seen 
-       int                             priority;                       // Priority if events handled by threads
-
-#if BLD_FEATURE_MULTITHREAD
-       MprCond                 *stoppingCond;          // Synchronization when stopping
-#endif
-
-  public:
-       MprSelectService *selectService;        // Select service pointer
-       MprSelectProc   proc;                           // Select handler procedure 
-
-  public:
-                                       MprSelectHandler(int fd, int mask, MprSelectProc proc, 
-                                               void *data, int priority);
-       bool                    dispose();
-       void                    disableEvents(bool wakeUp);
-       void                    enableEvents(bool wakeUp);
-       int                             getFd() { return fd; };
-       int                             getFlags() { return flags; };
-       void                    runHandler();
-       void                    selectProc(MprTask *tp);
-       void                    setInterest(int mask);
-       void                    setWinInterest();
-       void                    setProc(MprSelectProc newProc, int mask);
-       void                    setCloseOnDispose();
-       int                             stop(int timeout);
-
-  private:
-                                       ~MprSelectHandler();
-
-       friend class    MprSelectService;
-};
-
-//////////////////////////////// MprInterface //////////////////////////////////
-
-class MprInterface : public MprLink {
-  public:
-       MprStr                  name;                           // Interface name
-       MprStr                  ipAddr;
-       MprStr                  broadcast;
-       MprStr                  mask;
-  public:
-                                       MprInterface(char *name, char *ipAddr, char *bcast, 
-                                               char *mask);
-                                       ~MprInterface();
-};
-
-////////////////////////////// MprSocketService ////////////////////////////////
-
-typedef void           (*MprSocketIoProc)(void *data, MprSocket *sp, int mask, 
-                                               int isMprPoolThread);
-typedef void           (*MprSocketAcceptProc)(void *data, MprSocket *sp, char *ip, 
-                                               int port, MprSocket *lp, int isMprPoolThread);
-//
-//     Mpr socket service class
-//
-class MprSocketService {
-  private:
-       MprList                 socketList;                     // List of all sockets
-       MprList                 ipList;                         // List of ip addresses 
-       MprLogModule    *log;
-
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *mutex;
-#endif
-
-  public:
-                                       MprSocketService();
-                                       ~MprSocketService();
-#if BLD_FEATURE_LOG
-       MprLogModule    *getLogModule() { return log; };
-#endif
-       MprList                 *getInterfaceList();
-       void                    insertMprSocket(MprSocket *sp);
-       void                    removeMprSocket(MprSocket *sp);
-       int                             start();
-       int                             stop();
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { mutex->lock(); };
-       void                    unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-  private:
-       int                             getInterfaces();
-};
-
-////////////////////////////////// MprSocket ///////////////////////////////////
-//
-//     close flags
-//
-#define MPR_SHUTDOWN_READ              0
-#define MPR_SHUTDOWN_WRITE             1
-#define MPR_SHUTDOWN_BOTH              2
-
-//
-//     Flags
-//
-#define MPR_SOCKET_BLOCK               0x1                     // Use blocking I/O 
-#define MPR_SOCKET_BROADCAST   0x2                     // Broadcast mode 
-#define MPR_SOCKET_CLOSED              0x4                     // MprSocket has been closed 
-#define MPR_SOCKET_CONNECTING  0x8                     // MprSocket has been closed 
-#define MPR_SOCKET_DATAGRAM            0x10            // Use datagrams 
-#define MPR_SOCKET_EOF                 0x20            // Seen end of file 
-#define MPR_SOCKET_LISTENER            0x40            // MprSocket is server listener 
-#define MPR_SOCKET_NOREUSE             0x80            // Dont set SO_REUSEADDR option  
-#define MPR_SOCKET_NODELAY             0x100           // Disable Nagle algorithm 
-#define MPR_SOCKET_DISPOSED            0x200           // Delete requested
-
-#define MPR_SOCKET_READABLE            0x2
-#define MPR_SOCKET_WRITABLE            0x4
-#define MPR_SOCKET_EXCEPTION   0x8
-
-class MprSocket : public MprLink 
-{
-  private:
-       MprSocketAcceptProc 
-                                       acceptCallback;         // Accept callback 
-       void                    *acceptData;            // User accept callback data 
-       int                             currentEvents;          // Mask of ready events (FD_x) 
-       int                             error;                          // Last error 
-       MprSelectHandler *handler;                      // Select handler
-       int                             handlerMask;            // Handler events of interest 
-       int                             handlerPriority;        // Handler priority 
-       int                             interestEvents;         // Mask of events to watch for 
-       MprSocketIoProc ioCallback;                     // User I/O callback 
-       void                    *ioData;                        // User io callback data 
-       void                    *ioData2;                       // Secondary user io callback data 
-       int                             inUse;                          // In use counter. Used by dispose()
-       MprStr                  ipAddr;                         // Host IP address
-       MprLogModule    *log;                           // Pointer to MprSocketService module
-       int                             port;                           // Port to listen on 
-       int                             selectEvents;           // Events being selected 
-
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *mutex;                         // Multi-thread sync
-#endif
-
-  protected:
-       int                             sock;                           // Actual socket handle 
-       int                             flags;                          // Current state flags 
-       bool                    secure;                         // MprSocket is using SSL
-
-  public:
-                                       MprSocket();
-       void                    forcedClose();
-       void                    acceptProc(int isMprPoolThread);
-       bool                    getEof();
-       int                             getError();
-       int                             getFlags();
-       char                    *getIpAddr() { return ipAddr; };
-       int                             getPort();
-       int                             getFd();
-       bool                    getBlockingMode();
-       void                    getAcceptCallback(MprSocketAcceptProc *fn, void **data);
-       void                    getCallback(MprSocketIoProc *fn, void **data, 
-                                               void **data2, int *mask);
-       bool                    isSecure() { return secure; };
-       int                             openServer(char *ipAddr, int portNum, 
-                                               MprSocketAcceptProc acceptFn, void *data, int flags);
-       int                             openClient(char *hostName, int portNum, int flags);
-       void                    setBlockingMode(bool on);
-       int                             setBufSize(int sendSize, int recvSize);
-       //      FUTURE -- rename: handler vs callback
-       void                    setCallback(MprSocketIoProc fn, void *data, 
-                                               void *data2, int mask, int pri = MPR_NORMAL_PRIORITY);
-       int                             write(char *s);
-
-       virtual                 ~MprSocket();
-       virtual void    close(int how);
-       virtual bool    dispose();
-       virtual void    ioProc(int mask, int isMprPoolThread);
-       virtual MprSocket       
-                                       *newSocket();
-       virtual int             read(char *buf, int len);
-       virtual int             write(char *buf, int len);
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    lock() { mutex->lock(); };
-       void                    unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-  private:
-       void                    setMask(int handlerMask);
-       void                    setNoDelay(bool on);
-
-       friend class    MprSocketService;
-};
-
-//////////////////////////////// MprPoolService ////////////////////////////////
-
-#if BLD_DEBUG
-class MprPoolStats {
-  public:
-       int                             maxThreads;                     // Configured max number of threads
-       int                             minThreads;                     // Configured minimum
-       int                             numThreads;                     // Configured minimum
-       int                             maxUse;                         // Max used 
-       int                             pruneHighWater;         // Peak thread use in last minute
-       int                             idleThreads;            // Current idle
-       int                             busyThreads;            // Current busy
-};
-#endif
-
-//
-//     A task queue consists of a list of tasks and optional list of threads
-//
-typedef void           (*MprTaskProc)(void *data, MprTask *tp);
-
-//
-//     Class for the overall thread pool service
-//
-class MprPoolService {
-  protected:                                                   // Allow MprPoolThreads to access
-       MprStr                  name;                           // Name of pool
-       int                             nextTaskNum;            // Unique next task number
-       MprList                 runningTasks;           // List of executing tasks
-       int                             stackSize;                      // Stack size for worker threads 
-       MprList                 tasks;                          // Prioritized list of pending tasks
-
-#if BLD_FEATURE_MULTITHREAD
-       MprList                 busyThreads;            // List of threads to service tasks
-       MprList                 idleThreads;            // List of threads to service tasks
-       int                             maxThreads;                     // Max # threads in pool 
-       int                             maxUseThreads;          // Max threads ever used
-       int                             minThreads;                     // Max # threads in pool 
-       MprMutex                *mutex;                         // Per task synchronization
-       int                             nextThreadNum;          // Unique next thread number
-       int                             numThreads;                     // Current number of threads in pool
-       int                             pruneHighWater;         // Peak thread use in last minute
-       MprTimer                *pruneTimer;            // Timer for excess threads pruner
-       MprMutex                *incMutex;                      // Per task synchronization
-#endif
-
-  public:
-       MprLogModule    *log;
-
-  public:
-                                       MprPoolService(char *name);
-                                       ~MprPoolService();
-       int                             assignNextTask(MprPoolThread *pt);
-       void                    dequeueTask(MprTask *tp);
-#if BLD_DEBUG
-       void                    getStats(MprPoolStats *ps);
-#endif
-       void                    insertTask(MprTask *np, MprTask *tp);
-       void                    prune();
-       void                    queueTask(MprTask *tp);
-       void                    queueRunningTask(MprTask *tp);
-       void                    removeTask(MprTask *tp);
-       int                             runTasks();
-       void                    setStackSize(int n);
-       int                             start();
-       int                             stop(int timeout);
-
-#if BLD_FEATURE_MULTITHREAD
-       void                    dispatchTasks();
-       int                             getMinPoolThreads() { return minThreads; };
-       int                             getNumPoolThreads() { 
-                                               return idleThreads.getNumItems() +
-                                                               busyThreads.getNumItems();
-                                       };
-       int                             getMaxPoolThreads() { return maxThreads; };
-       int                             getNumIdleThreads() { return idleThreads.getNumItems(); };
-       void                    lock();
-       int                             getNextThreadNum();
-       void                    removeThread(MprPoolThread *pt);
-       void                    setMinPoolThreads(int n);
-       void                    setMaxPoolThreads(int n);
-       void                    unlock();
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-       int                             getMaxPoolThreads() { return 0; };
-#endif
-
-       friend class    MprPoolThread;
-       friend class    MprTask;
-};
-
-///////////////////////////////// MprPoolThread ////////////////////////////////
-#if BLD_FEATURE_MULTITHREAD
-//
-//     Flags
-//
-#define MPR_POOL_THREAD_SLEEPING       0x1
-
-//
-//     Class for each thread in the thread pool
-//
-class MprPoolThread : public MprLink {
-  private:
-       MprPoolService  *pool;                          // Which thread pool do we swim in
-       MprTask                 *currentTask;           // Current task being run
-       int                             flags;                          
-
-#if BLD_FEATURE_MULTITHREAD
-       MprThread               *thread;                        // Associated thread
-       MprCond                 *idleCond;                      // Used to wait for work
-#endif
-
-  public:
-                                       MprPoolThread(MprPoolService *pool, int stackSize);
-                                       ~MprPoolThread();
-       MprPoolService  *getMprPoolService() { return pool; };
-       MprThread               *getThread() { return thread; };
-       MprTask                 *getCurrentTask() { return currentTask; };
-       void                    makeIdle();
-       void                    start();
-       void                    setTask(MprTask *tp);
-       void                    threadMain();
-       void                    wakeup();
-};
-
-#endif
-/////////////////////////////////// MprTask ////////////////////////////////////
-//
-//     Flags
-//
-#define MPR_TASK_DISPOSED      0x1
-#define MPR_TASK_RUNNING       0x2
-
-//
-//     Class for each task (unit of work) 
-//
-class MprTask : public MprLink {
-  public:
-       void                    *data;                          // Task data 
-       int                             flags;                          // Control flags
-       int                             inUse;                          // In use counter. Used by dispose()
-       MprPoolService  *pool;                          // Managing pool
-       int                             priority;                       // Priority of event 
-       MprTaskProc             proc;                           // Procedure to service this event. 
-
-#if BLD_FEATURE_MULTITHREAD
-       MprPoolThread   *pt;                            // Pool thread servicing this task
-       MprCond                 *stoppingCond;          // Synchronization for timer->dispose()
-#endif
-
-  public:
-                                       MprTask(MprTaskProc proc, void *data, 
-                                               int priority = MPR_NORMAL_PRIORITY);
-                                       MprTask(MprPoolService *pool, MprTaskProc proc, 
-                                               void *data, int priority = MPR_NORMAL_PRIORITY);
-       bool                    dispose();
-       void                    start();
-       int                             stop(int timeout);
-
-#if BLD_FEATURE_MULTITHREAD
-       MprPoolThread   *getThread() { return pt; }; 
-#endif
-
-  private:
-                                       ~MprTask();
-       friend class    MprPoolThread;
-       friend class    MprPoolService;
-};
-
-/////////////////////////////// MprThreadService ///////////////////////////////
-#if BLD_FEATURE_MULTITHREAD
-// 
-//     Threading primitives
-//
-typedef void           (*MprThreadProc)(void *arg, MprThread *tp);
-
-class MprThreadService {
-  private:
-       MprList                 threads;                        // List of all threads
-       MprThread               *mainThread;            // Main application Mpr thread id 
-       MprMutex                *mutex;                         // Multi-thread sync
-
-  public:
-                                       MprThreadService();
-                                       ~MprThreadService();
-       MprThread               *getCurrentThread();
-       void                    insertThread(MprThread *tp);
-       void                    removeThread(MprThread *tp);
-       int                             start();
-       int                             stop(int timeout);
-
-       inline void     lock() { 
-                                               if (mutex) {
-                                                       mutex->lock(); 
-                                               }
-                                       };
-       inline void             unlock() { 
-                                               if (mutex) {
-                                                       mutex->unlock(); 
-                                               }
-                                       };
-};
-
-/////////////////////////////////// MprThread //////////////////////////////////
-
-class MprThread : public MprLink {
-  private:
-       #if WIN
-               int                     osThreadId;                     // O/S thread id
-               handle          threadHandle;           // Threads OS handle 
-       #endif
-       #if LINUX || MACOSX || SOLARIS
-               pthread_t       osThreadId;                     // O/S thread id 
-       #endif
-       #if VXWORKS
-               int                     osThreadId;                     // O/S thread id (same as pid)
-       #endif
-       void                    *data;                          // Data argument
-       MprThreadProc   entry;                          // Users thread entry point
-       MprStr                  name;                           // Name of thead for trace
-       MprMutex                *mutex;                         // Multi-thread synchronization
-       int                             pid;                            // Owning process id
-       int                             priority;                       // Current priority 
-       int                             stackSize;                      // Only VxWorks implements
-
-  public:
-                                       MprThread(int pri, char *name);
-                                       //      FUTURE -- move pri to last and default it.
-                                       MprThread(MprThreadProc proc, int pri, void *data, 
-                                               char *name, int stackSize = 0);
-                                       ~MprThread();
-       int                             getId() { return (int) osThreadId; };
-       char                    *getName() { return name; };
-       int                             getPriority() { return priority; };
-       void                    lock() { mutex->lock(); };
-       void                    setId(int id);
-       void                    setPriority(int priority);
-       void                    setStackSize(int size);
-       int                             start();
-       void                    threadProc();
-       void                    unlock() { mutex->unlock(); };
-  private:
-       int                             mapMprPriorityToOs(int mprPriority);
-       int                             mapOsPriorityToMpr(int nativePriority);
-};
-
-extern MprThread       *mprGetCurrentThread();
-extern int                     mprGetMaxPoolThreads();
-
-#endif // BLD_FEATURE_MULTITHREAD
-/////////////////////////////// MprTimerService ////////////////////////////////
-
-#define MPR_TIMER_TOLERANCE            2               // Used in timer calculations
-
-//
-//     Timer service. One per MPR 
-//
-class MprTimerService {
-  private:
-       int                             lastIdleTime;           // Last return value from getIdleTime()
-       int                             lastRanTimers;          // Last call to runTimers()
-       MprLogModule    *log;                           // Log module to identify trace
-       MprList                 timerList;                      // List of all timers
-
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *mutex;                         // Multi-thread sync
-#endif
-
-  public:
-                                       MprTimerService();
-                                       ~MprTimerService();
-       void                    callTimer(MprTimer *tp);
-       int                             getIdleTime();
-       int                             runTimers();
-       int                             stop();
-       int                             start();
-
-#if BLD_FEATURE_MULTITHREAD
-       MprMutex                *getMutex() { return mutex; };
-       inline void             lock() { mutex->lock(); };
-       inline void             unlock() { mutex->unlock(); };
-#else
-       inline void             lock() {};
-       inline void             unlock() {};
-#endif
-
-  protected:
-       void                    updateSelect(MprTimer *tp);
-
-       friend class    MprTimer;
-};
-
-//////////////////////////////////// MprTimer //////////////////////////////////
-//
-//     MprTimer callback function prototype
-//
-typedef void           (*MprTimerProc)(void *data, MprTimer *tp);
-
-//
-//     MprTimer flags
-//
-#define MPR_TIMER_DISPOSED             0x1
-#define MPR_TIMER_RUNNING              0x2
-#define MPR_TIMER_TASK                 0x4
-#define MPR_TIMER_AUTO_RESCHED 0x8
-
-class MprTimer : public MprLink {
-  private:
-       void                    *data;                          // Argument to pass to callback
-       int                             flags;
-       int                             inUse;                          // In use counter. Used by dispose()
-       int                             period;                         // Reschedule period 
-       MprTimerProc    proc;                           // Callback procedure
-       MprTime                 time;                           // When timer is due to next run
-       MprTimerService *timerService;
-
-#if BLD_FEATURE_MULTITHREAD
-       MprCond                 *stoppingCond;          // Synchronization when stopping
-#endif
-
-  public:
-                                       MprTimer(int msec, MprTimerProc routine, void *arg, 
-                                               int userFlags = 0);
-       bool                    dispose();
-       int                             getPeriod() { return period; };
-       MprTimerService *getMprTimerService() { return timerService; };
-       void                    reschedule();
-       void                    reschedule(int msec);
-       int                             stop(int timeout);
-
-private:
-                                       ~MprTimer();
-       friend class    MprTimerService;
-};
-
-//////////////////////////////// MprWinService /////////////////////////////////
-#if BLD_FEATURE_RUN_AS_SERVICE && WIN
-
-class MprWinService {
-  private:
-       MprStr                  svcName;
-  public:
-                                       MprWinService(char *name);
-                                       ~MprWinService();
-       int                             install(char *displayName, char *cmd);
-       int                             registerService(HANDLE threadHandle, HANDLE waitEvent);
-       int                             remove(int code);
-       int                             startDispatcher(LPSERVICE_MAIN_FUNCTION svcMain);
-       int                             start();
-       int                             stop(int code);
-       void                    updateStatus(int status, int exitCode);
-};
-
-#endif
-////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////// Other C++ Stuff ////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#if BLD_DEBUG && UNUSED
-#if LINUX || MACOSX
-#if MPR_CPU_IX86
-       inline int64 mprGetHiResTime() {
-               int64   now;
-               __asm__ __volatile__ ("rdtsc" : "=A" (now));
-               return now;
-       }
-#endif
-#endif
-#if WIN
-       inline int64 mprGetHiResTime() {
-               int64   now;
-               QueryPerformanceCounter((LARGE_INTEGER*) &now);
-               return now;
-       }
-#endif
-       
-////////////////////////////////////////////////////////////////////////////////
-
-inline int64 mprGetElapsedTime() 
-{
-       static int64    lastMark = 0;
-       int64                   now, elapsed;
-       
-       now = mprGetHiResTime();
-       if (now > lastMark) {
-               elapsed = now - lastMark;
-               lastMark = now;
-       } else {
-               elapsed = lastMark - now + 1;
-               lastMark = now;
-       }
-       return elapsed;
-};
-
-#endif // BLD_DEBUG && UNUSED
-#endif // __cplusplus
-
-////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////// C Prototypes //////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- *     Generic array type
- */
-typedef struct MprArray {
-       int             max;                                    /**< Size of the handles array. */
-       int             used;                                   /**< Count of used entries in handles. */
-       void    **handles;
-} MprArray;
-
-#if BLD_FEATURE_SQUEEZE
-#define MPR_ARRAY_INCR         8
-#else
-#define MPR_ARRAY_INCR         16
-#endif
-
-//
-//     Array
-//
-extern MprArray        *mprCreateArray();
-extern void    mprDestroyArray(MprArray *array);
-extern int             mprAddToArray(MprArray *array, void *item);
-extern int             mprRemoveFromArray(MprArray *array, int index);
-
-//
-//     Printf replacements
-//
-#define        MPR_STDOUT      1
-#define        MPR_STDERR      2
-
-extern int             mprPrintf(char *fmt, ...);
-extern int             mprStaticPrintf(char *fmt, ...);
-extern int             mprFprintf(int fd, char *fmt, ...);
-extern int             mprAllocSprintf(char **s, int n, char *fmt, ...);
-extern int             mprAllocVsprintf(char **s, int n, char *fmt, va_list arg);
-extern int             mprSprintf(char *s, int n, char *fmt, ...);
-extern int             mprVsprintf(char *s, int n, char *fmt, va_list arg);
-extern char            *mprItoa(int value, char *userBuf, int width);
-extern int             mprAtoi(char *str, int radix);
-
-//
-//     Safe string routines
-//
-extern int             mprStrcpy(char *dest, int destMax, const char *src);
-extern int             mprMemcpy(char *dest, int destMax, const char *src, 
-                                               int nbytes);
-extern int             mprAllocStrcpy(char **dest, int max, const char *src);
-extern int             mprReallocStrcpy(char **dest, int max, const char *src);
-extern int             mprAllocMemcpy(char **dest, int destMax, const char *src, 
-                                               int nbytes);
-extern int             mprStrcat(char *dest, int max, const char *delim, 
-                                               const char *src, ...);
-extern int             mprAllocStrcat(char **dest, int max, const char *delim, 
-                                               const char *src, ...);
-extern int             mprReallocStrcat(char **dest, int max, int existingLen,
-                                               const char *delim, const char *src, ...);
-extern int             mprStrlen(char *src, int max);
-
-//     FUTURE (rename to Strcmpi, Strncmpi)
-extern int             mprStrCmpAnyCase(char *s1, char *s2);
-extern int             mprStrCmpAnyCaseCount(char *s1, char *s2, int len);
-extern char            *mprStrLower(char *string);
-extern char            *mprStrUpper(char *string);
-extern char            *mprStrTrim(char *string, char c);
-
-//
-//     Reentrant string and time routines
-//
-extern char            *mprStrTok(char *str, const char *sep, char **last);
-extern char            *mprGetWordTok(char *word, int wordLen, char *str, 
-                                               const char *delim, char **tok);
-extern int             mprCtime(const time_t* timer, char *buf, int bufsize);
-extern int             mprGetTime(MprTime *tp);
-extern int             mprAsctime(const struct tm *timeptr, char *buf, int bufsiz);
-extern struct tm *mprGmtime(time_t* now, struct tm *tmp);
-extern struct tm *mprLocaltime(time_t* now, struct tm *tmp);
-extern int             mprRfcTime(char *buf, int size, const struct tm *timeptr);
-
-//
-//     General other xPlatform routines
-//
-extern char            *mprGetBaseName(char *name);
-extern int             mprGetDirName(char *buf, int bufsize, char *path);
-extern void            mprMakeArgv(char *prog, char *cmd, char ***argv, int *argc);
-extern int             mprMakeDir(char *path);
-extern char    *mprInetNtoa(char *buf, int size, const struct in_addr in);
-extern void            mprSleep(int msec);
-extern struct hostent* mprGetHostByName(char *name);
-extern void            mprFreeGetHostByName(struct hostent* hostp);
-extern int             mprGetRandomBytes(uchar *buf, int size, int block);
-
-#if BLD_FEATURE_MULTITHREAD
-extern char            *mprGetCurrentThreadName();
-extern void            mprLock();
-extern void            mprUnlock();
-#else
-#if __cplusplus
-inline void            mprLock() {};
-inline void            mprUnlock() {};
-#else
-#define mprLock()
-#define mprUnlock()
-#endif
-#endif
-
-extern bool            mprGetDebugMode();
-extern void            mprSetDebugMode(bool on);
-
-extern int             mprGetOsError();
-extern char            *mprGetErrorMsg(int errCode);
-extern char            *mprMakeTempFileName(char *buf, int bufsize, char *tempDir);
-extern void            mprNextFds(char *msg);
-extern char            *mprGetFullPathName(char *buf, int buflen, char *path);
-
-extern void            mprError(char *file, int line, int flags, char *fmt, ...);
-
-
-#if BLD_FEATURE_LOG || !__cplusplus
-extern void            mprLog(int level, char *fmt, ...);
-#endif
-
-typedef void   (*MprMemProc)(int askSize, int totalPoolMem, int limit);
-
-extern void            *mprCalloc(uint numElem, uint size);
-extern int             mprCreateMemHeap(char *userBuf, int initialSize, int limit);
-extern void            mprFree(void *ptr);
-extern void            *mprMalloc(uint size);
-extern void            mprMemClose();
-#if BLD_FEATURE_MALLOC_HOOK
-extern void            mprHookMalloc();
-#endif
-extern void            mprMemStop();
-extern void            mprPrintMemStats();
-extern void            *mprRealloc(void *ptr, uint size);
-extern void            mprRequestMemStats(bool on);
-extern void            mprSetMemHandler(MprMemProc cback);
-extern char            *mprStrdup(const char *str);
-
-#if WIN
-extern int             mprReadRegistry(char *key, char *val, char **buf, int max);
-#endif
-
-
-#if __cplusplus
-} // extern "C"
-#endif
-
-#endif // _h_MPR 
-
-//
-// Local variables:
-// tab-width: 4
-// c-basic-offset: 4
-// End:
-// vim:tw=78
-// vim600: sw=4 ts=4 fdm=marker
-// vim<600: sw=4 ts=4
-//