Bsrhrki

What is a good way to write a definition of the type fun below

funabc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 efg jkl abc4 EDF2 xyz4 ...

where the number of arguments is not known in advance, may be 1, or may be more than 9, like 12, and the result is as below

abc1 EDF1 formxyz1 efg jkl abc2 EDF2 formxyz2 efg jkl abc3 EDF3 formxyz3 efg jkl abc4 EDF2 formxyz4 ...

Assume for answers form is same type as newcommandform[1]emph#1. But delay expansion until the end. Just in case.

Probably requires several nested def cases taking two variables each and a if to decide when to halt the loop ... like when allowing more than 9 arguments to a macro? Or use etoolbox for something better?

If separator words efg jkl are not the same from one place to the next, certain they they are of some specific length, assume efg jkl <=> always 9 characters separating one input from the next. While abc EDF xyz are of different lengths possibly, but always three separate words.

CLARIFICATION: The xyz can be arbitrary. But the sentence is periodic in that the 3rd, 8th, 13th, 18th word is form wrapped. If it exists. At least 3 words exists. But can be 3, and if not 3 then 8, and if not 8 then 13, as long as needed, ends when no separator behind three words which can all differ ... The separator " efg jkl " does repeat with certainty however and can be caught to parse.

documentclassarticle
usepackagexparse

ExplSyntaxOn
NewDocumentCommandfunm
 
 % split the input at the spaces
 seq_set_split:Nnn l_tmpa_seq ~ #1 
 % use a counter for knowing where we are
 int_zero:N l_tmpa_int
 % map the sequence
 seq_map_inline:Nn l_tmpa_seq
 % one more step
 int_incr:N l_tmpa_int
 int_compare:nTF int_mod:nn l_tmpa_int - 3 5 = 0 
 % if we're at the 3rd, 5th, 8th, 13th, ... item, apply form
 form ##1 
 
 % otherwise just deliver the item
 ##1
 
 % if not at the last, add a space
 int_compare:nT l_tmpa_int < seq_count:N l_tmpa_seq ~ 
 
 
ExplSyntaxOff

NewDocumentCommandformmemph#1

begindocument

raggedright

funNon eram nescius Brute cum quae summis ingeniis exquisitaque 
doctrina philosophi Graeco sermone tractavissent ea Latinis 
litteris mandaremus fore ut hic noster labor in varias 
reprehensiones incurreret Nam quibusdam et iis quidem non 
admodum indoctis totum hoc displicet philosophari Quidam 
autem non tam id reprehendunt si remissius agatur sed tantum 
studium tamque multam operam ponendam in eo non arbitrantur 
Erunt etiam et ii quidem eruditi Graecis litteris contemnentes 
Latinas qui se dicant in Graecis legendis operam malle consumere 
Postremo aliquos futuros suspicor qui me ad alias litteras 
vocent genus hoc scribendi etsi sit elegans personae tamen 
et dignitatis esse negent

enddocument

The listofitems package can grab these inputs very easily, preserving the original tokens without expansion.

documentclassarticle
usepackage[T1]fontenc
usepackagelistofitems,tabto
newcommandform[1]emph#1
newcommandfun[1]%
 setsepchar %
 readlistfunlist#1%
 foreachitemxinfunlist[]%
 Argument xcnt istabto1.3in``detokenizeexpandafterx'': 
 tabto2.5inxpar
 %

begindocument
funabc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 
 efg jkl abc4 EDF2 xyz4 ... abc1 EDF1 formxyz1 efg jkl abc2 
 EDF2 formxyz2 efg jkl abc3 EDF3 formxyz3 efg jkl abc4 
 EDF2 formxyz4 ...
enddocument

If you need multi-layer parsing, say that efg jkl is the trigger to separate larger subgroups of arguments, then we have the following (note: efg jkl is not considered an argument, but an argument separator):

documentclassarticle
usepackage[T1]fontenc
usepackagelistofitems,tabto
newcommandform[1]emph#1
newcommandfun[1]%
 setsepcharefg jkl/ %
 readlist*funlist#1%
 foreachitemxinfunlist[]%
 foreachitemyinfunlist[xcnt]%
 Group xcnt sub-argument ycnt istabto2in``detokenize
 expandafterexpandafterexpandafterfunlist[xcnt,ycnt]'': 
 tabto3.2infunlist[xcnt,ycnt]par
 %

begindocument
funabc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 
 efg jkl abc4 EDF2 xyz4 ... abc1 EDF1 formxyz1 efg jkl abc2 
 EDF2 formxyz2 efg jkl abc3 EDF3 formxyz3 efg jkl abc4 
 EDF2 formxyz4 ...
enddocument

Here's a LuaLaTeX-based solution. It employs Lua's powerful string.gsub function to the argument of the fun macro, to encase the third word of each group of five words -- where "word" is any combination of characters and digits delimited by whitespace -- in the argument of fun in a form... "wrapper".

Because luastringN (where N stands for "no expansion") is used in the argument of fun, the argument of fun is not expaneded prior to being passed to the Lua function that does all of the work.

% !TEX TS-program = lualatex
documentclassarticle
usepackageluacode % for 'luacode' env. and `luastringN` macro

%% Lua-side code
beginluacode

function do_fun ( s )
 tex.sprint ( ( s:gsub ( 
 "(%w+%s*%w+%s*)(%w+)(%s*%w+%s*%w+%s-)" , 
 "%1\form%2%3" ) ) )
end

endluacode

%% TeX-side code
newcommandfun[1]directluado_fun(luastringN#1)
newcommandform[1]emph#1

begindocument

noindent
funabc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 efg jkl 
 abc4 EDF4 xyz4 efg jkl abc5 EDF5 xyz5 efg jkl abc6 EDF6 xyz6 efg jkl 
 abc7 EDF7 xyz7 efg jkl abc8 EDF8 xyz8 efg jkl abc9 EDF9 xyz9 efg jkl 
 abc10 EDF10 xyz10 efg jkl abc11 EDF11 xyz11 efg jkl abc12 EDF12 xyz12 efg jkl 
 abc13 EDF13 xyz13 efg jkl abc14 EDF14 xyz14 efg jkl abc15 EDF15 xyz15 efg jkl 
 abc16 EDF16 xyz16 efg jkl abc17 EDF17 xyz17 efg jkl
enddocument