controllerdata.cpp

   1 #include "lsnes.hpp"
   2 #include "controllerdata.hpp"
   3 #include <sstream>
   4 #include <cctype>
   5 #include <iostream>
   6 #include <cstring>
   7
   8
   9 namespace
  10 {
  11         inline unsigned ccindex(unsigned port, unsigned controller, unsigned control) throw(std::logic_error)
  12         {
  13                 if(port >= MAX_PORTS || controller >= MAX_CONTROLLERS_PER_PORT || control >= CONTROLLER_CONTROLS) {
  14                         std::ostringstream x;
  15                         x << "ccindex: Invalid (port, controller, control) tuple (" << port << "," << controller
  16                                 << "," << control << ")";
  17                         throw std::logic_error(x.str());
  18                 }
  19                 return MAX_SYSTEM_CONTROLS + port * CONTROLLER_CONTROLS * MAX_CONTROLLERS_PER_PORT +
  20                                 CONTROLLER_CONTROLS * controller + control;
  21         }
  22
  23         bool parse_button_ctrl(const std::string& str, size_t& pos) throw()
  24         {
  25                 if(pos >= str.length())
  26                         return false;
  27                 switch(str[pos]) {
  28                 case '.':
  29                 case ' ':
  30                 case '\t':
  31                         pos++;
  32                 case '|':
  33                         return false;
  34                 default:
  35                         pos++;
  36                         return true;
  37                 }
  38         }
  39
  40         short parse_number_ctrl(const std::string& str, size_t& pos) throw()
  41         {
  42                 char ch;
  43                 //Skip ws.
  44                 while(pos < str.length()) {
  45                         char ch = str[pos];
  46                         if(ch != ' ' && ch != '\t')
  47                                 break;
  48                         pos++;
  49                 }
  50                 //Read the sign if any.
  51                 if(pos >= str.length() || (ch = str[pos]) == '|')
  52                         return 0;
  53                 bool negative = false;
  54                 if(ch == '-') {
  55                         negative = true;
  56                         pos++;
  57                 }
  58                 if(ch == '+')
  59                         pos++;
  60
  61                 //Read numeric value.
  62                 int numval = 0;
  63                 while(pos < str.length() && isdigit(static_cast<unsigned char>(ch = str[pos]))) {
  64                         numval = numval * 10 + (ch - '0');
  65                         pos++;
  66                 }
  67                 if(negative)
  68                         numval = -numval;
  69
  70                 return static_cast<short>(numval);
  71         }
  72
  73         void parse_end_of_field(const std::string& str, size_t& pos) throw()
  74         {
  75                 while(pos < str.length() && str[pos] != '|')
  76                         pos++;
  77         }
  78 }
  79
  80 size_t cdecode::system(const std::string& line, size_t pos, short* controls, unsigned version) throw(std::bad_alloc,
  81         std::runtime_error)
  82 {
  83         controls[0] = parse_button_ctrl(line, pos);     //Frame sync.
  84         controls[1] = parse_button_ctrl(line, pos);     //Reset.
  85         controls[2] = parse_number_ctrl(line, pos);     //Reset cycles hi.
  86         controls[3] = parse_number_ctrl(line, pos);     //Reset cycles lo.
  87         parse_end_of_field(line, pos);
  88         return pos;
  89 }
  90
  91 size_t cdecode::none(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
  92         std::runtime_error)
  93 {
  94         return pos;
  95 }
  96
  97 size_t cdecode::gamepad(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
  98         std::runtime_error)
  99 {
 100         for(unsigned i = 0; i < 12; i++)
 101                 controls[ccindex(port, 0, i)] = parse_button_ctrl(line, pos);
 102         parse_end_of_field(line, pos);
 103         return pos;
 104 }
 105
 106 size_t cdecode::multitap(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
 107         std::runtime_error)
 108 {
 109         for(unsigned j = 0; j < 4; j++) {
 110                 for(unsigned i = 0; i < 12; i++)
 111                         controls[ccindex(port, j, i)] = parse_button_ctrl(line, pos);
 112                 parse_end_of_field(line, pos);
 113                 pos++;
 114         }
 115         return pos;
 116 }
 117
 118 size_t cdecode::mouse(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
 119         std::runtime_error)
 120 {
 121         controls[ccindex(port, 0, 2)] = parse_button_ctrl(line, pos);
 122         controls[ccindex(port, 0, 3)] = parse_button_ctrl(line, pos);
 123         controls[ccindex(port, 0, 0)] = parse_number_ctrl(line, pos);
 124         controls[ccindex(port, 0, 1)] = parse_number_ctrl(line, pos);
 125         parse_end_of_field(line, pos);
 126         return pos;
 127 }
 128
 129 size_t cdecode::superscope(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
 130         std::runtime_error)
 131 {
 132         controls[ccindex(port, 0, 2)] = parse_button_ctrl(line, pos);
 133         controls[ccindex(port, 0, 3)] = parse_button_ctrl(line, pos);
 134         controls[ccindex(port, 0, 4)] = parse_button_ctrl(line, pos);
 135         controls[ccindex(port, 0, 5)] = parse_button_ctrl(line, pos);
 136         controls[ccindex(port, 0, 0)] = parse_number_ctrl(line, pos);
 137         controls[ccindex(port, 0, 1)] = parse_number_ctrl(line, pos);
 138         parse_end_of_field(line, pos);
 139         return pos;
 140 }
 141
 142 size_t cdecode::justifier(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
 143         std::runtime_error)
 144 {
 145         controls[ccindex(port, 0, 2)] = parse_button_ctrl(line, pos);
 146         controls[ccindex(port, 0, 3)] = parse_button_ctrl(line, pos);
 147         controls[ccindex(port, 0, 0)] = parse_number_ctrl(line, pos);
 148         controls[ccindex(port, 0, 1)] = parse_number_ctrl(line, pos);
 149         parse_end_of_field(line, pos);
 150         return pos;
 151 }
 152
 153 size_t cdecode::justifiers(unsigned port, const std::string& line, size_t pos, short* controls) throw(std::bad_alloc,
 154         std::runtime_error)
 155 {
 156         for(unsigned i = 0; i < 2; i++) {
 157                 controls[ccindex(port, i, 2)] = parse_button_ctrl(line, pos);
 158                 controls[ccindex(port, i, 3)] = parse_button_ctrl(line, pos);
 159                 controls[ccindex(port, i, 0)] = parse_number_ctrl(line, pos);
 160                 controls[ccindex(port, i, 1)] = parse_number_ctrl(line, pos);
 161                 parse_end_of_field(line, pos);
 162                 pos++;
 163         }
 164         return pos;
 165 }
 166
 167 size_t cencode::system(char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 168 {
 169         buffer[bufferpos++] = controls[0] ? 'F' : '.';
 170         buffer[bufferpos++] = controls[1] ? 'R' : '.';
 171         if(controls[2] || controls[3]) {
 172                 bufferpos += sprintf(buffer + bufferpos, " %i %i", static_cast<int>(controls[2]),
 173                         static_cast<int>(controls[3]));
 174         }
 175         return bufferpos;
 176 }
 177
 178 size_t cencode::none(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 179 {
 180         return ENCODE_SPECIAL_NO_OUTPUT;
 181 }
 182
 183 size_t cencode::gamepad(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 184 {
 185         static const char* characters = "BYsSudlrAXLR";
 186         for(unsigned i = 0; i < 12; i++)
 187                 buffer[bufferpos++] = controls[ccindex(port, 0, i)] ? characters[i] : '.';
 188         return bufferpos;
 189 }
 190
 191 size_t cencode::multitap(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 192 {
 193         static const char* characters = "BYsSudlrAXLR";
 194         for(unsigned j = 0; j < 4; j++) {
 195                 for(unsigned i = 0; i < 12; i++)
 196                         buffer[bufferpos++] = controls[ccindex(port, j, i)] ? characters[i] : '.';
 197                 buffer[bufferpos++] = '|';
 198         }
 199         bufferpos--;    //Eat the last '|', it shouldn't be there.
 200         return bufferpos;
 201 }
 202
 203 size_t cencode::mouse(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 204 {
 205         bufferpos += sprintf(buffer + bufferpos, "%c%c %i %i", controls[ccindex(port, 0, 2)] ? 'L' : '.',
 206                 controls[ccindex(port, 0, 3)] ? 'R' : '.', static_cast<int>(controls[ccindex(port, 0, 0)]),
 207                 static_cast<int>(controls[ccindex(port, 0, 1)]));
 208         return bufferpos;
 209 }
 210
 211 size_t cencode::superscope(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 212 {
 213         bufferpos += sprintf(buffer + bufferpos, "%c%c%c%c %i %i", controls[ccindex(port, 0, 2)] ? 'T' : '.',
 214                 controls[ccindex(port, 0, 3)] ? 'C' : '.', controls[ccindex(port, 0, 4)] ? 'U' : '.',
 215                 controls[ccindex(port, 0, 5)] ? 'P' : '.', static_cast<int>(controls[ccindex(port, 0, 0)]),
 216                 static_cast<int>(controls[ccindex(port, 0, 1)]));
 217         return bufferpos;
 218 }
 219
 220 size_t cencode::justifier(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 221 {
 222         bufferpos += sprintf(buffer + bufferpos, "%c%c %i %i", controls[ccindex(port, 0, 2)] ? 'T' : '.',
 223                 controls[ccindex(port, 0, 3)] ? 'S' : '.', static_cast<int>(controls[ccindex(port, 0, 0)]),
 224                 static_cast<int>(controls[ccindex(port, 0, 1)]));
 225         return bufferpos;
 226 }
 227
 228 size_t cencode::justifiers(unsigned port, char* buffer, size_t bufferpos, const short* controls) throw(std::bad_alloc)
 229 {
 230         bufferpos += sprintf(buffer + bufferpos, "%c%c %i %i", controls[ccindex(port, 0, 2)] ? 'T' : '.',
 231                 controls[ccindex(port, 0, 3)] ? 'S' : '.', static_cast<int>(controls[ccindex(port, 0, 0)]),
 232                 static_cast<int>(controls[ccindex(port, 0, 1)]));
 233         buffer[bufferpos++] = '|';
 234         bufferpos += sprintf(buffer + bufferpos, "%c%c %i %i", controls[ccindex(port, 0, 2)] ? 'T' : '.',
 235                 controls[ccindex(port, 0, 3)] ? 'S' : '.', static_cast<int>(controls[ccindex(port, 0, 0)]),
 236                 static_cast<int>(controls[ccindex(port, 0, 1)]));
 237         return bufferpos;
 238 }
 239
 240
 241 unsigned ccindex2(unsigned port, unsigned controller, unsigned control) throw(std::logic_error)
 242 {
 243         return ccindex(port, controller, control);
 244 }
 245
 246
 247 controls_t controls_t::operator^(controls_t other) throw()
 248 {
 249         controls_t x;
 250         for(size_t i = 0; i < TOTAL_CONTROLS; i++)
 251                 x.controls[i] = controls[i] ^ ((i < MAX_SYSTEM_CONTROLS) ? 0 : other.controls[i]);
 252         return x;
 253 }
 254
 255 controls_t::controls_t(bool sync) throw()
 256 {
 257         memset(controls, 0, sizeof(controls));
 258         if(sync)
 259                 controls[CONTROL_FRAME_SYNC] = 1;
 260 }
 261
 262 const short& controls_t::operator()(unsigned port, unsigned controller, unsigned control) const throw(std::logic_error)
 263 {
 264         return controls[ccindex(port, controller, control)];
 265 }
 266
 267 const short& controls_t::operator()(unsigned control) const throw(std::logic_error)
 268 {
 269         if(control >= TOTAL_CONTROLS)
 270                 throw std::logic_error("controls_t::operator(): Invalid control index");
 271         return controls[control];
 272 }
 273
 274 short& controls_t::operator()(unsigned port, unsigned controller, unsigned control) throw(std::logic_error)
 275 {
 276         return controls[ccindex(port, controller, control)];
 277 }
 278
 279 short& controls_t::operator()(unsigned control) throw(std::logic_error)
 280 {
 281         if(control >= TOTAL_CONTROLS)
 282                 throw std::logic_error("controls_t::operator(): Invalid control index");
 283         return controls[control];
 284 }
 285
 286 controls_t::controls_t(const std::string& line, const std::vector<cdecode::fn_t>& decoders, unsigned version)
 287         throw(std::bad_alloc, std::runtime_error)
 288 {
 289         memset(controls, 0, sizeof(controls));
 290         size_t position = 0;
 291         position = cdecode::system(line, position, controls, version);
 292         for(unsigned i = 0; i < decoders.size(); i++) {
 293                 if(position < line.length() && line[position] == '|')
 294                         position++;
 295                 position = decoders[i](i, line, position, controls);
 296         }
 297 }
 298
 299 std::string controls_t::tostring(const std::vector<cencode::fn_t>& encoders) const throw(std::bad_alloc)
 300 {
 301         char buffer[1024];
 302         size_t linelen = 0, tmp;
 303         tmp = cencode::system(buffer, linelen, controls);
 304         for(unsigned i = 0; i < encoders.size(); i++) {
 305                 if(tmp != ENCODE_SPECIAL_NO_OUTPUT)
 306                         buffer[(linelen = tmp)++] = '|';
 307                 tmp = encoders[i](i, buffer, linelen, controls);
 308         }
 309         if(tmp != ENCODE_SPECIAL_NO_OUTPUT)
 310                 linelen = tmp;
 311         return std::string(buffer, buffer + linelen);
 312 }
 313
 314 bool controls_t::operator==(const controls_t& c) const throw()
 315 {
 316         for(size_t i = 0; i < TOTAL_CONTROLS; i++)
 317                 if(controls[i] != c.controls[i])
 318                         return false;
 319         return true;
 320 }
 321
 322
 323 const port_type& port_type::lookup(const std::string& name, bool port2) throw(std::bad_alloc,
 324         std::runtime_error)
 325 {
 326         for(unsigned i = 0; i <= PT_LAST_CTYPE; i++) {
 327                 if(name != port_types[i].name)
 328                         continue;
 329                 if(!port2 && !port_types[i].valid_port1)
 330                         throw std::runtime_error("Can't connect " + name + " to port #1");
 331                 return port_types[i];
 332         }
 333         throw std::runtime_error("Unknown port type '" + name + "'");
 334 }
 335
 336 port_type port_types[] = {
 337         { "none", cdecode::none, cencode::none, PT_NONE, 0, DT_NONE, true },
 338         { "gamepad", cdecode::gamepad, cencode::gamepad, PT_GAMEPAD, 1, DT_GAMEPAD, true },
 339         { "multitap", cdecode::multitap, cencode::multitap, PT_MULTITAP, 4, DT_GAMEPAD, true },
 340         { "mouse", cdecode::mouse, cencode::mouse, PT_MOUSE, 1, DT_MOUSE, true },
 341         { "superscope", cdecode::superscope, cencode::superscope, PT_SUPERSCOPE, 1, DT_SUPERSCOPE, false },
 342         { "justifier", cdecode::justifier, cencode::justifier, PT_JUSTIFIER, 1, DT_JUSTIFIER, false },
 343         { "justifiers", cdecode::justifiers, cencode::justifiers, PT_JUSTIFIERS, 2, DT_JUSTIFIER, false }
 344 };