From 90203c9b86ac97a40d574c376cf184f8b60f74d7 Mon Sep 17 00:00:00 2001
From: Michael Davidsaver <mdavidsaver@gmail.com>
Date: Sun, 19 Jul 2020 19:58:17 -0700
Subject: [PATCH] truncate when storing scalar numeric

---
 src/data.cpp      | 38 +++++++++++++++++++++++++++++++++++---
 test/testdata.cpp | 31 ++++++++++++++++++++++++++++++-
 test/testtype.cpp | 28 +++++++++++++++++++++++++++-
 3 files changed, 92 insertions(+), 5 deletions(-)

diff --git a/src/data.cpp b/src/data.cpp
index 5c477d8..4486fdf 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -512,9 +512,41 @@ void Value::copyIn(const void *ptr, StoreType type)
         throw NoField();
 
     switch(store->code) {
-    case StoreType::Real:     if(!copyInScalar(store->as<double>(), ptr, type)) throw NoConvert(); break;
-    case StoreType::Integer:  if(!copyInScalar(store->as<int64_t>(), ptr, type)) throw NoConvert(); break;
-    case StoreType::UInteger: if(!copyInScalar(store->as<uint64_t>(), ptr, type)) throw NoConvert(); break;
+    case StoreType::Real: {
+        if(!copyInScalar(store->as<double>(), ptr, type)) throw NoConvert();
+        // truncate as if assigned to narrower type
+        if(desc->code==TypeCode::Float32)
+            store->as<double>() = float(store->as<double>());
+        break;
+    }
+    case StoreType::Integer: {
+        if(!copyInScalar(store->as<int64_t>(), ptr, type)) throw NoConvert();
+        // truncate as if assigned to narrower type
+        int64_t orig = store->as<int64_t>();
+        switch(desc->code.code) {
+        case TypeCode::Int8: orig = int8_t(orig); break;
+        case TypeCode::Int16: orig = int16_t(orig); break;
+        case TypeCode::Int32: orig = int32_t(orig); break;
+        case TypeCode::Int64: orig = int64_t(orig); break;
+        default: break;
+        }
+        store->as<int64_t>() = orig;
+        break;
+    }
+    case StoreType::UInteger: {
+        if(!copyInScalar(store->as<uint64_t>(), ptr, type)) throw NoConvert();
+        // truncate as if assigned to narrower type
+        int64_t orig = store->as<int64_t>();
+        switch(desc->code.code) {
+        case TypeCode::UInt8: orig = uint8_t(orig); break;
+        case TypeCode::UInt16: orig = uint16_t(orig); break;
+        case TypeCode::UInt32: orig = uint32_t(orig); break;
+        case TypeCode::UInt64: orig = uint64_t(orig); break;
+        default: break;
+        }
+        store->as<int64_t>() = orig;
+        break;
+    }
     case StoreType::Bool: {
         auto& dest = store->as<bool>();
         switch(type) {
diff --git a/test/testdata.cpp b/test/testdata.cpp
index a6ba262..6c8c24d 100644
--- a/test/testdata.cpp
+++ b/test/testdata.cpp
@@ -273,6 +273,26 @@ void testConvertScalar(const Store& store, const Inout& inout)
     testEq(inout, cont.as<Inout>())<<typeid(Store).name()<<"->"<<typeid(Inout).name();
 }
 
+template<typename Store, typename In, typename Out>
+void testConvertScalar2(const Store& store, const In& in, const Out& out)
+{
+    testShow()<<__func__<<"("<<store<<","<<in<<","<<out<<")";
+
+    typedef impl::ScalarMap<Store> store_t;
+
+    auto cont = TypeDef(store_t::code).create();
+
+    try {
+        cont.from(in);
+    }catch(std::exception& e){
+        testCase(false)<<"Error storing as "<<typeid (Store).name()<<" "<<in<<" : "<<e.what();
+    }
+
+    testEq(store, cont.as<Store>())<<typeid(Store).name();
+
+    testEq(out, cont.as<Out>())<<typeid(Store).name()<<"->"<<typeid(Out).name();
+}
+
 void testAssignSimilar()
 {
     testShow()<<__func__;
@@ -342,7 +362,7 @@ void testAssignSimilar()
 
 MAIN(testdata)
 {
-    testPlan(99);
+    testPlan(111);
     testSetup();
     testTraverse();
     testAssign();
@@ -351,6 +371,7 @@ MAIN(testdata)
     testIterStruct();
     testIterUnion();
     testPvRequest();
+
     testConvertScalar<double, bool>(1.0, true);
     testConvertScalar<double, bool>(0.0, false);
     testConvertScalar<double, uint32_t>(5.0, 5);
@@ -365,6 +386,10 @@ MAIN(testdata)
     testConvertScalar<int32_t, int32_t>(-5, -5);
     testConvertScalar<int32_t, double>(-5, -5.0);
     testConvertScalar<int32_t, std::string>(-5, "-5");
+    testConvertScalar<uint32_t, int32_t>(0xffffffff, -1);
+    testConvertScalar<uint32_t, int16_t>(0xffffffff, -1);
+    testConvertScalar<uint16_t, int32_t>(0xffff, 0xffff);
+    testConvertScalar<uint32_t, int32_t>(0x80000000, -2147483648);
     testConvertScalar<std::string, bool>("true", true);
     testConvertScalar<std::string, bool>("false", false);
     testConvertScalar<std::string, uint32_t>("5", 5);
@@ -372,6 +397,10 @@ MAIN(testdata)
     testConvertScalar<std::string, int32_t>("-5", -5);
     testConvertScalar<std::string, double>("-5", -5.0);
     testConvertScalar<std::string, std::string>("-5", "-5");
+
+    testConvertScalar2<int32_t, uint64_t, int64_t>(-2147483648, 0x80000000, -2147483648);
+    testConvertScalar2<int32_t, uint64_t, int64_t>(0, 0x100000000llu, -0);
+
     testAssignSimilar();
     cleanup_for_valgrind();
     return testDone();
diff --git a/test/testtype.cpp b/test/testtype.cpp
index 3db8373..59dc406 100644
--- a/test/testtype.cpp
+++ b/test/testtype.cpp
@@ -28,6 +28,31 @@ void showSize()
 #undef CASE
 }
 
+void testCode()
+{
+    testDiag("%s()", __func__);
+
+    testEq(TypeCode{TypeCode::UInt8}.size(), 1u);
+    testEq(TypeCode{TypeCode::UInt16}.size(), 2u);
+    testEq(TypeCode{TypeCode::UInt32}.size(), 4u);
+    testEq(TypeCode{TypeCode::UInt64}.size(), 8u);
+
+    testEq(TypeCode{TypeCode::UInt8A}.size(), 1u);
+    testEq(TypeCode{TypeCode::UInt16A}.size(), 2u);
+    testEq(TypeCode{TypeCode::UInt32A}.size(), 4u);
+    testEq(TypeCode{TypeCode::UInt64A}.size(), 8u);
+
+    testEq(TypeCode{TypeCode::Int8}.size(), 1u);
+    testEq(TypeCode{TypeCode::Int16}.size(), 2u);
+    testEq(TypeCode{TypeCode::Int32}.size(), 4u);
+    testEq(TypeCode{TypeCode::Int64}.size(), 8u);
+
+    testEq(TypeCode{TypeCode::Int8A}.size(), 1u);
+    testEq(TypeCode{TypeCode::Int16A}.size(), 2u);
+    testEq(TypeCode{TypeCode::Int32A}.size(), 4u);
+    testEq(TypeCode{TypeCode::Int64A}.size(), 8u);
+}
+
 void testBasic()
 {
     testDiag("%s()", __func__);
@@ -460,9 +485,10 @@ void testFormat()
 
 MAIN(testtype)
 {
-    testPlan(29);
+    testPlan(45);
     testSetup();
     showSize();
+    testCode();
     testBasic();
     testTypeDef();
     testTypeDefDynamic();