Add missing const& to catch statements.
Standard_Real aLength;
try {
aLength = UnitsAPI::AnyToLS(100. ,"mm");
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
aLength = 0.1;
}
DA->SetAxisLength(aLength,aLength,aLength);
Handle(Font_FTFont) aFont = new Font_FTFont();
aFont->Init (aTextAspect->Aspect()->Font().ToCString(),
aTextAspect->Aspect()->GetTextFontAspect(),
- (const unsigned int)aTextAspect->Height(),
+ (unsigned int )aTextAspect->Height(),
THE_2D_TEXT_RESOLUTION);
for (NCollection_Utf8Iter anIter = anUTFString.Iterator(); *anIter != 0; )
updateAttributes (thePrs);
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
#ifdef OCCT_DEBUG
std::cout << "AIS_TexturedShape::Compute() in ShadingMode failed \n";
try {
Variation.Approximate();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return;
}
TestCurveOnSurface();
}
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
BOPAlgo_CheckResult aResult;
aResult.SetCheckStatus(BOPAlgo_CheckUnknown);
myResult.Append(aResult);
PerformInternal1(theFiller);
}
//
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
AddError (new BOPAlgo_AlertBuilderFailed);
}
}
PostTreat();
}
//
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
AddError (new BOPAlgo_AlertIntersectionFailed);
}
}
PerformInternal();
}
//
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
AddError (new BOPAlgo_AlertIntersectionFailed);
}
}
myFlag=myContext->ComputeVE (myV, myE, myT, myTolVNew, myFuzzyValue);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertIntersectionFailed);
}
IntTools_EdgeEdge::Perform();
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertIntersectionFailed);
}
myFlag=myContext->ComputeVF(myV, myF, myT1, myT2, myTolVNew, myFuzzyValue);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertIntersectionFailed);
}
IntTools_EdgeFace::Perform();
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertIntersectionFailed);
}
IntTools_FaceFace::Perform(myF1, myF2);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertIntersectionFailed);
}
UpdateVertices(aCopyE, myF);
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertBuildingPCurveFailed(TopoDS_Shape()));
}
// Post treatment
PostTreat();
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
AddError(new BOPAlgo_AlertRemoveFeaturesFailed());
}
// Trim the extended faces
TrimExtendedFaces(aFaceExtFaceMap);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
// Make sure the warning will be given on the higher level
myHasAdjacentFaces = Standard_True;
aBB.Add(aRFaces, aFSp);
}
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
continue;
}
}
BRepLib::SameParameter(aE1T);
BRepLib::SameRange(aE1T);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
iRet = 6;
return iRet;
myResShape = aQuilt.Shells();
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
SetStatus(FS_Exception);
#ifdef OCCT_DEBUG
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
isSamePar = Standard_False;
}
BRepLib::SameParameter(sec, BRep_Tool::Tolerance(sec));
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
#ifdef OCCT_DEBUG
cout << "Fail: BRepBuilderAPI_Sewing::SameParameterShape exception in BRepLib::SameParameter" << endl;
#endif
B.Continuity(E,F1,F2,aCont);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
#ifdef OCCT_DEBUG
cout << "Failure: Exception in BRepLib::EncodeRegularity" << endl;
TopoDS_Vertex aV2 = TopExp::LastVertex( aLastEdge, Standard_True );
return ( aV1.IsSame( aV2 ) && Is2DConnected( aLastEdge, aFisrtEdge, theSurface, theLocation));
}
- catch ( Standard_Failure ) {
+ catch (Standard_Failure const&) {
return Standard_False;
}
}
this->registerNode(BRep_Tool::Pnt(theVertex), aPnt2d,
BRepMesh_Fixed, Standard_False);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
}
}
{
tgtfaces(E, F1, F2, couture, theResAngle);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
}
}
if (aFM.IsDone())
aF = aFM.Face();
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
}
CreateSmoothed();
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
NotDone();
return;
alignOffset (1);
Standard_Integer aSize = (Standard_Integer)(strlen (theValue) + 1);
prepareForPut (aSize);
- putArray ((void* const)theValue, aSize);
+ putArray ((void* )theValue, aSize);
return *this;
}
alignOffset (BP_INTSIZE, Standard_True);
Standard_Integer aSize = theValue.Length() + 1;
prepareForPut (aSize);
- putArray ((void* const)theValue.ToCString(), aSize);
+ putArray ((void*)theValue.ToCString(), aSize);
return *this;
}
Standard_Integer aStartIndex = myIndex;
Standard_Integer aStartOffset = myOffset;
#endif
- putArray ((void* const)theValue.ToExtString(), aSize);
+ putArray ((void* )theValue.ToExtString(), aSize);
#if DO_INVERSE
inverseExtCharData (aStartIndex, aStartOffset, aSize - BP_EXTCHARSIZE);
#endif
if (aReader.IsNull())
return PCDM_RS_NoDriver;
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
// no need to report error, this was just check for availability
}
}
}
- catch (CDF_MetaDataDriverError anException) {
+ catch (CDF_MetaDataDriverError const& anException) {
CAUGHT(anException, aStatusAssociatedText, TCollection_ExtendedString("metadatadriver failed; reason:"));
status = PCDM_SS_DriverFailure;
}
try {
LoadNamingDS(aResultLabel, aWire, anArV, isClosed);
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
aFunction->SetFailure(NAMING_FAILED);
return -1;
}
#ifdef _WIN32
#define EXCEPTION ...
#else
-#define EXCEPTION Standard_Failure
+#define EXCEPTION Standard_Failure const&
#endif
#include <ModelDefinitions.hxx>
//#define DEBUG
if(!aSelector.Select(aShape, aCONTEXT, aGeometry, aKeepOrientation))
return 1;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
}
if(!aSelector.Select(aShape, aCONTEXT, aGeometry, aKeepOrientation))
return 1;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
cout << "EXCEPTION: SELECTION_IMPOSSIBLE" <<endl;
}
#ifdef _WIN32
#define EXCEPTION ...
#else
-#define EXCEPTION Standard_Failure
+#define EXCEPTION Standard_Failure const&
#endif
#define FACES_TAG 1
try {
OSD::ControlBreak();
}
- catch (OSD_Exception_CTRL_BREAK) {
+ catch (OSD_Exception_CTRL_BREAK const&) {
di << "User pressed Control-Break";
return 1; // Tcl exception
}
OCC_CATCH_SIGNALS
Tcl_Exit(0);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
#ifdef OCCT_DEBUG
cout <<"Tcl_Exit have an exeption" << endl;
#endif
try {
OCC_CATCH_SIGNALS
Tk_Init(interp) ;
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
cout <<" Pb au lancement de TK_Init "<<endl;
}
{
Draw_DisplayConnection = new Aspect_DisplayConnection();
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
std::cout << "Cannot open display. Interpret commands in batch mode." << std::endl;
return Standard_False;
prompt:
if (tty) Prompt(Draw::GetInterpretor().Interp(), gotPartial);
- } catch (Standard_Failure) {}
+ } catch (Standard_Failure const&) {}
}
ExprIntrp_stop_string();
return Standard_True;
}
- catch (Standard_Failure) {}
+ catch (Standard_Failure const&) {}
}
ExprIntrp_stop_string();
return Standard_False;
try {
Variation.Approximate();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return;
}
try {
Variation.Approximate();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return;
}
try {
Variation.Approximate();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return;
}
try {
Variation2.Approximate();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return;
}
Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
}
- catch (Standard_ConstructionError) {
+ catch (Standard_ConstructionError const&) {
IsTrsf = Standard_False;
}
if (!IsTrsf) {
theFVal = -1.0*aP1.SquareDistance(aP2);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
return Standard_False;
}
//
*theDeriv2 = -2.0*(aVec2.SquareMagnitude() + aVec1.Dot(aVec3));
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
return Standard_False;
}
myMaxDistance = sqrt(Abs(myMaxDistance));
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
myErrorStatus = 3;
}
}
theNbParticles = Max(theNbParticles, aBS2DCurv->Degree());
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
#ifdef OCCT_DEBUG
cout << "ERROR! BRepLib_CheckCurveOnSurface.cxx, "
}
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
#ifdef OCCT_DEBUG
cout << "BRepLib_CheckCurveOnSurface.cxx: Exception in MinComputing()!" << endl;
}
}
- catch (Standard_Failure )
+ catch (Standard_Failure const&)
{
di << " Standard Failure \n";
}
DBRep::Set("Ellipse",edge_curve);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
di << " Standard Failure \n";
}
}
}
- catch (Standard_Failure )
+ catch (Standard_Failure const&)
{
di << " Standard Failure \n";
}
if (level == 3) C = CT.CheckList();
else C = CT.CompleteCheckList();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
Handle(Message_Messenger) sout = Message::DefaultMessenger();
sout<<" **** Interruption DumpModel (Check) par Exception ****\n";
S<<" ** ** Exception Raised during Check ! ** **\n";
OCC_CATCH_SIGNALS
IGESFile_ReadHeader(IR);
} // fin essai 1 (global)
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// Sending of message : Internal error during the header reading
Message_Msg Msg11 = Message_Msg("XSTEP_11");
IGESFile_Check (1,Msg11);
// Sending of message : Loaded data
} // fin essai 2 (entites)
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// Sending of message : Internal error during the content reading
if (recupnp == 0) {
Message_Msg Msg13 = Message_Msg("XSTEP_13");
OCC_CATCH_SIGNALS
dump.Dump(igesent,S,level,(level-1)/3);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
S << " ** Dump Interrupt **" << endl;
}
}
OCC_CATCH_SIGNALS
BRepLib::EncodeRegularity (sh,tolang);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
return Standard_False;
}
return Standard_True;
OCC_CATCH_SIGNALS
shape = CAS.TransferGeometry(ent);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
shape.Nullify();
}
}
BSplineRes->Segment(Udeb, Ufin);
res = BSplineRes;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(BSplineRes2,Udeb,Ufin);
res = gtc;
}
OCC_CATCH_SIGNALS
res = TransferCurveAndSurface(start);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
Message_Msg msg1015("IGES_1015");
SendFail(start, msg1015);
}
OCC_CATCH_SIGNALS
res = TransferGeometry(stsub);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
res.Nullify();
Message_Msg msg1015("IGES_1015");
SendFail( st408, msg1015);
OCC_CATCH_SIGNALS
item = TransferGeometry(st308->AssociatedEntity(i));
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
item.Nullify();
Message_Msg msg1015("IGES_1015");
SendFail( st308->AssociatedEntity(i), msg1015);
OCC_CATCH_SIGNALS
item = TransferGeometry(st402f1->Entity(i));
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
item.Nullify();
Message_Msg msg1015("IGES_1015");
SendFail(st402f1->Entity(i),msg1015);
OCC_CATCH_SIGNALS
item = TransferGeometry(st402f7->Entity(i));
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
item.Nullify();
Message_Msg msg1015("IGES_1015");
SendFail(st402f7->Entity(i),msg1015);
OCC_CATCH_SIGNALS
BRepLib::EncodeRegularity (sh,tolang);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
return Standard_False;
}
return Standard_True;
TP.Transfer(ent);
shape = TransferBRep::ShapeResult (theProc,ent);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
Message_Msg msg1005("IGES_1005");
TF->Send (msg1005, Message_Info);
continue;
OCC_CATCH_SIGNALS
shape = CAS.TransferGeometry (ent);
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
Message_Msg msg1015("IGES_1015");
TF->Send (msg1015, Message_Info);
exceptionRaised = Standard_True;
}
inline const ThePSurface& IntImp_ZerParFunc::AuxillarSurface1() const {
- return (*((const ThePSurface * const)(surf1)));
+ return *((const ThePSurface* )surf1);
}
inline const ThePSurface& IntImp_ZerParFunc::AuxillarSurface2() const {
- return (*((const ThePSurface * const)(surf2)));
+ return *((const ThePSurface* )surf2);
}
(aP1.XYZ()-aP2.XYZ()).Coord(theF(anIndF), theF(anIndF+1), theF(anIndF+2));
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
return Standard_False;
}
aD2[mySeamCoordInd].Reversed().Coord(theD(anIndRD, anIndCD+2),
theD(anIndRD+1, anIndCD+2), theD(anIndRD+2, anIndCD+2));
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
return Standard_False;
}
OCC_CATCH_SIGNALS
BeginRead(amodel); // selon la norme
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// Sendinf of message : Internal error during the header reading
Message_Msg Msg11("XSTEP_11");
TF->Send (Msg11, Message_Info);
OCC_CATCH_SIGNALS
EndRead(amodel); // selon la norme
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// Sendinf of message : Internal error during the header reading
Message_Msg Msg11("XSTEP_11");
TF->Send (Msg11, Message_Info);
Standard_Integer aCount = 0;
// Analyse if there is a non-standard character in the string
for(;;) {
- const unsigned int iSrc =
- (const unsigned int) * (const unsigned char *) ptrSrc;
+ const unsigned int iSrc = (unsigned int ) *(const unsigned char* )ptrSrc;
if (iSrc == 0) {
endSrc = ptrSrc;
break;
char * ptrDest = new char [(endSrc - theSrc) + aCount * 5 + 1];
aDest = ptrDest;
for (ptrSrc = theSrc; ptrSrc < endSrc; ptrSrc++) {
- const unsigned int iSrc =
- (const unsigned int) * (const unsigned char *) ptrSrc;
+ const unsigned int iSrc = (unsigned int ) *(const unsigned char* )ptrSrc;
const int aCode = myTab[iSrc];
if (aCode == NORMAL_C) // normal (regular) character
* ptrDest++ = * ptrSrc;
unsigned int aCRC = 0;
const unsigned char * aPtr = (const unsigned char *) aString;
for (Standard_Integer i = aLen; i > 0; i--) {
- const unsigned int bTmp = aCRC ^ (const unsigned int) (* aPtr++);
+ const unsigned int bTmp = aCRC ^ (unsigned int) (* aPtr++);
aCRC = ((aCRC >> 8) ^ wCRC16a[bTmp & 0x0F]) ^ wCRC16b[(bTmp >> 4) & 0x0F];
}
return Standard_Integer (aCRC & HASH_MASK /* myMask */);
} // otherwise ERROR
} // end of switch
myError = "Unknown XML object: ";
- myError += TCollection_AsciiString ((const Standard_CString)myPtr,
- XML_MIN_BUFFER);
+ myError += TCollection_AsciiString (myPtr, XML_MIN_BUFFER);
return XML_UNKNOWN;
case '\0':
if (myEOF == Standard_True) continue;
if(!AddClosedWire(W,F))
return Standard_False;
}
- } catch (Standard_Failure ) {
+ } catch (Standard_Failure const&) {
#ifdef OCCT_DEBUG
cout << "Warning: SpliShape internal problem detected, some faces may be lost. Check input edges/wires" <<endl;
#endif
theFormat = td.Types()->Value(1);
}
}
- catch (Standard_Failure) {}
+ catch (Standard_Failure const&) {}
if(theFileIsOpen)theFileDriver->Close();
for ( i =1; i<= refUserInfo.Length() ; i++) {
if(refUserInfo(i).Search(REFERENCE_COUNTER) != -1) {
try { OCC_CATCH_SIGNALS theReferencesCounter=refUserInfo(i).Token(" ",2).IntegerValue();}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// cout << "warning: could not read the reference counter in " << aFileName << endl;
TCollection_ExtendedString aMsg("Warning: ");
aMsg = aMsg.Cat("could not read the reference counter in ").Cat(aFileName).Cat("\0");
}
}
- catch (Standard_Failure) {}
+ catch (Standard_Failure const&) {}
if(theFileIsOpen) theFileDriver->Close();
for ( i =1; i<= refUserInfo.Length() ; i++) {
if(refUserInfo(i).Search(MODIFICATION_COUNTER) != -1) {
try { OCC_CATCH_SIGNALS theVersion=refUserInfo(i).Token(" ",2).IntegerValue();}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// cout << "warning: could not read the version in " << aFileName << endl;
TCollection_ExtendedString aMsg("Warning: ");
aMsg = aMsg.Cat("could not read the version in ").Cat(aFileName).Cat("\0");
}
}
- catch (Standard_Failure) {}
+ catch (Standard_Failure const&) {}
if(theFileIsOpen) theFileDriver->Close();
delete theFileDriver;
if(aRevolSurf->IsUPeriodic()) {di << "Surface is u-periodic \n";} else {di << "Surface is not u-periodic \n";}
if(aRevolSurf->IsVPeriodic()) {di << "Surface is v-periodic \n";} else {di << "Surface is not v-periodic \n";}
}
- catch (Standard_Failure) {di << "isperiodic Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "isperiodic Exception \n" ;return 0;}
return 0;
}
}
else return 1;
}
- catch (Standard_Failure) {di << "OCC486 Exception \n" ;return 1;}
+ catch (Standard_Failure const&) {di << "OCC486 Exception \n" ;return 1;}
}
#include <GC_MakeArcOfCircle.hxx>
DBRep::Set(argv[1], slabShape);
}
}
- catch ( Standard_Failure ) //--------------------> STEP:2
+ catch ( Standard_Failure const& ) //--------------------> STEP:2
{
di << " Error in Draft Slab \n";
return 1;
performTriangulation(theRes, di);
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
di << "*********************************************************\n";
di << "***** ******\n";
performTriangulation(fuse, di);
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
di << "*********************************************************\n";
di << "***** ******\n";
performTriangulation(fuse, di);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "*********************************************************\n";
di << "***** ******\n";
performTriangulation(fuse, di);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "*********************************************************\n";
di << "***** ******\n";
di << "Trianglating Faces of CUT 2 .....\n";
performTriangulation(cut2, di);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "*********************************************************\n";
di << "***** ******\n";
di << "Fuse Created ! Triangulating !\n";
performTriangulation(fuse, di);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "*********************************************************\n";
di << "***** ******\n";
performTriangulation(fuse2, di);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "*********************************************************\n";
di << "***** ******\n";
status = 1;
}
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
status = 1;
}
// cout << "Blending Successfully Done ! Now Triangulating ..." << endl;
// performTriangulation(aShape);
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
di << " Error in Draft Slab \n";
return 1;
if ( ! seq.Value(i).FindAttribute ( TPrsStd_AISPresentation::GetID(), prs ) )
prs = TPrsStd_AISPresentation::Set(seq.Value(i),XCAFPrs_Driver::GetID());
}
- catch(Standard_Failure) { di << "FAULTY OCC363 : Exception during reading document.\n";return 0;}
+ catch(Standard_Failure const&) { di << "FAULTY OCC363 : Exception during reading document.\n";return 0;}
di << "OCC363 OK\n";
return 0;
else {di << "OCC377 FAULTY\n"; return 0;}
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
di << "OCC377 Exception";
}
// 4.3. Create result Draw shape
DBRep::Set(argv[1], aResultShape);
}
- catch (Standard_Failure) {di << "OCC22 Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "OCC22 Exception \n" ;return 0;}
return 0;
}
DBRep::Set(argv[1], aResultShape);
}
- catch (Standard_Failure) {di << "OCC24 Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "OCC24 Exception \n" ;return 0;}
return 0;
}
BRepMesh_IncrementalMesh aMesh(aShape, aMeshParams);
}
- catch (Standard_Failure) {di << "OCC369 Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "OCC369 Exception \n" ;return 0;}
di << "OCC369 OK \n";
return 0;
Succes = Standard_False;
}
#if defined(SOLARIS) || defined(_WIN32)
- catch(Standard_DivideByZero)
+ catch(Standard_DivideByZero const&)
#else
- catch(Standard_NumericError)
+ catch(Standard_NumericError const&)
#endif
{
di << "Caught, OK\n";
di << "Error: 4.0 / 0.0 = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
- catch(Standard_DivideByZero) // Solaris, Windows w/o SSE2
+ catch(Standard_DivideByZero const&) // Solaris, Windows w/o SSE2
{
di << "Caught, OK\n";
}
- catch(Standard_NumericError) // Linux, Windows with SSE2
+ catch(Standard_NumericError const&) // Linux, Windows with SSE2
{
di << "Caught, OK\n";
}
//++++ Succes = Standard_False;
di << "Not caught: " << i << " + 1 = " << res << ", still OK\n";
}
- catch(Standard_Overflow) {
+ catch(Standard_Overflow const&) {
di << "Caught, OK\n";
}
catch(Standard_Failure const& anException) {
di << "Error: " << r << "*" << r << " = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
- catch(Standard_Overflow) // Solaris, Windows w/o SSE2
+ catch(Standard_Overflow const&) // Solaris, Windows w/o SSE2
{
di << "Caught, OK\n";
}
- catch(Standard_NumericError) // Linux, Windows with SSE2
+ catch(Standard_NumericError const&) // Linux, Windows with SSE2
{
di << "Caught, OK\n";
}
//++++ Succes = Standard_False;
di << "Not caught: " << r << "*" << r << " = " << res << ", still OK\n";
}
- catch(Standard_Underflow) // could be on Solaris, Windows w/o SSE2
+ catch(Standard_Underflow const&) // could be on Solaris, Windows w/o SSE2
{
di << "Exception caught, KO\n";
Succes = Standard_False;
}
- catch(Standard_NumericError) // could be on Linux, Windows with SSE2
+ catch(Standard_NumericError const&) // could be on Linux, Windows with SSE2
{
di << "Exception caught, KO\n";
Succes = Standard_False;
di << "Error: swrt(-1) = " << res << " - no exception is raised!\n";
Succes = Standard_False;
}
- catch(Standard_NumericError) {
+ catch(Standard_NumericError const&) {
di << "Caught, OK\n";
}
catch(Standard_Failure const& anException) {
Succes = Standard_False;
}
#ifdef _WIN32
- catch(OSD_Exception_ACCESS_VIOLATION)
+ catch(OSD_Exception_ACCESS_VIOLATION const&)
#else
- catch(OSD_SIGSEGV)
+ catch(OSD_SIGSEGV const&)
#endif
{
di << "Caught, OK\n";
di << "Error - no exception is raised!\n";
Succes = Standard_False;
}
- catch(OSD_Exception_STACK_OVERFLOW) {
+ catch(OSD_Exception_STACK_OVERFLOW const&) {
di << "Caught, OK\n";
}
catch(Standard_Failure const& anException) {
writer.Write(aFilePath.ToCString());
}
}
- catch(OSD_Exception_STACK_OVERFLOW) {
+ catch(OSD_Exception_STACK_OVERFLOW const&) {
di << "Failed : STACK OVERFLOW\n\n";
}
catch (Standard_Failure const& anException) {
gp_Pnt2d anOrigin = aLin2d.Location();
di << "X_0 = " << anOrigin.X() << " Y_0 = " << anOrigin.Y() << "\n" ;
}
- catch(Standard_ConstructionError)
+ catch(Standard_ConstructionError const&)
{
di << argv[0] << " Exception: Sqrt(A*A + B*B) <= Resolution from gp\n";
}
OCC_CATCH_SIGNALS
di << " yes\n";
}
- catch (Standard_TypeMismatch) {
+ catch (Standard_TypeMismatch const&) {
di << " no\n";
}
B.Add(wallSolid,TubeShell);
di << " yes\n";
}
- catch (Standard_TypeMismatch) {
+ catch (Standard_TypeMismatch const&) {
di << "Can't convert to shell...\n";
TopExp_Explorer getSol;
getSol.Init(SewIt.SewedShape(), TopAbs_SOLID);
OCC_CATCH_SIGNALS
OSD_Path Path (argv[1], SysType1);
}
- catch (Standard_ProgramError) {
+ catch (Standard_ProgramError const&) {
di << "1\n";
return 0;
}
OCC_CATCH_SIGNALS
OSD_Path Path (argv[1], SysType2);
}
- catch (Standard_ProgramError) {
+ catch (Standard_ProgramError const&) {
di << "2\n";
return 0;
}
DBRep::Set(argv[1],aFinalShape);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
di << argv[0] << ": Exception in fillet\n";
return 2;
DBRep::Set(a[1],bsp_face1);
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
di<<"ERROR: Exception in GeomFill_NSections\n";
}
aList.Append(MyStubObject(Standard::Allocate(aLargeBlockSize)));
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "caught out of memory for large blocks: OK\n";
}
aList.Append(MyStubObject(Standard::Allocate(aSmallBlockSize)));
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
di << "caught out of memory for small blocks: OK\n";
}
#ifdef _WIN32
#define EXCEPTION ...
#else
-#define EXCEPTION Standard_Failure
+#define EXCEPTION Standard_Failure const&
#endif
static ShapeExtend_Status getStatusGap(const Handle(ShapeFix_Wire)& theFix,
{
DBRep::Set(a[1], gtrf.ModifiedShape(aSrcShape));
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
di << "Error: Exception is thrown\n";
}
}
}
}
- catch (Standard_Failure) {di << "OCC527 Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "OCC527 Exception \n" ;return 0;}
return 0;
}
for (;;)
aList.Append(Standard::Allocate(aBlockSizes[i]));
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
aStatus |= OUMCatchOK;
}
Geom2dAdaptor_Curve(normalLine),1e-9,g1,g1,g3);
aDuumyList.Append(aCircleBuilder.NbSolutions());
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
theDI << "Exception was caught\n";
}
DBRep::Set(theArgVal[2], bsp_face1);
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
theDI << "ERROR: Exception in GeomFill_NSections\n";
}
di << "par_edge = " << par_edge << "\n";
}
- catch (Standard_Failure) {di << "OCC5696 Exception \n" ;return 0;}
+ catch (Standard_Failure const&) {di << "OCC5696 Exception \n" ;return 0;}
return 0;
}
OCC_CATCH_SIGNALS
Dir.Build(OSD_Protection(OSD_RX, OSD_RWXD, OSD_RX, OSD_RX));
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
aStatus = Standard_False;
}
}
OCC_CATCH_SIGNALS
File.Build(OSD_ReadWrite, theProt);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
aStatus = Standard_False;
}
}
}
// add extern ref
- const Standard_CString format = (const Standard_CString) ( schema == 3 ? "STEP AP203" : "STEP AP214" );
+ const char* format = (schema == 3 ? "STEP AP203" : "STEP AP214");
// try to get PD from SDR
StepRepr_RepresentedDefinition RD = SDR->Definition();
Handle(StepRepr_PropertyDefinition) aPropDef = RD.PropertyDefinition();
found = Standard_True;
}
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
TP->AddFail(start,"Exeption is raised. Entity was not translated.");
TP->Bind(start, shbinder);
return shbinder;
TP->Bind(fs, sb);
return sb; // TP->Find (start);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
TP->AddFail(fs,"Exeption is raised. Entity was not translated.");
sb.Nullify();
angle1 = V11.Angle(V12);
angle2 = V21.Angle(V22);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
#ifdef OCCT_DEBUG
cout << "Couldn't compute angle between derivative vectors" <<endl;
AppendControlPoles(seq,bslp);
done = Standard_True;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
}
}
else if ( aBaseCrv->IsKind(STANDARD_TYPE(Geom_BezierCurve))) {
AppendControlPoles(seq,bz);
done = Standard_True;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
}
}
if (!done) {
OCC_CATCH_SIGNALS
result = MD.ModifiedShape( current );
}
- catch (Standard_NoSuchObject)
+ catch (Standard_NoSuchObject const&)
{
// the sub shape isn't in the map
result.Nullify();
aMult-1,
theTolerance);
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
}
}
Standard_Boolean sewing_ok = Standard_True;
{
try { OCC_CATCH_SIGNALS theSewer.Perform(); }
- catch(Standard_Failure) { sewing_ok = Standard_False; }
+ catch(Standard_Failure const&) { sewing_ok = Standard_False; }
}
if ( sewing_ok )
if (theSewer.SewedShape().IsNull()) sewing_ok = Standard_False;
if ( ! TryNewPCurve ( E, face, c2d, first, last, tol ) ) return Standard_False;
}
- catch ( Standard_Failure ) {
+ catch ( Standard_Failure const& ) {
#ifdef OCCT_DEBUG
cout << "Warning: ShapeFix_Wire::FixLacking: Exception in Geom2d_BSplineCurve::Segment()" << endl;
#endif
done1 = done2 = Standard_True;
}
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
}
}
OCC_CATCH_SIGNALS
corrected = MyBSpline->RemoveKnot(iknot, newMultiplicity, myTolerance);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
corrected = Standard_False;
}
}
OCC_CATCH_SIGNALS
corrected = MyBSpline->RemoveKnot(iknot, newMultiplicity, myTolerance);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
corrected = Standard_False;
}
}
return anIIInt.TangentFaces();
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
return Standard_False;
}
}
aFileDriver->ReadReferenceType (aRef, aType);
anError = Storage_VSOk;
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
anError = Storage_VSTypeMismatch;
}
aReadData.ReadPersistentObject (i);
anError = Storage_VSOk;
}
- catch (Storage_StreamTypeMismatchError) { anError = Storage_VSTypeMismatch; }
- catch (Storage_StreamFormatError ) { anError = Storage_VSFormatError; }
- catch (Storage_StreamReadError ) { anError = Storage_VSFormatError; }
+ catch (Storage_StreamTypeMismatchError const&) { anError = Storage_VSTypeMismatch; }
+ catch (Storage_StreamFormatError const& ) { anError = Storage_VSFormatError; }
+ catch (Storage_StreamReadError const& ) { anError = Storage_VSFormatError; }
raiseOnStorageError (anError);
}
}
}
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
// ...
}
try {
OCC_CATCH_SIGNALS
cu3d.Initialize (anEdge);
- } catch (Standard_NullObject) {
+ } catch (Standard_NullObject const&) {
return;
}
OCC_CATCH_SIGNALS
cu3d.Initialize (aWireExplorer.Current());
}
- catch (Standard_NullObject)
+ catch (Standard_NullObject const&)
{
continue;
}
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*aDriver, theFileName, Storage_VSRead);
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
return Storage_VSOpenError;
}
theDriver.ReadReferenceType(aRef, aType);
anError = Storage_VSOk;
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
anError = Storage_VSTypeMismatch;
}
aReadData.ReadPersistentObject(i);
anError = Storage_VSOk;
}
- catch (Storage_StreamTypeMismatchError) { anError = Storage_VSTypeMismatch; }
- catch (Storage_StreamFormatError) { anError = Storage_VSFormatError; }
- catch (Storage_StreamReadError) { anError = Storage_VSFormatError; }
+ catch (Storage_StreamTypeMismatchError const&) { anError = Storage_VSTypeMismatch; }
+ catch (Storage_StreamFormatError const&) { anError = Storage_VSFormatError; }
+ catch (Storage_StreamReadError const&) { anError = Storage_VSFormatError; }
if (anError != Storage_VSOk)
return anError;
if (anError != Storage_VSOk)
return anError;
}
- catch (Storage_StreamWriteError) {
+ catch (Storage_StreamWriteError const&) {
return Storage_VSWriteError;
}
myDataType,
myUserInfo);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadInfo";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadInfo";
OCC_CATCH_SIGNALS
theDriver.ReadComment(myComments);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadComment";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadComment";
myDataType,
myUserInfo);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "WriteInfo";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "WriteInfo";
OCC_CATCH_SIGNALS
theDriver.WriteComment(myComments);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "WriteComment";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "WriteComment";
OCC_CATCH_SIGNALS
theDriver.ReadRoot(aRootName, aRef, aTypeName);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadRoot";
OCC_CATCH_SIGNALS
theDriver.WriteRoot(aRoot->Name(), aRoot->Reference(), aRoot->Type());
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadRoot";
OCC_CATCH_SIGNALS
theDriver.ReadTypeInformations (aTypeNum, aTypeName);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadTypeInformations";
OCC_CATCH_SIGNALS
theDriver.WriteTypeInformations(i, Type(i));
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "WriteTypeInformations";
}
}
- catch(Standard_Failure)
+ catch(Standard_Failure const&)
{
return C2d;
}
myDataType,
myUserInfo);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadInfo";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadInfo";
OCC_CATCH_SIGNALS
theDriver.ReadComment (myComments);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadComment";
return Standard_False;
}
- catch (Storage_StreamExtCharParityError)
+ catch (Storage_StreamExtCharParityError const&)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadComment";
OCC_CATCH_SIGNALS
theDriver.ReadRoot (aRootName, aRef, aTypeName);
}
- catch (Storage_StreamTypeMismatchError)
+ catch (Storage_StreamTypeMismatchError const&)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadRoot";
errorContext = "EndWriteDataSection";
f.EndWriteDataSection();
}
- catch(Storage_StreamWriteError) {
+ catch(Storage_StreamWriteError const&) {
aData->SetErrorStatus(Storage_VSWriteError);
aData->SetErrorStatusExtension(errorContext);
}
}
if (pFoundNode) {
unsigned int aFullMask (0xffffffff);
- aResult = TColStd_intMapNode_findNext ((const Standard_Address )pFoundNode, aFullMask);
+ aResult = TColStd_intMapNode_findNext ((Standard_Address )pFoundNode, aFullMask);
}
}
return aResult;
}
if (pFoundNode) {
unsigned int aFullMask (0xffffffff);
- aResult = TColStd_intMapNode_findPrev ((const Standard_Address )pFoundNode, aFullMask);
+ aResult = TColStd_intMapNode_findPrev ((Standard_Address )pFoundNode, aFullMask);
}
}
return aResult;
OCC_CATCH_SIGNALS
S->LoadDriver();
}
- catch (Plugin_Failure)
+ catch (Plugin_Failure const&)
{
myIsDriverLoaded = Standard_False;
}
break;
}
}
-} catch (Standard_Failure) {
+} catch (Standard_Failure const&) {
#ifdef OCCT_DEBUG
cout << "Name::Solve: EXCEPTION==> NameType = " << NameTypeToString(myType) << " ";
PrintEntry(aLab);
{
isValid = isValid && aLabel.Data() == aDoc->GetData();
}
- catch (Standard_Failure)
+ catch (Standard_Failure const&)
{
isValid = Standard_False;
}
}
}
}
- catch(Standard_Failure) {
+ catch(Standard_Failure const&) {
ais.Nullify();
}
}
OCC_CATCH_SIGNALS
CA.Initialize (anEdge);
}
- catch (Standard_NullObject) {
+ catch (Standard_NullObject const&) {
return Standard_False;
}
}
// ... Exceptions a Rattraper : elles ne se ressemblent pas toutes ... !
- catch (Transfer_TransferDeadLoop) {
+ catch (Transfer_TransferDeadLoop const&) {
if (binder.IsNull()) {
themessenger << " *** Dead Loop with no Result" << endl;
if (thetrace) StartTrace (binder, start, thelevel-1,0);
OCC_CATCH_SIGNALS
theLayerId = myZLayerGenId.Next();
}
- catch (Aspect_IdentDefinitionError)
+ catch (Aspect_IdentDefinitionError const&)
{
// new index can't be generated
return Standard_False;
{
theGeomCircle = Cir.Value();
}
- catch (StdFail_NotDone)
+ catch (StdFail_NotDone const&)
{
std::cout << "vcircle error: can't create circle\n";
return -1; // TCL_ERROR
{
theGeomCircle = Cir.Value();
}
- catch (StdFail_NotDone)
+ catch (StdFail_NotDone const&)
{
std::cout << "vcircle error: can't create circle\n";
return -1; // TCL_ERROR
{
theGeomCircle = Cir.Value();
}
- catch (StdFail_NotDone)
+ catch (StdFail_NotDone const&)
{
std::cout << "vcircle error: can't create circle\n";
return -1; // TCL_ERROR
{
theGeomCircle = Cir.Value();
}
- catch (StdFail_NotDone)
+ catch (StdFail_NotDone const&)
{
std::cout << "vcircle error: can't create circle\n";
return -1; // TCL_ERROR
mySize.X(), mySize.Y(), mySize.Z());
SetTShape (aShell.TShape());
myIsModified = Standard_False;
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
myTShape.Nullify();
}
}
else
myTShape = aBuilder.Shell().TShape();
myIsModified = Standard_False;
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
myTShape.Nullify();
}
}
aShapeBuilder.AddShellFace (aShell, aBuilder.BottomFace());
myTShape = aShell.TShape();
myIsModified = Standard_False;
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
myTShape.Nullify();
}
}
try {
myTShape = BRepPrim_Sphere(myRadius).Shell().TShape();
myIsModified = Standard_False;
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
myTShape.Nullify();
}
}
N=v1^v2;
Plane123=gp_Pln( Som1, gp_Dir( N ) );
}
- catch(Standard_Failure) {return(0.);}
+ catch(Standard_Failure const&) {return(0.);}
}
double L1, L2, L3;
L1 = Som1.Distance(Som2);
( wholeDoc ? "" : "\n" ));
di << string2;
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
//printf ( "%-16.16s", "exception" );
char string3[260];
Sprintf (string3, "%-16.16s", "exception" );
try {
OCC_CATCH_SIGNALS
aScaleValue = (aCoords.Value(1) - (Standard_Real) aMinX) / aDelta;
- } catch(Standard_Failure) {
+ } catch(Standard_Failure const&) {
aScaleValue = 0;
}
}
}
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
di << "Error\n";
}
aDrawer->SetDouble( MeshVS_DA_EdgeWidth, aWidth );
anIC->Redisplay (aMesh, Standard_True);
}
- catch ( Standard_Failure )
+ catch ( Standard_Failure const& )
{
di << "Error\n";
}
Standard_Integer aRefCounter = anInf.Token(" ",2).IntegerValue();
theNewDocument->SetReferenceCounter(aRefCounter);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
// cout << "warning: could not read the reference counter in " << aFileName << endl;
TCollection_ExtendedString aMsg("Warning: ");
aMsg = aMsg.Cat("could not read the reference counter").Cat("\0");
Standard_Integer aModCounter = anInf.Token(" ",2).IntegerValue();
theNewDocument->SetModifications (aModCounter);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure const&) {
TCollection_ExtendedString aMsg("Warning: could not read the modification counter\0");
if(!aMsgDriver.IsNull())
aMsgDriver->Send(aMsg.ToExtString(), Message_Warning);
#ifdef _WIN32
#define EXCEPTION ...
#else
-#define EXCEPTION Standard_Failure
+#define EXCEPTION Standard_Failure const&
#endif
//=======================================================================
//function : XmlMDataStd_NamedDataDriver
OCC_CATCH_SIGNALS
str.Allocate(25 * realArray.Length() + 1);
}
- catch (Standard_OutOfMemory)
+ catch (Standard_OutOfMemory const&)
{
// If allocation of big space for the string of double array values failed,
// try to calculate the necessary space more accurate and allocate it.
}
myIsDone = Standard_True;
}
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
}
}
}
myIsDone = Standard_True;
}
- } catch (Standard_Failure) {
+ } catch (Standard_Failure const&) {
}
}
projects / occt.git / commitdiff