global Variablen, Mehrfachdeklaration

[WS1976]

Hallo,

in zwei units wird zweimal die gleiche Variable deklariert:

Delphi-Quellcode:

unit1;

INTERFACE

uses xxx,yyy;

var
    versa_SB_str                               : string;

Delphi-Quellcode:

unit2;

INTERFACE

uses xxx,yyy;

var
    versa_SB_str                               : string;

in einer dritten unit steht dann unter uses:

Delphi-Quellcode:

uses
unit1,unit2;

In dieser dritten ist dann letztendlich überhaupt nicht mehr, bei einer Zuweisung, klar welche Variablbe "versa_SB_str" gemeint ist.
Ich weiss, dass das katastrophaler Programmierstil ist, aber ich habe ein altes Programm zum Überarbeiten bekommen und weiss an der Stelle eigentlich nicht mehr weiter.
Mit D2 kann ich das Ganze kompilieren und läuft. Mit D7 bringt er alles durcheinander.
Beide Compiler bringen keine Fehlermeldung!
Gibts ein Tool oder eine Möglichkeit solche Doppeldeklarationen zu erkennen?
Kann mir jemand helfen?
Grüsse Rainer

[guidok]

Hallo,

ich hatte mal das Problem, das TBitmap auch zweimal deklariert ist. Der Compiler nimmt sich die Deklaration, die in deiner Uses-Anweisung als erstes auftaucht (bei dir Unit1), glaube ich zumindest. Du kannst allerdings auch genau auf die Deklaration zugreifen, die du möchtest mit

Delphi-Quellcode:

unit1.versa_SB_str
unit2.versa_SB_str

Ob du solche Mehrfachdeklarationen auch anders erkennen kannst weiß ich leider nicht.

Gruß,

Guido

[WS1976]

Hallo,

danke für die Antwort.
Die Version unit1.variable ist mir bekannt, nur gemacht hat mein Vorgänger das nirgends.
Mein Beispiel ist auch nur die Spitze des Eisbergs.
Es geht in mehr als 100 Units kreuz und quer durcheinander.
Sieht irgendjemand einen Sinn in einer solchen Doppeldeklaration? Kann ich eine Variable "absolut global" machen, sodass der Compiler merkt, dass es hier eine Doppeldeklaration gibt?
Eigentlich müsste man daraus eigentlich schliessen, dass es in Delphi nur unit-globale Variablen gibt und keine wirklich globalen.

Grüsse
Rainer

[Reinhard Kern]

Zitat:

Zitat von WS1976

Hallo,

...Eigentlich müsste man daraus eigentlich schliessen, dass es in Delphi nur unit-globale Variablen gibt und keine wirklich globalen.

Grüsse
Rainer

Hallo Rainer,

ohne uses ist in Delphi nichts sichtbar, in der dpr-Datei kann man zwar Variablen definieren, aber die kann man in anderen Units nicht verwenden.

Die sauberste Methode ist, eine Unit "globals" o.ä. anzulegen, alles globale dort rein zu packen (auch z.B. Prozeduren) und die in allen anderen als erste unter uses aufzuführen.

Doppeldeklarationen sind für Delphi ein Problem, u.a. wenn man eine Deklaration in eine andere Unit verlegt. Ich behelfe mir mit der Suchfunktion "in allen Projektdateien suchen".

Gruss Reinhard

[SirThornberry]

Die sauberste Variante ist eher soweit wie möglich auf globale Variablen zu verzichten. Dieses Beispiel zeigt sehr schön warum Globale so ungern gesehen sind bei den meisten Programmierern.
Sinn von solchen Doppeldefinitionen war eventuell das man nicht immer die eine Unit einbinden muss nur weil man die Constante daraus braucht. Also definiert man sie sich neu.
Pfofessional ist das natürlich nicht, eine ordentliche Planung sorgt eigentlich dafür das Constanten nur an einer Stelle definiert werden und nicht mehrfach.

[mschaefer]

Im Grßen und Ganzen stimme ich dem zu. Aber bei Basisdefinitionen geht das manchmal nicht. Zum Beispiel bei der Definiton der Farbwerten oder Styletypen ist es sinnvoll die Systemweit zu definieren. In dem Fall würde ich ein Teil der Unitbezeichnung in den Anfang des Variablennamens legen. Sonst neige ich dazu als zentrale Speicherstelle ein MemImi-Objekt oder einen MemTree zu nehmen und dort zentral alles abzulegen.

Grüße // Martin


PS: Die Verwaltung von Optionseinstellungen scheinen bisher in den meisten Delphianwendungen etwas leidlich gelöst zu sein.

[Reinhard Kern]

Zitat:

Zitat von SirThornberry

Die sauberste Variante ist eher soweit wie möglich auf globale Variablen zu verzichten. Dieses Beispiel zeigt sehr schön warum Globale so ungern gesehen sind bei den meisten Programmierern.
Sinn von solchen Doppeldefinitionen war eventuell das man nicht immer die eine Unit einbinden muss nur weil man die Constante daraus braucht. Also definiert man sie sich neu.
Pfofessional ist das natürlich nicht, eine ordentliche Planung sorgt eigentlich dafür das Constanten nur an einer Stelle definiert werden und nicht mehrfach.

Hello Sir,

das Gegenteil ist der Fall: das Problem ist nicht, dass jemand globale Variable verwendet, sondern dass Delphi keine kennt. Das geht ja auch aus deinem 2. Satz hervor - bei echten globalen Variablen dürfte es eben keine unangemeckerten Doppeldefinitionen geben. Wenn ich eine Umrechnungskonstante mm2inch definiere, dann will ich selbstverständlich, dass jedes kleinste Stück meiner Software genau diese Konstante benutzt - was soll daran so böse sein, dass man es verbieten muss? Ist sowieso lächerlich, weil es Software ohne globale Variablen garnicht gibt - schreib mal ein Delphi-Programm ohne Application. Auch wenn man alles dynamisch in den Speicher lädt, was sowieso eher unsicher ist, irgendwo muss ja alles anfangen.

Das Problem ist also, dass es Doppeldefinitionen gibt, die es für Globales garnicht geben dürfte, und das ist ein reines Delphi-Problem. Selbst jeder Assembler meldet sowas als Fehler.

Gruss Reinhard

[SirThornberry]

@Reinhard Kern: Es geht ohne ein globales ApplicationObject aber das wäre jetzt eine Grundsatzdikussion und hat mit deinem Problem nichts zu tun.

[Nuclear-Ping]

Wenn ich solche "globalen" Variablen brauche, mache ich es ungefähr so:

Delphi-Quellcode:

unit MyGlobals;

interface

type
  ...

const
  ...

var
  ...;
  MyGlobVar: String;

implementation

end.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, ..., MyGlobals;

type
  ...

implementation

procedure TForm1.FormCreate (...);
begin
  MyGlobVar := 'Foo';
end;

...

end.

Delphi-Quellcode:

unit Unit2;

interface

uses
  Windows, ..., MyGlobals;

type
  ...

implementation

procedure TForm2.FormCreate (...);
begin
  ShowMessage (MyGlobVar);
end;

...

end.

Also eine Unit anlegen, in der solche Sachen gesammelt werden (Types, Consts, Vars) und diese Unit dann in den jeweiligen Units einbinden, wo du die Variablen / Typen / ... brauchst.

[WS1976]

Hallo nuclear,

solange du ein neues Projekt hast mach das auch so. Ich hab aber nach wie vor das Problem, dass mein Vorgänger alle möglichen Variablen an alle möglichen Stellen verteilt hat.
Es ist extrem mühsam alle Variablen zu suchen und auch Doppeldeklarationen aufzudecken.
Das Projekt umfasst ca 320000 Zeilen Code.
Hat jemand eine Ahnung ob es vielleicht irgendein Tool gibt mit dem mir geholfen wird?
Wenn nicht schreib ich mir selbst eins.

Fazit:
Wenn schon globale Variablen, dann übersichtlich in eine Unit!

Grüsse
Rainer

[Nuclear-Ping]

Uff, da hast du ja wirklich einen dicken Brocken bekommen.

Keine Ahnung, ob es so ein Tool schon gibt. Wenn nicht, wäre das aber sicher etwas nützliches für einige Programmierer.

[Reinhard Kern]

Zitat:

Zitat von WS1976

Hallo nuclear,

...
Hat jemand eine Ahnung ob es vielleicht irgendein Tool gibt mit dem mir geholfen wird?
Wenn nicht schreib ich mir selbst eins.

Fazit:
Wenn schon globale Variablen, dann übersichtlich in eine Unit!

Grüsse
Rainer

Hallo,

wenn z.B. global1 in 2 Units deklariert ist, dann taucht im Map-File im Abschnitt "Adress - Publics by Name" global1 auch 2 mal auf an verschiedenen Adressen. Liest man das in Excel ein und sortiert nach Name (hab ich noch nicht praktiziert), so kann man doppelte Publics sehen. Damit weiss man noch nicht, wo, aber dass (es doppelt vorhanden ist). Das könnte man an den benachbarten Variablen in der ursprünglichen Reihenfolge abschätzen oder mit der "Suche in allen Projektdateien".

Ein eigenes Tool müsste schon recht umfangreiche Parserfunktionen erfüllen, da es var, const und procedure Deklarationen im Programmtext erkennen müsste. Normalerweise steht da ja nicht "var global1".

Am Mapfile sieht man übrigens, wie blöde das Delphikonzept in diesem Punkt ist - doppelte Publics darf es eigentlich überhaupt nicht geben, schon garnicht unkommentiert und ohne weitere Spezifikation.

Gruss Reinhard

[WS1976]

Puuuh,

irgendwie ist das schon ein Hammer. Im Map File hab ich, wie Reinhard beschrieben hat, wenigstens einen Hinweis darauf, dass es die Variable doppelt gibt. Wenn ich jetzt über das Projekt suche komm ich weiter.
Ich werde ein Tool basteln das mir die doppelt vorkommenden Einträg rausfieselt. Dann muss ich wohl oder übel per Hand suchen.
Irgendwie schreit die ganze Sache noch einer Lösung.

Danke an Alle, besonders an Reinhard.
Rainer

[Amateurprofi]

Zitat:

Zitat von guidok

Hallo,

ich hatte mal das Problem, das TBitmap auch zweimal deklariert ist. Der Compiler nimmt sich die Deklaration, die in deiner Uses-Anweisung als erstes auftaucht (bei dir Unit1), glaube ich zumindest. Du kannst allerdings auch genau auf die Deklaration zugreifen, die du möchtest mit

Delphi-Quellcode:

unit1.versa_SB_str
unit2.versa_SB_str

Ob du solche Mehrfachdeklarationen auch anders erkennen kannst weiß ich leider nicht.

Gruß,

Guido

Nein! Der Compiler nimmt die Deklaration, die in der Uses-Liste als letzte auftaucht....

[s-off]

Zitat:

Zitat von WS1976

Dann muss ich wohl oder übel per Hand suchen.

Lass das doch Deine Azubis machen. Schliesslich muss man die Kosten für so eine Aktion im Auge behalten.

Zitat:

Zitat von WS1976

Irgendwie schreit die ganze Sache noch einer Lösung.

Ganz genau! Und daher freuen wir uns alle auf ein nettes kleines Tool von Dir - mit Quelltext versteht sich.

[WS1976]

Hi s-off,

müssen diese zynischen Bemerkungen sein?
Lass es doch einfach.

Rainer

[s-off]

Hallo WS1976.

Traurig, dass Du alle meine Antworten als zynisch betrachtest.

Wenn man zugrunde legt, dass Du, in Deiner Tätigkeit als Ausbilder, der Firma, für die Du tätig bist, durch Bezug Deines Gehaltes, höhere Kosten verursachst (auf der anderen Seite aber auch mehr Umsatz einfahren kannst), als Deine 'Schützlinge', dann ist es eher ein wohlwollender Rat von mir.

Und da ich davon ausgehe, dass Du mit Deinem Problem der x-Fach deklarierten Variablen nicht alleine auf weiter Flur stehst, ist auch meine zweite Aussage alles andere als zynisch.

Wenn Du Deine Anschuldigungen auf der kleinen Diskussion von gestern begründest -> ich bin nicht nachtragend; Du etwa?

[WS1976]

Hallo s-off,

Mir ist das sehr ernst mit meinem Problem. Wenn ich die Azubis dransetze kann ichs genausogut selbst machen, muss nämlich alles nochmal kontrollieren.

Hast du irgendeinen Ansatz zur Lösung meines Problems (Azubis ist keiner hihi)?
Ich bin schon dabei ein Tool auf Basis des Mapfiles aufzubauen. Dort kann ich wenigstens erkennen ob die Variablen doppelt sind.

Bemerkung: Meine Tools sind immer mit Quellcode. Wenn's jemand interessiert stell ich das Ganze ins DP.
Ich bin absolut nicht nachtragend. Hab Gestern mindestens 20 Mails gekriegt hab sie alle gelöscht ohne sie zu lesen. ( Hätte mich nur aufgeregt. Hab ich mir erspart )

Also Friede?

Grüsse
Rainer

[s-off]

Huhu,

Zitat:

Zitat von WS1976

Mir ist das sehr ernst mit meinem Problem. Wenn ich die Azubis dransetze kann ichs genausogut selbst machen, muss nämlich alles nochmal kontrollieren.

Ok, dann liege ich mit meinem Kosten-Nutzen-Vergleich tatsächlich schief :?

Zitat:

Zitat von WS1976

Hast du irgendeinen Ansatz zur Lösung meines Problems (Azubis ist keiner hihi)?

Leider nein - ich hätte sie auch nicht vorenthalten, wenn ich sie hätte :(

Zitat:

Zitat von WS1976

Ich bin schon dabei ein Tool auf Basis des Mapfiles aufzubauen. Dort kann ich wenigstens erkennen ob die Variablen doppelt sind.

Der Ansatz, über das Map-File zu gehen, erscheint mir allerdings gar nicht übel. Musst Dir nur überlegen, wie Du weitermachst, sobald Du weisst, welche Variablen mehrfach deklariert sind.

Zur Suche innerhalb Deiner Sourcen empfehle ich entweder GrepSearch, welches in den GExperts enthalten ist, oder aber ein professionelles Such-Tool wie bspw. FileLocator Pro.

Mir würde allerdings ad hoc wirklich keine Möglichkeit einfallen, Dein Problem im zweiten Schritt automatisch und vor allem sauber zu lösen. Es dürfte problematisch sein, herzuleiten, auf welche Variable aus welcher Unit bei einem speziellen Aufruf gezeigt wird.

Zitat:

Zitat von WS1976

Also Friede?

Friede kann nur dort geschlossen werden, wo Krieg herrscht - und Krieg sieht in meinen Augen anders aus - aber um es offiziell zu machen => Friede :!:

:wink:

[mschaefer]

Moin, moin,

Sagt mal bei aller liebgewonnenen Zynik, warum lässt man nicht den Compiler suchen? Nimm doch einfach alle globale Variable und nenne diese um im Stil von "Unitnamen_Variablennamen" und versuche zu compilieren. Dann springt der Compiler zu jeder stelle wo er nicht weiterkommt und Du kannst entscheiden welche dahin kommt. Jedenfalls in Map-Files suchen scheint mir doch eher Zeitvertreib zu sein.

Prinzipbedingt braucht man da auch kein Tool schreiben!
Ein Tool wird kaum entscheiden können welche der doppelten Globalvariablen im Kontext nun genau hingehört.


Grüße // Martin

[s-off]

Zitat:

Zitat von mschaefer

Sagt mal bei aller liebgewonnenen Zynik, warum lässt man nicht den Compiler suchen?

Prinzipiell eine schöne Sache, aber...

Zitat:

Zitat von mschaefer

Nimm doch einfach alle globale Variable und nenne diese um im Stil von "Unitnamen_Variablennamen" und versuche zu compilieren.

...möchtest Du alle globalen Variablen umbenennen, die über x Dateien verteilt sind?

Zitat:

Zitat von mschaefer

Jedenfalls in Map-Files suchen scheint mir doch eher Zeitvertreib zu sein.

Hier sicher die einfachste Möglichkeit, alle Doppeldeklarationen sicher zu entdecken.

Zitat:

Zitat von mschaefer

Ein Tool wird kaum entscheiden können welche der doppelten Globalvariablen im Kontext nun genau hingehört.

Wie ich bereits sagte.

Fazit:
Man kann durch Analyse des Map-Files sämtliche Doppeldeklarationen aufdecken; ab da geht es allerdings per pedes weiter.

[mschaefer]

[quote="s-off"]

Zitat:

Zitat von mschaefer

...möchtest Du alle globalen Variablen umbenennen, die über x Dateien verteilt sind?

Ok über die Map-Files kann man ja reden, aber prinzipiell würde ich tatsächlich in Betracht ziehen, die Variabeln mit einer systematik Projektweit umzubenennen. Das liegt daran, dass meine Projekte bisher immer wieder erweitert wurden und ich muß mich darauf verlassen, dass sowas nicht passieren kann. Das würde jede Zeitplanung sabotieren. Jemand der so ein Unsinn verzapft würde wohl auch nicht lange in meinem Projekten mitarbeiten.

Grüße // Martin

[s-off]

Zitat:

Zitat von mschaefer

Ok über die Map-Files kann man ja reden, aber prinzipiell würde ich tatsächlich in Betracht ziehen, die Variabeln mit einer systematik Projektweit umzubenennen.

Da möchte ich Dir auch gar nicht widersprechen; das wäre natürlich eine sehr schöne Lösung. Nur denke ich, dass das automatische Umbenennen sämtlicher globaler Variablen ein nicht weniger großes Problem darstellt, als die Bereinigung der bekannten Doppeldeklarationen.
Zwar bedarf es hier keiner besonderen Logik, nur stehen wir hier vor dem Problem, den Delphi Code parsen zu müssen, was sicherlich nicht ganz anspruchslos ist, und man so auch wieder nicht um ein separates Tool herum kommt.

Zitat:

Zitat von mschaefer

Jemand der so ein Unsinn verzapft würde wohl auch nicht lange in meinem Projekten mitarbeiten.

Darum ist es ja vielleicht auch sein Vorgänger :mrgreen:

[WS1976]

Hi alle,

mein Vorgänger ist oder war (ich weiss nicht ob er noch, als Programmierer, existiert) ein professioneller Programmierer. Die Source wurde in einer externen Softwareschmiede 1998 erstellt. Bei Ihm und seiner Beurteilung bin ich jedenfalls sehr vorsichtig da er sehr tricky programmiert hat und meist irgendein (hinterlistiger) Sinn darin steckt.

Hallo Amateurprofi:
nochmal, dass das ganz klar ist:
bei den Mehrfachdeklaration wird nicht die erste oder die letzte genommen, sondern die sind gleichberechtigt nebeneinander vorhanden. Sogar die Unit-Reihenfolge in der uses Klausel der zugreifenden Unit ( ihr wisst was ich meine ) spielt keine Rolle.
Welche der Compiler wo wann nimmt ist scheinbar purer Zufall.
Eine zweite Sache ist noch der Debugger, der macht nochmal was er will.

Ich jedenfalls werde mich des Mapfiles bedienen!

Grüsse
Rainer

[guidok]

Zitat:

bei den Mehrfachdeklaration wird nicht die erste oder die letzte genommen, sondern die sind gleichberechtigt nebeneinander vorhanden. Sogar die Unit-Reihenfolge in der uses Klausel der zugreifenden Unit ( ihr wisst was ich meine ) spielt keine Rolle.
Welche der Compiler wo wann nimmt ist scheinbar purer Zufall.

Bist du dir da sicher?

Wenn du in Delphi ein neues Projekt beginnst werden ja standardmäßig in der uses-Klausel einige Units eingebunden unter anderem "windows" VOR "graphics" und eben in diesen beiden Units wird ein Typ namens TBitmap deklariert. Im weiteren Programmierverlauf wird aber immer die, in den meisten Fällen, richtige TBitmap aus graphics verwendet.

[mschaefer]

Moin, moin

Soweit ich das mit meinen Projekten beobachtet habe
werden zunächst die Units aus dem aktuellen Projekt genommen, dann die Units aus den Biblitheken .

Viele Grüße // Martin


PS: Wenn ich "tricky" programmieren will nehme ich C, Perl oder SAS-Macros.
Einigermassen übersichtlich, Kommentare und eine aufgeräumte Unit- und Objektstruktur sind mir inzwischen viel näher.

PPS: Natürlich kann man auch in Delphi Tricky programmieren. Gerade mit Pointern kann man da schöne Optimierungen machen und in der Listenprogrammierung kommt man oft nicht ohne aus. Für die meisten Aufgaben schätze ich das aber weniger. Im Team ist es oft wichtiger, dass alle schnell vertsehen welche Abläufe stattfinden damit Programmieren nicht zm Selbstzweck und zur Beschäftigungstherapie des Kollegen wird.

(Da es nicht das Threatthema ist, sind es nur Postscriptum-Anmerkungen)

[s-off]

Zitat:

Zitat von mschaefer

PS: Wenn ich "tricky" programmieren will nehme ich C, Perl oder SAS-Macros. Einigermassen übersichtlich, Kommentare und eine aufgeräumte Unit- und Objektstruktur sind mir inzwischen viel näher.

Willst Du damit ausdrücken, dass es mit Delphi nicht möglich ist, 'tricky' zu programmieren?

[Amateurprofi]

Zitat:

Zitat von WS1976

Hi alle,

mein Vorgänger ist oder war (ich weiss nicht ob er noch, als Programmierer, existiert) ein professioneller Programmierer. Die Source wurde in einer externen Softwareschmiede 1998 erstellt. Bei Ihm und seiner Beurteilung bin ich jedenfalls sehr vorsichtig da er sehr tricky programmiert hat und meist irgendein (hinterlistiger) Sinn darin steckt.

Hallo Amateurprofi:
nochmal, dass das ganz klar ist:
bei den Mehrfachdeklaration wird nicht die erste oder die letzte genommen, sondern die sind gleichberechtigt nebeneinander vorhanden. Sogar die Unit-Reihenfolge in der uses Klausel der zugreifenden Unit ( ihr wisst was ich meine ) spielt keine Rolle.
Welche der Compiler wo wann nimmt ist scheinbar purer Zufall.Eine zweite Sache ist noch der Debugger, der macht nochmal was er will.

Ich jedenfalls werde mich des Mapfiles bedienen!

Grüsse
Rainer

Das, was ich jetzt gern schreiben würde, schreibe ich aus Gründen der Höflichkeit nicht.
Glaubst du denn ernsthaft, daß der Compiler quasi per Zufallsgenerator arbeitet ??
Ich glaube das nicht und (daß auch das ganz klar ist), die Verfasser der Delphi-Helpfiles glauben das offensichtlich auch nicht.

Zitat:

Mehrere und indirekte Unit-Referenzen

Die Reihenfolge der Units in der uses-Klausel bestimmt die Reihenfolge der Initialisierung dieser Units und wirkt sich auf die Suche des Compilers nach den Bezeichnern aus. Wenn zwei Units eine Variable, eine Konstante, einen Typ, eine Prozedur oder eine Funktion mit identischem Namen deklarieren, verwendet der Compiler die Deklaration der in der uses-Klausel zuletzt angegebenen Unit. Wollen Sie auf den Bezeichner in einer anderen Unit zugreifen, müssen Sie den vollständigen Bezeichnernamen angeben: Unitname.Bezeichner

[WS1976]

Hi Amateuerprofi,

Zitat:

Das, was ich jetzt gern schreiben würde, schreibe ich aus Gründen der Höflichkeit nicht.

Dieser Kommentar ist absolut überflüssig.

Zitat:

Glaubst du denn ernsthaft, daß der Compiler quasi per Zufallsgenerator arbeitet ??

Ich hab dás so nie behauptet und auch so nicht dargestellt.
Vielleicht solltest du, bevor du Kommentare abgibst, meinen Originalbeitrag lesen.
Ich habe mehr als 100 Units in denen die Reihenfolge der Uniteinträge beliebig ist. In
mehreren sind die gleichen Variablennamen (Unitglobal) definiert.

Tatsache ist:
Es ist völlig egal wo im Programm ich debugge ( hab mir die Variablen auch schon per label angeschaut, gleiches Ergebnis ), ich bekomme mal die richtigen und mal die falsche Variable angezeigt und das ist völlig wilkürlich.

Grüsse
Rainer

PS:

[Amateurprofi]

Zitat:

Zitat von WS1976

Hi Amateuerprofi,

Zitat:

Das, was ich jetzt gern schreiben würde, schreibe ich aus Gründen der Höflichkeit nicht.

Dieser Kommentar ist absolut überflüssig.

Zitat:

Glaubst du denn ernsthaft, daß der Compiler quasi per Zufallsgenerator arbeitet ??

Ich hab dás so nie behauptet und auch so nicht dargestellt.Vielleicht solltest du, bevor du Kommentare abgibst, meinen Originalbeitrag lesen.
Ich habe mehr als 100 Units in denen die Reihenfolge der Uniteinträge beliebig ist. In
mehreren sind die gleichen Variablennamen (Unitglobal) definiert.

Tatsache ist:
Es ist völlig egal wo im Programm ich debugge ( hab mir die Variablen auch schon per label angeschaut, gleiches Ergebnis ), ich bekomme mal die richtigen und mal die falsche Variable angezeigt und das ist völlig wilkürlich.

Grüsse
Rainer

PS:

@ws1976

Wenn du das so nie behauptet hast, wie soll denn der Satz "Welche der Compiler wo wann nimmt ist scheinbar purer Zufall." sonst zu verstehen sein.
Es war auch nicht gefragt, was der Debugger anzeigt, sondern wie der Compiler den Source-Code umsetzt.
Und der Compiler benutzt weder die Deklarationen der zuerst genannten Unit noch überläßt er es dem Zufall, welche Deklarationen er verwendet sondern er benutzt immer die Deklarationen der zuletzt genannten Unit.
Vielleicht solltest du, bevor du Kommentare abgibst, deinen Originalbeitrag lesen......

[WS1976]

Hallo Amateurprofi,

Selbstverständlich bezieht die Problemstellung den Debugger mit ein.
Die Problemstellung war übrigens nicht der Compiler und was der eventuell für einen Mist verzapft, sondern ich fragte nach einem Tool mit dem ich solche Doppeldeklarationen finden kann.

Grüsse
Rainer

[Amateurprofi]

Zitat:

Selbstverständlich bezieht die Problemstellung den Debugger mit ein.
Die Problemstellung war übrigens nicht der Compiler und was der eventuell für einen Mist verzapft, sondern ich fragte nach einem Tool mit dem ich solche Doppeldeklarationen finden kann.

Ja, das ist wohl so; nur bezog ich mich nicht auf den ursprünglichen Beitrag, sondern ausdrücklich auf deine Behauptung "Welche der Compiler wo wann nimmt ist scheinbar purer Zufall." im Beitrag #24.