Function ParseScript

src/core_read.cpp:59–194

} // namespace

CScript ParseScript(const std::string &s) {
    CScript result;

    std::vector<std::string> words = SplitString(s, " \t\n");

    size_t push_size = 0, next_push_size = 0;
    size_t script_size = 0;
    // Deal with PUSHDATA1 operation with some more hacks.
    size_t push_data_size = 0;

    for (const auto &w : words) {
        if (w.empty()) {
            // Empty string, ignore. (SplitString doesn't combine multiple
            // separators)
            continue;
        }

        // Update script size.
        script_size = result.size();

        // Make sure we keep track of the size of push operations.
        push_size = next_push_size;
        next_push_size = 0;

        // Decimal numbers
        if (std::all_of(w.begin(), w.end(), ::IsDigit) ||
            (w.front() == '-' && w.size() > 1 &&
             std::all_of(w.begin() + 1, w.end(), ::IsDigit))) {
            // Number
            const auto num{ToIntegral<int64_t>(w)};

            // Limit the range of numbers ParseScript accepts in decimal
            // since numbers outside -0x7FFFFFFFFFFFFFFF...0x7FFFFFFFFFFFFFFF
            // are illegal in scripts.
            // This means, only the int64_t -0x8000000000000000 is illegal.
            if (!num.has_value() ||
                num == std::numeric_limits<int64_t>::min()) {
                throw std::runtime_error(
                    "script parse error: decimal numeric value only allowed in "
                    "the range -0x7FFFFFFFFFFFFFFF...0x7FFFFFFFFFFFFFFF");
            }

            result << num.value();
            goto next;
        }

        // Hex Data
        if (w.substr(0, 2) == "0x" && w.size() > 2) {
            if (!IsHex(std::string(w.begin() + 2, w.end()))) {
                // Should only arrive here for improperly formatted hex values
                throw std::runtime_error("Hex numbers expected to be formatted "
                                         "in full-byte chunks (ex: 0x00 "
                                         "instead of 0x0)");
            }

            // Raw hex data, inserted NOT pushed onto stack:
            std::vector<uint8_t> raw =
                ParseHex(std::string(w.begin() + 2, w.end()));