Thread: Removing comments from textual files

Hello,
my friend ask me to write simple program that open file and removes all commented lines.
Here's what I made:

Code:

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main ()
{
    ifstream infile("Test.txt");
    ofstream outfile("Test2.txt");
    string str, search_start="/*", search_end = "*/";
    string :: size_type siz;
    bool comment = false;//flag that indicates if line is commented
    //read line
    while (getline(infile, str))
    {
        //write line to file if there is no markers /*, */ or line is not commented
        if (str.find("/*") == string :: npos && str.find("*/") == string :: npos && !comment)
        {
            outfile << str << endl;
        }
        else //line is commented
        {
            comment = true;
            siz = str.find("*/");//try to find end of comment
            if (siz != string :: npos)
            {
                //close comment part and continu, read next line
                comment = false;
                continue;
            }
            else
            {
                //read lines until end of comment marek is found 
                while (siz != string :: npos)
                {
                    getline(infile, str);
                    siz = str.find("*/");
                    comment = false;
                }
            }
        }
    }
    return 0;
}

This code does what it's supposed to do, but I wonder if this could be written more elegant.
i think maybe better solution will be to use temp file, if everything goes OK contents of temp file will overwrite original file. ofcourse error checking should include unfinished comment in order to prevent lose of code if there is mistake in comments.
Tell me what you think and perhaps suggest better solution.

Thanks

Thanks, interesting idea, I need to handle case if comment is in same line with code, for example

Code:

cout<<x;/*comment*/

I'll post second version soon.

You also need to handle comments within strings - they're not comments.

Hehe, at first glance trivial task now becoming more and more interesting

This is newer version:

Code:

#include <iostream>
#include <string> 
#include <fstream>
#include <sstream>

using namespace std;

int main()
{
	ifstream infile("test.txt");
	stringstream sstr;
	sstr<< infile.rdbuf();
	string :: size_type start_CPP, start_C, end;
	string str = sstr.str();
	start_CPP = str.find("//");
	start_C = str.find("/*");

	while (start_CPP != string :: npos || start_C != string :: npos)
	{
		if (start_CPP != string :: npos)
		{
			str.erase(start_CPP, str.find("\n", start_CPP+2)-start_CPP);
		}
		end = str.find("*/");

		if (end != string :: npos)
		{
			str.erase(start_C, end+2-start_C);
		}
		start_C = str.find("/*");
		start_CPP = str.find("//");
	}
	
	cout <<str;
	ofstream outfile("res.txt");
	outfile << str<<endl;
	return 0;
}

However I need to think how to parse string if /* is in regular text and not represents comment although it will be rare.
Can you suggest something?
Thanks

One way is to keep a bool flag. Whenever a double quote is found the flag is set. When a second double quote is found the flag is reset. Thus a true state means inside a quoted text, while a false state means outside.

However, some rules have to be set:

- You will only set or reset the flag if the double quote is preceded by \ (i.e. the double quote is an escape sequence)

- You will not set or reset the flag if you are aready inside a block of commented text.

Best way is a full FSM, a finite state machine. It would have the states normal, in-string, string-escape, in-slcomment, slcomment-escape and in-mlcomment. This is your state transition table:
normal + " -> in-string
normal + // -> in-slcomment
normal + /* -> in-mlcomment
in-string + \ -> string-escape
string-escape + anything -> in-string
in-string + " -> normal
in-slcomment + \ -> slcomment-escape
slcomment-escape + anything -> in-slcomment
in-slcomment + newline -> normal
in-mlcomment + */ -> normal
normal or in-slcomment + EOF -> done (but emit a warning about missing newline before EOF if in-slcomment, it's a convention to have one in *nix)
string-escape or slcomment-escape or in-string or in-mlcomment + EOF -> error

The -escape states are because of strings like "Hello, \"Peter\"!" and because a single-line comment can be continued to the next line with a backslash. (Although this is very bad practice - you might want to emit a warning.)

Hmm, thanks, I guess I'll need to read more about finite state machines. I'm not really familliar with it and need to learn how they're programmed.

To simplify things you can add a newline to the end of the file, so you won't need to check for EOF when parsing comments. Remove the newline when you are done.

Don't forget the unstandard combo char '/**/'

Oh yeah, and the trigraph ??/ is the same as a single \, so you might want to check for that too

Maybe you can specify a string for "c_comm" "cpp_comm" and "end", so that you process the file line by line. If you find "cpp_comm" by way of search in algorithms, then you continue to the next line. If you find c_comm (you can make one for the beginning or the end), then you won't copy any strings until after you find */)

or you can search for a single character like '\/', have an inside if else. if the character after it is '\/', then exclude the whole line, if it's "*", then just keep searching for '*' and a '\/' after it.