PuqiAR/Fig-TreeWalker
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 9 Wiki Activity

阶段性保存，全面修改Value为Object

Browse Source
This commit is contained in:
PuqiAR
2025-12-22 19:18:43 +08:00
parent 34a56beb90
commit 271846143a
15 changed files with 334 additions and 418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/Value/Type.hpp
View File

@@ -63,15 +63,5 @@ namespace Fig
using BoolClass = bool;
using NullClass = std::monostate;
using StringClass = FString;
/* complex types */
struct FunctionStruct;
using FunctionClass = FunctionStruct;
struct StructT;
using StructTypeClass = StructT;
struct StructInstanceT;
using StructInstanceClass = StructInstanceT;
}; // namespace ValueType
}; // namespace Fig

74
include/Value/function.hpp
View File

@@ -1,32 +1,35 @@
#pragma once
#include <Value/BaseValue.hpp>
#include <Ast/functionParameters.hpp>
#include <context_forward.hpp>
#include <atomic>
#include <functional>
#include <memory>
#include <vector>
namespace Fig
{
class Value;
/* complex objects */
struct FunctionStruct
class Object;
class Function
{
public:
std::size_t id;
Ast::FunctionParameters paras;
TypeInfo retType;
Ast::BlockStatement body;
bool isBuiltin = false;
std::function<Value(const std::vector<Value> &)> builtin;
std::function<Object(const std::vector<Object> &)> builtin;
int builtinParamCount = -1;
std::shared_ptr<Context> closureContext;
FunctionStruct() = default;
// ===== Constructors =====
Function() :
id(nextId()) {}
FunctionStruct(Ast::FunctionParameters _paras, TypeInfo _retType, Ast::BlockStatement _body, ContextPtr _closureContext) :
Function(Ast::FunctionParameters _paras, TypeInfo _retType, Ast::BlockStatement _body, ContextPtr _closureContext) :
id(nextId()), // 分配唯一 ID
paras(std::move(_paras)),
retType(std::move(_retType)),
@@ -35,27 +38,23 @@ namespace Fig
{
}
FunctionStruct(std::function<Value(const std::vector<Value> &)> fn, int argc);
Function(std::function<Object(const std::vector<Object> &)> fn, int argc) :
id(nextId()), isBuiltin(true), builtin(std::move(fn)), builtinParamCount(argc)
{
}
FunctionStruct(const FunctionStruct &other) :
id(other.id),
paras(other.paras),
retType(other.retType),
body(other.body),
isBuiltin(other.isBuiltin),
builtin(other.builtin),
builtinParamCount(other.builtinParamCount),
closureContext(other.closureContext) {}
// ===== Copy / Move =====
Function(const Function &other) = default;
Function(Function &&) noexcept = default;
Function &operator=(const Function &) = default;
Function &operator=(Function &&) noexcept = default;
FunctionStruct &operator=(const FunctionStruct &other) = default;
FunctionStruct(FunctionStruct &&) noexcept = default;
FunctionStruct &operator=(FunctionStruct &&) noexcept = default;
bool operator==(const FunctionStruct &other) const noexcept
// ===== Comparison =====
bool operator==(const Function &other) const noexcept
{
return id == other.id;
}
bool operator!=(const FunctionStruct &other) const noexcept
bool operator!=(const Function &other) const noexcept
{
return !(*this == other);
}
@@ -67,31 +66,4 @@ namespace Fig
return counter++;
}
};
class Function final : public __ValueWrapper<FunctionStruct>
{
public:
Function(const FunctionStruct &x) :
__ValueWrapper(ValueType::Function)
{
data = std::make_unique<FunctionStruct>(x);
}
Function(Ast::FunctionParameters paras, TypeInfo ret, Ast::BlockStatement body, ContextPtr closureContext) :
__ValueWrapper(ValueType::Function)
{
data = std::make_unique<FunctionStruct>(
std::move(paras), std::move(ret), std::move(body), std::move(closureContext));
}
Function(std::function<Value(const std::vector<Value> &)> fn, int argc);
bool operator==(const Function &other) const noexcept
{
if (!data || !other.data) return false;
return *data == *other.data; // call -> FunctionStruct::operator== (based on ID comparing)
}
Function(const Function &) = default;
Function(Function &&) noexcept = default;
Function &operator=(const Function &) = default;
Function &operator=(Function &&) noexcept = default;
};
} // namespace Fig

48
include/Value/structInstance.hpp
View File

@@ -1,50 +1,32 @@
#pragma once
#include <Value/BaseValue.hpp>
#include <context_forward.hpp>
namespace Fig
{
struct StructInstanceT final
struct StructInstance
{
size_t parentId;
ContextPtr localContext;
StructInstanceT(size_t _parentId, ContextPtr _localContext) :
parentId(std::move(_parentId)), localContext(std::move(_localContext)) {}
StructInstanceT(const StructInstanceT &other) :
parentId(other.parentId), localContext(other.localContext) {}
StructInstanceT &operator=(const StructInstanceT &) = default;
StructInstanceT(StructInstanceT &&) = default;
StructInstanceT &operator=(StructInstanceT &&) = default;
bool operator==(const StructInstanceT &) const = default;
};
class StructInstance final : public __ValueWrapper<StructInstanceT>
{
public:
StructInstance(const StructInstanceT &x) :
__ValueWrapper(ValueType::StructInstance)
{
data = std::make_unique<StructInstanceT>(x);
}
// ===== Constructors =====
StructInstance(size_t _parentId, ContextPtr _localContext) :
__ValueWrapper(ValueType::StructInstance)
{
data = std::make_unique<StructInstanceT>(std::move(_parentId), std::move(_localContext));
}
parentId(_parentId), localContext(std::move(_localContext)) {}
StructInstance(const StructInstance &other) = default;
StructInstance(StructInstance &&) noexcept = default;
StructInstance &operator=(const StructInstance &) = default;
StructInstance &operator=(StructInstance &&) noexcept = default;
// ===== Comparison =====
bool operator==(const StructInstance &other) const noexcept
{
return data == other.data;
return parentId == other.parentId && localContext == other.localContext;
}
bool operator!=(const StructInstance &other) const noexcept
{
return !(*this == other);
}
StructInstance(const StructInstance &) = default;
StructInstance(StructInstance &&) = default;
StructInstance &operator=(const StructInstance &) = default;
StructInstance &operator=(StructInstance &&) = default;
};
}; // namespace Fig
} // namespace Fig

85
include/Value/structType.hpp
View File

@@ -7,56 +7,57 @@
#include <Value/BaseValue.hpp>
#include <context_forward.hpp>
#include <atomic>
#include <memory>
#include <vector>
namespace Fig
{
struct Field
{
bool isPublic() const
{
return am == AccessModifier::Public or am == AccessModifier::PublicConst or am == AccessModifier::PublicFinal;
}
bool isConst() const
{
return am == AccessModifier::Const or am == AccessModifier::PublicConst;
}
bool isFinal() const
{
return am == AccessModifier::Final or am == AccessModifier::PublicFinal;
}
AccessModifier am;
FString name;
TypeInfo type;
Ast::Expression defaultValue;
Field(AccessModifier _am, FString _name, TypeInfo _type, Ast::Expression _defaultValue) :
am(std::move(_am)), name(std::move(_name)), type(std::move(_type)), defaultValue(std::move(_defaultValue)) {}
am(_am), name(std::move(_name)), type(std::move(_type)), defaultValue(std::move(_defaultValue)) {}
bool isPublic() const
{
return am == AccessModifier::Public || am == AccessModifier::PublicConst || am == AccessModifier::PublicFinal;
}
bool isConst() const
{
return am == AccessModifier::Const || am == AccessModifier::PublicConst;
}
bool isFinal() const
{
return am == AccessModifier::Final || am == AccessModifier::PublicFinal;
}
};
struct StructT final// = StructType 结构体定义
struct StructType
{
std::size_t id;
ContextPtr defContext; // 定义时的上下文
std::vector<Field> fields;
StructT(ContextPtr _defContext, std::vector<Field> fieldsMap) :
defContext(std::move(_defContext)),
fields(std::move(fieldsMap))
{
id = nextId();
}
StructT(const StructT &other) :
id(other.id), fields(other.fields) {}
StructT &operator=(const StructT &other) = default;
StructT(StructT &&) noexcept = default;
StructT &operator=(StructT &&) noexcept = default;
bool operator==(const StructT &other) const noexcept
// ===== Constructors =====
StructType(ContextPtr _defContext, std::vector<Field> _fields) :
id(nextId()), defContext(std::move(_defContext)), fields(std::move(_fields)) {}
StructType(const StructType &other) = default;
StructType(StructType &&) noexcept = default;
StructType &operator=(const StructType &) = default;
StructType &operator=(StructType &&) noexcept = default;
// ===== Comparison =====
bool operator==(const StructType &other) const noexcept
{
return id == other.id;
}
bool operator!=(const StructT &other) const noexcept
bool operator!=(const StructType &other) const noexcept
{
return !(*this == other);
}
@@ -68,28 +69,4 @@ namespace Fig
return counter++;
}
};
class StructType final : public __ValueWrapper<StructT>
{
public:
StructType(const StructT &x) :
__ValueWrapper(ValueType::StructType)
{
data = std::make_unique<StructT>(x);
}
StructType(ContextPtr _defContext, std::vector<Field> fieldsMap) :
__ValueWrapper(ValueType::StructType)
{
data = std::make_unique<StructT>(std::move(_defContext), std::move(fieldsMap));
}
bool operator==(const StructType &other) const noexcept
{
return data == other.data;
}
StructType(const StructType &) = default;
StructType(StructType &&) noexcept = default;
StructType &operator=(const StructType &) = default;
StructType &operator=(StructType &&) noexcept = default;
};
}; // namespace Fig
} // namespace Fig