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