C++ nach Delphi übersetzen

[SnuffMaster23]

Hi,
ich brauche jemanden der mir ein wenig Code nach Delphi übersetzt, und zwar das BB-SDK.
Ist nicht viel, aber ich bin leider nur des QuickBASIC :D und Delphi mächtig.

MfG,
SnuffMaster23

[morp2]

Ach sind ja nur 1600 Zeilen. Mach ich gerne.

[Corpsman]

ich habe auch schon von c nach Pascal übersetzt ist gar net so arg schwer. Zumindest meistens.

Schau einfach mal HEX von meiner HP an. da ist der Delphi wie der Code dabei.

[SirThornberry]

es wäre das sinnvollste zu versuchen das selbst zu wandeln. Wenn es nur ein sdk ist handelt es sich ja im einfache Datentypen und strukturen. Ansonsten musst du immer wieder wenn dir c-code in die Finger fällt Hilfe aufsuchen. Und spätestens bei Benutzung des MSDN brauchst du die Kenntnisse.

[SnuffMaster23]

1600 Zeilen :shock:
da hab ich wohl was übersehen

Ok, ihr habt mich überzeugt, ich übersetz es selber, aber ein paar Basics wären nicht schlecht.
Beim MSDN bin ich immer am rumraten, auf Dauer ist das auch nichts ;)

Was muss ich da denn genau übersetzen, für was sind z.B. die .def-files?
Reichen die .cpp und .h-files?

//Edit:
Was fang ich denn damit an? Brauch ich das überhaupt alles?
Ich nehm mal an den ersten Teil kann ich weglassen.
Welchen Units entsprechen windows.h (windows.pas?) und stdio.h?

Code:

//------------------------------------------
// Compiler specifics
//------------------------------------------

#ifdef __GNUC__
  #define _WIN32_IE 0x0500
  #ifndef __BBCORE__
   #define GetBlackboxPath _GetBlackboxPath
  #endif
#endif

#ifdef __BORLANDC__
  #define DLL_EXPORT
#endif

#ifndef DLL_EXPORT
  #define DLL_EXPORT __declspec(dllexport)
#endif

//------------------------------------------
// windows include:
//------------------------------------------

#define WIN32_LEAN_AND_MEAN
#define WINVER 0x0500

#include <windows.h>
#include <stdio.h>

[angos]

Zitat:

Zitat von SnuffMaster23

1600 Zeilen :shock:
da hab ich wohl was übersehen

Ok, ihr habt mich überzeugt, ich übersetz es selber, aber ein paar Basics wären nicht schlecht.
Beim MSDN bin ich immer am rumraten, auf Dauer ist das auch nichts ;)

Was muss ich da denn genau übersetzen, für was sind z.B. die .def-files?
Reichen die .cpp und .h-files?

//Edit:
Was fang ich denn damit an? Brauch ich das überhaupt alles?
Ich nehm mal an den ersten Teil kann ich weglassen.
Welchen Units entsprechen windows.h (windows.pas?) und stdio.h?

Code:

//------------------------------------------
// Compiler specifics
//------------------------------------------

#ifdef __GNUC__
  #define _WIN32_IE 0x0500
  #ifndef __BBCORE__
   #define GetBlackboxPath _GetBlackboxPath
  #endif
#endif

#ifdef __BORLANDC__
  #define DLL_EXPORT
#endif

#ifndef DLL_EXPORT
  #define DLL_EXPORT __declspec(dllexport)
#endif

//------------------------------------------
// windows include:
//------------------------------------------

#define WIN32_LEAN_AND_MEAN
#define WINVER 0x0500

#include <windows.h>
#include <stdio.h>

Also der erste Bereich sind scheinbar Compilerschalter, da musste mal schauen, ob du was in Delphi brauchst (AM Anfang eher nicht)

das zweite sind die genutzten Units. Da das C-Standardunits sind, werden die sich in Delphi definitiv ändern ;)

[SnuffMaster23]

Tja, so weit war auch auch schon...

Und ich hab schon den nächsten Stolperstein:

Code:

   // BB_REDRAWGUI wParam bitflags:
     BBRG_TOOLBAR (1<<0)
     BBRG_MENU    (1<<1)
     BBRG_WINDOW  (1<<2)
     BBRG_DESK    (1<<3)
     BBRG_FOCUS   (1<<4)
     BBRG_PRESSED (1<<5)
     BBRG_STICKY  (1<<6)
     BBRG_FOLDER  (1<<7)

Da es um Flags geht nehm ich mal an dass << ein bitweiser Operator ist. Ist das in Delphi vielleicht shl?


//Edit:

Code:

typedef struct StyleItem
{
   int bevelstyle;
   int bevelposition;
.
.
.
   COLORREF bulletColor;
   //bool FontShadow; xoblite extension
} StyleItem;

Das gibt einen record-Typ denk ich, hat das eine Bedeutung dass da zweimal StyleItem steht?

Code:

char Font[256-20];        //steht innerhalb der typedef von oben
---------------

#define PicColor TextColor

class Menu;
class MenuItem;

Damit kann ich nichts anfangen...

[ste_ett]

Delphi-Quellcode:

const
  BBRG_TOOLBAR = (1 shl 0);
  BBRG_MENU    = (1 shl 1);
  BBRG_WINDOW  = (1 shl 2);
  BBRG_DESK    = (1 shl 3);
  BBRG_FOCUS   = (1 shl 4);
  BBRG_PRESSED = (1 shl 5);
  BBRG_STICKY  = (1 shl 6);
  BBRG_FOLDER  = (1 shl 7);

"shl" ist korrekt. :)

Das mit dem Namen ist korrekt so, der Name, der unten steht wird nach aussen bekannt gemacht.
Für Delphi ist das irrelevant. :)

Delphi-Quellcode:

TStyleItem = packed record
  bevelstyle,
  bevelposition: Integer;
.
.
.
   bulletColor: COLORREF;
end;

Array werden in C/C++ folgendermassen deklariert:
Typ Name[Anzahl]; // Index von 0 bis Anzahl-1

Delphi-Quellcode:

var
  Font: array[0..235] of Char; // 0..255-20

[SnuffMaster23]

Code:

//===========================================================================
// constants for GetSettingPtr(int index) -> returns:
enum {
   SN_STYLESTRUCT      = 0   , // StyleStruct *
   SN_TOOLBAR          = 1   , // StyleItem *
   SN_TOOLBARBUTTON          , // StyleItem *
.
.
.
   SN_MENUFRAME_DISABLECOLOR , // COLORREF *
   SN_LAST
};

Was ist das?

Und das nochmal, damits nicht untergeht:

Code:

#define PicColor TextColor

class Menu;
class MenuItem;

Mit denen kann ich auch nichts anfangen.
Wird da PicColor der Wert von TextColor zugewiesen?
Werden da zwei Konstanten definiert?
TextColor gibts garnicht, außer als Element von StyleItem :?

Leere Klassendefinitionen??

[ste_ett]

Das Enum ist nur dazu da, den Variablen einen Wert zu geben.
In Delphi kann man diesen Fall über "const" oder "type" regeln.
Wahlweise kann man auch jede Variable einzeln als Integer und Konstante deklarieren.

Delphi-Quellcode:

{$MINENUMSIZE 4} // WICHTIG, wenn man Enumerationen aus der "C/C++"-Welt übernimmt!
type
  TEnum = ( // In Delphi muss ein Name vergeben werden, der hier allerdings bedeutungslos ist.
    SN_STYLESTRUCT      = 0   , // StyleStruct *

    SN_TOOLBAR          = 1   , // StyleItem *
    SN_TOOLBARBUTTON          , // StyleItem *
    SN_TOOLBARBUTTONP         , // StyleItem *
    SN_TOOLBARLABEL           , // StyleItem *
    SN_TOOLBARWINDOWLABEL     , // StyleItem *
    SN_TOOLBARCLOCK           , // StyleItem *
    SN_MENUTITLE              , // StyleItem *
    SN_MENUFRAME              , // StyleItem *
    SN_MENUHILITE             , // StyleItem *

    SN_MENUBULLET             , // char *
    SN_MENUBULLETPOS          , // char *

    SN_BORDERWIDTH            , // int *
    SN_BORDERCOLOR            , // COLORREF *
    SN_BEVELWIDTH             , // int *
    SN_FRAMEWIDTH             , // int *
    SN_HANDLEWIDTH            , // int *
    SN_ROOTCOMMAND            , // char *

    SN_MENUALPHA              , // int *
    SN_TOOLBARALPHA           , // int *
    SN_METRICSUNIX            , // bool *
    SN_BULLETUNIX             , // bool *

    SN_WINFOCUS_TITLE         , // StyleItem *
    SN_WINFOCUS_LABEL         , // StyleItem *
    SN_WINFOCUS_HANDLE        , // StyleItem *
    SN_WINFOCUS_GRIP          , // StyleItem *
    SN_WINFOCUS_BUTTON        , // StyleItem *
    SN_WINFOCUS_BUTTONP       , // StyleItem *

    SN_WINUNFOCUS_TITLE       , // StyleItem *
    SN_WINUNFOCUS_LABEL       , // StyleItem *
    SN_WINUNFOCUS_HANDLE      , // StyleItem *
    SN_WINUNFOCUS_GRIP        , // StyleItem *
    SN_WINUNFOCUS_BUTTON      , // StyleItem *

    SN_WINFOCUS_FRAME_COLOR   , // COLORREF *
    SN_WINUNFOCUS_FRAME_COLOR , // COLORREF *
    SN_MENUFRAME_DISABLECOLOR , // COLORREF *
    SN_LAST
  );

Das "#define PicColor TextColor" muss im Zusammenhang mit der vorhergehenden Strukturdeklaration gesehen werden.
Dort ist das "TextColor" schon deklariert.
"PicColor" ist nur ein Präprozessormakro. Kann man als eine Art Platzhalter sehen.

Man muss wissen, dass "Typen" die unter C/C++ per "#define" definiert werden, vor dem Kompilieren umgeschrieben werden, d.h. aus jedem "PicColor" wird "TextColor", usw.
Deshalb kann man unter C/C++ folgendes schreiben:

Code:

  StyleItem si; // vorherige Struktur
  si.TextColor = 5;
  si.PicColor = 6;

Obwohl die Struktur kein "PicColor" besitzt, kann man die Variable so ansprechen, da vor dem Kompilieren "PicColor" in "TextColor" umgewandelt wird, was wiederrum einen gültigen Ausdruck erzeugt.

In Delphi gibt es sowas (zum Glück) nicht. :)
Die ggf. auftretenden Stellen musst du "PicColor" durch "TextColor" ersetzen und ggf. mit einem Kommentar versehen.


Die Klassendeklarationen machen nicht direkt Sinn, wenn man nur die Header-datei alleine betrachtet.
Der einzige Punkt, wo diese Klassen gebraucht werden ist ein Pointer auf diese Klassen als Rückgabewert mehrerer Funktionen, die weiter unter deklariert werden.
Ich denke mal, von diesen Klassen werden in anderen Dateien Klassen abgeleitet und die Funktion wurde so deklariert, damit man alle Klassen nutzen kann. :)

[Oxmyx]

Zitat:

Zitat von SnuffMaster23

Code:

//===========================================================================
// constants for GetSettingPtr(int index) -> returns:
enum {
   SN_STYLESTRUCT      = 0   , // StyleStruct *
   SN_TOOLBAR          = 1   , // StyleItem *
   SN_TOOLBARBUTTON          , // StyleItem *
.
.
.
   SN_MENUFRAME_DISABLECOLOR , // COLORREF *
   SN_LAST
};

Was ist das?

Eine Aufzählung:

Delphi-Quellcode:

type
  TEineAufzaehlung = (
    SN_STYLESTRUCT,
    SN_TOOLBAR,
    SN_TOOLB ARBUTTON,
    ...
    SN_Last)

Zitat:

Und das nochmal, damits nicht untergeht:

Code:

#define PicColor TextColor

class Menu;
class MenuItem;

Mit denen kann ich auch nichts anfangen.
Wird da PicColor der Wert von TextColor zugewiesen?
Werden da zwei Konstanten definiert?
TextColor gibts garnicht, außer als Element von StyleItem :?

Leere Klassendefinitionen??

Durch das #define wird überall, wo PicColor im Quelltext vorkommt, ein TextColor daraus gemacht. Sowas gibt's in Delphi nicht, du musst das entsprechend berücksichtigen.
Die "leeren Klassen" sind keine leeren Klassen, sondern nur Ankündigungen, dass die Klassendefinition noch folgen wird:

Delphi-Quellcode:

type
  TKlasseA = class;

  TKlasseB = class
    klasseA: TKlasseA;
  end;

  TKlasseA = class
    //...
  end;

[SnuffMaster23]

Da gehts um exportierte Funktionen, aber mehr weiß ich auch nicht :(

Code:

#ifdef __BBCORE__
#define API_EXPORT DLL_EXPORT
#else
#define API_EXPORT
#endif

extern "C" {
   // ------------------------------------
   // Read Settings
   API_EXPORT bool ReadBool(LPCSTR filePointer, LPCSTR string, bool defaultBool);
   API_EXPORT int ReadInt(LPCSTR filePointer, LPCSTR string, int defaultInt);
   API_EXPORT LPCSTR ReadString(LPCSTR filePointer, LPCSTR string, LPCSTR defaultString);
   API_EXPORT COLORREF ReadColor(LPCSTR filePointer, LPCSTR string, LPCSTR defaultString);

   // Read a rc-value as string. If 'ptr' is specified, it can read a sequence of items with the same name.
   API_EXPORT LPCSTR ReadValue(LPCSTR fp, LPCSTR keyword, LPLONG ptr = NULL);

   // Was the last Value actually read from the rc-file ?
   // Returns: 0 == not found / 1 == found exact value / 2 == found wildcard
   API_EXPORT int FoundLastValue(void);
.
.
.

Kommt das einfach in die exports-Klausel?