---

OS.cpp

Go to the documentation of this file.

//#include <errno.h>
#include "OSDependent/OS.h"

const char OS::DirectorySeparator  = '\\';
const char *OS::TemporaryDirectory = "C:\\Temp";
const char *OS::LineSeparator      = "\r\n";
/*
 * Get the hostname of this machine.
 * The returned value is statically allocated, so the user does 
 * not need to deallocate.  This value will not change, so we
 * are safe to use static memory.
 *
 * Returns name on success, NULL on failure.
 */
const char *
OS::getMyHostName()
{        
    return NULL;  
}

/*
 * Reentrant version of strtok.
 */
char *
OS::strtok_r(char *s, const char *tokens, char **lasts)
{
  if (s == NULL)
    s = *lasts;
  else
    *lasts = s;
  if (*s == '\0') 
    return NULL;
  char *end = s + strlen(s);
  s = ::strtok(s, tokens);
  if (s == NULL)
    return NULL;
  int l_sub = strlen(s);
  *lasts = s + l_sub;
  if (end != s + l_sub)
    *lasts += 1;
  return s;
}


char *
OS::strdup(const char *orig)
{
        if(orig==0)
                return 0;

        char *temp = new char[strlen(orig)+1];
        strcpy(temp,orig);

        return temp;
}

int
OS::remove(const char *name)
{
/*  if (::DeleteFile(__TEXT(name)) == FALSE)
    return -1;*/
  return 0;
}

bool
OS::isDirectory(const char *name)
{
/*  DWORD attributes = ::GetFileAttributes(__TEXT(name));
        if (attributes == -1)
                return false;
  return (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0 ? false : true;*/
    return false;
}

int
OS::mkdir(const char *name)
{
  // Check if directory already exists.  If not try to create it.
/*  if (isDirectory(name))
    return 0;
  if (::CreateDirectory(__TEXT(name), NULL) == FALSE)
    return -1;*/
  return 0;
}

int
OS::rmdir(const char *name)
{
/*  if (::RemoveDirectory(__TEXT(name)) == FALSE)
    return -1;*/
  return 0;
}

int
OS::rename(const char *src, const char *dst)
{
/*  if (::MoveFileEx(__TEXT(src), __TEXT(dst), MOVEFILE_REPLACE_EXISTING) == FALSE)
    return -1;*/
  return 0;
}

char *
OS::getProcessorName ()
{
  static char buf[512];
  OSVERSIONINFO osvi;
  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

  ::GetVersionEx (&osvi);

  switch(osvi.dwPlatformId) {
  case VER_PLATFORM_WIN32s:
  case VER_PLATFORM_WIN32_WINDOWS:
    OS::strcpy(buf,"windows");
    break;
  case VER_PLATFORM_WIN32_NT:
    OS::strcpy(buf,"windows-nt");
    break;
  default:
    OS::strcpy(buf,"windows-unknown");
    break;
  }
  
  return(buf);
}

char *
OS::getOSName()
{
  static char buf[512];
  SYSTEM_INFO si;

  ::GetSystemInfo(&si);

  if (OS::strcmp(getProcessorName(), "windows-nt") == 0) {
    if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
      switch (si.wProcessorLevel) {
      case 3: 
        OS::strcpy(buf,"i386");
        break;
      case 4: 
        OS::strcpy(buf,"i486");
        break;
      case 5: 
        OS::strcpy(buf, "i586");
        break;
      default:        
        OS::strcpy(buf,"intel");
        break;
      }
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_MIPS) {
      OS::strcpy(buf,"mips");
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA) {
      OS::sprintf(buf, "Alpha%d", si.wProcessorLevel);
    } else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_PPC) {
      OS::sprintf(buf, "PPC 6%02d", si.wProcessorLevel);
    }
  } else {
    if (si.dwProcessorType == PROCESSOR_INTEL_386) {
      OS::strcpy(buf,"i386");
    } else if (si.dwProcessorType == PROCESSOR_INTEL_486) {
      OS::strcpy(buf,"i486");
    } else if (si.dwProcessorType == PROCESSOR_INTEL_PENTIUM) {
      OS::strcpy(buf,"i586");
    } else OS::strcpy(buf,"intel");
  }

  return (buf);
}

/*
 * Convert the last error to errno.
 */
int
OS::getErrno()
{
  int val = 0;
/*  switch (GetLastError()) {
    case ERROR_INVALID_HANDLE:
      val = EISDIR;
      break;
    case ERROR_ACCESS_DENIED:
      val = EROFS;
      break;
    case ERROR_NOT_ENOUGH_MEMORY:
      val = ENOSPC;
      break;
    case ERROR_TOO_MANY_OPEN_FILES:
      val = EMFILE;
      break;
    case ERROR_BUFFER_OVERFLOW:
      val = ENAMETOOLONG;
      break;
    case ERROR_OUTOFMEMORY:
      val = ENOMEM;
      break;
    case ERROR_FILE_NOT_FOUND:
      val = ENOENT;
      break;
    case ERROR_PATH_NOT_FOUND:
      val = ENOTDIR;
      break;
    case ERROR_INVALID_FUNCTION:
    default:
      val = EINVAL;
      break;
  }*/
  return val;
}

/*
 * Get an environment variable.
 */
char *
OS::getenv(const char *str)
{
        //return ::getenv(str);
    return NULL;
}

/*
 * Start a new process.
 */
int
OS::system(const char *fmt, ...)
{
/*  char cmd[512] = "start ";
  va_list ap;
  va_start(ap, fmt);
  if (::vsprintf(cmd+strlen(cmd), fmt, ap) < 0) {
    va_end(ap);
    return -1;
  }
  if (::system(cmd) < 0) {
    va_end(ap);
    return -1;
  }
  va_end(ap);*/
  return 0;
}


int 
OS::sprintf( char *buffer, const char *format, ... )
{
    va_list vl;
    int i,j=0;
        char temp[256];
        
    //  format is the last argument specified; all
    //   others must be accessed using the variable-
    //   argument macros.
    va_start( vl, format );

    // Step through the list.
    for( i = 0; format[i] != '\0'; ++i )
    {
        union Printable_t
        {
            int     i;
            float   f;
            char    c;
            char   *s;
        } Printable;

                if(format[i]!='%')
                {
                        buffer[j++]=format[i];
                }
                else
                {
            buffer[j]=0;
            //A % was detected. Move the pointer to the next char and retrieve the
                        //right parameter.
                        i++;
                        switch( format[i] )    // Type to expect.
                        {
                                case 'd':
                                        Printable.i = va_arg( vl, int );
                                        _itoa( Printable.i, temp, 10 );
                                        strcat(buffer, temp);
                                        j+=strlen(temp);
                                        break;

                        case 'c':
                                        Printable.c = va_arg( vl, char );
                                        buffer[j] = Printable.c ;
                                        j++;
                                        break;

                                case 's':
                                        Printable.s = va_arg( vl, char * );
                                        strcat(buffer,Printable.s);
                                        j+=strlen(Printable.s);
                                        break;

                                default:
                                        break;
                        }
        }
    }
    va_end( vl );

    buffer[j]=0;

    return j;
}


char OS::setValue (char *key, char *subKey, char* value)
{
    LONG lResult;
    HKEY   hkey; 
    DWORD dwSize;
    WCHAR uniBuffer[512];

    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, key, -1, uniBuffer, 1024 );

    lResult = RegCreateKeyEx( HKEY_LOCAL_MACHINE, uniBuffer, 0, 0, 0, 0, NULL, &hkey, &dwSize );

    if ( ERROR_SUCCESS != lResult )
    {
        return -1;
    }

    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, subKey, -1, uniBuffer, 512 );

    RegSetValueEx( hkey, uniBuffer, 0, REG_SZ, (const unsigned char*)value, strlen(value)+1);
    RegCloseKey( hkey );

    return 1;
}


char *OS::getValue (char *key, char *subkey)
{
    LONG lResult;
    HKEY   hkey; 
    WCHAR uniBuffer[1024];
    char value[256];
    DWORD dwSize = 256;
    
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, key, -1, uniBuffer, 1024 );
    lResult = RegOpenKeyEx( HKEY_LOCAL_MACHINE, uniBuffer, 0, 0, &hkey);

    if ( ERROR_SUCCESS != lResult )
        return 0;

    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, subkey, -1, uniBuffer, 1024 );

    RegQueryValueEx( hkey, uniBuffer, 0, NULL, (LPBYTE)value, &dwSize);
    RegCloseKey( hkey );

    return strdup(value);
}


void OS::free(void *p)
{
    MemoryManager::globalMemMgr_->freeMem(p);
}

void *OS::malloc(size_t t)
{
    return ::malloc(t);
}

---