Subversion Repositories Kolibri OS

Rev

Rev 7420 | Rev 7741 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // Author: Pavel Iakovlev by. pavelyakov
  2.  
  3.  
  4. // Array memory: [dword key][byte flags][dword left][dword right][dword value] -> 17 bytes = 1 position
  5. // If key don't exists then value == 0
  6. :struct Array
  7. {
  8.         dword memory;
  9.         dword offsetMemory;
  10.         dword lenInitSize;
  11.         dword recursiveIndex(dword i, address);
  12.         byte set(dword key, data);
  13.         dword get(dword key);
  14.         void reallocMemory(dword newSize);
  15.         //dword del(dword key);
  16.         byte init(dword size);
  17. };
  18.  
  19. :void Array::reallocMemory(dword newSize)
  20. {
  21.         memory = realloc(memory, newSize);
  22.         lenInitSize = newSize;
  23. }
  24.  
  25. :dword Array::recursiveIndex(dword key, address)
  26. {
  27.         dword flags = 0;
  28.         IF (DSDWORD[address] == key) RETURN address;
  29.         flags = DSBYTE[address + 4];
  30.         //IF (flags & 100b) RETURN address; // if delete
  31.         IF (flags & 010b) && (DSDWORD[address] < key) RETURN recursiveIndex(key, DSDWORD[address + 5]); // left tree
  32.         IF (flags & 001b) && (DSDWORD[address] > key) RETURN recursiveIndex(key, DSDWORD[address + 9]); // right tree
  33.         RETURN address;
  34. }
  35. :byte Array::init(dword size)
  36. {
  37.         IF(!size) RETURN 0;
  38.         IF(!memory)
  39.         {
  40.                 lenInitSize = size * 17;
  41.                 memory = malloc(lenInitSize);
  42.                 EBX = memory;
  43.                 DSDWORD[EBX] = 0;
  44.                 DSBYTE[EBX + 4] = 0;
  45.                 DSDWORD[EBX + 5] = 0;
  46.                 DSDWORD[EBX + 9] = 0;
  47.                 DSDWORD[EBX + 13] = 0;
  48.                 offsetMemory = 17;
  49.                 RETURN 0xFF;
  50.         }
  51.         IF(size > lenInitSize)
  52.         {
  53.                 reallocMemory(size * 17);
  54.                 RETURN 0xFF;
  55.         }
  56.         RETURN 0;
  57. }
  58. :byte Array::set(dword key, data)
  59. {
  60.         dword address = 0;
  61.         dword newOffset = 0;
  62.         IF(offsetMemory > lenInitSize) reallocMemory(offsetMemory << 1);
  63.         address = recursiveIndex(key, memory);
  64.         /*IF(DSBYTE[address + 4] & 100b)
  65.         {
  66.                 IF(DSDWORD[address] < key)
  67.                 {
  68.                         DSBYTE[address + 4] |= 10b;
  69.                         DSDWORD[address + 5] = newOffset;
  70.                 }
  71.                 ELSE IF(DSDWORD[address] > key)
  72.                 {
  73.                         DSBYTE[address + 4] |= 01b;
  74.                         DSDWORD[address + 9] = newOffset;
  75.                 }
  76.                 ELSE
  77.                 {
  78.                         DSDWORD[address + 13] = data;
  79.                         RETURN 0xFF;
  80.                 }
  81.         }*/
  82.         newOffset = memory + offsetMemory;
  83.         IF(DSDWORD[address] < key)
  84.         {
  85.                 DSBYTE[address + 4] |= 010b; // set flag left address
  86.                 DSDWORD[address + 5] = newOffset;
  87.         }
  88.         ELSE IF(DSDWORD[address] > key)
  89.         {
  90.                 DSBYTE[address + 4] |= 001b; // set flag right address
  91.                 DSDWORD[address + 9] = newOffset;
  92.         }
  93.         ELSE
  94.         {
  95.                 DSDWORD[address + 13] = data;
  96.                 RETURN 0xFF;
  97.         }
  98.         DSDWORD[newOffset] = key;
  99.         DSBYTE[newOffset+4] = 0;
  100.         DSDWORD[newOffset+5] = 0;
  101.         DSDWORD[newOffset+9] = 0;
  102.         DSDWORD[newOffset+13] = data;
  103.         offsetMemory += 17;
  104.         RETURN 0xFF;
  105. }
  106. :dword Array::get(dword key)
  107. {
  108.         EBX = recursiveIndex(key, memory);
  109.         IF(DSDWORD[EBX] != key) RETURN 0;
  110.         IF(DSBYTE[EBX + 4] & 100b) RETURN 0;
  111.         RETURN DSDWORD[EBX + 13];
  112. }
  113. /*:dword Array::del(dword key)
  114. {
  115.         dword address = 0;
  116.         address = recursiveIndex(key, memory);
  117.         IF(DSDWORD[address] != key) RETURN 0;
  118.         DSBYTE[address + 4] |= 100b;
  119.         RETURN 0xFF;
  120. }*/
  121.  
  122. :struct Dictionary
  123. {
  124.         Array array;
  125.         dword hash(dword text);
  126.         byte set(dword key, value);
  127.         dword get(dword key);
  128.         byte init(dword size);
  129. };
  130.  
  131. :dword Dictionary::hash(dword text) // max 255 bytes as strings => 4 byte or duble word hash
  132. {
  133.         dword checkSum1 = 1;
  134.         dword checkSum2 = 0;
  135.         dword beginAddress = 0;
  136.        
  137.         beginAddress = text;
  138.         WHILE(DSBYTE[text])
  139.         {
  140.                 checkSum1 += DSBYTE[text];
  141.                 checkSum2 += checkSum1;
  142.                 text++;
  143.         }
  144.         //IF(h1 > 0x03FFF) RETURN h1 << 8 ^ h2;
  145.         //IF(h2 > 0x3FFFF) RETURN h1 << 8 ^ h2;
  146.         EAX = text - beginAddress;
  147.         EAX <<= 23;
  148.         RETURN EAX | checkSum2;
  149. }
  150.  
  151. :byte Dictionary::set(dword key, value)
  152. {
  153.         RETURN array.set(hash(key),value);
  154. }
  155.  
  156. :dword Dictionary::get(dword key)
  157. {
  158.         RETURN array.get(hash(key));
  159. }
  160.  
  161. :byte Dictionary::init(dword size)
  162. {
  163.         RETURN array.init(size);
  164. }