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
#if DO_INVERSE
aBufSz[0] = InverseSize ((Standard_Integer)aBufSize);
#else
- aBufSz[0] = aBufSize;
+ aBufSz[0] = (Standard_Integer)aBufSize;
#endif
theStream.write (&aBuf[0], aBufSize + sizeof(Standard_Integer));
(const Standard_CString theValue)
{
alignOffset (1);
- Standard_Integer aSize = strlen (theValue) + 1;
+ Standard_Integer aSize = (Standard_Integer)(strlen (theValue) + 1);
prepareForPut (aSize);
putArray ((void* const)theValue, aSize);
return *this;
Standard_Byte* anImageRow = myImageAlpha->ChangeRow (aRowIter);
for (Standard_Size aColumnIter = 0; aColumnIter < myImage->Width(); aColumnIter++)
{
- myImage->PixelColor ((Standard_Integer )aColumnIter, (Standard_Integer )aRowIter, anAlpha);
+ myImage->PixelColor ((Standard_Integer)aColumnIter, (Standard_Integer)aRowIter, anAlpha);
anImageRow[aColumnIter] = Standard_Byte (255.0 * anAlpha);
}
}
char cardeb = text.Value(1);
Standard_Integer ln,lnt,i,j;
ln = text.Length();
- lnt = strlen(val) - ln;
+ lnt = (Standard_Integer)(strlen(val) - ln);
for (i = 0; i <= lnt; i ++) {
if (val[i] == cardeb) {
// un candidat
res->Append (text,lt, Interface_ParamText,0);
sprintf(nombre,"%d",theIntegerBits);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
sprintf(nombre,"%d",theMaxPower10Single);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
sprintf(nombre,"%d",theMaxDigitsSingle);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
sprintf(nombre,"%d",theMaxPower10Double);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
sprintf(nombre,"%d",theMaxDigitsDouble);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
MakeHollerith (theReceiveName,text,lt);
res->Append (text,lt, Interface_ParamText,0);
Interface_FloatWriter::Convert (theScale,nombre,Standard_True,0.,0.,"%f","%f");
// sprintf(nombre,"%f",theScale);
- res->Append (nombre,strlen(nombre),Interface_ParamReal,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamReal,0);
sprintf(nombre,"%d",theUnitFlag);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
MakeHollerith (theUnitName,text,lt);
res->Append (text,lt, Interface_ParamText,0);
sprintf(nombre,"%d",theLineWeightGrad);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
Interface_FloatWriter::Convert (theMaxLineWeight,nombre,Standard_True,0.,0.,"%f","%f");
// sprintf(nombre,"%f",theMaxLineWeight);
- res->Append (nombre,strlen(nombre),Interface_ParamReal,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamReal,0);
MakeHollerith (theDate,text,lt);
res->Append (text,lt, Interface_ParamText,0);
Interface_FloatWriter::Convert (theResolution,nombre,Standard_True,0.,0.,"%g","%g");
// sprintf(nombre,"%f",theResolution);
- res->Append (nombre,strlen(nombre),Interface_ParamReal,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamReal,0);
if (hasMaxCoord)
Interface_FloatWriter::Convert (theMaxCoord,nombre,Standard_True,0.,0.,"%f","%f");
// sprintf(nombre,"%f",theMaxCoord);
else nombre[0] = '\0';
- res->Append (nombre,strlen(nombre),Interface_ParamReal,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamReal,0);
MakeHollerith (theAuthorName,text,lt);
res->Append (text,lt, Interface_ParamText,0);
res->Append (text,lt, Interface_ParamText,0);
sprintf(nombre,"%d",theIGESVersion);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
sprintf(nombre,"%d",theDraftingStandard);
- res->Append (nombre,strlen(nombre),Interface_ParamInteger,0);
+ res->Append (nombre,(Standard_Integer)strlen(nombre),Interface_ParamInteger,0);
if (!theLastChangeDate.IsNull()) {
MakeHollerith (theLastChangeDate,text,lt);
void IGESData_IGESReaderData::AddGlobal
(const Interface_ParamType atype, const Standard_CString aval)
{
- theparh->Append(aval,strlen(aval),atype,0);
+ theparh->Append(aval,(int)strlen(aval),atype,0);
}
void IGESData_IGESReaderData::SetGlobalSection ()
//
pstartline=(Standard_PCharacter)startline;
//
- Standard_Integer lst = strlen (startline);
+ Standard_Size lst = strlen (startline);
if (lst == 0) return;
if (thestar.IsNull()) thestar = new TColStd_HSequenceOfHAsciiString();
- if (lst <= MaxcarsG) {
+ if (lst <= (Standard_Size)MaxcarsG) {
thestar->Append (new TCollection_HAsciiString(startline));
return;
}
const Standard_Integer more)
{
Standard_Integer lnstr = lnval;
- if (lnstr <= 0) lnstr = strlen(val);
+ if (lnstr <= 0) lnstr = (Standard_Integer)strlen(val);
if (!thecurr.CanGet (lnstr + more + 1)) {
// + 1 (18-SEP-1996) pour etre sur que le separateur n est pas en tete de ligne
if (thesect < 3) thehead->Append(thecurr.Moved());
/* Complement du parametre courant (cf Hollerith sur +ieurs lignes) */
void iges_addparam (int longval, char* parval)
{
- char *newval, *oldval; int i,long0;
+ char *newval, *oldval; int i;
+ size_t long0;
if (longval <= 0) return;
oldval = curparam->parval;
long0 = strlen(oldval);
/* newval = (char*) malloc(long0+longval+1); */
- newval = iges_newchar("",long0+longval+1);
+ newval = iges_newchar("",(int)long0+longval+1);
for (i = 0; i < long0; i ++) newval[i] = oldval[i];
for (i = 0; i < longval; i ++) newval[i+long0] = parval[i];
newval[long0+longval] = '\0';
if (myGroupsOfDiffPixels.IsEmpty())
{
TColStd_MapOfInteger* aGroup = new TColStd_MapOfInteger();
- aGroup->Add (aValue1);
- aGroup->Add (aValue2);
+ aGroup->Add ((Standard_Integer)aValue1);
+ aGroup->Add ((Standard_Integer)aValue2);
myGroupsOfDiffPixels.Append (aGroup);
}
else
for (ListOfMapOfInteger::Iterator aGrIter (myGroupsOfDiffPixels); aGrIter.More(); aGrIter.Next())
{
TColStd_MapOfInteger*& aGroup = aGrIter.ChangeValue();
- if (aGroup->Contains (aValue1))
+ if (aGroup->Contains ((Standard_Integer)aValue1))
{
- aGroup->Add (aValue2);
+ aGroup->Add ((Standard_Integer)aValue2);
isFound = Standard_True;
break;
}
{
// Create a new group
TColStd_MapOfInteger* aGroup = new TColStd_MapOfInteger();
- aGroup->Add (aValue1);
- aGroup->Add (aValue2);
+ aGroup->Add ((Standard_Integer)aValue1);
+ aGroup->Add ((Standard_Integer)aValue2);
myGroupsOfDiffPixels.Append (aGroup);
}
}
for (Standard_Size aNgbrIter = 0; aNgbrIter < NEIGHBOR_PIXELS_NB; ++aNgbrIter)
{
if (NEIGHBOR_PIXELS[aNgbrIter].isValid (aDataRef, aRow1, aCol1)
- && aGroup->Contains (NEIGHBOR_PIXELS[aNgbrIter].pixel2Int (aRow1, aCol1)))
+ && aGroup->Contains ((Standard_Integer)NEIGHBOR_PIXELS[aNgbrIter].pixel2Int (aRow1, aCol1)))
{
++aNeighboursNb;
}
if(( (Dup*UV1mUtest + Dvp*UV2mVtest) < 0) ||
( Abs(UV1mUtest) < tolu
&& Abs(UV2mVtest) < tolv)) {
- i_candidates.Append(i);
+ i_candidates.Append((Standard_Integer)i);
SqDist_candidates.Append(Dup*Dup + Dvp*Dvp);
/*
Irang=i;
(Vp-Vmult(j))*(UV(2)-Vmult(j)) < 0) ||
(Abs(UV(1)-Umult(j)) < tolu &&
Abs(UV(2)-Vmult(j)) < tolv)) {
- Irang=i;
+ Irang=(Standard_Integer)i;
Arrive = Standard_True;
UV(1) = Utest;
UV(2) = Vtest;
const Standard_CString aval, const Interface_ParamType atype,
const Standard_Integer nument)
{
-// Interface_FileParameter FP;
-// FP.Init(aval,atype);
theparams->Append(aval,-1,atype,nument);
- //thenbpar(num) ++; // SetValue(num,thenbpar(num)+1);
}
void Interface_FileReaderData::AddParam
const TCollection_AsciiString& aval, const Interface_ParamType atype,
const Standard_Integer nument)
{
-// Interface_FileParameter FP;
-// FP.Init(aval,atype);
theparams->Append(aval.ToCString(),aval.Length(),atype,nument);
- //thenbpar(num) ++; // .SetValue(num,thenbpar(num)+1);
}
void Interface_FileReaderData::AddParam
const Interface_FileParameter& FP)
{
theparams->Append(FP);
- //thenbpar(num) ++; // .SetValue(num,thenbpar(num)+1);
}
(const Standard_Integer num, const Standard_Integer nump,
const Interface_FileParameter& FP)
{
- //if (nump <= thenbpar.Value(num))
theparams->SetParam(thenumpar(num-1)+nump,FP);
}
(const Standard_Integer num) const
{
if (num > 1) return (thenumpar(num) - thenumpar(num-1));
- else if(num ==1) return thenumpar(num); //thenbpar(num);
+ else if(num ==1) return thenumpar(num);
else return theparams->NbParams();
}
pText[j0+5] = lxp[4];
pText[j0+6] = '\0';
}
- return strlen(text);
+ return (Standard_Integer)strlen(text);
}
// .... AJOUTS ....
void Interface_LineBuffer::Add (const Standard_CString text)
- { Add (text,strlen(text)); }
+ { Add (text,(Standard_Integer)strlen(text)); }
void Interface_LineBuffer::Add
(const Standard_CString text, const Standard_Integer lntext)
Standard_Integer i;
if (thelnval + lnval + 1 > thelnres) {
// Reservation de caracteres insuffisante : d abord augmenter
- Standard_Integer newres = thelnres*2 + lnval ;
+ Standard_Integer newres = (Standard_Integer)(thelnres*2 + lnval);
char* newval = new char[newres];
for (i = 0; i < thelnval; i++)
newval[i] = theval[i]; //szv#4:S4163:12Mar99 `<= thelnres` was wrong
Interface_FileParameter& FP = thelist->ChangeValue(thenbpar);
FP.Init(&theval[thelnval],typ);
if (nument != 0) FP.SetEntityNumber(nument);
- thelnval += (lnval+1);
+ thelnval += (Standard_Integer)(lnval+1);
}
return thenbpar;
}
} // end else
+#pragma warning(push)
+#pragma warning(disable:4306) /* level 4 warning on cast of int to HWND in HWND_BROADCAST macro */
PostMessage ( HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0 );
+#pragma warning(pop)
} else {
va_start( argptr, fmt );
cnt = vsprintf ( buffer, fmt, argptr );
va_end ( argptr );
- WriteConsole ( hConsole, buffer, strlen ( buffer ), &lpcchWritten, NULL );
+ WriteConsole ( hConsole, buffer, (DWORD) strlen ( buffer ), &lpcchWritten, NULL );
return cnt;
} /* end cPrintf */
va_start( argptr, fmt );
cnt = vsprintf ( buffer, fmt, argptr );
va_end ( argptr );
- WriteConsole ( hConsole, buffer, strlen ( buffer ), &lpcchWritten, NULL );
+ WriteConsole ( hConsole, buffer, (DWORD )strlen ( buffer ), &lpcchWritten, NULL );
return cnt;
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);
}
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;
// 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
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;
// 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;
// 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;")) {
}
// 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;
ptrDest += entity_ref[aCode].length;
}
}
- theLen = ptrDest - aDest;
+ theLen = (Standard_Integer)(ptrDest - aDest);
* ptrDest = '\0';
}
return aDest;
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;
}
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;
}
{
const char * aTagString = theTagName.GetString();
LDOM_BasicElement& aBasicElem = LDOM_BasicElement::Create (aTagString,
- strlen(aTagString),
+ (Standard_Integer)strlen(aTagString),
myMemManager);
return LDOM_Element (aBasicElem, myMemManager);
}
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;
// 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)
myPtr = aNameEnd;
if (myPtr < myEndPtr) {
myElement = & LDOM_BasicElement::Create (aStartData,
- myPtr - aStartData,
+ (Standard_Integer)(myPtr - aStartData),
myDocument);
myLastChild = NULL;
aState = STATE_ATTRIBUTE_NAME;
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:
myEntry : Address ; -- unused by Windows NT code
myInit : Integer ; -- unused by Windows NT code
myError : Error;
- myHandle : Integer; -- Windows NT specific
+ myHandle : Address; -- Windows NT specific
myData : Address; -- Windows NT specific
myFirstCall : Boolean; -- Windows NT specific
end DirectoryIterator from OSD;
) {
myFlag = Standard_False;
- myHandle = ( Standard_Integer )INVALID_HANDLE_VALUE;
+ myHandle = INVALID_HANDLE_VALUE;
where.SystemName ( myPlace );
if ( myData != NULL ) HeapFree ( GetProcessHeap (), 0, myData );
- if ( myHandle != ( Standard_Integer )INVALID_HANDLE_VALUE )
+ if ( myHandle != INVALID_HANDLE_VALUE )
FindClose ( ( HANDLE )myHandle );
Standard_Boolean OSD_DirectoryIterator :: More () {
- if ( myHandle == ( Standard_Integer )INVALID_HANDLE_VALUE ) {
+ if ( myHandle == INVALID_HANDLE_VALUE ) {
TCollection_AsciiString wc = myPlace + TEXT( "/" ) + myMask;
GetProcessHeap (), HEAP_GENERATE_EXCEPTIONS, sizeof ( WIN32_FIND_DATA )
);
- myHandle = ( Standard_Integer )FindFirstFile (
- wc.ToCString (), ( PWIN32_FIND_DATA )myData
- );
+ myHandle = FindFirstFile (wc.ToCString (), (PWIN32_FIND_DATA)myData);
- if ( myHandle == ( Standard_Integer )INVALID_HANDLE_VALUE )
-
- _osd_wnt_set_error ( myError, OSD_WDirectoryIterator );
+ if ( myHandle == INVALID_HANDLE_VALUE )
+
+ _osd_wnt_set_error ( myError, OSD_WDirectoryIterator );
else {
} else if ( !myFlag ) {
FindClose ( ( HANDLE )myHandle );
- myHandle = ( Standard_Integer )INVALID_HANDLE_VALUE;
+ myHandle = INVALID_HANDLE_VALUE;
} // end if
myEntry : Address ; -- unused by Windows NT code
myInit : Integer ; -- unused by Windows NT code
myError : Error;
- myHandle : Integer; -- Windows NT specific
+ myHandle : Address; -- Windows NT specific
myData : Address; -- Windows NT specific
myFirstCall : Boolean; -- Windows NT specific
end FileIterator from OSD;
) {
myFlag = Standard_False;
- myHandle = ( Standard_Integer )INVALID_HANDLE_VALUE;
+ myHandle = INVALID_HANDLE_VALUE;
where.SystemName ( myPlace );
if ( myData != NULL ) HeapFree ( GetProcessHeap (), 0, myData );
- if ( myHandle != ( Standard_Integer )INVALID_HANDLE_VALUE )
+ if ( myHandle != INVALID_HANDLE_VALUE )
FindClose ( ( HANDLE )myHandle );
Standard_Boolean OSD_FileIterator :: More () {
- if ( myHandle == ( Standard_Integer )INVALID_HANDLE_VALUE ) {
+ if ( myHandle == INVALID_HANDLE_VALUE ) {
TCollection_AsciiString wc = myPlace + TEXT( "/" ) + myMask;
GetProcessHeap (), HEAP_GENERATE_EXCEPTIONS, sizeof ( WIN32_FIND_DATA )
);
- myHandle = ( Standard_Integer )FindFirstFile (
- wc.ToCString (), ( PWIN32_FIND_DATA )myData
- );
+ myHandle = FindFirstFile (wc.ToCString (), (PWIN32_FIND_DATA)myData);
- if ( myHandle == ( Standard_Integer )INVALID_HANDLE_VALUE )
+ if ( myHandle == INVALID_HANDLE_VALUE )
_osd_wnt_set_error ( myError, OSD_WDirectoryIterator );
} else if ( !myFlag ) {
FindClose ( ( HANDLE )myHandle );
- myHandle = ( Standard_Integer )INVALID_HANDLE_VALUE;
+ myHandle = INVALID_HANDLE_VALUE;
} // end if
static int intstr(Standard_Integer V,Standard_CString F)
{
sprintf(cnvbuf,F,V);
- return strlen(cnvbuf);
+ return (int)strlen(cnvbuf);
}
//-----------------------------------------------------------------------
static int realstr(Standard_Real V, Standard_CString F)
{
sprintf(cnvbuf,F,V);
- return strlen(cnvbuf);
+ return (int)strlen(cnvbuf);
}
//-----------------------------------------------------------------------
si = 0;
memcpy(arr,sarr,2000);
arr[1999]=0;
- int n = strlen(arr), s=0;
+ int n = (int)strlen(arr), s=0;
while (n--)
s += StackOverflow(i-1);
return i + s + StackOverflow(i-1);
PERF_STOP_METER("NCollection_SparseArray filling")
PERF_START_METER("NCollection_SparseArray size")
- Standard_Integer sizeSparseArray=a1.Size();
+ Standard_Size sizeSparseArray=a1.Size();
+ (void)sizeSparseArray; // avoid compiler warning on unused variable
PERF_STOP_METER("NCollection_SparseArray size")
PERF_START_METER("NCollection_Array1 Assign")
}
else if (partyp == Interface_ParamText) {
// Return integre a supprimer silya
- Standard_Integer lval = strlen(val); Standard_Integer mval = -1;
+ Standard_Integer lval = (Standard_Integer)strlen(val); Standard_Integer mval = -1;
for (Standard_Integer j = 0; j < lval; j ++) {
if (val[j] == '\n') { mval = i; break; }
}
iloc = i - decal;
if(!a[iloc]) break;
if (a[iloc][0] == '-') {
- l = strlen(a[iloc]);
+ l = (Standard_Integer)strlen(a[iloc]);
for (j=1; j<l; j++) {
if (a[iloc][j] == 'g') tgeo=Standard_True;
else if(!strcmp(a[iloc],"-tol")) tolflag = Standard_True;
/**
* Set the polygons
*/
- inline void SetPolygons (const Standard_Integer nPolygons,
+ inline void SetPolygons (const Standard_Size nPolygons,
const Standard_Integer ** thePolygons)
{ myNbPolygons = nPolygons; myArrPolygons = thePolygons; }
/**
* Set the normals array of indice
*/
- inline void SetNormalInd (const Standard_Integer nIndice,
+ inline void SetNormalInd (const Standard_Size nIndice,
const Standard_Integer ** theIndice)
{ myNbNormals = nIndice; myArrNormalInd = theIndice; }
/**
* Set the colors array of indice
*/
- inline void SetColorInd (const Standard_Integer nIndice,
+ inline void SetColorInd (const Standard_Size nIndice,
const Standard_Integer ** theIndice)
{ myNbColors = nIndice; myArrColorInd = theIndice; }
/**
* Set the TexCoordiante array of indice
*/
- inline void SetTextureCoordInd (const Standard_Integer nIndice,
+ inline void SetTextureCoordInd (const Standard_Size nIndice,
const Standard_Integer ** theIndice)
{ myNbTextures = nIndice; myArrTextureInd = theIndice; }
/**
* Set the polygons
*/
- inline void SetPolygons (const Standard_Integer nPolygons,
+ inline void SetPolygons (const Standard_Size nPolygons,
const Standard_Integer ** thePolygons)
{ myNbPolygons = nPolygons; myArrPolygons = thePolygons; }
/**
* Set the colors array of indice
*/
- inline void SetColorInd (const Standard_Integer nIndice,
+ inline void SetColorInd (const Standard_Size nIndice,
const Standard_Integer ** theIndice)
{ myNbColors = nIndice; myArrColorInd = theIndice; }
if (aTagValue <= 0 || aPtr[0] != aQuote ||
errno == ERANGE || errno == EINVAL)
return Standard_False;
- Standard_Integer aLen = aPtr - &aSource[1];
+ Standard_Integer aLen = (Standard_Integer)(aPtr - &aSource[1]);
aTagEntryPtr[0] = ':';
memcpy (&aTagEntryPtr[1], &aSource[1], aLen);
aTagEntryPtr += (aLen + 1);
long aTagValue = strtol (aTagEntry, &ptr, 10);
if (aTagValue <= 0 || errno == ERANGE || errno == EINVAL)
return; // error
- Standard_Integer aTagSize = ptr - aTagEntry;
+ Standard_Integer aTagSize = (Standard_Integer)(ptr - aTagEntry);
// Add one XPath level to the expression in aTarget
memcpy (&aTargetPtr[0], aRefElem1, anElem1Size);
TCollection_AsciiString( i );
TCollection_AsciiString aStrIndex = TCollection_AsciiString( ITEM_VALUE ) +
TCollection_AsciiString( i );
- theTarget.Element().setAttribute( anIdStr.ToCString(), anIt.Index() );
+ theTarget.Element().setAttribute( anIdStr.ToCString(), (Standard_Integer)anIt.Index() );
theTarget.Element().setAttribute( aStrIndex.ToCString(), anIt.Value() );
i++;
}
projects / occt-copy.git / commitdiff