generic/memorywatch.cpp

   1 #include "memorywatch.hpp"
   2 #include "memorymanip.hpp"
   3 #include <cstdio>
   4 #include <cstdlib>
   5 #include <list>
   6 #include <iomanip>
   7 #include <stack>
   8 #include <cmath>
   9 #include <sstream>
  10
  11 std::string evaluate_watch(const std::string& expr) throw(std::bad_alloc)
  12 {
  13         std::stack<double> s;
  14         size_t y;
  15         std::string _expr = expr;
  16         std::string t;
  17         double a;
  18         double b;
  19         int d;
  20         for(size_t i = 0; i < expr.length(); i++) {
  21                 switch(expr[i]) {
  22                 case 'C':
  23                         y = expr.find_first_of("z", i);
  24                         if(y > expr.length())
  25                                 return "#syntax (noterm)";
  26                         t = _expr.substr(i + 1, y - i - 1);
  27                         if(t.length() > 2 && t.substr(0, 2) == "0x") {
  28                                 char* end;
  29                                 s.push(strtoull(t.c_str() + 2, &end, 16));
  30                                 if(*end)
  31                                         return "#syntax (badhex)";
  32                         } else {
  33                                 char* end;
  34                                 s.push(strtod(t.c_str(), &end));
  35                                 if(*end)
  36                                         return "#syntax (badnum)";
  37                         }
  38                         i = y;
  39                         break;
  40                 case 'R':
  41                         if(i + 1 == expr.length())
  42                                 return "#syntax (noparam)";
  43                         d = expr[++i] - '0';
  44                         a = s.top();
  45                         s.pop();
  46                         b = pow(10, d);
  47                         s.push(floor(b * a + 0.5) / b);
  48                         break;
  49                 case 'a':
  50                         if(s.size() < 1)
  51                                 return "#syntax (underflow)";
  52                         a = s.top();
  53                         s.pop();
  54                         s.push(atan(a));
  55                         break;
  56                 case 'A':
  57                         if(s.size() < 2)
  58                                 return "#syntax (underflow)";
  59                         a = s.top();
  60                         s.pop();
  61                         b = s.top();
  62                         s.pop();
  63                         s.push(atan2(a, b));
  64                         break;
  65                 case 'c':
  66                         if(s.size() < 1)
  67                                 return "#syntax (underflow)";
  68                         a = s.top();
  69                         s.pop();
  70                         s.push(cos(a));
  71                         break;
  72                 case 'r':
  73                         if(s.size() < 1)
  74                                 return "#syntax (underflow)";
  75                         a = s.top();
  76                         s.pop();
  77                         s.push(sqrt(a));
  78                         break;
  79                 case 's':
  80                         if(s.size() < 1)
  81                                 return "#syntax (underflow)";
  82                         a = s.top();
  83                         s.pop();
  84                         s.push(sin(a));
  85                         break;
  86                 case 't':
  87                         if(s.size() < 1)
  88                                 return "#syntax (underflow)";
  89                         a = s.top();
  90                         s.pop();
  91                         s.push(tan(a));
  92                         break;
  93                 case 'u':
  94                         if(s.size() < 1)
  95                                 return "#syntax (underflow)";
  96                         s.push(s.top());
  97                         break;
  98                 case 'p':
  99                         s.push(4 * atan(1));
 100                         break;
 101                 case '+':
 102                         if(s.size() < 2)
 103                                 return "#syntax (underflow)";
 104                         a = s.top();
 105                         s.pop();
 106                         b = s.top();
 107                         s.pop();
 108                         s.push(a + b);
 109                         break;
 110                 case '-':
 111                         if(s.size() < 2)
 112                                 return "#syntax (underflow)";
 113                         a = s.top();
 114                         s.pop();
 115                         b = s.top();
 116                         s.pop();
 117                         s.push(a - b);
 118                         break;
 119                 case '*':
 120                         if(s.size() < 2)
 121                                 return "#syntax (underflow)";
 122                         a = s.top();
 123                         s.pop();
 124                         b = s.top();
 125                         s.pop();
 126                         s.push(a * b);
 127                         break;
 128                 case 'i':
 129                         if(s.size() < 2)
 130                                 return "#syntax (underflow)";
 131                         a = s.top();
 132                         s.pop();
 133                         b = s.top();
 134                         s.pop();
 135                         s.push(a / b);
 136                         break;
 137                 case '/':
 138                         if(s.size() < 2)
 139                                 return "#syntax (underflow)";
 140                         a = s.top();
 141                         s.pop();
 142                         b = s.top();
 143                         s.pop();
 144                         s.push(static_cast<int64_t>(a / b));
 145                         break;
 146                 case '%':
 147                         if(s.size() < 2)
 148                                 return "#syntax (underflow)";
 149                         a = s.top();
 150                         s.pop();
 151                         b = s.top();
 152                         s.pop();
 153                         s.push(a - static_cast<int64_t>(a / b) * b);
 154                         break;
 155                 case 'b':
 156                         if(s.size() < 1)
 157                                 return "#syntax (underflow)";
 158                         a = s.top();
 159                         s.pop();
 160                         s.push(static_cast<int8_t>(memory_read_byte(a)));
 161                         break;
 162                 case 'B':
 163                         if(s.size() < 1)
 164                                 return "#syntax (underflow)";
 165                         a = s.top();
 166                         s.pop();
 167                         s.push(static_cast<uint8_t>(memory_read_byte(a)));
 168                         break;
 169                 case 'w':
 170                         if(s.size() < 1)
 171                                 return "#syntax (underflow)";
 172                         a = s.top();
 173                         s.pop();
 174                         s.push(static_cast<int16_t>(memory_read_word(a)));
 175                         break;
 176                 case 'W':
 177                         if(s.size() < 1)
 178                                 return "#syntax (underflow)";
 179                         a = s.top();
 180                         s.pop();
 181                         s.push(static_cast<uint16_t>(memory_read_word(a)));
 182                         break;
 183                 case 'd':
 184                         if(s.size() < 1)
 185                                 return "#syntax (underflow)";
 186                         a = s.top();
 187                         s.pop();
 188                         s.push(static_cast<int32_t>(memory_read_dword(a)));
 189                         break;
 190                 case 'D':
 191                         if(s.size() < 1)
 192                                 return "#syntax (underflow)";
 193                         a = s.top();
 194                         s.pop();
 195                         s.push(static_cast<uint32_t>(memory_read_dword(a)));
 196                         break;
 197                 case 'q':
 198                         if(s.size() < 1)
 199                                 return "#syntax (underflow)";
 200                         a = s.top();
 201                         s.pop();
 202                         s.push(static_cast<int64_t>(memory_read_qword(a)));
 203                         break;
 204                 case 'Q':
 205                         if(s.size() < 1)
 206                                 return "#syntax (underflow)";
 207                         a = s.top();
 208                         s.pop();
 209                         s.push(static_cast<uint64_t>(memory_read_qword(a)));
 210                         break;
 211                 default:
 212                         return "#syntax (illchar)";
 213                 }
 214         }
 215         if(s.empty())
 216                 return "#ERR";
 217         else {
 218                 char buffer[512];
 219                 sprintf(buffer, "%f", s.top());
 220                 return buffer;
 221         }
 222 }