You are thinking about this "from the wrong side". I suggest you read again what i said about parsers reading one character at a time and applying rules to it. I'll take our phantasy-shell example and show you a solution to this, you will still have to come up with a solution for your original problem:

At first, we need some "memory" to remember what we have read so far. Memory comes in the form of status flags (TRUE/FALSE) , which we maintain while reading the code. We start with one for remembering the escape-sequence. We need to do this first, because escaping the strongest "coupling" construct of a language. It is like operator precedence: this is the "operator" with the highest precedence so we have to take care of this first *):

Code:

next_character_is_escaped=false # we have to interpret the next character

WHILE not at the end of the input file
      read a character
      
      IF next_character_is_escaped != true
           [... we will have to work on the character further here ...]
      ELSE
           next_character_is_escaped=false
      END IF

      output the read character

END WHILE

You see, the loop does nothing more than to read one character at a time and maintain a status flag for escaped characters. This relates to the "rule 2" of my last posting.

I suggest you take a piece of paper and try to go through a real script with this pseudo-program "by hand" to see how the status flags are maintained and the logic works (the same for the other pieces of code to follow - this is a invaluable exercise in grasping programming constructs, believe me! *) ). You see that what the escaped-status-flag does is to exclude the next character from being interpreted by the logic (the "further work") we are going to apply now. Let's start with quoting (i ignore single quotes here to keep the example short - this doesn't mean we could forget about them in the real world):

Code:

inside_a_quote=false          # we are not between "..." right now
next_character_is_escaped=false # we have to interpret the next character

WHILE not at the end of the input file
      read a character

      IF next_character_is_escaped != true
           CASE the read character is
                - the escape char
                     next_character_is_escaped=true

                - the quote char
                     IF inside_a_quote == true
                          inside_a_quote=false
                     ELSE
                          inside_a_quote=true
                     END IF 

           END CASE
      ELSE
           next_character_is_escaped=false
      END IF

      output the read character

END WHILE

The added logic just flips the inside-quote-status flag when we encounter double quotes (actually: double quotes which aren't escaped). Now, that we have covered what was "rule 1" in my last posting we are ready to tackle the comments themselves:

Notice, that applying a rule to the character read is indeed changing the way we are applying the following rules: if rule 1 says "don't look at the character any further" this means that rule 3 won't be applied to it, because there is "nothing any more that it could be applied to", so to say.

I have added some logic at the end to let you see if the program correctly catches all instances of comments. Again, i suggest you "execute" it by hand with a piece of paper to see its operation.

Code:

inside_a_quote=false          # we are not between "..." right now
inside_a_comment=false        # we are not between a comment-start and a comment-end
next_character_is_escaped=false # we have to interpret the next character

WHILE not at the end of the input file
      read a character

      IF next_character_is_escaped != true
           CASE the read character is
                - the escape char
                     next_character_is_escaped=true

                - the quote char
                     IF inside_a_quote == true
                          inside_a_quote=false
                     ELSE
                          inside_a_quote=true
                     END IF

                - the comment-start char
                     IF inside_a_quote == false
                          inside_a_comment=true
                     END IF

                - the comment-end char
                     IF inside_a_quote == false
                          inside_a_comment=false
                     END IF

           END CASE
      ELSE
           next_character_is_escaped=false
      END IF

      IF inside_a_comment == false
           output the read character in black
      ELSE
           output the read character in red
      END IF

END WHILE

Some notes reagrding your own program: you will notice that (unlike in my example) there is not a "comment-start character" but a "comment-start SEQUENCE". You will have to implement additional status flags to catch these sequences.

Put your efforts here, in pseudo-code like i did, and we will discuss your solution and finally implement the program itself.

I hope this helps.

bakunin
__________

*) This is easily shown by looking at this: "\"" . If the quoting would be primary and the escaping secondary the escaping would not take place because of being inside a quote. And the output would be 2 characters (backslash-quote sign). There would be no way to have the double quote character inside a quoted string. As it is escaping takes place before quoting and therefore the string means "an escaped double-quote sign inside a quoted string" and this accomplishes the "double-quote inside a quoted string" just fine.

*) Alan Turing did exactly this with his first try at a chess program.