Get rid of NULLs in xfa/fxbarcode/

xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 // Original code is licensed as follows:
 /*
  * Copyright 2013 ZXing authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ skipping 28 matching lines @@
 #include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h"
 #include "xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h"
 #include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h"
 #include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h"
 #include "xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h"
 #include "xfa/fxbarcode/utils.h"
 
 int32_t CBC_PDF417ScanningDecoder::CODEWORD_SKEW_SIZE = 2;
 int32_t CBC_PDF417ScanningDecoder::MAX_ERRORS = 3;
 int32_t CBC_PDF417ScanningDecoder::MAX_EC_CODEWORDS = 512;
-CBC_PDF417ECErrorCorrection* CBC_PDF417ScanningDecoder::errorCorrection = NULL;
+CBC_PDF417ECErrorCorrection* CBC_PDF417ScanningDecoder::errorCorrection =
+    nullptr;
 
 CBC_PDF417ScanningDecoder::CBC_PDF417ScanningDecoder() {}
 CBC_PDF417ScanningDecoder::~CBC_PDF417ScanningDecoder() {}
 void CBC_PDF417ScanningDecoder::Initialize() {
   errorCorrection = new CBC_PDF417ECErrorCorrection;
 }
 void CBC_PDF417ScanningDecoder::Finalize() {
   delete errorCorrection;
 }
 CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::decode(
     CBC_CommonBitMatrix* image,
     CBC_ResultPoint* imageTopLeft,
     CBC_ResultPoint* imageBottomLeft,
     CBC_ResultPoint* imageTopRight,
     CBC_ResultPoint* imageBottomRight,
     int32_t minCodewordWidth,
     int32_t maxCodewordWidth,
     int32_t& e) {
   CBC_BoundingBox* boundingBox = new CBC_BoundingBox(
       image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight, e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
-  CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn = NULL;
-  CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn = NULL;
-  CBC_DetectionResult* detectionResult = NULL;
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
+  CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn = nullptr;
+  CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn = nullptr;
+  CBC_DetectionResult* detectionResult = nullptr;
   for (int32_t i = 0; i < 2; i++) {
     if (imageTopLeft) {
       leftRowIndicatorColumn =
           getRowIndicatorColumn(image, boundingBox, *imageTopLeft, TRUE,
                                 minCodewordWidth, maxCodewordWidth);
     }
     if (imageTopRight) {
       rightRowIndicatorColumn =
           getRowIndicatorColumn(image, boundingBox, *imageTopRight, FALSE,
                                 minCodewordWidth, maxCodewordWidth);
     }
     detectionResult = merge(leftRowIndicatorColumn, rightRowIndicatorColumn, e);
     if (e != BCExceptionNO) {
       e = BCExceptiontNotFoundInstance;
       delete leftRowIndicatorColumn;
       delete rightRowIndicatorColumn;
       delete boundingBox;
-      return NULL;
+      return nullptr;
     }
     if (i == 0 && (detectionResult->getBoundingBox()->getMinY() <
                        boundingBox->getMinY() ||
                    detectionResult->getBoundingBox()->getMaxY() >
                        boundingBox->getMaxY())) {
       delete boundingBox;
       boundingBox = detectionResult->getBoundingBox();
     } else {
       detectionResult->setBoundingBox(boundingBox);
       break;
     }
   }
   int32_t maxBarcodeColumn = detectionResult->getBarcodeColumnCount() + 1;
   detectionResult->setDetectionResultColumn(0, leftRowIndicatorColumn);
   detectionResult->setDetectionResultColumn(maxBarcodeColumn,
                                             rightRowIndicatorColumn);
-  FX_BOOL leftToRight = leftRowIndicatorColumn != NULL;
+  FX_BOOL leftToRight = !!leftRowIndicatorColumn;
   for (int32_t barcodeColumnCount = 1; barcodeColumnCount <= maxBarcodeColumn;
        barcodeColumnCount++) {
     int32_t barcodeColumn = leftToRight ? barcodeColumnCount
                                         : maxBarcodeColumn - barcodeColumnCount;
     if (detectionResult->getDetectionResultColumn(barcodeColumn)) {
       continue;
     }
-    CBC_DetectionResultColumn* detectionResultColumn = NULL;
+    CBC_DetectionResultColumn* detectionResultColumn = nullptr;
     if (barcodeColumn == 0 || barcodeColumn == maxBarcodeColumn) {
       detectionResultColumn = new CBC_DetectionResultRowIndicatorColumn(
           boundingBox, barcodeColumn == 0);
     } else {
       detectionResultColumn = new CBC_DetectionResultColumn(boundingBox);
     }
     detectionResult->setDetectionResultColumn(barcodeColumn,
                                               detectionResultColumn);
     int32_t startColumn = -1;
     int32_t previousStartColumn = startColumn;
@@ skipping 19 matching lines @@
         maxCodewordWidth = maxCodewordWidth > codeword->getWidth()
                                ? maxCodewordWidth
                                : codeword->getWidth();
       }
     }
   }
   CBC_CommonDecoderResult* decoderresult =
       createDecoderResult(detectionResult, e);
   if (e != BCExceptionNO) {
     delete detectionResult;
-    return NULL;
+    return nullptr;
   }
   return decoderresult;
 }
 
 CFX_ByteString CBC_PDF417ScanningDecoder::toString(
     CBC_BarcodeValueArrayArray* barcodeMatrix) {
   CFX_ByteString result;
   for (int32_t row = 0; row < barcodeMatrix->GetSize(); row++) {
     result += row;
     for (int32_t l = 0; l < barcodeMatrix->GetAt(row)->GetSize(); l++) {
       CBC_BarcodeValue* barcodeValue = barcodeMatrix->GetAt(row)->GetAt(l);
       if (barcodeValue->getValue()->GetSize() == 0) {
         result += "";
       } else {
         result += barcodeValue->getValue()->GetAt(0);
         result +=
             barcodeValue->getConfidence(barcodeValue->getValue()->GetAt(0));
       }
     }
   }
   return result;
 }
 
 CBC_DetectionResult* CBC_PDF417ScanningDecoder::merge(
     CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn,
     CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn,
     int32_t& e) {
-  if (leftRowIndicatorColumn == NULL && rightRowIndicatorColumn == NULL) {
+  if (!leftRowIndicatorColumn && !rightRowIndicatorColumn) {
     e = BCExceptionIllegalArgument;
-    return NULL;
+    return nullptr;
   }
   CBC_BarcodeMetadata* barcodeMetadata =
       getBarcodeMetadata(leftRowIndicatorColumn, rightRowIndicatorColumn);
-  if (barcodeMetadata == NULL) {
+  if (!barcodeMetadata) {
     e = BCExceptionCannotMetadata;
-    return NULL;
+    return nullptr;
   }
   CBC_BoundingBox* leftboundingBox =
       adjustBoundingBox(leftRowIndicatorColumn, e);
   if (e != BCExceptionNO) {
     delete barcodeMetadata;
-    return NULL;
+    return nullptr;
   }
   CBC_BoundingBox* rightboundingBox =
       adjustBoundingBox(rightRowIndicatorColumn, e);
   if (e != BCExceptionNO) {
     delete barcodeMetadata;
-    return NULL;
+    return nullptr;
   }
   CBC_BoundingBox* boundingBox =
       CBC_BoundingBox::merge(leftboundingBox, rightboundingBox, e);
   if (e != BCExceptionNO) {
     delete barcodeMetadata;
-    return NULL;
+    return nullptr;
   }
   CBC_DetectionResult* detectionresult =
       new CBC_DetectionResult(barcodeMetadata, boundingBox);
   return detectionresult;
 }
 CBC_BoundingBox* CBC_PDF417ScanningDecoder::adjustBoundingBox(
     CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn,
     int32_t& e) {
-  if (rowIndicatorColumn == NULL) {
-    return NULL;
-  }
+  if (!rowIndicatorColumn)
+    return nullptr;
+
   CFX_Int32Array* rowHeights = rowIndicatorColumn->getRowHeights(e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   int32_t maxRowHeight = getMax(*rowHeights);
   int32_t missingStartRows = 0;
   for (int32_t i = 0; i < rowHeights->GetSize(); i++) {
     int32_t rowHeight = rowHeights->GetAt(i);
     missingStartRows += maxRowHeight - rowHeight;
     if (rowHeight > 0) {
       break;
     }
   }
   CFX_ArrayTemplate<CBC_Codeword*>* codewords =
       rowIndicatorColumn->getCodewords();
-  for (int32_t row = 0; missingStartRows > 0 && codewords->GetAt(row) == NULL;
-       row++) {
+  for (int32_t row = 0; missingStartRows > 0 && !codewords->GetAt(row); row++) {
     missingStartRows--;
   }
   int32_t missingEndRows = 0;
   for (int32_t row1 = rowHeights->GetSize() - 1; row1 >= 0; row1--) {
     missingEndRows += maxRowHeight - rowHeights->GetAt(row1);
     if (rowHeights->GetAt(row1) > 0) {
       break;
     }
   }
   for (int32_t row2 = codewords->GetSize() - 1;
-       missingEndRows > 0 && codewords->GetAt(row2) == NULL; row2--) {
+       missingEndRows > 0 && !codewords->GetAt(row2); row2--) {
     missingEndRows--;
   }
   CBC_BoundingBox* boundingBox =
       rowIndicatorColumn->getBoundingBox()->addMissingRows(
           missingStartRows, missingEndRows, rowIndicatorColumn->isLeft(), e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   return boundingBox;
 }
 int32_t CBC_PDF417ScanningDecoder::getMax(CFX_Int32Array& values) {
   int32_t maxValue = -1;
   for (int32_t i = 0; i < values.GetSize(); i++) {
     int32_t value = values.GetAt(i);
     maxValue = maxValue > value ? maxValue : value;
   }
   return maxValue;
 }
 CBC_BarcodeMetadata* CBC_PDF417ScanningDecoder::getBarcodeMetadata(
     CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn,
     CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn) {
-  CBC_BarcodeMetadata* leftBarcodeMetadata = NULL;
-  CBC_BarcodeMetadata* rightBarcodeMetadata = NULL;
-  if (leftRowIndicatorColumn == NULL ||
-      (leftBarcodeMetadata = leftRowIndicatorColumn->getBarcodeMetadata()) ==
-          NULL) {
-    return rightRowIndicatorColumn == NULL
-               ? NULL
-               : rightRowIndicatorColumn->getBarcodeMetadata();
+  CBC_BarcodeMetadata* leftBarcodeMetadata =
+      leftRowIndicatorColumn ? leftRowIndicatorColumn->getBarcodeMetadata()
+                             : nullptr;
+  if (!leftBarcodeMetadata) {
+    return rightRowIndicatorColumn
+               ? rightRowIndicatorColumn->getBarcodeMetadata()
+               : nullptr;
   }
-  if (rightRowIndicatorColumn == NULL ||
-      (rightBarcodeMetadata = rightRowIndicatorColumn->getBarcodeMetadata()) ==
-          NULL) {
-    return leftRowIndicatorColumn == NULL
-               ? NULL
-               : leftRowIndicatorColumn->getBarcodeMetadata();
+
+  CBC_BarcodeMetadata* rightBarcodeMetadata =
+      rightRowIndicatorColumn ? rightRowIndicatorColumn->getBarcodeMetadata()
+                              : nullptr;
+  if (!rightBarcodeMetadata) {
+    return leftRowIndicatorColumn ? leftRowIndicatorColumn->getBarcodeMetadata()
+                                  : nullptr;
   }
+
   if (leftBarcodeMetadata->getColumnCount() !=
           rightBarcodeMetadata->getColumnCount() &&
       leftBarcodeMetadata->getErrorCorrectionLevel() !=
           rightBarcodeMetadata->getErrorCorrectionLevel() &&
       leftBarcodeMetadata->getRowCount() !=
           rightBarcodeMetadata->getRowCount()) {
     delete leftBarcodeMetadata;
     delete rightBarcodeMetadata;
-    return NULL;
+    return nullptr;
   }
   delete rightBarcodeMetadata;
   return leftBarcodeMetadata;
 }
 CBC_DetectionResultRowIndicatorColumn*
 CBC_PDF417ScanningDecoder::getRowIndicatorColumn(CBC_CommonBitMatrix* image,
                                                  CBC_BoundingBox* boundingBox,
                                                  CBC_ResultPoint startPoint,
                                                  FX_BOOL leftToRight,
                                                  int32_t minCodewordWidth,
@@ skipping 137 matching lines @@
       } else {
         ambiguousIndexCount[i] = 0;
         if (i == ambiguousIndexCount.GetSize() - 1) {
           e = BCExceptionChecksumInstance;
           return nullptr;
         }
       }
     }
   }
   e = BCExceptionChecksumInstance;
-  return NULL;
+  return nullptr;
 }
 CBC_BarcodeValueArrayArray* CBC_PDF417ScanningDecoder::createBarcodeMatrix(
     CBC_DetectionResult* detectionResult) {
   CBC_BarcodeValueArrayArray* barcodeMatrix = new CBC_BarcodeValueArrayArray;
   barcodeMatrix->SetSize(detectionResult->getBarcodeRowCount());
   for (int32_t row = 0; row < barcodeMatrix->GetSize(); row++) {
     CBC_BarcodeValueArray* temp = new CBC_BarcodeValueArray;
     temp->SetSize(detectionResult->getBarcodeColumnCount() + 2);
     for (int32_t column = 0;
          column < detectionResult->getBarcodeColumnCount() + 2; column++) {
       temp->SetAt(column, new CBC_BarcodeValue());
     }
     barcodeMatrix->SetAt(row, temp);
   }
   for (int32_t i = 0;
        i < detectionResult->getDetectionResultColumns().GetSize(); i++) {
     CBC_DetectionResultColumn* detectionResultColumn =
         (CBC_DetectionResultColumn*)detectionResult->getDetectionResultColumns()
             .GetAt(i);
-    if (detectionResultColumn == NULL) {
+    if (!detectionResultColumn)
       continue;
-    }
+
     CFX_ArrayTemplate<CBC_Codeword*>* temp =
         detectionResultColumn->getCodewords();
     for (int32_t l = 0; l < temp->GetSize(); l++) {
       CBC_Codeword* codeword = temp->GetAt(l);
-      if (codeword == NULL || codeword->getRowNumber() == -1) {
+      if (!codeword || codeword->getRowNumber() == -1)
         continue;
-      }
+
       barcodeMatrix->GetAt(codeword->getRowNumber())
           ->GetAt(i)
           ->setValue(codeword->getValue());
     }
   }
   return barcodeMatrix;
 }
 FX_BOOL CBC_PDF417ScanningDecoder::isValidBarcodeColumn(
     CBC_DetectionResult* detectionResult,
     int32_t barcodeColumn) {
   return barcodeColumn >= 0 &&
          barcodeColumn <= detectionResult->getBarcodeColumnCount() + 1;
 }
 int32_t CBC_PDF417ScanningDecoder::getStartColumn(
     CBC_DetectionResult* detectionResult,
     int32_t barcodeColumn,
     int32_t imageRow,
     FX_BOOL leftToRight) {
   int32_t offset = leftToRight ? 1 : -1;
-  CBC_Codeword* codeword = NULL;
+  CBC_Codeword* codeword = nullptr;
   if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
     codeword = detectionResult->getDetectionResultColumn(barcodeColumn - offset)
                    ->getCodeword(imageRow);
   }
   if (codeword) {
     return leftToRight ? codeword->getEndX() : codeword->getStartX();
   }
   codeword = detectionResult->getDetectionResultColumn(barcodeColumn)
                  ->getCodewordNearby(imageRow);
   if (codeword) {
@@ skipping 37 matching lines @@
     int32_t maxColumn,
     FX_BOOL leftToRight,
     int32_t startColumn,
     int32_t imageRow,
     int32_t minCodewordWidth,
     int32_t maxCodewordWidth) {
   startColumn = adjustCodewordStartColumn(image, minColumn, maxColumn,
                                           leftToRight, startColumn, imageRow);
   CFX_Int32Array* moduleBitCount = getModuleBitCount(
       image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
-  if (moduleBitCount == NULL) {
-    return NULL;
-  }
+  if (!moduleBitCount)
+    return nullptr;
+
   int32_t endColumn;
   int32_t codewordBitCount = CBC_PDF417Common::getBitCountSum(*moduleBitCount);
   if (leftToRight) {
     endColumn = startColumn + codewordBitCount;
   } else {
     for (int32_t i = 0; i<moduleBitCount->GetSize()>> 1; i++) {
       int32_t tmpCount = moduleBitCount->GetAt(i);
       moduleBitCount->SetAt(
           i, moduleBitCount->GetAt(moduleBitCount->GetSize() - 1 - i));
       moduleBitCount->SetAt(moduleBitCount->GetSize() - 1 - i, tmpCount);
     }
     endColumn = startColumn;
     startColumn = endColumn - codewordBitCount;
   }
   int32_t decodedValue =
       CBC_PDF417CodewordDecoder::getDecodedValue(*moduleBitCount);
   int32_t codeword = CBC_PDF417Common::getCodeword(decodedValue);
   delete moduleBitCount;
   if (codeword == -1) {
-    return NULL;
+    return nullptr;
   }
   return new CBC_Codeword(startColumn, endColumn,
                           getCodewordBucketNumber(decodedValue), codeword);
 }
 CFX_Int32Array* CBC_PDF417ScanningDecoder::getModuleBitCount(
     CBC_CommonBitMatrix* image,
     int32_t minColumn,
     int32_t maxColumn,
     FX_BOOL leftToRight,
     int32_t startColumn,
@@ skipping 16 matching lines @@
       previousPixelValue = !previousPixelValue;
     }
   }
   if (moduleNumber == moduleBitCount->GetSize() ||
       (((leftToRight && imageColumn == maxColumn) ||
         (!leftToRight && imageColumn == minColumn)) &&
        moduleNumber == moduleBitCount->GetSize() - 1)) {
     return moduleBitCount;
   }
   delete moduleBitCount;
-  return NULL;
+  return nullptr;
 }
 int32_t CBC_PDF417ScanningDecoder::getNumberOfECCodeWords(
     int32_t barcodeECLevel) {
   return 2 << barcodeECLevel;
 }
 int32_t CBC_PDF417ScanningDecoder::adjustCodewordStartColumn(
     CBC_CommonBitMatrix* image,
     int32_t minColumn,
     int32_t maxColumn,
     FX_BOOL leftToRight,
@@ skipping 22 matching lines @@
   return minCodewordWidth - CODEWORD_SKEW_SIZE <= codewordSize &&
          codewordSize <= maxCodewordWidth + CODEWORD_SKEW_SIZE;
 }
 CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::decodeCodewords(
     CFX_Int32Array& codewords,
     int32_t ecLevel,
     CFX_Int32Array& erasures,
     int32_t& e) {
   if (codewords.GetSize() == 0) {
     e = BCExceptionFormatInstance;
-    return NULL;
+    return nullptr;
   }
   int32_t numECCodewords = 1 << (ecLevel + 1);
   correctErrors(codewords, erasures, numECCodewords, e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   verifyCodewordCount(codewords, numECCodewords, e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   CFX_ByteString bytestring;
   CBC_CommonDecoderResult* decoderResult = CBC_DecodedBitStreamPaser::decode(
       codewords, bytestring.FormatInteger(ecLevel), e);
-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
   return decoderResult;
 }
 int32_t CBC_PDF417ScanningDecoder::correctErrors(CFX_Int32Array& codewords,
                                                  CFX_Int32Array& erasures,
                                                  int32_t numECCodewords,
                                                  int32_t& e) {
   if ((erasures.GetSize() != 0 &&
        erasures.GetSize() > (numECCodewords / 2 + MAX_ERRORS)) ||
       numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
     e = BCExceptionChecksumInstance;
@@ skipping 49 matching lines @@
   int32_t result = getCodewordBucketNumber(*array);
   delete array;
   return result;
 }
 int32_t CBC_PDF417ScanningDecoder::getCodewordBucketNumber(
     CFX_Int32Array& moduleBitCount) {
   return (moduleBitCount.GetAt(0) - moduleBitCount.GetAt(2) +
           moduleBitCount.GetAt(4) - moduleBitCount.GetAt(6) + 9) %
          9;
 }