Autom. Header und LIB aus einer DLL erstellen?



  • Ich habe hier eine DLL (um genau zusein, die vom Firebird 1.5 Embedded Server) die ich gerne mal ausprobieren will. Leider wird keine Header- und LIB-Datei mitgeliefert.

    Mit welchem Tool kann ich mir die nötigen Dateien autom. erzeugen lassen?



  • Mit garkeinem Tool, da Tools nicht hellsehen können.
    Die benötigten Informationen sind nicht in der DLL enthalten, was ja auch der Grund dafür ist dass es .lib Files gibt.



  • hol dir doch den source.. http://www.firebirdsql.org/index.php?op=files&id=fb2_rc5
    manchmal lohnt es auch, selber zu kompilieren, auch unter windows ist das meist nicht unmöglich 😉

    ich denke, du meintest diese, oder?
    gruß



  • @hustbaer! Also man kann ja mit DUMPBIN.EXE von MS sich auch Object-Dateien aus DLLs erstellen lassen und die Symbole in der DLL sich anzeigen lassen. Also denke ich mir, das der letzte Step der LIB-Datei auch möglich sein sollte. Nur bin ich aus der MSDN nicht schlaue geworden.

    @elise! Ja, selber bauen wäre natürlich auch möglich. Ich habe aber z.B. bei SQLite das gleiche Problem: die bieten zum Download auch nur eine DLL und eine soganannte DEF-Datei an. Ich wette, man kann daraus auch eine LIB erzeugen. Nur wie? 😕 Weil so macht es ja keinen Sinn, wenn die ganzen EmbeddedDB-Anbieter einem immer nur die DLL anbieten? Wenn man es eh selber bauen muß, dann können die sich doch den Extra-Download sparen?



  • Unter Windows gibt es keinen Supporten Weg sowas zu machen.
    Wenn Du *nur* die DLL hast, dann steht in der DLL keinerlei Infos über Aufrufkonventionen / Parameter / Rückgabewerte drin (es sei denn es ist C++ und Du weisst mit welchem Compiler es erstellt wurde).
    Auch wenn Du die DEF-Datei hast, hilft es Dir nicht viel weiter.

    Wenn Du noch die PDB-Datei hast, dann kann man da vielleicht was machen... aber LIB zu erzeugen, da hab ich meine Zweifel...



  • OK, habe mal weiter geforscht. Eine LIB lässt sich erzeugen, aber man braucht eine DEF-Datei (die auch bei SQLite-DLL dabei ist):

    lib.exe /def:sqlite.def
    

    Hat mich also die Info aus der MSDN nicht ganz getäuscht. Aber die Firebird-Jungs haben doch tatsächlich keine DEF Datei im Download. Die Header braucht man aber anscheinend doch.

    Im Prinzip müssten die SQLite- und Firebird-Jungs drei Dateien in den Download legen:

    1. die DLL
    2. die DEF-Datei, dann kann man sich die LIB für seinen Compiler bzw. Linker automatisch bauen.
    3. die wichtigsten Header-Dateien, die man als User braucht.

    Wäre Compiler-unabhängig und man müsste sich nicht die kompletten Sourcen runter laden.

    Habe mir jetzt den Source von Firebird 2 runter geladen, in dem Embedded-Unterprojekt liegen doch tatsächlich DEF-Dateien. Da liegen sie warm und trocken. 👍



  • ganz so einfach ist das nicht 😉 aber
    mit der Dumpbin.exe erstellst du dir die Moduledefinitionsdatei.def
    der korrecte befehl dafür lautet als eingabe in cmd.exe

    dumpbin namederdll.dll /Exports /Out:NamederModuledefinitionsdatei.def

    anstelle von Exports kann natürlich auch Imports stehn.

    Ich gehe jetzt davon aus das sich die cmd.exe & die *.dll im verzeichniss der dumpbin.exe befindet.

    diese *.def datei must du jetzt bearbeiten, entweder liest du sie gleich aus dem Konsolenprog. aus dies setzt aber voraus das du dir ein eigenes programm schreibst was die dumbin- lib- link &o. undname.exe startet. oder aber du läst sie dir erstmal als textdatei mit der endung *.def erstellen. was dabei rauskommt sieht dann ungefähr so aus

    Dump of file NamederDll.dll

    File Type: DLL

    Section contains the following exports for NamederDll.dll

    0 characteristics
    4294DCD9 time date stamp Wed May 25 22:15:21 2005
    0.00 version
    1 ordinal base
    7497 number of functions
    7497 number of names

    ordinal hint RVA name

    1 A 00007063 ??0AAmmunition@@QAE@ABV0@@Z
    2 B 000087F6 ??0AAmmunition@@QAE@XZ
    3 C 00008562 ??0AAntiPortalActor@@IAE@XZ

    diese kauderwelsch ??0AAmmunition@@QAE@ABV0@@Z nennt sich ergänzter Name

    was nun für dich interessant ist zu wissen sind die zahlen die in der spalte ordinal stehen und das was unter name steht. Du must nun die *.def datei die dir dumpbin erstellt hat so umbauen das sie wie unten aufgeführt aussieht. das ist sehr wichtig ansonsten frist sie kein weiterführendes prog. wie Lib- o. Link.exe

    LIBRARY NameDerDll.DLL

    EXPORTS
    ??0AAmmunition@@QAE@ABV0@@Z @ 1
    ??0AAmmunition@@QAE@XZ @ 2
    ??0AAntiPortalActor@@IAE@XZ @ 3
    ...

    jeh nachdem was du oben entpackt hast Exports o. Imports Funktionen muss hier nätürlich auch wieder Exports o. Imports stehn.

    wenn du nun die *.def richtig erstellt hast öffnest du wieder die cmd.exe (achtung ich gehe wieder davon aus das die cmd.exe sich im verzeichniss der lib.exe befindet) und gibst folgendes ein

    lib /def:NamederModuledefinitionsdatei.def /out:NamederLib*.lib

    wenn du alles richtig gemacht hast, erstellt dir die Lib.exe die gewünschte *.lib und die *.exp. Diese kannst du nun in dein Project einbinden.

    Um dir nun daraus ne header zu basteln, wird das ganze noch ein wenig komplizierter, hierfür brauchst du nur die ergänzter Name
    ??0AAmmunition@@QAE@ABV0@@Z und die undname.exe
    den ergänzten namen übergibts du an undname.exe wie unten folgt. (achtung ich gehe wieder davon aus das die cmd.exe im verzeichniss der undname.exe liegt) öffne die cmd.exe und gib dort ein.

    undname -f ??0AAmmunition@@QAE@ABV0@@Z

    und sie gibt dir zurück

    public: __thiscall AAmmunition::AAmmunition(class AAmmunition const &);

    du must das dann noch weiterverarbeiten, denn so kann kein prog damit was anfangen, und zwar in der form

    public gibt dir den zugriffstatus der funktion zurück

    AAmmunition:: gibt dir den classennamen bzw. den headernamen an

    ::AAmmunition(class AAmmunition const &) gibt dir den funktionsnamen an

    so das wars wie man ne header erstellt nur dürfte klar sein das dies über die cmd.exe etwas schwierig zu lösen sein dürfte. und darin liegt nun die kunst. du wirst um dir ne header zu erstellen nicht darum kommen dir ein eigenes programm zu schreiben das dir alle ergänzten namen an die undname.exe übergibt und gleichzeitig das zurückgegeben wieder ausliest und weiterverarbeitet. 😃

    eine andere möglichkeit wäre, an die ergänzten namen zu kommen, das ganze über
    Portable Executable File Format zu erledigen, diesbezüglich bräuchtest du nicht den umweg über die dumbin.exe zu gehn sondern könntest direkt dir die *.def erstellen und alles an undname.exe übergeben.

    Anbei sei noch vermerkt
    es gibt nicht umsonst leute die 250$ und mehr für solche header zahlen. das eröffnet einem nämlich unteranderem unendliche möglichkeiten des cheatens 😉

    LowFly



  • LowFly! Danke für die ausführliche Beschreibung. 👍 😃 Aber so kompliziert habe ich es mir nicht vorgestellt. Gut, aber letztendlich sollte man sich fragen, warum einige OpenSource-Projekte nur eine DLL anbieten, nach dem Motto "Hier haste und kannste benutzen". Wundert mich halt nur...



  • Aber so kompliziert habe ich es mir nicht vorgestellt

    😕

    hmm,
    vor einem jahr hab ich noch zu denen gehört die steif & fest behauptet haben es wäre überhaupt nicht möglich. vor einigen monaten dachte ich noch das man studiert & den doctor title haben muss, um fähig zu sein, header aus ner dll zu erstellen.

    im enddefect ist es aber nur das ausführen von programmen in der richtigen reihenfolge & pissbillige Stringbearbeitung das wars.

    bzw. wenn man sich mal in Portable Executable File Format eingearbeitet hat geht das ganze noch viel einfacher & schneller & es bleibt zum schluß nur noch die Stringbearbeitung.

    klar man muss sich mal etwas intensiver mit dem thema auseinander setzen als es eben mal so aus dem ärmel zu schüteln, jedoch geht es & das sogar recht einfach 😃

    LowFly



  • Zum Header erstellen müsste man auch wissen welche Member die Klassen alle haben, wie gross die Instanzen sind etc.
    Und die Info steht in der DLL nicht drinnen.



  • Mir glaubt mal wieder niemand: Es geht nicht. Es mag für ganz spezielle spezialfälle gehen; abe rnicht in der Regel.



  • nicht alle funktionen haben member, die es zB nicht haben sind konstructor & destructor der klassen. wenn du mal das nachvollzogen hättest dann wüstest du das man alles bekommt was man braucht um sich header zu erstellen.
    da ich auch nicht die addresse der funktion im laufenden process austauchsen will und durch meine ersetzen will interesiert auch die größe der Instanze & ect. nicht 😉

    @ Jochen nein ich kann dir nicht glauben,
    da ich mir son tool geschrieben und komischerweise kann ich ungefähr 5% aller dll's die ich auf der platte hab NICHT entpacken 95% aller dll's kann ich entpacken. die ich nicht entpacken kann sind meistens dll's die mit mfc.. anfangen. Fackt ist das ich die dll's enpacke und diese header in verbindung mit den lib's in ein project einbinde & nutzen kann. ob du es mir nun glaubst oder nicht is mir egal. nur bitte behaupte es nicht das es nicht geht wenn du selbst nicht versucht hast es erfolgreich nachzufollziehn.

    so sieht zB das aus was ich von der undname bekomme. ich nenne es mal die vorläufige header

    public: class UFluidVolumeInterface & __thiscall AFluidVolume::GetInterface(void);
    public: float __thiscall USkeletalMeshInstance::GetKeyAlpha(int,struct MeshAnimChannel const &);
    private: float __thiscall USkeletalMeshInstance::GetKeyAlphaInternal(int,struct MeshAnimChannel const &);
    private: float __thiscall USkeletalMeshInstance::GetKeyAlphaOfHigherBlendsOnChannel(int,struct MeshAnimChannel const &);
    public: double __thiscall UTexture::GetLastUpdateTime(void);
    public: static void __cdecl USkinVertexBuffer::InternalConstructor(void *);
    public: static void __cdecl USound::InternalConstructor(void *);
    public: static void __cdecl USparkEmitter::InternalConstructor(void *);
    public: static void __cdecl USpeechManager::InternalConstructor(void *);
    public: static void __cdecl USpriteEmitter::InternalConstructor(void *);
    public: static void __cdecl UStaticMesh::InternalConstructor(void *);
    public: static void __cdecl UStaticMeshInstance::InternalConstructor(void *);
    public: static void __cdecl UStaticShadow::InternalConstructor(void *);
    public: static void __cdecl UTerrainMaterial::InternalConstructor(void *);
    public: static void __cdecl UTerrainPrimitive::InternalConstructor(void *);
    public: static void __cdecl UTerrainSector::InternalConstructor(void *);
    public: virtual int __thiscall UModifier::IsTransparent(void);
    public: virtual int __thiscall UShader::IsTransparent(void);
    public: virtual int __thiscall UTexture::IsTransparent(void);
    public: int __thiscall UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);
    public: virtual bool __thiscall APawn::IsVisionEnabled(void);
    public: int __thiscall AActor::IsVolumeBrush(void)const ;
    public: virtual int __thiscall ADoor::IsWedged(void);
    public: int __thiscall UViewport::IsWire(void);
    public: bool __thiscall UMassiveAdClient::IsZoneLoaded(void);
    public: virtual int __thiscall UEngine::Key(class UViewport *,enum EInputKey,unsigned short);
    public: unsigned char __thiscall UInput::KeyDown(int);
    public: virtual void __thiscall AEmitter::Kill(void);
    public: int __thiscall USkeletalMesh::LODFootprint(int,int);

    und das lass ich dann das tool daraus machen und erstell mir das als headerdatei auf der platte und binde dies in ein project.

    class AActor
    {

    public:
    AActor(class AActor const &);//
    AActor(void);//
    virtual ~AActor(void);//
    static void * __cdecl operator new(unsigned int,class UObject *,class FName,unsigned long);//
    static void * __cdecl operator new(unsigned int,enum EInternal *);//
    class & operator=(class AActor const &);//
    virtual int AddMyMarker(class AActor *);//
    virtual int AnimGetSpecialChannel(void);//
    virtual class * AssociatedLevelGeometry(void);//
    void AttachProjector(class AProjector *);//
    int AttachToBone(class AActor *,class FName);//
    void BeginTouch(class AActor *);//
    virtual void BoundProjectileVelocity(void);//
    virtual int CanCoverPlaneBillboard(void)const;//
    void execSetTweenMode(struct FFrame &,void * const);//
    void execSimulateSoundOnDedicatedServer(struct FFrame &,void * const);//
    ................
    virtual void initialiseHavokDataObject(void);//
    int moveSmooth(class FVector);//
    virtual void performPhysics(float);//
    virtual void physFalling(float,int);//
    void physProjectile(float,int);//
    void physRootMotion(float);//
    void physTrailer(float);//
    void physicsRotation(float);//
    virtual void processHitWall(class FVector,class AActor *);//
    virtual void processLanded(class FVector,class AActor *,float,int);//
    virtual void setPhysics(unsigned char,class AActor *,class FVector);//
    int setRelativeLocation(class FVector);//
    int setRelativeRotation(class FRotator);//
    virtual void stepDown(class FVector const &,struct FCheckResult &);//
    virtual void stepUp(class FVector,class FVector,class FVector,struct FCheckResult &);//

    protected:

    private:
    static class PrivateStaticClass;//

    /*Müll:

    */

    };



  • Dann musst Du mir noch eines erklären: Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss? Du hast hier keinerlei Member-Variablen drin... woher soll das "new" es dan erahnen?

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen, da diese *nur* Namen (oder Ordinal) exportieren und Du weder Aufrufkonventionen noch Parameter kennst.

    Es kann *nur* (ohne Zusatzinfos) gehen, wenn reine C++-Funktionen (also keine Klassen) exportiert werden, da hier in dem dekorierten Namen alles drin steht.



  • Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

    indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

    naja dann frag ich mich wieso es bei mir geht 😉

    da diese *nur* Namen (oder Ordinal) exportieren

    falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast. denn dort bekommst du die ordinal zahl & den ergänzten name der Funktion & noch einiges mehr. um dir daraus ne *lib anzufertigen zu lassen must du allerdings die *.def umbauen die dir dumpbin erstellt. und die umgebaute *def übergibst du dann an die lib.exe. Ich hab alles beschrieben wies geht probier es aus, allerdings plauder ich nicht aus dem nähkästchen, mitdenken muss man & setz ich voraus. mehr sag ich nicht mehr dazu.

    der andere weg ist wie gesagt über Portable Executable File Format und dort lass ich mir die ergänzten namen durch eine schleife in einer array plazieren und ihr platz in der Array +1 entspricht auch gleichzeitig ihrer ordinal zahl.

    und Du weder Aufrufkonventionen noch Parameter kennst.

    wie gesagt das zeigt das du es noch nie probiert hast den der aufruf einer classe passiert genau so wie normal auch, wenn du dich im ausführenden process einklingst

    UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);

    UTerrainSector *pUTS = new UTerrainSector();
    pUTS->IsTriangleAll(0,1,2,3,4,_T("Test"));

    na & die Parameternamen auf die du hinauswills interesieren absolut nicht in einer header es reicht der parametertyp und den bekommst ja oder bitte was ist das IsTriangleAll(int,int,int,int,int,unsigned char) in der *.cpp geb ich dir recht dort brauchst du den Parameternamen, nur kann der gänzlich anderst heisen wie in dem orginal.

    kuck dir mal diese beispiele an,
    http://www.codeproject.com/debug/LibView.asp
    insbesondere dieses
    http://www.codeproject.com/dll/Execute_DLL_Function.asp

    ich sag auch nicht das man sich da mal schnell hinsetzt den code runtertippt und man header hat die sofort einsetztbar sind. bei den lib's egal was du sagst funzt es bei mir (man muss die *.def RICHTIG umbaun) und mit den headern rumspielen. dann klapp das auch (mit dem nachbarn 😉 )

    LowFly



  • Ein .lib File zusammenpfuschen ist eine Sache, eine vollständig verwendbare Header Datei eine gänzlich andere.
    Sag was du willst, aber du *kannst* aus einer DLL (mit oder ohne .def File) keine Headers erstellen mit denen man vernünftig arbeiten kann. Es geht nicht. Punkt.

    Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will.

    Im übrigen wird das was du tust dem OP nixe bringen, er will ja nicht eine "ersatz-dll" schreiben oder irgendwelche Funktionen patchen, sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht.



  • es ist einfach zu trollig.

    Ein .lib File zusammenpfuschen ist eine Sache, eine vollständig verwendbare Header Datei eine gänzlich andere.
    Sag was du willst, aber du *kannst* aus einer DLL (mit oder ohne .def File) keine Headers erstellen mit denen man vernünftig arbeiten kann. Es geht nicht. Punkt.

    Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will

    verstehn und es selbst probieren sind zwei paar stiefel die sich gänzlich unterscheiden. und pfuschen tut hier keiner. die aussage zeigt das man(n) sich nicht ernsthaft damit beschäftig, zuwas und wofür gedacht ist die Dumpbin- lib- & link.exe zu nutzen.

    anhand eurer ausssagen sehe ich das ihr es bislang nie ernsthaft versucht habt dies zu bewerkstelligen und spätestens dann aufgehört habt als die ersten stollpersteine kamen o. euch das verständniss dafür fehlt. bzw. nur aus eurem wissen (was ich an dieser stelle keinem streitig machen will) vermutungen anstellt wie etwas zu sein hat. womit ihr beide aber sowas von daneben liegt.

    sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht

    ich kann mich nur wiederholen es zeigt wieviel ahnung du hast, hättest du nur einmal in das beispiel gekuckt. Es zu verstehen versucht, hättest du dir diese aussage verkniffen da wird zum teil genau das gemacht was du behauptest das es nicht geht.

    aber nochmal langsam zum mitschreiben.

    1; erstelle dir eine *.lib von der dll deren funktion du nutzen willst & binde sie in dein project ein.

    2; wenn nötig erstelle dir eine header aus dem was dir undname.exe anhand der ergänzten namen zurückgibt & binde diese in dein Project.

    die header ist nur notwenig damit der compiler nicht motzt es würden irgendwo nichtaufgelöste externe symbole geben. zu nix anderem ist die header notwendig.

    3; hier gibt es zwei wege zum erfolg
    entweder injeziere die dll die funktionen manipulieren soll in den laufenden process & aktiviere sie
    oder
    lade die gewünschte dll beim start des programms via LoadLibary(...) in deinen Project und du erhälst zugriff auf alle funktionen die in der dll zu finden sind.

    nun kannst du natürlich weiter behaupten das es nicht geht.

    dann frag ich mich aber warum klappt es bei mir egal wie, ob ich nun etwas in einen process injeziere oder die gewünschte dll beim start in mein project lade.

    warscheinlich hab ich nen zauberpc



  • LowFly schrieb:

    Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

    indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

    Was hat denn das mit meiner Frage zu tun!? Und wer will hier was manipulieren? Weder ich noch der OP...

    LowFly schrieb:

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

    naja dann frag ich mich wieso es bei mir geht 😉

    da diese *nur* Namen (oder Ordinal) exportieren

    falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast.

    Ich vermute eher mal, dass Du es noch nie mit Windows-DLLs probiert hast!
    Ein Dumpbin von kernel32.dll liefet z.B.:

    Dump of file C:\WINDOWS\SysWOW64\kernel32.dll
    
    File Type: DLL
    
      Section contains the following exports for KERNEL32.dll
    
        00000000 characteristics
        42435E2F time date stamp Fri Mar 25 01:41:19 2005
            0.00 version
               1 ordinal base
             978 number of functions
             978 number of names
    
        ordinal hint RVA      name
    
              1    0 000219F6 ActivateActCtx = _ActivateActCtx@8
              2    1 00023F79 AddAtomA = _AddAtomA@4
              3    2 00043A11 AddAtomW = _AddAtomW@4
              4    3 00081C71 AddConsoleAliasA = _AddConsoleAliasA@12
              5    4 00081C33 AddConsoleAliasW = _AddConsoleAliasW@12
              6    5 00068005 AddLocalAlternateComputerNameA = _AddLocalAlternateComputerNameA@8
              7    6 00067F1E AddLocalAlternateComputerNameW = _AddLocalAlternateComputerNameW@8
    

    So: Und jetzt erklär mir mal bitte, wie Du ohne Infos über die Funktionen eine h-Datei und eine LIB-Datei erzeugen willst!?
    Dir sind weder Parameter/Aufrufkonventionen noch sonstwas bekannt...

    Wie gesagt: Wenn Du die Header irgendwo hast, dann geht es... aber wenn Du *nur* die DLL hast (wie es beim OP geheisen hat), dann ist es IMHO zu 99% unmöglich.



  • ich hab auch nicht behauptet das es einfach ist windows dll zu enpacken
    im falle der kernel stimmt die hab ich noch nicht entpackt warum auch den für die meisten windows *.dll braucht man keine *.libs zu erzeugen den die *.lib's finden sich in ätlichen SDK's 😉 wenn nötig auch die header dazu.

    im fall der kernel zB hat man keine ergänzten namen sondern bekommt gleich den funktionsnamen allerdings OHNE Parameter angabe das ist richtig. aber willst du mir vieleicht erzählen das man für die kernel irgendwelche aufrufkonventionen braucht, ich hoffe nicht.

    und für die Parameter der windows- kernelfunktionen reicht erstens ein rechtsklick auf parametertyp bzw ein blick in die MSDNActivateActCtx

    und für die die windows dll's die keine *.lib's und header in SDK's bereitstellen klappt das beschrieben verfahren. und wenns eben nicht klappt fallen die unter die besagten 5% 😉

    LowFly



  • Man sieht: Es geht nur in Spezialfällen ohne Zusatzinfos. Und das ist, wenn C++-Funktion exportiert werden. In allen anderen Fällen (Klassen, C-Funktionen) geht es nicht.
    Wenn Du mir dies wiederlegen kannst, kannst Du es ja posten. Ich kann Dir auch eine DLL schicken zu der Du mir die h-Datei und die LIB-Datei machen kannst 😉



  • LowFly, du kommst dir wohl sehr schlau vor. Es wurde nach einem Tool gefragt welches aus einer DLL nen .lib file und .h File machen kann. Die Antwort ist ein Tool kann das nicht. Ende & aus.

    Das man mit Hilfe von Tools und ewig rumraten und pfriemeln vielleicht in ein paar sehr sehr einfachen Fällen Erfolg hat - ja, ok, wen interessierts, das geht nämlich sogar ganz ohne Tool. (Ok, .lib File schreib ich nicht mit Hand, aber .def File, und mit dem mach ich dann mein .lib File). Bloss ist das ein gänzlich anderes Thema.

    Wie willst du bitte bei einer C++ DLL sizeof(X) rausbekommen? Wie willst du zu den Klassen kommen die gänzlich inline implementiert sind? Zu den Templates? Wie willst du die Funktionen/Methoden aufrufen deren Parameterliste eine komplett inline implementierte Klasse enthält?

    Du redest hier von spezialfällen, und ignorierst fest das wir anderen das nicht tun.

    BTW: das "MessageBoxA" Beispiel ist wohl komplett lächerlich. Davon abgehesen: das dort vorgestellte Tool erfordert erst recht wieder das man die Parameterliste mit Hand eingigt. Und nun sag mir wie du die Parameterliste von MessageBoxA erraten willst wenn du sie eben nicht weisst, und nicht nachgucken kannst? Hm? Blubb.


Log in to reply