stdlibx.cpp

opal的ptlib c++源程序 可以从官方网站上下载

//////////////////////////////////////////////////////
//
// VisualStudio 2005 PWLib Port, 
// (c) 2007 Dinsk.net
// [e-mail] 
//
//////////////////////////////////////////////////////
//
// (c) Yuri Kiryanov, [e-mail] and
//     Yuriy Gorvitovskiy
//
// for Openh323, www.Openh323.org
//
// Windows CE Port
//
// stdlib routines implemented through Windows CE API
//

#include <ptlib.h>

#ifdef _WIN32_WCE

//#include <Atlconv.h>
#include <winbase.h>
#include <winnt.h>

#include <ptlib/sockets.h>
#include <ptclib/pdns.h>

#define DELETE (0x00010000L) // defined in <winnt.h> and undef "msos/ptlib/contain.h"

#ifndef __cplusplus
#include <tchar.h>
int isprint(int c) { return _istprint(c);}
int isxdigit(int c) { return _istxdigit(c); }
int isspace( int c ) { return _istspace(c); }
int isupper( int c ) { return _istupper(c); }
int islower( int c ) { return _istlower(c); }
int isalnum( int c ) { return _istalnum(c); }
int isalpha( int c ) { return _istalpha(c); }
int iscntrl( int c ) { return _istcntrl(c); }
int isdigit( int c ) { return _istdigit(c); }
int ispunct( int c ) { return _istpunct(c); }
#endif


void __cdecl abort(void)
{ 
  static HANDLE mutex = CreateSemaphore(NULL, 1, 1, NULL);
  WaitForSingleObject(mutex, INFINITE);

  switch (MessageBox(NULL, _T("Abort?"), _T("Portable Windows Library"),
    MB_ABORTRETRYIGNORE|MB_ICONHAND|MB_APPLMODAL)) {
      case IDABORT :
        ExitProcess(255);

      case IDRETRY :
        DebugBreak();
  }

  ReleaseSemaphore(mutex, 1, NULL);
}


void __cdecl perror(const char * s)
{
  PVarString msg = s;
  MessageBox(NULL, msg, _T("Portable Tools Library"), MB_OK); 
}


long _lseek(int nHandle, long off, int orig)
{
  DWORD dwMoveMethod=FILE_BEGIN;
  switch(orig)
  {
    case SEEK_SET:
      dwMoveMethod=FILE_BEGIN;
      break;
    case SEEK_CUR:
      dwMoveMethod=FILE_CURRENT;
      break;
    case SEEK_END:
      dwMoveMethod=FILE_END;
      break;
  }
  return SetFilePointer((HANDLE)nHandle,off,NULL,dwMoveMethod);
}


int  _close(int nHandle)
{
  FlushFileBuffers((HANDLE)nHandle);
  return (CloseHandle((HANDLE)nHandle)) ? 0 : -1;
}


int  _read(int nHandle, void *p, unsigned int s)
{
  DWORD size=0;
  ReadFile((HANDLE)nHandle,p,s,&size,NULL);
  return size;
}


int  _write(int nHandle, const void *p, unsigned int s)
{
  DWORD size=0;
  WriteFile((HANDLE)nHandle,p,s,&size,NULL);
  //[YG]???? FlushFileBuffers((HANDLE)nHandle);
  return size;
}


int	_open(const char *filename, int oflag , int)
{
  HANDLE	osfh;                    /* OS handle of opened file */
  DWORD	fileaccess;               /* OS file access (requested) */
  DWORD	fileshare;                /* OS file sharing mode */
  DWORD	filecreate;               /* OS method of opening/creating */
  DWORD	fileattrib;               /* OS file attribute flags */

  /*
  * decode the access flags
  */
  switch( oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR) ) 
  {
    case _O_RDONLY:         /* read access */
      fileaccess = GENERIC_READ;
      break;
    case _O_WRONLY:         /* write access */
      fileaccess = GENERIC_WRITE;
      break;
    case _O_RDWR:           /* read and write access */
      fileaccess = GENERIC_READ | GENERIC_WRITE;
      break;
    default:                /* error, bad oflag */
      set_errno(EINVAL);
      return -1;
  }

  /*
  * decode sharing flags
  */
  fileshare = FILE_SHARE_READ | FILE_SHARE_WRITE;

  /*
  * decode open/create method flags
  */
  switch ( oflag & (_O_CREAT | _O_EXCL | _O_TRUNC) ) 
  {
    case 0:
    case _O_EXCL:                   // ignore EXCL w/o CREAT
      filecreate = OPEN_EXISTING;
      break;

    case _O_CREAT:
      filecreate = OPEN_ALWAYS;
      break;

    case _O_CREAT | _O_EXCL:
    case _O_CREAT | _O_TRUNC | _O_EXCL:
      filecreate = CREATE_NEW;
      break;

    case _O_TRUNC:
    case _O_TRUNC | _O_EXCL:        // ignore EXCL w/o CREAT
      filecreate = TRUNCATE_EXISTING;
      break;

    case _O_CREAT | _O_TRUNC:
      filecreate = CREATE_ALWAYS;
      break;

    default:
      // this can't happen ... all cases are covered
      set_errno(EINVAL);
      return -1;
  }

  /*
  * decode file attribute flags if _O_CREAT was specified
  */
  fileattrib = FILE_ATTRIBUTE_NORMAL;     /* default */

  if ( oflag & _O_CREAT ) 
  {
    /*
    * set up variable argument list stuff
    */
    if ( oflag & _O_RDONLY )
      fileattrib = FILE_ATTRIBUTE_READONLY;
  }

  /*
  * Set temporary file (delete-on-close) attribute if requested.
  */
  if ( oflag & _O_TEMPORARY ) 
  {
    fileattrib |= FILE_FLAG_DELETE_ON_CLOSE;
    fileaccess |= DELETE;
  }

  /*
  * Set temporary file (delay-flush-to-disk) attribute if requested.
  */
  if ( oflag & _O_SHORT_LIVED )
    fileattrib |= FILE_ATTRIBUTE_TEMPORARY;

  /*
  * Set sequential or random access attribute if requested.
  */
  if ( oflag & _O_SEQUENTIAL )
    fileattrib |= FILE_FLAG_SEQUENTIAL_SCAN;
  else if ( oflag & _O_RANDOM )
    fileattrib |= FILE_FLAG_RANDOM_ACCESS;

  /*
  * get an available handle.
  *
  * multi-thread note: the returned handle is locked!
  */
  /*
  * try to open/create the file
  */

  PWideString widefilename = filename;
  if ( (osfh = CreateFile(widefilename,
                          fileaccess,
                          fileshare,
                          NULL,
                          filecreate,
                          fileattrib,
                          NULL ))
                          == INVALID_HANDLE_VALUE )
  {
    return -1;                      /* return error to caller */
  }
  return (int)osfh;
}


int _sopen(const char *filename, int oflag , int pmode, ...)
{ 
  return _open(filename, oflag , pmode); 
}


int	_chsize( int nHandle, long size )
{
  if ((DWORD)size!=SetFilePointer((HANDLE)nHandle,size,NULL,FILE_BEGIN))
    return -1;

  return (SetEndOfFile((HANDLE)nHandle)) ? 0 : -1;
}



int _mkdir(const char *sDir)
{	
  PString folderName = sDir;

  if (folderName[folderName.GetLength() - 1] == PDIR_SEPARATOR) {
    folderName.Delete(folderName.GetLength() - 1, 1);
  }

  return (CreateDirectory(folderName.AsUCS2(),NULL) ? 0 : -1);
}

int  _rmdir(const char *sDir)
{	
  PString folderName = sDir;
  if (folderName[folderName.GetLength() - 1] == PDIR_SEPARATOR)
    folderName.Delete(folderName.GetLength() - 1, 1);

  return (RemoveDirectory(folderName.AsUCS2()) ? 0 : -1);
}


int  _access(const char *sName, int mode)
{
  WIN32_FIND_DATA FindFileData;

  PString test(sName);
  if (test[test.GetLength() - 1] == '.' && test[test.GetLength() - 2] == PDIR_SEPARATOR)
    test.Delete(test.GetLength() - 2, 2);

  HANDLE file = FindFirstFile(test.AsUCS2(), &FindFileData);

  if (file == INVALID_HANDLE_VALUE ) 
    return -1;

  FindClose(file);

  switch(mode)
  {
    case 0: //checking for the existance
      return 0;
    case 4: //checking for read permission
      return 0;
    case 2: //checking for write permission
      return (FindFileData.dwFileAttributes&FILE_ATTRIBUTE_READONLY) ? -1 : 0;
    case 6: //checking for read and write permission
      return (FindFileData.dwFileAttributes&FILE_ATTRIBUTE_READONLY) ? -1 : 0;
  }
  return -1;
}


int	remove(const char *name)
{
  PVarString filename = name;
  return (DeleteFile(filename) ? 0 : -1);
}


int	_chmod( const char *filename, int pmode )
{
  PString pstrFileName(filename);
  DWORD attr = GetFileAttributes(pstrFileName.AsUCS2());
  if (pmode&_S_IWRITE)
    attr|=FILE_ATTRIBUTE_READONLY;
  else
    attr&=~FILE_ATTRIBUTE_READONLY;

  return (SetFileAttributes(pstrFileName.AsUCS2(), attr) ? 0: -1);	
}


int	rename( const char *oldname, const char *newname )
{
  PString pstrOldFileName(oldname);
  PString pstrNewFileName(newname);
  return (DeleteAndRenameFile(pstrNewFileName.AsUCS2(), pstrOldFileName.AsUCS2()) ? 0 : -1);
}

//used by regex.cxx
void printchar (char n)
{
  printf(" %d ",n);	
}


#if _WIN32_WCE < 0x501

long strtol (const char *nptr,char **endptr,int ibase)
{
  const TCHAR* tnptr = PString(nptr).AsUCS2();
  TCHAR* tendptr = NULL;

  long res= _tcstoul(tnptr,&tendptr,ibase);
  if (endptr)
  {
    if (tendptr) 
      *endptr=const_cast<char*>(nptr+(tendptr-tnptr));
    else		 
      *endptr=NULL;
  }
  return res;
}

unsigned long strtoul (const char *nptr,char **endptr,int ibase)
{
  const TCHAR* tnptr = PString(nptr).AsUCS2();
  TCHAR* tendptr = NULL;

  unsigned long res= _tcstoul(tnptr,&tendptr,ibase);
  if (endptr)
  {
    if (tendptr)
      *endptr=const_cast<char*>(nptr+(tendptr-tnptr));
    else
      *endptr=NULL;
  }
  return res;
}

double strtod( const char *nptr, char **endptr )
{
  const TCHAR* tnptr = PString(nptr).AsUCS2();
  TCHAR* tendptr = NULL;

  double res= _tcstod(tnptr,&tendptr);
  if (endptr)
  {
    if (tendptr)
      *endptr=const_cast<char*>(nptr+(tendptr-tnptr));
    else
      *endptr=NULL;
  }
  return res;
}


size_t strspn( const char *string, const char *strCharSet )
{
  const unsigned char *str = (const unsigned char*)string;
  const unsigned char *ctrl = (const unsigned char*)strCharSet;

  unsigned char map[32];
  int count;

  /* Clear out bit map */