`7d332b5`

Fix -F newline splitting and flag interactions

- Split -F patterns on newlines (each line is an OR alternative)
- Add count_subpatterns() and split_pattern_on_newlines() helpers
- Use compiled%count for split pattern count in match_line
- Fix -c with -l: only print filename when count > 0
- Fix -o with -c: count mode takes priority over only-matching

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

SHA: 7d332b5abc3dbd6b2ffc8b62724498a3cd0eee24
Parents: a3c0ed6
Tree: f5fbf8a

1 changed file

Status	File	+	-
M	`src/ferp_matcher.f90`	145	10

src/ferp_matcher.f90modified

      type(compiled_patterns_t), intent(out) :: compiled
      integer, intent(out) :: ierr
 -    integer :: i, n, plen
 +    integer :: i, j, n, plen, total_subpats, subpat_count
      logical :: is_ere
      character(len=max_pattern_len) :: pattern
 +    character(len=max_pattern_len), allocatable :: subpatterns(:)
      ierr = 0
      n = size(patterns)
      ! Use Boyer-Moore for fixed string patterns
      if (compiled%is_fixed) then
 -      allocate(compiled%bm_pats(n))
 +      ! For -F mode, patterns containing newlines should be split into multiple patterns
 +      ! First count total subpatterns
 +      total_subpats = 0
 +      do i = 1, n
 +        total_subpats = total_subpats + count_subpatterns(patterns(i))
 +      end do
++
 +      allocate(compiled%bm_pats(total_subpats))
 +      allocate(subpatterns(total_subpats))
 +      ! Split patterns on newlines
 +      j = 0
        do i = 1, n
 -        plen = pattern_len(patterns(i))
 +        call split_pattern_on_newlines(patterns(i), subpatterns, j)
 +      end do
++
 +      compiled%count = j
++
 +      ! Compile each subpattern
 +      do i = 1, j
 +        plen = pattern_len(subpatterns(i))
          ! For case-insensitive, convert pattern to lowercase
          if (opts%ignore_case) then
 -          call bm_compile(compiled%bm_pats(i), patterns(i)(1:plen), .true.)
 +          call bm_compile(compiled%bm_pats(i), subpatterns(i)(1:plen), .true.)
          else
 -          call bm_compile(compiled%bm_pats(i), patterns(i)(1:plen), .false.)
 +          call bm_compile(compiled%bm_pats(i), subpatterns(i)(1:plen), .false.)
          end if
        end do
 +      deallocate(subpatterns)
        compiled%compiled = .true.
        return
      end if
      type(compiled_patterns_t), intent(inout), optional :: compiled  ! inout for DFA cache
      logical :: matches
 -    integer :: i
 +    integer :: i, num_patterns
      character(len=:), allocatable :: search_line
      character(len=max_pattern_len) :: search_pattern
        search_line = line
      end if
 +    ! Determine number of patterns to try
 +    ! For -F mode with compiled patterns, use compiled%count (may differ due to newline splitting)
 +    if (present(compiled) .and. compiled%compiled .and. compiled%is_fixed) then
 +      num_patterns = compiled%count
 +    else
 +      num_patterns = size(patterns)
 +    end if
++
      ! Try each pattern
 -    do i = 1, size(patterns)
 +    do i = 1, num_patterns
        ! Match based on pattern type
        select case (opts%pattern_type)
          case (PATTERN_FIXED)
      ! Handle count mode
      if (opts%count_only) then
 -      call print_count(match_count, src%filename, opts)
 +      ! When -l is also set, only print filename for files with matches
 +      if (opts%files_with_matches) then
 +        if (match_count > 0) then
 +          call print_filename(src%filename, opts)
 +        end if
 +      else
 +        call print_count(match_count, src%filename, opts)
 +      end if
      end if
    end function process_source_batch
      logical :: need_separator  ! Need to print -- before next output
      logical :: use_context
      integer :: k
 +    integer(i64) :: file_size
++
 +    ! Calculate line number width for -T alignment (based on file size)
 +    if (opts%initial_tab) then
 +      if (src%source_type == SOURCE_MMAP .and. src%mmap_file%size > 0) then
 +        file_size = src%mmap_file%size
 +        if (file_size < 10) then
 +          opts%line_number_width = 1
 +        else if (file_size < 100) then
 +          opts%line_number_width = 2
 +        else if (file_size < 1000) then
 +          opts%line_number_width = 3
 +        else if (file_size < 10000) then
 +          opts%line_number_width = 4
 +        else if (file_size < 100000) then
 +          opts%line_number_width = 5
 +        else if (file_size < 1000000) then
 +          opts%line_number_width = 6
 +        else
 +          opts%line_number_width = 7
 +        end if
 +      else
 +        ! Stdin or unknown: use large default for alignment
 +        opts%line_number_width = 7
 +      end if
 +    end if
      ! Try optimized batch mode for simple cases
      if (present(compiled) .and. compiled%compiled .and. can_use_batch_mode(src, opts)) then
            call print_filename(src%filename, opts)
            if (allocated(before_buffer)) deallocate(before_buffer)
            return
 -        else if (opts%only_matching) then
 +        else if (opts%only_matching .and. .not. opts%count_only) then
 +          ! -o mode: print each match (but -c takes priority)
            if (present(compiled)) then
              call find_matches(line, patterns, opts, compiled, match_starts, match_ends, num_matches)
            else
      ! Handle -c (count) mode
      if (opts%count_only) then
 -      call print_count(match_count, src%filename, opts)
 +      ! When -l is also set, only print filename for files with matches
 +      if (opts%files_with_matches) then
 +        if (match_count > 0) then
 +          call print_filename(src%filename, opts)
 +        end if
 +      else
 +        call print_count(match_count, src%filename, opts)
 +      end if
      end if
      ! Handle -L (files without match) mode
    end function process_source
 +  function count_subpatterns(pattern) result(count)
 +    !> Count the number of subpatterns when splitting on newlines
 +    !> Returns at least 1 for any non-empty pattern
 +    character(len=*), intent(in) :: pattern
 +    integer :: count
++
 +    integer :: i, plen
++
 +    plen = pattern_len(pattern)
 +    if (plen == 0) then
 +      count = 0
 +      return
 +    end if
++
 +    count = 1
 +    do i = 1, plen
 +      if (pattern(i:i) == char(10)) then
 +        count = count + 1
 +      end if
 +    end do
++
 +  end function count_subpatterns
++
 +  subroutine split_pattern_on_newlines(pattern, subpatterns, next_idx)
 +    !> Split a pattern on newline characters into multiple subpatterns
 +    !> Appends subpatterns to the array starting at next_idx+1
 +    character(len=*), intent(in) :: pattern
 +    character(len=max_pattern_len), intent(inout) :: subpatterns(:)
 +    integer, intent(inout) :: next_idx
++
 +    integer :: i, plen, start_pos, subpat_len
++
 +    plen = pattern_len(pattern)
 +    if (plen == 0) return
++
 +    start_pos = 1
 +    do i = 1, plen
 +      if (pattern(i:i) == char(10)) then
 +        ! Found a newline - extract subpattern
 +        subpat_len = i - start_pos
 +        if (subpat_len > 0) then
 +          next_idx = next_idx + 1
 +          subpatterns(next_idx) = pattern(start_pos:i-1)
 +          ! Add null terminator
 +          subpatterns(next_idx)(subpat_len+1:subpat_len+1) = char(0)
 +        else
 +          ! Empty subpattern (consecutive newlines or newline at start)
 +          next_idx = next_idx + 1
 +          subpatterns(next_idx) = char(0)
 +        end if
 +        start_pos = i + 1
 +      end if
 +    end do
++
 +    ! Handle last segment (after final newline or entire string if no newlines)
 +    if (start_pos <= plen) then
 +      subpat_len = plen - start_pos + 1
 +      next_idx = next_idx + 1
 +      subpatterns(next_idx) = pattern(start_pos:plen)
 +      ! Add null terminator
 +      if (subpat_len < max_pattern_len) then
 +        subpatterns(next_idx)(subpat_len+1:subpat_len+1) = char(0)
 +      end if
 +    end if
++
 +  end subroutine split_pattern_on_newlines
++
  end module ferp_matcher