This is unbelievable. It works so beautifully. I am done

with switch!
eudisd · Apr 25, 2011 · 2e48dfc · 2e48dfc
1 parent 1a7892f
commit 2e48dfc
Show file tree

Hide file tree

Showing 7 changed files with 35 additions and 11 deletions.
diff --git a/bin/c b/bin/c
diff --git a/examples/bin/c b/examples/bin/c
diff --git a/examples/bin/cvm b/examples/bin/cvm
diff --git a/src/compiler/c b/src/compiler/c
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
@@ -399,23 +399,38 @@ void Case()
 
     if(tk == TK_CASE){
         match("case");
+
+
+        /* The result of E() is pushed onto the stack right now, we must save it then
+           compare down the chain */
+
+        Instruction inst_hole, inst_dup, inst_junk, inst_eql;
+
+        /* The dup happens before the E() */
+        printf("%d: dup \n", code_count);
+
+        inst_dup.opcode = OP_DUP;
+        inst_dup.operand.i = 0;
+        code[code_count] = inst_dup;
+        code_count++;
+
         TYPE t = E();
         if(t != 'C' && t != 'I'){
             fprintf(stderr, "Error in switch statement!  Case must be integer constant!");
             exit(EXIT_FAILURE);
         }
         match(":");
 
-        /* The result of E() is pushed onto the stack right now, we must save it then
-           compare down the chain */
-
-        Instruction inst_hole;
-
-        printf("%d: dup \n", code_count);
+        /* generate code for equality test here */
 
-        code_count++;// There is a dup here
+        printf("%d: eql \n", code_count);
+        inst_eql.opcode = OP_EQL;
+        inst_eql.operand.i = 0;
+        code[code_count] = inst_eql;
+        code_count++;
 
         printf("%d: jfalse 0 (Dummy Hole) \n", code_count);
+
 
         /* Since this is the first case, we don't lookup the 
            to see if there already a case hole */
@@ -424,11 +439,20 @@ void Case()
 		inst_hole.operand.i = 0;
 		code[code_count] = inst_hole;
         case_hole = code_count;
-
 		code_count++;
+
         Statements();
+
+
+        code[case_hole].operand.i = code_count; /* Fill in hole before we are done in this case */
 
-        code[case_hole].operand.i = code_count;
+        /* Pop junk off the stack */
+        printf("%d: pop (Empty) \n", code_count);
+
+        inst_junk.opcode = OP_POPEMPTY;
+        inst_junk.operand.i = 0;
+        code[code_count] = inst_junk;
+        code_count++;
 
         Case();
     }

diff --git a/src/compiler/test.c b/src/compiler/test.c
@@ -1,5 +1,5 @@
 
-    switch(1){
+    switch(2){
         case 1:
             printf (1);
         case 2:

diff --git a/src/cvm/cvm.c b/src/cvm/cvm.c
@@ -168,7 +168,7 @@ void run(char *program)
                     break;
                 case OP_EQL:
                     stack[sp - 2].i = stack[sp - 2].i == stack[sp - 1].i;
-                    break;
+                    sp--;
                     break;
                 case OP_NEG:
                     stack[sp - 1].i = -stack[sp - 1].i;