+ s0 = s1;
+ }
+ *src = s0;
+ return *s0;
+}
+
+static int term_100 (ZebraMaps zebra_maps, int reg_type,
+ const char **src, char *dst, int space_split)
+{
+ const char *s0, *s1;
+ const char **map;
+ int i = 0;
+
+ if (!term_pre (zebra_maps, reg_type, src, NULL, NULL))
+ return 0;
+ s0 = *src;
+ while (*s0)
+ {
+ s1 = s0;
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
+ if (space_split && **map == *CHR_SPACE)
+ break;
+ while (s1 < s0)
+ {
+ if (!isalnum (*s1) && *s1 != '-')
+ dst[i++] = '\\';
+ dst[i++] = *s1++;
+ }
+ }
+ dst[i] = '\0';
+ *src = s0;
+ return i;
+}
+
+static int term_101 (ZebraMaps zebra_maps, int reg_type,
+ const char **src, char *dst, int space_split)
+{
+ const char *s0, *s1;
+ const char **map;
+ int i = 0;
+
+ if (!term_pre (zebra_maps, reg_type, src, "#", "#"))
+ return 0;
+ s0 = *src;
+ while (*s0)
+ {
+ if (*s0 == '#')
+ {
+ dst[i++] = '.';
+ dst[i++] = '*';
+ s0++;
+ }
+ else
+ {
+ s1 = s0;
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
+ if (space_split && **map == *CHR_SPACE)
+ break;
+ while (s1 < s0)
+ {
+ if (!isalnum (*s1))
+ dst[i++] = '\\';
+ dst[i++] = *s1++;
+ }
+ }
+ }
+ dst[i] = '\0';
+ *src = s0;
+ return i;
+}
+
+
+static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
+ char *dst, int *errors, int space_split)
+{
+ int i = 0;
+ const char *s0, *s1;
+ const char **map;
+
+ if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "("))
+ return 0;
+ s0 = *src;
+ if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
+ isdigit (s0[1]))
+ {
+ *errors = s0[1] - '0';
+ s0 += 3;
+ if (*errors > 3)
+ *errors = 3;
+ }
+ while (*s0)
+ {
+ if (strchr ("^\\()[].*+?|-", *s0))
+ dst[i++] = *s0++;
+ else
+ {
+ s1 = s0;
+ map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
+ if (**map == *CHR_SPACE)
+ break;
+ while (s1 < s0)
+ {
+ if (!isalnum (*s1))
+ dst[i++] = '\\';
+ dst[i++] = *s1++;
+ }
+ }
+ }
+ dst[i] = '\0';
+ *src = s0;
+ return i;
+}
+
+static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
+ char *dst, int space_split)
+{
+ return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split);
+}
+
+/* gen_regular_rel - generate regular expression from relation
+ * val: border value (inclusive)
+ * islt: 1 if <=; 0 if >=.
+ */
+static void gen_regular_rel (char *dst, int val, int islt)
+{
+ int dst_p;
+ int w, d, i;
+ int pos = 0;
+ char numstr[20];
+
+ logf (LOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
+ if (val >= 0)
+ {
+ if (islt)
+ strcpy (dst, "(-[0-9]+|(");
+ else
+ strcpy (dst, "((");
+ }
+ else
+ {
+ if (!islt)
+ {
+ strcpy (dst, "([0-9]+|-(");
+ dst_p = strlen (dst);
+ islt = 1;
+ }
+ else
+ {
+ strcpy (dst, "((-");
+ islt = 0;
+ }
+ val = -val;
+ }
+ dst_p = strlen (dst);
+ sprintf (numstr, "%d", val);
+ for (w = strlen(numstr); --w >= 0; pos++)
+ {
+ d = numstr[w];
+ if (pos > 0)
+ {
+ if (islt)
+ {
+ if (d == '0')
+ continue;
+ d--;
+ }
+ else
+ {
+ if (d == '9')
+ continue;
+ d++;
+ }
+ }
+
+ strcpy (dst + dst_p, numstr);
+ dst_p = strlen(dst) - pos - 1;
+
+ if (islt)
+ {
+ if (d != '0')
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = '0';
+ dst[dst_p++] = '-';
+ dst[dst_p++] = d;
+ dst[dst_p++] = ']';
+ }
+ else
+ dst[dst_p++] = d;
+ }
+ else
+ {
+ if (d != '9')
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = d;
+ dst[dst_p++] = '-';
+ dst[dst_p++] = '9';
+ dst[dst_p++] = ']';
+ }
+ else
+ dst[dst_p++] = d;
+ }
+ for (i = 0; i<pos; i++)
+ {
+ dst[dst_p++] = '[';
+ dst[dst_p++] = '0';
+ dst[dst_p++] = '-';
+ dst[dst_p++] = '9';
+ dst[dst_p++] = ']';
+ }
+ dst[dst_p++] = '|';
+ }
+ dst[dst_p] = '\0';
+ if (islt)
+ {
+ for (i=1; i<pos; i++)
+ strcat (dst, "[0-9]?");
+ }
+ else
+ {
+ for (i = 0; i <= pos; i++)
+ strcat (dst, "[0-9]");
+ strcat (dst, "[0-9]*");
+ }
+ strcat (dst, "))");
+}
+
+static int relational_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ const char **term_sub,
+ char *term_dict,
+ oid_value attributeSet,
+ struct grep_info *grep_info,
+ int *max_pos,
+ int reg_type)
+{
+ AttrType relation;
+ int relation_value;
+ int term_value;
+ int r;
+ char *term_tmp = term_dict + strlen(term_dict);
+
+ attr_init (&relation, zapt, 2);
+ relation_value = attr_find (&relation, NULL);
+
+ logf (LOG_DEBUG, "relation value=%d", relation_value);
+ switch (relation_value)
+ {
+ case 1:
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
+ return 0;
+ term_value = atoi (term_tmp);
+ logf (LOG_DEBUG, "Relation <");
+ gen_regular_rel (term_tmp, term_value-1, 1);
+ break;
+ case 2:
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
+ return 0;
+ term_value = atoi (term_tmp);
+ logf (LOG_DEBUG, "Relation <=");
+ gen_regular_rel (term_tmp, term_value, 1);
+ break;
+ case 4:
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
+ return 0;
+ term_value = atoi (term_tmp);
+ logf (LOG_DEBUG, "Relation >=");
+ gen_regular_rel (term_tmp, term_value, 0);
+ break;
+ case 5:
+ if (!term_100 (zi->zebra_maps, reg_type, term_sub, term_tmp, 1))
+ return 0;
+ term_value = atoi (term_tmp);
+ logf (LOG_DEBUG, "Relation >");
+ gen_regular_rel (term_tmp, term_value+1, 0);
+ break;
+ default:
+ return 0;
+ }
+ logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
+ r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info, max_pos,
+ 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);
+ return 1;
+}
+
+static int field_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ const char **term_sub,
+ oid_value attributeSet, struct grep_info *grep_info,
+ int reg_type, int complete_flag,
+ int num_bases, char **basenames)
+{
+ char term_dict[2*IT_MAX_WORD+2];
+ int j, r, base_no;
+ AttrType truncation;
+ int truncation_value;
+ AttrType use;
+ int use_value;
+ oid_value curAttributeSet = attributeSet;
+ const char *termp;
+ struct rpn_char_map_info rcmi;
+ int space_split = complete_flag ? 0 : 1;
+
+ rpn_char_map_prepare (zi, reg_type, &rcmi);
+ attr_init (&use, zapt, 1);
+ use_value = attr_find (&use, &curAttributeSet);
+ logf (LOG_DEBUG, "field_term, use value %d", use_value);
+ attr_init (&truncation, zapt, 5);
+ truncation_value = attr_find (&truncation, NULL);
+ logf (LOG_DEBUG, "truncation value %d", truncation_value);
+
+ if (use_value == -1)
+ use_value = 1016;
+
+ for (base_no = 0; base_no < num_bases; base_no++)
+ {
+ attent attp;
+ data1_local_attribute *local_attr;
+ int max_pos, prefix_len = 0;
+
+ termp = *term_sub;
+ if ((r=att_getentbyatt (zi, &attp, curAttributeSet, use_value)))
+ {
+ logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
+ curAttributeSet, use_value, r);
+ if (r == -1)
+ zi->errCode = 114;
+ else
+ zi->errCode = 121;
+ return -1;
+ }
+ if (zebTargetInfo_curDatabase (zi->zti, basenames[base_no]))
+ {
+ zi->errCode = 109; /* Database unavailable */
+ zi->errString = basenames[base_no];
+ return -1;
+ }
+ for (local_attr = attp.local_attributes; local_attr;
+ local_attr = local_attr->next)
+ {
+ int ord;
+
+ ord = zebTargetInfo_lookupSU (zi->zti, attp.attset_ordinal,
+ local_attr->local);
+ if (ord < 0)
+ continue;
+ if (prefix_len)
+ term_dict[prefix_len++] = '|';
+ else
+ term_dict[prefix_len++] = '(';
+ term_dict[prefix_len++] = 1;
+ term_dict[prefix_len++] = ord;
+ }
+ if (!prefix_len)
+ {
+ zi->errCode = 114;
+ return -1;
+ }
+ term_dict[prefix_len++] = ')';
+ term_dict[prefix_len++] = 1;
+ term_dict[prefix_len++] = reg_type;
+ logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
+ term_dict[prefix_len] = '\0';
+ if (!relational_term (zi, zapt, &termp, term_dict,
+ attributeSet, grep_info, &max_pos, reg_type))
+ {
+ j = prefix_len;
+ switch (truncation_value)
+ {
+ case -1: /* not specified */
+ case 100: /* do not truncate */
+ term_dict[j++] = '(';
+ if (!term_100 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
+ return 0;
+ strcat (term_dict, ")");
+ r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=none:%d", r);
+ break;
+ case 1: /* right truncation */
+ term_dict[j++] = '(';
+ if (!term_100 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
+ return 0;
+ strcat (term_dict, ".*)");
+ dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
+ &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 */
+ term_dict[j++] = '(';
+ if (!term_101 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
+ return 0;
+ strcat (term_dict, ")");
+ r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r);
+ break;
+ case 102: /* Regexp-1 */
+ term_dict[j++] = '(';
+ if (!term_102 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, space_split))
+ return 0;
+ strcat (term_dict, ")");
+ logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
+ r = dict_lookup_grep (zi->dict, term_dict, 0, grep_info,
+ &max_pos, 0, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
+ r);
+ break;
+ case 103: /* Regexp-2 */
+ r = 1;
+ term_dict[j++] = '(';
+ if (!term_103 (zi->zebra_maps, reg_type,
+ &termp, term_dict + j, &r, space_split))
+ return 0;
+ strcat (term_dict, ")");
+ logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
+ r = dict_lookup_grep (zi->dict, term_dict, r, grep_info,
+ &max_pos, 2, grep_handle);
+ if (r)
+ logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
+ r);
+ break;
+ }
+ }
+ }
+ *term_sub = termp;
+ logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);