## Java 8 - 354 bytes

Golfed version:

<!-- language: lang-java -->

    import java.util.*;class C{static int i,j;public static void main(String[]z){boolean[]b=new boolean[256];List o=Arrays.asList("chew","swallow","vomit","complain","feedtodog","playwithfood");Runnable[]r={()->b[i]=!b[i],()->i++,()->i--,()->System.out.print(b[i]?1:0),()->j+=b[i]?1:0,()->j-=b[i]?3:0};for(;;){r[o.indexOf(z[j])].run();i=i<0|i>255?0:i;j++;}}}

Somewhat ungolfed version (whitespaces and comments added):

<!-- language: lang-java -->

    // Needed for java.util.List and java.util.Arrays.
    import java.util.*;

    class C {
        // Declared as static so they may be changed inside the lambdas without the compiler complaining about that.
        // i is the bit index and j is the instruction pointer.
        static int i, j;
    
        public static void main(String[] z) {
            // The array.
            boolean[] b = new boolean[256];
    
            // Declared as a list so we can use the indexOf method further down. Screw up the generics.
            List o = Arrays.asList("chew", "swallow", "vomit", "complain", "feedtodog", "playwithfood");
    
            // An array of lambdas.
            Runnable[] r = {
                () -> b[i] = !b[i], // chew
                () -> i++, // swallow
                () -> i--, // vomit
                () -> System.out.print(b[i] ? 1 : 0), // complain
                () -> j += b[i] ? 1 : 0, // feedtodog. It is 1 and 0 instead of 2 and 1 due to the j++ down there.
                () -> j -= b[i] ? 3 : 0 // playwithfood. It is -3 and 0 instead of -2 and +1 due to the j++ down there.
            };
    
            // This is the interpreter itself. Runs forever (or until an exception is raised).
            for (;;) {
                // Fetch an instruction and runs it. Throws an exception on unknown or mistyped instructions.
                r[o.indexOf(z[j])].run();
    
                // Resets the bit index if out of range.
                i = i < 0 | i > 255 ? 0 : i;
    
                // Next instruction. No special treatment for branching needed because the branching instructions already considers this.
                j++;
            }
        }
    }

This is a quick and dirty version that I made. It could probably be somewhat shorter, but I done this in just a few minutes.

We surely should have testcases. I am not sure if there is some bug hiding out there.

Anyway I run it with that (input is given as command line arguments):

<!-- language: lang-none -->

    chew complain swallow chew complain swallow chew complain swallow complain

And here is the output:

    1110
    Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    	at C.main(C.java:1)

The `ArrayIndexOutOfBoundsException` is the standard way to finish the program, it is not a bug!