ida-domain 0.3.6.dev2__tar.gz → 0.3.6.dev3__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/PKG-INFO +1 -1
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/__init__.py +1 -1
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/functions.py +1 -1
- ida_domain-0.3.6.dev3/ida_domain/py.typed +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/types.py +1065 -1
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/PKG-INFO +1 -1
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/SOURCES.txt +1 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/pyproject.toml +1 -1
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/LICENSE +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/README.md +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/base.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/bytes.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/comments.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/database.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/entries.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/flowchart.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/heads.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/hooks.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/instructions.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/names.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/operands.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/segments.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/signature_files.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/strings.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain/xrefs.py +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/dependency_links.txt +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/requires.txt +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/ida_domain.egg-info/top_level.txt +0 -0
- {ida_domain-0.3.6.dev2 → ida_domain-0.3.6.dev3}/setup.cfg +0 -0
|
@@ -649,7 +649,7 @@ class Functions(DatabaseEntity):
|
|
|
649
649
|
"""
|
|
650
650
|
return ida_domain.flowchart.FlowChart(self.database, func, None, flags)
|
|
651
651
|
|
|
652
|
-
def get_instructions(self, func: func_t) ->
|
|
652
|
+
def get_instructions(self, func: func_t) -> Iterator[insn_t]:
|
|
653
653
|
"""
|
|
654
654
|
Retrieves all instructions within the given function.
|
|
655
655
|
|
|
File without changes
|
|
@@ -2,22 +2,34 @@ from __future__ import annotations
|
|
|
2
2
|
|
|
3
3
|
import logging
|
|
4
4
|
import warnings
|
|
5
|
+
from dataclasses import dataclass
|
|
5
6
|
from enum import Enum, EnumMeta, Flag, IntEnum, IntFlag, auto
|
|
6
7
|
from pathlib import Path
|
|
7
8
|
|
|
8
9
|
import ida_nalt
|
|
9
10
|
import ida_typeinf
|
|
10
11
|
from ida_typeinf import (
|
|
12
|
+
BT_FLOAT,
|
|
13
|
+
BT_INT8,
|
|
14
|
+
BT_INT16,
|
|
15
|
+
BT_INT32,
|
|
16
|
+
BT_INT64,
|
|
17
|
+
BT_VOID,
|
|
18
|
+
BTF_STRUCT,
|
|
19
|
+
BTF_UNION,
|
|
20
|
+
BTMT_DOUBLE,
|
|
11
21
|
array_type_data_t,
|
|
12
22
|
bitfield_type_data_t,
|
|
13
23
|
enum_type_data_t,
|
|
14
24
|
func_type_data_t,
|
|
25
|
+
funcarg_t,
|
|
15
26
|
ptr_type_data_t,
|
|
16
27
|
til_t,
|
|
17
28
|
tinfo_t,
|
|
29
|
+
udm_t,
|
|
18
30
|
udt_type_data_t,
|
|
19
31
|
)
|
|
20
|
-
from typing_extensions import TYPE_CHECKING, Callable, Dict, Iterator, Optional, Tuple
|
|
32
|
+
from typing_extensions import TYPE_CHECKING, Callable, Dict, Iterator, List, Optional, Tuple, Union
|
|
21
33
|
|
|
22
34
|
from . import __ida_version__
|
|
23
35
|
from .base import (
|
|
@@ -867,6 +879,477 @@ class TypeDetailsVisitor(ida_typeinf.tinfo_visitor_t):
|
|
|
867
879
|
return 0
|
|
868
880
|
|
|
869
881
|
|
|
882
|
+
# =============================================================================
|
|
883
|
+
# Member Information Dataclasses
|
|
884
|
+
# =============================================================================
|
|
885
|
+
|
|
886
|
+
|
|
887
|
+
@dataclass
|
|
888
|
+
class UdtMemberInfo:
|
|
889
|
+
"""Details about a struct/union member."""
|
|
890
|
+
|
|
891
|
+
name: str
|
|
892
|
+
"""Member name."""
|
|
893
|
+
|
|
894
|
+
type: tinfo_t
|
|
895
|
+
"""Member type information."""
|
|
896
|
+
|
|
897
|
+
offset: int
|
|
898
|
+
"""Byte offset within the structure."""
|
|
899
|
+
|
|
900
|
+
size: int
|
|
901
|
+
"""Size in bytes."""
|
|
902
|
+
|
|
903
|
+
is_bitfield: bool
|
|
904
|
+
"""True if this is a bitfield member."""
|
|
905
|
+
|
|
906
|
+
bit_offset: Optional[int] = None
|
|
907
|
+
"""Bit offset within the byte (for bitfields only)."""
|
|
908
|
+
|
|
909
|
+
bit_size: Optional[int] = None
|
|
910
|
+
"""Bit size (for bitfields only)."""
|
|
911
|
+
|
|
912
|
+
|
|
913
|
+
@dataclass
|
|
914
|
+
class EnumMemberInfo:
|
|
915
|
+
"""Details about an enum member."""
|
|
916
|
+
|
|
917
|
+
name: str
|
|
918
|
+
"""Member name."""
|
|
919
|
+
|
|
920
|
+
value: int
|
|
921
|
+
"""Numeric value."""
|
|
922
|
+
|
|
923
|
+
|
|
924
|
+
@dataclass
|
|
925
|
+
class FuncArgumentInfo:
|
|
926
|
+
"""Details about a function argument."""
|
|
927
|
+
|
|
928
|
+
index: int
|
|
929
|
+
"""Argument index (0-based)."""
|
|
930
|
+
|
|
931
|
+
name: str
|
|
932
|
+
"""Argument name (may be empty/auto-generated)."""
|
|
933
|
+
|
|
934
|
+
type: tinfo_t
|
|
935
|
+
"""Argument type information."""
|
|
936
|
+
|
|
937
|
+
|
|
938
|
+
# =============================================================================
|
|
939
|
+
# Type Member Lookup Mode
|
|
940
|
+
# =============================================================================
|
|
941
|
+
|
|
942
|
+
|
|
943
|
+
class TypeMemberLookupMode(Enum):
|
|
944
|
+
"""Mode for member lookup operations."""
|
|
945
|
+
|
|
946
|
+
NAME = "name"
|
|
947
|
+
"""Look up member by name"""
|
|
948
|
+
|
|
949
|
+
OFFSET = "offset"
|
|
950
|
+
"""Look up member by offset (for UDT)"""
|
|
951
|
+
|
|
952
|
+
INDEX = "index"
|
|
953
|
+
"""Look up member by index (for enum, func args)"""
|
|
954
|
+
|
|
955
|
+
VALUE = "value"
|
|
956
|
+
"""Look up member by value (for enum)"""
|
|
957
|
+
|
|
958
|
+
|
|
959
|
+
# =============================================================================
|
|
960
|
+
# Calling Convention Enum
|
|
961
|
+
# =============================================================================
|
|
962
|
+
|
|
963
|
+
|
|
964
|
+
class CallingConvention(Enum):
|
|
965
|
+
"""Calling convention for function types."""
|
|
966
|
+
|
|
967
|
+
CDECL = "cdecl"
|
|
968
|
+
STDCALL = "stdcall"
|
|
969
|
+
FASTCALL = "fastcall"
|
|
970
|
+
THISCALL = "thiscall"
|
|
971
|
+
DEFAULT = "default"
|
|
972
|
+
|
|
973
|
+
|
|
974
|
+
# =============================================================================
|
|
975
|
+
# Type Builders
|
|
976
|
+
# =============================================================================
|
|
977
|
+
|
|
978
|
+
|
|
979
|
+
class StructBuilder:
|
|
980
|
+
"""
|
|
981
|
+
Builder for creating struct types.
|
|
982
|
+
|
|
983
|
+
Example:
|
|
984
|
+
>>> builder = db.types.create_struct("MyStruct")
|
|
985
|
+
>>> builder.add_member("x", db.types.create_primitive(4))
|
|
986
|
+
>>> builder.add_member("y", db.types.create_primitive(4))
|
|
987
|
+
>>> my_struct = builder.build()
|
|
988
|
+
"""
|
|
989
|
+
|
|
990
|
+
def __init__(self, name: str) -> None:
|
|
991
|
+
"""
|
|
992
|
+
Initialize a struct builder.
|
|
993
|
+
|
|
994
|
+
Args:
|
|
995
|
+
name: Name for the struct type.
|
|
996
|
+
"""
|
|
997
|
+
self._name = name
|
|
998
|
+
self._members: List[Tuple[str, tinfo_t, Optional[int]]] = []
|
|
999
|
+
self._packed = False
|
|
1000
|
+
self._alignment: Optional[int] = None
|
|
1001
|
+
|
|
1002
|
+
def add_member(
|
|
1003
|
+
self,
|
|
1004
|
+
name: str,
|
|
1005
|
+
member_type: tinfo_t,
|
|
1006
|
+
offset: Optional[int] = None
|
|
1007
|
+
) -> 'StructBuilder':
|
|
1008
|
+
"""
|
|
1009
|
+
Add a member to the struct.
|
|
1010
|
+
|
|
1011
|
+
Args:
|
|
1012
|
+
name: Member name.
|
|
1013
|
+
member_type: Member type.
|
|
1014
|
+
offset: Explicit byte offset (auto-calculated if None).
|
|
1015
|
+
|
|
1016
|
+
Returns:
|
|
1017
|
+
Self for method chaining.
|
|
1018
|
+
"""
|
|
1019
|
+
self._members.append((name, member_type, offset))
|
|
1020
|
+
return self
|
|
1021
|
+
|
|
1022
|
+
def set_packed(self, packed: bool = True) -> 'StructBuilder':
|
|
1023
|
+
"""
|
|
1024
|
+
Set whether the struct is packed (no padding).
|
|
1025
|
+
"""
|
|
1026
|
+
self._packed = packed
|
|
1027
|
+
return self
|
|
1028
|
+
|
|
1029
|
+
def set_alignment(self, alignment: int) -> 'StructBuilder':
|
|
1030
|
+
"""
|
|
1031
|
+
Set explicit alignment for the struct.
|
|
1032
|
+
"""
|
|
1033
|
+
self._alignment = alignment
|
|
1034
|
+
return self
|
|
1035
|
+
|
|
1036
|
+
def build(self) -> tinfo_t:
|
|
1037
|
+
"""
|
|
1038
|
+
Build and return the struct type.
|
|
1039
|
+
|
|
1040
|
+
Returns:
|
|
1041
|
+
The constructed tinfo_t.
|
|
1042
|
+
|
|
1043
|
+
Raises:
|
|
1044
|
+
RuntimeError: If struct creation fails.
|
|
1045
|
+
"""
|
|
1046
|
+
udt = udt_type_data_t()
|
|
1047
|
+
udt.is_union = False
|
|
1048
|
+
|
|
1049
|
+
for name, member_type, offset in self._members:
|
|
1050
|
+
if offset is not None:
|
|
1051
|
+
udt_member = udt.add_member(name, member_type, offset)
|
|
1052
|
+
else:
|
|
1053
|
+
udt_member = udt.add_member(name, member_type)
|
|
1054
|
+
if udt_member is None:
|
|
1055
|
+
raise RuntimeError(f"Failed to add member '{name}' to struct '{self._name}'")
|
|
1056
|
+
|
|
1057
|
+
result = tinfo_t()
|
|
1058
|
+
if not result.create_udt(udt, BTF_STRUCT):
|
|
1059
|
+
raise RuntimeError(f"Failed to create struct '{self._name}'")
|
|
1060
|
+
|
|
1061
|
+
return result
|
|
1062
|
+
|
|
1063
|
+
def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
|
|
1064
|
+
"""
|
|
1065
|
+
Build the struct and save it to a type library.
|
|
1066
|
+
|
|
1067
|
+
Args:
|
|
1068
|
+
library: Target library (local library if None).
|
|
1069
|
+
|
|
1070
|
+
Returns:
|
|
1071
|
+
The constructed and saved tinfo_t.
|
|
1072
|
+
"""
|
|
1073
|
+
result = self.build()
|
|
1074
|
+
if library is None:
|
|
1075
|
+
library = ida_typeinf.get_idati()
|
|
1076
|
+
if result.set_named_type(library, self._name) < 0:
|
|
1077
|
+
raise RuntimeError(f"Failed to save struct '{self._name}' to library")
|
|
1078
|
+
return result
|
|
1079
|
+
|
|
1080
|
+
|
|
1081
|
+
class UnionBuilder:
|
|
1082
|
+
"""
|
|
1083
|
+
Builder for creating union types.
|
|
1084
|
+
|
|
1085
|
+
Example:
|
|
1086
|
+
>>> builder = db.types.create_union("MyUnion")
|
|
1087
|
+
>>> builder.add_member("as_int", db.types.create_primitive(4))
|
|
1088
|
+
>>> builder.add_member("as_float", db.types.create_primitive(4))
|
|
1089
|
+
>>> my_union = builder.build()
|
|
1090
|
+
"""
|
|
1091
|
+
|
|
1092
|
+
def __init__(self, name: str) -> None:
|
|
1093
|
+
"""
|
|
1094
|
+
Initialize a union builder.
|
|
1095
|
+
|
|
1096
|
+
Args:
|
|
1097
|
+
name: Name for the union type.
|
|
1098
|
+
"""
|
|
1099
|
+
self._name = name
|
|
1100
|
+
self._members: List[Tuple[str, tinfo_t]] = []
|
|
1101
|
+
|
|
1102
|
+
def add_member(self, name: str, member_type: tinfo_t) -> 'UnionBuilder':
|
|
1103
|
+
"""
|
|
1104
|
+
Add a member to the union.
|
|
1105
|
+
|
|
1106
|
+
Args:
|
|
1107
|
+
name: Member name.
|
|
1108
|
+
member_type: Member type.
|
|
1109
|
+
|
|
1110
|
+
Returns:
|
|
1111
|
+
Self for method chaining.
|
|
1112
|
+
"""
|
|
1113
|
+
self._members.append((name, member_type))
|
|
1114
|
+
return self
|
|
1115
|
+
|
|
1116
|
+
def build(self) -> tinfo_t:
|
|
1117
|
+
"""
|
|
1118
|
+
Build and return the union type.
|
|
1119
|
+
|
|
1120
|
+
Returns:
|
|
1121
|
+
The constructed tinfo_t.
|
|
1122
|
+
|
|
1123
|
+
Raises:
|
|
1124
|
+
RuntimeError: If union creation fails.
|
|
1125
|
+
"""
|
|
1126
|
+
udt = udt_type_data_t()
|
|
1127
|
+
udt.is_union = True
|
|
1128
|
+
|
|
1129
|
+
for name, member_type in self._members:
|
|
1130
|
+
udt_member = udt.add_member(name, member_type)
|
|
1131
|
+
if udt_member is None:
|
|
1132
|
+
raise RuntimeError(f"Failed to add member '{name}' to union '{self._name}'")
|
|
1133
|
+
|
|
1134
|
+
result = tinfo_t()
|
|
1135
|
+
if not result.create_udt(udt, BTF_UNION):
|
|
1136
|
+
raise RuntimeError(f"Failed to create union '{self._name}'")
|
|
1137
|
+
|
|
1138
|
+
return result
|
|
1139
|
+
|
|
1140
|
+
def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
|
|
1141
|
+
"""
|
|
1142
|
+
Build the union and save it to a type library.
|
|
1143
|
+
|
|
1144
|
+
Args:
|
|
1145
|
+
library: Target library (local library if None).
|
|
1146
|
+
|
|
1147
|
+
Returns:
|
|
1148
|
+
The constructed and saved tinfo_t.
|
|
1149
|
+
"""
|
|
1150
|
+
result = self.build()
|
|
1151
|
+
if library is None:
|
|
1152
|
+
library = ida_typeinf.get_idati()
|
|
1153
|
+
if result.set_named_type(library, self._name) < 0:
|
|
1154
|
+
raise RuntimeError(f"Failed to save union '{self._name}' to library")
|
|
1155
|
+
return result
|
|
1156
|
+
|
|
1157
|
+
|
|
1158
|
+
class EnumBuilder:
|
|
1159
|
+
"""
|
|
1160
|
+
Builder for creating enum types.
|
|
1161
|
+
|
|
1162
|
+
Example:
|
|
1163
|
+
>>> builder = db.types.create_enum("FileMode", base_size=4)
|
|
1164
|
+
>>> builder.add_member("READ", 1)
|
|
1165
|
+
>>> builder.add_member("WRITE", 2)
|
|
1166
|
+
>>> builder.add_member("EXEC", 4)
|
|
1167
|
+
>>> file_mode = builder.build()
|
|
1168
|
+
"""
|
|
1169
|
+
|
|
1170
|
+
def __init__(self, name: str, base_size: int = 4) -> None:
|
|
1171
|
+
"""
|
|
1172
|
+
Initialize an enum builder.
|
|
1173
|
+
|
|
1174
|
+
Args:
|
|
1175
|
+
name: Name for the enum type.
|
|
1176
|
+
base_size: Size in bytes (1, 2, 4, or 8).
|
|
1177
|
+
"""
|
|
1178
|
+
self._name = name
|
|
1179
|
+
self._base_size = base_size
|
|
1180
|
+
self._members: List[Tuple[str, int]] = []
|
|
1181
|
+
self._is_bitmask = False
|
|
1182
|
+
|
|
1183
|
+
def add_member(self, name: str, value: int) -> 'EnumBuilder':
|
|
1184
|
+
"""
|
|
1185
|
+
Add a member to the enum.
|
|
1186
|
+
|
|
1187
|
+
Args:
|
|
1188
|
+
name: Member name.
|
|
1189
|
+
value: Numeric value.
|
|
1190
|
+
|
|
1191
|
+
Returns:
|
|
1192
|
+
Self for method chaining.
|
|
1193
|
+
"""
|
|
1194
|
+
self._members.append((name, value))
|
|
1195
|
+
return self
|
|
1196
|
+
|
|
1197
|
+
def set_bitmask(self, is_bitmask: bool = True) -> 'EnumBuilder':
|
|
1198
|
+
"""
|
|
1199
|
+
Set whether this is a bitmask enum.
|
|
1200
|
+
"""
|
|
1201
|
+
self._is_bitmask = is_bitmask
|
|
1202
|
+
return self
|
|
1203
|
+
|
|
1204
|
+
def build(self) -> tinfo_t:
|
|
1205
|
+
"""
|
|
1206
|
+
Build and return the enum type.
|
|
1207
|
+
|
|
1208
|
+
Returns:
|
|
1209
|
+
The constructed tinfo_t.
|
|
1210
|
+
|
|
1211
|
+
Raises:
|
|
1212
|
+
RuntimeError: If enum creation fails.
|
|
1213
|
+
"""
|
|
1214
|
+
enum_data = enum_type_data_t()
|
|
1215
|
+
|
|
1216
|
+
for name, value in self._members:
|
|
1217
|
+
enum_data.add_constant(name, value)
|
|
1218
|
+
|
|
1219
|
+
if self._is_bitmask:
|
|
1220
|
+
enum_data.set_bf(True)
|
|
1221
|
+
|
|
1222
|
+
result = tinfo_t()
|
|
1223
|
+
if not result.create_enum(enum_data):
|
|
1224
|
+
raise RuntimeError(f"Failed to create enum '{self._name}'")
|
|
1225
|
+
|
|
1226
|
+
return result
|
|
1227
|
+
|
|
1228
|
+
def build_and_save(self, library: Optional[til_t] = None) -> tinfo_t:
|
|
1229
|
+
"""
|
|
1230
|
+
Build the enum and save it to a type library.
|
|
1231
|
+
|
|
1232
|
+
Args:
|
|
1233
|
+
library: Target library (local library if None).
|
|
1234
|
+
|
|
1235
|
+
Returns:
|
|
1236
|
+
The constructed and saved tinfo_t.
|
|
1237
|
+
"""
|
|
1238
|
+
result = self.build()
|
|
1239
|
+
if library is None:
|
|
1240
|
+
library = ida_typeinf.get_idati()
|
|
1241
|
+
if result.set_named_type(library, self._name) < 0:
|
|
1242
|
+
raise RuntimeError(f"Failed to save enum '{self._name}' to library")
|
|
1243
|
+
return result
|
|
1244
|
+
|
|
1245
|
+
|
|
1246
|
+
class FuncTypeBuilder:
|
|
1247
|
+
"""
|
|
1248
|
+
Builder for creating function types.
|
|
1249
|
+
|
|
1250
|
+
Example:
|
|
1251
|
+
>>> builder = db.types.create_func_type()
|
|
1252
|
+
>>> builder.set_return_type(db.types.create_primitive(4))
|
|
1253
|
+
>>> builder.add_argument("count", db.types.create_primitive(4))
|
|
1254
|
+
>>> builder.add_argument("buffer", db.types.create_pointer(db.types.create_primitive(1)))
|
|
1255
|
+
>>> func_type = builder.build()
|
|
1256
|
+
"""
|
|
1257
|
+
|
|
1258
|
+
def __init__(self) -> None:
|
|
1259
|
+
"""Initialize a function type builder."""
|
|
1260
|
+
self._return_type: Optional[tinfo_t] = None
|
|
1261
|
+
self._arguments: List[Tuple[str, tinfo_t]] = []
|
|
1262
|
+
self._calling_convention: Optional[CallingConvention] = None
|
|
1263
|
+
self._variadic = False
|
|
1264
|
+
|
|
1265
|
+
def set_return_type(self, ret_type: tinfo_t) -> 'FuncTypeBuilder':
|
|
1266
|
+
"""
|
|
1267
|
+
Set the return type.
|
|
1268
|
+
|
|
1269
|
+
Args:
|
|
1270
|
+
ret_type: Return type (void if not set).
|
|
1271
|
+
|
|
1272
|
+
Returns:
|
|
1273
|
+
Self for method chaining.
|
|
1274
|
+
"""
|
|
1275
|
+
self._return_type = ret_type
|
|
1276
|
+
return self
|
|
1277
|
+
|
|
1278
|
+
def add_argument(
|
|
1279
|
+
self,
|
|
1280
|
+
name: str,
|
|
1281
|
+
arg_type: tinfo_t
|
|
1282
|
+
) -> 'FuncTypeBuilder':
|
|
1283
|
+
"""
|
|
1284
|
+
Add an argument to the function type.
|
|
1285
|
+
|
|
1286
|
+
Args:
|
|
1287
|
+
name: Argument name.
|
|
1288
|
+
arg_type: Argument type.
|
|
1289
|
+
|
|
1290
|
+
Returns:
|
|
1291
|
+
Self for method chaining.
|
|
1292
|
+
"""
|
|
1293
|
+
self._arguments.append((name, arg_type))
|
|
1294
|
+
return self
|
|
1295
|
+
|
|
1296
|
+
def set_calling_convention(self, cc: CallingConvention) -> 'FuncTypeBuilder':
|
|
1297
|
+
"""
|
|
1298
|
+
Set the calling convention.
|
|
1299
|
+
|
|
1300
|
+
Args:
|
|
1301
|
+
cc: Calling convention enum value.
|
|
1302
|
+
|
|
1303
|
+
Returns:
|
|
1304
|
+
Self for method chaining.
|
|
1305
|
+
"""
|
|
1306
|
+
self._calling_convention = cc
|
|
1307
|
+
return self
|
|
1308
|
+
|
|
1309
|
+
def set_variadic(self, variadic: bool = True) -> 'FuncTypeBuilder':
|
|
1310
|
+
"""
|
|
1311
|
+
Set whether function accepts variable arguments.
|
|
1312
|
+
|
|
1313
|
+
Returns:
|
|
1314
|
+
Self for method chaining.
|
|
1315
|
+
"""
|
|
1316
|
+
self._variadic = variadic
|
|
1317
|
+
return self
|
|
1318
|
+
|
|
1319
|
+
def build(self) -> tinfo_t:
|
|
1320
|
+
"""
|
|
1321
|
+
Build and return the function type.
|
|
1322
|
+
|
|
1323
|
+
Returns:
|
|
1324
|
+
The constructed tinfo_t.
|
|
1325
|
+
|
|
1326
|
+
Raises:
|
|
1327
|
+
RuntimeError: If function type creation fails.
|
|
1328
|
+
"""
|
|
1329
|
+
ftd = func_type_data_t()
|
|
1330
|
+
|
|
1331
|
+
# Set return type
|
|
1332
|
+
if self._return_type is not None:
|
|
1333
|
+
ftd.rettype = self._return_type
|
|
1334
|
+
else:
|
|
1335
|
+
void_type = tinfo_t()
|
|
1336
|
+
void_type.create_simple_type(BT_VOID)
|
|
1337
|
+
ftd.rettype = void_type
|
|
1338
|
+
|
|
1339
|
+
# Add arguments
|
|
1340
|
+
for name, arg_type in self._arguments:
|
|
1341
|
+
fa = funcarg_t()
|
|
1342
|
+
fa.name = name
|
|
1343
|
+
fa.type = arg_type
|
|
1344
|
+
ftd.push_back(fa)
|
|
1345
|
+
|
|
1346
|
+
result = tinfo_t()
|
|
1347
|
+
if not result.create_func(ftd):
|
|
1348
|
+
raise RuntimeError("Failed to create function type")
|
|
1349
|
+
|
|
1350
|
+
return result
|
|
1351
|
+
|
|
1352
|
+
|
|
870
1353
|
@decorate_all_methods(check_db_open)
|
|
871
1354
|
class Types(DatabaseEntity):
|
|
872
1355
|
"""
|
|
@@ -1234,3 +1717,584 @@ class Types(DatabaseEntity):
|
|
|
1234
1717
|
Comment text, or empty string if no comment exists.
|
|
1235
1718
|
"""
|
|
1236
1719
|
return type_info.get_type_cmt() or ''
|
|
1720
|
+
|
|
1721
|
+
# =========================================================================
|
|
1722
|
+
# UDT (Struct/Union) Member Access
|
|
1723
|
+
# =========================================================================
|
|
1724
|
+
|
|
1725
|
+
def get_udt_members(self, type_info: tinfo_t) -> Iterator[UdtMemberInfo]:
|
|
1726
|
+
"""
|
|
1727
|
+
Iterate over all members of a struct or union type.
|
|
1728
|
+
|
|
1729
|
+
Args:
|
|
1730
|
+
type_info: A UDT (struct or union) type.
|
|
1731
|
+
|
|
1732
|
+
Returns:
|
|
1733
|
+
Iterator of UdtMemberInfo for each member.
|
|
1734
|
+
Empty iterator if type is not a UDT.
|
|
1735
|
+
|
|
1736
|
+
Example:
|
|
1737
|
+
>>> struct_type = db.types.get_by_name("MyStruct")
|
|
1738
|
+
>>> for member in db.types.get_udt_members(struct_type):
|
|
1739
|
+
... print(f"{member.name}: {member.size} bytes at offset {member.offset}")
|
|
1740
|
+
"""
|
|
1741
|
+
if not type_info.is_udt():
|
|
1742
|
+
return
|
|
1743
|
+
|
|
1744
|
+
udt_data = udt_type_data_t()
|
|
1745
|
+
if not type_info.get_udt_details(udt_data):
|
|
1746
|
+
return
|
|
1747
|
+
|
|
1748
|
+
for member in udt_data:
|
|
1749
|
+
m: udm_t = member
|
|
1750
|
+
byte_offset = int(m.offset) // 8 # Offsets are in bits
|
|
1751
|
+
is_bitfield = m.type.is_bitfield()
|
|
1752
|
+
|
|
1753
|
+
bit_offset = None
|
|
1754
|
+
bit_size = None
|
|
1755
|
+
if is_bitfield:
|
|
1756
|
+
bit_offset = int(m.offset) % 8
|
|
1757
|
+
bit_size = m.size
|
|
1758
|
+
|
|
1759
|
+
yield UdtMemberInfo(
|
|
1760
|
+
name=m.name,
|
|
1761
|
+
type=m.type,
|
|
1762
|
+
offset=byte_offset,
|
|
1763
|
+
size=m.type.get_size(),
|
|
1764
|
+
is_bitfield=is_bitfield,
|
|
1765
|
+
bit_offset=bit_offset,
|
|
1766
|
+
bit_size=bit_size,
|
|
1767
|
+
)
|
|
1768
|
+
|
|
1769
|
+
def get_udt_member_by_name(
|
|
1770
|
+
self, type_info: tinfo_t, name: str
|
|
1771
|
+
) -> Optional[UdtMemberInfo]:
|
|
1772
|
+
"""
|
|
1773
|
+
Get a specific UDT member by name.
|
|
1774
|
+
|
|
1775
|
+
Args:
|
|
1776
|
+
type_info: A UDT (struct or union) type.
|
|
1777
|
+
name: Member name to find.
|
|
1778
|
+
|
|
1779
|
+
Returns:
|
|
1780
|
+
UdtMemberInfo if found, None otherwise.
|
|
1781
|
+
"""
|
|
1782
|
+
for member in self.get_udt_members(type_info):
|
|
1783
|
+
if member.name == name:
|
|
1784
|
+
return member
|
|
1785
|
+
return None
|
|
1786
|
+
|
|
1787
|
+
def get_udt_member_by_offset(
|
|
1788
|
+
self, type_info: tinfo_t, offset: int
|
|
1789
|
+
) -> Optional[UdtMemberInfo]:
|
|
1790
|
+
"""
|
|
1791
|
+
Get a UDT member at the specified byte offset.
|
|
1792
|
+
|
|
1793
|
+
Args:
|
|
1794
|
+
type_info: A UDT (struct or union) type.
|
|
1795
|
+
offset: Byte offset within the structure.
|
|
1796
|
+
|
|
1797
|
+
Returns:
|
|
1798
|
+
UdtMemberInfo if found, None otherwise.
|
|
1799
|
+
"""
|
|
1800
|
+
for member in self.get_udt_members(type_info):
|
|
1801
|
+
if member.offset == offset:
|
|
1802
|
+
return member
|
|
1803
|
+
return None
|
|
1804
|
+
|
|
1805
|
+
def get_udt_member_count(self, type_info: tinfo_t) -> int:
|
|
1806
|
+
"""
|
|
1807
|
+
Get the number of members in a UDT.
|
|
1808
|
+
|
|
1809
|
+
Args:
|
|
1810
|
+
type_info: A UDT type.
|
|
1811
|
+
|
|
1812
|
+
Returns:
|
|
1813
|
+
Member count, or 0 if not a UDT.
|
|
1814
|
+
"""
|
|
1815
|
+
if not type_info.is_udt():
|
|
1816
|
+
return 0
|
|
1817
|
+
return type_info.get_udt_nmembers()
|
|
1818
|
+
|
|
1819
|
+
# =========================================================================
|
|
1820
|
+
# Enum Member Access
|
|
1821
|
+
# =========================================================================
|
|
1822
|
+
|
|
1823
|
+
def get_enum_members(self, type_info: tinfo_t) -> Iterator[EnumMemberInfo]:
|
|
1824
|
+
"""
|
|
1825
|
+
Iterate over all members of an enum type.
|
|
1826
|
+
|
|
1827
|
+
Args:
|
|
1828
|
+
type_info: An enum type.
|
|
1829
|
+
|
|
1830
|
+
Returns:
|
|
1831
|
+
Iterator of EnumMemberInfo for each member.
|
|
1832
|
+
Empty iterator if type is not an enum.
|
|
1833
|
+
|
|
1834
|
+
Example:
|
|
1835
|
+
>>> enum_type = db.types.get_by_name("FileMode")
|
|
1836
|
+
>>> for member in db.types.get_enum_members(enum_type):
|
|
1837
|
+
... print(f"{member.name} = {member.value}")
|
|
1838
|
+
"""
|
|
1839
|
+
if not type_info.is_enum():
|
|
1840
|
+
return
|
|
1841
|
+
|
|
1842
|
+
for e in type_info.iter_enum():
|
|
1843
|
+
yield EnumMemberInfo(name=e.name, value=e.value)
|
|
1844
|
+
|
|
1845
|
+
def get_enum_member_by_name(
|
|
1846
|
+
self, type_info: tinfo_t, name: str
|
|
1847
|
+
) -> Optional[EnumMemberInfo]:
|
|
1848
|
+
"""
|
|
1849
|
+
Get a specific enum member by name.
|
|
1850
|
+
|
|
1851
|
+
Args:
|
|
1852
|
+
type_info: An enum type.
|
|
1853
|
+
name: Member name to find.
|
|
1854
|
+
|
|
1855
|
+
Returns:
|
|
1856
|
+
EnumMemberInfo if found, None otherwise.
|
|
1857
|
+
"""
|
|
1858
|
+
for member in self.get_enum_members(type_info):
|
|
1859
|
+
if member.name == name:
|
|
1860
|
+
return member
|
|
1861
|
+
return None
|
|
1862
|
+
|
|
1863
|
+
def get_enum_member_by_value(
|
|
1864
|
+
self, type_info: tinfo_t, value: int
|
|
1865
|
+
) -> Optional[EnumMemberInfo]:
|
|
1866
|
+
"""
|
|
1867
|
+
Get a specific enum member by value.
|
|
1868
|
+
|
|
1869
|
+
Args:
|
|
1870
|
+
type_info: An enum type.
|
|
1871
|
+
value: Numeric value to find.
|
|
1872
|
+
|
|
1873
|
+
Returns:
|
|
1874
|
+
EnumMemberInfo if found, None otherwise.
|
|
1875
|
+
"""
|
|
1876
|
+
for member in self.get_enum_members(type_info):
|
|
1877
|
+
if member.value == value:
|
|
1878
|
+
return member
|
|
1879
|
+
return None
|
|
1880
|
+
|
|
1881
|
+
def get_enum_member_count(self, type_info: tinfo_t) -> int:
|
|
1882
|
+
"""
|
|
1883
|
+
Get the number of members in an enum.
|
|
1884
|
+
|
|
1885
|
+
Args:
|
|
1886
|
+
type_info: An enum type.
|
|
1887
|
+
|
|
1888
|
+
Returns:
|
|
1889
|
+
Member count, or 0 if not an enum.
|
|
1890
|
+
"""
|
|
1891
|
+
if not type_info.is_enum():
|
|
1892
|
+
return 0
|
|
1893
|
+
|
|
1894
|
+
enum_data = enum_type_data_t()
|
|
1895
|
+
if type_info.get_enum_details(enum_data):
|
|
1896
|
+
return enum_data.size()
|
|
1897
|
+
return 0
|
|
1898
|
+
|
|
1899
|
+
# =========================================================================
|
|
1900
|
+
# Function Type Access
|
|
1901
|
+
# =========================================================================
|
|
1902
|
+
|
|
1903
|
+
def get_func_arguments(self, type_info: tinfo_t) -> Iterator[FuncArgumentInfo]:
|
|
1904
|
+
"""
|
|
1905
|
+
Iterate over all arguments of a function type.
|
|
1906
|
+
|
|
1907
|
+
Args:
|
|
1908
|
+
type_info: A function type.
|
|
1909
|
+
|
|
1910
|
+
Returns:
|
|
1911
|
+
Iterator of FuncArgumentInfo for each argument.
|
|
1912
|
+
Empty iterator if type is not a function.
|
|
1913
|
+
|
|
1914
|
+
Example:
|
|
1915
|
+
>>> func_type = db.types.get_at(0x401000)
|
|
1916
|
+
>>> for arg in db.types.get_func_arguments(func_type):
|
|
1917
|
+
... print(f"Arg {arg.index}: {arg.name}")
|
|
1918
|
+
"""
|
|
1919
|
+
if not type_info.is_func():
|
|
1920
|
+
return
|
|
1921
|
+
|
|
1922
|
+
for i, arg in enumerate(type_info.iter_func()):
|
|
1923
|
+
arg_name = arg.name if arg.name else f"arg{i}"
|
|
1924
|
+
yield FuncArgumentInfo(index=i, name=arg_name, type=arg.type)
|
|
1925
|
+
|
|
1926
|
+
def get_func_argument_by_index(
|
|
1927
|
+
self, type_info: tinfo_t, index: int
|
|
1928
|
+
) -> Optional[FuncArgumentInfo]:
|
|
1929
|
+
"""
|
|
1930
|
+
Get a specific function argument by index.
|
|
1931
|
+
|
|
1932
|
+
Args:
|
|
1933
|
+
type_info: A function type.
|
|
1934
|
+
index: Argument index (0-based).
|
|
1935
|
+
|
|
1936
|
+
Returns:
|
|
1937
|
+
FuncArgumentInfo if found, None otherwise.
|
|
1938
|
+
"""
|
|
1939
|
+
for arg in self.get_func_arguments(type_info):
|
|
1940
|
+
if arg.index == index:
|
|
1941
|
+
return arg
|
|
1942
|
+
return None
|
|
1943
|
+
|
|
1944
|
+
def get_func_argument_count(self, type_info: tinfo_t) -> int:
|
|
1945
|
+
"""
|
|
1946
|
+
Get the number of arguments in a function type.
|
|
1947
|
+
|
|
1948
|
+
Args:
|
|
1949
|
+
type_info: A function type.
|
|
1950
|
+
|
|
1951
|
+
Returns:
|
|
1952
|
+
Argument count, or 0 if not a function type.
|
|
1953
|
+
"""
|
|
1954
|
+
if not type_info.is_func():
|
|
1955
|
+
return 0
|
|
1956
|
+
|
|
1957
|
+
func_data = func_type_data_t()
|
|
1958
|
+
if type_info.get_func_details(func_data):
|
|
1959
|
+
return len(func_data)
|
|
1960
|
+
return 0
|
|
1961
|
+
|
|
1962
|
+
def get_return_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
|
|
1963
|
+
"""
|
|
1964
|
+
Get the return type of a function type.
|
|
1965
|
+
|
|
1966
|
+
Args:
|
|
1967
|
+
type_info: A function type.
|
|
1968
|
+
|
|
1969
|
+
Returns:
|
|
1970
|
+
The return type, or None if not a function type.
|
|
1971
|
+
"""
|
|
1972
|
+
if not type_info.is_func():
|
|
1973
|
+
return None
|
|
1974
|
+
return type_info.get_rettype()
|
|
1975
|
+
|
|
1976
|
+
# =========================================================================
|
|
1977
|
+
# Pointer/Array Type Access
|
|
1978
|
+
# =========================================================================
|
|
1979
|
+
|
|
1980
|
+
def get_pointed_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
|
|
1981
|
+
"""
|
|
1982
|
+
Get the type pointed to by a pointer type.
|
|
1983
|
+
|
|
1984
|
+
Args:
|
|
1985
|
+
type_info: A pointer type.
|
|
1986
|
+
|
|
1987
|
+
Returns:
|
|
1988
|
+
The pointed-to type, or None if not a pointer.
|
|
1989
|
+
|
|
1990
|
+
Example:
|
|
1991
|
+
>>> ptr_type = db.types.get_at(0x401000) # char*
|
|
1992
|
+
>>> base = db.types.get_pointed_type(ptr_type) # char
|
|
1993
|
+
"""
|
|
1994
|
+
if not type_info.is_ptr() and not type_info.is_funcptr():
|
|
1995
|
+
return None
|
|
1996
|
+
return type_info.get_pointed_object()
|
|
1997
|
+
|
|
1998
|
+
def get_array_element_type(self, type_info: tinfo_t) -> Optional[tinfo_t]:
|
|
1999
|
+
"""
|
|
2000
|
+
Get the element type of an array type.
|
|
2001
|
+
|
|
2002
|
+
Args:
|
|
2003
|
+
type_info: An array type.
|
|
2004
|
+
|
|
2005
|
+
Returns:
|
|
2006
|
+
The element type, or None if not an array.
|
|
2007
|
+
"""
|
|
2008
|
+
if not type_info.is_array():
|
|
2009
|
+
return None
|
|
2010
|
+
|
|
2011
|
+
array_data = array_type_data_t()
|
|
2012
|
+
if type_info.get_array_details(array_data):
|
|
2013
|
+
return array_data.elem_type
|
|
2014
|
+
return None
|
|
2015
|
+
|
|
2016
|
+
def get_array_length(self, type_info: tinfo_t) -> Optional[int]:
|
|
2017
|
+
"""
|
|
2018
|
+
Get the number of elements in an array type.
|
|
2019
|
+
|
|
2020
|
+
Args:
|
|
2021
|
+
type_info: An array type.
|
|
2022
|
+
|
|
2023
|
+
Returns:
|
|
2024
|
+
The array length, or None if not an array.
|
|
2025
|
+
"""
|
|
2026
|
+
if not type_info.is_array():
|
|
2027
|
+
return None
|
|
2028
|
+
|
|
2029
|
+
array_data = array_type_data_t()
|
|
2030
|
+
if type_info.get_array_details(array_data):
|
|
2031
|
+
return array_data.nelems
|
|
2032
|
+
return None
|
|
2033
|
+
|
|
2034
|
+
# =========================================================================
|
|
2035
|
+
# Type Creation Methods
|
|
2036
|
+
# =========================================================================
|
|
2037
|
+
|
|
2038
|
+
def create_void(self) -> tinfo_t:
|
|
2039
|
+
"""
|
|
2040
|
+
Create a void type.
|
|
2041
|
+
|
|
2042
|
+
Returns:
|
|
2043
|
+
A void tinfo_t.
|
|
2044
|
+
"""
|
|
2045
|
+
result = tinfo_t()
|
|
2046
|
+
result.create_simple_type(BT_VOID)
|
|
2047
|
+
return result
|
|
2048
|
+
|
|
2049
|
+
def create_primitive(self, size: int, signed: bool = True) -> tinfo_t:
|
|
2050
|
+
"""
|
|
2051
|
+
Create a primitive integer type.
|
|
2052
|
+
|
|
2053
|
+
Args:
|
|
2054
|
+
size: Size in bytes (1, 2, 4, or 8).
|
|
2055
|
+
signed: True for signed, False for unsigned.
|
|
2056
|
+
|
|
2057
|
+
Returns:
|
|
2058
|
+
The primitive type.
|
|
2059
|
+
|
|
2060
|
+
Raises:
|
|
2061
|
+
InvalidParameterError: If size is not 1, 2, 4, or 8.
|
|
2062
|
+
|
|
2063
|
+
Example:
|
|
2064
|
+
>>> int32 = db.types.create_primitive(4, signed=True)
|
|
2065
|
+
>>> uint8 = db.types.create_primitive(1, signed=False)
|
|
2066
|
+
"""
|
|
2067
|
+
size_to_type = {
|
|
2068
|
+
1: BT_INT8,
|
|
2069
|
+
2: BT_INT16,
|
|
2070
|
+
4: BT_INT32,
|
|
2071
|
+
8: BT_INT64,
|
|
2072
|
+
}
|
|
2073
|
+
|
|
2074
|
+
if size not in size_to_type:
|
|
2075
|
+
raise InvalidParameterError("size", size, "must be 1, 2, 4, or 8")
|
|
2076
|
+
|
|
2077
|
+
result = tinfo_t()
|
|
2078
|
+
result.create_simple_type(size_to_type[size])
|
|
2079
|
+
return result
|
|
2080
|
+
|
|
2081
|
+
def create_float(self, size: int = 4) -> tinfo_t:
|
|
2082
|
+
"""
|
|
2083
|
+
Create a floating-point type.
|
|
2084
|
+
|
|
2085
|
+
Args:
|
|
2086
|
+
size: 4 for float, 8 for double.
|
|
2087
|
+
|
|
2088
|
+
Returns:
|
|
2089
|
+
The floating-point type.
|
|
2090
|
+
|
|
2091
|
+
Raises:
|
|
2092
|
+
InvalidParameterError: If size is not 4 or 8.
|
|
2093
|
+
"""
|
|
2094
|
+
if size == 4:
|
|
2095
|
+
result = tinfo_t()
|
|
2096
|
+
result.create_simple_type(BT_FLOAT)
|
|
2097
|
+
return result
|
|
2098
|
+
elif size == 8:
|
|
2099
|
+
result = tinfo_t()
|
|
2100
|
+
result.create_simple_type(BT_FLOAT | BTMT_DOUBLE)
|
|
2101
|
+
return result
|
|
2102
|
+
else:
|
|
2103
|
+
raise InvalidParameterError("size", size, "must be 4 or 8")
|
|
2104
|
+
|
|
2105
|
+
def create_pointer(self, target: tinfo_t) -> tinfo_t:
|
|
2106
|
+
"""
|
|
2107
|
+
Create a pointer type.
|
|
2108
|
+
|
|
2109
|
+
Args:
|
|
2110
|
+
target: The type being pointed to.
|
|
2111
|
+
|
|
2112
|
+
Returns:
|
|
2113
|
+
A pointer to the target type.
|
|
2114
|
+
|
|
2115
|
+
Example:
|
|
2116
|
+
>>> char_type = db.types.create_primitive(1)
|
|
2117
|
+
>>> char_ptr = db.types.create_pointer(char_type)
|
|
2118
|
+
"""
|
|
2119
|
+
result = tinfo_t()
|
|
2120
|
+
result.create_ptr(target)
|
|
2121
|
+
return result
|
|
2122
|
+
|
|
2123
|
+
def create_array(self, element_type: tinfo_t, count: int) -> tinfo_t:
|
|
2124
|
+
"""
|
|
2125
|
+
Create an array type.
|
|
2126
|
+
|
|
2127
|
+
Args:
|
|
2128
|
+
element_type: Type of array elements.
|
|
2129
|
+
count: Number of elements.
|
|
2130
|
+
|
|
2131
|
+
Returns:
|
|
2132
|
+
The array type.
|
|
2133
|
+
|
|
2134
|
+
Example:
|
|
2135
|
+
>>> char_type = db.types.create_primitive(1)
|
|
2136
|
+
>>> buffer = db.types.create_array(char_type, 256)
|
|
2137
|
+
"""
|
|
2138
|
+
array_data = array_type_data_t()
|
|
2139
|
+
array_data.elem_type = element_type
|
|
2140
|
+
array_data.nelems = count
|
|
2141
|
+
array_data.base = 0
|
|
2142
|
+
|
|
2143
|
+
result = tinfo_t()
|
|
2144
|
+
result.create_array(array_data)
|
|
2145
|
+
return result
|
|
2146
|
+
|
|
2147
|
+
# =========================================================================
|
|
2148
|
+
# Builder Factory Methods
|
|
2149
|
+
# =========================================================================
|
|
2150
|
+
|
|
2151
|
+
def create_struct(self, name: str) -> StructBuilder:
|
|
2152
|
+
"""
|
|
2153
|
+
Create a struct builder.
|
|
2154
|
+
|
|
2155
|
+
Args:
|
|
2156
|
+
name: Name for the struct.
|
|
2157
|
+
|
|
2158
|
+
Returns:
|
|
2159
|
+
A StructBuilder for constructing the type.
|
|
2160
|
+
|
|
2161
|
+
Example:
|
|
2162
|
+
>>> point = db.types.create_struct("Point") \\
|
|
2163
|
+
... .add_member("x", db.types.create_primitive(4)) \\
|
|
2164
|
+
... .add_member("y", db.types.create_primitive(4)) \\
|
|
2165
|
+
... .build()
|
|
2166
|
+
"""
|
|
2167
|
+
return StructBuilder(name)
|
|
2168
|
+
|
|
2169
|
+
def create_union(self, name: str) -> UnionBuilder:
|
|
2170
|
+
"""
|
|
2171
|
+
Create a union builder.
|
|
2172
|
+
|
|
2173
|
+
Args:
|
|
2174
|
+
name: Name for the union.
|
|
2175
|
+
|
|
2176
|
+
Returns:
|
|
2177
|
+
A UnionBuilder for constructing the type.
|
|
2178
|
+
"""
|
|
2179
|
+
return UnionBuilder(name)
|
|
2180
|
+
|
|
2181
|
+
def create_enum(self, name: str, base_size: int = 4) -> EnumBuilder:
|
|
2182
|
+
"""
|
|
2183
|
+
Create an enum builder.
|
|
2184
|
+
|
|
2185
|
+
Args:
|
|
2186
|
+
name: Name for the enum.
|
|
2187
|
+
base_size: Underlying integer size (1, 2, 4, or 8).
|
|
2188
|
+
|
|
2189
|
+
Returns:
|
|
2190
|
+
An EnumBuilder for constructing the type.
|
|
2191
|
+
"""
|
|
2192
|
+
return EnumBuilder(name, base_size)
|
|
2193
|
+
|
|
2194
|
+
def create_func_type(self) -> FuncTypeBuilder:
|
|
2195
|
+
"""
|
|
2196
|
+
Create a function type builder.
|
|
2197
|
+
|
|
2198
|
+
Returns:
|
|
2199
|
+
A FuncTypeBuilder for constructing the type.
|
|
2200
|
+
"""
|
|
2201
|
+
return FuncTypeBuilder()
|
|
2202
|
+
|
|
2203
|
+
# =========================================================================
|
|
2204
|
+
# Unified LLM-Friendly Interface
|
|
2205
|
+
# =========================================================================
|
|
2206
|
+
|
|
2207
|
+
def get_member(
|
|
2208
|
+
self,
|
|
2209
|
+
type_info: tinfo_t,
|
|
2210
|
+
key: Union[str, int],
|
|
2211
|
+
by: Union[TypeMemberLookupMode, str] = TypeMemberLookupMode.NAME
|
|
2212
|
+
) -> Optional[Union[UdtMemberInfo, EnumMemberInfo, FuncArgumentInfo]]:
|
|
2213
|
+
"""
|
|
2214
|
+
Get a type member (LLM-friendly unified interface).
|
|
2215
|
+
|
|
2216
|
+
Works for struct/union members, enum members, and function arguments.
|
|
2217
|
+
|
|
2218
|
+
Args:
|
|
2219
|
+
type_info: The type to inspect.
|
|
2220
|
+
key: Lookup key (name, offset, index, or value depending on 'by').
|
|
2221
|
+
by: Lookup mode:
|
|
2222
|
+
- "name": Look up by member/argument name
|
|
2223
|
+
- "offset": Look up by byte offset (UDT only)
|
|
2224
|
+
- "index": Look up by index (enum, func args)
|
|
2225
|
+
- "value": Look up by enum value (enum only)
|
|
2226
|
+
|
|
2227
|
+
Returns:
|
|
2228
|
+
The member info if found, None otherwise.
|
|
2229
|
+
|
|
2230
|
+
Example:
|
|
2231
|
+
>>> # Get struct member by name
|
|
2232
|
+
>>> member = db.types.get_member(struct_type, "x", by="name")
|
|
2233
|
+
>>> # Get struct member by offset
|
|
2234
|
+
>>> member = db.types.get_member(struct_type, 4, by="offset")
|
|
2235
|
+
>>> # Get function argument by index
|
|
2236
|
+
>>> arg = db.types.get_member(func_type, 0, by="index")
|
|
2237
|
+
"""
|
|
2238
|
+
# Normalize mode
|
|
2239
|
+
if isinstance(by, str):
|
|
2240
|
+
by = TypeMemberLookupMode(by)
|
|
2241
|
+
|
|
2242
|
+
if by == TypeMemberLookupMode.NAME:
|
|
2243
|
+
if not isinstance(key, str):
|
|
2244
|
+
raise InvalidParameterError("key", key, "must be a string when by='name'")
|
|
2245
|
+
if type_info.is_udt():
|
|
2246
|
+
return self.get_udt_member_by_name(type_info, key)
|
|
2247
|
+
elif type_info.is_enum():
|
|
2248
|
+
return self.get_enum_member_by_name(type_info, key)
|
|
2249
|
+
# Function arguments don't typically have meaningful names to search by
|
|
2250
|
+
return None
|
|
2251
|
+
|
|
2252
|
+
elif by == TypeMemberLookupMode.OFFSET:
|
|
2253
|
+
if not isinstance(key, int):
|
|
2254
|
+
raise InvalidParameterError("key", key, "must be an int when by='offset'")
|
|
2255
|
+
if type_info.is_udt():
|
|
2256
|
+
return self.get_udt_member_by_offset(type_info, key)
|
|
2257
|
+
return None
|
|
2258
|
+
|
|
2259
|
+
elif by == TypeMemberLookupMode.INDEX:
|
|
2260
|
+
if not isinstance(key, int):
|
|
2261
|
+
raise InvalidParameterError("key", key, "must be an int when by='index'")
|
|
2262
|
+
if type_info.is_func():
|
|
2263
|
+
return self.get_func_argument_by_index(type_info, key)
|
|
2264
|
+
return None
|
|
2265
|
+
|
|
2266
|
+
elif by == TypeMemberLookupMode.VALUE:
|
|
2267
|
+
if not isinstance(key, int):
|
|
2268
|
+
raise InvalidParameterError("key", key, "must be an int when by='value'")
|
|
2269
|
+
if type_info.is_enum():
|
|
2270
|
+
return self.get_enum_member_by_value(type_info, key)
|
|
2271
|
+
return None
|
|
2272
|
+
|
|
2273
|
+
return None
|
|
2274
|
+
|
|
2275
|
+
def get_members(
|
|
2276
|
+
self,
|
|
2277
|
+
type_info: tinfo_t
|
|
2278
|
+
) -> Iterator[Union[UdtMemberInfo, EnumMemberInfo, FuncArgumentInfo]]:
|
|
2279
|
+
"""
|
|
2280
|
+
Get all members of a type (LLM-friendly unified interface).
|
|
2281
|
+
|
|
2282
|
+
Works for struct/union types, enum types, and function types.
|
|
2283
|
+
|
|
2284
|
+
Args:
|
|
2285
|
+
type_info: The type to inspect.
|
|
2286
|
+
|
|
2287
|
+
Returns:
|
|
2288
|
+
Iterator of member info objects.
|
|
2289
|
+
Empty iterator if type has no members.
|
|
2290
|
+
|
|
2291
|
+
Example:
|
|
2292
|
+
>>> for member in db.types.get_members(struct_type):
|
|
2293
|
+
... print(f"{member.name}")
|
|
2294
|
+
"""
|
|
2295
|
+
if type_info.is_udt():
|
|
2296
|
+
yield from self.get_udt_members(type_info)
|
|
2297
|
+
elif type_info.is_enum():
|
|
2298
|
+
yield from self.get_enum_members(type_info)
|
|
2299
|
+
elif type_info.is_func():
|
|
2300
|
+
yield from self.get_func_arguments(type_info)
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|