☰

XeLaTeX、LuaLaTeX、fontspec、unicode 和规范化

tag-icon • tag-icon xetex luatex unicode
XeLaTeX、LuaLaTeX、fontspec、unicode 和规范化

LuaTeX 和 XeLaTeX 规范化 unicode 组合字符的方式让我很困扰。我指的是 NFC/NFD。

请参阅以下 MWE

\documentclass{article}
\usepackage{fontspec}
\setmainfont{Linux Libertine O}

\begin{document}


ᾳ GREEK SMALL LETTER ALPHA (U+03B1) + COMBINING GREEK YPOGEGRAMMENI (U+0345)

ᾳ GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI (U+1FB3)

\end{document}

使用 LuaLaTeX 我获得： 使用 LuaLaTeX 编译的示例

正如你所见，Lua 并没有规范化 unicode 字符，而 Linux Libertine 有一个 bug（http://sourceforge.net/p/linuxlibertine/bugs/266/），我性格很不好。

使用 XeLaTeX，我获得使用 XeLaTeX 编译的示例

如您所见，Unicode 已标准化。

我的三个问题是：

  1. 为什么 XeLaTeX 已经标准化（在 NFC 中），尽管我没有使用过\XeTeXinputnormalization
  2. 这个功能与过去相比是否有所变化。因为我以前用 TeXLive 2012 发送的结果很糟糕（参见我当时写的文章http://geekographie.maieul.net/Normalisation-des-caracteres）
  3. LuaTeX 是否有类似\XeTeXinputnormalizationXeTeX 的选项？

答案1

我不知道前两个问题的答案，因为我不使用 XeTeX，但我想为第三个问题提供选项。

谢谢亚瑟密码我能够在 LuaLaTeX 中创建用于 unicode 规范化的基本包。代码只需稍作修改即可与当前的 LuaTeX 配合使用。我将仅在此处发布主要的 Lua 文件，完整项目可在Github 作为 uninormalize。

使用示例：

\documentclass{article}
\usepackage{fontspec}
\usepackage[czech]{babel}
\setmainfont{Linux Libertine O}
\usepackage[nodes,buffer=false, debug]{uninormalize}
\begin{document}

Some tests:
\begin{itemize}
  \item combined letter ᾳ %GREEK SMALL LETTER ALPHA (U+03B1) + COMBINING GREEK YPOGEGRAMMENI (U+0345)
  \item normal letter ᾳ% GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI (U+1FB3)
\end{itemize}

Some more combined and normal letters: 
óóōōöö

Linux Libertine does support some combined chars: \parbox{4em}{příliš}
\end{document}

（请注意，该文件的正确版本在 Github 上，本例中组合字母传输错误）

该包的主要思想如下：处理输入，当发现字母后跟组合标记时，则将其替换为规范化的 NFC 形式。提供了两种方法，我的第一种方法是使用节点处理回调将分解的字形替换为规范化字符。这样做的优势在于可以使用节点属性在任何地方打开或关闭处理。另一个可能的功能是检查当前字体是否包含规范化字符，如果不包含，则使用原始形式。不幸的是，在我的测试中，它无法处理某些字符，特别í是在节点中组合为dotless i + ´，而不是i + ´，在规范化之后不会产生正确的字符，因此改用组合字符。但这会产生重音位置错误的输出。所以这种方法要么需要一些修正，要么就是完全错误的。

因此，另一种方法是使用process_input_buffer回调来规范化从磁盘读取的输入文件。此方法不允许使用字体信息，也不允许在行中间关闭，但它更容易实现，回调函数可能如下所示：

function buffer_callback(line) 
  return NFC(line)
end

在节点处理版本上花了三天时间后，这真是一个不错的发现。

出于好奇，这是 Lua 包：

local M = {}
dofile("unicode-names.lua")
dofile('unicode-normalization.lua')
local NFC = unicode.conformance.toNFC
local char = unicode.utf8.char
local gmatch = unicode.utf8.gmatch
local name = unicode.conformance.name
local byte = unicode.utf8.byte
local unidata = characters.data
local length = unicode.utf8.len

M.debug = false

-- for some reason variable number of arguments doesn't work
local function debug_msg(a,b,c,d,e,f,g,h,i)
  if M.debug then
    local t = {a,b,c,d,e,f,g,h,i}
    print("[uninormalize]", unpack(t))
  end
end

local function make_hash (t) 
  local y = {}
  for _,v in ipairs(t) do 
    y[v] = true
  end
  return y
end

local letter_categories = make_hash {"lu","ll","lt","lo","lm"}

local mark_categories = make_hash {"mn","mc","me"}

local function printchars(s)
    local t = {}
    for x in gmatch(s,".") do
        t[#t+1] = name(byte(x))
    end
    debug_msg("characters",table.concat(t,":"))
end

local categories = {}


local function get_category(charcode)
  local charcode = charcode or ""
  if categories[charcode] then
    return categories[charcode] 
  else
    local unidatacode = unidata[charcode] or {}
    local category = unidatacode.category
    categories[charcode] = category
    return category
  end
end

-- get glyph char and category
local function glyph_info(n)
  local char = n.char
  return char, get_category(char)
end

local function get_mark(n)
  if n.id == 37 then
    local character, cat = glyph_info(n)
    if mark_categories[cat] then
      return char(character)
    end
  end
  return false
end

local function make_glyphs(head, nextn,s, lang, font, subtype) 
  local g = function(a) 
    local new_n = node.new(37, subtype)
    new_n.lang = lang
    new_n.font = font
    new_n.char = byte(a)
    return new_n
  end
  if length(s) == 1 then
    return node.insert_before(head, nextn,g(s))
  else
    local t = {}
    local first = true
    for x in gmatch(s,".") do
      debug_msg("multi letter",x)
        head, newn = node.insert_before(head, nextn, g(x))
    end
    return head
  end
end

local function normalize_marks(head, n)
  local lang, font, subtype = n.lang, n.font, n.subtype
  local text = {}
  text[#text+1] = char(n.char)
  local head, nextn = node.remove(head, n)
  --local nextn = n.next
  local info = get_mark(nextn)
  while(info) do
    text[#text+1] = info
    head, nextn = node.remove(head,nextn)
    info = get_mark(nextn)
  end
  local s = NFC(table.concat(text))
  debug_msg("We've got mark: " .. s)
  local new_n = node.new(37, subtype)
  new_n.lang = lang
  new_n.font = font
  new_n.char = byte(s)
  --head, new_n = node.insert_before(head, nextn, new_n)
  -- head, new_n = node.insert_before(head, nextn, make_glyphs(s, lang, font, subtype))
  head, new_n = make_glyphs(head, nextn, s, lang, font, subtype)
  local t = {}
  for x in node.traverse_id(37,head) do
    t[#t+1] = char(x.char)
  end
  debug_msg("Variables ", table.concat(t,":"), table.concat(text,";"), char(byte(s)),length(s))
  return head, nextn
end

local function normalize_glyphs(head, n)
  --local charcode = n.char
  --local category = get_category(charcode)
  local charcode, category = glyph_info(n)
  if letter_categories[category] then 
    local nextn = n.next
    if nextn.id == 37 then
      --local nextchar = nextn.char
      --local nextcat = get_category(nextchar)
      local nextchar, nextcat = glyph_info(nextn)
      if mark_categories[nextcat] then
        return normalize_marks(head,n)
      end
    end
  end
  return head, n.next 
end


function M.nodes(head)
    local t = {}
    local text = false
  local n = head
    -- for n in node.traverse(head) do
  while n do
        if n.id == 37 then
      local charcode = n.char
            debug_msg("unicode name",name(charcode))
            debug_msg("character category",get_category(charcode))
            t[#t+1]= char(charcode)
            text = true
      head, n = normalize_glyphs(head, n)
        else
            if text then
                local s = table.concat(t)
                debug_msg("text chunk",s)
                --printchars(NFC(s))
                debug_msg("----------")
            end
            text = false
            t = {}
      n = n.next
        end
    end
    return head
end

--[[
-- These functions aren't needed when processing buffer. We can call NFC on the whole input line
local unibytes = {}

local function get_charcategory(s)
  local s = s or ""
  local b = unibytes[s] or byte(s) or 0
  unibytes[s] = b
  return get_category(b)
end

local function normalize_charmarks(t,i)
  local c = {t[i]}
  local i = i + 1
  local s = get_charcategory(t[i])
  while mark_categories[s] do
    c[#c+1] = t[i]
    i = i + 1
    s = get_charcategory(t[i])
  end
  return NFC(table.concat(c)), i
end

local function normalize_char(t,i)
  local ch = t[i]
  local c = get_charcategory(ch)
  if letter_categories[c] then
    local nextc = get_charcategory(t[i+1])
    if mark_categories[nextc] then
      return normalize_charmarks(t,i)
    end
  end
  return ch, i+1
end
-- ]]
function M.buffer(line)
  --[[
  local t = {}
  local new_t = {}
  -- we need to make table witl all uni chars on the line
  for x in gmatch(line,".") do
    t[#t+1] = x
  end
  local i = 1
  -- normalize next char
  local c, i = normalize_char(t, i)
  new_t[#new_t+1] = c
  while t[i] do
    c, i = normalize_char(t,i)
    -- local  c = t[i]
    -- i =  i + 1
    new_t[#new_t+1] = c
  end
  return table.concat(new_t)
  --]]
  return NFC(line)
end


return M

现在是看一些照片的时间了。

未经规范化：

在此处输入图片描述

你可以看到组合希腊字符是错误的，其他组合由 Linux Libertine 支持

节点规范化：

在此处输入图片描述

希腊字母是正确的，但í第一个příliš是错误的。这就是我所谈论的问题。

现在缓冲区规范化：

在此处输入图片描述

现在一切都好了

相关内容