Bxdty

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

fun{abc1 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 form{xyz1} efg jkl abc2 EDF2 form{xyz2} efg jkl abc3 EDF3 form{xyz3} efg jkl abc4 EDF2 form{xyz4} ...

Assume for answers form is same type as newcommand{form}[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.

documentclass{article}

usepackage{xparse}



ExplSyntaxOn

NewDocumentCommand{fun}{m}

 {

  % 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



NewDocumentCommand{form}{m}{emph{#1}}



begin{document}



raggedright



fun{Non 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}



end{document}

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

documentclass{article}

usepackage[T1]{fontenc}

usepackage{listofitems,tabto}

newcommandform[1]{emph{#1}}

newcommandfun[1]{%

  setsepchar{ }%

  readlistfunlist{#1}%

  foreachitemxinfunlist{%

    Argument xcnt{} istabto{1.3in}``detokenizeexpandafter{x}'': 

    tabto{2.5in}xpar

  }%

}

begin{document}

fun{abc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 

  efg jkl abc4 EDF2 xyz4 ... abc1 EDF1 form{xyz1} efg jkl abc2 

  EDF2 form{xyz2} efg jkl abc3 EDF3 form{xyz3} efg jkl abc4 

  EDF2 form{xyz4} ...}

end{document}

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):

documentclass{article}

usepackage[T1]{fontenc}

usepackage{listofitems,tabto}

newcommandform[1]{emph{#1}}

newcommandfun[1]{%

  setsepchar{efg jkl/ }%

  readlist*funlist{#1}%

  foreachitemxinfunlist{%

    foreachitemyinfunlist[xcnt]{%

    Group xcnt{} sub-argument ycnt{} istabto{2in}``detokenize

      expandafterexpandafterexpandafter{funlist[xcnt,ycnt]}'': 

    tabto{3.2in}funlist[xcnt,ycnt]par

  }}%

}

begin{document}

fun{abc1 EDF1 xyz1 efg jkl abc2 EDF2 xyz2 efg jkl abc3 EDF3 xyz3 

  efg jkl abc4 EDF2 xyz4 ... abc1 EDF1 form{xyz1} efg jkl abc2 

  EDF2 form{xyz2} efg jkl abc3 EDF3 form{xyz3} efg jkl abc4 

  EDF2 form{xyz4} ...}

end{document}

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

documentclass{article}

usepackage{luacode} % for 'luacode' env. and `luastringN` macro



%% Lua-side code

begin{luacode}

function do_fun ( s )

  tex.sprint ( ( s:gsub ( 

      "(%w+%s*%w+%s*)(%w+)(%s*%w+%s*%w+%s-)" , 

      "%1\form{%2}%3" ) ) )

end

end{luacode}



%% TeX-side code

newcommandfun[1]{directlua{do_fun(luastringN{#1})}}

newcommandform[1]{emph{#1}}



begin{document}



noindent

fun{abc1 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}

end{document}