source/src/statesub.cpp

   1
   2 #include "common.h"
   3 #include "fileio.h"
   4 #include "fifo.h"
   5
   6 #include "state_data.h"
   7 #include "statesub.h"
   8
   9 csp_state_data_saver::csp_state_data_saver(FILEIO *_fio)
  10 {
  11         fio = _fio;
  12 }
  13
  14 csp_state_data_saver::~csp_state_data_saver()
  15 {
  16 }
  17
  18 size_t csp_state_data_saver::save_string_data(const _TCHAR *p, uint32_t *sumseed, int maxlen, bool *__stat)
  19 {
  20         size_t locallen;
  21         if(__stat != NULL) *__stat =  false;
  22         if(p == NULL) return -1;
  23         if(maxlen <= 0) {
  24                 locallen = strlen(p);
  25         } else {
  26                 locallen = strnlen(p, maxlen);
  27         }
  28         if(locallen < 0) return locallen;
  29         locallen += 1; // Include "\0";
  30         if(sumseed != NULL) {
  31                 *sumseed = calc_crc32(*sumseed, (uint8_t *)p, locallen * sizeof(char));
  32         }
  33         size_t cp;
  34         for(cp = 0; cp < locallen; cp++) {
  35                 int _t = (int)(p[cp]);
  36                 int res = fio->Fputc(_t);
  37                 if((_t == '\0') || (_t == 0x00)){
  38                         cp++;
  39                         if(__stat != NULL) *__stat =  true;
  40                         break;
  41                 } else if(_t == EOF) {
  42                         return (size_t)EOF; // ERROR
  43                 }
  44         }
  45         return locallen;
  46 }
  47
  48 size_t csp_state_data_saver::load_string_data(_TCHAR *p, uint32_t *sumseed, int maxlen, bool *__stat)
  49 {
  50         size_t cp;
  51         size_t _nlen;
  52         if(__stat != NULL) *__stat =  false;
  53         if(p == NULL) return -1;
  54         if(maxlen <= 0) return -1;
  55         memset(p, 0x00, sizeof(_TCHAR) * maxlen);
  56         for(cp = 0; cp < maxlen; cp++) {
  57                 int _t = fio->Fgetc();
  58                 if((_t == '\0') || (_t == 0x00)){
  59                         p[cp] = 0x00;
  60                         cp++;
  61                         if(__stat != NULL) *__stat =  true;
  62                         break;
  63                 } else  if(_t == EOF) {
  64                         p[cp] = 0x00;
  65                         cp++;
  66                         if(__stat != NULL) *__stat =  false;
  67                         break;
  68                 } else if((cp + 1) >= maxlen) {
  69                         p[cp] = (_TCHAR)_t;
  70                         if(__stat != NULL) *__stat =  true;
  71                         cp++;
  72                         break;
  73                 }
  74                 p[cp] = (_TCHAR)_t;
  75         }
  76         if(cp >= maxlen) {
  77                 p[maxlen - 1] = '\0';
  78                 cp = maxlen;
  79         }
  80         _nlen = (size_t)cp;
  81         if(sumseed != NULL){
  82                 *sumseed = calc_crc32(*sumseed, (uint8_t *)p, _nlen * sizeof(_TCHAR));
  83         }
  84         return _nlen;
  85 }
  86 // ALL OF BYNARY VALUES SHOULD BE SAVED BY BIG ENDIAN
  87 int csp_state_data_saver::save_and_change_byteorder_be(uint32_t *sum, void *val, int bytes, int rep)
  88 {
  89         //int swapoffset = bytes;
  90         int members = 0;
  91         uint8_t *buf;
  92         uint8_t *srcp = (uint8_t *)val;
  93
  94         if((bytes <= 0) || (rep < 1)) return 0;
  95         if(val == NULL) return 0;
  96         buf = (uint8_t *)malloc(bytes); // swap buffer
  97         if(buf == NULL) return 0;
  98         for(members = 0; members < rep; members++) {
  99 #if defined(__LITTLE_ENDIAN__)
 100                 int k = 0;
 101                 for(int j = (bytes - 1); j >= 0; j--) {
 102                         buf[j] = srcp[k];
 103                         k++;
 104                 }
 105 #else // BIG_ENDIAN
 106                 memcpy(buf, srcp, bytes);
 107 #endif
 108                 if(fio->Fwrite(buf, bytes, 1) != 1) {
 109                         free(buf);
 110                         return members;
 111                 }
 112                 *sum = calc_crc32(*sum, buf, bytes);
 113                 srcp += bytes;
 114         }
 115         free(buf);
 116         return members;
 117 }
 118
 119 int csp_state_data_saver::load_and_change_byteorder_be(uint32_t *sum, void *val, int bytes, int rep)
 120 {
 121         //int swapoffset = bytes;
 122         int members = 0;
 123         uint8_t *buf;
 124         uint8_t *srcp = (uint8_t *)val;
 125
 126         if((bytes <= 0) || (rep < 1)) return 0;
 127         if(val == NULL) return 0;
 128         buf = (uint8_t *)malloc(bytes); // swap buffer
 129         if(buf == NULL) return 0;
 130         for(members = 0; members < rep; members++) {
 131                 if(fio->Fread(buf, bytes, 1) != 1) {
 132                         free(buf);
 133                         return members;
 134                 }
 135                 *sum = calc_crc32(*sum, buf, bytes);
 136 #if defined(__LITTLE_ENDIAN__)
 137                 int k = 0;
 138                 for(int j = (bytes - 1); j >= 0; j--) {
 139                         srcp[k] = buf[j];
 140                         k++;
 141                 }
 142 #else // BIG_ENDIAN
 143                 memcpy(srcp, buf, bytes);
 144 #endif
 145                 srcp += bytes;
 146         }
 147         free(buf);
 148         return members;
 149 }
 150
 151 void csp_state_data_saver::put_byte(uint8_t val, uint32_t *sumseed, bool *__stat)
 152 {
 153
 154         if(fio != NULL) {
 155                 if(fio->IsOpened()) {
 156                         fio->FputUint8(val);
 157                         if(sumseed != NULL) {
 158                                 *sumseed = calc_crc32(*sumseed, &val, 1);
 159                         }
 160                         if(__stat != NULL) *__stat =  true;
 161                         return;
 162                 }
 163         }
 164         if(__stat != NULL) *__stat =  false;
 165         return;
 166 }
 167
 168 uint8_t csp_state_data_saver::get_byte(uint32_t *sumseed, bool *__stat)
 169 {
 170         if(fio != NULL) {
 171                 if(fio->IsOpened()) {
 172                         uint8_t val = fio->FgetUint8();
 173                         if(sumseed != NULL) {
 174                                 *sumseed = calc_crc32(*sumseed, &val, 1);
 175                         }
 176                         if(__stat != NULL) *__stat =  true;
 177                         return val;
 178                 }
 179         }
 180         if(__stat != NULL) *__stat =  false;
 181         return 0x00000000;
 182 }
 183
 184 void csp_state_data_saver::put_bool(bool val, uint32_t *sumseed, bool *__stat)
 185 {
 186         uint8_t tv;
 187         tv = (val == false) ? 0x00 : 0x01;
 188         if(fio != NULL) {
 189                 if(fio->IsOpened()) {
 190                         fio->FputUint8(tv);
 191                         if(sumseed != NULL) {
 192                                 *sumseed = calc_crc32(*sumseed, &tv, 1);
 193                         }
 194                         if(__stat != NULL) *__stat =  true;
 195                         return;
 196                 }
 197         }
 198         if(__stat != NULL) *__stat =  false;
 199         return;
 200 }
 201
 202 bool csp_state_data_saver::get_bool(uint32_t *sumseed, bool *__stat)
 203 {
 204         if(fio != NULL) {
 205                 if(fio->IsOpened()) {
 206                         uint8_t val = fio->FgetUint8();
 207                         if(val != 0x00) val = 0x01;
 208                         if(sumseed != NULL) {
 209                                 *sumseed = calc_crc32(*sumseed, &val, 1);
 210                         }
 211                         if(__stat != NULL) *__stat =  true;
 212                         return (val == 0x00) ? false : true;
 213                 }
 214         }
 215         if(__stat != NULL) *__stat =  false;
 216         return false;
 217 }
 218
 219 void csp_state_data_saver::put_word(uint16_t val, uint32_t *sumseed, bool *__stat)
 220 {
 221         if(fio != NULL) {
 222                 if(fio->IsOpened()) {
 223                         fio->FputUint16_BE(val);
 224                         if(sumseed != NULL) {
 225                                 pair_t tval;
 226                                 uint8_t buf[2];
 227                                 tval.w.l = val;
 228                                 tval.write_2bytes_be_to(buf);
 229                                 *sumseed = calc_crc32(*sumseed, buf, 2);
 230                         }
 231                         if(__stat != NULL) *__stat =  true;
 232                         return;
 233                 }
 234         }
 235         if(__stat != NULL) *__stat =  false;
 236         return;
 237 }
 238
 239 uint16_t csp_state_data_saver::get_word(uint32_t *sumseed, bool *__stat)
 240 {
 241         if(fio != NULL) {
 242                 if(fio->IsOpened()) {
 243                         uint16_t val = fio->FgetUint16_BE();
 244                         if(__stat != NULL) *__stat =  true;
 245                         if(sumseed != NULL) {
 246                                 pair_t tval;
 247                                 uint8_t buf[2];
 248                                 tval.w.l = val;
 249                                 tval.write_2bytes_be_to(buf);
 250                                 *sumseed = calc_crc32(*sumseed, buf, 2);
 251                         }
 252                         return val;
 253                 }
 254         }
 255         if(__stat != NULL) *__stat =  false;
 256         return 0x00000000;
 257 }
 258
 259 void csp_state_data_saver::put_dword(uint32_t val, uint32_t *sumseed, bool *__stat)
 260 {
 261
 262         if(fio != NULL) {
 263                 if(fio->IsOpened()) {
 264                         fio->FputUint32_BE(val);
 265                         if(__stat != NULL) *__stat =  true;
 266                         if(sumseed != NULL) {
 267                                 pair_t tval;
 268                                 uint8_t buf[4];
 269                                 tval.d = val;
 270                                 tval.write_4bytes_be_to(buf);
 271                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 272                         }
 273                         return;
 274                 }
 275         }
 276         if(__stat != NULL) *__stat =  false;
 277         return;
 278 }
 279
 280 uint32_t csp_state_data_saver::get_dword(uint32_t *sumseed, bool *__stat)
 281 {
 282         if(fio != NULL) {
 283                 if(fio->IsOpened()) {
 284                         uint32_t val = fio->FgetUint32_BE();
 285                         if(__stat != NULL) *__stat =  true;
 286                         if(sumseed != NULL) {
 287                                 pair_t tval;
 288                                 uint8_t buf[4];
 289                                 tval.d = val;
 290                                 tval.write_4bytes_be_to(buf);
 291                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 292                         }
 293                         return val;
 294                 }
 295         }
 296         if(__stat != NULL) *__stat =  false;
 297         return 0x00000000;
 298 }
 299
 300 void csp_state_data_saver::put_qword(uint64_t val, uint32_t *sumseed, bool *__stat)
 301 {
 302
 303         if(fio != NULL) {
 304                 if(fio->IsOpened()) {
 305                         fio->FputUint64_BE(val);
 306                         if(__stat != NULL) *__stat =  true;
 307                         if(sumseed != NULL) {
 308                                 pair64_sav_t tval;
 309                                 uint8_t buf[8];
 310                                 tval.u64 = val;
 311                                 tval.write_8bytes_be_to(buf);
 312                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 313                         }
 314                         return;
 315                 }
 316         }
 317         if(__stat != NULL) *__stat =  false;
 318         return;
 319 }
 320
 321 uint64_t csp_state_data_saver::get_qword(uint32_t *sumseed, bool *__stat)
 322 {
 323         if(fio != NULL) {
 324                 if(fio->IsOpened()) {
 325                         uint64_t val = fio->FgetUint64_BE();
 326                         if(__stat != NULL) *__stat =  true;
 327                         if(sumseed != NULL) {
 328                                 pair64_sav_t tval;
 329                                 uint8_t buf[8];
 330                                 tval.u64 = val;
 331                                 tval.write_8bytes_be_to(buf);
 332                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 333                         }
 334                         return val;
 335                 }
 336         }
 337         if(__stat != NULL) *__stat =  false;
 338         return 0x00000000;
 339 }
 340
 341 void csp_state_data_saver::put_int8(int8_t val, uint32_t *sumseed, bool *__stat)
 342 {
 343
 344         if(fio != NULL) {
 345                 if(fio->IsOpened()) {
 346                         fio->FputInt8(val);
 347                         if(__stat != NULL) *__stat =  true;
 348                         if(sumseed != NULL) {
 349                                 *sumseed = calc_crc32(*sumseed, &val, 1);
 350                         }
 351                         return;
 352                 }
 353         }
 354         if(__stat != NULL) *__stat = false;
 355         return;
 356 }
 357
 358 int8_t csp_state_data_saver::get_int8(uint32_t *sumseed, bool *__stat)
 359 {
 360         if(fio != NULL) {
 361                 if(fio->IsOpened()) {
 362                         int8_t val = fio->FgetInt8();
 363                         if(__stat != NULL) *__stat = true;
 364                         if(sumseed != NULL) {
 365                                 *sumseed = calc_crc32(*sumseed, &val, 1);
 366                         }
 367                         return val;
 368                 }
 369         }
 370         if(__stat != NULL) *__stat = false;
 371         return 0x00000000;
 372 }
 373
 374 void csp_state_data_saver::put_int16(int16_t val, uint32_t *sumseed, bool *__stat)
 375 {
 376
 377         if(fio != NULL) {
 378                 if(fio->IsOpened()) {
 379                         fio->FputInt16_BE(val);
 380                         if(__stat != NULL) *__stat = true;
 381                         if(sumseed != NULL) {
 382                                 pair_t tval;
 383                                 uint8_t buf[2];
 384                                 tval.sw.l = val;
 385                                 tval.write_2bytes_be_to(buf);
 386                                 *sumseed = calc_crc32(*sumseed, buf, 2);
 387                         }
 388                         return;
 389                 }
 390         }
 391         if(__stat != NULL) *__stat = false;
 392         return;
 393 }
 394
 395 int16_t csp_state_data_saver::get_int16(uint32_t *sumseed, bool *__stat)
 396 {
 397         if(fio != NULL) {
 398                 if(fio->IsOpened()) {
 399                         int16_t val = fio->FgetInt16_BE();
 400                         if(__stat != NULL) *__stat = true;
 401                         if(sumseed != NULL) {
 402                                 pair_t tval;
 403                                 uint8_t buf[2];
 404                                 tval.sw.l = val;
 405                                 tval.write_2bytes_be_to(buf);
 406                                 *sumseed = calc_crc32(*sumseed, buf, 2);
 407                         }
 408                         return val;
 409                 }
 410         }
 411         if(__stat != NULL) *__stat = false;
 412         return 0x00000000;
 413 }
 414
 415 void csp_state_data_saver::put_int32(int32_t val, uint32_t *sumseed, bool *__stat)
 416 {
 417
 418         if(fio != NULL) {
 419                 if(fio->IsOpened()) {
 420                         fio->FputInt32_BE(val);
 421                         if(__stat != NULL) *__stat = true;
 422                         if(sumseed != NULL) {
 423                                 pair_t tval;
 424                                 uint8_t buf[4];
 425                                 tval.sd = val;
 426                                 tval.write_4bytes_be_to(buf);
 427                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 428                         }
 429                         return;
 430                 }
 431         }
 432         if(__stat != NULL) *__stat = false;
 433         return;
 434 }
 435
 436 int32_t csp_state_data_saver::get_int32(uint32_t *sumseed, bool *__stat)
 437 {
 438         if(fio != NULL) {
 439                 if(fio->IsOpened()) {
 440                         int32_t val = fio->FgetInt32_BE();
 441                         if(__stat != NULL) *__stat = true;
 442                         if(sumseed != NULL) {
 443                                 pair_t tval;
 444                                 uint8_t buf[4];
 445                                 tval.sd = val;
 446                                 tval.write_4bytes_be_to(buf);
 447                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 448                         }
 449                         return val;
 450                 }
 451         }
 452         if(__stat != NULL) *__stat = false;
 453         return 0x00000000;
 454 }
 455
 456 void csp_state_data_saver::put_int64(int64_t val, uint32_t *sumseed, bool *__stat)
 457 {
 458
 459         if(fio != NULL) {
 460                 if(fio->IsOpened()) {
 461                         fio->FputInt64_BE(val);
 462                         if(__stat != NULL) *__stat = true;
 463                         if(sumseed != NULL) {
 464                                 pair64_sav_t tval;
 465                                 uint8_t buf[8];
 466                                 tval.s64 = val;
 467                                 tval.write_8bytes_be_to(buf);
 468                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 469                         }
 470                         return;
 471                 }
 472         }
 473         if(__stat != NULL) *__stat = false;
 474         return;
 475 }
 476
 477 int64_t csp_state_data_saver::get_int64(uint32_t *sumseed, bool *__stat)
 478 {
 479         if(fio != NULL) {
 480                 if(fio->IsOpened()) {
 481                         int64_t val = fio->FgetInt64_BE();
 482                         if(__stat != NULL) *__stat = true;
 483                         if(sumseed != NULL) {
 484                                 pair64_sav_t tval;
 485                                 uint8_t buf[8];
 486                                 tval.s64 = val;
 487                                 tval.write_8bytes_be_to(buf);
 488                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 489                         }
 490                         return val;
 491                 }
 492         }
 493         if(__stat != NULL) *__stat = false;
 494         return 0x00000000;
 495 }
 496
 497 /*
 498  * For floating values, internal format is differnt by ARCHTECTURE, OS, COMPILER etc.
 499  * So, saving / loading those values by ascii, not binary.
 500  * -- 20180520 K.Ohta.
 501  */
 502 #include <stdexcept>
 503
 504 float csp_state_data_saver::get_float(uint32_t *sumseed, bool *__stat)
 505 {
 506         size_t _sp;
 507         std::string _s;
 508         char tmps[1024]; // OK?
 509         float _v;
 510         size_t _nlen = sizeof(tmps) / sizeof(char);
 511         size_t donelen;
 512         if(fio != NULL) {
 513                 memset(tmps, 0x00, sizeof(tmps));
 514                 donelen = load_string_data(tmps, sumseed, _nlen - 1);
 515                 if((donelen <= 0) || (donelen >= _nlen)) {  //
 516                         if(__stat != NULL) *__stat = false;
 517                         return 0.0f;
 518                 }
 519                 _s = std::string(tmps);
 520                 try {
 521                         _v = std::stof(_s, &_sp);
 522                 } catch(const std::invalid_argument& e) {
 523                         if(__stat != NULL) *__stat = false;
 524                         return 0.0f;
 525                 } catch(const std::out_of_range& e) {
 526                         if(__stat != NULL) *__stat =  false;
 527                         return 0.0f;
 528                 }
 529                 if(__stat != NULL) *__stat =  true;
 530                 if(sumseed != NULL) {
 531                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 532                 }
 533                 return _v;
 534         }
 535         if(__stat != NULL) *__stat =  true;
 536         return 0.0f;
 537 }
 538
 539 void csp_state_data_saver::put_float(float val, uint32_t *sumseed, bool *__stat)
 540 {
 541         std::string _s;
 542         char tmps[1024]; // OK?
 543         float _v = val;
 544         int _nlen = sizeof(tmps) / sizeof(char);
 545         size_t donelen;
 546         if(fio != NULL) {
 547                 memset(tmps, 0x00, sizeof(tmps));
 548                 _s = std::to_string(_v);
 549                 _s.copy(tmps, _nlen - 1);
 550                 size_t rlen = strnlen(tmps, _nlen);
 551                 if((rlen <= 0) || (rlen >= _nlen)) { //
 552                         if(__stat != NULL) *__stat =  false;
 553                         return;
 554                 }
 555                 donelen = save_string_data(tmps, sumseed, rlen);
 556                 if((donelen <= 0) || (donelen != (rlen + 1))) {
 557                         if(__stat != NULL) *__stat =  false;
 558                         return;
 559                 }
 560                 if(sumseed != NULL) {
 561                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 562                 }
 563                 if(__stat != NULL) *__stat =  true;
 564                 return;
 565         }
 566         if(__stat != NULL) *__stat =  false;
 567         return;
 568 }
 569
 570 double csp_state_data_saver::get_double(uint32_t *sumseed, bool *__stat)
 571 {
 572         std::string _s;
 573         char tmps[1024]; // OK?
 574         double _v;
 575         size_t _nlen = sizeof(tmps) / sizeof(char);
 576         size_t donelen;
 577         size_t _sp;
 578         if(fio != NULL) {
 579                 memset(tmps, 0x00, sizeof(tmps));
 580                 donelen = load_string_data(tmps, sumseed, _nlen - 1);
 581                 if((donelen <= 0) || (donelen >= _nlen)) {  //
 582                         if(__stat != NULL) *__stat =  false;
 583                         return 0.0;
 584                 }
 585                 _s = std::string(tmps);
 586                 try {
 587                         _v = std::stod(_s, &_sp);
 588                 } catch(const std::invalid_argument& e) {
 589                         if(__stat != NULL) *__stat =  false;
 590                         return 0.0;
 591                 } catch(const std::out_of_range& e) {
 592                         if(__stat != NULL) *__stat =  false;
 593                         return 0.0;
 594                 }
 595                 if(__stat != NULL) *__stat =  true;
 596                 if(sumseed != NULL) {
 597                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 598                 }
 599                 return _v;
 600         }
 601         if(__stat != NULL) *__stat =  true;
 602         return 0.0;
 603 }
 604
 605 void csp_state_data_saver::put_double(double val, uint32_t *sumseed, bool *__stat)
 606 {
 607         std::string _s;
 608         char tmps[1024]; // OK?
 609         double _v = val;
 610         int _nlen = sizeof(tmps) / sizeof(char);
 611         size_t donelen;
 612         if(fio != NULL) {
 613                 memset(tmps, 0x00, sizeof(tmps));
 614                 _s = std::to_string(_v);
 615                 _s.copy(tmps, _nlen - 1);
 616                 size_t rlen = strnlen(tmps, _nlen);
 617                 if((rlen <= 0) || (rlen >= _nlen)) { //
 618                         if(__stat != NULL) *__stat =  false;
 619                         return;
 620                 }
 621                 donelen = save_string_data(tmps, sumseed, rlen);
 622                 if((donelen <= 0) || (donelen != (rlen + 1))) {
 623                         if(__stat != NULL) *__stat =  false;
 624                         return;
 625                 }
 626                 if(sumseed != NULL) {
 627                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 628                 }
 629                 if(__stat != NULL) *__stat =  true;
 630                 return;
 631         }
 632         if(__stat != NULL) *__stat =  false;
 633         return;
 634 }
 635
 636 long double csp_state_data_saver::get_long_double(uint32_t *sumseed, bool *__stat)
 637 {
 638         size_t _sp;
 639         std::string _s;
 640         char tmps[1024]; // OK?
 641         long double _v;
 642         size_t _nlen = sizeof(tmps) / sizeof(char);
 643         size_t donelen;
 644         if(fio != NULL) {
 645                 memset(tmps, 0x00, sizeof(tmps));
 646                 donelen = load_string_data(tmps, sumseed, _nlen - 1);
 647                 if((donelen <= 0) || (donelen >= _nlen)) {  //
 648                         if(__stat != NULL) *__stat =  false;
 649                         return 0.0;
 650                 }
 651                 _s = std::string(tmps);
 652                 try {
 653                         _v = std::stold(_s, &_sp);
 654                 } catch(const std::invalid_argument& e) {
 655                         if(__stat != NULL) *__stat =  false;
 656                         return 0.0;
 657                 } catch(const std::out_of_range& e) {
 658                         if(__stat != NULL) *__stat =  false;
 659                         return 0.0;
 660                 }
 661                 if(__stat != NULL) *__stat =  true;
 662                 if(sumseed != NULL) {
 663                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 664                 }
 665                 return _v;
 666         }
 667         if(__stat != NULL) *__stat =  true;
 668         return 0.0;
 669 }
 670
 671 void csp_state_data_saver::put_long_double(long double val, uint32_t *sumseed, bool *__stat)
 672 {
 673         std::string _s;
 674         char tmps[1024]; // OK?
 675         long double _v = val;
 676         int _nlen = sizeof(tmps) / sizeof(char);
 677         size_t donelen;
 678         if(fio != NULL) {
 679                 memset(tmps, 0x00, sizeof(tmps));
 680                 _s = std::to_string(_v);
 681                 _s.copy(tmps, _nlen - 1);
 682                 size_t rlen = strnlen(tmps, _nlen);
 683                 if((rlen <= 0) || (rlen >= _nlen)) { //
 684                         if(__stat != NULL) *__stat =  false;
 685                         return;
 686                 }
 687                 donelen = save_string_data(tmps, sumseed, rlen);
 688                 if((donelen <= 0) || (donelen != (rlen + 1))) {
 689                         if(__stat != NULL) *__stat =  false;
 690                         return;
 691                 }
 692                 if(sumseed != NULL) {
 693                         *sumseed = calc_crc32(*sumseed, tmps, donelen);
 694                 }
 695                 if(__stat != NULL) *__stat =  true;
 696                 return;
 697         }
 698         if(__stat != NULL) *__stat =  false;
 699         return;
 700 }
 701
 702 size_t csp_state_data_saver::get_byte_array(uint8_t *p, size_t len, size_t repeat, uint32_t *sumseed, bool *__stat)
 703 {
 704         size_t donelen = 0;
 705         bool _nstat = true;
 706         if((len <= 0) || (repeat <= 0) || (p == NULL)) {
 707                 _nstat = false;
 708         }
 709         if(fio == NULL) _nstat = false;
 710         if(_nstat) {
 711                 donelen = fio->Fread(p, len, repeat);
 712                 if(donelen != repeat) {
 713                         _nstat = false;
 714                 } else {
 715                         // Data OK.
 716                         int calcsize = len * donelen;
 717                         if((calcsize > 0) && (sumseed != NULL)) {
 718                                 *sumseed = calc_crc32(*sumseed, p, calcsize);
 719                         }
 720                         _nstat = true;
 721                 }
 722         }
 723         if(__stat != NULL) *__stat =  _nstat;
 724         if(_nstat) {
 725                 return len * donelen; // RETURN BYTES;
 726         } else {
 727                 return -1;
 728         }
 729 }
 730
 731 size_t csp_state_data_saver::put_byte_array(uint8_t *p, size_t len, size_t repeat, uint32_t *sumseed, bool *__stat)
 732 {
 733         size_t donelen = 0;
 734         bool _nstat = true;
 735         if((len <= 0) || (repeat <= 0) || (p == NULL)) {
 736                 _nstat = false;
 737         }
 738         if(fio == NULL) _nstat = false;
 739         if(_nstat) {
 740                 donelen = fio->Fwrite(p, len, repeat);
 741                 if(donelen != repeat) {
 742                         _nstat = false;
 743                 } else {
 744                         // Data OK.
 745                         int calcsize = len * donelen;
 746                         if((calcsize > 0) && (sumseed != NULL)) {
 747                                 *sumseed = calc_crc32(*sumseed, p, calcsize);
 748                         }
 749                         _nstat = true;
 750                 }
 751         }
 752         if(__stat != NULL) *__stat =  _nstat;
 753         if(_nstat) {
 754                 return len * donelen; // RETURN BYTES;
 755         } else {
 756                 return -1;
 757         }
 758 }
 759
 760
 761 void csp_state_data_saver::put_pair32(pair_t val, uint32_t *sumseed, bool *__stat)
 762 {
 763
 764         if(fio != NULL) {
 765                 if(fio->IsOpened()) {
 766                         uint8_t buf[4];
 767                         val.write_4bytes_be_to(buf);
 768                         size_t memb = fio->Fwrite(buf, 1, 4);
 769                         if(memb != 4) {
 770                                 if(__stat != NULL) *__stat =  false;
 771                                 return;
 772                         }
 773                         if(__stat != NULL) *__stat = true;
 774                         if(sumseed != NULL) {
 775                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 776                         }
 777                         return;
 778                 }
 779         }
 780         if(__stat != NULL) *__stat = false;
 781         return;
 782 }
 783
 784 pair_t csp_state_data_saver::get_pair32(uint32_t *sumseed, bool *__stat)
 785 {
 786         pair_t val;
 787         val.d = 0;
 788         if(fio != NULL) {
 789                 if(fio->IsOpened()) {
 790                         uint8_t buf[4];
 791                         size_t memb = fio->Fread(buf, 1, 4);
 792                         if(memb != 4) {
 793                                 if(__stat != NULL) *__stat = false;
 794                                 return val;
 795                         }
 796                         val.read_4bytes_be_from(buf);
 797                         if(__stat != NULL) *__stat = true;
 798                         if(sumseed != NULL) {
 799                                 *sumseed = calc_crc32(*sumseed, buf, 4);
 800                         }
 801                         return val;
 802                 }
 803         }
 804         if(__stat != NULL) *__stat = false;
 805         return val;
 806 }
 807
 808 pair64_sav_t csp_state_data_saver::get_pair64(uint32_t *sumseed, bool *__stat)
 809 {
 810         pair64_sav_t val;
 811         val.u64 = 0;
 812         if(fio != NULL) {
 813                 if(fio->IsOpened()) {
 814                         uint8_t buf[8];
 815                         size_t memb = fio->Fread(buf, 1, 8);
 816                         if(memb != 8) {
 817                                 if(__stat != NULL) *__stat = false;
 818                                 return val;
 819                         }
 820                         val.read_8bytes_be_from(buf);
 821                         if(__stat != NULL) *__stat = true;
 822                         if(sumseed != NULL) {
 823                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 824                         }
 825                         return val;
 826                 }
 827         }
 828         if(__stat != NULL) *__stat = false;
 829         return val;
 830 }
 831
 832 void csp_state_data_saver::put_pair64(pair64_sav_t val, uint32_t *sumseed, bool *__stat)
 833 {
 834         if(fio != NULL) {
 835                 if(fio->IsOpened()) {
 836                         uint8_t buf[8];
 837                         val.write_8bytes_be_to(buf);
 838                         size_t memb = fio->Fwrite(buf, 1, 8);
 839                         if(memb != 8) {
 840                                 if(__stat != NULL) *__stat = false;
 841                                 return;
 842                         }
 843                         if(__stat != NULL) *__stat = true;
 844                         if(sumseed != NULL) {
 845                                 *sumseed = calc_crc32(*sumseed, buf, 8);
 846                         }
 847                         return;
 848                 }
 849         }
 850         if(__stat != NULL) *__stat = false;
 851         return;
 852 }
 853
 854 bool csp_state_data_saver::pre_proc_saving(uint32_t *sumseed, bool *__stat)
 855 {
 856         bool mb = false;
 857         if(sumseed != NULL) {
 858                 const uint8_t headdata[4] = {0xff, 0xff, 0xff, 0xff};
 859                 *sumseed = calc_crc32(*sumseed, headdata, 4);
 860                 mb = true;
 861         }
 862         if(__stat != NULL) *__stat = mb;
 863         return mb;
 864 }
 865
 866 bool csp_state_data_saver::post_proc_saving(uint32_t *sumseed, bool *__stat)
 867 {
 868         bool mb = false;
 869         if(sumseed != NULL) {
 870                 const uint8_t taildata[4] = {0x00, 0x00, 0x00, 0x00};
 871                 *sumseed = calc_crc32(*sumseed, taildata, 4);
 872                 if(fio != NULL) {
 873                         if(fio->IsOpened()) {
 874                                 fio->FputUint32_BE(*sumseed);
 875                                 mb = true;
 876                         }
 877                 }
 878         }
 879         if(__stat != NULL) *__stat = mb;
 880         return mb;
 881 }
 882
 883 bool csp_state_data_saver::pre_proc_loading(uint32_t *sumseed, bool *__stat)
 884 {
 885         bool mb = false;
 886         if(sumseed != NULL) {
 887                 const uint8_t headdata[4] = {0xff, 0xff, 0xff, 0xff};
 888                 *sumseed = calc_crc32(*sumseed, headdata, 4);
 889                 mb = true;
 890         }
 891         if(__stat != NULL) *__stat = mb;
 892         return mb;
 893 }
 894
 895 bool csp_state_data_saver::post_proc_loading(uint32_t *sumseed, bool *__stat)
 896 {
 897         bool mb = false;
 898         uint32_t tmp_crc;
 899         if(sumseed != NULL) {
 900                 const uint8_t taildata[4] = {0x00, 0x00, 0x00, 0x00};
 901                 *sumseed = calc_crc32(*sumseed, taildata, 4);
 902                 if(fio != NULL) {
 903                         if(fio->IsOpened()) {
 904                                 tmp_crc = fio->FgetUint32_BE();
 905                                 if(*sumseed == tmp_crc) mb = true;
 906                         }
 907                 }
 908         }
 909         if(__stat != NULL) *__stat = mb;
 910         return mb;
 911 }
 912
 913
 914 csp_state_utils::csp_state_utils(int _version, int device_id, const _TCHAR *classname, CSP_Logger* p_logger)
 915 {
 916         listptr.clear();
 917         crc_value = 0;
 918         listptr.clear();
 919
 920         this_device_id = device_id;
 921         this_device_id_bak = this_device_id;
 922         logger = p_logger;
 923
 924         memset(__classname, 0x00, sizeof(__classname));
 925         memset(__classname_bak, 0x00, sizeof(__classname_bak));
 926         memset(magic, 0x00, sizeof(magic));
 927         memset(magic_bak, 0x00, sizeof(magic_bak));
 928
 929         strncpy(magic, _T("CSP_SAVE"), 16 - 1);
 930         strncpy(magic_bak, magic, 16 - 1);
 931
 932         if(classname != NULL) {
 933                 strncpy(__classname, classname, sizeof(__classname) - 1);
 934         } else {
 935                 strncpy(__classname, "Unknown Class", sizeof(__classname) - 1);
 936         }
 937         strncpy(__classname_bak, __classname, sizeof(__classname_bak) - 1);
 938
 939         class_version = _version;
 940         class_version_bak = _version;
 941
 942         internal_version = 1;
 943         internal_version_bak = internal_version;
 944         out_debug_log("NEW SAVE STATE: NAME=%s DEVID=%d VER=%d", classname, device_id, _version);
 945
 946         add_entry_tchar(_T("HEADER"), magic_bak, strlen(magic_bak) + 1);
 947         add_entry_tchar(_T("CLASSNAME"), __classname_bak, strlen(__classname_bak) + 1);
 948         add_entry(_T("DEVICE_ID"), &this_device_id_bak);
 949         add_entry(_T("STAVE_VER"), &class_version_bak);
 950         add_entry(_T("INTERNAL_VER"), &internal_version_bak);
 951
 952         fio = NULL;
 953 }
 954
 955 csp_state_utils::~csp_state_utils()
 956 {
 957 }
 958
 959 /*
 960  * Note:
 961  * With MinGW and DLL linker, not able top find extern symbols.
 962  */
 963
 964 #include "config.h"
 965 #include "csp_logger.h"
 966
 967 void csp_state_utils::out_debug_log(const char *fmt, ...)
 968 {
 969         if(logger == NULL) return;
 970         // Temporally disabled 20180618
 971 //#if !defined(__MINGW32__) && !defined(__MINGW64__)
 972         char strbuf[8192];
 973         va_list ap;
 974         va_start(ap, fmt);
 975         vsnprintf(strbuf, 8192, fmt, ap);
 976         logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_VM_STATE, strbuf);
 977         va_end(ap);
 978 //#endif
 979 }
 980
 981 std::list<std::string> csp_state_utils::get_entries_list(void)
 982 {
 983         __list_t _l;
 984         std::list<std::string> _rlist;
 985         std::string _tname, _vname;
 986         _rlist.clear();
 987
 988         for(auto p = listptr.begin(); p != listptr.end(); ++p) {
 989                 void *pp = (*p).ptr.p;
 990                 if(pp != NULL) {
 991                         _vname = _T("NAME:");
 992                         switch((*p).type_id) {
 993                         case csp_saver_entry_float:
 994                                 _tname = _T("TYPE: float");
 995                                 break;
 996                         case csp_saver_entry_double:
 997                                 _tname = _T("TYPE: double");
 998                                 break;
 999                         case csp_saver_entry_long_double:
1000                                 _tname = _T("TYPE: long double");
1001                                 break;
1002                         case csp_saver_entry_pair:
1003                                 _tname = _T("TYPE: pair_t");
1004                                 break;
1005                         case csp_saver_entry_int:
1006                                 _tname = _T("TYPE: int");
1007                                 break;
1008                         case csp_saver_entry_uint8:
1009                                 _tname = _T("TYPE: uint8_t");
1010                                 break;
1011                         case csp_saver_entry_int8:
1012                                 _tname = _T("TYPE: int8_t");
1013                                 break;
1014                         case csp_saver_entry_uint16:
1015                                 _tname = _T("TYPE: uint16_t");
1016                                 break;
1017                         case csp_saver_entry_int16:
1018                                 _tname = _T("TYPE: int16_t");
1019                                 break;
1020                         case csp_saver_entry_uint32:
1021                                 _tname = _T("TYPE: uint32_t");
1022                                 break;
1023                         case csp_saver_entry_int32:
1024                                 _tname = _T("TYPE: int32_t");
1025                                 break;
1026                         case csp_saver_entry_uint64:
1027                                 _tname = _T("TYPE: uint64_t");
1028                                 break;
1029                         case csp_saver_entry_int64:
1030                                 _tname = _T("TYPE: int64_t");
1031                                 break;
1032                         case csp_saver_entry_bool:
1033                                 _tname = _T("TYPE: bool");
1034                                 break;
1035                         case csp_saver_entry_tchar:
1036                                 _tname = _T("TYPE: _TCHAR");
1037                                 break;
1038                         case csp_saver_entry_any:
1039                                 _tname = _T("TYPE: ANY");
1040                                 break;
1041                         default:
1042                                 _tname = _T("TYPE: ANY(UNKNOWN)");
1043                                 break;
1044                         }
1045                         _vname = _vname + (*p).name;
1046                         _rlist.push_back(_vname);
1047                         _rlist.push_back(_tname);
1048                 }
1049         }
1050         return _rlist;
1051 }
1052 uint32_t csp_state_utils::get_crc_value(void)
1053 {
1054         return crc_value;
1055 }
1056 void csp_state_utils::get_class_name(_TCHAR *buf, int len)
1057 {
1058         strncpy(buf, __classname_bak, ((size_t)len >= sizeof(__classname_bak)) ? (sizeof(__classname_bak) - 1) : len);
1059 }
1060
1061
1062 void csp_state_utils::add_entry_fifo(const _TCHAR *__name, FIFO **p, int _len, int __num)
1063 {
1064         __list_t _l;
1065         std::string _name = std::string(__name);
1066         if(__num >= 0) _name = _name + std::string("_#[") +std::to_string(__num) + std::string("]");
1067         _l.ptr.p = (void *)p;
1068         _l.len = _len;
1069         _l.atomlen = 1;
1070         _l.name = _name;
1071         _l.datalenptr = NULL;
1072         _l.local_num = __num;
1073         _l.assume_byte = false;
1074         _l.type_id = csp_saver_entry_fifo;
1075         _l.use_is_null = false;
1076         _l._null_atomlen = 1;
1077         _l._null_type_id = csp_saver_entry_any;
1078         _l.is_null_value.u = 0;
1079         _l.is_null_value_const = false;
1080         _l.not_null_value.u = 0;
1081         _l.not_null_value_const = false;
1082         _l.recv_ptr.u = 0;
1083
1084         out_debug_log("ADD ENTRY: NAME=%s TYPE=FIFO len=%d atomlen=%d", _name.c_str(), _len, _l.atomlen);
1085         listptr.push_back(_l);
1086 }
1087
1088 void csp_state_utils::add_entry_cur_time_t(const _TCHAR *__name, cur_time_t *p, int _len, int __num)
1089 {
1090         __list_t _l;
1091         std::string _name = std::string(__name);
1092         if(__num >= 0) _name = _name + std::string("_#[") +std::to_string(__num) + std::string("]");
1093         _l.ptr.p = (void *)p;
1094         _l.len = _len;
1095         _l.atomlen = 1;
1096         _l.name = _name;
1097         _l.datalenptr = NULL;
1098         _l.local_num = __num;
1099         _l.assume_byte = false;
1100         _l.use_is_null = false;
1101         _l.type_id = csp_saver_entry_cur_time_t;
1102         _l._null_atomlen = 1;
1103         _l._null_type_id = csp_saver_entry_any;
1104         _l.is_null_value.u = 0;
1105         _l.is_null_value_const = false;
1106         _l.not_null_value.u = 0;
1107         _l.not_null_value_const = false;
1108         _l.recv_ptr.u = 0;
1109         out_debug_log("ADD ENTRY: NAME=%s TYPE=CUR_TIME_T len=%d atomlen=%d", _name.c_str(), _len, _l.atomlen);
1110         listptr.push_back(_l);
1111 }
1112
1113 void csp_state_utils::add_entry_tchar(const _TCHAR *__name, _TCHAR *p, int _len, int __num, bool is_const)
1114 {
1115         __list_t _l;
1116         std::string _name = std::string(__name);
1117         if(__num >= 0) _name = _name + std::string("_#[") +std::to_string(__num) + std::string("]");
1118
1119         if(p == NULL) return;
1120         _l.ptr.p = (void *)p;
1121         _l.type_id = csp_saver_entry_tchar;
1122         _l.len = _len;
1123         _l.atomlen = sizeof(_TCHAR);
1124         _l.name = _name;
1125         _l.local_num = __num;
1126         _l.assume_byte = true;
1127         _l.use_is_null = false;
1128         _l._null_atomlen = 1;
1129         _l._null_type_id = csp_saver_entry_any;
1130         _l.is_null_value.u = 0;
1131         _l.is_null_value_const = false;
1132         _l.not_null_value.u = 0;
1133         _l.not_null_value_const = false;
1134         _l.recv_ptr.u = 0;
1135
1136         if(is_const) _l.type_id = _l.type_id | csp_saver_entry_const;
1137
1138         out_debug_log("ADD ENTRY: NAME=%s TYPE=_TCHAR* VAL=%s len=%d atomlen=%d HEAD=%08x", __name, p, _len, _l.atomlen, p);
1139         listptr.push_back(_l);
1140 }
1141
1142 bool csp_state_utils::save_state(FILEIO *__fio, uint32_t *pcrc)
1143 {
1144         const uint8_t initdata[4] = {0xff, 0xff, 0xff, 0xff};
1145         const uint8_t taildata[4] = {0x00, 0x00, 0x00, 0x00};
1146         int retval;
1147         bool _stat;
1148
1149         class_version_bak = class_version;
1150         this_device_id_bak = this_device_id;
1151         memset(__classname_bak, 0x00, sizeof(__classname_bak));
1152         strncpy(__classname_bak, __classname, sizeof(__classname) - 1);
1153         // Initialize crc;
1154         if(pcrc == NULL) {
1155                 crc_value = 0xffffffff;
1156         } else {
1157                 crc_value = *pcrc;
1158         }
1159         // Write header
1160         out_debug_log("SAVE STATE: NAME=%s DEVID=%d VER=%d", __classname, this_device_id, class_version);
1161         //printf("SAVE STATE: NAME=%s DEVID=%d VER=%d", __classname, this_device_id, class_version);
1162
1163         fio = new csp_state_data_saver(__fio);
1164         if(fio != NULL) {
1165                 bool need_mfree = false;
1166                 fio->pre_proc_saving(&crc_value, &_stat);
1167
1168                 for(auto p = listptr.begin(); p != listptr.end(); ++p) {
1169                         void *pp = NULL;
1170                         void *_ppshadow = NULL;
1171                         int _tid = (*p).type_id;
1172                         int _asize = (*p).atomlen;
1173                         int _len = (*p).len;
1174                         bool _use_is_null = (*p).use_is_null;
1175                         if(_use_is_null) {
1176                                 pp = (*p).ptr.p;
1177                         } else if((_tid & csp_saver_entry_const) != 0) {
1178                                 _ppshadow = (*p).ptr.p;
1179                                 if((*p).assume_byte) {
1180                                         pp = malloc(_len);
1181                                         memcpy(pp, _ppshadow, _len);
1182                                 } else {
1183                                         pp = malloc(_len * _asize);
1184                                         memcpy(pp, _ppshadow, _len * _asize);
1185                                 }
1186                                 _tid = _tid & 0xffff;
1187                                 need_mfree = true;
1188                                 if(((*p).assume_byte)) {
1189                                         if(_asize > 1) {
1190                                                 _len = _len / _asize;
1191                                         }
1192                                 }
1193                         } else if((_tid & csp_saver_entry_vararray) != 0) {
1194                                 if((*p).datalenptr != NULL) {
1195                                         _len = *((*p).datalenptr);
1196                                 } else {
1197                                         _len = 0;
1198                                 }
1199                                 (*p).len =_len;
1200                                 _tid = _tid & ((int)~csp_saver_entry_vararray);
1201                                 void **xp = (void **)((*p).ptr.p);
1202                                 if(*xp != NULL) {
1203                                         pp = (void *)(*xp);
1204                                 } else {
1205                                         pp = NULL;
1206                                         _len = 0;
1207                                 }
1208                                 fio->put_int32(_len, &crc_value, &_stat);
1209                                 //out_debug_log("SAVE VARARRAY p=%08x len=%d atom=%d CRC=%08x",pp, _len, _asize, crc_value);
1210                                 //printf("SAVE VARARRAY p=%08x len=%d atom=%d CRC=%08x\n",pp, _len, _asize, crc_value);
1211                                 if(((*p).assume_byte) && (_asize > 1)) {
1212                                         _len = _len / _asize;
1213                                 }
1214                         } else {
1215                                 pp = (*p).ptr.p;
1216                         }
1217                         if((pp != NULL) && (_len > 0)) {
1218                                 int64_t tval;
1219                                 if(_use_is_null) {
1220                                         bool nval;
1221                                         _tid = (*p)._null_type_id;
1222                                         _asize = (*p)._null_atomlen;
1223                                         void **_pp = (void **)pp;
1224                                         if(*_pp == NULL) { // is_null
1225                                                 if((*p).is_null_value_const) {
1226                                                         tval = (*p).is_null_value.s;
1227                                                         pp = &tval;
1228                                                         _tid = typeid_map[typeid(int64_t)];
1229                                                 } else {
1230                                                         // Assume int
1231                                                         // ToDo: Apply type.
1232                                                         tval = *((int *)((*p).is_null_value.p));
1233                                                         pp = &tval;
1234                                                         _tid = typeid_map[typeid(int64_t)];
1235                                                 }
1236                                                 nval = true;
1237                                         } else { // not_null
1238                                                 if((*p).not_null_value_const) {
1239                                                         tval = (*p).not_null_value.s;
1240                                                         pp = &tval;
1241                                                         _tid = typeid_map[typeid(int64_t)];
1242                                                 } else {
1243                                                         // Assume int
1244                                                         // ToDo: Apply type.
1245                                                         tval = *((int *)((*p).not_null_value.p));
1246                                                         pp = &tval;
1247                                                         _tid = typeid_map[typeid(int64_t)];
1248                                                 }
1249                                                 nval = false;
1250                                         }
1251                                         fio->put_bool(nval, &crc_value, &_stat);
1252                                 }
1253                                 switch(_tid) {
1254                                 case csp_saver_entry_float:
1255                                         {
1256                                                 retval = 0;
1257                                                 float *px = (float *)pp;
1258                                                 for(int i = 0; i < _len; i++) {
1259                                                         fio->put_float(px[i], &crc_value, &_stat);
1260                                                         if(!_stat) {
1261                                                                 retval = -1;
1262                                                                 break;
1263                                                         }
1264                                                         retval++;
1265                                                 }
1266                                         }
1267                                         break;
1268                                 case csp_saver_entry_double:
1269                                         {
1270                                                 retval = 0;
1271                                                 double *px = (double *)pp;
1272                                                 for(int i = 0; i < _len; i++) {
1273                                                         fio->put_double(px[i], &crc_value, &_stat);
1274                                                         if(!_stat) {
1275                                                                 retval = -1;
1276                                                                 break;
1277                                                         }
1278                                                         retval++;
1279                                                 }
1280                                         }
1281                                         break;
1282                                 case csp_saver_entry_long_double:
1283                                         {
1284                                                 retval = 0;
1285                                                 long double *px = (long double *)pp;
1286                                                 for(int i = 0; i < _len; i++) {
1287                                                         fio->put_long_double(px[i], &crc_value, &_stat);
1288                                                         if(!_stat) {
1289                                                                 retval = -1;
1290                                                                 break;
1291                                                         }
1292                                                         retval++;
1293                                                 }
1294                                         }
1295                                         break;
1296                                 case csp_saver_entry_pair:
1297                                         {
1298                                                 retval = 0;
1299                                                 pair_t *px = (pair_t *)pp;
1300                                                 for(int i = 0; i < _len; i++) {
1301                                                         fio->put_pair32(px[i], &crc_value, &_stat);
1302                                                         if(!_stat) {
1303                                                                 retval = -1;
1304                                                                 break;
1305                                                         }
1306                                                         retval++;
1307                                                 }
1308                                         }
1309                                         break;
1310                                 case csp_saver_entry_int:
1311                                         {
1312                                                 retval = 0;
1313                                                 int *px = (int *)pp;
1314                                                 for(int i = 0; i < _len; i++) {
1315                                                         fio->put_int32(px[i], &crc_value, &_stat);
1316                                                         if(!_stat) {
1317                                                                 retval = -1;
1318                                                                 break;
1319                                                         }
1320                                                         retval++;
1321                                                 }
1322                                         }
1323                                         break;
1324                                 case csp_saver_entry_uint8:
1325                                         {
1326                                                 retval = 0;
1327                                                 uint8_t *px = (uint8_t *)pp;
1328                                                 if(_len > 1) {
1329                                                         size_t _n = __fio->Fwrite(px, _len, 1);
1330                                                         if(_n != 1) {
1331                                                                 retval = 0;
1332                                                                 _stat = false;
1333                                                         } else {
1334                                                                 retval = _len;
1335                                                                 _stat = true;
1336                                                                 crc_value = calc_crc32(crc_value, px, _len);
1337                                                         }
1338                                                 } else {
1339                                                         fio->put_byte(*px, &crc_value, &_stat);
1340                                                         if(!_stat) {
1341                                                                 retval = -1;
1342                                                                 break;
1343                                                         }
1344                                                         retval++;
1345                                                 }
1346                                         }
1347                                         break;
1348                                 case csp_saver_entry_int8:
1349                                         {
1350                                                 retval = 0;
1351                                                 int8_t *px = (int8_t *)pp;
1352                                                 if(_len > 1) {
1353                                                         size_t _n = __fio->Fwrite(px, _len, 1);
1354                                                         if(_n != 1) {
1355                                                                 retval = 0;
1356                                                                 _stat = false;
1357                                                         } else {
1358                                                                 retval = _len;
1359                                                                 _stat = true;
1360                                                                 crc_value = calc_crc32(crc_value, (uint8_t *)px, _len);
1361                                                         }
1362                                                 } else {
1363                                                         fio->put_int8(*px, &crc_value, &_stat);
1364                                                         if(!_stat) {
1365                                                                 retval = -1;
1366                                                                 break;
1367                                                         }
1368                                                         retval++;
1369                                                 }
1370                                         }
1371                                         break;
1372                                 case csp_saver_entry_uint16:
1373                                         {
1374                                                 retval = 0;
1375                                                 uint16_t *px = (uint16_t *)pp;
1376                                                 for(int i = 0; i < _len; i++) {
1377                                                         fio->put_word(px[i], &crc_value, &_stat);
1378                                                         if(!_stat) {
1379                                                                 retval = -1;
1380                                                                 break;
1381                                                         }
1382                                                         retval++;
1383                                                 }
1384                                         }
1385                                         break;
1386                                 case csp_saver_entry_int16:
1387                                         {
1388                                                 retval = 0;
1389                                                 int16_t *px = (int16_t *)pp;
1390                                                 for(int i = 0; i < _len; i++) {
1391                                                         fio->put_int16(px[i], &crc_value, &_stat);
1392                                                         if(!_stat) {
1393                                                                 retval = -1;
1394                                                                 break;
1395                                                         }
1396                                                         retval++;
1397                                                 }
1398                                         }
1399                                         break;
1400                                 case csp_saver_entry_uint32:
1401                                         {
1402                                                 retval = 0;
1403                                                 uint32_t *px = (uint32_t *)pp;
1404                                                 for(int i = 0; i < _len; i++) {
1405                                                         fio->put_dword(px[i], &crc_value, &_stat);
1406                                                         if(!_stat) {
1407                                                                 retval = -1;
1408                                                                 break;
1409                                                         }
1410                                                         retval++;
1411                                                 }
1412                                         }
1413                                         break;
1414                                 case csp_saver_entry_int32:
1415                                         {
1416                                                 retval = 0;
1417                                                 int32_t *px = (int32_t *)pp;
1418                                                 for(int i = 0; i < _len; i++) {
1419                                                         fio->put_int32(px[i], &crc_value, &_stat);
1420                                                         if(!_stat) {
1421                                                                 retval = -1;
1422                                                                 break;
1423                                                         }
1424                                                         retval++;
1425                                                 }
1426                                         }
1427                                         break;
1428                                 case csp_saver_entry_uint64:
1429                                         {
1430                                                 retval = 0;
1431                                                 uint64_t *px = (uint64_t *)pp;
1432                                                 for(int i = 0; i < _len; i++) {
1433                                                         fio->put_qword(px[i], &crc_value, &_stat);
1434                                                         if(!_stat) {
1435                                                                 retval = -1;
1436                                                                 break;
1437                                                         }
1438                                                         retval++;
1439                                                 }
1440                                         }
1441                                         break;
1442                                 case csp_saver_entry_int64:
1443                                         {
1444                                                 retval = 0;
1445                                                 int64_t *px = (int64_t *)pp;
1446                                                 for(int i = 0; i < _len; i++) {
1447                                                         fio->put_int64(px[i], &crc_value, &_stat);
1448                                                         if(!_stat) {
1449                                                                 retval = -1;
1450                                                                 break;
1451                                                         }
1452                                                         retval++;
1453                                                 }
1454                                         }
1455                                         break;
1456                                 case csp_saver_entry_bool:
1457                                         {
1458                                                 retval = 0;
1459                                                 bool *px = (bool *)pp;
1460                                                 for(int i = 0; i < _len ; i++) {
1461                                                         fio->put_bool(px[i], &crc_value, &_stat);
1462                                                         if(!_stat) {
1463                                                                 retval = -1;
1464                                                                 break;
1465                                                         }
1466                                                         retval++;
1467                                                 }
1468                                         }
1469                                         break;
1470                                 case csp_saver_entry_tchar:
1471                                         {
1472                                                 retval = fio->save_string_data((const _TCHAR *)pp, &crc_value, _len, &_stat);
1473                                                 if(!_stat) retval = -1;
1474                                         }
1475                                         break;
1476                                 case csp_saver_entry_any:
1477                                         {
1478                                                 retval = fio->put_byte_array((uint8_t *)pp, _asize, _len, &crc_value, &_stat);
1479                                                 if(!_stat) retval = -1;
1480                                         }
1481                                         break;
1482                                 case csp_saver_entry_fifo:
1483                                         if(pp != NULL) {
1484                                                 FIFO **fp = (FIFO **)pp;
1485                                                 for(int i = 0; i < _len; i++) {
1486                                                         fp[i]->save_state_helper(fio, &crc_value, &_stat);
1487                                                 }
1488                                                 retval = _len;
1489                                         }
1490                                         break;
1491                                 case csp_saver_entry_cur_time_t:
1492                                         if(pp != NULL) {
1493                                                 cur_time_t *fp = (cur_time_t *)pp;
1494                                                 for(int i = 0; i < _len; i++) {
1495                                                         fp[i].save_state_helper(fio, &crc_value, &_stat);
1496                                                 }
1497                                                 retval = _len;
1498                                         }
1499                                         break;
1500                                 default:
1501                                         retval = 0;
1502                                         break;
1503                                 }
1504                                 if((retval <= 0) || (!_stat)) {
1505                                         if(need_mfree) {
1506                                                 if(pp != NULL) free(pp);
1507                                         }
1508                                         delete fio;
1509                                         return false;
1510                                 }
1511
1512                         }
1513                         //out_debug_log("CRC=%08x", crc_value);
1514                         if(need_mfree) {
1515                                 if(pp != NULL) free(pp);
1516                         }
1517                         need_mfree = false;
1518                 }
1519                 fio->post_proc_saving(&crc_value, &_stat);
1520                 delete fio;
1521         }
1522         fio = NULL;
1523         // embed CRC
1524         out_debug_log("CRC: VAL=%08x", crc_value);
1525         if(pcrc != NULL) *pcrc = crc_value;
1526         return true;
1527 }
1528
1529 bool csp_state_utils::load_state(FILEIO *__fio, uint32_t *pcrc)
1530 {
1531         int retval;
1532         bool _stat;
1533         bool crc_stat = false;
1534         // Initialize crc;
1535         //class_version_bak = class_version;
1536         //this_device_id_bak = this_device_id;
1537         memset(__classname_bak, 0x00, sizeof(__classname_bak));
1538         //strncpy(__classname_bak, __classname, sizeof(__classname));
1539         if(pcrc == NULL) {
1540                 crc_value = 0xffffffff;
1541         } else {
1542                 crc_value = *pcrc;
1543         }
1544
1545         fio = new csp_state_data_saver(__fio);
1546         out_debug_log("LOAD STATE: NAME=%s DEVID=%d VER=%d", __classname, this_device_id, class_version);
1547         if(fio != NULL) {
1548                 bool need_mfree = false;
1549                 fio->pre_proc_loading(&crc_value, &_stat);
1550                 for(auto p = listptr.begin(); p != listptr.end(); ++p) {
1551                         void *pp = NULL;
1552                         int _tid = (*p).type_id;
1553                         int _asize = (*p).atomlen;
1554                         int _len = (*p).len;
1555                         std::string _name = (*p).name;
1556                         bool _use_is_null = (*p).use_is_null;
1557                         bool nval = false;
1558                         int64_t tval;
1559                         if(_use_is_null) {
1560                                 pp = (*p).ptr.p;
1561                         } else if((_tid & csp_saver_entry_const) != 0) {
1562                                 //_ppshadow = (*p).ptr;
1563                                 if((*p).assume_byte) {
1564                                         pp = malloc(_len);
1565                                         //memcpy(pp, _ppshadow, _len);
1566                                 } else {
1567                                         pp = malloc(_len * _asize);
1568                                         //memcpy(pp, _ppshadow, _len * asize);
1569                                 }
1570                                 _tid = _tid & 0xffff;
1571                                 need_mfree = true;
1572                                 if(((*p).assume_byte)) {
1573                                         if(_asize > 1) {
1574                                                 _len = _len / _asize;
1575                                         }
1576                                 }
1577                         } else  if((_tid & csp_saver_entry_vararray) != 0) {
1578                                 _len = fio->get_int32(&crc_value, &_stat);
1579                                 void **xp = (void **)((*p).ptr.p);
1580                                 if(*xp != NULL) {
1581                                         free(*xp);
1582                                 }
1583                                 *xp = NULL;
1584                                 if(_len > 0) {
1585                                         if(((*p).assume_byte)) {
1586                                                 *xp = malloc(_len);
1587                                         } else {
1588                                                 *xp = malloc(_asize * _len);
1589                                         }
1590                                         if(*xp == NULL) _len = 0;
1591                                 }
1592                                 if((*p).datalenptr != NULL) {
1593                                         *((*p).datalenptr) = _len;
1594                                 }
1595                                 pp = *xp;
1596                                 _tid = _tid & ((int)~csp_saver_entry_vararray);
1597                                 if(((*p).assume_byte)) {
1598                                         if(_asize > 1) {
1599                                                 _len = _len / _asize;
1600                                         }
1601                                 }
1602                                 //out_debug_log("LOAD VARARRAY p=%08x len=%d atom=%d CRC=%08x",pp, _len, _asize, crc_value);
1603                                 //printf("LOAD VARARRAY p=%08x len=%d atom=%d CRC=%08x\n",pp, _len, _asize, crc_value);
1604                         } else {
1605                                 pp = (*p).ptr.p;
1606                         }
1607                         if((pp != NULL) && (_len > 0)) {
1608                                 if(_use_is_null) {
1609                                         nval = fio->get_bool(&crc_value, &_stat);
1610                                         if(nval) {
1611                                                 if((*p).is_null_value_const) {
1612                                                         _tid = typeid_map[typeid(int64_t)];
1613                                                         pp = &tval;
1614                                                         _asize = sizeof(int64_t);
1615                                                 } else {
1616                                                         _tid = (*p)._null_type_id;
1617                                                         pp = (*p).recv_ptr.p;
1618                                                         _asize = (*p)._null_atomlen;
1619                                                 }
1620                                         } else {
1621                                                 if((*p).not_null_value_const) {
1622                                                         _tid = typeid_map[typeid(int64_t)];
1623                                                         pp = &tval;
1624                                                         _asize = sizeof(int64_t);
1625                                                 } else {
1626                                                         _tid = (*p)._null_type_id;
1627                                                         pp = (*p).recv_ptr.p;
1628                                                         _asize = (*p)._null_atomlen;
1629                                                 }
1630                                         }
1631                                 }
1632                                 switch(_tid) {
1633                                 case csp_saver_entry_float:
1634                                         {
1635                                                 retval = 0;
1636                                                 float *px = (float *)pp;
1637                                                 for(int i = 0; i < _len; i++) {
1638                                                         px[i] = fio->get_float(&crc_value, &_stat);
1639                                                         if(!_stat) {
1640                                                                 retval = -1;
1641                                                                 break;
1642                                                         }
1643                                                         retval++;
1644                                                 }
1645                                         }
1646                                         out_debug_log("NAME=%s FLOAT: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1647                                         break;
1648                                 case csp_saver_entry_double:
1649                                         {
1650                                                 retval = 0;
1651                                                 double *px = (double *)pp;
1652                                                 for(int i = 0; i < _len; i++) {
1653                                                         px[i] = fio->get_double(&crc_value, &_stat);
1654                                                         if(!_stat) {
1655                                                                 retval = -1;
1656                                                                 break;
1657                                                         }
1658                                                         retval++;
1659                                                 }
1660                                         }
1661                                         out_debug_log("NAME=%s DOUBLE: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1662                                         break;
1663                                 case csp_saver_entry_long_double:
1664                                         {
1665                                                 retval = 0;
1666                                                 long double *px = (long double *)pp;
1667                                                 for(int i = 0; i < _len; i++) {
1668                                                         px[i] = fio->get_long_double(&crc_value, &_stat);
1669                                                         if(!_stat) {
1670                                                                 retval = -1;
1671                                                                 break;
1672                                                         }
1673                                                         retval++;
1674                                                 }
1675                                         }
1676                                         out_debug_log("NAME=%s LONG DOUBLE: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1677                                         break;
1678                                 case csp_saver_entry_pair:
1679                                         {
1680                                                 retval = 0;
1681                                                 pair_t *px = (pair_t *)pp;
1682                                                 for(int i = 0; i < _len; i++) {
1683                                                         px[i] = fio->get_pair32(&crc_value, &_stat);
1684                                                         if(!_stat) {
1685                                                                 retval = -1;
1686                                                                 break;
1687                                                         }
1688                                                         retval++;
1689                                                 }
1690                                         }
1691                                         out_debug_log("NAME=%s PAIR_T: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0,pp);
1692                                         break;
1693                                 case csp_saver_entry_int:
1694                                         {
1695                                                 retval = 0;
1696                                                 int *px = (int *)pp;
1697                                                 for(int i = 0; i < _len; i++) {
1698                                                         px[i] = fio->get_int32(&crc_value, &_stat);
1699                                                         if(!_stat) {
1700                                                                 retval = -1;
1701                                                                 break;
1702                                                         }
1703                                                         retval++;
1704                                                 }
1705                                         }
1706                                         out_debug_log("NAME=%s INT: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1707                                         break;
1708                                 case csp_saver_entry_uint8:
1709                                         {
1710                                                 retval = 0;
1711                                                 uint8_t *px = (uint8_t *)pp;
1712                                                 if((_len > 1) && (px != NULL)) {
1713                                                         size_t _n = __fio->Fread(px, _len, 1);
1714                                                         if(_n != 1) {
1715                                                                 retval = 0;
1716                                                                 _stat = false;
1717                                                         } else {
1718                                                                 retval = _len;
1719                                                                 _stat = true;
1720                                                                 crc_value = calc_crc32(crc_value, px, _len);
1721                                                         }
1722                                                 } else {
1723                                                         *px = fio->get_byte(&crc_value, &_stat);
1724                                                         if(!_stat) {
1725                                                                 retval = -1;
1726                                                                 break;
1727                                                         }
1728                                                         retval++;
1729                                                 }
1730                                         }
1731                                         out_debug_log("NAME=%s UINT8: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1732                                         break;
1733                                 case csp_saver_entry_int8:
1734                                         {
1735                                                 retval = 0;
1736                                                 int8_t *px = (int8_t *)pp;
1737                                                 if((_len > 1) && (px != NULL)) {
1738                                                         size_t _n = __fio->Fread(px, _len, 1);
1739                                                         if(_n != 1) {
1740                                                                 retval = 0;
1741                                                                 _stat = false;
1742                                                         } else {
1743                                                                 retval = _len;
1744                                                                 _stat = true;
1745                                                                 crc_value = calc_crc32(crc_value, px, _len);
1746                                                         }
1747                                                 } else {
1748                                                         *px = fio->get_int8(&crc_value, &_stat);
1749                                                         if(!_stat) {
1750                                                                 retval = -1;
1751                                                                 break;
1752                                                         }
1753                                                         retval++;
1754                                                 }
1755                                         }
1756                                         out_debug_log("NAME=%s INT8: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1757                                         break;
1758                                 case csp_saver_entry_uint16:
1759                                         {
1760                                                 retval = 0;
1761                                                 uint16_t *px = (uint16_t *)pp;
1762                                                 for(int i = 0; i < _len; i++) {
1763                                                         px[i] = fio->get_word(&crc_value, &_stat);
1764                                                         if(!_stat) {
1765                                                                 retval = -1;
1766                                                                 break;
1767                                                         }
1768                                                         retval++;
1769                                                 }
1770                                         }
1771                                         out_debug_log("NAMEE=%s UINT16: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1772                                         break;
1773                                 case csp_saver_entry_int16:
1774                                         {
1775                                                 retval = 0;
1776                                                 int16_t *px = (int16_t *)pp;
1777                                                 for(int i = 0; i < _len; i++) {
1778                                                         px[i] = fio->get_int16(&crc_value, &_stat);
1779                                                         if(!_stat) {
1780                                                                 retval = -1;
1781                                                                 break;
1782                                                         }
1783                                                         retval++;
1784                                                 }
1785                                         }
1786                                         out_debug_log("NAME=%s INT16: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1787                                         break;
1788                                 case csp_saver_entry_uint32:
1789                                         {
1790                                                 retval = 0;
1791                                                 uint32_t *px = (uint32_t *)pp;
1792                                                 for(int i = 0; i < _len; i++) {
1793                                                         px[i] = fio->get_dword(&crc_value, &_stat);
1794                                                         if(!_stat) {
1795                                                                 retval = -1;
1796                                                                 break;
1797                                                         }
1798                                                 retval++;
1799                                                 }
1800                                         }
1801                                         out_debug_log("NAME=%s UINT32: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1802                                         break;
1803                                 case csp_saver_entry_int32:
1804                                         {
1805                                                 retval = 0;
1806                                                 int32_t *px = (int32_t *)pp;
1807                                                 for(int i = 0; i < _len; i++) {
1808                                                         px[i] = fio->get_int32(&crc_value, &_stat);
1809                                                         if(!_stat) {
1810                                                                 retval = -1;
1811                                                                 break;
1812                                                         }
1813                                                         retval++;
1814                                                 }
1815                                         }
1816                                         out_debug_log("NAME=%s INT32: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1817                                         break;
1818                                 case csp_saver_entry_uint64:
1819                                         {
1820                                                 retval = 0;
1821                                                 uint64_t *px = (uint64_t *)pp;
1822                                                 for(int i = 0; i < _len; i++) {
1823                                                         px[i] = fio->get_qword(&crc_value, &_stat);
1824                                                         if(!_stat) {
1825                                                                 retval = -1;
1826                                                                 break;
1827                                                         }
1828                                                         retval++;
1829                                                 }
1830
1831                                         }
1832                                         out_debug_log("NAME=%s UINT64: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1833                                         break;
1834                                 case csp_saver_entry_int64:
1835                                         {
1836                                                 retval = 0;
1837                                                 int64_t *px = (int64_t *)pp;
1838                                                 for(int i = 0; i < _len; i++) {
1839                                                         px[i] = fio->get_int64(&crc_value, &_stat);
1840                                                         if(!_stat) {
1841                                                                 retval = -1;
1842                                                                 break;
1843                                                         }
1844                                                 retval++;
1845                                                 }
1846                                         }
1847                                         out_debug_log("NAME=%s INT64: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1848                                         break;
1849                                 case csp_saver_entry_bool:
1850                                         {
1851                                                 retval = 0;
1852                                                 bool *px = (bool *)pp;
1853                                                 for(int i = 0; i < _len; i++) {
1854                                                         px[i] = fio->get_bool(&crc_value, &_stat);
1855                                                         if(!_stat) {
1856                                                                 retval = -1;
1857                                                                 break;
1858                                                         }
1859                                                 retval++;
1860                                                 }
1861                                         }
1862                                         out_debug_log("NAME=%s BOOL: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1863                                         break;
1864                                 case csp_saver_entry_tchar:
1865                                         {
1866                                                 retval = fio->load_string_data((const _TCHAR *)pp, &crc_value, _len, &_stat);
1867                                                 out_debug_log("NAME=%s STR: LEN=%d STAT=%d S=%s", _name.c_str(), retval, (_stat) ? 1 : 0, (_TCHAR *)pp);
1868                                                 if(!_stat) retval = -1;
1869                                         }
1870                                         break;
1871                                 case csp_saver_entry_any:
1872                                         {
1873                                                 retval = fio->get_byte_array((uint8_t *)pp, _asize, _len, &crc_value, &_stat);
1874                                                 if(!_stat) retval = -1;
1875                                                 out_debug_log("NAME=%s BYTE-ARRAY: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), retval, (_stat) ? 1 : 0, pp);
1876                                         }
1877                                         break;
1878                                 case csp_saver_entry_fifo:
1879                                         if(pp != NULL) {
1880                                                 FIFO **fp = (FIFO **)pp;
1881                                                 bool _s = false;
1882                                                 for(int i = 0; i < _len; i++) {
1883                                                         _s = fp[i]->load_state_helper(fio, &crc_value, &_stat);
1884                                                         if(!(_s)) {
1885                                                                 retval = -1;
1886                                                                 _stat = false;
1887                                                                 break;
1888                                                         }
1889                                                 }
1890                                                 if(_s) retval = _len;
1891                                         }
1892                                         break;
1893                                 case csp_saver_entry_cur_time_t:
1894                                         if(pp != NULL) {
1895                                                 cur_time_t *fp = (cur_time_t *)pp;
1896                                                 bool _s = false;
1897                                                 for(int i = 0; i < _len; i++) {
1898                                                         _s = fp[i].load_state_helper(fio, &crc_value, &_stat);
1899                                                         if(!(_s)) {
1900                                                                 retval = -1;
1901                                                                 _stat = false;
1902                                                                 break;
1903                                                         }
1904                                                 }
1905                                                 if(_s) retval = _len;
1906                                         }
1907                                         break;
1908                                 default:
1909                                         retval = 0;
1910                                         out_debug_log("NAME=%s UNKNOWN TID=%d: LEN=%d STAT=%d HEAD=%08x", _name.c_str(), _tid, retval, (_stat) ? 1 : 0, pp);
1911                                         break;
1912                                 }
1913                                 if((retval <= 0) || (!_stat)) {
1914                                         if(need_mfree) {
1915                                                 if(pp != NULL) free(pp);
1916                                         }
1917                                         delete fio;
1918                                         return false;
1919                                 }
1920                         }
1921                         out_debug_log("CRC=%08x", crc_value);
1922                         if(need_mfree) {
1923                                 if(memcmp(pp, (*p).ptr.p , _len * _asize) != 0) {
1924                                         delete fio;
1925                                         free(pp);
1926                                         return false;
1927                                 }
1928                                 free(pp);
1929                         }
1930                         need_mfree = false;
1931                         if((_use_is_null) && ((*p).recv_ptr.p != NULL)){
1932                                 void *np;
1933                                 bool f = false;
1934                                 if(nval) {
1935                                         if((*p).is_null_value_const) {
1936                                                 f = true;
1937                                         }
1938                                 } else {
1939                                         if((*p).not_null_value_const) {
1940                                                 f = true;
1941                                         }
1942                                 }
1943                                 if(f) {
1944                                         switch((*p)._null_type_id) {
1945                                         case csp_saver_entry_int:
1946                                         case csp_saver_entry_int32:
1947                                                 *((int32_t *)((*p).recv_ptr.p)) = (int32_t)tval;
1948                                                 break;
1949                                         case csp_saver_entry_uint32:
1950                                                 *((uint32_t *)((*p).recv_ptr.p)) = (uint32_t)tval;
1951                                                 break;
1952                                         case csp_saver_entry_int8:
1953                                                 *((int8_t *)((*p).recv_ptr.p)) = (int8_t)tval;
1954                                                 break;
1955                                         case csp_saver_entry_uint8:
1956                                                 *((uint8_t *)((*p).recv_ptr.p)) = (uint8_t)tval;
1957                                                 break;
1958                                         case csp_saver_entry_int16:
1959                                                 *((int16_t *)((*p).recv_ptr.p)) = (int16_t)tval;
1960                                                 break;
1961                                         case csp_saver_entry_uint16:
1962                                                 *((uint16_t *)((*p).recv_ptr.p)) = (uint16_t)tval;
1963                                                 break;
1964                                         case csp_saver_entry_int64:
1965                                                 *((int64_t *)((*p).recv_ptr.p)) = (int64_t)tval;
1966                                                 break;
1967                                         case csp_saver_entry_uint64:
1968                                                 *((uint64_t *)((*p).recv_ptr.p)) = (uint64_t)tval;
1969                                                 break;
1970                                         case csp_saver_entry_bool:
1971                                                 *((bool *)((*p).recv_ptr.p)) = (tval == 0) ? false : true;
1972                                                 break;
1973                                         default:
1974                                                 break;
1975                                         }
1976                                 }
1977                         }
1978                 }
1979                 crc_stat = fio->post_proc_loading(&crc_value, &_stat);
1980                 delete fio;
1981         }
1982         fio = NULL;
1983
1984         if(pcrc != NULL) *pcrc = crc_value;
1985         if(!crc_stat) {
1986                 out_debug_log("WRONG crc_value: expects=%08x", crc_value);
1987                 return false;
1988         }
1989         // Check header
1990         if(this_device_id != this_device_id_bak) {
1991                 out_debug_log("WRONG device_id %d", this_device_id_bak);
1992                 return false;
1993         }
1994         if(class_version != class_version_bak) {
1995                 out_debug_log("WRONG crass_version %d", class_version_bak);
1996                 return false;
1997         }
1998         if(strncmp(__classname, __classname_bak, sizeof(__classname)) != 0) {
1999                 out_debug_log("WRONG CRASS NAME %s", __classname_bak);
2000                 return false;
2001         }
2002         out_debug_log("OK CRC=%08x", crc_value);
2003         return true;
2004 }