Delete all comments in a C program
Bugs

When processing an expression like 10/2 or 10*2, the 2 gets discarded from the output.

It looks like you attempted to implement a circular buffer for the output, but it actually fails miserably if the output exceeds 1000 bytes.  One problem is performance: myputchar() performs a linear scan of the buffer to find the end of the string, where it can write the next character.  A second problem is buffer overflow: myputchar() makes no attempt to ensure that the location where it stores the next character lies within the buffer.  The third problem is that when you do if (i &gt; MAXCHAR)i = 0, you haven't made any attempt to print the buffer contents before trying to reuse the buffer.

C grammar

In C, a /* or // that appears within a "string literal" should be treated literally.  It should not be interpreted as a start-of-comment marker.

Furthermore, within a //-style comment, any /* or */ needs to be disregarded.  Similarly, within a /* */-style comment, any // should be disregarded.  That is, the correct output for the following C99 program…


#include &lt;stdio.h&gt;
int main() {
    puts("First " /* asdf // */ "example"
    );
    puts("Second " // /*
         "example"
         // */
    );
    puts("Third " /* "/" */ "example");
}



… should be




First example
Second example
Third example





(I also got this wrong in Rev 1 of this answer.  I've corrected the bug, but this illustrates a point that C requires a stateful parser.)

Organization

The variables c, d, newFileText, longDisable, shortDisable, and i are global; they should all be local to the main function.

It is customary to put the main function last, so that you don't need to declare the functions it uses.

Input / output

You read one character at a time with getchar(), but you attempt to print the output in chunks of up to 1000 characters.  Writing in chunks could be more efficient than writing a character at a time, but it is certainly more difficult to implement correctly.  However, after you go through the effort of accumulating the chunks, you then proceed to print the buffer one character at a time using printf("%c", theArray[i]), which negates any performance advantage you could have gained.

Therefore, you would have been better off printing the output one character at a time to begin with, without any attempt at buffering.  To do so, you could use putchar(…), which is simpler than printf("%c", …).

If you did want to efficiently write a chunk of bytes at a time, you could use the write() function instead of the loop in printArray().

Suggested solution

This solution addresses the more serious logic bugs, without attempting to handle string literals correctly.

#include &lt;stdio.h&gt;

int main(void) {
    int c, d;
    int longDisable = 0, shortDisable = 0;

    while ((c = getchar()) != EOF) {
        switch (c) {
          case '/':
          case '*':
            d = getchar();
            if (!longDisable &amp;&amp; c == '/' &amp;&amp; d == '/') {
                shortDisable = 1;
            } else if (!shortDisable &amp;&amp; c == '/' &amp;&amp; d == '*') {
                longDisable = 1;
            } else if (!shortDisable &amp;&amp; c == '*' &amp;&amp; d == '/') {
                longDisable = 0;
            } else if (!(shortDisable || longDisable)) {
                putchar(c);
                if (d != EOF) putchar(d);
            }
            break;

          case '\n':
            shortDisable = 0;
            /* fall through... */
          default:
            if (!(shortDisable || longDisable)) {
                putchar(c);
            }
        }
    }
}