Zugriff auf Main von innerhalb eines Moduls

[Nino]

Sorry, wenn ich das hier ausbuddel, aber ich habe mich gerade ähnliches gefragt ("warum kann ich im Modul nicht auf Konstanten des Hauptprogramms zugreifen?"), zumal bei WIN-Api Konstanten offenbar eine Ausnahme gemacht wird.

Ich denke nicht, dass es eine Ausnahme speziell für WinAPI Konstanten gibt.
Sondern die Regel scheint mir zu sein, dass man innerhalb eines Moduls auf alle Bezeichner zugreifen kann, deren Definition PB selbst mitbringt. Das gilt für viele WinAPI-Konstanten, aber auch für diejenigen die mit #PB_ anfangen und auch für alle in PB eingebauten Funktionen. Und das ist gut so. Abgeschottet werden sollen offenbar nur die von Dir oder mir selbst definierten Bezeichner. Ich finde das durchaus logisch.

[Kurzer]

Das ist sicherlich eine Ansichtssache und man kann vermutlich genau so wenig drüber streiten wie über verschiedene Geschmäcker.

Ich ging davon aus, dass Module von Fred ins Leben gerufen worden sind, um deren Code zu kapseln, so dass durch den Modulecode keine Seiteneffekte oder Namenskollisionen im Zusammenhang mit dem Hauptcode entstehen.
Wenn ein Modul Konstanten des Hauptcodes nutzt sehe ich diese Gefahr nicht. Aber evtl. war es für Fred leichter zu implementieren, wenn man alle Elemente des Hauptcodes ausblendet. Who knows?

Mit der doppelten Definition der Konstanten komme ich jetzt aber prima zurecht.

[NeoChris]

Da sind wir wieder beim gleichen Thema, dass das alles total logisch ist, so Meinung von Nino und GPI.
Natürlich haben alle anderen das Konzept Module einfach nicht verstanden. xD
Man sieht hier wieder ganz deutlich dass die Implementierung von Module einfach noch nicht ausgereift ist und nicht gerade durchdacht wurde...

[Nino]

Mit der doppelten Definition der Konstanten komme ich jetzt aber prima zurecht.

Du kannst auch die betr. Konstanten in eine Include-Datei schreiben, und diese Datei dann 2x "includieren": Einmal innerhalb des Moduls und einmal außerhalb. Habe ich nicht getestet, sollte aber gehen.

[Nino]

Da sind wir wieder beim gleichen Thema, dass das alles total logisch ist, so Meinung von Nino und GPI.

Wer lesen kann der wird bemerkt haben, dass ich von "alles" nie geschrieben habe. Aber manche wollen hier halt nur polemisieren.

Natürlich haben alle anderen das Konzept Module einfach nicht verstanden. xD

Und du bist der Sprecher für "alle anderen"?

[Sicro]

Mit der doppelten Definition der Konstanten komme ich jetzt aber prima zurecht.

Was hältst du davon:

Code: Alles auswählen

DeclareModule Test
  Macro OptionsMacro
    Enumeration Options
      #Option_1
      #Option_2
      #Option_3
    EndEnumeration
  EndMacro
EndDeclareModule

Module Test
  OptionsMacro
  Debug #Option_3
EndModule

Test::OptionsMacro
Debug #Option_2

Am besten finde ich in dem Fall jedoch, wenn der Haupt-Code ebenfalls in einem Modul gekapselt ist.

[mk-soft]

Warum zwei mal deklarieren?

Code: Alles auswählen

;-TOP

DeclareModule Public
  
  Enumeration 1
    #My_Option_1
    #My_Option_2
    #My_Option_3
    #My_Option_4
  EndEnumeration
  
EndDeclareModule

Module Public
  ;
EndModule

; ----

DeclareModule MyModule
  Declare Show()
EndDeclareModule

Module MyModule
  
  UseModule Public
  
  Procedure Show()
    Debug #PB_Compiler_Module + " / Option 1 = " + #My_Option_1
    Debug #PB_Compiler_Module + " / Option 2 = " + #My_Option_2
    Debug #PB_Compiler_Module + " / Option 3 = " + #My_Option_3
    Debug #PB_Compiler_Module + " / Option 4 = " + #My_Option_4
  EndProcedure
  
EndModule

; ----

UseModule Public

Debug "Option 1 = " + #My_Option_1
Debug "Option 2 = " + #My_Option_2
Debug "Option 3 = " + #My_Option_3
Debug "Option 4 = " + #My_Option_4

Debug "----"
MyModule::Show()

[helpy]

PS: Ich löse das jetzt damit, dass ich die betreffenden Konstanten zweimal deklariere. Innerhalb und außerhalb des Moduls.

Ja, anders geht es auch nicht.

Ihr wisst schon, dass das doch auch anders geht

Alle Konstanten, die für andere Module verfügbar sein sollen in einem eigenen Modul deklarieren:

Code: Alles auswählen

DeclareModule CONSTANTS
	Enumeration
		#GG_DATAMODE_INTEGER
		#GG_DATAMODE_FLOAT
	EndEnumeration
EndDeclareModule
Module CONSTANTS : EndModule

Diese Konstanten können dann in anderen Modulen dann auch wiederverwendet werden, entweder mit UseModule oder mit dem Modul-Präfix:

Code: Alles auswählen

DeclareModule TEST1
	UseModule CONSTANTS
	Declare Test()
EndDeclareModule
Module TEST1
	Procedure Test()
		Debug #GG_DATAMODE_INTEGER
		Debug #GG_DATAMODE_FLOAT
	EndProcedure
EndModule

DeclareModule TEST2
	Declare Test()
EndDeclareModule
Module TEST2
	Procedure Test()
		Debug CONSTANTS::#GG_DATAMODE_INTEGER
		Debug CONSTANTS::#GG_DATAMODE_FLOAT
	EndProcedure
EndModule

Ich schreibe grundsätzlich keinen Code mehr im globalen Scope und verwende für die Hauptanwendung "Module Application..."

Code: Alles auswählen

DeclareModule Application
	EnableExplicit
EndDeclareModule
Module Application
	Procedure MAIN()
		TEST1::Test()
		TEST2::Test()
	EndProcedure
	End MAIN()
EndModule

[Kurzer]

Ich deklariere die Konstanten in meiner ModuleDatei zweimal (einmal außerhalb und einmal innerhalb des Modulscopes), weil ich...

... bei Nutzung des Moduls ohne UseModule einfach...

GraphGadget::Draw(*GHnd, #GG_DATAMODE_INTEGER) schreiben kann und nicht die umständliche Variante
GraphGadget::Draw(*GHnd, GraphGadget::#GG_DATAMODE_INTEGER), wenn ich die beiden Konstanten innerhalb des Moduls deklarieren würde.

Es ging in dem Fall darum die Konstanten ohne vorheriges UseModule() bei Verwendung der expliziten Adressierung des Moduls (ModuleName::) mit dem reinen Konstantennamen verwenden zu können.

Aber trotzdem gut hier so viel andere Vorschläge versammelt zu sehen. Danke.

[mhs]

Ich deklariere die Konstanten in meiner ModuleDatei zweimal (einmal außerhalb und einmal innerhalb des Modulscopes), weil ich...

... bei Nutzung des Moduls ohne UseModule einfach...

GraphGadget::Draw(*GHnd, #GG_DATAMODE_INTEGER) schreiben kann und nicht die umständliche Variante
GraphGadget::Draw(*GHnd, GraphGadget::#GG_DATAMODE_INTEGER), wenn ich die beiden Konstanten innerhalb des Moduls deklarieren würde.

Es ging in dem Fall darum die Konstanten ohne vorheriges UseModule() bei Verwendung der expliziten Adressierung des Moduls (ModuleName::) mit dem reinen Konstantennamen verwenden zu können.

Aber trotzdem gut hier so viel andere Vorschläge versammelt zu sehen. Danke.

Allerdings immer mit der Gefahr, dass du irgendwo einen Fehler machst und die gleiche Konstante mit zwei unterschiedlichen Werten belegst.

Das kann so ziemlich der Worst-Case sein, da solche Fehler oft während der Entwicklung nicht sofort auffallen und erst nach Wochen, Monaten oder gar Jahren zum Vorschein kommen und man dann erkennen muss, dass alle bisherigen Berechnungen, Datensätze, o.ä. falsch sind.

PB kapselt die Konstanten des Main Scopes ebenfalls, da es auch hier zu Überschneidungen kommen könnte. Das ist eigentlich sogar ziemlich gut durchdacht. Gehe davon aus, dass aus irgendwelchen Gründen im Main Scope bereits #GG_DATAMODE_INTEGER deklariert ist, was passiert dann innerhalb des Moduls, wenn die gleiche Konstante nochmal deklariert wird? Das ist in dem Fall zwar unwahrscheinlich, die Konstante könnte aber auch einfach #ALL, #NONE, etc heißen. Ich persönlich arbeite immer mit dem Modulscope ohne zusätzliche Abkürzungen, z.B. GraphGadget::#DATAMODE_INTEGER und habe immer ein "Main" Modul. So bin ich es auch aus anderen Programmiersprachen gewohnt.

Vielleicht solltest du nochmal den Vorschlag von Sicro mit dem Macro anschauen. Den finde ich für deine Vorgehensweise recht sinnig, da du weiterhin die Konstanten zweimal deklariert hast, aber nur einmal im Code pfllegen musst und dadurch etwaige Fehler vermeidest:

Code: Alles auswählen

; Modul Datei
; -----------
DeclareModule Test

  Macro OptionsMacro
    Enumeration Options
      #Option_1
      #Option_2
      #Option_3
    EndEnumeration
  EndMacro
  
  OptionsMacro
  
EndDeclareModule

Module Test  
  Debug #Option_3
EndModule

Test::OptionsMacro
; -----------


; Main Datei
; ----------
; Include Modul Datei
Debug #Option_2
; ----------