introduce join_spaced functionality (#3)

Author: perazz

README.md

@@ -33,7 +33,6 @@ tokens = split('whatever ',success=success)
 ! With complete error flag
 tokens = split('whatever ',error)
 print *, 'error message=',error%string
-
 ```
 
 And the `shlex` function has the same API, but returns a list of `type(shlex_token)`s instead of an allocatable character array. 
@@ -55,8 +54,24 @@ tokens = shlex('whatever ',success=success)
 tokens = shlex('whatever ',error)
 print *, 'error message=',error%string
 
+---
+
+## Version 1.1.0 - `join_spaced` to combine spaced compiler flags
+
+Starting with version **1.1.0**, a new high-level interface is available:
+
+```fortran
+tokens = split_joined_bool('gfortran -I /include -L /lib -lm', join_spaced=.true., success=success)
 ```
 
+When the second argument (`join_spaced`) is `.true.`, `split_joined_bool()` will:
+- combine spaced flags like `-I /path` into `-I/path`
+- work for any single-letter flags (e.g., `-I`, `-L`, `-D`) if the next token does *not* begin with `-`
+- still respect quotes and shell-like rules for escaping
+
+This is useful for parsing compiler and linker flags where `-I`, `-L`, etc. may be followed by a separate token due to quoting or formatting.
+
+---
 
 ## License
 

src/shlex_module.f90

@@ -24,14 +24,16 @@ module shlex_module
     public :: shlex
     interface shlex
         module procedure shlex_bool
-        module procedure shlex_error
+        module procedure shlex_error        
     end interface
 
     ! Split: return split strings
     public :: split
     interface split
         module procedure split_bool
         module procedure split_error
+        module procedure split_joined_bool
+        module procedure split_joined_error
     end interface
 
     ! Turn on verbosity for debugging
@@ -156,22 +158,100 @@ function split_error(pattern,error) result(list)
 
         type(shlex_token), allocatable :: tokens(:)
 
-        integer :: n,maxlen,i,l
-
         tokens = shlex(pattern,error)
+        call tokens_to_strings(tokens,list)
 
+    end function split_error
+    
+    ! Convert a list of tokens to strings
+    pure subroutine tokens_to_strings(tokens,list)
+        type(shlex_token), optional, intent(in) :: tokens(:)
+        character(kind=SCK,len=:), allocatable, intent(out) :: list(:)
+        
+        integer :: n,maxlen,i
+        
         n      = size(tokens)
         maxlen = 0
+        
         do i=1,n
            maxlen = max(maxlen,len(tokens(i)%string))
         end do
 
         allocate(character(kind=SCK,len=maxlen) :: list(n))
         do i=1,n
             list(i) = tokens(i)%string
-        end do
+        end do        
+        
+    end subroutine tokens_to_strings
+
+    ! High level interface: also join spaced flags like -I /path -> -I/path
+    function split_joined_bool(pattern, join_spaced, success) result(list)
+        character(*),      intent(in)   :: pattern
+        logical,           intent(in)   :: join_spaced
+        logical,           intent(out)  :: success
+        character(kind=SCK,len=:), allocatable :: list(:)
+        type(shlex_token) :: error
 
-    end function split_error
+        list = split_joined_error(pattern, join_spaced, error)
+        success = error%type==NO_ERROR        
+        
+    end function split_joined_bool
+
+    ! High level interface: also join spaced flags like -I /path -> -I/path
+    function split_joined_error(pattern, join_spaced, error) result(list)
+        character(*),      intent(in)  :: pattern
+        type(shlex_token), intent(out) :: error
+        logical,           intent(in)  :: join_spaced
+        character(kind=SCK,len=:), allocatable :: list(:)
+
+        integer :: i, n, count
+        type(shlex_token) :: tok, next_tok
+        type(shlex_token), allocatable :: raw(:),joined(:)
+
+        raw = shlex(pattern,error)
+
+        if (error%type/=NO_ERROR .or. .not. join_spaced) then
+            
+            call tokens_to_strings(raw,list)
+            
+        else
+            
+            n = size(raw)
+            
+            allocate(joined(n))
+            count = 0
+            i = 1
+
+            old_tokens: do while (i <= n)
+                tok = raw(i)
+                
+                if (len_trim(tok%string)==2) then 
+                    
+                    if (tok%string(1:1) == '-' .and. &
+                       (tok%string(2:2) >= 'A' .and. tok%string(2:2) <= 'Z' .or. tok%string(2:2) >= 'a' .and. tok%string(2:2) <= 'z')) then
+                        if (i + 1 <= n) then
+                            next_tok = raw(i + 1)
+                            if (.not. (len_trim(next_tok%string) >= 1 .and. next_tok%string(1:1) == '-')) then
+                                count = count + 1
+                                joined(count) = shlex_token(TOKEN_WORD,trim(tok%string)//trim(next_tok%string))
+                                i = i + 2
+                                cycle old_tokens
+                            end if
+                        end if   
+                    endif                    
+                    
+                end if
+
+                count = count + 1
+                joined(count) = tok
+                i = i + 1
+            end do old_tokens
+            
+            call tokens_to_strings(joined(:count),list)
+
+        end if
+
+    end function split_joined_error
 
     ! High level interface: return a list of tokens
     function shlex_bool(pattern,success) result(list)

test/shlex_test.f90

@@ -21,15 +21,14 @@ program shlex_tests
     integer :: nfailed = 0
     integer :: npassed = 0
 
-    integer :: i,length
-    logical :: valid
-    character(len=30) :: pattern,str
-
     call add_test(test_1())
     call add_test(test_2())
     call add_test(test_3())
     call add_test(test_4())
     call add_test(test_5())
+    call add_test(test_joined_1())
+    call add_test(test_joined_2())
+    call add_test(test_joined_3())
 
 
     if (nfailed<=0) then
@@ -129,9 +128,6 @@ logical function test_4() result(success)
        end do
     end function test_4
 
-
-
-
     logical function test_5() result(success)
 
        character(*), parameter :: string     = &
@@ -159,5 +155,72 @@ logical function test_5() result(success)
        end do
     end function test_5
 
+    ! fpm case input
+    logical function test_joined_1() result(success)
+
+        character(*), parameter :: string = &
+        '-I/path/to/include -I /test -I"/path/to/include with spaces" -I "spaces here too" -L/path/to/lib -lmylib -O2 -g -Wall'
+
+        character(*), parameter :: results(*) = [character(40) :: &
+            '-I/path/to/include', '-I/test', '-I/path/to/include with spaces', '-Ispaces here too', &
+            '-L/path/to/lib', '-lmylib', '-O2', '-g', '-Wall']
+
+        integer :: i
+        character(len=:), allocatable :: tokens(:)
+
+        tokens = split(string, join_spaced=.true., success=success)
+        if (.not.success) return
+        success = size(tokens) == size(results)
+
+        do i = 1, size(tokens)
+            success = tokens(i) == trim(results(i))
+            if (.not.success) print *, 'token=', tokens(i), ' expected=', results(i)
+            if (.not.success) return
+        end do
+
+    end function test_joined_1
+
+    ! mixed spacing, no quoted flags
+    logical function test_joined_2() result(success)
+
+        character(*), parameter :: string = '-I include -L lib -O3 -Wall -lm'
+        character(*), parameter :: results(*) = [character(10) :: '-Iinclude', '-Llib', '-O3', '-Wall', '-lm']
+
+        integer :: i
+        character(len=:), allocatable :: tokens(:)
+
+        tokens = split(string, .true., success)
+        if (.not.success) return
+        success = size(tokens) == size(results)
+
+        do i = 1, size(tokens)
+            success = tokens(i) == trim(results(i))
+            if (.not.success) print *, 'token=', tokens(i), ' expected=', results(i)
+            if (.not.success) return
+        end do
+
+    end function test_joined_2
+
+    ! ensure flags with attached args are left untouched
+    logical function test_joined_3() result(success)
+
+        character(*), parameter :: string = '-I/path -I /spaced -DMACRO=1 -lfoo'
+        character(*), parameter :: results(*) = [character(20) :: '-I/path', '-I/spaced', '-DMACRO=1', '-lfoo']
+
+        integer :: i
+        character(len=:), allocatable :: tokens(:)
+
+        tokens = split(string, .true., success)
+        if (.not.success) return
+        success = size(tokens) == size(results)
+
+        do i = 1, size(tokens)
+            success = tokens(i) == trim(results(i))
+            if (.not.success) print *, 'token=', tokens(i), ' expected=', results(i)
+            if (.not.success) return
+        end do
+
+    end function test_joined_3
+
 
 end program shlex_tests