Rev 7420 | Rev 7521 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 7420 | pavelyakov | 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; |
||
| 7430 | pavelyakov | 10 | dword lenInitSize; |
| 7420 | pavelyakov | 11 | dword recursiveIndex(dword i, address); |
| 12 | byte set(dword key, data); |
||
| 13 | dword get(dword key); |
||
| 7430 | pavelyakov | 14 | void reallocMemory(dword newSize); |
| 7420 | pavelyakov | 15 | //dword del(dword key); |
| 16 | byte init(dword size); |
||
| 17 | }; |
||
| 18 | |||
| 7430 | pavelyakov | 19 | :void Array::reallocMemory(dword newSize) |
| 20 | { |
||
| 21 | memory = realloc(memory, newSize); |
||
| 22 | lenInitSize = newSize; |
||
| 23 | } |
||
| 24 | |||
| 7420 | pavelyakov | 25 | :dword Array::recursiveIndex(dword key, address) |
| 26 | { |
||
| 27 | dword flags = 0; |
||
| 7430 | pavelyakov | 28 | IF (DSDWORD[address] == key) RETURN address; |
| 7420 | pavelyakov | 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 | { |
||
| 7430 | pavelyakov | 40 | lenInitSize = size * 17; |
| 41 | memory = malloc(lenInitSize); |
||
| 7420 | pavelyakov | 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 | } |
||
| 7430 | pavelyakov | 51 | IF(size > lenInitSize) |
| 52 | { |
||
| 53 | reallocMemory(size * 17); |
||
| 54 | RETURN 0xFF; |
||
| 55 | } |
||
| 56 | RETURN 0; |
||
| 7420 | pavelyakov | 57 | } |
| 58 | :byte Array::set(dword key, data) |
||
| 59 | { |
||
| 60 | dword address = 0; |
||
| 61 | dword newOffset = 0; |
||
| 7430 | pavelyakov | 62 | IF(offsetMemory > lenInitSize) reallocMemory(offsetMemory << 1); |
| 7420 | pavelyakov | 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 | { |
||
| 7430 | pavelyakov | 85 | DSBYTE[address + 4] |= 010b; // set flag left address |
| 7420 | pavelyakov | 86 | DSDWORD[address + 5] = newOffset; |
| 87 | } |
||
| 88 | ELSE IF(DSDWORD[address] > key) |
||
| 89 | { |
||
| 7430 | pavelyakov | 90 | DSBYTE[address + 4] |= 001b; // set flag right address |
| 7420 | pavelyakov | 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 | |||
| 7430 | pavelyakov | 131 | :dword Dictionary::hash(dword text) // max 255 bytes as strings => 4 byte or duble word hash |
| 7420 | pavelyakov | 132 | { |
| 7430 | pavelyakov | 133 | dword checkSum1 = 1; |
| 134 | dword checkSum2 = 0; |
||
| 135 | dword beginAddress = 0; |
||
| 7420 | pavelyakov | 136 | |
| 7430 | pavelyakov | 137 | beginAddress = text; |
| 7420 | pavelyakov | 138 | WHILE(DSBYTE[text]) |
| 139 | { |
||
| 7430 | pavelyakov | 140 | checkSum1 += DSBYTE[text]; |
| 141 | checkSum2 += checkSum1; |
||
| 7420 | pavelyakov | 142 | text++; |
| 143 | } |
||
| 7430 | pavelyakov | 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; |
||
| 7420 | pavelyakov | 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 | } |