www.digitalmars.com         C & C++   DMDScript  

D - nested comments?

reply "Pavel Minayev" <evilone omen.ru> writes:
Are nested multiline /* */ comments allowed in D?
Jan 01 2002
parent reply "Walter" <walter digitalmars.com> writes:
no. Use the version statement to block out sections.

"Pavel Minayev" <evilone omen.ru> wrote in message
news:a0t1rg$kjn$1 digitaldaemon.com...

 Are nested multiline /* */ comments allowed in D?
Jan 01 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Walter" <walter digitalmars.com> wrote in message
news:a0tbj5$ptm$1 digitaldaemon.com...


 no. Use the version statement to block out sections.


Unfortunately, version cannot comment out blocks with bad syntax -
which is needed sometimes. For example, I occasionally start
writing something, then decide to try another idea, but comment
the unfinished block out rather than deleting it in case I'll
revert back to it later... and such a block may have improper
syntax (like "if(a == ").
Jan 01 2002
next sibling parent reply "Walter" <walter digitalmars.com> writes:
I've been considering making version more tolerant of bad syntax, but it is
going to have to count { and } !

"Pavel Minayev" <evilone omen.ru> wrote in message
news:a0th24$svc$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tbj5$ptm$1 digitaldaemon.com...


 no. Use the version statement to block out sections.


 Unfortunately, version cannot comment out blocks with bad syntax -
 which is needed sometimes. For example, I occasionally start
 writing something, then decide to try another idea, but comment
 the unfinished block out rather than deleting it in case I'll
 revert back to it later... and such a block may have improper
 syntax (like "if(a == ").
Jan 01 2002
next sibling parent "Sean L. Palmer" <spalmer iname.com> writes:
That's perfect.  Surely we can make the brackets nest correctly.

Sean

"Walter" <walter digitalmars.com> wrote in message
news:a0tv8q$15rd$1 digitaldaemon.com...

 I've been considering making version more tolerant of bad syntax, but it


is

 going to have to count { and } !

 "Pavel Minayev" <evilone omen.ru> wrote in message
 news:a0th24$svc$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tbj5$ptm$1 digitaldaemon.com...


 no. Use the version statement to block out sections.


 Unfortunately, version cannot comment out blocks with bad syntax -
 which is needed sometimes. For example, I occasionally start
 writing something, then decide to try another idea, but comment
 the unfinished block out rather than deleting it in case I'll
 revert back to it later... and such a block may have improper
 syntax (like "if(a == ").
Jan 02 2002
prev sibling parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Walter" <walter digitalmars.com> wrote in message
news:a0tv8q$15rd$1 digitaldaemon.com...


 I've been considering making version more tolerant of bad syntax, but it


is

 going to have to count { and } !


Still... what's wrong with nested comments? It's really funny to
see that, even though ANSI commitee didn't make them standart,
most C++ compilers around have a switch which enables them.
It's not so hard to implement, but could be a useful thing!
Jan 02 2002
next sibling parent reply "Walter" <walter digitalmars.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a0ujps$1iqj$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tv8q$15rd$1 digitaldaemon.com...


 I've been considering making version more tolerant of bad syntax, but it


 is

 going to have to count { and } !


 Still... what's wrong with nested comments? It's really funny to
 see that, even though ANSI commitee didn't make them standart,
 most C++ compilers around have a switch which enables them.
 It's not so hard to implement, but could be a useful thing!


I'd like to try using the version statement unless it really reaches a dead
end.
Jan 02 2002
parent reply "Robert W. Cunningham" <rwc_2001 yahoo.com> writes:
Walter wrote:


 "Pavel Minayev" <evilone omen.ru> wrote in message
 news:a0ujps$1iqj$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tv8q$15rd$1 digitaldaemon.com...


 I've been considering making version more tolerant of bad syntax, but it


 is

 going to have to count { and } !


 Still... what's wrong with nested comments? It's really funny to
 see that, even though ANSI commitee didn't make them standart,
 most C++ compilers around have a switch which enables them.
 It's not so hard to implement, but could be a useful thing!


 I'd like to try using the version statement unless it really reaches a dead
 end.


... And we have to resort to using a pre-processor!

BTW, I've used M4 for years to do stuff other preprocessors failed to do for
me.  I'll probably find uses for M4 with D as well.  Perhaps weeding out code
that should not be compiled is a valid use.  Otherwise, all the code you feed
in should get compiled, right?


-BobC
Jan 02 2002
parent "Pavel Minayev" <evilone omen.ru> writes:
"Robert W. Cunningham" <rwc_2001 yahoo.com> wrote in message
news:3C33BF45.187E8D57 yahoo.com...


 BTW, I've used M4 for years to do stuff other preprocessors failed to do


for

 me.  I'll probably find uses for M4 with D as well.  Perhaps weeding out


code

 that should not be compiled is a valid use.  Otherwise, all the code you


feed

 in should get compiled, right?


Nope, version and debug statements don't compile the code if the
condition is not satisfied.
Jan 03 2002
prev sibling parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a0ujps$1iqj$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tv8q$15rd$1 digitaldaemon.com...


 I've been considering making version more tolerant of bad syntax, but it


 is

 going to have to count { and } !


 Still... what's wrong with nested comments? It's really funny to
 see that, even though ANSI commitee didn't make them standart,
 most C++ compilers around have a switch which enables them.
 It's not so hard to implement, but could be a useful thing!


Yes indeed, what *is* wrong with nested comments?
It seems almost no language supports it (C/C++, Java,
Pascal, HTML, D?) but why?
Is it that difficult to implement?
Is it a feature that would easily be misused?
Is there something I am totally missing?

Personally I think one of the very big disadvantages of
all the languages mentioned above is their lack of nested
comments. It is just so easy to comment out a block of code
for debugging purposes with the /* and */ comments...I
never ever use /* and */ for normal comments, because then
I 'lose' the option to comment out blocks of code. So when
I write a function header comment, it looks like this:

// ===================================
//  Print ([in] char[] string)
//
//  DESCRIPTION:   Prints out the string argument to stdout
//  ARGUMENT:       string:  The string to print
//  RETURNS:           -
//  EXCEPTIONS:     -
// ----------------------------------------------------

Something like that...
I would rather want to use /* */ but because they can't
be nested it causes all kinds of problems, so I avoid
using them for normal comments at all.
Worse still, when I get someone elses code, who does
use /* and */ I am in trouble...

So I beg you, please make the comments nest...It would
solve a lot of problems (for me).


--
Stijn
OddesE_XYZ hotmail.com
http://www.OddesE.f2s.com
__________________________________________
Remove _XYZ from my address when replying by mail
Jan 17 2002
next sibling parent reply "Martin York" <Martin.York veritas.com> writes:
 Worse still, when I get someone elses code, who does
 use /* and */ I am in trouble...



Just use

#if 0

/* Commented out code

*/


#endif
Jan 17 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Martin York" <Martin.York veritas.com> wrote in message
news:a27ara$nbl$1 digitaldaemon.com...


 Just use

 #if 0

 /* Commented out code

 */

 #endif


D doesn't have preprocessor!

One could use the version() blocks but they require correct
code syntax inside themselves, so it's just a partial solution.
Jan 17 2002
parent reply "Martin York" <Martin.York veritas.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a27b0o$nl7$1 digitaldaemon.com...

 "Martin York" <Martin.York veritas.com> wrote in message
 news:a27ara$nbl$1 digitaldaemon.com...


 Just use

 #if 0

 /* Commented out code

 */

 #endif


 D doesn't have preprocessor!

 One could use the version() blocks but they require correct
 code syntax inside themselves, so it's just a partial solution.


Maybe this is a feature that needs to be added to languages (in general)
The ability to "comment" out sections of code for debugging purposes,
but that refuses to compile in release mode.


Just a thought.

Martin
Jan 17 2002
parent "Pavel Minayev" <evilone omen.ru> writes:
"Martin York" <Martin.York veritas.com> wrote in message
news:a27fv5$quv$1 digitaldaemon.com...


 Maybe this is a feature that needs to be added to languages (in general)
 The ability to "comment" out sections of code for debugging purposes,
 but that refuses to compile in release mode.


D has this, in form of debug() statement (RTFM!). Comments, however,
can be used for lots other purposes.

BTW an alternative to nested comments could be another, alternative,
syntax - like in Pascal where most people use { } for "normal"
comments and (* *) to comment out unneeded blocks of code. I have
no ideas how this could look though.
Jan 17 2002
prev sibling next sibling parent reply Ben Cohen <bc skygate.co.uk> writes:
On Thu, 17 Jan 2002 20:02:24 +0000, OddesE wrote:


 Yes indeed, what *is* wrong with nested comments? It seems almost no
 language supports it (C/C++, Java, Pascal, HTML, D?) but why? Is it that
 difficult to implement?
 Is it a feature that would easily be misused? Is there something I am
 totally missing?


What about a type of comment which can be nested but which forces you to
state explicitly that you are nesting?

For example, say normal comments look like this:
 /* ........ */

Nested comments could have a label at the start which has to correspond
to one at the end:

 /*1 ... /*2 .... /*4 ......  .....  4*/  ....  2*/   ....  1*/
Jan 18 2002
parent reply Russell Borogove <kaleja estarcion.com> writes:
Ben Cohen wrote:


 On Thu, 17 Jan 2002 20:02:24 +0000, OddesE wrote:
 
 

Yes indeed, what *is* wrong with nested comments? It seems almost no
language supports it (C/C++, Java, Pascal, HTML, D?) but why? Is it that
difficult to implement?
Is it a feature that would easily be misused? Is there something I am
totally missing?


 
 What about a type of comment which can be nested but which forces you to
 state explicitly that you are nesting?
 
 For example, say normal comments look like this:
  /* ........ */
 
 Nested comments could have a label at the start which has to correspond
 to one at the end:
 
  /*1 ... /*2 .... /*4 ......  .....  4*/  ....  2*/   ....  1*/
 


Sounds like more complexity to no benefit. It's not hard to
support nesting of /* */ comments in a compiler (change the
parser's are-we-in-a-comment logic to be semantically integer
instead of semantically boolean) -- I present the large number
of C compilers which have offered this as an option over the
years. Nested comments seem unlikely to create obscure errors,
because the file won't compile until you have balanced /* */.
Existing code which has /* /* */ in it should produce an error
message which could hint at the probable cause and solution.
The only downside I can see is that at some point your editor's
syntax highlighting and your compiler's rules might be at odds
as to whether comments are nestable, which would be confusing.

But then, I *never* use /* */ comments when I can use // instead.

-RB
Jan 18 2002
next sibling parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Russell Borogove" <kaleja estarcion.com> wrote in message
news:3C486312.90800 estarcion.com...


 But then, I *never* use /* */ comments when I can use // instead.


Who does? But it happens when I first comment out a 10-line
loop with /* */ (too lazy to use //s for that =)), and then
I want to comment out the entire 100-line function and
have to use #ifdef
Jan 18 2002
parent reply "Juan Carlos Arevalo Baeza" <jcab roningames.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a29q8c$2l9t$1 digitaldaemon.com...

 "Russell Borogove" <kaleja estarcion.com> wrote in message
 news:3C486312.90800 estarcion.com...


 But then, I *never* use /* */ comments when I can use // instead.


 Who does? But it happens when I first comment out a 10-line
 loop with /* */ (too lazy to use //s for that =)), and then
 I want to comment out the entire 100-line function and
 have to use #ifdef


   On the other side, personally, most of the times I comment something out,
I want to put an alternative piece of code. Thanks to the fact that C++ uses
non-nested comments, I can do the following:

---
/*
   Code 1
/*/
   Code 2
//*/
---

   Code 1 is commented out, while Code 2 is not. Then, I can add a forward
slash at the beginning of the first line to uncomment code 1 and comment
code 2. Very useful. Cannot be done with nested comments, though.

   Ideally, D could provide something like:

---
comment(1) {
case 1:
   Code 1
case 2:
   Code 2
}
---

   You'd then be able to change the number (or identifier, or whatever)
inside the comment parenthesis. This would need to have tokenizable contents
within the braces, of course, but no parsing or semantic checks (no matching
of identifiers and such) would need to be done, which makes it perfect for
commenting-out code.

Salutaciones,
                         JCAB
Jan 18 2002
next sibling parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Juan Carlos Arevalo Baeza" <jcab roningames.com> wrote in message
news:a2afk9$2ia$1 digitaldaemon.com...


    On the other side, personally, most of the times I comment something


out,

 I want to put an alternative piece of code. Thanks to the fact that C++


uses

 non-nested comments, I can do the following:

 ---
 /*
    Code 1
 /*/
    Code 2
 //*/
 ---

    Code 1 is commented out, while Code 2 is not. Then, I can add a forward
 slash at the beginning of the first line to uncomment code 1 and comment
 code 2. Very useful. Cannot be done with nested comments, though.


Never thought of it... a nice trick!
Well... looks like a draw =)
Jan 18 2002
parent "Juan Carlos Arevalo Baeza" <jcab roningames.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a2ag5i$30n$1 digitaldaemon.com...


 "Juan Carlos Arevalo Baeza" <jcab roningames.com> wrote in message
 news:a2afk9$2ia$1 digitaldaemon.com...

 ---
 /*
    Code 1
 /*/
    Code 2
 //*/
 ---


 Never thought of it... a nice trick!


   :) I couldn't believe it when I found it...


 Well... looks like a draw =)


   My point was... it needs not be. We're abusing the comment feature of the
language for a purpose for which it was not designed. Instead, the language
should provide an appropriate way to do it. Like above.

   It already does, actually: version {} Only it'd be nice to be able to
specify sub-blocks and select one for uncommenting, all in the same place.
Maybe there's a way, I haven't really played with it much.

Salutaciones,
                         JCAB
Jan 18 2002
prev sibling parent "Walter" <walter digitalmars.com> writes:
"Juan Carlos Arevalo Baeza" <jcab roningames.com> wrote in message
news:a2afk9$2ia$1 digitaldaemon.com...

    Ideally, D could provide something like:

 ---
 comment(1) {
 case 1:
    Code 1
 case 2:
    Code 2
 }
 ---

    You'd then be able to change the number (or identifier, or whatever)
 inside the comment parenthesis. This would need to have tokenizable


contents

 within the braces, of course, but no parsing or semantic checks (no


matching

 of identifiers and such) would need to be done, which makes it perfect for
 commenting-out code.


That's pretty much just what D does do with the 'version' statement.
Jan 20 2002
prev sibling parent reply "Walter" <walter digitalmars.com> writes:
"Russell Borogove" <kaleja estarcion.com> wrote in message
news:3C486312.90800 estarcion.com...

 But then, I *never* use /* */ comments when I can use // instead.


Then you're covered. Use // for normal commenting, and then /* */ is
available for commenting out blocks of code.
Jan 20 2002
parent reply "Sean L. Palmer" <spalmer iname.com> writes:
You still can't comment out a block that contains other commented-out
blocks.

Sean

"Walter" <walter digitalmars.com> wrote in message
news:a2dvi7$2fed$2 digitaldaemon.com...

 "Russell Borogove" <kaleja estarcion.com> wrote in message
 news:3C486312.90800 estarcion.com...

 But then, I *never* use /* */ comments when I can use // instead.


 Then you're covered. Use // for normal commenting, and then /* */ is
 available for commenting out blocks of code.
Jan 20 2002
parent "Walter" <walter digitalmars.com> writes:
True.

"Sean L. Palmer" <spalmer iname.com> wrote in message
news:a2e7nf$2k7h$1 digitaldaemon.com...

 You still can't comment out a block that contains other commented-out
 blocks.

 Sean

 "Walter" <walter digitalmars.com> wrote in message
 news:a2dvi7$2fed$2 digitaldaemon.com...

 "Russell Borogove" <kaleja estarcion.com> wrote in message
 news:3C486312.90800 estarcion.com...

 But then, I *never* use /* */ comments when I can use // instead.


 Then you're covered. Use // for normal commenting, and then /* */ is
 available for commenting out blocks of code.
Jan 20 2002
prev sibling next sibling parent reply la7y6nvo shamko.com writes:
I'd like to take the other side of this argument and say
that comments should *not* nest.  Here are my reasons:

    1. D follows the C /* */ comment convention.  Features taken from
    other languages should be kept the same unless there is a d***
    good reason to change them.

    2. Using comments to "comment out" code is not a d*** good reason.
    In fact it's not even a good reason.

    3. For "commenting out" code, I've taken to using

       if(0){ unused code here...    }

    (sometimes without the braces if only one line is being removed).
    It works great!

    4. If you want to do weird things like comment out the last half of
    one function body and the first half of another, shame on you.  The
    language should not be adapted one angstrom to support such nonsense.

    5. Clearly there are cases were the if(0){ ... } style doesn't work.
    So what?  Comments are for commenting programs, not for program
    versioning.  If what's being done is complicated enough so that the
    simple if(0){ ... } form doesn't cover it, then it's complicated
    enough to spend some time and give some thought to what it is that
    needs expressing and how to express it.  It's hard to find something
    worse than code that's gone through iteration after iteration of take
    out this, take out that, meanwhile leaving all the previous code
    version (comments included) present.  As in regular writing, if the
    simple rules don't cover it, rewrite!

Summary:  use comment delimiters to write comments, and only to write
comments.  Use other mechanisms (and D has several good ones) to
remove obsolete code.  If comment delimiters are used only to write
comments, it's better to stick with non-nesting comments.



"OddesE" <OddesE_XYZ hotmail.com> writes:


 "Pavel Minayev" <evilone omen.ru> wrote in message
 news:a0ujps$1iqj$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tv8q$15rd$1 digitaldaemon.com...


 I've been considering making version more tolerant of bad syntax, but it


 is

 going to have to count { and } !


 Still... what's wrong with nested comments? It's really funny to
 see that, even though ANSI commitee didn't make them standart,
 most C++ compilers around have a switch which enables them.
 It's not so hard to implement, but could be a useful thing!


 
 Yes indeed, what *is* wrong with nested comments?
 It seems almost no language supports it (C/C++, Java,
 Pascal, HTML, D?) but why?
 Is it that difficult to implement?
 Is it a feature that would easily be misused?
 Is there something I am totally missing?
 
 Personally I think one of the very big disadvantages of
 all the languages mentioned above is their lack of nested
 comments. It is just so easy to comment out a block of code
 for debugging purposes with the /* and */ comments...I
 never ever use /* and */ for normal comments, because then
 I 'lose' the option to comment out blocks of code. So when
 I write a function header comment, it looks like this:
 
 // ===================================
 //  Print ([in] char[] string)
 //
 //  DESCRIPTION:   Prints out the string argument to stdout
 //  ARGUMENT:       string:  The string to print
 //  RETURNS:           -
 //  EXCEPTIONS:     -
 // ----------------------------------------------------
 
 Something like that...
 I would rather want to use /* */ but because they can't
 be nested it causes all kinds of problems, so I avoid
 using them for normal comments at all.
 Worse still, when I get someone elses code, who does
 use /* and */ I am in trouble...
 
 So I beg you, please make the comments nest...It would
 solve a lot of problems (for me).
 
 
 --
 Stijn
 OddesE_XYZ hotmail.com
 http://www.OddesE.f2s.com
 __________________________________________
 Remove _XYZ from my address when replying by mail
Jan 18 2002
next sibling parent reply "Pavel Minayev" <evilone omen.ru> writes:
<la7y6nvo shamko.com> wrote in message
news:s7cu1tj4430.fsf michael.shamko.com...

 I'd like to take the other side of this argument and say
 that comments should *not* nest.  Here are my reasons:

     1. D follows the C /* */ comment convention.  Features taken from
     other languages should be kept the same unless there is a d***
     good reason to change them.


D has quite a lot of changes from C. Just to remember syntax used
to declare pointers...


     2. Using comments to "comment out" code is not a d*** good reason.
     In fact it's not even a good reason.


A debateful statement it is.


     3. For "commenting out" code, I've taken to using

        if(0){ unused code here...    }

     (sometimes without the braces if only one line is being removed).
     It works great!


Try to comment out a function like that!


     4. If you want to do weird things like comment out the last half of
     one function body and the first half of another, shame on you.  The
     language should not be adapted one angstrom to support such nonsense.


Why not, if it's a practical situation?


     5. Clearly there are cases were the if(0){ ... } style doesn't work.
     So what?  Comments are for commenting programs, not for program
     versioning.  If what's being done is complicated enough so that the
     simple if(0){ ... } form doesn't cover it, then it's complicated
     enough to spend some time and give some thought to what it is that
     needs expressing and how to express it.  It's hard to find something
     worse than code that's gone through iteration after iteration of take
     out this, take out that, meanwhile leaving all the previous code
     version (comments included) present.  As in regular writing, if the
     simple rules don't cover it, rewrite!


I don't leave the code present. I might start doing it one way, then
understand that there _might_ be a better one... so I comment out what
I have, implement it in the "better" way, and either remove the comment
or the new code depending on whether it works or not.
Jan 18 2002
parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
In response to the dicussion between la7y6nvo and
Pavel, I would like to add some more points...


"Pavel Minayev" <evilone omen.ru> wrote in message
news:a2afp4$2ji$1 digitaldaemon.com...

 <la7y6nvo shamko.com> wrote in message
 news:s7cu1tj4430.fsf michael.shamko.com...

 I'd like to take the other side of this argument and say
 that comments should *not* nest.  Here are my reasons:

     1. D follows the C /* */ comment convention.  Features taken from
     other languages should be kept the same unless there is a d***
     good reason to change them.


 D has quite a lot of changes from C. Just to remember syntax used
 to declare pointers...


Nesting comments is a very small change, that is immediately
obvious when you try to misuse it, and therefore doesn't form
a huge obstacle. Furthermore, people programming in D will
have to learn D anyhow, because there are a lot of things that
have changed significantly. I agree that changing something just
a little bit should have a very good reason, but I personally
think including nested comments is.



     2. Using comments to "comment out" code is not a d*** good reason.
     In fact it's not even a good reason.


 A debateful statement it is.


Definitely. I personally do it all the time, and so do most other
programmers I know. It is just very convenient.



     3. For "commenting out" code, I've taken to using

        if(0){ unused code here...    }

     (sometimes without the braces if only one line is being removed).
     It works great!


 Try to comment out a function like that!


There is a big difference between these two methods. When I
comment out code, I *remove* that code from the program.
When you use the if (0) technique you just make sure it does
not run. Worse still, another programmer is going to have a hard
time trying to figure out why you wrote a piece of code that
is never going to be executed. It is very obvious that if code
is commented out, it probably was replaced by other code, or
is no longer neccesary.



     4. If you want to do weird things like comment out the last half of
     one function body and the first half of another, shame on you.  The
     language should not be adapted one angstrom to support such




nonsense.

 Why not, if it's a practical situation?


That would be a wierd situation, but you can already
easily do that without nested comments...The language
doesn't have to be adapted at all, it already supports
such 'nonsense'!



     5. Clearly there are cases were the if(0){ ... } style doesn't work.
     So what?  Comments are for commenting programs, not for program
     versioning.  If what's being done is complicated enough so that the
     simple if(0){ ... } form doesn't cover it, then it's complicated
     enough to spend some time and give some thought to what it is that
     needs expressing and how to express it.  It's hard to find something
     worse than code that's gone through iteration after iteration of




take

     out this, take out that, meanwhile leaving all the previous code
     version (comments included) present.  As in regular writing, if the
     simple rules don't cover it, rewrite!


 I don't leave the code present. I might start doing it one way, then
 understand that there _might_ be a better one... so I comment out what
 I have, implement it in the "better" way, and either remove the comment
 or the new code depending on whether it works or not.


Definitely! Or trying to find out if a piece of code causes a bug
by commenting it out, or rewriting a function for efficiency without
throwing it away.


But there is one big point that la7y6nvo is making that I
wholeheartedly agree with:


Comments are for commenting programs, not
for program versioning.




Totally agreed! Comments where designed with the
purpose of commenting on what you are doing in a
piece of code.

However, practice has shown that programmers want
a way to easily remove pieces of code from a program,
without actually totally removing it from the source text.
Maybe there should indeed be introduced a new type
of 'comments' (or should I say removers?), that do nest.
They could be highlighted with a different color in the
editor, and then /* */ would be restored to it's original
purpose, commenting on code.

At the moment, most experienced programmers avoid
using /* */ altogether, even when it's use would be very
practical, to keep the option of using them for
commenting out pieces of code.

I am for simply nesting the existing /* */, but another
way of 'removing' code would be good to.


--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
__________________________________________
Remove _XYZ from my address when replying by mail
Jan 19 2002
parent "Roberto Mariottini" <rmariottini lycosmail.com> writes:
"OddesE" <OddesE_XYZ hotmail.com> ha scritto nel messaggio
news:a2cusb$1q0c$1 digitaldaemon.com...
[...]

 But there is one big point that la7y6nvo is making that I
 wholeheartedly agree with:


Comments are for commenting programs, not
for program versioning.




 Totally agreed! Comments where designed with the
 purpose of commenting on what you are doing in a
 piece of code.

 However, practice has shown that programmers want
 a way to easily remove pieces of code from a program,
 without actually totally removing it from the source text.
 Maybe there should indeed be introduced a new type
 of 'comments' (or should I say removers?), that do nest.
 They could be highlighted with a different color in the
 editor, and then /* */ would be restored to it's original
 purpose, commenting on code.

 At the moment, most experienced programmers avoid
 using /* */ altogether, even when it's use would be very
 practical, to keep the option of using them for
 commenting out pieces of code.

 I am for simply nesting the existing /* */, but another
 way of 'removing' code would be good to.


And the JavaDOC-like tool question you wrote in the other post
is another good argument.

Nesting or non-nesting is not the real question.
We need a simple way to comment-out code.
In C/C++ i would use #if 0, but in D there is nothing like that...

Ciao
Jan 21 2002
prev sibling parent "Walter" <walter digitalmars.com> writes:
<la7y6nvo shamko.com> wrote in message
news:s7cu1tj4430.fsf michael.shamko.com...

     3. For "commenting out" code, I've taken to using

        if(0){ unused code here...    }

     (sometimes without the braces if only one line is being removed).
     It works great!


I use that too. But I keep getting grief from various compilers that insist
I must have made a mistake having a constant in a conditional. Notably, DMC
does *not* issue warnings about that construct!

That form was the genesis of the version statement in D. (I wanted it to
work with declarations,  too, and not introduce a new scope in the { }.
Using a new keyword made it greppable, and allowed some other semantic
tweaking to make it work nice.)
Jan 20 2002
prev sibling parent reply "OddesE" <OddesE_XYZ hotmail.com> writes:
<SNIP>


 I would rather want to use /* */ but because they can't
 be nested it causes all kinds of problems, so I avoid
 using them for normal comments at all.
 Worse still, when I get someone elses code, who does
 use /* and */ I am in trouble...


<SNIP>

I just thought of something else... What about tools
like JavaDoc (or the future DDoc), which require
documentation to start with /** and end with */ ?

Now you can kiss using /* */ for removing code
goodbye...A major nuisance.


--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
__________________________________________
Remove _XYZ from my address when replying by mail
Jan 19 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"OddesE" <OddesE_XYZ hotmail.com> wrote in message
news:a2cuup$1q1a$1 digitaldaemon.com...


 I just thought of something else... What about tools
 like JavaDoc (or the future DDoc), which require
 documentation to start with /** and end with */ ?

 Now you can kiss using /* */ for removing code
 goodbye...A major nuisance.


Why? If it uses /** */, why can't I use /* */ ?
Jan 19 2002
parent "OddesE" <OddesE_XYZ hotmail.com> writes:
"Pavel Minayev" <evilone omen.ru> wrote in message
news:a2dnv9$29hv$1 digitaldaemon.com...

 "OddesE" <OddesE_XYZ hotmail.com> wrote in message
 news:a2cuup$1q1a$1 digitaldaemon.com...


 I just thought of something else... What about tools
 like JavaDoc (or the future DDoc), which require
 documentation to start with /** and end with */ ?

 Now you can kiss using /* */ for removing code
 goodbye...A major nuisance.


 Why? If it uses /** */, why can't I use /* */ ?


If you have functions with documentation like this:

/**
    Documentation for Func1
*/
void Func1()
{
    // ...
}

/**
    Documentation for Func2
*/
void Func2()
{
    // ...
}


You can't comment both of them out at once
using /* */. You would have to comment out both
of them seperately.

This could be done in all these kinds of situations,
but I would like comments to nest to make it easier
to comment out large blocks at once. Think of a class
that you want to comment out...Gets problematic if
you have documented your functions using JavaDoc
style /** */....

--
Stijn
OddesE_XYZ hotmail.com
http://OddesE.cjb.net
__________________________________________
Remove _XYZ from my address when replying by mail
Jan 20 2002
prev sibling parent reply "Roberto Mariottini" <rmariottini lycosmail.com> writes:
"Pavel Minayev" <evilone omen.ru> ha scritto nel messaggio
news:a0th24$svc$1 digitaldaemon.com...

 "Walter" <walter digitalmars.com> wrote in message
 news:a0tbj5$ptm$1 digitaldaemon.com...


 no. Use the version statement to block out sections.


 Unfortunately, version cannot comment out blocks with bad syntax -
 which is needed sometimes. For example, I occasionally start
 writing something, then decide to try another idea, but comment
 the unfinished block out rather than deleting it in case I'll
 revert back to it later... and such a block may have improper
 syntax (like "if(a == ").


I also often need nested comments as a fast way to comment-out weird code.
To me seems better to define a new style of comment to comment out big
blocks of code
(or a block of natural language description). This new "wipe-out" comment
must be
clearly visible and we can choose it can be nested (it's new, so noone
should complain).
I think to something like:


  


 .. big block of text, with nested >   and <   ...
<  

I like to think this comment must be at column 0, so it's easy to
distinguish from normal code

Ciao.
Jan 07 2002
next sibling parent "Pavel Minayev" <evilone omen.ru> writes:
"Roberto Mariottini" <rmariottini lycosmail.com> wrote in message
news:a1ck0f$1alu$1 digitaldaemon.com...


  


  .. big block of text, with nested >   and <   ...
 <  


Maybe then <   > ?
Jan 07 2002
prev sibling parent reply Russell Borogove <kaleja estarcion.com> writes:
Roberto Mariottini wrote:


 "Pavel Minayev" <evilone omen.ru> ha scritto nel messaggio
 news:a0th24$svc$1 digitaldaemon.com...
 

"Walter" <walter digitalmars.com> wrote in message
news:a0tbj5$ptm$1 digitaldaemon.com...



no. Use the version statement to block out sections.


Unfortunately, version cannot comment out blocks with bad syntax -
which is needed sometimes. For example, I occasionally start
writing something, then decide to try another idea, but comment
the unfinished block out rather than deleting it in case I'll
revert back to it later... and such a block may have improper
syntax (like "if(a == ").


 
 I also often need nested comments as a fast way to comment-out weird code.
 To me seems better to define a new style of comment to comment out big
 blocks of code
 (or a block of natural language description)....
 
 

  


  .. big block of text, with nested >   and <   ...
 <  
 
 I like to think this comment must be at column 0, so it's easy to
 distinguish from normal code



Insert the text:

//weirdcode//

at the beginning of each line.

Or, use the D-in-HTML feature and comment out large chunks with
<!-- ... -->

-RB
Jan 07 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Russell Borogove" <kaleja estarcion.com> wrote in message
news:3C3A713E.4050605 estarcion.com...


 Insert the text:

 //weirdcode//

 at the beginning of each line.


Suppose you have 100 lines...


 Or, use the D-in-HTML feature and comment out large chunks with
 <!-- ... -->


For this to work, file must have .html extension. I personally
prefer .d =)
Jan 08 2002
next sibling parent "Sean L. Palmer" <spalmer iname.com> writes:
So name them foo.d.html    ;)

Might be nice for D compiler to automatically detect a <html> tag and assume
it should start parsing HTML automagically until it finds a </html>.  So
long as Walter never wants to use C++ template syntax this shouldn't be a
problem.  Then you can just use foo.d as your file name.

Sean

"Pavel Minayev" <evilone omen.ru> wrote in message
news:a1egsp$2g3g$1 digitaldaemon.com...

 "Russell Borogove" <kaleja estarcion.com> wrote in message
 news:3C3A713E.4050605 estarcion.com...


 Insert the text:

 //weirdcode//

 at the beginning of each line.


 Suppose you have 100 lines...


 Or, use the D-in-HTML feature and comment out large chunks with
 <!-- ... -->


 For this to work, file must have .html extension. I personally
 prefer .d =)
Jan 08 2002
prev sibling parent reply Russell Borogove <kaleja estarcion.com> writes:
Pavel Minayev wrote:


 "Russell Borogove" <kaleja estarcion.com> wrote in message
 news:3C3A713E.4050605 estarcion.com...
 
 

Insert the text:

//weirdcode//

at the beginning of each line.


 
 Suppose you have 100 lines...



Suppose you have an editor that can paste a rectangular
selection and drop down to the same column on the next
line in a single keystroke. (Dev Studio, for example)

Anyway, that's what works for me, and I understand it
doesn't work for everybody.

-RB
Jan 08 2002
parent "Pavel Minayev" <evilone omen.ru> writes:
"Russell Borogove" <kaleja estarcion.com> wrote in message
news:3C3B64F8.4070003 estarcion.com...


 Suppose you have an editor that can paste a rectangular
 selection and drop down to the same column on the next
 line in a single keystroke. (Dev Studio, for example)


Well I do hav DevIde. But since it doesn't support D (yet?),
I have to use the FAR built-in editor + Colorer plug-in,
after writing a highlighting scheme for D. Unfortunately,
this editor doesn't support tricks like the one you mentioned...
Jan 08 2002