summaryrefslogtreecommitdiff
path: root/Build
diff options
context:
space:
mode:
Diffstat (limited to 'Build')
-rwxr-xr-xBuild/source/texk/texlive/linked_scripts/de-macro/de-macro1841
1 files changed, 924 insertions, 917 deletions
diff --git a/Build/source/texk/texlive/linked_scripts/de-macro/de-macro b/Build/source/texk/texlive/linked_scripts/de-macro/de-macro
index 04d286d8ee9..c5795fe891f 100755
--- a/Build/source/texk/texlive/linked_scripts/de-macro/de-macro
+++ b/Build/source/texk/texlive/linked_scripts/de-macro/de-macro
@@ -1,17 +1,20 @@
#!/usr/bin/python -O
-"""
-Copyright 2005 Peter Gacs
+r"""
+Copyright 2005-2020 Peter Gacs
Licensed under the Academic Free Licence version 2.1
- DE-MACRO
+ DE-MACRO
-Version 1.3 - this version is much more conservative about deleting
- comments and inserting or deleting blank space: tries to
- leave in all comments, adds space only when necessary, and
- tries not to delete space in the main text.
- The motivating comments came from Daniel Webb.
-Version 1.2 - a syntactical bug corrected, thanks Brian de Alwis!
+Version 1.4 - Luca Citi made it python2.7 and python3 compatible.
+ Peter Gacs improved the parsing of \input{<filename>},
+ and made @ a letter in the style files.
+Version 1.3 - this version is much more conservative about deleting
+ comments and inserting or deleting blank space: tries to
+ leave in all comments, adds space only when necessary, and
+ tries not to delete space in the main text.
+ The motivating comments came from Daniel Webb.
+Version 1.2 - a syntactical bug corrected, thanks Brian de Alwis!
PURPOSE
@@ -21,13 +24,17 @@ Applications:
- your publisher has difficulty dealing with many private macros
- you cooperate with colleagues who do not understand your macros
- preprocessing before a system like latex2html, which is somewhat
- unpredictable with private macros.
+ unpredictable with private macros.
+
+It cannot be used to eliminate more complex macros that rely on
+more programming-like constructs in style files. In particular, it will
+not replace style files that have options.
USAGE
de-macro [--defs <defs-db>] <tex-file-1>[.tex] [<tex-file-2>[.tex] ...]
-Simplest example: de-macro testament
+Simplest example: de-macro testament
(As you see, the <> is used only in the notation of this documentation,
you should not type it.)
@@ -77,105 +84,105 @@ import sys, os, re, shelve
# Utilities
class No_detail:
- strerror = ""
+ strerror = ""
no_detail = No_detail()
class Error(Exception):
- """Base class for exceptions in this module."""
- pass
+ """Base class for exceptions in this module."""
+ pass
class Empty_text_error(Error):
- """Exception raised for errors in the input.
+ """Exception raised for errors in the input.
- Attributes:
- data -- data that was found empty
- message
- """
+ Attributes:
+ data -- data that was found empty
+ message
+ """
- def __init__(self, data, message):
- self.data = data
- self.message = message
+ def __init__(self, data, message):
+ self.data = data
+ self.message = message
def warn(error_message, detail = no_detail):
- sys.stderr.write(error_message + "\n")
- if no_detail != detail:
- sys.stderr.write(detail.strerror + "\n")
+ sys.stderr.write(error_message + "\n")
+ if no_detail != detail:
+ sys.stderr.write(detail.strerror + "\n")
def die(error_message, detail = no_detail):
- warn(error_message, detail = no_detail)
- sys.exit(1)
+ warn(error_message, detail = no_detail)
+ sys.exit(1)
def getopt_map(one_letter_opts, long_optlist):
- "Turns long options into an option map, using getopt."
- import getopt
- optlist, args = getopt.getopt(sys.argv[1:],
- one_letter_opts, long_optlist)
- opt_map = {}
- for pair in optlist: opt_map[pair[0]] = pair[1] or 1
- return opt_map, args
+ "Turns long options into an option map, using getopt."
+ import getopt
+ optlist, args = getopt.getopt(sys.argv[1:],
+ one_letter_opts, long_optlist)
+ opt_map = {}
+ for pair in optlist: opt_map[pair[0]] = pair[1] or 1
+ return opt_map, args
def newer(file1, file2):
- if not os.path.isfile(file1):
- return False
+ if not os.path.isfile(file1):
+ return False
- try:
- stat_return = os.lstat(file1)
- except OSError, detail:
- die("lstat " + file1 + " failed:", detail)
- time1 = stat_return.st_mtime
+ try:
+ stat_return = os.lstat(file1)
+ except OSError as detail:
+ die("lstat " + file1 + " failed:", detail)
+ time1 = stat_return.st_mtime
- try:
- stat_return = os.lstat(file2)
- except OSError, detail:
- die("lstat " + file2 + " failed:", detail)
- time2 = stat_return.st_mtime
+ try:
+ stat_return = os.lstat(file2)
+ except OSError as detail:
+ die("lstat " + file2 + " failed:", detail)
+ time2 = stat_return.st_mtime
- return time1 > time2
+ return time1 > time2
def cut_extension(filename, ext):
- """
- If filename has extension ext (including the possible dot),
- it will be cut off.
- """
- file = filename
- index = filename.rfind(ext)
- if 0 <= index and len(file)-len(ext) == index:
- file = file[:index]
- return file
+ """
+ If filename has extension ext (including the possible dot),
+ it will be cut off.
+ """
+ file = filename
+ index = filename.rfind(ext)
+ if 0 <= index and len(file)-len(ext) == index:
+ file = file[:index]
+ return file
class Stream:
- data = None
- pos = None
- item = None
-
- def legal(self):
- return 0 <= self.pos and self.pos < len(self.data)
-
- def uplegal(self):
- return self.pos < len(self.data)
-
- def __init__(self, data_v = None):
- self.data = data_v
- if self.data:
- self.pos = 0
- self.item = self.data[self.pos]
-
- def next(self):
- self.pos += 1
- if self.pos < len(self.data):
- self.item = self.data[self.pos]
- return self.item
-
- def reset(self):
- if self.data and 0 < len(self.data):
- self.pos = 0
- self.item = self.data[0]
- return self.item
-
+ data = None
+ pos = None
+ item = None
+
+ def legal(self):
+ return 0 <= self.pos and self.pos < len(self.data)
+
+ def uplegal(self):
+ return self.pos < len(self.data)
+
+ def __init__(self, data_v = None):
+ self.data = data_v
+ if self.data:
+ self.pos = 0
+ self.item = self.data[self.pos]
+
+ def next(self):
+ self.pos += 1
+ if self.pos < len(self.data):
+ self.item = self.data[self.pos]
+ return self.item
+
+ def reset(self):
+ if self.data and 0 < len(self.data):
+ self.pos = 0
+ self.item = self.data[0]
+ return self.item
+
# Basic classes
@@ -186,97 +193,97 @@ blank_or_rbrace_re = re.compile(r"[\s}]")
pos_digit_re = re.compile(r"[1-9]")
def isletter(c, isatletter=False):
- if "@" == c:
- return isatletter
- else:
- return c.isalpha()
+ if "@" == c:
+ return isatletter
+ else:
+ return c.isalpha()
class Token:
- """Type 0 means ordinary character, type 1 means escape sequence
- (without the \ ), type 2 means comment.
- """
- simple_ty = 0
- esc_symb_ty = 1
- esc_str_ty = 2
- comment_ty = 3
-
- type = simple_ty
- val = " "
-
- def __init__(self, type_v=simple_ty, val_v=" "):
- self.type = type_v
- self.val = val_v
-
- def show(self, isatletter=False):
- out = ""
- if simple_ty == self.type or comment_ty == self.type:
- out = self.val
- else:
- out = "\\" + self.val
- return out
+ """Type 0 means ordinary character, types 1,2 mean escape sequence
+ (without the \ ), type 3 means comment.
+ """
+ simple_ty = 0
+ esc_symb_ty = 1
+ esc_str_ty = 2
+ comment_ty = 3
+
+ type = simple_ty
+ val = " "
+
+ def __init__(self, type_v=simple_ty, val_v=" "):
+ self.type = type_v
+ self.val = val_v
+
+ def show(self):
+ out = ""
+ if simple_ty == self.type or comment_ty == self.type:
+ out = self.val
+ else:
+ out = "\\" + self.val
+ return out
# Constants
-g_token = Token(0," ") # generic token
+g_token = Token(0," ") # generic token
simple_ty = g_token.simple_ty
comment_ty = g_token.comment_ty
esc_symb_ty = g_token.esc_symb_ty
esc_str_ty = g_token.esc_str_ty
+def detokenize(text, isatletter=False):
+ """
+ Input is a list of tokens.
+ Output is a string.
+ """
+ out = ""
+ if 0 == len(text):
+ return
+ pos = 0
+ out += text[pos].show()
+ pos += 1
+ while pos < len(text):
+ previtem = text[pos-1]
+ item = text[pos]
+ """Insert a separating space after an escape sequence if it is a
+ string and is followed by a letter."""
+ if (esc_str_ty == previtem.type
+ and simple_ty == item.type and isletter(item.val[0], isatletter)):
+ out += " "
+ out += item.show()
+ pos += 1
+ return out
-def detokenize(text):
- """
- Input is a list of tokens.
- Output is a string.
- """
- out = ""
- if 0 == len(text):
- return
- pos = 0
- out += text[pos].show()
- pos += 1
- while pos < len(text):
- previtem = text[pos-1]
- item = text[pos]
- """Insert a separating space after an escape sequence if it is a
- string and is followed by a letter."""
- if (esc_str_ty == previtem.type
- and simple_ty == item.type and isletter(item.val[0], False)):
- out += " "
- out += item.show()
- pos += 1
- return out
def strip_comments(text):
- """
- Input is a list of tokens.
- Output is the same list except the comment tokens.
- """
- out = []
- for token in text:
- if not comment_ty == token.type:
- out.append(token)
- return out
+ """
+ Input is a list of tokens.
+ Output is the same list except the comment tokens.
+ """
+ out = []
+ for token in text:
+ if not comment_ty == token.type:
+ out.append(token)
+ return out
class Group:
- """type 0 means a token, type 1 means contents of a group within {}
- """
- token_ty = 0
- group_ty = 1
- type = token_ty
- val = [] # Value is a token list.
-
- def __init__(self, type_v, val_v):
- self.type = type_v
- self.val = val_v
-
- def show(self):
- if token_ty == self.type:
- return self.val.show()
- else:
- return "{%s}" % detokenize(self.val)
+ """type 0 means a token, type 1 means contents of a group within {}
+ """
+ token_ty = 0
+ group_ty = 1
+ type = token_ty
+ val = [] # Value is a token list.
+
+ def __init__(self, type_v, val_v):
+ self.type = type_v
+ self.val = val_v
+
+ def show(self):
+ if token_ty == self.type:
+ return self.val.show()
+ else:
+ return "{%s}" % detokenize(self.val)
# Constants
@@ -285,779 +292,779 @@ token_ty = g_group.token_ty
group_ty = g_group.group_ty
-def tokenize(in_str):
- """Returns a list of tokens.
- """
- text = []
- isatletter=False
- cs = Char_stream(in_str)
- cs.reset()
- if not cs.legal():
- raise "No string to tokenize."
- while cs.uplegal():
- if "%" == cs.item:
- comment = cs.scan_comment_token()
- text.append(Token(comment_ty, comment))
- elif "\\" != cs.item:
- text.append(Token(simple_ty, cs.item))
- cs.next()
- else:
- cs.next()
- name = cs.scan_escape_token(isatletter)
- if isletter(name[0], isatletter):
- token = Token(esc_str_ty, name)
- else:
- token = Token(esc_symb_ty, name)
- text.append(token)
- if "makeatletter" == name:
- isatletter=True
- elif "makeatother" == name:
- isatletter=False
- return text
-
-
-
+def tokenize(in_str, isatletter=False):
+ """Returns a list of tokens.
+ """
+ text = []
+ cs = Char_stream(in_str)
+ cs.reset()
+ if not cs.legal():
+ raise Error("No string to tokenize.")
+ while cs.uplegal():
+ if "%" == cs.item:
+ comment = cs.scan_comment_token()
+ text.append(Token(comment_ty, comment))
+ elif "\\" != cs.item:
+ text.append(Token(simple_ty, cs.item))
+ cs.next()
+ else:
+ cs.next()
+ name = cs.scan_escape_token(isatletter)
+ if isletter(name[0], isatletter):
+ token = Token(esc_str_ty, name)
+ else:
+ token = Token(esc_symb_ty, name)
+ text.append(token)
+ if "makeatletter" == name:
+ isatletter=True
+ elif "makeatother" == name:
+ isatletter=False
+ return text
+
+
class Command_def:
- name = "1"
- numargs = 0
- body= ""
+ name = "1"
+ numargs = 0
+ body= ""
- def __init__(self, name_v, numargs_v, body_v):
- self.name = name_v
- self.numargs = numargs_v
- self.body = body_v
+ def __init__(self, name_v, numargs_v, body_v):
+ self.name = name_v
+ self.numargs = numargs_v
+ self.body = body_v
- def show(self):
- out = "\\newcommand{\\%s}" % (self.name)
- if 0 < self.numargs:
- out += "[%d]" % self.numargs
- out += "{%s}" % detokenize(self.body)
- return out
+ def show(self):
+ out = "\\newcommand{\\%s}" % (self.name)
+ if 0 < self.numargs:
+ out += "[%d]" % self.numargs
+ out += "{%s}" % detokenize(self.body)
+ return out
class Env_def:
- name = "1"
- numargs = 0
- begin = ""
- end = ""
-
- def __init__(self, name_v, numargs_v, begin_v, end_v):
- self.name = name_v
- self.numargs = numargs_v
- self.begin = begin_v
- self.end = end_v
-
- def show(self):
- out = "\\newenvironment{%s}" % self.name
- if 0 < self.numargs:
- out += "[%d]" % self.numargs
- out += "{%s}" % detokenize(self.begin)
- out += "{%s}" % detokenize(self.end)
- return out
+ name = "1"
+ numargs = 0
+ begin = ""
+ end = ""
+
+ def __init__(self, name_v, numargs_v, begin_v, end_v):
+ self.name = name_v
+ self.numargs = numargs_v
+ self.begin = begin_v
+ self.end = end_v
+
+ def show(self):
+ out = "\\newenvironment{%s}" % self.name
+ if 0 < self.numargs:
+ out += "[%d]" % self.numargs
+ out += "{%s}" % detokenize(self.begin)
+ out += "{%s}" % detokenize(self.end)
+ return out
class Command_instance:
- name = "1"
- args = []
+ name = "1"
+ args = []
- def __init__(self, name_v, args_v):
- self.name = name_v
- self.args = args_v
+ def __init__(self, name_v, args_v):
+ self.name = name_v
+ self.args = args_v
- def show(self):
- out = "\\"+self.name
- for arg in self.args:
- out += "{%s}" % detokenize(arg)
- return out
+ def show(self):
+ out = "\\"+self.name
+ for arg in self.args:
+ out += "{%s}" % detokenize(arg)
+ return out
class Env_instance:
- name = "1"
- args = []
-
- def __init__(self, name_v, args_v, body_v):
- self.name = name_v
- self.args = args_v
- self.body = body_v
-
- def show(self):
- out = "\\begin{%s}" % self.name
- for arg in self.args:
- out += "{%s}" % detokenize(arg)
- out += detokenize(self.body)
- out += "\\end{%s}" % self.name
- return out
+ name = "1"
+ args = []
+
+ def __init__(self, name_v, args_v, body_v):
+ self.name = name_v
+ self.args = args_v
+ self.body = body_v
+
+ def show(self):
+ out = "\\begin{%s}" % self.name
+ for arg in self.args:
+ out += "{%s}" % detokenize(arg)
+ out += detokenize(self.body)
+ out += "\\end{%s}" % self.name
+ return out
class Char_stream(Stream):
- def scan_escape_token(self, isatletter=False):
- """
- Starts after the escape sign, assumes that it is scanning a symbol.
- Returns a token-string.
- """
- out = self.item # Continue only if this is a letter.
- item = self.next()
- if isletter(out, isatletter):
- while self.uplegal() and isletter(item, isatletter):
- out += item
- item = self.next()
- return out
-
- def scan_comment_token(self):
- """
- Starts at the comment sign %, assumes that it is scanning a comment.
- Returns the whole comment string,
- including the % and all empty space after it.
- """
- comment = ""
- while "\n" != self .item:
- comment += self.item
- self.next()
- while self.uplegal() and blank_re.match(self.item):
- comment += self.item
- self.next()
- return comment
-
- def scan_input_filename(self):
- """We just read an \input token. The next group or word will be
- interpreted as a filename (possibly without .tex).
- Return the filename.
- """
- item = self.item
- while self.uplegal() and blank_re.match(self.item):
- item = self.next()
- if "{" == item:
- item = self.next()
- file = ""
- while self.uplegal() and not blank_or_rbrace_re.match(item):
- file += item
- item = self.next()
- self.next()
- return file
-
- def scan_package_filenames(self):
- """We just read a \usepackage token. The next group will be
- interpreted as a list of filenames (without .sty) separated by commas.
- Return the list.
- """
- item = self.item
- while self.uplegal() and blank_re.match(item):
- item = self.next()
- file = ""
- if not "{" == item:
- raise "\\usepackage not followed by brace."
- item = self.next()
- while self.uplegal() and not blank_or_rbrace_re.match(item):
- file += item
- item = self.next()
- self.next()
- return file.split(",")
+ def scan_escape_token(self, isatletter=False):
+ """
+ Starts after the escape sign, assumes that it is scanning a symbol.
+ Returns a token-string.
+ """
+ out = self.item # Continue only if this is a letter.
+ item = self.next()
+ if isletter(out, isatletter):
+ while self.uplegal() and isletter(item, isatletter):
+ out += item
+ item = self.next()
+ return out
+
+ def scan_comment_token(self):
+ """
+ Starts at the comment sign %, assumes that it is scanning a comment.
+ Returns the whole comment string,
+ including the % and all empty space after it.
+ """
+ comment = ""
+ while self.uplegal() and "\n" != self .item:
+ comment += self.item
+ self.next()
+ while self.uplegal() and blank_re.match(self.item):
+ comment += self.item
+ self.next()
+ return comment
+
+ def scan_input_filename(self):
+ """We have just read an \input token. The next group or word will be
+ interpreted as a filename (possibly without .tex). Filenames should not begin with spaces.
+ Return the filename.
+ """
+ item = self.item
+ file = ""
+ while self.uplegal() and blank_re.match(self.item):
+ item = self.next()
+ if "{" == item:
+ item = self.next()
+ while self.uplegal() and not "}" == item:
+ file += item
+ item = self.next()
+ self.next()
+ else:
+ while self.uplegal() and not blank_re.match(item):
+ file += item
+ item = self.next()
+ return file
+
+ def scan_package_filenames(self):
+ r"""We just read a \usepackage token. The next group will be
+ interpreted as a list of filenames (without .sty) separated by commas.
+ Return the list.
+ """
+ item = self.item
+ while self.uplegal() and blank_re.match(item):
+ item = self.next()
+ file = ""
+ if not "{" == item:
+ raise Error("\\usepackage not followed by brace.")
+ item = self.next()
+ while self.uplegal() and not blank_or_rbrace_re.match(item):
+ file += item
+ item = self.next()
+ self.next()
+ return file.split(",")
class Tex_stream(Stream):
- defs = ({}, {})
- defs_db = "x"
- defs_db_file = "x.db"
- debug = False
-
- def smart_tokenize(self, in_str, handle_inputs=False):
- """Returns a list of tokens.
- It may interpret and carry out all \input commands.
- """
- self.data = []
- text = self.data
- isatletter=False
- cs = Char_stream(in_str)
- cs.reset()
- if not cs.legal():
- raise "No string to tokenize."
- while cs.uplegal():
- if "%" == cs.item:
- comment = cs.scan_comment_token()
- text.append(Token(comment_ty, comment))
- elif "\\" != cs.item:
- text.append(Token(simple_ty, cs.item))
- cs.next()
- else:
- cs.next()
- name = cs.scan_escape_token(isatletter)
- if "input" == name and handle_inputs:
- file = cs.scan_input_filename()
- to_add = self.process_if_newer(file)
- text.extend(to_add)
- elif "usepackage" == name:
- while cs.uplegal() and blank_re.match(cs.item):
- cs.next()
- if "[" == cs.item: # private packages have no options
- text.extend([Token(esc_str_ty, "usepackage"),
- Token(simple_ty, "[")])
- cs.next()
- continue
- files = cs.scan_package_filenames()
- i = 0
- while i < len(files): # process private packages
- file = files[i]
- p = file.rfind("-private")
- if p < 0 or not len(file) - len("-private") == p:
- i += 1
- continue
- defs_db_file = file+".db"
- self.add_defs(file)
- del files[i:(i+1)]
- if files: # non-private packages left
- group_content = ",".join(files)
- to_add_str = "\\usepackage{%s}" % (group_content)
- to_add = tokenize(to_add_str)
- text.extend(to_add)
- else:
- if isletter(name[0], isatletter):
- token = Token(esc_str_ty, name)
- else:
- token = Token(esc_symb_ty, name)
- text.append(token)
- if "makeatletter" == name:
- isatletter=True
- elif "makeatother" == name:
- isatletter=False
- self.reset()
- return self.data
-
- def smart_detokenize(self):
- """
- Output is a string.
- If the list contains an \input{file} then the content of file
- file-clean.tex replaces it in the output.
- """
- self.reset()
- if not self.legal():
- return ""
- out = ""
- previtem = None
- while self.uplegal():
- item = self.item
- """Insert a separating space after an escape sequence if it is a
- string and is followed by a letter."""
- if (None != previtem and esc_str_ty == previtem.type
- and simple_ty == item.type and isletter(item.val[0], False)):
- out += " "
- previtem = item
- if not (esc_str_ty == item.type and "input" == item.val):
- out += item.show()
- self.next()
- else:
- self.next()
- group = self.scan_group()
- file = detokenize(group.val)
- clean_file = "%s-clean.tex" % (file)
- print "Reading file %s" % (clean_file)
- fp = open(clean_file,"r")
- content = fp.read()
- fp.close()
- out += content
- return out
-
- # Basic tex scanning
-
- def skip_blank_tokens(self): # we also skip comment tokens.
- item = self.item
- while (self.uplegal() and
- (comment_ty == item.type or
- (simple_ty == item.type and blank_re.match(item.val)))):
- item = self.next()
- return item
-
- def scan_group(self):
- """Returns group.
- """
- if not self.legal():
- raise "No group to scan."
- item = self.item
- if not (simple_ty == item.type and "{" == item.val):
- return Group(token_ty, [self.item])
- count = 1
- group = []
- item = self.next()
- while count and self.uplegal():
- if simple_ty == item.type:
- if "{" == item.val:
- count += 1
- elif "}" == item.val:
- count -= 1
- if count != 0:
- group.append(item)
- item = self.next()
- return Group(group_ty, group)
-
- # Command and environment definitions
-
- def scan_command_name(self):
- """Returns name.
- """
- if not self.legal():
- raise "No command name to scan."
- item = self.item
- name = ""
- if item.type in [esc_symb_ty, esc_str_ty]:
- name = item.val
- else:
- if not "{" == item.val:
- raise "Command definition misses first {."
- self.next()
- item = self.skip_blank_tokens()
- if not item.type in [esc_symb_ty, esc_str_ty]:
- raise "Command definition does not begin with control sequence."
- name = item.val
- self.next()
- item = self.skip_blank_tokens()
- if not "}" == item.val:
- raise ("Definition for commmand %s misses first }., %s" %
- (name, item.val))
- self.next()
- self.skip_blank_tokens()
- return name
-
- def scan_numargs(self, name):
- """
- name is the name of the command or environment definition being
- scanned.
- Starts on a nonblank token.
- Returns numargs
- where numargs is the number of arguments in a command or environment
- definition,
- """
- if not self.legal():
- raise "No numargs to scan."
- item = self.item
- numargs = 0
- if not simple_ty == item.type:
- raise "Illegal command or environment definition: "+name
- if "[" == item.val:
- if not 4 < len(self.data):
- raise "Command or environment definition is illegal: "+name
- item = self.next()
- if not simple_ty == item.type:
- raise "Illegal command or environment definition: "+name
- numargs = item.val
- if not pos_digit_re.match(numargs):
- raise "%s must be argument number after %s" % (numargs, name)
- numargs = int(numargs)
- self.next()
- item = self.skip_blank_tokens()
- if not simple_ty == item.type:
- raise "Illegal command definition: "+name
- if "]" != item.val:
- raise "Illegal command definition: "+name
- self.next()
- self.skip_blank_tokens()
- return numargs
-
- def scan_command_def(self):
- """Scan a command definition.
- Return command_def.
- Assumes that the number of arguments is at most 9.
- """
- if not self.legal():
- raise "No command definition to scan."
- item = self.item
- if not 2 < len(self.data):
- raise "Command definition is illegal."
- # newcommand or renewcommand
- if not item.type in [esc_symb_ty, esc_str_ty]:
- raise "Command definition should begin with control sequence: "+item.val
- if item.val not in ["newcommand", "renewcommand"]:
- raise "Command definition should begin with control sequence."
- self.next()
- self.skip_blank_tokens()
-
- cmd_name = self.scan_command_name()
- numargs = self.scan_numargs(cmd_name)
-
- body_group = self.scan_group()
- if group_ty != body_group.type:
- raise "Command body missing: "+cmd_name
- body_val = strip_comments(body_group.val)
- return Command_def(cmd_name, numargs, body_val)
-
- def scan_env_name(self):
- """Starts on a {.
- Returns name.
- """
- if not self.legal():
- raise "No environment name to scan."
- item = self.item
- if not "{" == item.val:
- raise "Env. definition begins with %s, not with {" % (item.val)
- self.next()
- item = self.skip_blank_tokens()
- name = ""
- if not simple_ty == item.type:
- raise ("1. Env. def. begins with cont. seq. %s, not with env.name."
- % (item.val))
- while self.uplegal() and not blank_or_rbrace_re.match(item.val):
- name += item.val
- item = self.next()
- if not simple_ty == item.type:
- raise ("2. Env. def. begins with cont. seq. %s, not with env.name."
- % (item.val))
- item = self.skip_blank_tokens()
- if not "}" == item.val:
- raise "Command definition does not begin with control sequence."
- self.next()
- self.skip_blank_tokens()
- return name
-
- def scan_env_def(self):
- """Scan an environment definition.
- Return env_def
- Assumes that the number of arguments is at most 9.
- """
- if not self.legal():
- raise "No environment definition to scan."
- item = self.item
- if not 7 < len(self.data):
- raise "Environment definition is illegal."
- pos = 0
-
- if not item.type in [esc_symb_ty, esc_str_ty]:
- raise ("Env. definition does not begin with control sequence:"+
- item.val)
- if item.val not in ["newenvironment", "renewenvironment"]:
- raise "Env. definition does not begin with control sequence."
- self.next()
- self.skip_blank_tokens()
-
- env_name = self.scan_env_name()
- numargs = self.scan_numargs(env_name)
- self.skip_blank_tokens()
-
- begin_group = self.scan_group()
- if group_ty != begin_group.type:
- raise "Begin body missing: "+env_name
- begin_val = strip_comments(begin_group.val)
-
- self.skip_blank_tokens()
-
- end_group = self.scan_group()
- if group_ty != end_group.type:
- raise "End body missing:"+env_name
- end_val = strip_comments(end_group.val)
-
- return Env_def(env_name, numargs, begin_val, end_val)
-
- def scan_defs(self):
- if not self.legal():
- raise "No definitions to scan."
- self.reset()
- command_defs, env_defs = self.defs
- while self.uplegal():
- if (esc_str_ty == self.item.type
- and self.item.val in ["newcommand", "renewcommand"]):
- command_def = self.scan_command_def()
- command_defs[command_def.name] = command_def
- elif (esc_str_ty == self.item.type and self.item.val
- in ["newenvironment", "renewenvironment"]):
- env_def = self.scan_env_def()
- env_defs[env_def.name] = env_def
- else:
- self.next()
-
- # Instances
-
- def scan_args(self, command_or_env_def):
- """Scan the arguments of a command or environment.
- Return [args].
- """
- if not self.legal():
- raise "No arguments to scan."
- numargs = command_or_env_def.numargs
- name = command_or_env_def.name
-
- args = []
- for i in range(numargs):
- arg = []
- if not (simple_ty == self.item.type and "{" == self.item.val):
- arg = [self.item]
- self.next()
- else:
- group = self.scan_group()
- arg = group.val
- args.append(arg)
- return args
-
- def scan_command(self, command_def):
- """Scan the arguments of a command.
- Return command_instance
- """
- if not self.legal():
- raise "No command to scan."
- if not self.item.type in [esc_symb_ty, esc_str_ty]:
- raise "Command does not begin with control sequence."
- name = self.item.val
- self.next()
- if 0 < command_def.numargs:
- self.skip_blank_tokens()
- args = self.scan_args(command_def)
- else:
- args = []
- return Command_instance(name, args)
-
- def test_env_boundary(self, item):
- """Check whether an environment begin or end follows.
- Return 1 if \begin, -1 if \end, 0 otherwise.
- """
- d = 0
- if esc_str_ty == item.type:
- if "begin"==item.val:
- d = 1
- elif "end"==item.val:
- d = -1
- return d
-
- def scan_env_begin(self):
- """Scan an environment name.
- Return env_name.
- """
- if not self.legal():
- raise "No environment begin to scan."
- item = self.item
- if not (esc_str_ty == item.type and "begin" == item.val):
- raise "Environment does not begin with begin."
- self.next()
- name_group = self.scan_group()
- name = detokenize(name_group.val)
- return name
-
- def scan_env_end(self):
- """Scan an environment end.
- Return env_name.
- """
- if not self.legal():
- raise "No environment end to scan."
- item = self.item
- if not (esc_str_ty == item.type and "end" == item.val):
- raise "Environment does not end with end."
- self.next()
- name_group = self.scan_group()
- name = detokenize(name_group.val)
- return name
-
- def scan_env_rest(self, env_def):
- """Scanning starts after \begin{envname}.
- Returns env_instance.
- """
- if not self.legal():
- raise "No environment rest to scan."
- count = 1 # We are already within a boundary.
- args = self.scan_args(env_def)
- body = []
- while count and self.uplegal():
- old_pos = self.pos
- d = self.test_env_boundary(self.item)
- count += d
- if 1 == d:
- self.scan_env_begin()
- elif -1 == d:
- self.scan_env_end()
- else:
- self.next()
- if 0 < count:
- body.extend(self.data[old_pos : self.pos])
- return Env_instance(env_def.name, args, body)
-
- # Definitions
-
- def restore_defs(self):
- if os.path.isfile(self.defs_db_file):
- print "Using defs db %s" % (self.defs_db_file)
- db_h = shelve.open(self.defs_db)
- self.defs = db_h["defs"]
- db_h.close()
-
- def save_defs(self):
- db_h = shelve.open(self.defs_db)
- if db_h.has_key("defs"):
- del db_h["defs"]
- db_h["defs"] = self.defs
- db_h.close()
-
- def add_defs(self, defs_file):
- defs_file_compl = defs_file + ".sty"
- if not os.path.isfile(defs_file_compl):
- raise "%s does not exist" % (defs_file_compl)
-
- defs_db_file = self.defs_db_file
- if newer(defs_db_file, defs_file_compl):
- print "Using defs db %s for %s" % (defs_db_file, defs_file)
- else:
- defs_fp = open(defs_file_compl, "r")
- defs_str = defs_fp.read()
- defs_fp.close()
- ds = Tex_stream()
- ds.defs = self.defs
- defs_text = ds.smart_tokenize(defs_str)
- # changing ds.defs will change self.defs
- if self.debug:
- defs_seen_file = "%s-seen.sty" % (defs_file)
- defs_seen_fp = open(defs_seen_file, "w")
- out = detokenize(defs_text)
- defs_seen_fp.write(out)
- defs_seen_fp.close()
- ds.scan_defs()
- if self.debug:
- out = ""
- command_defs, env_defs = self.defs
- for def_name in command_defs.keys():
- out += command_defs[def_name].show() + "\n"
- for def_name in env_defs.keys():
- out += env_defs[def_name].show() +"\n"
- print "Definitions after reading %s:" % (defs_file)
- print out
-
- # Applying definitions, recursively
- # (maybe not quite in Knuth order, so avoid tricks!)
-
- def subst_args(self, body, args):
- out = []
- pos = 0
- while pos < len(body):
- item = body[pos]
- if not (simple_ty == item.type and "#" == item.val):
- out.append(item)
- pos += 1
- continue
- pos += 1
- token = body[pos]
- argnum = token.val
- if not pos_digit_re.match(argnum):
- raise "# is not followed by number."
- argnum = int(argnum)
- if argnum > len(args):
- raise "Too large argument number."
- arg = args[argnum-1]
- out += arg
- pos += 1
- return out
-
- def apply_command_recur(self, command_instance):
- command_defs, env_defs = self.defs
- name = command_instance.name
- command_def = command_defs[name]
-
- args = command_instance.args
- body = command_def.body
- result = self.subst_args(body, args)
- try:
- result = self.apply_all_recur(result)
- except Empty_text_error, e:
- raise "apply_all_recur fails on command instance %s: %s, %s" % \
- (command_instance.show(), detokenize(e.data), e.message)
- return result
-
- def apply_env_recur(self, env_instance):
- command_defs, env_defs = self.defs
- name = env_instance.name
- env_def = env_defs[name]
-
- begin, end = env_def.begin, env_def.end
- body, args = env_instance.body, env_instance.args
- out = self.subst_args(begin, args) + body + self.subst_args(end, args)
- return self.apply_all_recur(out)
-
-
- def apply_all_recur(self, data, report=False):
- ts = Tex_stream(data)
- ts.defs = self.defs
- command_defs, env_defs = self.defs
- out = []
- progress_step = 10000
- progress = progress_step
- if not ts.legal():
- raise Empty_text_error(data, "No text to process.")
- while ts.uplegal():
- if self.pos > progress:
- if report:
- print self.pos
- progress += progress_step
- if not ts.item.type in [esc_symb_ty, esc_str_ty]:
- out.append(ts.item)
- ts.next()
- continue
- if 1 == ts.test_env_boundary(ts.item):
- old_pos = ts.pos
- env_name = ts.scan_env_begin()
- if not env_defs.has_key(env_name):
- out.extend(ts.data[old_pos : ts.pos])
- continue
- else:
- env_def = env_defs[env_name]
- env_instance = ts.scan_env_rest(env_def)
- result = ts.apply_env_recur(env_instance)
- out.extend(result)
- elif not command_defs.has_key(ts.item.val):
- out.append(ts.item)
- ts.next()
- continue
- else:
- command_def = command_defs[ts.item.val]
- command_inst = ts.scan_command(command_def)
- result = ts.apply_command_recur(command_inst)
- out.extend(result)
- return out
-
-
- # Processing files
-
- def process_file(self, file):
- """Returns the new defs.
- """
- file = cut_extension(file, ".tex")
- source_file = "%s.tex" % (file)
- print "File %s [" % (source_file)
- source_fp = open(source_file, "r")
- text_str = source_fp.read()
- source_fp.close()
-
- self.smart_tokenize(text_str, handle_inputs=True)
- if not self.data:
- raise "Empty tokenization result."
- self.reset()
-
- if self.debug:
- source_seen_fname = "%s-seen.tex" % (file)
- source_seen_fp = open(source_seen_fname, "w")
- source_seen_fp.write(detokenize(self.data))
- source_seen_fp.close()
-
- self.data = self.apply_all_recur(self.data, report=True)
-
- result_fname = "%s-clean.tex" % (file)
- print "Writing %s [" % (result_fname)
- result_fp = open(result_fname, "w")
- result_fp.write(self.smart_detokenize())
- result_fp.close()
- print "] file %s" % (result_fname)
- print "] file %s" % (source_file)
-
- def process_if_newer(self, file):
- """
- \input{file} is be added to the token list.
- If the input file is newer it is processed.
- Returns tokenized \input{file}.
- """
- file = cut_extension(file, ".tex")
- tex_file = file+".tex"
- clean_tex_file = file+"-clean.tex"
- if newer(clean_tex_file, tex_file):
- print "Using %s." % (clean_tex_file)
- else:
- ts = Tex_stream()
- ts.data = []
- ts.defs = self.defs
- ts.process_file(file)
- to_add = "\\input{%s}" % (file)
- return tokenize(to_add)
-
+ defs = ({}, {})
+ defs_db = "x"
+ defs_db_file = "x.db"
+ debug = False
+
+ def smart_tokenize(self, in_str, handle_inputs=False, isatletter=False):
+ """Returns a list of tokens.
+ It may interpret and carry out all \input commands.
+ """
+ self.data = []
+ text = self.data
+ cs = Char_stream(in_str)
+ cs.reset()
+ if not cs.legal():
+ raise Error("No string to tokenize.")
+ while cs.uplegal():
+ if "%" == cs.item:
+ comment = cs.scan_comment_token()
+ text.append(Token(comment_ty, comment))
+ elif "\\" != cs.item:
+ text.append(Token(simple_ty, cs.item))
+ cs.next()
+ else:
+ cs.next()
+ name = cs.scan_escape_token(isatletter)
+ if "input" == name and handle_inputs:
+ file = cs.scan_input_filename()
+ to_add = self.process_if_newer(file)
+ text.extend(to_add)
+ elif "usepackage" == name:
+ while cs.uplegal() and blank_re.match(cs.item):
+ cs.next()
+ if "[" == cs.item: # Packages with options will not be processed.
+ text.extend([Token(esc_str_ty, "usepackage"),
+ Token(simple_ty, "[")])
+ cs.next()
+ continue
+ files = cs.scan_package_filenames()
+ i = 0
+ while i < len(files): # process private packages
+ file = files[i]
+ p = file.rfind("-private")
+ if p < 0 or not len(file) - len("-private") == p:
+ i += 1
+ continue
+ defs_db_file = file+".db"
+ self.add_defs(file)
+ del files[i:(i+1)]
+ if files: # non-private packages left
+ group_content = ",".join(files)
+ to_add_str = "\\usepackage{%s}" % (group_content)
+ to_add = tokenize(to_add_str,isatletter)
+ text.extend(to_add)
+ else:
+ if isletter(name[0], isatletter):
+ token = Token(esc_str_ty, name)
+ else:
+ token = Token(esc_symb_ty, name)
+ text.append(token)
+ if "makeatletter" == name:
+ isatletter=True
+ elif "makeatother" == name:
+ isatletter=False
+ self.reset()
+ return self.data
+
+ def smart_detokenize(self,isatletter=False):
+ """
+ Output is a string.
+ If the list contains an \input{file} then the content of file
+ file-clean.tex replaces it in the output.
+ """
+ self.reset()
+ if not self.legal():
+ return ""
+ out = ""
+ previtem = None
+ while self.uplegal():
+ item = self.item
+ """Insert a separating space after an escape sequence if it is a
+ string and is followed by a letter."""
+ if (None != previtem and esc_str_ty == previtem.type
+ and simple_ty == item.type and isletter(item.val[0], isatletter)):
+ out += " "
+ previtem = item
+ if not (esc_str_ty == item.type and "input" == item.val):
+ out += item.show()
+ self.next()
+ else:
+ self.next()
+ group = self.scan_group()
+ file = detokenize(group.val)
+ clean_file = "%s-clean.tex" % (file)
+ print("Reading file %s" % (clean_file))
+ fp = open(clean_file,"r")
+ content = fp.read()
+ fp.close()
+ out += content
+ return out
+
+ # Basic tex scanning
+
+ def skip_blank_tokens(self): # we also skip comment tokens.
+ item = self.item
+ while (self.uplegal() and
+ (comment_ty == item.type or
+ (simple_ty == item.type and blank_re.match(item.val)))):
+ item = self.next()
+ return item
+
+ def scan_group(self):
+ """Returns group.
+ """
+ if not self.legal():
+ raise Error("No group to scan.")
+ item = self.item
+ if not (simple_ty == item.type and "{" == item.val):
+ return Group(token_ty, [self.item])
+ count = 1
+ group = []
+ item = self.next()
+ while count and self.uplegal():
+ if simple_ty == item.type:
+ if "{" == item.val:
+ count += 1
+ elif "}" == item.val:
+ count -= 1
+ if count != 0:
+ group.append(item)
+ item = self.next()
+ return Group(group_ty, group)
+
+ # Command and environment definitions
+
+ def scan_command_name(self):
+ """Returns name.
+ """
+ if not self.legal():
+ raise Error("No command name to scan.")
+ item = self.item
+ name = ""
+ if item.type in [esc_symb_ty, esc_str_ty]:
+ name = item.val
+ else:
+ if not "{" == item.val:
+ raise Error("Command definition misses first {.")
+ self.next()
+ item = self.skip_blank_tokens()
+ if not item.type in [esc_symb_ty, esc_str_ty]:
+ raise Error("Command definition does not begin with control sequence.")
+ name = item.val
+ self.next()
+ item = self.skip_blank_tokens()
+ if not "}" == item.val:
+ raise Error("Definition for commmand %s misses first }., %s" %
+ (name, item.val))
+ self.next()
+ self.skip_blank_tokens()
+ return name
+
+ def scan_numargs(self, name):
+ """
+ name is the name of the command or environment definition being
+ scanned.
+ Starts on a nonblank token.
+ Returns numargs
+ where numargs is the number of arguments in a command or environment
+ definition,
+ """
+ if not self.legal():
+ raise Error("No numargs to scan.")
+ item = self.item
+ numargs = 0
+ if not simple_ty == item.type:
+ raise Error("Illegal command or environment definition: "+name)
+ if "[" == item.val:
+ if not 4 < len(self.data):
+ raise Error("Command or environment definition is illegal: "+name)
+ item = self.next()
+ if not simple_ty == item.type:
+ raise Error("Illegal command or environment definition: "+name)
+ numargs = item.val
+ if not pos_digit_re.match(numargs):
+ raise Error("%s must be argument number after %s" % (numargs, name))
+ numargs = int(numargs)
+ self.next()
+ item = self.skip_blank_tokens()
+ if not simple_ty == item.type:
+ raise Error("Illegal command definition: "+name)
+ if "]" != item.val:
+ raise Error("Illegal command definition: "+name)
+ self.next()
+ self.skip_blank_tokens()
+ return numargs
+
+ def scan_command_def(self):
+ """Scan a command definition.
+ Return command_def.
+ Assumes that the number of arguments is at most 9.
+ """
+ if not self.legal():
+ raise Error("No command definition to scan.")
+ item = self.item
+ if not 2 < len(self.data):
+ raise Error("Command definition is illegal.")
+ # newcommand or renewcommand
+ if not item.type in [esc_symb_ty, esc_str_ty]:
+ raise Error("Command definition should begin with control sequence: "+item.val)
+ if item.val not in ["newcommand", "renewcommand"]:
+ raise Error("Command definition should begin with control sequence.")
+ self.next()
+ self.skip_blank_tokens()
+
+ cmd_name = self.scan_command_name()
+ numargs = self.scan_numargs(cmd_name)
+
+ body_group = self.scan_group()
+ if group_ty != body_group.type:
+ raise Error("Command body missing: "+cmd_name)
+ body_val = strip_comments(body_group.val)
+ return Command_def(cmd_name, numargs, body_val)
+
+ def scan_env_name(self):
+ """Starts on a {.
+ Returns name.
+ """
+ if not self.legal():
+ raise Error("No environment name to scan.")
+ item = self.item
+ if not "{" == item.val:
+ raise Error("Env. definition begins with %s, not with {" % (item.val))
+ self.next()
+ item = self.skip_blank_tokens()
+ name = ""
+ if not simple_ty == item.type:
+ raise Error("1. Env. def. begins with cont. seq. %s, not with env.name."
+ % (item.val))
+ while self.uplegal() and not blank_or_rbrace_re.match(item.val):
+ name += item.val
+ item = self.next()
+ if not simple_ty == item.type:
+ raise Error("2. Env. def. begins with cont. seq. %s, not with env.name."
+ % (item.val))
+ item = self.skip_blank_tokens()
+ if not "}" == item.val:
+ raise Error("Command definition does not begin with control sequence.")
+ self.next()
+ self.skip_blank_tokens()
+ return name
+
+ def scan_env_def(self):
+ """Scan an environment definition.
+ Return env_def
+ Assumes that the number of arguments is at most 9.
+ """
+ if not self.legal():
+ raise Error("No environment definition to scan.")
+ item = self.item
+ if not 7 < len(self.data):
+ raise Error("Environment definition is illegal.")
+ pos = 0
+
+ if not item.type in [esc_symb_ty, esc_str_ty]:
+ raise Error("Env. definition does not begin with control sequence:"+
+ item.val)
+ if item.val not in ["newenvironment", "renewenvironment"]:
+ raise Error("Env. definition does not begin with control sequence.")
+ self.next()
+ self.skip_blank_tokens()
+
+ env_name = self.scan_env_name()
+ numargs = self.scan_numargs(env_name)
+ self.skip_blank_tokens()
+
+ begin_group = self.scan_group()
+ if group_ty != begin_group.type:
+ raise Error("Begin body missing: "+env_name)
+ begin_val = strip_comments(begin_group.val)
+
+ self.skip_blank_tokens()
+
+ end_group = self.scan_group()
+ if group_ty != end_group.type:
+ raise Error("End body missing:"+env_name)
+ end_val = strip_comments(end_group.val)
+
+ return Env_def(env_name, numargs, begin_val, end_val)
+
+ def scan_defs(self):
+ if not self.legal():
+ raise Error("No definitions to scan.")
+ self.reset()
+ command_defs, env_defs = self.defs
+ while self.uplegal():
+ if (esc_str_ty == self.item.type
+ and self.item.val in ["newcommand", "renewcommand"]):
+ command_def = self.scan_command_def()
+ command_defs[command_def.name] = command_def
+ elif (esc_str_ty == self.item.type and self.item.val
+ in ["newenvironment", "renewenvironment"]):
+ env_def = self.scan_env_def()
+ env_defs[env_def.name] = env_def
+ else:
+ self.next()
+
+ # Instances
+
+ def scan_args(self, command_or_env_def):
+ """Scan the arguments of a command or environment.
+ Return [args].
+ """
+ if not self.legal():
+ raise Error("No arguments to scan.")
+ numargs = command_or_env_def.numargs
+ name = command_or_env_def.name
+
+ args = []
+ for i in range(numargs):
+ arg = []
+ if not (simple_ty == self.item.type and "{" == self.item.val):
+ arg = [self.item]
+ self.next()
+ else:
+ group = self.scan_group()
+ arg = group.val
+ args.append(arg)
+ return args
+
+ def scan_command(self, command_def):
+ """Scan the arguments of a command.
+ Return command_instance
+ """
+ if not self.legal():
+ raise Error("No command to scan.")
+ if not self.item.type in [esc_symb_ty, esc_str_ty]:
+ raise Error("Command does not begin with control sequence.")
+ name = self.item.val
+ self.next()
+ if 0 < command_def.numargs:
+ self.skip_blank_tokens()
+ args = self.scan_args(command_def)
+ else:
+ args = []
+ return Command_instance(name, args)
+
+ def test_env_boundary(self, item):
+ """Check whether an environment begin or end follows.
+ Return 1 if \begin, -1 if \end, 0 otherwise.
+ """
+ d = 0
+ if esc_str_ty == item.type:
+ if "begin"==item.val:
+ d = 1
+ elif "end"==item.val:
+ d = -1
+ return d
+
+ def scan_env_begin(self):
+ """Scan an environment name.
+ Return env_name.
+ """
+ if not self.legal():
+ raise Error("No environment begin to scan.")
+ item = self.item
+ if not (esc_str_ty == item.type and "begin" == item.val):
+ raise Error("Environment does not begin with begin.")
+ self.next()
+ name_group = self.scan_group()
+ name = detokenize(name_group.val)
+ return name
+
+ def scan_env_end(self):
+ """Scan an environment end.
+ Return env_name.
+ """
+ if not self.legal():
+ raise Error("No environment end to scan.")
+ item = self.item
+ if not (esc_str_ty == item.type and "end" == item.val):
+ raise Error("Environment does not end with end.")
+ self.next()
+ name_group = self.scan_group()
+ name = detokenize(name_group.val)
+ return name
+
+ def scan_env_rest(self, env_def):
+ """Scanning starts after \begin{envname}.
+ Returns env_instance.
+ """
+ if not self.legal():
+ raise Error("No environment rest to scan.")
+ count = 1 # We are already within a boundary.
+ args = self.scan_args(env_def)
+ body = []
+ while count and self.uplegal():
+ old_pos = self.pos
+ d = self.test_env_boundary(self.item)
+ count += d
+ if 1 == d:
+ self.scan_env_begin()
+ elif -1 == d:
+ self.scan_env_end()
+ else:
+ self.next()
+ if 0 < count:
+ body.extend(self.data[old_pos : self.pos])
+ return Env_instance(env_def.name, args, body)
+
+ # Definitions
+
+ def restore_defs(self):
+ if os.path.isfile(self.defs_db_file):
+ print("Using defs db %s" % (self.defs_db_file))
+ db_h = shelve.open(self.defs_db)
+ self.defs = db_h["defs"]
+ db_h.close()
+
+ def save_defs(self):
+ db_h = shelve.open(self.defs_db)
+ if "defs" in db_h:
+ del db_h["defs"]
+ db_h["defs"] = self.defs
+ db_h.close()
+
+ def add_defs(self, defs_file):
+ defs_file_compl = defs_file + ".sty"
+ if not os.path.isfile(defs_file_compl):
+ raise Error("%s does not exist" % (defs_file_compl))
+
+ defs_db_file = self.defs_db_file
+ if newer(defs_db_file, defs_file_compl):
+ print("Using defs db %s for %s" % (defs_db_file, defs_file))
+ else:
+ defs_fp = open(defs_file_compl, "r")
+ defs_str = defs_fp.read()
+ defs_fp.close()
+ ds = Tex_stream()
+ ds.defs = self.defs
+ defs_text = ds.smart_tokenize(defs_str,isatletter=True)
+ # changing ds.defs will change self.defs
+ if self.debug:
+ defs_seen_file = "%s-seen.sty" % (defs_file)
+ defs_seen_fp = open(defs_seen_file, "w")
+ out = detokenize(defs_text,isatletter=True)
+ defs_seen_fp.write(out)
+ defs_seen_fp.close()
+ ds.scan_defs()
+ if self.debug:
+ out = ""
+ command_defs, env_defs = self.defs
+ for def_name in command_defs.keys():
+ out += command_defs[def_name].show() + "\n"
+ for def_name in env_defs.keys():
+ out += env_defs[def_name].show() +"\n"
+ print("Definitions after reading %s:" % (defs_file))
+ print(out)
+
+ # Applying definitions, recursively
+ # (maybe not quite in Knuth order, so avoid tricks!)
+
+ def subst_args(self, body, args):
+ out = []
+ pos = 0
+ while pos < len(body):
+ item = body[pos]
+ if not (simple_ty == item.type and "#" == item.val):
+ out.append(item)
+ pos += 1
+ continue
+ pos += 1
+ token = body[pos]
+ argnum = token.val
+ if not pos_digit_re.match(argnum):
+ raise Error("# is not followed by number.")
+ argnum = int(argnum)
+ if argnum > len(args):
+ raise Error("Too large argument number.")
+ arg = args[argnum-1]
+ out += arg
+ pos += 1
+ return out
+
+ def apply_command_recur(self, command_instance):
+ command_defs, env_defs = self.defs
+ name = command_instance.name
+ command_def = command_defs[name]
+
+ args = command_instance.args
+ body = command_def.body
+ result = self.subst_args(body, args)
+ try:
+ result = self.apply_all_recur(result)
+ except Empty_text_error as e:
+ raise Error("apply_all_recur fails on command instance %s: %s, %s" % \
+ (command_instance.show(), detokenize(e.data), e.message))
+ return result
+
+ def apply_env_recur(self, env_instance):
+ command_defs, env_defs = self.defs
+ name = env_instance.name
+ env_def = env_defs[name]
+
+ begin, end = env_def.begin, env_def.end
+ body, args = env_instance.body, env_instance.args
+ out = self.subst_args(begin, args) + body + self.subst_args(end, args)
+ return self.apply_all_recur(out)
+
+
+ def apply_all_recur(self, data, report=False):
+ ts = Tex_stream(data)
+ ts.defs = self.defs
+ command_defs, env_defs = self.defs
+ out = []
+ progress_step = 10000
+ progress = progress_step
+ if not ts.legal():
+ raise Empty_text_error(data, "No text to process.")
+ while ts.uplegal():
+ if self.pos > progress:
+ if report:
+ print(self.pos)
+ progress += progress_step
+ if not ts.item.type in [esc_symb_ty, esc_str_ty]:
+ out.append(ts.item)
+ ts.next()
+ continue
+ if 1 == ts.test_env_boundary(ts.item):
+ old_pos = ts.pos
+ env_name = ts.scan_env_begin()
+ if env_name not in env_defs:
+ out.extend(ts.data[old_pos : ts.pos])
+ continue
+ else:
+ env_def = env_defs[env_name]
+ env_instance = ts.scan_env_rest(env_def)
+ result = ts.apply_env_recur(env_instance)
+ out.extend(result)
+ elif ts.item.val not in command_defs:
+ out.append(ts.item)
+ ts.next()
+ continue
+ else:
+ command_def = command_defs[ts.item.val]
+ command_inst = ts.scan_command(command_def)
+ result = ts.apply_command_recur(command_inst)
+ out.extend(result)
+ return out
+
+
+ # Processing files
+
+ def process_file(self, file):
+ """Returns the new defs.
+ """
+ file = cut_extension(file, ".tex")
+ source_file = "%s.tex" % (file)
+ print("File %s [" % (source_file))
+ source_fp = open(source_file, "r")
+ text_str = source_fp.read()
+ source_fp.close()
+
+ self.smart_tokenize(text_str, handle_inputs=True)
+ if not self.data:
+ raise Error("Empty tokenization result.")
+ self.reset()
+
+ if self.debug:
+ source_seen_fname = "%s-seen.tex" % (file)
+ source_seen_fp = open(source_seen_fname, "w")
+ source_seen_fp.write(detokenize(self.data))
+ source_seen_fp.close()
+
+ self.data = self.apply_all_recur(self.data, report=True)
+
+ result_fname = "%s-clean.tex" % (file)
+ print("Writing %s [" % (result_fname))
+ result_fp = open(result_fname, "w")
+ result_fp.write(self.smart_detokenize())
+ result_fp.close()
+ print("] file %s" % (result_fname))
+ print("] file %s" % (source_file))
+
+ def process_if_newer(self, file):
+ """
+ \input{file} is added to the token list.
+ If the input file is newer it is processed.
+ Returns tokenized \input{file}.
+ """
+ file = cut_extension(file, ".tex")
+ tex_file = file+".tex"
+ clean_tex_file = file+"-clean.tex"
+ if newer(clean_tex_file, tex_file):
+ print("Using %s." % (clean_tex_file))
+ else:
+ ts = Tex_stream()
+ ts.data = []
+ ts.defs = self.defs
+ ts.process_file(file)
+ to_add = "\\input{%s}" % (file)
+ return tokenize(to_add)
# Main
@@ -1065,15 +1072,15 @@ long_optlist = ["debug","defs="]
options, restargs = getopt_map("x", long_optlist)
debug = False
-if options.has_key("--debug"):
- debug = True
+if "--debug" in options:
+ debug = True
root = restargs[0]
root = cut_extension(root, ".tex")
-if options.has_key("--defs"):
- defs_root = options["--defs"]
+if "--defs" in options:
+ defs_root = options["--defs"]
else:
- defs_root = "%s" % (root)
+ defs_root = "%s" % (root)
defs_db = defs_root
defs_db_file = defs_root+".db"
@@ -1084,7 +1091,7 @@ ts.debug = debug
ts.restore_defs()
for root in restargs:
- ts.process_file(root)
+ ts.process_file(root)
-print "(Re)creating defs db %s" % (defs_db)
+print("(Re)creating defs db %s" % (defs_db))
ts.save_defs()