OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-29 14:00:49 +03:00
Code Activity

0024002: Overall code and build procedure refactoring -- automatic

Browse Source 
Automatic upgrade of OCCT code by command "occt_upgrade . -nocdl":
- WOK-generated header files from inc and sources from drv are moved to src
- CDL files removed
- All packages are converted to nocdlpack
This commit is contained in:
abv
2015-07-12 07:42:38 +03:00
parent 543a996496
commit 42cf5bc1ca
15354 changed files with 623957 additions and 509844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
src/Standard/FILES
View File

@@ -1,61 +1,101 @@
EXTERNLIB
Standard_PCharacter.hxx
Standard_PExtCharacter.hxx
Standard_MMgrRoot.cxx
Standard_MMgrRoot.hxx
Standard.cxx
Standard.hxx
Standard_AbortiveTransaction.hxx
Standard_Address.hxx
Standard_Assert.hxx
Standard_Atomic.hxx
Standard_Boolean.hxx
Standard_Byte.hxx
Standard_Character.hxx
Standard_CLocaleSentry.cxx
Standard_CLocaleSentry.hxx
Standard_ConstructionError.hxx
Standard_Copy.tcl
Standard_CString.cxx
Standard_CString.hxx
Standard_DefineAlloc.hxx
Standard_DefineException.hxx
Standard_DefineHandle.hxx
Standard_DimensionError.hxx
Standard_DimensionMismatch.hxx
Standard_DivideByZero.hxx
Standard_DomainError.hxx
Standard_ErrorHandler.cxx
Standard_ErrorHandler.hxx
Standard_ErrorHandler.lxx
Standard_ErrorHandlerCallback.cxx
Standard_ErrorHandlerCallback.hxx
Standard_ErrorHandlerCallback.lxx
Standard_ExtCharacter.hxx
Standard_ExtString.cxx
Standard_ExtString.hxx
Standard_Failure.cxx
Standard_Failure.hxx
Standard_Failure.lxx
Standard_GUID.cxx
Standard_GUID.hxx
Standard_Handle.hxx
Standard_HandlerStatus.hxx
Standard_ImmutableObject.hxx
Standard_Integer.hxx
Standard_IStream.hxx
Standard_JmpBuf.hxx
Standard_LicenseError.hxx
Standard_LicenseNotFound.hxx
Standard_Macro.hxx
Standard_math.cxx
Standard_math.hxx
Standard_MMgrOpt.cxx
Standard_MMgrOpt.hxx
Standard_MMgrRaw.cxx
Standard_MMgrRaw.hxx
Standard_JmpBuf.hxx
Standard_CMPLRS.edl
Standard_Copy.tcl
Standard_WOKSteps.edl
Standard_Address.hxx
Standard_Boolean.hxx
Standard_Byte.hxx
Standard_PByte.hxx
Standard_CLocaleSentry.hxx
Standard_CLocaleSentry.cxx
Standard_CString.cxx
Standard_CString.hxx
Standard_Character.hxx
Standard_ExtCharacter.hxx
Standard_ExtString.cxx
Standard_ExtString.hxx
Standard_Handle.hxx
Standard_IStream.hxx
Standard_Integer.hxx
Standard_Macro.hxx
Standard_OStream.hxx
Standard_Persistent.hxx
Standard_PrimitiveTypes.hxx
Standard_Real.cxx
Standard_Real.hxx
Standard_SStream.cxx
Standard_SStream.hxx
Standard_ShortReal.cxx
Standard_ShortReal.hxx
Standard_Stream.hxx
Standard_Time.hxx
Standard_Transient.hxx
Standard_TypeDef.hxx
Standard_Type.hxx
Standard_Type.cxx
Standard_math.cxx
Standard_math.hxx
Standard_values.h
Standard_DefineHandle.hxx
Standard_UUID.cxx
Standard_UUID.hxx
Standard_Version.hxx
Standard_Mutex.hxx
Standard_Mutex.cxx
Standard_Size.hxx
Standard_ThreadId.hxx
Standard_Atomic.hxx
Standard_DefineException.hxx
Standard_MMgrRoot.cxx
Standard_MMgrRoot.hxx
Standard_MMgrTBBalloc.cxx
Standard_MMgrTBBalloc.hxx
Standard_Assert.hxx
Standard_DefineAlloc.hxx
Standard_MultiplyDefined.hxx
Standard_Mutex.cxx
Standard_Mutex.hxx
Standard_NegativeValue.hxx
Standard_NoMoreObject.hxx
Standard_NoSuchObject.hxx
Standard_NotImplemented.hxx
Standard_NullObject.hxx
Standard_NullValue.hxx
Standard_NumericError.hxx
Standard_OStream.hxx
Standard_OutOfMemory.hxx
Standard_OutOfRange.hxx
Standard_Overflow.hxx
Standard_PByte.hxx
Standard_PCharacter.hxx
Standard_PErrorHandler.hxx
Standard_Persistent.cxx
Standard_Persistent.hxx
Standard_PExtCharacter.hxx
Standard_PrimitiveTypes.hxx
Standard_ProgramError.hxx
Standard_RangeError.hxx
Standard_Real.cxx
Standard_Real.hxx
Standard_ShortReal.cxx
Standard_ShortReal.hxx
Standard_Size.hxx
Standard_SStream.cxx
Standard_SStream.hxx
Standard_Stream.hxx
Standard_ThreadId.hxx
Standard_Time.hxx
Standard_TooManyUsers.hxx
Standard_Transient.cxx
Standard_Transient.hxx
Standard_Type.cxx
Standard_Type.hxx
Standard_TypeDef.hxx
Standard_TypeMismatch.hxx
Standard_Underflow.hxx
Standard_UUID.cxx
Standard_UUID.hxx
Standard_values.h
Standard_Version.hxx

148
src/Standard/Standard.cdl
View File

@@ -1,148 +0,0 @@
-- Created on: 1991-09-05
-- Created by: J.P. TIRAUlt
-- Copyright (c) 1991-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.
-- C. LEYNADIER
package Standard
---Purpose:
-- The package Standard provides the minimum services necessary
-- for other toolkits to handle persistent and transient objects.
-- It is the Standard run-time encapsulation of the CAS.CADE
-- database, that is, it defines a single programming interface
-- for creating and accessing persistent objects manipulated by
-- handles.
is
enumeration HandlerStatus is HandlerVoid, HandlerJumped, HandlerProcessed;
imported IStream;
imported OStream;
imported SStream;
imported UUID;
imported JmpBuf;
imported ThreadId;
primitive CString;
primitive ExtString;
primitive Address;
primitive Size;
primitive PByte;
primitive PCharacter;
primitive PExtCharacter;
primitive Utf8Char;
primitive Utf16Char;
primitive Utf32Char;
primitive WideChar;
deferred class ErrorHandlerCallback;
class ErrorHandler;
primitive Boolean;
primitive Character;
primitive ExtCharacter;
primitive Integer;
primitive Byte;
primitive Real;
primitive ShortReal;
primitive Time;
primitive OId;
class GUID;
imported deferred class Persistent ;
imported deferred class Transient ;
imported transient class Type; -- inherits Transient
class Failure; -- inherits Transient
exception AbortiveTransaction inherits Failure;
exception DomainError inherits Failure;
exception ConstructionError inherits DomainError;
exception NullObject inherits DomainError;
exception NoSuchObject inherits DomainError;
exception NoMoreObject inherits DomainError;
exception ImmutableObject inherits DomainError;
exception TypeMismatch inherits DomainError;
exception MultiplyDefined inherits DomainError;
exception DimensionError inherits DomainError;
exception DimensionMismatch inherits DimensionError;
exception RangeError inherits DomainError;
exception OutOfRange inherits RangeError;
exception NullValue inherits RangeError;
exception NegativeValue inherits RangeError;
exception NumericError inherits Failure;
exception Underflow inherits NumericError;
exception Overflow inherits NumericError;
exception DivideByZero inherits NumericError;
exception ProgramError inherits Failure;
exception NotImplemented inherits ProgramError;
exception OutOfMemory inherits ProgramError;
exception LicenseError inherits Failure;
exception LicenseNotFound inherits LicenseError;
exception TooManyUsers inherits LicenseError;
pointer PErrorHandler to ErrorHandler;
--
-- Mutex: a class to synchronize access to shared data
-- from threads within one process
--
imported Mutex;
--
-- Memory manager
--
Allocate (aSize: Size from Standard)
returns Address from Standard;
---Purpose: Allocates memory blocks
-- aSize - bytes to allocate
Free (aStorage: Address from Standard);
---Purpose: Deallocates memory blocks
-- aStorage - previously allocated memory block to be freed
---C++: alias "template <typename T> static inline void Free (T*& thePtr) { Free ((void*)thePtr); thePtr = 0; }"
Reallocate(aStorage: Address from Standard;
aNewSize: Size from Standard)
returns Address from Standard;
---Purpose: Reallocates memory blocks
-- aStorage - previously allocated memory block
-- aNewSize - new size in bytes
AllocateAligned (theSize : Size from Standard;
theAlign : Size from Standard)
returns Address from Standard;
---Purpose: Allocates aligned memory blocks.
-- Should be used with CPU instructions which require specific alignment.
-- For example: SSE requires 16 bytes, AVX requires 32 bytes.
-- @param theSize bytes to allocate
-- @param theAlign alignment in bytes
FreeAligned (thePtrAligned : Address from Standard);
---Purpose: Deallocates memory blocks
-- @param thePtrAligned the memory block previously allocated with AllocateAligned()
---C++: alias "template <typename T> static inline void FreeAligned (T*& thePtrAligned) { FreeAligned ((void* )thePtrAligned); thePtrAligned = 0; }"
Purge returns Integer from Standard;
---Purpose: Deallocates the storage retained on the free list
-- and clears the list.
-- Returns non-zero if some memory has been actually freed.
end Standard;

5
src/Standard/Standard.cxx
View File

@@ -14,14 +14,13 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard.ixx>
#include <stdlib.h>
#include <Standard.hxx>
#include <Standard_MMgrOpt.hxx>
#include <Standard_MMgrRaw.hxx>
#include <Standard_MMgrTBBalloc.hxx>
#include <stdlib.h>
#if(defined(_WIN32) || defined(__WIN32__))
#include <windows.h>
#include <malloc.h>

103
src/Standard/Standard.hxx Normal file
View File

@@ -0,0 +1,103 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_HeaderFile
#define _Standard_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Size.hxx>
#include <Standard_Integer.hxx>
class Standard_ErrorHandlerCallback;
class Standard_ErrorHandler;
class Standard_GUID;
class Standard_Persistent;
class Standard_Transient;
class Standard_Failure;
class Standard
{
public:
DEFINE_STANDARD_ALLOC
//! Allocates memory blocks
//! aSize - bytes to allocate
Standard_EXPORT static Standard_Address Allocate (const Standard_Size aSize);
//! Deallocates memory blocks
//! aStorage - previously allocated memory block to be freed
Standard_EXPORT static void Free (const Standard_Address aStorage);
template <typename T> static inline void Free (T*& thePtr) { Free ((void*)thePtr); thePtr = 0; }
//! Reallocates memory blocks
//! aStorage - previously allocated memory block
//! aNewSize - new size in bytes
Standard_EXPORT static Standard_Address Reallocate (const Standard_Address aStorage, const Standard_Size aNewSize);
//! Allocates aligned memory blocks.
//! Should be used with CPU instructions which require specific alignment.
//! For example: SSE requires 16 bytes, AVX requires 32 bytes.
//! @param theSize bytes to allocate
//! @param theAlign alignment in bytes
Standard_EXPORT static Standard_Address AllocateAligned (const Standard_Size theSize, const Standard_Size theAlign);
//! Deallocates memory blocks
//! @param thePtrAligned the memory block previously allocated with AllocateAligned()
Standard_EXPORT static void FreeAligned (const Standard_Address thePtrAligned);
template <typename T> static inline void FreeAligned (T*& thePtrAligned) { FreeAligned ((void* )thePtrAligned); thePtrAligned = 0; }
//! Deallocates the storage retained on the free list
//! and clears the list.
//! Returns non-zero if some memory has been actually freed.
Standard_EXPORT static Standard_Integer Purge();
protected:
private:
friend class Standard_ErrorHandlerCallback;
friend class Standard_ErrorHandler;
friend class Standard_GUID;
friend class Standard_Persistent;
friend class Standard_Transient;
friend class Standard_Failure;
};
#endif // _Standard_HeaderFile

37
src/Standard/Standard_AbortiveTransaction.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_AbortiveTransaction_HeaderFile
#define _Standard_AbortiveTransaction_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_Failure.hxx>
class Standard_AbortiveTransaction;
DEFINE_STANDARD_HANDLE(Standard_AbortiveTransaction, Standard_Failure)
#if !defined No_Exception && !defined No_Standard_AbortiveTransaction
#define Standard_AbortiveTransaction_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_AbortiveTransaction::Raise(MESSAGE);
#else
#define Standard_AbortiveTransaction_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_AbortiveTransaction, Standard_Failure)
#endif // _Standard_AbortiveTransaction_HeaderFile

23
src/Standard/Standard_CMPLRS.edl
View File

@@ -1,23 +0,0 @@
-- 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.
@ifnotdefined (%Standard_CMPLRS_EDL) then
@set %Standard_CMPLRS_EDL="";
@if ( %Station != "sun" ) then
@string %CMPLRS_CXX_INCLUDE += " " %CSF_TBB_INCLUDES;
@endif;
@endif;

37
src/Standard/Standard_ConstructionError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_ConstructionError_HeaderFile
#define _Standard_ConstructionError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_ConstructionError;
DEFINE_STANDARD_HANDLE(Standard_ConstructionError, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_ConstructionError
#define Standard_ConstructionError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_ConstructionError::Raise(MESSAGE);
#else
#define Standard_ConstructionError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_ConstructionError, Standard_DomainError)
#endif // _Standard_ConstructionError_HeaderFile

37
src/Standard/Standard_DimensionError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_DimensionError_HeaderFile
#define _Standard_DimensionError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_DimensionError;
DEFINE_STANDARD_HANDLE(Standard_DimensionError, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_DimensionError
#define Standard_DimensionError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_DimensionError::Raise(MESSAGE);
#else
#define Standard_DimensionError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_DimensionError, Standard_DomainError)
#endif // _Standard_DimensionError_HeaderFile

37
src/Standard/Standard_DimensionMismatch.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_DimensionMismatch_HeaderFile
#define _Standard_DimensionMismatch_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DimensionError.hxx>
class Standard_DimensionMismatch;
DEFINE_STANDARD_HANDLE(Standard_DimensionMismatch, Standard_DimensionError)
#if !defined No_Exception && !defined No_Standard_DimensionMismatch
#define Standard_DimensionMismatch_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_DimensionMismatch::Raise(MESSAGE);
#else
#define Standard_DimensionMismatch_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_DimensionMismatch, Standard_DimensionError)
#endif // _Standard_DimensionMismatch_HeaderFile

37
src/Standard/Standard_DivideByZero.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_DivideByZero_HeaderFile
#define _Standard_DivideByZero_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_NumericError.hxx>
class Standard_DivideByZero;
DEFINE_STANDARD_HANDLE(Standard_DivideByZero, Standard_NumericError)
#if !defined No_Exception && !defined No_Standard_DivideByZero
#define Standard_DivideByZero_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_DivideByZero::Raise(MESSAGE);
#else
#define Standard_DivideByZero_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_DivideByZero, Standard_NumericError)
#endif // _Standard_DivideByZero_HeaderFile

37
src/Standard/Standard_DomainError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_DomainError_HeaderFile
#define _Standard_DomainError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_Failure.hxx>
class Standard_DomainError;
DEFINE_STANDARD_HANDLE(Standard_DomainError, Standard_Failure)
#if !defined No_Exception && !defined No_Standard_DomainError
#define Standard_DomainError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_DomainError::Raise(MESSAGE);
#else
#define Standard_DomainError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_DomainError, Standard_Failure)
#endif // _Standard_DomainError_HeaderFile

93
src/Standard/Standard_ErrorHandler.cdl
View File

@@ -1,93 +0,0 @@
-- Created on: 1992-09-28
-- Created by: Ramin BARRETO
-- Copyright (c) 1992-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.
class ErrorHandler from Standard
uses
Failure from Standard,
Boolean from Standard,
Address from Standard,
PErrorHandler from Standard,
Type from Standard
is
Create returns ErrorHandler;
--- Purpose: Create a ErrorHandler (to be used with try{}catch(){}).
-- It uses the "setjmp" and "longjmp" routines.
---Level: Advanced
Destroy(me: in out);
---Purpose: Unlinks and checks if there is a raised exception.
---C++: alias ~
---Level: Advanced
Unlink(me: in out);
---Purpose: Removes handler from the handlers list
---Level: Advanced
Catches(me: in out; aType: Type) returns Boolean;
---Purpose: Returns "True" if the caught exception has the same type
-- or inherits from "aType"
---Level: Advanced
Label(me: in out) returns JmpBuf from Standard;
---Purpose: Returns label for jump
---C++: inline
---C++: return &
---Level: Advanced
Abort(myclass; theError : Failure) is private;
---Purpose: A exception is raised but it is not yet caught.
-- So Abort the current function and transmit the exception
-- to "calling routines".
-- Warning: If no catch is prepared for this exception, it displays the
-- exception name and calls "exit(1)".
---Level: Internal
Error(me) returns Failure;
---Purpose: Returns the current Error.
LastCaughtError(myclass) returns Failure;
---Purpose: Returns the caught exception.
--
---Level: Advanced
Error(myclass; aError: Failure) is private;
---Purpose: Set the Error which will be transmitted to "calling routines".
---Level: Advanced
IsInTryBlock(myclass) returns Boolean from Standard;
---Purpose: Test if the code is currently running in a try block
---Level: Internal
FindHandler(myclass; theStatus: HandlerStatus from Standard;
theUnlink: Boolean from Standard)
returns PErrorHandler from Standard is private;
---Purpose: Returns the current handler (Top in former implemntations)
fields
myPrevious : PErrorHandler from Standard;
myCaughtError : Failure from Standard;
myLabel : JmpBuf from Standard;
myStatus : HandlerStatus from Standard;
myThread : ThreadId from Standard;
myCallbackPtr : Address from Standard;
friends
class Failure,
class ErrorHandlerCallback
end ErrorHandler from Standard;

118
src/Standard/Standard_ErrorHandler.hxx Normal file
View File

@@ -0,0 +1,118 @@
// Created on: 1992-09-28
// Created by: Ramin BARRETO
// Copyright (c) 1992-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 _Standard_ErrorHandler_HeaderFile
#define _Standard_ErrorHandler_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_PErrorHandler.hxx>
#include <Standard_JmpBuf.hxx>
#include <Standard_HandlerStatus.hxx>
#include <Standard_ThreadId.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Type.hxx>
class Standard_Failure;
class Standard_ErrorHandlerCallback;
class Standard_ErrorHandler
{
public:
DEFINE_STANDARD_ALLOC
//! Create a ErrorHandler (to be used with try{}catch(){}).
//! It uses the "setjmp" and "longjmp" routines.
Standard_EXPORT Standard_ErrorHandler();
//! Unlinks and checks if there is a raised exception.
Standard_EXPORT void Destroy();
~Standard_ErrorHandler()
{
Destroy();
}
//! Removes handler from the handlers list
Standard_EXPORT void Unlink();
//! Returns "True" if the caught exception has the same type
//! or inherits from "aType"
Standard_EXPORT Standard_Boolean Catches (const Handle(Standard_Type)& aType);
//! Returns label for jump
Standard_JmpBuf& Label();
//! Returns the current Error.
Standard_EXPORT Handle(Standard_Failure) Error() const;
//! Returns the caught exception.
Standard_EXPORT static Handle(Standard_Failure) LastCaughtError();
//! Test if the code is currently running in a try block
Standard_EXPORT static Standard_Boolean IsInTryBlock();
friend class Standard_Failure;
friend class Standard_ErrorHandlerCallback;
protected:
private:
//! A exception is raised but it is not yet caught.
//! So Abort the current function and transmit the exception
//! to "calling routines".
//! Warning: If no catch is prepared for this exception, it displays the
//! exception name and calls "exit(1)".
Standard_EXPORT static void Abort (const Handle(Standard_Failure)& theError);
//! Set the Error which will be transmitted to "calling routines".
Standard_EXPORT static void Error (const Handle(Standard_Failure)& aError);
//! Returns the current handler (Top in former implemntations)
Standard_EXPORT static Standard_PErrorHandler FindHandler (const Standard_HandlerStatus theStatus, const Standard_Boolean theUnlink);
Standard_PErrorHandler myPrevious;
Handle(Standard_Failure) myCaughtError;
Standard_JmpBuf myLabel;
Standard_HandlerStatus myStatus;
Standard_ThreadId myThread;
Standard_Address myCallbackPtr;
};
#include <Standard_ErrorHandler.lxx>
#endif // _Standard_ErrorHandler_HeaderFile

65
src/Standard/Standard_ErrorHandlerCallback.cdl
View File

@@ -1,65 +0,0 @@
-- Created on: 2006-04-13
-- Created by: Andrey BETENEV
-- Copyright (c) 2006-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.
deferred class ErrorHandlerCallback from Standard
---Purpose: Defines a base class for callback objects that can be registered
-- in the OCC error handler (the class simulating C++ exceptions)
-- so as to be correctly destroyed when error handler is activated.
--
-- Note that this is needed only when Open CASCADE is compiled with
-- NO_CXX_EXCEPTION or OCC_CONVERT_SIGNALS options (i.e. on UNIX/Linux).
-- In that case, raising OCC exception and/or signal will not cause
-- C++ stack unwinding and destruction of objects created in the stack.
--
-- This class is intended to protect critical objects and operations in
-- the try {} catch {} block from being bypassed by OCC signal or exception.
--
-- Inherit your object from that class, implement DestroyCallback() function,
-- and call Register/Unregister in critical points.
--
-- Note that you must ensure that your object has life span longer than
-- that of the try {} block in which it calls Register().
is
Initialize returns ErrorHandlerCallback;
---Purpose: Empty constructor
---C++: inline
RegisterCallback (me: in out);
---Purpose: Registers this callback object in the current error handler
-- (if found).
---C++: inline
UnregisterCallback (me: in out);
---Purpose: Unregisters this callback object from the error handler.
---C++: inline
---C++: alias "virtual Standard_EXPORT ~Standard_ErrorHandlerCallback ();"
DestroyCallback (me: in out) is deferred;
---Purpose: The callback function to perform necessary callback action.
-- Called by the exception handler when it is being destroyed but
-- still has this callback registered.
fields
myHandler: Address from Standard; -- Pointer to the error handler
myPrev, myNext: Address from Standard; -- Pointers to the previous and next callback objects
friends
class ErrorHandler
end ErrorHandlerCallback;

2
src/Standard/Standard_ErrorHandlerCallback.cxx
View File

@@ -16,8 +16,8 @@
// If either NO_CXX_EXCEPTION or OCC_CONVERT_SIGNALS is defined,
// provide complete implementation
#include <Standard_ErrorHandlerCallback.ixx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_ErrorHandlerCallback.hxx>
#if defined(NO_CXX_EXCEPTION) || defined(OCC_CONVERT_SIGNALS)

95
src/Standard/Standard_ErrorHandlerCallback.hxx Normal file
View File

@@ -0,0 +1,95 @@
// Created on: 2006-04-13
// Created by: Andrey BETENEV
// Copyright (c) 2006-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 _Standard_ErrorHandlerCallback_HeaderFile
#define _Standard_ErrorHandlerCallback_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
class Standard_ErrorHandler;
//! Defines a base class for callback objects that can be registered
//! in the OCC error handler (the class simulating C++ exceptions)
//! so as to be correctly destroyed when error handler is activated.
//!
//! Note that this is needed only when Open CASCADE is compiled with
//! NO_CXX_EXCEPTION or OCC_CONVERT_SIGNALS options (i.e. on UNIX/Linux).
//! In that case, raising OCC exception and/or signal will not cause
//! C++ stack unwinding and destruction of objects created in the stack.
//!
//! This class is intended to protect critical objects and operations in
//! the try {} catch {} block from being bypassed by OCC signal or exception.
//!
//! Inherit your object from that class, implement DestroyCallback() function,
//! and call Register/Unregister in critical points.
//!
//! Note that you must ensure that your object has life span longer than
//! that of the try {} block in which it calls Register().
class Standard_ErrorHandlerCallback
{
public:
DEFINE_STANDARD_ALLOC
//! Registers this callback object in the current error handler
//! (if found).
void RegisterCallback();
//! Unregisters this callback object from the error handler.
void UnregisterCallback();
virtual Standard_EXPORT ~Standard_ErrorHandlerCallback ();
//! The callback function to perform necessary callback action.
//! Called by the exception handler when it is being destroyed but
//! still has this callback registered.
Standard_EXPORT virtual void DestroyCallback() = 0;
friend class Standard_ErrorHandler;
protected:
//! Empty constructor
Standard_ErrorHandlerCallback();
private:
Standard_Address myHandler;
Standard_Address myPrev;
Standard_Address myNext;
};
#include <Standard_ErrorHandlerCallback.lxx>
#endif // _Standard_ErrorHandlerCallback_HeaderFile

121
src/Standard/Standard_Failure.cdl
View File

@@ -1,121 +0,0 @@
-- Created on: 1991-09-05
-- Created by: Philippe COICADAN
-- Copyright (c) 1991-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.
-- Revised J.P. TIRAULT
-- New organization of standard Package (August 1992)
class Failure from Standard inherits Transient from Standard
---Purpose:
-- Forms the root of the entire exception hierarchy.
uses
CString from Standard,
OStream from Standard,
SStream from Standard
raises
NoSuchObject from Standard
is
Create returns Failure;
---Purpose:
-- Creates a status object of type "Failure".
---Level: Advanced
---C++: alias "Standard_EXPORT Standard_Failure (const Standard_Failure& f);"
Create (aString: CString) returns Failure;
---Purpose:
-- Creates a status object of type "Failure".
---Level: Advanced
---C++: alias "Standard_EXPORT Standard_Failure& operator= (const Standard_Failure& f);"
Destroy(me:mutable);
---Level: Advanced
---C++: alias ~
Print (me; s: in out OStream);
---Purpose:
-- Prints on the stream <s> the exception name followed by
-- the error message.
-- Level: Advanced
-- Warning:
-- The operator "OStream& operator<< (Standard_OStream&,
-- Handle(Standard_Failure)&)"
-- is implemented. (This operator uses the method Print)
--
---C++: alias operator<<
GetMessageString (me) returns CString from Standard;
---Purpose: Returns error message
---C++: inline
SetMessageString (me: mutable; aMessage: CString);
---Purpose: Sets error message
Reraise (me: mutable);
Reraise (me: mutable; aMessage: CString);
Reraise (me: mutable; aReason: SStream);
---Purpose: Reraises a caught exception and changes its error message.
---Level: Advanced
Raise (myclass; aMessage: CString = "") ;
---Purpose: Raises an exception of type "Failure" and associates
-- an error message to it. The message can be printed
-- in an exception handler.
---Level: Advanced
Raise (myclass; aReason: SStream) ;
---Purpose: Raises an exception of type "Failure" and associates
-- an error message to it. The message can be constructed
-- at run-time.
---Level: Advanced
NewInstance(myclass; aMessage: CString) returns Failure;
---Purpose: Used to construct an instance of the exception object
-- as a handle. Shall be used to protect against possible
-- construction of exception object in C stack -- that is
-- dangerous since some of methods require that object
-- was allocated dynamically.
Jump (me: mutable);
---Purpose: Used to throw CASCADE exception from C signal handler.
-- On platforms that do not allow throwing C++ exceptions
-- from this handler (e.g. Linux), uses longjump to get to
-- the current active signal handler, and only then is
-- converted to C++ exception.
---Level: Advanced, not for regular use
Caught (myclass) returns Failure raises NoSuchObject;
---Purpose: Returns the last caught exception.
-- Needed when exceptions are emulated by C longjumps,
-- in other cases is also provided for compatibility.
Throw (me) is virtual protected;
---Purpose: Used only if standard C++ exceptions are used.
-- Throws exception of the same type as this by C++ throw,
-- and stores current object as last thrown exception,
-- to be accessible by method Caught()
fields
myMessage: CString;
end Failure from Standard;

16
src/Standard/Standard_Failure.cxx
View File

@@ -12,14 +12,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.ixx>
#include <Standard_TypeMismatch.hxx>
#include <Standard_Type.hxx>
#include <Standard_Macro.hxx>
#include <string.h>
#include <Standard_PCharacter.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <Standard_Macro.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_PCharacter.hxx>
#include <Standard_Type.hxx>
#include <Standard_TypeMismatch.hxx>
#include <string.h>
static Standard_CString allocate_message(const Standard_CString AString)
{
Standard_CString aStr = 0;

143
src/Standard/Standard_Failure.hxx Normal file
View File

@@ -0,0 +1,143 @@
// Created on: 1991-09-05
// Created by: Philippe COICADAN
// Copyright (c) 1991-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 _Standard_Failure_HeaderFile
#define _Standard_Failure_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_CString.hxx>
#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
#include <Standard_SStream.hxx>
class Standard_NoSuchObject;
class Standard_Failure;
DEFINE_STANDARD_HANDLE(Standard_Failure, Standard_Transient)
//! Forms the root of the entire exception hierarchy.
class Standard_Failure : public Standard_Transient
{
public:
//! Creates a status object of type "Failure".
Standard_EXPORT Standard_Failure();
Standard_EXPORT Standard_Failure (const Standard_Failure& f);
//! Creates a status object of type "Failure".
Standard_EXPORT Standard_Failure(const Standard_CString aString);
Standard_EXPORT Standard_Failure& operator= (const Standard_Failure& f);
Standard_EXPORT void Destroy();
~Standard_Failure()
{
Destroy();
}
//! Prints on the stream <s> the exception name followed by
//! the error message.
//! Level: Advanced
//! Warning:
//! The operator "OStream& operator<< (Standard_OStream&,
//! Handle(Standard_Failure)&)"
//! is implemented. (This operator uses the method Print)
Standard_EXPORT void Print (Standard_OStream& s) const;
void operator<< (Standard_OStream& s) const
{
Print(s);
}
//! Returns error message
Standard_CString GetMessageString() const;
//! Sets error message
Standard_EXPORT void SetMessageString (const Standard_CString aMessage);
Standard_EXPORT void Reraise();
Standard_EXPORT void Reraise (const Standard_CString aMessage);
//! Reraises a caught exception and changes its error message.
Standard_EXPORT void Reraise (const Standard_SStream& aReason);
//! Raises an exception of type "Failure" and associates
//! an error message to it. The message can be printed
//! in an exception handler.
Standard_EXPORT static void Raise (const Standard_CString aMessage = "");
//! Raises an exception of type "Failure" and associates
//! an error message to it. The message can be constructed
//! at run-time.
Standard_EXPORT static void Raise (const Standard_SStream& aReason);
//! Used to construct an instance of the exception object
//! as a handle. Shall be used to protect against possible
//! construction of exception object in C stack -- that is
//! dangerous since some of methods require that object
//! was allocated dynamically.
Standard_EXPORT static Handle(Standard_Failure) NewInstance (const Standard_CString aMessage);
//! Used to throw CASCADE exception from C signal handler.
//! On platforms that do not allow throwing C++ exceptions
//! from this handler (e.g. Linux), uses longjump to get to
//! the current active signal handler, and only then is
//! converted to C++ exception.
Standard_EXPORT void Jump();
//! Returns the last caught exception.
//! Needed when exceptions are emulated by C longjumps,
//! in other cases is also provided for compatibility.
Standard_EXPORT static Handle(Standard_Failure) Caught();
DEFINE_STANDARD_RTTI(Standard_Failure,Standard_Transient)
protected:
//! Used only if standard C++ exceptions are used.
//! Throws exception of the same type as this by C++ throw,
//! and stores current object as last thrown exception,
//! to be accessible by method Caught()
Standard_EXPORT virtual void Throw() const;
private:
Standard_CString myMessage;
};
#include <Standard_Failure.lxx>
#endif // _Standard_Failure_HeaderFile

125
src/Standard/Standard_GUID.cdl
View File

@@ -1,125 +0,0 @@
-- Created on: 1997-06-19
-- Created by: Christophe LEYNADIER
-- Copyright (c) 1997-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.
class GUID from Standard
is
Create returns GUID from Standard;
Create(aGuid : CString from Standard)
returns GUID from Standard;
---Purpose: build a GUID from an ascii string with the
-- following format:
-- Length : 36 char
-- "00000000-0000-0000-0000-000000000000"
Create(aGuid : ExtString from Standard)
returns GUID from Standard;
---Purpose: build a GUID from an unicode string with the
-- following format:
--
-- "00000000-0000-0000-0000-000000000000"
Create(a32b : Integer from Standard;
a16b1 : ExtCharacter from Standard;
a16b2 : ExtCharacter from Standard;
a16b3 : ExtCharacter from Standard;
a8b1 : Byte from Standard;
a8b2 : Byte from Standard;
a8b3 : Byte from Standard;
a8b4 : Byte from Standard;
a8b5 : Byte from Standard;
a8b6 : Byte from Standard)
returns GUID from Standard;
Create(aGuid : UUID from Standard)
returns GUID from Standard;
Create(aGuid : GUID from Standard)
returns GUID from Standard;
ToUUID(me)
returns UUID from Standard ;
ToCString(me; aStrGuid : PCharacter from Standard);
---Purpose: translate the GUID into ascii string
-- the aStrGuid is allocated by user.
-- the guid have the following format:
--
-- "00000000-0000-0000-0000-000000000000"
ToExtString(me; aStrGuid : PExtCharacter from Standard);
---Purpose: translate the GUID into unicode string
-- the aStrGuid is allocated by user.
-- the guid have the following format:
--
-- "00000000-0000-0000-0000-000000000000"
IsSame(me; uid : GUID from Standard)
returns Boolean from Standard;
---C++: alias operator ==
IsNotSame(me; uid : GUID from Standard)
returns Boolean from Standard;
---C++: alias operator !=
Assign(me : out; uid : GUID from Standard);
---C++: alias operator =
Assign(me : out; uid : UUID from Standard);
---C++: alias operator =
ShallowDump(me; aStream : in out OStream from Standard);
---Purpose: Display the GUID with the following format:
--
-- "00000000-0000-0000-0000-000000000000"
CheckGUIDFormat(myclass; aGuid : CString from Standard)
returns Boolean from Standard;
---Purpose: Check the format of a GUID string.
-- It checks the size, the position of the '-' and the correct size of fields.
Hash(me; Upper : Integer)
returns Integer;
---Level: Internal
---Purpose: Hash function for GUID.
HashCode(myclass ; aguid : GUID from Standard; Upper : Integer)
returns Integer;
---Level: Internal
---Purpose: H method used by collections.
IsEqual(myclass ; string1 : GUID from Standard;
string2 : GUID from Standard)
returns Boolean;
---Level: Internal
---Purpose: Returns True when the two GUID are the same.
fields
my32b : Integer;
my16b1 : ExtCharacter;
my16b2 : ExtCharacter;
my16b3 : ExtCharacter;
my8b1 : Byte;
my8b2 : Byte;
my8b3 : Byte;
my8b4 : Byte;
my8b5 : Byte;
my8b6 : Byte;
end;

9
src/Standard/Standard_GUID.cxx
View File

@@ -12,11 +12,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Standard_GUID.ixx>
#include <Standard_RangeError.hxx>
#include <Standard_IStream.hxx>
#include <stdio.h>
#include <Standard_GUID.hxx>
#include <Standard_IStream.hxx>
#include <Standard_RangeError.hxx>
#include <stdio.h>
#define Standard_GUID_SIZE 36
#define Standard_GUID_SIZE_ALLOC Standard_GUID_SIZE+1

155
src/Standard/Standard_GUID.hxx Normal file
View File

@@ -0,0 +1,155 @@
// Created on: 1997-06-19
// Created by: Christophe LEYNADIER
// Copyright (c) 1997-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 _Standard_GUID_HeaderFile
#define _Standard_GUID_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_ExtCharacter.hxx>
#include <Standard_Byte.hxx>
#include <Standard_CString.hxx>
#include <Standard_ExtString.hxx>
#include <Standard_UUID.hxx>
#include <Standard_PCharacter.hxx>
#include <Standard_PExtCharacter.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_OStream.hxx>
class Standard_GUID
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Standard_GUID();
//! build a GUID from an ascii string with the
//! following format:
//! Length : 36 char
//! "00000000-0000-0000-0000-000000000000"
Standard_EXPORT Standard_GUID(const Standard_CString aGuid);
//! build a GUID from an unicode string with the
//! following format:
//!
//! "00000000-0000-0000-0000-000000000000"
Standard_EXPORT Standard_GUID(const Standard_ExtString aGuid);
Standard_EXPORT Standard_GUID(const Standard_Integer a32b, const Standard_ExtCharacter a16b1, const Standard_ExtCharacter a16b2, const Standard_ExtCharacter a16b3, const Standard_Byte a8b1, const Standard_Byte a8b2, const Standard_Byte a8b3, const Standard_Byte a8b4, const Standard_Byte a8b5, const Standard_Byte a8b6);
Standard_EXPORT Standard_GUID(const Standard_UUID& aGuid);
Standard_EXPORT Standard_GUID(const Standard_GUID& aGuid);
Standard_EXPORT Standard_UUID ToUUID() const;
//! translate the GUID into ascii string
//! the aStrGuid is allocated by user.
//! the guid have the following format:
//!
//! "00000000-0000-0000-0000-000000000000"
Standard_EXPORT void ToCString (const Standard_PCharacter aStrGuid) const;
//! translate the GUID into unicode string
//! the aStrGuid is allocated by user.
//! the guid have the following format:
//!
//! "00000000-0000-0000-0000-000000000000"
Standard_EXPORT void ToExtString (const Standard_PExtCharacter aStrGuid) const;
Standard_EXPORT Standard_Boolean IsSame (const Standard_GUID& uid) const;
Standard_Boolean operator == (const Standard_GUID& uid) const
{
return IsSame(uid);
}
Standard_EXPORT Standard_Boolean IsNotSame (const Standard_GUID& uid) const;
Standard_Boolean operator != (const Standard_GUID& uid) const
{
return IsNotSame(uid);
}
Standard_EXPORT void Assign (const Standard_GUID& uid);
void operator = (const Standard_GUID& uid)
{
Assign(uid);
}
Standard_EXPORT void Assign (const Standard_UUID& uid);
void operator = (const Standard_UUID& uid)
{
Assign(uid);
}
//! Display the GUID with the following format:
//!
//! "00000000-0000-0000-0000-000000000000"
Standard_EXPORT void ShallowDump (Standard_OStream& aStream) const;
//! Check the format of a GUID string.
//! It checks the size, the position of the '-' and the correct size of fields.
Standard_EXPORT static Standard_Boolean CheckGUIDFormat (const Standard_CString aGuid);
//! Hash function for GUID.
Standard_EXPORT Standard_Integer Hash (const Standard_Integer Upper) const;
//! H method used by collections.
Standard_EXPORT static Standard_Integer HashCode (const Standard_GUID& aguid, const Standard_Integer Upper);
//! Returns True when the two GUID are the same.
Standard_EXPORT static Standard_Boolean IsEqual (const Standard_GUID& string1, const Standard_GUID& string2);
protected:
private:
Standard_Integer my32b;
Standard_ExtCharacter my16b1;
Standard_ExtCharacter my16b2;
Standard_ExtCharacter my16b3;
Standard_Byte my8b1;
Standard_Byte my8b2;
Standard_Byte my8b3;
Standard_Byte my8b4;
Standard_Byte my8b5;
Standard_Byte my8b6;
};
#endif // _Standard_GUID_HeaderFile

28
src/Standard/Standard_HandlerStatus.hxx Normal file
View File

@@ -0,0 +1,28 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_HandlerStatus_HeaderFile
#define _Standard_HandlerStatus_HeaderFile
enum Standard_HandlerStatus
{
Standard_HandlerVoid,
Standard_HandlerJumped,
Standard_HandlerProcessed
};
#endif // _Standard_HandlerStatus_HeaderFile

37
src/Standard/Standard_ImmutableObject.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_ImmutableObject_HeaderFile
#define _Standard_ImmutableObject_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_ImmutableObject;
DEFINE_STANDARD_HANDLE(Standard_ImmutableObject, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_ImmutableObject
#define Standard_ImmutableObject_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_ImmutableObject::Raise(MESSAGE);
#else
#define Standard_ImmutableObject_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_ImmutableObject, Standard_DomainError)
#endif // _Standard_ImmutableObject_HeaderFile

37
src/Standard/Standard_LicenseError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_LicenseError_HeaderFile
#define _Standard_LicenseError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_Failure.hxx>
class Standard_LicenseError;
DEFINE_STANDARD_HANDLE(Standard_LicenseError, Standard_Failure)
#if !defined No_Exception && !defined No_Standard_LicenseError
#define Standard_LicenseError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_LicenseError::Raise(MESSAGE);
#else
#define Standard_LicenseError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_LicenseError, Standard_Failure)
#endif // _Standard_LicenseError_HeaderFile

37
src/Standard/Standard_LicenseNotFound.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_LicenseNotFound_HeaderFile
#define _Standard_LicenseNotFound_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_LicenseError.hxx>
class Standard_LicenseNotFound;
DEFINE_STANDARD_HANDLE(Standard_LicenseNotFound, Standard_LicenseError)
#if !defined No_Exception && !defined No_Standard_LicenseNotFound
#define Standard_LicenseNotFound_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_LicenseNotFound::Raise(MESSAGE);
#else
#define Standard_LicenseNotFound_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_LicenseNotFound, Standard_LicenseError)
#endif // _Standard_LicenseNotFound_HeaderFile

37
src/Standard/Standard_MultiplyDefined.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_MultiplyDefined_HeaderFile
#define _Standard_MultiplyDefined_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_MultiplyDefined;
DEFINE_STANDARD_HANDLE(Standard_MultiplyDefined, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_MultiplyDefined
#define Standard_MultiplyDefined_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_MultiplyDefined::Raise(MESSAGE);
#else
#define Standard_MultiplyDefined_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_MultiplyDefined, Standard_DomainError)
#endif // _Standard_MultiplyDefined_HeaderFile

37
src/Standard/Standard_NegativeValue.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NegativeValue_HeaderFile
#define _Standard_NegativeValue_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_RangeError.hxx>
class Standard_NegativeValue;
DEFINE_STANDARD_HANDLE(Standard_NegativeValue, Standard_RangeError)
#if !defined No_Exception && !defined No_Standard_NegativeValue
#define Standard_NegativeValue_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NegativeValue::Raise(MESSAGE);
#else
#define Standard_NegativeValue_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NegativeValue, Standard_RangeError)
#endif // _Standard_NegativeValue_HeaderFile

37
src/Standard/Standard_NoMoreObject.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NoMoreObject_HeaderFile
#define _Standard_NoMoreObject_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_NoMoreObject;
DEFINE_STANDARD_HANDLE(Standard_NoMoreObject, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_NoMoreObject
#define Standard_NoMoreObject_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NoMoreObject::Raise(MESSAGE);
#else
#define Standard_NoMoreObject_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NoMoreObject, Standard_DomainError)
#endif // _Standard_NoMoreObject_HeaderFile

37
src/Standard/Standard_NoSuchObject.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NoSuchObject_HeaderFile
#define _Standard_NoSuchObject_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_NoSuchObject;
DEFINE_STANDARD_HANDLE(Standard_NoSuchObject, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_NoSuchObject
#define Standard_NoSuchObject_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NoSuchObject::Raise(MESSAGE);
#else
#define Standard_NoSuchObject_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NoSuchObject, Standard_DomainError)
#endif // _Standard_NoSuchObject_HeaderFile

37
src/Standard/Standard_NotImplemented.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NotImplemented_HeaderFile
#define _Standard_NotImplemented_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_ProgramError.hxx>
class Standard_NotImplemented;
DEFINE_STANDARD_HANDLE(Standard_NotImplemented, Standard_ProgramError)
#if !defined No_Exception && !defined No_Standard_NotImplemented
#define Standard_NotImplemented_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NotImplemented::Raise(MESSAGE);
#else
#define Standard_NotImplemented_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NotImplemented, Standard_ProgramError)
#endif // _Standard_NotImplemented_HeaderFile

37
src/Standard/Standard_NullObject.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NullObject_HeaderFile
#define _Standard_NullObject_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_NullObject;
DEFINE_STANDARD_HANDLE(Standard_NullObject, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_NullObject
#define Standard_NullObject_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NullObject::Raise(MESSAGE);
#else
#define Standard_NullObject_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NullObject, Standard_DomainError)
#endif // _Standard_NullObject_HeaderFile

37
src/Standard/Standard_NullValue.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NullValue_HeaderFile
#define _Standard_NullValue_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_RangeError.hxx>
class Standard_NullValue;
DEFINE_STANDARD_HANDLE(Standard_NullValue, Standard_RangeError)
#if !defined No_Exception && !defined No_Standard_NullValue
#define Standard_NullValue_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NullValue::Raise(MESSAGE);
#else
#define Standard_NullValue_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NullValue, Standard_RangeError)
#endif // _Standard_NullValue_HeaderFile

37
src/Standard/Standard_NumericError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_NumericError_HeaderFile
#define _Standard_NumericError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_Failure.hxx>
class Standard_NumericError;
DEFINE_STANDARD_HANDLE(Standard_NumericError, Standard_Failure)
#if !defined No_Exception && !defined No_Standard_NumericError
#define Standard_NumericError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_NumericError::Raise(MESSAGE);
#else
#define Standard_NumericError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_NumericError, Standard_Failure)
#endif // _Standard_NumericError_HeaderFile

37
src/Standard/Standard_OutOfMemory.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_OutOfMemory_HeaderFile
#define _Standard_OutOfMemory_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_ProgramError.hxx>
class Standard_OutOfMemory;
DEFINE_STANDARD_HANDLE(Standard_OutOfMemory, Standard_ProgramError)
#if !defined No_Exception && !defined No_Standard_OutOfMemory
#define Standard_OutOfMemory_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_OutOfMemory::Raise(MESSAGE);
#else
#define Standard_OutOfMemory_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_OutOfMemory, Standard_ProgramError)
#endif // _Standard_OutOfMemory_HeaderFile

37
src/Standard/Standard_OutOfRange.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_OutOfRange_HeaderFile
#define _Standard_OutOfRange_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_RangeError.hxx>
class Standard_OutOfRange;
DEFINE_STANDARD_HANDLE(Standard_OutOfRange, Standard_RangeError)
#if !defined No_Exception && !defined No_Standard_OutOfRange
#define Standard_OutOfRange_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_OutOfRange::Raise(MESSAGE);
#else
#define Standard_OutOfRange_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_OutOfRange, Standard_RangeError)
#endif // _Standard_OutOfRange_HeaderFile

37
src/Standard/Standard_Overflow.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_Overflow_HeaderFile
#define _Standard_Overflow_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_NumericError.hxx>
class Standard_Overflow;
DEFINE_STANDARD_HANDLE(Standard_Overflow, Standard_NumericError)
#if !defined No_Exception && !defined No_Standard_Overflow
#define Standard_Overflow_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_Overflow::Raise(MESSAGE);
#else
#define Standard_Overflow_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_Overflow, Standard_NumericError)
#endif // _Standard_Overflow_HeaderFile

23
src/Standard/Standard_PErrorHandler.hxx Normal file
View File

@@ -0,0 +1,23 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_PErrorHandler_HeaderFile
#define _Standard_PErrorHandler_HeaderFile
class Standard_ErrorHandler;
typedef Standard_ErrorHandler* Standard_PErrorHandler;
#endif // _Standard_PErrorHandler_HeaderFile

34
src/Standard/Standard_Persistent.cdl
View File

@@ -1,34 +0,0 @@
-- Created on: 1992-08-24
-- Created by: Ramin BARRETO
-- Copyright (c) 1992-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.
imported deferred class Persistent from Standard
inherits Transient from Standard
uses
Transient
---Purpose:
-- Root of "persistent" classes, a legacy support of
-- object oriented databases, now outdated.
is
Initialize returns Persistent;
end Persistent from Standard;

37
src/Standard/Standard_ProgramError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_ProgramError_HeaderFile
#define _Standard_ProgramError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_Failure.hxx>
class Standard_ProgramError;
DEFINE_STANDARD_HANDLE(Standard_ProgramError, Standard_Failure)
#if !defined No_Exception && !defined No_Standard_ProgramError
#define Standard_ProgramError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_ProgramError::Raise(MESSAGE);
#else
#define Standard_ProgramError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_ProgramError, Standard_Failure)
#endif // _Standard_ProgramError_HeaderFile

37
src/Standard/Standard_RangeError.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_RangeError_HeaderFile
#define _Standard_RangeError_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_RangeError;
DEFINE_STANDARD_HANDLE(Standard_RangeError, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_RangeError
#define Standard_RangeError_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_RangeError::Raise(MESSAGE);
#else
#define Standard_RangeError_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_RangeError, Standard_DomainError)
#endif // _Standard_RangeError_HeaderFile

37
src/Standard/Standard_TooManyUsers.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_TooManyUsers_HeaderFile
#define _Standard_TooManyUsers_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_LicenseError.hxx>
class Standard_TooManyUsers;
DEFINE_STANDARD_HANDLE(Standard_TooManyUsers, Standard_LicenseError)
#if !defined No_Exception && !defined No_Standard_TooManyUsers
#define Standard_TooManyUsers_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_TooManyUsers::Raise(MESSAGE);
#else
#define Standard_TooManyUsers_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_TooManyUsers, Standard_LicenseError)
#endif // _Standard_TooManyUsers_HeaderFile

83
src/Standard/Standard_Transient.cdl
View File

@@ -1,83 +0,0 @@
-- Created on: 1992-08-24
-- Created by: Ramin BARRETO
-- Copyright (c) 1992-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.
imported deferred class Transient from Standard
---Purpose: Abstract class which forms the root of the entire
-- Transient class hierarchy.
---Warning: This CDL file is actually a stub, even if it attempts to be correct.
-- See actual header in Standard_Transient_proto.hxx
uses
Type from Standard,
Boolean from Standard,
Integer from Standard
is
Initialize;
---Purpose: Empty constructor
---Warning: Copy constructor and assignment operators cannot be
-- declared cleanly in CDL, so we use "C++ alias" for that
---C++: alias "Standard_Transient(const Standard_Transient&) : count(0) {}"
---C++: alias "Standard_Transient& operator= (const Standard_Transient&) { return *this; }"
Delete(me) is virtual;
---Purpose: Memory deallocator for transient classes
---Level: Advanced
---C++: alias "Standard_EXPORT virtual ~Standard_Transient();"
DynamicType (me) returns Type is virtual;
---Purpose: Returns a type information object about this object.
---Level: Advanced
IsInstance (me; TheType : Type) returns Boolean is static;
---Purpose: Returns a true value if this is an instance of Type.
---Level: Advanced
IsInstance (me; TheTypeName : CString) returns Boolean is static;
---Purpose: Returns a true value if this is an instance of TypeName.
---Level: Advanced
IsKind (me; TheType : Type) returns Boolean is static;
---Purpose: Returns true if this is an instance of Type or an
-- instance of any class that inherits from Type.
-- Note that multiple inheritance is not supported by OCCT RTTI mechanism.
---Level: Advanced
IsKind (me; TheTypeName : CString) returns Boolean is static;
---Purpose: Returns true if this is an instance of TypeName or an
-- instance of any class that inherits from TypeName.
-- Note that multiple inheritance is not supported by OCCT RTTI mechanism.
---Level: Advanced
This (me) returns Transient
---Purpose: Returns a Handle which references this object.
---Warning: Must never be called to objects created in stack.
---Level: Advanced
is virtual protected;
---Level: Advanced
GetRefCount(me)
---Purpose: get the reference counter
-- of this object.
returns Integer from Standard;
fields
count : Integer from Standard;
end Transient from Standard;

37
src/Standard/Standard_TypeMismatch.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_TypeMismatch_HeaderFile
#define _Standard_TypeMismatch_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_DomainError.hxx>
class Standard_TypeMismatch;
DEFINE_STANDARD_HANDLE(Standard_TypeMismatch, Standard_DomainError)
#if !defined No_Exception && !defined No_Standard_TypeMismatch
#define Standard_TypeMismatch_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_TypeMismatch::Raise(MESSAGE);
#else
#define Standard_TypeMismatch_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_TypeMismatch, Standard_DomainError)
#endif // _Standard_TypeMismatch_HeaderFile

37
src/Standard/Standard_Underflow.hxx Normal file
View File

@@ -0,0 +1,37 @@
// Created on: 1991-09-05
// Created by: J.P. TIRAUlt
// Copyright (c) 1991-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 _Standard_Underflow_HeaderFile
#define _Standard_Underflow_HeaderFile
#include <Standard_Type.hxx>
#include <Standard_DefineException.hxx>
#include <Standard_SStream.hxx>
#include <Standard_NumericError.hxx>
class Standard_Underflow;
DEFINE_STANDARD_HANDLE(Standard_Underflow, Standard_NumericError)
#if !defined No_Exception && !defined No_Standard_Underflow
#define Standard_Underflow_Raise_if(CONDITION, MESSAGE) \
if (CONDITION) Standard_Underflow::Raise(MESSAGE);
#else
#define Standard_Underflow_Raise_if(CONDITION, MESSAGE)
#endif
DEFINE_STANDARD_EXCEPTION(Standard_Underflow, Standard_NumericError)
#endif // _Standard_Underflow_HeaderFile

25
src/Standard/Standard_WOKSteps.edl
View File

@@ -1,25 +0,0 @@
-- 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.
@ifnotdefined ( %Standard_WOKSteps_EDL ) then
@set %Standard_WOKSteps_EDL = "";
@string %WOKSteps_XcppGroup += " xcpp.copy ";
@set %WOKSteps_xcpp_copy = "Standard_Copy(xcpp.header)";
@set %WOKSteps_toolkit_ListWith = "obj.comp obj.idep ";
@endif;