X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=fml%2Ffmlmem.c;h=e4bec8136de70f8f7517773aff1a2241fc0a2cd8;hb=e1ec9d39463f431383547891f38e30f2ff17842c;hp=4bc4c5668b5e9bb8da3f877ce5fac72f9561c996;hpb=345de2254e0c2f8c5f40951d0509e8f5ddbc11a9;p=egate.git diff --git a/fml/fmlmem.c b/fml/fmlmem.c index 4bc4c56..e4bec81 100644 --- a/fml/fmlmem.c +++ b/fml/fmlmem.c @@ -1,9 +1,89 @@ /* + * Copyright (c) 1995, the EUROPAGATE consortium (see below). + * + * The EUROPAGATE consortium members are: + * + * University College Dublin + * Danmarks Teknologiske Videnscenter + * An Chomhairle Leabharlanna + * Consejo Superior de Investigaciones Cientificas + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation, in whole or in part, for any purpose, is hereby granted, + * provided that: + * + * 1. This copyright and permission notice appear in all copies of the + * software and its documentation. Notices of copyright or attribution + * which appear at the beginning of any file must remain unchanged. + * + * 2. The names of EUROPAGATE or the project partners may not be used to + * endorse or promote products derived from this software without specific + * prior written permission. + * + * 3. Users of this software (implementors and gateway operators) agree to + * inform the EUROPAGATE consortium of their use of the software. This + * information will be used to evaluate the EUROPAGATE project and the + * software, and to plan further developments. The consortium may use + * the information in later publications. + * + * 4. Users of this software agree to make their best efforts, when + * documenting their use of the software, to acknowledge the EUROPAGATE + * consortium, and the role played by the software in their work. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND, + * EXPRESS, IMPLIED, OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY + * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. + * IN NO EVENT SHALL THE EUROPAGATE CONSORTIUM OR ITS MEMBERS BE LIABLE + * FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF + * ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA + * OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND + * ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE + * USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ +/* * FML interpreter. Europagate, 1995 * * $Log: fmlmem.c,v $ - * Revision 1.1 1995/02/06 13:48:09 adam - * Initial revision + * Revision 1.12 1995/05/16 09:39:34 adam + * LICENSE. + * + * Revision 1.11 1995/03/02 10:18:48 adam + * Bug fix. + * + * Revision 1.10 1995/03/02 08:06:03 adam + * Fml function strsub implemented. New test files marc[45].fml. + * New test options in fmltest. + * + * Revision 1.9 1995/02/27 09:01:20 adam + * Regular expression support. Argument passing by name option. New FML + * function strlen. + * + * Revision 1.8 1995/02/23 08:32:05 adam + * Changed header. + * + * Revision 1.6 1995/02/10 18:15:52 adam + * FML function 'strcmp' implemented. This function can be used to + * test for existence of MARC fields. + * + * Revision 1.5 1995/02/09 14:37:18 adam + * Removed .depend from cvs. Removed function fml_mk_list. + * + * Revision 1.4 1995/02/09 14:33:37 adam + * Split source fml.c and define relevant build-in functions in separate + * files. New operators mult, div, not, llen implemented. + * + * Revision 1.3 1995/02/09 13:07:15 adam + * Nodes are freed now. Many bugs fixed. + * + * Revision 1.2 1995/02/06 15:23:26 adam + * Added some more relational operators (le,ne,ge). Added increment + * and decrement operators. Function index changed, so that first + * element is 1 - not 0. Function fml_atom_val edited. + * + * Revision 1.1.1.1 1995/02/06 13:48:10 adam + * First version of the FML interpreter. It's slow and memory isn't + * freed properly. In particular, the FML nodes aren't released yet. * */ #include @@ -16,6 +96,9 @@ #define FML_ATOM_CHUNK 1024 #define FML_NODE_CHUNK 1024 +static int no_nodes = 0; +static int no_atoms = 0; + struct fml_node *fml_node_alloc (Fml fml) { struct fml_node *n; @@ -38,6 +121,7 @@ struct fml_node *fml_node_alloc (Fml fml) fml->node_free_list = n->p[1]; n->p[0] = n->p[1] = NULL; n->is_atom = 0; + no_nodes++; return n; } @@ -61,6 +145,7 @@ static struct fml_atom *atom_malloc (Fml fml) } fa = fml->atom_free_list; fml->atom_free_list = fa->next; + no_atoms++; return fa; } @@ -68,6 +153,7 @@ static void atom_delete (Fml fml, struct fml_atom *a) { a->next = fml->atom_free_list; fml->atom_free_list = a; + no_atoms--; } static struct fml_atom *atom_copy (Fml fml, struct fml_atom *a) @@ -77,7 +163,7 @@ static struct fml_atom *atom_copy (Fml fml, struct fml_atom *a) a0 = a1 = atom_malloc (fml); while (a) { - memcpy (&a1->buf, &a->buf, FML_ATOM_CHUNK); + memcpy (&a1->buf, &a->buf, FML_ATOM_BUF); if (!a->next) break; a = a->next; @@ -108,24 +194,27 @@ struct fml_atom *fml_atom_alloc (Fml fml, char *str) return a0; } -struct fml_node *fml_mk_list (Fml fml, struct fml_node *fn) +int fml_atom_cmp (Fml fml, struct fml_atom *a1, struct fml_atom *a2) { - if (fn->is_atom) + while (a1 && a2) { - struct fml_node *fn2; - - fn2 = fml_node_alloc (fml); - fn2->is_atom = 1; - fn2->p[0] = fn->p[0]; - return fn2; + int n; + n = strncmp (a1->buf, a2->buf, FML_ATOM_BUF); + if (n) + return n; + a1 = a1->next; + a2 = a2->next; } - else - return fn->p[0]; + if (!a1 && !a2) + return 0; + if (a1) + return 1; + return -1; } int fml_atom_str (struct fml_atom *a, char *str) { - int len = 0; + int i, len = 0; assert (a); while (a->next) @@ -135,9 +224,14 @@ int fml_atom_str (struct fml_atom *a, char *str) len += FML_ATOM_BUF; a = a->next; } + for (i=0; ibuf[i]; i++) + ; if (str) - strcpy (str+len, a->buf); - len += strlen(str+len); + { + memcpy (str+len, a->buf, i); + str[len+i] = 0; + } + len += i; return len; } @@ -156,10 +250,41 @@ void fml_atom_strx (struct fml_atom *a, char *str, int max) str[len+FML_ATOM_BUF-1] = '\0'; } +int fml_atom_len (struct fml_atom *a) +{ + int len = 0; + if (a) + { + while (a->next) + { + len += FML_ATOM_BUF; + a = a->next; + } + len += strlen (a->buf); + } + return len; +} + int fml_atom_val (struct fml_atom *a) { + static char arg[256]; assert (a); - return atoi (a->buf); + if (!a->next) + return atoi (a->buf); + fml_atom_strx (a, arg, 200); + return atoi (arg); +} + +struct fml_node *fml_mk_node_val (Fml fml, int val) +{ + static char arg[64]; + struct fml_node *fn; + + sprintf (arg, "%d", val); + fn = fml_node_alloc (fml); + fn->is_atom = 1; + fn->p[0] = fml_atom_alloc (fml, arg); + return fn; } void fml_node_delete (Fml fml, struct fml_node *fn) @@ -175,6 +300,7 @@ void fml_node_delete (Fml fml, struct fml_node *fn) fn->p[1] = fml->node_free_list; fml->node_free_list = fn; + no_nodes--; fn = f1; } @@ -203,3 +329,32 @@ struct fml_node *fml_node_copy (Fml fml, struct fml_node *fn) } return fn0; } + +void fml_node_stat (Fml fml) +{ + if (fml->debug & 2) + printf ("<>", no_nodes, no_atoms); +} + +struct fml_atom *fml_atom_strsub (Fml fml, struct fml_atom *a, int o, int l) +{ + static char buf[512]; + char *cp; + struct fml_atom *an; + int ol = fml_atom_len (a); + + if (ol >= 510) + { + cp = malloc (ol + 1); + assert (cp); + } + else + cp = buf; + fml_atom_str (a, buf); + if (o + l < ol) + buf[o+l] = '\0'; + an = fml_atom_alloc (fml, buf+o); + if (ol >= 510) + free (cp); + return an; +}