How to ignore reading contents of /*comment*/ while reading a file

Question

Below is my code:

string ckeywords = File.ReadAllText("E:\\ckeywords.csv");
string[] clines = File.ReadAllLines("E:\\cprogram\\cpro\\bubblesort.c");
string letters="";

foreach(string line in clines)
{
    char[] c = line.ToCharArray();
    foreach(char i in c)
    {
        if (i == '/' || i == '"')
        {
            break;
        }
        else 
        {
            letters = letters + i;
        }
    }
}
letters = Regex.Replace(letters, @"[^a-zA-Z ]+", " ");

List<string> listofc = letters.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
List<string> listofcsv = ckeywords.Split(new char[] { ',', '\t', '\n', ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim()).ToList();
List<string> Commonlist = listofcsv.Intersect(listofc).ToList();

With this if condition, I am able to ignore reading contents of single line comment and contents between ("").

I need to ignore reading contents of multi line comments. Which condition should I use? Suppose my .c file is having this line of comment so with above code I don't know how to start iterating from /* to */ and to ignore the contents in between.

/*printf("Sorted list in ascending order:\n");

for ( c = 0 ; c < n ; c++ ) printf("%d\n", array[c]);*/

Answer 1

I successfully solved my problem now I can ignore reading contents of /* */ in a simpler way without using Regular Expression. Here is my code:

string[] clines = File.ReadAllLines("E:\\cprogram\\cpro\\bubblesort.c");
List<string> list = new List<string>();
int startIndexofcomm, endIndexofcomm;

 for (int i = 0; i < clines.Length ; i++ )
    {
       if (clines[i].Contains(@"/*"))
          {
             startIndexofcomm = clines[i].IndexOf(@"/*");
             list.Add(clines[i].Substring(0, startIndexofcomm));

             while(!(clines[i].Contains(@"*/")))
             {
                i++;
             }

             endIndexofcomm = clines[i].IndexOf(@"*/");
             list.Add(clines[i].Substring(endIndexofcomm+2));

             continue;
          }
          list.Add(clines[i]);
     }

Answer 2

Here is code that naively does the following:

1. It strips out any multi-line comments starting with /* and ending with */, even if there are newlines between the two.
2. It strips out any single-line comments starting with // and ending at the end of the line
3. It does not strip out any comments like the above if they're within a string that starts with " and ends with a ".

LINQPad code:

void Main()
{
    var code = File.ReadAllText(@"d:\temp\test.c");
    code.Dump("input");

    bool inString = false;
    bool inSingleLineComment = false;
    bool inMultiLineComment = false;

    var output = new StringBuilder();
    int index = 0;

    while (index < code.Length)
    {
        // First deal with single line comments: // xyz
        if (inSingleLineComment)
        {
            if (code[index] == '\n' || code[index] == '\r')
            {
                inSingleLineComment = false;
                output.Append(code[index]);
                index++;
            }
            else
                index++;

            continue;
        }

        // Then multi-line comments: /* ... */
        if (inMultiLineComment)
        {
            if (code[index] == '*' && index + 1 < code.Length && code[index + 1] == '/')
            {
                inMultiLineComment = false;
                index += 2;
            }
            else
                index++;
            continue;
        }

        // Then deal with strings
        if (inString)
        {
            output.Append(code[index]);
            if (code[index] == '"')
                inString = false;
            index++;
            continue;
        }

        // If we get here we're not in a string or in a comment
        if (code[index] == '"')
        {
            // We found the start of a string
            output.Append(code[index]);
            inString = true;
            index++;
        }
        else if (code[index] == '/' && index + 1 < code.Length && code[index + 1] == '/')
        {
            // We found the start of a single line comment
            inSingleLineComment = true;
            index++;
        }
        else if (code[index] == '/' && index + 1 < code.Length && code[index + 1] == '*')
        {
            // We found the start of a multi line comment
            inMultiLineComment = true;
            index++;
        }
        else
        {
            // Just another character
            output.Append(code[index]);
            index++;
        }
    }

    output.ToString().Dump("output");
}

Sample input:

This should be included // This should not
This should also be included /* while this
should not */ but this should again be included.

Any comments in " /* strings */ " should be included as well.
This goes for "// single line comments" as well.

Sample output (note that there are some spaces at the end of some of the lines below that aren't visible):

This should be included 
This should also be included  but this should again be included.

Any comments in " /* strings */ " should be included as well.
This goes for "// single line comments" as well.