Define NDEBUG instead of SK_DEBUG/SK_RELEASE.

experimental/Intersection/QuadraticImplicit.cpp

 // Another approach is to start with the implicit form of one curve and solve
 // (seek implicit coefficients in QuadraticParameter.cpp
 // by substituting in the parametric form of the other.
 // The downside of this approach is that early rejects are difficult to come by.
 // http://planetmath.org/encyclopedia/GaloisTheoreticDerivationOfTheQuarticFormula.html#step
 
 
 #include "CubicUtilities.h"
 #include "CurveIntersection.h"
 #include "Intersections.h"
 #include "QuadraticParameterization.h"
 #include "QuarticRoot.h"
 #include "QuadraticUtilities.h"
 #include "TSearch.h"
 
-#if SK_DEBUG
+#ifdef SK_DEBUG
 #include "LineUtilities.h"
 #endif
 
 /* given the implicit form 0 = Ax^2 + Bxy + Cy^2 + Dx + Ey + F
  * and given x = at^2 + bt + c  (the parameterized form)
  *           y = dt^2 + et + f
  * then
  * 0 = A(at^2+bt+c)(at^2+bt+c)+B(at^2+bt+c)(dt^2+et+f)+C(dt^2+et+f)(dt^2+et+f)+D(at^2+bt+c)+E(dt^2+et+f)+F
  */
 
@@ skipping 132 matching lines @@
     sub_divide(q1, t1s, t1e, hull);
     _Line line = {hull[2], hull[0]};
     const _Line* testLines[] = { &line, (const _Line*) &hull[0], (const _Line*) &hull[1] };
     size_t testCount = sizeof(testLines) / sizeof(testLines[0]);
     SkTDArray<double> tsFound;
     for (size_t index = 0; index < testCount; ++index) {
         Intersections rootTs;
         int roots = intersect(q2, *testLines[index], rootTs);
         for (int idx2 = 0; idx2 < roots; ++idx2) {
             double t = rootTs.fT[0][idx2];
-#if SK_DEBUG
+#ifdef SK_DEBUG
         _Point qPt, lPt;
         xy_at_t(q2, t, qPt.x, qPt.y);
         xy_at_t(*testLines[index], rootTs.fT[1][idx2], lPt.x, lPt.y);
         SkASSERT(qPt.approximatelyEqual(lPt));
 #endif
             if (approximately_negative(t - t2s) || approximately_positive(t - t2e)) {
                 continue;
             }
             *tsFound.append() = rootTs.fT[0][idx2];
         }
@@ skipping 74 matching lines @@
     if (!approximately_zero_sqrt(measure)) {
         return false;
     }
     return isLinearInner(q1, 0, 1, q2, 0, 1, i, NULL);
 }
 
 // FIXME: if flat measure is sufficiently large, then probably the quartic solution failed
 static void relaxedIsLinear(const Quadratic& q1, const Quadratic& q2, Intersections& i) {
     double m1 = flatMeasure(q1);
     double m2 = flatMeasure(q2);
-#if SK_DEBUG
+#ifdef SK_DEBUG
     double min = SkTMin(m1, m2);
     if (min > 5) {
         SkDebugf("%s maybe not flat enough.. %1.9g\n", __FUNCTION__, min);
     }
 #endif
     i.reset();
     const Quadratic& rounder = m2 < m1 ? q1 : q2;
     const Quadratic& flatter = m2 < m1 ? q2 : q1;
     bool subDivide = false;
     isLinearInner(flatter, 0, 1, rounder, 0, 1, i, &subDivide);
@@ skipping 288 matching lines @@
         if (lowestIndex < 0) {
             break;
         }
         i.insert(roots1Copy[lowestIndex], roots2Copy[closest[lowestIndex]],
                 pts1[lowestIndex]);
         closest[lowestIndex] = -1;
     } while (++used < r1Count);
     i.fFlip = false;
     return i.intersected();
 }