OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0029152: Coding Rules - eliminate GCC compiler warnings -Wmisleading-indentation when using MinGW

Browse Source 
OSD_File::myFileHandle/myIO pair is now switched within class definition
instead of myFileHandle_is_only_for_Windows/myFileChannel_is_only_for_Linux macros.

OSD_Directory/OSD_Disk/OSD_File methods implementation of WinAPI/non-WinAPI
has been merged within .cxx file and reformatted.
Resolved several inconsistences on handling invalid input
between WinAPI/non-WinAPI implementations.
NCollection_Array1 is now used in several places instead of
raw memory allocation (HeapAlloc()/HeapFree()/new/delete).
TCollection_ExtendedString is used instead of StringCchCopyW.

Unused field OSD_Disk::myQuotaSize and not implemented methods OSD_Disk::*Quota*() have been removed.

Obsolete code fragment "for Visual Age compiler" is removed.
Macro __try is undefined before redefinition on MinGW to avoid warning.
This commit is contained in:
kgv 2017-09-28 21:29:22 +03:00 committed by bugmaster
parent 9026dea8d2
commit cda06ac0e3
8 changed files with 2227 additions and 3239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

225
src/OSD/OSD_Directory.cxx
View File

@ -12,122 +12,65 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _WIN32
#include <OSD_Directory.hxx>
#include <OSD_Path.hxx>
#include <OSD_Protection.hxx>
#include <OSD_WhoAmI.hxx>
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
const OSD_WhoAmI Iam = OSD_WDirectory;
OSD_Directory::OSD_Directory():OSD_FileNode() {
}
OSD_Directory::OSD_Directory(const OSD_Path& Name):OSD_FileNode(Name){
}
// Create physically a directory
void OSD_Directory::Build(const OSD_Protection& Protect){
int status;
Standard_Integer internal_prot;
TCollection_AsciiString aBuffer;
internal_prot = Protect.Internal();
myPath.SystemName(aBuffer);
umask ( 0 );
status = mkdir (aBuffer.ToCString(), (mode_t)internal_prot);
if (status == -1 && errno == ENOENT)
{
OSD_Path aSupPath = myPath;
aSupPath.UpTrek();
aSupPath.SetName (myPath.TrekValue (myPath.TrekLength())); // incredible, but required!
OSD_Directory aSupDir (aSupPath);
aSupDir.Build (Protect);
if (aSupDir.Failed())
{
myError = aSupDir.myError;
return;
}
status = mkdir (aBuffer.ToCString(), (mode_t)internal_prot);
}
if (status == -1 && errno != EEXIST) {
Standard_Character err_message[2048];
Sprintf (err_message, "OSD_Directory::Build Directory \"%.2000s\"",
aBuffer.ToCString());
myError.SetValue (errno, Iam, err_message);
}
}
OSD_Directory OSD_Directory::BuildTemporary(){
OSD_Directory aDirectoryToReturn;
char name[] = "/tmp/CSFXXXXXX";
// Create a temporary directory with 0700 permissions.
if (NULL == mkdtemp( name ))
return aDirectoryToReturn; // Can't create a directory
unlink(name);//Destroys link but directory still exists while
//current process lives.
TCollection_AsciiString aString (name);
aDirectoryToReturn.SetPath ( aString );
return aDirectoryToReturn;
}
#else
//------------------------------------------------------------------------
//------------------- WNT Sources of OSD_Diretory -----------------------
//------------------------------------------------------------------------
#include <OSD_Directory.hxx>
#include <OSD_Protection.hxx>
#include <Standard_ProgramError.hxx>
#include <TCollection_ExtendedString.hxx>
#include <NCollection_String.hxx>
#ifdef _WIN32
#include <OSD_WNT_1.hxx>
#include <stdio.h>
#ifndef _INC_TCHAR
#include <tchar.h>
#endif // _INC_TCHAR
#ifdef _UNICODE
# define tctmpnam _wtmpnam
#else
# define tctmpnam tmpnam
#endif // _UNICODE
#endif
void _osd_wnt_set_error (OSD_Error&, OSD_WhoAmI, ... );
#else
#include <errno.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
OSD_Directory :: OSD_Directory () {
const OSD_WhoAmI Iam = OSD_WDirectory;
#endif
} // end constructor ( 1 )
// =======================================================================
// function : OSD_Directory
// purpose :
// =======================================================================
OSD_Directory::OSD_Directory()
{
//
}
OSD_Directory :: OSD_Directory ( const OSD_Path& Name ) :
OSD_FileNode ( Name ) {
} // end constructor ( 2 )
void OSD_Directory :: Build (const OSD_Protection& Protect) {
TCollection_AsciiString dirName;
myPath.SystemName ( dirName );
if ( dirName.IsEmpty () )
// =======================================================================
// function : OSD_Directory
// purpose :
// =======================================================================
OSD_Directory::OSD_Directory (const OSD_Path& theName)
: OSD_FileNode (theName)
{
//
}
// =======================================================================
// function : Build
// purpose :
// =======================================================================
void OSD_Directory::Build (const OSD_Protection& theProtect)
{
#ifdef _WIN32
TCollection_AsciiString aDirName;
myPath.SystemName (aDirName);
if (aDirName.IsEmpty())
{
throw Standard_ProgramError ( "OSD_Directory::Build(): incorrect call - no directory name");
}
Standard_Boolean isOK = Exists();
if (!isOK)
@ -136,8 +79,8 @@ void OSD_Directory :: Build (const OSD_Protection& Protect) {
myError.Reset();
// create directory if it does not exist;
TCollection_ExtendedString dirNameW(dirName);
if (CreateDirectoryW (dirNameW.ToWideString(), NULL))
TCollection_ExtendedString aDirNameW (aDirName);
if (CreateDirectoryW (aDirNameW.ToWideString(), NULL))
{
isOK = Standard_True;
}
@ -148,43 +91,87 @@ void OSD_Directory :: Build (const OSD_Protection& Protect) {
aSupPath.UpTrek();
aSupPath.SetName (myPath.TrekValue (myPath.TrekLength())); // incredible, but required!
OSD_Directory aSupDir (aSupPath);
aSupDir.Build (Protect);
aSupDir.Build (theProtect);
if (aSupDir.Failed())
{
myError = aSupDir.myError;
return;
}
isOK = (CreateDirectoryW (dirNameW.ToWideString(), NULL) != 0);
isOK = (CreateDirectoryW (aDirNameW.ToWideString(), NULL) != 0);
}
}
if (isOK)
{
#ifndef OCCT_UWP
SetProtection(Protect);
SetProtection (theProtect);
#else
(void)Protect;
(void)theProtect;
#endif
}
else
{
_osd_wnt_set_error (myError, OSD_WDirectory);
}
} // end OSD_Directory :: Build
OSD_Directory OSD_Directory :: BuildTemporary () {
OSD_Directory retVal;
OSD_Protection prt;
wchar_t* aName = _wtmpnam(NULL);
OSD_Path dirPath (TCollection_AsciiString (aName != NULL ? aName : L""));
retVal.SetPath ( dirPath );
retVal.Build ( prt );
return retVal;
} // end OSD_Directory :: BuildTemporary
#else
TCollection_AsciiString aBuffer;
mode_t anInternalProt = (mode_t )theProtect.Internal();
myPath.SystemName (aBuffer);
umask (0);
int aStatus = mkdir (aBuffer.ToCString(), anInternalProt);
if (aStatus == -1 && errno == ENOENT)
{
OSD_Path aSupPath = myPath;
aSupPath.UpTrek();
aSupPath.SetName (myPath.TrekValue (myPath.TrekLength())); // incredible, but required!
OSD_Directory aSupDir (aSupPath);
aSupDir.Build (theProtect);
if (aSupDir.Failed())
{
myError = aSupDir.myError;
return;
}
aStatus = mkdir (aBuffer.ToCString(), anInternalProt);
}
if (aStatus == -1 && errno != EEXIST)
{
char anErrMsg[2048];
Sprintf (anErrMsg, "OSD_Directory::Build Directory \"%.2000s\"", aBuffer.ToCString());
myError.SetValue (errno, Iam, anErrMsg);
}
#endif
}
// =======================================================================
// function : BuildTemporary
// purpose :
// =======================================================================
OSD_Directory OSD_Directory::BuildTemporary()
{
#ifdef _WIN32
wchar_t* aTmpNameW = _wtmpnam (NULL);
if (aTmpNameW == NULL)
{
return OSD_Directory();
}
TCollection_AsciiString aTmpName (aTmpNameW);
OSD_Path aDirPath (aTmpName);
OSD_Directory aDir;
aDir.SetPath (aDirPath);
aDir.Build (OSD_Protection());
return aDir;
#else
// create a temporary directory with 0700 permissions
char aTmpName[] = "/tmp/CSFXXXXXX";
if (NULL == mkdtemp (aTmpName))
{
return OSD_Directory(); // can't create a directory
}
unlink (aTmpName); // destroys link but directory still exists while current process lives
OSD_Directory aDir;
aDir.SetPath (TCollection_AsciiString (aTmpName));
return aDir;
#endif
}

41
src/OSD/OSD_Directory.hxx
View File

@ -17,29 +17,25 @@
#ifndef _OSD_Directory_HeaderFile
#define _OSD_Directory_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <OSD_FileNode.hxx>
class OSD_Path;
class OSD_Protection;
//! Management of directories (a set of directory oriented tools)
class OSD_Directory : public OSD_FileNode
{
public:
DEFINE_STANDARD_ALLOC
//! Creates a temporary Directory in current directory.
//! This directory is automatically removed when object dies.
Standard_EXPORT static OSD_Directory BuildTemporary();
public:
//! Creates Directory object.
//! It is initiliazed to an empty name.
Standard_EXPORT OSD_Directory();
//! Creates Directory object initialized with Name.
Standard_EXPORT OSD_Directory(const OSD_Path& Name);
//! Creates Directory object initialized with theName.
Standard_EXPORT OSD_Directory (const OSD_Path& theName);
//! Creates (physically) a directory.
//! When a directory of the same name already exists, no error is
@ -49,31 +45,6 @@ public:
//! OSDError is raised.
Standard_EXPORT void Build (const OSD_Protection& Protect);
//! Creates a temporary Directory in current directory.
//! This directory is automatically removed when object dies.
Standard_EXPORT static OSD_Directory BuildTemporary();
protected:
private:
};
#endif // _OSD_Directory_HeaderFile

530
src/OSD/OSD_Disk.cxx
View File

@ -12,20 +12,84 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _WIN32
#include <OSD_Disk.hxx>
#include <OSD_OSDError.hxx>
#include <OSD_Path.hxx>
#include <OSD_WhoAmI.hxx>
#include <Standard_ProgramError.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_String.hxx>
#include <TCollection_ExtendedString.hxx>
#ifdef _WIN32
#include <windows.h>
void _osd_wnt_set_error (OSD_Error&, OSD_WhoAmI, ... );
static TCollection_AsciiString _osd_wnt_set_disk_name (const OSD_Path& thePath)
{
{
TCollection_AsciiString aDisk = thePath.Disk();
if (aDisk.UsefullLength() != 0)
{
return aDisk + '/';
}
}
TCollection_AsciiString aDir = thePath.Trek();
const int j = aDir.UsefullLength();
if (j < 3
|| aDir.Value (1) != '|'
|| aDir.Value (2) != '|')
{
throw Standard_ProgramError ("OSD_Disk: bad disk name");
}
aDir.SetValue (1, '\\');
aDir.SetValue (2, '\\');
int k = 0;
for (int i = 3; i <= j; ++i)
{
if (aDir.Value (i) == '|')
{
if (k == 0)
{
aDir.SetValue (i, '\\');
++k;
continue;
}
aDir.SetValue (i, '\\');
break;
}
}
if (k == 0)
{
if (thePath.Name().UsefullLength() == 0
&& thePath.Extension().UsefullLength() == 0)
{
throw Standard_ProgramError ("OSD_Disk: bad disk name");
}
else
{
aDir += '\\';
aDir += thePath.Name();
aDir += thePath.Extension();
}
}
if (aDir.Value (aDir.UsefullLength()) != '\\')
{
aDir += '\\';
}
return aDir;
}
#else
const OSD_WhoAmI Iam = OSD_WDisk;
#ifdef __cplusplus
extern "C" {
#endif
#if defined(__ANDROID__)
#include <sys/vfs.h>
#define statvfs statfs
@ -33,379 +97,135 @@ extern "C" {
#else
#include <sys/statvfs.h>
#endif
#ifdef __cplusplus
}
#include <errno.h>
#endif
#include <errno.h>
OSD_Disk::OSD_Disk() : myQuotaSize(0) {}
OSD_Disk::OSD_Disk(const OSD_Path& name){
DiskName = name.Disk();
myQuotaSize = 0;
}
OSD_Disk::OSD_Disk(const Standard_CString name)
// =======================================================================
// function : OSD_Disk
// purpose :
// =======================================================================
OSD_Disk::OSD_Disk()
{
DiskName = name;
myQuotaSize = 0;
#ifdef _WIN32
const DWORD aBuffLen = GetCurrentDirectoryW (0, NULL);
NCollection_Array1<wchar_t> aBuff (0, aBuffLen);
GetCurrentDirectoryW (aBuffLen, &aBuff.ChangeFirst());
aBuff.ChangeValue (aBuffLen - 1) = (aBuff.Value (aBuffLen - 2) == L'\\') ? L'\0' : L'\\';
aBuff.ChangeLast() = L'\0';
if (aBuffLen > 3 && aBuff.First() != L'\\')
{
aBuff.ChangeValue (3) = L'\0';
myDiskName = TCollection_AsciiString (&aBuff.ChangeFirst());
}
#endif
}
void OSD_Disk::SetName(const OSD_Path& name){
DiskName = name.Disk();
// =======================================================================
// function : OSD_Disk
// purpose :
// =======================================================================
OSD_Disk::OSD_Disk (const OSD_Path& theName)
: myDiskName (theName.Disk())
{
#ifdef _WIN32
myDiskName = _osd_wnt_set_disk_name (theName);
#endif
}
OSD_Path OSD_Disk::Name()const{
OSD_Path result;
result.SetDisk(DiskName);
return(result);
OSD_Disk::OSD_Disk (const Standard_CString theName)
: myDiskName (theName)
{
#ifdef _WIN32
OSD_Path aPath (theName);
myDiskName = _osd_wnt_set_disk_name (aPath);
#endif
}
Standard_Integer OSD_Disk::DiskSize(){
// =======================================================================
// function : SetName
// purpose :
// =======================================================================
void OSD_Disk::SetName (const OSD_Path& theName)
{
myDiskName = theName.Disk();
}
// =======================================================================
// function : Name
// purpose :
// =======================================================================
OSD_Path OSD_Disk::Name() const
{
#ifdef _WIN32
return myDiskName;
#else
OSD_Path aPath;
aPath.SetDisk (myDiskName);
return aPath;
#endif
}
// =======================================================================
// function : DiskSize
// purpose :
// =======================================================================
Standard_Integer OSD_Disk::DiskSize()
{
#ifdef _WIN32
ULARGE_INTEGER aNbFreeAvailableBytes, aNbTotalBytes, aNbTotalFreeBytes;
const TCollection_ExtendedString aDiskNameW (myDiskName);
if (!GetDiskFreeSpaceExW (aDiskNameW.ToWideString(),
&aNbFreeAvailableBytes,
&aNbTotalBytes,
&aNbTotalFreeBytes))
{
_osd_wnt_set_error (myError, OSD_WDisk);
return 0;
}
ULONGLONG aSize = aNbTotalBytes.QuadPart / 512;
return (Standard_Integer )aSize; // may be an overflow
#else
struct statvfs buffer;
if ( statvfs(DiskName.ToCString(),&buffer) == 0 ){
if (statvfs (myDiskName.ToCString(), &buffer) == 0)
{
int BSize512 = buffer.f_frsize / 512;
return buffer.f_blocks * BSize512;
}
else {
myError.SetValue (errno, Iam, "OSD_Disk: statvfs failed.");
return 0;
}
#endif
}
Standard_Integer OSD_Disk::DiskFree(){
// =======================================================================
// function : DiskFree
// purpose :
// =======================================================================
Standard_Integer OSD_Disk::DiskFree()
{
#ifdef _WIN32
ULARGE_INTEGER aNbFreeAvailableBytes, aNbTotalBytes, aNbTotalFreeBytes;
const TCollection_ExtendedString aDiskNameW (myDiskName);
if (!GetDiskFreeSpaceExW (aDiskNameW.ToWideString(),
&aNbFreeAvailableBytes,
&aNbTotalBytes,
&aNbTotalFreeBytes))
{
_osd_wnt_set_error (myError, OSD_WDisk);
return 0;
}
ULONGLONG aSize = aNbFreeAvailableBytes.QuadPart / 512;
return (Standard_Integer )aSize; // may be an overflow
#else
struct statvfs buffer;
if ( statvfs (DiskName.ToCString(),&buffer) == 0 ){
if (statvfs (myDiskName.ToCString(), &buffer) == 0)
{
int BSize512 = buffer.f_frsize / 512;
return buffer.f_bavail * BSize512;
}
else {
myError.SetValue (errno, Iam, "OSD_Disk: statvfs failed.");
return 0;
}
}
Standard_Integer OSD_Disk::DiskQuota(){
//@@@ A faire
return 0;
}
void OSD_Disk::SetDiskQuota(const Standard_Integer ){
// int status;
// struct dqblk quota_info;
#ifdef ULTRIX
// status = quota(Q_SETDLIM,<< User Id>>,&quota_info);
#else
// status = quotactl(Q_SETQLIM,"",<< User Id >>,&quota_info);
#endif
//@@@ A terminer
}
void OSD_Disk::SetQuotaOff(){
//int status;
#ifdef ULTRIX
// status = setquota("","");
#else
// status = quotactl(Q_QUOTAOFF,"",0,NULL);
#endif
//@@@ A faire
}
void OSD_Disk::SetQuotaOn(){
//TCollection_AsciiString quota_file="????";
//int status;
#ifdef ULTRIX
// status = setquota("",quota_file);
#else
// status = quotactl(Q_QUOTAON,"",0,quota_file);
#endif
//@@@ A faire
}
void OSD_Disk::Reset(){
myError.Reset();
}
Standard_Boolean OSD_Disk::Failed()const{
return( myError.Failed());
}
void OSD_Disk::Perror() {
myError.Perror();
}
Standard_Integer OSD_Disk::Error()const{
return( myError.Error());
}
#else
//-------------------------------------------------------------------------------
//---------------------------- Windows NT System --------------------------------
//-------------------------------------------------------------------------------
#include <OSD_Disk.hxx>
#include <OSD_OSDError.hxx>
#include <OSD_Path.hxx>
#include <Standard_ProgramError.hxx>
#include <NCollection_String.hxx>
#include <TCollection_ExtendedString.hxx>
#include <windows.h>
void _osd_wnt_set_error ( OSD_Error&, OSD_WhoAmI, ... );
static void __fastcall _osd_wnt_set_disk_name ( TCollection_AsciiString&, const OSD_Path& );
OSD_Disk :: OSD_Disk () {
DWORD aBuffLen = GetCurrentDirectoryW(0, NULL);
wchar_t* aBuff = new wchar_t[size_t(aBuffLen) + 1];
GetCurrentDirectoryW(aBuffLen, aBuff);
aBuff[aBuffLen - 1] = (aBuff[aBuffLen - 2] == L'\\') ? L'\0' : L'\\';
aBuff[aBuffLen] = L'\0';
if (aBuffLen > 3 && aBuff[0] != L'\\')
{
aBuff[3] = L'\0';
DiskName = TCollection_AsciiString (aBuff);
delete[] aBuff;
}
else
{
DiskName = "";
}
} // end constructor ( 1 )
OSD_Disk :: OSD_Disk ( const OSD_Path& Name ) {
_osd_wnt_set_disk_name ( DiskName, Name );
} // end constructor ( 2 )
OSD_Disk :: OSD_Disk ( const Standard_CString PathName ) {
OSD_Path path ( PathName );
_osd_wnt_set_disk_name ( DiskName, path );
} // end constructor ( 3 )
OSD_Path OSD_Disk :: Name () const {
return DiskName;
} // end OSD_Disk :: Name
void OSD_Disk :: SetName ( const OSD_Path& Name ) {
DiskName = Name.Disk ();
} // end OSD_Disk :: SetName
Standard_Integer OSD_Disk :: DiskSize () {
Standard_Integer retVal = 0;
// DWORD dwSpC;
// DWORD dwBpS;
// DWORD dwFC;
// DWORD dwC;
// if ( !GetDiskFreeSpace ( DiskName.ToCString (), &dwSpC, &dwBpS, &dwFC, &dwC ) )
ULARGE_INTEGER lpFreeBytesAvailableToCaller; // receives the number of bytes on
// disk available to the caller
ULARGE_INTEGER lpTotalNumberOfBytes; // receives the number of bytes on disk
ULARGE_INTEGER lpTotalNumberOfFreeBytes;// receives the free bytes on disk
TCollection_ExtendedString DiskNameW(DiskName);
if (!GetDiskFreeSpaceExW (DiskNameW.ToWideString(),
&lpFreeBytesAvailableToCaller,
&lpTotalNumberOfBytes,
&lpTotalNumberOfFreeBytes))
_osd_wnt_set_error ( myError, OSD_WDisk );
else {
ULONGLONG aSize = lpTotalNumberOfBytes.QuadPart /512;
retVal = ( Standard_Integer ) aSize; // may be an overflow
// retVal = ( Standard_Integer )( dwSpC * dwBpS * dwFC );
}
return retVal;
} // end OSD_Disk :: DiskSize
Standard_Integer OSD_Disk :: DiskFree () {
Standard_Integer retVal = -1;
// DWORD dwSpC;
// DWORD dwBpS;
// DWORD dwFC;
// DWORD dwC;
ULARGE_INTEGER lpFreeBytesAvailableToCaller; // receives the number of bytes on
// disk available to the caller
ULARGE_INTEGER lpTotalNumberOfBytes; // receives the number of bytes on disk
ULARGE_INTEGER lpTotalNumberOfFreeBytes;// receives the free bytes on disk
// if ( !GetDiskFreeSpace ( DiskName.ToCString (), &dwSpC, &dwBpS, &dwFC, &dwC ) )
TCollection_ExtendedString DiskNameW(DiskName);
if (!GetDiskFreeSpaceExW (DiskNameW.ToWideString(),
&lpFreeBytesAvailableToCaller,
&lpTotalNumberOfBytes,
&lpTotalNumberOfFreeBytes))
_osd_wnt_set_error ( myError, OSD_WDisk );
else {
ULONGLONG aSize = lpFreeBytesAvailableToCaller.QuadPart /512;
retVal = ( Standard_Integer ) aSize; // may be an overflow
// retVal = ( Standard_Integer )( dwSpC * dwBpS * dwFC );
}
return retVal;
} // end OSD_Disk :: DiskFree
Standard_Integer OSD_Disk :: DiskQuota () {
return DiskSize ();
} // end OSD_Disk :: DiskQuota
void OSD_Disk :: SetDiskQuota ( const Standard_Integer /*QuotaSize*/ ) {
SetLastError ( ( DWORD )STG_E_UNIMPLEMENTEDFUNCTION );
_osd_wnt_set_error ( myError, OSD_WDisk );
} // end OSD_Disk :: SetDiskQuota
void OSD_Disk :: SetQuotaOn () {
SetLastError ( ( DWORD )STG_E_UNIMPLEMENTEDFUNCTION );
_osd_wnt_set_error ( myError, OSD_WDisk );
} // end OSD_Disk :: SetQuotaOn
void OSD_Disk :: SetQuotaOff () {
SetLastError ( ( DWORD )STG_E_UNIMPLEMENTEDFUNCTION );
_osd_wnt_set_error ( myError, OSD_WDisk );
} // end OSD_Disk :: SetQuotaOff
Standard_Boolean OSD_Disk :: Failed () const {
return myError.Failed ();
} // end OSD_Disk :: Failed
void OSD_Disk :: Reset () {
myError.Reset ();
} // end OSD_Disk :: Reset
void OSD_Disk :: Perror () {
myError.Perror ();
} // end OSD_Disk :: Perror
Standard_Integer OSD_Disk :: Error () const {
return myError.Error ();
} // end OSD_Disk :: Error
static void __fastcall _osd_wnt_set_disk_name ( TCollection_AsciiString& result, const OSD_Path& path ) {
TCollection_AsciiString dir;
result = path.Disk ();
if ( result.UsefullLength () == 0 ) {
int i, j, k;
dir = path.Trek ();
if ( ( j = dir.UsefullLength () ) > 2 &&
dir.Value ( 1 ) == '|' &&
dir.Value ( 2 ) == '|'
) {
dir.SetValue ( 1, '\\');
dir.SetValue ( 2, '\\');
for ( i = 3, k = 0; i <= j; ++i )
if ( dir.Value ( i ) == '|') {
if ( k == 0 ) {
dir.SetValue ( i, '\\');
++k;
continue;
} // end if
dir.SetValue ( i, '\\');
break;
} /* end if */
if ( k == 0 )
{
if ( path.Name ().UsefullLength () == 0 && path.Extension ().UsefullLength () == 0 )
goto badPath;
else {
dir += '\\';
dir += path.Name ();
dir += path.Extension ();
} // end else
}
if ( dir.Value ( dir.UsefullLength () ) != '\\') dir += '\\';
result = dir;
} else {
badPath:
throw Standard_ProgramError ( "OSD_Disk: bad disk name" );
} // end else
} else result += '/';
} // end _osd_set_disk_name
#endif

56
src/OSD/OSD_Disk.hxx
View File

@ -17,18 +17,9 @@
#ifndef _OSD_Disk_HeaderFile
#define _OSD_Disk_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TCollection_AsciiString.hxx>
#include <Standard_Integer.hxx>
#include <OSD_Error.hxx>
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
class OSD_OSDError;
class OSD_Path;
#include <OSD_Path.hxx>
//! Disk management (a set of disk oriented tools)
class OSD_Disk
@ -37,7 +28,6 @@ public:
DEFINE_STANDARD_ALLOC
//! Creates a disk object.
//! This is used only when a class contains a Disk field.
//! By default, its name is initialized to current working disk.
@ -67,57 +57,23 @@ public:
//! Returns free available 512 bytes blocks on disk.
Standard_EXPORT Standard_Integer DiskFree();
//! Returns user's disk quota (in Bytes).
Standard_EXPORT Standard_Integer DiskQuota();
//! Sets user's disk quota (in Bytes).
//! Warning: Needs system administrator privilege.
Standard_EXPORT void SetDiskQuota (const Standard_Integer QuotaSize);
//! Activates user's disk quota
//! Warning: Needs system administrator privilege.
Standard_EXPORT void SetQuotaOn();
//! Deactivates user's disk quota
//! Warning: Needs system administrator privilege.
Standard_EXPORT void SetQuotaOff();
//! Returns TRUE if an error occurs
Standard_EXPORT Standard_Boolean Failed() const;
Standard_Boolean Failed() const { return myError.Failed(); }
//! Resets error counter to zero
Standard_EXPORT void Reset();
void Reset() { myError.Reset(); }
//! Raises OSD_Error
Standard_EXPORT void Perror();
void Perror() { myError.Perror(); }
//! Returns error number if 'Failed' is TRUE.
Standard_EXPORT Standard_Integer Error() const;
protected:
Standard_Integer Error() const { return myError.Error(); }
private:
TCollection_AsciiString DiskName;
Standard_Integer myQuotaSize;
TCollection_AsciiString myDiskName;
OSD_Error myError;
};
#endif // _OSD_Disk_HeaderFile

4452
src/OSD/OSD_File.cxx
View File

File diff suppressed because it is too large Load Diff

67
src/OSD/OSD_File.hxx
View File

@ -17,24 +17,15 @@
#ifndef _OSD_File_HeaderFile
#define _OSD_File_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <OSD_LockType.hxx>
#include <OSD_OpenMode.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
#include <OSD_FileNode.hxx>
#include <OSD_FromWhere.hxx>
#include <OSD_KindFile.hxx>
#include <Standard_Size.hxx>
#include <OSD_LockType.hxx>
#include <OSD_OpenMode.hxx>
class Standard_ProgramError;
class OSD_Path;
class OSD_Protection;
class TCollection_AsciiString;
//! Basic tools to manage files
//! Warning: 'ProgramError' is raised when somebody wants to use the methods
@ -43,9 +34,6 @@ class OSD_File : public OSD_FileNode
{
public:
DEFINE_STANDARD_ALLOC
//! Creates File object.
Standard_EXPORT OSD_File();
@ -118,13 +106,15 @@ public:
//! parameter Readbyte will contain the number of read bytes.
Standard_EXPORT void Read (const Standard_Address Buffer, const Standard_Integer Nbyte, Standard_Integer& Readbyte);
//! Attempts to write Nbyte bytes from the AsciiString to the file
//! associated to the object File.
Standard_EXPORT void Write (const TCollection_AsciiString& Buffer, const Standard_Integer Nbyte);
//! Attempts to write theNbBytes bytes from the AsciiString to the file.
void Write (const TCollection_AsciiString& theBuffer, const Standard_Integer theNbBytes)
{
Write ((Standard_Address )theBuffer.ToCString(), theNbBytes);
}
//! Attempts to write Nbyte bytes from the buffer pointed
//! to by Buffer to the file associated to the object File.
Standard_EXPORT void Write (const Standard_Address Buffer, const Standard_Integer Nbyte);
//! Attempts to write theNbBytes bytes from the buffer pointed
//! to by theBuffer to the file associated to the object File.
Standard_EXPORT void Write (const Standard_Address theBuffer, const Standard_Integer theNbBytes);
//! Sets the seek pointer associated with the open file
Standard_EXPORT void Seek (const Standard_Integer Offset, const OSD_FromWhere Whence);
@ -150,10 +140,17 @@ public:
Standard_EXPORT void UnLock();
//! Returns the current lock state
Standard_EXPORT OSD_LockType GetLock();
OSD_LockType GetLock() const { return myLock; }
//! Returns TRUE if this file is locked.
Standard_EXPORT Standard_Boolean IsLocked();
Standard_Boolean IsLocked() const
{
#ifdef _WIN32
return ImperativeFlag;
#else
return myLock != OSD_NoLock;
#endif
}
//! Returns actual number of bytes of <me>.
Standard_EXPORT Standard_Size Size();
@ -202,32 +199,22 @@ public:
//! aTmp.Close();
Standard_EXPORT int Capture(int theDescr);
protected:
Standard_Integer myIO;
Standard_Address myFILE;
Standard_Integer myFileChannel;
#ifdef _WIN32
Standard_Address myFileHandle;
#else
Standard_Integer myFileChannel;
#endif
Standard_Address myFILE;
Standard_Integer myIO;
private:
Standard_Boolean ImperativeFlag;
OSD_LockType myLock;
OSD_OpenMode myMode;
Standard_Boolean ImperativeFlag;
};
#endif // _OSD_File_HeaderFile

7
src/OSD/OSD_FileNode.cxx
View File

@ -858,6 +858,9 @@ void _osd_wnt_set_error ( OSD_Error& err, OSD_WhoAmI who, ... ) {
} // end _set_error
#if defined(__CYGWIN32__) || defined(__MINGW32__)
#ifdef __try /* is defined on MinGw as either "try" or "if (true)" */
#undef __try
#endif
#define __try
#define __finally
#define __leave return retVal
@ -904,10 +907,6 @@ static BOOL __fastcall _get_file_time (const wchar_t* fName, LPSYSTEMTIME lpSysT
} // end __finally
#ifdef VAC
leave: ; // added for VisualAge
#endif
return retVal;
} // end _get_file_time

2
src/OSD/OSD_signal.cxx
View File

@ -410,6 +410,8 @@ void OSD::SetSignal (const Standard_Boolean theFloatingSignal)
else {
_controlfp (_OSD_FPX, _OSD_FPX); // JR add :
}
#else
(void)theFloatingSignal; // silence compiler warning on MinGw
#endif
} // end OSD :: SetSignal