openisis/0.9.0/luti.c

/*
        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: luti.c,v 1.48 2003/06/23 14:47:35 kripke Exp $
        utilities
*/

#include <string.h> /* strlen */

#include "openisis.h"
#include "luti.h"


/* ************************************************************
        private types
*/

typedef struct {
        char *name;
        int   id;
} LutiLTEnt;

typedef struct OpenIsisLT {
        LutiLTEnt *arr;
        int        siz; /* malloc'ed */
        int        num; /* used */
} LutiLTNod;

#define LT_NUM   27
#define LT_SIZE (LT_NUM * sizeof (LutiLTNod))

#define LTIDX(name) (  \
        ('a' <= *(name) && 'z' >= *(name)) ? *(name) - 'a' :  ( \
        ('A' <= *(name) && 'Z' >= *(name)) ? *(name) - 'A' : 26 \
))

#define LT_INCR 2

/* ************************************************************
        private data
*/


/* ************************************************************
        private functions
*/


/* ************************************************************
        package data
*/
const char luti_hex[16] = {
        '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'
};

/* ************************************************************
        package functions
*/

void log_rec (
        int level, Rec *rec, const char *msg, const char *delim
) {
        Field *F;
        int ch = 2;
        if (0 > level) {
                level = -level;
                ch = 1;
        }
        if ((unsigned)level > log_lev) {
                return;
        }
        if (msg && *msg) {
                sMsg (ch, msg);
        }
        sMsg (ch, "%p", rec);
        if (rec) {
                if (! delim) {
                        delim = "; ";
                }
                sMsg (ch, " #f=%d", (int)rec->len);
                for (F = rec->field; rec->len > F - rec->field; ++F) {
                        sMsg (ch, delim);
                        sMsg (ch, "%d", (int)F->tag);
                        sMsg (ch, " %.*s", (int)F->len, F->val);
                }
        }
        sMsg (ch, "\n");
}


int lprint ( void *buf, int i )
{
        char *c = buf;
        if ( 0 > i ) {
                *c++ = '-';
                i = -i;
        }
        if ( ! i )
                *c++ = '0';
        else {
                int dig = 0, j=i;
                char *p;
                for ( ; j; j /= 10 )
                        dig++;
                p = c += dig;
                for ( ; i; i /= 10 )
                        *--p = '0' + i % 10;
        }
        *c = 0;
        return c - (char*)buf;
}       /* lprint */


int a2il ( const char *p, int l, int *res )
{
        const char *s = p;
        const char *e = p + (0<=l ? l : (int)strlen(p));
        char op = 0;
        int ret = 0;
        while ( p < e && ' ' >= (unsigned char)*p ) /* skip white */
                p++;
        if ( p < e )
                switch ( *p ) {
                case '-':
                        if ( p+1 == e ) ret = 1; /* so sole '-' is -1 */
                case '~': /* sole ~ is ~0 */
                case '+':
                        op = *p++;
                }
        if ( p < e && '0' == *p && ++p < e && 'x' == *p ) {
                while ( ++p < e ) {
                        int v = *p;
                        if ( '0' <= v && v <= '9' )
                                v -= '0';
                        else if ( 'a' <= v && v <= 'f' )
                                v -= 'a'-10;
                        else if ( 'A' <= v && v <= 'F' )
                                v -= 'A'-10;
                        else
                                break;
                        ret = (ret<<4) + v;
                }
        } else {
                while ( p < e && '0' <= *p && *p <= '9' )
                        ret = 10*ret + *p++ - '0';
        }
        if (0 != res)
                switch (op) {
                case '-': *res = -ret; break;
                case '~': *res = ~ret; break;
                default: *res = ret;
                }
        return p - s;
}       /* a2il */

int a2i ( const char *p, int l ) {
        int res;
        a2il (p, l, &res);
        return res;
}

int a2id ( const char *p, int l, int dflt ) {
        int res;
        if (0 > l) {
                l = (int) strlen (p);
        }
        if (l != a2il (p, l, &res)) {
                return dflt;
        }
        return res;
}


int i2a ( char *p, int i )
{
        if ( i ) {
                int min, dig = 0, j;
                if ( 0 < i ) 
                        min = 0;
                else {
                        min = 1;
                        *p++ = '-';
                        i = -i;
                }
                for ( j=i; j; j/=10 )
                        dig++;
                for ( *(p+=dig)=0; i; i/=10 )
                        *--p = '0' + (i % 10);
                return min+dig;
        }
        *p++ = '0';
        *p = 0;
        return 1;
}       /* i2a */


int u2a ( char *p, unsigned u )
{
        if ( u ) {
                int dig = 0, j;
                for ( j=u; j; j/=10 )
                        dig++;
                for ( *(p+=dig)=0; u; u/=10 )
                        *--p = '0' + (u % 10);
                return dig;
        }
        *p++ = '0';
        *p = 0;
        return 1;
}       /* u2a */


LutiLT luti_ltnew () {
        LutiLT res = (LutiLT) mAlloc (LT_SIZE);
        return res;
}

void luti_ltdel (LutiLT lt) {
        LutiLTNod *N;
        LutiLTEnt *E;
        if (lt) {
                for (N = lt + LT_NUM; --N >= lt;  ) {
                        if (N->arr) {
                                for (E = N->arr + N->num; --E >= N->arr;  ) {
                                        if (E->name) {
                                                mFree (E->name);
                                        }
                                }
                                mFree (N->arr);
                        }
                }
                mFree (lt);
        }
}

void luti_ltadd (LutiLT lt, const char *name, int id) {
        if (0 != lt) {
                LutiLTNod *N;
                LutiLTEnt *E;
                int idx;
                if (!name) {
                        name = "";
                }
                idx = LTIDX (name);
                N = lt + idx;
                if (N->siz == N->num) {
                        E = mAlloc ( (LT_INCR + N->siz) * sizeof (LutiLTEnt));
                        if (N->siz) {
                                memcpy (E, N->arr, N->siz * sizeof (LutiLTEnt));
                                mFree (N->arr);
                        }
                        N->arr = E;
                        N->siz += LT_INCR;
                }
                N->arr[N->num].name = mDup (name, -1);
                N->arr[N->num].id = id;
                ++N->num;
        }
}

int luti_ltget (LutiLT lt, const char *name) {
        if (0 != lt) {
                LutiLTNod *N;
                LutiLTEnt *E;
                int idx;
                if (!name) {
                        name = "";
                }
                idx = LTIDX (name);
                N = lt + idx;
                if (N->num) {
                        for (E = N->arr + N->num; --E >= N->arr; ) {
                                if (! strcmp (E->name, name)) {
                                        return E->id;
                                }
                        }
                }
        }
        return -1;
}

void luti_ltrmv (LutiLT lt, const char *name) {
        if (0 != lt) {
                LutiLTNod *N;
                LutiLTEnt *E;
                int idx;
                if (!name) {
                        name = "";
                }
                idx = LTIDX (name);
                N = lt + idx;
                if (N->num) {
                        for (E = N->arr + N->num; --E >= N->arr; ) {
                                if (! strcmp (E->name, name)) {
                                        int len = N->num - (E - N->arr) - 1;
                                        mFree (E->name);
                                        if (len) {
                                                memmove (E, E + 1, len * sizeof (LutiLTEnt));
                                        }
                                        --N->num;
                                        return;
                                }
                        }
                }
                log_msg (LOG_WARN, "luti_ltrmv: no such entry <%s>", name);
        }
}

static Rec *_unwrap ( Rec *env, int *pos, int tag, int dbid, int rdonly )
{
        Field *F;
        Rec   *rec = 0;
        int    rlen, np;
        if (! env ) {
                return 0;
        }
        if (! pos) {
                np = 0;
                pos = &np;
        }
        F = rGet (env, tag, pos);
        if (!F) {
                return 0;
        }
        rlen = a2id (F->val, (int)F->len, -1);
        if (0 > rlen) {
                sMsg (LOG_ERROR,
                        "luti_unwrap: illegal reclen %d, pos %d, tag %d",
                        rlen, *pos, F->tag);
                return 0;
        }
        ++F;
        if (env->len < *pos + rlen) {
                sMsg (LOG_ERROR,
                        "luti_unwrap: illegal reclen %d, pos %d, tag %d, env %d",
                        rlen, *pos, F->tag, env->len);
                return 0;
        }
        if (! rlen && ! rdonly) {
                OPENISIS_RSPACE (rec, 0, 0);
                if (0 == rec) {
                        return 0;
                }
        }
        while (0 <= --rlen) {
                if (! rdonly) {
                        RADD (rec, F->tag, F->val, F->len, !0);
                        if (0 == rec) {
                                return 0;
                        }
                }
                ++F;
                ++(*pos);
        }
        if (rdonly) {
                return (Rec*)1;
        }
        rec->dbid = dbid;
        return rec;
}

Rec *luti_unwrap ( Rec *env, int *pos, int tag, int dbid)
{
        return _unwrap (env, pos, tag, dbid, 0);
}

Rec* luti_append (Rec *tgt, Rec *src) {
        Field *F, *E;
        if (!src) {
                return tgt;
        }
        E = src->field + src->len;
        for (F = src->field; tgt && E > F; ++F) {
                RADD (tgt, F->tag, F->val, F->len, !0);
        }
        return tgt;
}

Rec *luti_wrap (Rec *env, Rec *rec, int tag) {
        if (!rec) {
                return env;
        }
        env = rAddI (env, tag, rec->len, !0);
        return luti_append (env, rec);
}

int luti_ptrincr (
        void *start, int *num, int incr, int siz, int maxn
) {
        char **base = (char**)start;
        char  *arr;
        int    oldn = *num;
        if (0 < maxn && oldn >= maxn) {
                return -1;
        }
        arr = mAlloc ((oldn + incr) * siz);
        if (!arr) {
                return -1;
        }
        if (oldn) {
                memcpy (arr, *base, oldn * siz);
                mFree (*base);
        }
        memset (arr + oldn * siz, 0, incr * siz);
        *num += incr;
        *base = arr;
        return oldn;
}

void luti_free (void **arr, int num) {
        if (arr) {
                while (0 <= --num) {
                        if (arr[num]) {
                                mFree (arr[num]);
                        }
                }
                mFree (arr);
        }
}

int luti_true (const char *str, int len) {
        if (! str || ! *str) {
                return -1;
        }
        if (0 > len) {
                len = strlen (str);
        }
        if (1 == len) {
                if ('0' == *str ||
                        'f' == *str ||
                        'F' == *str ||
                        'n' == *str ||
                        'N' == *str
                ) {
                        return 0;
                }
                if ('1' == *str ||
                        'y' == *str ||
                        'Y' == *str ||
                        't' == *str ||
                        'T' == *str
                ) {
                        return 1;
                }
                return -1;
        }
        if (! strncmp ("false", str, len) ||
                ! strncmp ("no", str, len)) {
                return 0;
        }
        if (! strncmp ("true", str, len) ||
                ! strncmp ("yes", str, len)) {
                return 1;
        }
        return -1;
}

/*      ------------------------------------------------------------------------
 *      unwrap by path
 */

Fdt* luti_fdt_from_rec (Rec *rec) {
        Db *dbh;
        if (rec &&
                0 <= rec->dbid &&
                (dbh = nDbById (rec->dbid))
        ) {
                return dbh->fdt;
        }
        return 0;
}

const char* luti_parse_path (
        const char *path, const Fdt *fdt, Fd **fd, int *tag, int *occ
) {
        Fd  *_f = 0;
        int  _t = -1;
        int  _o = -1;
        int  num, qsub;

        if (fd) {
                *fd = 0;
        }
        if (tag) {
                *tag = -1;
        }
        if (occ) {
                *occ = -1;
        }
        if (! path) {
                return 0;
        }

        if ('.' == *path
                || ('-' == *path && (path[1]<'0' || '9'<path[1]))
        ) {  /* path or option style */
                ++path;
        }

        num = a2il (path, -1, &_t);
        if (num) {
                if (fdt) {
                        _f = fById (fdt, _t, 0);
                }
        }
        else {
                char name[OPENISIS_FD_NAMELEN];
                if (! fdt) {
                        return 0;
                }
                for (num = 0;
                        path[num] && '[' != path[num] && '(' != path[num];
                        ++num)
                        ;
                if (num > OPENISIS_FD_NAMELEN - 1) {
                        return 0;
                }
                strncpy (name, path, num) [num] = 0;
                _f = fByName ( fdt, name );
                if (! _f) {
                        return 0;
                }
                _t = _f->id;
        }
        path += num;

        if (tag) {
                *tag = _t;
        }
        if (fd) {
                *fd = _f;
        }

        if ('[' != *path && '(' != *path) {
                return path;
        }
        qsub = *path;

        ++path;
        num = a2il (path, -1, &_o);
        if (! num || 0 > _o) {
                return 0;
        }
        path += num;
        if ((']' != *path && '[' == qsub) || (')' != *path && '(' == qsub)) {
                return 0;
        }

        if (occ) {
                *occ = _o;
        }
        return path + 1;
}

Rec* luti_getembed ( Rec *env, const char *path, const Fdt *fdt)
{
        Rec *res;
        int  tag, occ, idx, pos;
        if ( ! env || ! path || ! *path) {
                return 0;
        }
        if (! fdt) {
                fdt = luti_fdt_from_rec (env);
        }
        path = luti_parse_path (path, fdt, 0, &tag, &occ);
        if (! path) {
                return 0;
        }
        res = 0;
        idx = pos = 0;
        while (1) {
                res = _unwrap (env, &pos, tag, -1, idx < occ);
                if (! res) {
                        return 0;
                }
                if (idx >= occ) {
                        break;
                }
                ++idx;
        }
        if (*path) {
                Rec *r2 = luti_getembed (res, path, 0);
                mFree (res);
                return r2;
        }
        return res;
}


int lhash ( const char *str, int len )
{
        int h = 0;
        while ( len-- )
                h = 31*h + *str++;
        return 0<=h ? h : -h;
}


/* ************************************************************
        public functions
*/

char *toHtml ( const char *str, int len )
{
        int l;
        char *p, *e, *ret;
        if ( ! str )
                return 0;
        if ( 0 > len )
                len = strlen(str);
        l = len + 1;
        for ( e = (p=(char*)str) + len; p<e; p++ )
                switch ( *p ) {
                case '<': case '>': l += 3; break;
                case '&': l += 4; break;
                case '"': l += 5; break;
                /* do not replace ' w/ &apos; -- many clients don't grok it */
                }
        ret = mAlloc( l );
        if ( ! ret )
                return 0;
        for ( p=ret; str<e; str++ )
                switch ( *str ) {
                case '<': *p='&'; p[1]='l'; p[2]='t'; p[3]=';'; p+=4; break;
                case '>': *p='&'; p[1]='g'; p[2]='t'; p[3]=';'; p+=4; break;
                case '&': *p='&'; p[1]='a'; p[2]='m'; p[3]='p'; p[4]=';'; p+=5; break;
                case '"': *p='&';p[1]='q';p[2]='u';p[3]='o';p[4]='t';p[5]=';';p+=6;break;
                default: *p++ = *str;
                }
        *p = 0;
        return ret;
}       /* toHtml */


int utf8Chk ( void *mem, int len, int *tof )
{
        unsigned char *c = (unsigned char *)mem;
        int f = 0; /* expected followers */
        int l = len;
        if ( tof )
                f = *tof;
        for ( ; l--; c++ ) {
                unsigned char u = *c;
                int tofollow = u < 128 ? 0 : u < 192 ? -1 : u < 224 ? 1 : 2;
                if ( f ) {
                        if ( 0 > tofollow ) { f--; continue; }
                        break;
                }
                if ( 0 <= tofollow ) { f = tofollow; continue; }
                goto croak;
        }
        if ( tof )
                *tof = f;
        if ( ! f )
                return 0;
        if ( 0 > l && tof ) /* exhausted buf, want follower */
                return 0;
        sMsg( LOG_ERROR, "expected follower at %d got %x", len-l-1, (int)*c );
        return len-l;
croak:
        sMsg( LOG_ERROR, "expected no follower at %d got %x", len-l-1, (int)*c );
        return len-l;
}       /* utf8Chk */
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: luti.c,v 1.48 2003/06/23 14:47:35 kripke Exp $
25			utilities
26			*/
27
28			#include <string.h> /* strlen */
29
30			#include "openisis.h"
31			#include "luti.h"
32
33
34			/* ************************************************************
35			private types
36			*/
37
38			typedef struct {
39			char *name;
40			int id;
41			} LutiLTEnt;
42
43			typedef struct OpenIsisLT {
44			LutiLTEnt *arr;
45			int siz; /* malloc'ed */
46			int num; /* used */
47			} LutiLTNod;
48
49			#define LT_NUM 27
50			#define LT_SIZE (LT_NUM * sizeof (LutiLTNod))
51
52			#define LTIDX(name) ( \
53			('a' <= (name) && 'z' >= (name)) ? *(name) - 'a' : ( \
54			('A' <= (name) && 'Z' >= (name)) ? *(name) - 'A' : 26 \
55			))
56
57			#define LT_INCR 2
58
59			/* ************************************************************
60			private data
61			*/
62
63
64
65			/* ************************************************************
66			private functions
67			*/
68
69
70			/* ************************************************************
71			package data
72			*/
73			const char luti_hex[16] = {
74			'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'
75			};
76
77			/* ************************************************************
78			package functions
79			*/
80
81			void log_rec (
82			int level, Rec rec, const char msg, const char *delim
83			) {
84			Field *F;
85			int ch = 2;
86			if (0 > level) {
87			level = -level;
88			ch = 1;
89			}
90			if ((unsigned)level > log_lev) {
91			return;
92			}
93			if (msg && *msg) {
94			sMsg (ch, msg);
95			}
96			sMsg (ch, "%p", rec);
97			if (rec) {
98			if (! delim) {
99			delim = "; ";
100			}
101			sMsg (ch, " #f=%d", (int)rec->len);
102			for (F = rec->field; rec->len > F - rec->field; ++F) {
103			sMsg (ch, delim);
104			sMsg (ch, "%d", (int)F->tag);
105			sMsg (ch, " %.*s", (int)F->len, F->val);
106			}
107			}
108			sMsg (ch, "\n");
109			}
110
111
112			int lprint ( void *buf, int i )
113			{
114			char *c = buf;
115			if ( 0 > i ) {
116			*c++ = '-';
117			i = -i;
118			}
119			if ( ! i )
120			*c++ = '0';
121			else {
122			int dig = 0, j=i;
123			char *p;
124			for ( ; j; j /= 10 )
125			dig++;
126			p = c += dig;
127			for ( ; i; i /= 10 )
128			*--p = '0' + i % 10;
129			}
130			*c = 0;
131			return c - (char*)buf;
132			} /* lprint */
133
134
135			int a2il ( const char p, int l, int res )
136			{
137			const char *s = p;
138			const char *e = p + (0<=l ? l : (int)strlen(p));
139			char op = 0;
140			int ret = 0;
141			while ( p < e && ' ' >= (unsigned char)p ) / skip white */
142			p++;
143			if ( p < e )
144			switch ( *p ) {
145			case '-':
146			if ( p+1 == e ) ret = 1; /* so sole '-' is -1 */
147			case '~': /* sole ~ is ~0 */
148			case '+':
149			op = *p++;
150			}
151			if ( p < e && '0' == p && ++p < e && 'x' == p ) {
152			while ( ++p < e ) {
153			int v = *p;
154			if ( '0' <= v && v <= '9' )
155			v -= '0';
156			else if ( 'a' <= v && v <= 'f' )
157			v -= 'a'-10;
158			else if ( 'A' <= v && v <= 'F' )
159			v -= 'A'-10;
160			else
161			break;
162			ret = (ret<<4) + v;
163			}
164			} else {
165			while ( p < e && '0' <= p && p <= '9' )
166			ret = 10ret + p++ - '0';
167			}
168			if (0 != res)
169			switch (op) {
170			case '-': *res = -ret; break;
171			case '~': *res = ~ret; break;
172			default: *res = ret;
173			}
174			return p - s;
175			} /* a2il */
176
177			int a2i ( const char *p, int l ) {
178			int res;
179			a2il (p, l, &res);
180			return res;
181			}
182
183			int a2id ( const char *p, int l, int dflt ) {
184			int res;
185			if (0 > l) {
186			l = (int) strlen (p);
187			}
188			if (l != a2il (p, l, &res)) {
189			return dflt;
190			}
191			return res;
192			}
193
194
195			int i2a ( char *p, int i )
196			{
197			if ( i ) {
198			int min, dig = 0, j;
199			if ( 0 < i )
200			min = 0;
201			else {
202			min = 1;
203			*p++ = '-';
204			i = -i;
205			}
206			for ( j=i; j; j/=10 )
207			dig++;
208			for ( *(p+=dig)=0; i; i/=10 )
209			*--p = '0' + (i % 10);
210			return min+dig;
211			}
212			*p++ = '0';
213			*p = 0;
214			return 1;
215			} /* i2a */
216
217
218			int u2a ( char *p, unsigned u )
219			{
220			if ( u ) {
221			int dig = 0, j;
222			for ( j=u; j; j/=10 )
223			dig++;
224			for ( *(p+=dig)=0; u; u/=10 )
225			*--p = '0' + (u % 10);
226			return dig;
227			}
228			*p++ = '0';
229			*p = 0;
230			return 1;
231			} /* u2a */
232
233
234			LutiLT luti_ltnew () {
235			LutiLT res = (LutiLT) mAlloc (LT_SIZE);
236			return res;
237			}
238
239			void luti_ltdel (LutiLT lt) {
240			LutiLTNod *N;
241			LutiLTEnt *E;
242			if (lt) {
243			for (N = lt + LT_NUM; --N >= lt; ) {
244			if (N->arr) {
245			for (E = N->arr + N->num; --E >= N->arr; ) {
246			if (E->name) {
247			mFree (E->name);
248			}
249			}
250			mFree (N->arr);
251			}
252			}
253			mFree (lt);
254			}
255			}
256
257			void luti_ltadd (LutiLT lt, const char *name, int id) {
258			if (0 != lt) {
259			LutiLTNod *N;
260			LutiLTEnt *E;
261			int idx;
262			if (!name) {
263			name = "";
264			}
265			idx = LTIDX (name);
266			N = lt + idx;
267			if (N->siz == N->num) {
268			E = mAlloc ( (LT_INCR + N->siz) * sizeof (LutiLTEnt));
269			if (N->siz) {
270			memcpy (E, N->arr, N->siz * sizeof (LutiLTEnt));
271			mFree (N->arr);
272			}
273			N->arr = E;
274			N->siz += LT_INCR;
275			}
276			N->arr[N->num].name = mDup (name, -1);
277			N->arr[N->num].id = id;
278			++N->num;
279			}
280			}
281
282			int luti_ltget (LutiLT lt, const char *name) {
283			if (0 != lt) {
284			LutiLTNod *N;
285			LutiLTEnt *E;
286			int idx;
287			if (!name) {
288			name = "";
289			}
290			idx = LTIDX (name);
291			N = lt + idx;
292			if (N->num) {
293			for (E = N->arr + N->num; --E >= N->arr; ) {
294			if (! strcmp (E->name, name)) {
295			return E->id;
296			}
297			}
298			}
299			}
300			return -1;
301			}
302
303			void luti_ltrmv (LutiLT lt, const char *name) {
304			if (0 != lt) {
305			LutiLTNod *N;
306			LutiLTEnt *E;
307			int idx;
308			if (!name) {
309			name = "";
310			}
311			idx = LTIDX (name);
312			N = lt + idx;
313			if (N->num) {
314			for (E = N->arr + N->num; --E >= N->arr; ) {
315			if (! strcmp (E->name, name)) {
316			int len = N->num - (E - N->arr) - 1;
317			mFree (E->name);
318			if (len) {
319			memmove (E, E + 1, len * sizeof (LutiLTEnt));
320			}
321			--N->num;
322			return;
323			}
324			}
325			}
326			log_msg (LOG_WARN, "luti_ltrmv: no such entry <%s>", name);
327			}
328			}
329
330			static Rec _unwrap ( Rec env, int *pos, int tag, int dbid, int rdonly )
331			{
332			Field *F;
333			Rec *rec = 0;
334			int rlen, np;
335			if (! env ) {
336			return 0;
337			}
338			if (! pos) {
339			np = 0;
340			pos = &np;
341			}
342			F = rGet (env, tag, pos);
343			if (!F) {
344			return 0;
345			}
346			rlen = a2id (F->val, (int)F->len, -1);
347			if (0 > rlen) {
348			sMsg (LOG_ERROR,
349			"luti_unwrap: illegal reclen %d, pos %d, tag %d",
350			rlen, *pos, F->tag);
351			return 0;
352			}
353			++F;
354			if (env->len < *pos + rlen) {
355			sMsg (LOG_ERROR,
356			"luti_unwrap: illegal reclen %d, pos %d, tag %d, env %d",
357			rlen, *pos, F->tag, env->len);
358			return 0;
359			}
360			if (! rlen && ! rdonly) {
361			OPENISIS_RSPACE (rec, 0, 0);
362			if (0 == rec) {
363			return 0;
364			}
365			}
366			while (0 <= --rlen) {
367			if (! rdonly) {
368			RADD (rec, F->tag, F->val, F->len, !0);
369			if (0 == rec) {
370			return 0;
371			}
372			}
373			++F;
374			++(*pos);
375			}
376			if (rdonly) {
377			return (Rec*)1;
378			}
379			rec->dbid = dbid;
380			return rec;
381			}
382
383			Rec luti_unwrap ( Rec env, int *pos, int tag, int dbid)
384			{
385			return _unwrap (env, pos, tag, dbid, 0);
386			}
387
388			Rec* luti_append (Rec tgt, Rec src) {
389			Field F, E;
390			if (!src) {
391			return tgt;
392			}
393			E = src->field + src->len;
394			for (F = src->field; tgt && E > F; ++F) {
395			RADD (tgt, F->tag, F->val, F->len, !0);
396			}
397			return tgt;
398			}
399
400			Rec luti_wrap (Rec env, Rec *rec, int tag) {
401			if (!rec) {
402			return env;
403			}
404			env = rAddI (env, tag, rec->len, !0);
405			return luti_append (env, rec);
406			}
407
408			int luti_ptrincr (
409			void start, int num, int incr, int siz, int maxn
410			) {
411			char base = (char)start;
412			char *arr;
413			int oldn = *num;
414			if (0 < maxn && oldn >= maxn) {
415			return -1;
416			}
417			arr = mAlloc ((oldn + incr) * siz);
418			if (!arr) {
419			return -1;
420			}
421			if (oldn) {
422			memcpy (arr, base, oldn siz);
423			mFree (*base);
424			}
425			memset (arr + oldn * siz, 0, incr * siz);
426			*num += incr;
427			*base = arr;
428			return oldn;
429			}
430
431			void luti_free (void **arr, int num) {
432			if (arr) {
433			while (0 <= --num) {
434			if (arr[num]) {
435			mFree (arr[num]);
436			}
437			}
438			mFree (arr);
439			}
440			}
441
442			int luti_true (const char *str, int len) {
443			if (! str \|\| ! *str) {
444			return -1;
445			}
446			if (0 > len) {
447			len = strlen (str);
448			}
449			if (1 == len) {
450			if ('0' == *str \|\|
451			'f' == *str \|\|
452			'F' == *str \|\|
453			'n' == *str \|\|
454			'N' == *str
455			) {
456			return 0;
457			}
458			if ('1' == *str \|\|
459			'y' == *str \|\|
460			'Y' == *str \|\|
461			't' == *str \|\|
462			'T' == *str
463			) {
464			return 1;
465			}
466			return -1;
467			}
468			if (! strncmp ("false", str, len) \|\|
469			! strncmp ("no", str, len)) {
470			return 0;
471			}
472			if (! strncmp ("true", str, len) \|\|
473			! strncmp ("yes", str, len)) {
474			return 1;
475			}
476			return -1;
477			}
478
479			/* ------------------------------------------------------------------------
480			* unwrap by path
481			*/
482
483			Fdt* luti_fdt_from_rec (Rec *rec) {
484			Db *dbh;
485			if (rec &&
486			0 <= rec->dbid &&
487			(dbh = nDbById (rec->dbid))
488			) {
489			return dbh->fdt;
490			}
491			return 0;
492			}
493
494			const char* luti_parse_path (
495			const char path, const Fdt fdt, Fd *fd, int tag, int *occ
496			) {
497			Fd *_f = 0;
498			int _t = -1;
499			int _o = -1;
500			int num, qsub;
501
502			if (fd) {
503			*fd = 0;
504			}
505			if (tag) {
506			*tag = -1;
507			}
508			if (occ) {
509			*occ = -1;
510			}
511			if (! path) {
512			return 0;
513			}
514
515			if ('.' == *path
516			\|\| ('-' == *path && (path[1]<'0' \|\| '9'<path[1]))
517			) { /* path or option style */
518			++path;
519			}
520
521			num = a2il (path, -1, &_t);
522			if (num) {
523			if (fdt) {
524			_f = fById (fdt, _t, 0);
525			}
526			}
527			else {
528			char name[OPENISIS_FD_NAMELEN];
529			if (! fdt) {
530			return 0;
531			}
532			for (num = 0;
533			path[num] && '[' != path[num] && '(' != path[num];
534			++num)
535			;
536			if (num > OPENISIS_FD_NAMELEN - 1) {
537			return 0;
538			}
539			strncpy (name, path, num) [num] = 0;
540			_f = fByName ( fdt, name );
541			if (! _f) {
542			return 0;
543			}
544			_t = _f->id;
545			}
546			path += num;
547
548			if (tag) {
549			*tag = _t;
550			}
551			if (fd) {
552			*fd = _f;
553			}
554
555			if ('[' != path && '(' != path) {
556			return path;
557			}
558			qsub = *path;
559
560			++path;
561			num = a2il (path, -1, &_o);
562			if (! num \|\| 0 > _o) {
563			return 0;
564			}
565			path += num;
566			if ((']' != path && '[' == qsub) \|\| (')' != path && '(' == qsub)) {
567			return 0;
568			}
569
570			if (occ) {
571			*occ = _o;
572			}
573			return path + 1;
574			}
575
576			Rec* luti_getembed ( Rec env, const char path, const Fdt *fdt)
577			{
578			Rec *res;
579			int tag, occ, idx, pos;
580			if ( ! env \|\| ! path \|\| ! *path) {
581			return 0;
582			}
583			if (! fdt) {
584			fdt = luti_fdt_from_rec (env);
585			}
586			path = luti_parse_path (path, fdt, 0, &tag, &occ);
587			if (! path) {
588			return 0;
589			}
590			res = 0;
591			idx = pos = 0;
592			while (1) {
593			res = _unwrap (env, &pos, tag, -1, idx < occ);
594			if (! res) {
595			return 0;
596			}
597			if (idx >= occ) {
598			break;
599			}
600			++idx;
601			}
602			if (*path) {
603			Rec *r2 = luti_getembed (res, path, 0);
604			mFree (res);
605			return r2;
606			}
607			return res;
608			}
609
610
611			int lhash ( const char *str, int len )
612			{
613			int h = 0;
614			while ( len-- )
615			h = 31h + str++;
616			return 0<=h ? h : -h;
617			}
618
619
620			/* ************************************************************
621			public functions
622			*/
623
624			char toHtml ( const char str, int len )
625			{
626			int l;
627			char p, e, *ret;
628			if ( ! str )
629			return 0;
630			if ( 0 > len )
631			len = strlen(str);
632			l = len + 1;
633			for ( e = (p=(char*)str) + len; p<e; p++ )
634			switch ( *p ) {
635			case '<': case '>': l += 3; break;
636			case '&': l += 4; break;
637			case '"': l += 5; break;
638			/* do not replace ' w/ ' -- many clients don't grok it */
639			}
640			ret = mAlloc( l );
641			if ( ! ret )
642			return 0;
643			for ( p=ret; str<e; str++ )
644			switch ( *str ) {
645			case '<': *p='&'; p[1]='l'; p[2]='t'; p[3]=';'; p+=4; break;
646			case '>': *p='&'; p[1]='g'; p[2]='t'; p[3]=';'; p+=4; break;
647			case '&': *p='&'; p[1]='a'; p[2]='m'; p[3]='p'; p[4]=';'; p+=5; break;
648			case '"': *p='&';p[1]='q';p[2]='u';p[3]='o';p[4]='t';p[5]=';';p+=6;break;
649			default: p++ = str;
650			}
651			*p = 0;
652			return ret;
653			} /* toHtml */
654
655
656			int utf8Chk ( void mem, int len, int tof )
657			{
658			unsigned char c = (unsigned char )mem;
659			int f = 0; /* expected followers */
660			int l = len;
661			if ( tof )
662			f = *tof;
663			for ( ; l--; c++ ) {
664			unsigned char u = *c;
665			int tofollow = u < 128 ? 0 : u < 192 ? -1 : u < 224 ? 1 : 2;
666			if ( f ) {
667			if ( 0 > tofollow ) { f--; continue; }
668			break;
669			}
670			if ( 0 <= tofollow ) { f = tofollow; continue; }
671			goto croak;
672			}
673			if ( tof )
674			*tof = f;
675			if ( ! f )
676			return 0;
677			if ( 0 > l && tof ) /* exhausted buf, want follower */
678			return 0;
679			sMsg( LOG_ERROR, "expected follower at %d got %x", len-l-1, (int)*c );
680			return len-l;
681			croak:
682			sMsg( LOG_ERROR, "expected no follower at %d got %x", len-l-1, (int)*c );
683			return len-l;
684			} /* utf8Chk */