☰

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 有一個錯誤（http://sourceforge.net/p/linuxlibertine/bugs/266/），我人品不好。

使用 XeLaTeX，我得到使用 XeLaTeX 編譯的範例

如您所見，Unicode 已標準化。

我的三個問題是：

  1. 為什麼 XeLaTeX 已經標準化（在 NFC 中），儘管我沒有使用過\XeTeXinputnormalization
  2. 這個功能與過去有變化嗎？因為我之前用TeXLive 2012發送的結果很糟糕（請參閱我此時寫的文章http://geekographie.maieul.net/Normalization-des-caracteres）
  3. LuaTeX 有像\XeTeXinputnormalizationXeTeX 那樣的選項嗎？

答案1

我不知道前兩個問題的答案，因為我不使用 XeTeX，但我想為第三個問題提供選項。

謝謝亞瑟密碼我能夠在 LuaLaTeX 中建立用於 unicode 規範化的基本包。程式碼只需稍作修改即可與目前的 LuaTeX 搭配使用。我只會在這裡發布主要的 Lua 文件，完整的專案可以在Github 作為非標準化。

使用範例：

\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š是錯誤的。這就是我正在談論的問題。

現在緩衝區標準化：

在此輸入影像描述

現在一切都好了

相關內容