mirror of
https://github.com/Ralim/IronOS.git
synced 2025-02-26 07:53:55 +00:00
15e51f9faa
This generates dedicates Translation.cpp files for translation language and derives all language-specific data from them. The Makefile is extended to also take care of generating these source files. This allows reuse of nearly all object files between builds of different languages for the same model and regenerating the translation sources if necessary. This speeds up the release builds and the normal write-compile-cycle considerably. It also eliminates miscompilations when manually building different languages.
535 lines
16 KiB
Python
Executable File
535 lines
16 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# coding=utf-8
|
|
from __future__ import print_function
|
|
import argparse
|
|
import json
|
|
import os
|
|
import io
|
|
from datetime import datetime
|
|
import sys
|
|
import fontTables
|
|
import re
|
|
import subprocess
|
|
|
|
HERE = os.path.dirname(__file__)
|
|
|
|
try:
|
|
to_unicode = unicode
|
|
except NameError:
|
|
to_unicode = str
|
|
|
|
|
|
def log(message):
|
|
print(message, file=sys.stdout)
|
|
|
|
|
|
# Loading a single JSON file
|
|
def loadJson(fileName, skipFirstLine):
|
|
with io.open(fileName, mode="r", encoding="utf-8") as f:
|
|
if skipFirstLine:
|
|
f.readline()
|
|
|
|
obj = json.loads(f.read())
|
|
|
|
return obj
|
|
|
|
|
|
def readTranslation(jsonDir, langCode):
|
|
fileName = 'translation_{}.json'.format(langCode)
|
|
|
|
fileWithPath = os.path.join(jsonDir, fileName)
|
|
|
|
try:
|
|
lang = loadJson(fileWithPath, False)
|
|
except json.decoder.JSONDecodeError as e:
|
|
log("Failed to decode " + fileName)
|
|
log(str(e))
|
|
sys.exit(2)
|
|
|
|
# Extract lang code from file name
|
|
langCode = fileName[12:-5].upper()
|
|
# ...and the one specified in the JSON file...
|
|
try:
|
|
langCodeFromJson = lang["languageCode"]
|
|
except KeyError:
|
|
langCodeFromJson = "(missing)"
|
|
|
|
# ...cause they should be the same!
|
|
if langCode != langCodeFromJson:
|
|
raise ValueError(
|
|
"Invalid languageCode " + langCodeFromJson + " in file " + fileName
|
|
)
|
|
|
|
return lang
|
|
|
|
|
|
def writeStart(f):
|
|
f.write(
|
|
to_unicode(
|
|
"""// WARNING: THIS FILE WAS AUTO GENERATED BY make_translation.py. PLEASE DO NOT EDIT.
|
|
|
|
#include "Translation.h"
|
|
"""
|
|
)
|
|
)
|
|
|
|
|
|
def escapeC(s):
|
|
return s.replace('"', '\\"')
|
|
|
|
|
|
def getConstants():
|
|
# Extra constants that are used in the firmware that are shared across all languages
|
|
consants = []
|
|
consants.append(("SymbolPlus", "+"))
|
|
consants.append(("SymbolMinus", "-"))
|
|
consants.append(("SymbolSpace", " "))
|
|
consants.append(("SymbolDot", "."))
|
|
consants.append(("SymbolDegC", "C"))
|
|
consants.append(("SymbolDegF", "F"))
|
|
consants.append(("SymbolMinutes", "M"))
|
|
consants.append(("SymbolSeconds", "S"))
|
|
consants.append(("SymbolWatts", "W"))
|
|
consants.append(("SymbolVolts", "V"))
|
|
consants.append(("SymbolDC", "DC"))
|
|
consants.append(("SymbolCellCount", "S"))
|
|
consants.append(("SymbolVersionNumber", buildVersion))
|
|
return consants
|
|
|
|
|
|
def getDebugMenu():
|
|
constants = []
|
|
constants.append(datetime.today().strftime("%d-%m-%y"))
|
|
constants.append("HW G ") # High Water marker for GUI task
|
|
constants.append("HW M ") # High Water marker for MOV task
|
|
constants.append("HW P ") # High Water marker for PID task
|
|
constants.append("Time ") # Uptime (aka timestamp)
|
|
constants.append("Move ") # Time of last significant movement
|
|
constants.append("RTip ") # Tip reading in uV
|
|
constants.append("CTip ") # Tip temp in C
|
|
constants.append("CHan ") # Handle temp in C
|
|
constants.append("Vin ") # Input voltage
|
|
constants.append("PCB ") # PCB Version AKA IMU version
|
|
constants.append("PWR ") # Power Negotiation State
|
|
constants.append("Max ") # Max deg C limit
|
|
|
|
return constants
|
|
|
|
|
|
def getLetterCounts(defs, lang):
|
|
textList = []
|
|
# iterate over all strings
|
|
obj = lang["menuOptions"]
|
|
for mod in defs["menuOptions"]:
|
|
eid = mod["id"]
|
|
textList.append(obj[eid]["desc"])
|
|
|
|
obj = lang["messages"]
|
|
for mod in defs["messages"]:
|
|
eid = mod["id"]
|
|
if eid not in obj:
|
|
textList.append(mod["default"])
|
|
else:
|
|
textList.append(obj[eid])
|
|
|
|
obj = lang["characters"]
|
|
|
|
for mod in defs["characters"]:
|
|
eid = mod["id"]
|
|
textList.append(obj[eid])
|
|
|
|
obj = lang["menuOptions"]
|
|
for mod in defs["menuOptions"]:
|
|
eid = mod["id"]
|
|
textList.append(obj[eid]["text2"][0])
|
|
textList.append(obj[eid]["text2"][1])
|
|
|
|
obj = lang["menuGroups"]
|
|
for mod in defs["menuGroups"]:
|
|
eid = mod["id"]
|
|
textList.append(obj[eid]["text2"][0])
|
|
textList.append(obj[eid]["text2"][1])
|
|
|
|
obj = lang["menuGroups"]
|
|
for mod in defs["menuGroups"]:
|
|
eid = mod["id"]
|
|
textList.append(obj[eid]["desc"])
|
|
constants = getConstants()
|
|
for x in constants:
|
|
textList.append(x[1])
|
|
textList.extend(getDebugMenu())
|
|
|
|
# collapse all strings down into the composite letters and store totals for these
|
|
|
|
symbolCounts = {}
|
|
for line in textList:
|
|
line = line.replace("\n", "").replace("\r", "")
|
|
line = line.replace("\\n", "").replace("\\r", "")
|
|
if len(line):
|
|
# print(line)
|
|
for letter in line:
|
|
symbolCounts[letter] = symbolCounts.get(letter, 0) + 1
|
|
symbolCounts = sorted(
|
|
symbolCounts.items(), key=lambda kv: (kv[1], kv[0])
|
|
) # swap to Big -> little sort order
|
|
symbolCounts = list(map(lambda x: x[0], symbolCounts))
|
|
symbolCounts.reverse()
|
|
return symbolCounts
|
|
|
|
|
|
def getFontMapAndTable(textList):
|
|
# the text list is sorted
|
|
# allocate out these in their order as number codes
|
|
symbolMap = {}
|
|
symbolMap["\n"] = "\\x01" # Force insert the newline char
|
|
index = 2 # start at 2, as 0= null terminator,1 = new line
|
|
forcedFirstSymbols = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
|
|
# enforce numbers are first
|
|
for sym in forcedFirstSymbols:
|
|
symbolMap[sym] = "\\x%0.2X" % index
|
|
index = index + 1
|
|
if len(textList) > (253 - len(forcedFirstSymbols)):
|
|
log("Error, too many used symbols for this version")
|
|
exit(1)
|
|
log("Generating fonts for {} symbols".format(len(textList)))
|
|
|
|
for sym in textList:
|
|
if sym not in symbolMap:
|
|
symbolMap[sym] = "\\x%0.2X" % index
|
|
index = index + 1
|
|
# Get the font table
|
|
fontTableStrings = []
|
|
fontSmallTableStrings = []
|
|
fontTable = fontTables.getFontMap()
|
|
fontSmallTable = fontTables.getSmallFontMap()
|
|
for sym in forcedFirstSymbols:
|
|
if sym not in fontTable:
|
|
log("Missing Large font element for {}".format(sym))
|
|
exit(1)
|
|
fontLine = fontTable[sym]
|
|
fontTableStrings.append(fontLine + "//{} -> {}".format(symbolMap[sym], sym))
|
|
if sym not in fontSmallTable:
|
|
log("Missing Small font element for {}".format(sym))
|
|
exit(1)
|
|
fontLine = fontSmallTable[sym]
|
|
fontSmallTableStrings.append(
|
|
fontLine + "//{} -> {}".format(symbolMap[sym], sym)
|
|
)
|
|
|
|
for sym in textList:
|
|
if sym not in fontTable:
|
|
log("Missing Large font element for {}".format(sym))
|
|
exit(1)
|
|
if sym not in forcedFirstSymbols:
|
|
fontLine = fontTable[sym]
|
|
fontTableStrings.append(fontLine + "//{} -> {}".format(symbolMap[sym], sym))
|
|
if sym not in fontSmallTable:
|
|
log("Missing Small font element for {}".format(sym))
|
|
exit(1)
|
|
fontLine = fontSmallTable[sym]
|
|
fontSmallTableStrings.append(
|
|
fontLine + "//{} -> {}".format(symbolMap[sym], sym)
|
|
)
|
|
outputTable = "const uint8_t USER_FONT_12[] = {" + to_unicode("\n")
|
|
for line in fontTableStrings:
|
|
# join font table int one large string
|
|
outputTable = outputTable + line + to_unicode("\n")
|
|
outputTable = outputTable + "};" + to_unicode("\n")
|
|
outputTable = outputTable + "const uint8_t USER_FONT_6x8[] = {" + to_unicode("\n")
|
|
for line in fontSmallTableStrings:
|
|
# join font table int one large string
|
|
outputTable = outputTable + line + to_unicode("\n")
|
|
outputTable = outputTable + "};" + to_unicode("\n")
|
|
return (outputTable, symbolMap)
|
|
|
|
|
|
def convStr(symbolConversionTable, text):
|
|
# convert all of the symbols from the string into escapes for their content
|
|
outputString = ""
|
|
for c in text.replace("\\r", "").replace("\\n", "\n"):
|
|
if c not in symbolConversionTable:
|
|
log("Missing font definition for {}".format(c))
|
|
else:
|
|
outputString = outputString + symbolConversionTable[c]
|
|
return outputString
|
|
|
|
|
|
def writeLanguage(lang, defs, f):
|
|
languageCode = lang['languageCode']
|
|
log("Generating block for " + languageCode)
|
|
# Iterate over all of the text to build up the symbols & counts
|
|
textList = getLetterCounts(defs, lang)
|
|
# From the letter counts, need to make a symbol translator & write out the font
|
|
(fontTableText, symbolConversionTable) = getFontMapAndTable(textList)
|
|
|
|
f.write(fontTableText)
|
|
try:
|
|
langName = lang["languageLocalName"]
|
|
except KeyError:
|
|
langName = languageCode
|
|
|
|
f.write(to_unicode("// ---- " + langName + " ----\n\n"))
|
|
|
|
# ----- Writing SettingsDescriptions
|
|
obj = lang["menuOptions"]
|
|
f.write(to_unicode("const char* SettingsDescriptions[] = {\n"))
|
|
|
|
maxLen = 25
|
|
index = 0
|
|
for mod in defs["menuOptions"]:
|
|
eid = mod["id"]
|
|
if "feature" in mod:
|
|
f.write(to_unicode("#ifdef " + mod["feature"] + "\n"))
|
|
f.write(
|
|
to_unicode(
|
|
" /* ["
|
|
+ "{:02d}".format(index)
|
|
+ "] "
|
|
+ eid.ljust(maxLen)[:maxLen]
|
|
+ " */ "
|
|
)
|
|
)
|
|
f.write(
|
|
to_unicode(
|
|
'"'
|
|
+ convStr(symbolConversionTable, (obj[eid]["desc"]))
|
|
+ '",'
|
|
+ "//{} \n".format(obj[eid]["desc"])
|
|
)
|
|
)
|
|
if "feature" in mod:
|
|
f.write(to_unicode("#endif\n"))
|
|
index = index + 1
|
|
|
|
f.write(to_unicode("};\n\n"))
|
|
|
|
# ----- Writing Message strings
|
|
|
|
obj = lang["messages"]
|
|
|
|
for mod in defs["messages"]:
|
|
eid = mod["id"]
|
|
sourceText = ""
|
|
if "default" in mod:
|
|
sourceText = mod["default"]
|
|
if eid in obj:
|
|
sourceText = obj[eid]
|
|
translatedText = convStr(symbolConversionTable, sourceText)
|
|
f.write(
|
|
to_unicode(
|
|
"const char* "
|
|
+ eid
|
|
+ ' = "'
|
|
+ translatedText
|
|
+ '";'
|
|
+ "//{} \n".format(sourceText.replace("\n", "_"))
|
|
)
|
|
)
|
|
|
|
f.write(to_unicode("\n"))
|
|
|
|
# ----- Writing Characters
|
|
|
|
obj = lang["characters"]
|
|
|
|
for mod in defs["characters"]:
|
|
eid = mod["id"]
|
|
f.write(
|
|
to_unicode(
|
|
"const char* "
|
|
+ eid
|
|
+ ' = "'
|
|
+ convStr(symbolConversionTable, obj[eid])
|
|
+ '";'
|
|
+ "//{} \n".format(obj[eid])
|
|
)
|
|
)
|
|
|
|
f.write(to_unicode("\n"))
|
|
|
|
# Write out firmware constant options
|
|
constants = getConstants()
|
|
for x in constants:
|
|
f.write(
|
|
to_unicode(
|
|
"const char* "
|
|
+ x[0]
|
|
+ ' = "'
|
|
+ convStr(symbolConversionTable, x[1])
|
|
+ '";'
|
|
+ "//{} \n".format(x[1])
|
|
)
|
|
)
|
|
|
|
f.write(to_unicode("\n"))
|
|
|
|
# Debug Menu
|
|
f.write(to_unicode("const char* DebugMenu[] = {\n"))
|
|
|
|
for c in getDebugMenu():
|
|
f.write(
|
|
to_unicode(
|
|
'\t "' + convStr(symbolConversionTable, c) + '",' + "//{} \n".format(c)
|
|
)
|
|
)
|
|
f.write(to_unicode("};\n\n"))
|
|
|
|
# ----- Writing SettingsDescriptions
|
|
obj = lang["menuOptions"]
|
|
f.write(to_unicode("const char* SettingsShortNames[][2] = {\n"))
|
|
|
|
maxLen = 25
|
|
index = 0
|
|
for mod in defs["menuOptions"]:
|
|
eid = mod["id"]
|
|
if "feature" in mod:
|
|
f.write(to_unicode("#ifdef " + mod["feature"] + "\n"))
|
|
f.write(
|
|
to_unicode(
|
|
" /* ["
|
|
+ "{:02d}".format(index)
|
|
+ "] "
|
|
+ eid.ljust(maxLen)[:maxLen]
|
|
+ " */ "
|
|
)
|
|
)
|
|
f.write(
|
|
to_unicode(
|
|
'{ "'
|
|
+ convStr(symbolConversionTable, (obj[eid]["text2"][0]))
|
|
+ '", "'
|
|
+ convStr(symbolConversionTable, (obj[eid]["text2"][1]))
|
|
+ '" },'
|
|
+ "//{} \n".format(obj[eid]["text2"])
|
|
)
|
|
)
|
|
|
|
if "feature" in mod:
|
|
f.write(to_unicode("#endif\n"))
|
|
index = index + 1
|
|
|
|
f.write(to_unicode("};\n\n"))
|
|
|
|
# ----- Writing Menu Groups
|
|
obj = lang["menuGroups"]
|
|
f.write(to_unicode("const char* SettingsMenuEntries[" + str(len(obj)) + "] = {\n"))
|
|
|
|
maxLen = 25
|
|
for mod in defs["menuGroups"]:
|
|
eid = mod["id"]
|
|
f.write(to_unicode(" /* " + eid.ljust(maxLen)[:maxLen] + " */ "))
|
|
f.write(
|
|
to_unicode(
|
|
'"'
|
|
+ convStr(
|
|
symbolConversionTable,
|
|
(obj[eid]["text2"][0]) + "\\n" + obj[eid]["text2"][1],
|
|
)
|
|
+ '",'
|
|
+ "//{} \n".format(obj[eid]["text2"])
|
|
)
|
|
)
|
|
|
|
f.write(to_unicode("};\n\n"))
|
|
|
|
# ----- Writing Menu Groups Descriptions
|
|
obj = lang["menuGroups"]
|
|
f.write(
|
|
to_unicode(
|
|
"const char* SettingsMenuEntriesDescriptions[" + str(len(obj)) + "] = {\n"
|
|
)
|
|
)
|
|
|
|
maxLen = 25
|
|
for mod in defs["menuGroups"]:
|
|
eid = mod["id"]
|
|
f.write(to_unicode(" /* " + eid.ljust(maxLen)[:maxLen] + " */ "))
|
|
f.write(
|
|
to_unicode(
|
|
'"'
|
|
+ convStr(symbolConversionTable, (obj[eid]["desc"]))
|
|
+ '",'
|
|
+ "//{} \n".format(obj[eid]["desc"])
|
|
)
|
|
)
|
|
|
|
f.write(to_unicode("};\n\n"))
|
|
f.write("const bool HasFahrenheit = " + (
|
|
"true" if lang.get('tempUnitFahrenheit', True) else "false") +
|
|
";\n")
|
|
|
|
|
|
|
|
def readVersion(jsonDir):
|
|
with open(os.path.relpath(jsonDir + "/../source/version.h"), "r") as version_file:
|
|
try:
|
|
for line in version_file:
|
|
if re.findall(r"^.*(?<=(#define)).*(?<=(BUILD_VERSION))", line):
|
|
line = re.findall(r"\"(.+?)\"", line)
|
|
if line:
|
|
version = line[0]
|
|
try:
|
|
version += (
|
|
"."
|
|
+ subprocess.check_output(
|
|
["git", "rev-parse", "--short=7", "HEAD"]
|
|
)
|
|
.strip()
|
|
.decode("ascii")
|
|
.upper()
|
|
)
|
|
# --short=7: the shorted hash with 7 digits. Increase/decrease if needed!
|
|
except OSError:
|
|
version += " git"
|
|
finally:
|
|
if version_file:
|
|
version_file.close()
|
|
return version
|
|
|
|
|
|
def orderOutput(langDict):
|
|
# These languages go first
|
|
mandatoryOrder = ["EN"]
|
|
|
|
# Then add all others in alphabetical order
|
|
sortedKeys = sorted(langDict.keys())
|
|
|
|
# Add the rest as they come
|
|
for key in sortedKeys:
|
|
if key not in mandatoryOrder:
|
|
mandatoryOrder.append(key)
|
|
|
|
return mandatoryOrder
|
|
|
|
|
|
def parseArgs():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument(
|
|
'--output', '-o',
|
|
help='Target file', type=argparse.FileType('w'), required=True)
|
|
parser.add_argument('languageCode', help='Language to generate')
|
|
return parser.parse_args()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
jsonDir = HERE
|
|
|
|
args = parseArgs()
|
|
|
|
try:
|
|
buildVersion = readVersion(jsonDir)
|
|
except:
|
|
log("error: could not get/extract build version")
|
|
sys.exit(1)
|
|
|
|
log("Build version: " + buildVersion)
|
|
log("Making " + args.languageCode + " from " + jsonDir)
|
|
|
|
lang = readTranslation(jsonDir, args.languageCode)
|
|
defs = loadJson(os.path.join(jsonDir, "translations_def.js"), True)
|
|
out = args.output
|
|
writeStart(out)
|
|
writeLanguage(lang, defs, out)
|
|
|
|
log("Done")
|