326 lines
11 KiB
Text
326 lines
11 KiB
Text
# i18n_xml.ludic — a component's template (NAME.xml) against en.po (i18n.ludic). The compiler reads
|
|
# the template's text, so it checks it: in every {hole} - an element's text or an attribute's value -
|
|
# `t('key', ...)` with a literal key names a key en.po has, and gives as many values after it as the
|
|
# English has holes; `t(expr)` with a key worked out at run time is left alone. What a player would
|
|
# read that is not a key is "English left" (a warning, counted): an element's words outside its
|
|
# holes, a text attribute's words (text, label, hint, title, caption, and any other attribute whose
|
|
# value is not a keyword - as tools/i18n/extract.py decided), and a quoted choice inside a hole that
|
|
# reads as words (a capital or a space) and is not a key. An element with translate="no" and all it
|
|
# holds are left alone. Comments, <? ?> and <! > are skipped; `&name;` is not a word.
|
|
var g_xk_src: pointer = ""
|
|
var g_xk_file: pointer = ""
|
|
var g_xk_i: int = 0
|
|
var g_xk_n: int = 0
|
|
|
|
function i18n_walk_templates() -> void {
|
|
var c = 0
|
|
while c < len(g_cm_name) {
|
|
let xml = g_cm_xml[c]
|
|
if xml != null and len(xml) > 0 and not is_runtime_file(g_cm_file[c]) { i18n_xml(g_cm_xml_path[c], xml) }
|
|
c += 1
|
|
}
|
|
}
|
|
# the cursor on to `to`
|
|
function xk_move(to: int) -> void {
|
|
g_xk_i = to
|
|
if g_xk_i > g_xk_n { g_xk_i = g_xk_n }
|
|
}
|
|
var g_xk_at_line: int = 0
|
|
var g_xk_at_col: int = 0
|
|
function xk_find(s: pointer, from: int, pat: pointer) -> int {
|
|
let n = len(s)
|
|
let m = len(pat)
|
|
var i = from
|
|
while i + m <= n {
|
|
if s[i .. i + m] == pat { return i }
|
|
i += 1
|
|
}
|
|
return n
|
|
}
|
|
function i18n_xml(path: pointer, src: pointer) -> void {
|
|
g_xk_src = src
|
|
g_xk_file = path
|
|
g_xk_i = 0
|
|
g_xk_n = len(src)
|
|
let names = new []pointer
|
|
var no_depth = -1 # the depth an untranslated element opened at
|
|
while g_xk_i < g_xk_n {
|
|
let c = src[g_xk_i]
|
|
if c == '<' {
|
|
if g_xk_i + 3 < g_xk_n and (src[g_xk_i + 1 .. g_xk_i + 4] == "!--") {
|
|
xk_move(xk_find(src, g_xk_i + 4, "-->") + 3)
|
|
continue
|
|
}
|
|
if g_xk_i + 1 < g_xk_n and (src[g_xk_i + 1] == '?' or src[g_xk_i + 1] == '!') {
|
|
xk_move(xk_find(src, g_xk_i, ">") + 1)
|
|
continue
|
|
}
|
|
if g_xk_i + 1 < g_xk_n and src[g_xk_i + 1] == '/' {
|
|
xk_move(xk_find(src, g_xk_i, ">") + 1)
|
|
if len(names) > 0 { let gone = List.pop(names) }
|
|
if no_depth >= 0 and len(names) <= no_depth { no_depth = -1 }
|
|
continue
|
|
}
|
|
let depth = len(names)
|
|
let r = xk_tag(no_depth >= 0)
|
|
if r > 0 and no_depth < 0 and r == 2 { no_depth = depth }
|
|
if g_xk_last_open { push(names, g_xk_last_name) }
|
|
else if no_depth == depth { no_depth = -1 } # a self-closed translate="no" holds nothing
|
|
continue
|
|
}
|
|
xk_text(no_depth >= 0)
|
|
}
|
|
}
|
|
# text up to the next tag: its holes checked, its words outside them English left
|
|
function xk_text(quiet: bool) -> void {
|
|
let src = g_xk_src
|
|
var words_at = -1
|
|
var run = 0
|
|
while g_xk_i < g_xk_n and src[g_xk_i] != '<' {
|
|
let c = src[g_xk_i]
|
|
if c == '{' {
|
|
let e = hole_end(src, g_xk_i + 1, g_xk_n)
|
|
xk_hole(g_xk_i + 1, e, quiet)
|
|
xk_move(e + 1)
|
|
run = 0
|
|
continue
|
|
}
|
|
if c == '&' {
|
|
var j = g_xk_i + 1
|
|
while j < g_xk_n and j < g_xk_i + 12 and src[j] != ';' and src[j] != '<' and src[j] != ' ' { j += 1 }
|
|
if j < g_xk_n and src[j] == ';' {
|
|
xk_move(j + 1)
|
|
run = 0
|
|
continue
|
|
}
|
|
}
|
|
if words_at < 0 {
|
|
if c < 0 or c >= 128 { words_at = g_xk_i }
|
|
if (c >= 'a' and c <= 'z') or (c >= 'A' and c <= 'Z') { run += 1 } else { run = 0 }
|
|
if run >= 2 { words_at = g_xk_i - 1 }
|
|
}
|
|
xk_move(g_xk_i + 1)
|
|
}
|
|
if words_at >= 0 and not quiet {
|
|
let a = xk_trim_start(words_at)
|
|
xk_where_back(a)
|
|
i18n_english_left(g_xk_file, g_xk_at_line, g_xk_at_col, `a template's words ("{i18n_short(xk_words_from(a))}") - write {{t('key')}} and give en.po the English, or mark the element translate="no"`)
|
|
}
|
|
}
|
|
# where a word starts: back from a letter to the space before it
|
|
function xk_trim_start(at: int) -> int {
|
|
var a = at
|
|
while a > 0 and g_xk_src[a - 1] != '>' and g_xk_src[a - 1] != '}' and g_xk_src[a - 1] != ' ' and g_xk_src[a - 1] != '\n' and g_xk_src[a - 1] != 9 { a -= 1 }
|
|
return a
|
|
}
|
|
function xk_words_from(a: int) -> pointer {
|
|
var e = a
|
|
while e < g_xk_n and g_xk_src[e] != '<' and g_xk_src[e] != '{' { e += 1 }
|
|
return g_xk_src[a .. e]
|
|
}
|
|
# the line and column of a byte already passed
|
|
function xk_where_back(at: int) -> void {
|
|
var ln = 1
|
|
var ls = 0
|
|
var i = 0
|
|
while i < at {
|
|
if g_xk_src[i] == '\n' {
|
|
ln += 1
|
|
ls = i + 1
|
|
}
|
|
i += 1
|
|
}
|
|
g_xk_at_line = ln
|
|
g_xk_at_col = at - ls + 1
|
|
}
|
|
|
|
# ---- a tag ---------------------------------------------------------------------------------------
|
|
var g_xk_last_open: bool = false # the tag read opens an element (it is not <x ... />)
|
|
var g_xk_last_name: pointer = ""
|
|
function xk_name_ch(c: int) -> bool { return char_is_alnum(c) or c == '_' or c == '-' or c == ':' or c == '.' or c == '@' }
|
|
function xk_space(c: int) -> bool { return c == ' ' or c == '\n' or c == 9 or c == 13 }
|
|
# `<name attr="v" ...>` from the cursor: 2 when it says translate="no", else 1
|
|
function xk_tag(quiet: bool) -> int {
|
|
let src = g_xk_src
|
|
var i = g_xk_i + 1
|
|
let a0 = i
|
|
while i < g_xk_n and xk_name_ch(src[i]) { i += 1 }
|
|
g_xk_last_name = src[a0 .. i]
|
|
g_xk_last_open = true
|
|
let an = new []pointer
|
|
let va = new []int
|
|
let vb = new []int
|
|
var no = false
|
|
while i < g_xk_n {
|
|
while i < g_xk_n and xk_space(src[i]) { i += 1 }
|
|
if i >= g_xk_n { break }
|
|
if src[i] == '>' {
|
|
i += 1
|
|
break
|
|
}
|
|
if src[i] == '/' {
|
|
g_xk_last_open = false
|
|
i += 1
|
|
continue
|
|
}
|
|
let na = i
|
|
while i < g_xk_n and not xk_space(src[i]) and src[i] != '=' and src[i] != '>' and src[i] != '/' { i += 1 }
|
|
if i == na { i += 1; continue }
|
|
let name = src[na .. i]
|
|
while i < g_xk_n and xk_space(src[i]) { i += 1 }
|
|
var a = i
|
|
var b = i
|
|
if i < g_xk_n and src[i] == '=' {
|
|
i += 1
|
|
while i < g_xk_n and xk_space(src[i]) { i += 1 }
|
|
if i < g_xk_n and (src[i] == '"' or src[i] == CH_SQUOTE) {
|
|
let q = src[i]
|
|
i += 1
|
|
a = i
|
|
while i < g_xk_n and src[i] != q {
|
|
if src[i] == '{' { i = hole_end(src, i + 1, g_xk_n) }
|
|
i += 1
|
|
}
|
|
b = i
|
|
if i < g_xk_n { i += 1 }
|
|
} else {
|
|
a = i
|
|
while i < g_xk_n and not xk_space(src[i]) and src[i] != '>' { i += 1 }
|
|
b = i
|
|
}
|
|
}
|
|
push(an, name)
|
|
push(va, a)
|
|
push(vb, b)
|
|
if (name == "translate") and (src[a .. b] == "no") { no = true }
|
|
}
|
|
var k = 0
|
|
while k < len(an) {
|
|
xk_attr(an[k], va[k], vb[k], quiet or no)
|
|
k += 1
|
|
}
|
|
g_xk_i = i
|
|
if no { return 2 }
|
|
return 1
|
|
}
|
|
function xk_not_text(n: pointer) -> bool {
|
|
if (n == "class") or (n == "id") or (n == "src") or (n == "style") or (n == "icon") or (n == "name") or (n == "type") { return true }
|
|
if (n == "key") or (n == "as") or (n == "in") or (n == "test") or (n == "index") or (n == "slot") or (n == "export") { return true }
|
|
if (n == "color") or (n == "bg") or (n == "background") or (n == "state") or (n == "min") or (n == "max") or (n == "width") { return true }
|
|
if (n == "height") or (n == "w") or (n == "h") or (n == "shade") or (n == "rows") or (n == "maxlength") or (n == "checked") { return true }
|
|
if (n == "enabled") or (n == "disabled") or (n == "hidden") or (n == "primary") or (n == "selected") or (n == "kind") { return true }
|
|
if (n == "translate") { return true }
|
|
return str_starts(n, "on") or str_starts(n, "--")
|
|
}
|
|
function xk_words_attr(n: pointer) -> bool {
|
|
return (n == "text") or (n == "label") or (n == "hint") or (n == "title") or (n == "caption")
|
|
}
|
|
# a keyword: nothing but a-z 0-9 _ . # % -
|
|
function xk_keyword(s: pointer) -> bool {
|
|
var i = 0
|
|
while i < len(s) {
|
|
let c = s[i]
|
|
let ok = (c >= 'a' and c <= 'z') or (c >= '0' and c <= '9') or c == '_' or c == '.' or c == '#' or c == '%' or c == '-'
|
|
if not ok { return false }
|
|
i += 1
|
|
}
|
|
return true
|
|
}
|
|
# one attribute's value, src[a..b]: its holes, and its words if it is text
|
|
function xk_attr(name: pointer, a: int, b: int, quiet: bool) -> void {
|
|
let src = g_xk_src
|
|
let textual = not xk_not_text(name)
|
|
let rest = buf_new()
|
|
var i = a
|
|
while i < b {
|
|
if src[i] == '{' {
|
|
let e = hole_end(src, i + 1, b)
|
|
xk_hole(i + 1, e, quiet or not textual)
|
|
i = e + 1
|
|
continue
|
|
}
|
|
buf_putc(rest, src[i])
|
|
i += 1
|
|
}
|
|
if quiet or not textual { return }
|
|
let words = buf_str(rest)
|
|
if not xk_words_attr(name) and xk_keyword(words) { return }
|
|
if not i18n_wordy(words) { return }
|
|
xk_where_back(a)
|
|
i18n_english_left(g_xk_file, g_xk_at_line, g_xk_at_col, `{name}="{i18n_short(words)}" in a template - write {name}="{{t('key')}}" and give en.po the English`)
|
|
}
|
|
|
|
# ---- a hole --------------------------------------------------------------------------------------
|
|
# the code of a hole, src[a..e]: each t('key', ...) checked; a quoted choice that reads as words is
|
|
# English left unless the text around it is quiet
|
|
function xk_hole(a: int, e: int, quiet: bool) -> void {
|
|
let src = g_xk_src
|
|
var i = a
|
|
while i < e {
|
|
let c = src[i]
|
|
if c == '"' or c == CH_SQUOTE {
|
|
var j = i + 1
|
|
while j < e and src[j] != c {
|
|
if src[j] == CH_BACKSLASH { j += 1 }
|
|
j += 1
|
|
}
|
|
let lit = src[i + 1 .. j]
|
|
if not quiet and xk_choice_wordy(lit) {
|
|
xk_where_back(i)
|
|
i18n_english_left(g_xk_file, g_xk_at_line, g_xk_at_col, `'{i18n_short(lit)}' in a template's hole - a choice the player reads is a key too: t('key')`)
|
|
}
|
|
i = j + 1
|
|
continue
|
|
}
|
|
if c == 't' and i + 1 < e and src[i + 1] == '(' and (i == a or not (xk_name_ch(src[i - 1]))) {
|
|
i = xk_t_call(i + 2, e)
|
|
continue
|
|
}
|
|
i += 1
|
|
}
|
|
}
|
|
function xk_choice_wordy(s: pointer) -> bool {
|
|
if not i18n_wordy(s) { return false }
|
|
var i = 0
|
|
while i < len(s) {
|
|
let c = s[i]
|
|
if (c >= 'A' and c <= 'Z') or c == ' ' or c < 0 or c >= 128 { return true }
|
|
i += 1
|
|
}
|
|
return false
|
|
}
|
|
# t( read, the cursor after it: a literal key is checked, and the values after it counted; where
|
|
# the scan goes on (just past the key, so a t() inside the values is found as well)
|
|
function xk_t_call(at: int, e: int) -> int {
|
|
let src = g_xk_src
|
|
var k = at
|
|
while k < e and xk_space(src[k]) { k += 1 }
|
|
if k >= e or (src[k] != CH_SQUOTE and src[k] != '"') { return at }
|
|
let q = src[k]
|
|
var j = k + 1
|
|
while j < e and src[j] != q { j += 1 }
|
|
let key = src[k + 1 .. j]
|
|
var depth = 0
|
|
var commas = 0
|
|
var m = j + 1
|
|
while m < e {
|
|
let c = src[m]
|
|
if c == '"' or c == CH_SQUOTE {
|
|
m += 1
|
|
while m < e and src[m] != c {
|
|
if src[m] == CH_BACKSLASH { m += 1 }
|
|
m += 1
|
|
}
|
|
} else if c == '(' or c == '[' or c == '{' { depth += 1 }
|
|
else if c == ')' or c == ']' or c == '}' {
|
|
if depth == 0 { break }
|
|
depth -= 1
|
|
}
|
|
else if c == ',' and depth == 0 { commas += 1 }
|
|
m += 1
|
|
}
|
|
xk_where_back(k)
|
|
i18n_use(key, false, KS_TEMPLATE, g_xk_file, g_xk_at_line, g_xk_at_col)
|
|
if g_i18n_en != null { i18n_holes(key, commas, "t()", g_xk_file, g_xk_at_line, g_xk_at_col) }
|
|
return j + 1
|
|
}
|