1 |
dpavlin |
237 |
/* |
2 |
|
|
openisis - an open implementation of the CDS/ISIS database |
3 |
|
|
Version 0.8.x (patchlevel see file Version) |
4 |
|
|
Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org |
5 |
|
|
|
6 |
|
|
This library is free software; you can redistribute it and/or |
7 |
|
|
modify it under the terms of the GNU Lesser General Public |
8 |
|
|
License as published by the Free Software Foundation; either |
9 |
|
|
version 2.1 of the License, or (at your option) any later version. |
10 |
|
|
|
11 |
|
|
This library is distributed in the hope that it will be useful, |
12 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 |
|
|
Lesser General Public License for more details. |
15 |
|
|
|
16 |
|
|
You should have received a copy of the GNU Lesser General Public |
17 |
|
|
License along with this library; if not, write to the Free Software |
18 |
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 |
|
|
|
20 |
|
|
see README for more information |
21 |
|
|
EOH */ |
22 |
|
|
#ifndef LSTR_H |
23 |
|
|
|
24 |
|
|
/* |
25 |
|
|
$Id: lstr.h,v 1.15 2003/04/08 00:20:53 kripke Exp $ |
26 |
|
|
definition of ISIS internal structures for openisis lib implementation. |
27 |
|
|
|
28 |
|
|
This header defines the common internal data structures and their members |
29 |
|
|
and external structure and member definition types. |
30 |
|
|
A internal data structure is the common in-memory representation of |
31 |
|
|
ISIS data; it may be backed by different external (in-file) structures. |
32 |
|
|
|
33 |
|
|
An in-memory data structure |
34 |
|
|
is a contigous int* chunk of memory, consisting of the sizes (one int), |
35 |
|
|
an array of members (int) and some buffer (array of char). |
36 |
|
|
|
37 |
|
|
A data structures sizes consists of the lengths |
38 |
|
|
fix and rep of the fixed and repeated part, resp., |
39 |
|
|
and the number of occurences of the repeated part. |
40 |
|
|
It is used in both an abstract description of a data type |
41 |
|
|
and each instance of a data structure. |
42 |
|
|
If the number of occurences of the repeated part is not fixed, |
43 |
|
|
it is 0 in the abstract case. |
44 |
|
|
The lengths are suitable as offsets into the lmbr array. |
45 |
|
|
This structure is designed to fit within 32 bits. |
46 |
|
|
|
47 |
|
|
The sizing is the only common meta-data description of a logical |
48 |
|
|
data type. For readability of code, however, the member indexes |
49 |
|
|
are enum-erated. When actually used, the type has to match the code's |
50 |
|
|
assumptions anyway. |
51 |
|
|
The numbers fix and rep are fixed for a given data structure. |
52 |
|
|
|
53 |
|
|
Although the logical data type has more properties, |
54 |
|
|
especially the type of each member (numeric, C-string or raw mem), |
55 |
|
|
a representation of this data is needed only when converting |
56 |
|
|
external data and thus is stored (somewhat redundantly) |
57 |
|
|
with the external properties. |
58 |
|
|
|
59 |
|
|
There are only two types of members: |
60 |
|
|
numeric and memory (mostly some character data). |
61 |
|
|
both are represented by a int, which, for memory, |
62 |
|
|
denotes an offset (counted in BYTES, not ints) from the records start |
63 |
|
|
(NOT offset into the data buffer, as with the isis mst record). |
64 |
|
|
|
65 |
|
|
The member array consists of a fixed number <emp>fix</emp> of initial |
66 |
|
|
members and a number <emp>occ</emp> of occurences |
67 |
|
|
of member arrays of fixed length <emp>rep</emp>. |
68 |
|
|
While <emp>occ</emp> is usually fixed, |
69 |
|
|
it varies for masterfile records. |
70 |
|
|
|
71 |
|
|
Note that this layout somewhat resembles the isis record itself, |
72 |
|
|
which supports a single level of nesting and repetition. |
73 |
|
|
*/ |
74 |
|
|
|
75 |
|
|
/* id of a structure */ |
76 |
|
|
|
77 |
|
|
/* construction |
78 |
|
|
*/ |
79 |
|
|
#define LSTRID( set, no, vari ) \ |
80 |
|
|
(((int)(vari))<<16 | (set)<<8 | (no) ) |
81 |
|
|
|
82 |
|
|
/* access |
83 |
|
|
*/ |
84 |
|
|
#define LSTRNO( l ) (char)(l) /* no of record type in set */ |
85 |
|
|
#define LSTRSET( l ) (char)((l)>>8) /* record set number */ |
86 |
|
|
#define LSTRVAR( l ) (short)((l)>>16) /* variant */ |
87 |
|
|
|
88 |
|
|
|
89 |
|
|
/* size of a structure */ |
90 |
|
|
|
91 |
|
|
/* construction |
92 |
|
|
*/ |
93 |
|
|
#define LSTRSIZE( fix, rep, occ ) \ |
94 |
|
|
(((int)(occ))<<16 | (rep)<<8 | (fix)) |
95 |
|
|
|
96 |
|
|
/* access |
97 |
|
|
*/ |
98 |
|
|
#define LSTRFIX( l ) (char)(l) /* length of fixed part */ |
99 |
|
|
#define LSTRREP( l ) (char)((l)>>8) /* length of repeated part */ |
100 |
|
|
#define LSTROCC( l ) (short)((l)>>16) /* the members */ |
101 |
|
|
/* actual number of members */ |
102 |
|
|
#define LSTRMEMS( l ) (LSTRFIX(l) + LSTRREP(l)*LSTROCC(l)) |
103 |
|
|
/* in-memory size of members (w/o buffer). */ |
104 |
|
|
#define LSTRLEN( t ) ((int)sizeof(int)*(1 + LSTRMEMS(t))) |
105 |
|
|
|
106 |
|
|
|
107 |
|
|
/** |
108 |
|
|
Description of a external members layout is encoded as a short "len" |
109 |
|
|
and a short offset "off" into the data or repeated part, resp. |
110 |
|
|
offset and len are combined into one int. |
111 |
|
|
If offsets are 0, they are computed based on the assumption, |
112 |
|
|
that members are layouted packed in the declared ordering. |
113 |
|
|
|
114 |
|
|
For character data, len just gives the length of the member |
115 |
|
|
in bytes (up to 2**15), with the highest bit cleared. |
116 |
|
|
A length of 0 denotes character data of variable size. |
117 |
|
|
|
118 |
|
|
Numerical data is marked with the highest bit set. |
119 |
|
|
For numbers, the lowest two bits give the ld of the length in bytes |
120 |
|
|
(i.e. 0=1,1=2,2=4,3=8 bytes). |
121 |
|
|
The offset and length of the actually used bits within these bytes |
122 |
|
|
are each encoded in six bits, which is enough for 0..63. |
123 |
|
|
A length of 0 (as resulting from 6-bit overflow on '64') means no masking. |
124 |
|
|
The 15th bit, if set, denotes high endian data. |
125 |
|
|
|
126 |
|
|
Note that the only reason for stuffing all that into a short is, |
127 |
|
|
that it is sufficient. The amount of space saved is minimal and |
128 |
|
|
depending on the actual processor there may be a slight performance |
129 |
|
|
penalty for the bit operations. |
130 |
|
|
|
131 |
|
|
*/ |
132 |
|
|
#define LONG2LEN( l ) ((short)(l)) |
133 |
|
|
#define LONG2OFF( l ) ((short)((l) >> 16)) |
134 |
|
|
|
135 |
|
|
/* constants |
136 |
|
|
*/ |
137 |
|
|
#define LMBR_FNUM 0x8000 /* flag numeric data */ |
138 |
|
|
#define LMBR_FHIE 0x4000 /* flag high endian data */ |
139 |
|
|
|
140 |
|
|
/* construction |
141 |
|
|
*/ |
142 |
|
|
#define LMBRNUM( ld ) (LMBR_FNUM | ld) |
143 |
|
|
/* standard nueric types: the world according to Java :) */ |
144 |
|
|
#define LMBRBYTE LMBRNUM(0) |
145 |
|
|
#define LMBRSHORT LMBRNUM(1) |
146 |
|
|
#define LMBRINT LMBRNUM(2) |
147 |
|
|
#define LMBRLONG LMBRNUM(3) |
148 |
|
|
/* bit mask construction for numerical data */ |
149 |
|
|
#define LMBRBITS( off, len, ld ) (LMBR_FNUM | (off)<<8 | (len)<<2 | (ld)) |
150 |
|
|
#define LMBRBITS4( off, len ) (LMBR_FNUM | (off)<<8 | (len)<<2 | 2) |
151 |
|
|
/* if you have to specify the offset explicitly */ |
152 |
|
|
#define LSTRLOFF( len, off ) ((len) | (off)<<16) |
153 |
|
|
|
154 |
|
|
/* access |
155 |
|
|
*/ |
156 |
|
|
#define LMBRISNUM( f ) (LMBR_FNUM & (f)) |
157 |
|
|
#define LMBRLD( f ) (0x3 & (f)) |
158 |
|
|
/* bit access for numerical data */ |
159 |
|
|
#define LMBRISBITS( f ) (0x3ffc & (f)) |
160 |
|
|
#define LMBRBITLEN( f ) (0x003f & ((f) >> 2)) |
161 |
|
|
#define LMBRBITOFF( f ) (0x003f & ((f) >> 8)) |
162 |
|
|
|
163 |
|
|
/** |
164 |
|
|
Description of an external structure layout. |
165 |
|
|
This is usually fixed for a given (implementation of a) type; |
166 |
|
|
for the isis mst record, however, the occurences of the repeated |
167 |
|
|
part and the total external and internal lengths vary for each record. |
168 |
|
|
*/ |
169 |
|
|
|
170 |
|
|
enum { |
171 |
|
|
LSTR_SIZE, /* sizes */ |
172 |
|
|
LSTR_XRLO, /* repeated part byte length and offset <<16; auto */ |
173 |
|
|
LSTR_XLEN, /* ext. total length of data; auto */ |
174 |
|
|
LSTR_ILEN, /* int. total length of data; auto */ |
175 |
|
|
LSTR_XMBR /* members */ |
176 |
|
|
}; |
177 |
|
|
#define LSTR_AUTOLENGTHS 0,0,0 |
178 |
|
|
#define LSTR_LONGS( totmbrs ) (4+(totmbrs)) |
179 |
|
|
|
180 |
|
|
/* technical variants of a record */ |
181 |
|
|
typedef enum { |
182 |
|
|
LVAR_PAC, /* packed little endian base variant */ |
183 |
|
|
LVAR_ALI, /* aligned variant */ |
184 |
|
|
LVAR_BIG, /* big endian aligned */ |
185 |
|
|
LVAR_VARI |
186 |
|
|
} lstr_variant; |
187 |
|
|
|
188 |
|
|
/* known record sets */ |
189 |
|
|
enum { |
190 |
|
|
LSET_MST, /* isis 1 master file */ |
191 |
|
|
LSET_INV, /* isis 1 inverted file */ |
192 |
|
|
LSET_SETS |
193 |
|
|
}; |
194 |
|
|
|
195 |
|
|
|
196 |
|
|
typedef struct { |
197 |
|
|
const char ***name; /* an array of names per record type */ |
198 |
|
|
int **desc[LVAR_VARI]; /* an array of descs per variant */ |
199 |
|
|
} LstrSet; |
200 |
|
|
|
201 |
|
|
|
202 |
|
|
/* data types of ISIS 1 master file */ |
203 |
|
|
typedef enum { |
204 |
|
|
LSTR_MFC, /* MST head */ |
205 |
|
|
LSTR_MFR, /* MST record */ |
206 |
|
|
LSTR_XRF, /* XRF record */ |
207 |
|
|
LSTR_MST /* count */ |
208 |
|
|
} lstr_mst; |
209 |
|
|
|
210 |
|
|
|
211 |
|
|
enum { /* MFC members */ |
212 |
|
|
LMFC_CTLM = 1, |
213 |
|
|
LMFC_NMFN, /* next available MFN */ |
214 |
|
|
LMFC_NMFB, /* next free block in MF counting from 1 */ |
215 |
|
|
LMFC_NMFP, /* next free pos in MF */ |
216 |
|
|
LMFC_TYPE, /* "0 for user's bases; 1 for messages" */ |
217 |
|
|
LMFC_RCNT, /* record count ? not used by CISIS */ |
218 |
|
|
LMFC_MFX1, |
219 |
|
|
LMFC_MFX2, /* LAN lock */ |
220 |
|
|
LMFC_MFX3, /* LAN lock */ |
221 |
|
|
LMFC__FL |
222 |
|
|
}; |
223 |
|
|
|
224 |
|
|
enum { /* XRF members */ |
225 |
|
|
LXRF_XPOS = 1, |
226 |
|
|
LXRF_XREC |
227 |
|
|
}; |
228 |
|
|
|
229 |
|
|
/* data types of ISIS 1 inverted file */ |
230 |
|
|
typedef enum { |
231 |
|
|
LSTR_CNT, /* CNT record */ |
232 |
|
|
LSTR_N01, /* N01 record */ |
233 |
|
|
LSTR_L01, /* L01 record */ |
234 |
|
|
LSTR_N02, /* N02 record */ |
235 |
|
|
LSTR_L02, /* L02 record */ |
236 |
|
|
LSTR_IFP, /* IFP record */ |
237 |
|
|
LSTR_INV /* count */ |
238 |
|
|
} lstr_inv; |
239 |
|
|
|
240 |
|
|
|
241 |
|
|
enum { /* CNT members */ |
242 |
|
|
LCNT_TYPE = 1, /* 1 or 2: N0x */ |
243 |
|
|
LCNT_ORDN, /* fix 5 */ |
244 |
|
|
LCNT_ORDF, /* fix 5 */ |
245 |
|
|
LCNT_N, /* fix 15 */ |
246 |
|
|
LCNT_K, /* fix 5 */ |
247 |
|
|
LCNT_LEV, /* depth of index */ |
248 |
|
|
LCNT_POSR, /* position of root */ |
249 |
|
|
LCNT_NMAX, |
250 |
|
|
LCNT_FMAX, |
251 |
|
|
LCNT_ABNO, |
252 |
|
|
LCNT__FL |
253 |
|
|
}; |
254 |
|
|
|
255 |
|
|
enum { /* N0x members */ |
256 |
|
|
LN0X_POS = 1, /* record number */ |
257 |
|
|
LN0X_OCK, /* number of keys */ |
258 |
|
|
LN0X_TYPE, /* type 1 or 2 */ |
259 |
|
|
LN0X__FL, /* offset of repeated part */ |
260 |
|
|
LN0X_KEY = 0, /* key chars */ |
261 |
|
|
LN0X_REF, /* ref to next node (>0) or leaf (<0) */ |
262 |
|
|
LN0X__RL /* length of repeated part */ |
263 |
|
|
}; |
264 |
|
|
|
265 |
|
|
enum { /* L0x members */ |
266 |
|
|
LL0X_POS = 1, /* record number */ |
267 |
|
|
LL0X_OCK, /* number of keys */ |
268 |
|
|
LL0X_TYPE, /* type 1 or 2 */ |
269 |
|
|
LL0X_PS, /* type 1 or 2 */ |
270 |
|
|
LL0X__FL, /* offset of repeated part */ |
271 |
|
|
LL0X_KEY = 0, /* key chars */ |
272 |
|
|
LL0X_INFB, /* ifp block */ |
273 |
|
|
LL0X_INFP, /* ifp pos */ |
274 |
|
|
LL0X__RL /* length of repeated part */ |
275 |
|
|
}; |
276 |
|
|
|
277 |
|
|
enum { /* IFP members */ |
278 |
|
|
LIFP_NXTB = 1, /* block of next segment */ |
279 |
|
|
LIFP_NXTP, /* pos of next segment */ |
280 |
|
|
LIFP_TOTP, /* total postings */ |
281 |
|
|
LIFP_SEGP, /* postings in this segment */ |
282 |
|
|
LIFP_SEGC, /* postings in this segment */ |
283 |
|
|
LIFP__FL, /* offset of repeated part */ |
284 |
|
|
LIFP_MFN = 0, /* mfn */ |
285 |
|
|
LIFP_ADD, /* additional qualifyers */ |
286 |
|
|
LIFP__RL /* length of repeated part */ |
287 |
|
|
}; |
288 |
|
|
|
289 |
|
|
|
290 |
|
|
extern const LstrSet lstrlib[LSET_SETS]; |
291 |
|
|
|
292 |
|
|
/** auto-initialise the given structure or all builtins, iff NULL. |
293 |
|
|
*/ |
294 |
|
|
extern int lstr_auto ( int *str ); |
295 |
|
|
|
296 |
|
|
#define LSTR_H |
297 |
|
|
#endif /* LSTR_H */ |