Bug? Can someone verify this?

[kpeters58]

Given the declaration

Code: Select all

 Declare.i DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = 0, Fatal.i = #False)

and the definition

Code: Select all

  Procedure DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = 0, Fatal.i = #False)
  ; ....
  EndProcedure

works very well.

If I replace the 'LineNr = 0' instances with 'LineNr = #PB_Compiler_Line', I get 'Declare doesn't match with real Procedure' which seems like a bug to me. Can anyone confirm or clear this up?

[Demivec]

If I replace the 'LineNr = 0' instances with 'LineNr = #PB_Compiler_Line', I get 'Declare doesn't match with real Procedure' which seems like a bug to me. Can anyone confirm or clear this up?

The constant #PB_Compiler_Line gets replaced by the number of the line in each line where it occurs. This means since the two lines you indicated are in fact on different lines, they each indicate that 'LineNr' will receive a different default value. The compiler error message is thus correct, no bug.

[Dude]

Everything after "Declare" and "Procedure" on both lines have to be literally the same.

[mk-soft]

Works only over Macro...

Code: Select all

Declare.i __DBError(Message1.s, Message2.s, ModuleName.s, ProcedureName.s, LineNr, Fatal.i)

Macro DBError(Message1, Message2 = "", ModuleName = #PB_Compiler_Module, ProcedureName = #PB_Compiler_Procedure, LineNr = #PB_Compiler_Line, Fatal = #False)
  __DBError(Message1, Message2, ModuleName, ProcedureName, LineNr, Fatal)
EndMacro
  
Procedure foo()
  DBError("Info")
EndProcedure

foo()
End

Procedure __DBError(Message1.s, Message2.s, ModuleName.s, ProcedureName.s, LineNr, Fatal.i)
  ; ....
  Debug "Message 1: " + Message1
  Debug "Modul: " + ModuleName
  Debug "Procedure: " + ProcedureName + "(...)"
  Debug "LineNr: " + LineNr
  ; ...
EndProcedure

[IdeasVacuum]

What if you made the code ugly with inline?

Code: Select all

Declare.i DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = #PB_Compiler_Line, Fatal.i = #False) : Procedure.i DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = #PB_Compiler_Line, Fatal.i = #False)
; ....
EndProcedure

[Demivec]

What if you made the code ugly with inline?

Code: Select all

Declare.i DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = #PB_Compiler_Line, Fatal.i = #False) : Procedure.i DBError(Message1.s, Message2.s = "", ModuleName.s = #PB_Compiler_Module, ProcedureName.s = #PB_Compiler_Procedure, LineNr = #PB_Compiler_Line, Fatal.i = #False)
; ....
EndProcedure

@IdeasVacuum: If it is written as you suggest you don't need the 'Declare' portion at all.

@kpeters58: Why do you use the compiler constants in the procedure's parameter list?

If you are wanting those values to indicate where each invocation of DBError() occurs it will not function as you intend it to do so. This is necause those values used as defaults in the parameter list are substtuted at compile time. What you would want to do is use those compiler constants in each invocation of DBError(). Still, another option is to use it in both places.

[mk-soft]

Simple example

Code: Select all

Procedure DBError(Message.s, ProcedureName.s = #PB_Compiler_Procedure)
  Debug Message
  Debug "Procedure: " + ProcedureName + "(...)"
EndProcedure

Procedure __DBError(Message.s, ProcedureName.s)
  Debug Message
  Debug "Procedure: " + ProcedureName + "(...)"
EndProcedure

Macro DBErrorMacro(Message, ProcedureName = #PB_Compiler_Procedure)
  __DBError(Message, ProcedureName)
EndMacro

Procedure foo()
  DBError("Not Work")
  DBErrorMacro("Over macro is working")
  ; Macro is replaced with '__DBError("Over macro is working", #PB_Compiler_Procedure). Now we have the right ProcedureName
EndProcedure

foo()

[#NULL]

This could be considered a feature request. In the D programming language (and maybe others too) that's exactly how it works. If you use __LINE__ etc. as default arguments of a function they will be evaluated at the call (or better 'instantiation' because D has templates). It might seem 'incorrect' but that's usually just what you want to do, the 'correct' way is of no use.