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