1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
ton/tolk/compiler-state.cpp
tolk-vm f3e620f48c
[Tolk] Nullable types T? and null safety
This commit introduces nullable types `T?` that are
distinct from non-nullable `T`.
Example: `int?` (int or null) and `int` are different now.
Previously, `null` could be assigned to any primitive type.
Now, it can be assigned only to `T?`.

A non-null assertion operator `!` was also introduced,
similar to `!` in TypeScript and `!!` in Kotlin.

If `int?` still occupies 1 stack slot, `(int,int)?` and
other nullable tensors occupy N+1 slots, the last for
"null precedence". `v == null` actually compares that slot.
Assigning `(int,int)` to `(int,int)?` implicitly creates
a null presence slot. Assigning `null` to `(int,int)?` widens
this null value to 3 slots. This is called "type transitioning".

All stdlib functions prototypes have been updated to reflect
whether they return/accept a nullable or a strict value.

This commit also contains refactoring from `const FunctionData*`
to `FunctionPtr` and similar.
2025-02-28 16:41:41 +03:00

73 lines
2.5 KiB
C++

/*
This file is part of TON Blockchain Library.
TON Blockchain Library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
TON Blockchain Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with TON Blockchain Library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "compiler-state.h"
#include <iostream>
#include <sstream>
namespace tolk {
CompilerState G; // the only mutable global variable in tolk internals
void ExperimentalOption::mark_deprecated(const char* deprecated_from_v, const char* deprecated_reason) {
this->deprecated_from_v = deprecated_from_v;
this->deprecated_reason = deprecated_reason;
}
std::string_view PersistentHeapAllocator::copy_string_to_persistent_memory(std::string_view str_in_tmp_memory) {
size_t len = str_in_tmp_memory.size();
char* allocated = new char[len];
memcpy(allocated, str_in_tmp_memory.data(), str_in_tmp_memory.size());
auto new_chunk = std::make_unique<ChunkInHeap>(allocated, std::move(head));
head = std::move(new_chunk);
return {head->allocated, len};
}
void PersistentHeapAllocator::clear() {
head = nullptr;
}
void CompilerSettings::enable_experimental_option(std::string_view name) {
ExperimentalOption* to_enable = nullptr;
if (name == remove_unused_functions.name) {
to_enable = &remove_unused_functions;
}
if (to_enable == nullptr) {
std::cerr << "unknown experimental option: " << name << std::endl;
} else if (to_enable->deprecated_from_v) {
std::cerr << "experimental option " << name << " "
<< "is deprecated since Tolk v" << to_enable->deprecated_from_v
<< ": " << to_enable->deprecated_reason << std::endl;
} else {
to_enable->enabled = true;
}
}
void CompilerSettings::parse_experimental_options_cmd_arg(const std::string& cmd_arg) {
std::istringstream stream(cmd_arg);
std::string token;
while (std::getline(stream, token, ',')) {
enable_experimental_option(token);
}
}
const std::vector<FunctionPtr>& get_all_not_builtin_functions() {
return G.all_functions;
}
} // namespace tolk