LLDB: Use `expression` to save the result into the history [ci skip]

3 files changed, 160 insertions, 162 deletions

diff --git a/misc/lldb_cruby.py b/misc/lldb_cruby.py
index e667a46628..400ccb45b9 100755
--- a/misc/lldb_cruby.py
+++ b/misc/lldb_cruby.py
@@ -206,8 +206,7 @@ def string2cstr(rstring):
 
 def output_string(debugger, result, rstring):
     cptr, clen = string2cstr(rstring)
-    expr = "print *(const char (*)[%d])%0#x" % (clen, cptr)
-    append_command_output(debugger, expr, result)
+    append_expression(debugger, "*(const char (*)[%d])%0#x" % (clen, cptr), result)
 
 def fixnum_p(x):
     return x & RUBY_FIXNUM_FLAG != 0
@@ -226,6 +225,9 @@ def append_command_output(debugger, command, result):
     result.write(output1)
     result.write(output2)
 
+def append_expression(debugger, expression, result):
+    append_command_output(debugger, "expression " + expression, result)
+
 def lldb_rp(debugger, command, result, internal_dict):
     if not ('RUBY_Qfalse' in globals()):
         lldb_init(debugger)
@@ -257,13 +259,13 @@ def lldb_inspect(debugger, target, result, val):
     elif fixnum_p(num):
         print(num >> 1, file=result)
     elif flonum_p(num):
-        append_command_output(debugger, "print rb_float_value(%0#x)" % val.GetValueAsUnsigned(), result)
+        append_expression(debugger, "rb_float_value(%0#x)" % val.GetValueAsUnsigned(), result)
     elif static_sym_p(num):
         if num < 128:
             print("T_SYMBOL: %c" % num, file=result)
         else:
             print("T_SYMBOL: (%x)" % num, file=result)
-            append_command_output(debugger, "p rb_id2name(%0#x)" % (num >> 8), result)
+            append_expression(debugger, "rb_id2name(%0#x)" % (num >> 8), result)
     elif num & RUBY_IMMEDIATE_MASK:
         print('immediate(%x)' % num, file=result)
     else:
@@ -291,13 +293,13 @@ def lldb_inspect(debugger, target, result, val):
             print('T_NIL: %s%s' % (flaginfo, val.Dereference()), file=result)
         elif flType == RUBY_T_OBJECT:
             result.write('T_OBJECT: %s' % flaginfo)
-            append_command_output(debugger, "print *(struct RObject*)%0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RObject*)%0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_CLASS or flType == RUBY_T_MODULE or flType == RUBY_T_ICLASS:
             result.write('T_%s: %s' % ('CLASS' if flType == RUBY_T_CLASS else 'MODULE' if flType == RUBY_T_MODULE else 'ICLASS', flaginfo))
-            append_command_output(debugger, "print *(struct RClass*)%0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RClass*)%0#x" % val.GetValueAsUnsigned(), result)
             tRClass = target.FindFirstType("struct RClass")
             if not val.Cast(tRClass).GetChildMemberWithName("ptr").IsValid():
-                append_command_output(debugger, "print *(struct rb_classext_struct*)%0#x" % (val.GetValueAsUnsigned() + tRClass.GetByteSize()), result)
+                append_expression(debugger, "*(struct rb_classext_struct*)%0#x" % (val.GetValueAsUnsigned() + tRClass.GetByteSize()), result)
         elif flType == RUBY_T_STRING:
             result.write('T_STRING: %s' % flaginfo)
             encidx = ((flags & RUBY_ENCODING_MASK)>>RUBY_ENCODING_SHIFT)
@@ -311,12 +313,12 @@ def lldb_inspect(debugger, target, result, val):
             if len == 0:
                 result.write("(empty)\n")
             else:
-                append_command_output(debugger, "print *(const char (*)[%d])%0#x" % (len, ptr), result)
+                append_expression(debugger, "*(const char (*)[%d])%0#x" % (len, ptr), result)
         elif flType == RUBY_T_SYMBOL:
             result.write('T_SYMBOL: %s' % flaginfo)
             tRSymbol = target.FindFirstType("struct RSymbol").GetPointerType()
             val = val.Cast(tRSymbol)
-            append_command_output(debugger, 'print (ID)%0#x ' % val.GetValueForExpressionPath("->id").GetValueAsUnsigned(), result)
+            append_expression(debugger, '(ID)%0#x ' % val.GetValueForExpressionPath("->id").GetValueAsUnsigned(), result)
             tRString = target.FindFirstType("struct RString").GetPointerType()
             output_string(debugger, result, val.GetValueForExpressionPath("->fstr").Cast(tRString))
         elif flType == RUBY_T_ARRAY:
@@ -342,12 +344,12 @@ def lldb_inspect(debugger, target, result, val):
             else:
                 result.write("\n")
                 if ptr.GetValueAsSigned() == 0:
-                    append_command_output(debugger, "expression -fx -- ((struct RArray*)%0#x)->as.ary" % val.GetValueAsUnsigned(), result)
+                    append_expression(debugger, "-fx -- ((struct RArray*)%0#x)->as.ary" % val.GetValueAsUnsigned(), result)
                 else:
-                    append_command_output(debugger, "expression -Z %d -fx -- (const VALUE*)%0#x" % (len, ptr.GetValueAsUnsigned()), result)
+                    append_expression(debugger, "-Z %d -fx -- (const VALUE*)%0#x" % (len, ptr.GetValueAsUnsigned()), result)
         elif flType == RUBY_T_HASH:
             result.write("T_HASH: %s" % flaginfo)
-            append_command_output(debugger, "p *(struct RHash *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RHash *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_BIGNUM:
             tRBignum = target.FindFirstType("struct RBignum").GetPointerType()
             val = val.Cast(tRBignum)
@@ -355,15 +357,15 @@ def lldb_inspect(debugger, target, result, val):
             if flags & RUBY_FL_USER2:
                 len = ((flags & (RUBY_FL_USER3|RUBY_FL_USER4|RUBY_FL_USER5)) >> (RUBY_FL_USHIFT+3))
                 print("T_BIGNUM: sign=%s len=%d (embed)" % (sign, len), file=result)
-                append_command_output(debugger, "print ((struct RBignum *) %0#x)->as.ary" % val.GetValueAsUnsigned(), result)
+                append_expression(debugger, "((struct RBignum *) %0#x)->as.ary" % val.GetValueAsUnsigned(), result)
             else:
                 len = val.GetValueForExpressionPath("->as.heap.len").GetValueAsSigned()
                 print("T_BIGNUM: sign=%s len=%d" % (sign, len), file=result)
                 print(val.Dereference(), file=result)
-                append_command_output(debugger, "expression -Z %x -fx -- (const BDIGIT*)((struct RBignum*)%d)->as.heap.digits" % (len, val.GetValueAsUnsigned()), result)
-                # append_command_output(debugger, "x ((struct RBignum *) %0#x)->as.heap.digits / %d" % (val.GetValueAsUnsigned(), len), result)
+                append_expression(debugger, "-Z %x -fx -- (const BDIGIT*)((struct RBignum*)%d)->as.heap.digits" % (len, val.GetValueAsUnsigned()), result)
+                # append_expression(debugger, "((struct RBignum *) %0#x)->as.heap.digits / %d" % (val.GetValueAsUnsigned(), len), result)
         elif flType == RUBY_T_FLOAT:
-            append_command_output(debugger, "print ((struct RFloat *)%d)->float_value" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "((struct RFloat *)%d)->float_value" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_RATIONAL:
             tRRational = target.FindFirstType("struct RRational").GetPointerType()
             val = val.Cast(tRRational)
@@ -396,39 +398,39 @@ def lldb_inspect(debugger, target, result, val):
             flag = val.GetValueForExpressionPath("->typed_flag")
             if flag.GetValueAsUnsigned() == 1:
                 print("T_DATA: %s" % val.GetValueForExpressionPath("->type->wrap_struct_name"), file=result)
-                append_command_output(debugger, "p *(struct RTypedData *) %0#x" % val.GetValueAsUnsigned(), result)
+                append_expression(debugger, "*(struct RTypedData *) %0#x" % val.GetValueAsUnsigned(), result)
             else:
                 print("T_DATA:", file=result)
-                append_command_output(debugger, "p *(struct RData *) %0#x" % val.GetValueAsUnsigned(), result)
+                append_expression(debugger, "*(struct RData *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_NODE:
             tRTypedData = target.FindFirstType("struct RNode").GetPointerType()
             nd_type = (flags & RUBY_NODE_TYPEMASK) >> RUBY_NODE_TYPESHIFT
-            append_command_output(debugger, "p (node_type) %d" % nd_type, result)
+            append_expression(debugger, "(node_type) %d" % nd_type, result)
             val = val.Cast(tRTypedData)
-            append_command_output(debugger, "p *(struct RNode *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RNode *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_MOVED:
             tRTypedData = target.FindFirstType("struct RMoved").GetPointerType()
             val = val.Cast(tRTypedData)
-            append_command_output(debugger, "p *(struct RMoved *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RMoved *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_MATCH:
             tRTypedData = target.FindFirstType("struct RMatch").GetPointerType()
             val = val.Cast(tRTypedData)
-            append_command_output(debugger, "p *(struct RMatch *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RMatch *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_IMEMO:
             # I'm not sure how to get IMEMO_MASK out of lldb. It's not in globals()
             imemo_type = (flags >> RUBY_FL_USHIFT) & 0x0F # IMEMO_MASK
 
             print("T_IMEMO: ", file=result)
-            append_command_output(debugger, "p (enum imemo_type) %d" % imemo_type, result)
-            append_command_output(debugger, "p *(struct MEMO *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "(enum imemo_type) %d" % imemo_type, result)
+            append_expression(debugger, "*(struct MEMO *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_STRUCT:
             tRTypedData = target.FindFirstType("struct RStruct").GetPointerType()
             val = val.Cast(tRTypedData)
-            append_command_output(debugger, "p *(struct RStruct *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RStruct *) %0#x" % val.GetValueAsUnsigned(), result)
         elif flType == RUBY_T_ZOMBIE:
             tRZombie = target.FindFirstType("struct RZombie").GetPointerType()
             val = val.Cast(tRZombie)
-            append_command_output(debugger, "p *(struct RZombie *) %0#x" % val.GetValueAsUnsigned(), result)
+            append_expression(debugger, "*(struct RZombie *) %0#x" % val.GetValueAsUnsigned(), result)
         else:
             print("Not-handled type %0#x" % flType, file=result)
             print(val, file=result)
diff --git a/misc/lldb_rb/commands/heap_page_command.py b/misc/lldb_rb/commands/heap_page_command.py
index edb74a415b..b56a3eae4e 100644
--- a/misc/lldb_rb/commands/heap_page_command.py
+++ b/misc/lldb_rb/commands/heap_page_command.py
@@ -14,8 +14,8 @@ class HeapPageCommand(RbBaseCommand):
         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(debugger, "(struct heap_page *) %0#x" % page.GetValueAsUnsigned(), result)
+        self._append_expression(debugger, "*(struct heap_page *) %0#x" % page.GetValueAsUnsigned(), result)
 
     def _get_page(self, val):
         addr = val.GetValueAsUnsigned()
diff --git a/misc/lldb_rb/utils.py b/misc/lldb_rb/utils.py
index b8ee5a31d7..7cd73569a6 100644
--- a/misc/lldb_rb/utils.py
+++ b/misc/lldb_rb/utils.py
@@ -16,6 +16,9 @@ class RbInspector(LLDBInterface):
         self.result.write(output1)
         self.result.write(output2)
 
+    def _append_expression(self, expression):
+        self._append_command_output("expression " + expression)
+
     def string2cstr(self, rstring):
         """Returns the pointer to the C-string in the given String object"""
         if rstring.TypeIsPointerType():
@@ -32,8 +35,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 +51,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"]
@@ -70,13 +72,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 +100,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 +108,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_command_expression(
+                        "*(struct rb_classext_struct*)%0#x" %
                         (val.GetValueAsUnsigned() + tRClass.GetByteSize())
                     )
 
@@ -133,7 +135,7 @@ class RbInspector(LLDBInterface):
                 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,8 +143,7 @@ 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"):
@@ -164,15 +165,13 @@ 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())
+                self._append_expression("*(struct RHash *) %0#x" % val.GetValueAsUnsigned())
 
             elif rval.is_type("RUBY_T_BIGNUM"):
                 sign = '-'
@@ -182,17 +181,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(rval.as_type("bignum"), file=self.result)
-                    self._append_command_output(
-                            "expression -Z %d -fx -- ((struct RBignum*)%d)->as.heap.digits" %
-                            (len, val.GetValueAsUnsigned()))
+                    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"):
@@ -233,12 +231,10 @@ class RbInspector(LLDBInterface):
                     print("T_DATA: %s" %
                           val.GetValueForExpressionPath("->type->wrap_struct_name"),
                           file=self.result)
-                    self._append_command_output(
-                            "p *(struct RTypedData *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RTypedData *) %0#x" % val.GetValueAsUnsigned())
                 else:
                     print("T_DATA:", file=self.result)
-                    self._append_command_output(
-                            "p *(struct RData *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RData *) %0#x" % val.GetValueAsUnsigned())
 
             elif rval.is_type("RUBY_T_NODE"):
                 tRNode = self.target.FindFirstType("struct RNode").GetPointerType()
@@ -248,226 +244,226 @@ class RbInspector(LLDBInterface):
                 nd_type = (rval.flags & rbNodeTypeMask) >> rbNodeTypeShift
                 val = val.Cast(tRNode)
 
-                self._append_command_output("p (node_type) %d" % nd_type)
+                self._append_expression("(node_type) %d" % nd_type)
 
                 if nd_type == self.ruby_globals["NODE_SCOPE"]:
-                    self._append_command_output("p *(struct RNode_SCOPE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_SCOPE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_BLOCK"]:
-                    self._append_command_output("p *(struct RNode_BLOCK *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_BLOCK *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_IF"]:
-                    self._append_command_output("p *(struct RNode_IF *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_IF *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_UNLESS"]:
-                    self._append_command_output("p *(struct RNode_UNLESS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_UNLESS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CASE"]:
-                    self._append_command_output("p *(struct RNode_CASE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CASE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CASE2"]:
-                    self._append_command_output("p *(struct RNode_CASE2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CASE2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CASE3"]:
-                    self._append_command_output("p *(struct RNode_CASE3 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CASE3 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_WHEN"]:
-                    self._append_command_output("p *(struct RNode_WHEN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_WHEN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_IN"]:
-                    self._append_command_output("p *(struct RNode_IN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_IN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_WHILE"]:
-                    self._append_command_output("p *(struct RNode_WHILE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_WHILE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_UNTIL"]:
-                    self._append_command_output("p *(struct RNode_UNTIL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_UNTIL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ITER"]:
-                    self._append_command_output("p *(struct RNode_ITER *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ITER *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FOR"]:
-                    self._append_command_output("p *(struct RNode_FOR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FOR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FOR_MASGN"]:
-                    self._append_command_output("p *(struct RNode_FOR_MASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FOR_MASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_BREAK"]:
-                    self._append_command_output("p *(struct RNode_BREAK *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_BREAK *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_NEXT"]:
-                    self._append_command_output("p *(struct RNode_NEXT *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_NEXT *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_REDO"]:
-                    self._append_command_output("p *(struct RNode_REDO *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_REDO *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RETRY"]:
-                    self._append_command_output("p *(struct RNode_RETRY *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RETRY *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_BEGIN"]:
-                    self._append_command_output("p *(struct RNode_BEGIN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_BEGIN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RESCUE"]:
-                    self._append_command_output("p *(struct RNode_RESCUE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RESCUE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RESBODY"]:
-                    self._append_command_output("p *(struct RNode_RESBODY *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RESBODY *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ENSURE"]:
-                    self._append_command_output("p *(struct RNode_ENSURE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ENSURE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_AND"]:
-                    self._append_command_output("p *(struct RNode_AND *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_AND *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OR"]:
-                    self._append_command_output("p *(struct RNode_OR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_MASGN"]:
-                    self._append_command_output("p *(struct RNode_MASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_MASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_LASGN"]:
-                    self._append_command_output("p *(struct RNode_LASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_LASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DASGN"]:
-                    self._append_command_output("p *(struct RNode_DASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_GASGN"]:
-                    self._append_command_output("p *(struct RNode_GASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_GASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_IASGN"]:
-                    self._append_command_output("p *(struct RNode_IASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_IASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CDECL"]:
-                    self._append_command_output("p *(struct RNode_CDECL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CDECL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CVASGN"]:
-                    self._append_command_output("p *(struct RNode_CVASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CVASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OP_ASGN1"]:
-                    self._append_command_output("p *(struct RNode_OP_ASGN1 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OP_ASGN1 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OP_ASGN2"]:
-                    self._append_command_output("p *(struct RNode_OP_ASGN2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OP_ASGN2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OP_ASGN_AND"]:
-                    self._append_command_output("p *(struct RNode_OP_ASGN_AND *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OP_ASGN_AND *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OP_ASGN_OR"]:
-                    self._append_command_output("p *(struct RNode_OP_ASGN_OR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OP_ASGN_OR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OP_CDECL"]:
-                    self._append_command_output("p *(struct RNode_OP_CDECL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OP_CDECL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CALL"]:
-                    self._append_command_output("p *(struct RNode_CALL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CALL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OPCALL"]:
-                    self._append_command_output("p *(struct RNode_OPCALL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OPCALL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FCALL"]:
-                    self._append_command_output("p *(struct RNode_FCALL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FCALL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_VCALL"]:
-                    self._append_command_output("p *(struct RNode_VCALL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_VCALL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_QCALL"]:
-                    self._append_command_output("p *(struct RNode_QCALL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_QCALL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_SUPER"]:
-                    self._append_command_output("p *(struct RNode_SUPER *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_SUPER *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ZSUPER"]:
-                    self._append_command_output("p *(struct RNode_ZSUPER *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ZSUPER *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_LIST"]:
-                    self._append_command_output("p *(struct RNode_LIST *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_LIST *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ZLIST"]:
-                    self._append_command_output("p *(struct RNode_ZLIST *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ZLIST *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_HASH"]:
-                    self._append_command_output("p *(struct RNode_HASH *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_HASH *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RETURN"]:
-                    self._append_command_output("p *(struct RNode_RETURN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RETURN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_YIELD"]:
-                    self._append_command_output("p *(struct RNode_YIELD *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_YIELD *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_LVAR"]:
-                    self._append_command_output("p *(struct RNode_LVAR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_LVAR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DVAR"]:
-                    self._append_command_output("p *(struct RNode_DVAR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DVAR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_GVAR"]:
-                    self._append_command_output("p *(struct RNode_GVAR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_GVAR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CONST"]:
-                    self._append_command_output("p *(struct RNode_CONST *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CONST *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CVAR"]:
-                    self._append_command_output("p *(struct RNode_CVAR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CVAR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_NTH_REF"]:
-                    self._append_command_output("p *(struct RNode_NTH_REF *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_NTH_REF *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_BACK_REF"]:
-                    self._append_command_output("p *(struct RNode_BACK_REF *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_BACK_REF *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_MATCH"]:
-                    self._append_command_output("p *(struct RNode_MATCH *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_MATCH *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_MATCH2"]:
-                    self._append_command_output("p *(struct RNode_MATCH2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_MATCH2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_MATCH3"]:
-                    self._append_command_output("p *(struct RNode_MATCH3 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_MATCH3 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_LIT"]:
-                    self._append_command_output("p *(struct RNode_LIT *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_LIT *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_STR"]:
-                    self._append_command_output("p *(struct RNode_STR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_STR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DSTR"]:
-                    self._append_command_output("p *(struct RNode_DSTR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DSTR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_XSTR"]:
-                    self._append_command_output("p *(struct RNode_XSTR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_XSTR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DXSTR"]:
-                    self._append_command_output("p *(struct RNode_DXSTR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DXSTR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_EVSTR"]:
-                    self._append_command_output("p *(struct RNode_EVSTR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_EVSTR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DREGX"]:
-                    self._append_command_output("p *(struct RNode_DREGX *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DREGX *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ONCE"]:
-                    self._append_command_output("p *(struct RNode_ONCE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ONCE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ARGS"]:
-                    self._append_command_output("p *(struct RNode_ARGS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ARGS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ARGS_AUX"]:
-                    self._append_command_output("p *(struct RNode_ARGS_AUX *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ARGS_AUX *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_OPT_ARG"]:
-                    self._append_command_output("p *(struct RNode_OPT_ARG *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_OPT_ARG *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_KW_ARG"]:
-                    self._append_command_output("p *(struct RNode_KW_ARG *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_KW_ARG *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_POSTARG"]:
-                    self._append_command_output("p *(struct RNode_POSTARG *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_POSTARG *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ARGSCAT"]:
-                    self._append_command_output("p *(struct RNode_ARGSCAT *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ARGSCAT *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ARGSPUSH"]:
-                    self._append_command_output("p *(struct RNode_ARGSPUSH *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ARGSPUSH *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_SPLAT"]:
-                    self._append_command_output("p *(struct RNode_SPLAT *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_SPLAT *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DEFN"]:
-                    self._append_command_output("p *(struct RNode_DEFN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DEFN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DEFS"]:
-                    self._append_command_output("p *(struct RNode_DEFS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DEFS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ALIAS"]:
-                    self._append_command_output("p *(struct RNode_ALIAS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ALIAS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_VALIAS"]:
-                    self._append_command_output("p *(struct RNode_VALIAS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_VALIAS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_UNDEF"]:
-                    self._append_command_output("p *(struct RNode_UNDEF *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_UNDEF *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_CLASS"]:
-                    self._append_command_output("p *(struct RNode_CLASS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_CLASS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_MODULE"]:
-                    self._append_command_output("p *(struct RNode_MODULE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_MODULE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_SCLASS"]:
-                    self._append_command_output("p *(struct RNode_SCLASS *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_SCLASS *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_COLON2"]:
-                    self._append_command_output("p *(struct RNode_COLON2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_COLON2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_COLON3"]:
-                    self._append_command_output("p *(struct RNode_COLON3 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_COLON3 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DOT2"]:
-                    self._append_command_output("p *(struct RNode_DOT2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DOT2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DOT3"]:
-                    self._append_command_output("p *(struct RNode_DOT3 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DOT3 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FLIP2"]:
-                    self._append_command_output("p *(struct RNode_FLIP2 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FLIP2 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FLIP3"]:
-                    self._append_command_output("p *(struct RNode_FLIP3 *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FLIP3 *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_SELF"]:
-                    self._append_command_output("p *(struct RNode_SELF *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_SELF *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_NIL"]:
-                    self._append_command_output("p *(struct RNode_NIL *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_NIL *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_TRUE"]:
-                    self._append_command_output("p *(struct RNode_TRUE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_TRUE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FALSE"]:
-                    self._append_command_output("p *(struct RNode_FALSE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FALSE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ERRINFO"]:
-                    self._append_command_output("p *(struct RNode_ERRINFO *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ERRINFO *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DEFINED"]:
-                    self._append_command_output("p *(struct RNode_DEFINED *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DEFINED *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_POSTEXE"]:
-                    self._append_command_output("p *(struct RNode_POSTEXE *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_POSTEXE *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_DSYM"]:
-                    self._append_command_output("p *(struct RNode_DSYM *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_DSYM *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ATTRASGN"]:
-                    self._append_command_output("p *(struct RNode_ATTRASGN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ATTRASGN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_LAMBDA"]:
-                    self._append_command_output("p *(struct RNode_LAMBDA *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_LAMBDA *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ARYPTN"]:
-                    self._append_command_output("p *(struct RNode_ARYPTN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ARYPTN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_HSHPTN"]:
-                    self._append_command_output("p *(struct RNode_HSHPTN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_HSHPTN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_FNDPTN"]:
-                    self._append_command_output("p *(struct RNode_FNDPTN *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_FNDPTN *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_ERROR"]:
-                    self._append_command_output("p *(struct RNode_ERROR *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_ERROR *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RIPPER"]:
-                    self._append_command_output("p *(struct RNode_RIPPER *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RIPPER *) %0#x" % val.GetValueAsUnsigned())
                 elif nd_type == self.ruby_globals["NODE_RIPPER_VALUES"]:
-                    self._append_command_output("p *(struct RNode_RIPPER_VALUES *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode_RIPPER_VALUES *) %0#x" % val.GetValueAsUnsigned())
                 else:
-                    self._append_command_output("p *(struct RNode *) %0#x" % val.GetValueAsUnsigned())
+                    self._append_expression("*(struct RNode *) %0#x" % val.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")