def register(self, name, dict={}):
"""
Attempt to register a package with the specified name. If a module is
found, create an object from the module's class called `Module',
passing it the environment and `dict' as arguments, and execute all
delayed commands for this module. The dictionary describes the
command that caused the registration.
"""
if name in self:
msg.debug(_("module %s already registered") % name)
return 2
# First look for a script
moddir = ""
mod = None
for path in "", join(moddir, "modules"):
file = join(path, name + ".rub")
if exists(file):
mod = ScriptModule(self.env, file)
msg.log(_("script module %s registered") % name)
break
# Then look for a Python module
if not mod:
if Plugins.register(self, name) == 0:
msg.debug(_("no support found for %s") % name)
return 0
mod = self.modules[name].Module(self.env, dict)
msg.log(_("built-in module %s registered") % name)
# Run any delayed commands.
if name in self.commands:
for (cmd, args, vars) in self.commands[name]:
msg.push_pos(vars)
try:
mod.command(cmd, args)
except AttributeError:
msg.warn(_("unknown directive '%s.%s'") % (name, cmd))
except TypeError:
msg.warn(_("wrong syntax for '%s.%s'") % (name, cmd))
msg.pop_pos()
del self.commands[name]
self.objects[name] = mod
return 1
def command(self):
cmd = []
if self.doc.program == "xelatex":
# If raw index is in UTF-8 the texindy command cannot be used
cmd.extend(["xindy", "-M", "texindy", "-C", self.doc.encoding])
# To behave even more like texindy
cmd.extend(["-q", "-M", "page-ranges"])
else:
# Call texindy to handle LICR encoded raw index
# Equivalent to xindy arguments (beware of module order):
# "xindy", "-M", "tex/inputenc/latin",
# "-M", "texindy", "-C", "latin",
# "-I", "latex"
cmd.extend(["texindy"])
# Specific output files?
if self.target:
cmd.extend(["-o", self.target])
if self.transcript:
cmd.extend(["-t", self.transcript])
# Find out which language to use
if self.index_lang:
lang = self.index_lang
elif self.doc.lang:
lang = self.languages.get(self.doc.lang)
if not (lang):
msg.warn(_("xindy: lang '%s' not found" % \
self.doc.lang), pkg="index")
else:
msg.log(_("xindy: lang '%s' mapped to '%s'" % \
(self.doc.lang, lang)), pkg="index")
else:
lang = None
if lang:
cmd.extend(["-L", lang])
for mod in self.modules:
cmd.extend(["-M", mod])
if self.opts:
cmd.extend(self.opts)
cmd.append(self.idxfile)
return cmd
def print_misschars(self):
"""
Sort the characters not handled by the selected font,
and print them as a warning.
"""
missed_chars = []
for c in self.log.get_misschars():
missed_chars.append((c["uchar"], c["font"]))
# Strip redundant missed chars
missed_chars = list(set(missed_chars))
missed_chars.sort()
for m in missed_chars:
# The log file is encoded in UTF8 (xetex) or in latin1 (pdftex)
uchar = m[0]
# Check we have a real char (e.g. not something like '^^a3')
if len(uchar) == 1:
msg.warn("Character U+%X (%s) not in font '%s'" % \
(ord(uchar), m[0], m[1]))
else:
msg.warn("Character '%s' not in font '%s'" % (m[0], m[1]))
def run(self):
cmd = self.command()
msg.debug(" ".join(cmd))
# Makeindex outputs everything to stderr, even progress messages
rc = subprocess.call(cmd, stderr=msg.stdout)
if (rc != 0):
msg.error(_("could not make index %s") % self.target)
return 1
# Beware with UTF-8 encoding, makeindex with headings can be messy
# because it puts in the headings the first 8bits char of the words
# under the heading which can be an invalid character in UTF-8
if (self.style and self.doc.encoding == "utf8"):
if not (self._index_is_unicode()):
# Retry without style to avoid headings
msg.warn(_("makeindex on UTF8 failed. Retry..."))
self.style = ""
return self.run()
return rc
def run(self):
self._sanitize_idxfile()
self._fix_invalid_ranges()
cmd = self.command()
msg.debug(" ".join(cmd))
# Collect the script output, and errors
logname = join(dirname(self.target), "xindy.log")
logfile = open(logname, "wb")
p = Popen(cmd, stdout=logfile, stderr=PIPE)
errdata = p.communicate()[1]
if isinstance(errdata, bytes):
errdata = errdata.decode(sys.getdefaultencoding())
rc = p.wait()
if msg.stdout:
msg.stdout.write(errdata)
else:
msg.warn(_(errdata.strip()))
logfile.close()
if (rc != 0):
msg.error(_("could not make index %s") % self.target)
return 1
self._detect_invalid_ranges(errdata)
# Now convert the built index to UTF-8 if required
if cmd[0] == "texindy" and self.doc.encoding == "utf8":
if not (self._index_is_unicode()):
encoding = self._find_index_encoding(logname)
tmpindex = join(dirname(self.target), "new.ind")
cmd = [
"iconv", "-f", encoding, "-t", "utf8", "-o", tmpindex,
self.target
]
msg.debug(" ".join(cmd))
rc = subprocess.call(cmd)
if rc == 0: os.rename(tmpindex, self.target)
return rc
def do_order(self, *args):
for opt in args:
if opt == "standard": self.opts = []
elif opt == "german": self.opts.append("-g")
elif opt == "letter": self.opts.append("-l")
else: msg.warn(_("unknown option '%s' for 'makeidx.order'") % opt)