fork/slippc

git clone https://git.julia.blue/fork/slippc

Patrick CrainFixed escape_json() breaking parsing of original_filename on Windows; bumped version to 0.7.162d6bb0

0.7.1
13.0 KiB449 linesraw
1#ifndef UTIL_H_
2#define UTIL_H_
3
4#if defined(__GNUC__) || defined(__GNUG__)
5#define swap32 __builtin_bswap32
6#define swap16 __builtin_bswap16
7#elif defined(_MSC_VER)
8#define swap32 _byteswap_ulong
9#define swap16 _byteswap_ushort
10#include <intrin.h>
11#endif
12
13#include <string.h>
14#include <iomanip>
15#include <iostream>
16#include <sstream>
17#include <fstream>
18#include <codecvt>
19#include <algorithm> //std::find
20#include <sys/stat.h> //std::find
21
22#include "lzma.h"
23
24#define BYTE8(b1,b2,b3,b4,b5,b6,b7,b8) (*((uint64_t*)(uint8_t[]){b1,b2,b3,b4,b5,b6,b7,b8}))
25#define BYTE4(b1,b2,b3,b4)             (*((uint32_t*)(uint8_t[]){b1,b2,b3,b4}))
26#define BYTE2(b1,b2)                   (*((uint16_t*)(uint8_t[]){b1,b2}))
27
28const uint64_t SLP_HEADER  = BYTE8(0x7b,0x55,0x03,0x72,0x61,0x77,0x5b,0x24); // {U.raw[$
29const uint32_t LZMA_HEADER = BYTE4(0xfd,0x37,0x7a,0x58);
30// const uint32_t LZMA_HEADER = BYTE4(0x37,0xfd,0x58,0x7a);
31
32
33const unsigned N_HEADER_BYTES      =  15; //Header is always 15 bytes
34const unsigned MIN_EV_PAYLOAD_SIZE =  14; //Payloads, game start, pre frame, post frame, game end always defined
35const unsigned MIN_GAME_START_SIZE = 353; //Minimum size for game start event (necessary for all replays)
36const unsigned MIN_REPLAY_LENGTH   = N_HEADER_BYTES + MIN_EV_PAYLOAD_SIZE + MIN_GAME_START_SIZE;
37
38// Version convenience macros
39#define MIN_VERSION(maj,min,rev) (_slippi_maj > (maj)) || (_slippi_maj == (maj) && ( (_slippi_min > (min)) || (_slippi_min == (min) && _slippi_rev >= (rev)) ))
40#define MAX_VERSION(maj,min,rev) (_slippi_maj < (maj)) || (_slippi_maj == (maj) && ( (_slippi_min < (min)) || (_slippi_min == (min) && _slippi_rev < (rev)) ))
41
42namespace slip {
43
44//Indent Level
45#define ILEV 1
46
47//Strings for various indentation amounts
48const std::string SPACE[10] = {
49  "",
50  " ",
51  "  ",
52  "   ",
53  "    ",
54  "     ",
55  "      ",
56  "       ",
57  "        ",
58  "         ",
59};
60
61static const std::string base64_chars =
62             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
63             "abcdefghijklmnopqrstuvwxyz"
64             "0123456789+/";
65
66
67static inline bool is_base64(unsigned char c) {
68  return (isalnum(c) || (c == '+') || (c == '/'));
69}
70
71//Hex Output stuff
72
73struct HexCharStruct {
74  unsigned char c;
75  HexCharStruct(unsigned char _c) : c(_c) { }
76};
77
78inline std::ostream& operator<<(std::ostream& o, const HexCharStruct& hs) {
79  return (o << "0x" << std::hex << (int)hs.c) << std::dec;
80}
81
82inline HexCharStruct hex(unsigned char _c) {
83  return HexCharStruct(_c);
84}
85
86inline void printBytes(char* buff, unsigned nchars) {
87  for(unsigned i = 0; i < nchars; ++i) {
88    std::cout << hex(buff[i]) << " ";
89  }
90  std::cout << std::dec << std::endl;
91}
92
93//Bitwise comparison of 8-bytes array with uint_64
94inline bool same8(char* array, uint64_t other) {
95  return ((*((uint64_t*)array)) ^ other) == 0;
96}
97//Bitwise comparison of 4-bytes array with uint_32
98inline bool same4(char* array, uint32_t other) {
99  return ((*((uint32_t*)array)) ^ other) == 0;
100}
101//Load a big-endian 32-bit unsigned int from an array
102inline uint32_t readBE4U(char* array) { return swap32(*((uint32_t*)array)); }
103//Load a big-endian 16-bit unsigned int from an array
104inline uint16_t readBE2U(char* array) { return swap16(*((uint16_t*)array)); }
105//Load a big-endian 32-bit int from an array
106inline int32_t  readBE4S(char* array) { return swap32(*((int32_t*)array)); }
107//Load a big-endian 16-bit int from an array
108inline int16_t  readBE2S(char* array) { return swap16(*((int16_t*)array)); }
109//Load a big-endian float from an array
110inline float readBE4F(char* array) {
111   float r;
112   char *rc = ( char* ) & r;
113   rc[0] = array[3];
114   rc[1] = array[2];
115   rc[2] = array[1];
116   rc[3] = array[0];
117   return r;
118}
119
120//Write a big-endian 32-bit unsigned int to an array
121inline void  writeBE4F(float f, char* a) {
122  char *wc = ( char* ) & f;
123  a[3] = wc[0];
124  a[2] = wc[1];
125  a[1] = wc[2];
126  a[0] = wc[3];
127}
128
129//Write a big-endian 16-bit unsigned int to an array
130inline void  writeBE2U(uint16_t i, char* a) {
131  a[1] =  i      & 0xff;
132  a[0] = (i>>8)  & 0xff;
133}
134
135//Write a big-endian 32-bit unsigned int to an array
136inline void  writeBE4U(uint32_t i, char* a) {
137  a[3] =  i      & 0xff;
138  a[2] = (i>>8)  & 0xff;
139  a[1] = (i>>16) & 0xff;
140  a[0] = (i>>24) & 0xff;
141}
142
143//Write a big-endian 32-bit signed int to an array
144inline void  writeBE4S(int32_t i, char* a) {
145  a[3] =  i      & 0xff;
146  a[2] = (i>>8)  & 0xff;
147  a[1] = (i>>16) & 0xff;
148  a[0] = (i>>24) & 0xff;
149}
150
151//Base64 encoder / decoder -> https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
152inline std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
153  std::string ret;
154  int i = 0;
155  int j = 0;
156  unsigned char char_array_3[3];
157  unsigned char char_array_4[4];
158
159  while (in_len--) {
160    char_array_3[i++] = *(bytes_to_encode++);
161    if (i == 3) {
162      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
163      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
164      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
165      char_array_4[3] = char_array_3[2] & 0x3f;
166
167      for(i = 0; (i <4) ; i++)
168        ret += base64_chars[char_array_4[i]];
169      i = 0;
170    }
171  }
172
173  if (i)
174  {
175    for(j = i; j < 3; j++)
176      char_array_3[j] = '\0';
177
178    char_array_4[0] = ( char_array_3[0] & 0xfc) >> 2;
179    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
180    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
181
182    for (j = 0; (j < i + 1); j++)
183      ret += base64_chars[char_array_4[j]];
184
185    while((i++ < 3))
186      ret += '=';
187
188  }
189
190  return ret;
191
192}
193
194//Base64 encoder / decoder -> https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
195inline std::string base64_decode(std::string const& encoded_string) {
196  int in_len = encoded_string.size();
197  int i = 0;
198  int j = 0;
199  int in_ = 0;
200  unsigned char char_array_4[4], char_array_3[3];
201  std::string ret;
202
203  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
204    char_array_4[i++] = encoded_string[in_]; in_++;
205    if (i ==4) {
206      for (i = 0; i <4; i++)
207        char_array_4[i] = base64_chars.find(char_array_4[i]);
208
209      char_array_3[0] = ( char_array_4[0] << 2       ) + ((char_array_4[1] & 0x30) >> 4);
210      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
211      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) +   char_array_4[3];
212
213      for (i = 0; (i < 3); i++)
214        ret += char_array_3[i];
215      i = 0;
216    }
217  }
218
219  if (i) {
220    for (j = 0; j < i; j++)
221      char_array_4[j] = base64_chars.find(char_array_4[j]);
222
223    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
224    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
225
226    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
227  }
228
229  return ret;
230}
231
232// https://stackoverflow.com/questions/7724448/simple-json-string-escape-for-c/33799784#33799784
233inline std::string escape_json(const std::string &s) {
234    std::ostringstream o;
235    for (auto c = s.cbegin(); c != s.cend(); c++) {
236        switch (*c) {
237        case '"': o << "\\\""; break;
238        case '\\': o << "\\\\"; break;
239        case '\b': o << "\\b"; break;
240        case '\f': o << "\\f"; break;
241        case '\n': o << "\\n"; break;
242        case '\r': o << "\\r"; break;
243        case '\t': o << "\\t"; break;
244        default:
245            if ('\x00' <= *c && *c <= '\x1f') {
246                o << "\\u"
247                  << std::hex << std::setw(4) << std::setfill('0') << (int)*c;
248            } else {
249                o << *c;
250            }
251        }
252    }
253    return o.str();
254}
255
256inline std::string to_utf8(const std::u16string &s) {
257  std::wstring_convert<std::codecvt_utf8<char16_t>, char16_t> conv;
258  std::string u = conv.to_bytes(s);
259  u.erase(std::find(u.begin(), u.end(), '\0'), u.end());
260  return u;
261}
262
263inline std::string decode_shift_jis(char* addr) {
264  std::u16string tag;
265  for(unsigned n = 0; n < 16; n+=2) {
266    uint16_t b = (readBE2U(addr+n));
267    if ((b>>8) == 0x82) {
268      if ( (b&0xff) < 0x59) { //Roman numerals
269        b -= 0x821f;
270      } else if ( (b&0xff) < 0x80) { //Roman letters
271        b -= 0x81ff;
272      } else { //Hiragana
273        b -= 0x525e;
274      }
275    } else if ((b>>8) == 0x83) {
276      if ( (b&0xff) < 0x80) { //Katakana, part 1
277        b -= 0x529f;
278      } else { //Katakana, part 2
279        b -= 0x52a0;
280      }
281    } else if ((b>>8) == 0x81) {  //Miscellaneous characters
282      switch(b&0xff) {
283        case(0x81): b = 0x003D; break; // =
284        case(0x5b): b = 0x30FC; break; // Hiragana Wave Dash (lol)
285        case(0x7c): b = 0x002D; break; // -
286        case(0x7b): b = 0x002B; break; // +
287        case(0x49): b = 0x0021; break; // !
288        case(0x48): b = 0x003F; break; // ?
289        case(0x97): b = 0x0040; break; // @
290        case(0x93): b = 0x0025; break; // %
291        case(0x95): b = 0x0026; break; // &
292        case(0x90): b = 0x0024; break; // $
293        case(0x44): b = 0x002E; break; // .
294        case(0x60): b = 0x301C; break; // Japanese tilde
295        case(0x42): b = 0x3002; break; // Japanese period
296        case(0x41): b = 0x3001; break; // Japanese comma
297        case(0x40): b = 0x3000; break; // Space
298        default:
299          // DOUT1("    Encountered unknown character in tag: " << b << std::endl);
300          b = 0;
301          break;
302      }
303    } else {
304      if (b != 0) {
305        // DOUT1("    Encountered unknown character in tag: " << b << std::endl);
306      }
307      b = 0;
308    }
309    tag += b;
310    if (b == 0) {
311      break;
312    }
313  }
314  return to_utf8(tag);
315}
316
317inline std::string floatToBinary(float f) {
318  union { float f; uint32_t i; } u;
319  u.f = f;
320  std::string s;
321  for (int i = 0; i < 32; i++) {
322    if (u.i % 2)  s.push_back('1');
323    else s.push_back('0');
324    u.i >>= 1;
325  }
326  // Reverse the string since now it's backwards
327  std::string temp(s.rbegin(), s.rend());
328  return temp;
329}
330
331// http://ptspts.blogspot.com/2011/11/how-to-simply-compress-c-string-with.html
332inline std::string compressWithLzma(const std::string& in, int level = 6) {
333  std::string result;
334  result.resize(in.size() + (in.size() >> 2) + 128);
335  size_t out_pos = 0;
336  if (LZMA_OK != lzma_easy_buffer_encode(
337      level, LZMA_CHECK_CRC32, NULL,
338      reinterpret_cast<uint8_t*>(const_cast<char*>(in.data())), in.size(),
339      reinterpret_cast<uint8_t*>(&result[0]), &out_pos, result.size()))
340    abort();
341  result.resize(out_pos);
342  return result;
343}
344
345inline std::string decompressWithLzma(const std::string& in) {
346  static const size_t kMemLimit = 1 << 30;  // 1 GB.
347  lzma_stream strm = LZMA_STREAM_INIT;
348  std::string result;
349  result.resize(8192);
350  size_t result_used = 0;
351  lzma_ret ret;
352  ret = lzma_stream_decoder(&strm, kMemLimit, LZMA_CONCATENATED);
353  if (ret != LZMA_OK)
354    abort();
355  size_t avail0 = result.size();
356  strm.next_in = reinterpret_cast<const uint8_t*>(in.data());
357  strm.avail_in = in.size();
358  strm.next_out = reinterpret_cast<uint8_t*>(&result[0]);
359  strm.avail_out = avail0;
360  while (true) {
361    ret = lzma_code(&strm, strm.avail_in == 0 ? LZMA_FINISH : LZMA_RUN);
362    if (ret == LZMA_STREAM_END) {
363      result_used += avail0 - strm.avail_out;
364      if (0 != strm.avail_in)  // Guaranteed by lzma_stream_decoder().
365        abort();
366      result.resize(result_used);
367      lzma_end(&strm);
368      return result;
369    }
370    if (ret != LZMA_OK)
371      abort();
372    if (strm.avail_out == 0) {
373      result_used += avail0 - strm.avail_out;
374      result.resize(result.size() << 1);
375      strm.next_out = reinterpret_cast<uint8_t*>(&result[0] + result_used);
376      strm.avail_out = avail0 = result.size() - result_used;
377    }
378  }
379}
380
381inline bool fileExists(std::string fname) {
382   std::ifstream i(fname.c_str());
383   return i.good();
384}
385
386// https://stackoverflow.com/questions/667183/padding-stl-strings-in-c
387inline std::string padString(std::string str, const size_t num, const char paddingChar = ' ') {
388    if(num > str.size())
389        str.insert(0, num - str.size(), paddingChar);
390    return str;
391}
392
393inline std::string padString(float f, const size_t num, const char paddingChar = ' ') {
394  return padString(std::to_string(f),num,paddingChar);
395}
396
397inline std::string padString(int i, const size_t num, const char paddingChar = ' ') {
398  return padString(std::to_string(i),num,paddingChar);
399}
400
401
402inline int diffBits(uint16_t u1, uint16_t u2) {
403  int count  = 0;
404  u1        ^= u2;
405  for (int i = 0; i < 16; i++) {
406    if ((u1 >> i) & 1) {
407      ++count;
408    }
409  }
410  return count;
411}
412
413inline int countBits(uint16_t u1) {
414  return diffBits(u1,0);
415}
416
417inline int diffBits(float f1, float f2) {
418  union { float f; uint32_t u; } n1, n2;
419  n1.f       = f1;
420  n2.f       = f2;
421  int count  = 0;
422  n1.u      ^= n2.u;
423  for (int i = 0; i < 32; i++) {
424    if ((n1.u >> i) & 1) {
425      ++count;
426    }
427  }
428  return count;
429}
430
431inline std::string getFileBase(std::string f) {
432  int extpos = f.find_last_of(".");
433  return f.substr(0,extpos);
434}
435
436
437inline std::string getFileExt(std::string f) {
438  int extpos = f.find_last_of(".");
439  return f.substr(extpos+1,f.size()-(extpos+1));
440}
441
442inline void stringtoChars(std::string s, char** c) {
443  *c = new char[s.size()+1];
444  strcpy(*c, s.c_str());
445}
446
447}
448
449#endif /* UTIL_H_ */