client/interpret.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3
   4 #include "mTaskSymbols.h"
   5 #include "interpret.h"
   6 #include "interface.h"
   7 #include "task.h"
   8 #include "sds.h"
   9
  10 #ifdef STM
  11 #define trace(op, ...) {};
  12 #else
  13 #define trace(op, ...) {};
  14 //#define trace(op, ...) printf("pc: %d, sp: %d, op: " op "\n", pc, sp, ##__VA_ARGS__);
  15 #endif
  16
  17 #define f16(p) program[pc]*265+program[pc+1]
  18
  19 void run_task(struct task *t)
  20 {
  21         uint8_t *program = t->bc;
  22         int plen = t->tlen;
  23         int pc = 0;
  24         int sp = 0;
  25         char stack[STACKSIZE] = {0};
  26         debug("Running task with length: %d", plen);
  27         while(pc < plen){
  28 //              debug("program: %d", program[pc]);
  29 //              debug("stack: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
  30 //                      stack[0], stack[1], stack[2], stack[3], stack[4],
  31 //                      stack[5], stack[6], stack[7], stack[8], stack[9]);
  32
  33                 switch(program[pc++]){
  34                 case BCNOP: trace("nop");
  35                         break;
  36                 case BCLAB: trace("label: 0x%02x!!!!!!", program[pc]);
  37                         pc++;
  38                         break;
  39                 case BCPUSH: trace("push %d", program[pc]*265+program[pc+1]);
  40                         switch(program[pc++]){
  41                         //Long
  42                         case 'l':
  43                         //Int
  44                         case 'i':
  45                                 stack[sp++] = f16(pc);
  46                                 pc+=2;
  47                                 break;
  48                         case 'b': //Bool
  49                         case 'c': //Character
  50                         case 'B': //Button
  51                         case 'L': //UserLED
  52                                 stack[sp++] = program[pc++];
  53                                 break;
  54                         }
  55                         break;
  56                 case BCPOP: trace("pop");
  57                         sp--;
  58                         break;
  59                 case BCSDSSTORE: trace("sds store: %d", f16(pc));
  60                         sds_store(f16(pc), stack[--sp]);
  61                         pc+=2;
  62                         break;
  63                 case BCSDSFETCH: trace("sds fetch: %d", f16(pc));
  64                         stack[sp++] = sds_fetch(f16(pc));
  65                         pc+=2;
  66                         break;
  67                 case BCSDSPUBLISH: trace("sds publish %d", f16(pc));
  68                         sds_publish(f16(pc));
  69                         pc+=2;
  70                         break;
  71                 case BCNOT: trace("not");
  72                         stack[sp] = stack[sp] > 0 ? 0 : 1;
  73                         break;
  74                 case BCADD: trace("add");
  75                         stack[sp-2] = stack[sp-2] + stack[sp-1];
  76                         sp -= 1;
  77                         break;
  78                 case BCSUB: trace("sub");
  79                         stack[sp-2] = stack[sp-2] - stack[sp-1];
  80                         sp -= 1;
  81                         break;
  82                 case BCMUL: trace("mul");
  83                         stack[sp-2] = stack[sp-2] * stack[sp-1];
  84                         sp -= 1;
  85                         break;
  86                 case BCDIV: trace("div");
  87                         stack[sp-2] = stack[sp-2] / stack[sp-1];
  88                         sp -= 1;
  89                         break;
  90                 case BCAND: trace("and");
  91                         stack[sp-2] = stack[sp-2] && stack[sp-1];
  92                         sp -= 1;
  93                         break;
  94                 case BCOR: trace("or");
  95                         stack[sp-2] = stack[sp-2] || stack[sp-1];
  96                         sp -= 1;
  97                         break;
  98                 case BCEQ: trace("eq");
  99                         stack[sp-2] = stack[sp-2] == stack[sp-1];
 100                         sp -= 1;
 101                         break;
 102                 case BCNEQ: trace("neq");
 103                         stack[sp-2] = stack[sp-2] != stack[sp-1];
 104                         sp -= 1;
 105                         break;
 106                 case BCLES: trace("les");
 107                         stack[sp-2] = stack[sp-2] < stack[sp-1];
 108                         sp -= 1;
 109                         break;
 110                 case BCGRE: trace("gre");
 111                         stack[sp-2] = stack[sp-2] > stack[sp-1];
 112                         sp -= 1;
 113                         break;
 114                 case BCLEQ: trace("leq");
 115                         stack[sp-2] = stack[sp-2] <= stack[sp-1];
 116                         sp -= 1;
 117                         break;
 118                 case BCGEQ: trace("geq");
 119                         stack[sp-2] = stack[sp-2] >= stack[sp-1];
 120                         sp -= 1;
 121                         break;
 122                 case BCJMP: trace("jmp to %d", program[pc]);
 123                         pc = program[pc]-1;
 124                         break;
 125                 case BCJMPT: trace("jmpt to %d", program[pc]);
 126                         pc = stack[--sp] ? program[pc]-1 : pc+1;
 127                         break;
 128                 case BCJMPF: trace("jmpf(%d) to %d", stack[sp-1], program[pc]);
 129                         pc = stack[--sp] ? pc+1 : program[pc]-1;
 130                         break;
 131                 case BCSERIALAVAIL: trace("SerialAvailable()");
 132                         break;
 133                 case BCSERIALPRINT: trace("SerialPrint()");
 134                         break;
 135                 case BCSERIALPRINTLN: trace("SerialPrintln()");
 136                         break;
 137                 case BCSERIALREAD: trace("SerialRead()");
 138                         break;
 139                 case BCSERIALPARSEINT: trace("SerialParseInt()");
 140                         break;
 141 #if HAVEAIO == 1
 142                 case BCANALOGREAD: trace("AnalogRead(%d)", program[pc]);
 143                         stack[sp++] = read_apin(program[pc++]);
 144                         break;
 145                 case BCANALOGWRITE: trace("AnalogWrite(%d)", program[pc]);
 146                         write_apin(program[pc++], stack[sp-1]);
 147                         sp--;
 148                         break;
 149 #endif
 150 #if HAVEDIO == 1
 151                 case BCDIGITALREAD: trace("DigitalRead(%d)", program[pc]);
 152                         stack[sp++] = read_dpin(program[pc++]);
 153                         break;
 154                 case BCDIGITALWRITE: trace("DigitalWrite(%d)", program[pc]);
 155                         write_dpin(program[pc++], stack[sp-1]);
 156                         sp--;
 157                         break;
 158 #endif
 159 #if HAVELED == 1
 160                 case BCLEDON: trace("LedOn(%d)", program[pc]);
 161                         led_on(stack[sp-1]);
 162                         sp--;
 163                         break;
 164                 case BCLEDOFF: trace("LedOn(%d)", program[pc]);
 165                         led_off(stack[sp-1]);
 166                         sp--;
 167                         break;
 168 #endif
 169                 default:
 170                         trace("unrecognized");
 171                         die("Unrecognized command: %d", program[pc-1]);
 172                 }
 173         }
 174         debug("Task terminated");
 175 }