Page 1 of 1
Double-defining a variable
Posted: Fri Apr 08, 2022 4:48 am
by jacdelad
Hello,
why is it possible to double-define a variable:
Code: Select all
Global testvariable
Global testvariable
Isn't that counterproductive?
BTW, the second "Global" is ignored, so
Code: Select all
Global testvariable=1
Global testvariable
Debug testvariable
...outputs "1".
Re: Double-defining a variable
Posted: Fri Apr 08, 2022 10:16 am
by Axolotl
this is probably due to the fact that the compiler recognizes the same names as errors only with different data types.
At least that's my observation.
BTW similar behavior with constants:
Code: Select all
Global testvariable=1
Global testvariable
Global testvariable.l ; <== compiler error .. different type
Debug testvariable
#TestConst = 1
#TestConst = 1
#TestConst = 2 ; <== compiler error .. different value
Re: Double-defining a variable
Posted: Fri Apr 08, 2022 6:08 pm
by Captn. Jinguji
With globals,there is some use for this behaviour, in order to remind you inside a procedure that a variable has global scope.
But in long procedures, even the Global definition (usually at the procedure's start ) is a daunting "solution".
(Personally, I prefer a "g_"... prefix for my global variable names )
Re: Double-defining a variable
Posted: Sat Apr 09, 2022 2:35 pm
by #NULL
Redeclaration is not consistent across the different keywords and situations.
Some notes that I already posted somewhere:
"Redeclaration errors are not very consitent":
Should Define be allowed for procedure parameters?
Code: Select all
; Global does not complain about redeclaration as long as the type does not change. That includes
; the case where the second declaration does not use any type and intends to use the default type
; Define does not complain about redeclaration but gives error for different implicit type
; Protected does not allow redeclaration at all
Similar topic:
Protected 'already declared'
My notes about the quirks of the different declaration keywords (including redeclarations)
from german thread:
Code: Select all
EnableExplicit
Debug "----------------------------- 1:"
; protected can shadow global
Global d1
Procedure p1()
Protected d1
d1 + 1
Debug d1
EndProcedure
p1() ; 1
P1() ; 1
Debug d1 ; 0
Debug "----------------------------- 2:"
; static can shadow global
Global d2
Procedure p2()
Static d2
d2 + 1
Debug d2
EndProcedure
p2() ; 1
P2() ; 2
Debug d1 ; 0
Debug "----------------------------- 3:"
; define cannot shadow global
; Global d3
;
; Procedure p3()
; Define d3 ; error: Variable already declared with a different scope
; d3 + 1
; Debug d3
; EndProcedure
;
; Define d3 ; error: Variable already declared with a different scope
Debug "----------------------------- 4:"
; procedure-local define does not conflict with main-local define and behaves like protected
Define d4
Procedure p4()
Define d4
d4 + 1
Debug d4
EndProcedure
p4() ; 1
P4() ; 1
Debug d4 ; 0
Debug "----------------------------- 5:"
; access to globals is implizit in procedures, even with EnableExplicit
Global d5
Procedure p5()
d5 + 1
Debug d5
EndProcedure
p5() ; 1
P5() ; 2
Debug d5 ; 2
Debug "----------------------------- 6:"
; access to main-locals in procedures needs explicit Shared
Define d6
Procedure p6()
Shared d6
d6 + 1
Debug d6
EndProcedure
p6() ; 1
P6() ; 2
Debug d6 ; 2
Debug "----------------------------- 7:"
; main-locals need to be declared before procedure to be accessible
; Procedure p7()
; Shared d7 ; error: With 'EnableExplicit', variables have to be declared
; d7 + 1
; Debug d7
; EndProcedure
;
; Define d7
;
; p7()
; P7()
; Debug d7
Debug "----------------------------- 8:"
; main-globals need to be declared before procedure to be accessible
; Procedure p8()
; d8 + 1 ; error: With 'EnableExplicit', variables have to be declared
; Debug d8
; EndProcedure
;
; Global d8
;
; p8()
; P8()
; Debug d8
Debug "----------------------------- 9:"
; Global in procedure creates main-global
Procedure p9()
Global d9
d9 + 1
Debug d9
EndProcedure
Procedure p99()
Debug d9
EndProcedure
p9() ; 1
P9() ; 2
Debug d9 ; 2
p99() ; 2
Debug "----------------------------- 10:"
; Shared does not care if already global
Global d10
Procedure p10()
Shared d10 ; ok
d10 + 1
Debug d10
EndProcedure
p10() ; 1
P10() ; 2
Debug d10 ; 2
Debug "----------------------------- 11:"
; you cannot define main-globals and main-locals together inside a procedure
Global d11_global_a ; main-global
Define d11_local_a ; main-local
Procedure declareVariables()
Global d11_global_b ; main-global
Define d11_local_b ; procedure-local
;Shared d11_local_c ; error: With 'EnableExplicit', variables have to be declared
EndProcedure
Debug "----------------------------- 12:"
; Define.<type> without variable to change the default type has been removed as of pb 5.60,
; the documentation is out-of-date (pb 5.61) but it's mentioned in the history/changelog
;Define.w ; Syntax error
;Define d12
Debug "----------------------------- 13:"
; Global does not complain about redeclaration as long as the type does not change. That includes
; the case where the second declaration does not use any type and intends to use the default type
Global g13.a = 255 ; somewhere
; ...
Global g13 ; assume integer and zero-initialization?
g13 + 1
Debug g13 ; 0
Procedure p13()
Global g13
g13 + 1
Debug g13 ; 1
EndProcedure
p13()
Debug "----------------------------- 14:"
; Define does not complain about redeclaration but gives error for different implicit type
Define d14 = 100 ; somewhere
; ...
Define d14 ; assume zero-initialization?
d14 + 1
Debug d14 ; 101
Define d14b.a
;Define d14b ; error: Variable already declared with another type
Procedure p14()
Define d14 = 200
; ...
Define d14 ; assume zero-initialization?
d14 + 1
Debug d14 ; 201
Define d14_.a = 200
;Define d14_ ; error: Variable already declared with another type
EndProcedure
p14()
Debug "----------------------------- 15:"
; Protected does not allow redeclaration at all
Procedure p15()
Protected d15
;Protected d15 ; error: Local variable already declared
EndProcedure
Debug "----------------------------- 16:"
; Threaded
; threads share variables by default (one variable instance for all threads)
Global d16_global = 100 ; main-global
Define d16_local = 200 ; main-local
d16_global + 1
d16_local + 1
Debug d16_global ; 101
Debug d16_local ; 201
Procedure p16(param)
Shared d16_local
d16_global + 1
d16_local + 1
Debug "thread: " + d16_global ; 102
Debug "thread: " + d16_local ; 202
EndProcedure
Define thread = CreateThread(@p16(), 0)
WaitThread(thread)
Debug "----------------------------- 17:"
; Threaded ..is like Global, but with separate variable instances per thread
; use Threaded instead of Global for that purpose, don't try to combine Threaded/Define/Shared etc.. in a declaration
Threaded d17_threaded_a = 100 ; initialized for each thread instance
Threaded d17_threaded_b
d17_threaded_a + 3 ; affects only main thread instance
d17_threaded_b = 500 ; affects only main thread instance
d17_threaded_b + 3 ; affects only main thread instance
Debug d17_threaded_a ; 103
Debug d17_threaded_b ; 503
Procedure p17(param)
d17_threaded_a + 1
d17_threaded_b + 1
Debug "thread: " + d17_threaded_a ; 101
Debug "thread: " + d17_threaded_b ; 1
EndProcedure
Define thread = CreateThread(@p17(), 0)
WaitThread(thread)
Re: Double-defining a variable
Posted: Tue Apr 12, 2022 9:52 pm
by jacdelad
I'm now as confused as before. Do other languages allow double declaration?
Re: Double-defining a variable
Posted: Wed Apr 13, 2022 8:50 pm
by fsw
jacdelad wrote: Tue Apr 12, 2022 9:52 pm
I'm now as confused as before. Do other languages allow double declaration?
A compiler should either not compile or compile and give a warning about it.
BTW: Go (golang) doesn’t let you having unused variables defined. They need to be deleted or commented out, before the compiler even compiles…