Fix DOS newlines

R=thestig@chromium.org

Review URL: https://codereview.chromium.org/1636873004 .

1 files changed, 234 insertions, 234 deletions

diff --git a/xfa/src/fxbarcode/oned/BC_OnedCode128Writer.cpp b/xfa/src/fxbarcode/oned/BC_OnedCode128Writer.cpp
index 118d426cf4..0387977e61 100644
--- a/xfa/src/fxbarcode/oned/BC_OnedCode128Writer.cpp
+++ b/xfa/src/fxbarcode/oned/BC_OnedCode128Writer.cpp
@@ -1,234 +1,234 @@
-// 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 2010 ZXing authors

- *

- * Licensed under the Apache License, Version 2.0 (the "License");

- * you may not use this file except in compliance with the License.

- * You may obtain a copy of the License at

- *

- *      http://www.apache.org/licenses/LICENSE-2.0

- *

- * Unless required by applicable law or agreed to in writing, software

- * distributed under the License is distributed on an "AS IS" BASIS,

- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

- * See the License for the specific language governing permissions and

- * limitations under the License.

- */

-

-#include "xfa/src/fxbarcode/barcode.h"

-#include "xfa/src/fxbarcode/BC_Writer.h"

-#include "xfa/src/fxbarcode/BC_Reader.h"

-#include "BC_OneDReader.h"

-#include "BC_OneDimWriter.h"

-#include "BC_OnedCode128Reader.h"

-#include "BC_OnedCode128Writer.h"

-const int32_t CBC_OnedCode128Writer::CODE_CODE_B = 100;

-const int32_t CBC_OnedCode128Writer::CODE_CODE_C = 99;

-const int32_t CBC_OnedCode128Writer::CODE_START_B = 104;

-const int32_t CBC_OnedCode128Writer::CODE_START_C = 105;

-const int32_t CBC_OnedCode128Writer::CODE_STOP = 106;

-CBC_OnedCode128Writer::CBC_OnedCode128Writer() {

-  m_codeFormat = BC_CODE128_B;

-}

-CBC_OnedCode128Writer::CBC_OnedCode128Writer(BC_TYPE type) {

-  m_codeFormat = type;

-}

-CBC_OnedCode128Writer::~CBC_OnedCode128Writer() {}

-BC_TYPE CBC_OnedCode128Writer::GetType() {

-  return m_codeFormat;

-}

-FX_BOOL CBC_OnedCode128Writer::CheckContentValidity(

-    const CFX_WideStringC& contents) {

-  FX_BOOL ret = TRUE;

-  int32_t position = 0;

-  int32_t patternIndex = -1;

-  if (m_codeFormat == BC_CODE128_B || m_codeFormat == BC_CODE128_C) {

-    while (position < contents.GetLength()) {

-      patternIndex = (int32_t)contents.GetAt(position);

-      if (patternIndex >= 32 && patternIndex <= 126 && patternIndex != 34) {

-        position++;

-        continue;

-      } else {

-        ret = FALSE;

-        break;

-      }

-      position++;

-    }

-  } else {

-    ret = FALSE;

-  }

-  return ret;

-}

-CFX_WideString CBC_OnedCode128Writer::FilterContents(

-    const CFX_WideStringC& contents) {

-  CFX_WideString filterChineseChar;

-  FX_WCHAR ch;

-  for (int32_t i = 0; i < contents.GetLength(); i++) {

-    ch = contents.GetAt(i);

-    if (ch > 175) {

-      i++;

-      continue;

-    }

-    filterChineseChar += ch;

-  }

-  CFX_WideString filtercontents;

-  if (m_codeFormat == BC_CODE128_B) {

-    for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {

-      ch = filterChineseChar.GetAt(i);

-      if (ch >= 32 && ch <= 126) {

-        filtercontents += ch;

-      } else {

-        continue;

-      }

-    }

-  } else if (m_codeFormat == BC_CODE128_C) {

-    for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {

-      ch = filterChineseChar.GetAt(i);

-      if (ch >= 32 && ch <= 106) {

-        filtercontents += ch;

-      } else {

-        continue;

-      }

-    }

-  } else {

-    filtercontents = contents;

-  }

-  return filtercontents;

-}

-FX_BOOL CBC_OnedCode128Writer::SetTextLocation(BC_TEXT_LOC location) {

-  if (location < BC_TEXT_LOC_NONE || location > BC_TEXT_LOC_BELOWEMBED) {

-    return FALSE;

-  }

-  m_locTextLoc = location;

-  return TRUE;

-}

-uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,

-                                       BCFORMAT format,

-                                       int32_t& outWidth,

-                                       int32_t& outHeight,

-                                       int32_t hints,

-                                       int32_t& e) {

-  if (format != BCFORMAT_CODE_128) {

-    e = BCExceptionOnlyEncodeCODE_128;

-    return NULL;

-  }

-  uint8_t* ret =

-      CBC_OneDimWriter::Encode(contents, format, outWidth, outHeight, hints, e);

-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);

-  return ret;

-}

-uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,

-                                       BCFORMAT format,

-                                       int32_t& outWidth,

-                                       int32_t& outHeight,

-                                       int32_t& e) {

-  uint8_t* ret = Encode(contents, format, outWidth, outHeight, 0, e);

-  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);

-  return ret;

-}

-FX_BOOL CBC_OnedCode128Writer::IsDigits(const CFX_ByteString& contents,

-                                        int32_t start,

-                                        int32_t length) {

-  int32_t end = start + length;

-  for (int32_t i = start; i < end; i++) {

-    if (contents[i] < '0' || contents[i] > '9') {

-      return FALSE;

-    }

-  }

-  return TRUE;

-}

-uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,

-                                       int32_t& outLength,

-                                       int32_t& e) {

-  if (contents.GetLength() < 1 || contents.GetLength() > 80) {

-    e = BCExceptionContentsLengthShouldBetween1and80;

-    return NULL;

-  }

-  CFX_PtrArray patterns;

-  int32_t checkSum = 0;

-  if (m_codeFormat == BC_CODE128_B) {

-    checkSum = Encode128B(contents, patterns);

-  } else if (m_codeFormat == BC_CODE128_C) {

-    checkSum = Encode128C(contents, patterns);

-  } else {

-    e = BCExceptionFormatException;

-    return NULL;

-  }

-  checkSum %= 103;

-  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[checkSum]);

-  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_STOP]);

-  m_iContentLen = contents.GetLength() + 3;

-  int32_t codeWidth = 0;

-  for (int32_t k = 0; k < patterns.GetSize(); k++) {

-    int32_t* pattern = (int32_t*)patterns[k];

-    for (int32_t j = 0; j < 7; j++) {

-      codeWidth += pattern[j];

-    }

-  }

-  outLength = codeWidth;

-  uint8_t* result = FX_Alloc(uint8_t, outLength);

-  int32_t pos = 0;

-  for (int32_t j = 0; j < patterns.GetSize(); j++) {

-    int32_t* pattern = (int32_t*)patterns[j];

-    pos += AppendPattern(result, pos, pattern, 7, 1, e);

-    if (e != BCExceptionNO) {

-      FX_Free(result);

-      return NULL;

-    }

-  }

-  return result;

-}

-int32_t CBC_OnedCode128Writer::Encode128B(const CFX_ByteString& contents,

-                                          CFX_PtrArray& patterns) {

-  int32_t checkSum = 0;

-  int32_t checkWeight = 1;

-  int32_t position = 0;

-  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_START_B]);

-  checkSum += CODE_START_B * checkWeight;

-  while (position < contents.GetLength()) {

-    int32_t patternIndex = 0;

-    patternIndex = contents[position] - ' ';

-    position += 1;

-    patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);

-    checkSum += patternIndex * checkWeight;

-    if (position != 0) {

-      checkWeight++;

-    }

-  }

-  return checkSum;

-}

-int32_t CBC_OnedCode128Writer::Encode128C(const CFX_ByteString& contents,

-                                          CFX_PtrArray& patterns) {

-  int32_t checkSum = 0;

-  int32_t checkWeight = 1;

-  int32_t position = 0;

-  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_START_C]);

-  checkSum += CODE_START_C * checkWeight;

-  while (position < contents.GetLength()) {

-    int32_t patternIndex = 0;

-    FX_CHAR ch = contents.GetAt(position);

-    if (ch < '0' || ch > '9') {

-      patternIndex = (int32_t)ch;

-      position++;

-    } else {

-      patternIndex = FXSYS_atoi(contents.Mid(position, 2));

-      if (contents.GetAt(position + 1) < '0' ||

-          contents.GetAt(position + 1) > '9') {

-        position += 1;

-      } else {

-        position += 2;

-      }

-    }

-    patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);

-    checkSum += patternIndex * checkWeight;

-    if (position != 0) {

-      checkWeight++;

-    }

-  }

-  return checkSum;

-}

+// 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 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "xfa/src/fxbarcode/barcode.h"
+#include "xfa/src/fxbarcode/BC_Writer.h"
+#include "xfa/src/fxbarcode/BC_Reader.h"
+#include "BC_OneDReader.h"
+#include "BC_OneDimWriter.h"
+#include "BC_OnedCode128Reader.h"
+#include "BC_OnedCode128Writer.h"
+const int32_t CBC_OnedCode128Writer::CODE_CODE_B = 100;
+const int32_t CBC_OnedCode128Writer::CODE_CODE_C = 99;
+const int32_t CBC_OnedCode128Writer::CODE_START_B = 104;
+const int32_t CBC_OnedCode128Writer::CODE_START_C = 105;
+const int32_t CBC_OnedCode128Writer::CODE_STOP = 106;
+CBC_OnedCode128Writer::CBC_OnedCode128Writer() {
+  m_codeFormat = BC_CODE128_B;
+}
+CBC_OnedCode128Writer::CBC_OnedCode128Writer(BC_TYPE type) {
+  m_codeFormat = type;
+}
+CBC_OnedCode128Writer::~CBC_OnedCode128Writer() {}
+BC_TYPE CBC_OnedCode128Writer::GetType() {
+  return m_codeFormat;
+}
+FX_BOOL CBC_OnedCode128Writer::CheckContentValidity(
+    const CFX_WideStringC& contents) {
+  FX_BOOL ret = TRUE;
+  int32_t position = 0;
+  int32_t patternIndex = -1;
+  if (m_codeFormat == BC_CODE128_B || m_codeFormat == BC_CODE128_C) {
+    while (position < contents.GetLength()) {
+      patternIndex = (int32_t)contents.GetAt(position);
+      if (patternIndex >= 32 && patternIndex <= 126 && patternIndex != 34) {
+        position++;
+        continue;
+      } else {
+        ret = FALSE;
+        break;
+      }
+      position++;
+    }
+  } else {
+    ret = FALSE;
+  }
+  return ret;
+}
+CFX_WideString CBC_OnedCode128Writer::FilterContents(
+    const CFX_WideStringC& contents) {
+  CFX_WideString filterChineseChar;
+  FX_WCHAR ch;
+  for (int32_t i = 0; i < contents.GetLength(); i++) {
+    ch = contents.GetAt(i);
+    if (ch > 175) {
+      i++;
+      continue;
+    }
+    filterChineseChar += ch;
+  }
+  CFX_WideString filtercontents;
+  if (m_codeFormat == BC_CODE128_B) {
+    for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {
+      ch = filterChineseChar.GetAt(i);
+      if (ch >= 32 && ch <= 126) {
+        filtercontents += ch;
+      } else {
+        continue;
+      }
+    }
+  } else if (m_codeFormat == BC_CODE128_C) {
+    for (int32_t i = 0; i < filterChineseChar.GetLength(); i++) {
+      ch = filterChineseChar.GetAt(i);
+      if (ch >= 32 && ch <= 106) {
+        filtercontents += ch;
+      } else {
+        continue;
+      }
+    }
+  } else {
+    filtercontents = contents;
+  }
+  return filtercontents;
+}
+FX_BOOL CBC_OnedCode128Writer::SetTextLocation(BC_TEXT_LOC location) {
+  if (location < BC_TEXT_LOC_NONE || location > BC_TEXT_LOC_BELOWEMBED) {
+    return FALSE;
+  }
+  m_locTextLoc = location;
+  return TRUE;
+}
+uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,
+                                       BCFORMAT format,
+                                       int32_t& outWidth,
+                                       int32_t& outHeight,
+                                       int32_t hints,
+                                       int32_t& e) {
+  if (format != BCFORMAT_CODE_128) {
+    e = BCExceptionOnlyEncodeCODE_128;
+    return NULL;
+  }
+  uint8_t* ret =
+      CBC_OneDimWriter::Encode(contents, format, outWidth, outHeight, hints, e);
+  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  return ret;
+}
+uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,
+                                       BCFORMAT format,
+                                       int32_t& outWidth,
+                                       int32_t& outHeight,
+                                       int32_t& e) {
+  uint8_t* ret = Encode(contents, format, outWidth, outHeight, 0, e);
+  BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+  return ret;
+}
+FX_BOOL CBC_OnedCode128Writer::IsDigits(const CFX_ByteString& contents,
+                                        int32_t start,
+                                        int32_t length) {
+  int32_t end = start + length;
+  for (int32_t i = start; i < end; i++) {
+    if (contents[i] < '0' || contents[i] > '9') {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,
+                                       int32_t& outLength,
+                                       int32_t& e) {
+  if (contents.GetLength() < 1 || contents.GetLength() > 80) {
+    e = BCExceptionContentsLengthShouldBetween1and80;
+    return NULL;
+  }
+  CFX_PtrArray patterns;
+  int32_t checkSum = 0;
+  if (m_codeFormat == BC_CODE128_B) {
+    checkSum = Encode128B(contents, patterns);
+  } else if (m_codeFormat == BC_CODE128_C) {
+    checkSum = Encode128C(contents, patterns);
+  } else {
+    e = BCExceptionFormatException;
+    return NULL;
+  }
+  checkSum %= 103;
+  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[checkSum]);
+  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_STOP]);
+  m_iContentLen = contents.GetLength() + 3;
+  int32_t codeWidth = 0;
+  for (int32_t k = 0; k < patterns.GetSize(); k++) {
+    int32_t* pattern = (int32_t*)patterns[k];
+    for (int32_t j = 0; j < 7; j++) {
+      codeWidth += pattern[j];
+    }
+  }
+  outLength = codeWidth;
+  uint8_t* result = FX_Alloc(uint8_t, outLength);
+  int32_t pos = 0;
+  for (int32_t j = 0; j < patterns.GetSize(); j++) {
+    int32_t* pattern = (int32_t*)patterns[j];
+    pos += AppendPattern(result, pos, pattern, 7, 1, e);
+    if (e != BCExceptionNO) {
+      FX_Free(result);
+      return NULL;
+    }
+  }
+  return result;
+}
+int32_t CBC_OnedCode128Writer::Encode128B(const CFX_ByteString& contents,
+                                          CFX_PtrArray& patterns) {
+  int32_t checkSum = 0;
+  int32_t checkWeight = 1;
+  int32_t position = 0;
+  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_START_B]);
+  checkSum += CODE_START_B * checkWeight;
+  while (position < contents.GetLength()) {
+    int32_t patternIndex = 0;
+    patternIndex = contents[position] - ' ';
+    position += 1;
+    patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);
+    checkSum += patternIndex * checkWeight;
+    if (position != 0) {
+      checkWeight++;
+    }
+  }
+  return checkSum;
+}
+int32_t CBC_OnedCode128Writer::Encode128C(const CFX_ByteString& contents,
+                                          CFX_PtrArray& patterns) {
+  int32_t checkSum = 0;
+  int32_t checkWeight = 1;
+  int32_t position = 0;
+  patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_START_C]);
+  checkSum += CODE_START_C * checkWeight;
+  while (position < contents.GetLength()) {
+    int32_t patternIndex = 0;
+    FX_CHAR ch = contents.GetAt(position);
+    if (ch < '0' || ch > '9') {
+      patternIndex = (int32_t)ch;
+      position++;
+    } else {
+      patternIndex = FXSYS_atoi(contents.Mid(position, 2));
+      if (contents.GetAt(position + 1) < '0' ||
+          contents.GetAt(position + 1) > '9') {
+        position += 1;
+      } else {
+        position += 2;
+      }
+    }
+    patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);
+    checkSum += patternIndex * checkWeight;
+    if (position != 0) {
+      checkWeight++;
+    }
+  }
+  return checkSum;
+}