#

"""Pseudo-builders for building and registering unit tests."""
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True

            

Reported by Pylint.

              """Pseudo-builders for building and registering unit tests."""
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True



            

Reported by Pylint.

              #

"""Pseudo-builders for building and registering unit tests."""
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True

            

Reported by Pylint.

              
from site_scons.mongo import insort_wrapper

def exists(env):
    return True


def build_cpp_unit_test(env, target, source, **kwargs):
    if not isinstance(target, list):

            

Reported by Pylint.

              
from site_scons.mongo import insort_wrapper

def exists(env):
    return True


def build_cpp_unit_test(env, target, source, **kwargs):
    if not isinstance(target, list):

            

Reported by Pylint.

                  return True


def build_cpp_unit_test(env, target, source, **kwargs):
    if not isinstance(target, list):
        target = [target]

    for t in target:
        if not t.endswith('_test'):

            

Reported by Pylint.

                  if not isinstance(target, list):
        target = [target]

    for t in target:
        if not t.endswith('_test'):
            env.ConfError(f"CppUnitTest target `{t}' does not end in `_test'")

    if not kwargs.get("UNITTEST_HAS_CUSTOM_MAINLINE", False):
        libdeps = kwargs.get("LIBDEPS", env.get("LIBDEPS", [])).copy()

            

Reported by Pylint.

                  return result


def generate(env):
    env.TestList("$UNITTEST_LIST", source=[])
    env.AddMethod(build_cpp_unit_test, "CppUnitTest")
    env.Alias("$UNITTEST_ALIAS", "$UNITTEST_LIST")

            

Reported by Pylint.

              	  }
  }

    sign_ab = ((BID_SINT64)(sign_a ^ sign_b))<<32;
    sign_ab = ((BID_SINT64) sign_ab) >> 63;
    CB = ((BID_UINT64)coefficient_b + sign_ab) ^ sign_ab;

	SU = (BID_UINT64)coefficient_a * bid_power10_table_128[diff_dec_expon].w[0];
	S = SU + CB;

            

Reported by Cppcheck.

                }

    sign_ab = ((BID_SINT64)(sign_a ^ sign_b))<<32;
    sign_ab = ((BID_SINT64) sign_ab) >> 63;
    CB = ((BID_UINT64)coefficient_b + sign_ab) ^ sign_ab;

	SU = (BID_UINT64)coefficient_a * bid_power10_table_128[diff_dec_expon].w[0];
	S = SU + CB;


            

Reported by Cppcheck.

              
      // add a constant to P, depending on rounding mode
      // 0.5*10^(digits_p - 16) for round-to-nearest
      P += bid_round_const_table[rmode][extra_digits];
      __mul_64x64_to_128(Tmp, P, bid_reciprocals10_64[extra_digits]);

      // now get P/10^extra_digits: shift Q_high right by M[extra_digits]-64
      amount = bid_short_recip_scale[extra_digits];
	  Q = Tmp.w[1] >> amount;

            

Reported by Cppcheck.

                    // add a constant to P, depending on rounding mode
      // 0.5*10^(digits_p - 16) for round-to-nearest
      P += bid_round_const_table[rmode][extra_digits];
      __mul_64x64_to_128(Tmp, P, bid_reciprocals10_64[extra_digits]);

      // now get P/10^extra_digits: shift Q_high right by M[extra_digits]-64
      amount = bid_short_recip_scale[extra_digits];
	  Q = Tmp.w[1] >> amount;


            

Reported by Cppcheck.

                    // add a constant to P, depending on rounding mode
      // 0.5*10^(digits_p - 16) for round-to-nearest
      P += bid_round_const_table[rmode][extra_digits];
      __mul_64x64_to_128(Tmp, P, bid_reciprocals10_64[extra_digits]);

      // now get P/10^extra_digits: shift Q_high right by M[extra_digits]-64
      amount = bid_short_recip_scale[extra_digits];
	  Q = Tmp.w[1] >> amount;


            

Reported by Cppcheck.

                    __mul_64x64_to_128(Tmp, P, bid_reciprocals10_64[extra_digits]);

      // now get P/10^extra_digits: shift Q_high right by M[extra_digits]-64
      amount = bid_short_recip_scale[extra_digits];
	  Q = Tmp.w[1] >> amount;

	  // remainder
	  R = P - Q * bid_power10_table_128[extra_digits].w[0];
      if(R==bid_round_const_table[rmode][extra_digits])

            

Reported by Cppcheck.

              	  Q = Tmp.w[1] >> amount;

	  // remainder
	  R = P - Q * bid_power10_table_128[extra_digits].w[0];
      if(R==bid_round_const_table[rmode][extra_digits])
		  status = 0;
	  else status = BID_INEXACT_EXCEPTION;

#ifdef BID_SET_STATUS_FLAGS

            

Reported by Cppcheck.

              
	  // remainder
	  R = P - Q * bid_power10_table_128[extra_digits].w[0];
      if(R==bid_round_const_table[rmode][extra_digits])
		  status = 0;
	  else status = BID_INEXACT_EXCEPTION;

#ifdef BID_SET_STATUS_FLAGS
      __set_status_flags (pfpsf, status);

            

Reported by Cppcheck.

                  __set_status_flags (pfpsf, BID_INVALID_EXCEPTION);
#endif
  res.w[0] = (coefficient_x & 0x000fffff);
  __mul_64x128_low (res, res.w[0], bid_power10_table_128[27]);
  res.w[1] |=
    ((((BID_UINT64) coefficient_x) << 32) & 0xfc00000000000000ull);

  BID_RETURN_NOFLAGS (res);
}

            

Reported by Cppcheck.

                res.w[0] = (coefficient_x & 0x000fffff);
  __mul_64x128_low (res, res.w[0], bid_power10_table_128[27]);
  res.w[1] |=
    ((((BID_UINT64) coefficient_x) << 32) & 0xfc00000000000000ull);

  BID_RETURN_NOFLAGS (res);
}
}


            

Reported by Cppcheck.

              
new_coeff.w[0] = coefficient_x;
new_coeff.w[1] = 0;
bid_get_BID128_very_fast (&res, ((BID_UINT64) sign_x) << 32,
		      exponent_x + DECIMAL_EXPONENT_BIAS_128 -
		      DECIMAL_EXPONENT_BIAS_32, new_coeff);
BID_RETURN_NOFLAGS (res);
}	// convert_bid32_to_bid128


            

Reported by Cppcheck.

                    Tmp.w[1] = (CX.w[1] & 0x00003fffffffffffull);
      Tmp.w[0] = CX.w[0];
      TP128 = bid_reciprocals10_128[27];
      __mul_128x128_full (Qh, Ql, Tmp, TP128);
      amount = bid_recip_scale[27] - 64;
      res = ((CX.w[1] >> 32) & 0xfc000000) | (Qh.w[1] >> amount);
#ifdef BID_SET_STATUS_FLAGS
      if ((x.w[1] & SNAN_MASK64) == SNAN_MASK64)	// sNaN
	__set_status_flags (pfpsf, BID_INVALID_EXCEPTION);

            

Reported by Cppcheck.

                    TP128 = bid_reciprocals10_128[27];
      __mul_128x128_full (Qh, Ql, Tmp, TP128);
      amount = bid_recip_scale[27] - 64;
      res = ((CX.w[1] >> 32) & 0xfc000000) | (Qh.w[1] >> amount);
#ifdef BID_SET_STATUS_FLAGS
      if ((x.w[1] & SNAN_MASK64) == SNAN_MASK64)	// sNaN
	__set_status_flags (pfpsf, BID_INVALID_EXCEPTION);
#endif
      BID_RETURN_VAL (res);

            

Reported by Cppcheck.

                    exponent_x = 0;
    if (exponent_x > DECIMAL_MAX_EXPON_32)
      exponent_x = DECIMAL_MAX_EXPON_32;
    res = (sign_x >> 32) | (exponent_x << 23);
    BID_RETURN_VAL (res);

  }

  if (CX.w[1] || (CX.w[0] >= 10000000)) {

            

Reported by Cppcheck.

                  CX.w[1] = CX.w[1] + T128.w[1] + carry;

    TP128 = bid_reciprocals10_128[extra_digits];
    __mul_128x128_full (Qh, Ql, CX, TP128);
    amount = bid_recip_scale[extra_digits];

    if (amount >= 64) {
      CX.w[0] = Qh.w[1] >> (amount - 64);
      CX.w[1] = 0;

            

Reported by Cppcheck.

                }

  res =
    get_BID32 ((BID_UINT32) (sign_x >> 32),
	       exponent_x - DECIMAL_EXPONENT_BIAS_128 +
	       DECIMAL_EXPONENT_BIAS_32, CX.w[0], rnd_mode, pfpsf);
  BID_RETURN_VAL (res);

}

            

Reported by Cppcheck.

              """
Pseudo-builders for building and registering benchmarks.
"""
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True

            

Reported by Pylint.

              """
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True



            

Reported by Pylint.

              """
Pseudo-builders for building and registering benchmarks.
"""
from SCons.Script import Action

from site_scons.mongo import insort_wrapper

def exists(env):
    return True

            

Reported by Pylint.

              
from site_scons.mongo import insort_wrapper

def exists(env):
    return True


def build_benchmark(env, target, source, **kwargs):


            

Reported by Pylint.

              
from site_scons.mongo import insort_wrapper

def exists(env):
    return True


def build_benchmark(env, target, source, **kwargs):


            

Reported by Pylint.

                  return True


def build_benchmark(env, target, source, **kwargs):

    bmEnv = env.Clone()
    bmEnv.InjectThirdParty(libraries=["benchmark"])

    if bmEnv.TargetOSIs("windows"):

            

Reported by Pylint.

              
def build_benchmark(env, target, source, **kwargs):

    bmEnv = env.Clone()
    bmEnv.InjectThirdParty(libraries=["benchmark"])

    if bmEnv.TargetOSIs("windows"):
        bmEnv.Append(LIBS=["ShLwApi"])


            

Reported by Pylint.

                  return result


def generate(env):
    env.TestList("$BENCHMARK_LIST", source=[])
    env.AddMethod(build_benchmark, "Benchmark")
    env.Alias("$BENCHMARK_ALIAS", "$BENCHMARK_LIST")

            

Reported by Pylint.

                if (exp_x > exp_y) {	// to simplify the loop below,

    // otherwise adjust the x significand upwards
    __mul_64x64_to_128MACH (sig_n_prime, sig_x,
			    bid_mult_factor[exp_x - exp_y]);
    // if postitive, return whichever significand is larger 
    // (converse if negative)
    if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
      res = y;

            

Reported by Cppcheck.

                  BID_RETURN (res);
  }
  // adjust the y significand upwards
  __mul_64x64_to_128MACH (sig_n_prime, sig_y,
			  bid_mult_factor[exp_y - exp_x]);

  // if postitive, return whichever significand is larger (converse if negative)
  if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
    res = y;

            

Reported by Cppcheck.

                // if |exp_x - exp_y| < 15, it comes down to the compensated significand
  if (exp_x > exp_y) {	// to simplify the loop below,
    // otherwise adjust the x significand upwards
    __mul_64x64_to_128MACH (sig_n_prime, sig_x,
			    bid_mult_factor[exp_x - exp_y]);
    // now, sig_n_prime has: sig_x * 10^(exp_x-exp_y), this is 
    // the compensated signif.
    if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
      // two numbers are equal, return minNum(x,y)

            

Reported by Cppcheck.

                  BID_RETURN (res);
  }
  // exp_y must be greater than exp_x, thus adjust the y significand upwards
  __mul_64x64_to_128MACH (sig_n_prime, sig_y,
			  bid_mult_factor[exp_y - exp_x]);

  if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
    res = ((y & MASK_SIGN) == MASK_SIGN) ? y : x;
    // two numbers are equal, return either

            

Reported by Cppcheck.

                // if |exp_x - exp_y| < 15, it comes down to the compensated significand
  if (exp_x > exp_y) {	// to simplify the loop below,
    // otherwise adjust the x significand upwards
    __mul_64x64_to_128MACH (sig_n_prime, sig_x,
			    bid_mult_factor[exp_x - exp_y]);
    // if postitive, return whichever significand is larger 
    // (converse if negative)
    if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
      res = y;

            

Reported by Cppcheck.

                  BID_RETURN (res);
  }
  // adjust the y significand upwards
  __mul_64x64_to_128MACH (sig_n_prime, sig_y,
			  bid_mult_factor[exp_y - exp_x]);

  // if postitive, return whichever significand is larger (converse if negative)
  if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
    res = y;

            

Reported by Cppcheck.

                // if |exp_x - exp_y| < 15, it comes down to the compensated significand
  if (exp_x > exp_y) {	// to simplify the loop below,
    // otherwise adjust the x significand upwards
    __mul_64x64_to_128MACH (sig_n_prime, sig_x,
			    bid_mult_factor[exp_x - exp_y]);
    // now, sig_n_prime has: sig_x * 10^(exp_x-exp_y), 
    // this is the compensated signif.
    if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
      // two numbers are equal, return maxNum(x,y)

            

Reported by Cppcheck.

                  BID_RETURN (res);
  }
  // exp_y must be greater than exp_x, thus adjust the y significand upwards
  __mul_64x64_to_128MACH (sig_n_prime, sig_y,
			  bid_mult_factor[exp_y - exp_x]);

  if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
    res = ((y & MASK_SIGN) == MASK_SIGN) ? x : y;
    // two numbers are equal, return either

            

Reported by Cppcheck.

                  void append(wasm::CallFarJump jmp) {
        enoughMemory_ &= callFarJumps_.append(jmp);
    }
    void append(wasm::MemoryAccess access) {
        enoughMemory_ &= memoryAccesses_.append(access);
    }
    void append(const wasm::MemoryAccessDesc& access, size_t codeOffset, size_t framePushed) {
        if (access.hasTrap()) {
            // If a memory access is trapping (wasm, SIMD.js, Atomics), create a

            

Reported by FlawFinder.

                      enoughMemory_ &= callFarJumps_.append(jmp);
    }
    void append(wasm::MemoryAccess access) {
        enoughMemory_ &= memoryAccesses_.append(access);
    }
    void append(const wasm::MemoryAccessDesc& access, size_t codeOffset, size_t framePushed) {
        if (access.hasTrap()) {
            // If a memory access is trapping (wasm, SIMD.js, Atomics), create a
            // OldTrapSite now which will generate a trap out-of-line path at the end

            

Reported by FlawFinder.

                  void append(wasm::MemoryAccess access) {
        enoughMemory_ &= memoryAccesses_.append(access);
    }
    void append(const wasm::MemoryAccessDesc& access, size_t codeOffset, size_t framePushed) {
        if (access.hasTrap()) {
            // If a memory access is trapping (wasm, SIMD.js, Atomics), create a
            // OldTrapSite now which will generate a trap out-of-line path at the end
            // of the function which will *then* append a MemoryAccess.
            wasm::OldTrapDesc trap(access.trapOffset(), wasm::Trap::OutOfBounds, framePushed,

            

Reported by FlawFinder.

                      enoughMemory_ &= memoryAccesses_.append(access);
    }
    void append(const wasm::MemoryAccessDesc& access, size_t codeOffset, size_t framePushed) {
        if (access.hasTrap()) {
            // If a memory access is trapping (wasm, SIMD.js, Atomics), create a
            // OldTrapSite now which will generate a trap out-of-line path at the end
            // of the function which will *then* append a MemoryAccess.
            wasm::OldTrapDesc trap(access.trapOffset(), wasm::Trap::OutOfBounds, framePushed,
                                   wasm::OldTrapSite::MemoryAccess);

            

Reported by FlawFinder.

                          // If a memory access is trapping (wasm, SIMD.js, Atomics), create a
            // OldTrapSite now which will generate a trap out-of-line path at the end
            // of the function which will *then* append a MemoryAccess.
            wasm::OldTrapDesc trap(access.trapOffset(), wasm::Trap::OutOfBounds, framePushed,
                                   wasm::OldTrapSite::MemoryAccess);
            append(wasm::OldTrapSite(trap, codeOffset));
        } else {
            // Otherwise, this is a plain asm.js access. On WASM_HUGE_MEMORY
            // platforms, asm.js uses signal handlers to remove bounds checks

            

Reported by FlawFinder.

                          // Otherwise, this is a plain asm.js access. On WASM_HUGE_MEMORY
            // platforms, asm.js uses signal handlers to remove bounds checks
            // and thus requires a MemoryAccess.
            MOZ_ASSERT(access.isPlainAsmJS());
#ifdef WASM_HUGE_MEMORY
            append(wasm::MemoryAccess(codeOffset));
#endif
        }
    }

            

Reported by FlawFinder.

              #endif
        }
    }
    void append(wasm::SymbolicAccess access) {
        enoughMemory_ &= symbolicAccesses_.append(access);
    }

    wasm::CallSiteVector& callSites() { return callSites_; }
    wasm::CallSiteTargetVector& callSiteTargets() { return callSiteTargets_; }

            

Reported by FlawFinder.

                      }
    }
    void append(wasm::SymbolicAccess access) {
        enoughMemory_ &= symbolicAccesses_.append(access);
    }

    wasm::CallSiteVector& callSites() { return callSites_; }
    wasm::CallSiteTargetVector& callSiteTargets() { return callSiteTargets_; }
    wasm::TrapSiteVectorArray& trapSites() { return trapSites_; }

            

Reported by FlawFinder.

                      ptrScratch = ToRegister(lir->ptrCopy());
    }

    if (IsUnaligned(mir->access())) {
        masm.wasmUnalignedLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()),
                                  ptrScratch, ToOutRegister64(lir), ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()), ptrScratch,
                         ToOutRegister64(lir));

            

Reported by FlawFinder.

                  }

    if (IsUnaligned(mir->access())) {
        masm.wasmUnalignedLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()),
                                  ptrScratch, ToOutRegister64(lir), ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()), ptrScratch,
                         ToOutRegister64(lir));
    }

            

Reported by FlawFinder.

                      masm.wasmUnalignedLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()),
                                  ptrScratch, ToOutRegister64(lir), ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmLoadI64(mir->access(), HeapReg, ToRegister(lir->ptr()), ptrScratch,
                         ToOutRegister64(lir));
    }
}

void

            

Reported by FlawFinder.

                      ptrScratch = ToRegister(lir->ptrCopy());
    }

    if (IsUnaligned(mir->access())) {
        masm.wasmUnalignedStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                                   ToRegister(lir->ptr()), ptrScratch, ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                          ToRegister(lir->ptr()), ptrScratch);

            

Reported by FlawFinder.

                  }

    if (IsUnaligned(mir->access())) {
        masm.wasmUnalignedStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                                   ToRegister(lir->ptr()), ptrScratch, ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                          ToRegister(lir->ptr()), ptrScratch);
    }

            

Reported by FlawFinder.

                      masm.wasmUnalignedStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                                   ToRegister(lir->ptr()), ptrScratch, ToRegister(lir->getTemp(1)));
    } else {
        masm.wasmStoreI64(mir->access(), ToRegister64(lir->value()), HeapReg,
                          ToRegister(lir->ptr()), ptrScratch);
    }
}

void

            

Reported by FlawFinder.

              {
    Register ptr = ToRegister(lir->ptr());
    Register64 output = ToOutRegister64(lir);
    uint32_t offset = lir->mir()->access().offset();

    BaseIndex addr(HeapReg, ptr, TimesOne, offset);

    masm.atomicLoad64(Synchronization::Full(), addr, Register64::Invalid(), output);
}

            

Reported by FlawFinder.

                  Register ptr = ToRegister(lir->ptr());
    Register64 value = ToRegister64(lir->value());
    Register tmp = ToRegister(lir->tmp());
    uint32_t offset = lir->mir()->access().offset();

    BaseIndex addr(HeapReg, ptr, TimesOne, offset);

    masm.atomicStore64(addr, tmp, value);
}

            

Reported by FlawFinder.

              class ProcessStream {
public:
    ProcessStream(const std::string& cmd) {
        _fp = ::popen(cmd.c_str(), "r");
        uassert(ErrorCodes::OperationFailed,
                str::stream() << "Unable to launch command: " << errnoWithDescription(),
                _fp);
        _fd = fileno(_fp);
    }

            

Reported by FlawFinder.

                          return;
        }

        char buf[kExecBufferSizeBytes];
        DWORD read = 0;
        uassert(ErrorCodes::OperationFailed,
                str::stream() << "Failed reading from subprocess: " << errnoWithDescription(),
                ReadFile(_stdout, buf, std::min<size_t>(sizeof(buf), len), &read, nullptr));


            

Reported by FlawFinder.

                  }

    void read(StringBuilder& sb, size_t len) {
        char buf[kExecBufferSizeBytes];
        len = fread(buf, 1, std::min<size_t>(sizeof(buf), len), _fp);
        sb << StringData(buf, len);
    }

    ~ProcessStream() {

            

Reported by FlawFinder.

                      }
    }

    void read(StringBuilder& sb, size_t len) {
        constexpr DWORD kPipeReadyTimeoutMS = 10;
        if (!_stdout || (WAIT_OBJECT_0 != WaitForSingleObject(_stdout, kPipeReadyTimeoutMS))) {
            return;
        }


            

Reported by FlawFinder.

                      DWORD read = 0;
        uassert(ErrorCodes::OperationFailed,
                str::stream() << "Failed reading from subprocess: " << errnoWithDescription(),
                ReadFile(_stdout, buf, std::min<size_t>(sizeof(buf), len), &read, nullptr));

        if (read == 0) {
            CloseHandle(_stdout);
            _stdout = nullptr;
        } else {

            

Reported by FlawFinder.

                          CloseHandle(_stdout);
            _stdout = nullptr;
        } else {
            sb << StringData(buf, read);
        }
    }

    ~ProcessStream() {
        if (_startup.hStdInput) {

            

Reported by FlawFinder.

                      }
    }

    void read(StringBuilder& sb, size_t len) {
        char buf[kExecBufferSizeBytes];
        len = fread(buf, 1, std::min<size_t>(sizeof(buf), len), _fp);
        sb << StringData(buf, len);
    }


            

Reported by FlawFinder.

                          return status;
        }

        process.read(sb, maxlen - sb.len());
        if (static_cast<size_t>(sb.len()) >= maxlen) {
            // Truncate at maxlen
            break;
        }
    }

            

Reported by FlawFinder.

              # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#

from SCons.Script import Action


def jsToH(env, target, source):
    return env.Command(
        target=target,

            

Reported by Pylint.

                  )


def generate(env, **kw):
    env.AddMethod(jsToH, "JSHeader")


def exists(env):
    return True

            

Reported by Pylint.

                  env.AddMethod(jsToH, "JSHeader")


def exists(env):
    return True

            

Reported by Pylint.

              # Copyright 2020 MongoDB Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:

            

Reported by Pylint.

              from SCons.Script import Action


def jsToH(env, target, source):
    return env.Command(
        target=target,
        source=["#site_scons/site_tools/jstoh.py"] + source,
        action=Action("$PYTHON ${SOURCES[0]} $TARGET ${SOURCES[1:]}"),
    )

            

Reported by Pylint.

              from SCons.Script import Action


def jsToH(env, target, source):
    return env.Command(
        target=target,
        source=["#site_scons/site_tools/jstoh.py"] + source,
        action=Action("$PYTHON ${SOURCES[0]} $TARGET ${SOURCES[1:]}"),
    )

            

Reported by Pylint.

                  )


def generate(env, **kw):
    env.AddMethod(jsToH, "JSHeader")


def exists(env):
    return True

            

Reported by Pylint.

                  env.AddMethod(jsToH, "JSHeader")


def exists(env):
    return True

            

Reported by Pylint.

              };

inline bool
IsUnaligned(const wasm::MemoryAccessDesc& access)
{
    if (!access.align())
        return false;

#ifdef JS_CODEGEN_MIPS32

            

Reported by FlawFinder.

              inline bool
IsUnaligned(const wasm::MemoryAccessDesc& access)
{
    if (!access.align())
        return false;

#ifdef JS_CODEGEN_MIPS32
    if (access.type() == Scalar::Int64 && access.align() >= 4)
        return false;

            

Reported by FlawFinder.

                      return false;

#ifdef JS_CODEGEN_MIPS32
    if (access.type() == Scalar::Int64 && access.align() >= 4)
        return false;
#endif

    return access.align() < access.byteSize();
}

            

Reported by FlawFinder.

                      return false;

#ifdef JS_CODEGEN_MIPS32
    if (access.type() == Scalar::Int64 && access.align() >= 4)
        return false;
#endif

    return access.align() < access.byteSize();
}

            

Reported by FlawFinder.

                      return false;
#endif

    return access.align() < access.byteSize();
}

} // namespace jit
} // namespace js


            

Reported by FlawFinder.

                      return false;
#endif

    return access.align() < access.byteSize();
}

} // namespace jit
} // namespace js


            

Reported by FlawFinder.

                          return;

        for (Slice* cur = head; cur != nullptr; cur = cur->getNext()) {
            memcpy(buffer, &cur->instructions, cur->length());
            buffer += cur->length();
        }
    }

    bool appendRawCode(const uint8_t* code, size_t numBytes) {

            

Reported by FlawFinder.

                  MOZ_COLD void spew(const char* fmt, va_list va) MOZ_FORMAT_PRINTF(2, 0) {
        // Buffer to hold the formatted string. Note that this may contain
        // '%' characters, so do not pass it directly to printf functions.
        char buf[200];

        int i = VsprintfLiteral(buf, fmt, va);
        if (i > -1) {
            if (printer)
                printer->printf("%s\n", buf);

            

Reported by FlawFinder.