replace C style comments by C++ style comments

Question

How can I automatically replace all C style comments (/* comment */) by C++ style comments (// comment)? This has to be done automatically in several files. Any solution is ok, as long as it works.

Answer 1

Why don't you write a C app to parse it's own source files? You could find the /* comments */ sections with a relatively easy Regex query. You could then replace the new line characters with new line character + "//".

Anyway, just a thought. Good luck with that.

Answer 2

This is not a trivial problem.

int * /* foo 
  /* this is not the beginning of a comment.

int * */ var = NULL;

What do you want to replace that with? Any real substitution requires sometimes splitting lines.

int * // foo
  // this is not the beginning of a comment.
// int *
var = NULL;

Answer 3

If you write an application/script to process the C source files, here are some things to be careful of:

• comment characters within strings
• comment characters in the middle of a line (you might not want to split the code line)

You might be better off trying to find an application that understands how to actually parse the code as code.

Answer 4

If there are just "several files" is it really necessary to write a program? Opening it up in a text editor might do the trick quicker in practice, unless there's a whole load of comments. emacs has a comment-region command that (unsurprisingly) comments a region, so it'd just be a case of ditching the offending '/*' and '*/'.

Answer 5

How do you intend to handle situations like this:

void CreateExportableDataTable(/*[out, retval]*/ IDispatch **ppVal)
{
 //blah
}

Note the comment inside the parens... this is a common way of documenting things in generated code, or mentioning default parameter values in the implementation of a class, etc. I'm usually not a fan of such uses of comments, but they are common and need to be considered. I don't think you can convert them to C++ style comments without doing some heavy thinking.

Answer 6

Here's a Python script that will (mostly) do the job. It handles most edge cases, but it does not handle comment characters inside of strings, although that should be easy to fix.

#!/usr/bin/python

import sys

out = ''
in_comment = False

file = open(sys.argv[1], 'r+')
for line in file:
    if in_comment:
        end = line.find('*/')
        if end != -1:
            out += '//' + line[:end] + '\n'
            out += ' ' * (end + 2) + line[end+2:]
            in_comment = False
        else:
            out += '//' + line
    else:
        start = line.find('/*')
        cpp_start = line.find('//')
        if start != -1 and (cpp_start == -1 or cpp_start > start):
            out += line[:start] + '//' + line[start+2:]
            in_comment = True
        else:
            out += line

file.seek(0)
file.write(out)

Answer 7

I'm with the people who commented in your question. Why do it? Just leave it.

it wastes time, adds useless commits to version control, risk of screwing up

EDIT: Adding details from the comments from the OP

The fundamental reason of preferring C++-style comment is that you can comment out a block of code which may have comments in it. If that comment is in C-style, this block-comment-out of code is not straight forward. – unknown (yahoo)

that might be a fair/ok thing to want to do, but I have two comments about that:

• I know of no one who would advocate changing all existing code - that is a preference for new code. (IMO)
• If you feel the need to "comment out code" (another iffy practice) then you can do it as needed - not before

It also appears that you want to use the c-style comments to block out a section of code? Or are you going to use the // to block out many lines?

One alternative is a preprocessor #ifdef for that situation. I cringe at that but it is just as bad as commenting out lines/blocks. Neither should be left in the production code.

Answer 8

This tool does the job: http://people.sc.fsu.edu/~burkardt/cpp_src/recomment/recomment.html

RECOMMENT is a C++ program which converts C style comments to C++ style comments.

It also handles all the non-trivial cases mentioned by other people:

This code incorporates suggestions and coding provided on 28 April 2005 by Steven Martin of JDS Uniphase, Melbourne Florida. These suggestions allow the program to ignore the internal contents of strings, (which might otherwise seem to begin or end comments), to handle lines of code with trailing comments, and to handle comments with trailing bits of code.