← Back to branch summary

~ubuntu-branches/ubuntu/lucid/postgresql-8.4/lucid-proposed

« back to all changes in this revision

Viewing changes to contrib/ltree/ltree_io.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-11 16:59:35 UTC
  • mfrom: (5.1.1 karmic)
  • Revision ID: james.westby@ubuntu.com-20090711165935-jfwin6gfrxf0gfsi
Tags: 8.4.0-2
http://bugs.debian.org/536139
* debian/libpq-dev.install: Ship catalog/genbki.h. (Closes: #536139)
* debian/rules: Drop --enable-cassert for final release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ltree/ltree_io.c
1
1
/*
2
2
 * in/out function for ltree and lquery
3
3
 * Teodor Sigaev <teodor@stack.net>
4
 
 * $PostgreSQL: pgsql/contrib/ltree/ltree_io.c,v 1.17 2008/06/30 18:30:48 teodor Exp $
 
4
 * $PostgreSQL: pgsql/contrib/ltree/ltree_io.c,v 1.18 2009/06/11 14:48:51 momjian Exp $
5
5
 */
6
6
#include "postgres.h"
7
7
 
32
32
typedef struct
33
33
{
34
34
        char       *start;
35
 
        int                     len;  /* length in bytes */ 
 
35
        int                     len;                    /* length in bytes */
36
36
        int                     flag;
37
 
        int                     wlen; /* length in characters */
38
 
}       nodeitem;
 
37
        int                     wlen;                   /* length in characters */
 
38
} nodeitem;
39
39
 
40
40
#define LTPRS_WAITNAME  0
41
41
#define LTPRS_WAITDELIM 1
52
52
        int                     state = LTPRS_WAITNAME;
53
53
        ltree      *result;
54
54
        ltree_level *curlevel;
55
 
        int             charlen;
56
 
        int                     pos=0;
 
55
        int                     charlen;
 
56
        int                     pos = 0;
57
57
 
58
58
        ptr = buf;
59
59
        while (*ptr)
60
60
        {
61
61
                charlen = pg_mblen(ptr);
62
 
                if ( charlen == 1 && t_iseq(ptr, '.') )
 
62
                if (charlen == 1 && t_iseq(ptr, '.'))
63
63
                        num++;
64
 
                ptr+=charlen;
 
64
                ptr += charlen;
65
65
        }
66
66
 
67
67
        list = lptr = (nodeitem *) palloc(sizeof(nodeitem) * (num + 1));
83
83
                }
84
84
                else if (state == LTPRS_WAITDELIM)
85
85
                {
86
 
                        if ( charlen == 1 && t_iseq(ptr, '.') )
 
86
                        if (charlen == 1 && t_iseq(ptr, '.'))
87
87
                        {
88
88
                                lptr->len = ptr - lptr->start;
89
89
                                if (lptr->wlen > 255)
92
92
                                                         errmsg("name of level is too long"),
93
93
                                                         errdetail("Name length is %d, must "
94
94
                                                                           "be < 256, in position %d.",
95
 
                                                                         lptr->wlen, pos)));
 
95
                                                                           lptr->wlen, pos)));
96
96
 
97
97
                                totallen += MAXALIGN(lptr->len + LEVEL_HDRSIZE);
98
98
                                lptr++;
105
105
                        /* internal error */
106
106
                        elog(ERROR, "internal error in parser");
107
107
 
108
 
                ptr+=charlen;
 
108
                ptr += charlen;
109
109
                lptr->wlen++;
110
110
                pos++;
111
111
        }
209
209
        bool            hasnot = false;
210
210
        bool            wasbad = false;
211
211
        int                     charlen;
212
 
        int                     pos=0;
 
212
        int                     pos = 0;
213
213
 
214
214
        ptr = buf;
215
215
        while (*ptr)
216
216
        {
217
217
                charlen = pg_mblen(ptr);
218
218
 
219
 
                if ( charlen == 1 )
 
219
                if (charlen == 1)
220
220
                {
221
221
                        if (t_iseq(ptr, '.'))
222
222
                                num++;
224
224
                                numOR++;
225
225
                }
226
226
 
227
 
                ptr+=charlen;
 
227
                ptr += charlen;
228
228
        }
229
229
 
230
230
        num++;
243
243
                                state = LQPRS_WAITDELIM;
244
244
                                curqlevel->numvar = 1;
245
245
                        }
246
 
                        else if (charlen==1 && t_iseq(ptr, '!'))
 
246
                        else if (charlen == 1 && t_iseq(ptr, '!'))
247
247
                        {
248
248
                                GETVAR(curqlevel) = lptr = (nodeitem *) palloc0(sizeof(nodeitem) * (numOR + 1));
249
249
                                lptr->start = ptr + 1;
252
252
                                curqlevel->flag |= LQL_NOT;
253
253
                                hasnot = true;
254
254
                        }
255
 
                        else if (charlen==1 && t_iseq(ptr, '*'))
 
255
                        else if (charlen == 1 && t_iseq(ptr, '*'))
256
256
                                state = LQPRS_WAITOPEN;
257
257
                        else
258
258
                                UNCHAR;
271
271
                }
272
272
                else if (state == LQPRS_WAITDELIM)
273
273
                {
274
 
                        if (charlen==1 && t_iseq(ptr, '@'))
 
274
                        if (charlen == 1 && t_iseq(ptr, '@'))
275
275
                        {
276
276
                                if (lptr->start == ptr)
277
277
                                        UNCHAR;
278
278
                                lptr->flag |= LVAR_INCASE;
279
279
                                curqlevel->flag |= LVAR_INCASE;
280
280
                        }
281
 
                        else if (charlen==1 && t_iseq(ptr, '*'))
 
281
                        else if (charlen == 1 && t_iseq(ptr, '*'))
282
282
                        {
283
283
                                if (lptr->start == ptr)
284
284
                                        UNCHAR;
285
285
                                lptr->flag |= LVAR_ANYEND;
286
286
                                curqlevel->flag |= LVAR_ANYEND;
287
287
                        }
288
 
                        else if (charlen==1 && t_iseq(ptr, '%'))
 
288
                        else if (charlen == 1 && t_iseq(ptr, '%'))
289
289
                        {
290
290
                                if (lptr->start == ptr)
291
291
                                        UNCHAR;
292
292
                                lptr->flag |= LVAR_SUBLEXEME;
293
293
                                curqlevel->flag |= LVAR_SUBLEXEME;
294
294
                        }
295
 
                        else if (charlen==1 && t_iseq(ptr, '|'))
 
295
                        else if (charlen == 1 && t_iseq(ptr, '|'))
296
296
                        {
297
297
                                lptr->len = ptr - lptr->start -
298
298
                                        ((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
304
304
                                                         errmsg("name of level is too long"),
305
305
                                                         errdetail("Name length is %d, must "
306
306
                                                                           "be < 256, in position %d.",
307
 
                                                                         lptr->wlen, pos)));
 
307
                                                                           lptr->wlen, pos)));
308
308
 
309
309
                                state = LQPRS_WAITVAR;
310
310
                        }
311
 
                        else if (charlen==1 && t_iseq(ptr, '.'))
 
311
                        else if (charlen == 1 && t_iseq(ptr, '.'))
312
312
                        {
313
313
                                lptr->len = ptr - lptr->start -
314
314
                                        ((lptr->flag & LVAR_SUBLEXEME) ? 1 : 0) -
320
320
                                                         errmsg("name of level is too long"),
321
321
                                                         errdetail("Name length is %d, must "
322
322
                                                                           "be < 256, in position %d.",
323
 
                                                                         lptr->wlen, pos)));
 
323
                                                                           lptr->wlen, pos)));
324
324
 
325
325
                                state = LQPRS_WAITLEVEL;
326
326
                                curqlevel = NEXTLEV(curqlevel);
335
335
                }
336
336
                else if (state == LQPRS_WAITOPEN)
337
337
                {
338
 
                        if (charlen==1 && t_iseq(ptr, '{'))
 
338
                        if (charlen == 1 && t_iseq(ptr, '{'))
339
339
                                state = LQPRS_WAITFNUM;
340
 
                        else if (charlen==1 && t_iseq(ptr, '.'))
 
340
                        else if (charlen == 1 && t_iseq(ptr, '.'))
341
341
                        {
342
342
                                curqlevel->low = 0;
343
343
                                curqlevel->high = 0xffff;
349
349
                }
350
350
                else if (state == LQPRS_WAITFNUM)
351
351
                {
352
 
                        if (charlen==1 && t_iseq(ptr, ','))
 
352
                        if (charlen == 1 && t_iseq(ptr, ','))
353
353
                                state = LQPRS_WAITSNUM;
354
354
                        else if (t_isdigit(ptr))
355
355
                        {
366
366
                                curqlevel->high = atoi(ptr);
367
367
                                state = LQPRS_WAITCLOSE;
368
368
                        }
369
 
                        else if (charlen==1 && t_iseq(ptr, '}'))
 
369
                        else if (charlen == 1 && t_iseq(ptr, '}'))
370
370
                        {
371
371
                                curqlevel->high = 0xffff;
372
372
                                state = LQPRS_WAITEND;
376
376
                }
377
377
                else if (state == LQPRS_WAITCLOSE)
378
378
                {
379
 
                        if (charlen==1 && t_iseq(ptr, '}'))
 
379
                        if (charlen == 1 && t_iseq(ptr, '}'))
380
380
                                state = LQPRS_WAITEND;
381
381
                        else if (!t_isdigit(ptr))
382
382
                                UNCHAR;
383
383
                }
384
384
                else if (state == LQPRS_WAITND)
385
385
                {
386
 
                        if (charlen==1 && t_iseq(ptr, '}'))
 
386
                        if (charlen == 1 && t_iseq(ptr, '}'))
387
387
                        {
388
388
                                curqlevel->high = curqlevel->low;
389
389
                                state = LQPRS_WAITEND;
390
390
                        }
391
 
                        else if (charlen==1 && t_iseq(ptr, ','))
 
391
                        else if (charlen == 1 && t_iseq(ptr, ','))
392
392
                                state = LQPRS_WAITSNUM;
393
393
                        else if (!t_isdigit(ptr))
394
394
                                UNCHAR;
395
395
                }
396
396
                else if (state == LQPRS_WAITEND)
397
397
                {
398
 
                        if (charlen==1 && t_iseq(ptr, '.'))
 
398
                        if (charlen == 1 && t_iseq(ptr, '.'))
399
399
                        {
400
400
                                state = LQPRS_WAITLEVEL;
401
401
                                curqlevel = NEXTLEV(curqlevel);
407
407
                        /* internal error */
408
408
                        elog(ERROR, "internal error in parser");
409
409
 
410
 
                ptr+=charlen;
411
 
                if ( state == LQPRS_WAITDELIM )
 
410
                ptr += charlen;
 
411
                if (state == LQPRS_WAITDELIM)
412
412
                        lptr->wlen++;
413
413
                pos++;
414
414
        }