Delphi *.res Dateien automatisch generieren

[hewy]

Irgendwie schnalle ich da was nicht.

In einem Programmgenerator sollte ich hunderte Delphi Projektdateien inklusive *.res Dateien erstellen. Dies funktioniert auch alles sauber bis auf die *.res Dateien.

Hab mir ‚Resource File Unit‘ dd-resfile-1.0.1.zip auf delphidabbler.com geholt. Laut Beschreibung sollte mein Vorhaben damit realisierbar sein.

Wie bereits gesagt komme ich jedoch mit dem Modul nicht zurecht. Sicher kennt der eine oder andere dieses Modul oder etwas Ähnliches und kann mir ein Beispiel geben wie ich ein vollständiges Delphi *.res File generiere.

Ich könnte brcc32.exe verwenden,ist jedoch in meinem Fall nicht zulässig.
Der Generator muss ohne externe Applikationen auskommen.

Schon mal im Voraus danke für jeden brauchbaren Hinweis.

[CCRDude]

Die ResourceUtils verwende ich seit Jahren erfolgreich. Muss man sich nur mal die Klassenhierarchie genau anschauen, um das ordentlich zu verstehen.

Allerdings: mir kanns ja Recht sein, wenn jede einzelne der hunderte von Varianten Deiner Malware ( :D ) einzeln kompiliert wird, aber wäre es nicht einfacher und schneller, die Resourcen in der Kopie eines Kompilats anzupassen?

[hewy]

Danke für die Info.
Meine Absicht die *.res files zu erzeugen kommt nicht von ungefähr.
Sicherlich wäre es einfacher dem fertigen Kompilat kurzum noch die Versionsinfos beizufügen. Allerdings in meinem Fall sollte beim nachträglichen Kompilieren in der DIE dieselben Infos zur Anwendung kommen wie auch bei den automatisch mit dem ‚command line‘ Compiler erstellten Kompilate. Der genannte Programmgenerator ist voll funktionstüchtig, nur die Versionsgeschichte macht immer wieder Schwierigkeiten.
Ich kann auch ein tempalte.res verwenden in dem ich die Versions und Herkunft Infos verändere. Und genau hier liegt der Punkt an dem ich nicht weiter komme.
ResEntry := TPJResourceEntry(aResourceFile.Entries[i]);
ResEntry.data ….
in diesem Stream befinden sich die Informationen welche ich verändern sollte, nur wie wird das gemacht?

[wicht]

Der "XN Resource Editor", der ja scheinbar die selben Komponenten nutzt, kann die Versionsinfos ändern, zumindest aber auslesen und schön darstellen. Da müsste man sich das doch abgucken können.

[hewy]

Danke für den Hint.
Genau da sollte man abgucken können.
Da ist ja auch die Source dabei. Allerdings werden einige Component Packages verwendet dass das Kompilieren nicht so leicht machbar ist.
Leider hab ich bisher keine Liste der dazu notwendigen Packages gefunden.
Daher wollte ich mir genau diesen Aufwand ersparen.

[Luckie]

Wozu musst du den Code compilieren können? Du brauchst dir doch nur abgucken, wie es da gemacht wird.

[hewy]

Vor allem das ‚doch nur abgucken‘ ist für mich anscheinend nicht so einfach wie für andere, daher wäre es etwas einfacher wenn ich den Ablauf im Debugger verfolgen könnte.
Vielleicht gibt es ja jemand der da nur schnell für mich abgucken kann, ich Steig da zu wenig durch.

[hewy]

Bin immer noch an meinem Versionsproblem. Der empfohlene XN ResourceEditor macht irgendwie nicht das wo erwartet.
Setze ich File Version und Product Version im XN ResourceEditor und prüfen dann im Windowsexplorer unter Properties, enthält File Version den Wert den ich in Product Version eingegeben habe und Product Version ist leer.
Hat vieleicht jemand eine Erklärung dazu?

[hewy]

Da offenbar kaum jemand Bescheid weiss wie die ResourceUtils von Clin Wilson eingesetzt werden können um Delphi resource Dateien zu bearbeiten, blieb mir nichts anderes übrig als dies selber zu erstellen. Hier den Relevanten Auszug aus meinem Ergebnis.

type
TVersionNumber = record
Major: Integer;
Minor: Integer;
Release: Integer;
Build: Integer;

procedure FromULargeInteger(aULargeInteger: TULargeInteger);
function AsULargeInteger: TULargeInteger;
end;

TSetVersion = class
private
{ Private declarations }
fResFile: string;

fOnMessageLog: TEventLog;
fOnErrorLog: TEventLog;
fOnHintLog: TEventLog;

fFileVerMajor: integer;
fFileVerMinor: integer;
fFileVerRelease: integer;
fFileVerBuild: integer;
fProductVerMajor: integer;
fProductVerMinor: integer;
fProductVerRelease: integer;
fProductVerBuild: integer;

fCompanyName: string;
fFileDescription: string;
fFileVersion: string;
fInternalName: string;
fLegalCopyright: string;
fLegalTrademarks: string;
fOriginalFilename: string;
fProductName: string;
fProductVersion: string;
fComments: string;

function VersionToString(version: TULargeInteger): string;
function StringToVersion(const version: string): TULargeInteger;
procedure logMessage(sMessage: string);
procedure logError(sMessage: string);
procedure logHint(sMessage: string);
public
{ Public declarations }

property FileVerMajor: integer read fFileVerMajor write fFileVerMajor;
property FileVerMinor: integer read fFileVerMinor write fFileVerMinor;
property FileVerRelease: integer read fFileVerRelease write fFileVerRelease;
property FileVerBuild: integer read fFileVerBuild write fFileVerBuild;
property ProductVerMajor: integer read fProductVerMajor write fProductVerMajor;
property ProductVerMinor: integer read fProductVerMinor write fProductVerMinor;
property ProductVerRelease: integer read fProductVerRelease write fProductVerRelease;
property ProductVerBuild: integer read fProductVerBuild write fProductVerBuild;

property CompanyName: string read fCompanyName write fCompanyName;
property FileDescription: string read fFileDescription write fFileDescription;
property FileVersion: string read fFileVersion write fFileVersion;
property InternalName: string read fInternalName write fInternalName;
property LegalCopyright: string read fLegalCopyright write fLegalCopyright;
property LegalTrademarks: string read fLegalTrademarks write fLegalTrademarks;
property OriginalFilename: string read fOriginalFilename write fOriginalFilename;
property ProductName: string read fProductName write fProductName;
property ProductVersion: string read fProductVersion write fProductVersion;
property Comments: string read fComments write fComments;

property OnMessageLog: TEventLog read fOnMessageLog write fOnMessageLog;
property OnHintLog: TEventLog read fOnHintLog write fOnHintLog;
property OnErrorLog: TEventLog read fOnErrorLog write fOnErrorLog;

function UpdateResVersion(aResFile: string): boolean;
end;

implementation

uses StrUtils, uMisc,
unitPEFile, unitResFile, unitNTModule, unitResourceDetails, unitResourceVersionInfo;

function TSetVersion.UpdateResVersion(aResFile: string): boolean;
var
i: Integer;
ResModule: TResModule;
VersionInfoResourceDetails: TVersionInfoResourceDetails;
VersionNumber: TVersionNumber;

function GetVersionInfoResourceDetails(aResModule: TResModule): TVersionInfoResourceDetails;
var
i: Integer;
begin
Result := nil;

for i := 0 to aResModule.ResourceCount - 1 do
begin
aResModule.ResourceDetails[i];
if aResModule.ResourceDetails[i] is TVersionInfoResourceDetails then
begin
Result := (aResModule.ResourceDetails[i]) as TVersionInfoResourceDetails;
Break; // I believe there should only ever be one Version resource.
end;
end;
end;

begin
result := true;
ResModule := TResModule.Create;
try
ResModule.LoadFromFile(aResFile);

VersionInfoResourceDetails := GetVersionInfoResourceDetails(ResModule);

if not Assigned(VersionInfoResourceDetails) then
begin
raise Exception.CreateFmt('No VersionInfo found in %s', [aResFile]);
end
else
begin

// logMessage('------------------------------------------ ');
// for I := 0 to VersionInfoResourceDetails.KeyCount - 1 do
// begin
// logHint(VersionInfoResourceDetails.Key[i].KeyName + ': ' + VersionInfoResourceDetails.Key[i].Value);
// end;
// logHint(format('Set Version File <%s>',[aResFile]));
VersionInfoResourceDetails.SetKeyValue('CompanyNam e', fCompanyName);
VersionInfoResourceDetails.SetKeyValue('FileDescri ption', fFileDescription);
VersionInfoResourceDetails.SetKeyValue('FileVersio n', fFileVersion);
VersionInfoResourceDetails.SetKeyValue('InternalNa me', fInternalName);
VersionInfoResourceDetails.SetKeyValue('LegalCopyr ight', fLegalCopyright);
VersionInfoResourceDetails.SetKeyValue('LegalTrade marks', fLegalTrademarks);
VersionInfoResourceDetails.SetKeyValue('OriginalFi lename', fOriginalFilename);
VersionInfoResourceDetails.SetKeyValue('ProductNam e', fProductName);
VersionInfoResourceDetails.SetKeyValue('ProductVer sion', fProductVersion);
VersionInfoResourceDetails.SetKeyValue('Comments', fComments);

VersionNumber.FromULargeInteger(VersionInfoResourc eDetails.FileVersion);
VersionNumber.Major := fProductVerMajor;
VersionNumber.Minor := fProductVerMinor;
VersionNumber.Release := fProductVerRelease;
VersionNumber.Build := fProductVerBuild;
VersionInfoResourceDetails.ProductVersion := VersionNumber.AsULargeInteger;

VersionNumber.FromULargeInteger(VersionInfoResourc eDetails.FileVersion);
VersionNumber.Major := fFileVerMajor;
VersionNumber.Minor := fFileVerMinor;
VersionNumber.Release := fFileVerRelease;
VersionNumber.Build := fFileVerBuild;
VersionInfoResourceDetails.FileVersion := VersionNumber.AsULargeInteger;

// commenting this out will copy existing RES files to [resfile].~res backup files
DeleteFile(PChar(aResFile));
ResModule.SaveToFile(aResFile);

// logMessage('------------------------------------------');
// logMessage(' ');
// for I := 0 to VersionInfoResourceDetails.KeyCount - 1 do
// begin
// if length(VersionInfoResourceDetails.Key[i].Value) > 0 then
// logHint(VersionInfoResourceDetails.Key[i].KeyName + ': ' + VersionInfoResourceDetails.Key[i].Value);
// end;
end;
finally
// ResModule.Free;
FreeAndNil(ResModule);
end;
end;

{ TVersionNumber }

function TVersionNumber.AsULargeInteger: TULargeInteger;
begin
Result.HighPart := Major shl 16 or Minor;
Result.LowPart := Release shl 16 or Build
end;

procedure TVersionNumber.FromULargeInteger(aULargeInteger: TULargeInteger);
begin
Major := aULargeInteger.HighPart shr 16;
Minor := aULargeInteger.HighPart and ((1 shl 16) - 1);
Release := aULargeInteger.LowPart shr 16;
Build := aULargeInteger.LowPart and ((1 shl 16) - 1);
end;

Softconsult GmbH Widen Schweiz.

[blondervolker]

Hallo und Guten Tag,

Kauf Dir was richtiges siehe Anhang.:thumb:

Da hast Du keine Sorgen...:-D:-D:-D

Das Teil ist auch noch in DEUTSCH.

Hier der Link:

http://www.resource-builder.de/?site...itorid2=746084

[CCRDude]

Zitat:

Zitat von hewy (Beitrag 1150980)

Da offenbar kaum jemand Bescheid weiss wie die ResourceUtils von Clin Wilson eingesetzt werden können um Delphi resource Dateien zu bearbeiten

Bescheid wissen schon (siehe oben, aber - da Du auf den Wink mit dem Stichwort "Spyware" nicht eingegangen bist - nicht gewollt. Sorry falls ich Dir damit unrecht getan haben sollte. Mir fällt nur außer Malware gerade einfach kein Nutzen für das von Dir beschriebene ein ;)

[David Martens]

@hewy: Kannst du den Code mal bitte vollständig posten und als Delphi-Code markieren. Man kann das so überhaupt nicht verwenden.

Es fehlt z.B.: TEventLog, ...

Aber viel schlimmer das UpdateResVersion zerstört die Datei.