0031939: Coding - correction of spelling errors in comments [part 10]

Fix various typos via codespell.

src/Standard/Standard.cxx

@@ -208,7 +208,7 @@ Standard_MMgrFactory::~Standard_MMgrFactory()
 // WNT MSVC++) to put destructing function in code segment that is called
 // after destructors of other (even static) objects. However, this is not 
 // done by the moment since it is compiler-dependent and there is no guarantee 
-// thatsome other object calling memory manager is not placed also in that segment...
+// that some other object calling memory manager is not placed also in that segment...
 //
 // Note that C runtime function atexit() could not help in this problem 
 // since its behaviour is the same as for destructors of static objects 

src/Standard/Standard_ArrayStreamBuffer.hxx

@@ -50,7 +50,7 @@ public:
 
   //! Main constructor.
   //! Passed pointer is stored as is (memory is NOT copied nor released with destructor).
-  //! @param theBegin pointer to the beggining of pre-allocated buffer
+  //! @param theBegin pointer to the beginning of pre-allocated buffer
   //! @param theSize  length of pre-allocated buffer
   Standard_EXPORT Standard_ArrayStreamBuffer (const char*  theBegin,
                                               const size_t theSize);
@@ -60,7 +60,7 @@ public:
 
   //! (Re)-initialize the stream.
   //! Passed pointer is stored as is (memory is NOT copied nor released with destructor).
-  //! @param theBegin pointer to the beggining of pre-allocated buffer
+  //! @param theBegin pointer to the beginning of pre-allocated buffer
   //! @param theSize  length of pre-allocated buffer
   Standard_EXPORT virtual void Init (const char*  theBegin,
                                      const size_t theSize);

src/Standard/Standard_Atomic.hxx

@@ -21,7 +21,7 @@
 //! By the moment, only operations necessary for reference counter
 //! in Standard_Transient objects are implemented.
 //!
-//! This is preffered to use fixed size types "int32_t" / "int64_t" for
+//! This is preferred to use fixed size types "int32_t" / "int64_t" for
 //! correct function declarations however we leave "int" assuming it is 32bits for now.
 
 #ifndef _Standard_Atomic_HeaderFile

src/Standard/Standard_CLocaleSentry.hxx

@@ -48,7 +48,7 @@
 //! Thus following calls to sprintf, atoi and other functions will use "C" locale.
 //! Destructor of this class will return original locale.
 //!
-//! Notice that this functionality is platfrom dependent and intended only to workaround alien code
+//! Notice that this functionality is platform dependent and intended only to workaround alien code
 //! that doesn't setup locale correctly.
 //!
 //! Internally you should prefer more portable C++ locale interfaces

src/Standard/Standard_CString.cxx

@@ -62,7 +62,7 @@ Standard_Integer HashCodes (const Standard_CString theString, const Standard_Int
 //======================================================================
 
 #ifdef __APPLE__
-  // There are a lot of *_l functions availalbe on Mac OS X - we use them
+  // There are a lot of *_l functions available on Mac OS X - we use them
   #define SAVE_TL()
 #elif defined(_MSC_VER)
   // MSVCRT has equivalents with slightly different syntax

src/Standard/Standard_Character.hxx

@@ -13,9 +13,8 @@
 // commercial license or contractual agreement.
 
 //============================================================================
-//==== Titre: Standard_Character.hxx
-//==== Role : The header file of primitve type "Character" from package 
-//====        "Standard"
+//==== Title: Standard_Character.hxx
+//==== Role : The header file of primitive type "Character" from package "Standard"
 //==== 
 //==== Implementation:  This is a primitive type implemented as typedef
 //====        typedef char Standard_Character

src/Standard/Standard_Dump.hxx

@@ -237,7 +237,7 @@
 //! Append into output value: "Name": { field dumped values }
 //! It computes Dump of the parent. The expected field is a parent class name to call ClassName::Dump.
 //! Use this macro for parent of the current class.
-//! The macros is recursive. Recursive is stoped when the depth value becomes equal to zero.
+//! The macros is recursive. Recursive is stopped when the depth value becomes equal to zero.
 //! Depth = -1 is the default value, dump here is unlimited.
 #define OCCT_DUMP_BASE_CLASS(theOStream, theDepth, theField) \
 { \

src/Standard/Standard_ErrorHandler.cxx

@@ -13,7 +13,7 @@
 // commercial license or contractual agreement.
 
 //============================================================================
-//==== Titre: Standard_ErrorHandler.cxx
+//==== Title: Standard_ErrorHandler.cxx
 //==== Role : class "Standard_ErrorHandler" implementation.
 //============================================================================
 #include <Standard_ErrorHandler.hxx>

src/Standard/Standard_ExtCharacter.hxx

@@ -13,9 +13,8 @@
 // commercial license or contractual agreement.
 
 //============================================================================
-//==== Titre: Standard_ExtCharacter.hxx
-//==== Role : The headr file of primitve type "ExtCharacter" from package 
-//====        "Standard"
+//==== Title: Standard_ExtCharacter.hxx
+//==== Role : The headr file of primitive type "ExtCharacter" from package "Standard"
 //==== 
 //==== Implementation:  This is a primitive type implemented with typedef
 //====                  Excepting "Unicod encoding"

src/Standard/Standard_ExtString.hxx

@@ -13,7 +13,7 @@
 // commercial license or contractual agreement.
 
 //============================================================================
-//==== Titre: Standard_ExtString.hxx
+//==== Title: Standard_ExtString.hxx
 //==== 
 //==== Implementation:  This is a primitive type implementadef with typedef
 //====        typedef short* Standard_ExtString;

src/Standard/Standard_MMgrOpt.cxx

@@ -120,10 +120,10 @@ extern "C" int getpagesize() ;
 
 /* In the allocated block, first bytes are used for storing of memory manager's data.
    (size of block). The minimal size of these data is sizeof(int).
-   The memory allocated in system usually alligned by 16 bytes.Tthe aligment of the 
-   data area in the memory block is shfted on BLOCK_SHIFT*sizeof(Standard_Size) 
+   The memory allocated in system usually aligned by 16 bytes. The alignment of the
+   data area in the memory block is shfted on BLOCK_SHIFT*sizeof(Standard_Size)
    bytes.
-   It is OK for WNT, SUN and Linux systems, but on SGI aligment should be 8 bytes.
+   It is OK for WNT, SUN and Linux systems, but on SGI alignment should be 8 bytes.
    So, BLOCK_SHIFT is formed as macro for support on other possible platforms.
 */
 

src/Standard/Standard_Macro.hxx

@@ -21,7 +21,7 @@
 # define _Standard_Macro_HeaderFile
 
 //! @def Standard_OVERRIDE
-//! Should be used in declarations of virtual methods overriden in the
+//! Should be used in declarations of virtual methods overridden in the
 //! derived classes, to cause compilation error in the case if that virtual 
 //! function disappears or changes its signature in the base class.
 //!

src/Standard/Standard_Mutex.hxx

@@ -32,14 +32,14 @@
   * @brief Mutex: a class to synchronize access to shared data. 
   *
   * This is simple encapsulation of tools provided by the
-  * operating system to syncronize access to shared data 
+  * operating system to synchronize access to shared data
   * from threads within one process.
   *
   * Current implementation is very simple and straightforward;
-  * it is just a wrapper around POSIX pthread librray on UNIX/Linux,
+  * it is just a wrapper around POSIX pthread library on UNIX/Linux,
   * and CRITICAL_SECTIONs on Windows NT. It does not provide any
-  * advanced functionaly such as recursive calls to the same mutex from 
-  * within one thread (such call will froze the execution).
+  * advanced functionality such as recursive calls to the same mutex from
+  * within one thread (such call will freeze the execution).
   *
   * Note that all the methods of that class are made inline, in order
   * to keep maximal performance. This means that a library using the mutex

src/Standard/Standard_Real.cxx

@@ -144,7 +144,7 @@ Standard_Real Sign(const Standard_Real a, const Standard_Real b)
 }
 
 //==========================================================================
-//===== The special routines for "IEEE" and differents hardwares ===========
+//===== The special routines for "IEEE" and different hardware =============
 //==========================================================================
 union RealMap {
   double real;
@@ -153,17 +153,17 @@ union RealMap {
 
 //--------------------------------------------------------------------
 // HardwareHighBitsOfDouble :  
-//    Returns 1 if the low bits are at end.   (exemple: decmips and ALPHA )
-//    Returns 0 if the low bits are at begin. (exemple: sun, sgi, ...)
+//    Returns 1 if the low bits are at end.   (example: decmips and ALPHA )
+//    Returns 0 if the low bits are at begin. (example: sun, sgi, ...)
 //--------------------------------------------------------------------
 static int HardwareHighBitsOfDouble()
 {
   RealMap MaxDouble;
   MaxDouble.real = DBL_MAX;
   //=========================================================
-  // reperesentation of the max double in IEEE is 
-  //      "7fef ffff ffff ffff"   for the big indiens.
-  //      "ffff ffff 7fef ffff"   for the littel indiens.
+  // representation of the max double in IEEE is
+  //      "7fef ffff ffff ffff"   for the big endians.
+  //      "ffff ffff 7fef ffff"   for the little endians.
   //=========================================================
 
   if(MaxDouble.map[1] != 0xffffffff){
@@ -175,17 +175,17 @@ static int HardwareHighBitsOfDouble()
 
 //--------------------------------------------------------------------
 // HardwareLowBitsOfDouble :  
-//    Returns 0 if the low bits are at end.   (exemple: decmips )
-//    Returns 1 if the low bits are at begin. (exemple: sun, sgi, ...)
+//    Returns 0 if the low bits are at end.   (example: decmips )
+//    Returns 1 if the low bits are at begin. (example: sun, sgi, ...)
 //--------------------------------------------------------------------
 static int HardwareLowBitsOfDouble()
 {
   RealMap MaxDouble;
   MaxDouble.real = DBL_MAX;
   //=========================================================
-  // reperesentation of the max double in IEEE is 
-  //      "7fef ffff ffff ffff"   for the big indiens.
-  //      "ffff ffff 7fef ffff"   for the littel indiens.
+  // representation of the max double in IEEE is
+  //      "7fef ffff ffff ffff"   for the big endians.
+  //      "ffff ffff 7fef ffff"   for the little endians.
   //=========================================================
 
   if(MaxDouble.map[1] != 0xffffffff){
@@ -211,7 +211,7 @@ double NextAfter(const double x, const double y)
     //=========================================
     //   -oo__________0___________+oo
     //               x=y
-    //  The direction is "Null", so there is nothing after 
+    //  The direction is "Null", so there is nothing after
     //=========================================
 
   } else if (((x<y) && (x>=0.0)) || ((x>y) && (x<0.0))) {
@@ -254,9 +254,9 @@ Standard_Real     ATanh(const Standard_Real Value)
 { 
   if ( (Value <= -1.) || (Value >= 1.) ){
 #ifdef OCCT_DEBUG
-    std::cout << "Illegal agument in ATanh" << std::endl ;
+    std::cout << "Illegal argument in ATanh" << std::endl ;
 #endif
-    throw Standard_NumericError("Illegal agument in ATanh");
+    throw Standard_NumericError("Illegal argument in ATanh");
   }
 #if __QNX__
   return std::atanh(Value);
@@ -272,9 +272,9 @@ Standard_Real     ACosh (const Standard_Real Value)
 { 
   if ( Value < 1. ){
 #ifdef OCCT_DEBUG
-    std::cout << "Illegal agument in ACosh" << std::endl ;
+    std::cout << "Illegal argument in ACosh" << std::endl ;
 #endif
-    throw Standard_NumericError("Illegal agument in ACosh");
+    throw Standard_NumericError("Illegal argument in ACosh");
   }
 #if __QNX__
   return std::acosh(Value);
@@ -317,9 +317,9 @@ Standard_Real     Sinh (const Standard_Real Value)
 Standard_Real     Log (const Standard_Real Value) 
 {   if ( Value <= 0. ){
 #ifdef OCCT_DEBUG
-    std::cout << "Illegal agument in Log" << std::endl ;
+    std::cout << "Illegal argument in Log" << std::endl ;
 #endif
-    throw Standard_NumericError("Illegal agument in Log");
+    throw Standard_NumericError("Illegal argument in Log");
   } 
  return log(Value); 
 }
@@ -330,9 +330,9 @@ Standard_Real     Sqrt (const Standard_Real Value)
 { 
   if (  Value < 0. ){
 #ifdef OCCT_DEBUG
-    std::cout << "Illegal agument in Sqrt" << std::endl ;
+    std::cout << "Illegal argument in Sqrt" << std::endl ;
 #endif
-    throw Standard_NumericError("Illegal agument in Sqrt");
+    throw Standard_NumericError("Illegal argument in Sqrt");
   } 
  return sqrt(Value); 
 }

src/Standard/Standard_Real.hxx

@@ -28,7 +28,7 @@
 // ===============================================
 
 // ==================================
-// Methods implemeted in Standard_Real.cxx
+// Methods implemented in Standard_Real.cxx
 // ==================================
 
 //! Computes a hash code for the given real, in the range [1, theUpperBound]
@@ -76,7 +76,7 @@ inline Standard_Boolean  IsEqual (const Standard_Real Value1,
          //  *********************************** //
          //       Class methods                  //
          //                                      //
-         //  Machine-dependant values            //
+         //  Machine-dependent values            //
          //  Should be taken from include file   //
          //  *********************************** //
 
@@ -142,7 +142,7 @@ inline Standard_Integer  RealSize()
 
 
          //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=//
-         //   End of machine-dependant values   //
+         //   End of machine-dependent values   //
          //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=//
 
 
@@ -176,7 +176,7 @@ inline Standard_Real     Cos (const Standard_Real Value)
 // Epsilon : The function returns absolute value of difference
 //           between 'Value' and other nearest value of
 //           Standard_Real type.
-//           Nearest value is choseen in direction of infinity
+//           Nearest value is chosen in direction of infinity
 //           the same sign as 'Value'.
 //           If 'Value' is 0 then returns minimal positive value
 //           of Standard_Real type.

src/Standard/Standard_ShortReal.hxx

@@ -24,7 +24,7 @@
          //  *********************************** //
          //       Class methods                  //
          //                                      //
-         //  Machine-dependant values            //
+         //  Machine-dependent values            //
          //  Should be taken from include file   //
          //  *********************************** //
 
@@ -136,7 +136,7 @@ inline Standard_ShortReal     Min (const Standard_ShortReal Val1,
 // ===============================================
 
 // ==================================
-// Methods implemeted in Standard_ShortReal.cxx
+// Methods implemented in Standard_ShortReal.cxx
 // ==================================
 
 //! Computes a hash code for the given short real, in the range [1, theUpperBound]

src/Standard/Standard_Type.cxx

@@ -99,7 +99,7 @@ namespace {
     return theRegistry;
   }
 
-  // To initialize theRegistry map as soon as possible to be destoryed the latest
+  // To initialize theRegistry map as soon as possible to be destroyed the latest
   Handle(Standard_Type) theType = STANDARD_TYPE(Standard_Transient);
 }
 

src/Standard/Standard_WarningsDisable.hxx

@@ -12,7 +12,7 @@
 // commercial license or contractual agreement.
 
 //!@file
-//! Supresses compiler warnings.
+//! Suppresses compiler warnings.
 //!
 //! Standard_WarningsDisable.hxx disables all compiler warnings.
 //! Standard_WarningsRestore.hxx restore the previous state of warnings.