Move debug over to windows build

closes #250

.decent_ci-Linux.yaml

@@ -38,4 +38,5 @@ compilers:
   - name: custom_check
     commands:
        - ./contrib/check_for_tabs.rb
+       - ./contrib/check_for_todos.rb
 

.decent_ci-MacOS.yaml

@@ -2,8 +2,4 @@ compilers:
   - name: clang
     cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
     build_package_generator: TBZ2
-  - name: clang
-    build_type: Debug
-    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=$COMMIT_SHA
-    skip_packaging: true
 

.decent_ci-Windows.yaml

@@ -17,4 +17,11 @@ compilers:
     version: 12
     architecture: Win64
     cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+  - name: Visual Studio
+    version: 14
+    build_type: Debug
+    architecture: Win64
+    cmake_extra_flags: -DBUILD_SAMPLES:BOOL=ON -DBUILD_PACKAGE:BOOL=ON -DBUILD_TESTING:BOOL=ON -DCOMMIT_SHA=%COMMIT_SHA%
+    compiler_extra_flags: /analyze
+    skip_packaging: true
 

.github/CONTRIBUTING.md

@@ -0,0 +1,41 @@
+# Contributing to ChaiScript
+
+Thank you for contributing!
+
+# Pull Requests
+
+Please follow the existing style in the code you are patching.
+
+ - two space indent
+ - no tabs EVER
+ - match the existing indentation level
+ 
+All ChaiScript commits are run through a large set of builds and analysis on all supported platforms. Those results are posted on the 
+[build dashboard](http://chaiscript.com/ChaiScript-BuildResults/index.html). No PR will be accepted until all tests pass.
+
+The build system has full integration with GitHub and you will be notified automatically if all tests have passed.
+
+# Issues
+
+Please do not post a "chaiscript is too slow", "chaiscript compiles too slowly", or "chaiscript needs more documentation" issue
+without first reading the following notes.
+
+## ChaiScript is Too Slow
+
+We are actively working on constently improving the runtime performance of ChaiScript. With the performance being
+[monitored with each commit](http://chaiscript.com/ChaiScript-BuildResults/performance.html).
+
+If you feel you *must* post an issue about performance, please post a complete example that illustrates the exact case you
+feel should be better optimized.
+
+Any issue request regarding performance without a complete example of the issue experienced will be closed.
+
+## ChaiScript Compiles Too Slowly
+
+This is also something we are actively working on. If you need highly optimized build times, please see [this discussion
+on the discourse site](http://discourse.chaiscript.com/t/slow-build-times/94).
+
+## ChaiScript Needs More Documentation
+
+If you have a question that is not addressed in the [cheatsheet](https://github.com/ChaiScript/ChaiScript/blob/develop/cheatsheet.md) 
+please open an issue so we can get the Cheatsheet updated.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,10 @@
+ * Compiler Used:
+ * Operating System:
+ * Architecture (ARM/x86/32bit/64bit/etc): 
+ 
+
+### Expected Behavior 
+
+### Actual Behavior 
+
+### Minimal Example to Reproduce Behavior

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+Issue this pull request references: #
+
+Changes proposed in this pull request
+
+ -
+ -
+ -
+ 

CMakeLists.txt

@@ -103,7 +103,7 @@ set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/description.txt"
 
 set(CPACK_PACKAGE_VERSION_MAJOR 5)
 set(CPACK_PACKAGE_VERSION_MINOR 8)
-set(CPACK_PACKAGE_VERSION_PATCH 0)
+set(CPACK_PACKAGE_VERSION_PATCH 1)
 
 set(CPACK_PACKAGE_EXECUTABLES "chai;ChaiScript Eval")
 set(CPACK_PACKAGE_VENDOR "ChaiScript.com")
@@ -158,11 +158,14 @@ else()
 endif()
 
 if(MSVC)
-  add_definitions(/W4)
+  add_definitions(/W4 /w14545 /w34242 /w34254 /w34287 /w44263 /w44265 /w44296 /w44311 /w44826 /we4289 /w14546 /w14547 /w14549 /w14555 /w14619 /w14905 /w14906 /w14928)
 
-  # VS2013 doesn't have magic statics
   if (MSVC_VERSION STREQUAL "1800")
+    # VS2013 doesn't have magic statics
     add_definitions(/w44640)
+  else()
+    # enum warnings are too noisy on MSVC2013
+    add_definitions(/w34062)
   endif()
 
   add_definitions(/bigobj)
@@ -175,10 +178,10 @@ if(MSVC)
   # how to workaround or fix the error. So I'm disabling it globally.
   add_definitions(/wd4503)
 else()
-  add_definitions(-Wall -Wextra -Wshadow -Wnon-virtual-dtor -Wold-style-cast -Wcast-align -Wcast-qual -Wunused -Woverloaded-virtual  -pedantic ${CPP11_FLAG})
+  add_definitions(-Wall -Wextra -Wconversion -Wshadow -Wnon-virtual-dtor -Wold-style-cast -Wcast-align -Wcast-qual -Wunused -Woverloaded-virtual  -pedantic ${CPP11_FLAG})
 
   if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-    add_definitions(-Weverything -Wno-c++98-compat-pedantic  -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-sign-conversion -Wno-missing-prototypes -Wno-padded -Wno-missing-noreturn -Wno-exit-time-destructors -Wno-documentation-unknown-command)
+    add_definitions(-Weverything -Wno-c++98-compat-pedantic  -Wno-c++98-compat -Wno-documentation -Wno-switch-enum -Wno-weak-vtables -Wno-missing-prototypes -Wno-padded -Wno-missing-noreturn -Wno-exit-time-destructors -Wno-documentation-unknown-command)
   else()
     add_definitions(-Wnoexcept)
   endif()

contrib/check_for_todos.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'json'
+
+`grep -rPIHni 'todo' src/* include/* samples/*`.lines { |line|
+  if /(?<filename>.+(hpp|cpp|chai)):(?<linenumber>[0-9]+):(?<restofline>.+)/ =~ line 
+    puts(JSON.dump({:line => linenumber, :filename => filename, :tool => "todo_checker", :message => "todo: #{restofline.strip}", :messagetype => "info"}))
+  end
+}
+
+

include/chaiscript/chaiscript_defines.hpp

@@ -93,11 +93,13 @@
 #endif
 
 #include <memory>
+#include <string>
+#include <cmath>
 
 namespace chaiscript {
   static const int version_major = 5;
   static const int version_minor = 8;
-  static const int version_patch = 0;
+  static const int version_patch = 1;
 
   static const char *compiler_version = CHAISCRIPT_COMPILER_VERSION;
   static const char *compiler_name = CHAISCRIPT_COMPILER_NAME;
@@ -113,6 +115,78 @@ namespace chaiscript {
 #endif
   }
 
+  template<typename Iter, typename Distance>
+    Iter advance_copy(Iter iter, Distance distance) {
+      std::advance(iter, static_cast<typename std::iterator_traits<Iter>::difference_type>(distance));
+      return iter;
+    }
+
+
+  template<typename T>
+    auto parse_num(const char *t_str) -> typename std::enable_if<std::is_integral<T>::value, T>::type
+    {
+      T t = 0;
+      for (char c = *t_str; (c = *t_str); ++t_str) {
+        if (c < '0' || c > '9') {
+          return t;
+        }
+        t *= 10;
+        t += c - '0';
+      }
+      return t;
+    }
+
+
+  template<typename T>
+    auto parse_num(const char *t_str) -> typename std::enable_if<!std::is_integral<T>::value, T>::type
+    {
+      T t = 0;
+      T base = 0;
+      T decimal_place = 0;
+      bool exponent = false;
+      bool neg_exponent = false;
+
+      const auto final_value = [](const T val, const T baseval, const bool hasexp, const bool negexp) -> T {
+        if (!hasexp) {
+          return val;
+        } else {
+          return baseval * std::pow(T(10), val*T(negexp?-1:1));
+        }
+      };
+
+      for(; *t_str != '\0'; ++t_str) {
+        char c = *t_str;
+        if (c == '.') {
+          decimal_place = 10;
+        } else if (c == 'e' || c == 'E') {
+          exponent = true;
+          decimal_place = 0;
+          base = t;
+          t = 0;
+        } else if (c == '-' && exponent) {
+          neg_exponent = true;
+        } else if (c == '+' && exponent) {
+          neg_exponent = false;
+        } else if (c < '0' || c > '9') {
+          return final_value(t, base, exponent, neg_exponent);
+        } else if (decimal_place < T(10)) {
+          t *= T(10);
+          t += T(c - '0');
+        } else {
+          t += (T(c - '0') / (T(decimal_place)));
+          decimal_place *= 10;
+        }
+      }
+
+      return final_value(t, base, exponent, neg_exponent);
+    }
+
+  template<typename T>
+    T parse_num(const std::string &t_str)
+    {
+      return parse_num<T>(t_str.c_str());
+    }
+
 }
 #endif
 

include/chaiscript/dispatchkit/bootstrap_stl.hpp

@@ -248,13 +248,17 @@ namespace chaiscript
           m->add(
               fun(
                 [](ContainerType &c, int index) -> typename ContainerType::reference {
-                  return c.at(index);
+                  /// \todo we are prefering to keep the key as 'int' to avoid runtime conversions
+                  /// during dispatch. reevaluate
+                  return c.at(static_cast<typename ContainerType::size_type>(index));
                 }), "[]");
 
           m->add(
               fun(
                 [](const ContainerType &c, int index) -> typename ContainerType::const_reference {
-                  return c.at(index);
+                  /// \todo we are prefering to keep the key as 'int' to avoid runtime conversions
+                  /// during dispatch. reevaluate
+                  return c.at(static_cast<typename ContainerType::size_type>(index));
                 }), "[]");
 
           return m;

include/chaiscript/dispatchkit/boxed_number.hpp

@@ -43,16 +43,19 @@ namespace chaiscript
 // this is OK, so we're disabling size/and sign type warnings
 #ifdef CHAISCRIPT_MSVC
 #pragma warning(push)
-#pragma warning(disable : 4244 4018 4389 4146 4365 4267)
+#pragma warning(disable : 4244 4018 4389 4146 4365 4267 4242)
 #endif
 
 
 #ifdef __GNUC__
 #pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wpragmas"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #pragma GCC diagnostic ignored "-Wconversion"
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wfloat-conversion"
 #endif
 
   /// \brief Represents any numeric type, generically. Used internally for generic operations between POD values

include/chaiscript/dispatchkit/dispatchkit.hpp

@@ -591,14 +591,14 @@ namespace chaiscript
         }
 
         /// Adds a new scope to the stack
-        void new_scope(Stack_Holder &t_holder)
+        static void new_scope(Stack_Holder &t_holder)
         {
           get_stack_data(t_holder).emplace_back();
           t_holder.call_params.emplace_back();
         }
 
         /// Pops the current scope from the stack
-        void pop_scope(Stack_Holder &t_holder)
+        static void pop_scope(Stack_Holder &t_holder)
         {
           t_holder.call_params.pop_back();
           StackData &stack = get_stack_data(t_holder);
@@ -635,7 +635,7 @@ namespace chaiscript
             loc_mask   = 0x0000FFFF
           };
 
-          uint_fast32_t loc = t_loc.load(std::memory_order_relaxed);
+          uint_fast32_t loc = t_loc;
 
           if (loc == 0)
           {
@@ -647,17 +647,16 @@ namespace chaiscript
               for (auto s = stack_elem->begin(); s != stack_elem->end(); ++s )
               {
                 if (s->first == name) {
-                  t_loc.store( static_cast<uint_fast32_t>(std::distance(stack.rbegin(), stack_elem) << 16)
-                             | static_cast<uint_fast32_t>(std::distance(stack_elem->begin(), s))
-                             | static_cast<uint_fast32_t>(Loc::located)
-                             | static_cast<uint_fast32_t>(Loc::is_local),
-                             std::memory_order_relaxed);
+                  t_loc = static_cast<uint_fast32_t>(std::distance(stack.rbegin(), stack_elem) << 16)
+                              | static_cast<uint_fast32_t>(std::distance(stack_elem->begin(), s))
+                              | static_cast<uint_fast32_t>(Loc::located)
+                              | static_cast<uint_fast32_t>(Loc::is_local);
                   return s->second;
                 }
               }
             }
 
-            t_loc.store( static_cast<uint_fast32_t>(Loc::located), std::memory_order_relaxed);
+            t_loc = static_cast<uint_fast32_t>(Loc::located);
           } else if (loc & static_cast<uint_fast32_t>(Loc::is_local)) {
             auto &stack = get_stack_data();
 
@@ -675,7 +674,7 @@ namespace chaiscript
 
           // no? is it a function object?
           auto obj = get_function_object_int(name, loc);
-          if (obj.first != loc) t_loc.store(uint_fast32_t(obj.first), std::memory_order_relaxed);
+          if (obj.first != loc) t_loc = uint_fast32_t(obj.first);
           return obj.second;
 
 
@@ -738,9 +737,9 @@ namespace chaiscript
 
         std::shared_ptr<std::vector<Proxy_Function>> get_method_missing_functions() const
         {
-          uint_fast32_t method_missing_loc = m_method_missing_loc.load(std::memory_order_relaxed);
+          uint_fast32_t method_missing_loc = m_method_missing_loc;
           auto method_missing_funs = get_function("method_missing", method_missing_loc);
-          if (method_missing_funs.first != method_missing_loc) m_method_missing_loc.store(uint_fast32_t(method_missing_funs.first), std::memory_order_relaxed);
+          if (method_missing_funs.first != method_missing_loc) m_method_missing_loc = uint_fast32_t(method_missing_funs.first);
           return std::move(method_missing_funs.second);
         }
 
@@ -911,8 +910,8 @@ namespace chaiscript
           return m_conversions;
         }
 
-        bool is_attribute_call(const std::vector<Proxy_Function> &t_funs, const std::vector<Boxed_Value> &t_params,
-            bool t_has_params, const Type_Conversions_State &t_conversions) const
+        static bool is_attribute_call(const std::vector<Proxy_Function> &t_funs, const std::vector<Boxed_Value> &t_params,
+            bool t_has_params, const Type_Conversions_State &t_conversions)
         {
           if (!t_has_params || t_params.empty()) {
             return false;
@@ -938,9 +937,9 @@ namespace chaiscript
         Boxed_Value call_member(const std::string &t_name, std::atomic_uint_fast32_t &t_loc, const std::vector<Boxed_Value> &params, bool t_has_params,
                                 const Type_Conversions_State &t_conversions)
         {
-          uint_fast32_t loc = t_loc.load(std::memory_order_relaxed);
+          uint_fast32_t loc = t_loc;
           const auto funs = get_function(t_name, loc);
-          if (funs.first != loc) t_loc.store(uint_fast32_t(funs.first), std::memory_order_relaxed);
+          if (funs.first != loc) t_loc = uint_fast32_t(funs.first);
 
           const auto do_attribute_call = 
             [this](int l_num_params, const std::vector<Boxed_Value> &l_params, const std::vector<Proxy_Function> &l_funs, const Type_Conversions_State &l_conversions)->Boxed_Value
@@ -1051,9 +1050,9 @@ namespace chaiscript
         Boxed_Value call_function(const std::string &t_name, std::atomic_uint_fast32_t &t_loc, const std::vector<Boxed_Value> &params,
             const Type_Conversions_State &t_conversions) const
         {
-          uint_fast32_t loc = t_loc.load(std::memory_order_relaxed);
+          uint_fast32_t loc = t_loc;
           const auto funs = get_function(t_name, loc);
-          if (funs.first != loc) t_loc.store(uint_fast32_t(funs.first), std::memory_order_relaxed);
+          if (funs.first != loc) t_loc = uint_fast32_t(funs.first);
           return dispatch::dispatch(*funs.second, params, t_conversions);
         }
 
@@ -1446,7 +1445,7 @@ namespace chaiscript
         static typename Container::const_iterator find_keyed_value(const Container &t_c, const Key &t_key, const size_t t_hint)
           {
             if (t_c.size() > t_hint && t_c[t_hint].first == t_key) {
-              return t_c.begin() + t_hint;
+              return advance_copy(t_c.begin(), t_hint);
             } else {
               return find_keyed_value(t_c, t_key);
             }

include/chaiscript/dispatchkit/type_info.hpp

@@ -32,11 +32,11 @@ namespace chaiscript
       CHAISCRIPT_CONSTEXPR Type_Info(bool t_is_const, bool t_is_reference, bool t_is_pointer, bool t_is_void, 
           bool t_is_arithmetic, const std::type_info *t_ti, const std::type_info *t_bare_ti)
         : m_type_info(t_ti), m_bare_type_info(t_bare_ti),
-          m_flags((t_is_const << is_const_flag)
-                + (t_is_reference << is_reference_flag)
-                + (t_is_pointer << is_pointer_flag)
-                + (t_is_void << is_void_flag)
-                + (t_is_arithmetic << is_arithmetic_flag))
+          m_flags((static_cast<unsigned int>(t_is_const) << is_const_flag)
+                + (static_cast<unsigned int>(t_is_reference) << is_reference_flag)
+                + (static_cast<unsigned int>(t_is_pointer) << is_pointer_flag)
+                + (static_cast<unsigned int>(t_is_void) << is_void_flag)
+                + (static_cast<unsigned int>(t_is_arithmetic) << is_arithmetic_flag))
       {
       }
 

include/chaiscript/language/chaiscript_engine.hpp

@@ -505,10 +505,10 @@ namespace chaiscript
 
         // Let's see if this is a link that we should expand
         std::vector<char> buf(2048);
-        const size_t pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
-        if (pathlen > 0 && pathlen < buf.size())
+        const auto pathlen = readlink(dllpath.c_str(), &buf.front(), buf.size());
+        if (pathlen > 0 && static_cast<size_t>(pathlen) < buf.size())
         {
-          dllpath = std::string(&buf.front(), pathlen);
+          dllpath = std::string(&buf.front(), static_cast<size_t>(pathlen));
         }
 
         m_module_paths.insert(m_module_paths.begin(), dllpath+"/");

include/chaiscript/language/chaiscript_parser.hpp

@@ -147,7 +147,7 @@ namespace chaiscript
         }
 
         size_t remaining() const {
-          return std::distance(m_pos, m_end);
+          return static_cast<size_t>(std::distance(m_pos, m_end));
         }
 
         char operator*() const {
@@ -621,11 +621,11 @@ namespace chaiscript
 
         if (float_)
         {
-          return const_var(std::stof(t_val.substr(0,i)));
+          return const_var(parse_num<float>(t_val.substr(0,i)));
         } else if (long_) {
-          return const_var(std::stold(t_val.substr(0,i)));
+          return const_var(parse_num<long double>(t_val.substr(0,i)));
         } else {
-          return const_var(std::stod(t_val.substr(0,i)));
+          return const_var(parse_num<double>(t_val.substr(0,i)));
         }
       }
 
@@ -2213,8 +2213,8 @@ namespace chaiscript
 
                 switch (m_operators[t_precedence]) {
                   case(AST_Node_Type::Ternary_Cond) :
-                    m_match_stack.erase(m_match_stack.begin() + m_match_stack.size() - 2,
-                        m_match_stack.begin() + m_match_stack.size() - 1);
+                    m_match_stack.erase(advance_copy(m_match_stack.begin(), m_match_stack.size() - 2),
+                                        advance_copy(m_match_stack.begin(), m_match_stack.size() - 1));
                     if (Symbol(":")) {
                       if (!Operator(t_precedence+1)) {
                         throw exception::eval_error("Incomplete "
@@ -2239,7 +2239,8 @@ namespace chaiscript
                   case(AST_Node_Type::Bitwise_Or) :
                   case(AST_Node_Type::Comparison) :
                     assert(m_match_stack.size() > 1);
-                    m_match_stack.erase(m_match_stack.begin() + m_match_stack.size() - 2, m_match_stack.begin() + m_match_stack.size() - 1);
+                    m_match_stack.erase(advance_copy(m_match_stack.begin(), m_match_stack.size() - 2), 
+                                        advance_copy(m_match_stack.begin(), m_match_stack.size() - 1));
                     build_match<eval::Binary_Operator_AST_Node>(prev_stack_top, oper->text);
                     break;
 

include/chaiscript/utility/json.hpp

@@ -212,16 +212,16 @@ class JSON
         }
 
         template <typename T>
-        JSON( T b, typename enable_if<is_same<T,bool>::value>::type* = 0 ) : Internal( b ), Type( Class::Boolean ){}
+        JSON( T b, typename enable_if<is_same<T,bool>::value>::type* = nullptr ) : Internal( b ), Type( Class::Boolean ){}
 
         template <typename T>
-        JSON( T i, typename enable_if<is_integral<T>::value && !is_same<T,bool>::value>::type* = 0 ) : Internal( long(i) ), Type( Class::Integral ){}
+        JSON( T i, typename enable_if<is_integral<T>::value && !is_same<T,bool>::value>::type* = nullptr ) : Internal( long(i) ), Type( Class::Integral ){}
 
         template <typename T>
-        JSON( T f, typename enable_if<is_floating_point<T>::value>::type* = 0 ) : Internal( double(f) ), Type( Class::Floating ){}
+        JSON( T f, typename enable_if<is_floating_point<T>::value>::type* = nullptr ) : Internal( double(f) ), Type( Class::Floating ){}
 
         template <typename T>
-        JSON( T s, typename enable_if<is_convertible<T,string>::value>::type* = 0 ) : Internal( string( s ) ), Type( Class::String ){}
+        JSON( T s, typename enable_if<is_convertible<T,string>::value>::type* = nullptr ) : Internal( string( s ) ), Type( Class::String ){}
 
         JSON( std::nullptr_t ) : Internal(), Type( Class::Null ){}
 
@@ -605,7 +605,7 @@ namespace {
             Number = std::stod( val ) * std::pow( 10, exp );
         else {
             if( !exp_str.empty() )
-                Number = std::stol( val ) * std::pow( 10, exp );
+                Number = static_cast<double>(std::stol( val )) * std::pow( 10, exp );
             else
                 Number = std::stol( val );
         }

releasenotes.md

@@ -1,6 +1,11 @@
 Notes:
 =======
-Current Version: 5.8.0
+Current Version: 5.8.1
+
+### Changes since 5.8.0
+* Fix parsing of floats to be locale independent #250
+* Various warning fixes on various platforms
+
 
 ### Changes since 5.7.1
 * Make all parser iterator operations range checked

samples/fun_call_performance.cpp

@@ -89,24 +89,24 @@ std::vector<std::string> default_search_paths()
   std::vector<char> buf(2048);
   ssize_t size = -1;
 
-  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) > 0)
   {
-    exepath = std::string(&buf.front(), size);
+    exepath = std::string(&buf.front(), static_cast<size_t>(size));
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) > 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) > 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 

src/main.cpp

@@ -88,24 +88,24 @@ std::vector<std::string> default_search_paths()
   std::vector<char> buf(2048);
   ssize_t size = -1;
 
-  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) != -1)
+  if ((size = readlink("/proc/self/exe", &buf.front(), buf.size())) >= 0)
   {
-    exepath = std::string(&buf.front(), size);
+    exepath = std::string(&buf.front(), static_cast<size_t>(size));
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/curproc/file", &buf.front(), buf.size())) >= 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 
   if (exepath.empty())
   {
-    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) != -1)
+    if ((size = readlink("/proc/self/path/a.out", &buf.front(), buf.size())) >= 0)
     {
-      exepath = std::string(&buf.front(), size);
+      exepath = std::string(&buf.front(), static_cast<size_t>(size));
     }
   }
 

unittests/compiled_tests.cpp

@@ -1,33 +1,31 @@
 // All of these are necessary because of catch.hpp. It's OK, they'll be
 // caught in other cpp files if chaiscript causes them
 
-#include <chaiscript/utility/utility.hpp>
-#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
 
-#ifdef CHAISCRIPT_MSVC
+#ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable : 4190 4640 28251 4702 6330)
+#pragma warning(disable : 4062 4242 4640 4702 6330 28251)
 #endif
 
+
 #ifdef __GNUC__
 #pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wparentheses"
 #endif
 
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
-#pragma clang diagnostic ignored "-Wold-style-cast"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wfloat-equal"
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
+
+#include <chaiscript/chaiscript.hpp>
+#include <chaiscript/utility/utility.hpp>
+#include <chaiscript/dispatchkit/bootstrap_stl.hpp>
+
 
 
 
 #define CATCH_CONFIG_MAIN
 
+#include <clocale>
+
 #include "catch.hpp"
 
 // lambda_tests
@@ -933,7 +931,21 @@ TEST_CASE("Map conversions")
   )");
 
   CHECK(c == 42);
+}
 
+
+TEST_CASE("Parse floats with non-posix locale")
+{
+#ifdef CHAISCRIPT_MSVC
+  std::setlocale(LC_ALL, "en-ZA");
+#else
+  std::setlocale(LC_ALL, "en_ZA.utf8");
+#endif
+  chaiscript::ChaiScript chai;
+  const double parsed = chai.eval<double>("print(1.3); 1.3");
+  CHECK(parsed == Approx(1.3));
+  const std::string str = chai.eval<std::string>("to_string(1.3)");
+  CHECK(str == "1.3");
 }
 
 

unittests/multithreaded_test.cpp

@@ -15,7 +15,7 @@ int expected_value(int num_iters)
   return i;
 }
 
-void do_work(chaiscript::ChaiScript &c, int id)
+void do_work(chaiscript::ChaiScript &c, const size_t id)
 {
   try{
     std::stringstream ss;
@@ -67,23 +67,23 @@ int main()
   std::vector<std::shared_ptr<std::thread> > threads;
 
   // Ensure at least two, but say only 7 on an 8 core processor
-  int num_threads = std::max(static_cast<int>(std::thread::hardware_concurrency()) - 1, 2);
+  size_t num_threads = static_cast<size_t>(std::max(static_cast<int>(std::thread::hardware_concurrency()) - 1, 2));
 
   std::cout << "Num threads: " << num_threads << '\n';
 
-  for (int i = 0; i < num_threads; ++i)
+  for (size_t i = 0; i < num_threads; ++i)
   {
     threads.push_back(std::make_shared<std::thread>(do_work, std::ref(chai), i));
   }
 
-  for (int i = 0; i < num_threads; ++i)
+  for (size_t i = 0; i < num_threads; ++i)
   {
     threads[i]->join();
   }
 
 
 
-  for (int i = 0; i < num_threads; ++i)
+  for (size_t i = 0; i < num_threads; ++i)
   {
     std::stringstream ss;
     ss << i;
@@ -92,7 +92,7 @@ int main()
       return EXIT_FAILURE;
     }
 
-    if (chai.eval<int>("getid(" + ss.str() + ")") != i)
+    if (chai.eval<int>("getid(" + ss.str() + ")") != static_cast<int>(i))
     {
       return EXIT_FAILURE;
     }

unittests/type_info_test.cpp

@@ -1,30 +1,22 @@
 // Tests to make sure that the order in which function dispatches occur is correct
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4062 4242 4640 4702 6330 28251)
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+
 #include <chaiscript/chaiscript_defines.hpp>
 #include <chaiscript/dispatchkit/type_info.hpp>
 #include <iostream>
 #include <cstdlib>
 
-#ifdef CHAISCRIPT_MSVC
-#pragma warning(push)
-#pragma warning(disable : 4190 4640 28251 4702 6330)
-#endif
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-#pragma GCC diagnostic ignored "-Wold-style-cast"
-#endif
-
-#ifdef __llvm__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
-#pragma clang diagnostic ignored "-Wold-style-cast"
-#pragma clang diagnostic ignored "-Wexit-time-destructors"
-#pragma clang diagnostic ignored "-Wfloat-equal"
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-