+++ /dev/null
-/*
- openisis - an open implementation of the CDS/ISIS database
- Version 0.8.x (patchlevel see file Version)
- Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
- see README for more information
-EOH */
-
-/*
- $Id: lrec.c,v 1.53 2003/05/29 18:03:35 kripke Exp $
- implementation of record cooking.
-*/
-
-#include <stddef.h>
-#include <stdarg.h>
-#include <stdio.h> /* vsnprintf */
-#include <stdlib.h> /* free */
-#include <string.h> /* memset et al */
-
-#ifdef WIN32
-# define vsnprintf _vsnprintf
-#endif /* WIN32 */
-
-#include "ldb.h"
-#include "lio.h"
-#include "lcs.h"
-
-
-/* ************************************************************
- private types
-*/
-
-typedef struct {
- int len; /* length of tagf */
- int tagf[2]; /* tag and modification flags */
-} LrecMF;
-
-#define MF_SET 0x01
-#define MF_DEL 0x02
-
-/* ************************************************************
- private data
-*/
-/* ************************************************************
- private functions
-*/
-
-static LrecMF* mfCtor (Rec *rec) {
- int len = (int)(2 * rec->len);
- int *M;
- Field *F;
- LrecMF *lmf = (LrecMF*) mAlloc ((1 + len) * sizeof (int));
- if (0 == lmf) {
- return 0;
- }
- memset (lmf->tagf, 0, len * sizeof (int));
- lmf->len = len;
- for (M = lmf->tagf, F = rec->field; len > M - lmf->tagf; ++F, M += 2) {
- *M = (int) F->tag;
- }
- return lmf;
-}
-
-static int rCompact (Rec *rec) {
- int rt = 0;
- if (0 != rec) {
- char *V = (char*)rec + rec->base;
- Field *F = rec->field;
- Field *L = F + rec->len;
- int used = rec->base;
- while (F < L) {
- if (V != F->val) {
- rt = !0;
- break;
- }
- V += F->len;
- used += F->len;
- ++F;
- }
- if (rt) {
- char *buf = (char*) mAlloc (rec->used - (V - (char*)rec));
- char *B = buf;
- int nb = 0;
- if (0 == buf) {
- return 0;
- }
- while (F < L) {
- memcpy (B, F->val, F->len);
- F->val = V;
- B += F->len;
- V += F->len;
- nb += F->len;
- ++F;
- }
- memcpy ((char*)rec + used, buf, nb);
- rec->used = used + nb;
- mFree (buf);
- }
- }
- return rt;
-}
-
-/** @return
- -2 - malloc failed,
- -1 - tag not present,
- 0 - compactification not neccessary,
- 1 - rec data buffer has gaps
-*/
-static int rReplace (
- Rec **rec, LrecMF *lmf,
- int tag, int occr, int lmode, const char *val, int disc
-) {
- Rec *nr;
- Field *F;
- int *M;
- int vlen;
- int fnd = -1;
- int ocnt = -1;
- for (M = lmf->tagf; lmf->len > M - lmf->tagf; M += 2) {
- if (tag == M[0]) {
- if (0 <= occr) {
- if (++ocnt == occr) {
- M[1] = lmode;
- fnd = (M - lmf->tagf) / 2;
- break;
- }
- }
- else {
- if (0 == (MF_SET & M[1])) {
- M[1] = lmode;
- fnd = (M - lmf->tagf) / 2;
- if (lmode) {
- for (M += 2; lmf->len > M - lmf->tagf; M += 2) {
- if (tag == M[0]) {
- M[1] = MF_DEL;
- }
- }
- }
- break;
- }
- }
- }
- }
- if (0 > fnd) {
- return -1;
- }
- if (MF_SET != lmode) {
- return 1;
- }
- F = (*rec)->field + fnd;
- vlen = strlen (val);
- if (F->len == vlen) {
- memcpy ((char*)F->val, val, vlen);
- return 0;
- }
- if (F->len > vlen) {
- memcpy ((char*)F->val, val, vlen);
- F->len = vlen;
- return 1;
- }
- if ((*rec)->bytes < (*rec)->used + vlen) {
- nr = rDup (*rec, vlen, disc);
- if (0 == nr) {
- return -2;
- }
- F = (*rec = nr)->field + fnd;
- }
- F->val = (char*)(*rec) + (*rec)->used;
- F->len = vlen;
- memcpy ((char*)F->val, val, vlen);
- (*rec)->used += vlen;
- return 1;
-}
-
-static int rDel (Rec *rec, LrecMF *lmf) {
- Field *F;
- int *M;
- int idx;
- int dcnt = 0;
- int done = 0;
- for (M = lmf->tagf; lmf->len > M - lmf->tagf; M += 2) {
- if (0 != (MF_DEL & M[1])) {
- idx = (M - lmf->tagf) / 2 - dcnt;
- if (idx < rec->len - 1) {
- F = rec->field + idx;
- memmove (F, F + 1, (rec->len - idx - 1) * sizeof (Field));
- }
- --(rec->len);
- ++dcnt;
- done = !0;
- }
- }
- return done;
-}
-
-/* ************************************************************
- package functions
-*/
-
-/* ************************************************************
- public functions
-*/
-
-
-Field *rGet ( Rec *r, int tag, int *pos )
-{
- if (r) {
- int p = pos ? *pos : 0;
- for ( ; p < r->len; p++ )
- if ( tag == r->field[p].tag ) {
- if ( pos )
- *pos = p+1;
- return &r->field[p];
- }
- if ( pos )
- *pos = r->len;
- }
- return 0;
-} /* rGet */
-
-Field *rOccurence ( Rec *r, int tag, int occ ) {
- Field *F;
- int pos = 0;
- do {
- F = rGet (r, tag, &pos);
- } while (F && 0 <= --occ);
- return F;
-}
-
-char *rString (Rec *rec, int tag, int *pos, char *buf, int len) {
- Field *F = rGet (rec, tag, pos);
- if (!F) {
- return 0;
- }
- if (len > 1 + F->len) {
- len = 1 + (int) F->len;
- }
- if (0 >= --len) {
- *buf = 0;
- return buf;
- }
- strncpy (buf, F->val, len) [len] = 0;
- return buf;
-}
-
-
-char *rString2 (Rec *rec, Rec *dflt, int tag, char *buf, int len) {
- char *rt = rString (rec, tag, 0, buf, len);
- if (rt) {
- return rt;
- }
- return rString (dflt, tag, 0, buf, len);
-}
-
-
-int rInt ( Rec *r, int tag, int def, int *pos )
-{
- if (r) {
- int p = pos ? *pos : 0;
- int rt;
- for ( ; p < r->len; p++ )
- if ( tag == r->field[p].tag ) {
- if ( pos )
- *pos = p+1;
- rt = a2i( r->field[p].val, r->field[p].len );
- if (rt) {
- return rt;
- }
- if (0 < luti_true (r->field[p].val, r->field[p].len)) {
- return 1;
- }
- return 0;
- }
- if ( pos )
- *pos = r->len;
- }
- return def;
-} /* rInt */
-
-
-int rInt2 (Rec *rec, Rec *dflt, int tag, int def) {
- int rt1 = rInt (rec, tag, def, 0);
- if (def == rt1) {
- return rInt (dflt, tag, def, 0);
- }
- return rt1;
-}
-
-
-int rEnum (Fdt *fdt, Rec *rec, int tag, int def, int *pos) {
- char buf[OPENISIS_FD_NAMELEN];
- Field *F;
- Fd *D;
- int len, ev;
- if (! fdt || ! rec) {
- return def;
- }
- D = fById (fdt, tag, 0);
- if (! D) {
- return def;
- }
- F = rGet (rec, tag, pos);
- if (! F) {
- return def;
- }
- len = (int) F->len;
- if (OPENISIS_FD_NAMELEN <= len) {
- len = OPENISIS_FD_NAMELEN - 1;
- }
- strncpy (buf, F->val, len) [len] = 0;
- ev = fEnum (fdt, tag, buf);
- if (NOENUM == ev) {
- return def;
- }
- return ev;
-}
-
-
-Rec* rDup ( Rec *r, int room, int discard )
-{
- Rec *nr = 0;
- int nfields, nbytes, hadfields, hadcontent;
- if ( ! r ) {
- nfields = 80; /* for a 1K base */
- nbytes = 8*1024;
- if ( nbytes < BASESZ(80) + room*3/2 )
- nbytes = BASESZ(80) + room*3/2;
- hadfields = 0;
- hadcontent = 0;
- } else {
- rCompact (r);
- hadfields = r->len;
- hadcontent = r->used - r->base;
- if ( 0 > room ) { /* shrink to fit */
- nfields = r->len;
- nbytes = BASESZ(nfields) + hadcontent;
- } else {
- nfields = 54 > r->len ? 80 : (r->len * 3 / 2); /* add 50% */
- if ( nfields < r->fields )
- nfields = r->fields;
- nbytes = 6*1024 > r->bytes ? 8*1024 : (r->bytes *3 / 2);
- if ( nbytes < r->used + room )
- nbytes = r->used + room*3/2;
- nbytes += (nfields - r->fields)*sizeof(Field);
- }
- }
- LOG_DBG( LOG_DEBUG,
- "extending rec size %d (cont %d) to %d bytes, %d -> %d fields",
- !r ? -1 : r->bytes, hadcontent, nbytes, hadfields, nfields );
- assert( nbytes >= BASESZ( nfields ) + hadcontent + room );
- if ( ! (nr = mAlloc( nbytes )) )
- return 0;
- memset( nr, 0, nbytes ); /* paranoia */
- nr->bytes = nbytes;
- nr->fields = nfields;
- nr->base = BASESZ( nfields );
- nr->used = nr->base + hadcontent;
- nr->len = hadfields;
- if ( ! r ) {
- nr->dbid = -1; /* no valid dbid if new rec */
- }
- else {
- char *obuf = ((char*)r) + r->base;
- char *nbuf = ((char*)nr) + nr->base;
- nr->dbid = r->dbid;
- /* for ! r, the following are 0 by memset */
- nr->rowid = r->rowid;
- nr->state = r->state;
- if ( hadcontent )
- memcpy( nbuf, obuf, hadcontent );
- if ( hadfields ) {
- int i;
- int displace = nbuf - obuf; /* ptrdiff_t */
- Field *f = nr->field;
- memcpy( nr->field, r->field, hadfields*sizeof(Field) );
- for ( i=hadfields; i--; )
- if ( f[i].val )
- f[i].val += displace;
-#ifndef NDEBUG
- {
- char *end = ((char*)nr) + nr->used;
- for ( i=hadfields; i--; )
- if ( f[i].val
- && (f[i].val < nbuf || f[i].val + f[i].len > end)
- ) {
- int wasok = r->field[i].val >= obuf
- && r->field[i].val + r->field[i].len <= obuf + hadcontent;
- sMsg( LOG_ERROR, "OOPS! nuked field %d which previously was %s",
- i, wasok ? "ok" : "already broken" );
- return 0; /* no cleanup, we're nearly dead anyway */
- }
- }
-#endif
- }
- if ( discard )
- free( r );
- }
- assert( RECOK(nr) );
- return nr;
-} /* rDup */
-
-
-Rec* rMsg ( Rec *r, int discard, int tag, const char *fmt, ... )
-{
- char buf[1024];
- int l;
- va_list ap;
- va_start( ap, fmt );
- l = vsnprintf( buf, sizeof(buf), fmt, ap );
- if ( 0 > l ) /* older versions return -1 */
- l = sizeof(buf);
- va_end( ap );
- RADD( r, tag, buf, l, discard );
- return r;
-} /* rMsg */
-
-/*
-#define openIsisPrintf( r, d, t, f, a... ) \
- openIsisRMsg( OPENISIS_SES0(), r, d, t, f, ## a )
- requires gcc ...
-*/
-Rec* openIsisPrintf ( Rec *r, int discard, int tag, const char *fmt, ... )
-{
- char buf[1024];
- int l;
- va_list ap;
- va_start( ap, fmt );
- l = vsnprintf( buf, sizeof(buf), fmt, ap );
- if ( 0 > l ) /* older versions return -1 */
- l = sizeof(buf);
- va_end( ap );
- RADD( r, tag, buf, l, discard );
- return r;
-} /* openIsisPrintf */
-
-
-Rec *rAddI (Rec *rec, int tag, int val, int discard) {
- char buf[32];
- int len = i2a (buf, (int)val);
- RADD (rec, tag, buf, len, discard);
- return rec;
-}
-
-
-Rec* rSet ( Rec *oldr, int mode, ... )
-{
- const char **argv = 0;
- LrecMF *lmf = 0;
- Fdt *fdt = 0;
- Rec *newr = oldr;
- int argc = 0xffff & mode;
- int dis = RDIS & mode;
- int op = ROP & mode;
- int lmode = MF_SET;
- int compact = 0;
-
- va_list ap;
- va_start( ap, mode );
-
- if (RFDT & mode) {
- fdt = va_arg( ap, Fdt* );
- }
- if (RARGV & mode) {
- argv = va_arg( ap, const char** );
- }
- if (! fdt) {
- fdt = luti_fdt_from_rec (oldr);
- }
- if (op) {
- switch (op) {
- case RDEL:
- lmode = MF_DEL;
- break;
- case RCHG:
- break;
- case RDFLT:
- lmode = 0;
- break;
- default:
- sMsg (ERR_IDIOT, "rSet: illegal mode %x", op);
- return newr;
- }
- if (oldr) {
- if (0 == (lmf = mfCtor (oldr))) {
- goto done;
- }
- }
- else if (RDEL == op) {
- goto done;
- }
- }
-
- for ( ;; ) {
- char ib[16];
- Rec *tmpr;
- const char *v = 0;
- int id = -1;
- int occr = -1;
- Fd *fd = 0;
- int rpl;
- if ( argv ) {
- if ( 1 > argc )
- break;
- v = luti_parse_path (*argv, fdt, &fd, &id, &occr);
- if (!v || *v) {
- fd = 0;
- id = -1;
- }
- v = 0;
- ++argv;
- --argc;
- }
- else {
- id = va_arg( ap, int );
- if ( ! id )
- break;
- fd = fdt ? fById( fdt, id, 0 ) : 0;
- if (RDEL != op) {
- v = va_arg( ap, char* );
- }
- }
- if ( fd ) {
- if (RDEL != op) {
- int e;
- if (argv) {
- if ( 1 > argc ) {
- if (FTB != fd->type) {
- break;
- }
- }
- else {
- v = *argv++;
- --argc;
- }
- }
- switch ( fd->type ) {
- case FTE:
- e = fEnum( fdt, fd->id, v );
- if ( NOENUM == e ) {
- if ( RIGN & mode )
- continue;
- sMsg( LOG_ERROR,
- "bad enum value '%s' for id %d", v, fd->id );
- goto error;
- }
- i2a( ib, e );
- v = ib;
- break;
- case FTB:
- e = v ? luti_true (v, -1) : 1;
- if (0 > e) {
- /* non-given values default to true */
- ++argc;
- --argv;
- v = "1";
- }
- else {
- v = e ? "1" : "0";
- }
- break;
- }
- } /* RDEL != op */
- } /* fd */
- else {
- if (argv) {
- if (RDEL != op) {
- if ( 1 > argc ) {
- break;
- }
- v = *argv++;
- --argc;
- }
- }
- if (fdt /*|| 0 >= id*/) {
- if ( RIGN & mode )
- continue;
- if ( argv )
- sMsg( LOG_ERROR, "unknown field name '%s'",
- argv[RDEL == op ? -1 : -2] );
- else
- sMsg( LOG_ERROR, "unknown field id %d", id );
- break;
- }
- }
- if (!v) {
- v = "";
- }
- if (op) {
- rpl = lmf ? rReplace (
- &newr, lmf, id, occr, lmode, v, dis || newr != oldr) :
- -1;
- if (RDFLT == op) {
- if (-1 != rpl) {
- continue;
- }
- }
- else {
- if (-2 == rpl) {
- goto done;
- }
- if (-1 != rpl) {
- if (1 == rpl) {
- compact = !0;
- }
- continue;
- }
- if (RDEL == op) {
- continue;
- }
- }
- /* fall thru */
- }
- tmpr = newr;
- RADDS( newr, id, v, dis || newr != oldr );
- if (0 == newr) {
- goto done;
- }
- if (newr != tmpr) {
- compact = 0;
- }
- sMsg( LOG_VERBOSE,
- "added v '%s' id %d as %dth", v, id, newr->len );
- }
-
-error:
- if (lmf) {
- if (rDel (newr, lmf)) {
- compact = !0;
- }
- }
-
- if (compact && 0 == (RNOC & mode)) {
- rCompact (newr);
- }
-
-done:
- if (lmf) {
- mFree (lmf);
- }
- va_end( ap );
- return newr;
-} /* rSet */
-
-
-Rec *dFmt ( Rec *buf, const char *fmt, int db, int rowid )
-{
- Rec *r = dRead( db, rowid );
- Rec *q;
- if ( ! r )
- return 0;
- q = rFmt( buf, fmt, r );
- free( r );
- return q;
-} /* dFmt */
-
-
-Rec *dScan ( int db, int rowid, int tag, const char *txt )
-{
- int max = dMaxId( db );
- int tlen = strlen( txt );
- const char f = *txt;
-
- for ( ; rowid <= max; rowid++ ) {
- int i, found = 0;
- Rec *r = dRead( db, rowid );
- if ( ! r )
- continue;
-
- for ( i=0; i < r->len; i++ ) {
- const char *c, *e;
- if ( found
- || (tag > 0 && tag != r->field[i].tag)
- || tlen > r->field[i].len
- )
- continue;
- c = r->field[i].val;
- e = c + r->field[i].len - tlen;
- for ( ; c<=e; c++ )
- if ( f == *c && !memcmp( c, txt, tlen ) ) {
- found = !0;
- break;
- }
- }
- if ( found )
- return r;
- }
- return 0;
-} /* dScan */
-
-
-
-
-
-Rec *rSplitf ( Rec *r, const Field* field )
-{
- int i;
- int nfields = 0; /* number of subfields */
- int size; /* byte length of field list */
- const char *p, *e;
-
- if ( ! field || 2 > field->len )
- return 0;
- if ( '^' != field->val[0] ) /* initial anonymous subfield */
- nfields = 1;
- /* go counting hats ... */
- for ( e = (p=field->val) + field->len - 1; p<e; )
- if ( '^' == *p++ && '^' != *p ) /* ignore first of ^^ */
- nfields++;
- if ( '^' == *p )
- sMsg( LOG_ERROR, "found trailing '^' in field '%.*s'",
- (int)field->len, field->val );
-
- if ( r ) {
- if ( 1 > r->len )
- return 0;
- size = sizeof(Rec) + (r->len - 1) * sizeof(Field);
- if ( nfields > r->len )
- nfields = r->len;
- } else {
- /* first field already counted in sizeof(Rec) */
- size = sizeof(Rec) + (nfields - 1) * sizeof(Field);
- r = (Rec *)mAlloc( size );
- if ( ! r )
- return 0;
- }
- memset( r, 0, size );
- r->rowid = 0;
- r->len = nfields;
-
- e = (p = field->val) + field->len;
- if ( '^' == *p ) /* else initial anonymous subfield */
- p++;
- for ( i=0; i<nfields; i++ ) {
- /* p is on hat or end ... skip all consecutive hats */
- while ( p<e && '^' == *p )
- p++;
- if ( p >= e ) {
- sMsg( LOG_ERROR,
- "confused cats hound counting hats at %d in '%.*s'",
- i, field->len, field->val );
- r->len = i;
- break;
- }
- /* p is after a hat */
- r->field[ i ].tag = p==field->val ? 0 : (unsigned char)*p++;
- r->field[ i ].val = p;
- /* advance in buf */
- while ( p<e && '^' != *p )
- p++;
- r->field[ i ].len = p - r->field[ i ].val;
- /* log_msg( LOG_ERROR, "subf %d of %d tag %c off %d",
- i, nfields, r->field[ i ].tag, r->field[ i ].val - field->val ); */
- }
-
- return r;
-} /* rSplitf */
-
-
-
-
-enum { /* stream reading state */
- RS_REC, /* not in any record */
- RS_TAG, /* in tag: done is at beginning of line */
- RS_SEP, /* in sep: done is at beginning of sep */
- RS_VAL, /* done is somewhere in the value ... */
- RS_EOL /* not really a state, but a flag */
-};
-
-
-/**
- read a record from a stream.
- This may either
- <ol>
- <li> read a record and return 1
- </li>
- <li> not get enough bytes on a non-blocking stream and return 0
- </li>
- <li> have some error and return negative
- </li>
- </ol>
-*/
-int sGetr ( OpenIsisRecStream *s )
-{
- Ios *lio = s->in;
- int state = 3 & s->flg;
- int emptyline = 0;
- int ret = 0;
- if ( ! s->rec
- && ! (s->rec = s->buf) /* have buffer ? */
- && ! (s->rec = rDup( 0, 0, 0 ))
- /* allocate and prepare an 8k standard record */
- ) {
- ret = sMsg( LOG_ERROR, "could not get record" );
- goto fatal;
- }
- if ( RS_REC == state ) { /* initialize */
- s->rec->rowid = 0;
- s->rec->len = 0; /* nuke all fields */
- s->rec->used = s->rec->base; /* nuke value buffer */
- /* let base/fields untouched, it hopefully has a reasonable value */
- state = RS_TAG;
- }
- if ( ! s->rec->len )
- state = RS_TAG;
- for (;;) {
- unsigned char *b, *p, *e; /* begin, pointer, end */
- if ( lio->b.done >= lio->b.fill ) {
- reload:
- if ( ! LIO_FILL( lio ) )
- goto done; /* EAGAIN -- see ya later */
- /* so we have bytes or EOF */
- if ( lio->b.done >= lio->b.fill ) {
- if ( LIO_IN & lio->file ) {
- sMsg( LOG_ERROR, "confused in instream: no bytes and no EOF" );
- lio_close( &lio->file, LIO_IN );
- }
- break;
- }
- }
- /* so we have bytes */
- p = b = lio->b.c + lio->b.done;
- e = lio->b.c + lio->b.fill;
- /* try to eat one line */
- switch ( state ) {
- case RS_TAG: {
- int tag = -1;
- int recognized = 0;
- if ( LCS_ISFR(lcs_latin1_ct[*p]) ) { /* line starts with line/record sep */
- if ( '\n' == *p && (RS_EOL & s->flg) ) { /* TODO */
- s->flg &= ~RS_EOL;
- continue;
- }
- emptyline = !0;
- break;
- }
- for (;;p++) {
- if ( p < e ) {
- if ( LCS_ISWORD(lcs_latin1_ct[*p]) )
- continue; /* tight loop */
- break;
- }
- if ( 4096 > p - b )
- goto reload;
- sMsg( ERR_TRASH, "tag too long" );
- goto fatal;
- }
- /* identify tag between s and p */
- if ( p == b )
- recognized = !0;/* empty tag */
- else if ( '0' <= *b && *b <= '9' ) {
- unsigned char *d = b; /* digit ? */
- tag = 0;
- while ( d < p && '0' <= *d && *d <= '9' )
- tag = 10*tag + *d++ - '0';
- if ( !(recognized = d == p) ) /* all digits */
- tag = -1;
- }
- if ( ! recognized && s->dict ) { /* dict lookup */
- int i=s->dict->len, l = p-b;
- Field *f = s->dict->field;
- for ( ; i--; f++ )
- if ( l == f->len && memcmp( b, f->val, l ) ) {
- tag = f->tag;
- break;
- }
- }
- /* create new field unless it's a continuation line */
- if ( p == b && s->rec->len )
- ;
- else if ( recognized )
- RADD( s->rec, tag, 0, 0, s->rec != s->buf );
- else
- RADD( s->rec, tag, b, p-b, s->rec != s->buf );
- if ( ! s->rec )
- goto outamem;
- /* did that */
- lio->b.done = (b = p) - lio->b.c;
- if ( LCS_ISFR(lcs_latin1_ct[*p]) )
- break;
- state = RS_SEP;
- } case RS_SEP:
- /* p = b is at beginning of separator */
- while ( p < e && ' ' == *p ) /* skip leading blanks */
- p++;
- if ( p < e && LCS_ISCST(lcs_latin1_ct[*p]) && '\t' != *p++ )
- while ( p < e && ' ' == *p ) /* skip trailing blanks */
- p++;
- if ( e == p ) {
- if ( 4096 > p - b )
- goto reload;
- sMsg( ERR_TRASH, "sep too long" );
- goto fatal;
- }
- assert( s->rec->len );
- if ( s->rec->field[s->rec->len - 1].len )
- RCAT( s->rec, b, p-b, s->rec != s->buf );
- if ( ! s->rec )
- goto outamem;
- lio->b.done = (b = p) - lio->b.c;
- if ( LCS_ISFR(lcs_latin1_ct[*p]) )
- break;
- state = RS_VAL;
- case RS_VAL: default: /* ??? */
- while ( p < e && !LCS_ISFR(lcs_latin1_ct[*p]) )
- p++;
- assert( s->rec->len );
- if ( p > b )
- RCAT( s->rec, b, p-b, s->rec != s->buf );
- if ( ! s->rec )
- goto outamem;
- lio->b.done = (b = p) - lio->b.c;
- if ( p == e )
- goto reload;
- /* else we found line or record separator */
- } /* switch state */
- if ( '\r' == *p ) { /* do that ole' ugly CR/NL quatsch */
- if ( e-p < 2 && 0 < LIO_FILL(lio) ) /* extend end */
- e = lio->b.c + lio->b.fill;
- if ( e-p < 2 )
- s->flg |= RS_EOL; /* possibly check later */
- else if ( '\n' == p[1] )
- p++;
- }
- lio->b.done = 1 + p - lio->b.c; /* consider p eaten */
- if ( LCS_R == lcs_latin1_ct[*p]
- || (emptyline && (OPENISIS_STOPONEMPTY & s->flg))
- )
- break;
- state = RS_TAG;
- }
- /* got record */
- state = RS_REC;
- if ( s->rec && s->rec->len ) {
- if ( (OPENISIS_AUTOCLONE & s->flg) && s->rec == s->buf )
- s->rec = rDup( s->buf, 0, 0 );
- ret = 1;
- }
- goto done;
-outamem:
-fatal:
- if ( LIO_SISOPEN( s->in ) )
- LIO_CLOSE( s->in );
-done:
- s->flg = state | (~3 & s->flg); /* save state */
- /* sMsg( LOG_ERROR, "fill %d done %d", lio->b.fill, lio->b.done ); */
- return ret;
-} /* openIsisReadStream */
-
-
-int rSer ( char *buf, OpenIsisRec *rec )
-{
- Field *f = rec->field;
- int i = rec->len;
- char *p = buf, *e;
-
- for ( ; i--; f++ ) {
- p += i2a( p, f->tag );
- *p++ = 9; /* TAB */
- memcpy( p, f->val, f->len );
- for ( e = p + f->len; p<e; )
- if ( 10 == *p++ )
- p[-1] = 11;
- *p++ = 10;
- }
- *p++ = 10;
- return p - buf;
-} /* rSer */
-
-
-/** binary serialize, turns newline into newline tab
- buf must have len >= 2*rec->used
-*/
-int rSerB ( char *buf, OpenIsisRec *rec )
-{
- Field *f = rec->field;
- int i = rec->len;
- char *p = buf;
- const char *s, *e;
-
- for ( ; i--; f++ ) {
- p += i2a( p, f->tag );
- *p++ = 9; /* TAB */
- for ( e = (s = f->val) + f->len; s<e; )
- if ( 10 == (*p++ = *s++) )
- *p++ = 9;
- *p++ = 10;
- }
- *p++ = 10;
- return p - buf;
-} /* rSerB */
-
-
-char* rSerA (Rec *rec, char *buf, int *len) {
- if (!len) {
- return 0;
- }
- if (!rec) {
- *len = 0;
- return buf;
- }
- if (*len <= rec->used) {
- buf = (char*) mAlloc (1 + rec->used);
- if (!buf) {
- sMsg (ERR_NOMEM, "rSerA: cannot malloc %d", (1 + rec->used));
- return 0;
- }
- }
- *len = rSer (buf, rec);
- return buf;
-}
-
-
-int rDeser ( OpenIsisRec **rp, const char *buf, int len, int flg )
-{
- Rec *rec = *rp;
- Field *f;
- const char *p = buf, *e = buf+len;
- char *q;
- int dis = RDIS & flg;
- int tag;
- /* non-transparent mode - no continuation lines */
- for ( ; e > p; p++ ) {
- if ( 10 == *p ) { /* blank line */
- if ( OPENISIS_STOPONEMPTY & flg )
- break;
- continue;
- }
- p += a2il( p, e-p, &tag );
- if ( e > p && 9 == *p ) /* TAB */
- p++;
- RADD( rec, tag, 0, e-p, dis || rec!=*rp );
- if ( !rec )
- break;
- f = rec->field + rec->len-1;
- for ( q=(char*)f->val; e>p && 10 != *p; )
- if ( 11 == (*q++ = *p++) )
- q[-1] = 10;
- rec->used += f->len = q - f->val;
- }
- *rp = rec;
- return p-buf;
-} /* rDeser */
projects / webpac / blobdiff