Tobject 类解析[转]-白红宇

Tobject 类解析[转]

阅读量：5096 次

发布时间：2019-06-13

本文共 10577 字，大约阅读时间需要 35 分钟。

原链接：

TObject = class

//创建

constructor Create;

//释放

procedure Free;

//初始化实列

class function InitInstance(Instance: Pointer): TObject;

//清除实列

procedure CleanupInstance;

//获得类的类型

function ClassType: TClass;

//获得了的名称

class function ClassName: ShortString;

//判断类的名称

class function ClassNameIs(const Name: string): Boolean;

//类的父类

class function ClassParent: TClass;

//类的信息指针

class function ClassInfo: Pointer;

//当前类的实列大小

class function InstanceSize: Longint;

//判断是否从一个类继承下来

class function InheritsFrom(AClass: TClass): Boolean;

//根据方法的名称获得方法的地址

class function MethodAddress(const Name: ShortString): Pointer;

//根据地址或的方法的名称

class function MethodName(Address: Pointer): ShortString;

//根据名称获得属性的地址

function FieldAddress(const Name: ShortString): Pointer;

//查询接口

function GetInterface(const IID: TGUID; out Obj): Boolean;

//获得接口的入口

class function GetInterfaceEntry(const IID: TGUID): PInterfaceEntry;

//获得接口表

class function GetInterfaceTable: PInterfaceTable;

//安全调用例外

function SafeCallException(ExceptObject: TObject;

ExceptAddr: Pointer): HResult; virtual;

//创建之后的执行

procedure AfterConstruction; virtual;

//释放之前的执行

procedure BeforeDestruction; virtual;

//分派消息

procedure Dispatch(var Message); virtual;

//默认的句柄

procedure DefaultHandler(var Message); virtual;

//新的实列

class function NewInstance: TObject; virtual;

//释放实列

procedure FreeInstance; virtual;

//释放

destructor Destroy; virtual;

end;

//初始化实列

class function TObject.InitInstance(Instance: Pointer): TObject;

{$IFDEF PUREPASCAL}

var

IntfTable: PInterfaceTable;

ClassPtr: TClass;

I: Integer;

begin

//分配需要的内存的大小

FillChar(Instance^, InstanceSize, 0);

//实列化分配好的内存

PInteger(Instance)^ := Integer(Self);

ClassPtr := Self;

//如果成功

while ClassPtr <> nil do

begin

//获得接口表

IntfTable := ClassPtr.GetInterfaceTable;

//遍历接口

if IntfTable <> nil then

for I := 0 to IntfTable.EntryCount-1 do

//初始化每个接口函数的具体实现

with IntfTable.Entries[I] do

begin

if VTable <> nil then

PInteger(@PChar(Instance)[IOffset])^ := Integer(VTable);

end;

ClassPtr := ClassPtr.ClassParent;

end;

Result := Instance;

end;

//清除实列

procedure TObject.CleanupInstance;

{$IFDEF PUREPASCAL}

var

ClassPtr: TClass;

InitTable: Pointer;

begin

//获得当前的类型

ClassPtr := ClassType;

//获得初始化标的地址

InitTable := PPointer(Integer(ClassPtr) + vmtInitTable)^;

//如果当前类存在并且初始化表也存在

while (ClassPtr <> nil) and (InitTable <> nil) do

begin

//释放所有的信息

_FinalizeRecord(Self, InitTable);

//如果当前类有父类则清楚父类的信息

ClassPtr := ClassPtr.ClassParent;

if ClassPtr <> nil then

InitTable := PPointer(Integer(ClassPtr) + vmtInitTable)^;

end;

//获得当前类的类型

function TObject.ClassType: TClass;

begin

//就是返回当前类的指针

Pointer(Result) := PPointer(Self)^;

end;

//获得当前类的类名

class function TObject.ClassName: ShortString;

{$IFDEF PUREPASCAL}

begin

//根据虚拟方发表返回指定的地址

Result := PShortString(PPointer(Integer(Self) + vmtClassName)^)^;

end;

// 判断当前类的类名

class function TObject.ClassNameIs(const Name: string): Boolean;

{$IFDEF PUREPASCAL}

var

Temp: ShortString;

I: Byte;

begin

Result := False;

//获得当前类的类名得指针

Temp := ClassName;

//根据字符串的长度比较每个字符区分大小写

for I := 0 to Byte(Temp[0]) do

if Temp[I] <> Name[I] then Exit;

Result := True;

end;

//获得当前类的父类

class function TObject.ClassParent: TClass;

{$IFDEF PUREPASCAL}

begin

//根据虚拟方法表或的父的地址指针

Pointer(Result) := PPointer(Integer(Self) + vmtParent)^;

//如果存在父类则返回

if Result <> nil then

Pointer(Result) := PPointer(Result)^;

end;

{$ELSE}

asm

MOV EAX,[EAX].vmtParent

TEST EAX,EAX

JE @@exit

MOV EAX,[EAX]

@@exit:

end;

//获得类型信息

class function TObject.ClassInfo: Pointer;

begin

Result := PPointer(Integer(Self) + vmtTypeInfo)^;

end;

//获得实列大小

class function TObject.InstanceSize: Longint;

begin

Result := PInteger(Integer(Self) + vmtInstanceSize)^;

end;

//判断是否从一个类继承下来

class function TObject.InheritsFrom(AClass: TClass): Boolean;

{$IFDEF PUREPASCAL}

var

ClassPtr: TClass;

begin

ClassPtr := Self;

//当前类是否存在并且和比较的类不等

while (ClassPtr <> nil) and (ClassPtr <> AClass) do

//获得这个类的父类

ClassPtr := PPointer(Integer(ClassPtr) + vmtParent)^;

Result := ClassPtr = AClass;

end;

{$ELSE}

asm

{ -> EAX Pointer to our class }

{ EDX Pointer to AClass }

{ <- AL Boolean result }

JMP @@haveVMT

@@loop:

MOV EAX,[EAX]

@@haveVMT:

CMP EAX,EDX

JE @@success

MOV EAX,[EAX].vmtParent

TEST EAX,EAX

JNE @@loop

JMP @@exit

@@success:

MOV AL,1

@@exit:

end;

//根据方法名称获得地址

class function TObject.MethodAddress(const Name: ShortString): Pointer;

asm

{ -> EAX Pointer to class }

{ EDX Pointer to name }

PUSH EBX

PUSH ESI

PUSH EDI

XOR ECX,ECX //清零

XOR EDI,EDI //清零

MOV BL,[EDX] //获得字符串的长度

JMP @@haveVMT //判断是否有虚拟方发表

@@outer: { upper 16 bits of ECX are 0 ! }

MOV EAX,[EAX]

@@haveVMT:

MOV ESI,[EAX].vmtMethodTable //获得虚拟方发表的地址

TEST ESI,ESI //是否存在

JE @@parent //如果不存在

MOV DI,[ESI] { EDI := method count }方法的数量

ADD ESI,2 // 开始

@@inner: { upper 16 bits of ECX are 0 ! }

MOV CL,[ESI+6] { compare length of strings } //获得名城的长度

CMP CL,BL //比较长度

JE @@cmpChar //如果相等就开始比较字符

@@cont: { upper 16 bits of ECX are 0 ! }

MOV CX,[ESI] { fetch length of method desc } //获得方法的长度 //长度两个字节指针4个字节 ///

ADD ESI,ECX { point ESI to next method } //指向下一个函数

DEC EDI

JNZ @@inner

@@parent: //获得父的方发表

MOV EAX,[EAX].vmtParent { fetch parent vmt }

TEST EAX,EAX //是否为0

JNE @@outer //不为零

JMP @@exit { return NIL } //已经到根

@@notEqual:

MOV BL,[EDX] { restore BL to length of name } //存储名字的长度

JMP @@cont //转移

@@cmpChar: { upper 16 bits of ECX are 0 ! }

MOV CH,0 { upper 24 bits of ECX are 0 ! } ///清空高位字节

@@cmpCharLoop:

MOV BL,[ESI+ECX+6] { case insensitive string cmp } //获得第一个字符

XOR BL,[EDX+ECX+0] { last char is compared first } //比较

AND BL,$DF //清空其他标志位

JNE @@notEqual

DEC ECX { ECX serves as counter } //比较下一个

JNZ @@cmpCharLoop //如果不为零进行下一个字符的比较

{ found it }

MOV EAX,[ESI+2] //找到并且得到指针 12 方法长度 3456 方法指针 7890 方法名称 7 方法名城的长度

@@exit:

POP EDI

POP ESI

POP EBX

end;

//根据字段名获得地址

function TObject.FieldAddress(const Name: ShortString): Pointer;

asm

{ -> EAX Pointer to instance }

{ EDX Pointer to name }

PUSH EBX

PUSH ESI

PUSH EDI

XOR ECX,ECX //清空Cx

XOR EDI,EDI //清空Edit

MOV BL,[EDX] //获得Name的长度

PUSH EAX { save instance pointer } //保存当前实列指针

@@outer:

MOV EAX,[EAX] { fetch class pointer } //获得当前类的指针

MOV ESI,[EAX].vmtFieldTable //获得字段列表的地址

TEST ESI,ESI //是否存在

JE @@parent //如果不存在就到当前的父类查找

MOV DI,[ESI] { fetch count of fields } //获得字段的数量

ADD ESI,6 // 2 为数量 4 位指针

@@inner:

MOV CL,[ESI+6] { compare string lengths } //获得当前字段的长度

CMP CL,BL //比较长度

JE @@cmpChar //如果相等就开始比较字符

@@cont: ///LEA是取变量的地址

LEA ESI,[ESI+ECX+7] { point ESI to next field } //Esi指向下一个字段ESI 当前位子+ECX 长度+7 ？？？

DEC EDI //数量减一

JNZ @@inner //如果不等于零则继续比较

@@parent:

MOV EAX,[EAX].vmtParent { fetch parent VMT } //获得当前的父类地址

TEST EAX,EAX //是否存在

JNE @@outer //如果存在则准备获得字段数量

POP EDX { forget instance, return Nil } //否则恢复Edx 恢复实列返回nil 当前Eax为空

JMP @@exit //并且退出

@@notEqual:

MOV BL,[EDX] { restore BL to length of name } //获得目的字段名称的长度

MOV CL,[ESI+6] { ECX := length of field name } //获得源字段名城的长度

JMP @@cont

@@cmpChar:

MOV BL,[ESI+ECX+6] { case insensitive string cmp } //字符比较

XOR BL,[EDX+ECX+0] { starting with last char }

AND BL,$DF //标志位处理

JNE @@notEqual //如果不等

DEC ECX { ECX serves as counter } //字符长度减一

JNZ @@cmpChar //如果还有没有比较完的字符

{ found it }

MOV EAX,[ESI] { result is field offset plus ... } //获得当前的地址的偏移量

POP EDX //恢复当前实列到Edx

ADD EAX,EDX { instance pointer } //获得字段的偏移地址

@@exit:

POP EDI

POP ESI

POP EBX

end;

function TObject.GetInterface(const IID: TGUID; out Obj): Boolean;

var

InterfaceEntry: PInterfaceEntry;

begin

Pointer(Obj) := nil;

InterfaceEntry := GetInterfaceEntry(IID);

if InterfaceEntry <> nil then

begin

if InterfaceEntry^.IOffset <> 0 then

begin

Pointer(Obj) := Pointer(Integer(Self) + InterfaceEntry^.IOffset);

if Pointer(Obj) <> nil then IInterface(Obj)._AddRef;

end

else

IInterface(Obj) := InvokeImplGetter(Self, InterfaceEntry^.ImplGetter);

end;

Result := Pointer(Obj) <> nil;

end;

----------------------

一个实列的创建过程

s:=Tstrings.create ;

Mov Dl ,$01,

Mov Eax , [$00412564]; //？？

Call Tobject.create ;

{

Test dl,dl ;

Jz +$08 ///???

Add Esp,-$10;

Call @ClassCreate;

{

push Edx,

Push Ecx,

Push Ebx,

Test Dl,dl

jl +03

Call Dword Ptr[eax-$0c]

{

NewInStance

push Ebx

mov Ebx ,eax

mov Eax ,ebx

Call Tobject.instancesize

{

Add Eax,-$28

Mov Eax,[Eax]

Ret

}

Call @GetMem

{

push Ebx

Test Eax,Eax

jle +$15

Call Dword ptr [memoryManager]

Mov Ebx,Eax

Test Ebx,ebx

Jnz +$0B

mov Al,%01

Call Error

Xor Ebx,Ebx

pop Ebx

Ret

}

mov Edx,Eax

Mov Eax,Ebx,

call Tobject.initInstance

pop Ebx

}

Xor Edx,edx

Lea Ecx,[Esp+$10]

Mov Ebx,Fs:[Edx]

mov [Ecx],EDx

mov [Ecx+$08],ebx

mov [Ecx+$04],$0040340D

mov Fs:[Edx] , Ecx

pop Ebx

pop Ecx

pop Edx

}

Test dl,dl,

jz +0f

Call @AfterConStruction

pop Dword ptr Fs:[$00000000]

Add Esp ,$0c

}

一个类实例的生成需要经过对象内存分配、内存初始化、设置对象执行框架三个步骤。

编译器首先调用 System._ClassCreate 进行对象内存分配、内存初始化的工作。而 System._ClassCreate 调用 TObject 类的虚方法 NewInstance 建立对象的实例空间，继承类通常不需要重载 TObject.NewInstance，除非你使用自己的内存管理器，因此缺省是调用 TObject.NewInstance。TObject.NewInstance 方法将根据编译器在类信息数据中初始化的对象实例尺寸（TObject.InstanceSize），调用系统缺省的 MemoryManager.GetMem 过程为该对象在堆（Heap）中分配内存，然后调用 TObject.InitInstance 方法将分配的空间初始化。InitInstance 方法首先将对象空间的头4个字节初始化为指向对象类的 VMT 的指针，然后将其余的空间清零。如果类中还设计了接口，它还要初始化接口表格（Interface Table）。

当对象实例在内存中分配且初始化后，开始设置执行框架。所谓设置执行框架就是执行你在 Create 方法里真正写的代码。设置执行框架的规矩是先设置基类的框架，然后再设置继承类的，通常用 Inherited 关键字来实现。

上述工作都做完后，编译器还要调用 System._AfterConstruction 让你有最后一次机会进行一些事务的处理工作。System._AfterConstruction 是调用虚方法 AfterConstruction 实现的。在 TObject 中 AfterConstruction 中只是个 Place Holder，你很少需要重载这个方法，重载这个方法通常只是为了与 C++ Builder 对象模型兼容。

最后，编译器返回对象实例数据的地址指针。

对象释放服务其实就是对象创建服务的逆过程，可以认为对象释放服务就是回收对象在创建过程中分配的资源。

当编译器遇到 destructor 关键字通常会这样编码：首先调用 System._BeforeDestruction，而 System._BeforeDestruction 继而调用虚方法 BeforeDestruction，在 TObject 中 BeforeDestruction 中只是个 Place Holder，你很少需要重载这个方法，重载这个方法通常只是为了与 C++ Builder 对象模型兼容。

这之后，编译器调用你在 Destroy 中真正写的代码，如果当前你在撰写的类是继承链上的一员，不要忘记通过 inherited 调用父类的析构函数以释放父类分配的资源，但规矩是，先释放当前类的资源，然后再调用父类的，这和对象创建服务中设置对象执行框架的顺序恰好相反。

当前类及继承链中所有类中分配的资源全部释放后，最后执行的就是释放掉对象本身及一些特别数据类型占用的内存空间。编译器调用 System._ClassDestroy 来完成这件工作。System._ClassDestroy 继而调用虚方法 FreeInstance，继承类通常不需要重载 TObject.FreeInstance，除非你使用自己的内存管理器，因此缺省是调用 TObject.FreeInstance。TObject.FreeInstance 继而调用 TObject.CleanupInstance 完成对于字符串数组、宽字符串数组、Variant、未定义类型数组、记录、接口和动态数组这些特别数据类型占用资源的释放[4]，最后 TObject.FreeInstance 调用 MemoryManager.FreeMem 释放对象本身占用的内存空间。

很有意思的是，对象释放服务与对象创建服务所用方法、函数是一一对应的，是不是有一种很整齐的感觉？

对象创建服务

对象释放服务

System._ClassCreate

System._ClassDestroy

System._AfterConstruction

System._BeforeDestruction

TObject.AfterConstruction(virtual)

TObject.BeforeDestruction(virtual)

TObject.NewInstance(virtual)

TObject.FreeInstance(virtual)

TObject.InitInstance