0024599: Tools for interacting with DRAW from Visual Studio debugger
authorabv <abv@opencascade.com>
Thu, 27 Feb 2014 14:22:52 +0000 (18:22 +0400)
committerapn <apn@opencascade.com>
Thu, 27 Feb 2014 14:25:18 +0000 (18:25 +0400)
Global functions are added to allow a user performing DRAW commands from VS Command Window when DRAW is interrupted on a breakpoint.
Previously existing functions are adapted to work with Visual Studio debugger (Command Window).
A manual describing use of these functions and other debugging facilities and some hints is added to Developer Guides.
Minor corrections and refinement of debug.md.

12 files changed:
dox/FILES.txt
dox/dev_guides/debug/debug.md [new file with mode: 0644]
dox/dev_guides/dev_guides.md
src/BRepTools/BRepTools.cxx
src/BRepTools/BRepTools_Debug.cxx [new file with mode: 0644]
src/BRepTools/FILES [new file with mode: 0644]
src/DBRep/DBRep_Debug.cxx
src/Draw/Draw_Debug.cxx [new file with mode: 0644]
src/Draw/FILES
src/DrawTrSurf/DrawTrSurf_Debug.cxx
src/GeomTools/FILES [new file with mode: 0644]
src/GeomTools/GeomTools_Debug.cxx [new file with mode: 0644]

index 9dead2a..df2ba2b 100644 (file)
@@ -38,6 +38,7 @@ dev_guides/contribution/coding_rules.md
 dev_guides/contribution_workflow/contribution_workflow.md
 dev_guides/git_guide/git_guide.md
 dev_guides/tests/tests.md
+dev_guides/debug/debug.md
 dev_guides/cdl/cdl.md
 dev_guides/wok/wok.md
 
diff --git a/dox/dev_guides/debug/debug.md b/dox/dev_guides/debug/debug.md
new file mode 100644 (file)
index 0000000..c618d3b
--- /dev/null
@@ -0,0 +1,244 @@
+Debugging tools and hints {#dev_guides__debug}
+=========================
+
+@tableofcontents
+
+@section occt_debug_intro Introduction
+
+This manual describes facilities included in OCCT to support debugging, and provides some hints for more efficient debug.
+
+@section occt_debug_bop Self-diagnostics in Boolean operations algorithm
+
+In real-world applications modeling operations are often performed in a long sequence, while the user sees only the final result of the whole sequence. If the final result is wrong, the first debug step is to identify the offending operation to be debugged further. Boolean operation algorithm in OCCT provides a self-diagnostic feature which can help to do that step.
+
+This feature can be activated by defining environment variable *CSF_DEBUG_BOP*, which should specify an existing writeable directory.
+
+The diagnostic code checks validity of the input arguments and the result of each Boolean operation. When an invalid situation is detected, the report consisting of argument shapes and a DRAW script to reproduce the problematic operation is saved to the directory pointed by *CSF_DEBUG_BOP*.
+
+@section occt_debug_exceptions Calling JIT debugger on exception
+
+On Windows platform when using Visual Studio compiler there is a possibility to start the debugger automatically if an exception is caught in a program running OCCT. For this, set environment variable *CSF_DEBUG* to any value. Note that this feature works only if you enable OCCT exception handler in your application by calling *OSD::SetSignal()*.
+
+@section occt_debug_call Functions for calling from debugger
+
+Modern interactive debuggers provide the possibility to execute application code at a program break point. This feature can be used to analyse the temporary objects available only in the context of the debugged code. OCCT provides several global functions that can be used in this way.
+
+Note that all these functions accept pointer to variable as <i>void*</i> to allow calling the function even when debugger does not recognize type equivalence or can not perform necessary type cast automatically. It is responsibility of the developer to provide the correct pointer. In general these functions are not guaranteed to work, thus use them with caution and at your own risk.
+
+@subsection occt_debug_call_draw Interacting with DRAW
+
+Open CASCADE Test Harness or @ref user_guides__test_harness "DRAW" provides an extensive set of tools for inspection and analysis of OCCT shapes and geometric objects and is mostly used as environment for prototyping and debugging OCCT-based algorithms.
+
+In some cases the objects to be inspected are available in DRAW as results of DRAW commands. In other cases, however, it is necessary to inspect intermediate objects created by the debugged algorithm. To support this, DRAW provides a set of commands allowing the developer to store intermediate objects directly from the debugger stopped at some point during the program execution (usually at a breakpoint).
+
+~~~~~
+const char* Draw_Eval (const char *theCommandStr)
+~~~~~
+
+Evaluates a DRAW command or script.
+A command is passed as a string parameter.
+
+~~~~~
+const char* DBRep_Set (const char* theNameStr, void* theShapePtr)
+~~~~~
+
+Sets the specified shape as a value of DRAW interpreter variable with the given name.
+- *theNameStr* – the DRAW interpreter variable name to set.
+- *theShapePtr* – a pointer to *TopoDS_Shape* variable.
+
+~~~~~
+const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
+const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
+const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
+~~~~~
+
+Sets the specified geometric object as a value of DRAW interpreter variable with the given name.
+- *theNameStr* – the DRAW interpreter variable name to set.
+- *theHandlePtr* – a pointer to the geometric variable (Handle to *Geom_Geometry* or *Geom2d_Curve* or descendant) to be set.
+- *thePntPtr* – a pointer to the variable of type *gp_Pnt* to be set.
+- *thePnt2dPtr* – a pointer to the variable of type *gp_Pnt2d* to be set.
+
+All these functions are defined in *TKDraw* toolkit and return a string indicating the result of execution.
+
+@subsection occt_debug_call_brep Saving and dumping shapes and geometric objects
+
+The following functions are provided by *TKBRep* toolkit and can be used from debugger prompt:
+
+~~~~~
+const char* BRepTools_Write (const char* theFileNameStr, void* theShapePtr)
+~~~~~
+
+Saves the specified shape to a file with the given name.
+- *theFileNameStr* – the DRAW interpreter variable name to set.
+- *theShapePtr* – a pointer to *TopoDS_Shape* variable.
+
+~~~~~
+const char* BRepTools_Dump (void* theShapePtr)
+const char* BRepTools_DumpLoc (void* theShapePtr)
+~~~~~
+
+Dumps shape or its location to cout.
+- *theShapePtr* – a pointer to *TopoDS_Shape* variable.
+
+The following additional function is provided by *TKGeomBase* toolkit:
+
+~~~~~
+const char* GeomTools_Dump (void* theHandlePtr)
+~~~~~
+
+Dump geometric object to cout.
+- *theHandlePtr* – a pointer to the geometric variable (<i>Handle</i> to *Geom_Geometry* or *Geom2d_Curve* or descendant) to be set.
+
+@section occt_debug_vstudio Using Visual Studio debugger 
+
+@subsection occt_debug_vstudio_command Command window 
+
+Visual Studio debugger provides the Command Window (can be activated from menu <b>View / Other Windows / Command Window</b>), which can be used to evaluate variables and expressions interactively in a debug session (see http://msdn.microsoft.com/en-us/library/c785s0kz.aspx). Note that the Immediate Window can also be used but it has some limitations, e.g. does not support aliases.
+
+When the execution is interrupted by a breakpoint, you can use this window to call the above described functions in context of the currently debugged function. Note that in most cases you will need to specify explicitly context of the function by indicating the name of the DLL where it is defined.
+
+For example, assume that you are debugging a function, where local variable *TopoDS_Edge* *anEdge1* is of interest.
+The following set of commands in the Command window will save this edge to file *edge1.brep*, then put it to DRAW variable *e1* and show it maximized in the axonometric DRAW view:
+
+~~~~~
+>? ({,,TKBRep.dll}BRepTools_Write)("d:/edge1.brep",(void*)&anEdge1)
+0x04a2f234 "d:/edge1.brep"
+>? ({,,TKDraw.dll}DBRep_Set)("e1",(void*)&anEdge1)
+0x0369eba8 "e1"
+>? ({,,TKDraw.dll}Draw_Eval)("donly e1; axo; fit")
+0x029a48f0 ""
+~~~~~
+
+For convenience it is possible to define aliases to commands in this window, for instance (here ">" is prompt provided by the command window; in the Immediate window this symbol should be entered manually):
+
+~~~~~
+>alias deval      ? ({,,TKDraw}Draw_Eval)
+>alias dsetshape  ? ({,,TKDraw}DBRep_Set)
+>alias dsetgeom   ? ({,,TKDraw}DrawTrSurf_SetPnt)
+>alias dsetpnt2d  ? ({,,TKDraw}DrawTrSurf_SetPnt2d)
+>alias saveshape  ? ({,,TKBRep}BRepTools_Write)
+>alias dumpshape  ? ({,,TKBRep}BRepTools_Dump)
+>alias dumploc    ? ({,,TKBRep}BRepTools_DumpLoc)
+>alias dumpgeom   ? ({,,TKGeomBase}GeomTools_Dump)
+~~~~~ 
+
+Note that aliases are stored in the Visual Studio user's preferences and it is sufficient to define them once on a workstation. With these aliases, the above example can be reproduced easier (note the space symbol after alias name!):
+
+~~~~~
+>saveshape ("d:/edge1.brep",(void*)&anEdge1)
+0x04a2f234 "d:/edge1.brep"
+>dsetshape ("e1",(void*)&anEdge1)
+0x0369eba8 "e1"
+>deval ("donly e1; axo; fit")
+0x029a48f0 ""
+~~~~~
+
+Note that there is no guarantee that the call will succeed and will not affect the program execution, thus use this feature at your own risk. In particular, the commands interacting with window system (such as *axo*, *vinit*, etc.) are known to cause application crash when the program is built in 64-bit mode. To avoid this, it is recommended to prepare all necessary view windows in advance, and arrange these windows to avoid overlapping with the Visual Studio window, to ensure that they are visible during debug. 
+
+@subsection occt_debug_vstudio_watch Customized display of variables content
+
+Visual Studio provides a way to customize display of variables of different types in debugger windows (Watch, Autos, Locals, etc.).
+
+In Visual Studio 2005-2010 the rules for this display are defined in file *autoexp.dat* located in  subfolder *Common7\\Packages\\Debugger* of the Visual Studio installation folder (hint: the path to that folder is given in the corresponding environment variable, e.g. *VS100COMNTOOLS* for vc10). This file contains two sections: *AutoExpand* and *Visualizer*. The following rules can be added to these sections to provide more convenient display of some OCCT data types. 
+
+### \[AutoExpand\] section 
+
+~~~~~
+; Open CASCADE classes
+Standard_Transient=<,t> count=<count,d>
+Handle_Standard_Transient=<entity,x> count=<entity->count,d> <,t>
+TCollection_AsciiString=<mylength,d> <mystring,s>
+TCollection_HAsciiString=<myString.mylength,d> <myString.mystring,s>
+TCollection_ExtendedString=<mylength,d> <mystring,su>
+TCollection_HExtendedString=<myString.mylength,d> <myString.mystring,su>
+TCollection_BaseSequence=size=<Size,d> curr=<CurrentIndex,d>
+TCollection_BasicMap=size=<mySize,d>
+NCollection_BaseSequence=size=<mySize,d> curr=<myCurrentIndex,d>
+NCollection_BaseList=length=<myLength,d>
+NCollection_BaseMap=size=<mySize,d> buckets=<myNbBuckets>
+NCollection_BaseVector=length=<myLength,d>
+TDF_Label=<myLabelNode,x> tag=<myLabelNode->myTag>
+TDF_LabelNode=tag=<myTag,d>
+TDocStd_Document=format=<myStorageFormat.mystring,su> count=<count,d> <,t>
+TopoDS_Shape=<myTShape.entity,x> <myOrient>
+gp_XYZ=<x,g>, <y,g>, <z,g>
+gp_Pnt=<coord.x,g>, <coord.y,g>, <coord.z,g>
+gp_Vec=<coord.x,g>, <coord.y,g>, <coord.z,g>
+gp_Dir=<coord.x,g>, <coord.y,g>, <coord.z,g>
+gp_XY=<x,g>, <y,g>
+gp_Pnt2d=<coord.x,g>, <coord.y,g>
+gp_Dir2d=<coord.x,g>, <coord.y,g>
+gp_Vec2d=<coord.x,g>, <coord.y,g>
+gp_Mat2d={<matrix[0][0],g>,<matrix[0][1],g>}, {<matrix[1][0],g>,<matrix[1][1],g>}
+gp_Ax1=loc={<loc.coord.x,g>, <loc.coord.y,g>, <loc.coord.z,g>} vdir={<vdir.coord.x,g>, <vdir.coord.y,g>, <vdir.coord.z,g>}
+~~~~~ 
+
+### \[Visualizer\] section
+
+~~~~~
+; Open CASCADE classes
+
+NCollection_Handle<*> {
+  preview ( *((($T0::Ptr*)$e.entity)->myPtr) )
+  children ( (($T0::Ptr*)$e.entity)->myPtr )
+}
+
+NCollection_List<*> {
+  preview ( #( "NCollection_List [", $e.myLength, "]" )        )
+  children ( #list( head: $c.myFirst, next: myNext ) : #(*($T1*)(&$e+1)) )
+}
+
+NCollection_Array1<*> {
+  preview ( #( "NCollection_Array1 [", $e.myLowerBound, "..", $e.myUpperBound, "]" ) )
+  children ( #array( expr: $c.myData[$i], size: 1+$c.myUpperBound ) )
+}
+
+math_Vector {
+  preview ( #( "math_Vector [", $e.LowerIndex, "..", $e.UpperIndex, "]" ) )
+  children ( #array ( expr: ((double*)($c.Array.Addr))[$i], size: 1+$c.UpperIndex ) )
+}
+
+TColStd_Array1OfReal {
+  preview ( #( "Array1OfReal [", $e.myLowerBound, "..", $e.myUpperBound, "]" ) )
+  children ( #array ( expr: ((double*)($c.myStart))[$i], size: 1+$c.myUpperBound ) )
+}
+
+Handle_TColStd_HArray1OfReal {
+  preview ( #( "HArray1OfReal [",
+               ((TColStd_HArray1OfReal*)$e.entity)->myArray.myLowerBound, "..", 
+               ((TColStd_HArray1OfReal*)$e.entity)->myArray.myUpperBound, "] ",
+               [$e.entity,x], " count=", $e.entity->count ) )
+  children ( #array ( expr: ((double*)(((TColStd_HArray1OfReal*)$e.entity)->myArray.myStart))[$i],
+                      size: 1+((TColStd_HArray1OfReal*)$e.entity)->myArray.myUpperBound ) )
+}
+
+TColStd_Array1OfInteger {
+  preview ( #( "Array1OfInteger [", $e.myLowerBound, "..", $e.myUpperBound, "]" ) )
+  children ( #array ( expr: ((int*)($c.myStart))[$i], size: 1+$c.myUpperBound ) )
+}
+
+Handle_TColStd_HArray1OfInteger {
+  preview ( #( "HArray1OfInteger [",
+               ((TColStd_HArray1OfInteger*)$e.entity)->myArray.myLowerBound, "..", 
+               ((TColStd_HArray1OfInteger*)$e.entity)->myArray.myUpperBound, "] ",
+               [$e.entity,x], " count=", $e.entity->count ) )
+  children ( #array ( expr: ((int*)(((TColStd_HArray1OfInteger*)$e.entity)->myArray.myStart))[$i],
+                      size: 1+((TColStd_HArray1OfInteger*)$e.entity)->myArray.myUpperBound ) )
+}
+
+Handle_TCollection_HExtendedString {
+  preview ( #( "HExtendedString ", [$e.entity,x], " count=", $e.entity->count, 
+               " ", ((TCollection_HExtendedString*)$e.entity)->myString ) )
+  children ( #([actual members]: [$e,!] ) )
+}
+
+Handle_TCollection_HAsciiString {
+  preview ( #( "HAsciiString ", [$e.entity,x], " count=", $e.entity->count, 
+               " ", ((TCollection_HAsciiString*)$e.entity)->myString ) )
+  children ( #([actual members]: [$e,!], 
+             #array( expr: ((TCollection_HAsciiString*)$e.entity)->myString.mystring[$i], 
+                     size: ((TCollection_HAsciiString*)$e.entity)->myString.mylength) ) )
+}
+~~~~~
+
+In Visual Studio 2012 and later, visualizers can be put in a separate file in subdirectory *Visualizers*. See file *occt.natvis* for example.
\ No newline at end of file
index a56dad1..e8d5880 100644 (file)
@@ -9,6 +9,7 @@ The following documents provide information on OCCT building, development and te
 * @subpage dev_guides__contribution_workflow "Contribution Workflow"
 * @subpage dev_guides__git_guide "Guide to installing and using Git for OCCT development"
 * @subpage dev_guides__tests "Automatic Testing system"
+* @subpage dev_guides__debug "Debugging tools and hints"
 
 Two other documents provide details on obsolete technologies used by OCCT, 
 to be removed in future releases:
index f4b8e01..ce2b8d7 100644 (file)
@@ -624,18 +624,6 @@ void  BRepTools::Dump(const TopoDS_Shape& Sh, Standard_OStream& S)
   SS.Dump(S);
 }
 
-#ifdef DEB
-//=======================================================================
-//function : BRepTools_Write 
-//purpose  : 
-//=======================================================================
-void BRepTools_Write (const TopoDS_Shape& S,
-                      const Standard_CString File)
-{
-  BRepTools::Write (S,File);  
-}
-#endif
-
 //=======================================================================
 //function : Write
 //purpose  : 
diff --git a/src/BRepTools/BRepTools_Debug.cxx b/src/BRepTools/BRepTools_Debug.cxx
new file mode 100644 (file)
index 0000000..bbe0c33
--- /dev/null
@@ -0,0 +1,112 @@
+// Created on: 1994-07-25
+// Created by: Remi LEQUETTE
+// Copyright (c) 1994-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 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.
+
+#include <BRepTools.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
+#include <TopTools_LocationSet.hxx>
+
+// This file defines global functions not declared in any public header,
+// intended for use from debugger prompt (Command Window in Visual Studio)
+
+//! Save shape to file
+const char* BRepTools_Write (const char* theFileStr, void* theShapePtr)
+{
+  if (theFileStr == 0 || theShapePtr == 0)
+  {
+    return "Error: name or shape is null";
+  }
+  try {
+    OCC_CATCH_SIGNALS
+    if (BRepTools::Write (*(TopoDS_Shape*)theShapePtr, theFileStr))
+      return theFileStr;
+    else
+      return "Error: write failed";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+//! Dump shape to cout
+const char* BRepTools_Dump (void* theShapePtr)
+{
+  if (theShapePtr == 0)
+  {
+    return "Error: name or shape is null";
+  }
+  try {
+    OCC_CATCH_SIGNALS
+
+    cout <<"\n\n";
+    BRepTools::Dump (*(TopoDS_Shape*)theShapePtr, cout);
+    cout << endl;
+
+    return "Shape dumped to cout";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+//! Dump shape location to cout
+const char* BRepTools_DumpLoc (void* theLocationPtr)
+{
+  if (theLocationPtr == 0)
+  {
+    return "Error: name or shape is null";
+  }
+  try {
+    OCC_CATCH_SIGNALS
+
+      cout <<"\n\n";
+    TopTools_LocationSet LS;
+    LS.Add(*(TopLoc_Location*)theLocationPtr);
+    LS.Dump(cout);
+    cout <<endl;
+
+    return "Location dumped to cout";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+// MSVC debugger cannot deal correctly with functions whose argunments 
+// have non-standard types. Here we define alternative to the above functions
+// with good types with the hope that GDB on Linux or other debugger could
+// work with them (DBX could, on SUN Solaris).
+#ifndef _MSC_VER
+
+const char* BRepTools_Write (const char* theFileNameStr, const TopoDS_Shape& theShape)
+{
+  return BRepTools_Write (theFileNameStr, (void*)&theShape);
+}
+
+const char* BRepTools_Dump (const TopoDS_Shape& theShape)
+{
+  return BRepTools_Dump ((void*)&theShape);
+}
+
+const char* BRepTools_DumpLoc (const TopoDS_Shape& theShape)
+{
+  return BRepTools_DumpLoc ((void*)&theShape);
+}
+
+#endif
diff --git a/src/BRepTools/FILES b/src/BRepTools/FILES
new file mode 100644 (file)
index 0000000..693791f
--- /dev/null
@@ -0,0 +1 @@
+BRepTools_Debug.cxx
index 17b5c95..c545b7f 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-// command that can be called within the debugger
-
 #include <DBRep.hxx>
-#include <BRepTools.hxx>
-#include <TopTools_LocationSet.hxx>
-#include <TopoDS_Shape.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
 
+// This file defines global functions not declared in any public header,
+// intended for use from debugger prompt (Command Window in Visual Studio)
 
-void DBRep_Set(char* name, const TopoDS_Shape& S)
+//! Save shape identified by pointer
+Standard_EXPORT const char* DBRep_Set (const char* theNameStr, void* theShapePtr)
 {
- DBRep::Set(name,S);
+  if (theNameStr == 0 || theShapePtr == 0)
+  {
+    return "Error: name or shape is null";
+  }
+  try {
+    DBRep::Set (theNameStr, *(TopoDS_Shape*)theShapePtr);
+    return theNameStr;
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
 }
 
+// MSVC debugger cannot deal correctly with functions whose argunments 
+// have non-standard types. Here we define alternative to the above functions
+// with good types with the hope that GDB on Linux or other debugger could
+// work with them (DBX could, on SUN Solaris).
+#ifndef _MSC_VER
+
+const char* DBRep_Set (char* theName, const TopoDS_Shape& theShape)
+{
+ return DBRep_Set (theName, (void*)&theShape);
+}
+
+#endif /* _MSC_VER */
+
+// old function, perhaps too dangerous to be used
+/*
 void DBRep_Get(char* name, TopoDS_Shape& S)
 {
   char n[255];
@@ -36,21 +62,4 @@ void DBRep_Get(char* name, TopoDS_Shape& S)
   if (*name == '.')
     cout << "Name : " << n << endl;
 }
-
-void DBRep_Dump(const TopoDS_Shape& S)
-{
-  cout <<"\n\n";
-  BRepTools::Dump(S,cout);
-  cout <<endl;
-}
-
-
-void DBRep_DumpLoc(const TopLoc_Location& L)
-{
-  cout <<"\n\n";
-  TopTools_LocationSet LS;
-  LS.Add(L);
-  LS.Dump(cout);
-  cout <<endl;
-}
-
+*/
diff --git a/src/Draw/Draw_Debug.cxx b/src/Draw/Draw_Debug.cxx
new file mode 100644 (file)
index 0000000..2bf952e
--- /dev/null
@@ -0,0 +1,42 @@
+// Created on: 2010-06-02
+// Created by: Peter KURNEV
+// Copyright (c) 2010-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.
+
+#include <DBRep.hxx>
+
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
+
+extern Draw_Interpretor theCommands;
+
+// This file defines global functions not declared in any public header,
+// intended for use from debugger prompt (Command Window in Visual Studio)
+
+//! Execute given DRAW command
+Standard_EXPORT const char* Draw_Eval (const char *theCommandStr)
+{
+  if (theCommandStr == 0)
+  {
+    return "Error: null command string";
+  }
+  try {
+    OCC_CATCH_SIGNALS
+    theCommands.Eval (theCommandStr);
+    return theCommands.Result();
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
index 71364b9..0ad398d 100755 (executable)
@@ -27,3 +27,4 @@ Draw_Main.cxx
 Draw_PluginMacro.hxx
 Draw_PloadCommands.cxx
 Draw_Window_1.mm
+Draw_Debug.cxx
index 401043e..a4c290e 100644 (file)
 #include <gp_Pnt.hxx>
 #include <gp_Pnt2d.hxx>
 
-// method to call with dbx
+// This file defines global functions not declared in any public header,
+// intended for use from debugger prompt (Command Window in Visual Studio)
 
-
-void DrawTrSurf_Set(char* name, const Handle(Standard_Transient)& G)
+//! Save geometric object identified by pointer to handle
+const char* DrawTrSurf_Set (const char* theNameStr, void* theHandlePtr)
 {
-  Handle(Geom_Geometry) GG = Handle(Geom_Geometry)::DownCast(G);
-  if (!GG.IsNull()) {
-    DrawTrSurf::Set(name,GG);
-      return;
+  if (theNameStr == 0 || theHandlePtr == 0)
+  {
+    return "Error: argument is null";
+  }
+  try {
+    const Handle(Standard_Transient)& aHandle = *(Handle(Standard_Transient)*)theHandlePtr;
+    Handle(Geom_Geometry) aGeom3d = Handle(Geom_Geometry)::DownCast(aHandle);
+    if (!aGeom3d.IsNull())
+    {
+      DrawTrSurf::Set (theNameStr, aGeom3d);
+      return theNameStr;
     }
-  Handle(Geom2d_Curve) GC = Handle(Geom2d_Curve)::DownCast(G);
-  if (!GC.IsNull()) {
-    DrawTrSurf::Set(name,GC);
-      return;
+    Handle(Geom2d_Curve) aGeom2d = Handle(Geom2d_Curve)::DownCast(aHandle);
+    if (!aGeom2d.IsNull())
+    {
+      DrawTrSurf::Set (theNameStr, aGeom2d);
+      return theNameStr;
     }
 
-  cout << "*** Not a geometric object ***" << endl;
+    return "Error: Not a geometric object";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+//! Set point to DRAW variable
+const char* DrawTrSurf_SetPnt (const char* theNameStr, void* thePntPtr)
+{
+  if (theNameStr == 0 || thePntPtr == 0)
+  {
+    return "Error: argument is null";
+  }
+  try {
+    const gp_Pnt& aP = *(gp_Pnt*)thePntPtr;
+    static char buff[256];
+    sprintf (buff, "Point (%.16g, %.16g, %.16g) set to DRAW variable %.80s", aP.X(), aP.Y(), aP.Z(), theNameStr);
+    DrawTrSurf::Set (theNameStr, aP);
+    return buff;
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+//! Set 2d point to DRAW variable
+const char* DrawTrSurf_SetPnt2d (const char* theNameStr, void* thePnt2dPtr)
+{
+  if (theNameStr == 0 || thePnt2dPtr == 0)
+  {
+    return "Error: argument is null";
+  }
+  try {
+    const gp_Pnt2d& aP = *(gp_Pnt2d*)thePnt2dPtr;
+    static char buff[256];
+    sprintf (buff, "Point (%.16g, %.16g) set to DRAW variable %.80s", aP.X(), aP.Y(), theNameStr);
+    DrawTrSurf::Set (theNameStr, aP);
+    return buff;
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+// MSVC debugger cannot deal correctly with functions whose argunments 
+// have non-standard types. Here we define alternative to the above functions
+// with good types with the hope that GDB on Linux or other debugger could
+// work with them (DBX could, on SUN Solaris).
+#ifndef _MSC_VER
+
+const char* DrawTrSurf_Set (const char* name, const Handle(Standard_Transient)& G)
+{
+  return DrawTrSurf_Set (name, (void*)&G);
 }
 
+const char* DrawTrSurf_Set (const char* theName, const gp_Pnt& thePnt)
+{
+  return DrawTrSurf_SetPnt (theName, (void*)&thePnt);
+}
+
+const char* DrawTrSurf_Set (const char* theName, const gp_Pnt2d& thePnt2d)
+{
+  return DrawTrSurf_SetPnt2d (theName, (void*)&thePnt2d);
+}
+
+#endif /* _MSC_VER */
+
+// old function, looks too dangerous to be used
+/*
 void DrawTrSurf_Get(const char* name, Handle(Standard_Transient)& G)
 {
   Handle(Geom_Geometry) GG = DrawTrSurf::Get(name);
@@ -58,41 +137,4 @@ void DrawTrSurf_Get(const char* name, Handle(Standard_Transient)& G)
 
   cout << "*** Not a geometric object ***" << endl;
 }
-
-void DrawTrSurf_Dump(const Handle(Standard_Transient)& G)
-{
-  cout << "\n\n";
-
-  Handle(Geom_Surface) GS = Handle(Geom_Surface)::DownCast(G);
-  if (!GS.IsNull()) {
-    GeomTools_SurfaceSet::PrintSurface(GS,cout);
-    cout << endl;
-      return;
-    }
-
-  Handle(Geom_Curve) GC = Handle(Geom_Curve)::DownCast(G);
-  if (!GC.IsNull()) {
-    GeomTools_CurveSet::PrintCurve(GC,cout);
-    cout << endl;
-      return;
-    }
-
-  Handle(Geom2d_Curve) GC2d = Handle(Geom2d_Curve)::DownCast(G);
-  if (!GC2d.IsNull()) {
-    GeomTools_Curve2dSet::PrintCurve2d(GC2d,cout);
-    cout << endl;
-      return;
-    }
-}
-
-void DrawTrSurf_Set(char* name, const gp_Pnt& P)
-{
-  cout<<"point "<<name<<" "<<P.X()<<" "<<P.Y()<<" "<<P.Z()<<endl;
-  DrawTrSurf::Set(name,P);
-}
-
-void DrawTrSurf_Set(char* name, const gp_Pnt2d& P)
-{
-  cout<<"point "<<name<<" "<<P.X()<<" "<<P.Y()<<endl;
-  DrawTrSurf::Set(name,P);
-}
+*/
diff --git a/src/GeomTools/FILES b/src/GeomTools/FILES
new file mode 100644 (file)
index 0000000..edb7a4c
--- /dev/null
@@ -0,0 +1 @@
+GeomTools_Debug.cxx
diff --git a/src/GeomTools/GeomTools_Debug.cxx b/src/GeomTools/GeomTools_Debug.cxx
new file mode 100644 (file)
index 0000000..730b9e8
--- /dev/null
@@ -0,0 +1,81 @@
+// Created on: 1994-07-25
+// Created by: Remi LEQUETTE
+// Copyright (c) 1994-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 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.
+
+#include <GeomTools.hxx>
+#include <GeomTools_SurfaceSet.hxx>
+#include <GeomTools_CurveSet.hxx>
+#include <GeomTools_Curve2dSet.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
+
+// This file defines global functions not declared in any public header,
+// intended for use from debugger prompt (Command Window in Visual Studio)
+
+//! Dump content of the geometric object to cout
+const char* GeomTools_Dump (void* theHandlePtr)
+{
+  if (theHandlePtr == 0)
+  {
+    return "Error: argument is null";
+  }
+  try {
+    OCC_CATCH_SIGNALS
+    const Handle(Standard_Transient)& aHandle = *(Handle(Standard_Transient)*)theHandlePtr;
+
+    Handle(Geom_Surface) GS = Handle(Geom_Surface)::DownCast(aHandle);
+    if (!GS.IsNull()) {
+      cout << "\n\n";
+      GeomTools_SurfaceSet::PrintSurface (GS,cout);
+      cout << endl;
+      return "Found Geom_Surface, see dump in cout";
+    }
+
+    Handle(Geom_Curve) GC = Handle(Geom_Curve)::DownCast(aHandle);
+    if (!GC.IsNull()) {
+      cout << "\n\n";
+      GeomTools_CurveSet::PrintCurve(GC,cout);
+      cout << endl;
+      return "Found Geom_Curve, see dump in cout";
+    }
+
+    Handle(Geom2d_Curve) GC2d = Handle(Geom2d_Curve)::DownCast(aHandle);
+    if (!GC2d.IsNull()) {
+      cout << "\n\n";
+      GeomTools_Curve2dSet::PrintCurve2d(GC2d,cout);
+      cout << endl;
+      return "Found Geom2d_Curve, see dump in cout";
+    }
+
+    return "Error: Not a geometric object";
+  }
+  catch (Standard_Failure)
+  {
+    return Standard_Failure::Caught()->GetMessageString();
+  }
+}
+
+// MSVC debugger cannot deal correctly with functions whose argunments 
+// have non-standard types. Here we define alternative to the above functions
+// with good types with the hope that GDB on Linux or other debugger could
+// work with them (DBX could, on SUN Solaris).
+#ifndef _MSC_VER
+
+const char* GeomTools_Dump (const Handle(Standard_Transient)& theGeom)
+{
+  return GeomTools_Dump ((void*)&theGeom);
+}
+
+#endif