[occt.git] / src / OSD / OSD_Error.cxx

// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef _WIN32


#include <OSD_Error.hxx>
#include <OSD_ErrorList.hxx>
#include <OSD_OSDError.hxx>
#include <TCollection_AsciiString.hxx>

#include <stdio.h>
/* Created by Stephan GARNAUD (ARM) 1992 for Matra Datavision */
OSD_Error::OSD_Error(){
 myErrno = 0;
}


void OSD_Error::Reset(){
 myErrno = 0;
}

Standard_Boolean OSD_Error::Failed()const{
 if (myErrno == 0) return (Standard_False);
              else return (Standard_True);
}


void OSD_Error::SetValue(const Standard_Integer errcode,
                         const Standard_Integer from,
                         const TCollection_AsciiString& message){
 myErrno = errcode;
 myCode  = (OSD_WhoAmI)from;
 myMessage = message;
}


Standard_Integer OSD_Error::Error()const{
 return(extCode);
}

 
void OSD_Error::Perror() {
 TCollection_AsciiString buffer;

 if (myErrno == 0) return;

 buffer += " :\n ";
 extCode = ERR_SURPRISE;

 switch (myErrno){
  case EBADF  :
   switch (myCode){
    case OSD_WFile:
      buffer += "Invalid file descriptor or bad mode";
      extCode = ERR_FBADF;
      break;
    default:
      break;
    }
    break;


#ifdef SUN
  case EBADMSG:
   switch (myCode){
    case OSD_WFile:
     buffer += 
     "The message waiting to be read on stream is not a data message";
     extCode = ERR_FBADMSG;
     break;
    default:
      break;
   }
   break;
#endif

  case EINVAL: 
   switch (myCode){
    case OSD_WFileNode:
      buffer += "Can't unlink '.' or '..'";
      extCode = ERR_FNINVAL;
      break;
    case OSD_WFile:
      buffer += "Invalid file descriptor";
      extCode = ERR_FINVAL;
      break;
    default :
      buffer += "User error : Bad parameter";
      extCode = ERR_INVAL;
      break;
   }
   break;
#if !defined(sun) && !defined(SOLARIS)
  case EDQUOT :
   switch (myCode){
    case OSD_WDirectory:
    case OSD_WFileNode:
    case OSD_WFile :
     buffer += "Exceed quota of disk blocks";
     extCode = ERR_QUOT;
     break;
    default:
      break;
   }
   break;
#endif

#ifdef SUN
  case EDEADLK:
   switch (myCode){
    case OSD_WFile:
     buffer += "Lock is already blocked by another process";
     extCode = ERR_FDEADLK;
     break;
    default:
      break;
   }
   break;
#endif

  case ENOLCK:
   switch (myCode){
    case OSD_WFile:
     buffer += "No more file lock entries available";
     extCode = ERR_FNOLCK;
     break;
    default:
      break;
   }
   break;
  case EOPNOTSUPP:
   switch (myCode){
    case OSD_WFile:
     buffer += "File descriptor doesn't refer to a file";
     extCode = ERR_FWFD;
     break;
    default:
     break;
   }
   break;
  case EACCES: 
    buffer += "Permission denied";
    extCode = ERR_ACCESS;
    break;
  case EBUSY:
   switch (myCode){
    case OSD_WFileNode:
     buffer += "Still used by system or a process";
     extCode = ERR_FNBUSY;
     break;
    default:
      break;
   }
   break;
  case ERANGE:
   switch (myCode){
    case OSD_WFile:
     buffer += "Not enough or too many bytes written";
     extCode = ERR_FRANGE;
     break;
    default:
      break;
   }
   break;
  case EPERM: 
   switch (myCode){
    case OSD_WPackage:
     buffer += "Permission denied";
     extCode = ERR_PPERM;
     break;
    case OSD_WFileNode:
     buffer += "Permission denied or can't unlink directory";
     extCode = ERR_FPERM;
     break;
    default : 
     buffer += "abnormal error : you modified OSD library";
     extCode = ERR_PERM;
     break;
    }
    break;
  case EROFS:
   switch (myCode){
    case OSD_WFileNode:
    case OSD_WFile:
     buffer += "Read only file system";
     extCode = ERR_ROFS;
     break;
    default:
     break;
   }
   break;
  case ENXIO:
  case EIO :
   switch (myCode){
    case OSD_WDirectory:
    case OSD_WFileNode:
     buffer += "I/O error";
     extCode = ERR_IO;
     break;
    case OSD_WFile :
     buffer += "I/O error or Hang up from terminal";
     extCode = ERR_FIO;
     break;
    default:
     break;
   }
   break;
  case EISDIR :
   switch (myCode){
    case OSD_WFileNode:
    case OSD_WFile :
     buffer += "The File is a Directory";
     extCode = ERR_ISDIR;
     break;
    default:
     break;
    }
    break;

#ifdef SUN
  case EWOULDBLOCK:
   switch (myCode){
    case OSD_WFile:
     buffer += "File is locked";
     extCode = ERR_FLOCKED;
     break;
    default:
     break;
   }
   break;
#endif

#ifdef IRIX4
  case EWOULDBLOCK:
   switch (myCode){
    case OSD_WFile:
     buffer += "File is locked";
     extCode = ERR_FLOCKED;
     break;
    default:
     break;
   }
   break;
#endif

  case EAGAIN:
   switch (myCode){
    case OSD_WFile:
     buffer += "No data ready to be read/written";
     extCode = ERR_FAGAIN;
     break;
    default:
     break;
   }
   break;
  case ENOTDIR:
   switch(myCode){
    case OSD_WDirectory:
    case OSD_WFileNode:
    case OSD_WFile:
     buffer += "A component of path is not a Directory";
     extCode = ERR_NOTDIR;
     break;
    default:
     break;
   }
   break;
  case EMLINK:
   switch (myCode){
    case OSD_WDirectory:
    buffer += "Too many links";
    extCode = ERR_DMLINK;
    break;
    default:
     break;
   }
   break;
  case ELOOP :
   switch (myCode){
    case OSD_WDirectory:
    case OSD_WFileNode:
    case OSD_WFile :
     buffer += "Too many symbolic links";
     break;
    default:
     break;
   }
   break;
  case EFAULT:
   buffer += "User error : arguments point to an illegal address";
   extCode = ERR_FAULT;
   break;
  case EFBIG:
   switch (myCode){
    case OSD_WFile:
     buffer += "Exceed process's file size limit or the maximum file size";
     extCode = ERR_FFBIG; 
     break;
    default:
     break;
   }
   break;
  case EINTR:
   buffer += "operation breaked by a signal";
   extCode = ERR_INTR;
   break;
  case ENOMEM: 
   buffer += "Not enough memory";
   extCode = ERR_NOMEM;
   break;
  case EMFILE : 
   switch(myCode){   
    case OSD_WFile :
       buffer += "Too many file descriptors are currently in use by this process";
       extCode = ERR_FMFILE;
       break;
    default:
     break;
    }
    break;
  case ENAMETOOLONG :
   buffer += "File name too long";
   extCode = ERR_NAMETOOLONG;
   break;
  case ENFILE :
   switch (myCode){
    case OSD_WFile:
     buffer += "Too many files are currently open in the system";
     extCode = ERR_FNFILE;
     break;
    default:
     break;
   }
   break;
  case EXDEV:
   switch (myCode){
    case OSD_WFileNode:
     buffer += "The link named by path2 and the file named by path1 are\n";
     buffer += "on different logical devices (file systems)";
     extCode = ERR_FNXDEV;
     break;
    default:
     break;
   }
   break;
  case ENOENT:
   switch (myCode){
    case OSD_WFileNode:
    case OSD_WFile:
     if (myMessage != "Open") buffer += "File doesn't exist or";
      buffer += "Invalid path (empty string)";
     extCode = ERR_NOENT;
     break;
    case OSD_WDirectory:
     buffer += "A component of the path prefix of path does not exist";
     extCode = ERR_DNOENT;
     break;
    default:
     break;
    }
    break;
  case ENOSPC: {
   switch (myCode){
    case OSD_WDirectory:
    case OSD_WFile:
     buffer += "No more free space on file system";
     extCode = ERR_FNOSPC;
     break;
    default:
     break;
   }
   break;
 }

//
// AIX maps ENOTEMPTY to EEXIST.  Move this case block to
// the EEXIST case block.
//
#if (!defined(_AIX)) && (!defined(AIX))
  case ENOTEMPTY:
   switch (myCode){
    case OSD_WFileNode:
     buffer += "Directory not empty";
     extCode = ERR_FNNOTEMPTY;
     break;
    default:
     break;
   }
   break;
#endif

  case EEXIST: 
   switch(myCode){
    case OSD_WFileNode:
     buffer += "Directory not empty";
     extCode = ERR_FNNOTEMPTY;
     break;
    case OSD_WFile:
     buffer += "OSD_Create and OSD_Exclude are set and the named file exists";
     extCode = ERR_FEXIST;
     break;
    default:
     buffer += "Identifier already exists for this key";
     extCode = ERR_EXIST;
     break;
   }
   break;
  case E2BIG: 
   buffer += "Too many Semaphore/Shared memory for a process.";
   buffer += "Reconfigure Kernel with greater values";
   extCode = ERR_TOOBIG;
   break;
   default: {
     Standard_Character buf[255];
     //
     sprintf(buf,"%sUnknowm error #%d",buffer.ToCString(),myErrno);
     TCollection_AsciiString interm(buf);
     buffer = interm;
     extCode = ERR_UNKNOWN;
   }
 }
 buffer += ".\n\n";
 throw OSD_OSDError(buffer.ToCString());
}

#else

//------------------------------------------------------------------------
//-------------------  Windows NT sources for OSD_Error ------------------
//------------------------------------------------------------------------

#include <OSD_Error.hxx>
#include <OSD_ErrorList.hxx>
#include <TCollection_ExtendedString.hxx>

#include <windows.h>
#include <strsafe.h>

typedef struct _error_table {

                DWORD            wnt_error;
                Standard_Integer csf_error;

               } ERROR_TABLE;

static ERROR_TABLE commErrorTable [] = {

 { ERROR_INVALID_FUNCTION,      ERR_INVAL       },
 { ERROR_FILE_NOT_FOUND,        ERR_NOENT       },
 { ERROR_PATH_NOT_FOUND,        ERR_NOENT       },
 { ERROR_ACCESS_DENIED,         ERR_ACCESS      },
 { ERROR_ARENA_TRASHED,         ERR_NOMEM       },
 { ERROR_NOT_ENOUGH_MEMORY,     ERR_NOMEM       },
 { ERROR_INVALID_BLOCK,         ERR_NOMEM       },
 { ERROR_BAD_ENVIRONMENT,       ERR_TOOBIG      },
 { ERROR_INVALID_ACCESS,        ERR_INVAL       },
 { ERROR_INVALID_DATA,          ERR_INVAL       },
 { ERROR_INVALID_DRIVE,         ERR_NOENT       },
 { ERROR_CURRENT_DIRECTORY,     ERR_ACCESS      },
 { ERROR_NO_MORE_FILES,         ERR_NOENT       },
 { ERROR_LOCK_VIOLATION,        ERR_ACCESS      },
 { ERROR_SHARING_VIOLATION,     ERR_ACCESS      },
 { ERROR_BAD_NETPATH,           ERR_NOENT       },
 { ERROR_NETWORK_ACCESS_DENIED, ERR_ACCESS      },
 { ERROR_BAD_NET_NAME,          ERR_NOENT       },
 { ERROR_FILE_EXISTS,           ERR_EXIST       },
 { ERROR_CANNOT_MAKE,           ERR_ACCESS      },
 { ERROR_FAIL_I24,              ERR_ACCESS      },
 { ERROR_INVALID_PARAMETER,     ERR_INVAL       },
 { ERROR_DRIVE_LOCKED,          ERR_ACCESS      },
 { ERROR_INVALID_HANDLE,        ERR_INVAL       },
 { ERROR_NEGATIVE_SEEK,         ERR_INVAL       },
 { ERROR_SEEK_ON_DEVICE,        ERR_ACCESS      },
 { ERROR_NOT_LOCKED,            ERR_ACCESS      },
 { ERROR_BAD_PATHNAME,          ERR_NOENT       },
 { ERROR_LOCK_FAILED,           ERR_ACCESS      },
 { ERROR_ALREADY_EXISTS,        ERR_EXIST       },
 { ERROR_FILENAME_EXCED_RANGE,  ERR_NOENT       },
 { ERROR_NOT_ENOUGH_QUOTA,      ERR_QUOT        },
 { ERROR_IO_DEVICE,             ERR_IO          },
 { ERROR_INVALID_BLOCK,         ERR_FAULT       },
 { ERROR_BAD_THREADID_ADDR,     ERR_FAULT       },
 { ERROR_INVALID_ADDRESS,       ERR_FAULT       },
 { ERROR_MAPPED_ALIGNMENT,      ERR_FAULT       },
 { ERROR_BUFFER_OVERFLOW,       ERR_NAMETOOLONG }

};

#define COMM_ERR_TABLE_SIZE (int)(sizeof(commErrorTable) / sizeof(commErrorTable[0]))

static ERROR_TABLE dirErrorTable[] = {

 { ERROR_FILE_NOT_FOUND,       ERR_NOENT },
 { ERROR_PATH_NOT_FOUND,       ERR_NOENT },
 { ERROR_INVALID_DRIVE,        ERR_NOENT },
 { ERROR_NO_MORE_FILES,        ERR_NOENT },
 { ERROR_BAD_NETPATH,          ERR_NOENT },
 { ERROR_BAD_NET_NAME,         ERR_NOENT },
 { ERROR_BAD_PATHNAME,         ERR_NOENT },
 { ERROR_FILENAME_EXCED_RANGE, ERR_NOENT }

};

#define DIR_ERR_TABLE_SIZE (int)(sizeof(dirErrorTable) / sizeof(dirErrorTable[0]))

static ERROR_TABLE fileErrorTable[] = {

 { ERROR_INVALID_HANDLE,        ERR_FBADF   },
 { ERROR_INVALID_TARGET_HANDLE, ERR_FBADF   },
 { ERROR_DIRECT_ACCESS_HANDLE,  ERR_FBADF   },
 { ERROR_FILE_EXISTS,           ERR_EXIST   },
 { ERROR_ALREADY_EXISTS,        ERR_EXIST   },
 { ERROR_TOO_MANY_OPEN_FILES,   ERR_FMFILE  },
 { ERROR_INVALID_FUNCTION,      ERR_FINVAL  },
 { ERROR_INVALID_ACCESS,        ERR_FINVAL  },
 { ERROR_INVALID_DATA,          ERR_FINVAL  },
 { ERROR_INVALID_PARAMETER,     ERR_FINVAL  },
 { ERROR_INVALID_HANDLE,        ERR_FINVAL  },
 { ERROR_NEGATIVE_SEEK,         ERR_FINVAL  },
 { ERROR_IO_PENDING,            ERR_FAGAIN  },
 { ERROR_WRITE_FAULT,           ERR_FIO     },
 { ERROR_READ_FAULT,            ERR_FIO     },
 { ERROR_NET_WRITE_FAULT,       ERR_FIO     },
 { ERROR_IO_DEVICE,             ERR_FIO     },
 { ERROR_LOCK_VIOLATION,        ERR_FLOCKED },
 { ERROR_LOCK_FAILED,           ERR_FLOCKED }

};

#define FILE_ERR_TABLE_SIZE (int)(sizeof(fileErrorTable) / sizeof(fileErrorTable[0]))

static ERROR_TABLE fileNodeErrorTable[] = {

 { ERROR_INVALID_FUNCTION,      ERR_FNINVAL    },
 { ERROR_INVALID_ACCESS,        ERR_FNINVAL    },
 { ERROR_INVALID_DATA,          ERR_FNINVAL    },
 { ERROR_INVALID_PARAMETER,     ERR_FNINVAL    },
 { ERROR_INVALID_HANDLE,        ERR_FNINVAL    },
 { ERROR_NEGATIVE_SEEK,         ERR_FNINVAL    },
 { ERROR_DISK_FULL,             ERR_FNOSPC     },
 { ERROR_DIR_NOT_EMPTY,         ERR_FNNOTEMPTY },
 { ERROR_NOT_SAME_DEVICE,       ERR_FNXDEV     }

};

#define FILE_NODE_ERR_TABLE_SIZE (int)(sizeof(fileNodeErrorTable) / sizeof(fileNodeErrorTable[0]))

static Standard_Integer _get_comm_error ( DWORD );

OSD_Error :: OSD_Error () : 
   myCode((OSD_WhoAmI)0),
   extCode(0)
{
 Reset ();
}  // end constructor ( 1 )

void OSD_Error :: Perror () {

 wchar_t buff[32];

  StringCchCopyW(buff, _countof(buff), L"Error ( ");

  switch ( myCode ) {
  
   case OSD_WDirectoryIterator:
     StringCchCatW(buff, _countof(buff), L"OSD_DirectoryIterator");
   break;

   case OSD_WDirectory:
    StringCchCatW(buff, _countof(buff), L"OSD_Directory");
   break;

   case OSD_WFileIterator:
    StringCchCatW(buff, _countof(buff), L"OSD_FileIterator");
   break;

   case OSD_WFile:
    StringCchCatW(buff, _countof(buff), L"OSD_File");
   break;

   case OSD_WFileNode:
    StringCchCatW(buff, _countof(buff), L"OSD_FileNode");
   break;

   case OSD_WHost:
    StringCchCatW(buff, _countof(buff), L"OSD_Host");
   break;

   case OSD_WProcess:
    StringCchCatW(buff, _countof(buff), L"OSD_Environment");
   break;

   case OSD_WEnvironmentIterator:
     StringCchCatW(buff, _countof(buff), L"OSD_EnvironmentIterator");
   break;

   case OSD_WEnvironment:
     StringCchCatW(buff, _countof(buff), L"OSD_Environment");
   break;

   case OSD_WDisk:
     StringCchCatW(buff, _countof(buff), L"OSD_Disk");
   break;

   default:
     StringCchCatW(buff, _countof(buff), L"Unknown");

  }  // end switch

  StringCchCatW(buff, _countof(buff), L" )");

  std::wcerr << buff;
 
 std::cerr << myMessage.ToCString() << std::endl << std::flush;

}  // end OSD_Error :: Perror

void OSD_Error :: SetValue (
                   const Standard_Integer Errcode,
                   const Standard_Integer From,
                   const TCollection_AsciiString& Message
                  ) {

 int i;

 myErrno   = Errcode;
 myCode    = ( OSD_WhoAmI )From;
 myMessage = Message;

 switch ( From ) {
 
  case OSD_WDirectory:

   for ( i = 0; i < DIR_ERR_TABLE_SIZE; ++i )

    if ( dirErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {

     extCode = dirErrorTable[ i ].csf_error;
     break;

   }  // end if

  if ( i == DIR_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );

  break;

  case OSD_WFile:

   for ( i = 0; i < FILE_ERR_TABLE_SIZE; ++i )

    if ( fileErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {

     extCode = fileErrorTable[ i ].csf_error;
     break;

   }  // end if

  if ( i == FILE_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );

  break;
 
  case OSD_WFileNode:

   for ( i = 0; i < FILE_NODE_ERR_TABLE_SIZE; ++i )

    if ( fileNodeErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {

     extCode = fileNodeErrorTable[ i ].csf_error;
     break;

   }  // end if

  if ( i == FILE_NODE_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );

  break;

  default:

   extCode = _get_comm_error ( Errcode );

 }  // end switch

}  // end OSD_Error :: SetValue

Standard_Integer OSD_Error :: Error () const {

 return extCode;

}  // end OSD_Error :: Error

Standard_Boolean OSD_Error :: Failed () const {

 return myErrno == ERROR_SUCCESS ? Standard_False : Standard_True;

}  // end OSD_Error :: Failed

void OSD_Error :: Reset ()
{
  myErrno = ERROR_SUCCESS;
}  // end OSD_Error :: Reset

static Standard_Integer _get_comm_error ( DWORD dwCode ) {

 int              i;
 Standard_Integer retVal = ERR_SURPRISE;

 for ( i = 0; i < COMM_ERR_TABLE_SIZE; ++i )

  if ( commErrorTable[ i ].wnt_error == ( DWORD )dwCode ) {

   retVal = commErrorTable[ i ].csf_error;
   break;

  }  // end if

 return retVal;

}  // end _get_comm_error

#endif
Commit	Line	Data
b311480e	1	// Copyright (c) 1998-1999 Matra Datavision
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
b311480e	5	//
d5f74e42	6	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	7	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
7fd59977	14
57c28b61	15	#ifndef _WIN32
7fd59977	16
42cf5bc1	17
42cf5bc1	18	#include <OSD_Error.hxx>
7fd59977	19	#include <OSD_ErrorList.hxx>
42cf5bc1	20	#include <OSD_OSDError.hxx>
42cf5bc1	21	#include <TCollection_AsciiString.hxx>
7fd59977	22
42cf5bc1	23	#include <stdio.h>
7fd59977	24	/* Created by Stephan GARNAUD (ARM) 1992 for Matra Datavision */
7fd59977	25	OSD_Error::OSD_Error(){
	26	myErrno = 0;
	27	}
	28
	29
	30	void OSD_Error::Reset(){
	31	myErrno = 0;
	32	}
	33
	34	Standard_Boolean OSD_Error::Failed()const{
	35	if (myErrno == 0) return (Standard_False);
	36	else return (Standard_True);
	37	}
	38
	39
	40
	41	void OSD_Error::SetValue(const Standard_Integer errcode,
	42	const Standard_Integer from,
	43	const TCollection_AsciiString& message){
	44	myErrno = errcode;
	45	myCode = (OSD_WhoAmI)from;
	46	myMessage = message;
	47	}
	48
	49
	50
	51	Standard_Integer OSD_Error::Error()const{
	52	return(extCode);
	53	}
	54
	55
	56	void OSD_Error::Perror() {
	57	TCollection_AsciiString buffer;
	58
	59	if (myErrno == 0) return;
	60
	61	buffer += " :\n ";
	62	extCode = ERR_SURPRISE;
	63
	64	switch (myErrno){
	65	case EBADF :
	66	switch (myCode){
	67	case OSD_WFile:
	68	buffer += "Invalid file descriptor or bad mode";
	69	extCode = ERR_FBADF;
	70	break;
7fd59977	71	default:
	72	break;
	73	}
	74	break;
	75
	76
	77	#ifdef SUN
	78	case EBADMSG:
	79	switch (myCode){
	80	case OSD_WFile:
	81	buffer +=
	82	"The message waiting to be read on stream is not a data message";
	83	extCode = ERR_FBADMSG;
	84	break;
	85	default:
	86	break;
	87	}
	88	break;
	89	#endif
	90
	91	case EINVAL:
	92	switch (myCode){
	93	case OSD_WFileNode:
	94	buffer += "Can't unlink '.' or '..'";
	95	extCode = ERR_FNINVAL;
	96	break;
	97	case OSD_WFile:
	98	buffer += "Invalid file descriptor";
	99	extCode = ERR_FINVAL;
	100	break;
7fd59977	101	default :
	102	buffer += "User error : Bad parameter";
	103	extCode = ERR_INVAL;
	104	break;
	105	}
	106	break;
	107	#if !defined(sun) && !defined(SOLARIS)
	108	case EDQUOT :
	109	switch (myCode){
	110	case OSD_WDirectory:
	111	case OSD_WFileNode:
	112	case OSD_WFile :
	113	buffer += "Exceed quota of disk blocks";
	114	extCode = ERR_QUOT;
	115	break;
	116	default:
	117	break;
	118	}
	119	break;
	120	#endif
	121
	122	#ifdef SUN
	123	case EDEADLK:
	124	switch (myCode){
	125	case OSD_WFile:
	126	buffer += "Lock is already blocked by another process";
	127	extCode = ERR_FDEADLK;
	128	break;
7fd59977	129	default:
7fd59977	130	break;
7fd59977	131	}
	132	break;
	133	#endif
	134
	135	case ENOLCK:
	136	switch (myCode){
	137	case OSD_WFile:
	138	buffer += "No more file lock entries available";
	139	extCode = ERR_FNOLCK;
	140	break;
	141	default:
	142	break;
	143	}
	144	break;
	145	case EOPNOTSUPP:
	146	switch (myCode){
	147	case OSD_WFile:
	148	buffer += "File descriptor doesn't refer to a file";
	149	extCode = ERR_FWFD;
	150	break;
	151	default:
	152	break;
	153	}
	154	break;
	155	case EACCES:
	156	buffer += "Permission denied";
	157	extCode = ERR_ACCESS;
	158	break;
	159	case EBUSY:
	160	switch (myCode){
	161	case OSD_WFileNode:
	162	buffer += "Still used by system or a process";
	163	extCode = ERR_FNBUSY;
	164	break;
	165	default:
	166	break;
	167	}
	168	break;
	169	case ERANGE:
	170	switch (myCode){
	171	case OSD_WFile:
	172	buffer += "Not enough or too many bytes written";
	173	extCode = ERR_FRANGE;
	174	break;
7fd59977	175	default:
	176	break;
	177	}
	178	break;
	179	case EPERM:
	180	switch (myCode){
	181	case OSD_WPackage:
	182	buffer += "Permission denied";
	183	extCode = ERR_PPERM;
	184	break;
	185	case OSD_WFileNode:
	186	buffer += "Permission denied or can't unlink directory";
	187	extCode = ERR_FPERM;
	188	break;
7fd59977	189	default :
	190	buffer += "abnormal error : you modified OSD library";
	191	extCode = ERR_PERM;
	192	break;
	193	}
	194	break;
	195	case EROFS:
	196	switch (myCode){
	197	case OSD_WFileNode:
	198	case OSD_WFile:
	199	buffer += "Read only file system";
	200	extCode = ERR_ROFS;
	201	break;
	202	default:
	203	break;
	204	}
	205	break;
	206	case ENXIO:
	207	case EIO :
	208	switch (myCode){
	209	case OSD_WDirectory:
	210	case OSD_WFileNode:
	211	buffer += "I/O error";
	212	extCode = ERR_IO;
	213	break;
	214	case OSD_WFile :
	215	buffer += "I/O error or Hang up from terminal";
	216	extCode = ERR_FIO;
	217	break;
	218	default:
	219	break;
	220	}
	221	break;
	222	case EISDIR :
	223	switch (myCode){
	224	case OSD_WFileNode:
	225	case OSD_WFile :
	226	buffer += "The File is a Directory";
	227	extCode = ERR_ISDIR;
	228	break;
	229	default:
	230	break;
	231	}
	232	break;
	233
	234	#ifdef SUN
	235	case EWOULDBLOCK:
	236	switch (myCode){
	237	case OSD_WFile:
	238	buffer += "File is locked";
	239	extCode = ERR_FLOCKED;
	240	break;
7fd59977	241	default:
7fd59977	242	break;
7fd59977	243	}
	244	break;
	245	#endif
	246
	247	#ifdef IRIX4
	248	case EWOULDBLOCK:
	249	switch (myCode){
	250	case OSD_WFile:
	251	buffer += "File is locked";
	252	extCode = ERR_FLOCKED;
	253	break;
7fd59977	254	default:
7fd59977	255	break;
7fd59977	256	}
	257	break;
	258	#endif
	259
	260	case EAGAIN:
	261	switch (myCode){
	262	case OSD_WFile:
	263	buffer += "No data ready to be read/written";
	264	extCode = ERR_FAGAIN;
	265	break;
	266	default:
	267	break;
	268	}
	269	break;
	270	case ENOTDIR:
	271	switch(myCode){
	272	case OSD_WDirectory:
	273	case OSD_WFileNode:
	274	case OSD_WFile:
	275	buffer += "A component of path is not a Directory";
	276	extCode = ERR_NOTDIR;
	277	break;
	278	default:
	279	break;
	280	}
	281	break;
	282	case EMLINK:
	283	switch (myCode){
	284	case OSD_WDirectory:
	285	buffer += "Too many links";
	286	extCode = ERR_DMLINK;
	287	break;
	288	default:
	289	break;
	290	}
	291	break;
	292	case ELOOP :
	293	switch (myCode){
	294	case OSD_WDirectory:
	295	case OSD_WFileNode:
	296	case OSD_WFile :
	297	buffer += "Too many symbolic links";
	298	break;
	299	default:
	300	break;
	301	}
	302	break;
	303	case EFAULT:
	304	buffer += "User error : arguments point to an illegal address";
	305	extCode = ERR_FAULT;
	306	break;
	307	case EFBIG:
	308	switch (myCode){
	309	case OSD_WFile:
	310	buffer += "Exceed process's file size limit or the maximum file size";
	311	extCode = ERR_FFBIG;
	312	break;
7fd59977	313	default:
	314	break;
	315	}
	316	break;
	317	case EINTR:
	318	buffer += "operation breaked by a signal";
	319	extCode = ERR_INTR;
	320	break;
7fd59977	321	case ENOMEM:
	322	buffer += "Not enough memory";
	323	extCode = ERR_NOMEM;
	324	break;
	325	case EMFILE :
	326	switch(myCode){
	327	case OSD_WFile :
	328	buffer += "Too many file descriptors are currently in use by this process";
	329	extCode = ERR_FMFILE;
	330	break;
7fd59977	331	default:
	332	break;
	333	}
	334	break;
	335	case ENAMETOOLONG :
	336	buffer += "File name too long";
	337	extCode = ERR_NAMETOOLONG;
	338	break;
	339	case ENFILE :
	340	switch (myCode){
	341	case OSD_WFile:
	342	buffer += "Too many files are currently open in the system";
	343	extCode = ERR_FNFILE;
	344	break;
	345	default:
	346	break;
	347	}
	348	break;
	349	case EXDEV:
	350	switch (myCode){
	351	case OSD_WFileNode:
	352	buffer += "The link named by path2 and the file named by path1 are\n";
	353	buffer += "on different logical devices (file systems)";
	354	extCode = ERR_FNXDEV;
	355	break;
	356	default:
	357	break;
	358	}
	359	break;
	360	case ENOENT:
	361	switch (myCode){
	362	case OSD_WFileNode:
	363	case OSD_WFile:
	364	if (myMessage != "Open") buffer += "File doesn't exist or";
	365	buffer += "Invalid path (empty string)";
	366	extCode = ERR_NOENT;
	367	break;
	368	case OSD_WDirectory:
	369	buffer += "A component of the path prefix of path does not exist";
	370	extCode = ERR_DNOENT;
	371	break;
7fd59977	372	default:
	373	break;
	374	}
	375	break;
	376	case ENOSPC: {
	377	switch (myCode){
	378	case OSD_WDirectory:
	379	case OSD_WFile:
	380	buffer += "No more free space on file system";
	381	extCode = ERR_FNOSPC;
	382	break;
7fd59977	383	default:
	384	break;
	385	}
	386	break;
	387	}
	388
	389	//
	390	// AIX maps ENOTEMPTY to EEXIST. Move this case block to
	391	// the EEXIST case block.
	392	//
	393	#if (!defined(_AIX)) && (!defined(AIX))
	394	case ENOTEMPTY:
	395	switch (myCode){
	396	case OSD_WFileNode:
	397	buffer += "Directory not empty";
	398	extCode = ERR_FNNOTEMPTY;
	399	break;
	400	default:
	401	break;
	402	}
	403	break;
	404	#endif
	405
	406	case EEXIST:
	407	switch(myCode){
	408	case OSD_WFileNode:
	409	buffer += "Directory not empty";
	410	extCode = ERR_FNNOTEMPTY;
	411	break;
	412	case OSD_WFile:
	413	buffer += "OSD_Create and OSD_Exclude are set and the named file exists";
	414	extCode = ERR_FEXIST;
	415	break;
	416	default:
	417	buffer += "Identifier already exists for this key";
	418	extCode = ERR_EXIST;
	419	break;
	420	}
	421	break;
	422	case E2BIG:
	423	buffer += "Too many Semaphore/Shared memory for a process.";
	424	buffer += "Reconfigure Kernel with greater values";
	425	extCode = ERR_TOOBIG;
	426	break;
7fd59977	427	default: {
	428	Standard_Character buf[255];
	429	//
	430	sprintf(buf,"%sUnknowm error #%d",buffer.ToCString(),myErrno);
	431	TCollection_AsciiString interm(buf);
	432	buffer = interm;
	433	extCode = ERR_UNKNOWN;
	434	}
	435	}
	436	buffer += ".\n\n";
9775fa61	437	throw OSD_OSDError(buffer.ToCString());
7fd59977	438	}
	439
	440	#else
	441
	442	//------------------------------------------------------------------------
	443	//------------------- Windows NT sources for OSD_Error ------------------
	444	//------------------------------------------------------------------------
	445
7fd59977	446	#include <OSD_Error.hxx>
7fd59977	447	#include <OSD_ErrorList.hxx>
d9ff84e8	448	#include <TCollection_ExtendedString.hxx>
7fd59977	449
7fd59977	450	#include <windows.h>
5fecc495	451	#include <strsafe.h>
7fd59977	452
	453	typedef struct _error_table {
	454
	455	DWORD wnt_error;
	456	Standard_Integer csf_error;
	457
	458	} ERROR_TABLE;
	459
7fd59977	460	static ERROR_TABLE commErrorTable [] = {
	461
	462	{ ERROR_INVALID_FUNCTION, ERR_INVAL },
	463	{ ERROR_FILE_NOT_FOUND, ERR_NOENT },
	464	{ ERROR_PATH_NOT_FOUND, ERR_NOENT },
	465	{ ERROR_ACCESS_DENIED, ERR_ACCESS },
	466	{ ERROR_ARENA_TRASHED, ERR_NOMEM },
	467	{ ERROR_NOT_ENOUGH_MEMORY, ERR_NOMEM },
	468	{ ERROR_INVALID_BLOCK, ERR_NOMEM },
	469	{ ERROR_BAD_ENVIRONMENT, ERR_TOOBIG },
	470	{ ERROR_INVALID_ACCESS, ERR_INVAL },
	471	{ ERROR_INVALID_DATA, ERR_INVAL },
	472	{ ERROR_INVALID_DRIVE, ERR_NOENT },
	473	{ ERROR_CURRENT_DIRECTORY, ERR_ACCESS },
	474	{ ERROR_NO_MORE_FILES, ERR_NOENT },
	475	{ ERROR_LOCK_VIOLATION, ERR_ACCESS },
	476	{ ERROR_SHARING_VIOLATION, ERR_ACCESS },
	477	{ ERROR_BAD_NETPATH, ERR_NOENT },
	478	{ ERROR_NETWORK_ACCESS_DENIED, ERR_ACCESS },
	479	{ ERROR_BAD_NET_NAME, ERR_NOENT },
	480	{ ERROR_FILE_EXISTS, ERR_EXIST },
	481	{ ERROR_CANNOT_MAKE, ERR_ACCESS },
	482	{ ERROR_FAIL_I24, ERR_ACCESS },
	483	{ ERROR_INVALID_PARAMETER, ERR_INVAL },
	484	{ ERROR_DRIVE_LOCKED, ERR_ACCESS },
	485	{ ERROR_INVALID_HANDLE, ERR_INVAL },
	486	{ ERROR_NEGATIVE_SEEK, ERR_INVAL },
	487	{ ERROR_SEEK_ON_DEVICE, ERR_ACCESS },
	488	{ ERROR_NOT_LOCKED, ERR_ACCESS },
	489	{ ERROR_BAD_PATHNAME, ERR_NOENT },
	490	{ ERROR_LOCK_FAILED, ERR_ACCESS },
	491	{ ERROR_ALREADY_EXISTS, ERR_EXIST },
	492	{ ERROR_FILENAME_EXCED_RANGE, ERR_NOENT },
	493	{ ERROR_NOT_ENOUGH_QUOTA, ERR_QUOT },
	494	{ ERROR_IO_DEVICE, ERR_IO },
	495	{ ERROR_INVALID_BLOCK, ERR_FAULT },
	496	{ ERROR_BAD_THREADID_ADDR, ERR_FAULT },
	497	{ ERROR_INVALID_ADDRESS, ERR_FAULT },
	498	{ ERROR_MAPPED_ALIGNMENT, ERR_FAULT },
	499	{ ERROR_BUFFER_OVERFLOW, ERR_NAMETOOLONG }
	500
	501	};
	502
f24125b9	503	#define COMM_ERR_TABLE_SIZE (int)(sizeof(commErrorTable) / sizeof(commErrorTable[0]))
7fd59977	504
	505	static ERROR_TABLE dirErrorTable[] = {
	506
	507	{ ERROR_FILE_NOT_FOUND, ERR_NOENT },
	508	{ ERROR_PATH_NOT_FOUND, ERR_NOENT },
	509	{ ERROR_INVALID_DRIVE, ERR_NOENT },
	510	{ ERROR_NO_MORE_FILES, ERR_NOENT },
	511	{ ERROR_BAD_NETPATH, ERR_NOENT },
	512	{ ERROR_BAD_NET_NAME, ERR_NOENT },
	513	{ ERROR_BAD_PATHNAME, ERR_NOENT },
	514	{ ERROR_FILENAME_EXCED_RANGE, ERR_NOENT }
	515
	516	};
	517
f24125b9	518	#define DIR_ERR_TABLE_SIZE (int)(sizeof(dirErrorTable) / sizeof(dirErrorTable[0]))
7fd59977	519
	520	static ERROR_TABLE fileErrorTable[] = {
	521
	522	{ ERROR_INVALID_HANDLE, ERR_FBADF },
	523	{ ERROR_INVALID_TARGET_HANDLE, ERR_FBADF },
	524	{ ERROR_DIRECT_ACCESS_HANDLE, ERR_FBADF },
	525	{ ERROR_FILE_EXISTS, ERR_EXIST },
	526	{ ERROR_ALREADY_EXISTS, ERR_EXIST },
	527	{ ERROR_TOO_MANY_OPEN_FILES, ERR_FMFILE },
	528	{ ERROR_INVALID_FUNCTION, ERR_FINVAL },
	529	{ ERROR_INVALID_ACCESS, ERR_FINVAL },
	530	{ ERROR_INVALID_DATA, ERR_FINVAL },
	531	{ ERROR_INVALID_PARAMETER, ERR_FINVAL },
	532	{ ERROR_INVALID_HANDLE, ERR_FINVAL },
	533	{ ERROR_NEGATIVE_SEEK, ERR_FINVAL },
	534	{ ERROR_IO_PENDING, ERR_FAGAIN },
	535	{ ERROR_WRITE_FAULT, ERR_FIO },
	536	{ ERROR_READ_FAULT, ERR_FIO },
	537	{ ERROR_NET_WRITE_FAULT, ERR_FIO },
	538	{ ERROR_IO_DEVICE, ERR_FIO },
	539	{ ERROR_LOCK_VIOLATION, ERR_FLOCKED },
	540	{ ERROR_LOCK_FAILED, ERR_FLOCKED }
	541
	542	};
	543
566f8441	544	#define FILE_ERR_TABLE_SIZE (int)(sizeof(fileErrorTable) / sizeof(fileErrorTable[0]))
7fd59977	545
	546	static ERROR_TABLE fileNodeErrorTable[] = {
	547
	548	{ ERROR_INVALID_FUNCTION, ERR_FNINVAL },
	549	{ ERROR_INVALID_ACCESS, ERR_FNINVAL },
	550	{ ERROR_INVALID_DATA, ERR_FNINVAL },
	551	{ ERROR_INVALID_PARAMETER, ERR_FNINVAL },
	552	{ ERROR_INVALID_HANDLE, ERR_FNINVAL },
	553	{ ERROR_NEGATIVE_SEEK, ERR_FNINVAL },
	554	{ ERROR_DISK_FULL, ERR_FNOSPC },
	555	{ ERROR_DIR_NOT_EMPTY, ERR_FNNOTEMPTY },
	556	{ ERROR_NOT_SAME_DEVICE, ERR_FNXDEV }
	557
	558	};
	559
f24125b9	560	#define FILE_NODE_ERR_TABLE_SIZE (int)(sizeof(fileNodeErrorTable) / sizeof(fileNodeErrorTable[0]))
7fd59977	561
	562	static Standard_Integer _get_comm_error ( DWORD );
	563
c24d4017	564	OSD_Error :: OSD_Error () :
	565	myCode((OSD_WhoAmI)0),
	566	extCode(0)
	567	{
7fd59977	568	Reset ();
7fd59977	569	} // end constructor ( 1 )
	570
	571	void OSD_Error :: Perror () {
	572
742cc8b0	573	wchar_t buff[32];
7fd59977	574
742cc8b0	575	StringCchCopyW(buff, _countof(buff), L"Error ( ");
7fd59977	576
	577	switch ( myCode ) {
	578
	579	case OSD_WDirectoryIterator:
742cc8b0	580	StringCchCatW(buff, _countof(buff), L"OSD_DirectoryIterator");
7fd59977	581	break;
	582
	583	case OSD_WDirectory:
742cc8b0	584	StringCchCatW(buff, _countof(buff), L"OSD_Directory");
7fd59977	585	break;
	586
	587	case OSD_WFileIterator:
742cc8b0	588	StringCchCatW(buff, _countof(buff), L"OSD_FileIterator");
7fd59977	589	break;
	590
	591	case OSD_WFile:
742cc8b0	592	StringCchCatW(buff, _countof(buff), L"OSD_File");
7fd59977	593	break;
	594
	595	case OSD_WFileNode:
742cc8b0	596	StringCchCatW(buff, _countof(buff), L"OSD_FileNode");
7fd59977	597	break;
	598
	599	case OSD_WHost:
742cc8b0	600	StringCchCatW(buff, _countof(buff), L"OSD_Host");
7fd59977	601	break;
	602
	603	case OSD_WProcess:
742cc8b0	604	StringCchCatW(buff, _countof(buff), L"OSD_Environment");
7fd59977	605	break;
	606
	607	case OSD_WEnvironmentIterator:
742cc8b0	608	StringCchCatW(buff, _countof(buff), L"OSD_EnvironmentIterator");
7fd59977	609	break;
	610
	611	case OSD_WEnvironment:
742cc8b0	612	StringCchCatW(buff, _countof(buff), L"OSD_Environment");
7fd59977	613	break;
7fd59977	614
7fd59977	615	case OSD_WDisk:
742cc8b0	616	StringCchCatW(buff, _countof(buff), L"OSD_Disk");
7fd59977	617	break;
	618
	619	default:
742cc8b0	620	StringCchCatW(buff, _countof(buff), L"Unknown");
7fd59977	621
	622	} // end switch
	623
742cc8b0	624	StringCchCatW(buff, _countof(buff), L" )");
	625
	626	std::wcerr << buff;
7fd59977	627
46802936	628	std::cerr << myMessage.ToCString() << std::endl << std::flush;
7fd59977	629
	630	} // end OSD_Error :: Perror
	631
	632	void OSD_Error :: SetValue (
	633	const Standard_Integer Errcode,
	634	const Standard_Integer From,
	635	const TCollection_AsciiString& Message
	636	) {
	637
	638	int i;
	639
	640	myErrno = Errcode;
	641	myCode = ( OSD_WhoAmI )From;
	642	myMessage = Message;
	643
	644	switch ( From ) {
	645
	646	case OSD_WDirectory:
	647
	648	for ( i = 0; i < DIR_ERR_TABLE_SIZE; ++i )
	649
	650	if ( dirErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {
	651
	652	extCode = dirErrorTable[ i ].csf_error;
	653	break;
	654
	655	} // end if
	656
	657	if ( i == DIR_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );
	658
	659	break;
	660
	661	case OSD_WFile:
	662
	663	for ( i = 0; i < FILE_ERR_TABLE_SIZE; ++i )
	664
	665	if ( fileErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {
	666
	667	extCode = fileErrorTable[ i ].csf_error;
	668	break;
	669
	670	} // end if
	671
	672	if ( i == FILE_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );
	673
	674	break;
	675
	676	case OSD_WFileNode:
	677
	678	for ( i = 0; i < FILE_NODE_ERR_TABLE_SIZE; ++i )
	679
	680	if ( fileNodeErrorTable[ i ].wnt_error == ( DWORD )Errcode ) {
	681
	682	extCode = fileNodeErrorTable[ i ].csf_error;
	683	break;
	684
	685	} // end if
	686
	687	if ( i == FILE_NODE_ERR_TABLE_SIZE ) extCode = _get_comm_error ( Errcode );
	688
	689	break;
	690
	691	default:
	692
693	extCode = _get_comm_error ( Errcode );
694
695	} // end switch
696
697	} // end OSD_Error :: SetValue
698
699	Standard_Integer OSD_Error :: Error () const {
700
701	return extCode;
702
703	} // end OSD_Error :: Error
704
705	Standard_Boolean OSD_Error :: Failed () const {
706
707	return myErrno == ERROR_SUCCESS ? Standard_False : Standard_True;
708
709	} // end OSD_Error :: Failed
710
46802936	711	void OSD_Error :: Reset ()
	712	{
	713	myErrno = ERROR_SUCCESS;
7fd59977	714	} // end OSD_Error :: Reset
7fd59977	715
7fd59977	716	static Standard_Integer _get_comm_error ( DWORD dwCode ) {
	717
	718	int i;
	719	Standard_Integer retVal = ERR_SURPRISE;
	720
	721	for ( i = 0; i < COMM_ERR_TABLE_SIZE; ++i )
	722
	723	if ( commErrorTable[ i ].wnt_error == ( DWORD )dwCode ) {
	724
	725	retVal = commErrorTable[ i ].csf_error;
	726	break;
	727
	728	} // end if
	729
	730	return retVal;
	731
	732	} // end _get_comm_error
	733
	734	#endif