+
+#define REGEX_CHARS "^[]{}()|.*+?!$"
+#define CCL_CHARS "#?\\"
+
+static int has_ccl_masking(const char *src_str,
+ size_t src_len,
+ const char **truncation_aliases,
+ const char **mask_aliases)
+{
+ size_t j;
+ int quote_mode = 0;
+
+ for (j = 0; j < src_len; j++)
+ {
+ size_t op_size;
+ if (j > 0 && src_str[j-1] == '\\')
+ ;
+ else if (src_str[j] == '"')
+ quote_mode = !quote_mode;
+ else if (!quote_mode &&
+ (op_size = cmp_operator(truncation_aliases,
+ src_str + j)))
+ return 1;
+ else if (!quote_mode &&
+ (op_size = cmp_operator(mask_aliases,
+ src_str + j)))
+ return 1;
+ }
+ return 0;
+}
+
+static int append_term(CCL_parser cclp, const char *src_str, size_t src_len,
+ char *dst_term, int regex_trunc, int z3958_trunc,
+ const char **truncation_aliases,
+ const char **mask_aliases,
+ int is_first, int is_last,
+ int *left_trunc, int *right_trunc)
+{
+ size_t j;
+ int quote_mode = 0;
+
+ for (j = 0; j < src_len; j++)
+ {
+ size_t op_size;
+ if (j > 0 && src_str[j-1] == '\\')
+ {
+ if (regex_trunc && strchr(REGEX_CHARS "\\", src_str[j]))
+ strcat(dst_term, "\\");
+ else if (z3958_trunc && strchr(CCL_CHARS "\\", src_str[j]))
+ strcat(dst_term, "\\");
+ strxcat(dst_term, src_str + j, 1);
+ }
+ else if (src_str[j] == '"')
+ quote_mode = !quote_mode;
+ else if (!quote_mode &&
+ (op_size = cmp_operator(truncation_aliases,
+ src_str + j))
+ )
+ {
+ j += (op_size - 1); /* j++ in for loop */
+ if (regex_trunc)
+ strcat(dst_term, ".*");
+ else if (z3958_trunc)
+ strcat(dst_term, "?");
+ else if (is_first && j == 0)
+ *left_trunc = 1;
+ else if (is_last && j == src_len - 1)
+ *right_trunc = 1;
+ else
+ {
+ cclp->error_code = CCL_ERR_TRUNC_NOT_EMBED;
+ return -1;
+ }
+ }
+ else if (!quote_mode &&
+ (op_size = cmp_operator(mask_aliases, src_str + j)))
+ {
+ j += (op_size - 1); /* j++ in for loop */
+ if (regex_trunc)
+ strcat(dst_term, ".");
+ else if (z3958_trunc)
+ strcat(dst_term, "#");
+ else
+ {
+ cclp->error_code = CCL_ERR_TRUNC_NOT_SINGLE;
+ return -1;
+ }
+ }
+ else if (src_str[j] != '\\')
+ {
+ if (regex_trunc && strchr(REGEX_CHARS, src_str[j]))
+ strcat(dst_term, "\\");
+ else if (z3958_trunc && strchr(CCL_CHARS, src_str[j]))
+ strcat(dst_term, "\\");
+ strxcat(dst_term, src_str + j, 1);
+ }
+ }
+ return 0;
+}
+
+
+static struct ccl_rpn_node *ccl_term_one_use(CCL_parser cclp,
+ struct ccl_token *lookahead0,
+ struct ccl_rpn_attr *attr_use,
+ ccl_qualifier_t *qa,
+ size_t no,
+ int is_phrase,
+ int auto_group)
+{
+ struct ccl_rpn_node *p;
+ size_t i;
+ int relation_value = -1;
+ int position_value = -1;
+ int structure_value = -1;
+ int truncation_value = -1;
+ int completeness_value = -1;
+
+ int left_trunc = 0;
+ int right_trunc = 0;
+ int regex_trunc = 0;
+ int z3958_trunc = 0;
+ int is_ccl_masked = 0;
+ char *attset;
+ struct ccl_token *lookahead = lookahead0;
+ const char **truncation_aliases;
+ const char *t_default[2];
+ const char **mask_aliases;
+ const char *m_default[2];
+ int term_len = 0;
+
+ truncation_aliases =
+ ccl_qual_search_special(cclp->bibset, "truncation");
+ if (!truncation_aliases)
+ {
+ truncation_aliases = t_default;
+ t_default[0] = "?";
+ t_default[1] = 0;
+ }
+ mask_aliases =
+ ccl_qual_search_special(cclp->bibset, "mask");
+ if (!mask_aliases)
+ {
+ mask_aliases = m_default;
+ m_default[0] = "#";
+ m_default[1] = 0;
+ }
+ for (i = 0; i < no; i++)
+ {
+ if (has_ccl_masking(lookahead->name, lookahead->len,
+ truncation_aliases,
+ mask_aliases))
+ is_ccl_masked = 1;
+
+ term_len += 1 + lookahead->len + lookahead->ws_prefix_len;
+ lookahead = lookahead->next;
+ }
+ lookahead = lookahead0;
+
+ p = ccl_rpn_node_create(CCL_RPN_TERM);
+ p->u.t.attr_list = NULL;
+ p->u.t.term = NULL;
+ if (qa && qa[0])
+ {
+ const char *n = ccl_qual_get_name(qa[0]);
+ if (n)
+ p->u.t.qual = xstrdup(n);
+ }
+ /* 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 = ccl_qual_get_attr(qa[i]); attr; attr = attr->next)
+ if (attr->type != 1 || !attr_use || attr == attr_use)
+ {
+ switch (attr->kind)
+ {
+ case CCL_RPN_ATTR_STRING:
+ ccl_add_attr_string(p, attr->set, attr->type,
+ attr->value.str);
+ break;
+ case CCL_RPN_ATTR_NUMERIC:
+ if (attr->value.numeric > 0)
+ { /* deal only with REAL attributes (positive) */
+ switch (attr->type)
+ {
+ case CCL_BIB1_REL:
+ if (relation_value != -1)
+ continue;
+ relation_value = attr->value.numeric;
+ break;
+ case CCL_BIB1_POS:
+ if (position_value != -1)
+ continue;
+ position_value = attr->value.numeric;
+ break;
+ case CCL_BIB1_STR:
+ if (structure_value != -1)
+ continue;
+ structure_value = attr->value.numeric;
+ break;
+ case CCL_BIB1_TRU:
+ if (truncation_value != -1)
+ continue;
+ truncation_value = attr->value.numeric;
+ break;
+ case CCL_BIB1_COM:
+ if (completeness_value != -1)
+ continue;
+ completeness_value = attr->value.numeric;
+ break;
+ }
+ ccl_add_attr_numeric(p, attr->set, attr->type,
+ attr->value.numeric);
+ }
+ }
+ }
+ }
+ attset = 0;
+ if (structure_value == -1 && (
+ auto_group ||
+ qual_val_type(qa, CCL_BIB1_STR, CCL_BIB1_STR_WP, &attset))
+ )
+ {
+ if (!is_phrase)
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_STR, 2);
+ else
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_STR, 1);
+ }
+ if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_REGEX,
+ &attset))
+ {
+ if (is_ccl_masked)
+ regex_trunc = 1; /* regex trunc (102) allowed */
+ }
+ else if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_Z3958,
+ &attset))
+ {
+ if (is_ccl_masked)
+ z3958_trunc = 1; /* Z39.58 trunc (CCL) trunc allowed */
+ }
+ /* make the RPN token */
+ p->u.t.term = (char *)xmalloc(term_len * 2 + 2);
+ ccl_assert(p->u.t.term);
+ p->u.t.term[0] = '\0';
+
+ for (i = 0; i < no; i++)
+ {
+ const char *src_str = lookahead->name;
+ size_t src_len = lookahead->len;
+
+ if (p->u.t.term[0] && lookahead->ws_prefix_len)
+ {
+ strxcat(p->u.t.term, lookahead->ws_prefix_buf,
+ lookahead->ws_prefix_len);
+ }
+ if (append_term(cclp, src_str, src_len, p->u.t.term, regex_trunc,
+ z3958_trunc, truncation_aliases, mask_aliases,
+ i == 0, i == no - 1,
+ &left_trunc, &right_trunc))
+ {
+ ccl_rpn_delete(p);
+ return NULL;
+ }
+ lookahead = lookahead->next;
+ }
+ if (left_trunc && right_trunc)
+ {
+ if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_BOTH,
+ &attset))
+ {
+ cclp->error_code = CCL_ERR_TRUNC_NOT_BOTH;
+ ccl_rpn_delete(p);
+ return NULL;
+ }
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 3);
+ }
+ else if (right_trunc)
+ {
+ if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_RIGHT,
+ &attset))
+ {
+ cclp->error_code = CCL_ERR_TRUNC_NOT_RIGHT;
+ ccl_rpn_delete(p);
+ return NULL;
+ }
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 1);
+ }
+ else if (left_trunc)
+ {
+ if (!qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_LEFT,
+ &attset))
+ {
+ cclp->error_code = CCL_ERR_TRUNC_NOT_LEFT;
+ ccl_rpn_delete(p);
+ return NULL;
+ }
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 2);
+ }
+ else if (regex_trunc)
+ {
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 102);
+ }
+ else if (z3958_trunc)
+ {
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 104);
+ }
+ else
+ {
+ if (qual_val_type(qa, CCL_BIB1_TRU, CCL_BIB1_TRU_CAN_NONE,
+ &attset))
+ ccl_add_attr_numeric(p, attset, CCL_BIB1_TRU, 100);
+ }
+ return p;
+}
+
+static struct ccl_rpn_node *ccl_term_multi_use(CCL_parser cclp,
+ struct ccl_token *lookahead0,
+ ccl_qualifier_t *qa,
+ size_t no,
+ int is_phrase,
+ int auto_group)
+{
+ struct ccl_rpn_node *p = 0;
+ int i;
+ for (i = 0; qa && qa[i]; i++)
+ {
+ struct ccl_rpn_attr *attr;
+ for (attr = ccl_qual_get_attr(qa[i]); attr; attr = attr->next)
+ if (attr->type == 1 && i == 0)
+ {
+ struct ccl_rpn_node *tmp2;
+ tmp2 = ccl_term_one_use(cclp, lookahead0,
+ attr, qa, no,
+ is_phrase, auto_group);
+ if (!tmp2)
+ {
+ ccl_rpn_delete(p);
+ return 0;
+ }
+ p = ccl_rpn_node_mkbool(p, tmp2, CCL_RPN_OR);
+ }
+ }
+ if (!p)
+ p = ccl_term_one_use(cclp, lookahead0,
+ 0 /* attr: no use */, qa, no,
+ is_phrase, auto_group);
+ return p;
+}
+
+static struct ccl_rpn_node *split_recur(CCL_parser cclp, ccl_qualifier_t *qa,
+ struct ccl_rpn_node *parent,
+ struct ccl_token **ar, size_t sz)
+{
+ size_t l;
+ struct ccl_rpn_node *p_top = 0;
+ assert(sz > 0);
+ for (l = 1; l <= sz; l++)
+ {
+ struct ccl_rpn_node *p1;
+ struct ccl_rpn_node *p2 = ccl_term_multi_use(cclp, ar[0],
+ qa, l,
+ l > 1,
+ /* auto_group */0);
+ if (!p2)
+ {
+ ccl_rpn_delete(p_top);
+ return 0;
+ }
+ if (parent)
+ {
+ struct ccl_rpn_node *tmp = ccl_rpn_node_create(CCL_RPN_AND);
+ tmp->u.p[0] = l > 1 ? ccl_rpn_dup(parent) : parent;
+ tmp->u.p[1] = p2;
+ p2 = tmp;
+ }
+ if (sz > l)
+ p1 = split_recur(cclp, qa, p2, ar + l, sz - l);
+ else
+ p1 = p2;
+ if (!p1)
+ {
+ ccl_rpn_delete(p2);
+ ccl_rpn_delete(p_top);
+ return 0;
+ }
+ p_top = ccl_rpn_node_mkbool(p_top, p1, CCL_RPN_OR);
+ }
+ assert(p_top);
+ return p_top;
+}
+
+static struct ccl_rpn_node *search_term_split_list(CCL_parser cclp,
+ ccl_qualifier_t *qa,
+ int *term_list, int multi)
+{
+ struct ccl_rpn_node *p;
+ struct ccl_token **ar;
+ struct ccl_token *lookahead = cclp->look_token;
+ size_t i, sz;
+ for (sz = 0; is_term_ok(lookahead->kind, term_list); sz++)
+ lookahead = lookahead->next;
+ if (sz == 0)
+ {
+ cclp->error_code = CCL_ERR_TERM_EXPECTED;
+ return 0;
+ }
+ ar = (struct ccl_token **) xmalloc(sizeof(*lookahead) * sz);
+ lookahead = cclp->look_token;
+ for (i = 0; is_term_ok(lookahead->kind, term_list); i++)
+ {
+ ar[i] = lookahead;
+ lookahead = lookahead->next;
+ }
+ p = split_recur(cclp, qa, 0, ar, sz);
+ xfree(ar);
+ for (i = 0; i < sz; i++)
+ ADVANCE;
+ return p;
+}
+
+/**
+ * search_term: Parse CCL search term.