Check limits when writing fields through python

Note that this code still has little to do with
segy_set_field/segy_set_field_int/segy_set_field_[type] functions, which
partly check for the same restrictions.

Decision about unification/removal of these functions/checks would come
later when we reevaluate how much these functions are needed for
"Appendix D-8. Stanza For Trace Header Layout" functionality
implementation.

Author: achaikou

python/segyio/segyio.cpp

@@ -1744,38 +1744,69 @@ PyObject* putfield( PyObject*, PyObject *args ) {
 
     switch ( fd.datatype ) {
         case SEGY_UNSIGNED_INTEGER_8_BYTE:
-            fd.value.u64 = PyLong_AsUnsignedLongLong(value_arg);
+            {
+                unsigned long long val = PyLong_AsUnsignedLongLong( value_arg );
+                if (PyErr_Occurred() or val > UINT64_MAX) {
+                    return ValueError( "Value out of range for unsigned long" );
+                }
+                fd.value.u64 = val;
+            }
             break;
         case SEGY_UNSIGNED_INTEGER_4_BYTE:
-            fd.value.u32 = PyLong_AsUnsignedLong(value_arg);
+            // currently no fields
+            // fd.value.u32 = PyLong_AsUnsignedLong(value_arg);
             break;
         case SEGY_UNSIGNED_SHORT_2_BYTE:
-            fd.value.u16 = PyLong_AsUnsignedLong(value_arg);
+            {
+                unsigned long val = PyLong_AsUnsignedLong( value_arg );
+                if( PyErr_Occurred() or val > UINT16_MAX ) {
+                    return ValueError( "Value out of range for unsigned short" );
+                }
+                fd.value.u16 = val;
+            }
             break;
         case SEGY_UNSIGNED_CHAR_1_BYTE:
-            fd.value.u8 = PyLong_AsUnsignedLong(value_arg);
+            {
+                unsigned long val = PyLong_AsUnsignedLong( value_arg );
+                if( PyErr_Occurred() or val > UINT8_MAX ) {
+                    return ValueError( "Value out of range for unsigned char" );
+                }
+                fd.value.u8 = val;
+            }
             break;
 
         case SEGY_SIGNED_INTEGER_8_BYTE:
-            fd.value.i64 = PyLong_AsLongLong(value_arg);
+            // currently no fields
+            // fd.value.i64 = PyLong_AsLongLong(value_arg);
             break;
         case SEGY_SIGNED_INTEGER_4_BYTE:
-            fd.value.i32 = PyLong_AsLong(value_arg);
+            {
+                long val = PyLong_AsLong( value_arg );
+                if( PyErr_Occurred() or val > INT32_MAX or val < INT32_MIN ) {
+                    return ValueError( "Value out of range for signed int" );
+                }
+                fd.value.i32 = val;
+            }
             break;
         case SEGY_SIGNED_SHORT_2_BYTE:
-            fd.value.i16 = PyLong_AsLong(value_arg);
-            break;
-        case SEGY_SIGNED_CHAR_1_BYTE:
-            fd.value.i8 = PyLong_AsLong(value_arg);
+            {
+                long val = PyLong_AsLong( value_arg );
+                if( PyErr_Occurred() or val > INT16_MAX or val < INT16_MIN ) {
+                    return ValueError( "Value out of range for signed short" );
+                }
+                fd.value.i16 = val;
+            }
             break;
 
         case SEGY_IEEE_FLOAT_8_BYTE:
-            fd.value.f64 = PyFloat_AsDouble(value_arg);
-            break;
-        case SEGY_IEEE_FLOAT_4_BYTE:
-            fd.value.f32 = PyFloat_AsDouble(value_arg);
-            break;
-
+            {
+                double val = PyFloat_AsDouble( value_arg );
+                if( PyErr_Occurred() ) {
+                    return ValueError( "Value out of range for double" );
+                }
+                fd.value.f64 = val;
+                break;
+            }
         default:
             return KeyError( "Field %d has unknown datatype %d", field, fd.datatype );
     }