[PB4.5Win32]Fehler bei Compiler-Direktiven in Macros

[Mok]

Siehe hier. PB4.50 Win32

[ts-soft]

Ich gehe mal davon aus, was auch logisch wäre, Compilerdirektiven haben Vorrang vor macro,
werden also nicht transportiert. Aufteilung in mehrere macros also nicht möglich.
Damit wären dann auch die meisten Fehlermeldungen erklärt.

Aber genaues sollte wohl besser freak sagen.

[STARGÅTE]

eben,

denn eigenlich sollte ja CompilerIf darüber entscheiden welches Macro benutzt wird:

Code: Alles auswählen

CompilerIf #PB_Compiler_OS = #PB_OS_Windows
 Macro Test
  Debug "Juppi"
 EndMacro
CompilerElse
 Macro Test
  Debug "Och nöö"
 EndMacro 
CompilerEndIf
  
Test

ansonsten halt mit einem Trick arbeiten wie ich bei Macros in Macros:

Code: Alles auswählen

Macro __EndM__ 
EndM
EndMacro 
Macro __acro__ 
acro
EndMacro 
Macro FakeEndMacro
:__EndM__#__acro__
EndMacro 


Macro BuildMacro(_Macro, _MacroLine) 
  Macro _Macro 
    _MacroLine
  FakeEndMacro 
EndMacro 

BuildMacro(Add(x,y),x + y) 
BuildMacro(Sub(x,y),x - y) 

Debug Add(3,2) 
Debug Sub(3,2)

Vllt kannst du dieses Beispiel auch bei dir verwenden, indem du die CompilerIfs und EndIfs erst von Macros zusammen bauen lässt.
Sodass sie vorher nicht auftauchen.

[Thorium]

Eigentlich wäre es logischer zuerst die Makros aufzulösen und dann die Compilerdirektiven, so könnten Compilerdirektiven in Makros stehen. Ich sehe dabei keinen Nachteil. Stargates Beispiel würde genauso funktionieren, wenn man anstatt 2 Makros nur eins macht und innerhalb per Compilerdirektiven verzweigt.

[freak]

Das Verhalten ist normal und kein Bug.

Es ist ganz simpel:

• Nach einem CompilerIf was false ergibt wird alles ignoriert bis zu einem CompilerElse oder CompilerEndIf
• Damit findet auch keine Expansion von Macros statt, weil der Code ja nicht compiliert wird
• Damit wird auch das Macro in dem CompilerEndIf steht nie expandiert
• ... und damit wird der CompilerIf-Block nie beendet

Code: Alles auswählen

Macro a()
  CompilerIf 0    ; hat erst einen Einfluss wenn a() benutzt wird, nicht hier bei der Definition
EndMacro
  
Macro b()
  CompilerEndIf   ; hätte auch erst einen Einfluss wenn b() benutzt/expandiert wird, was aber nie passiert (siehe unten)
EndMacro

a()  ; wird expandiert zu "CompilerIf 0", also befinden wir uns in einem Code-Block der ignoriert werden muss

; ...

b()  ; b() wird nie expandiert, weil Code der ignoriert wird bis ein CompilerEndIf gefunden wurde

; Also enden wir hier ohne ein CompilerEndIf

> Eigentlich wäre es logischer zuerst die Makros aufzulösen und dann die Compilerdirektiven, so könnten Compilerdirektiven in Makros stehen.

Genau das trifft auch zu. Compilerdirektiven können in Macros stehen und Macroparameter als Argumente haben. Aber wenn man einen CompilerIf-Block in einem Macro anfängt muss man ihn auch dort beenden weil keine weiteren Macros expandiert werden bis der Block beendet wird. Ist eigentlich logisch.

[STARGÅTE]

jo klingt logisch.

danke für die Erklärung.

[Nino]

freak,

besten Dank für die gute Erklärung!
Ich hab' das Zusammenspiel von Makros und Compilerdirektiven jetzt zum 1. Mal verstanden.

Grüße, Nino