third_party/v8/src/builtins/string-pad.tq

// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include 'src/builtins/builtins-string-gen.h'

namespace string {

extern transitioning builtin
StringSubstring(implicit context: Context)(String, intptr, intptr): String;

const kStringPadStart: constexpr int31 = 0;
const kStringPadEnd: constexpr int31 = 1;

transitioning macro StringPad(implicit context: Context)(
    receiver: JSAny, arguments: Arguments, methodName: constexpr string,
    variant: constexpr int31): String {
  const receiverString: String = ToThisString(receiver, methodName);
  const stringLength: Smi = receiverString.length_smi;

  if (arguments.length == 0) {
    return receiverString;
  }
  const maxLength: Number = ToLength_Inline(arguments[0]);
  assert(IsNumberNormalized(maxLength));

  typeswitch (maxLength) {
    case (smiMaxLength: Smi): {
      if (smiMaxLength <= stringLength) {
        return receiverString;
      }
    }
    case (Number): {
    }
  }

  let fillString: String = ' ';
  let fillLength: intptr = 1;

  if (arguments.length != 1) {
    const fill = arguments[1];
    if (fill != Undefined) {
      fillString = ToString_Inline(fill);
      fillLength = fillString.length_intptr;
      if (fillLength == 0) {
        return receiverString;
      }
    }
  }

  // Pad.
  assert(fillLength > 0);
  // Throw if max_length is greater than String::kMaxLength.
  if (!TaggedIsSmi(maxLength)) {
    ThrowInvalidStringLength(context);
  }

  const smiMaxLength: Smi = UnsafeCast<Smi>(maxLength);
  if (smiMaxLength > SmiConstant(kStringMaxLength)) {
    ThrowInvalidStringLength(context);
  }
  assert(smiMaxLength > stringLength);
  const padLength: Smi = smiMaxLength - stringLength;

  let padding: String;
  if (fillLength == 1) {
    // Single char fill.
    // Fast path for a single character fill.  No need to calculate number of
    // repetitions or remainder.
    padding = StringRepeat(context, fillString, padLength);
  } else {
    // Multi char fill.
    const fillLengthWord32: int32 = TruncateIntPtrToInt32(fillLength);
    const padLengthWord32: int32 = Convert<int32>(padLength);
    const repetitionsWord32: int32 = padLengthWord32 / fillLengthWord32;
    const remainingWord32: int32 = padLengthWord32 % fillLengthWord32;
    padding =
        StringRepeat(context, fillString, Convert<Smi>(repetitionsWord32));

    if (remainingWord32 != 0) {
      const remainderString =
          StringSubstring(fillString, 0, Convert<intptr>(remainingWord32));
      padding = padding + remainderString;
    }
  }

  // Return result.
  assert(padLength == padding.length_smi);
  if (variant == kStringPadStart) {
    return padding + receiverString;
  }
  assert(variant == kStringPadEnd);
  return receiverString + padding;
}

// ES6 #sec-string.prototype.padstart
transitioning javascript builtin
StringPrototypePadStart(
    js-implicit context: NativeContext, receiver: JSAny)(...arguments): String {
  const methodName: constexpr string = 'String.prototype.padStart';
  return StringPad(receiver, arguments, methodName, kStringPadStart);
}

// ES6 #sec-string.prototype.padend
transitioning javascript builtin
StringPrototypePadEnd(
    js-implicit context: NativeContext, receiver: JSAny)(...arguments): String {
  const methodName: constexpr string = 'String.prototype.padEnd';
  return StringPad(receiver, arguments, methodName, kStringPadEnd);
}
}