← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbxt/src/util_xt.cc

  • Committer: Brian Aker
  • Date: 2010-03-15 21:50:05 UTC
  • mto: This revision was merged to the branch mainline in revision 1343.
  • Revision ID: brian@gaz-20100315215005-oqoblpbll9n0albj
Merge of table cache/def DD.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbxt/src/util_xt.cc
1
 
/* Copyright (C) 2005 PrimeBase Technologies GmbH
2
 
 *
3
 
 * PrimeBase XT
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
 
 *
19
 
 * 2004-01-03   Paul McCullagh
20
 
 *
21
 
 * H&G2JCtL
22
 
 */
23
 
 
24
 
#include "xt_config.h"
25
 
 
26
 
#include <stdio.h>
27
 
#include <time.h>
28
 
#include <ctype.h>
29
 
#ifndef XT_WIN
30
 
#include <sys/param.h>
31
 
#endif
32
 
 
33
 
#include "util_xt.h"
34
 
#include "strutil_xt.h"
35
 
#include "memory_xt.h"
36
 
 
37
 
xtPublic int xt_comp_log_pos(xtLogID id1, off_t off1, xtLogID id2, off_t off2)
38
 
{
39
 
        if (id1 < id2)
40
 
                return -1;
41
 
        if (id1 > id2)
42
 
                return 1;
43
 
        if (off1 < off2)
44
 
                return -1;
45
 
        if (off1 > off2)
46
 
                return 1;
47
 
        return 0;
48
 
}
49
 
 
50
 
/*
51
 
 * This function returns the current time in micorsonds since
52
 
 * 00:00:00 UTC, January 1, 1970.
53
 
 * Currently it is accurate to the second :(
54
 
 */
55
 
xtPublic xtWord8 xt_time_now(void)
56
 
{
57
 
        xtWord8 ms;
58
 
 
59
 
        ms = (xtWord8) time(NULL);
60
 
        ms *= 1000000;
61
 
        return ms;
62
 
}
63
 
 
64
 
xtPublic void xt_free_nothing(struct XTThread *XT_UNUSED(thread), void *XT_UNUSED(x))
65
 
{
66
 
}
67
 
 
68
 
/*
69
 
 * A file name has the form:
70
 
 * <text>-<number>[.<ext>]
71
 
 * This function return the number part as a
72
 
 * u_long.
73
 
 */
74
 
xtPublic xtWord4 xt_file_name_to_id(char *file_name)
75
 
{
76
 
        u_long value = 0;
77
 
 
78
 
        if (file_name) {
79
 
                char    *num = file_name +  strlen(file_name) - 1;
80
 
                
81
 
                while (num >= file_name && *num != '-')
82
 
                        num--;
83
 
                num++;
84
 
                if (isdigit(*num))
85
 
                        sscanf(num, "%lu", &value);
86
 
        }
87
 
        return (xtWord4) value;
88
 
}
89
 
 
90
 
/*
91
 
 * now is moving forward. then is a static time in the
92
 
 * future. What is the time difference?
93
 
 *
94
 
 * These variables can overflow.
95
 
 */ 
96
 
xtPublic int xt_time_difference(register xtWord4 now, register xtWord4 then)
97
 
{
98
 
        /* now is after then, so the now time has passed 
99
 
         * then. So we return a negative difference.
100
 
         */
101
 
        if (now >= then) {
102
 
                /* now has gone past then. If the difference is
103
 
                 * great, then we assume an overflow, and reverse!
104
 
                 */
105
 
                if ((now - then) > (xtWord4) 0xFFFFFFFF/2)
106
 
                        return (int) (0xFFFFFFFF - (now - then));
107
 
 
108
 
                return (int) now - (int) then;
109
 
        }
110
 
        /* If now is before then, we check the difference.
111
 
         * If the difference is very large, then we assume
112
 
         * that now has gone past then, and overflowed.
113
 
         */
114
 
        if ((then - now) > (xtWord4) 0xFFFFFFFF/2)
115
 
                return - (int) (0xFFFFFFFF - (then - now));
116
 
        return then - now;
117
 
}
118
 
 
119
 
xtPublic xtWord2 xt_get_checksum(xtWord1 *data, size_t len, u_int interval)
120
 
{
121
 
        register xtWord4        sum = 0, g;
122
 
        xtWord1                         *chk;
123
 
 
124
 
        chk = data + len - 1;
125
 
        while (chk > data) {
126
 
                sum = (sum << 4) + *chk;
127
 
                if ((g = sum & 0xF0000000)) {
128
 
                        sum = sum ^ (g >> 24);
129
 
                        sum = sum ^ g;
130
 
                }
131
 
                chk -= interval;
132
 
        }
133
 
        return (xtWord2) (sum ^ (sum >> 16));
134
 
}
135
 
 
136
 
xtPublic xtWord1 xt_get_checksum1(xtWord1 *data, size_t len)
137
 
{
138
 
        register xtWord4        sum = 0, g;
139
 
        xtWord1                         *chk;
140
 
 
141
 
        chk = data + len - 1;
142
 
        while (chk > data) {
143
 
                sum = (sum << 4) + *chk;
144
 
                if ((g = sum & 0xF0000000)) {
145
 
                        sum = sum ^ (g >> 24);
146
 
                        sum = sum ^ g;
147
 
                }
148
 
                chk--;
149
 
        }
150
 
        return (xtWord1) (sum ^ (sum >> 24) ^ (sum >> 16) ^ (sum >> 8));
151
 
}
152
 
 
153
 
xtPublic xtWord4 xt_get_checksum4(xtWord1 *data, size_t len)
154
 
{
155
 
        register xtWord4        sum = 0, g;
156
 
        xtWord1                         *chk;
157
 
 
158
 
        chk = data + len - 1;
159
 
        while (chk > data) {
160
 
                sum = (sum << 4) + *chk;
161
 
                if ((g = sum & 0xF0000000)) {
162
 
                        sum = sum ^ (g >> 24);
163
 
                        sum = sum ^ g;
164
 
                }
165
 
                chk--;
166
 
        }
167
 
        return sum;
168
 
}
169
 
 
170
 
/*
171
 
 * --------------- Data Buffer ------------------
172
 
 */
173
 
 
174
 
xtPublic xtBool xt_db_set_size(struct XTThread *self, XTDataBufferPtr dbuf, size_t size)
175
 
{
176
 
        if (dbuf->db_size < size) {
177
 
                if (!xt_realloc(self, (void **) &dbuf->db_data, size))
178
 
                        return FAILED;
179
 
                dbuf->db_size = size;
180
 
        }
181
 
        else if (!size) {
182
 
                if (dbuf->db_data)
183
 
                        xt_free(self, dbuf->db_data);
184
 
                dbuf->db_data = NULL;
185
 
                dbuf->db_size = 0;
186
 
        }
187
 
        return OK;
188
 
}
189
 
 
190
 
/*
191
 
 * --------------- Data Buffer ------------------
192
 
 */
193
 
 
194
 
xtPublic xtBool xt_ib_alloc(struct XTThread *self, XTInfoBufferPtr ib, size_t size)
195
 
{
196
 
        if (!ib->ib_free) {
197
 
                ib->ib_db.db_size = 0;
198
 
                ib->ib_db.db_data = NULL;
199
 
        }
200
 
        if (size <= ib->ib_db.db_size)
201
 
                return OK;
202
 
 
203
 
        if (size <= XT_IB_DEFAULT_SIZE) {
204
 
                ib->ib_db.db_size = XT_IB_DEFAULT_SIZE;
205
 
                ib->ib_db.db_data = ib->ib_data;
206
 
                return OK;
207
 
        }
208
 
 
209
 
        if (ib->ib_db.db_data == ib->ib_data) {
210
 
                ib->ib_db.db_size = 0;
211
 
                ib->ib_db.db_data = NULL;
212
 
        }
213
 
 
214
 
        ib->ib_free = TRUE;
215
 
        return xt_db_set_size(self, &ib->ib_db, size);
216
 
}
217
 
 
218
 
void xt_ib_free(struct XTThread *self, XTInfoBufferPtr ib)
219
 
{
220
 
        if (ib->ib_free) {
221
 
                xt_db_set_size(self, &ib->ib_db, 0);
222
 
                ib->ib_free = FALSE;
223
 
        }
224
 
}
225
 
 
226
 
/*
227
 
 * --------------- Basic List ------------------
228
 
 */
229
 
 
230
 
xtPublic xtBool xt_bl_set_size(struct XTThread *self, XTBasicListPtr bl, size_t size)
231
 
{
232
 
        if (bl->bl_size < size) {
233
 
                if (!xt_realloc(self, (void **) &bl->bl_data, size * bl->bl_item_size))
234
 
                        return FAILED;
235
 
                bl->bl_size = size;
236
 
        }
237
 
        else if (!size) {
238
 
                if (bl->bl_data)
239
 
                        xt_free(self, bl->bl_data);
240
 
                bl->bl_data = NULL;
241
 
                bl->bl_size = 0;
242
 
                bl->bl_count = 0;
243
 
        }
244
 
        return OK;
245
 
}
246
 
 
247
 
xtPublic xtBool xt_bl_dup(struct XTThread *self, XTBasicListPtr from_bl, XTBasicListPtr to_bl)
248
 
{
249
 
        to_bl->bl_item_size = from_bl->bl_item_size;
250
 
        to_bl->bl_size = 0;
251
 
        to_bl->bl_count = from_bl->bl_count;
252
 
        to_bl->bl_data = NULL;
253
 
        if (!xt_bl_set_size(self, to_bl, from_bl->bl_count))
254
 
                return FAILED;
255
 
        memcpy(to_bl->bl_data, from_bl->bl_data, to_bl->bl_count * to_bl->bl_item_size);
256
 
        return OK;
257
 
}
258
 
 
259
 
xtPublic xtBool xt_bl_append(struct XTThread *self, XTBasicListPtr bl, void *value)
260
 
{
261
 
        if (bl->bl_count == bl->bl_size) {
262
 
                if (!xt_bl_set_size(self, bl, bl->bl_count+1))
263
 
                        return FAILED;
264
 
        }
265
 
        memcpy(&bl->bl_data[bl->bl_count * bl->bl_item_size], value, bl->bl_item_size);
266
 
        bl->bl_count++;
267
 
        return OK;
268
 
}
269
 
 
270
 
xtPublic void *xt_bl_last_item(XTBasicListPtr bl)
271
 
{
272
 
        if (!bl->bl_count)
273
 
                return NULL;
274
 
        return &bl->bl_data[(bl->bl_count-1) * bl->bl_item_size];
275
 
}
276
 
 
277
 
xtPublic void *xt_bl_item_at(XTBasicListPtr bl, u_int i)
278
 
{
279
 
        if (i >= bl->bl_count)
280
 
                return NULL;
281
 
        return &bl->bl_data[i * bl->bl_item_size];
282
 
}
283
 
 
284
 
xtPublic void xt_bl_free(struct XTThread *self, XTBasicListPtr wl)
285
 
{
286
 
        xt_bl_set_size(self, wl, 0);
287
 
}
288
 
 
289
 
/*
290
 
 * --------------- Basic Queue ------------------
291
 
 */
292
 
 
293
 
xtPublic xtBool xt_bq_set_size(struct XTThread *self, XTBasicQueuePtr bq, size_t size)
294
 
{
295
 
        if (bq->bq_size < size) {
296
 
                if (!xt_realloc(self, (void **) &bq->bq_data, size * bq->bq_item_size))
297
 
                        return FAILED;
298
 
                bq->bq_size = size;
299
 
        }
300
 
        else if (!size) {
301
 
                if (bq->bq_data)
302
 
                        xt_free(self, bq->bq_data);
303
 
                bq->bq_data = NULL;
304
 
                bq->bq_size = 0;
305
 
                bq->bq_front = 0;
306
 
                bq->bq_back = 0;
307
 
        }
308
 
        return OK;
309
 
}
310
 
 
311
 
xtPublic void *xt_bq_get(XTBasicQueuePtr bq)
312
 
{
313
 
        if (bq->bq_back == bq->bq_front)
314
 
                return NULL;
315
 
        return &bq->bq_data[bq->bq_back * bq->bq_item_size];
316
 
}
317
 
 
318
 
xtPublic void xt_bq_next(XTBasicQueuePtr bq)
319
 
{
320
 
        if (bq->bq_back < bq->bq_front) {
321
 
                bq->bq_back++;
322
 
                if (bq->bq_front == bq->bq_back) {
323
 
                        bq->bq_front = 0;
324
 
                        bq->bq_back = 0;
325
 
                }
326
 
        }
327
 
}
328
 
 
329
 
xtPublic xtBool xt_bq_add(struct XTThread *self, XTBasicQueuePtr bq, void *value)
330
 
{
331
 
        if (bq->bq_front == bq->bq_size) {
332
 
                if (bq->bq_back >= bq->bq_max_waste) {
333
 
                        bq->bq_front -= bq->bq_back;
334
 
                        memmove(bq->bq_data, &bq->bq_data[bq->bq_back * bq->bq_item_size], bq->bq_front * bq->bq_item_size);
335
 
                        bq->bq_back = 0;
336
 
                }
337
 
                else {
338
 
                        if (!xt_bq_set_size(self, bq, bq->bq_front+bq->bq_item_inc))
339
 
                                return FAILED;
340
 
                }
341
 
        }
342
 
        memcpy(&bq->bq_data[bq->bq_front * bq->bq_item_size], value, bq->bq_item_size);
343
 
        bq->bq_front++;
344
 
        return OK;
345
 
}
346
 
 
347
 
xtPublic void xt_sb_free(struct XTThread *self, XTStringBufferPtr dbuf)
348
 
{
349
 
        xt_sb_set_size(self, dbuf, 0);
350
 
}
351
 
 
352
 
xtPublic xtBool xt_sb_set_size(struct XTThread *self, XTStringBufferPtr dbuf, size_t size)
353
 
{
354
 
        if (dbuf->sb_size < size) {
355
 
                if (!xt_realloc(self, (void **) &dbuf->sb_cstring, size))
356
 
                        return FAILED;
357
 
                dbuf->sb_size = size;
358
 
        }
359
 
        else if (!size) {
360
 
                if (dbuf->sb_cstring)
361
 
                        xt_free(self, dbuf->sb_cstring);
362
 
                dbuf->sb_cstring = NULL;
363
 
                dbuf->sb_size = 0;
364
 
                dbuf->sb_len = 0;
365
 
        }
366
 
        return OK;
367
 
}
368
 
 
369
 
xtPublic xtBool xt_sb_concat_len(struct XTThread *self, XTStringBufferPtr dbuf, c_char *str, size_t len)
370
 
{
371
 
        if (!xt_sb_set_size(self, dbuf, dbuf->sb_len + len + 1))
372
 
                return FAILED;
373
 
        memcpy(dbuf->sb_cstring + dbuf->sb_len, str, len);
374
 
        dbuf->sb_len += len;
375
 
        dbuf->sb_cstring[dbuf->sb_len] = 0;
376
 
        return OK;
377
 
}
378
 
 
379
 
xtPublic xtBool xt_sb_concat(struct XTThread *self, XTStringBufferPtr dbuf, c_char *str)
380
 
{
381
 
        return xt_sb_concat_len(self, dbuf, str, strlen(str));
382
 
}
383
 
 
384
 
xtPublic xtBool xt_sb_concat_char(struct XTThread *self, XTStringBufferPtr dbuf, int ch)
385
 
{
386
 
        if (!xt_sb_set_size(self, dbuf, dbuf->sb_len + 1 + 1))
387
 
                return FAILED;
388
 
        dbuf->sb_cstring[dbuf->sb_len] = (char) ch;
389
 
        dbuf->sb_len++;
390
 
        dbuf->sb_cstring[dbuf->sb_len] = 0;
391
 
        return OK;
392
 
}
393
 
 
394
 
xtPublic xtBool xt_sb_concat_int8(struct XTThread *self, XTStringBufferPtr dbuf, xtInt8 val)
395
 
{
396
 
        char buffer[200];
397
 
 
398
 
        sprintf(buffer, "%"PRId64, val);
399
 
        return xt_sb_concat(self, dbuf, buffer);
400
 
}
401
 
 
402
 
xtPublic char *xt_sb_take_cstring(XTStringBufferPtr sbuf)
403
 
{
404
 
        char *str = sbuf->sb_cstring;
405
 
        
406
 
        sbuf->sb_cstring = NULL;
407
 
        sbuf->sb_size = 0; 
408
 
        sbuf->sb_len = 0; 
409
 
        return str;
410
 
}
411
 
 
412
 
xtPublic xtBool xt_sb_concat_url_len(struct XTThread *self, XTStringBufferPtr dbuf, c_char *from, size_t len_from)
413
 
{
414
 
        if (!xt_sb_set_size(self, dbuf, dbuf->sb_len + len_from + 1))
415
 
                return FAILED;
416
 
        while (len_from--) {
417
 
                if (*from == '%' && len_from >= 2 && isxdigit(*(from+1)) && isxdigit(*(from+2))) {
418
 
                        unsigned char a = xt_hex_digit(*(from+1));
419
 
                        unsigned char b = xt_hex_digit(*(from+2));
420
 
                        dbuf->sb_cstring[dbuf->sb_len] = a << 4 | b;
421
 
                        from += 3;
422
 
                }
423
 
                else
424
 
                        dbuf->sb_cstring[dbuf->sb_len] = *from++;
425
 
                dbuf->sb_len++;
426
 
        }
427
 
        dbuf->sb_cstring[dbuf->sb_len] = 0;
428
 
        return OK;
429
 
}
430
 
 
431