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