/[webpac]/trunk2/openisis/lstr.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /trunk2/openisis/lstr.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 237 - (hide annotations)
Mon Mar 8 17:43:12 2004 UTC (19 years, 11 months ago) by dpavlin
Original Path: openisis/current/lstr.c
File MIME type: text/plain
File size: 9579 byte(s)
initial import of openisis 0.9.0 vendor drop

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    
23     /*
24     $Id: lstr.c,v 1.13 2003/04/08 00:20:53 kripke Exp $
25     implementation of record cooking.
26     */
27     #include <stdlib.h>
28    
29     #include "lstr.h"
30     #include "luti.h"
31    
32    
33     /* ************************************************************
34     private types
35     */
36     /* ************************************************************
37     private data
38     */
39     static const char * nameMfc[] = {
40     "Mfc", "CTLM", "NMFN", "NMFB", "NMFP", "TYPE", "RCNT", "MFX1", "MFX2", "MFX3"
41     };
42    
43     static int descMfc[] = {
44     LSTRSIZE( 9, 0, 0 ), /* sizes (fix, rep, occ) */
45     LSTR_AUTOLENGTHS,
46     LMBRINT,
47     LMBRINT,
48     LMBRINT,
49     LMBRSHORT,
50     LMBRSHORT,
51     LMBRINT,
52     LMBRINT,
53     LMBRINT,
54     LMBRINT
55     }; /* descMfc */
56    
57    
58     static const char * nameMfr[] = {
59     "Mfr", "MFN", "RECL", "BWB", "BWP", "BASE", "NVF", "STAT",
60     "TAG", "'POS", "LEN"
61     };
62     static int descMfr[] = {
63     LSTRSIZE( 7, 3, 0 ), /* sizes (fix, rep, occ) */
64     LSTR_AUTOLENGTHS,
65     LMBRINT,
66     LMBRSHORT,
67     LMBRINT,
68     LMBRSHORT,
69    
70     LMBRSHORT,
71     LMBRSHORT,
72     LMBRSHORT,
73    
74     LMBRSHORT,
75     LMBRSHORT,
76     LMBRSHORT
77     }; /* descMfr */
78    
79     /* aligned version */
80     static int descMfrA[] = {
81     LSTRSIZE( 7, 3, 0 ), /* sizes (fix, rep, occ) */
82     LSTR_AUTOLENGTHS,
83     LMBRINT,
84     LMBRSHORT,
85     LSTRLOFF( LMBRINT, 8 ),
86     LMBRSHORT,
87    
88     LMBRSHORT,
89     LMBRSHORT,
90     LMBRSHORT,
91    
92     LMBRSHORT,
93     LMBRSHORT,
94     LMBRSHORT
95     }; /* descMfr */
96    
97     static const char * nameXrf[] = {
98     "Xrf", "XPOS", "XREC"
99     };
100     static int descXrf[] = {
101     LSTRSIZE( 1, 1, 127 ), /* sizes (fix, rep, occ) */
102     LSTR_AUTOLENGTHS,
103     LMBRINT,
104     LMBRINT
105     }; /* descXrf */
106    
107     static const char ** nameMst[LSTR_MST] = {
108     nameMfc, nameMfr, nameXrf
109     };
110    
111     static int* descMst[LSTR_MST] = {
112     descMfc, /* MST head */
113     descMfr, /* MST record */
114     descXrf /* XRF record */
115     };
116    
117     static int* descMstA[LSTR_MST] = {
118     descMfc, /* MST head */
119     descMfrA, /* MST record */
120     descXrf /* XRF record */
121     };
122    
123    
124     static const char * nameCnt[] = {
125     "Cnt", "TYPE", "ORDN", "ORDF", "N", "K", "LEV", "POSR", "NMAX", "FMAX", "ABNO"
126     };
127     static int descCnt[] = {
128     LSTRSIZE( 10, 0, 0 ), /* sizes (fix, rep, occ) */
129     LSTR_AUTOLENGTHS,
130     LMBRSHORT, /* TYPE */
131     LMBRSHORT, /* ORDN */
132     LMBRSHORT, /* ORDF */
133     LMBRSHORT, /* N */
134     LMBRSHORT, /* K */
135     LMBRSHORT, /* LEV */
136     LMBRINT, /* POSR */
137     LMBRINT, /* NMAX */
138     LMBRINT, /* FMAX */
139     LMBRSHORT /* ABNO */
140     }; /* descCnt */
141    
142     static int descCntA[] = {
143     LSTRSIZE( 10, 0, 0 ), /* sizes (fix, rep, occ) */
144     0,28,44,
145     LMBRSHORT, /* TYPE */
146     LMBRSHORT, /* ORDN */
147     LMBRSHORT, /* ORDF */
148     LMBRSHORT, /* N */
149     LMBRSHORT, /* K */
150     LMBRSHORT, /* LEV */
151     LMBRINT, /* POSR */
152     LMBRINT, /* NMAX */
153     LMBRINT, /* FMAX */
154     LMBRSHORT /* ABNO */
155     }; /* descCntA */
156    
157     static const char * nameN0[] = {
158     "N0", "POS", "OCK", "TYPE", "'KEY", "REF"
159     };
160     static int descN01[] = {
161     LSTRSIZE( 3, 2, 10 ), /* sizes (fix, rep, occ) */
162     LSTR_AUTOLENGTHS,
163     LMBRINT, /* POS */
164     LMBRSHORT, /* OCK */
165     LMBRSHORT, /* TYPE */
166     10, /* KEY */
167     LMBRINT /* REF */
168     };
169    
170     static int descN01A[] = {
171     LSTRSIZE( 3, 2, 10 ), /* sizes (fix, rep, occ) */
172     LSTR_AUTOLENGTHS,
173     LMBRINT, /* POS */
174     LMBRSHORT, /* OCK */
175     LMBRSHORT, /* TYPE */
176     10, /* KEY */
177     LSTRLOFF( LMBRINT, 12 ) /* REF */
178     };
179    
180     static int descN02[] = {
181     LSTRSIZE( 3, 2, 10 ), /* sizes (fix, rep, occ) */
182     LSTR_AUTOLENGTHS,
183     LMBRINT, /* POS */
184     LMBRSHORT, /* OCK */
185     LMBRSHORT, /* TYPE */
186     30, /* KEY */
187     LMBRINT /* REF */
188     };
189     static int descN02A[] = {
190     LSTRSIZE( 3, 2, 10 ), /* sizes (fix, rep, occ) */
191     LSTR_AUTOLENGTHS,
192     LMBRINT, /* POS */
193     LMBRSHORT, /* OCK */
194     LMBRSHORT, /* TYPE */
195     30, /* KEY */
196     LSTRLOFF( LMBRINT, 32 ) /* REF */
197     };
198    
199     static const char * nameL0[] = {
200     "L0", "POS", "OCK", "TYPE", "PS", "'KEY", "INFB", "INFP"
201     };
202     static int descL01[] = {
203     LSTRSIZE( 4, 3, 10 ), /* sizes (fix, rep, occ) */
204     LSTR_AUTOLENGTHS,
205     LMBRINT, /* POS */
206     LMBRSHORT, /* OCK */
207     LMBRSHORT, /* TYPE */
208     LMBRINT, /* PS */
209     10, /* KEY */
210     LMBRINT, /* INFB */
211     LMBRINT /* INFP */
212     };
213     static int descL01A[] = {
214     LSTRSIZE( 4, 3, 10 ), /* sizes (fix, rep, occ) */
215     LSTR_AUTOLENGTHS,
216     LMBRINT, /* POS */
217     LMBRSHORT, /* OCK */
218     LMBRSHORT, /* TYPE */
219     LMBRINT, /* PS */
220     10, /* KEY */
221     LSTRLOFF( LMBRINT, 12 ), /* INFB */
222     LMBRINT /* INFP */
223     };
224    
225    
226     static int descL02[] = {
227     LSTRSIZE( 4, 3, 10 ), /* sizes (fix, rep, occ) */
228     LSTR_AUTOLENGTHS,
229     LMBRINT, /* POS */
230     LMBRSHORT, /* OCK */
231     LMBRSHORT, /* TYPE */
232     LMBRINT, /* PS */
233     30, /* KEY */
234     LMBRINT, /* INFB */
235     LMBRINT /* INFP */
236     };
237     static int descL02A[] = {
238     LSTRSIZE( 4, 3, 10 ), /* sizes (fix, rep, occ) */
239     LSTR_AUTOLENGTHS,
240     LMBRINT, /* POS */
241     LMBRSHORT, /* OCK */
242     LMBRSHORT, /* TYPE */
243     LMBRINT, /* PS */
244     30, /* KEY */
245     LSTRLOFF( LMBRINT, 32 ), /* INFB */
246     LMBRINT /* INFP */
247     };
248    
249     static const char * nameIfp[] = {
250     "IfH", "NXTB", "NXTP", "TOTP", "SEGP", "SEGC", "MFN", "INFO"
251     };
252     static int descIfp[] = {
253     #ifdef CONVERT_POSTINGS
254     /*
255     to properly convert postings,
256     the repeated part needs to be a big-endian 64bit int
257    
258     however, converting can't be done in a straightforward fashion anyway,
259     since posting segments have holes of one or two longs at block boundaries
260     */
261     LSTRSIZE( 5, 2, 1 ), /* sizes (fix, rep, occ) */
262     LSTR_AUTOLENGTHS,
263     LMBRINT, /* */
264     LMBRINT, /* */
265     #else
266     LSTRSIZE( 5, 0, 0 ), /* sizes (fix, rep, occ) */
267     LSTR_AUTOLENGTHS,
268     #endif
269     LMBRINT, /* */
270     LMBRINT, /* */
271     LMBRINT, /* */
272     LMBRINT, /* */
273     LMBRINT /* */
274     };
275    
276     static const char ** nameInv[LSTR_INV] = {
277     nameCnt,
278     nameN0,
279     nameL0,
280     nameN0,
281     nameL0,
282     nameIfp
283     };
284    
285     static int* descInv[LSTR_INV] = {
286     descCnt, /* CNT record */
287     descN01, /* N01 record */
288     descL01, /* L01 record */
289     descN02, /* N02 record */
290     descL02, /* L02 record */
291     descIfp /* Ifp record */
292     };
293    
294     static int* descInvA[LSTR_INV] = {
295     descCntA, /* CNT record */
296     descN01A, /* N01 record */
297     descL01A, /* L01 record */
298     descN02A, /* N02 record */
299     descL02A, /* L02 record */
300     descIfp /* Ifp record */
301     };
302    
303    
304     /* ************************************************************
305     private functions
306     */
307     /* ************************************************************
308     package data
309     */
310     const LstrSet lstrlib[LSET_SETS] = {
311     { /* Isis 1 MST */
312     nameMst, { descMst, descMstA }
313     },
314     { /* Isis 1 INV */
315     nameInv, { descInv, descInvA }
316     },
317     }; /* lstrlib */
318    
319     /* ************************************************************
320     package functions
321     */
322     /* ************************************************************
323     public functions
324     */
325     int lstr_auto ( int *str ) {
326     static int pow2[] = { 1, 2, 4, 8 };
327     int ret = 0;
328     int fix,rep,occ,i;
329     int *xmbrs, txlen, tilen;
330     int nmbrs, off = 0, xlen[2] = {0,0}, blen[2] = {0,0}, x=0;
331    
332    
333     if ( NULL == str ) {
334     #define DOALL( x ) \
335     for ( i=0; i<(int)(sizeof(x)/sizeof(x[0])); i++ ) \
336     if ( NULL != x[i] ) ret |= lstr_auto( x[i] )
337     DOALL( descMst );
338     DOALL( descInv );
339     DOALL( descMstA );
340     DOALL( descInvA );
341     return ret;
342     }
343    
344     fix = LSTRFIX(*str);
345     rep = LSTRREP(*str);
346     occ = LSTROCC(*str);
347     xmbrs = str + LSTR_XMBR;
348     nmbrs = fix;
349    
350     for ( x=0; ; x++ ) { /* fix and rep */
351     for ( i=0; i<nmbrs; i++ ) {
352     int xmbr = xmbrs[i];
353     int len;
354     if ( LONG2OFF( xmbr ) )
355     off = LONG2OFF( xmbr );
356     else {
357     xmbrs[i] |= off << 16;
358     }
359     if ( LMBRISNUM(xmbr) )
360     len = pow2[ LMBRLD(xmbr) ];
361     else {
362     len = LONG2LEN(xmbr);
363     blen[x] += len+1;
364     }
365     LOG_DBG( LOG_ALL, "x.i %d.%d off %3ld, xmbr %08x len %d",
366     x, i, off, xmbrs[i], len );
367     off += len;
368     if ( xlen[x] < off )
369     xlen[x] = off;
370     }
371     /* done with one part */
372     if ( x || !rep ) /* was 2nd */
373     break;
374     xmbrs += fix;
375     nmbrs = rep;
376     off = 0;
377     }
378     /* got length's and buffer lengths of both parts */
379     LOG_DBG( LOG_ALL, "%08x %08x %d %d: xl %d %d bl %d %d",
380     str[0], str[1], str[2], str[3],
381     xlen[0], xlen[1], blen[0], blen[1] );
382     if ( !(short)(str[LSTR_XRLO] >> 16) )
383     str[LSTR_XRLO] |= xlen[0] << 16;
384     else if ( xlen[0] > (short)(str[LSTR_XRLO] >> 16) )
385     log_msg( LOG_WARN, "short xlen[0] %hd < %d",
386     (short)(str[LSTR_XRLO] >> 16), xlen[0] );
387     if ( !(short)str[LSTR_XRLO] )
388     str[LSTR_XRLO] |= 0xffff & xlen[1];
389     else if ( xlen[1] > (short)str[LSTR_XRLO] )
390     log_msg( LOG_WARN, "short xlen[1] %hd < %d",
391     (short)str[LSTR_XRLO], xlen[1] );
392     /* build totals applying occ */
393     txlen = (short)(str[LSTR_XRLO] >> 16)
394     + (int)occ*(short)str[LSTR_XRLO];
395     if ( !str[LSTR_XLEN] )
396     str[LSTR_XLEN] = txlen;
397     else if ( txlen > str[LSTR_XLEN] )
398     log_msg( LOG_WARN, "short xlen %d < %d",
399     str[LSTR_XLEN], txlen );
400     tilen = LSTRLEN(*str) + blen[0] + (int)occ*blen[1];
401     if ( !str[LSTR_ILEN] )
402     str[LSTR_ILEN] = tilen;
403     else if ( tilen > str[LSTR_ILEN] )
404     log_msg( LOG_WARN, "short ilen %d < %d",
405     str[LSTR_ILEN], tilen );
406     LOG_DBG( LOG_ALL, "%08x xrlo %08x xl %d il %d",
407     str[0], str[1], str[2], str[3] );
408     return ret;
409     } /* lstr_auto */

  ViewVC Help
Powered by ViewVC 1.1.26