use line-specific corrections in zlib test

3 files changed, 34 insertions, 10 deletions

diff --git a/src/jsifier.js b/src/jsifier.js
index f3e55a39..73774373 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -769,7 +769,7 @@ function JSify(data, functionsOnly, givenTypes, givenFunctions, givenGlobalVaria
           // TODO: figure out something here along the lines of return '(' + Math.pow(2, 32) + '+((' + value + ')|0))';
         }
       }
-      return op + 'Sign(' + value + ', ' + bits + ')';
+      return op + 'Sign(' + value + ', ' + bits + ', ' + correctSpecificSign() + ')'; // If we are correcting a specific sign here, do not check for it
     } else {
       return value;
     }
@@ -778,7 +778,7 @@ function JSify(data, functionsOnly, givenTypes, givenFunctions, givenGlobalVaria
   function handleOverflow(text, bits) {
     if (!bits) return text;
     if (bits <= 32 && correctOverflows()) text = '(' + text + ')&' + (Math.pow(2, bits) - 1);
-    if (!CHECK_OVERFLOWS) return text;
+    if (!CHECK_OVERFLOWS || correctSpecificOverflow()) return text; // If we are correcting a specific overflow here, do not check for it
     return 'CHECK_OVERFLOW(' + text + ', ' + bits + ')';
   }
 
diff --git a/src/parseTools.js b/src/parseTools.js
index 81831d75..0990eb2f 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -539,11 +539,17 @@ function indentify(text, indent) {
 
 // Correction tools
 
+function correctSpecificSign() {
+  return CORRECT_SIGNS === 2 && Debugging.getIdentifier(Framework.currItem.lineNum) in CORRECT_SIGNS_LINES;
+}
 function correctSigns() {
-  return CORRECT_SIGNS === 1 || (CORRECT_SIGNS === 2 && Debugging.getIdentifier(Framework.currItem.lineNum) in CORRECT_SIGNS_LINES);
+  return CORRECT_SIGNS === 1 || correctSpecificSign();
 }
 
+function correctSpecificOverflow() {
+  return CORRECT_OVERFLOWS === 2 && Debugging.getIdentifier(Framework.currItem.lineNum) in CORRECT_OVERFLOWS_LINES;
+}
 function correctOverflows() {
-  return CORRECT_OVERFLOWS === 1 || (CORRECT_OVERFLOWS === 2 && Debugging.getIdentifier(Framework.currItem.lineNum) in CORRECT_OVERFLOWS_LINES);
+  return CORRECT_OVERFLOWS === 1 || correctSpecificOverflow();
 }
 
diff --git a/src/preamble.js b/src/preamble.js
index a65ffdce..0124e6c3 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -101,13 +101,31 @@ function __Z18UNPROTECT_HEAPADDRPv(dest) {
 //==========================================
 #endif
 
+var CorrectionsMonitor = {
+  MAX_ALLOWED: 0, // Infinity,
+  corrections: 0,
+  sigs: {},
+
+  note: function(type) {
+    var sig = type + '|' + new Error().stack;
+    if (!this.sigs[sig]) {
+      print('Correction: ' + sig);
+      this.sigs[sig] = 0;
+    }
+    this.sigs[sig]++;
+    this.corrections++;
+    if (this.corrections >= this.MAX_ALLOWED) abort('\n\nToo many corrections!');
+  }
+};
+
 #if CHECK_OVERFLOWS
 //========================================
 // Debugging tools - Mathop overflows
 //========================================
 function CHECK_OVERFLOW(value, bits) {
-  assert(value !== Infinity && value !== -Infinity, 'Infinity!');
-  assert(Math.abs(value) < Math.pow(2, bits), 'Overflow!');
+  if (value === Infinity || value === -Infinity || Math.abs(value) >= Math.pow(2, bits)) {
+    CorrectionsMonitor.note('Overflow');
+  }
   return value;
 }
 #endif
@@ -374,10 +392,10 @@ function intArrayToString(array) {
 
 // Converts a value we have as signed, into an unsigned value. For
 // example, -1 in int32 would be a very large number as unsigned.
-function unSign(value, bits) {
+function unSign(value, bits, ignore) {
   if (value >= 0) return value;
 #if CHECK_SIGNS
-  abort('unSign needed, data: ' + [value, bits]);
+  if (!ignore) CorrectionsMonitor.note('UnSign');
 #endif
   return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
                     : Math.pow(2, bits)         + value;
@@ -386,13 +404,13 @@ function unSign(value, bits) {
 
 // Converts a value we have as unsigned, into a signed value. For
 // example, 200 in a uint8 would be a negative number.
-function reSign(value, bits) {
+function reSign(value, bits, ignore) {
   if (value <= 0) return value;
   var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
                         : Math.pow(2, bits-1);
   if (value >= half) {
 #if CHECK_SIGNS
-  abort('reSign needed, data: ' + [value, bits]);
+  if (!ignore) CorrectionsMonitor.note('ReSign');
 #endif
     value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
   }