[Vm-dev] problem with Interpreter>>#printNameOfClass:count:

[Eliot Miranda]

looks good.  I'll integrate in Cog soon.  BTW, you can use
fetchClassOfNonInt: where you know you won't encounter an immediate, hence

printNameOfClass: classOop count: cnt "Details: The count argument is used
to avoid a possible infinite recursion if classOop is a corrupted object." |
metaclassClass | cnt <= 0 ifTrue: [ ^ self print: 'bad class' ].
metaclassClass := self fetchClassOfNonInt: (self fetchClassOfNonInt: (self
fetchPointer: ClassInteger ofObject: specialObjectsOop)). metaclassClass =
(self fetchClassOfNonInt: classOop) "Is it a metaclass?" ifTrue: [self
printNameOfClass: (self fetchPointer: 5 "thisClass" ofObject: classOop)
count: cnt - 1. self print: ' class'] ifFalse: [self printStringOf: (self
fetchPointer: 6 "name" ofObject: classOop)]

On Thu, Mar 31, 2011 at 8:51 PM, Javier Pimás <elpochodelagente at gmail.com>wrote:

>
> Hi, this method of Interpreter is used for debugging, and should print the
> name of the class passed in console:
>
> printNameOfClass: classOop count: cnt
> "Details: The count argument is used to avoid a possible infinite recursion
> if classOop is a corrupted object."
>
> cnt <= 0 ifTrue: [ ^ self print: 'bad class' ].
> (self sizeBitsOf: classOop) = (7 * self bytesPerWord) "(Metaclass
> instSize+1 * 4)"
>  ifTrue: [self printNameOfClass: (self fetchPointer: 5 "thisClass"
> ofObject: classOop)
> count: cnt - 1.
>  self print: ' class']
> ifFalse: [self printStringOf: (self fetchPointer: 6 "name" ofObject:
> classOop)]
>
> it's logic is this: if the classOop is of a normal Class instance, it
> should use the instance var number six, which corresponds to the class'
> name. If not, then the classOop represents a Metaclass instance, and then it
> will fetch inst var number 5, which is the corresponding class, print its
> name, and then print 'class' to let you distinguish it that it is a
> metaclass.
>
> The problem of the method is that it determines if it's a class instance or
> a metaclass instance by looking at the size of the oop, which seems to have
> changed, at least in pharo (Metaclass instSize+1 * 4 = 36 =
> 9*bytesPerWord).
>
> The method could be fixed by changing 7 to 9 then. But it will break if
> Metaclass changes again. So I have this idea: make it check if the classOop
> is a metaclass instance. Metaclass class is not a special object, but can be
> obtained by accessing any special one, like with
>
> Integer class class
>
> or directly with
>
> nil class class class (!!)
>
> then the proposed code is:
>
> printNameOfClass: classOop count: cnt "Details: The count argument is used
> to avoid a possible infinite recursion if classOop is a corrupted object." |
> metaclassClass | cnt <= 0 ifTrue: [ ^ self print: 'bad class' ].
> metaclassClass := self fetchClassOf: (self fetchClassOf: (self fetchPointer:
> ClassInteger ofObject: specialObjectsOop)). metaclassClass = (self
> fetchClassOf: classOop) "Is it a metaclass?" ifTrue: [self printNameOfClass:
> (self fetchPointer: 5 "thisClass" ofObject: classOop) count: cnt - 1. self
> print: ' class'] ifFalse: [self printStringOf: (self fetchPointer: 6 "name"
> ofObject: classOop)]
>
>
> I'd also like to have this included too:
>
> printClassOf: oop
>  "Print the class of the oop in console"
> self printNameOfClass: (self fetchClassOf: oop) count: 5.
>
> which is simple but pretty much useful.
>
> What do you think?
>
> Regards,
>            Javier.
>
> --
> Javier Pimás
> Ciudad de Buenos Aires
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.squeakfoundation.org/pipermail/vm-dev/attachments/20110405/4e72cb82/attachment-0001.htm