jx_client_neibu/lua_probject/tolua_project/lpeg/re.lua

-- $Id: re.lua,v 1.44 2013/03/26 20:11:40 roberto Exp $

-- imported functions and modules
local tonumber, type, print, error = tonumber, type, print, error
local setmetatable = setmetatable
local m = require "lpeg"

-- 'm' will be used to parse expressions, and 'mm' will be used to
-- create expressions; that is, 're' runs on 'm', creating patterns
-- on 'mm'
local mm = m

-- pattern's metatable
local mt = getmetatable(mm.P(0))



-- No more global accesses after this point
local version = _VERSION
if version == "Lua 5.2" then _ENV = nil end


local any = m.P(1)


-- Pre-defined names
local Predef = { nl = m.P "\n" }


local mem
local fmem
local gmem


local function updatelocale()
  mm.locale(Predef)
  Predef.a = Predef.alpha
  Predef.c = Predef.cntrl
  Predef.d = Predef.digit
  Predef.g = Predef.graph
  Predef.l = Predef.lower
  Predef.p = Predef.punct
  Predef.s = Predef.space
  Predef.u = Predef.upper
  Predef.w = Predef.alnum
  Predef.x = Predef.xdigit
  Predef.A = any - Predef.a
  Predef.C = any - Predef.c
  Predef.D = any - Predef.d
  Predef.G = any - Predef.g
  Predef.L = any - Predef.l
  Predef.P = any - Predef.p
  Predef.S = any - Predef.s
  Predef.U = any - Predef.u
  Predef.W = any - Predef.w
  Predef.X = any - Predef.x
  mem = {} -- restart memoization
  fmem = {}
  gmem = {}
  local mt = { __mode = "v" }
  setmetatable(mem, mt)
  setmetatable(fmem, mt)
  setmetatable(gmem, mt)
end


updatelocale()



local I = m.P(function(s, i)
  print(i, s:sub(1, i - 1)); return i
end)


local function getdef(id, defs)
  local c = defs and defs[id]
  if not c then error("undefined name: " .. id) end
  return c
end


local function patt_error(s, i)
  local msg = (#s < i + 20) and s:sub(i)
      or s:sub(i, i + 20) .. "..."
  msg = ("pattern error near '%s'"):format(msg)
  error(msg, 2)
end

local function mult(p, n)
  local np = mm.P(true)
  while n >= 1 do
    if n % 2 >= 1 then np = np * p end
    p = p * p
    n = n / 2
  end
  return np
end

local function equalcap(s, i, c)
  if type(c) ~= "string" then return nil end
  local e = #c + i
  if s:sub(i, e - 1) == c then return e else return nil end
end


local S = (Predef.space + "--" * (any - Predef.nl) ^ 0) ^ 0

local name = m.R("AZ", "az", "__") * m.R("AZ", "az", "__", "09") ^ 0

local arrow = S * "<-"

local seq_follow = m.P "/" + ")" + "}" + ":}" + "~}" + "|}" + (name * arrow) + -1

name = m.C(name)


-- a defined name only have meaning in a given environment
local Def = name * m.Carg(1)

local num = m.C(m.R "09" ^ 1) * S / tonumber

local String = "'" * m.C((any - "'") ^ 0) * "'" +
    '"' * m.C((any - '"') ^ 0) * '"'


local defined = "%" * Def / function(c, Defs)
  local cat = Defs and Defs[c] or Predef[c]
  if not cat then error("name '" .. c .. "' undefined") end
  return cat
end

local Range = m.Cs(any * (m.P "-" / "") * (any - "]")) / mm.R

local item = defined + Range + m.C(any)

local Class =
    "["
    * (m.C(m.P "^" ^ -1)) -- optional complement symbol
    * m.Cf(item * (item - "]") ^ 0, mt.__add) /
    function(c, p) return c == "^" and any - p or p end
    * "]"

local function adddef(t, k, exp)
  if t[k] then
    error("'" .. k .. "' already defined as a rule")
  else
    t[k] = exp
  end
  return t
end

local function firstdef(n, r) return adddef({ n }, n, r) end


local function NT(n, b)
  if not b then
    error("rule '" .. n .. "' used outside a grammar")
  else
    return mm.V(n)
  end
end


local exp = m.P { "Exp",
  Exp = S * (m.V "Grammar"
    + m.Cf(m.V "Seq" * ("/" * S * m.V "Seq") ^ 0, mt.__add)),
  Seq = m.Cf(m.Cc(m.P "") * m.V "Prefix" ^ 0, mt.__mul)
      * (#seq_follow + patt_error),
  Prefix = "&" * S * m.V "Prefix" / mt.__len
      + "!" * S * m.V "Prefix" / mt.__unm
      + m.V "Suffix",
  Suffix = m.Cf(m.V "Primary" * S *
    ((m.P "+" * m.Cc(1, mt.__pow)
      + m.P "*" * m.Cc(0, mt.__pow)
      + m.P "?" * m.Cc(-1, mt.__pow)
      + "^" * (m.Cg(num * m.Cc(mult))
        + m.Cg(m.C(m.S "+-" * m.R "09" ^ 1) * m.Cc(mt.__pow))
      )
      + "->" * S * (m.Cg((String + num) * m.Cc(mt.__div))
        + m.P "{}" * m.Cc(nil, m.Ct)
        + m.Cg(Def / getdef * m.Cc(mt.__div))
      )
      + "=>" * S * m.Cg(Def / getdef * m.Cc(m.Cmt))
    ) * S
    ) ^ 0, function(a, b, f) return f(a, b) end),
  Primary = "(" * m.V "Exp" * ")"
      + String / mm.P
      + Class
      + defined
      + "{:" * (name * ":" + m.Cc(nil)) * m.V "Exp" * ":}" /
      function(n, p) return mm.Cg(p, n) end
      + "=" * name / function(n) return mm.Cmt(mm.Cb(n), equalcap) end
      + m.P "{}" / mm.Cp
      + "{~" * m.V "Exp" * "~}" / mm.Cs
      + "{|" * m.V "Exp" * "|}" / mm.Ct
      + "{" * m.V "Exp" * "}" / mm.C
      + m.P "." * m.Cc(any)
      + (name * -arrow + "<" * name * ">") * m.Cb("G") / NT,
  Definition = name * arrow * m.V "Exp",
  Grammar = m.Cg(m.Cc(true), "G") *
      m.Cf(m.V "Definition" / firstdef * m.Cg(m.V "Definition") ^ 0,
        adddef) / mm.P
}

local pattern = S * m.Cg(m.Cc(false), "G") * exp / mm.P * (-any + patt_error)


local function compile(p, defs)
  if mm.type(p) == "pattern" then return p end -- already compiled
  local cp = pattern:match(p, 1, defs)
  if not cp then error("incorrect pattern", 3) end
  return cp
end

local function match(s, p, i)
  local cp = mem[p]
  if not cp then
    cp = compile(p)
    mem[p] = cp
  end
  return cp:match(s, i or 1)
end

local function find(s, p, i)
  local cp = fmem[p]
  if not cp then
    cp = compile(p) / 0
    cp = mm.P { mm.Cp() * cp * mm.Cp() + 1 * mm.V(1) }
    fmem[p] = cp
  end
  local i, e = cp:match(s, i or 1)
  if i then
    return i, e - 1
  else
    return i
  end
end

local function gsub(s, p, rep)
  local g = gmem[p] or {} -- ensure gmem[p] is not collected while here
  gmem[p] = g
  local cp = g[rep]
  if not cp then
    cp = compile(p)
    cp = mm.Cs((cp / rep + 1) ^ 0)
    g[rep] = cp
  end
  return cp:match(s)
end


-- exported names
local re = {
  compile = compile,
  match = match,
  find = find,
  gsub = gsub,
  updatelocale = updatelocale,
}

if version == "Lua 5.1" then
  --I need this to work with strict.lua, sorry for breaking compatibility.
  --_G.re = re
end

return re