Remove comments from C program - c

Question

Following is my code to remove comments from a C program. But the comment lines don't get removed. It removes /* and */, but doesn't remove the sentence between this delimiters.
#include <stdio.h>
main(int argc, char *argv[]) {
FILE *fp, *ft;
char ch;
if (argc < 3) {
printf("No file name given");
}
fp = fopen(argv[1], "r");
ft = fopen(argv[2], "w");
if (fp == NULL)
printf("Opening error");
if (ft == NULL)
printf("Opening error");
while (1) {
ch = fgetc(fp);
if (ch == EOF)
break;
if (ch == '/') {
ch = fgetc(fp);
if (ch == '*') {
putc(' ', ft);
}
} else if (ch == '*') {
ch = fgetc(fp);
if (ch == '/') {
putc(' ', ft);
}
} else {
putc(ch, ft);
}
}
fclose(fp);
fclose(ft);
}
Please help me to remove comment lines.

Answer 1

There are multiple issues in your code:
the return type of main should not be omitted. Implicit int is obsolete and no longer allowed by the C Standard. The prototype should be int main(int argc, char *argv[])
if command line arguments were not passed to the program, it should exit after printing the error message, which should be output to stderr instead of stdout.
if the input file cannot be open, the program should not create the output file.
if either fopen failed, the program should stop instead of wandering into the realm of undefined behavior.
ch must have type int instead of char for the test (ch == EOF) to behave correctly.
you correctly identify the sequences /* and */ and replace them by a single , but it will actually remove all other occurrences of / and * and the subsequent character and you do not have any provisions for skipping the characters in between.
main should return 0.
Note also that your method might not identify comments correctly if the sequences /* or */ occur in single line comments or string or character constants. Furthermore, you should also handle escaped newlines (\ at the end of a line) as these may occur between the / and *, concealing the comment start or end sequences.
Here is a modified version that handles these cases:
#include <stdio.h>
/* read the next byte from the C source file, handing escaped newlines */
int getcpp(FILE *fp) {
int ch;
while ((ch = getc(fp)) == '\\') {
if ((ch = getc(fp)) != '\n') {
ungetc(ch, fp);
return '\\';
}
}
return ch;
}
/* read and write character and string constants */
int skipstr(int cch, FILE *fp, FILE *ft) {
int ch;
putc(cch, ft);
while ((ch = getcpp(fp)) != EOF) {
putc(ch, ft);
if (ch == cch)
return 0;
if (ch == '\\') {
if ((ch = getcpp(fp)) == EOF)
return EOF;
putc(ch, ft);
}
}
return EOF;
}
int main(int argc, char *argv[]) {
FILE *fp, *ft;
int ch;
if (argc < 3) {
fprintf(stderr, "Missing arguments. Need input and output filenames\n");
return 1;
}
if ((fp = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "Cannot open input file %s\n", argv[1]);
return 1;
}
if ((ft = fopen(argv[2], "w")) == NULL) {
fprintf(stderr, "Cannot open output file %s\n", argv[2]);
return 1;
}
while ((ch = getcpp(fp)) != EOF) {
if (ch == '\'' || ch == '"') {
if (skipstr(ch, fp, ft)) {
fprintf(stderr, "unterminated string or character constant\n");
break;
}
continue;
}
if (ch == '/') {
if ((ch = getcpp(fp)) == '*') {
/* multi-line comment */
int lastc = 0;
while ((ch = getcpp(fp)) != EOF) {
if (ch == '/' && lastc == '*') {
break;
}
lastc = ch;
}
if (ch == EOF) {
fprintf(stderr, "unterminated comment\n");
break;
}
ch = ' ';
} else if (ch == '/') {
/* single-line comment */
while ((ch = getcpp(fp)) != EOF && ch != '\n')
continue;
if (ch == EOF)
break;
} else {
putc('/', ft);
}
}
putc(ch, ft);
}
fclose(fp);
fclose(ft);
return 0;
}

Answer 2

Your code correctly identifies the comment start sequence "/" and the comment end sequence "/" and deletes them but doesn't delete what lays between them (a flag for instance should do it)
/*
* flag = 1 if comment detected
* flag = 0 otherwise
*/
if (flag == 0)
{
putc (ch, ft);
}
If you keep your code as it is, it will delete all '/' not only in comment but anywhere in the file. I can think of at least one bad consequence for this (when calling headers such as <sys/time.h>, <sys/stat.h>, <netinet/in.h>, and so on ).
Since the start and end sequences of comment are two characters wide, I would suggest that you use 2 "cursors" to read fp, as if you are reading 2 characters per loop. Hereafter an example (even though it works, for simplicity and readability reasons it doesn't handle edge cases such as non closed comment before EOF, or EOF right after a closing comment sequence).
#include <stdio.h>
int
main (int argc, char *argv[])
{
FILE *fp, *ft;
char ch, nextc;
if (argc < 3)
{
printf ("No file name given");
}
fp = fopen (argv[1], "r");
ft = fopen (argv[2], "w");
if (fp == NULL)
printf ("Opening error");
if (ft == NULL)
printf ("Opening error");
nextc = fgetc (fp);
while (nextc != EOF)
{
ch = nextc;
nextc = fgetc (fp);
if ((ch == '/') && (nextc == '*'))
{
nextc = fgetc (fp);
while ((ch != '*') && (nextc != '/')) /* unroll until the end of comment*/
{
ch = nextc;
nextc = fgetc (fp);
}
ch = fgetc (fp);
nextc = fgetc (fp);
}
putc (ch, ft);
}
fclose (fp);
fclose (ft);
return 0;
}
Hope this helps.

Answer 3

Your last else part is writing all characters which are not '/' and '*'.
I have changed your code below. *******Additional line ********* shows the changed parts. Try it and inform me?? good luckk...
#include<stdio.h>
main(int argc,char*argv[])
{
FILE *fp,*ft;
char ch;
int flag=0; //**********************additional line********
if(argc<3)
{
printf("No file name given");
}
fp=fopen(argv[1],"r");
ft=fopen(argv[2],"w");
if(fp==NULL)
printf("Opening error");
if(ft==NULL)
printf("Opening error");
while(1)
{
ch=fgetc(fp);
if(ch==EOF)
break;
if(ch=='/')
{
ch=fgetc(fp);
if(ch=='*')
{
flag=1; //**********************additional line********
putc(' ',ft);
}
}
else if (ch=='*')
{
ch=fgetc(fp);
if(ch=='/')
{
flag=0;//**********************additional line********
putc(' ',ft);
}
}
if(flag==0) //**********************additional line********
{
putc(ch,ft);
}
}
fclose(fp);
fclose(ft);
}

Answer 4

Just change the line in above code
while ((ch != '*') && (nextc != '/'))
to
while (!((ch == '*') && (nextc == '/')))

Answer 5

For this question most of the answers handled only multi line comment (/..../) but there may be single (//....) line comment as well.
So to handle single line comment slight modification is there in krouis 's code.
#include <stdio.h>
int main (int argc, char *argv[])
{
FILE *fp, *ft;
char ch, nextc;
if (argc < 3)
{
printf ("No file name given");
}
fp = fopen (argv[1], "r");
ft = fopen (argv[2], "w");
if (fp == NULL)
printf ("Opening error");
if (ft == NULL)
printf ("Opening error");
nextc = fgetc (fp);
while (nextc != EOF)
{
ch = nextc;
nextc = fgetc (fp);
if ((ch == '/') && (nextc == '*'))
{
ch = fgetc (fp);
nextc = fgetc (fp);
while (!((ch == '*') && (nextc == '/'))) /* unroll until the end of comment*/
{
ch = nextc;
nextc = fgetc (fp);
}
nextc = fgetc (fp);
continue;
}else if((ch=='/') && (nextc == '/')) // block to handle single line comment.
{
nextc = fgetc (fp);
while (!(nextc == '\n')){
nextc = fgetc (fp);
}
nextc = fgetc (fp);
continue;
}
putc (ch, ft);
}
fclose (fp);
fclose (ft);
return 0;
}

Answer 6

/* This file is to remove all comments from a c/c++ source file */
/* Modified by John Dai 2020-05-06 */
#include <stdio.h>
int main (void)
{
char *sourceFile = "D:/Temp/MyCfile.cpp"; //your source code
char *outputFile = "D:/Temp/MyCfileWoComments.cpp"; //output file
FILE *fp, *ft;
char ch, nextc;
fp = fopen (sourceFile, "r");
ft = fopen (outputFile, "w");
if (fp == NULL) {printf ("Error in opening source file\n"); return 1;}
if (ft == NULL) {printf ("Error in opening output file\n"); return 1;}
nextc = fgetc (fp);
while (nextc != EOF)
{
ch = nextc;
nextc = fgetc (fp);
if ((ch == '/') && (nextc == '/'))
{
nextc = fgetc (fp);
while (nextc != '\n') {// move to the end of line
nextc = fgetc (fp);
}
ch = nextc; //end of line character
nextc = fgetc(fp); //read 1st character from a new line
}
else if ((ch == '/') && (nextc == '*')){
{
nextc = fgetc (fp);
while (!((ch == '*') && (nextc == '/'))) {/* move to the end of comment*/
ch = nextc;
nextc = fgetc (fp);
}
ch = fgetc (fp); //read first character after the end of comment block
nextc = fgetc (fp);
}
}
putc (ch, ft);
}
fclose (fp);
fclose (ft);
return 0;
}

Answer 7

you can try something like this:
#include <stdio.h>
#include <string.h>
#define READ 0
#define SINGLE_LINE_COMMENT 1
#define MULTILINE_COMMENT 2
#define STRING_READ 3
#define CHAR_READ 4
int row = 1;
int col = 0;
int er_line = 0;
int er_col = 0;
void read_source(FILE *src, FILE *dst, int flag, char prev_char, int past_read)
{
if (feof(src))
{
if (flag == STRING_READ)
{
printf("Error : non-terminatig string at line :%d col :%d \n", er_line, er_col);
}
if (flag == CHAR_READ)
{
printf("Error : non-terminatig char constant at line :%d col :%d \n", er_line, er_col);
}
if (flag == MULTILINE_COMMENT)
{
printf("Error : comment reach to end of file at line :%d col :%d \n", er_line, er_col);
}
fclose(src);
fclose(dst);
return;
}
char ch = fgetc(src);
past_read++;
if (ch == '\n')
{
row++;
col = 0;
}
else
{
col++;
}
char next_ch = '\0';
switch (ch)
{
case '\n':
if (flag == SINGLE_LINE_COMMENT)
{
flag = READ;
past_read = 0;
}
else
{
if (flag == STRING_READ)
{
printf("Error : non-terminatig string at line :%d col :%d \n", er_line, er_col);
return;
}
if (flag == CHAR_READ)
{
printf("Error : non-terminatig char constant at line :%d col :%d \n", er_line, er_col);
return;
}
}
break;
case '/':
next_ch = fgetc(src);
if (next_ch == '/')
{
if (flag != STRING_READ && flag != CHAR_READ && flag != SINGLE_LINE_COMMENT && flag != MULTILINE_COMMENT)
{
flag = SINGLE_LINE_COMMENT;
er_line = row;
er_col = col;
past_read = 0;
}
}
else
{
if (next_ch == '*')
{
if (flag != STRING_READ && flag != CHAR_READ && flag != SINGLE_LINE_COMMENT && flag != MULTILINE_COMMENT)
{
flag = MULTILINE_COMMENT;
er_line = row;
er_col = col;
past_read = 0;
}
}
else
{
fseek(src, -1, SEEK_CUR);
}
}
break;
case '"':
if (prev_char != '\\')
{
if (flag == STRING_READ)
{
flag = READ;
past_read = 0;
}
else
{
if (flag != STRING_READ && flag != CHAR_READ && flag != SINGLE_LINE_COMMENT && flag != MULTILINE_COMMENT)
{
flag = STRING_READ;
er_line = row;
er_col = col;
past_read = 0;
}
}
}
break;
case '\'':
if (prev_char != '\\')
{
if (flag == CHAR_READ)
{
flag = READ;
past_read = 0;
}
else
{
if (flag != STRING_READ && flag != CHAR_READ && flag != SINGLE_LINE_COMMENT && flag != MULTILINE_COMMENT)
{
flag = CHAR_READ;
er_line = row;
er_col = col;
past_read = 0;
}
}
}
else
{
if (flag == CHAR_READ)
{
if (past_read > 2)
{
flag = READ;
past_read = 0;
}
}
}
break;
case '*':
if (flag == MULTILINE_COMMENT)
{
next_ch = fgetc(src);
if (next_ch == '/')
{
ch = '\0';
flag = READ;
past_read = 0;
}
else
{
fseek(src, -1, SEEK_CUR);
}
}
break;
}
//to work with char constant
if (flag == CHAR_READ)
{
if (ch != '\\')
{
if (prev_char != '\\')
{
if (past_read > 3)
{
printf(" Error : non-terminatig char constant at line :%d col :%d\n", er_line, er_col);
return;
}
}
}
else
{
if (past_read > 3)
{
printf(" Error : non-terminatig char constant at line :%d col :%d\n", er_line, er_col);
return;
}
}
}
if (flag != MULTILINE_COMMENT && flag != SINGLE_LINE_COMMENT && ch != '\0' && ch != EOF)
{
fputc(ch, dst);
}
read_source(src, dst, flag, ch, past_read);
return;
}
int main(int argc, char **argv)
{
FILE *fp = fopen(argv[1], "r");
FILE *fp2 = NULL;
if (fp == NULL)
{
printf("Unable to open file %s\n", argv[1]);
return 0;
}
fp2 = fopen(argv[2], "w");
if (fp2 == NULL)
{
printf("Unable to open file %s\n", argv[2]);
}
read_source(fp, fp2, READ, '\0', 0);
return 0;
}