Why don't more languages support recursive/nested comments? [duplicate]

Question

Possible Duplicate:
Why do most programming languages not nest block comments?

Most languages I've worked with don't have support for recursive/nested comments.

1. Is there any reason why language designers would choose not to implement this?
2. Is it deceptively complex?
3. Would it have undesired results?

I know there could be issues such as:

/*
    string Str = "aslfkalfksnflkn/*aslkfasnflkn";

*/

Console.WriteLine("asdoadokn");

However, we could still get the same issue with non-recursive ones (consider */ in a string in a comment) so i don't feel that's a good argument against.

Answer 1

The problem is that recursive comments force you to actually parse the comments section, pushing it outside the scope of a normal lexer and possibly introducing more problems.

As a refresher: A compiler usually has a number of distinct stages with different jobs, and the first stages are the lexer, which gets the input program and separates it into a sequence of tokens (each of which contains a keyword, and identifier or an operator), and the parser, which structures this sequence of tokens into an abstract syntax tree (AST).

For the scope of a lexer, remember that lexing can normally be done by regular expressions. Bracket-like structures like recursive comments cannot be parsed by regular expressions (see context-free grammars), so the lexer would have to have much additional complexity, e.g. would need to be implemented via a recursive-descent parser.

Additionally, for C and similar languages (who most famously used the /**/ comment syntax) the need never arose to comment out large chunks of code, since they had the pre-processor and unused chunks of code were just wrapped by

#if 0
....
#endif

which circumvented the parsing problem by delegating the problem to a second, much simpler compiler (the pre-processor).

Summarizing: Because recursive comments would make compiling more complicated, it's usually disallowed, and only languages with C-style comments, but without a preprocessor, really need it. That Java is amongst them is unfortunate, of course.

Edit: This doesn't mean recursive comments would be impossible or even very hard to do. You could use a recursive-descent lexer or could have a preprocessor before the lexer for filtering out comments. However, both approaches come with considerable cost compared to the standard model (use RE to auto-build the lexer and an EBNF to auto-build the parser), and the gain is pretty small.

Answer 2

I'm with you on this. When you work with large, old code bases, then those are littered with comments regarding hacks, commented out code, and other dirt and grit, let alone C interfaces documented in /*...*/ comments. If you need to comment out some of that, using /*...*/ comments is almost never an option, because they do not nest.

I don't believe "further complicating the compiler" is a reason either, because compared to the complexity of C++, parsing comments for /*, */ (and maybe //) should be laughably easy. In fact, I seem to remember Borland C++ (in the 90s) offering the option to parse nested comments - and that compiler used to be known for its lighting speed.

But the problem with non-standard solutions is that you cannot use them if you might have to port your code later. (And, in C++, who would ever rule out that?)

So I agree that it would be an improvement if this was standardized.

In the meantime, I use // comments to comment out chunks of code. Fortunately, most modern editors/IDEs have an option to apply this to several lines at once.

Answer 3

I modified a C compiler to do this once, it wasn't terribly hard. It's all taken care of in the lexical scanner, so you don't have to muck about with the guts of the parser. It's really just a matter of keeping track of the nesting level and ignoring anything within string delimiters.

Answer 4

Newspeak has structured comments which can nest. And it has a very simple grammar, so it is obviously not "deceptively complex".

Answer 5

Comments that span over multiple lines should be the exception, not the rule.

Even in C, I use C++ style // instead of standard /* */.

If I absolutely need to comment out a large portion of code, I use #if 0 preprocessor directive, which supports nesting.

Answer 6

This is recursion:

public void recursion()
{
    recursion();
}

I have no idea what recursive comments would look like.

Nested comments on the other hand, would make sense, and actually already works to some extent. You can nest single line comments inside multiple line comments.

/* No longer use this!
// This is a method.
public void method()
{
}
*/

Supporting what you are asking, from the point of perspective of the programmer, would make perfect sense.

/* No longer use this!
// This is a method.
public void method()
{
    /* Disabled!
       doInterestingStuff();
       ...
    */
}
*/

Considering that programming languages are just tools in which programmers can express their intentions, supporting this intention would be an added value.

I can't comment on the technical aspects by heart, but it looks like some of the other answers already provided information on that.

Answer 7

One reason is probably compatibility with existing codebases; C-like languages typically do everything just like C did, even stupid things like 031==25 (octal literals, who ever needed them?)

Another reason is more philosophical: A comment starts with (e.g.) /* and ends with the next */, and whatever is in between those, doesn't matter at all. Nested comments require defining a syntax for comments, too.

BTW, if you don't need that piece code anymore, why not just remove it entirely and leave it to the VCS to keep the older version? Commented code is a code smell.