# where the last statement resets the counter to accord with the added
# lines.
def wrap_into_ert(string, src, dst):
- " Wrap a something into an ERT"
+ '''Within string, replace occurrences of src with dst, wrapped into ERT
+ E.g.: wrap_into_ert('sch\"on', "\\", "\\backslash") is:
+ sch<ERT>\\backslash</ERT>"on'''
return string.replace(src, '\n\\begin_inset ERT\nstatus collapsed\n\\begin_layout Standard\n'
+ dst + '\n\\end_layout\n\\end_inset\n')
+def put_cmd_in_ert(string):
+ string = string.replace('\\', "\\backslash\n")
+ string = "\\begin_inset ERT\nstatus collapsed\n\\begin_layout Standard\n" \
+ + string + "\n\\end_layout\n\\end_inset"
+ return string
+
def add_to_preamble(document, text):
""" Add text to the preamble if it is not already there.
Only the first line is checked!"""
return l
+def read_unicodesymbols():
+ " Read the unicodesymbols list of unicode characters and corresponding commands."
+ pathname = os.path.abspath(os.path.dirname(sys.argv[0]))
+ fp = open(os.path.join(pathname.strip('lyx2lyx'), 'unicodesymbols'))
+ spec_chars = []
+ # Two backslashes, followed by some non-word character, and then a character
+ # in brackets. The idea is to check for constructs like: \"{u}, which is how
+ # they are written in the unicodesymbols file; but they can also be written
+ # as: \"u.
+ r = re.compile(r'\\\\(\W)\{(\w)\}')
+ for line in fp.readlines():
+ if line[0] != '#' and line.strip() != "":
+ line=line.replace(' "',' ') # remove all quotation marks with spaces before
+ line=line.replace('" ',' ') # remove all quotation marks with spaces after
+ line=line.replace(r'\"','"') # replace \" by " (for characters with diaeresis)
+ try:
+ [ucs4,command,dead] = line.split(None,2)
+ if command[0:1] != "\\":
+ continue
+ spec_chars.append([command, unichr(eval(ucs4))])
+ except:
+ continue
+ m = r.match(command)
+ if m != None:
+ command = "\\\\"
+ # If the character is a double-quote, then we need to escape it, too,
+ # since it is done that way in the LyX file.
+ if m.group(1) == "\"":
+ command += "\\"
+ command += m.group(1) + m.group(2)
+ spec_chars.append([command, unichr(eval(ucs4))])
+ fp.close()
+ return spec_chars
+
+
+def extract_argument(line):
+ 'Extracts a LaTeX argument from the start of line. Returns (arg, rest).'
+
+ if not line:
+ return (None, "")
+
+ bracere = re.compile("(\s*)(.*)")
+ n = bracere.match(line)
+ whitespace = n.group(1)
+ stuff = n.group(2)
+ brace = stuff[:1]
+ if brace != "[" and brace != "{":
+ return (None, line)
+
+ # find closing brace
+ remain = stuff[1:]
+ pos = 0
+ num = 1
+ term = "}"
+ if brace == "[":
+ term = "]"
+ skip = False
+ for c in remain:
+ if skip:
+ skip = False
+ elif c == "\\":
+ skip = True
+ elif c == brace:
+ num += 1
+ elif c == term:
+ num -= 1
+ if c == 0:
+ break
+ pos += 1
+ if num != 0:
+ # We never found the matching brace
+ # So, to be on the safe side, let's just return everything
+ # which will then get wrapped as ERT
+ return (line, "")
+ return (line[:pos + 1], line[pos + 1:])
+
+
+def latex2ert(line):
+ '''Converts LaTeX commands into ERT. line may well be a multi-line
+ string when it is returned.'''
+ if not line:
+ return line
+
+ retval = ""
+ ## FIXME Escaped \ ??
+ labelre = re.compile(r'(.*?)\\(\\(?:[a-zA-Z]+|.))(.*)')
+
+ m = labelre.match(line)
+ while m != None:
+ retval += m.group(1)
+ cmd = m.group(2)
+ end = m.group(3)
+
+ while True:
+ (arg, rest) = extract_argument(end)
+ if arg == None:
+ break
+ cmd += arg
+ end = rest
+ cmd = put_cmd_in_ert(cmd)
+ retval += "\n" + cmd + "\n"
+ line = end
+ m = labelre.match(line)
+ retval += line
+ return retval
+
+
+def latex2lyx(data):
+ '''Takes a string, possibly multi-line, and returns the result of
+ converting LaTeX constructs into LyX constructs. Returns a list of
+ lines, suitable for insertion into document.body.'''
+
+ retval = []
+
+ # Convert LaTeX to Unicode
+ reps = read_unicodesymbols()
+ # Commands of this sort need to be checked to make sure they are
+ # followed by a non-alpha character, lest we replace too much.
+ hardone = re.compile(r'^\\\\[a-zA-Z]+$')
+
+ for rep in reps:
+ if hardone.match(rep[0]):
+ pos = 0
+ while True:
+ pos = data.find(rep[0], pos)
+ if pos == -1:
+ break
+ nextpos = pos + len(rep[0])
+ nextchar = data[nextpos - 1 : nextpos]
+ if nextchar.isalpha():
+ # not the end of that command
+ pos = nextpos
+ continue
+ data = data[:pos] + rep[1] + data[nextpos:]
+ pos = nextpos
+ else:
+ data = data.replace(rep[0], rep[1])
+
+ # Generic, \" -> ":
+ data = wrap_into_ert(data, r'\"', '"')
+
+ # Math:
+ mathre = re.compile('^(.*?)(\$.*?\$)(.*)')
+ lines = data.split('\n')
+ for line in lines:
+ #document.warning("LINE: " + line)
+ #document.warning(str(i) + ":" + document.body[i])
+ #document.warning("LAST: " + document.body[-1])
+ g = line
+ m = mathre.match(g)
+ while m != None:
+ s = m.group(1)
+ f = m.group(2).replace('\\\\', '\\')
+ g = m.group(3)
+ if s:
+ # this is non-math!
+ s = latex2ert(s)
+ subst = s.split('\n')
+ retval += subst
+ retval.append("\\begin_inset Formula " + f)
+ retval.append("\\end_inset")
+ m = mathre.match(g)
+ # Handle whatever is left, which is just text
+ g = latex2ert(g)
+ subst = g.split('\n')
+ retval += subst
+ return retval
+
+
####################################################################
def convert_ltcaption(document):
"Revert optional options for wrap floats (wrapfig)."
i = 0
while True:
- i = find_token(document.body, "lines", i)
+ i = find_token(document.body, "\\begin_inset Wrap figure", i)
if i == -1:
return
- j = find_token(document.body, "overhang", i+1)
- if j != i + 2 and j != -1:
- document.warning("Malformed LyX document: Couldn't find overhang parameter of wrap float.")
+ j = find_end_of_inset(document.body, i)
if j == -1:
- return
- del document.body[i]
- del document.body[j-1]
- i = i + 1
-
+ document.warning("Can't find end of Wrap inset at line " + str(i))
+ i += 1
+ continue
+ k = find_default_layout(document, i, j)
+ if k == -1:
+ document.warning("Can't find default layout for Wrap figure!")
+ i = j
+ continue
+ # Options should be between i and k now
+ l = find_token(document.body, "lines", i, k)
+ if l == -1:
+ document.warning("Can't find lines option for Wrap figure!")
+ i = k
+ continue
+ m = find_token(document.body, "overhang", i + 1, k)
+ if m == -1:
+ document.warning("Malformed LyX document: Couldn't find overhang parameter of wrap float!")
+ i = k
+ continue
+ # Do these in reverse order
+ del document.body[m]
+ del document.body[l]
+ i = k
-# To convert and revert indices, we need to convert between LaTeX
-# strings and LyXText. Here we do a minimal conversion to prevent
-# crashes and data loss. Manual patch-up may be needed.
-replacements = [
- [r'\\\"a', u'ä'],
- [r'\\\"o', u'ö'],
- [r'\\\"u', u'ü'],
- [r'\\\'a', u'á'],
- [r'\\\'e', u'é'],
- [r'\\\'i', u'í'],
- [r'\\\'o', u'ó'],
- [r'\\\'u', u'ú']
-]
def convert_latexcommand_index(document):
"Convert from LatexCommand form to collapsable form."
i = 0
+ r1 = re.compile('name "(.*)"')
while True:
i = find_token(document.body, "\\begin_inset CommandInset index", i)
if i == -1:
return
if document.body[i + 1] != "LatexCommand index": # Might also be index_print
return
- fullcontent = document.body[i + 2][5:]
- fullcontent.strip()
- fullcontent = fullcontent[1:-1]
+ m = r1.match(document.body[i + 2])
+ if m == None:
+ document.warning("Unable to match: " + document.body[i+2])
+ i += 1
+ continue
+ fullcontent = m.group(1)
+ #document.warning(fullcontent)
document.body[i:i + 3] = ["\\begin_inset Index",
"status collapsed",
"\\begin_layout Standard"]
# We are now on the blank line preceding "\end_inset"
# We will write the content here, into the inset.
- # Do the LaTeX --> LyX text conversion
- for rep in replacements:
- fullcontent = fullcontent.replace(rep[0], rep[1])
- # Generic, \" -> ":
- fullcontent = wrap_into_ert(fullcontent, r'\"', '"')
- # Math:
- r = re.compile('^(.*?)(\$.*?\$)(.*)')
- lines = fullcontent.split('\n')
- for line in lines:
- #document.warning("LINE: " + line)
- #document.warning(str(i) + ":" + document.body[i])
- #document.warning("LAST: " + document.body[-1])
- g = line
- while r.match(g):
- m = r.match(g)
- s = m.group(1)
- f = m.group(2).replace('\\\\', '\\')
- g = m.group(3)
- if s:
- # this is non-math!
- s = wrap_into_ert(s, r'\\', '\\backslash')
- s = wrap_into_ert(s, '{', '{')
- s = wrap_into_ert(s, '}', '}')
- subst = s.split('\n')
- document.body[i:i] = subst
- i += len(subst)
- document.body.insert(i + 1, "\\begin_inset Formula " + f)
- document.body.insert(i + 2, "\\end_inset")
- i += 2
- # Generic, \\ -> \backslash:
- g = wrap_into_ert(g, r'\\', '\\backslash')
- g = wrap_into_ert(g, '{', '{')
- g = wrap_into_ert(g, '}', '}')
- subst = g.split('\n')
- document.body[i+1:i+1] = subst
- i += len(subst)
+ linelist = latex2lyx(fullcontent)
+ document.body[i+1:i+1] = linelist
+ i += len(linelist)
+
document.body.insert(i + 1, "\\end_layout")
+ i += 1
def revert_latexcommand_index(document):
i = i + 2
def revert_url(document):
- 'Reverts Flex URL insets to old-style URL insets'
- i = 0
- while True:
- i = find_token(document.body, "\\begin_inset Flex URL", i)
- if i == -1:
- return
- j = find_end_of_inset(document.body, i)
- if j == -1:
- document.warning("Can't find end of inset in revert_url!")
- return
- k = find_default_layout(document, i, j)
- if k == -1:
- document.warning("Can't find default layout in revert_url!")
- i = j
- continue
- l = find_end_of(document.body, k, "\\begin_layout", "\\end_layout")
- if l == -1 or l >= j:
- document.warning("Can't find end of default layout in revert_url!")
- i = j
- continue
- # OK, so the inset's data is between lines k and l.
- data = " ".join(document.body[k+1:l])
- data = data.strip()
- newinset = ["\\begin_inset LatexCommand url", "target \"" + data + "\"",\
- "", "\\end_inset"]
- document.body[i:j+1] = newinset
- i = i + len(newinset)
-
-
+ 'Reverts Flex URL insets to old-style URL insets'
+ i = 0
+ while True:
+ i = find_token(document.body, "\\begin_inset Flex URL", i)
+ if i == -1:
+ return
+ j = find_end_of_inset(document.body, i)
+ if j == -1:
+ document.warning("Can't find end of inset in revert_url!")
+ return
+ k = find_default_layout(document, i, j)
+ if k == -1:
+ document.warning("Can't find default layout in revert_url!")
+ i = j
+ continue
+ l = find_end_of(document.body, k, "\\begin_layout", "\\end_layout")
+ if l == -1 or l >= j:
+ document.warning("Can't find end of default layout in revert_url!")
+ i = j
+ continue
+ # OK, so the inset's data is between lines k and l.
+ data = " ".join(document.body[k+1:l])
+ data = data.strip()
+ newinset = ["\\begin_inset LatexCommand url", "target \"" + data + "\"",\
+ "", "\\end_inset"]
+ document.body[i:j+1] = newinset
+ i = i + len(newinset)
+
def convert_include(document):
'Converts include insets to new format.'
def revert_include(document):
'Reverts include insets to old format.'
i = 0
+ r0 = re.compile('preview.*')
r1 = re.compile('LatexCommand (.+)')
- r2 = re.compile('filename (.+)')
- r3 = re.compile('options (.*)')
+ r2 = re.compile('filename "(.+)"')
+ r3 = re.compile('lstparams "(.*)"')
while True:
i = find_token(document.body, "\\begin_inset CommandInset include", i)
if i == -1:
return
- previewline = document.body[i + 1]
- m = r1.match(document.body[i + 2])
+ nextline = i + 1
+ if r0.match(document.body[nextline]):
+ previewline = document.body[nextline]
+ nextline += 1
+ else:
+ previewline = ""
+ m = r1.match(document.body[nextline])
if m == None:
document.warning("Malformed LyX document: No LatexCommand line for `" +
document.body[i] + "' on line " + str(i) + ".")
i += 1
continue
cmd = m.group(1)
- m = r2.match(document.body[i + 3])
+ nextline += 1
+ m = r2.match(document.body[nextline])
if m == None:
document.warning("Malformed LyX document: No filename line for `" + \
document.body[i] + "' on line " + str(i) + ".")
i += 2
continue
fn = m.group(1)
+ nextline += 1
options = ""
- numlines = 4
if (cmd == "lstinputlisting"):
- m = r3.match(document.body[i + 4])
+ m = r3.match(document.body[nextline])
if m != None:
options = m.group(1)
numlines = 5
+ nextline += 1
newline = "\\begin_inset Include \\" + cmd + "{" + fn + "}"
if options:
newline += ("[" + options + "]")
- insertion = [newline, previewline]
- document.body[i : i + numlines] = insertion
+ insertion = [newline]
+ if previewline != "":
+ insertion.append(previewline)
+ document.body[i : nextline] = insertion
i += 2
revert_inset_embedding(document, 'External')
-# FIXME This code can still be cleaned up a fair bit.
def convert_subfig(document):
" Convert subfigures to subfloats. "
i = 0
continue
k = find_token(document.body, '\tsubcaption', i, endInset)
if k == -1:
- i += 1
+ i = endInset
continue
l = find_token(document.body, '\tsubcaptionText', i, endInset)
+ if l == -1:
+ document.warning("Malformed lyx document: Can't find subcaptionText!")
+ i = endInset
+ continue
caption = document.body[l][16:].strip('"')
- savestr = document.body[i]
- laststr = document.body[endInset]
del document.body[l]
del document.body[k]
addedLines = -2
- # savestr should no longer be needed here.
subst = ['\\begin_inset Float figure', 'wide false', 'sideways false',
'status open', '', '\\begin_layout Plain Layout', '\\begin_inset Caption',
- '', '\\begin_layout Plain Layout',
- caption, '\\end_layout', '', '\\end_inset', '',
- '\\end_layout', '', '\\begin_layout Plain Layout', savestr]
- document.body[i : i+1] = subst
- addedLines += len(subst) - 1
+ '', '\\begin_layout Plain Layout'] + latex2lyx(caption) + \
+ [ '\\end_layout', '', '\\end_inset', '',
+ '\\end_layout', '', '\\begin_layout Plain Layout']
+ document.body[i : i] = subst
+ addedLines += len(subst)
endInset += addedLines
- # There should be an easier way to do this.
- subst = ['', '\\end_inset', '', '\\end_layout', laststr]
- document.body[endInset : endInset+1] = subst
- addedLines += len(subst) - 1
+ subst = ['', '\\end_inset', '', '\\end_layout']
+ document.body[endInset : endInset] = subst
+ addedLines += len(subst)
i += addedLines + 1
insertion = insertion.split('\n')
document.body[k : k + 1] = insertion
addedLines += len(insertion) - 1
- add_to_preamble(document,
- ['\\usepackage{subfig}\n'])
+ add_to_preamble(document, ['\\usepackage{subfig}\n'])
i += addedLines + 1
" Revert placement options wrap floats (wrapfig). "
i = 0
while True:
- i = find_token(document.body, "lines", i)
+ i = find_token(document.body, "\\begin_inset Wrap figure", i)
if i == -1:
return
- j = find_token(document.body, "placement", i+1)
- if j != i + 1:
+ e = find_end_of_inset(document.body, i)
+ j = find_token(document.body, "placement", i + 1, e)
+ if j == -1:
document.warning("Malformed LyX document: Couldn't find placement parameter of wrap float.")
- return
- document.body[j] = document.body[j].replace("placement O", "placement o")
- document.body[j] = document.body[j].replace("placement I", "placement i")
- document.body[j] = document.body[j].replace("placement L", "placement l")
- document.body[j] = document.body[j].replace("placement R", "placement r")
- i = i + 1
+ i += 1
+ continue
+ r = re.compile("placement (o|i|l|r)")
+ m = r.match(document.body[j])
+ if m == None:
+ document.warning("Malformed LyX document: Placement option isn't O|I|R|L!")
+ document.body[j] = "placement " + m.group(1).lower()
+ i = j
def remove_extra_embedded_files(document):