Move unused makeCopyValues to parseTools_legacy.js (#18679)

Author: sbc100

src/parseTools.js

@@ -399,39 +399,6 @@ function makeSetValue(ptr, pos, value, type, noNeedFirst, ignore, align, sep = '
   return slab + '[' + getHeapOffset(offset, type) + '] = ' + value;
 }
 
-const UNROLL_LOOP_MAX = 8;
-
-function makeCopyValues(dest, src, num, type, modifier, align, sep = ';') {
-  assert(typeof align === 'undefined');
-  function unroll(type, num, jump = 1) {
-    const setValues = range(num).map((i) => makeSetValue(dest, i * jump, makeGetValue(src, i * jump, type), type));
-    return setValues.join(sep);
-  }
-  // If we don't know how to handle this at compile-time, or handling it is best
-  // done in a large amount of code, call memcpy
-  if (!isNumber(num)) num = stripCorrections(num);
-  if (!isNumber(align)) align = stripCorrections(align);
-  if (!isNumber(num) || (parseInt(num) / align >= UNROLL_LOOP_MAX)) {
-    return '(_memcpy(' + dest + ', ' + src + ', ' + num + ')|0)';
-  }
-  num = parseInt(num);
-  // remove corrections, since we will be correcting after we add anyhow,
-  dest = stripCorrections(dest);
-  src = stripCorrections(src);
-  // and in the heap assignment expression
-  const ret = [];
-  [4, 2, 1].forEach((possibleAlign) => {
-    if (num == 0) return;
-    if (align >= possibleAlign) {
-      ret.push(unroll('i' + (possibleAlign * 8), Math.floor(num / possibleAlign), possibleAlign));
-      src = getFastValue(src, '+', Math.floor(num / possibleAlign) * possibleAlign);
-      dest = getFastValue(dest, '+', Math.floor(num / possibleAlign) * possibleAlign);
-      num %= possibleAlign;
-    }
-  });
-  return ret.join(sep);
-}
-
 function makeHEAPView(which, start, end) {
   const size = parseInt(which.replace('U', '').replace('F', '')) / 8;
   const mod = size == 1 ? '' : ('>>' + Math.log2(size));
@@ -590,34 +557,6 @@ function makeThrow(what) {
   return `throw ${what};`;
 }
 
-function stripCorrections(param) {
-  let m;
-  while (true) {
-    if (m = /^\((.*)\)$/.exec(param)) {
-      param = m[1];
-      continue;
-    }
-    if (m = /^\(([$_\w]+)\)&\d+$/.exec(param)) {
-      param = m[1];
-      continue;
-    }
-    if (m = /^\(([$_\w()]+)\)\|0$/.exec(param)) {
-      param = m[1];
-      continue;
-    }
-    if (m = /^\(([$_\w()]+)\)\>>>0$/.exec(param)) {
-      param = m[1];
-      continue;
-    }
-    if (m = /CHECK_OVERFLOW\(([^,)]*),.*/.exec(param)) {
-      param = m[1];
-      continue;
-    }
-    break;
-  }
-  return param;
-}
-
 function charCode(char) {
   return char.charCodeAt(0);
 }

src/parseTools_legacy.js

@@ -23,3 +23,64 @@ function receiveI64ParamAsDouble(name) {
   // 32 bits.
   return `var ${name} = ${name}_high * 0x100000000 + (${name}_low >>> 0);`;
 }
+
+function stripCorrections(param) {
+  let m;
+  while (true) {
+    if (m = /^\((.*)\)$/.exec(param)) {
+      param = m[1];
+      continue;
+    }
+    if (m = /^\(([$_\w]+)\)&\d+$/.exec(param)) {
+      param = m[1];
+      continue;
+    }
+    if (m = /^\(([$_\w()]+)\)\|0$/.exec(param)) {
+      param = m[1];
+      continue;
+    }
+    if (m = /^\(([$_\w()]+)\)\>>>0$/.exec(param)) {
+      param = m[1];
+      continue;
+    }
+    if (m = /CHECK_OVERFLOW\(([^,)]*),.*/.exec(param)) {
+      param = m[1];
+      continue;
+    }
+    break;
+  }
+  return param;
+}
+
+const UNROLL_LOOP_MAX = 8;
+
+function makeCopyValues(dest, src, num, type, modifier, align, sep = ';') {
+  assert(typeof align === 'undefined');
+  function unroll(type, num, jump = 1) {
+    const setValues = range(num).map((i) => makeSetValue(dest, i * jump, makeGetValue(src, i * jump, type), type));
+    return setValues.join(sep);
+  }
+  // If we don't know how to handle this at compile-time, or handling it is best
+  // done in a large amount of code, call memcpy
+  if (!isNumber(num)) num = stripCorrections(num);
+  if (!isNumber(align)) align = stripCorrections(align);
+  if (!isNumber(num) || (parseInt(num) / align >= UNROLL_LOOP_MAX)) {
+    return '(_memcpy(' + dest + ', ' + src + ', ' + num + ')|0)';
+  }
+  num = parseInt(num);
+  // remove corrections, since we will be correcting after we add anyhow,
+  dest = stripCorrections(dest);
+  src = stripCorrections(src);
+  // and in the heap assignment expression
+  const ret = [];
+  [4, 2, 1].forEach((possibleAlign) => {
+    if (num == 0) return;
+    if (align >= possibleAlign) {
+      ret.push(unroll('i' + (possibleAlign * 8), Math.floor(num / possibleAlign), possibleAlign));
+      src = getFastValue(src, '+', Math.floor(num / possibleAlign) * possibleAlign);
+      dest = getFastValue(dest, '+', Math.floor(num / possibleAlign) * possibleAlign);
+      num %= possibleAlign;
+    }
+  });
+  return ret.join(sep);
+}