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                         stack[sp++] = f16(pc);
  41                         pc+=2;
  42                         break;
  43                 case BCPOP: trace("pop");
  44                         sp--;
  45                         break;
  46                 case BCSDSSTORE: trace("sds store: %d", f16(pc));
  47                         sds_store(f16(pc), stack[--sp]);
  48                         pc+=2;
  49                         break;
  50                 case BCSDSFETCH: trace("sds fetch: %d", f16(pc));
  51                         stack[sp++] = sds_fetch(f16(pc));
  52                         pc+=2;
  53                         break;
  54                 case BCSDSPUBLISH: trace("sds publish %d", f16(pc));
  55                         sds_publish(f16(pc));
  56                         pc+=2;
  57                         break;
  58                 case BCNOT: trace("not");
  59                         stack[sp] = stack[sp] > 0 ? 0 : 1;
  60                         break;
  61                 case BCADD: trace("add");
  62                         stack[sp-2] = stack[sp-2] + stack[sp-1];
  63                         sp -= 1;
  64                         break;
  65                 case BCSUB: trace("sub");
  66                         stack[sp-2] = stack[sp-2] - stack[sp-1];
  67                         sp -= 1;
  68                         break;
  69                 case BCMUL: trace("mul");
  70                         stack[sp-2] = stack[sp-2] * stack[sp-1];
  71                         sp -= 1;
  72                         break;
  73                 case BCDIV: trace("div");
  74                         stack[sp-2] = stack[sp-2] / stack[sp-1];
  75                         sp -= 1;
  76                         break;
  77                 case BCAND: trace("and");
  78                         stack[sp-2] = stack[sp-2] && stack[sp-1];
  79                         sp -= 1;
  80                         break;
  81                 case BCOR: trace("or");
  82                         stack[sp-2] = stack[sp-2] || stack[sp-1];
  83                         sp -= 1;
  84                         break;
  85                 case BCEQ: trace("eq");
  86                         stack[sp-2] = stack[sp-2] == stack[sp-1];
  87                         sp -= 1;
  88                         break;
  89                 case BCNEQ: trace("neq");
  90                         stack[sp-2] = stack[sp-2] != stack[sp-1];
  91                         sp -= 1;
  92                         break;
  93                 case BCLES: trace("les");
  94                         stack[sp-2] = stack[sp-2] < stack[sp-1];
  95                         sp -= 1;
  96                         break;
  97                 case BCGRE: trace("gre");
  98                         stack[sp-2] = stack[sp-2] > stack[sp-1];
  99                         sp -= 1;
 100                         break;
 101                 case BCLEQ: trace("leq");
 102                         stack[sp-2] = stack[sp-2] <= stack[sp-1];
 103                         sp -= 1;
 104                         break;
 105                 case BCGEQ: trace("geq");
 106                         stack[sp-2] = stack[sp-2] >= stack[sp-1];
 107                         sp -= 1;
 108                         break;
 109                 case BCJMP: trace("jmp to %d", program[pc]);
 110                         pc = program[pc]-1;
 111                         break;
 112                 case BCJMPT: trace("jmpt to %d", program[pc]);
 113                         pc = stack[--sp] ? program[pc]-1 : pc+1;
 114                         break;
 115                 case BCJMPF: trace("jmpf(%d) to %d", stack[sp-1], program[pc]);
 116                         pc = stack[--sp] ? pc+1 : program[pc]-1;
 117                         break;
 118                 case BCSERIALAVAIL: trace("SerialAvailable()");
 119                         break;
 120                 case BCSERIALPRINT: trace("SerialPrint()");
 121                         break;
 122                 case BCSERIALPRINTLN: trace("SerialPrintln()");
 123                         break;
 124                 case BCSERIALREAD: trace("SerialRead()");
 125                         break;
 126                 case BCSERIALPARSEINT: trace("SerialParseInt()");
 127                         break;
 128                 case BCANALOGREAD: trace("AnalogRead(%d)", program[pc]);
 129                         stack[sp++] = read_apin(program[pc++]);
 130                         break;
 131                 case BCANALOGWRITE: trace("AnalogWrite(%d)", program[pc]);
 132                         write_apin(program[pc++], stack[sp-1]);
 133                         sp--;
 134                         break;
 135                 case BCDIGITALREAD: trace("DigitalRead(%d)", program[pc]);
 136                         stack[sp++] = read_dpin(program[pc++]);
 137                         break;
 138                 case BCDIGITALWRITE: trace("DigitalWrite(%d)", program[pc]);
 139                         write_dpin(program[pc++], stack[sp-1]);
 140                         sp--;
 141                         break;
 142                 case BCLEDON: trace("LedOn(%d)", program[pc]);
 143                         led_on(stack[sp-1]);
 144                         sp--;
 145                         break;
 146                 case BCLEDOFF: trace("LedOn(%d)", program[pc]);
 147                         led_off(stack[sp-1]);
 148                         sp--;
 149                         break;
 150                 default:
 151                         trace("unrecognized");
 152                         die("Unrecognized command: %d", program[pc-1]);
 153                 }
 154         }
 155         debug("Task terminated");
 156 }