www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - version(debug)

reply "denizzzka" <4denizzz gmail.com> writes:
Why

version(assert){ int i = 1; } else { int k = 1; }

causes error:
Error: identifier or integer expected, not assert
?

This is bug or feature?
http://dlang.org/version.html says what it is correct code, 
because "assert" in the list of "Predefined Version Identifiers"

How I can solve this problem by other way?
Oct 06 2012
next sibling parent reply "denizzzka" <4denizzz gmail.com> writes:
huh, text should be from upper letter: Assert, Debug
Oct 06 2012
parent =?UTF-8?B?QWxleCBSw7hubmUgUGV0ZXJzZW4=?= <alex lycus.org> writes:
On 06-10-2012 20:23, Jonathan M Davis wrote:

 On Saturday, October 06, 2012 20:02:13 denizzzka wrote:

 huh, text should be from upper letter: Assert, Debug



 No. Those are wrong. The code compiles, but those versions don't exist, so
 they're not compiled in. A version(Assert) or version(Debug) block will never
 be compiled in unless you define those versions. version(assert) is correct.
 For instance, this prints "yes" without -release and "no" with -release:

 import std.stdio;

 void main()
 {
      version(assert)
      {
          writeln("yes");
      }
      else
      {
          writeln("no");
      }
 }

 I am not seeing a compilation error with your example. What version of the
 compiler are you using? Maybe version(assert) is new (I'd never heard of it
 before), and your compiler is too old.

 The only reason that you would see an error due to an invalid version
 identifier would be if it's a keyword which isn't valid as a version identifier
 (e.g. debug). The fact that the compiler doesn't know about a version
 identifier doesn't produce an error. That just means that that particular block
 of code isn't compiled in.

 And debug isn't a valid version. It's not even in the list. The correct thing
 to do is to a use a debug block. For instance, this code

 import std.stdio;

 void main()
 {
      debug
      {
          writeln("yes");
      }
      else
      {
          writeln("no");
      }
 }

 will print "yes" when you compile with -debug and "no" otherwise.

 - Jonathan M Davis



version (assert) is a very recent addition to the compiler and is not in 
2.060.

-- 
Alex Rønne Petersen
alex lycus.org
http://lycus.org
Oct 06 2012
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 10/6/12, denizzzka <4denizzz gmail.com> wrote:

 This is bug or feature?
 http://dlang.org/version.html says what it is correct code,
 because "assert" in the list of "Predefined Version Identifiers"



I think that must be a typo on the website. Use version(debug) instead.
Oct 06 2012
prev sibling next sibling parent "denizzzka" <4denizzz gmail.com> writes:
Strange, when you write to the forum then you solve problem 
immediately by yourself :-)

Thx for fast answers!
Oct 06 2012
prev sibling next sibling parent "denizzzka" <4denizzz gmail.com> writes:
On Saturday, 6 October 2012 at 18:15:49 UTC, Andrej Mitrovic
wrote:

 On 10/6/12, denizzzka <4denizzz gmail.com> wrote:

 This is bug or feature?
 http://dlang.org/version.html says what it is correct code,
 because "assert" in the list of "Predefined Version 
 Identifiers"



 I think that must be a typo on the website. Use version(debug) 
 instead.



No, debug also don't works. Debug and Assert works fine
Oct 06 2012
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 10/6/12, denizzzka <4denizzz gmail.com> wrote:

 No, debug also don't works. Debug and Assert works fine



Oh right, I was thinking of this:
debug
{
    // blabla
}

I don't even know why there is a version(Debug) when you can use a debug block.
Oct 06 2012
prev sibling next sibling parent Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
On 10/6/12, denizzzka <4denizzz gmail.com> wrote:

 Strange, when you write to the forum then you solve problem
 immediately by yourself :-)



That happens to me all the time too. :)
Oct 06 2012
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Saturday, October 06, 2012 20:02:13 denizzzka wrote:

 huh, text should be from upper letter: Assert, Debug



No. Those are wrong. The code compiles, but those versions don't exist, so 
they're not compiled in. A version(Assert) or version(Debug) block will never 
be compiled in unless you define those versions. version(assert) is correct. 
For instance, this prints "yes" without -release and "no" with -release:

import std.stdio;

void main()
{
    version(assert)
    {
        writeln("yes");
    }
    else
    {
        writeln("no");
    }
}

I am not seeing a compilation error with your example. What version of the 
compiler are you using? Maybe version(assert) is new (I'd never heard of it 
before), and your compiler is too old.

The only reason that you would see an error due to an invalid version 
identifier would be if it's a keyword which isn't valid as a version identifier 
(e.g. debug). The fact that the compiler doesn't know about a version 
identifier doesn't produce an error. That just means that that particular block 
of code isn't compiled in.

And debug isn't a valid version. It's not even in the list. The correct thing 
to do is to a use a debug block. For instance, this code

import std.stdio;

void main()
{
    debug
    {
        writeln("yes");
    }
    else
    {
        writeln("no");
    }
}

will print "yes" when you compile with -debug and "no" otherwise.

- Jonathan M Davis
Oct 06 2012
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Saturday, October 06, 2012 20:21:52 Andrej Mitrovic wrote:

 I don't even know why there is a version(Debug) when you can use a debug
 block.



There isn't. It's just that it compiles because Debug isn't a keyword. The 
code within a version(Debug) block won't be compiled in unless you define such 
a version yourself.

- Jonathan M Davis
Oct 06 2012
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Saturday, October 06, 2012 20:42:01 Alex R=C3=B8nne Petersen wrote:

 version (assert) is a very recent addition to the compiler and is not=




 2.060.



Which would probably explain why it's not working for him, since presum=
ably,=20
he's not building the compiler himself, but then it really shouldn't be=
 up on=20
the website yet.

- Jonathan M Davis
Oct 06 2012
prev sibling next sibling parent "denizzzka" <4denizzz gmail.com> writes:
On Saturday, 6 October 2012 at 19:16:26 UTC, Jonathan M Davis 
wrote:

 On Saturday, October 06, 2012 20:42:01 Alex Rønne Petersen 
 wrote:

 version (assert) is a very recent addition to the compiler and 
 is not in
 2.060.



 Which would probably explain why it's not working for him, 
 since presumably,
 he's not building the compiler himself, but then it really 
 shouldn't be up on
 the website yet.

 - Jonathan M Davis



I am on dmd 2.060

debug {} else {} was not obvious for me - I thought that debug is 
a kind of qualifer.
Oct 06 2012
prev sibling next sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Saturday, October 06, 2012 23:49:23 denizzzka wrote:

 I am on dmd 2.060
 
 debug {} else {} was not obvious for me - I thought that debug is
 a kind of qualifer.



I wouldn't expect you to try either version(debug) or debug {} without seeing 
them in the docs or in TDPL. I suppose that I can see why you would try 
version(debug), but it's not listed in the docs.

There isn't really a debug version of anything in D. What debug {} does is 
it's compiled in when -debug is compiled in, and that can be used in 
conjunction with -release if you want to. So talking about debug vs release in 
D is likely to get very confusing. Rather -debug enables debug blocks which 
are intended for inserting debug code, _not_ code which is meant for non-
release builds.

It looks like version(assert) (which I guess is only in the github version 
right now) will effectively correspond to not having -release, but if there's 
ever a compiler flag which specifically enables or disables assertions instead 
of -release (which does more than just disable assertions - e.g. it disables 
bounds checking in non- safe code), then it won't actually be guaranteed to 
not be there if -release isn't there. It's close enough though I guess, 
particularly when the type of stuff that you specifically do in non-release
code 
is typically the kind of stuff that you want done with assertions are enabled 
and probably wouldn't want enable if assertions were turned off, even if that 
were to somehow happen without -release.

In any case, -debug and debug{} should be explained in the docs somewhere. 
It's certainly not the sort of thing that I would expect you to magically 
know.

- Jonathan M Davis
Oct 06 2012
prev sibling next sibling parent "denizzzka" <4denizzz gmail.com> writes:
On Sunday, 7 October 2012 at 01:20:49 UTC, Jonathan M Davis wrote:

 On Saturday, October 06, 2012 23:49:23 denizzzka wrote:

 I am on dmd 2.060
 
 debug {} else {} was not obvious for me - I thought that debug 
 is
 a kind of qualifer.



 I wouldn't expect you to try either version(debug) or debug {} 
 without seeing
 them in the docs or in TDPL. I suppose that I can see why you 
 would try
 version(debug), but it's not listed in the docs.

 There isn't really a debug version of anything in D. What debug 
 {} does is
 it's compiled in when -debug is compiled in, and that can be 
 used in
 conjunction with -release if you want to. So talking about 
 debug vs release in
 D is likely to get very confusing. Rather -debug enables debug 
 blocks which
 are intended for inserting debug code, _not_ code which is 
 meant for non-
 release builds.

 It looks like version(assert) (which I guess is only in the 
 github version
 right now) will effectively correspond to not having -release, 
 but if there's
 ever a compiler flag which specifically enables or disables 
 assertions instead
 of -release (which does more than just disable assertions - 
 e.g. it disables
 bounds checking in non- safe code), then it won't actually be 
 guaranteed to
 not be there if -release isn't there. It's close enough though 
 I guess,
 particularly when the type of stuff that you specifically do in 
 non-release code
 is typically the kind of stuff that you want done with 
 assertions are enabled
 and probably wouldn't want enable if assertions were turned 
 off, even if that
 were to somehow happen without -release.




I've got a situation that debug information should be placed into 
the class via the constructor. Therefore, when used -debug 
constructor has another arguments list, and its need debug {} 
else {} for ctor calling.



 In any case, -debug and debug{} should be explained in the docs 
 somewhere.
 It's certainly not the sort of thing that I would expect you to 
 magically
 know.



Yes.
Oct 07 2012
prev sibling parent Jonathan M Davis <jmdavisProg gmx.com> writes:
On Sunday, October 07, 2012 09:27:31 denizzzka wrote:

 I've got a situation that debug information should be placed into
 the class via the constructor. Therefore, when used -debug
 constructor has another arguments list, and its need debug {}
 else {} for ctor calling.



Which is fine. It's just that you need to realize that debug blocks are enabled 
with -debug and have nothing to do with whether -release is used or not, so it 
doesn't correspond with what people typically mean when they talk about debug 
mode and release mode.

- Jonathan M Davis
Oct 07 2012