int/int.c

   1 #include <stdio.h>
   2 #include <stdbool.h>
   3
   4 #include "mTaskSymbols.h"
   5
   6 #define STACKSIZE 1024
   7 #define PROGRAMSIZE 1024
   8
   9 #define DEBUG
  10 #ifdef DEBUG
  11 #define debug(s, ...) printf(s, ##__VA_ARGS__);
  12 #else
  13 #define debug(s, ...) ;
  14 #endif
  15
  16 #define die(s, ...) {fprintf(stderr, s, ##__VA_ARGS__); return 1;}
  17
  18 char program[PROGRAMSIZE+1] = {0};
  19 int stack[STACKSIZE+1] = {0};
  20
  21 bool input_available(){
  22         struct timeval tv;
  23         fd_set fds;
  24         tv.tv_sec = 0;
  25         tv.tv_usec = 0;
  26         FD_ZERO(&fds);
  27         FD_SET(0, &fds);
  28         select(1, &fds, NULL, NULL, &tv);
  29         return FD_ISSET(0, &fds);
  30 }
  31
  32
  33 int main(void)
  34 {
  35         char c;
  36         int pl, sp, pc;
  37
  38         //Read program
  39         pc = 0;
  40         while ((c = getchar()) != EOF && pc < PROGRAMSIZE)
  41                 program[pc++] = c;
  42         if (pc >= PROGRAMSIZE)
  43                 die("Max program size: %d\n", PROGRAMSIZE);
  44         pl = pc;
  45         debug("Done reading, program length: %d\n", pl);
  46
  47         //Evaluate program
  48         //Reset program counter and stack counter
  49         pc = 0;
  50         sp = 0;
  51         while(pc != pl){
  52                 switch(program[pc++]){
  53                 case BCNop:;
  54                         break;
  55                 case BCPush:
  56                         stack[sp++] = program[pc++];
  57                         break;
  58                 case BCPop:
  59                         sp--;
  60                         break;
  61                 case BCNot:
  62                         stack[sp] = stack[sp] > 0 ? 0 : 1;
  63                         break;
  64                 case BCAdd:
  65                         stack[sp-1] = stack[sp] + stack[sp-1];
  66                         sp -= 1;
  67                         break;
  68                 case BCSub:
  69                         stack[sp-1] = stack[sp] - stack[sp-1];
  70                         sp -= 1;
  71                         break;
  72                 case BCMul:
  73                         stack[sp-1] = stack[sp] * stack[sp-1];
  74                         sp -= 1;
  75                         break;
  76                 case BCDiv:
  77                         stack[sp-1] = stack[sp] / stack[sp-1];
  78                         sp -= 1;
  79                         break;
  80                 case BCAnd:
  81                         stack[sp-1] = stack[sp] && stack[sp-1];
  82                         sp -= 1;
  83                         break;
  84                 case BCOr:
  85                         stack[sp-1] = stack[sp] || stack[sp-1];
  86                         sp -= 1;
  87                         break;
  88                 case BCEq:
  89                         stack[sp-1] = stack[sp] == stack[sp-1];
  90                         sp -= 1;
  91                         break;
  92                 case BCNeq:
  93                         stack[sp-1] = stack[sp] != stack[sp-1];
  94                         sp -= 1;
  95                         break;
  96                 case BCLes:
  97                         stack[sp-1] = stack[sp] < stack[sp-1];
  98                         sp -= 1;
  99                         break;
 100                 case BCGre:
 101                         stack[sp-1] = stack[sp] > stack[sp-1];
 102                         sp -= 1;
 103                         break;
 104                 case BCLeq:
 105                         stack[sp-1] = stack[sp] <= stack[sp-1];
 106                         sp -= 1;
 107                         break;
 108                 case BCGeq:
 109                         stack[sp-1] = stack[sp] >= stack[sp-1];
 110                         sp -= 1;
 111                         break;
 112                 case BCJmp:
 113                         pc = pc + program[pc];
 114                         break;
 115                 case BCJmpT:
 116                         pc += stack[sp] ? program[pc] : 1;
 117                         break;
 118                 case BCJmpF:
 119                         pc += stack[sp] ? 1 : program[pc];
 120                         break;
 121                 case BCSERIALAVAIL:
 122                         printf("SerialAvailable()\n");
 123                         break;
 124                 case BCSERIALPRINT:
 125                         printf("SerialPrint()\n");
 126                         break;
 127                 case BCSERIALPRINTLN:
 128                         printf("SerialPrintln()\n");
 129                         break;
 130                 case BCSERIALREAD:
 131                         printf("SerialRead()\n");
 132                         break;
 133                 case BCSERIALPARSEINT:
 134                         printf("SerialParseInt()\n");
 135                         break;
 136                 case BCANALOGREAD:
 137                         printf("AnalogRead()\n");
 138                         break;
 139                 case BCANALOGWRITE:
 140                         printf("AnalogWrite()\n");
 141                 default:
 142                         die("Unrecognized command: %X\n", program[--pc]);
 143                 }
 144         }
 145         return 0;
 146 }