Replace value checks with IsInvalidXXX calls.

Author: awulkiew

Visual_Studio_2017/GraphicalDebugging/ExpressionLoader.cs

@@ -637,7 +637,7 @@ MemoryReader.Converter<double> arrayConverter
                 if (byteSize == 0)
                     return null;
                 long byteOffset = ExpressionParser.GetAddressDifference(debugger, name, elemName);
-                if (ExpressionParser.IsInvalidAddressDifference(byteOffset))
+                if (ExpressionParser.IsInvalidOffset(byteSize, byteOffset))
                     return null;
                 return new MemoryReader.StructConverter<double>(byteSize,
                             new MemoryReader.Member<double>(arrayConverter, (int)byteOffset));
@@ -834,16 +834,12 @@ public override MemoryReader.Converter<double> GetMemoryConverter(Loaders loader
                 MemoryReader.Converter<double> pointConverter = pointLoader.GetMemoryConverter(loaders, mreader, debugger, m_min_corner, pointType);
 
                 int size = (new ExpressionParser(debugger)).GetValueSizeof(name);
+                if (ExpressionParser.IsInvalidSize(size))
+                    return null;
+
                 long minDiff = ExpressionParser.GetAddressDifference(debugger, name, m_min_corner);
                 long maxDiff = ExpressionParser.GetAddressDifference(debugger, name, m_max_corner);
-
-                if (size <= 0
-                    || ExpressionParser.IsInvalidAddressDifference(minDiff)
-                    || ExpressionParser.IsInvalidAddressDifference(maxDiff)
-                    || minDiff < 0
-                    || maxDiff < 0
-                    || minDiff >= size
-                    || maxDiff >= size)
+                if (ExpressionParser.IsInvalidOffset(size, minDiff, maxDiff))
                     return null;
 
                 return new MemoryReader.StructConverter<double>(size,

Visual_Studio_2017/GraphicalDebugging/ExpressionLoader_UserDefined.cs

@@ -43,35 +43,33 @@ public override void Initialize(Debugger debugger, string name)
                 exprY.Initialize(debugger, name, type);
 
                 sizeOf = ExpressionParser.GetTypeSizeof(debugger, type);
-                if (sizeOf <= 0)
+                if (ExpressionParser.IsInvalidSize(sizeOf))
+                {
+                    sizeOf = 0;
                     return;
+                }
 
                 string nameX = exprX.GetString(name);
                 string nameY = exprY.GetString(name);
                 typeX = ExpressionParser.GetValueType(debugger, nameX);
                 typeY = ExpressionParser.GetValueType(debugger, nameY);
-                if (typeX == null || typeY == null)
+                if (ExpressionParser.IsInvalidType(typeX, typeY))
                 {
                     sizeOf = 0;
                     return;
                 }
 
                 sizeX = ExpressionParser.GetTypeSizeof(debugger, typeX);
                 sizeY = ExpressionParser.GetTypeSizeof(debugger, typeY);
-                if (sizeX <= 0 || sizeY <= 0)
+                if (ExpressionParser.IsInvalidSize(sizeX, sizeY))
                 {
                     sizeOf = 0;
                     return;
                 }
 
                 offsetX = ExpressionParser.GetAddressDifference(debugger, name, nameX);
                 offsetY = ExpressionParser.GetAddressDifference(debugger, name, nameY);
-                if (ExpressionParser.IsInvalidAddressDifference(offsetX)
-                    || ExpressionParser.IsInvalidAddressDifference(offsetY)
-                    || offsetX < 0
-                    || offsetY < 0
-                    || offsetX > sizeOf
-                    || offsetY > sizeOf)
+                if (ExpressionParser.IsInvalidOffset(sizeOf, offsetX, offsetY))
                     // offsetX + sizeX > sizeOf
                     // offsetY + sizeY > sizeOf
                 {
@@ -145,6 +143,7 @@ protected MemoryReader.Converter<double> GetMemoryConverter(MemoryReader mreader
             string id;
             ClassScopeExpression exprX;
             ClassScopeExpression exprY;
+            // For memory loading:
             string typeX;
             string typeY;
             long offsetX;

Visual_Studio_2017/GraphicalDebugging/ExpressionParser.cs

@@ -157,6 +157,39 @@ public static string GetValueType(Debugger debugger, string valName)
                  : null;
         }
 
+        public static bool IsInvalidType(string type)
+        {
+            return type == null;
+        }
+
+        public static bool IsInvalidType(string type1, string type2)
+        {
+            return type1 == null || type2 == null;
+        }
+
+        public static bool IsInvalidSize(int size)
+        {
+            return size <= 0;
+        }
+
+        public static bool IsInvalidSize(int size1, int size2)
+        {
+            return size1 <= 0 || size2 <= 0;
+        }
+
+        public static bool IsInvalidOffset(long size, long offset)
+        {
+            return ExpressionParser.IsInvalidAddressDifference(offset)
+                || offset < 0
+                || offset >= size;
+        }
+
+        public static bool IsInvalidOffset(long size, long offset1, long offset2)
+        {
+            return IsInvalidOffset(size, offset1)
+                || IsInvalidOffset(size, offset2);
+        }
+
         public ExpressionParser(Debugger debugger)
         {
             string language = debugger.CurrentStackFrame.Language;