Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5936 | pavelyakov | 1 | /* |
2 | 2015 |
||
3 | Author: Pavel Yakovlev. |
||
4 | */ |
||
5 | |||
6 | #define LIB_NAME "array" |
||
7 | |||
8 | #include "coff.h" |
||
9 | |||
10 | #include |
||
11 | #include |
||
12 | |||
13 | typedef struct |
||
14 | { |
||
15 | dword key; |
||
16 | dword value; |
||
17 | } array; |
||
18 | |||
19 | char *ARRAY_KEY_STRING = (char *)0; |
||
20 | char *ARRAY_VALUE_STRING = (char *)0; |
||
21 | array *ARRAY_ADRESS = (dword)0; |
||
22 | |||
23 | dword hash_binary(char *data,dword size) |
||
24 | { |
||
25 | byte h1,h2,h3,h4; |
||
26 | if(!size) return 0; |
||
27 | h1 = *data; |
||
28 | if(size==1) return h1<<24; |
||
29 | h2 = *++data; |
||
30 | if(size==2) return (h1<<24)|(h2<<16); |
||
31 | h3 = *++data; |
||
32 | if(size==3) return (h1<<24)|(h2<<16)|(h3<<8); |
||
33 | h4 = *++data; |
||
34 | if(size==4) return (h1<<24)|(h2<<16)|(h3<<8)|(h4); |
||
35 | |||
36 | size-=4; |
||
37 | |||
38 | while(size--) |
||
39 | { |
||
40 | h1^=*data;h2^=*data;h3^=*data;h4^=*data; |
||
41 | ++data; |
||
42 | } |
||
43 | |||
44 | return (h1<<24)|(h2<<16)|(h3<<8)|(h4); |
||
45 | } |
||
46 | dword hash_string(char *data) |
||
47 | { |
||
48 | byte h1,h2,h3,h4; |
||
49 | if(!*data) return 0; |
||
50 | h1 = *data; |
||
51 | if(!*++data) return h1<<24; |
||
52 | h2 = *data; |
||
53 | if(!*++data) return (h1<<24)|(h2<<16); |
||
54 | h3 = *data; |
||
55 | if(!*++data) return (h1<<24)|(h2<<16)|(h3<<8); |
||
56 | h4 = *data; |
||
57 | if(!*++data) return (h1<<24)|(h2<<16)|(h3<<8)|(h4); |
||
58 | |||
59 | while(*data) |
||
60 | { |
||
61 | h1^=*data;h2^=*data;h3^=*data;h4^=*data; |
||
62 | ++data; |
||
63 | } |
||
64 | |||
65 | return (h1<<24)|(h2<<16)|(h3<<8)|(h4); |
||
66 | } |
||
67 | |||
68 | dword hash_integer(dword dec) |
||
69 | { |
||
70 | dword tmp = dec; |
||
71 | tmp <<= 16; |
||
72 | tmp ^= 0xFFFFFFFF; |
||
73 | dec &= tmp; |
||
74 | dec ^= dec>>5; |
||
75 | dec += dec<<3; |
||
76 | dec ^= dec>>13; |
||
77 | tmp = dec<<9; |
||
78 | tmp ^= 0xFFFFFFFF; |
||
79 | dec += tmp; |
||
80 | dec ^= dec>>17; |
||
81 | return dec; |
||
82 | } |
||
83 | |||
84 | dword buffer = 0xFF; |
||
85 | dword ARRAY_COUNT = 0; |
||
86 | dword tmp,tmp1; |
||
87 | |||
88 | array *key_string_set(dword *ary,char *key,void *data) |
||
89 | { |
||
90 | //dword *ptr = (dword *)ary; |
||
91 | array *m; |
||
92 | if(!*ary) |
||
93 | { |
||
94 | *ary = (dword)malloc(sizeof(array)*(buffer+1)); |
||
95 | m = (array *)*ary; |
||
96 | m[0].value = buffer; |
||
97 | } |
||
98 | |||
99 | else |
||
100 | { |
||
101 | m = (array *)*ary; |
||
102 | if(m[0].value<=m[0].key) |
||
103 | { |
||
104 | m[0].value += buffer; |
||
105 | *ary = (dword)realloc((void*)*ary,sizeof(array)*(m[0].value+1)); |
||
106 | } |
||
107 | } |
||
108 | |||
109 | ++m[0].key; |
||
110 | |||
111 | dword tmp = hash_string(key)%buffer; |
||
112 | tmp+=(m[0].value/buffer)*buffer; |
||
113 | ++tmp; |
||
114 | |||
115 | while(m[tmp].key) |
||
116 | { |
||
117 | if(!strcmp(key,(char*)m[tmp].key))break; |
||
118 | ++tmp; |
||
119 | } |
||
120 | m[tmp].key = (dword)key; |
||
121 | m[tmp].value = (dword)data; |
||
122 | return m; |
||
123 | } |
||
124 | |||
125 | array *key_binary_set(dword *ary,void *key,void *data,dword size) |
||
126 | { |
||
127 | |||
128 | array *m; |
||
129 | if(!*ary) |
||
130 | { |
||
131 | *ary = (dword)malloc(sizeof(array)*(buffer+1)); |
||
132 | m = (array *)*ary; |
||
133 | m[0].value = buffer+1; |
||
134 | } |
||
135 | else |
||
136 | { |
||
137 | m = (array *)*ary; |
||
138 | } |
||
139 | |||
140 | ++m[0].key; |
||
141 | |||
142 | dword tmp = hash_string(key)%buffer; |
||
143 | ++tmp; |
||
144 | while(m[tmp].key) |
||
145 | { |
||
146 | if(!strncmp((char*)key,(char*)m[tmp].key,size))break; |
||
147 | ++tmp; |
||
148 | } |
||
149 | m[tmp].key = (dword)key; |
||
150 | m[tmp].value = (dword)data; |
||
151 | return m; |
||
152 | } |
||
153 | |||
154 | array *key_integer_set(dword *ary,dword key,void *data) |
||
155 | { |
||
156 | |||
157 | |||
158 | if(!*ary) |
||
159 | { |
||
160 | //(dword)m[0].value = (dword)buffer; |
||
161 | *ary = (dword)malloc(sizeof(array)*(buffer+1)); |
||
162 | } |
||
163 | |||
164 | array *m = (array *)*ary; |
||
165 | |||
166 | dword tmp = hash_integer(key)%buffer; |
||
167 | |||
168 | while(m[tmp].key) |
||
169 | { |
||
170 | if(key==m[tmp].key)break; |
||
171 | ++tmp; |
||
172 | } |
||
173 | m[tmp].key = (dword)key; |
||
174 | m[tmp].value = (dword)data; |
||
175 | return m; |
||
176 | } |
||
177 | |||
178 | |||
179 | void *key_string_get(dword *ary,char *key) |
||
180 | { |
||
181 | if(!*ary)return 0; |
||
182 | |||
183 | array *m = (array *)*ary; |
||
184 | |||
185 | dword tmp = hash_string(key)%buffer; |
||
186 | tmp+=(m[0].value/buffer)*buffer; |
||
187 | ++tmp; |
||
188 | while(m[tmp].key) |
||
189 | { |
||
190 | if(!strcmp(key,(char*)m[tmp].key))break; |
||
191 | ++tmp; |
||
192 | } |
||
193 | return (void *)m[tmp].value; |
||
194 | } |
||
195 | |||
196 | void *key_binary_get(dword *ary,char *key,dword size) |
||
197 | { |
||
198 | if(!*ary)return 0; |
||
199 | |||
200 | array *m = (array *)*ary; |
||
201 | |||
202 | dword tmp = hash_string(key)%buffer; |
||
203 | |||
204 | while(m[tmp].key) |
||
205 | { |
||
206 | if(!strncmp(key,(char*)m[tmp].key,size))break; |
||
207 | ++tmp; |
||
208 | } |
||
209 | return (void *)m[tmp].value; |
||
210 | } |
||
211 | |||
212 | void *key_integer_get(dword *ary,dword key) |
||
213 | { |
||
214 | if(!*ary)return 0; |
||
215 | |||
216 | array *m = (array *)*ary; |
||
217 | |||
218 | dword tmp = hash_integer(key)%buffer; |
||
219 | |||
220 | while(m[tmp].key) |
||
221 | { |
||
222 | if(key==m[tmp].key)break; |
||
223 | ++tmp; |
||
224 | } |
||
225 | return (void *)m[tmp].value; |
||
226 | } |
||
227 | |||
228 | |||
229 | EXPORT_ |
||
230 | export(buffer) |
||
231 | |||
232 | export(hash_string) |
||
233 | export(hash_binary) |
||
234 | export(hash_integer) |
||
235 | |||
236 | export(key_string_set) |
||
237 | export(key_binary_set) |
||
238 | export(key_integer_set) |
||
239 | |||
240 | export(key_string_get) |
||
241 | export(key_binary_get) |
||
242 | export(key_integer_get) |
||
243 | |||
244 | _EXPORT=m[0].key) |