Problem of compiler with this double "global const" declaration?

[Imbuter2000]

Minimalist reproduction of the "problem":

Create a file "constants.au3" with only this line:

global const $foobar = "apple"

 

Then create this script and launch it:

Func test()
 #include <constants.au3>
EndFunc
#include <constants.au3>

msgbox(0,"",$foobar)

You'll get (only) this error:

"F:\test\test.au3" (6) : ==> Variable used without being declared.:
msgbox(0,"",$foobar)
msgbox(0,"",^ ERROR

 

Why? Why does it not find $foorbar declared?

I suppose that the reason is that there's a previous and hidden(?) error of "$foobar previously declared as a 'Const'" like happens if you substitute the first #include with its actual content but...  I believe that keeping this previous error hidden is dangerous and could be very difficult to spot in complex scripts.

Why not expliciting it?

Edited January 22, 2015 by Melba23
Removed "bug" from title - it is not

[MikahS]

What is the point of putting the include in your script twice? You only need it once, and you aren't even running the reproducer function anyway in that script.

Another problem, is that you are naming your const file constants.au3 when there is already a constants.au3 in the include with AutoIt, you'll need to rename it to something like MyConstants.au3

this works fine for me:

MyConstants.au3

global const $foobar = "apple"

test.au3

#include <MyConstants.au3>
 
MsgBox(0, "", $foobar)

Hope that clears it up.

Edited January 16, 2015 by MikahS

[guinness]

That's not a bug, just misunderstanding from you, as using <> checks the include folder, whereas "" checks the script directory. So I would follow what MikahS said and perhaps use "" when not an AutoIt include.

Please don't throw the b word around, as it ends up being the user's fault in the end.

[jdelaney]

Probably want to throw one of these in the constants.au3, also:

#include-once

[guinness]

It has always confused me as to why you would want to include an include file maybe more than once. Isn't #include-once sort of implied anyway?

[Imbuter2000]

Sorry for the path and naming errors, the actual real case doesn't have these errors while it has the problem.

I need(?) to keep the include twice because one include (the one I really need) is in the working script while the other (the disturbing one) is in an unneded function of an included my_universal_functions_library.au3.

I need to keep the #include <my_universal_functions_library.au3> because I need some other functions of it...

[mrider]

More than anything else, jdelaney's response is what you want.  You found a side effect of includes, not necessarily a "bug".  If you look at C code you'll find that (well written) headers include wrappers around their functions such that they are only included once.  The nature of your question is such that people answering are going to disagree with the layout of your replicator script, regardless of the merits of the question. I've experienced this exact phenomenon myself.

A more realistic scenario is where you have an .au3 that has utility functions and constants such that it is useful in many places.  You write a library for yourself, and so you include that file in the library.  Now you write a program that both includes the utility functions file and the library.  You have to use #include-once in such a scenario in both your utility functions .au3 and your library, otherwise you will see the exact error you are seeing.

E.g.:

; ... foo.au3
Global Const $my_const = "const"
...

; ... library.au3
#include "foo.au3"
...


; ... program.au3
#include "foo.au3"
#include "library.au3"
...

[EDIT] In your case, the following would solve this nicely:

; ... foo.au3
#include-once
Global Const $my_const = "const"
...

; ... library.au3
#include-once
#include "foo.au3"
...


; ... program.au3
#include "foo.au3"
#include "library.au3"
...

Edited January 16, 2015 by mrider

[JohnOne]

Bug? No.

Poor coding? Yes.

The End.

[jdelaney]

I like all my scripts to be executable, even the included scripts, so I can have several cross-referenced includes.

That way, everything that is dependent on something else will always function when included, without having to setup 20 includes on your driving script.

[mrider]

@jdelaney: Agreed.  Not to mention that I like all my library scripts to be written such that I can get a clean syntax check without running the main script.  That way I have a quick sanity check when I make changes.

[Jos]

Sorry for the path and naming errors, the actual real case doesn't have these errors while it has the problem.

I need(?) to keep the include twice because one include (the one I really need) is in the working script while the other (the disturbing one) is in an unneded function of an included my_universal_functions_library.au3.

I need to keep the #include <my_universal_functions_library.au3> because I need some other functions of it...

Post an example that shows your problem as the previous posted code understandably goes wrong.

Jos

[czardas]

Can't you just rename the variable?

Global Const $foobar_NOT_THE_ONE_IN_my_universal_functions_library

[SmOke_N]

It has always confused me as to why you would want to include an include file maybe more than once. Isn't #include-once sort of implied anyway?

Multiple #includes use the same #include file within their functions.  #include-once then becomes necessary.

Edit:

eg.

MyInclude.au3

Global Const $foo = "bar"

MySecondInclude.au3

#include <MyInclude.au3>
 
Func somefunc()
    ConsoleWrite($foo & @CRLF)
EndFunc

MyScript.au3

#include <MyInclude.au3>
#include <Array.au3>
#include <MySecondInclude.au3>
 
somefunc()
 
MsgBox(64 + 262144, "Info", $foo)

The above should error unless I put #include-once at the top of them... Although it didn't.

Rather than having to go through every include to see what they are including, #include-once makes it simple.

Edited January 16, 2015 by SmOke_N

[guinness]

Multiple #includes use the same #include file within their functions.  #include-once then becomes necessary.

But I am talking about compilation in regards to all the includes being merged into one single script. Why would there be a need to have multiple copies of the same include added to the main script file? Surely #include-once should be enabled by default when compiling, without having to be explicitly declared in each file.

Maybe I missing the point, perhaps I am overlooking something.

Edit: Spelling.

Edited January 16, 2015 by guinness

[SmOke_N]

But I am talking about compilation in regards to all the includes being merged into one single script. Why would there be a need to have multiple copies of the same include added to the main script file? Surely #include-once should be enabled by default when compiling, without having to be explicitly declare in each file.

Maybe I missing the point, perhaps I am overlooking something.

I misunderstood, and I agree, maybe that's changed because the above didn't fail for me like it would have before?

[guinness]

I tested early and this was the compilation output...

; 1.au3
Global Const $PI = 3.14

; 2.au3.
#include "1.au3"

Global Const $YEAR = 2015

; Example.au3
#include "1.au3"
#include "2.au3"

; When the Example.au3 is compiled, the main script is basically ...

; Merged script.
Global Const $PI = 3.14
Global Const $PI = 3.14
Global Const $YEAR = 2015

I used Au3Stripper to confirm that the merged script looked similar, as Jos based it on Jon's implementation.

Surely it just makes sense that if the include path has already been included once, don't include again? Regardless of whether #include-once is present.

Suffice to say if I add #include-once to both 1.au3 and 2.au3, then there is no duplication of the $PI constant.

[Melba23]

guinness,

 

Surely #include-once should be enabled by default when compiling, without having to be explicitly declared in each file

I disagree. I have come across people who (mis)use the #include directive to add repetitive boilerplate code sections to their scripts - not something I would encourage (use a function instead) but perfectly legal. So I would leave things as they are.

M23

[Imbuter2000]

I read all your messages and still believe that there is something wrong either in my code or in compiler output:

; test1.au3:
#include <F:\AutoIt\myscripts\my_big_library_of_functions.au3>
#include <WindowsConstants.au3>
msgbox(0,"",$WC_ANIMATE)

; F:\AutoIt\myscripts\my_big_library_of_functions.au3:
; [omissis...]
func one_of_many_functions()
     #include <WindowsConstants.au3>
     ; [omissis...]
EndFunc
; [omissis...]

; WindowsCostants.au3  (originally included in AutoIT):
#include-once
; [omissis...]
; Window Classes
Global Const $WC_ANIMATE = 'SysAnimate32'
; [omissis...]

Compiler execution output:
"F:\AutoIt\myscripts\test1.au3" (4) : ==> Variable used without being declared.:
msgbox(0,"",$WC_ANIMATE)
msgbox(0,"",^ ERROR
->15:06:07 AutoIt3.exe ended.rc:1

The function one_of_many_functions() is not needed in this specific script, it's a function that I use from some other scripts. I would not want to modify it.

An interesting fact is that if in my_big_library_of_functions.au3 I put the #include before/outside the function, all works perfectly, so the problem seems connected to that #include being inside the function.

Is there something wrong or something that I should be aware of in putting #include inside a function?

Edited January 21, 2015 by Imbuter2000

[BrewManNH]

Never put an include line inside a function.

Include lines are always acted on by the compiler, there's no such thing as a conditional include.

Includes are placed into the main script at the point the #include line is in your script, so you just included the file into the middle of your function one_of_many_functions.

[SmOke_N]

Your scripts are read from top to bottom.

The includes are inserted the same way (from top to bottom where they are inserted in your code).

So, you're essentially doing:

ConsoleWrite($sString & @CRLF)
Global $sString = "Apple"

 

1.  Without running that code, what do you expect to happen?

2.  Run the code, you should get an exception, there's no way for ConsoleWrite to know what value $sString has, because it hasn't been assigned yet

That's the issue you're running into by putting your includes in functions.

Please understand, that upon compiling of your script, that it doesn't matter at all if your #includes are in functions, all of the include data is inserted into that function.

So you also run into the issue of having nested "functions" which would cause an issue.

Run this by itself:

Func _myIncludeFuncError()
    #include <Array.au3>
    ConsoleWrite("Apple" & @CRLF)
EndFunc

 

You'll error out because of funcs inside of funcs.

The only 2 ways I could see your code ever working is:

1.  If you only had variables inside the #include/include function, and you empty declared them outside the function before any code that required the variable, then called the function to set the globals.

2.  You had #include-once at the top of your #include, and had already declared the #include before.