Lines Matching full:pstr
24 re_string_t *pstr,
43 re_string_allocate (re_string_t *pstr, const char *str, Idx len, Idx init_len,
53 re_string_construct_common (str, len, pstr, trans, icase, dfa);
55 ret = re_string_realloc_buffers (pstr, init_buf_len);
59 pstr->word_char = dfa->word_char;
60 pstr->word_ops_used = dfa->word_ops_used;
61 pstr->mbs = pstr->mbs_allocated ? pstr->mbs : (unsigned char *) str;
62 pstr->valid_len = (pstr->mbs_allocated || dfa->mb_cur_max > 1) ? 0 : len;
63 pstr->valid_raw_len = pstr->valid_len;
71 re_string_construct (re_string_t *pstr, const char *str, Idx len,
75 memset (pstr, '\0', sizeof (re_string_t));
76 re_string_construct_common (str, len, pstr, trans, icase, dfa);
80 ret = re_string_realloc_buffers (pstr, len + 1);
84 pstr->mbs = pstr->mbs_allocated ? pstr->mbs : (unsigned char *) str;
93 ret = build_wcs_upper_buffer (pstr);
96 if (pstr->valid_raw_len >= len)
98 if (pstr->bufs_len > pstr->valid_len + dfa->mb_cur_max)
100 ret = re_string_realloc_buffers (pstr, pstr->bufs_len * 2);
107 build_upper_buffer (pstr);
113 build_wcs_buffer (pstr);
118 re_string_translate_buffer (pstr);
121 pstr->valid_len = pstr->bufs_len;
122 pstr->valid_raw_len = pstr->bufs_len;
134 re_string_realloc_buffers (re_string_t *pstr, Idx new_buf_len)
137 if (pstr->mb_cur_max > 1)
146 new_wcs = re_realloc (pstr->wcs, wint_t, new_buf_len);
149 pstr->wcs = new_wcs;
150 if (pstr->offsets != NULL)
152 Idx *new_offsets = re_realloc (pstr->offsets, Idx, new_buf_len);
155 pstr->offsets = new_offsets;
159 if (pstr->mbs_allocated)
161 unsigned char *new_mbs = re_realloc (pstr->mbs, unsigned char,
165 pstr->mbs = new_mbs;
167 pstr->bufs_len = new_buf_len;
174 re_string_construct_common (const char *str, Idx len, re_string_t *pstr,
178 pstr->raw_mbs = (const unsigned char *) str;
179 pstr->len = len;
180 pstr->raw_len = len;
181 pstr->trans = trans;
182 pstr->icase = icase;
183 pstr->mbs_allocated = (trans != NULL || icase);
184 pstr->mb_cur_max = dfa->mb_cur_max;
185 pstr->is_utf8 = dfa->is_utf8;
186 pstr->map_notascii = dfa->map_notascii;
187 pstr->stop = pstr->len;
188 pstr->raw_stop = pstr->stop;
193 /* Build wide character buffer PSTR->WCS.
201 Note that this function assumes PSTR->VALID_LEN elements are already
202 built and starts from PSTR->VALID_LEN. */
206 build_wcs_buffer (re_string_t *pstr)
210 assert (MB_LEN_MAX >= pstr->mb_cur_max);
218 /* Build the buffers from pstr->valid_len to either pstr->len or
219 pstr->bufs_len. */
220 end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
221 for (byte_idx = pstr->valid_len; byte_idx < end_idx;)
227 prev_st = pstr->cur_state;
229 if (BE (pstr->trans != NULL, 0))
233 for (i = 0; i < pstr->mb_cur_max && i < remain_len; ++i)
235 ch = pstr->raw_mbs [pstr->raw_mbs_idx + byte_idx + i];
236 buf[i] = pstr->mbs[byte_idx + i] = pstr->trans[ch];
241 p = (const char *) pstr->raw_mbs + pstr->raw_mbs_idx + byte_idx;
242 mbclen = __mbrtowc (&wc, p, remain_len, &pstr->cur_state);
246 pstr->cur_state = prev_st;
253 wc = (wchar_t) pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
254 if (BE (pstr->trans != NULL, 0))
255 wc = pstr->trans[wc];
256 pstr->cur_state = prev_st;
260 pstr->wcs[byte_idx++] = wc;
263 pstr->wcs[byte_idx++] = WEOF;
265 pstr->valid_len = byte_idx;
266 pstr->valid_raw_len = byte_idx;
269 /* Build wide character buffer PSTR->WCS like build_wcs_buffer,
274 build_wcs_upper_buffer (re_string_t *pstr)
281 assert (MB_LEN_MAX >= pstr->mb_cur_max);
286 byte_idx = pstr->valid_len;
287 end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
291 if (! pstr->map_notascii && pstr->trans == NULL && !pstr->offsets_needed)
297 if (isascii (pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx])
298 && mbsinit (&pstr->cur_state))
301 pstr->mbs[byte_idx]
302 = toupper (pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx]);
305 pstr->wcs[byte_idx] = (wchar_t) pstr->mbs[byte_idx];
311 prev_st = pstr->cur_state;
313 ((const char *) pstr->raw_mbs + pstr->raw_mbs_idx
314 + byte_idx), remain_len, &pstr->cur_state);
325 memcpy (pstr->mbs + byte_idx, buf, mbclen);
333 memcpy (pstr->mbs + byte_idx,
334 pstr->raw_mbs + pstr->raw_mbs_idx + byte_idx, mbclen);
335 pstr->wcs[byte_idx++] = wcu;
338 pstr->wcs[byte_idx++] = WEOF;
343 int ch = pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
344 pstr->mbs[byte_idx] = ch;
346 pstr->wcs[byte_idx++] = (wchar_t) ch;
348 pstr->cur_state = prev_st;
353 pstr->cur_state = prev_st;
357 pstr->valid_len = byte_idx;
358 pstr->valid_raw_len = byte_idx;
362 for (src_idx = pstr->valid_raw_len; byte_idx < end_idx;)
368 prev_st = pstr->cur_state;
369 if (BE (pstr->trans != NULL, 0))
373 for (i = 0; i < pstr->mb_cur_max && i < remain_len; ++i)
375 ch = pstr->raw_mbs [pstr->raw_mbs_idx + src_idx + i];
376 buf[i] = pstr->trans[ch];
381 p = (const char *) pstr->raw_mbs + pstr->raw_mbs_idx + src_idx;
382 mbclen = __mbrtowc (&wc, p, remain_len, &pstr->cur_state);
393 memcpy (pstr->mbs + byte_idx, buf, mbclen);
398 if (byte_idx + mbcdlen > pstr->bufs_len)
400 pstr->cur_state = prev_st;
404 if (pstr->offsets == NULL)
406 pstr->offsets = re_malloc (Idx, pstr->bufs_len);
408 if (pstr->offsets == NULL)
411 if (!pstr->offsets_needed)
414 pstr->offsets[i] = i;
415 pstr->offsets_needed = 1;
418 memcpy (pstr->mbs + byte_idx, buf, mbcdlen);
419 pstr->wcs[byte_idx] = wcu;
420 pstr->offsets[byte_idx] = src_idx;
423 pstr->offsets[byte_idx + i]
425 pstr->wcs[byte_idx + i] = WEOF;
427 pstr->len += mbcdlen - mbclen;
428 if (pstr->raw_stop > src_idx)
429 pstr->stop += mbcdlen - mbclen;
430 end_idx = (pstr->bufs_len > pstr->len)
431 ? pstr->len : pstr->bufs_len;
437 memcpy (pstr->mbs + byte_idx, p, mbclen);
440 memcpy (pstr->mbs + byte_idx, p, mbclen);
442 if (BE (pstr->offsets_needed != 0, 0))
446 pstr->offsets[byte_idx + i] = src_idx + i;
450 pstr->wcs[byte_idx++] = wcu;
453 pstr->wcs[byte_idx++] = WEOF;
458 int ch = pstr->raw_mbs[pstr->raw_mbs_idx + src_idx];
460 if (BE (pstr->trans != NULL, 0))
461 ch = pstr->trans [ch];
462 pstr->mbs[byte_idx] = ch;
464 if (BE (pstr->offsets_needed != 0, 0))
465 pstr->offsets[byte_idx] = src_idx;
469 pstr->wcs[byte_idx++] = (wchar_t) ch;
471 pstr->cur_state = prev_st;
476 pstr->cur_state = prev_st;
480 pstr->valid_len = byte_idx;
481 pstr->valid_raw_len = src_idx;
490 re_string_skip_chars (re_string_t *pstr, Idx new_raw_idx, wint_t *last_wc)
498 for (rawbuf_idx = pstr->raw_mbs_idx + pstr->valid_raw_len;
503 remain_len = pstr->len - rawbuf_idx;
504 prev_st = pstr->cur_state;
505 mbclen = __mbrtowc (&wc2, (const char *) pstr->raw_mbs + rawbuf_idx,
506 remain_len, &pstr->cur_state);
513 wc = *(unsigned char *) (pstr->raw_mbs + rawbuf_idx);
515 pstr->cur_state = prev_st;
527 /* Build the buffer PSTR->MBS, and apply the translation if we need.
532 build_upper_buffer (re_string_t *pstr)
535 end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
537 for (char_idx = pstr->valid_len; char_idx < end_idx; ++char_idx)
539 int ch = pstr->raw_mbs[pstr->raw_mbs_idx + char_idx];
540 if (BE (pstr->trans != NULL, 0))
541 ch = pstr->trans[ch];
543 pstr->mbs[char_idx] = toupper (ch);
545 pstr->mbs[char_idx] = ch;
547 pstr->valid_len = char_idx;
548 pstr->valid_raw_len = char_idx;
551 /* Apply TRANS to the buffer in PSTR. */
555 re_string_translate_buffer (re_string_t *pstr)
558 end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
560 for (buf_idx = pstr->valid_len; buf_idx < end_idx; ++buf_idx)
562 int ch = pstr->raw_mbs[pstr->raw_mbs_idx + buf_idx];
563 pstr->mbs[buf_idx] = pstr->trans[ch];
566 pstr->valid_len = buf_idx;
567 pstr->valid_raw_len = buf_idx;
571 Concretely, convert to wide character in case of pstr->mb_cur_max > 1,
576 re_string_reconstruct (re_string_t *pstr, Idx idx, int eflags)
580 if (BE (pstr
581 offset = idx - pstr->raw_mbs_idx;
586 if (pstr->mb_cur_max > 1)
587 memset (&pstr->cur_state, '\0', sizeof (mbstate_t));
589 pstr->len = pstr->raw_len;
590 pstr->stop = pstr->raw_stop;
591 pstr->valid_len = 0;
592 pstr->raw_mbs_idx = 0;
593 pstr->valid_raw_len = 0;
594 pstr->offsets_needed = 0;
595 pstr->tip_context = ((eflags & REG_NOTBOL) ? CONTEXT_BEGBUF
597 if (!pstr->mbs_allocated)
598 pstr->mbs = (unsigned char *) pstr->raw_mbs;
605 if (BE (offset < pstr->valid_raw_len, 1))
609 if (BE (pstr->offsets_needed, 0))
611 Idx low = 0, high = pstr->valid_len, mid;
615 if (pstr->offsets[mid] > offset)
617 else if (pstr->offsets[mid] < offset)
623 if (pstr->offsets[mid] < offset)
625 pstr->tip_context = re_string_context_at (pstr, mid - 1,
631 if (pstr->valid_len > offset
632 && mid == offset && pstr->offsets[mid] == offset)
634 memmove (pstr->wcs, pstr->wcs + offset,
635 (pstr->valid_len - offset) * sizeof (wint_t));
636 memmove (pstr->mbs, pstr->mbs + offset, pstr->valid_len - offset);
637 pstr->valid_len -= offset;
638 pstr->valid_raw_len -= offset;
639 for (low = 0; low < pstr->valid_len; low++)
640 pstr->offsets[low] = pstr->offsets[low + offset] - offset;
646 pstr->len = pstr->raw_len - idx + offset;
647 pstr->stop = pstr->raw_stop - idx + offset;
648 pstr->offsets_needed = 0;
649 while (mid > 0 && pstr->offsets[mid - 1] == offset)
651 while (mid < pstr->valid_len)
652 if (pstr->wcs[mid] != WEOF)
656 if (mid == pstr->valid_len)
657 pstr->valid_len = 0;
660 pstr->valid_len = pstr->offsets[mid] - offset;
661 if (pstr->valid_len)
663 for (low = 0; low < pstr->valid_len; ++low)
664 pstr->wcs[low] = WEOF;
665 memset (pstr->mbs, 255, pstr->valid_len);
668 pstr->valid_raw_len = pstr->valid_len;
674 pstr->tip_context = re_string_context_at (pstr, offset - 1,
677 if (pstr->mb_cur_max > 1)
678 memmove (pstr->wcs, pstr->wcs + offset,
679 (pstr->valid_len - offset) * sizeof (wint_t));
681 if (BE (pstr->mbs_allocated, 0))
682 memmove (pstr->mbs, pstr->mbs + offset,
683 pstr->valid_len - offset);
684 pstr->valid_len -= offset;
685 pstr->valid_raw_len -= offset;
687 assert (pstr->valid_len > 0);
695 Idx prev_valid_len = pstr->valid_len;
697 if (BE (pstr->offsets_needed, 0))
699 pstr->len = pstr->raw_len - idx + offset;
700 pstr->stop = pstr->raw_stop - idx + offset;
701 pstr->offsets_needed = 0;
704 pstr->valid_len = 0;
706 if (pstr->mb_cur_max > 1)
711 if (pstr->is_utf8)
717 raw = pstr->raw_mbs + pstr->raw_mbs_idx;
718 end = raw + (offset - pstr->mb_cur_max);
719 if (end < pstr->raw_mbs)
720 end = pstr->raw_mbs;
725 if (isascii (*p) && BE (pstr->trans == NULL, 1))
727 memset (&pstr->cur_state, '\0', sizeof (mbstate_t));
728 /* pstr->valid_len = 0; */
738 Idx mlen = raw + pstr->len - p;
742 if (BE (pstr->trans != NULL, 0))
746 buf[i] = pstr->trans[p[i]];
756 memset (&pstr->cur_state, '\0',
758 pstr->valid_len = mbclen - (raw + offset - p);
766 pstr->valid_len = re_string_skip_chars (pstr, idx, &wc) - idx;
768 pstr->tip_context
769 = re_string_context_at (pstr, prev_valid_len - 1, eflags);
771 pstr->tip_context = ((BE (pstr->word_ops_used != 0, 0)
775 && pstr->newline_anchor)
777 if (BE (pstr->valid_len, 0))
779 for (wcs_idx = 0; wcs_idx < pstr->valid_len; ++wcs_idx)
780 pstr->wcs[wcs_idx] = WEOF;
781 if (pstr->mbs_allocated)
782 memset (pstr->mbs, 255, pstr->valid_len);
784 pstr->valid_raw_len = pstr->valid_len;
789 int c = pstr->raw_mbs[pstr->raw_mbs_idx + offset - 1];
790 pstr->valid_raw_len = 0;
791 if (pstr->trans)
792 c = pstr->trans[c];
793 pstr->tip_context = (bitset_contain (pstr->word_char, c)
795 : ((IS_NEWLINE (c) && pstr->newline_anchor)
799 if (!BE (pstr->mbs_allocated, 0))
800 pstr->mbs += offset;
802 pstr->raw_mbs_idx = idx;
803 pstr->len -= offset;
804 pstr->stop -= offset;
808 if (pstr->mb_cur_max > 1)
810 if (pstr->icase)
812 reg_errcode_t ret = build_wcs_upper_buffer (pstr);
817 build_wcs_buffer (pstr);
821 if (BE (pstr->mbs_allocated, 0))
823 if (pstr->icase)
824 build_upper_buffer (pstr);
825 else if (pstr->trans != NULL)
826 re_string_translate_buffer (pstr);
829 pstr->valid_len = pstr->len;
831 pstr->cur_idx = 0;
837 re_string_peek_byte_case (const re_string_t *pstr, Idx idx)
843 if (BE (!pstr->mbs_allocated, 1))
844 return re_string_peek_byte (pstr, idx);
847 if (pstr->mb_cur_max > 1
848 && ! re_string_is_single_byte_char (pstr, pstr->cur_idx + idx))
849 return re_string_peek_byte (pstr, idx);
852 off = pstr->cur_idx + idx;
854 if (pstr->offsets_needed)
855 off = pstr->offsets[off];
858 ch = pstr->raw_mbs[pstr->raw_mbs_idx + off];
865 if (pstr->offsets_needed && !isascii (ch))
866 return re_string_peek_byte (pstr, idx);
874 re_string_fetch_byte_case (re_string_t *pstr)
876 if (BE (!pstr->mbs_allocated, 1))
877 return re_string_fetch_byte (pstr);
880 if (pstr->offsets_needed)
892 if (!re_string_first_byte (pstr, pstr->cur_idx))
893 return re_string_fetch_byte (pstr);
895 off = pstr->offsets[pstr->cur_idx];
896 ch = pstr->raw_mbs[pstr->raw_mbs_idx + off];
899 return re_string_fetch_byte (pstr);
901 re_string_skip_bytes (pstr,
902 re_string_char_size_at (pstr, pstr->cur_idx));
907 return pstr->raw_mbs[pstr->raw_mbs_idx + pstr->cur_idx++];
912 re_string_destruct (re_string_t *pstr)
915 re_free (pstr->wcs);
916 re_free (pstr->offsets);
918 if (pstr->mbs_allocated)
919 re_free (pstr->mbs);
