← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbms/src/cslib/CSDefs.h

  • Committer: Brian Aker
  • Date: 2010-11-08 18:54:26 UTC
  • mto: (1921.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 1916.
  • Revision ID: brian@tangent.org-20101108185426-fymkf2xnelupf11x
Rename lock methods to be style + well make sense.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbms/src/cslib/CSDefs.h
 
1
/* Copyright (c) 2008 PrimeBase Technologies GmbH, Germany
 
2
 *
 
3
 * PrimeBase Media Stream for MySQL
 
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
 * Original author: Paul McCullagh (H&G2JCtL)
 
20
 * Continued development: Barry Leslie
 
21
 *
 
22
 * 2007-06-02
 
23
 *
 
24
 * CORE SYSTEM:
 
25
 * Common definitions that may be required be included at the
 
26
 * top of every header file.
 
27
 *
 
28
 */
 
29
 
 
30
#ifndef __CSDEFS_H__
 
31
#define __CSDEFS_H__
 
32
 
 
33
#include <sys/types.h>
 
34
 
 
35
// Use standard portable data types
 
36
#include <stdint.h>
 
37
 
 
38
/* Those compilers that support the function
 
39
 * macro (in particular the "pretty" function
 
40
 * macro must be defined here.
 
41
 */
 
42
#ifdef OS_WINDOWS
 
43
#define __FUNC__                                __FUNCTION__
 
44
#elif defined(OS_SOLARIS)
 
45
#define __FUNC__                                "__func__"
 
46
#else
 
47
#define __FUNC__                                __PRETTY_FUNCTION__
 
48
#endif
 
49
 
 
50
/*
 
51
 * An unsigned integer, 1 byte long:
 
52
 */
 
53
#ifndef u_char
 
54
#define u_char                  unsigned char
 
55
#endif
 
56
 
 
57
/*
 
58
 * An usigned integer, 1 byte long:
 
59
 */
 
60
#define s_char                  unsigned char
 
61
 
 
62
/* We assumes that off_t is 8 bytes so to ensure this always use  off64_t*/
 
63
#define off64_t                 uint64_t
 
64
 
 
65
 
 
66
/*
 
67
 * A signed integer at least 32 bits long.
 
68
 * The size used is whatever is most
 
69
 * convenient to the machine.
 
70
 */
 
71
#define s_int int_fast32_t
 
72
 
 
73
/* Forward declartion of a thread: */
 
74
class CSThread;
 
75
 
 
76
// Used to avoid warnings about unused parameters.
 
77
#define UNUSED(x) (void)x
 
78
 
 
79
#ifdef OS_WINDOWS
 
80
 
 
81
#define CS_DEFAULT_EOL          "\r\n"
 
82
#define CS_DIR_CHAR                     '\\'
 
83
#define CS_DIR_DELIM            "\\"
 
84
#define IS_DIR_CHAR(ch)         ((ch) == CS_DIR_CHAR || (ch) == '/')
 
85
 
 
86
#ifndef PATH_MAX
 
87
#define PATH_MAX                MAX_PATH
 
88
#endif
 
89
 
 
90
#ifndef NAME_MAX
 
91
#define NAME_MAX                MAX_PATH
 
92
#endif
 
93
 
 
94
#else
 
95
 
 
96
#define CS_DEFAULT_EOL          "\n"
 
97
#define CS_DIR_CHAR                     '/'
 
98
#define CS_DIR_DELIM            "/"
 
99
#define IS_DIR_CHAR(ch)         ((ch) == CS_DIR_CHAR)
 
100
 
 
101
#endif // OS_WINDOWS
 
102
 
 
103
#define CS_CALL_STACK_SIZE              100
 
104
#define CS_RELEASE_STACK_SIZE   200
 
105
#define CS_JUMP_STACK_SIZE              20
 
106
 
 
107
/* C string display width sizes including space for a null terminator and possible sign. */
 
108
#define CS_WIDTH_INT_8  5
 
109
#define CS_WIDTH_INT_16 7
 
110
#define CS_WIDTH_INT_32 12
 
111
#define CS_WIDTH_INT_64 22
 
112
 
 
113
typedef uint8_t                 CSDiskValue1[1];        
 
114
typedef uint8_t                 CSDiskValue2[2];        
 
115
typedef uint8_t                 CSDiskValue3[3];        
 
116
typedef uint8_t                 CSDiskValue4[4];        
 
117
typedef uint8_t                 CSDiskValue6[6];        
 
118
typedef uint8_t                 CSDiskValue8[8];        
 
119
 
 
120
/*
 
121
 * Byte order on the disk is little endian! This is the byte order of the i386.
 
122
 * Little endian byte order starts with the least significan byte.
 
123
 *
 
124
 * The reason for choosing this byte order for the disk is 2-fold:
 
125
 * Firstly the i386 is the cheapest and fasted platform today.
 
126
 * Secondly the i386, unlike RISK chips (with big endian) can address
 
127
 * memory that is not aligned!
 
128
 *
 
129
 * Since the disk image of PrimeBase XT is not aligned, the second point
 
130
 * is significant. A RISK chip needs to access it byte-wise, so we might as
 
131
 * well do the byte swapping at the same time.
 
132
 *
 
133
 * The macros below are of 4 general types:
 
134
 *
 
135
 * GET/SET - Get and set 1,2,4,8 byte values (short, int, long, etc).
 
136
 * Values are swapped only on big endian platforms. This makes these
 
137
 * functions very efficient on little-endian platforms.
 
138
 *
 
139
 * COPY - Transfer data without swapping regardless of platform. This
 
140
 * function is a bit more efficient on little-endian platforms
 
141
 * because alignment is not an issue.
 
142
 *
 
143
 * MOVE - Similar to get and set, but the deals with memory instead
 
144
 * of values. Since no swapping is done on little-endian platforms
 
145
 * this function is identical to COPY on little-endian platforms.
 
146
 *
 
147
 * SWAP - Transfer and swap data regardless of the platform type.
 
148
 * Aligment is not assumed.
 
149
 *
 
150
 * The DISK component of the macro names indicates that alignment of
 
151
 * the value cannot be assumed.
 
152
 *
 
153
 */
 
154
#if BYTE_ORDER == BIG_ENDIAN
 
155
/* The native order of the machine is big endian. Since the native disk
 
156
 * disk order of XT is little endian, all data to and from disk
 
157
 * must be swapped.
 
158
 */
 
159
#define CS_SET_DISK_1(d, s)             ((d)[0] = (uint8_t) (s))
 
160
 
 
161
#define CS_SET_DISK_2(d, s)             do { (d)[0] = (uint8_t)  (((uint16_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint16_t) (s)) >> 8 ) & 0xFF); } while (0)
 
162
 
 
163
#define CS_SET_DISK_3(d, s)             do { (d)[0] = (uint8_t)  (((uint32_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint32_t) (s)) >> 8 ) & 0xFF); \
 
164
                                                                         (d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); } while (0)
 
165
 
 
166
#define CS_SET_DISK_4(d, s)             do { (d)[0] = (uint8_t)  (((uint32_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint32_t) (s)) >> 8 ) & 0xFF); \
 
167
                                                                         (d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint32_t) (s)) >> 24) & 0xFF); } while (0)
 
168
 
 
169
#define CS_SET_DISK_6(d, s)             do { (d)[0] = (uint8_t)  (((uint64_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint64_t) (s)) >> 8 ) & 0xFF); \
 
170
                                                                         (d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
 
171
                                                                         (d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); } while (0)
 
172
 
 
173
#define CS_SET_DISK_8(d, s)             do { (d)[0] = (uint8_t)  (((uint64_t) (s))        & 0xFF); (d)[1] = (uint8_t) ((((uint64_t) (s)) >> 8 ) & 0xFF); \
 
174
                                                                         (d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
 
175
                                                                         (d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); \
 
176
                                                                         (d)[6] = (uint8_t) ((((uint64_t) (s)) >> 48) & 0xFF); (d)[7] = (uint8_t) ((((uint64_t) (s)) >> 56) & 0xFF); } while (0)
 
177
 
 
178
#define CS_GET_DISK_1(s)                ((s)[0])
 
179
 
 
180
#define CS_GET_DISK_2(s)                ((uint16_t) (((uint16_t) (s)[0]) | (((uint16_t) (s)[1]) << 8)))
 
181
 
 
182
#define CS_GET_DISK_3(s)                ((uint32_t) (((uint32_t) (s)[0]) | (((uint32_t) (s)[1]) << 8) | (((uint32_t) (s)[2]) << 16)))
 
183
 
 
184
#define CS_GET_DISK_4(s)                (((uint32_t) (s)[0])        | (((uint32_t) (s)[1]) << 8 ) | \
 
185
                                                                (((uint32_t) (s)[2]) << 16) | (((uint32_t) (s)[3]) << 24))
 
186
 
 
187
#define CS_GET_DISK_6(s)                (((uint64_t) (s)[0])        | (((uint64_t) (s)[1]) << 8 ) | \
 
188
                                                                (((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
 
189
                                                                (((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40))
 
190
 
 
191
#define CS_GET_DISK_8(s)                (((uint64_t) (s)[0])        | (((uint64_t) (s)[1]) << 8 ) | \
 
192
                                                                (((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
 
193
                                                                (((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40) | \
 
194
                                                                (((uint64_t) (s)[6]) << 48) | (((uint64_t) (s)[7]) << 56))
 
195
 
 
196
/* Move will copy memory, and swap the bytes on a big endian machine.
 
197
 * On a little endian machine it is the same as COPY.
 
198
 */
 
199
#define CS_MOVE_DISK_1(d, s)    ((d)[0] = (s)[0])
 
200
#define CS_MOVE_DISK_2(d, s)    do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
 
201
#define CS_MOVE_DISK_3(d, s)    do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
 
202
#define CS_MOVE_DISK_4(d, s)    do { (d)[0] = (s)[3]; (d)[1] = (s)[2]; (d)[2] = (s)[1]; (d)[3] = (s)[0]; } while (0)
 
203
#define CS_MOVE_DISK_8(d, s)    do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; \
 
204
                                                                         (d)[2] = (s)[5]; (d)[3] = (s)[4]; \
 
205
                                                                         (d)[4] = (s)[3]; (d)[5] = (s)[2]; \
 
206
                                                                         (d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
 
207
 
 
208
/*
 
209
 * Copy just copies the number of bytes assuming the data is not alligned.
 
210
 */
 
211
#define CS_COPY_DISK_1(d, s)    (d)[0] = s
 
212
#define CS_COPY_DISK_2(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; } while (0)
 
213
#define CS_COPY_DISK_3(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; (d)[2] = (s)[2]; } while (0)
 
214
#define CS_COPY_DISK_4(d, s)    do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; (d)[2] = (s)[2]; (d)[3] = (s)[3]; } while (0)
 
215
#define CS_COPY_DISK_6(d, s)    memcpy(&((d)[0]), &((s)[0]), 6)
 
216
#define CS_COPY_DISK_8(d, s)    memcpy(&((d)[0]), &((s)[0]), 8)
 
217
#define CS_COPY_DISK_10(d, s)   memcpy(&((d)[0]), &((s)[0]), 10)
 
218
 
 
219
#define CS_SET_NULL_DISK_1(d)   CS_SET_DISK_1(d, 0)
 
220
#define CS_SET_NULL_DISK_2(d)   do { (d)[0] = 0; (d)[1] = 0; } while (0)
 
221
#define CS_SET_NULL_DISK_4(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; } while (0)
 
222
#define CS_SET_NULL_DISK_6(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; (d)[4] = 0; (d)[5] = 0; } while (0)
 
223
#define CS_SET_NULL_DISK_8(d)   do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; (d)[4] = 0; (d)[5] = 0; (d)[6] = 0; (d)[7] = 0; } while (0)
 
224
 
 
225
#define CS_IS_NULL_DISK_1(d)    (!(CS_GET_DISK_1(d)))
 
226
#define CS_IS_NULL_DISK_4(d)    (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3])
 
227
#define CS_IS_NULL_DISK_8(d)    (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3] && !(d)[4] && !(d)[5] && !(d)[6] && !(7)[3])
 
228
 
 
229
#define CS_EQ_DISK_4(d, s)              ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3])
 
230
#define CS_EQ_DISK_8(d, s)              ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3] && \
 
231
                                                                (d)[4] == (s)[4] && (d)[5] == (s)[5] && (d)[6] == (s)[6] && (d)[7] == (s)[7])
 
232
 
 
233
#define CS_IS_FF_DISK_4(d)              ((d)[0] == 0xFF && (d)[1] == 0xFF && (d)[2] == 0xFF && (d)[3] == 0xFF)
 
234
#else
 
235
/*
 
236
 * The native order of the machine is little endian. This means the data to
 
237
 * and from disk need not be swapped. In addition to this, since
 
238
 * the i386 can access non-aligned memory we are not required to
 
239
 * handle the data byte-for-byte.
 
240
 */
 
241
#define CS_SET_DISK_1(d, s)             ((d)[0] = (uint8_t) (s))
 
242
#define CS_SET_DISK_2(d, s)             (*((uint16_t *) &((d)[0])) = (uint16_t) (s))
 
243
#define CS_SET_DISK_3(d, s)             do { (*((uint16_t *) &((d)[0])) = (uint16_t) (s));  *((uint8_t *) &((d)[2])) = (uint8_t) (((uint32_t) (s)) >> 16); } while (0)
 
244
#define CS_SET_DISK_4(d, s)             (*((uint32_t *) &((d)[0])) = (uint32_t) (s))
 
245
#define CS_SET_DISK_6(d, s)             do { *((uint32_t *) &((d)[0])) = (uint32_t) (s); *((uint16_t *) &((d)[4])) = (uint16_t) (((uint64_t) (s)) >> 32); } while (0)
 
246
#define CS_SET_DISK_8(d, s)             (*((uint64_t *) &((d)[0])) = (uint64_t) (s))
 
247
 
 
248
#define CS_GET_DISK_1(s)                ((s)[0])
 
249
#define CS_GET_DISK_2(s)                *((uint16_t *) &((s)[0]))
 
250
#define CS_GET_DISK_3(s)                ((uint32_t) *((uint16_t *) &((s)[0])) | (((uint32_t) *((uint8_t *) &((s)[2]))) << 16))
 
251
#define CS_GET_DISK_4(s)                *((uint32_t *) &((s)[0]))
 
252
#define CS_GET_DISK_6(s)                ((uint64_t) *((uint32_t *) &((s)[0])) | (((uint64_t) *((uint16_t *) &((s)[4]))) << 32))
 
253
#define CS_GET_DISK_8(s)                *((uint64_t *) &((s)[0]))
 
254
 
 
255
#define CS_MOVE_DISK_1(d, s)    ((d)[0] = (s)[0])
 
256
#define CS_MOVE_DISK_2(d, s)    CS_COPY_DISK_2(d, s)
 
257
#define CS_MOVE_DISK_3(d, s)    CS_COPY_DISK_3(d, s)
 
258
#define CS_MOVE_DISK_4(d, s)    CS_COPY_DISK_4(d, s)
 
259
#define CS_MOVE_DISK_8(d, s)    CS_COPY_DISK_8(d, s)
 
260
 
 
261
#define CS_COPY_DISK_1(d, s)    (d)[0] = s
 
262
#define CS_COPY_DISK_2(d, s)    (*((uint16_t *) &((d)[0])) = (*((uint16_t *) &((s)[0]))))
 
263
#define CS_COPY_DISK_3(d, s)    do { *((uint16_t *) &((d)[0])) = *((uint16_t *) &((s)[0])); (d)[2] = (s)[2]; } while (0)
 
264
#define CS_COPY_DISK_4(d, s)    (*((uint32_t *) &((d)[0])) = (*((uint32_t *) &((s)[0]))))
 
265
#define CS_COPY_DISK_6(d, s)    do { *((uint32_t *) &((d)[0])) = *((uint32_t *) &((s)[0])); *((uint16_t *) &((d)[4])) = *((uint16_t *) &((s)[4])); } while (0)
 
266
#define CS_COPY_DISK_8(d, s)    (*((uint64_t *) &(d[0])) = (*((uint64_t *) &((s)[0]))))
 
267
#define CS_COPY_DISK_10(d, s)   memcpy(&((d)[0]), &((s)[0]), 10)
 
268
 
 
269
#define CS_SET_NULL_DISK_1(d)   CS_SET_DISK_1(d, 0)
 
270
#define CS_SET_NULL_DISK_2(d)   CS_SET_DISK_2(d, 0)
 
271
#define CS_SET_NULL_DISK_3(d)   CS_SET_DISK_3(d, 0)
 
272
#define CS_SET_NULL_DISK_4(d)   CS_SET_DISK_4(d, 0L)
 
273
#define CS_SET_NULL_DISK_6(d)   CS_SET_DISK_6(d, 0LL)
 
274
#define CS_SET_NULL_DISK_8(d)   CS_SET_DISK_8(d, 0LL)
 
275
 
 
276
#define CS_IS_NULL_DISK_1(d)    (!(CS_GET_DISK_1(d)))
 
277
#define CS_IS_NULL_DISK_2(d)    (!(CS_GET_DISK_2(d)))
 
278
#define CS_IS_NULL_DISK_3(d)    (!(CS_GET_DISK_3(d)))
 
279
#define CS_IS_NULL_DISK_4(d)    (!(CS_GET_DISK_4(d)))
 
280
#define CS_IS_NULL_DISK_8(d)    (!(CS_GET_DISK_8(d)))
 
281
 
 
282
#define CS_EQ_DISK_4(d, s)              (CS_GET_DISK_4(d) == CS_GET_DISK_4(s))
 
283
#define CS_EQ_DISK_8(d, s)              (CS_GET_DISK_8(d) == CS_GET_DISK_8(s))
 
284
 
 
285
#define CS_IS_FF_DISK_4(d)              (CS_GET_DISK_4(d) == 0xFFFFFFFF)
 
286
#endif
 
287
 
 
288
#define CS_CMP_DISK_4(a, b)             ((int32_t) CS_GET_DISK_4(a) - (int32_t) CS_GET_DISK_4(b))
 
289
#define CS_CMP_DISK_8(d, s)             memcmp(&((d)[0]), &((s)[0]), 8)
 
290
//#define CS_CMP_DISK_8(d, s)           (CS_CMP_DISK_4((d).h_number_4, (s).h_number_4) == 0 ? CS_CMP_DISK_4((d).h_file_4, (s).h_file_4) : CS_CMP_DISK_4((d).h_number_4, (s).h_number_4))
 
291
 
 
292
#define CS_SWAP_DISK_2(d, s)    do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
 
293
#define CS_SWAP_DISK_3(d, s)    do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
 
294
#define CS_SWAP_DISK_4(d, s)    do { (d)[0] = (s)[3]; (d)[1] = (s)[2]; (d)[2] = (s)[1]; (d)[3] = (s)[0]; } while (0)
 
295
#define CS_SWAP_DISK_8(d, s)    do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; (d)[2] = (s)[5]; (d)[3] = (s)[4]; \
 
296
                                                                         (d)[4] = (s)[3]; (d)[5] = (s)[2]; (d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
 
297
 
 
298
typedef union {
 
299
        CSDiskValue1 val_1;
 
300
        CSDiskValue4 val_4;
 
301
} CSIntRec, *CSIntPtr;
 
302
 
 
303
typedef union {
 
304
                const char *rec_cchars;
 
305
                char *rec_chars;
 
306
                CSIntPtr int_val;
 
307
} CSDiskData;
 
308
 
 
309
#define CHECKSUM_VALUE_SIZE                     16
 
310
typedef struct {
 
311
        u_char val[CHECKSUM_VALUE_SIZE];
 
312
} Md5Digest;
 
313
 
 
314
        
 
315
#endif