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 > 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 <stdio.h>
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 <stdio.h>
int main(void) {
int c, d;
int longDisable = 0, shortDisable = 0;
while ((c = getchar()) != EOF) {
switch (c) {
case '/':
case '*':
d = getchar();
if (!longDisable && c == '/' && d == '/') {
shortDisable = 1;
} else if (!shortDisable && c == '/' && d == '*') {
longDisable = 1;
} else if (!shortDisable && c == '*' && 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);
}
}
}
}
