Method get_ids_consts_tokens_v2

bytecode/bytecode_base.cpp:194–297

#define CHECK_GDSC_HEADER(p_buffer) _GDRE_CHECK_HEADER(p_buffer, GDSC_HEADER)

Error GDScriptDecomp::get_ids_consts_tokens_v2(const Vector<uint8_t> &p_buffer, Vector<StringName> &identifiers, Vector<Variant> &constants, Vector<uint32_t> &tokens, HashMap<uint32_t, uint32_t> &lines, HashMap<uint32_t, uint32_t> &end_lines, HashMap<uint32_t, uint32_t> &columns) {
	const uint8_t *buf = p_buffer.ptr();
	GDSDECOMP_FAIL_COND_V_MSG(p_buffer.size() < 12 || !CHECK_GDSC_HEADER(p_buffer), ERR_INVALID_DATA, "Invalid GDScript tokenizer buffer.");

	int version = decode_uint32(&buf[4]);
	GDSDECOMP_FAIL_COND_V_MSG(version > LATEST_GDSCRIPT_VERSION, ERR_INVALID_DATA, "Binary GDScript is too recent! Please use a newer engine version.");
	GDSDECOMP_FAIL_COND_V_MSG(version < GDSCRIPT_2_0_VERSION, ERR_INVALID_DATA, "Don't use this function for older versions of GDScript.");

	int decompressed_size = decode_uint32(&buf[8]);

	Vector<uint8_t> contents;
	GDSDECOMP_FAIL_COND_V_MSG(decompress_buf(p_buffer, contents) != decompressed_size, ERR_INVALID_DATA, "Error decompressing GDScript tokenizer buffer.");

	int total_len = contents.size();
	buf = contents.ptr();
	const int token_count_offset = version < CONTENT_HEADER_SIZE_CHANGED ? 16 : 12;
	const int content_header_size = token_count_offset + 4;
	uint32_t identifier_count = decode_uint32(&buf[0]);
	uint32_t constant_count = decode_uint32(&buf[4]);
	uint32_t token_line_count = decode_uint32(&buf[8]);
	uint32_t token_count = decode_uint32(&buf[token_count_offset]);

	const uint8_t *b = &buf[content_header_size];
	total_len -= content_header_size;

	identifiers.resize(identifier_count);
	for (uint32_t i = 0; i < identifier_count; i++) {
		uint32_t len = decode_uint32(b);
		total_len -= 4;
		GDSDECOMP_FAIL_COND_V_MSG((len * 4u) > (uint32_t)total_len, ERR_INVALID_DATA, "Invalid identifier length.");
		b += 4;
		Vector<uint32_t> cs;
		cs.resize(len);
		for (uint32_t j = 0; j < len; j++) {
			uint8_t tmp[4];
			for (uint32_t k = 0; k < 4; k++) {
				tmp[k] = b[j * 4 + k] ^ 0xb6;
			}
			cs.write[j] = decode_uint32(tmp);
		}
		String s = String::utf32({ reinterpret_cast<const char32_t *>(cs.ptr()), len });
		b += len * 4;
		total_len -= len * 4;
		identifiers.write[i] = StringName(s);
	}

	constants.resize(constant_count);
	for (uint32_t i = 0; i < constant_count; i++) {
		Variant v;
		int len;
		Error err = VariantDecoderCompat::decode_variant_compat(get_variant_ver_major(), v, b, total_len, &len);
		if (err) {
			return err;
		}
		b += len;
		total_len -= len;
		constants.write[i] = v;
	}