Pastebin: DFM Decoder!

Format

Delphi

Post date

2021-04-09 04:02

Publication Period

Unlimited

 procedure ReadTextDFM(ADFMFile: TFileName; List: TStrings);
 var
   FileStream: TFileStream;
   BinaryStream: TMemoryStream;
   AuxShortString: ShortString;
   AuxUTF8String: UTF8String;
   AuxInt8: Int8;
   AuxInt16: Int16;
   AuxInt32: Int32;
   AuxInt64: Int64;
   PropertyName: ShortString;
   PropertyValue: String;
   Buffer: PByte;
 begin
   List.Clear;
   FileStream := TFileStream.Create(ADFMFile, fmOpenRead);
   try
     BinaryStream := TMemoryStream.Create;
     try
       FileStream.Seek(0, sofrombeginning);
       ObjectTextToBinary(FileStream, BinaryStream);
       BinaryStream.Seek(0,soFromBeginning);
 
       // Signature (ShortString)
       // Numa ShortString o elemento zero é o tamanho da string e o elemento 1 é
       // o início da string propriamente dita! Eu sei que a string de assinatura
       // tem 4 bytes, logo, pra começar eu configuro o tamanho corretamente da
       // string em seguida eu copio os 4 bytes a partir do elemento 1 da string,
       // dessa forma eu terei uma ShortString bem formada que contém a
       // assinatura do arquivo (magic number)
       AuxShortString[0] := AnsiChar(4);
       BinaryStream.Read(AuxShortString[1],4);
       List.Add('Signature = ' + AuxShortString);
 
       // FormClassName (ShortString)
       // Primeiro obtém o tamanho, depos usa esse tamanho para obter o valor do
       // nome da classe do form
       BinaryStream.Read(AuxInt8,1);
       AuxShortString[0] := AnsiChar(AuxInt8);
       BinaryStream.Read(AuxShortString[1],AuxInt8);
       List.Add('Form Class Name = ' + AuxShortString);
 
       // FormName (ShortString)
       BinaryStream.Read(AuxInt8,1);
       AuxShortString[0] := AnsiChar(AuxInt8);
       BinaryStream.Read(AuxShortString[1],AuxInt8);
       List.Add('Form Name = ' + AuxShortString);
 
       // A partir desse ponto é a parte que varia de acordo com qual componente
       // está sendo lido do dfm.
       while BinaryStream.Position < BinaryStream.Size do
       begin
         // Cada loop vai ser responsável por ler uma propriedade, então no
         // inicio do loop eu sempre estarei lendo o tamanho do nome da
         // propriedade. Quando o byte lido aqui é zero, significa que um
         // componente vai começar, um componente colocado no form. Neste momento
         // a função atual tem que ser chamada desde o começo, porém a partir do
         // ponto onde estamos em BinaryStream. Não vou implementar isso... Se
         // vira! (Envolve recursividade)
 
         // NomeDaPropriedade
         BinaryStream.Read(AuxInt8,1);
 
         if AuxInt8 = 0 then
           Break;
 
         PropertyName[0] := AnsiChar(AuxInt8);
         BinaryStream.Read(PropertyName[1],AuxInt8);
 
         // Tipo da propriedade
         BinaryStream.Read(AuxInt8,1);
 
         case TValueType(AuxInt8) of
           vaInt8: begin // Lê 1 Byte
             BinaryStream.Read(AuxInt8,1);
             PropertyValue := AuxInt8.ToString;
           end;
           vaInt16: begin // Lê 2 Bytes
             BinaryStream.Read(AuxInt16,2);
             PropertyValue := AuxInt16.ToString;
           end;
           vaInt32: begin // Lê 4 Bytes
             BinaryStream.Read(AuxInt32,4);
             PropertyValue := AuxInt32.ToString;
           end;
           vaInt64: begin // Lê 8 Bytes
             BinaryStream.Read(AuxInt64,8);
             PropertyValue := AuxInt64.ToString;
           end;
           vaUTF8String: begin // String UTF8 (Esta algoritmo não está bom)
             BinaryStream.Read(AuxInt32,4);
             // Variáveis declaradas que não são ponteiros ou objetos são
             // inicializadas automaticamente pelo Delphi. Variáveis String, e
             // isso inclui UTF8String, são ponteiros que apontam para o local
             // real onde a string está. O tamanho da string está nos 4 bytes
             // anteriores ao endereço de onde está a string propriamente dita,
             // mais ou menos assim:
             // XX XX XX XX YY YY YY YY YY YY
             // Onde XX são os bytes que represetam o tamanho da string e YY são
             // os bytes da string propriamente dita. O valor de uma variável
             // string é um ponteiro que aponta para o primeiro Byte da string
             // (Primeiro YY no exemplo). Ao declarar uma variável string, a sua
             // memória já estará alocada, mas a memória da string propriamente
             // dita, não! Antes da primeira atribuição a string, ela aponta para
             // "nil" e é por isso que não podemos acessar o endereço da string
             // propriamente dita, porque ele contém nil. Ao fazer a primeira
             // atribuição a string é inicializada e passa a apontar para um
             // endereço válido, aliás, toda vez que se atribui um novo valor a
             // uma string, ela passa a apontar para outro local da memória,
             // sempre ocupando o tamanho da string em Bytes + 4 Bytes de tamanho
             // no offset negativo. O gerenciamento da memória das strings é
             // feito automaticamente pelo Delphi. Como abaixo eu quero acessar
             // os dados da string diretamente, eu preciso inicializar a string
             // com a quantidade de Bytes, para (re)inicializar a string de forma
             // que ela aponte para um endereço válido. O SetString em combinação
             // com DupeString resolvem esse problema! Após a linha a seguir
             // teremos um endereço válido de memória que poderá ser preenchido
             // diretamente
             SetString(AuxUTF8String,PChar(DupeString(#0,AuxInt32)),AuxInt32);
 
             BinaryStream.Read(Pointer(AuxUTF8String)^,AuxInt32);
             // Isso já resolve a conversão entre UTF-8 e Unicode automaticamente
             PropertyValue := String(AuxUTF8String);
           end;
           vaIdent, vaString: begin // Membro de uma enumeração ou ShortString (é shortstring mesmo)
             BinaryStream.Read(AuxInt8,1);
 
             AuxShortString[0] := AnsiChar(AuxInt8);
             BinaryStream.Read(AuxShortString[1],AuxInt8);
 
             PropertyValue := String(AuxShortString);
           end;
           vaExtended: begin
               // Não implementei
           end;
           vaBinary: begin
              // Não implementei
           end;
           vaSet: begin
             BinaryStream.Read(AuxInt8,1);
 
             if AuxInt8 > 0 then
             begin
               // Não implementei
             end
             else
               PropertyValue := '[]';
           end;
           vaFalse: begin
             // Não precisa ler nada, pois o valor é o tipo, no caso False
             PropertyValue := 'False';
           end;
           vaTrue: begin
             // Não precisa ler nada, pois o valor é o tipo, no caso True
             PropertyValue := 'True';
           end;
         end;
 
         List.Add(PropertyName + ' = ' + PropertyValue);
       end;
     finally
       BinaryStream.Free;
     end;
 
   finally
     FileStream.Free;
   end;
 end;