Node.js MongoDB Driver API

Source: node_modules/bson/lib/bson/decimal128.js

  1. 'use strict';
  3. var Long = require('./long');
  5. var PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
  6. var PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
  7. var PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i;
  9. var EXPONENT_MAX = 6111;
  10. var EXPONENT_MIN = -6176;
  11. var EXPONENT_BIAS = 6176;
  12. var MAX_DIGITS = 34;
  14. // Nan value bits as 32 bit values (due to lack of longs)
  15. var NAN_BUFFER = [
  16.   0x7c,
  17.   0x00,
  18.   0x00,
  19.   0x00,
  20.   0x00,
  21.   0x00,
  22.   0x00,
  23.   0x00,
  24.   0x00,
  25.   0x00,
  26.   0x00,
  27.   0x00,
  28.   0x00,
  29.   0x00,
  30.   0x00,
  31.   0x00
  32. ].reverse();
  33. // Infinity value bits 32 bit values (due to lack of longs)
  34. var INF_NEGATIVE_BUFFER = [
  35.   0xf8,
  36.   0x00,
  37.   0x00,
  38.   0x00,
  39.   0x00,
  40.   0x00,
  41.   0x00,
  42.   0x00,
  43.   0x00,
  44.   0x00,
  45.   0x00,
  46.   0x00,
  47.   0x00,
  48.   0x00,
  49.   0x00,
  50.   0x00
  51. ].reverse();
  52. var INF_POSITIVE_BUFFER = [
  53.   0x78,
  54.   0x00,
  55.   0x00,
  56.   0x00,
  57.   0x00,
  58.   0x00,
  59.   0x00,
  60.   0x00,
  61.   0x00,
  62.   0x00,
  63.   0x00,
  64.   0x00,
  65.   0x00,
  66.   0x00,
  67.   0x00,
  68.   0x00
  69. ].reverse();
  71. var EXPONENT_REGEX = /^([-+])?(\d+)?$/;
  73. // Detect if the value is a digit
  74. var isDigit = function(value) {
  75.   return !isNaN(parseInt(value, 10));
  76. };
  78. // Divide two uint128 values
  79. var divideu128 = function(value) {
  80.   var DIVISOR = Long.fromNumber(1000 * 1000 * 1000);
  81.   var _rem = Long.fromNumber(0);
  82.   var i = 0;
  84.   if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {
  85.     return { quotient: value, rem: _rem };
  86.   }
  88.   for (i = 0; i <= 3; i++) {
  89.     // Adjust remainder to match value of next dividend
  90.     _rem = _rem.shiftLeft(32);
  91.     // Add the divided to _rem
  92.     _rem = _rem.add(new Long(value.parts[i], 0));
  93.     value.parts[i] = _rem.div(DIVISOR).low_;
  94.     _rem = _rem.modulo(DIVISOR);
  95.   }
  97.   return { quotient: value, rem: _rem };
  98. };
  100. // Multiply two Long values and return the 128 bit value
  101. var multiply64x2 = function(left, right) {
  102.   if (!left && !right) {
  103.     return { high: Long.fromNumber(0), low: Long.fromNumber(0) };
  104.   }
  106.   var leftHigh = left.shiftRightUnsigned(32);
  107.   var leftLow = new Long(left.getLowBits(), 0);
  108.   var rightHigh = right.shiftRightUnsigned(32);
  109.   var rightLow = new Long(right.getLowBits(), 0);
  111.   var productHigh = leftHigh.multiply(rightHigh);
  112.   var productMid = leftHigh.multiply(rightLow);
  113.   var productMid2 = leftLow.multiply(rightHigh);
  114.   var productLow = leftLow.multiply(rightLow);
  116.   productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
  117.   productMid = new Long(productMid.getLowBits(), 0)
  118.     .add(productMid2)
  119.     .add(productLow.shiftRightUnsigned(32));
  121.   productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
  122.   productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0));
  124.   // Return the 128 bit result
  125.   return { high: productHigh, low: productLow };
  126. };
  128. var lessThan = function(left, right) {
  129.   // Make values unsigned
  130.   var uhleft = left.high_ >>> 0;
  131.   var uhright = right.high_ >>> 0;
  133.   // Compare high bits first
  134.   if (uhleft < uhright) {
  135.     return true;
  136.   } else if (uhleft === uhright) {
  137.     var ulleft = left.low_ >>> 0;
  138.     var ulright = right.low_ >>> 0;
  139.     if (ulleft < ulright) return true;
  140.   }
  142.   return false;
  143. };
  145. // var longtoHex = function(value) {
  146. //   var buffer = new Buffer(8);
  147. //   var index = 0;
  148. //   // Encode the low 64 bits of the decimal
  149. //   // Encode low bits
  150. //   buffer[index++] = value.low_ & 0xff;
  151. //   buffer[index++] = (value.low_ >> 8) & 0xff;
  152. //   buffer[index++] = (value.low_ >> 16) & 0xff;
  153. //   buffer[index++] = (value.low_ >> 24) & 0xff;
  154. //   // Encode high bits
  155. //   buffer[index++] = value.high_ & 0xff;
  156. //   buffer[index++] = (value.high_ >> 8) & 0xff;
  157. //   buffer[index++] = (value.high_ >> 16) & 0xff;
  158. //   buffer[index++] = (value.high_ >> 24) & 0xff;
  159. //   return buffer.reverse().toString('hex');
  160. // };
  162. // var int32toHex = function(value) {
  163. //   var buffer = new Buffer(4);
  164. //   var index = 0;
  165. //   // Encode the low 64 bits of the decimal
  166. //   // Encode low bits
  167. //   buffer[index++] = value & 0xff;
  168. //   buffer[index++] = (value >> 8) & 0xff;
  169. //   buffer[index++] = (value >> 16) & 0xff;
  170. //   buffer[index++] = (value >> 24) & 0xff;
  171. //   return buffer.reverse().toString('hex');
  172. // };
  174. /**
  175.  * A class representation of the BSON Decimal128 type.
  176.  *
  177.  * @class
  178.  * @param {Buffer} bytes a buffer containing the raw Decimal128 bytes.
  179.  * @return {Double}
  180.  */
  181. var Decimal128 = function(bytes) {
  182.   this._bsontype = 'Decimal128';
  183.   this.bytes = bytes;
  184. };
  186. /**
  187.  * Create a Decimal128 instance from a string representation
  188.  *
  189.  * @method
  190.  * @param {string} string a numeric string representation.
  191.  * @return {Decimal128} returns a Decimal128 instance.
  192.  */
  193. Decimal128.fromString = function(string) {
  194.   // Parse state tracking
  195.   var isNegative = false;
  196.   var sawRadix = false;
  197.   var foundNonZero = false;
  199.   // Total number of significant digits (no leading or trailing zero)
  200.   var significantDigits = 0;
  201.   // Total number of significand digits read
  202.   var nDigitsRead = 0;
  203.   // Total number of digits (no leading zeros)
  204.   var nDigits = 0;
  205.   // The number of the digits after radix
  206.   var radixPosition = 0;
  207.   // The index of the first non-zero in *str*
  208.   var firstNonZero = 0;
  210.   // Digits Array
  211.   var digits = [0];
  212.   // The number of digits in digits
  213.   var nDigitsStored = 0;
  214.   // Insertion pointer for digits
  215.   var digitsInsert = 0;
  216.   // The index of the first non-zero digit
  217.   var firstDigit = 0;
  218.   // The index of the last digit
  219.   var lastDigit = 0;
  221.   // Exponent
  222.   var exponent = 0;
  223.   // loop index over array
  224.   var i = 0;
  225.   // The high 17 digits of the significand
  226.   var significandHigh = [0, 0];
  227.   // The low 17 digits of the significand
  228.   var significandLow = [0, 0];
  229.   // The biased exponent
  230.   var biasedExponent = 0;
  232.   // Read index
  233.   var index = 0;
  235.   // Trim the string
  236.   string = string.trim();
  238.   // Naively prevent against REDOS attacks.
  239.   // TODO: implementing a custom parsing for this, or refactoring the regex would yield
  240.   //       further gains.
  241.   if (string.length >= 7000) {
  242.     throw new Error('' + string + ' not a valid Decimal128 string');
  243.   }
  245.   // Results
  246.   var stringMatch = string.match(PARSE_STRING_REGEXP);
  247.   var infMatch = string.match(PARSE_INF_REGEXP);
  248.   var nanMatch = string.match(PARSE_NAN_REGEXP);
  250.   // Validate the string
  251.   if ((!stringMatch && !infMatch && !nanMatch) || string.length === 0) {
  252.     throw new Error('' + string + ' not a valid Decimal128 string');
  253.   }
  255.   // Check if we have an illegal exponent format
  256.   if (stringMatch && stringMatch[4] && stringMatch[2] === undefined) {
  257.     throw new Error('' + string + ' not a valid Decimal128 string');
  258.   }
  260.   // Get the negative or positive sign
  261.   if (string[index] === '+' || string[index] === '-') {
  262.     isNegative = string[index++] === '-';
  263.   }
  265.   // Check if user passed Infinity or NaN
  266.   if (!isDigit(string[index]) && string[index] !== '.') {
  267.     if (string[index] === 'i' || string[index] === 'I') {
  268.       return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
  269.     } else if (string[index] === 'N') {
  270.       return new Decimal128(new Buffer(NAN_BUFFER));
  271.     }
  272.   }
  274.   // Read all the digits
  275.   while (isDigit(string[index]) || string[index] === '.') {
  276.     if (string[index] === '.') {
  277.       if (sawRadix) {
  278.         return new Decimal128(new Buffer(NAN_BUFFER));
  279.       }
  281.       sawRadix = true;
  282.       index = index + 1;
  283.       continue;
  284.     }
  286.     if (nDigitsStored < 34) {
  287.       if (string[index] !== '0' || foundNonZero) {
  288.         if (!foundNonZero) {
  289.           firstNonZero = nDigitsRead;
  290.         }
  292.         foundNonZero = true;
  294.         // Only store 34 digits
  295.         digits[digitsInsert++] = parseInt(string[index], 10);
  296.         nDigitsStored = nDigitsStored + 1;
  297.       }
  298.     }
  300.     if (foundNonZero) {
  301.       nDigits = nDigits + 1;
  302.     }
  304.     if (sawRadix) {
  305.       radixPosition = radixPosition + 1;
  306.     }
  308.     nDigitsRead = nDigitsRead + 1;
  309.     index = index + 1;
  310.   }
  312.   if (sawRadix && !nDigitsRead) {
  313.     throw new Error('' + string + ' not a valid Decimal128 string');
  314.   }
  316.   // Read exponent if exists
  317.   if (string[index] === 'e' || string[index] === 'E') {
  318.     // Read exponent digits
  319.     var match = string.substr(++index).match(EXPONENT_REGEX);
  321.     // No digits read
  322.     if (!match || !match[2]) {
  323.       return new Decimal128(new Buffer(NAN_BUFFER));
  324.     }
  326.     // Get exponent
  327.     exponent = parseInt(match[0], 10);
  329.     // Adjust the index
  330.     index = index + match[0].length;
  331.   }
  333.   // Return not a number
  334.   if (string[index]) {
  335.     return new Decimal128(new Buffer(NAN_BUFFER));
  336.   }
  338.   // Done reading input
  339.   // Find first non-zero digit in digits
  340.   firstDigit = 0;
  342.   if (!nDigitsStored) {
  343.     firstDigit = 0;
  344.     lastDigit = 0;
  345.     digits[0] = 0;
  346.     nDigits = 1;
  347.     nDigitsStored = 1;
  348.     significantDigits = 0;
  349.   } else {
  350.     lastDigit = nDigitsStored - 1;
  351.     significantDigits = nDigits;
  353.     if (exponent !== 0 && significantDigits !== 1) {
  354.       while (string[firstNonZero + significantDigits - 1] === '0') {
  355.         significantDigits = significantDigits - 1;
  356.       }
  357.     }
  358.   }
  360.   // Normalization of exponent
  361.   // Correct exponent based on radix position, and shift significand as needed
  362.   // to represent user input
  364.   // Overflow prevention
  365.   if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {
  366.     exponent = EXPONENT_MIN;
  367.   } else {
  368.     exponent = exponent - radixPosition;
  369.   }
  371.   // Attempt to normalize the exponent
  372.   while (exponent > EXPONENT_MAX) {
  373.     // Shift exponent to significand and decrease
  374.     lastDigit = lastDigit + 1;
  376.     if (lastDigit - firstDigit > MAX_DIGITS) {
  377.       // Check if we have a zero then just hard clamp, otherwise fail
  378.       var digitsString = digits.join('');
  379.       if (digitsString.match(/^0+$/)) {
  380.         exponent = EXPONENT_MAX;
  381.         break;
  382.       } else {
  383.         return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
  384.       }
  385.     }
  387.     exponent = exponent - 1;
  388.   }
  390.   while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
  391.     // Shift last digit
  392.     if (lastDigit === 0) {
  393.       exponent = EXPONENT_MIN;
  394.       significantDigits = 0;
  395.       break;
  396.     }
  398.     if (nDigitsStored < nDigits) {
  399.       // adjust to match digits not stored
  400.       nDigits = nDigits - 1;
  401.     } else {
  402.       // adjust to round
  403.       lastDigit = lastDigit - 1;
  404.     }
  406.     if (exponent < EXPONENT_MAX) {
  407.       exponent = exponent + 1;
  408.     } else {
  409.       // Check if we have a zero then just hard clamp, otherwise fail
  410.       digitsString = digits.join('');
  411.       if (digitsString.match(/^0+$/)) {
  412.         exponent = EXPONENT_MAX;
  413.         break;
  414.       } else {
  415.         return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
  416.       }
  417.     }
  418.   }
  420.   // Round
  421.   // We've normalized the exponent, but might still need to round.
  422.   if (lastDigit - firstDigit + 1 < significantDigits && string[significantDigits] !== '0') {
  423.     var endOfString = nDigitsRead;
  425.     // If we have seen a radix point, 'string' is 1 longer than we have
  426.     // documented with ndigits_read, so inc the position of the first nonzero
  427.     // digit and the position that digits are read to.
  428.     if (sawRadix && exponent === EXPONENT_MIN) {
  429.       firstNonZero = firstNonZero + 1;
  430.       endOfString = endOfString + 1;
  431.     }
  433.     var roundDigit = parseInt(string[firstNonZero + lastDigit + 1], 10);
  434.     var roundBit = 0;
  436.     if (roundDigit >= 5) {
  437.       roundBit = 1;
  439.       if (roundDigit === 5) {
  440.         roundBit = digits[lastDigit] % 2 === 1;
  442.         for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
  443.           if (parseInt(string[i], 10)) {
  444.             roundBit = 1;
  445.             break;
  446.           }
  447.         }
  448.       }
  449.     }
  451.     if (roundBit) {
  452.       var dIdx = lastDigit;
  454.       for (; dIdx >= 0; dIdx--) {
  455.         if (++digits[dIdx] > 9) {
  456.           digits[dIdx] = 0;
  458.           // overflowed most significant digit
  459.           if (dIdx === 0) {
  460.             if (exponent < EXPONENT_MAX) {
  461.               exponent = exponent + 1;
  462.               digits[dIdx] = 1;
  463.             } else {
  464.               return new Decimal128(
  465.                 new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER)
  466.               );
  467.             }
  468.           }
  469.         } else {
  470.           break;
  471.         }
  472.       }
  473.     }
  474.   }
  476.   // Encode significand
  477.   // The high 17 digits of the significand
  478.   significandHigh = Long.fromNumber(0);
  479.   // The low 17 digits of the significand
  480.   significandLow = Long.fromNumber(0);
  482.   // read a zero
  483.   if (significantDigits === 0) {
  484.     significandHigh = Long.fromNumber(0);
  485.     significandLow = Long.fromNumber(0);
  486.   } else if (lastDigit - firstDigit < 17) {
  487.     dIdx = firstDigit;
  488.     significandLow = Long.fromNumber(digits[dIdx++]);
  489.     significandHigh = new Long(0, 0);
  491.     for (; dIdx <= lastDigit; dIdx++) {
  492.       significandLow = significandLow.multiply(Long.fromNumber(10));
  493.       significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
  494.     }
  495.   } else {
  496.     dIdx = firstDigit;
  497.     significandHigh = Long.fromNumber(digits[dIdx++]);
  499.     for (; dIdx <= lastDigit - 17; dIdx++) {
  500.       significandHigh = significandHigh.multiply(Long.fromNumber(10));
  501.       significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx]));
  502.     }
  504.     significandLow = Long.fromNumber(digits[dIdx++]);
  506.     for (; dIdx <= lastDigit; dIdx++) {
  507.       significandLow = significandLow.multiply(Long.fromNumber(10));
  508.       significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
  509.     }
  510.   }
  512.   var significand = multiply64x2(significandHigh, Long.fromString('100000000000000000'));
  514.   significand.low = significand.low.add(significandLow);
  516.   if (lessThan(significand.low, significandLow)) {
  517.     significand.high = significand.high.add(Long.fromNumber(1));
  518.   }
  520.   // Biased exponent
  521.   biasedExponent = exponent + EXPONENT_BIAS;
  522.   var dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) };
  524.   // Encode combination, exponent, and significand.
  525.   if (
  526.     significand.high
  527.       .shiftRightUnsigned(49)
  528.       .and(Long.fromNumber(1))
  529.       .equals(Long.fromNumber)
  530.   ) {
  531.     // Encode '11' into bits 1 to 3
  532.     dec.high = dec.high.or(Long.fromNumber(0x3).shiftLeft(61));
  533.     dec.high = dec.high.or(
  534.       Long.fromNumber(biasedExponent).and(Long.fromNumber(0x3fff).shiftLeft(47))
  535.     );
  536.     dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x7fffffffffff)));
  537.   } else {
  538.     dec.high = dec.high.or(Long.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));
  539.     dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x1ffffffffffff)));
  540.   }
  542.   dec.low = significand.low;
  544.   // Encode sign
  545.   if (isNegative) {
  546.     dec.high = dec.high.or(Long.fromString('9223372036854775808'));
  547.   }
  549.   // Encode into a buffer
  550.   var buffer = new Buffer(16);
  551.   index = 0;
  553.   // Encode the low 64 bits of the decimal
  554.   // Encode low bits
  555.   buffer[index++] = dec.low.low_ & 0xff;
  556.   buffer[index++] = (dec.low.low_ >> 8) & 0xff;
  557.   buffer[index++] = (dec.low.low_ >> 16) & 0xff;
  558.   buffer[index++] = (dec.low.low_ >> 24) & 0xff;
  559.   // Encode high bits
  560.   buffer[index++] = dec.low.high_ & 0xff;
  561.   buffer[index++] = (dec.low.high_ >> 8) & 0xff;
  562.   buffer[index++] = (dec.low.high_ >> 16) & 0xff;
  563.   buffer[index++] = (dec.low.high_ >> 24) & 0xff;
  565.   // Encode the high 64 bits of the decimal
  566.   // Encode low bits
  567.   buffer[index++] = dec.high.low_ & 0xff;
  568.   buffer[index++] = (dec.high.low_ >> 8) & 0xff;
  569.   buffer[index++] = (dec.high.low_ >> 16) & 0xff;
  570.   buffer[index++] = (dec.high.low_ >> 24) & 0xff;
  571.   // Encode high bits
  572.   buffer[index++] = dec.high.high_ & 0xff;
  573.   buffer[index++] = (dec.high.high_ >> 8) & 0xff;
  574.   buffer[index++] = (dec.high.high_ >> 16) & 0xff;
  575.   buffer[index++] = (dec.high.high_ >> 24) & 0xff;
  577.   // Return the new Decimal128
  578.   return new Decimal128(buffer);
  579. };
  581. // Extract least significant 5 bits
  582. var COMBINATION_MASK = 0x1f;
  583. // Extract least significant 14 bits
  584. var EXPONENT_MASK = 0x3fff;
  585. // Value of combination field for Inf
  586. var COMBINATION_INFINITY = 30;
  587. // Value of combination field for NaN
  588. var COMBINATION_NAN = 31;
  589. // Value of combination field for NaN
  590. // var COMBINATION_SNAN = 32;
  591. // decimal128 exponent bias
  592. EXPONENT_BIAS = 6176;
  594. /**
  595.  * Create a string representation of the raw Decimal128 value
  596.  *
  597.  * @method
  598.  * @return {string} returns a Decimal128 string representation.
  599.  */
  600. Decimal128.prototype.toString = function() {
  601.   // Note: bits in this routine are referred to starting at 0,
  602.   // from the sign bit, towards the coefficient.
  604.   // bits 0 - 31
  605.   var high;
  606.   // bits 32 - 63
  607.   var midh;
  608.   // bits 64 - 95
  609.   var midl;
  610.   // bits 96 - 127
  611.   var low;
  612.   // bits 1 - 5
  613.   var combination;
  614.   // decoded biased exponent (14 bits)
  615.   var biased_exponent;
  616.   // the number of significand digits
  617.   var significand_digits = 0;
  618.   // the base-10 digits in the significand
  619.   var significand = new Array(36);
  620.   for (var i = 0; i < significand.length; i++) significand[i] = 0;
  621.   // read pointer into significand
  622.   var index = 0;
  624.   // unbiased exponent
  625.   var exponent;
  626.   // the exponent if scientific notation is used
  627.   var scientific_exponent;
  629.   // true if the number is zero
  630.   var is_zero = false;
  632.   // the most signifcant significand bits (50-46)
  633.   var significand_msb;
  634.   // temporary storage for significand decoding
  635.   var significand128 = { parts: new Array(4) };
  636.   // indexing variables
  637.   i;
  638.   var j, k;
  640.   // Output string
  641.   var string = [];
  643.   // Unpack index
  644.   index = 0;
  646.   // Buffer reference
  647.   var buffer = this.bytes;
  649.   // Unpack the low 64bits into a long
  650.   low =
  651.     buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
  652.   midl =
  653.     buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
  655.   // Unpack the high 64bits into a long
  656.   midh =
  657.     buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
  658.   high =
  659.     buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
  661.   // Unpack index
  662.   index = 0;
  664.   // Create the state of the decimal
  665.   var dec = {
  666.     low: new Long(low, midl),
  667.     high: new Long(midh, high)
  668.   };
  670.   if (dec.high.lessThan(Long.ZERO)) {
  671.     string.push('-');
  672.   }
  674.   // Decode combination field and exponent
  675.   combination = (high >> 26) & COMBINATION_MASK;
  677.   if (combination >> 3 === 3) {
  678.     // Check for 'special' values
  679.     if (combination === COMBINATION_INFINITY) {
  680.       return string.join('') + 'Infinity';
  681.     } else if (combination === COMBINATION_NAN) {
  682.       return 'NaN';
  683.     } else {
  684.       biased_exponent = (high >> 15) & EXPONENT_MASK;
  685.       significand_msb = 0x08 + ((high >> 14) & 0x01);
  686.     }
  687.   } else {
  688.     significand_msb = (high >> 14) & 0x07;
  689.     biased_exponent = (high >> 17) & EXPONENT_MASK;
  690.   }
  692.   exponent = biased_exponent - EXPONENT_BIAS;
  694.   // Create string of significand digits
  696.   // Convert the 114-bit binary number represented by
  697.   // (significand_high, significand_low) to at most 34 decimal
  698.   // digits through modulo and division.
  699.   significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);
  700.   significand128.parts[1] = midh;
  701.   significand128.parts[2] = midl;
  702.   significand128.parts[3] = low;
  704.   if (
  705.     significand128.parts[0] === 0 &&
  706.     significand128.parts[1] === 0 &&
  707.     significand128.parts[2] === 0 &&
  708.     significand128.parts[3] === 0
  709.   ) {
  710.     is_zero = true;
  711.   } else {
  712.     for (k = 3; k >= 0; k--) {
  713.       var least_digits = 0;
  714.       // Peform the divide
  715.       var result = divideu128(significand128);
  716.       significand128 = result.quotient;
  717.       least_digits = result.rem.low_;
  719.       // We now have the 9 least significant digits (in base 2).
  720.       // Convert and output to string.
  721.       if (!least_digits) continue;
  723.       for (j = 8; j >= 0; j--) {
  724.         // significand[k * 9 + j] = Math.round(least_digits % 10);
  725.         significand[k * 9 + j] = least_digits % 10;
  726.         // least_digits = Math.round(least_digits / 10);
  727.         least_digits = Math.floor(least_digits / 10);
  728.       }
  729.     }
  730.   }
  732.   // Output format options:
  733.   // Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd
  734.   // Regular    - ddd.ddd
  736.   if (is_zero) {
  737.     significand_digits = 1;
  738.     significand[index] = 0;
  739.   } else {
  740.     significand_digits = 36;
  741.     i = 0;
  743.     while (!significand[index]) {
  744.       i++;
  745.       significand_digits = significand_digits - 1;
  746.       index = index + 1;
  747.     }
  748.   }
  750.   scientific_exponent = significand_digits - 1 + exponent;
  752.   // The scientific exponent checks are dictated by the string conversion
  753.   // specification and are somewhat arbitrary cutoffs.
  754.   //
  755.   // We must check exponent > 0, because if this is the case, the number
  756.   // has trailing zeros.  However, we *cannot* output these trailing zeros,
  757.   // because doing so would change the precision of the value, and would
  758.   // change stored data if the string converted number is round tripped.
  760.   if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {
  761.     // Scientific format
  762.     string.push(significand[index++]);
  763.     significand_digits = significand_digits - 1;
  765.     if (significand_digits) {
  766.       string.push('.');
  767.     }
  769.     for (i = 0; i < significand_digits; i++) {
  770.       string.push(significand[index++]);
  771.     }
  773.     // Exponent
  774.     string.push('E');
  775.     if (scientific_exponent > 0) {
  776.       string.push('+' + scientific_exponent);
  777.     } else {
  778.       string.push(scientific_exponent);
  779.     }
  780.   } else {
  781.     // Regular format with no decimal place
  782.     if (exponent >= 0) {
  783.       for (i = 0; i < significand_digits; i++) {
  784.         string.push(significand[index++]);
  785.       }
  786.     } else {
  787.       var radix_position = significand_digits + exponent;
  789.       // non-zero digits before radix
  790.       if (radix_position > 0) {
  791.         for (i = 0; i < radix_position; i++) {
  792.           string.push(significand[index++]);
  793.         }
  794.       } else {
  795.         string.push('0');
  796.       }
  798.       string.push('.');
  799.       // add leading zeros after radix
  800.       while (radix_position++ < 0) {
  801.         string.push('0');
  802.       }
  804.       for (i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {
  805.         string.push(significand[index++]);
  806.       }
  807.     }
  808.   }
  810.   return string.join('');
  811. };
  813. Decimal128.prototype.toJSON = function() {
  814.   return { $numberDecimal: this.toString() };
  815. };
  817. module.exports = Decimal128;
  818. module.exports.Decimal128 = Decimal128;