`6a04d1a`

Update matcher to use pattern_len for -w/-x options

Use explicit pattern lengths when applying word boundary (-w) and
line regexp (-x) transformations. This prevents null terminators
from being included in the transformed patterns.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 6a04d1af1422fb10330a8f4598185ffa84af34cb
Parents: 5263050
Tree: d4260e0

1 changed file

Status	File	+	-
M	`src/ferp_matcher.f90`	37	28

src/ferp_matcher.f90modified

  module ferp_matcher
    !> Pattern matching orchestration for FERP
    !> Thread-safe: no SAVE variables, all buffers are dynamically allocated
--  use ferp_kinds
++  use ferp_kinds, only: i64, max_pattern_len, pattern_len
    use ferp_options
    use ferp_io
    use ferp_output
      type(compiled_patterns_t), intent(out) :: compiled
      integer, intent(out) :: ierr
--    integer :: i, n
++    integer :: i, n, plen
      logical :: is_ere
      character(len=max_pattern_len) :: pattern
        allocate(compiled%bm_pats(n))
        do i = 1, n
--        pattern = patterns(i)
++        plen = pattern_len(patterns(i))
          ! For case-insensitive, convert pattern to lowercase
          if (opts%ignore_case) then
--          call bm_compile(compiled%bm_pats(i), trim(pattern), .true.)
++          call bm_compile(compiled%bm_pats(i), patterns(i)(1:plen), .true.)
          else
--          call bm_compile(compiled%bm_pats(i), trim(pattern), .false.)
++          call bm_compile(compiled%bm_pats(i), patterns(i)(1:plen), .false.)
          end if
        end do
        allocate(compiled%pcres(n))
        do i = 1, n
--        pattern = patterns(i)
++        plen = pattern_len(patterns(i))
          ! Apply -w (word) transformation using PCRE word boundaries
          if (opts%word_regexp) then
--          pattern = '\b' // trim(pattern) // '\b'
++          pattern = '\b' // patterns(i)(1:plen) // '\b'
--        end if
++          plen = plen + 4  ! \b and \b
--
          ! Apply -x (line) transformation
--        if (opts%line_regexp) then
++        else if (opts%line_regexp) then
--          pattern = '^' // trim(pattern) // '$'
++          pattern = '^' // patterns(i)(1:plen) // '$'
++          plen = plen + 2  ! ^ and $
++        else
++          pattern = patterns(i)(1:plen)
          end if
--        call pcre_compile(compiled%pcres(i), trim(pattern), opts%ignore_case, ierr)
++        call pcre_compile(compiled%pcres(i), pattern(1:plen), opts%ignore_case, ierr)
          if (ierr /= 0) then
            compiled%compiled = .false.
            return
      is_ere = (opts%pattern_type == PATTERN_ERE)
      do i = 1, n
--      pattern = patterns(i)
++      plen = pattern_len(patterns(i))
        ! Apply -w (word) transformation
        if (opts%word_regexp .and. opts%pattern_type /= PATTERN_FIXED) then
--        pattern = '\<' // trim(pattern) // '\>'
++        pattern = '\<' // patterns(i)(1:plen) // '\>'
--      end if
++        plen = plen + 4  ! \< and \>
--
        ! Apply -x (line) transformation
--      if (opts%line_regexp .and. opts%pattern_type /= PATTERN_FIXED) then
++      else if (opts%line_regexp .and. opts%pattern_type /= PATTERN_FIXED) then
--        pattern = '^' // trim(pattern) // '$'
++        pattern = '^' // patterns(i)(1:plen) // '$'
++        plen = plen + 2  ! ^ and $
++      else
++        pattern = patterns(i)(1:plen)
        end if
--      call regex_compile(compiled%regexes(i), trim(pattern), is_ere, ierr)
++      ! Compile with exact pattern length
++      call regex_compile(compiled%regexes(i), pattern(1:plen), is_ere, ierr)
        if (ierr /= 0) then
          compiled%compiled = .false.
          return
      matches = .false.
      line_len = len_trim(line)
--    pat_len = len_trim(pattern)
++    pat_len = pattern_len(pattern)  ! Use pattern_len to preserve whitespace patterns
      if (pat_len == 0) then
        ! Empty pattern matches everything
        return
      end if
--    ! Find pattern in line
++    ! Find pattern in line (use exact length, not trim)
--    pos = index(line(1:line_len), trim(pattern))
++    pos = index(line(1:line_len), pattern(1:pat_len))
      if (pos == 0) return
      integer, intent(out) :: match_starts(:), match_ends(:)
      integer, intent(out) :: num_matches
--    integer :: i, pos, line_len
++    integer :: i, pos, line_len, pat_len
      type(match_result_t) :: res
      type(pcre_match_result_t) :: pcre_res
      character(len=:), allocatable :: search_line
        end if
        do i = 1, size(patterns)
++        ! Get pattern length (preserving whitespace patterns)
++        pat_len = pattern_len(patterns(i))
++        if (pat_len == 0) cycle
++
          if (opts%ignore_case) then
--          search_pattern = to_lower(patterns(i))
++          search_pattern = to_lower(patterns(i)(1:pat_len))
          else
--          search_pattern = patterns(i)
++          search_pattern = patterns(i)(1:pat_len)
          end if
          pos = 1
          do while (pos <= line_len)
--          pos = index(search_line(pos:line_len), trim(search_pattern))
++          pos = index(search_line(pos:line_len), search_pattern(1:pat_len))
            if (pos == 0) exit
            ! Adjust for substring offset
            if (num_matches < size(match_starts)) then
              num_matches = num_matches + 1
              match_starts(num_matches) = pos
--            match_ends(num_matches) = pos + len_trim(search_pattern) - 1
++            match_ends(num_matches) = pos + pat_len - 1
            end if
            ! Move past this match
--          pos = pos + len_trim(search_pattern)
++          pos = pos + pat_len
          end do
        end do
        return