Versions Nummer parsen

[EWeiss]

Wieder ICH ;)

In Delphi gebe ich die Version Nummer auf diese weise zurück

Delphi-Quellcode:

const
  // constant for DLL Version number
   Ver_Major_Hi: byte = 0;
   Ver_Major_Lo: byte = 2;
   Ver_Minor_Hi: byte = 1;
   Ver_Minor_Lo: byte = 0;

Delphi-Quellcode:

function KVideo_GetVersion: longint; stdcall;
begin
   result := Ver_Major_Hi * $1000000 + Ver_Major_Lo * $10000 + Ver_Minor_Hi * $100 + Ver_Minor_Lo;
end;

Wie kann ich jetzt in C++ den LONG wert wieder zurück in einem WCHAR bringen ? (1.0.0.0 als Beispiel)

Code:

LONG KVIDEOPLAYERDEF(KVideo_GetVersion)();

gruss

[Zacherl]

Ich würde dir hier empfehlen schon in deiner DLL auf die arithmetischen Operationen zu verzichten und deine Versionsnummer stattdessen so zusammenzusetzen (davon ausgehend, dass die einzelnen Nummern jeweils Bytes - genauer gesagt unsigned 8-bit ints sind):

Delphi-Quellcode:

Result := (Ver_Major_Hi shl 24) or (Ver_Major_Lo shl 16) or (Ver_Minor_Hi shl 8) or Ver_Minor_Lo;

Dann kannst du die Rückrechnung nämlich einfach analog mit right-shifts vornehmen:

Delphi-Quellcode:

Ver_Major_Hi := (Version shr 24) and $FF;
Ver_Major_Lo := (Version shr 16) and $FF;
Ver_Minor_Hi := (Version shr 8) and $FF;
Ver_Minor_Lo := Version and $FF;

oder in C:

Delphi-Quellcode:

Ver_Major_Hi = (Version >> 24) & 0xFF;
Ver_Major_Lo = (Version >> 16) & 0xFF;
Ver_Minor_Hi = (Version >> 8) & 0xFF;
Ver_Minor_Lo = Version & 0xFF;

Deine jetzige Version macht - vor allem mit der hexadezimalen Multiplikation - nicht allzu viel Sinn. Wenn du die Faktoren in Dezimalform bringst, würde es funktionieren. Dann müsstest du allerdings mit

Delphi-Quellcode:

div

und

Delphi-Quellcode:

mod

zurückrechnen, was ich persönlich weniger elegant finde.

[EWeiss]

Zitat:

Ich würde dir hier empfehlen schon in deiner DLL auf die arithmetischen Operationen zu verzichten

Ich denke wohl das ist der einfachste weg.

Werde es ändern Danke dir.

EDIT:
So geht's

Code:

LONG KVideoPlayerVersion = KVideo_GetVersion();
WCHAR Version[MAX_PATH] = { 0 };
_snwprintf_s(Version, MAX_PATH, 259, L"%i.%i.%i.%i", (KVideoPlayerVersion >> 24) & 0xFF, (KVideoPlayerVersion >> 16) & 0xFF, (KVideoPlayerVersion >> 8) & 0xFF, KVideoPlayerVersion & 0xFF);

gruss

[Namenloser]

Nur der Klugscheißerei wegen ;)

Das hier:

Delphi-Quellcode:

function KVideo_GetVersion: longint; stdcall;
begin
  result := Ver_Major_Hi * $1000000 + Ver_Major_Lo * $10000 + Ver_Minor_Hi * $100 + Ver_Minor_Lo;
end;

Lässt sich wie folgt umkehren:

Delphi-Quellcode:

procedure ParseVersion(const Version: LongInt; out Major_Hi: Integer; out Major_Lo: Integer; out Minor_Hi: Integer; out Minor_Lo: Integer);
begin
  Minor_Lo := Version mod $100;
  Minor_Hi := (Version mod $10000) div $100;
  Major_Lo := (Version mod $1000000) div $10000;
  Major_Hi := Version div $1000000;
end;

[EWeiss]

Jo ;) div 4
Ist aber nicht der normale Standard.

Denke die meisten arbeiten mit Shl.. von daher war das schnell geändert.

gruss

[generic]

Warum die ganzen mathematischen Funktionen, wenn man ein Record nehmen kann, welcher zwei Entsprechungen hat (Long und die vier Bytes)?

Code:

const
  // constant for DLL Version number
   Ver_Major_Hi: byte = 1;
   Ver_Major_Lo: byte = 2;
   Ver_Minor_Hi: byte = 3;
   Ver_Minor_Lo: byte = 4;

type
  RVersion = record
    case boolean of
      true: (Version: LONG);
      false: (Ver_Minor_Lo: byte;
       Ver_Minor_Hi: byte;
       Ver_Major_Lo: byte;
       Ver_Major_Hi: byte)
  end;


procedure TForm2.FormCreate(Sender: TObject);
var
  x: RVersion;
begin
  x.Ver_Major_Hi:=Ver_Major_Hi;
  x.Ver_Major_Lo:=Ver_Major_Lo;
  x.Ver_Minor_Hi:=Ver_Minor_Hi;
  x.Ver_Minor_Lo:=Ver_Minor_Lo;

  Caption:=IntToHex(x.Version, 8);
end;

[EWeiss]

Zitat:

Zitat von generic (Beitrag 1378307)

Warum die ganzen mathematischen Funktionen, wenn man ein Record nehmen kann, welcher zwei Entsprechungen hat (Long und die vier Bytes)?

Gute frage vielleicht deshalb weil ich die Versionsabfrage in C++ oder anderer Sprache tätigen will.
Und deshalb extra einen Record?

gruss

[himitsu]

Zitat:

Zitat von generic (Beitrag 1378307)

Warum die ganzen mathematischen Funktionen, wenn man ein Record nehmen kann, welcher zwei Entsprechungen hat (Long und die vier Bytes)?

Weil das zu einfach wäre?

In Anlenung an die bekannte Versions-Ressource des Windows, könnte man sich auch überlegen das mit 2x DWORD aka UInt64 / 4x WORD umzusetzen, also mit Word statt Byte pro Nummer.

Zitat:

Delphi-Quellcode:

tagVS_FIXEDFILEINFO = packed record
  dwSignature: DWORD;        { e.g. $feef04bd }
  dwStrucVersion: DWORD;     { e.g. $00000042 = "0.42" }
  dwFileVersionMS: DWORD;    { e.g. $00030075 = "3.75" }
  dwFileVersionLS: DWORD;    { e.g. $00000031 = "0.31" }
  dwProductVersionMS: DWORD; { e.g. $00030010 = "3.10" }
  dwProductVersionLS: DWORD; { e.g. $00000031 = "0.31" }
  dwFileFlagsMask: DWORD;    { = $3F for version "0.42" }
  dwFileFlags: DWORD;        { e.g. VFF_DEBUG | VFF_PRERELEASE }
  dwFileOS: DWORD;           { e.g. VOS_DOS_WINDOWS16 }
  dwFileType: DWORD;         { e.g. VFT_DRIVER }
  dwFileSubtype: DWORD;      { e.g. VFT2_DRV_KEYBOARD }
  dwFileDateMS: DWORD;       { e.g. 0 }
  dwFileDateLS: DWORD;       { e.g. 0 }
end;

[EWeiss]

Ach.. Ich kann mein Brot auch mit einem Löffel streichen letztendlich zählt nur das die Butter auf dem Brot ist.
Man kann das ganze auch bis zum exzess treiben.

gruss

[bra]

Man kann auch einfach eine fortlaufende Nummer als Version verwenden, dann braucht man nur ein Integer :stupid: