1
/* Copyright (C) 2008 PrimeBase Technologies GmbH, Germany
3
* PrimeBase Media Stream for MySQL
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.
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.
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
19
* Original author: Paul McCullagh (H&G2JCtL)
20
* Continued development: Barry Leslie
25
* Common definitions that may be required be included at the
26
* top of every header file.
34
#include <sys/types.h>
36
// Use standard portable data types
39
/* Those compilers that support the function
40
* macro (in particular the "pretty" function
41
* macro must be defined here.
44
#define __FUNC__ __FUNCTION__
45
#elif defined(OS_SOLARIS)
46
#define __FUNC__ "__func__"
48
#define __FUNC__ __PRETTY_FUNCTION__
52
* An unsigned integer, 1 byte long:
55
#define u_char unsigned char
59
* An usigned integer, 1 byte long:
61
#define s_char unsigned char
63
/* We assumes that off_t is 8 bytes so to ensure this always use off64_t*/
64
#define off64_t uint64_t
68
* A signed integer at least 32 bits long.
69
* The size used is whatever is most
70
* convenient to the machine.
72
#define s_int int_fast32_t
74
/* Forward declartion of a thread: */
77
// Used to avoid warnings about unused parameters.
78
#define UNUSED(x) (void)x
82
#define CS_DEFAULT_EOL "\r\n"
83
#define CS_DIR_CHAR '\\'
84
#define CS_DIR_DELIM "\\"
85
#define IS_DIR_CHAR(ch) ((ch) == CS_DIR_CHAR || (ch) == '/')
88
#define PATH_MAX MAX_PATH
92
#define NAME_MAX MAX_PATH
97
#define CS_DEFAULT_EOL "\n"
98
#define CS_DIR_CHAR '/'
99
#define CS_DIR_DELIM "/"
100
#define IS_DIR_CHAR(ch) ((ch) == CS_DIR_CHAR)
104
#define CS_CALL_STACK_SIZE 100
105
#define CS_RELEASE_STACK_SIZE 200
106
#define CS_JUMP_STACK_SIZE 20 // NOTE: If a stack overflow occurs check that there are no returns inside of try_() blocks.
108
/* C string display width sizes including space for a null terminator and possible sign. */
109
#define CS_WIDTH_INT_8 5
110
#define CS_WIDTH_INT_16 7
111
#define CS_WIDTH_INT_32 12
112
#define CS_WIDTH_INT_64 22
114
typedef uint8_t CSDiskValue1[1];
115
typedef uint8_t CSDiskValue2[2];
116
typedef uint8_t CSDiskValue3[3];
117
typedef uint8_t CSDiskValue4[4];
118
typedef uint8_t CSDiskValue6[6];
119
typedef uint8_t CSDiskValue8[8];
122
* Byte order on the disk is little endian! This is the byte order of the i386.
123
* Little endian byte order starts with the least significan byte.
125
* The reason for choosing this byte order for the disk is 2-fold:
126
* Firstly the i386 is the cheapest and fasted platform today.
127
* Secondly the i386, unlike RISK chips (with big endian) can address
128
* memory that is not aligned!
130
* Since the disk image of PrimeBase XT is not aligned, the second point
131
* is significant. A RISK chip needs to access it byte-wise, so we might as
132
* well do the byte swapping at the same time.
134
* The macros below are of 4 general types:
136
* GET/SET - Get and set 1,2,4,8 byte values (short, int, long, etc).
137
* Values are swapped only on big endian platforms. This makes these
138
* functions very efficient on little-endian platforms.
140
* COPY - Transfer data without swapping regardless of platform. This
141
* function is a bit more efficient on little-endian platforms
142
* because alignment is not an issue.
144
* MOVE - Similar to get and set, but the deals with memory instead
145
* of values. Since no swapping is done on little-endian platforms
146
* this function is identical to COPY on little-endian platforms.
148
* SWAP - Transfer and swap data regardless of the platform type.
149
* Aligment is not assumed.
151
* The DISK component of the macro names indicates that alignment of
152
* the value cannot be assumed.
155
#if BYTE_ORDER == BIG_ENDIAN
156
/* The native order of the machine is big endian. Since the native disk
157
* disk order of XT is little endian, all data to and from disk
160
#define CS_SET_DISK_1(d, s) ((d)[0] = (uint8_t) (s))
162
#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)
164
#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); \
165
(d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); } while (0)
167
#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); \
168
(d)[2] = (uint8_t) ((((uint32_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint32_t) (s)) >> 24) & 0xFF); } while (0)
170
#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); \
171
(d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
172
(d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); } while (0)
174
#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); \
175
(d)[2] = (uint8_t) ((((uint64_t) (s)) >> 16) & 0xFF); (d)[3] = (uint8_t) ((((uint64_t) (s)) >> 24) & 0xFF); \
176
(d)[4] = (uint8_t) ((((uint64_t) (s)) >> 32) & 0xFF); (d)[5] = (uint8_t) ((((uint64_t) (s)) >> 40) & 0xFF); \
177
(d)[6] = (uint8_t) ((((uint64_t) (s)) >> 48) & 0xFF); (d)[7] = (uint8_t) ((((uint64_t) (s)) >> 56) & 0xFF); } while (0)
179
#define CS_GET_DISK_1(s) ((s)[0])
181
#define CS_GET_DISK_2(s) ((uint16_t) (((uint16_t) (s)[0]) | (((uint16_t) (s)[1]) << 8)))
183
#define CS_GET_DISK_3(s) ((uint32_t) (((uint32_t) (s)[0]) | (((uint32_t) (s)[1]) << 8) | (((uint32_t) (s)[2]) << 16)))
185
#define CS_GET_DISK_4(s) (((uint32_t) (s)[0]) | (((uint32_t) (s)[1]) << 8 ) | \
186
(((uint32_t) (s)[2]) << 16) | (((uint32_t) (s)[3]) << 24))
188
#define CS_GET_DISK_6(s) (((uint64_t) (s)[0]) | (((uint64_t) (s)[1]) << 8 ) | \
189
(((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
190
(((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40))
192
#define CS_GET_DISK_8(s) (((uint64_t) (s)[0]) | (((uint64_t) (s)[1]) << 8 ) | \
193
(((uint64_t) (s)[2]) << 16) | (((uint64_t) (s)[3]) << 24) | \
194
(((uint64_t) (s)[4]) << 32) | (((uint64_t) (s)[5]) << 40) | \
195
(((uint64_t) (s)[6]) << 48) | (((uint64_t) (s)[7]) << 56))
197
/* Move will copy memory, and swap the bytes on a big endian machine.
198
* On a little endian machine it is the same as COPY.
200
#define CS_MOVE_DISK_1(d, s) ((d)[0] = (s)[0])
201
#define CS_MOVE_DISK_2(d, s) do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
202
#define CS_MOVE_DISK_3(d, s) do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
203
#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)
204
#define CS_MOVE_DISK_8(d, s) do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; \
205
(d)[2] = (s)[5]; (d)[3] = (s)[4]; \
206
(d)[4] = (s)[3]; (d)[5] = (s)[2]; \
207
(d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
210
* Copy just copies the number of bytes assuming the data is not alligned.
212
#define CS_COPY_DISK_1(d, s) (d)[0] = s
213
#define CS_COPY_DISK_2(d, s) do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; } while (0)
214
#define CS_COPY_DISK_3(d, s) do { (d)[0] = (s)[0]; (d)[1] = (s)[1]; (d)[2] = (s)[2]; } while (0)
215
#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)
216
#define CS_COPY_DISK_6(d, s) memcpy(&((d)[0]), &((s)[0]), 6)
217
#define CS_COPY_DISK_8(d, s) memcpy(&((d)[0]), &((s)[0]), 8)
218
#define CS_COPY_DISK_10(d, s) memcpy(&((d)[0]), &((s)[0]), 10)
220
#define CS_SET_NULL_DISK_1(d) CS_SET_DISK_1(d, 0)
221
#define CS_SET_NULL_DISK_2(d) do { (d)[0] = 0; (d)[1] = 0; } while (0)
222
#define CS_SET_NULL_DISK_4(d) do { (d)[0] = 0; (d)[1] = 0; (d)[2] = 0; (d)[3] = 0; } while (0)
223
#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)
224
#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)
226
#define CS_IS_NULL_DISK_1(d) (!(CS_GET_DISK_1(d)))
227
#define CS_IS_NULL_DISK_4(d) (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3])
228
#define CS_IS_NULL_DISK_8(d) (!(d)[0] && !(d)[1] && !(d)[2] && !(d)[3] && !(d)[4] && !(d)[5] && !(d)[6] && !(7)[3])
230
#define CS_EQ_DISK_4(d, s) ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3])
231
#define CS_EQ_DISK_8(d, s) ((d)[0] == (s)[0] && (d)[1] == (s)[1] && (d)[2] == (s)[2] && (d)[3] == (s)[3] && \
232
(d)[4] == (s)[4] && (d)[5] == (s)[5] && (d)[6] == (s)[6] && (d)[7] == (s)[7])
234
#define CS_IS_FF_DISK_4(d) ((d)[0] == 0xFF && (d)[1] == 0xFF && (d)[2] == 0xFF && (d)[3] == 0xFF)
237
* The native order of the machine is little endian. This means the data to
238
* and from disk need not be swapped. In addition to this, since
239
* the i386 can access non-aligned memory we are not required to
240
* handle the data byte-for-byte.
242
#define CS_SET_DISK_1(d, s) ((d)[0] = (uint8_t) (s))
243
#define CS_SET_DISK_2(d, s) (*((uint16_t *) &((d)[0])) = (uint16_t) (s))
244
#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)
245
#define CS_SET_DISK_4(d, s) (*((uint32_t *) &((d)[0])) = (uint32_t) (s))
246
#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)
247
#define CS_SET_DISK_8(d, s) (*((uint64_t *) &((d)[0])) = (uint64_t) (s))
249
#define CS_GET_DISK_1(s) ((s)[0])
250
#define CS_GET_DISK_2(s) *((uint16_t *) &((s)[0]))
251
#define CS_GET_DISK_3(s) ((uint32_t) *((uint16_t *) &((s)[0])) | (((uint32_t) *((uint8_t *) &((s)[2]))) << 16))
252
#define CS_GET_DISK_4(s) *((uint32_t *) &((s)[0]))
253
#define CS_GET_DISK_6(s) ((uint64_t) *((uint32_t *) &((s)[0])) | (((uint64_t) *((uint16_t *) &((s)[4]))) << 32))
254
#define CS_GET_DISK_8(s) *((uint64_t *) &((s)[0]))
256
#define CS_MOVE_DISK_1(d, s) ((d)[0] = (s)[0])
257
#define CS_MOVE_DISK_2(d, s) CS_COPY_DISK_2(d, s)
258
#define CS_MOVE_DISK_3(d, s) CS_COPY_DISK_3(d, s)
259
#define CS_MOVE_DISK_4(d, s) CS_COPY_DISK_4(d, s)
260
#define CS_MOVE_DISK_8(d, s) CS_COPY_DISK_8(d, s)
262
#define CS_COPY_DISK_1(d, s) (d)[0] = s
263
#define CS_COPY_DISK_2(d, s) (*((uint16_t *) &((d)[0])) = (*((uint16_t *) &((s)[0]))))
264
#define CS_COPY_DISK_3(d, s) do { *((uint16_t *) &((d)[0])) = *((uint16_t *) &((s)[0])); (d)[2] = (s)[2]; } while (0)
265
#define CS_COPY_DISK_4(d, s) (*((uint32_t *) &((d)[0])) = (*((uint32_t *) &((s)[0]))))
266
#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)
267
#define CS_COPY_DISK_8(d, s) (*((uint64_t *) &(d[0])) = (*((uint64_t *) &((s)[0]))))
268
#define CS_COPY_DISK_10(d, s) memcpy(&((d)[0]), &((s)[0]), 10)
270
#define CS_SET_NULL_DISK_1(d) CS_SET_DISK_1(d, 0)
271
#define CS_SET_NULL_DISK_2(d) CS_SET_DISK_2(d, 0)
272
#define CS_SET_NULL_DISK_3(d) CS_SET_DISK_3(d, 0)
273
#define CS_SET_NULL_DISK_4(d) CS_SET_DISK_4(d, 0L)
274
#define CS_SET_NULL_DISK_6(d) CS_SET_DISK_6(d, 0LL)
275
#define CS_SET_NULL_DISK_8(d) CS_SET_DISK_8(d, 0LL)
277
#define CS_IS_NULL_DISK_1(d) (!(CS_GET_DISK_1(d)))
278
#define CS_IS_NULL_DISK_2(d) (!(CS_GET_DISK_2(d)))
279
#define CS_IS_NULL_DISK_3(d) (!(CS_GET_DISK_3(d)))
280
#define CS_IS_NULL_DISK_4(d) (!(CS_GET_DISK_4(d)))
281
#define CS_IS_NULL_DISK_8(d) (!(CS_GET_DISK_8(d)))
283
#define CS_EQ_DISK_4(d, s) (CS_GET_DISK_4(d) == CS_GET_DISK_4(s))
284
#define CS_EQ_DISK_8(d, s) (CS_GET_DISK_8(d) == CS_GET_DISK_8(s))
286
#define CS_IS_FF_DISK_4(d) (CS_GET_DISK_4(d) == 0xFFFFFFFF)
289
#define CS_CMP_DISK_4(a, b) ((int32_t) CS_GET_DISK_4(a) - (int32_t) CS_GET_DISK_4(b))
290
#define CS_CMP_DISK_8(d, s) memcmp(&((d)[0]), &((s)[0]), 8)
291
//#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))
293
#define CS_SWAP_DISK_2(d, s) do { (d)[0] = (s)[1]; (d)[1] = (s)[0]; } while (0)
294
#define CS_SWAP_DISK_3(d, s) do { (d)[0] = (s)[2]; (d)[1] = (s)[1]; (d)[2] = (s)[0]; } while (0)
295
#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)
296
#define CS_SWAP_DISK_8(d, s) do { (d)[0] = (s)[7]; (d)[1] = (s)[6]; (d)[2] = (s)[5]; (d)[3] = (s)[4]; \
297
(d)[4] = (s)[3]; (d)[5] = (s)[2]; (d)[6] = (s)[1]; (d)[7] = (s)[0]; } while (0)
302
} CSIntRec, *CSIntPtr;
305
const char *rec_cchars;
310
#define CHECKSUM_VALUE_SIZE 16
312
u_char val[CHECKSUM_VALUE_SIZE];
added
removed
plugin/pbms/src/cslib/CSDefs.h
