# This file is part of Rubber and thus covered by the GPL
# (c) Emmanuel Beffara, 2002--2006
"""
LaTeX document building system for Rubber.

This module defines the class that parses the input LaTeX to load the expected
modules.
"""
import re

class TexParser:
    re_input = re.compile("\\\\input +(?P<arg>[^{} \n\\\\]+)")
    re_comment = re.compile(r"(?P<line>([^\\%]|\\%|\\)*)(%.*)?")

    def __init__(self, doc):
        self.doc = doc
        self.comment_mark = "%"
        self.exclude_mods = []
        self.hooks = {
            "usepackage"   : self.h_usepackage,
            "begin{btSect}": self.h_bibtopic,
        }
        self.update_rehooks()

    def update_rehooks(self):
        """
        Update the regular expression used to match macro calls using the keys
        in the `hook' dictionary. We don't match all control sequences for
        obvious efficiency reasons.
        """
        # Make a "foo|bar\*stub" list
        hooklist = [x.replace("*", "\\*") for x in self.hooks]

        pattern = "\\\\(?P<name>%s)\*?"\
                  " *(\\[(?P<opt>[^\\]]*)\\])?"\
                  " *({(?P<arg>[^{}]*)}|(?=[^A-Za-z]))"

        self.rehooks = re.compile(pattern % "|".join(hooklist))

    def add_hook(self, name, fun):
        """
        Register a given function to be called (with no arguments) when a
        given macro is found.
        """
        self.hooks[name] = fun
        self.update_rehooks()

    def parse(self, fd, exclude_mods=None):
        """
        Process a LaTeX source. The file must be open, it is read to the end
        calling the handlers for the macro calls. This recursively processes
        the included sources.

        If the optional argument 'dump' is not None, then it is considered as
        a stream on which all text not matched as a macro is written.
        """
        self.exclude_mods = exclude_mods or []
        self.lineno = 0
        for line in fd:
            self.parse_line(line)

    def parse_line(self, line, dump=None):
        self.lineno += 1

        # Remove comments
        line = self.re_comment.match(line).group("line")

        match = self.rehooks.search(line)
        while match:
            dict = match.groupdict()
            name = dict["name"]
            
            # The case of \input is handled specifically, because of the
            # TeX syntax with no braces

            if name == "input" and not dict["arg"]:
                match2 = self.re_input.search(line)
                if match2:
                    match = match2
                    dict = match.groupdict()

            if dump: dump.write(line[:match.start()])
            dict["match"] = line[match.start():match.end()]
            dict["line"] = line[match.end():]
            #dict["pos"] = { 'file': self.vars["file"], 'line': self.lineno }
            dict["pos"] = { 'file': "file", 'line': self.lineno }
            dict["dump"] = dump

#            if self.env.caching:
#                self.cache_list.append(("hook", name, dict))

            self.hooks[name](dict)
            line = dict["line"]
            match = self.rehooks.search(line)

        if dump: dump.write(line)

    def h_usepackage(self, dict):
        """
        Called when a \\usepackage macro is found. If there is a package in the
        directory of the source file, then it is treated as an include file
        unless there is a supporting module in the current directory,
        otherwise it is treated as a package.
        """
        if not dict["arg"]: return
        for name in dict["arg"].split(","):
            name = name.strip()
#            file = self.env.find_file(name + ".sty")
#            if file and not exists(name + ".py"):
#                self.process(file)
#            else:
            if (name in self.exclude_mods):
                continue
            self.doc.modules.register(name, dict)

    def h_bibtopic(self, dict):
        """
        Called when a \\btSect macro is found. It can also be loaded by a
        usepackage of bibtopic. Note that once loaded the btSect hook will be
        preempted by the bibtopic module hook.
        """
        if ("bibtopic" in self.exclude_mods):
            return
        self.doc.modules.register("bibtopic", dict)