From 3888e88cde70f36851544ab7acc04e0943470ec6 Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Fri, 11 Oct 1996 15:00:23 +0000 Subject: [PATCH] CCL parser from Europagate Email gateway 1.0. --- ccl/LICENSE | 43 ++++++ ccl/Makefile | 33 +++-- ccl/bib1 | 79 +++++++++- ccl/cclerrms.c | 62 +++++++- ccl/cclfind.c | 446 +++++++++++++++++++++++++++++++++++++++++--------------- ccl/cclptree.c | 54 ++++++- ccl/cclqfile.c | 180 +++++++++++++++++++++++ ccl/cclqual.c | 206 ++++++++++++++------------ ccl/cclsh.c | 58 +++++++- ccl/cclstr.c | 110 ++++++++++++++ ccl/ccltoken.c | 220 +++++++++++++++++++++++----- include/ccl.h | 121 +++++++++++++-- 12 files changed, 1321 insertions(+), 291 deletions(-) create mode 100644 ccl/LICENSE create mode 100644 ccl/cclqfile.c create mode 100644 ccl/cclstr.c diff --git a/ccl/LICENSE b/ccl/LICENSE new file mode 100644 index 0000000..13c4ac3 --- /dev/null +++ b/ccl/LICENSE @@ -0,0 +1,43 @@ +/* + * Copyright (c) 1995-1996, 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. + * + */ diff --git a/ccl/Makefile b/ccl/Makefile index ecdefc8..8f8e89c 100644 --- a/ccl/Makefile +++ b/ccl/Makefile @@ -2,20 +2,22 @@ # Europagate, 1995 # # $Log: Makefile,v $ -# Revision 1.5 1996-05-22 08:35:40 adam -# Removed CFLAGS definiton. +# Revision 1.6 1996-10-11 15:00:24 adam +# CCL parser from Europagate Email gateway 1.0. # -# Revision 1.4 1995/06/25 10:53:43 quinn -# Smallish adjustments. +# Revision 1.12 1996/05/22 08:37:13 adam +# Removed CFLAGS definition. # -# Revision 1.3 1995/05/30 10:25:45 quinn -# Fixed dependency control +# Revision 1.11 1995/11/10 10:19:10 adam +# cclsh now build on 'make all'. # -# Revision 1.2 1995/04/17 09:37:36 quinn -# *** empty log message *** +# Revision 1.10 1995/05/11 14:03:56 adam +# Changes in the reading of qualifier(s). New function: ccl_qual_fitem. +# New variable ccl_case_sensitive, which controls whether reserved +# words and field names are case sensitive or not. # -# Revision 1.1 1995/04/10 10:28:16 quinn -# Added copy of CCL. +# Revision 1.9 1995/04/17 09:31:34 adam +# Improved handling of qualifiers. Aliases or reserved words. # # Revision 1.8 1995/04/10 10:22:35 quinn # Added ccl directory. @@ -42,10 +44,9 @@ SHELL=/bin/sh INCLUDE=-I../include TPROG1=cclsh LIB=../lib/ccl.a -PO=cclfind.o ccltoken.o cclerrms.o cclqual.o cclptree.o +PO=cclfind.o ccltoken.o cclerrms.o cclqual.o cclptree.o cclqfile.o cclstr.o CPP=$(CC) -E DEFS=$(INCLUDE) -RANLIB=ranlib all: $(LIB) @@ -55,7 +56,7 @@ $(TPROG1): $(TPROG1).o $(LIB) $(LIB): $(PO) rm -f $(LIB) ar qc $(LIB) $(PO) - $(RANLIB) $(LIB) + ranlib $(LIB) .c.o: $(CC) -c $(DEFS) $(CFLAGS) $< @@ -66,10 +67,14 @@ clean: depend: depend2 depend1: + sed '/^#Depend/q' Makefile.tmp + $(CPP) $(DEFS) -M *.c >>Makefile.tmp + mv -f Makefile.tmp Makefile depend2: - $(CPP) $(INCLUDE) -M *.c >.depend + $(CPP) $(DEFS) -M *.c >.depend +#GNU make style depend ifeq (.depend,$(wildcard .depend)) include .depend endif diff --git a/ccl/bib1 b/ccl/bib1 index 914e0e2..864931a 100644 --- a/ccl/bib1 +++ b/ccl/bib1 @@ -1,6 +1,28 @@ -# $Id: bib1,v 1.1 1995-04-10 10:28:17 quinn Exp $ +# $Id: bib1,v 1.2 1996-10-11 15:00:24 adam Exp $ # CCL qualifiers and their mapping to a bib-1 subset # +# Each line takes the form: +# name =,.. = ... +# Where type is one of: +# u use-attribute +# r relation-attribute ) +# p position-attribute +# s structure-attribute +# t truncation-attribute +# c completeness-attribute +# +# Special value for relation: +# o ordered. Tells the CCL parser to convert a ccl relation +# to a bib-1 relation (1,2,..6). +# Special value for structure: +# pw phrase/word. The CCL parser will decide whether phrase or word +# is needed. Phrase is used if term contain blanks; otherwise +# Word is used. +# Special value for truncation: +# l Allow left truncation if ? is at left side of term. +# r Allow right truncation if ? is at left side of term. +# b Allow left&right truncation if ? is at left&right side of term. +# n Set truncation explicitly to "none" if no ? is given. term s=pw t=l,r au u=1 s=pw ti u=4 s=pw @@ -8,10 +30,63 @@ isbn u=7 issn u=8 cc u=20 su u=21 s=pw -date u=30 r=o +date u=30 r=o s=pw dp u=31 r=o da u=32 r=o la u=54 s=pw ab u=62 s=pw note u=63 s=pw af u=1006 s=pw +rel s=9 +cln + +# Relation Attributes +rel:lt r=1 +rel:le r=2 +rel:eq r=3 +rel:ge r=4 +rel:gt r=5 +rel:ne r=6 +rel:phon r=100 +rel:stem r=101 +rel:rele r=102 +rel:alwa r=103 + +# Position Attributes +pos:ff p=1 +pos:fs p=2 +pos:af p=3 + +# Structure Attributes +str:wp s=pw +str:phrase s=1 +str:word s=2 +str:key s=3 +str:year s=4 +str:date s=5 +str:wlist s=6 +str:dateu s=100 +str:daten s=101 +str:nameu s=102 +str:struc s=103 +str:urx s=104 +str:fft s=105 +str:dt s=106 +str:ln s=107 +str:str s=108 +str:num s=109 + +# Truncation Attributes +tru:right t=1 +tru:left t=2 +tru:both t=3 +tru:none t=100 +tru:proh t=101 +tru:re1 t=102 +tru:re2 t=103 + +# Completeness Attributes +com:is c=1 +com:cs c=2 +com:cf c=3 + diff --git a/ccl/cclerrms.c b/ccl/cclerrms.c index 86a53be..d40acf8 100644 --- a/ccl/cclerrms.c +++ b/ccl/cclerrms.c @@ -1,15 +1,58 @@ /* + * 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. + * + */ +/* * Europagate, 1995 * * $Log: cclerrms.c,v $ - * Revision 1.3 1995-09-29 17:11:59 quinn - * Smallish + * Revision 1.4 1996-10-11 15:00:24 adam + * CCL parser from Europagate Email gateway 1.0. * - * Revision 1.2 1995/09/27 15:02:43 quinn - * Modified function heads & prototypes. + * Revision 1.8 1995/05/16 09:39:25 adam + * LICENSE. * - * Revision 1.1 1995/04/10 10:28:18 quinn - * Added copy of CCL. + * Revision 1.7 1995/04/17 09:31:40 adam + * Improved handling of qualifiers. Aliases or reserved words. * * Revision 1.6 1995/02/23 08:31:59 adam * Changed header. @@ -28,8 +71,6 @@ * */ -#include - char *err_msg_array[] = { "Ok", "Search word expected", @@ -46,6 +87,11 @@ char *err_msg_array[] = { "Right truncation not supported" }; +/* + * ccl_err_msg: return name of CCL error + * ccl_errno: Error no. + * return: Name of error. + */ const char *ccl_err_msg (int ccl_errno) { return err_msg_array[ccl_errno]; diff --git a/ccl/cclfind.c b/ccl/cclfind.c index 6fe807b..efd807b 100644 --- a/ccl/cclfind.c +++ b/ccl/cclfind.c @@ -1,18 +1,65 @@ +/* + * 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. + * + */ /* CCL find (to rpn conversion) * Europagate, 1995 * * $Log: cclfind.c,v $ - * Revision 1.4 1995-11-01 13:54:20 quinn - * Minor adjustments + * Revision 1.5 1996-10-11 15:00:24 adam + * CCL parser from Europagate Email gateway 1.0. * - * Revision 1.3 1995/09/29 17:11:59 quinn - * Smallish + * Revision 1.16 1996/01/08 08:41:13 adam + * Removed unused function. * - * Revision 1.2 1995/09/27 15:02:44 quinn - * Modified function heads & prototypes. + * Revision 1.15 1995/07/20 08:14:34 adam + * Qualifiers were observed too often. Instead tokens are treated as + * qualifiers only when separated by comma. * - * Revision 1.1 1995/04/10 10:28:19 quinn - * Added copy of CCL. + * Revision 1.14 1995/05/16 09:39:26 adam + * LICENSE. + * + * Revision 1.13 1995/04/17 09:31:42 adam + * Improved handling of qualifiers. Aliases or reserved words. * * Revision 1.12 1995/03/20 15:27:43 adam * Minor changes. @@ -58,36 +105,51 @@ #include +/* current lookahead token */ static struct ccl_token *look_token; + +/* holds error no if error occur */ static int ccl_error; + +/* current bibset */ static CCL_bibset bibset; +/* returns type of current lookahead */ #define KIND (look_token->kind) + +/* move one token forward */ #define ADVANCE look_token = look_token->next -#define ADVX(x) x=(x)->next -static struct ccl_rpn_attr *qual_val (struct ccl_rpn_attr *list, int type) +/* + * qual_val_type: test for existance of attribute type/value pair. + * qa: Attribute array + * type: Type of attribute to search for + * value: Value of attribute to seach for + * return: 1 if found; 0 otherwise. + */ +static int qual_val_type (struct ccl_rpn_attr **qa, int type, int value) { - while (list) - { - if (list->type == type) - return list; - list = list->next; - } - return NULL; -} + int i; + struct ccl_rpn_attr *q; -static int qual_val_type (struct ccl_rpn_attr *list, int type, int value) -{ - while (list) - { - if (list->type == type && list->value == value) - return 1; - list = list->next; - } + if (!qa) + return 0; + for (i = 0; (q=qa[i]); i++) + while (q) + { + if (q->type == type && q->value == value) + return 1; + q = q->next; + } return 0; } +/* + * strxcat: concatenate strings. + * n: Null-terminated Destination string + * src: Source string to be appended (not null-terminated) + * len: Length of source string. + */ static void strxcat (char *n, const char *src, int len) { while (*n) @@ -97,24 +159,38 @@ static void strxcat (char *n, const char *src, int len) *n = '\0'; } +/* + * copy_token_name: Return copy of CCL token name + * tp: Pointer to token info. + * return: malloc(3) allocated copy of token name. + */ static char *copy_token_name (struct ccl_token *tp) { - char *str = xmalloc (tp->len + 1); + char *str = malloc (tp->len + 1); assert (str); memcpy (str, tp->name, tp->len); str[tp->len] = '\0'; return str; } +/* + * mk_node: Create RPN node. + * kind: Type of node. + * return: pointer to allocated node. + */ static struct ccl_rpn_node *mk_node (enum rpn_node_kind kind) { struct ccl_rpn_node *p; - p = xmalloc (sizeof(*p)); + p = malloc (sizeof(*p)); assert (p); p->kind = kind; return p; } +/* + * ccl_rpn_delete: Delete RPN tree. + * rpn: Pointer to tree. + */ void ccl_rpn_delete (struct ccl_rpn_node *rpn) { struct ccl_rpn_attr *attr, *attr1; @@ -129,32 +205,38 @@ void ccl_rpn_delete (struct ccl_rpn_node *rpn) ccl_rpn_delete (rpn->u.p[1]); break; case CCL_RPN_TERM: - xfree (rpn->u.t.term); + free (rpn->u.t.term); for (attr = rpn->u.t.attr_list; attr; attr = attr1) { attr1 = attr->next; - xfree (attr); + free (attr); } break; case CCL_RPN_SET: - xfree (rpn->u.setname); + free (rpn->u.setname); break; case CCL_RPN_PROX: ccl_rpn_delete (rpn->u.p[0]); ccl_rpn_delete (rpn->u.p[1]); break; } - xfree (rpn); + free (rpn); } static struct ccl_rpn_node *find_spec (struct ccl_rpn_attr **qa); static struct ccl_rpn_node *search_terms (struct ccl_rpn_attr **qa); +/* + * add_attr: Add attribute (type/value) to RPN term node. + * p: RPN node of type term. + * type: Type of attribute + * value: Value of attribute + */ static void add_attr (struct ccl_rpn_node *p, int type, int value) { struct ccl_rpn_attr *n; - n = xmalloc (sizeof(*n)); + n = malloc (sizeof(*n)); assert (n); n->type = type; n->value = value; @@ -162,26 +244,92 @@ static void add_attr (struct ccl_rpn_node *p, int type, int value) p->u.t.attr_list = n; } +/* + * search_term: Parse CCL search term. + * qa: Qualifier attributes already applied. + * return: pointer to node(s); NULL on error. + */ static struct ccl_rpn_node *search_term (struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p; - struct ccl_rpn_attr *attr; struct ccl_token *lookahead = look_token; int len = 0; int no, i; int left_trunc = 0; int right_trunc = 0; int mid_trunc = 0; + int relation_value = -1; + int position_value = -1; + int structure_value = -1; + int truncation_value = -1; + int completeness_value = -1; if (KIND != CCL_TOK_TERM) { ccl_error = CCL_ERR_TERM_EXPECTED; return NULL; } + /* create the term node, but wait a moment before adding the term */ + p = mk_node (CCL_RPN_TERM); + p->u.t.attr_list = NULL; + p->u.t.term = NULL; + + if (!qa) + { + /* no qualifier(s) applied. Use 'term' if it is defined */ + + qa = malloc (2*sizeof(*qa)); + assert (qa); + qa[0] = ccl_qual_search (bibset, "term", 4); + qa[1] = NULL; + } + + /* go through all attributes and add them to the attribute list */ + for (i=0; qa && qa[i]; i++) + { + struct ccl_rpn_attr *attr; + + for (attr = qa[i]; attr; attr = attr->next) + if (attr->value > 0) + { /* deal only with REAL attributes (positive) */ + switch (attr->type) + { + case CCL_BIB1_REL: + if (relation_value != -1) + continue; + relation_value = attr->value; + break; + case CCL_BIB1_POS: + if (position_value != -1) + continue; + position_value = attr->value; + break; + case CCL_BIB1_STR: + if (structure_value != -1) + continue; + structure_value = attr->value; + break; + case CCL_BIB1_TRU: + if (truncation_value != -1) + continue; + truncation_value = attr->value; + break; + case CCL_BIB1_COM: + if (completeness_value != -1) + continue; + completeness_value = attr->value; + break; + } + add_attr (p, attr->type, attr->value); + } + } + /* go through each TERM token. If no truncation attribute is yet + met, then look for left/right truncation markers (?) and + set left_trunc/right_trunc/mid_trunc accordingly */ for (no = 0; lookahead->kind == CCL_TOK_TERM; no++) { for (i = 0; ilen; i++) - if (lookahead->name[i] == '?') + if (truncation_value == -1 && lookahead->name[i] == '?') { if (no == 0 && i == 0 && lookahead->len >= 1) left_trunc = 1; @@ -194,10 +342,22 @@ static struct ccl_rpn_node *search_term (struct ccl_rpn_attr **qa) len += 1+lookahead->len; lookahead = lookahead->next; } - p = mk_node (CCL_RPN_TERM); - p->u.t.term = xmalloc (len); + /* len now holds the number of characters in the RPN term */ + /* no holds the number of CCL tokens (1 or more) */ + + if (structure_value == -1 && + qual_val_type (qa, CCL_BIB1_STR, CCL_BIB1_STR_WP)) + { /* no structure attribute met. Apply either structure attribute + WORD or PHRASE depending on number of CCL tokens */ + if (no == 1) + add_attr (p, CCL_BIB1_STR, 2); + else + add_attr (p, CCL_BIB1_STR, 1); + } + + /* make the RPN token */ + p->u.t.term = malloc (len); assert (p->u.t.term); - p->u.t.attr_list = NULL; p->u.t.term[0] = '\0'; for (i = 0; iu.t.term, src_str, src_len); ADVANCE; } - if (qa) - { - int i; - for (i=0; qa[i]; i++) - { - struct ccl_rpn_attr *attr; - - for (attr = qa[i]; attr; attr = attr->next) - if (attr->value > 0) - add_attr (p, attr->type, attr->value); - } - attr = qa[0]; - } - else - attr = ccl_qual_search (bibset, "term", 4); - if (attr && qual_val_type (attr, CCL_BIB1_STR, CCL_BIB1_STR_WP)) - { - if (no == 1) - add_attr (p, CCL_BIB1_STR, 2); - else - add_attr (p, CCL_BIB1_STR, 1); - } if (left_trunc && right_trunc) { - if (attr && !qual_val_type (attr, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_BOTH)) + if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_BOTH)) { ccl_error = CCL_ERR_TRUNC_NOT_BOTH; - if (qa) - xfree (qa); + free (qa); ccl_rpn_delete (p); return NULL; } @@ -252,11 +389,10 @@ static struct ccl_rpn_node *search_term (struct ccl_rpn_attr **qa) } else if (right_trunc) { - if (attr && !qual_val_type (attr, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT)) + if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT)) { ccl_error = CCL_ERR_TRUNC_NOT_RIGHT; - if (qa) - xfree (qa); + free (qa); ccl_rpn_delete (p); return NULL; } @@ -264,11 +400,10 @@ static struct ccl_rpn_node *search_term (struct ccl_rpn_attr **qa) } else if (left_trunc) { - if (attr && !qual_val_type (attr, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT)) + if (!qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT)) { ccl_error = CCL_ERR_TRUNC_NOT_LEFT; - if (qa) - xfree (qa); + free (qa); ccl_rpn_delete (p); return NULL; } @@ -276,53 +411,64 @@ static struct ccl_rpn_node *search_term (struct ccl_rpn_attr **qa) } else { - if (attr && qual_val_type (attr, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE)) + if (qual_val_type (qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE)) add_attr (p, CCL_BIB1_TRU, 100); } return p; } +/* + * qualifiers: Parse CCL qualifiers and search terms. + * la: Token pointer to RELATION token. + * qa: Qualifier attributes already applied. + * return: pointer to node(s); NULL on error. + */ static struct ccl_rpn_node *qualifiers (struct ccl_token *la, struct ccl_rpn_attr **qa) { struct ccl_token *lookahead = look_token; struct ccl_rpn_attr **ap; - int no = 1; + int no = 0; int i, rel; - struct ccl_rpn_attr *attr; - +#if 0 if (qa) { ccl_error = CCL_ERR_DOUBLE_QUAL; return NULL; } +#endif for (lookahead = look_token; lookahead != la; lookahead=lookahead->next) no++; - ap = xmalloc (no * sizeof(*ap)); + if (qa) + for (i=0; qa[i]; i++) + no++; + ap = malloc ((no+1) * sizeof(*ap)); assert (ap); - for (i=0; look_token != la; i++) + for (i = 0; look_token != la; i++) { ap[i] = ccl_qual_search (bibset, look_token->name, look_token->len); if (!ap[i]) { ccl_error = CCL_ERR_UNKNOWN_QUAL; - xfree (ap); + free (ap); return NULL; } ADVANCE; if (KIND == CCL_TOK_COMMA) ADVANCE; } + if (qa) + while (*qa) + ap[i++] = *qa++; ap[i] = NULL; - if (! (attr = qual_val (ap[0], CCL_BIB1_REL)) || - attr->value != CCL_BIB1_REL_ORDER) + if (!qual_val_type (ap, CCL_BIB1_REL, CCL_BIB1_REL_ORDER)) { /* unordered relation */ struct ccl_rpn_node *p; if (KIND != CCL_TOK_EQ) { ccl_error = CCL_ERR_EQ_EXPECTED; - xfree (ap); + free (ap); return NULL; } ADVANCE; @@ -331,21 +477,21 @@ static struct ccl_rpn_node *qualifiers (struct ccl_token *la, ADVANCE; if (!(p = find_spec (ap))) { - xfree (ap); + free (ap); return NULL; } if (KIND != CCL_TOK_RP) { ccl_error = CCL_ERR_RP_EXPECTED; ccl_rpn_delete (p); - xfree (ap); + free (ap); return NULL; } ADVANCE; } else p = search_terms (ap); - xfree (ap); + free (ap); return p; } rel = 0; @@ -374,54 +520,93 @@ static struct ccl_rpn_node *qualifiers (struct ccl_token *la, struct ccl_rpn_node *p; ADVANCE; /* skip relation */ - if (KIND == CCL_TOK_TERM) + if (KIND == CCL_TOK_TERM && look_token->next->kind == CCL_TOK_MINUS) { struct ccl_rpn_node *p1; - p1 = search_term (ap); - if (KIND == CCL_TOK_MINUS) + if (!(p1 = search_term (ap))) + { + free (ap); + return NULL; + } + ADVANCE; /* skip '-' */ + if (KIND == CCL_TOK_TERM) /* = term - term ? */ { - ADVANCE; /* skip '-' */ - if (KIND == CCL_TOK_TERM) /* = term - term ? */ - { - struct ccl_rpn_node *p2; - - p2 = search_term (ap); - p = mk_node (CCL_RPN_AND); - p->u.p[0] = p1; - add_attr (p1, CCL_BIB1_REL, 4); - p->u.p[1] = p2; - add_attr (p2, CCL_BIB1_REL, 2); - xfree (ap); - return p; - } - else /* = term - */ - { - add_attr (p1, CCL_BIB1_REL, 4); - xfree (ap); - return p1; - } + struct ccl_rpn_node *p2; + + if (!(p2 = search_term (ap))) + { + ccl_rpn_delete (p1); + free (ap); + return NULL; + } + p = mk_node (CCL_RPN_AND); + p->u.p[0] = p1; + add_attr (p1, CCL_BIB1_REL, 4); + p->u.p[1] = p2; + add_attr (p2, CCL_BIB1_REL, 2); + free (ap); + return p; } - else + else /* = term - */ { - add_attr (p1, CCL_BIB1_REL, rel); - xfree (ap); + add_attr (p1, CCL_BIB1_REL, 4); + free (ap); return p1; } } else if (KIND == CCL_TOK_MINUS) /* = - term ? */ { ADVANCE; - p = search_term (ap); + if (!(p = search_term (ap))) + { + free (ap); + return NULL; + } add_attr (p, CCL_BIB1_REL, 2); - xfree (ap); + free (ap); return p; } + else if (KIND == CCL_TOK_LP) + { + ADVANCE; + if (!(p = find_spec (ap))) + { + free (ap); + return NULL; + } + if (KIND != CCL_TOK_RP) + { + ccl_error = CCL_ERR_RP_EXPECTED; + ccl_rpn_delete (p); + free (ap); + return NULL; + } + ADVANCE; + free (ap); + return p; + } + else + { + if (!(p = search_terms (ap))) + { + free (ap); + return NULL; + } + add_attr (p, CCL_BIB1_REL, rel); + free (ap); + return p; + } ccl_error = CCL_ERR_TERM_EXPECTED; } - xfree (ap); + free (ap); return NULL; } +/* + * search_terms: Parse CCL search terms - including proximity. + * qa: Qualifier attributes already applied. + * return: pointer to node(s); NULL on error. + */ static struct ccl_rpn_node *search_terms (struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p1, *p2, *pn; @@ -463,6 +648,11 @@ static struct ccl_rpn_node *search_terms (struct ccl_rpn_attr **qa) return p1; } +/* + * search_elements: Parse CCL search elements + * qa: Qualifier attributes already applied. + * return: pointer to node(s); NULL on error. + */ static struct ccl_rpn_node *search_elements (struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p1; @@ -499,13 +689,23 @@ static struct ccl_rpn_node *search_elements (struct ccl_rpn_attr **qa) } lookahead = look_token; - while (lookahead->kind==CCL_TOK_TERM || lookahead->kind==CCL_TOK_COMMA) - lookahead = lookahead->next; - if (lookahead->kind == CCL_TOK_REL || lookahead->kind == CCL_TOK_EQ) - return qualifiers (lookahead, qa); + while (lookahead->kind==CCL_TOK_TERM) + { + lookahead = lookahead->next; + if (lookahead->kind == CCL_TOK_REL || lookahead->kind == CCL_TOK_EQ) + return qualifiers (lookahead, qa); + if (lookahead->kind != CCL_TOK_COMMA) + break; + lookahead = lookahead->next; + } return search_terms (qa); } +/* + * find_spec: Parse CCL find specification + * qa: Qualifier attributes already applied. + * return: pointer to node(s); NULL on error. + */ static struct ccl_rpn_node *find_spec (struct ccl_rpn_attr **qa) { struct ccl_rpn_node *p1, *p2, *pn; @@ -560,6 +760,14 @@ static struct ccl_rpn_node *find_spec (struct ccl_rpn_attr **qa) return p1; } +/* + * ccl_find: Parse CCL find - token representation + * abibset: Bibset to be used for the parsing + * list: List of tokens + * error: Pointer to integer. Holds error no. on completion. + * pos: Pointer to char position. Holds approximate error position. + * return: RPN tree on successful completion; NULL otherwise. + */ struct ccl_rpn_node *ccl_find (CCL_bibset abibset, struct ccl_token *list, int *error, const char **pos) { @@ -585,6 +793,14 @@ struct ccl_rpn_node *ccl_find (CCL_bibset abibset, struct ccl_token *list, return p; } +/* + * ccl_find_str: Parse CCL find - string representation + * bibset: Bibset to be used for the parsing + * str: String to be parsed + * error: Pointer to integer. Holds error no. on completion. + * pos: Pointer to char position. Holds approximate error position. + * return: RPN tree on successful completion; NULL otherwise. + */ struct ccl_rpn_node *ccl_find_str (CCL_bibset bibset, const char *str, int *error, int *pos) { diff --git a/ccl/cclptree.c b/ccl/cclptree.c index 2b2cb9a..d8aef6e 100644 --- a/ccl/cclptree.c +++ b/ccl/cclptree.c @@ -1,15 +1,55 @@ +/* + * 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. + * + */ /* CCL print rpn tree - infix notation * Europagate, 1995 * * $Log: cclptree.c,v $ - * Revision 1.3 1995-09-29 17:11:59 quinn - * Smallish - * - * Revision 1.2 1995/09/27 15:02:44 quinn - * Modified function heads & prototypes. + * Revision 1.4 1996-10-11 15:00:25 adam + * CCL parser from Europagate Email gateway 1.0. * - * Revision 1.1 1995/04/10 10:28:20 quinn - * Added copy of CCL. + * Revision 1.6 1995/05/16 09:39:26 adam + * LICENSE. * * Revision 1.5 1995/02/23 08:31:59 adam * Changed header. diff --git a/ccl/cclqfile.c b/ccl/cclqfile.c new file mode 100644 index 0000000..e8063ea --- /dev/null +++ b/ccl/cclqfile.c @@ -0,0 +1,180 @@ +/* + * 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. + * + */ +/* CCL qualifiers + * Europagate, 1995 + * + * $Log: cclqfile.c,v $ + * Revision 1.1 1996-10-11 15:00:25 adam + * CCL parser from Europagate Email gateway 1.0. + * + * Revision 1.3 1995/05/16 09:39:26 adam + * LICENSE. + * + * Revision 1.2 1995/05/11 14:03:56 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. + * + * Revision 1.1 1995/04/17 09:31:45 adam + * Improved handling of qualifiers. Aliases or reserved words. + * + */ + +#include +#include +#include +#include + +#include + +void ccl_qual_fitem (CCL_bibset bibset, const char *cp, const char *qual_name) +{ + char qual_type[128]; + int no_scan; + int pair[128]; + int pair_no = 0; + + while (1) + { + char *qual_value; + char *split; + + if (sscanf (cp, "%s%n", qual_type, &no_scan) != 1) + break; + + if (!(split = strchr (qual_type, '='))) + break; + cp += no_scan; + + *split++ = '\0'; + while (1) + { + int type, value; + + qual_value = split; + if ((split = strchr (qual_value, ','))) + *split++ = '\0'; + value = atoi (qual_value); + switch (qual_type[0]) + { + case 'u': + case 'U': + type = CCL_BIB1_USE; + break; + case 'r': + case 'R': + type = CCL_BIB1_REL; + if (!ccl_stricmp (qual_value, "o")) + value = CCL_BIB1_REL_ORDER; + break; + case 'p': + case 'P': + type = CCL_BIB1_POS; + break; + case 's': + case 'S': + type = CCL_BIB1_STR; + if (!ccl_stricmp (qual_value, "pw")) + value = CCL_BIB1_STR_WP; + break; + case 't': + case 'T': + type = CCL_BIB1_TRU; + if (!ccl_stricmp (qual_value, "l")) + value = CCL_BIB1_TRU_CAN_LEFT; + else if (!ccl_stricmp (qual_value, "r")) + value = CCL_BIB1_TRU_CAN_RIGHT; + else if (!ccl_stricmp (qual_value, "b")) + value = CCL_BIB1_TRU_CAN_BOTH; + else if (!ccl_stricmp (qual_value, "n")) + value = CCL_BIB1_TRU_CAN_NONE; + break; + case 'c': + case 'C': + type = CCL_BIB1_COM; + break; + default: + type = atoi (qual_type); + } + pair[pair_no*2] = type; + pair[pair_no*2+1] = value; + pair_no++; + if (!split) + break; + } + } + ccl_qual_add (bibset, qual_name, pair_no, pair); +} + +/* + * ccl_qual_file: Read bibset definition from file. + * bibset: Bibset + * inf: FILE pointer. + * + * Each line format is: + * = = .... + * Where is name of qualifier; + * = is a attribute definition pair where is one of: + * u(use), r(relation), p(position), t(truncation), c(completeness) + * or plain integer. + * is an integer or special pseudo-value. + */ +void ccl_qual_file (CCL_bibset bibset, FILE *inf) +{ + char line[256]; + char *cp; + char qual_name[128]; + int no_scan; + + while (fgets (line, 255, inf)) + { + cp = line; + if (*cp == '#') + continue; /* ignore lines starting with # */ + if (sscanf (cp, "%s%n", qual_name, &no_scan) != 1) + continue; /* also ignore empty lines */ + cp += no_scan; + ccl_qual_fitem (bibset, cp, qual_name); + } +} diff --git a/ccl/cclqual.c b/ccl/cclqual.c index 2230b77..2787a7b 100644 --- a/ccl/cclqual.c +++ b/ccl/cclqual.c @@ -1,18 +1,63 @@ +/* + * 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. + * + */ /* CCL qualifiers * Europagate, 1995 * * $Log: cclqual.c,v $ - * Revision 1.4 1995-11-01 13:54:21 quinn - * Minor adjustments + * Revision 1.5 1996-10-11 15:00:25 adam + * CCL parser from Europagate Email gateway 1.0. * - * Revision 1.3 1995/09/29 17:12:00 quinn - * Smallish + * Revision 1.9 1995/05/16 09:39:27 adam + * LICENSE. * - * Revision 1.2 1995/09/27 15:02:44 quinn - * Modified function heads & prototypes. + * Revision 1.8 1995/05/11 14:03:57 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. * - * Revision 1.1 1995/04/10 10:28:20 quinn - * Added copy of CCL. + * Revision 1.7 1995/04/17 09:31:46 adam + * Improved handling of qualifiers. Aliases or reserved words. * * Revision 1.6 1995/02/23 08:32:00 adam * Changed header. @@ -40,10 +85,20 @@ #include +/* Definition of CCL_bibset pointer */ struct ccl_qualifiers { struct ccl_qualifier *list; }; +/* + * ccl_qual_add: Add qualifier to Bibset. If qualifier already + * exists, then attributes are appendend to old + * definition. + * name: name of qualifier + * no: No of attribute type/value pairs. + * pairs: Attributes. pairs[0] first type, pair[1] first value, + * ... pair[2*no-2] last type, pair[2*no-1] last value. + */ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) { struct ccl_qualifier *q; @@ -55,13 +110,13 @@ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) break; if (!q) { - struct ccl_qualifier *new_qual = xmalloc (sizeof(*new_qual)); + struct ccl_qualifier *new_qual = malloc (sizeof(*new_qual)); assert (new_qual); new_qual->next = b->list; b->list = new_qual; - new_qual->name = xmalloc (strlen(name)+1); + new_qual->name = malloc (strlen(name)+1); assert (new_qual->name); strcpy (new_qual->name, name); attrp = &new_qual->attr_list; @@ -76,7 +131,7 @@ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) { struct ccl_rpn_attr *attr; - attr = xmalloc (sizeof(*attr)); + attr = malloc (sizeof(*attr)); assert (attr); attr->type = *pairs++; attr->value = *pairs++; @@ -86,109 +141,68 @@ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *pairs) *attrp = NULL; } +/* + * ccl_qual_mk: Make new (empty) bibset. + * return: empty bibset. + */ CCL_bibset ccl_qual_mk (void) { - CCL_bibset b = xmalloc (sizeof(*b)); + CCL_bibset b = malloc (sizeof(*b)); assert (b); b->list = NULL; return b; } +/* + * ccl_qual_rm: Delete bibset. + * b: pointer to bibset + */ void ccl_qual_rm (CCL_bibset *b) { - assert (*b); + struct ccl_qualifier *q, *q1; + + if (!*b) + return; + for (q = (*b)->list; q; q = q1) + { + struct ccl_rpn_attr *attr, *attr1; + + for (attr = q->attr_list; attr; attr = attr1) + { + attr1 = attr->next; + free (attr); + } + q1 = q->next; + free (q); + } + free (*b); *b = NULL; } +/* + * ccl_qual_search: Search for qualifier in bibset. + * b: Bibset + * name: Name of qualifier to search for (need no null-termination) + * len: Length of name. + * return: Attribute info. NULL if not found. + */ struct ccl_rpn_attr *ccl_qual_search (CCL_bibset b, const char *name, int len) { struct ccl_qualifier *q; assert (b); for (q = b->list; q; q = q->next) - if (strlen(q->name) == len && !memcmp (name, q->name, len)) - return q->attr_list; - return NULL; -} - -void ccl_qual_file (CCL_bibset bibset, FILE *inf) -{ - char line[256]; - char *cp; - char qual_name[128]; - char qual_des[128]; - int no_scan; - - while (fgets (line, 255, inf)) - { - cp = line; - if (*cp == '#') - continue; - if (sscanf (cp, "%s%n", qual_name, &no_scan) != 1) - continue; - cp += no_scan; - while (1) - { - int pair[2]; - char *qual_type; - char *qual_value; - char *split; - - if (sscanf (cp, "%s%n", qual_des, &no_scan) != 1) - break; - - if (!(split = strchr (qual_des, '='))) - break; - cp += no_scan; - - *split++ = '\0'; - qual_type = qual_des; - qual_value = split; - while (1) + if (strlen(q->name) == len) + if (ccl_case_sensitive) { - if ((split = strchr (qual_value, ','))) - *split++ = '\0'; - pair[1] = atoi (qual_value); - switch (qual_type[0]) - { - case 'u': - pair[0] = CCL_BIB1_USE; - break; - case 'r': - pair[0] = CCL_BIB1_REL; - if (!strcmp (qual_value, "o")) - pair[1] = CCL_BIB1_REL_ORDER; - break; - case 'p': - pair[0] = CCL_BIB1_POS; - break; - case 's': - pair[0] = CCL_BIB1_STR; - if (!strcmp (qual_value, "pw")) - pair[1] = CCL_BIB1_STR_WP; - break; - case 't': - pair[0] = CCL_BIB1_TRU; - if (!strcmp (qual_value, "l")) - pair[1] = CCL_BIB1_TRU_CAN_LEFT; - else if (!strcmp (qual_value, "r")) - pair[1] = CCL_BIB1_TRU_CAN_RIGHT; - else if (!strcmp (qual_value, "b")) - pair[1] = CCL_BIB1_TRU_CAN_BOTH; - else if (!strcmp (qual_value, "n")) - pair[1] = CCL_BIB1_TRU_CAN_NONE; - break; - case 'c': - pair[0] = CCL_BIB1_COM; - break; - default: - pair[0] = atoi (qual_type); - } - ccl_qual_add (bibset, qual_name, 1, pair); - if (!split) - break; - qual_value = split; + if (!memcmp (name, q->name, len)) + return q->attr_list; } - } - } + else + { + if (!ccl_memicmp (name, q->name, len)) + return q->attr_list; + } + return NULL; } + diff --git a/ccl/cclsh.c b/ccl/cclsh.c index acff48f..6a69c9d 100644 --- a/ccl/cclsh.c +++ b/ccl/cclsh.c @@ -1,9 +1,60 @@ +/* + * 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. + * + */ /* CCL shell. * Europagate 1995 * * $Log: cclsh.c,v $ - * Revision 1.1 1995-04-10 10:28:21 quinn - * Added copy of CCL. + * Revision 1.2 1996-10-11 15:00:25 adam + * CCL parser from Europagate Email gateway 1.0. + * + * Revision 1.11 1995/05/16 09:39:27 adam + * LICENSE. + * + * Revision 1.10 1995/05/11 14:03:57 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. * * Revision 1.9 1995/02/23 08:32:00 adam * Changed header. @@ -57,6 +108,9 @@ int main (int argc, char **argv) { switch (argv[0][1]) { + case 'c': + ccl_case_sensitive = 0; + break; case 'd': debug = 1; break; diff --git a/ccl/cclstr.c b/ccl/cclstr.c new file mode 100644 index 0000000..7187295 --- /dev/null +++ b/ccl/cclstr.c @@ -0,0 +1,110 @@ +/* + * 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. + * + */ +/* CCL string compare utilities + * Europagate, 1995 + * + * $Log: cclstr.c,v $ + * Revision 1.1 1996-10-11 15:00:26 adam + * CCL parser from Europagate Email gateway 1.0. + * + * Revision 1.3 1996/01/24 10:11:19 adam + * Added include of stdlib.h. + * + * Revision 1.2 1995/05/16 09:39:27 adam + * LICENSE. + * + * Revision 1.1 1995/05/11 14:03:57 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. + * + */ +#include +#include +#include + +#include + +static int ccli_toupper (int c) +{ + return toupper (c); +} + +int (*ccl_toupper)(int c) = NULL; + +int ccl_stricmp (const char *s1, const char *s2) +{ + if (!ccl_toupper) + ccl_toupper = ccli_toupper; + while (*s1 && *s2) + { + int c1, c2; + c1 = (*ccl_toupper)(*s1); + c2 = (*ccl_toupper)(*s2); + if (c1 != c2) + return c1 - c2; + s1++; + s2++; + } + return (*ccl_toupper)(*s1) - (*ccl_toupper)(*s2); +} + +int ccl_memicmp (const char *s1, const char *s2, size_t n) +{ + if (!ccl_toupper) + ccl_toupper = ccli_toupper; + while (1) + { + int c1, c2; + + c1 = (*ccl_toupper)(*s1); + c2 = (*ccl_toupper)(*s2); + if (n <= 1 || c1 != c2) + return c1 - c2; + s1++; + s2++; + --n; + } +} + diff --git a/ccl/ccltoken.c b/ccl/ccltoken.c index 14b217d..68f31af 100644 --- a/ccl/ccltoken.c +++ b/ccl/ccltoken.c @@ -1,18 +1,70 @@ +/* + * 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. + * + */ /* CCL - lexical analysis * Europagate, 1995 * * $Log: ccltoken.c,v $ - * Revision 1.4 1995-11-01 13:54:22 quinn - * Minor adjustments + * Revision 1.5 1996-10-11 15:00:26 adam + * CCL parser from Europagate Email gateway 1.0. + * + * Revision 1.10 1995/07/11 12:28:31 adam + * New function: ccl_token_simple (split into simple tokens) and + * ccl_token_del (delete tokens). * - * Revision 1.3 1995/09/29 17:12:00 quinn - * Smallish + * Revision 1.9 1995/05/16 09:39:28 adam + * LICENSE. * - * Revision 1.2 1995/09/27 15:02:44 quinn - * Modified function heads & prototypes. + * Revision 1.8 1995/05/11 14:03:57 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. * - * Revision 1.1 1995/04/10 10:28:22 quinn - * Added copy of CCL. + * Revision 1.7 1995/04/19 12:11:24 adam + * Minor change. + * + * Revision 1.6 1995/04/17 09:31:48 adam + * Improved handling of qualifiers. Aliases or reserved words. * * Revision 1.5 1995/02/23 08:32:00 adam * Changed header. @@ -38,21 +90,112 @@ #include -static int strin (const char *s, const char *cset) +const char *ccl_token_and = "and"; +const char *ccl_token_or = "or"; +const char *ccl_token_not = "not andnot"; +const char *ccl_token_set = "set"; +int ccl_case_sensitive = 1; + +/* + * token_cmp: Compare token with keyword(s) + * kw: Keyword list. Each keyword is separated by space. + * token: CCL token. + * return: 1 if token string matches one of the keywords in list; + * 0 otherwise. + */ +static int token_cmp (const char *kw, struct ccl_token *token) { - while (*cset) + const char *cp1 = kw; + const char *cp2; + if (!kw) + return 0; + while ((cp2 = strchr (cp1, ' '))) { - if (*cset++ == *s) - return 1; + if (token->len == cp2-cp1) + if (ccl_case_sensitive) + { + if (!memcmp (cp1, token->name, token->len)) + return 1; + } + else + { + if (!ccl_memicmp (cp1, token->name, token->len)) + return 1; + } + cp1 = cp2+1; } - return 0; + if (ccl_case_sensitive) + return token->len == strlen(cp1) + && !memcmp (cp1, token->name, token->len); + return token->len == strlen(cp1) && + !ccl_memicmp (cp1, token->name, token->len); } -const char *ccl_token_and = "and"; -const char *ccl_token_or = "or"; -const char *ccl_token_not = "not"; -const char *ccl_token_set = "set"; +/* + * ccl_token_simple: tokenize CCL raw tokens + */ +struct ccl_token *ccl_token_simple (const char *command) +{ + const char *cp = command; + struct ccl_token *first = NULL; + struct ccl_token *last = NULL; + while (1) + { + while (*cp && strchr (" \t\r\n", *cp)) + { + cp++; + continue; + } + if (!first) + { + first = last = malloc (sizeof (*first)); + assert (first); + last->prev = NULL; + } + else + { + last->next = malloc (sizeof(*first)); + assert (last->next); + last->next->prev = last; + last = last->next; + } + last->next = NULL; + last->name = cp; + last->len = 1; + switch (*cp++) + { + case '\0': + last->kind = CCL_TOK_EOL; + return first; + case '\"': + last->kind = CCL_TOK_TERM; + last->name = cp; + last->len = 0; + while (*cp && *cp != '\"') + { + cp++; + ++ last->len; + } + if (*cp == '\"') + cp++; + break; + default: + while (*cp && !strchr (" \t\n\r", *cp)) + { + cp++; + ++ last->len; + } + last->kind = CCL_TOK_TERM; + } + } + return first; +} + +/* + * ccl_tokenize: tokenize CCL command string. + * return: CCL token list. + */ struct ccl_token *ccl_tokenize (const char *command) { const char *cp = command; @@ -61,20 +204,20 @@ struct ccl_token *ccl_tokenize (const char *command) while (1) { - while (*cp && strin (cp, " \t\r\n")) + while (*cp && strchr (" \t\r\n", *cp)) { cp++; continue; } if (!first) { - first = last = xmalloc (sizeof (*first)); + first = last = malloc (sizeof (*first)); assert (first); last->prev = NULL; } else { - last->next = xmalloc (sizeof(*first)); + last->next = malloc (sizeof(*first)); assert (last->next); last->next->prev = last; last = last->next; @@ -135,26 +278,37 @@ struct ccl_token *ccl_tokenize (const char *command) cp++; break; default: - while (*cp && !strin (cp, "(),%!><=- \t\n\r")) + while (*cp && !strchr ("(),%!><=- \t\n\r", *cp)) { cp++; ++ last->len; } - if (strlen (ccl_token_and)==last->len && - !memcmp (ccl_token_and, last->name, last->len)) - last->kind = CCL_TOK_AND; - else if (strlen (ccl_token_or)==last->len && - !memcmp (ccl_token_or, last->name, last->len)) - last->kind = CCL_TOK_OR; - else if (strlen (ccl_token_not)==last->len && - !memcmp (ccl_token_not, last->name, last->len)) - last->kind = CCL_TOK_NOT; - else if (strlen (ccl_token_set)==last->len && - !memcmp (ccl_token_set, last->name, last->len)) - last->kind = CCL_TOK_SET; + if (token_cmp (ccl_token_and, last)) + last->kind = CCL_TOK_AND; + else if (token_cmp (ccl_token_or, last)) + last->kind = CCL_TOK_OR; + else if (token_cmp (ccl_token_not, last)) + last->kind = CCL_TOK_NOT; + else if (token_cmp (ccl_token_set, last)) + last->kind = CCL_TOK_SET; else last->kind = CCL_TOK_TERM; } } return first; } + +/* + * ccl_token_del: delete CCL tokens + */ +void ccl_token_del (struct ccl_token *list) +{ + struct ccl_token *list1; + + while (list) + { + list1 = list->next; + free (list); + list = list1; + } +} diff --git a/include/ccl.h b/include/ccl.h index 39fa54c..e40777d 100644 --- a/include/ccl.h +++ b/include/ccl.h @@ -1,15 +1,71 @@ -/* CCL - header file - * Europagate, 1995 +/* + * 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. + * + */ + +/* + * CCL - header file * * $Log: ccl.h,v $ - * Revision 1.3 1995-09-29 17:12:01 quinn - * Smallish + * Revision 1.4 1996-10-11 15:02:26 adam + * CCL parser from Europagate Email gateway 1.0. + * + * Revision 1.10 1996/01/08 08:41:22 adam + * Minor changes. + * + * Revision 1.9 1995/07/20 08:15:16 adam + * Bug fix: Token value for comma and OR were the same! + * + * Revision 1.8 1995/07/11 12:28:34 adam + * New function: ccl_token_simple (split into simple tokens) and + * ccl_token_del (delete tokens). * - * Revision 1.2 1995/09/27 15:02:46 quinn - * Modified function heads & prototypes. + * Revision 1.7 1995/05/16 09:39:38 adam + * LICENSE. * - * Revision 1.1 1995/04/10 10:28:27 quinn - * Added copy of CCL. + * Revision 1.6 1995/05/11 14:04:03 adam + * Changes in the reading of qualifier(s). New function: ccl_qual_fitem. + * New variable ccl_case_sensitive, which controls whether reserved + * words and field names are case sensitive or not. * * Revision 1.5 1995/02/23 08:32:11 adam * Changed header. @@ -29,8 +85,6 @@ #ifndef CCL_H #define CCL_H -#include - /* CCL error numbers */ #define CCL_ERR_OK 0 #define CCL_ERR_TERM_EXPECTED 1 @@ -125,11 +179,12 @@ typedef struct ccl_qualifiers *CCL_bibset; #define CCL_TOK_RP 6 #define CCL_TOK_COMMA 7 #define CCL_TOK_AND 8 -#define CCL_TOK_OR 7 -#define CCL_TOK_NOT 9 -#define CCL_TOK_MINUS 10 -#define CCL_TOK_SET 11 +#define CCL_TOK_OR 9 +#define CCL_TOK_NOT 10 +#define CCL_TOK_MINUS 11 +#define CCL_TOK_SET 12 +/* CCL token */ struct ccl_token { char kind; char len; @@ -138,34 +193,72 @@ struct ccl_token { struct ccl_token *prev; }; +/* CCL Qualifier */ struct ccl_qualifier { char *name; struct ccl_rpn_attr *attr_list; struct ccl_qualifier *next; }; +/* Generate tokens from command string - obeys all CCL opererators */ struct ccl_token *ccl_tokenize (const char *command); +/* Generate tokens from command string - oebeys only simple tokens and + quoted strings */ +struct ccl_token *ccl_token_simple (const char *command); + +/* Delete token list */ +void ccl_token_del (struct ccl_token *list); + +/* Parse CCL Find command - NULL-terminated string */ struct ccl_rpn_node *ccl_find_str (CCL_bibset bibset, const char *str, int *error, int *pos); +/* Parse CCL Find command - Tokens read by ccl_tokenize */ struct ccl_rpn_node *ccl_find (CCL_bibset abibset, struct ccl_token *list, int *error, const char **pos); + +/* Return english-readable error message */ char *ccl_err_msg (int ccl_errno); + +/* Delete RPN tree returned by ccl_find */ void ccl_rpn_delete (struct ccl_rpn_node *rpn); + +/* Dump RPN tree in readable format to fd_out */ void ccl_pr_tree (struct ccl_rpn_node *rpn, FILE *fd_out); +/* Add CCL qualifier */ void ccl_qual_add (CCL_bibset b, const char *name, int no, int *attr); + +/* Read CCL qualifier list spec from file inf */ void ccl_qual_file (CCL_bibset bibset, FILE *inf); + +/* Add CCL qualifier by using single-line spec */ +void ccl_qual_fitem (CCL_bibset bibset, const char *cp, const char *qual_name); + +/* Make CCL qualifier set */ CCL_bibset ccl_qual_mk (void); + +/* Delete CCL qualifier set */ void ccl_qual_rm (CCL_bibset *b); +/* Misc. reserved words */ extern const char *ccl_token_and; extern const char *ccl_token_or; extern const char *ccl_token_not; extern const char *ccl_token_set; +/* Whether the CCL parser is command sensitive */ +extern int ccl_case_sensitive; + +/* Char-to-upper function */ +extern int (*ccl_toupper)(int c); + +/* String utilities */ +int ccl_stricmp (const char *s1, const char *s2); +int ccl_memicmp (const char *s1, const char *s2, size_t n); +/* Search for qualifier 'name' in set 'b'. */ struct ccl_rpn_attr *ccl_qual_search (CCL_bibset b, const char *name, int len); #endif -- 1.7.10.4