more CGAL_USE and some reindentations

Bounding_volumes/include/CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation_impl.h

@@ -28,6 +28,7 @@
 #include <numeric>
 
 #include <CGAL/tags.h>
+#include <CGAL/use.h>
 #include <CGAL/Approximate_min_ellipsoid_d/Khachiyan_approximation.h>
 
 namespace CGAL {
@@ -366,7 +367,7 @@ namespace CGAL {
     CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) || tau == eps/((1+eps)*d-1));
     CGAL_APPEL_ASSERT(!check_tag(Exact_flag()) || 
 		      excess<ET>(tco.cartesian_begin(*P[k])) == (1+eps)*d);
-    
+    CGAL_USE(tau);
     const FT mu = eps / ((d-1)*(1+eps));
     const FT alpha = 1 + mu;
     const FT beta = mu / (1+eps);

Kernel_d/include/CGAL/Kernel_d/Sphere_d.h

@@ -28,6 +28,7 @@
 #include <CGAL/basic.h>
 #include <vector>
 #include <CGAL/Dimension.h>
+#include <CGAL/use.h>
 
 namespace CGAL {
 
@@ -56,6 +57,7 @@ public:
      P(first,last), cp(0)
   { TUPLE_DIM_CHECK(P.begin(),P.end(),Sphere_d);
     CGAL_assertion(d+1==int(P.size()));
+    CGAL_USE(d);
     typename R::Orientation_d orientation_;
     orient = orientation_(P.begin(),P.end()); }
 

Kernel_d/include/CGAL/Kernel_d/Tuple_d.h

@@ -224,11 +224,13 @@ void Tuple_d<NT,LA>::print(std::ostream& os, const char* l) const
     case CGAL::IO::ASCII :
       os << size() << " ";
       for (i = 0; i < size(); ++i) 
-        os << v[i] << " "; break;
+        os << v[i] << " ";
+      break;
     case CGAL::IO::BINARY :
       CGAL::write(os, size()); 
       for (i = 0; i < size(); ++i) 
-        CGAL::write(os, v[i]); break;
+        CGAL::write(os, v[i]);
+      break;
     default :
       os << l << "(" << size() << ", ";
       for (i = 0; i < size(); ++i) {

Kernel_d/include/CGAL/Kernel_d/function_objectsCd.h

@@ -27,6 +27,7 @@
 
 #include <CGAL/basic.h>
 #include <CGAL/enum.h>
+#include <CGAL/use.h>
 #include <CGAL/Referenced_argument.h>
 
 #undef CGAL_KD_TRACE
@@ -143,6 +144,7 @@ public:
     result_type operator()(Forward_iterator start, Forward_iterator end) const
     {
         CGAL_assertion(start!=end);
+        CGAL_USE(d);
         int d = start->dimension();
         Matrix M(d);
         Vector b(d);

Kernel_d/include/CGAL/Kernel_d/function_objectsHd.h

@@ -128,6 +128,7 @@ typedef typename R::LA LA;
 template <class Forward_iterator>
 Point_d operator()(Forward_iterator start, Forward_iterator end) const
 { CGAL_assertion(start!=end);
+  CGAL_USE(end);
   int d = start->dimension();
   typename LA::Matrix M(d);
   typename LA::Vector b(d);

Nef_2/include/CGAL/Nef_2/PM_point_locator.h

@@ -174,8 +174,9 @@ public:
     Direction d_res = direction(e_res);
     Halfedge_around_vertex_const_circulator el(e_res),ee(el);
     CGAL_For_all(el,ee) {
-      if ( K.strictly_ordered_ccw(d_res, direction(el), d) )
+      if ( K.strictly_ordered_ccw(d_res, direction(el), d) ){
         e_res = el; d_res = direction(e_res);
+      }
     }
     CGAL_NEF_TRACEN("  determined "<<PE(e_res)<<" "<<d_res);
     if ( direction(cyclic_adj_succ(e_res)) == d ) {

Nef_2/include/CGAL/Nef_polyhedron_2.h

@@ -282,9 +282,17 @@ protected:
       D(d), _e(), _v(), _it(it), _m(m) {}
 
     void supporting_segment(Halfedge_handle e, ES_iterator it) 
-    { if ( it == _it ) _e = e; D.mark(e) = _m; }
+    {
+      if ( it == _it )
+        _e = e;
+      D.mark(e) = _m; 
+    }
     void trivial_segment(Vertex_handle v, ES_iterator it) 
-    { if ( it == _it ) _v = v; D.mark(v) = _m; }
+    {
+      if ( it == _it )
+        _v = v;
+      D.mark(v) = _m;
+    }
     void starting_segment(Vertex_handle v, ES_iterator) 
     { D.mark(v) = _m; }
     void passing_segment(Vertex_handle v, ES_iterator) 

Nef_3/include/CGAL/Nef_polyhedron_3.h

@@ -196,7 +196,7 @@ protected:
   struct AND { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const { return b1&&b2; } };
   struct OR { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const { return b1||b2; } };
   struct DIFF { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { 
-    if(inverted) return !b1&&b2; return b1&&!b2; } };
+    return (inverted) ? !b1&&b2  :  b1&&!b2 ; };
   struct XOR { Mark operator()(const Mark& b1, const Mark& b2, bool /* inverted */ =false) const 
     { return (b1&&!b2)||(!b1&&b2); } };
 

Nef_S2/include/CGAL/Nef_S2/Sphere_triangle.h

@@ -103,7 +103,8 @@ template <typename R>
 std::ostream& operator<<(std::ostream& os, 
                          const CGAL::Sphere_triangle<R>& t)
 { for (int i=0; i<3; ++i) os << t.point(i);
-  for (int i=0; i<3; ++i) os << t.circle(i); return os; }
+  for (int i=0; i<3; ++i) os << t.circle(i);
+  return os; }
 
 template <typename R>
 std::istream& operator>>(std::istream& is,