int/interpret.c

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