0024186: Eliminate remaining compiler warnings in MSVC++ 2010 64 bit with warning level 4

Eliminated some warnings of type C4267 (conversion from Type1 to Type2: possible loss of data); size_t to int explicit casts added.
Fixed warning C4267 and 4244 in OSD* files

Change in OSD_FileNode and OSD_File reverted since different handle types are needed on Unix and Windows

src/LDOM/LDOMString.cxx

@@ -56,7 +56,7 @@ LDOMString::LDOMString (const LDOMBasicString&          anOther,
   case LDOM_AsciiDoc:
     {
       const char * aString = anOther.GetString ();
-      Standard_Integer aLen = strlen (aString) + 1;
+      Standard_Integer aLen = (Standard_Integer)(strlen (aString) + 1);
       myVal.ptr = ((LDOM_MemManager *) myPtrDoc) -> Allocate (aLen);
       memcpy (myVal.ptr, aString, aLen);
     }

src/LDOM/LDOM_BasicAttribute.cxx

@@ -46,7 +46,7 @@ LDOM_BasicAttribute& LDOM_BasicAttribute::Create
 
   const char * aString = theName.GetString();
   aNewAtt -> myName =
-    theDoc -> HashedAllocate (aString, strlen(aString), theHash);
+    theDoc -> HashedAllocate (aString, (Standard_Integer)strlen(aString), theHash);
 
   aNewAtt -> myNodeType = LDOM_Node::ATTRIBUTE_NODE;
   return * aNewAtt;

src/LDOM/LDOM_BasicElement.cxx

@@ -277,7 +277,7 @@ const LDOM_BasicNode * LDOM_BasicElement::RemoveAttribute
   //  Check attribute hash value against the current mask
   const char * const aNameStr = aName.GetString();
   const Standard_Integer aHash =
-    LDOM_MemManager::Hash (aNameStr, strlen(aNameStr));
+    LDOM_MemManager::Hash (aNameStr, (Standard_Integer)strlen(aNameStr));
   const unsigned int anAttrMaskValue = aHash & (8*sizeof(myAttributeMask) - 1);
   const unsigned long anAttributeMask = (1 << anAttrMaskValue);
 #ifdef DEBUG_MASK
@@ -422,7 +422,7 @@ void LDOM_BasicElement::ReplaceElement
         const LDOM_BasicElement& aBNodeElem = *(const LDOM_BasicElement*)aBNode;
         const char * aTagString = aBNodeElem.GetTagName();
         LDOM_BasicElement& aNewBNodeElem =
-          LDOM_BasicElement::Create (aTagString, strlen(aTagString), aDocument);
+          LDOM_BasicElement::Create (aTagString, (Standard_Integer)strlen(aTagString), aDocument);
         aNewBNodeElem.ReplaceElement (aBNodeElem, aDocument); //reccur
         aNewBNode = &aNewBNodeElem;
         break;

src/LDOM/LDOM_CharReference.cxx

@@ -61,15 +61,15 @@ char * LDOM_CharReference::Decode (char * theSrc, Standard_Integer& theLen)
       //        End of the loop
       aPtr = strchr (aSrcPtr, '\0');
       if (anIncrCount == 0)
-        theLen = aPtr - theSrc;
+        theLen = (Standard_Integer)(aPtr - theSrc);
       else {
-        Standard_Integer aByteCount = aPtr - aSrcPtr;
+        Standard_Integer aByteCount = (Standard_Integer)(aPtr - aSrcPtr);
         memmove (aDstPtr, aSrcPtr, aByteCount + 1);
-        theLen = (aDstPtr - theSrc) + aByteCount;
+        theLen = (Standard_Integer)(aDstPtr - theSrc) + aByteCount;
       }
       break;
     }
-    Standard_Integer aByteCount = aPtr - aSrcPtr;
+    Standard_Integer aByteCount = (Standard_Integer)(aPtr - aSrcPtr);
     if (aByteCount > 0 && aDstPtr != aSrcPtr)
       memmove (aDstPtr, aSrcPtr, aByteCount);
     aSrcPtr = aPtr;
@@ -85,7 +85,7 @@ char * LDOM_CharReference::Decode (char * theSrc, Standard_Integer& theLen)
         //      Error reading an XML string
         return NULL;
       aDstPtr[-1] = (char) aChar;
-      anIncrCount += aNewPtr - aSrcPtr;
+      anIncrCount += (Standard_Integer)(aNewPtr - aSrcPtr);
       aSrcPtr = &aNewPtr[1];
     }
     else if (IS_EQUAL(aSrcPtr+1, "amp;")) {
@@ -167,7 +167,7 @@ char * LDOM_CharReference::Encode (const char* theSrc, Standard_Integer& theLen,
   }
   //    If there are such, copy the string with replacements
   if (!aCount)
-    theLen = endSrc - theSrc;
+    theLen = (Standard_Integer)(endSrc - theSrc);
   else {
     char * ptrDest = new char [(endSrc - theSrc) + aCount * 5 + 1];
     aDest = ptrDest;
@@ -188,7 +188,7 @@ char * LDOM_CharReference::Encode (const char* theSrc, Standard_Integer& theLen,
           ptrDest += entity_ref[aCode].length;
         }
     }
-    theLen = ptrDest - aDest;
+    theLen = (Standard_Integer)(ptrDest - aDest);
     * ptrDest = '\0';
   }
   return aDest;

src/LDOM/LDOM_CharacterData.cxx

@@ -78,6 +78,6 @@ void LDOM_CharacterData::setData (const LDOMString& theValue)
 Standard_Integer LDOM_CharacterData::getLength () const
 {
   if (myLength < 0)
-    (Standard_Integer&)myLength = strlen (getNodeValue().GetString());
+    (Standard_Integer&)myLength = (Standard_Integer)strlen (getNodeValue().GetString());
   return myLength;
 }

src/LDOM/LDOM_Document.cxx

@@ -108,7 +108,7 @@ LDOM_Document LDOM_Document::createDocument (const LDOMString& theQualifiedName)
   if (strlen(aString) == 0)
     aString = "document";
   aDoc.myMemManager -> myRootElement =
-    & LDOM_BasicElement::Create (aString, strlen(aString), aDoc.myMemManager);
+    & LDOM_BasicElement::Create (aString, (Standard_Integer)strlen(aString), aDoc.myMemManager);
   return aDoc;
 }
 
@@ -121,7 +121,7 @@ LDOM_Element LDOM_Document::createElement (const LDOMString& theTagName)
 {
   const char * aTagString = theTagName.GetString();
   LDOM_BasicElement& aBasicElem = LDOM_BasicElement::Create (aTagString,
-                                                             strlen(aTagString),
+                                                             (Standard_Integer)strlen(aTagString),
                                                              myMemManager);
   return LDOM_Element (aBasicElem, myMemManager);
 }

src/LDOM/LDOM_MemManager.cxx

@@ -84,7 +84,7 @@ void * LDOM_MemManager::MemBlock::AllocateAndCheck
                          const LDOM_MemManager::MemBlock *& aFirstWithoutRoom)
 {
   void * aResult = NULL;
-  Standard_Integer aRoom = myEndBlock - myFreeSpace;
+  Standard_Integer aRoom = (Standard_Integer)(myEndBlock - myFreeSpace);
   if (aSize <= aRoom) {
     aResult = myFreeSpace;
     myFreeSpace += aSize;

src/LDOM/LDOM_XmlReader.cxx

@@ -120,7 +120,7 @@ LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord
     //  Check if the current file buffer is exhausted
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     //  There should always be some bytes available in the buffer for analysis
-    Standard_Integer aBytesRest = myEndPtr - myPtr;
+    Standard_Integer aBytesRest = (Standard_Integer)(myEndPtr - myPtr);
     if (aBytesRest < XML_MIN_BUFFER) {
       if (myEOF == Standard_True) {
         if (aBytesRest <= 0)
@@ -202,7 +202,7 @@ LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord
             myPtr = aNameEnd;
             if (myPtr < myEndPtr) {
               myElement = & LDOM_BasicElement::Create (aStartData,
-                                                       myPtr - aStartData,
+                                                       (Standard_Integer)(myPtr - aStartData),
                                                        myDocument);
               myLastChild = NULL;
               aState = STATE_ATTRIBUTE_NAME;
@@ -408,7 +408,7 @@ LDOM_XmlReader::RecordType LDOM_XmlReader::ReadRecord
           aStartData = myPtr;
         else {
           if (theData.Length() == 0)
-            anAttrName = LDOMBasicString(myPtr, aNameEnd - myPtr, myDocument);
+            anAttrName = LDOMBasicString(myPtr, (Standard_Integer)(aNameEnd - myPtr), myDocument);
           else {
             theData.rdbuf()->sputn(myPtr, aNameEnd - myPtr);
 attr_name: