Skip to content

Commit a4b17e7

Browse files
bruvzgbruvzg
committedNov 29, 2024
[FileAccess] Return error codes from store_* methods.
1 parent 56a7dba commit a4b17e7

30 files changed

+277
-136
lines changed
 

‎core/io/file_access.compat.inc

+72-1
Original file line numberDiff line numberDiff line change
@@ -34,8 +34,79 @@ Ref<FileAccess> FileAccess::_open_encrypted_bind_compat_98918(const String &p_pa
3434
return open_encrypted(p_path, p_mode_flags, p_key, Vector<uint8_t>());
3535
}
3636

37+
void FileAccess::store_8_bind_compat_78289(uint8_t p_dest) {
38+
store_8(p_dest);
39+
}
40+
41+
void FileAccess::store_16_bind_compat_78289(uint16_t p_dest) {
42+
store_16(p_dest);
43+
}
44+
45+
void FileAccess::store_32_bind_compat_78289(uint32_t p_dest) {
46+
store_32(p_dest);
47+
}
48+
49+
void FileAccess::store_64_bind_compat_78289(uint64_t p_dest) {
50+
store_64(p_dest);
51+
}
52+
53+
void FileAccess::store_buffer_bind_compat_78289(const Vector<uint8_t> &p_buffer) {
54+
store_buffer(p_buffer);
55+
}
56+
57+
void FileAccess::store_var_bind_compat_78289(const Variant &p_var, bool p_full_objects) {
58+
store_var(p_var, p_full_objects);
59+
}
60+
61+
void FileAccess::store_half_bind_compat_78289(float p_dest) {
62+
store_half(p_dest);
63+
}
64+
65+
void FileAccess::store_float_bind_compat_78289(float p_dest) {
66+
store_float(p_dest);
67+
}
68+
69+
void FileAccess::store_double_bind_compat_78289(double p_dest) {
70+
store_double(p_dest);
71+
}
72+
73+
void FileAccess::store_real_bind_compat_78289(real_t p_real) {
74+
store_real(p_real);
75+
}
76+
77+
void FileAccess::store_string_bind_compat_78289(const String &p_string) {
78+
store_string(p_string);
79+
}
80+
81+
void FileAccess::store_line_bind_compat_78289(const String &p_line) {
82+
store_line(p_line);
83+
}
84+
85+
void FileAccess::store_csv_line_bind_compat_78289(const Vector<String> &p_values, const String &p_delim) {
86+
store_csv_line(p_values, p_delim);
87+
}
88+
89+
void FileAccess::store_pascal_string_bind_compat_78289(const String &p_string) {
90+
store_pascal_string(p_string);
91+
}
92+
3793
void FileAccess::_bind_compatibility_methods() {
3894
ClassDB::bind_compatibility_static_method("FileAccess", D_METHOD("open_encrypted", "path", "mode_flags", "key"), &FileAccess::_open_encrypted_bind_compat_98918);
95+
96+
ClassDB::bind_compatibility_method(D_METHOD("store_8", "value"), &FileAccess::store_8_bind_compat_78289);
97+
ClassDB::bind_compatibility_method(D_METHOD("store_16", "value"), &FileAccess::store_16_bind_compat_78289);
98+
ClassDB::bind_compatibility_method(D_METHOD("store_32", "value"), &FileAccess::store_32_bind_compat_78289);
99+
ClassDB::bind_compatibility_method(D_METHOD("store_64", "value"), &FileAccess::store_64_bind_compat_78289);
100+
ClassDB::bind_compatibility_method(D_METHOD("store_half", "value"), &FileAccess::store_half_bind_compat_78289);
101+
ClassDB::bind_compatibility_method(D_METHOD("store_float", "value"), &FileAccess::store_float_bind_compat_78289);
102+
ClassDB::bind_compatibility_method(D_METHOD("store_double", "value"), &FileAccess::store_double_bind_compat_78289);
103+
ClassDB::bind_compatibility_method(D_METHOD("store_real", "value"), &FileAccess::store_real_bind_compat_78289);
104+
ClassDB::bind_compatibility_method(D_METHOD("store_buffer", "buffer"), &FileAccess::store_buffer_bind_compat_78289);
105+
ClassDB::bind_compatibility_method(D_METHOD("store_line", "line"), &FileAccess::store_line_bind_compat_78289);
106+
ClassDB::bind_compatibility_method(D_METHOD("store_csv_line", "values", "delim"), &FileAccess::store_csv_line_bind_compat_78289, DEFVAL(","));
107+
ClassDB::bind_compatibility_method(D_METHOD("store_string", "string"), &FileAccess::store_string_bind_compat_78289);
108+
ClassDB::bind_compatibility_method(D_METHOD("store_var", "value", "full_objects"), &FileAccess::store_var_bind_compat_78289, DEFVAL(false));
109+
ClassDB::bind_compatibility_method(D_METHOD("store_pascal_string", "string"), &FileAccess::store_pascal_string_bind_compat_78289);
39110
}
40111

41-
#endif // DISABLE_DEPRECATED
112+
#endif

‎core/io/file_access.cpp

+48-37
Original file line numberDiff line numberDiff line change
@@ -495,56 +495,56 @@ String FileAccess::get_as_utf8_string(bool p_skip_cr) const {
495495
return s;
496496
}
497497

498-
void FileAccess::store_8(uint8_t p_dest) {
499-
store_buffer(&p_dest, sizeof(uint8_t));
498+
bool FileAccess::store_8(uint8_t p_dest) {
499+
return store_buffer(&p_dest, sizeof(uint8_t));
500500
}
501501

502-
void FileAccess::store_16(uint16_t p_dest) {
502+
bool FileAccess::store_16(uint16_t p_dest) {
503503
if (big_endian) {
504504
p_dest = BSWAP16(p_dest);
505505
}
506506

507-
store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint16_t));
507+
return store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint16_t));
508508
}
509509

510-
void FileAccess::store_32(uint32_t p_dest) {
510+
bool FileAccess::store_32(uint32_t p_dest) {
511511
if (big_endian) {
512512
p_dest = BSWAP32(p_dest);
513513
}
514514

515-
store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint32_t));
515+
return store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint32_t));
516516
}
517517

518-
void FileAccess::store_64(uint64_t p_dest) {
518+
bool FileAccess::store_64(uint64_t p_dest) {
519519
if (big_endian) {
520520
p_dest = BSWAP64(p_dest);
521521
}
522522

523-
store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint64_t));
523+
return store_buffer(reinterpret_cast<uint8_t *>(&p_dest), sizeof(uint64_t));
524524
}
525525

526-
void FileAccess::store_real(real_t p_real) {
526+
bool FileAccess::store_real(real_t p_real) {
527527
if constexpr (sizeof(real_t) == 4) {
528-
store_float(p_real);
528+
return store_float(p_real);
529529
} else {
530-
store_double(p_real);
530+
return store_double(p_real);
531531
}
532532
}
533533

534-
void FileAccess::store_half(float p_dest) {
535-
store_16(Math::make_half_float(p_dest));
534+
bool FileAccess::store_half(float p_dest) {
535+
return store_16(Math::make_half_float(p_dest));
536536
}
537537

538-
void FileAccess::store_float(float p_dest) {
538+
bool FileAccess::store_float(float p_dest) {
539539
MarshallFloat m;
540540
m.f = p_dest;
541-
store_32(m.i);
541+
return store_32(m.i);
542542
}
543543

544-
void FileAccess::store_double(double p_dest) {
544+
bool FileAccess::store_double(double p_dest) {
545545
MarshallDouble m;
546546
m.d = p_dest;
547-
store_64(m.l);
547+
return store_64(m.l);
548548
}
549549

550550
uint64_t FileAccess::get_modified_time(const String &p_file) {
@@ -628,19 +628,18 @@ Error FileAccess::set_read_only_attribute(const String &p_file, bool p_ro) {
628628
return err;
629629
}
630630

631-
void FileAccess::store_string(const String &p_string) {
631+
bool FileAccess::store_string(const String &p_string) {
632632
if (p_string.length() == 0) {
633-
return;
633+
return true;
634634
}
635635

636636
CharString cs = p_string.utf8();
637-
store_buffer((uint8_t *)&cs[0], cs.length());
637+
return store_buffer((uint8_t *)&cs[0], cs.length());
638638
}
639639

640-
void FileAccess::store_pascal_string(const String &p_string) {
640+
bool FileAccess::store_pascal_string(const String &p_string) {
641641
CharString cs = p_string.utf8();
642-
store_32(cs.length());
643-
store_buffer((uint8_t *)&cs[0], cs.length());
642+
return store_32(cs.length()) && store_buffer((uint8_t *)&cs[0], cs.length());
644643
}
645644

646645
String FileAccess::get_pascal_string() {
@@ -655,13 +654,12 @@ String FileAccess::get_pascal_string() {
655654
return ret;
656655
}
657656

658-
void FileAccess::store_line(const String &p_line) {
659-
store_string(p_line);
660-
store_8('\n');
657+
bool FileAccess::store_line(const String &p_line) {
658+
return store_string(p_line) && store_8('\n');
661659
}
662660

663-
void FileAccess::store_csv_line(const Vector<String> &p_values, const String &p_delim) {
664-
ERR_FAIL_COND(p_delim.length() != 1);
661+
bool FileAccess::store_csv_line(const Vector<String> &p_values, const String &p_delim) {
662+
ERR_FAIL_COND_V(p_delim.length() != 1, false);
665663

666664
String line = "";
667665
int size = p_values.size();
@@ -678,30 +676,43 @@ void FileAccess::store_csv_line(const Vector<String> &p_values, const String &p_
678676
line += value;
679677
}
680678

681-
store_line(line);
679+
return store_line(line);
682680
}
683681

684-
void FileAccess::store_buffer(const Vector<uint8_t> &p_buffer) {
682+
bool FileAccess::store_buffer(const Vector<uint8_t> &p_buffer) {
685683
uint64_t len = p_buffer.size();
684+
if (len == 0) {
685+
return true;
686+
}
687+
686688
const uint8_t *r = p_buffer.ptr();
687689

688-
store_buffer(r, len);
690+
return store_buffer(r, len);
691+
}
692+
693+
bool FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) {
694+
ERR_FAIL_COND_V(!p_src && p_length > 0, false);
695+
for (uint64_t i = 0; i < p_length; i++) {
696+
if (unlikely(!store_8(p_src[i]))) {
697+
return false;
698+
}
699+
}
700+
return true;
689701
}
690702

691-
void FileAccess::store_var(const Variant &p_var, bool p_full_objects) {
703+
bool FileAccess::store_var(const Variant &p_var, bool p_full_objects) {
692704
int len;
693705
Error err = encode_variant(p_var, nullptr, len, p_full_objects);
694-
ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
706+
ERR_FAIL_COND_V_MSG(err != OK, false, "Error when trying to encode Variant.");
695707

696708
Vector<uint8_t> buff;
697709
buff.resize(len);
698710

699711
uint8_t *w = buff.ptrw();
700712
err = encode_variant(p_var, &w[0], len, p_full_objects);
701-
ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
713+
ERR_FAIL_COND_V_MSG(err != OK, false, "Error when trying to encode Variant.");
702714

703-
store_32(len);
704-
store_buffer(buff);
715+
return store_32(len) && store_buffer(buff);
705716
}
706717

707718
Vector<uint8_t> FileAccess::get_file_as_bytes(const String &p_path, Error *r_error) {
@@ -864,7 +875,7 @@ void FileAccess::_bind_methods() {
864875
ClassDB::bind_method(D_METHOD("store_float", "value"), &FileAccess::store_float);
865876
ClassDB::bind_method(D_METHOD("store_double", "value"), &FileAccess::store_double);
866877
ClassDB::bind_method(D_METHOD("store_real", "value"), &FileAccess::store_real);
867-
ClassDB::bind_method(D_METHOD("store_buffer", "buffer"), (void(FileAccess::*)(const Vector<uint8_t> &)) & FileAccess::store_buffer);
878+
ClassDB::bind_method(D_METHOD("store_buffer", "buffer"), (bool(FileAccess::*)(const Vector<uint8_t> &)) & FileAccess::store_buffer);
868879
ClassDB::bind_method(D_METHOD("store_line", "line"), &FileAccess::store_line);
869880
ClassDB::bind_method(D_METHOD("store_csv_line", "values", "delim"), &FileAccess::store_csv_line, DEFVAL(","));
870881
ClassDB::bind_method(D_METHOD("store_string", "string"), &FileAccess::store_string);

‎core/io/file_access.h

+31-15
Original file line numberDiff line numberDiff line change
@@ -112,6 +112,21 @@ class FileAccess : public RefCounted {
112112
#ifndef DISABLE_DEPRECATED
113113
static Ref<FileAccess> _open_encrypted_bind_compat_98918(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key);
114114

115+
void store_8_bind_compat_78289(uint8_t p_dest);
116+
void store_16_bind_compat_78289(uint16_t p_dest);
117+
void store_32_bind_compat_78289(uint32_t p_dest);
118+
void store_64_bind_compat_78289(uint64_t p_dest);
119+
void store_buffer_bind_compat_78289(const Vector<uint8_t> &p_buffer);
120+
void store_var_bind_compat_78289(const Variant &p_var, bool p_full_objects = false);
121+
void store_half_bind_compat_78289(float p_dest);
122+
void store_float_bind_compat_78289(float p_dest);
123+
void store_double_bind_compat_78289(double p_dest);
124+
void store_real_bind_compat_78289(real_t p_real);
125+
void store_string_bind_compat_78289(const String &p_string);
126+
void store_line_bind_compat_78289(const String &p_line);
127+
void store_csv_line_bind_compat_78289(const Vector<String> &p_values, const String &p_delim = ",");
128+
void store_pascal_string_bind_compat_78289(const String &p_string);
129+
115130
static void _bind_compatibility_methods();
116131
#endif
117132

@@ -164,6 +179,7 @@ class FileAccess : public RefCounted {
164179
virtual String get_as_utf8_string(bool p_skip_cr = false) const;
165180

166181
/**
182+
167183
* Use this for files WRITTEN in _big_ endian machines (ie, amiga/mac)
168184
* It's not about the current CPU type but file formats.
169185
* This flag gets reset to `false` (little endian) on each open.
@@ -175,27 +191,27 @@ class FileAccess : public RefCounted {
175191

176192
virtual Error resize(int64_t p_length) = 0;
177193
virtual void flush() = 0;
178-
virtual void store_8(uint8_t p_dest); ///< store a byte
179-
virtual void store_16(uint16_t p_dest); ///< store 16 bits uint
180-
virtual void store_32(uint32_t p_dest); ///< store 32 bits uint
181-
virtual void store_64(uint64_t p_dest); ///< store 64 bits uint
194+
virtual bool store_8(uint8_t p_dest); ///< store a byte
195+
virtual bool store_16(uint16_t p_dest); ///< store 16 bits uint
196+
virtual bool store_32(uint32_t p_dest); ///< store 32 bits uint
197+
virtual bool store_64(uint64_t p_dest); ///< store 64 bits uint
182198

183-
virtual void store_half(float p_dest);
184-
virtual void store_float(float p_dest);
185-
virtual void store_double(double p_dest);
186-
virtual void store_real(real_t p_real);
199+
virtual bool store_half(float p_dest);
200+
virtual bool store_float(float p_dest);
201+
virtual bool store_double(double p_dest);
202+
virtual bool store_real(real_t p_real);
187203

188-
virtual void store_string(const String &p_string);
189-
virtual void store_line(const String &p_line);
190-
virtual void store_csv_line(const Vector<String> &p_values, const String &p_delim = ",");
204+
virtual bool store_string(const String &p_string);
205+
virtual bool store_line(const String &p_line);
206+
virtual bool store_csv_line(const Vector<String> &p_values, const String &p_delim = ",");
191207

192-
virtual void store_pascal_string(const String &p_string);
208+
virtual bool store_pascal_string(const String &p_string);
193209
virtual String get_pascal_string();
194210

195-
virtual void store_buffer(const uint8_t *p_src, uint64_t p_length) = 0; ///< store an array of bytes, needs to be overwritten by children.
196-
void store_buffer(const Vector<uint8_t> &p_buffer);
211+
virtual bool store_buffer(const uint8_t *p_src, uint64_t p_length) = 0; ///< store an array of bytes, needs to be overwritten by children.
212+
bool store_buffer(const Vector<uint8_t> &p_buffer);
197213

198-
void store_var(const Variant &p_var, bool p_full_objects = false);
214+
bool store_var(const Variant &p_var, bool p_full_objects = false);
199215

200216
virtual void close() = 0;
201217

‎core/io/file_access_compressed.cpp

+14-16
Original file line numberDiff line numberDiff line change
@@ -40,18 +40,6 @@ void FileAccessCompressed::configure(const String &p_magic, Compression::Mode p_
4040
block_size = p_block_size;
4141
}
4242

43-
#define WRITE_FIT(m_bytes) \
44-
{ \
45-
if (write_pos + (m_bytes) > write_max) { \
46-
write_max = write_pos + (m_bytes); \
47-
} \
48-
if (write_max > write_buffer_size) { \
49-
write_buffer_size = next_power_of_2(write_max); \
50-
buffer.resize(write_buffer_size); \
51-
write_ptr = buffer.ptrw(); \
52-
} \
53-
}
54-
5543
Error FileAccessCompressed::open_after_magic(Ref<FileAccess> p_base) {
5644
f = p_base;
5745
cmode = (Compression::Mode)f->get_32();
@@ -309,13 +297,23 @@ void FileAccessCompressed::flush() {
309297
// compressed files keep data in memory till close()
310298
}
311299

312-
void FileAccessCompressed::store_buffer(const uint8_t *p_src, uint64_t p_length) {
313-
ERR_FAIL_COND_MSG(f.is_null(), "File must be opened before use.");
314-
ERR_FAIL_COND_MSG(!writing, "File has not been opened in write mode.");
300+
bool FileAccessCompressed::store_buffer(const uint8_t *p_src, uint64_t p_length) {
301+
ERR_FAIL_COND_V_MSG(f.is_null(), false, "File must be opened before use.");
302+
ERR_FAIL_COND_V_MSG(!writing, false, "File has not been opened in write mode.");
303+
304+
if (write_pos + (p_length) > write_max) {
305+
write_max = write_pos + (p_length);
306+
}
307+
if (write_max > write_buffer_size) {
308+
write_buffer_size = next_power_of_2(write_max);
309+
ERR_FAIL_COND_V(buffer.resize(write_buffer_size) != OK, false);
310+
write_ptr = buffer.ptrw();
311+
}
315312

316-
WRITE_FIT(p_length);
317313
memcpy(write_ptr + write_pos, p_src, p_length);
314+
318315
write_pos += p_length;
316+
return true;
319317
}
320318

321319
bool FileAccessCompressed::file_exists(const String &p_name) {

‎core/io/file_access_compressed.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -89,7 +89,7 @@ class FileAccessCompressed : public FileAccess {
8989

9090
virtual Error resize(int64_t p_length) override { return ERR_UNAVAILABLE; }
9191
virtual void flush() override;
92-
virtual void store_buffer(const uint8_t *p_src, uint64_t p_length) override;
92+
virtual bool store_buffer(const uint8_t *p_src, uint64_t p_length) override;
9393

9494
virtual bool file_exists(const String &p_name) override; ///< return true if a file exists
9595

0 commit comments

Comments
 (0)