summaryrefslogtreecommitdiff
path: root/misc/lldb_rb
diff options
context:
space:
mode:
Diffstat (limited to 'misc/lldb_rb')
-rw-r--r--misc/lldb_rb/commands/heap_page_command.py5
-rw-r--r--misc/lldb_rb/commands/print_flags_command.py6
-rw-r--r--misc/lldb_rb/commands/rp_command.py1
-rw-r--r--misc/lldb_rb/lldb_interface.py10
-rw-r--r--misc/lldb_rb/rb_base_command.py1
-rw-r--r--misc/lldb_rb/rb_heap_structs.py36
-rw-r--r--misc/lldb_rb/utils.py339
7 files changed, 321 insertions, 77 deletions
diff --git a/misc/lldb_rb/commands/heap_page_command.py b/misc/lldb_rb/commands/heap_page_command.py
index edb74a415b..2eed3c3bee 100644
--- a/misc/lldb_rb/commands/heap_page_command.py
+++ b/misc/lldb_rb/commands/heap_page_command.py
@@ -8,14 +8,15 @@ class HeapPageCommand(RbBaseCommand):
help_string = "prints out 'struct heap_page' for a VALUE pointer in the page"
def call(self, debugger, command, exe_ctx, result):
+ self.result = result
self.t_heap_page_body = self.target.FindFirstType("struct heap_page_body")
self.t_heap_page_ptr = self.target.FindFirstType("struct heap_page").GetPointerType()
page = self._get_page(self.frame.EvaluateExpression(command))
page.Cast(self.t_heap_page_ptr)
- self._append_command_output(debugger, "p (struct heap_page *) %0#x" % page.GetValueAsUnsigned(), result)
- self._append_command_output(debugger, "p *(struct heap_page *) %0#x" % page.GetValueAsUnsigned(), result)
+ self._append_expression("(struct heap_page *) %0#x" % page.GetValueAsUnsigned())
+ self._append_expression("*(struct heap_page *) %0#x" % page.GetValueAsUnsigned())
def _get_page(self, val):
addr = val.GetValueAsUnsigned()
diff --git a/misc/lldb_rb/commands/print_flags_command.py b/misc/lldb_rb/commands/print_flags_command.py
index 00da4834bf..bc494ae01a 100644
--- a/misc/lldb_rb/commands/print_flags_command.py
+++ b/misc/lldb_rb/commands/print_flags_command.py
@@ -11,13 +11,13 @@ class PrintFlagsCommand(RbBaseCommand):
# call is where our command logic will be implemented
def call(self, debugger, command, exe_ctx, result):
- rclass_t = self.target.FindFirstType("struct RBasic")
+ rclass_t = self.target.FindFirstType("::RBasic")
rcass_ptr = self.target.EvaluateExpression(command).Cast(rclass_t.GetPointerType())
obj_flags = rcass_ptr.GetValueForExpressionPath("->flags").GetValueAsUnsigned()
flags = [
- "RUBY_FL_WB_PROTECTED", "RUBY_FL_PROMOTED0", "RUBY_FL_PROMOTED1", "RUBY_FL_FINALIZE",
- "RUBY_FL_SHAREABLE", "RUBY_FL_EXIVAR", "RUBY_FL_FREEZE",
+ "RUBY_FL_WB_PROTECTED", "RUBY_FL_PROMOTED", "RUBY_FL_FINALIZE",
+ "RUBY_FL_SHAREABLE", "RUBY_FL_FREEZE",
"RUBY_FL_USER0", "RUBY_FL_USER1", "RUBY_FL_USER2", "RUBY_FL_USER3", "RUBY_FL_USER4",
"RUBY_FL_USER5", "RUBY_FL_USER6", "RUBY_FL_USER7", "RUBY_FL_USER8", "RUBY_FL_USER9",
"RUBY_FL_USER10", "RUBY_FL_USER11", "RUBY_FL_USER12", "RUBY_FL_USER13", "RUBY_FL_USER14",
diff --git a/misc/lldb_rb/commands/rp_command.py b/misc/lldb_rb/commands/rp_command.py
index 9da9688b96..06b2516d50 100644
--- a/misc/lldb_rb/commands/rp_command.py
+++ b/misc/lldb_rb/commands/rp_command.py
@@ -13,4 +13,3 @@ class RbID2StrCommand(RbBaseCommand):
val = self.frame.EvaluateExpression(command)
inspector = RbInspector(debugger, result, self.ruby_globals)
inspector.inspect(val)
-
diff --git a/misc/lldb_rb/lldb_interface.py b/misc/lldb_rb/lldb_interface.py
index 893064db90..25930b2e16 100644
--- a/misc/lldb_rb/lldb_interface.py
+++ b/misc/lldb_rb/lldb_interface.py
@@ -6,3 +6,13 @@ class LLDBInterface:
self.thread = self.process.GetSelectedThread()
self.frame = self.thread.GetSelectedFrame()
+ def _append_command_output(self, command):
+ output1 = self.result.GetOutput()
+ self.debugger.GetCommandInterpreter().HandleCommand(command, self.result)
+ output2 = self.result.GetOutput()
+ self.result.Clear()
+ self.result.write(output1)
+ self.result.write(output2)
+
+ def _append_expression(self, expression):
+ self._append_command_output("expression " + expression)
diff --git a/misc/lldb_rb/rb_base_command.py b/misc/lldb_rb/rb_base_command.py
index 23c628971e..70a5addd6d 100644
--- a/misc/lldb_rb/rb_base_command.py
+++ b/misc/lldb_rb/rb_base_command.py
@@ -55,4 +55,3 @@ class RbBaseCommand(LLDBInterface):
def get_long_help(self):
return self.__class__.help_string
-
diff --git a/misc/lldb_rb/rb_heap_structs.py b/misc/lldb_rb/rb_heap_structs.py
index 0428b7fc3f..798b838080 100644
--- a/misc/lldb_rb/rb_heap_structs.py
+++ b/misc/lldb_rb/rb_heap_structs.py
@@ -1,4 +1,5 @@
import lldb
+import math
from lldb_rb.lldb_interface import LLDBInterface
from lldb_rb.constants import *
@@ -50,8 +51,7 @@ class RbObject(LLDBInterface):
self.flUser9 = self.ruby_globals["RUBY_FL_USER9"]
self.flUshift = self.ruby_globals["RUBY_FL_USHIFT"]
- self.tRBasic = self.target.FindFirstType("struct RBasic").GetPointerType()
- self.tRValue = self.target.FindFirstType("struct RVALUE")
+ self.tRBasic = self.target.FindFirstType("::RBasic").GetPointerType()
self.val = ptr.Cast(self.tRBasic)
self.page = HeapPage(self.debugger, self.val)
@@ -70,10 +70,12 @@ class RbObject(LLDBInterface):
return ' '
def dump_bits(self, result, end = "\n"):
- tRValue = self.target.FindFirstType("struct RVALUE")
tUintPtr = self.target.FindFirstType("uintptr_t") # bits_t
- num_in_page = (self.val.GetValueAsUnsigned() & HEAP_PAGE_ALIGN_MASK) // tRValue.GetByteSize();
+ slot_size = self.page.to_heap_page_struct().GetChildMemberWithName("heap").GetChildMemberWithName("slot_size").unsigned
+ byte_size = 40 ** math.floor(math.log(slot_size, 40))
+
+ num_in_page = (self.val.GetValueAsUnsigned() & HEAP_PAGE_ALIGN_MASK) // byte_size;
bits_bitlength = tUintPtr.GetByteSize() * 8
bitmap_index = num_in_page // bits_bitlength
bitmap_offset = num_in_page & (bits_bitlength - 1)
@@ -108,11 +110,22 @@ class RbObject(LLDBInterface):
else:
return False
+ def as_type(self, type_name):
+ if type_name == "array":
+ tRarray = self.target.FindFirstType("struct RArray")
+ return self.val.Cast(tRarray.GetPointerType())
+ elif type_name == "bignum":
+ tRbignum = self.target.FindFirstType("struct RBignum")
+ return self.val.Cast(tRbignum.GetPointerType())
+ else:
+ print("as_type is not implemented for:", type_name)
+
def ary_ptr(self):
+ rval = self.as_type("array")
if self.flags & self.ruby_globals["RUBY_FL_USER1"]:
- ptr = self.val.GetValueForExpressionPath("->as.ary")
+ ptr = rval.GetValueForExpressionPath("->as.ary")
else:
- ptr = self.val.GetValueForExpressionPath("->as.heap.ptr")
+ ptr = rval.GetValueForExpressionPath("->as.heap.ptr")
return ptr
def ary_len(self):
@@ -122,19 +135,18 @@ class RbObject(LLDBInterface):
self.flUser7 | self.flUser8 | self.flUser9)
) >> (self.flUshift + 3))
else:
- len = self.val.GetValueForExpressionPath("->as.heap.len")
+ rval = self.as_type("array")
+ len = rval.GetValueForExpressionPath("->as.heap.len").GetValueAsSigned()
return len
def bignum_len(self):
- if self.flags & flUser2:
+ if self.flags & self.flUser2:
len = ((self.flags &
(self.flUser3 | self.flUser4 | self.flUser5)
) >> (self.flUshift + 3))
else:
- len = self.val.GetValueForExpressionPath("->as.heap.len")
+ len = (self.as_type("bignum").GetValueForExpressionPath("->as.heap.len").
+ GetValueAsUnsigned())
return len
-
-
-
diff --git a/misc/lldb_rb/utils.py b/misc/lldb_rb/utils.py
index bd2c0330b8..a2bcedc328 100644
--- a/misc/lldb_rb/utils.py
+++ b/misc/lldb_rb/utils.py
@@ -8,14 +8,6 @@ class RbInspector(LLDBInterface):
self.result = result
self.ruby_globals = ruby_globals
- def _append_command_output(self, command):
- output1 = self.result.GetOutput()
- self.debugger.GetCommandInterpreter().HandleCommand(command, self.result)
- output2 = self.result.GetOutput()
- self.result.Clear()
- self.result.write(output1)
- self.result.write(output2)
-
def string2cstr(self, rstring):
"""Returns the pointer to the C-string in the given String object"""
if rstring.TypeIsPointerType():
@@ -32,8 +24,7 @@ class RbInspector(LLDBInterface):
def output_string(self, rstring):
cptr, clen = self.string2cstr(rstring)
- expr = "print *(const char (*)[%d])%0#x" % (clen, cptr)
- self._append_command_output(expr)
+ self._append_expression("*(const char (*)[%d])%0#x" % (clen, cptr))
def fixnum_p(self, x):
return x & self.ruby_globals["RUBY_FIXNUM_FLAG"] != 0
@@ -49,7 +40,7 @@ class RbInspector(LLDBInterface):
def generic_inspect(self, val, rtype):
tRType = self.target.FindFirstType("struct %s" % rtype).GetPointerType()
val = val.Cast(tRType)
- self._append_command_output("p *(struct %s *) %0#x" % (rtype, val.GetValueAsUnsigned()))
+ self._append_expression("*(struct %s *) %0#x" % (rtype, val.GetValueAsUnsigned()))
def inspect(self, val):
rbTrue = self.ruby_globals["RUBY_Qtrue"]
@@ -58,6 +49,9 @@ class RbInspector(LLDBInterface):
rbUndef = self.ruby_globals["RUBY_Qundef"]
rbImmediateMask = self.ruby_globals["RUBY_IMMEDIATE_MASK"]
+ if self.inspect_node(val):
+ return
+
num = val.GetValueAsSigned()
if num == rbFalse:
print('false', file=self.result)
@@ -70,13 +64,13 @@ class RbInspector(LLDBInterface):
elif self.fixnum_p(num):
print(num >> 1, file=self.result)
elif self.flonum_p(num):
- self._append_command_output("print rb_float_value(%0#x)" % val.GetValueAsUnsigned())
+ self._append_expression("rb_float_value(%0#x)" % val.GetValueAsUnsigned())
elif self.static_sym_p(num):
if num < 128:
print("T_SYMBOL: %c" % num, file=self.result)
else:
print("T_SYMBOL: (%x)" % num, file=self.result)
- self._append_command_output("p rb_id2name(%0#x)" % (num >> 8))
+ self._append_expression("rb_id2name(%0#x)" % (num >> 8))
elif num & rbImmediateMask:
print('immediate(%x)' % num, file=self.result)
@@ -98,7 +92,7 @@ class RbInspector(LLDBInterface):
elif rval.is_type("RUBY_T_OBJECT"):
self.result.write('T_OBJECT: %s' % flaginfo)
- self._append_command_output("print *(struct RObject*)%0#x" % val.GetValueAsUnsigned())
+ self._append_expression("*(struct RObject*)%0#x" % val.GetValueAsUnsigned())
elif (rval.is_type("RUBY_T_CLASS") or
rval.is_type("RUBY_T_MODULE") or
@@ -106,10 +100,10 @@ class RbInspector(LLDBInterface):
self.result.write('T_%s: %s' % (rval.type_name.split('_')[-1], flaginfo))
tRClass = self.target.FindFirstType("struct RClass")
- self._append_command_output("print *(struct RClass*)%0#x" % val.GetValueAsUnsigned())
+ self._append_expression("*(struct RClass*)%0#x" % val.GetValueAsUnsigned())
if not val.Cast(tRClass).GetChildMemberWithName("ptr").IsValid():
- self._append_command_output(
- "print *(struct rb_classext_struct*)%0#x" %
+ self._append_expression(
+ "*(struct rb_classext_struct*)%0#x" %
(val.GetValueAsUnsigned() + tRClass.GetByteSize())
)
@@ -117,6 +111,10 @@ class RbInspector(LLDBInterface):
self.result.write('T_STRING: %s' % flaginfo)
tRString = self.target.FindFirstType("struct RString").GetPointerType()
+ chilled = self.ruby_globals["RUBY_FL_USER3"]
+ if (rval.flags & chilled) != 0:
+ self.result.write("[CHILLED] ")
+
rb_enc_mask = self.ruby_globals["RUBY_ENCODING_MASK"]
rb_enc_shift = self.ruby_globals["RUBY_ENCODING_SHIFT"]
encidx = ((rval.flags & rb_enc_mask) >> rb_enc_shift)
@@ -129,11 +127,21 @@ class RbInspector(LLDBInterface):
else:
self.result.write('[enc=%d] ' % encidx)
+ coderange = rval.flags & self.ruby_globals["RUBY_ENC_CODERANGE_MASK"]
+ if coderange == self.ruby_globals["RUBY_ENC_CODERANGE_7BIT"]:
+ self.result.write('[7BIT] ')
+ elif coderange == self.ruby_globals["RUBY_ENC_CODERANGE_VALID"]:
+ self.result.write('[VALID] ')
+ elif coderange == self.ruby_globals["RUBY_ENC_CODERANGE_BROKEN"]:
+ self.result.write('[BROKEN] ')
+ else:
+ self.result.write('[UNKNOWN] ')
+
ptr, len = self.string2cstr(val.Cast(tRString))
if len == 0:
self.result.write("(empty)\n")
else:
- self._append_command_output("print *(const char (*)[%d])%0#x" % (len, ptr))
+ self._append_expression("*(const char (*)[%d])%0#x" % (len, ptr))
elif rval.is_type("RUBY_T_SYMBOL"):
self.result.write('T_SYMBOL: %s' % flaginfo)
@@ -141,12 +149,10 @@ class RbInspector(LLDBInterface):
tRString = self.target.FindFirstType("struct RString").GetPointerType()
val = val.Cast(tRSymbol)
- self._append_command_output(
- 'print (ID)%0#x ' % val.GetValueForExpressionPath("->id").GetValueAsUnsigned())
+ self._append_expression('(ID)%0#x ' % val.GetValueForExpressionPath("->id").GetValueAsUnsigned())
self.output_string(val.GetValueForExpressionPath("->fstr").Cast(tRString))
elif rval.is_type("RUBY_T_ARRAY"):
- tRArray = self.target.FindFirstType("struct RArray").GetPointerType()
len = rval.ary_len()
ptr = rval.ary_ptr()
@@ -165,19 +171,20 @@ class RbInspector(LLDBInterface):
else:
self.result.write("\n")
if ptr.GetValueAsSigned() == 0:
- self._append_command_output(
- "expression -fx -- ((struct RArray*)%0#x)->as.ary" % val.GetValueAsUnsigned())
+ self._append_expression("-fx -- ((struct RArray*)%0#x)->as.ary" % val.GetValueAsUnsigned())
else:
- self._append_command_output(
- "expression -Z %d -fx -- (const VALUE*)%0#x" % (len, ptr.GetValueAsUnsigned()))
+ self._append_expression("-Z %d -fx -- (const VALUE*)%0#x" % (len, ptr.GetValueAsUnsigned()))
elif rval.is_type("RUBY_T_HASH"):
self.result.write("T_HASH: %s" % flaginfo)
- self._append_command_output("p *(struct RHash *) %0#x" % val.GetValueAsUnsigned())
+ ptr = val.GetValueAsUnsigned()
+ self._append_expression("*(struct RHash *) %0#x" % ptr)
+ if rval.flags & self.ruby_globals["RUBY_FL_USER3"]:
+ self._append_expression("*(struct st_table *) (%0#x + sizeof(struct RHash))" % ptr)
+ else:
+ self._append_expression("*(struct ar_table *) (%0#x + sizeof(struct RHash))" % ptr)
elif rval.is_type("RUBY_T_BIGNUM"):
- tRBignum = self.target.FindFirstType("struct RBignum").GetPointerType()
-
sign = '-'
if (rval.flags & self.ruby_globals["RUBY_FL_USER1"]) != 0:
sign = '+'
@@ -185,17 +192,16 @@ class RbInspector(LLDBInterface):
if rval.flags & self.ruby_globals["RUBY_FL_USER2"]:
print("T_BIGNUM: sign=%s len=%d (embed)" % (sign, len), file=self.result)
- self._append_command_output("print ((struct RBignum *) %0#x)->as.ary"
+ self._append_expression("((struct RBignum *) %0#x)->as.ary"
% val.GetValueAsUnsigned())
else:
print("T_BIGNUM: sign=%s len=%d" % (sign, len), file=self.result)
- print(val.Dereference(), file=self.result)
- self._append_command_output(
- "expression -Z %x -fx -- (const BDIGIT*)((struct RBignum*)%d)->as.heap.digits" %
- (len, val.GetValueAsUnsigned()))
+ print(rval.as_type("bignum"), file=self.result)
+ self._append_expression("-Z %d -fx -- ((struct RBignum*)%d)->as.heap.digits" %
+ (len, val.GetValueAsUnsigned()))
elif rval.is_type("RUBY_T_FLOAT"):
- self._append_command_output("print ((struct RFloat *)%d)->float_value"
+ self._append_expression("((struct RFloat *)%d)->float_value"
% val.GetValueAsUnsigned())
elif rval.is_type("RUBY_T_RATIONAL"):
@@ -230,37 +236,28 @@ class RbInspector(LLDBInterface):
elif rval.is_type("RUBY_T_DATA"):
tRTypedData = self.target.FindFirstType("struct RTypedData").GetPointerType()
val = val.Cast(tRTypedData)
- flag = val.GetValueForExpressionPath("->typed_flag")
-
- if flag.GetValueAsUnsigned() == 1:
- print("T_DATA: %s" %
- val.GetValueForExpressionPath("->type->wrap_struct_name"),
- file=self.result)
- self._append_command_output(
- "p *(struct RTypedData *) %0#x" % val.GetValueAsUnsigned())
- else:
- print("T_DATA:", file=self.result)
- self._append_command_output(
- "p *(struct RData *) %0#x" % val.GetValueAsUnsigned())
-
- elif rval.is_type("RUBY_T_NODE"):
- tRNode = self.target.FindFirstType("struct RNode").GetPointerType()
- rbNodeTypeMask = self.ruby_globals["RUBY_NODE_TYPEMASK"]
- rbNodeTypeShift = self.ruby_globals["RUBY_NODE_TYPESHIFT"]
- nd_type = (rval.flags & rbNodeTypeMask) >> rbNodeTypeShift
- val = val.Cast(tRNode)
-
- self._append_command_output("p (node_type) %d" % nd_type)
- self._append_command_output("p *(struct RNode *) %0#x" % val.GetValueAsUnsigned())
+ type = val.GetValueForExpressionPath("->type").GetValueAsUnsigned()
+ embed = (type & 1)
+ if embed:
+ flaginfo += "[EMBED] "
+ type = self.frame.EvaluateExpression("(rb_data_type_t *)%0#x" % (type & ~1))
+ print("T_DATA: %s%s" %
+ (flaginfo, type.GetValueForExpressionPath("->wrap_struct_name")),
+ file=self.result)
+ print("%s", type.Dereference(), file=self.result)
+ ptr = val.GetValueForExpressionPath("->data")
+ if embed:
+ ptr = ptr.AddressOf()
+ self._append_expression("(void *)%0#x" % ptr.GetValueAsUnsigned())
elif rval.is_type("RUBY_T_IMEMO"):
imemo_type = ((rval.flags >> self.ruby_globals["RUBY_FL_USHIFT"])
& IMEMO_MASK)
print("T_IMEMO: ", file=self.result)
- self._append_command_output("p (enum imemo_type) %d" % imemo_type)
- self._append_command_output("p *(struct MEMO *) %0#x" % val.GetValueAsUnsigned())
+ self._append_expression("(enum imemo_type) %d" % imemo_type)
+ self._append_expression("*(struct MEMO *) %0#x" % val.GetValueAsUnsigned())
elif rval.is_type("RUBY_T_FILE"):
self.generic_inspect(val, "RFile")
@@ -281,3 +278,229 @@ class RbInspector(LLDBInterface):
print("Not-handled type %0#x" % rval.type, file=self.result)
print(val, file=self.result)
+ def inspect_node(self, val):
+ tRNode = self.target.FindFirstType("struct RNode").GetPointerType()
+
+ # if val.GetType() != tRNode: does not work for unknown reason
+
+ if val.GetType().GetPointeeType().GetCanonicalType().name != "RNode":
+ return False
+
+ rbNodeTypeMask = self.ruby_globals["RUBY_NODE_TYPEMASK"]
+ rbNodeTypeShift = self.ruby_globals["RUBY_NODE_TYPESHIFT"]
+ flags = val.Cast(tRNode).GetChildMemberWithName("flags").GetValueAsUnsigned()
+ nd_type = (flags & rbNodeTypeMask) >> rbNodeTypeShift
+
+ self._append_expression("(node_type) %d" % nd_type)
+
+ if nd_type == self.ruby_globals["NODE_SCOPE"]:
+ self._append_expression("*(rb_node_scope_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_BLOCK"]:
+ self._append_expression("*(rb_node_block_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_IF"]:
+ self._append_expression("*(rb_node_if_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_UNLESS"]:
+ self._append_expression("*(rb_node_unless_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CASE"]:
+ self._append_expression("*(rb_node_case_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CASE2"]:
+ self._append_expression("*(rb_node_case2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CASE3"]:
+ self._append_expression("*(rb_node_case3_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_WHEN"]:
+ self._append_expression("*(rb_node_when_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_IN"]:
+ self._append_expression("*(rb_node_in_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_WHILE"]:
+ self._append_expression("*(rb_node_while_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_UNTIL"]:
+ self._append_expression("*(rb_node_until_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ITER"]:
+ self._append_expression("*(rb_node_iter_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FOR"]:
+ self._append_expression("*(rb_node_for_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FOR_MASGN"]:
+ self._append_expression("*(rb_node_for_masgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_BREAK"]:
+ self._append_expression("*(rb_node_break_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_NEXT"]:
+ self._append_expression("*(rb_node_next_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_REDO"]:
+ self._append_expression("*(rb_node_redo_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_RETRY"]:
+ self._append_expression("*(rb_node_retry_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_BEGIN"]:
+ self._append_expression("*(rb_node_begin_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_RESCUE"]:
+ self._append_expression("*(rb_node_rescue_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_RESBODY"]:
+ self._append_expression("*(rb_node_resbody_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ENSURE"]:
+ self._append_expression("*(rb_node_ensure_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_AND"]:
+ self._append_expression("*(rb_node_and_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OR"]:
+ self._append_expression("*(rb_node_or_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_MASGN"]:
+ self._append_expression("*(rb_node_masgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_LASGN"]:
+ self._append_expression("*(rb_node_lasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DASGN"]:
+ self._append_expression("*(rb_node_dasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_GASGN"]:
+ self._append_expression("*(rb_node_gasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_IASGN"]:
+ self._append_expression("*(rb_node_iasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CDECL"]:
+ self._append_expression("*(rb_node_cdecl_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CVASGN"]:
+ self._append_expression("*(rb_node_cvasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OP_ASGN1"]:
+ self._append_expression("*(rb_node_op_asgn1_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OP_ASGN2"]:
+ self._append_expression("*(rb_node_op_asgn2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OP_ASGN_AND"]:
+ self._append_expression("*(rb_node_op_asgn_and_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OP_ASGN_OR"]:
+ self._append_expression("*(rb_node_op_asgn_or_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OP_CDECL"]:
+ self._append_expression("*(rb_node_op_cdecl_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CALL"]:
+ self._append_expression("*(rb_node_call_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OPCALL"]:
+ self._append_expression("*(rb_node_opcall_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FCALL"]:
+ self._append_expression("*(rb_node_fcall_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_VCALL"]:
+ self._append_expression("*(rb_node_vcall_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_QCALL"]:
+ self._append_expression("*(rb_node_qcall_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_SUPER"]:
+ self._append_expression("*(rb_node_super_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ZSUPER"]:
+ self._append_expression("*(rb_node_zsuper_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_LIST"]:
+ self._append_expression("*(rb_node_list_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ZLIST"]:
+ self._append_expression("*(rb_node_zlist_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_HASH"]:
+ self._append_expression("*(rb_node_hash_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_RETURN"]:
+ self._append_expression("*(rb_node_return_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_YIELD"]:
+ self._append_expression("*(rb_node_yield_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_LVAR"]:
+ self._append_expression("*(rb_node_lvar_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DVAR"]:
+ self._append_expression("*(rb_node_dvar_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_GVAR"]:
+ self._append_expression("*(rb_node_gvar_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CONST"]:
+ self._append_expression("*(rb_node_const_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CVAR"]:
+ self._append_expression("*(rb_node_cvar_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_NTH_REF"]:
+ self._append_expression("*(rb_node_nth_ref_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_BACK_REF"]:
+ self._append_expression("*(rb_node_back_ref_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_MATCH"]:
+ self._append_expression("*(rb_node_match_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_MATCH2"]:
+ self._append_expression("*(rb_node_match2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_MATCH3"]:
+ self._append_expression("*(rb_node_match3_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_STR"]:
+ self._append_expression("*(rb_node_str_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DSTR"]:
+ self._append_expression("*(rb_node_dstr_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_XSTR"]:
+ self._append_expression("*(rb_node_xstr_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DXSTR"]:
+ self._append_expression("*(rb_node_dxstr_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_EVSTR"]:
+ self._append_expression("*(rb_node_evstr_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_REGX"]:
+ self._append_expression("*(rb_node_regx_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DREGX"]:
+ self._append_expression("*(rb_node_dregx_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ONCE"]:
+ self._append_expression("*(rb_node_once_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ARGS"]:
+ self._append_expression("*(rb_node_args_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ARGS_AUX"]:
+ self._append_expression("*(rb_node_args_aux_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_OPT_ARG"]:
+ self._append_expression("*(rb_node_opt_arg_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_KW_ARG"]:
+ self._append_expression("*(rb_node_kw_arg_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_POSTARG"]:
+ self._append_expression("*(rb_node_postarg_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ARGSCAT"]:
+ self._append_expression("*(rb_node_argscat_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ARGSPUSH"]:
+ self._append_expression("*(rb_node_argspush_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_SPLAT"]:
+ self._append_expression("*(rb_node_splat_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DEFN"]:
+ self._append_expression("*(rb_node_defn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DEFS"]:
+ self._append_expression("*(rb_node_defs_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ALIAS"]:
+ self._append_expression("*(rb_node_alias_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_VALIAS"]:
+ self._append_expression("*(rb_node_valias_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_UNDEF"]:
+ self._append_expression("*(rb_node_undef_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_CLASS"]:
+ self._append_expression("*(rb_node_class_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_MODULE"]:
+ self._append_expression("*(rb_node_module_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_SCLASS"]:
+ self._append_expression("*(rb_node_sclass_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_COLON2"]:
+ self._append_expression("*(rb_node_colon2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_COLON3"]:
+ self._append_expression("*(rb_node_colon3_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DOT2"]:
+ self._append_expression("*(rb_node_dot2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DOT3"]:
+ self._append_expression("*(rb_node_dot3_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FLIP2"]:
+ self._append_expression("*(rb_node_flip2_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FLIP3"]:
+ self._append_expression("*(rb_node_flip3_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_SELF"]:
+ self._append_expression("*(rb_node_self_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_NIL"]:
+ self._append_expression("*(rb_node_nil_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_TRUE"]:
+ self._append_expression("*(rb_node_true_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FALSE"]:
+ self._append_expression("*(rb_node_false_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ERRINFO"]:
+ self._append_expression("*(rb_node_errinfo_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DEFINED"]:
+ self._append_expression("*(rb_node_defined_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_POSTEXE"]:
+ self._append_expression("*(rb_node_postexe_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_DSYM"]:
+ self._append_expression("*(rb_node_dsym_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ATTRASGN"]:
+ self._append_expression("*(rb_node_attrasgn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_LAMBDA"]:
+ self._append_expression("*(rb_node_lambda_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ARYPTN"]:
+ self._append_expression("*(rb_node_aryptn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_HSHPTN"]:
+ self._append_expression("*(rb_node_hshptn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FNDPTN"]:
+ self._append_expression("*(rb_node_fndptn_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_ERROR"]:
+ self._append_expression("*(rb_node_error_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_LINE"]:
+ self._append_expression("*(rb_node_line_t *) %0#x" % val.GetValueAsUnsigned())
+ elif nd_type == self.ruby_globals["NODE_FILE"]:
+ self._append_expression("*(rb_node_file_t *) %0#x" % val.GetValueAsUnsigned())
+ else:
+ self._append_expression("*(NODE *) %0#x" % val.GetValueAsUnsigned())
+ return True
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-07 23:14:21 +0000