C program that removes comments - c

Question

This was my first time posting so i apologize for poor format and or any unreasonable questions.
So i have been working on the "remove comments" program for some time and made progress but very minimal. I am new to C so I'm writing it using some basic functions and skills. The input file for the code does not require any functions to be read but instead is passed to the program using < in the terminal.
The text file that I'm using contains the following:
some/* crazy */stuff
some/* crazy */ stuff
some/*crazy /*crazy*/*/stuff
"some /* crazy */ stuff "
some/* "crazy" */ stuff
some/* crazy stuff
To test the different comment formats.
The code i have so far is:
#include <stdio.h>
#define IN_COMMENT 1
int main(int argc, char **argv)
{
int c;
while ((c=getchar())!=EOF)
{
if(c=='/'&&getchar()=='*')
{
while(c!='*' && getchar()!='/')
{
c = " ";
c= getchar();
}
}
if(c=='"')
{
c=getchar();
while(c!='"')
{
putchar(c);
c=getchar();
}
putchar(c);
}
}
putchar(c);
printf("done.\n");
return 0;
}
The thing is that i cannot figure out a way to set up a condition that would print out an error message when there is a case in which the comment is started but never closed, such as (some/* crazy stuff)
Another problem is that i cant seem to find the bug which when i run my program and input the text file omits the *, so when i input :
some/* crazy */stuff
some/* crazy */ stuff
some/*crazy /*crazy*/*/stuff
"some /* crazy */ stuff "
some/* "crazy" */ stuff
i end up getting the following:
some*stuff
some* stuff
some**/tuff
"some /* crazy */ stuff "
some* stuff
I cant figure out a way to fix the two issues. The professor suggested a different way of writing the program by defining different states, but when i tried that it was even more confusing.

Answer 1

Your description is focusing on the difference between operating on a stream and operating on a buffer. In both C and Java either technique is possible.
Here your task is to do the job in a stream situation, i.e. you cannot "look ahead" and you cannot "write backwards" - all you can do is retrieve the next character, update some variables if appropriate, and decide whether or not to output that character.
This is called a state machine; your main loop will read a character and then take different action based on what state your variables were in.
To get you started, you're going to need to store at least the following:
whether you are in a comment or not
If you're not in a comment, then whether you just read a /.
For example, if the latter state is set and you get a '*' then you would set the former state (and reset the latter).

Answer 2

Well, usual solution to this kind of problem is to make FSM. So, just make number of states and deаfine how each next letter will affect state, due to current state. Smth like
//#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//#include <conio.h>
#include <string.h>
typedef enum states {
CODE,
HASH_START,
STAR_END,
COMMENT
} states;
void main() {
FILE *input = NULL;
char c;
states state;
state = CODE;
input = fopen("C:/c/code.txt", "r");
if (input == NULL) {
exit(EXIT_FAILURE);
}
while (fscanf(input, "%c", &c) == 1) {
switch (c) {
case '/' :
switch (state) {
case CODE:
state = HASH_START;
break;
case STAR_END:
//a bit ugly here, but require less states. You can omit read next
//if use more states
fscanf(input, "%c", &c);
state = CODE;
break;
}
break;
case '*' :
switch (state) {
case HASH_START:
state = COMMENT;
break;
case COMMENT:
state = STAR_END;
break;
}
break;
default:
if (state == HASH_START) {
state = CODE;
}
}
if (state == CODE) {
printf("%c", c);
}
}
//_getch();
}
this code deletes only /**/. Write bigger diagram and complete code.

Answer 3

#include <stdio.h>
#if 0
Description :
To delete a comment by entering the C source from standard input.
// To delete a line break up (newline remain)
/**/ To allow the nest (standard does not allow)
also replaced with a single space（The request by the standard）
#endif
int main(void){
FILE *fp = stdin;
int ch, chn;
int nest_level=0;
#if 0
in_range_comment : /* this */
in_line_comment : //this
in_string : "this"
in_char_constnt : ' '
#endif
enum { none, in_line_comment, in_range_comment, in_string, in_char_constant } status;
status = none;
while(EOF!=(ch=fgetc(fp))){
switch(status){
case in_line_comment :
if(ch == '\n'){
status = none;
putchar(ch);
}
continue;
case in_range_comment :
if(ch == '*'){
chn = fgetc(fp);
if(chn == '/'){
if(--nest_level == 0){
status = none;
putchar(' ');
}
continue;
}
ungetc(chn, fp);
} else if(ch == '/'){
chn = fgetc(fp);
if(chn == '*'){
++nest_level;
continue;
}
ungetc(chn, fp);
}
continue;
case in_string :
if(ch == '\\'){
putchar(ch);
chn = fgetc(fp);
if(chn == '"'){
putchar(chn);
continue;
}
ungetc(chn, fp);
} else {
if(ch == '"')
status = none;
putchar(ch);
}
continue;
case in_char_constant :
if(ch == '\\'){
putchar(ch);
chn = fgetc(fp);
if(chn == '\''){
putchar(chn);
continue;
}
ungetc(chn, fp);
} else {
if(ch == '\'')
status = none;
putchar(ch);
}
continue;
case none :
switch(ch){
case '/':
if('/' == (chn = fgetc(fp))){
status = in_line_comment;
continue;
} else if('*' == chn){
status = in_range_comment;
++nest_level;
continue;
} else
ungetc(chn, fp);
putchar(ch);
break;
case '"':
status = in_string;
putchar(ch);
break;
case '\'':
status = in_char_constant;
putchar(ch);
break;
default:
putchar(ch);
}
}
}
return 0;
}