[luatex] String manipulation in Lua.

[Paul Isambert]

Le 03/12/2010 00:22, Philipp Gesang a écrit :
> On 2010-12-02<20:59:51>, Paul Isambert wrote:
>> local sub, gsub = string.sub, string.gsub
>> function isub (str, pattern, replace, index, num)
>>    -- Extract the suffix starting at given index
>>    local s1 = sub(str, index)
>>    -- Make the replacement on the suffix
>>    local s2 = gsub(s1, pattern, replace, num)
>>    -- Replace the suffix in the string with it modified version
>>    return gsub(str, s1 .. "$", s2)
>> end
>>
>> It works, but I find the solution an overkill for what seems to be a
>> basic operation. So, as I like to ask: have I missed something?
> Hi Paul,
>
> “string.sub” takes an optional third argument so that you can do
> something like this:
>
> ···8<····························································
>
> local sub, gsub = string.sub, string.gsub
> function isub (str, pattern, replace, index, num)
>    local left  = sub(str, 1, index-1)
>    local right = sub(str,index):gsub(pattern, replace, num)
>    return left .. right
> end
>
> print(isub("abc)abc%def-def",   "b",   "B", 4))
> print(isub("abc)abc%def-def", "def", "FED", 1, 1))
>
> ···8<····························································

Thank you Philip. That's what I'd figured out in the meanwhile. So there 
is no "primitive" isub...

> If you encounter problems with magic characters in patterns,
> there is some assistance waiting in the context helper libs:
> http://wiki.contextgarden.net/String_Manipulation#string.escapedpattern.28string.29_.7C_string.partialescapedpattern.28string.29

Are you trying to lure me into ConTeXt? :)
Nice to get inspiration from, though.

> PS: What’s the problem with lpeg, anyways?

Nothing, but I don't know how to use it and it seems to me it can't be 
used lightly; and for the moment I have other things to do.
Your code, for instance, which seems to involve a so-called grammar, 
looks really interesting, except I don't know what lpeg.Cmt, lpeg.Cs, 
etc., mean, so to me it's unreadable. [Ok, from what I can read, it does 
the same thing as the above function.]

Best,
Paul

>> (Yes, probably LPeg, but I don't want to go into that for the
>> moment.)
> ···8<····························································
>
> local lpeg = require "lpeg"
> local Cmt, Cs, P, V = lpeg.Cmt, lpeg.Cs, lpeg.P, lpeg.V
>
> local function lpeg_gsub (str, pattern, replacement, threshold, limit)
>      local idx = 1
>      local threshold = threshold or 0
>      local sub_cnt = 0
>
>      local peg = P{
>          [1] = "initial",
>
>          initial = Cs((V"p" + V"other")^0),
>
>          p = Cmt(P(pattern), function (_,_, matched)
>                  if idx>= threshold and
>                     ( (limit ~= nil) and (sub_cnt<  limit) or (limit == nil) )
>                     then
>                      idx = idx + #matched
>                      sub_cnt = sub_cnt + 1
>                      return true
>                  end
>                  return false
>              end) / replacement,
>
>          other = Cmt(1, function () idx = idx + 1 return true end)
>      }
>
>      --peg:print()
>      return peg:match(str)
> end
>
>
> local test = "abcdefg abcdefg abcdefg abcdefg"
>
> print(lpeg_gsub(test, "def", "FED", 10))
> print(lpeg_gsub(test, "def", "FED", 07, 2))
> print(lpeg_gsub(test, "def", "FED", 15))
>
> io.write("\n")
>
> print(lpeg_gsub(test,   "a",   "A", 1, 2))
> print(lpeg_gsub(test,   "b",   "B", 4, 1))
> print(lpeg_gsub(test,   "c",   "C", 9, 0))
> print(lpeg_gsub(test,   "d",   "D", 9))
>
> io.write("\n")
>
> local p1 = P"a" * P(1 - P"g")^1 * P"g"
> local p2 = lpeg.S"bdf"
> local p3 = lpeg.R"dg"
>
> print(lpeg_gsub(test, p1, "O", 9, 1))
> print(lpeg_gsub(test, p2, "O", 1, 3))
> print(lpeg_gsub(test, p3, "O", 22))
>
> ···8<····························································
>
>