diff options
Diffstat (limited to 'type.cpp')
| -rw-r--r-- | type.cpp | 989 |
1 files changed, 866 insertions, 123 deletions
@@ -496,15 +496,6 @@ Confidence<BNMemberScope> Type::GetScope() const } -void Type::SetScope(const Confidence<BNMemberScope>& scope) -{ - BNMemberScopeWithConfidence mc; - mc.value = scope.GetValue(); - mc.confidence = scope.GetConfidence(); - return BNTypeSetMemberScope(m_object, &mc); -} - - Confidence<BNMemberAccess> Type::GetAccess() const { BNMemberAccessWithConfidence result = BNTypeGetMemberAccess(m_object); @@ -512,33 +503,6 @@ Confidence<BNMemberAccess> Type::GetAccess() const } -void Type::SetAccess(const Confidence<BNMemberAccess>& access) -{ - BNMemberAccessWithConfidence mc; - mc.value = access.GetValue(); - mc.confidence = access.GetConfidence(); - return BNTypeSetMemberAccess(m_object, &mc); -} - - -void Type::SetConst(const Confidence<bool>& cnst) -{ - BNBoolWithConfidence bc; - bc.value = cnst.GetValue(); - bc.confidence = cnst.GetConfidence(); - BNTypeSetConst(m_object, &bc); -} - - -void Type::SetVolatile(const Confidence<bool>& vltl) -{ - BNBoolWithConfidence bc; - bc.value = vltl.GetValue(); - bc.confidence = vltl.GetConfidence(); - BNTypeSetVolatile(m_object, &bc); -} - - Confidence<Ref<Type>> Type::GetChildType() const { BNTypeWithConfidence type = BNGetChildType(m_object); @@ -868,15 +832,6 @@ Ref<Type> Type::FunctionType(const Confidence<Ref<Type>>& returnValue, } -void Type::SetFunctionCanReturn(const Confidence<bool>& canReturn) -{ - BNBoolWithConfidence bc; - bc.value = canReturn.GetValue(); - bc.confidence = canReturn.GetConfidence(); - BNSetFunctionTypeCanReturn(m_object, &bc); -} - - string Type::GenerateAutoTypeId(const string& source, const QualifiedName& name) { BNQualifiedName nameObj = name.GetAPIObject(); @@ -943,14 +898,6 @@ QualifiedName Type::GetTypeName() const } -void Type::SetTypeName(const QualifiedName& names) -{ - BNQualifiedName nameObj = names.GetAPIObject(); - BNTypeSetTypeName(m_object, &nameObj); - QualifiedName::FreeAPIObject(&nameObj); -} - - Confidence<Ref<Type>> Type::WithConfidence(uint8_t conf) { return Confidence<Ref<Type>>(this, conf); @@ -966,64 +913,580 @@ QualifiedName Type::GetStructureName() const } -NamedTypeReference::NamedTypeReference(BNNamedTypeReference* nt) +Ref<Type> Type::WithReplacedStructure(Structure* from, Structure* to) { - m_object = nt; + BNType* result = BNTypeWithReplacedStructure(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeType(result); + return this; + } + return new Type(result); } -NamedTypeReference::NamedTypeReference(BNNamedTypeReferenceClass cls, const string& id, const QualifiedName& names) +Ref<Type> Type::WithReplacedEnumeration(Enumeration* from, Enumeration* to) { - m_object = BNCreateNamedType(); - BNSetTypeReferenceClass(m_object, cls); - if (id.size() != 0) + BNType* result = BNTypeWithReplacedEnumeration(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) { - BNSetTypeReferenceId(m_object, id.c_str()); + BNFreeType(result); + return this; } - if (names.size() != 0) + return new Type(result); +} + + +Ref<Type> Type::WithReplacedNamedTypeReference(NamedTypeReference* from, NamedTypeReference* to) +{ + BNType* result = BNTypeWithReplacedNamedTypeReference(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) { - BNQualifiedName nameObj = names.GetAPIObject(); - BNSetTypeReferenceName(m_object, &nameObj); - QualifiedName::FreeAPIObject(&nameObj); + BNFreeType(result); + return this; } + return new Type(result); } -void NamedTypeReference::SetTypeClass(BNNamedTypeReferenceClass cls) +TypeBuilder::TypeBuilder() { - BNSetTypeReferenceClass(m_object, cls); + m_object = BNCreateVoidTypeBuilder(); } -BNNamedTypeReferenceClass NamedTypeReference::GetTypeClass() const +TypeBuilder::TypeBuilder(BNTypeBuilder* type) { - return BNGetTypeReferenceClass(m_object); + m_object = type; } -string NamedTypeReference::GetTypeId() const +TypeBuilder::TypeBuilder(const TypeBuilder& type) { - char* str = BNGetTypeReferenceId(m_object); + m_object = BNDuplicateTypeBuilder(type.m_object); +} + + +TypeBuilder::TypeBuilder(TypeBuilder&& type) +{ + m_object = type.m_object; + type.m_object = BNCreateVoidTypeBuilder(); +} + + +TypeBuilder::TypeBuilder(Type* type) +{ + m_object = BNCreateTypeBuilderFromType(type->GetObject()); +} + + +TypeBuilder& TypeBuilder::operator=(const TypeBuilder& type) +{ + if (this != &type) + { + BNFreeTypeBuilder(m_object); + m_object = BNDuplicateTypeBuilder(type.m_object); + } + return *this; +} + + +TypeBuilder& TypeBuilder::operator=(TypeBuilder&& type) +{ + std::swap(m_object, type.m_object); + return *this; +} + + +TypeBuilder& TypeBuilder::operator=(Type* type) +{ + BNFreeTypeBuilder(m_object); + m_object = BNCreateTypeBuilderFromType(type->GetObject()); + return *this; +} + + +Ref<Type> TypeBuilder::Finalize() +{ + return new Type(BNFinalizeTypeBuilder(m_object)); +} + + +BNTypeClass TypeBuilder::GetClass() const +{ + return BNGetTypeBuilderClass(m_object); +} + + +uint64_t TypeBuilder::GetWidth() const +{ + return BNGetTypeBuilderWidth(m_object); +} + + +size_t TypeBuilder::GetAlignment() const +{ + return BNGetTypeBuilderAlignment(m_object); +} + + +Confidence<bool> TypeBuilder::IsSigned() const +{ + BNBoolWithConfidence result = BNIsTypeBuilderSigned(m_object); + return Confidence<bool>(result.value, result.confidence); +} + + +Confidence<bool> TypeBuilder::IsConst() const +{ + BNBoolWithConfidence result = BNIsTypeBuilderConst(m_object); + return Confidence<bool>(result.value, result.confidence); +} + + +Confidence<BNMemberScope> TypeBuilder::GetScope() const +{ + BNMemberScopeWithConfidence result = BNTypeBuilderGetMemberScope(m_object); + return Confidence<BNMemberScope>(result.value, result.confidence); +} + + +void TypeBuilder::SetScope(const Confidence<BNMemberScope>& scope) +{ + BNMemberScopeWithConfidence mc; + mc.value = scope.GetValue(); + mc.confidence = scope.GetConfidence(); + return BNTypeBuilderSetMemberScope(m_object, &mc); +} + + +Confidence<BNMemberAccess> TypeBuilder::GetAccess() const +{ + BNMemberAccessWithConfidence result = BNTypeBuilderGetMemberAccess(m_object); + return Confidence<BNMemberAccess>(result.value, result.confidence); +} + + +void TypeBuilder::SetAccess(const Confidence<BNMemberAccess>& access) +{ + BNMemberAccessWithConfidence mc; + mc.value = access.GetValue(); + mc.confidence = access.GetConfidence(); + return BNTypeBuilderSetMemberAccess(m_object, &mc); +} + + +void TypeBuilder::SetConst(const Confidence<bool>& cnst) +{ + BNBoolWithConfidence bc; + bc.value = cnst.GetValue(); + bc.confidence = cnst.GetConfidence(); + BNTypeBuilderSetConst(m_object, &bc); +} + + +void TypeBuilder::SetVolatile(const Confidence<bool>& vltl) +{ + BNBoolWithConfidence bc; + bc.value = vltl.GetValue(); + bc.confidence = vltl.GetConfidence(); + BNTypeBuilderSetVolatile(m_object, &bc); +} + + +Confidence<Ref<Type>> TypeBuilder::GetChildType() const +{ + BNTypeWithConfidence type = BNGetTypeBuilderChildType(m_object); + if (type.type) + return Confidence<Ref<Type>>(new Type(type.type), type.confidence); + return nullptr; +} + + +Confidence<Ref<CallingConvention>> TypeBuilder::GetCallingConvention() const +{ + BNCallingConventionWithConfidence cc = BNGetTypeBuilderCallingConvention(m_object); + if (cc.convention) + return Confidence<Ref<CallingConvention>>(new CoreCallingConvention(cc.convention), cc.confidence); + return nullptr; +} + + +vector<FunctionParameter> TypeBuilder::GetParameters() const +{ + size_t count; + BNFunctionParameter* types = BNGetTypeBuilderParameters(m_object, &count); + + vector<FunctionParameter> result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + FunctionParameter param; + param.name = types[i].name; + param.type = Confidence<Ref<Type>>(new Type(BNNewTypeReference(types[i].type)), types[i].typeConfidence); + param.defaultLocation = types[i].defaultLocation; + param.location.type = types[i].location.type; + param.location.index = types[i].location.index; + param.location.storage = types[i].location.storage; + result.push_back(param); + } + + BNFreeTypeParameterList(types, count); + return result; +} + + +Confidence<bool> TypeBuilder::HasVariableArguments() const +{ + BNBoolWithConfidence result = BNTypeBuilderHasVariableArguments(m_object); + return Confidence<bool>(result.value, result.confidence); +} + + +Confidence<bool> TypeBuilder::CanReturn() const +{ + BNBoolWithConfidence result = BNFunctionTypeBuilderCanReturn(m_object); + return Confidence<bool>(result.value, result.confidence); +} + + +Ref<Structure> TypeBuilder::GetStructure() const +{ + BNStructure* s = BNGetTypeBuilderStructure(m_object); + if (s) + return new Structure(s); + return nullptr; +} + + +Ref<Enumeration> TypeBuilder::GetEnumeration() const +{ + BNEnumeration* e = BNGetTypeBuilderEnumeration(m_object); + if (e) + return new Enumeration(e); + return nullptr; +} + + +Ref<NamedTypeReference> TypeBuilder::GetNamedTypeReference() const +{ + BNNamedTypeReference* ref = BNGetTypeBuilderNamedTypeReference(m_object); + if (ref) + return new NamedTypeReference(ref); + return nullptr; +} + + +uint64_t TypeBuilder::GetElementCount() const +{ + return BNGetTypeBuilderElementCount(m_object); +} + + +uint64_t TypeBuilder::GetOffset() const +{ + return BNGetTypeBuilderOffset(m_object); +} + + +Confidence<int64_t> TypeBuilder::GetStackAdjustment() const +{ + BNOffsetWithConfidence result = BNGetTypeBuilderStackAdjustment(m_object); + return Confidence<int64_t>(result.value, result.confidence); +} + + +string TypeBuilder::GetString(Platform* platform) const +{ + char* str = BNGetTypeBuilderString(m_object, platform ? platform->GetObject() : nullptr); + string result = str; + BNFreeString(str); + return result; +} + + +string TypeBuilder::GetTypeAndName(const QualifiedName& nameList) const +{ + BNQualifiedName name = nameList.GetAPIObject(); + char* outName = BNGetTypeBuilderTypeAndName(m_object, &name); + QualifiedName::FreeAPIObject(&name); + return outName; +} + +string TypeBuilder::GetStringBeforeName(Platform* platform) const +{ + char* str = BNGetTypeBuilderStringBeforeName(m_object, platform ? platform->GetObject() : nullptr); string result = str; BNFreeString(str); return result; } -void NamedTypeReference::SetTypeId(const string& id) +string TypeBuilder::GetStringAfterName(Platform* platform) const +{ + char* str = BNGetTypeBuilderStringAfterName(m_object, platform ? platform->GetObject() : nullptr); + string result = str; + BNFreeString(str); + return result; +} + + +vector<InstructionTextToken> TypeBuilder::GetTokens(Platform* platform, uint8_t baseConfidence) const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokens(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); +} + + +vector<InstructionTextToken> TypeBuilder::GetTokensBeforeName(Platform* platform, uint8_t baseConfidence) const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokensBeforeName(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); +} + + +vector<InstructionTextToken> TypeBuilder::GetTokensAfterName(Platform* platform, uint8_t baseConfidence) const +{ + size_t count; + BNInstructionTextToken* tokens = BNGetTypeBuilderTokensAfterName(m_object, + platform ? platform->GetObject() : nullptr, baseConfidence, &count); + + return InstructionTextToken::ConvertAndFreeInstructionTextTokenList(tokens, count); +} + + +TypeBuilder TypeBuilder::VoidType() { - BNSetTypeReferenceId(m_object, id.c_str()); + return TypeBuilder(BNCreateVoidTypeBuilder()); } -void NamedTypeReference::SetName(const QualifiedName& names) +TypeBuilder TypeBuilder::BoolType() +{ + return TypeBuilder(BNCreateBoolTypeBuilder()); +} + + +TypeBuilder TypeBuilder::IntegerType(size_t width, const Confidence<bool>& sign, const string& altName) +{ + BNBoolWithConfidence bc; + bc.value = sign.GetValue(); + bc.confidence = sign.GetConfidence(); + return TypeBuilder(BNCreateIntegerTypeBuilder(width, &bc, altName.c_str())); +} + + +TypeBuilder TypeBuilder::FloatType(size_t width, const string& altName) +{ + return TypeBuilder(BNCreateFloatTypeBuilder(width, altName.c_str())); +} + + +TypeBuilder TypeBuilder::StructureType(Structure* strct) +{ + return TypeBuilder(BNCreateStructureTypeBuilder(strct->GetObject())); +} + + +TypeBuilder TypeBuilder::NamedType(NamedTypeReference* ref, size_t width, size_t align) +{ + return TypeBuilder(BNCreateNamedTypeReferenceBuilder(ref->GetObject(), width, align)); +} + + +TypeBuilder TypeBuilder::NamedType(const QualifiedName& name, Type* type) +{ + return NamedType("", name, type); +} + + +TypeBuilder TypeBuilder::NamedType(const string& id, const QualifiedName& name, Type* type) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + BNTypeBuilder* coreObj = BNCreateNamedTypeReferenceBuilderFromTypeAndId(id.c_str(), &nameObj, + type ? type->GetObject() : nullptr); + QualifiedName::FreeAPIObject(&nameObj); + return coreObj ? TypeBuilder(coreObj) : VoidType(); +} + + +TypeBuilder TypeBuilder::NamedType(BinaryView* view, const QualifiedName& name) +{ + BNQualifiedName nameObj = name.GetAPIObject(); + BNTypeBuilder* coreObj = BNCreateNamedTypeReferenceBuilderFromType(view->GetObject(), &nameObj); + QualifiedName::FreeAPIObject(&nameObj); + return coreObj ? TypeBuilder(coreObj) : VoidType(); +} + + +TypeBuilder TypeBuilder::EnumerationType(Architecture* arch, Enumeration* enm, size_t width, bool isSigned) +{ + return TypeBuilder(BNCreateEnumerationTypeBuilder(arch->GetObject(), enm->GetObject(), width, isSigned)); +} + + +TypeBuilder TypeBuilder::PointerType(Architecture* arch, const Confidence<Ref<Type>>& type, + const Confidence<bool>& cnst, const Confidence<bool>& vltl, BNReferenceType refType) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + BNBoolWithConfidence cnstConf; + cnstConf.value = cnst.GetValue(); + cnstConf.confidence = cnst.GetConfidence(); + + BNBoolWithConfidence vltlConf; + vltlConf.value = vltl.GetValue(); + vltlConf.confidence = vltl.GetConfidence(); + + return TypeBuilder(BNCreatePointerTypeBuilder(arch->GetObject(), &typeConf, &cnstConf, &vltlConf, refType)); +} + + +TypeBuilder TypeBuilder::PointerType(size_t width, const Confidence<Ref<Type>>& type, + const Confidence<bool>& cnst, const Confidence<bool>& vltl, BNReferenceType refType) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + + BNBoolWithConfidence cnstConf; + cnstConf.value = cnst.GetValue(); + cnstConf.confidence = cnst.GetConfidence(); + + BNBoolWithConfidence vltlConf; + vltlConf.value = vltl.GetValue(); + vltlConf.confidence = vltl.GetConfidence(); + + return TypeBuilder(BNCreatePointerTypeBuilderOfWidth(width, &typeConf, &cnstConf, &vltlConf, refType)); +} + + +TypeBuilder TypeBuilder::ArrayType(const Confidence<Ref<Type>>& type, uint64_t elem) +{ + BNTypeWithConfidence typeConf; + typeConf.type = type->GetObject(); + typeConf.confidence = type.GetConfidence(); + return TypeBuilder(BNCreateArrayTypeBuilder(&typeConf, elem)); +} + + +TypeBuilder TypeBuilder::FunctionType(const Confidence<Ref<Type>>& returnValue, + const Confidence<Ref<CallingConvention>>& callingConvention, + const std::vector<FunctionParameter>& params, const Confidence<bool>& varArg, + const Confidence<int64_t>& stackAdjust) +{ + BNTypeWithConfidence returnValueConf; + returnValueConf.type = returnValue->GetObject(); + returnValueConf.confidence = returnValue.GetConfidence(); + + BNCallingConventionWithConfidence callingConventionConf; + callingConventionConf.convention = callingConvention ? callingConvention->GetObject() : nullptr; + callingConventionConf.confidence = callingConvention.GetConfidence(); + + BNFunctionParameter* paramArray = new BNFunctionParameter[params.size()]; + for (size_t i = 0; i < params.size(); i++) + { + paramArray[i].name = (char*)params[i].name.c_str(); + paramArray[i].type = params[i].type->GetObject(); + paramArray[i].typeConfidence = params[i].type.GetConfidence(); + paramArray[i].defaultLocation = params[i].defaultLocation; + paramArray[i].location.type = params[i].location.type; + paramArray[i].location.index = params[i].location.index; + paramArray[i].location.storage = params[i].location.storage; + } + + BNBoolWithConfidence varArgConf; + varArgConf.value = varArg.GetValue(); + varArgConf.confidence = varArg.GetConfidence(); + + BNOffsetWithConfidence stackAdjustConf; + stackAdjustConf.value = stackAdjust.GetValue(); + stackAdjustConf.confidence = stackAdjust.GetConfidence(); + + TypeBuilder type(BNCreateFunctionTypeBuilder(&returnValueConf, &callingConventionConf, + paramArray, params.size(), &varArgConf, &stackAdjustConf)); + delete[] paramArray; + return type; +} + + +void TypeBuilder::SetFunctionCanReturn(const Confidence<bool>& canReturn) +{ + BNBoolWithConfidence bc; + bc.value = canReturn.GetValue(); + bc.confidence = canReturn.GetConfidence(); + BNSetFunctionTypeBuilderCanReturn(m_object, &bc); +} + + +bool TypeBuilder::IsReferenceOfType(BNNamedTypeReferenceClass refType) +{ + return (GetClass() == NamedTypeReferenceClass) && (GetNamedTypeReference()->GetTypeClass() == refType); +} + + +QualifiedName TypeBuilder::GetTypeName() const +{ + BNQualifiedName name = BNTypeBuilderGetTypeName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); + return result; +} + + +void TypeBuilder::SetTypeName(const QualifiedName& names) +{ + BNQualifiedName nameObj = names.GetAPIObject(); + BNTypeBuilderSetTypeName(m_object, &nameObj); + QualifiedName::FreeAPIObject(&nameObj); +} + + +QualifiedName TypeBuilder::GetStructureName() const +{ + BNQualifiedName name = BNTypeBuilderGetStructureName(m_object); + QualifiedName result = QualifiedName::FromAPIObject(&name); + BNFreeQualifiedName(&name); + return result; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReference* nt) +{ + m_object = nt; +} + + +NamedTypeReference::NamedTypeReference(BNNamedTypeReferenceClass cls, const string& id, const QualifiedName& names) { BNQualifiedName nameObj = names.GetAPIObject(); - BNSetTypeReferenceName(m_object, &nameObj); + m_object = BNCreateNamedType(cls, id.c_str(), &nameObj); QualifiedName::FreeAPIObject(&nameObj); } +BNNamedTypeReferenceClass NamedTypeReference::GetTypeClass() const +{ + return BNGetTypeReferenceClass(m_object); +} + + +string NamedTypeReference::GetTypeId() const +{ + char* str = BNGetTypeReferenceId(m_object); + string result = str; + BNFreeString(str); + return result; +} + + QualifiedName NamedTypeReference::GetName() const { BNQualifiedName name = BNGetTypeReferenceName(m_object); @@ -1057,18 +1520,6 @@ Ref<NamedTypeReference> NamedTypeReference::GenerateAutoDebugTypeReference(BNNam } -Structure::Structure() -{ - m_object = BNCreateStructure(); -} - - -Structure::Structure(BNStructureType type, bool packed) -{ - m_object = BNCreateStructureWithOptions(type, packed); -} - - Structure::Structure(BNStructure* s) { m_object = s; @@ -1113,7 +1564,14 @@ bool Structure::GetMemberByName(const string& name, StructureMember& result) con bool Structure::GetMemberAtOffset(int64_t offset, StructureMember& result) const { - BNStructureMember* member = BNGetStructureMemberAtOffset(m_object, offset); + size_t i; + return GetMemberAtOffset(offset, result, i); +} + + +bool Structure::GetMemberAtOffset(int64_t offset, StructureMember& result, size_t& idx) const +{ + BNStructureMember* member = BNGetStructureMemberAtOffset(m_object, offset, &idx); if (member) { result.type = new Type(BNNewTypeReference(member->type)); @@ -1132,84 +1590,284 @@ uint64_t Structure::GetWidth() const } -void Structure::SetWidth(size_t width) +size_t Structure::GetAlignment() const { - BNSetStructureWidth(m_object, width); + return BNGetStructureAlignment(m_object); } -size_t Structure::GetAlignment() const +bool Structure::IsPacked() const { - return BNGetStructureAlignment(m_object); + return BNIsStructurePacked(m_object); } -void Structure::SetAlignment(size_t align) +bool Structure::IsUnion() const { - BNSetStructureAlignment(m_object, align); + return BNIsStructureUnion(m_object); } -bool Structure::IsPacked() const +BNStructureType Structure::GetStructureType() const { - return BNIsStructurePacked(m_object); + return BNGetStructureType(m_object); } -void Structure::SetPacked(bool packed) +Ref<Structure> Structure::WithReplacedStructure(Structure* from, Structure* to) { - BNSetStructurePacked(m_object, packed); + BNStructure* result = BNStructureWithReplacedStructure(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); } -bool Structure::IsUnion() const +Ref<Structure> Structure::WithReplacedEnumeration(Enumeration* from, Enumeration* to) { - return BNIsStructureUnion(m_object); + BNStructure* result = BNStructureWithReplacedEnumeration(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); } -void Structure::SetStructureType(BNStructureType t) +Ref<Structure> Structure::WithReplacedNamedTypeReference(NamedTypeReference* from, NamedTypeReference* to) { - BNSetStructureType(m_object, t); + BNStructure* result = BNStructureWithReplacedNamedTypeReference(m_object, from->GetObject(), to->GetObject()); + if (result == m_object) + { + BNFreeStructure(result); + return this; + } + return new Structure(result); } -BNStructureType Structure::GetStructureType() const +StructureBuilder::StructureBuilder() { - return BNGetStructureType(m_object); + m_object = BNCreateStructureBuilder(); +} + + +StructureBuilder::StructureBuilder(BNStructureBuilder* s) +{ + m_object = s; +} + + +StructureBuilder::StructureBuilder(BNStructureType type, bool packed) +{ + m_object = BNCreateStructureBuilderWithOptions(type, packed); +} + + +StructureBuilder::StructureBuilder(const StructureBuilder& s) +{ + m_object = BNDuplicateStructureBuilder(s.m_object); +} + + +StructureBuilder::StructureBuilder(StructureBuilder&& s) +{ + m_object = s.m_object; + s.m_object = BNCreateStructureBuilder(); } -void Structure::AddMember(const Confidence<Ref<Type>>& type, const string& name) +StructureBuilder::StructureBuilder(Structure* s) +{ + m_object = BNCreateStructureBuilderFromStructure(s->GetObject()); +} + + +StructureBuilder::~StructureBuilder() +{ + BNFreeStructureBuilder(m_object); +} + + +StructureBuilder& StructureBuilder::operator=(const StructureBuilder& s) +{ + if (this != &s) + { + BNFreeStructureBuilder(m_object); + m_object = BNDuplicateStructureBuilder(s.m_object); + } + return *this; +} + + +StructureBuilder& StructureBuilder::operator=(StructureBuilder&& s) +{ + if (this != &s) + std::swap(m_object, s.m_object); + return *this; +} + + +StructureBuilder& StructureBuilder::operator=(Structure* s) +{ + BNFreeStructureBuilder(m_object); + m_object = BNCreateStructureBuilderFromStructure(s->GetObject()); + return *this; +} + + +Ref<Structure> StructureBuilder::Finalize() const +{ + return new Structure(BNFinalizeStructureBuilder(m_object)); +} + + +vector<StructureMember> StructureBuilder::GetMembers() const +{ + size_t count; + BNStructureMember* members = BNGetStructureBuilderMembers(m_object, &count); + + vector<StructureMember> result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + StructureMember member; + member.type = new Type(BNNewTypeReference(members[i].type)); + member.name = members[i].name; + member.offset = members[i].offset; + result.push_back(member); + } + + BNFreeStructureMemberList(members, count); + return result; +} + + +bool StructureBuilder::GetMemberByName(const string& name, StructureMember& result) const +{ + BNStructureMember* member = BNGetStructureBuilderMemberByName(m_object, name.c_str()); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +bool StructureBuilder::GetMemberAtOffset(int64_t offset, StructureMember& result) const +{ + size_t i; + return GetMemberAtOffset(offset, result, i); +} + + +bool StructureBuilder::GetMemberAtOffset(int64_t offset, StructureMember& result, size_t& idx) const +{ + BNStructureMember* member = BNGetStructureBuilderMemberAtOffset(m_object, offset, &idx); + if (member) + { + result.type = new Type(BNNewTypeReference(member->type)); + result.name = member->name; + result.offset = member->offset; + BNFreeStructureMember(member); + return true; + } + return false; +} + + +uint64_t StructureBuilder::GetWidth() const +{ + return BNGetStructureBuilderWidth(m_object); +} + + +void StructureBuilder::SetWidth(size_t width) +{ + BNSetStructureBuilderWidth(m_object, width); +} + + +size_t StructureBuilder::GetAlignment() const +{ + return BNGetStructureBuilderAlignment(m_object); +} + + +void StructureBuilder::SetAlignment(size_t align) +{ + BNSetStructureBuilderAlignment(m_object, align); +} + + +bool StructureBuilder::IsPacked() const +{ + return BNIsStructureBuilderPacked(m_object); +} + + +void StructureBuilder::SetPacked(bool packed) +{ + BNSetStructureBuilderPacked(m_object, packed); +} + + +bool StructureBuilder::IsUnion() const +{ + return BNIsStructureBuilderUnion(m_object); +} + + +void StructureBuilder::SetStructureType(BNStructureType t) +{ + BNSetStructureBuilderType(m_object, t); +} + + +BNStructureType StructureBuilder::GetStructureType() const +{ + return BNGetStructureBuilderType(m_object); +} + + +void StructureBuilder::AddMember(const Confidence<Ref<Type>>& type, const string& name) { BNTypeWithConfidence tc; tc.type = type->GetObject(); tc.confidence = type.GetConfidence(); - BNAddStructureMember(m_object, &tc, name.c_str()); + BNAddStructureBuilderMember(m_object, &tc, name.c_str()); } -void Structure::AddMemberAtOffset(const Confidence<Ref<Type>>& type, const string& name, uint64_t offset) +void StructureBuilder::AddMemberAtOffset(const Confidence<Ref<Type>>& type, const string& name, uint64_t offset) { BNTypeWithConfidence tc; tc.type = type->GetObject(); tc.confidence = type.GetConfidence(); - BNAddStructureMemberAtOffset(m_object, &tc, name.c_str(), offset); + BNAddStructureBuilderMemberAtOffset(m_object, &tc, name.c_str(), offset); } -void Structure::RemoveMember(size_t idx) +void StructureBuilder::RemoveMember(size_t idx) { - BNRemoveStructureMember(m_object, idx); + BNRemoveStructureBuilderMember(m_object, idx); } -void Structure::ReplaceMember(size_t idx, const Confidence<Ref<Type>>& type, const std::string& name) +void StructureBuilder::ReplaceMember(size_t idx, const Confidence<Ref<Type>>& type, const std::string& name) { BNTypeWithConfidence tc; tc.type = type->GetObject(); tc.confidence = type.GetConfidence(); - BNReplaceStructureMember(m_object, idx, &tc, name.c_str()); + BNReplaceStructureBuilderMember(m_object, idx, &tc, name.c_str()); } @@ -1219,16 +1877,101 @@ Enumeration::Enumeration(BNEnumeration* e) } -Enumeration::Enumeration() +vector<EnumerationMember> Enumeration::GetMembers() const +{ + size_t count; + BNEnumerationMember* members = BNGetEnumerationMembers(m_object, &count); + + vector<EnumerationMember> result; + result.reserve(count); + for (size_t i = 0; i < count; i++) + { + EnumerationMember member; + member.name = members[i].name; + member.value = members[i].value; + member.isDefault = members[i].isDefault; + result.push_back(member); + } + + BNFreeEnumerationMemberList(members, count); + return result; +} + + +EnumerationBuilder::EnumerationBuilder() { - m_object = BNCreateEnumeration(); + m_object = BNCreateEnumerationBuilder(); } -vector<EnumerationMember> Enumeration::GetMembers() const +EnumerationBuilder::EnumerationBuilder(BNEnumerationBuilder* e) +{ + m_object = e; +} + + +EnumerationBuilder::EnumerationBuilder(const EnumerationBuilder& e) +{ + m_object = BNDuplicateEnumerationBuilder(e.m_object); +} + + +EnumerationBuilder::EnumerationBuilder(EnumerationBuilder&& e) +{ + m_object = e.m_object; + e.m_object = BNCreateEnumerationBuilder(); +} + + +EnumerationBuilder::EnumerationBuilder(Enumeration* e) +{ + m_object = BNCreateEnumerationBuilderFromEnumeration(e->GetObject()); +} + + +EnumerationBuilder::~EnumerationBuilder() +{ + BNFreeEnumerationBuilder(m_object); +} + + +EnumerationBuilder& EnumerationBuilder::operator=(const EnumerationBuilder& e) +{ + if (this != &e) + { + BNFreeEnumerationBuilder(m_object); + m_object = BNDuplicateEnumerationBuilder(e.m_object); + } + return *this; +} + + +EnumerationBuilder& EnumerationBuilder::operator=(EnumerationBuilder&& e) +{ + if (this != &e) + std::swap(m_object, e.m_object); + return *this; +} + + +EnumerationBuilder& EnumerationBuilder::operator=(Enumeration* e) +{ + BNFreeEnumerationBuilder(m_object); + m_object = BNCreateEnumerationBuilderFromEnumeration(e->GetObject()); + return *this; +} + + +Ref<Enumeration> EnumerationBuilder::Finalize() const +{ + return new Enumeration(BNFinalizeEnumerationBuilder(m_object)); +} + + +vector<EnumerationMember> EnumerationBuilder::GetMembers() const { size_t count; - BNEnumerationMember* members = BNGetEnumerationMembers(m_object, &count); + BNEnumerationMember* members = BNGetEnumerationBuilderMembers(m_object, &count); vector<EnumerationMember> result; result.reserve(count); @@ -1246,27 +1989,27 @@ vector<EnumerationMember> Enumeration::GetMembers() const } -void Enumeration::AddMember(const string& name) +void EnumerationBuilder::AddMember(const string& name) { - BNAddEnumerationMember(m_object, name.c_str()); + BNAddEnumerationBuilderMember(m_object, name.c_str()); } -void Enumeration::AddMemberWithValue(const string& name, uint64_t value) +void EnumerationBuilder::AddMemberWithValue(const string& name, uint64_t value) { - BNAddEnumerationMemberWithValue(m_object, name.c_str(), value); + BNAddEnumerationBuilderMemberWithValue(m_object, name.c_str(), value); } -void Enumeration::RemoveMember(size_t idx) +void EnumerationBuilder::RemoveMember(size_t idx) { - BNRemoveEnumerationMember(m_object, idx); + BNRemoveEnumerationBuilderMember(m_object, idx); } -void Enumeration::ReplaceMember(size_t idx, const string& name, uint64_t value) +void EnumerationBuilder::ReplaceMember(size_t idx, const string& name, uint64_t value) { - BNReplaceEnumerationMember(m_object, idx, name.c_str(), value); + BNReplaceEnumerationBuilderMember(m_object, idx, name.c_str(), value); } |