From 44cec91a73f331f5825fea0f2ef640cc28fdda11 Mon Sep 17 00:00:00 2001 From: Adam Dickmeiss Date: Wed, 20 Mar 1996 09:36:40 +0000 Subject: [PATCH] Function dict_lookup_grep got extra parameter, init_pos, which marks from which position in pattern approximate pattern matching should occur. Approximate pattern matching is used in relevance=re-2. --- index/zlogs.c | 175 ++++++++++++++++++++++++++++++++++++++++++++++++++----- index/zrpn.c | 42 +++++++++---- index/zserver.c | 8 ++- 3 files changed, 198 insertions(+), 27 deletions(-) diff --git a/index/zlogs.c b/index/zlogs.c index 2d97ded..30920cc 100644 --- a/index/zlogs.c +++ b/index/zlogs.c @@ -4,7 +4,12 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: zlogs.c,v $ - * Revision 1.2 1996-01-03 16:22:11 quinn + * Revision 1.3 1996-03-20 09:36:40 adam + * Function dict_lookup_grep got extra parameter, init_pos, which marks + * from which position in pattern approximate pattern matching should occur. + * Approximate pattern matching is used in relevance=re-2. + * + * Revision 1.2 1996/01/03 16:22:11 quinn * operator->roperator * * Revision 1.1 1995/11/16 17:00:55 adam @@ -14,13 +19,13 @@ #include #include - #include "zserver.h" static char *attrStr (int type, int value, enum oid_value ast) { static char str[80]; + *str = '\0'; switch (ast) { case VAL_BIB1: @@ -29,29 +34,169 @@ static char *attrStr (int type, int value, enum oid_value ast) switch (type) { case 1: - sprintf (str, "use=%d", value); - return str; + sprintf (str, "use"); + break; case 2: - sprintf (str, "relation=%d", value); - return str; + switch (value) + { + case 1: + sprintf (str, "relation=Less than"); + break; + case 2: + sprintf (str, "relation=Less than or equal"); + break; + case 3: + sprintf (str, "relation=Equal"); + break; + case 4: + sprintf (str, "relation=Greater or equal"); + break; + case 5: + sprintf (str, "relation=Greater than"); + break; + case 6: + sprintf (str, "relation=Not equal"); + break; + case 100: + sprintf (str, "relation=Phonetic"); + break; + case 101: + sprintf (str, "relation=Stem"); + break; + case 102: + sprintf (str, "relation=Relevance"); + break; + case 103: + sprintf (str, "relation=AlwaysMatches"); + break; + default: + sprintf (str, "relation"); + } + break; case 3: - sprintf (str, "position=%d", value); - return str; + switch (value) + { + case 1: + sprintf (str, "position=First in field"); + break; + case 2: + sprintf (str, "position=First in any subfield"); + break; + case 3: + sprintf (str, "position=Any position in field"); + break; + default: + sprintf (str, "position"); + } + break; case 4: - sprintf (str, "structure=%d", value); - return str; + switch (value) + { + case 1: + sprintf (str, "structure=Phrase"); + break; + case 2: + sprintf (str, "structure=Word"); + break; + case 3: + sprintf (str, "structure=Key"); + break; + case 4: + sprintf (str, "structure=Year"); + break; + case 5: + sprintf (str, "structure=Date"); + break; + case 6: + sprintf (str, "structure=Word list"); + break; + case 100: + sprintf (str, "structure=Date (un)"); + break; + case 101: + sprintf (str, "structure=Name (norm)"); + break; + case 102: + sprintf (str, "structure=Name (un)"); + break; + case 103: + sprintf (str, "structure=Structure"); + break; + case 104: + sprintf (str, "structure=urx"); + break; + case 105: + sprintf (str, "structure=free-form-text"); + break; + case 106: + sprintf (str, "structure=document-text"); + break; + case 107: + sprintf (str, "structure=local-number"); + break; + case 108: + sprintf (str, "structure=string"); + break; + case 109: + sprintf (str, "structure=numeric string"); + break; + default: + sprintf (str, "structure"); + } + break; case 5: - sprintf (str, "truncation=%d", value); - return str; + switch (value) + { + case 1: + sprintf (str, "truncation=Right"); + break; + case 2: + sprintf (str, "truncation=Left"); + break; + case 3: + sprintf (str, "truncation=Left&right"); + break; + case 100: + sprintf (str, "truncation=Do not truncate"); + break; + case 101: + sprintf (str, "truncation=Process #"); + break; + case 102: + sprintf (str, "truncation=re-1"); + break; + case 103: + sprintf (str, "truncation=re-2"); + break; + default: + sprintf (str, "truncation"); + } + break; case 6: - sprintf (str, "completeness=%d", value); - return str; + switch (value) + { + case 1: + sprintf (str, "completeness=Incomplete subfield"); + break; + case 2: + sprintf (str, "completeness=Complete subfield"); + break; + case 3: + sprintf (str, "completeness=Complete field"); + break; + default: + sprintf (str, "completeness"); + } + break; } break; default: break; } - sprintf (str, "%d=%d", type, value); + if (*str) + sprintf (str + strlen(str), " (%d=%d)", type, value); + else + sprintf (str, "%d=%d", type, value); return str; } diff --git a/index/zrpn.c b/index/zrpn.c index f7a2330..866af77 100644 --- a/index/zrpn.c +++ b/index/zrpn.c @@ -4,7 +4,12 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: zrpn.c,v $ - * Revision 1.40 1996-02-02 13:44:44 adam + * Revision 1.41 1996-03-20 09:36:43 adam + * Function dict_lookup_grep got extra parameter, init_pos, which marks + * from which position in pattern approximate pattern matching should occur. + * Approximate pattern matching is used in relevance=re-2. + * + * Revision 1.40 1996/02/02 13:44:44 adam * The public dictionary functions simply use char instead of Dict_char * to represent search strings. Dict_char is used internally only. * @@ -634,7 +639,7 @@ static int relational_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt, } logf (LOG_DEBUG, "dict_lookup_grep: %s", term_dict); r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, max_pos, - grep_handle); + 0, grep_handle); if (r) logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r); logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx); @@ -685,35 +690,35 @@ static int trunc_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt, if (!relational_term (zi, zapt, term_sub, term_dict, attributeSet, grep_info, &max_pos)) { + const char *cp; + + j = prefix_len; switch (truncation_value) { case -1: /* not specified */ case 100: /* do not truncate */ - j = strlen(term_dict); term_dict[j++] = '('; for (i = 0; term_sub[i]; i++) verbatim_char (term_sub[i], &j, term_dict); strcpy (term_dict+j, ")"); r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, - &max_pos, grep_handle); + &max_pos, 0, grep_handle); if (r) logf (LOG_WARN, "dict_lookup_grep err, trunc=none:%d", r); break; case 1: /* right truncation */ - j = strlen(term_dict); term_dict[j++] = '('; for (i = 0; term_sub[i]; i++) verbatim_char (term_sub[i], &j, term_dict); strcpy (term_dict+j, ".*)"); dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, - &max_pos, grep_handle); + &max_pos, 0, grep_handle); break; case 2: /* left truncation */ case 3: /* left&right truncation */ zi->errCode = 120; return -1; case 101: /* process # in term */ - j = strlen(term_dict); term_dict[j++] = '('; for (i=0; term_sub[i]; i++) if (term_sub[i] == '#' && i > 2) @@ -725,19 +730,34 @@ static int trunc_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt, verbatim_char (term_sub[i], &j, term_dict); strcpy (term_dict+j, ")"); r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, - &max_pos, grep_handle); + &max_pos, 0, grep_handle); if (r) logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r); break; case 102: /* regular expression */ - sprintf (term_dict + strlen(term_dict), "(%s)", term_sub); + sprintf (term_dict + j, "(%s)", term_sub); r = dict_lookup_grep (zi->wordDict, term_dict, 0, grep_info, - &max_pos, grep_handle); + &max_pos, 0, grep_handle); if (r) logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d", r); break; + case 103: /* regular expression with error correction */ + cp = term_sub; + r = 0; + if (*cp == '*' && cp[1] && cp[2]) + { + r = atoi (cp+1); + cp += 2; + } + sprintf (term_dict + j, "(%s)", cp); + r = dict_lookup_grep (zi->wordDict, term_dict, r, grep_info, + &max_pos, j, grep_handle); + if (r) + logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d", + r); + break; } } if (max_pos <= strlen(basenames[base_no])) @@ -1363,7 +1383,7 @@ int rpn_scan (ZServerInfo *zi, Z_AttributesPlusTerm *zapt, use_value = 1016; i = index_word_prefix (termz, 1, use_value, *basenames); - dict_lookup_grep (zi->wordDict, termz, 0, NULL, &max_pos, + dict_lookup_grep (zi->wordDict, termz, 0, NULL, &max_pos, 0, dummy_handle); if (max_pos <= strlen(*basenames)) { diff --git a/index/zserver.c b/index/zserver.c index 93767a8..6d61dc3 100644 --- a/index/zserver.c +++ b/index/zserver.c @@ -4,7 +4,12 @@ * Sebastian Hammer, Adam Dickmeiss * * $Log: zserver.c,v $ - * Revision 1.33 1996-01-17 14:57:56 adam + * Revision 1.34 1996-03-20 09:36:46 adam + * Function dict_lookup_grep got extra parameter, init_pos, which marks + * from which position in pattern approximate pattern matching should occur. + * Approximate pattern matching is used in relevance=re-2. + * + * Revision 1.33 1996/01/17 14:57:56 adam * Prototype changed for reader functions in extract/retrieve. File * is identified by 'void *' instead of 'int. * @@ -300,6 +305,7 @@ static int record_fetch (ZServerInfo *zi, int sysno, int score, ODR stream, *output_format = VAL_SUTRS; *rec_bufp = msg; *rec_lenp = strlen (msg); + logf (LOG_DEBUG, "rec_get fail on sysno=%d", sysno); return 0; } file_type = rec->info[recInfo_fileType]; -- 1.7.10.4