MSVC2010 support, enabled -ansi and -pedantic

cpp/SConscript

@@ -1,38 +1,43 @@
 # -*- python -*-
 
 Decider('MD5')
+import platform
 import fnmatch
 import os
 
 vars = Variables()
 vars.Add(BoolVariable('DEBUG', 'Set to disable optimizations', 1))
 vars.Add(BoolVariable('PIC', 'Set to 1 for to always generate PIC code', 0))
 env = Environment(variables = vars)
-# env.Replace(CXX = "clang++") 
+# env.Replace(CXX = 'clang++') 
 
 debug = env['DEBUG']
 compile_options = {}
-flags = []
-if debug:
-	#compile_options['CPPDEFINES'] = "-DDEBUG"
-	flags.append("-O0 -g3 -ggdb -Wall")
+if platform.system() is 'Windows':
+  compile_options['CXXFLAGS'] = '-D_CRT_SECURE_NO_WARNINGS /fp:fast /EHsc'
 else:
-	flags.append("-Os -g3 -Wall")
-if env['PIC']:
-	flags.append("-fPIC")
-
-flags.append("-Wextra -Werror")
-# Can't enable unless we get rid of the dynamic variable length arrays
-# flags.append("-pedantic")
-
-compile_options['CXXFLAGS'] = ' '.join(flags)
-compile_options['LINKFLAGS'] = "-ldl -L/usr/lib -L/opt/local/lib -L/usr/local/lib"
+  cxxflags = []
+  if debug:
+    #compile_options['CPPDEFINES'] = '-DDEBUG'
+    cxxflags.append('-O0 -g3 -ggdb -Wall')
+  else:
+    cxxflags.append('-Os -g3 -Wall')
+  if env['PIC']:
+    cxxflags.append('-fPIC')
+
+  cxxflags.append('-Wextra -Werror')
+
+  # Force ANSI (C++98) to ensure compatibility with MSVC.
+  cxxflags.append('-ansi -pedantic')
+
+  compile_options['CXXFLAGS'] = ' '.join(cxxflags)
+  compile_options['LINKFLAGS'] = '-ldl -L/usr/lib -L/opt/local/lib -L/usr/local/lib'
 
 def all_files(dir, ext='.cpp', level=6):
-	files = []
-	for i in range(1, level):
-		files += Glob(dir + ('/*' * i) + ext) 
-	return files
+  files = []
+  for i in range(1, level):
+    files += Glob(dir + ('/*' * i) + ext) 
+  return files
 
 
 
@@ -50,14 +55,16 @@ for root, dirnames, filenames in os.walk('/usr/lib/'):
       matches.append(os.path.join(root, filename))
 
 if matches:
-	magick_libs.append('iconv')
+  magick_libs.append('iconv')
 
 cppunit_include = ['/opt/local/include/']
 cppunit_libs = ['cppunit']
 
 zxing_files = all_files('core/src')
-
 zxing_include = ['core/src']
+if platform.system() is 'Windows':
+  zxing_files += all_files('win32')
+  zxing_include += ['win32']
 zxing_libs = env.Library('zxing', source=zxing_files, CPPPATH=zxing_include, **compile_options)
 
 app_files = ['magick/src/MagickBitmapSource.cpp', 'magick/src/main.cpp']

cpp/core/src/zxing/DecodeHints.cpp

@@ -21,7 +21,9 @@
 #include <zxing/common/IllegalArgumentException.h>
 namespace zxing {
 
+#if !defined(_WIN32) && !defined(_WIN64)
 const DecodeHintType DecodeHints::CHARACTER_SET;
+#endif
 
 const DecodeHints DecodeHints::PRODUCT_HINT(
     BARCODEFORMAT_UPC_E_HINT |

cpp/core/src/zxing/aztec/AztecDetectorResult.cpp

@@ -28,7 +28,7 @@ namespace zxing {
         compact_(compact),
         nbDatablocks_(nbDatablocks),
         nbLayers_(nbLayers) {
-        };
+        }
 
         bool AztecDetectorResult::isCompact() {
             return compact_;
@@ -42,4 +42,4 @@ namespace zxing {
             return nbLayers_;
         }
     }
-}
+}

cpp/core/src/zxing/aztec/AztecReader.cpp

@@ -28,7 +28,7 @@ namespace zxing {
 
     AztecReader::AztecReader() : decoder_() {
       // nothing
-    };
+    }
 
     Ref<Result> AztecReader::decode(Ref<zxing::BinaryBitmap> image) {
       Detector detector(image->getBlackMatrix());

cpp/core/src/zxing/common/EdgeDetector.cpp

@@ -19,6 +19,7 @@
  */
 
 #include <zxing/common/EdgeDetector.h>
+#include <zxing/common/detector/math_utils.h>
 #include <algorithm>
 #include <cmath>
 

cpp/core/src/zxing/common/detector/math_utils.h

@@ -19,6 +19,15 @@
 
 #include <math.h>
 
+#if defined(_WIN32) || defined(_WIN64)
+#include <float.h>
+#include <limits>
+#define isnan(a) _isnan(a)
+#define fmax max
+#define INFINITY (std::numeric_limits<float>::infinity())
+#define NAN (std::numeric_limits<float>::quiet_NaN())
+#endif
+
 namespace zxing { namespace common { namespace detector { namespace math_utils {
 
 /**
@@ -38,7 +47,7 @@ inline float distance(float aX, float aY, float bX, float bY) {
 inline float distance(int aX, int aY, int bX, int bY) {
   int xDiff = aX - bX;
   int yDiff = aY - bY;
-  return (float) sqrt(xDiff * xDiff + yDiff * yDiff);
+  return (float) sqrt((double)xDiff * xDiff + yDiff * yDiff);
 }
 
 }}}}

cpp/core/src/zxing/common/reedsolomon/GenericGFPoly.cpp

@@ -28,6 +28,8 @@ using zxing::GenericGFPoly;
 using zxing::ArrayRef;
 using zxing::Ref;
 
+namespace zxing {
+
 GenericGFPoly::GenericGFPoly(Ref<GenericGF> field,
                              ArrayRef<int> coefficients)
   :  field_(field) {
@@ -213,3 +215,5 @@ std::vector<Ref<GenericGFPoly> > GenericGFPoly::divide(Ref<GenericGFPoly> other)
   returnValue[1] = remainder;
   return returnValue;
 }
+
+}

cpp/core/src/zxing/oned/ITFReader.cpp

@@ -121,7 +121,7 @@ namespace zxing {
       // interleaved white lines for the second digit.
       // Therefore, need to scan 10 lines and then
       // split these into two arrays
-      int counterDigitPairLen = 10;
+      const int counterDigitPairLen = 10;
       int counterDigitPair[counterDigitPairLen];
       for (int i=0; i<counterDigitPairLen; i++) {
         counterDigitPair[i] = 0;
@@ -291,7 +291,7 @@ namespace zxing {
       // TODO: This is very similar to implementation in UPCEANReader. Consider if they can be
       // merged to a single method.
       int patternLength = patternLen;
-      int counters[patternLength];
+      std::vector<int> counters(patternLength);
       for (int i=0; i<patternLength; i++) {
         counters[i] = 0;
       }
@@ -306,7 +306,7 @@ namespace zxing {
           counters[counterPosition]++;
         } else {
           if (counterPosition == patternLength - 1) {
-            if (patternMatchVariance(counters, patternLength, pattern,
+            if (patternMatchVariance(&counters[0], patternLength, pattern,
                 MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
               int* resultValue = new int[2];
               resultValue[0] = patternStart;
@@ -343,11 +343,11 @@ namespace zxing {
       int bestMatch = -1;
       int max = PATTERNS_LEN;
       for (int i = 0; i < max; i++) {
-        int pattern[countersLen];
+        std::vector<int> pattern(countersLen);
         for(int ind = 0; ind<countersLen; ind++){
           pattern[ind] = PATTERNS[i][ind];
         }
-        unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
+        unsigned int variance = patternMatchVariance(counters, countersLen, &pattern[0],
             MAX_INDIVIDUAL_VARIANCE);
         if (variance < bestVariance) {
           bestVariance = variance;

cpp/core/src/zxing/oned/OneDReader.cpp

@@ -21,6 +21,7 @@
 #include "OneDReader.h"
 #include <zxing/ReaderException.h>
 #include <zxing/oned/OneDResultPoint.h>
+#include <zxing/common/detector/math_utils.h>
 #include <math.h>
 #include <limits.h>
 

cpp/core/src/zxing/oned/UPCEANReader.cpp

@@ -166,7 +166,7 @@ namespace zxing {
     bool UPCEANReader::findGuardPattern(Ref<BitArray> row, int rowOffset, bool whiteFirst,
         const int pattern[], int patternLen, int* start, int* end) {
       int patternLength = patternLen;
-      int counters[patternLength];
+      std::vector<int> counters(patternLength);
       int countersCount = sizeof(counters) / sizeof(int);
       for (int i = 0; i < countersCount; i++) {
         counters[i] = 0;
@@ -189,7 +189,7 @@ namespace zxing {
           counters[counterPosition]++;
         } else {
           if (counterPosition == patternLength - 1) {
-            if (patternMatchVariance(counters, countersCount, pattern,
+            if (patternMatchVariance(&counters[0], countersCount, pattern,
                 MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
               *start = patternStart;
               *end = x;
@@ -231,12 +231,12 @@ namespace zxing {
         case UPC_EAN_PATTERNS_L_PATTERNS:
           max = L_PATTERNS_LEN;
           for (int i = 0; i < max; i++) {
-            int pattern[countersLen];
+            std::vector<int> pattern(countersLen);
             for(int j = 0; j< countersLen; j++){
               pattern[j] = L_PATTERNS[i][j];
             }
 
-            unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
+            unsigned int variance = patternMatchVariance(counters, countersLen, &pattern[0],
                 MAX_INDIVIDUAL_VARIANCE);
             if (variance < bestVariance) {
               bestVariance = variance;
@@ -247,12 +247,12 @@ namespace zxing {
         case UPC_EAN_PATTERNS_L_AND_G_PATTERNS:
           max = L_AND_G_PATTERNS_LEN;
           for (int i = 0; i < max; i++) {
-            int pattern[countersLen];
+            std::vector<int> pattern(countersLen);
             for(int j = 0; j< countersLen; j++){
               pattern[j] = L_AND_G_PATTERNS[i][j];
             }
 
-            unsigned int variance = patternMatchVariance(counters, countersLen, pattern,
+            unsigned int variance = patternMatchVariance(counters, countersLen, &pattern[0],
                 MAX_INDIVIDUAL_VARIANCE);
             if (variance < bestVariance) {
               bestVariance = variance;

cpp/core/src/zxing/qrcode/decoder/Decoder.cpp

@@ -32,6 +32,9 @@ using zxing::qrcode::Decoder;
 using zxing::DecoderResult;
 using zxing::Ref;
 
+namespace zxing {
+namespace qrcode {
+
 Decoder::Decoder() :
   rsDecoder_(GenericGF::QR_CODE_FIELD_256) {
 }
@@ -98,3 +101,5 @@ Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits) {
                                         DecodedBitStreamParser::Hashtable());
 }
 
+}
+}

cpp/core/src/zxing/qrcode/decoder/Mode.cpp

@@ -26,6 +26,7 @@
 #include <sstream>
 
 using zxing::qrcode::Mode;
+using zxing::qrcode::Version;
 using std::ostringstream;
 
 Mode Mode::TERMINATOR(0, 0, 0, 0x00, "TERMINATOR");

cpp/core/src/zxing/qrcode/detector/AlignmentPatternFinder.cpp

@@ -22,6 +22,7 @@
 #include "AlignmentPatternFinder.h"
 #include <zxing/ReaderException.h>
 #include <zxing/common/BitArray.h>
+#include <zxing/common/detector/math_utils.h>
 #include <vector>
 #include <cmath>
 #include <cstdlib>

cpp/core/src/zxing/qrcode/detector/Detector.cpp

@@ -36,7 +36,6 @@ namespace math_utils = zxing::common::detector::math_utils;
 using std::ostringstream;
 using std::min;
 using std::max;
-using std::isnan;
 using zxing::qrcode::Detector;
 using zxing::Ref;
 using zxing::BitMatrix;
@@ -45,6 +44,11 @@ using zxing::DetectorResult;
 using zxing::PerspectiveTransform;
 using zxing::qrcode::AlignmentPattern;
 
+namespace zxing {
+namespace qrcode {
+
+using namespace std;
+
 Detector::Detector(Ref<BitMatrix> image) :
   image_(image) {
 }
@@ -306,3 +310,6 @@ Ref<AlignmentPattern> Detector::findAlignmentInRegion(float overallEstModuleSize
                                          - alignmentAreaLeftX, alignmentAreaBottomY - alignmentAreaTopY, overallEstModuleSize, callback_);
   return alignmentFinder.find();
 }
+
+}
+}

cpp/core/src/zxing/qrcode/detector/FinderPatternFinder.cpp

@@ -20,6 +20,7 @@
  */
 
 #include <zxing/qrcode/detector/FinderPatternFinder.h>
+#include <zxing/common/detector/math_utils.h>
 #include <zxing/ReaderException.h>
 #include <zxing/DecodeHints.h>
 #include <vector>

cpp/win32/iconv.h

@@ -0,0 +1,14 @@
+#ifndef _LIBICONV_H
+#define _LIBICONV_H
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void* iconv_t;
+iconv_t iconv_open(const char *tocode, const char *fromcode);
+int iconv_close(iconv_t cd);
+size_t iconv(iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);
+#ifdef __cplusplus
+}
+#endif
+#endif//_LIBICONV_H