disjoin_nfa_each_transition Subroutine

public pure subroutine disjoin_nfa_each_transition(transition, seg_list)

Uses

This subroutine updates the NFA state transitions by disjoining the segments.

It breaks down overlapping segments into non-overlapping segments, and creates new transitions accordingly.

Arguments

Type IntentOptional Attributes Name
type(nfa_transition_t), intent(inout) :: transition
type(segment_t), intent(in) :: seg_list(:)

Source Code

   pure subroutine disjoin_nfa_each_transition(transition, seg_list)
      use :: forgex_segment_m, only: segment_t
      use :: forgex_segment_disjoin_m
      implicit none
      type(nfa_transition_t), intent(inout) :: transition
      type(segment_t),        intent(in) :: seg_list(:)

      type(segment_t), allocatable ::  tmp(:)

      integer :: k, m, n, siz

      if (.not. allocated(transition%c%sps)) return

      siz = size(seg_list, dim=1)

      allocate(tmp(siz))

      block
         logical :: flag(siz)

         n = 0 ! to count valid disjoined segments.
         do k = 1, size(transition%c%sps, dim=1)

            flag(:) = is_overlap_to_seg_list(transition%c%sps(k), seg_list, siz)

            do m = 1, siz
               if (flag(m)) then
                  n = n + 1
                  tmp(n) = seg_list(m)
               end if
            end do

         end do
      end block

      if (n == 0) return

      if (allocated(transition%c%sps)) then
         if (size(transition%c%sps, dim=1) < n) then
            deallocate(transition%c%sps)
            allocate(transition%c%sps(n))
         end if
      end if

      ! Deep copy the result into the arguemnt's component
      do k = 1, n
         transition%c%sps(k) = tmp(k)
      end do

      deallocate(tmp)
   end subroutine disjoin_nfa_each_transition