1 # This file is part of lyx2lyx
2 # -*- coding: utf-8 -*-
3 # Copyright (C) 2002-2011 Dekel Tsur <dekel@lyx.org>,
4 # José Matos <jamatos@lyx.org>, Richard Heck <rgheck@comcast.net>
6 # This program is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU General Public License
8 # as published by the Free Software Foundation; either version 2
9 # of the License, or (at your option) any later version.
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 This module offers several free functions to help parse lines.
23 More documentaton is below, but here is a quick guide to what
24 they do. Optional arguments are marked by brackets.
26 find_token(lines, token, start[, end[, ignorews]]):
27 Returns the first line i, start <= i < end, on which
28 token is found at the beginning. Returns -1 if not
30 If ignorews is (given and) True, then differences
31 in whitespace do not count, except that there must be no
32 extra whitespace following token itself.
34 find_token_exact(lines, token, start[, end]):
35 As find_token, but with ignorews set to True.
37 find_tokens(lines, tokens, start[, end[, ignorews]]):
38 Returns the first line i, start <= i < end, on which
39 one of the tokens in tokens is found at the beginning.
40 Returns -1 if not found.
41 If ignorews is (given and) True, then differences
42 in whitespace do not count, except that there must be no
43 extra whitespace following token itself.
45 find_tokens_exact(lines, token, start[, end]):
46 As find_tokens, but with ignorews True.
48 find_token_backwards(lines, token, start):
49 find_tokens_backwards(lines, tokens, start):
50 As before, but look backwards.
52 find_re(lines, rexp, start[, end]):
53 As find_token, but rexp is a regular expression object,
54 so it has to be passed as e.g.: re.compile(r'...').
56 get_value(lines, token, start[, end[, default]):
57 Similar to find_token, but it returns what follows the
58 token on the found line. Example:
59 get_value(document.header, "\\use_xetex", 0)
60 will find a line like:
62 and, in that case, return "true". (Note that whitespace
63 is stripped.) The final argument, default, defaults to "",
64 and is what is returned if we do not find anything. So you
65 can use that to set a default.
67 get_quoted_value(lines, token, start[, end[, default]):
68 Similar to get_value, but it will strip quotes off the
69 value, if they are present. So use this one for cases
70 where the value is normally quoted.
72 get_option_value(line, option):
73 This assumes we have a line with something like:
75 and returns value. Returns "" if not found.
77 del_token(lines, token, start[, end]):
78 Like find_token, but deletes the line if it finds one.
79 Returns True if a line got deleted, otherwise False.
81 find_beginning_of(lines, i, start_token, end_token):
82 Here, start_token and end_token are meant to be a matching
83 pair, like "\\begin_layout" and "\\end_layout". We look for
84 the start_token that pairs with the end_token that occurs
85 on or after line i. Returns -1 if not found.
86 So, in the layout case, this would find the \\begin_layout
87 for the layout line i is in.
89 ec = find_token(document.body, "</cell", i)
90 bc = find_beginning_of(document.body, ec, \
92 Now, assuming no -1s, bc-ec wraps the cell for line i.
94 find_end_of(lines, i, start_token, end_token):
95 Like find_beginning_of, but looking for the matching
96 end_token. This might look like:
97 bc = find_token_(document.body, "<cell", i)
98 ec = find_end_of(document.body, bc, "<cell", "</cell")
99 Now, assuming no -1s, bc-ec wrap the next cell.
101 find_end_of_inset(lines, i):
102 Specialization of find_end_of for insets.
104 find_end_of_layout(lines, i):
105 Specialization of find_end_of for layouts.
107 find_end_of_sequence(lines, i):
108 Find the end of the sequence of layouts of the same kind.
109 Considers nesting. If the last paragraph in sequence is nested,
110 the position of the last \end_deeper is returned, else
111 the position of the last \end_layout.
113 is_in_inset(lines, i, inset):
114 Checks if line i is in an inset of the given type.
115 If so, returns starting and ending lines. Otherwise,
118 is_in_inset(document.body, i, "\\begin_inset Tabular")
119 returns False unless i is within a table. If it is, then
120 it returns the line on which the table begins and the one
121 on which it ends. Note that this pair will evaulate to
124 will do what you expect.
126 get_containing_inset(lines, i):
127 Finds out what kind of inset line i is within. Returns a
128 list containing what follows \begin_inset on the line
129 on which the inset begins, plus the starting and ending line.
130 Returns False on any kind of error or if it isn't in an inset.
131 So get_containing_inset(document.body, i) might return:
132 ("CommandInset ref", 300, 306)
133 if i is within an InsetRef beginning on line 300 and ending
136 get_containing_layout(lines, i):
137 As get_containing_inset, but for layout. Additionally returns the
138 position of real paragraph start (after par params) as 4th value.
140 find_nonempty_line(lines, start[, end):
141 Finds the next non-empty line.
143 check_token(line, token):
144 Does line begin with token?
146 is_nonempty_line(line):
147 Does line contain something besides whitespace?
149 count_pars_in_inset(lines, i):
150 Counts the paragraphs inside an inset.
156 # Utilities for one line
157 def check_token(line, token):
158 """ check_token(line, token) -> bool
160 Return True if token is present in line and is the first element
161 else returns False."""
163 return line[:len(token)] == token
166 def is_nonempty_line(line):
167 """ is_nonempty_line(line) -> bool
169 Return False if line is either empty or it has only whitespaces,
171 return line != " "*len(line)
174 # Utilities for a list of lines
175 def find_token(lines, token, start, end = 0, ignorews = False):
176 """ find_token(lines, token, start[[, end], ignorews]) -> int
178 Return the lowest line where token is found, and is the first
179 element, in lines[start, end].
181 If ignorews is True (default is False), then differences in
182 whitespace are ignored, except that there must be no extra
183 whitespace following token itself.
185 Return -1 on failure."""
187 if end == 0 or end > len(lines):
190 for i in range(start, end):
199 if lines[i][:m] == token:
204 def find_token_exact(lines, token, start, end = 0):
205 return find_token(lines, token, start, end, True)
208 def find_tokens(lines, tokens, start, end = 0, ignorews = False):
209 """ find_tokens(lines, tokens, start[[, end], ignorews]) -> int
211 Return the lowest line where one token in tokens is found, and is
212 the first element, in lines[start, end].
214 Return -1 on failure."""
215 if end == 0 or end > len(lines):
218 for i in range(start, end):
228 if lines[i][:len(token)] == token:
233 def find_tokens_exact(lines, tokens, start, end = 0):
234 return find_tokens(lines, tokens, start, end, True)
237 def find_re(lines, rexp, start, end = 0):
238 """ find_token_re(lines, rexp, start[, end]) -> int
240 Return the lowest line where rexp, a regular expression, is found
241 in lines[start, end].
243 Return -1 on failure."""
245 if end == 0 or end > len(lines):
247 for i in range(start, end):
248 if rexp.match(lines[i]):
253 def find_token_backwards(lines, token, start):
254 """ find_token_backwards(lines, token, start) -> int
256 Return the highest line where token is found, and is the first
257 element, in lines[start, end].
259 Return -1 on failure."""
261 for i in range(start, -1, -1):
263 if line[:m] == token:
268 def find_tokens_backwards(lines, tokens, start):
269 """ find_tokens_backwards(lines, token, start) -> int
271 Return the highest line where token is found, and is the first
272 element, in lines[end, start].
274 Return -1 on failure."""
275 for i in range(start, -1, -1):
278 if line[:len(token)] == token:
283 def get_value(lines, token, start, end = 0, default = ""):
284 """ get_value(lines, token, start[[, end], default]) -> string
286 Find the next line that looks like:
287 token followed by other stuff
288 Returns "followed by other stuff" with leading and trailing
292 i = find_token_exact(lines, token, start, end)
295 l = lines[i].split(None, 1)
301 def get_quoted_value(lines, token, start, end = 0, default = ""):
302 """ get_quoted_value(lines, token, start[[, end], default]) -> string
304 Find the next line that looks like:
305 token "followed by other stuff"
306 Returns "followed by other stuff" with leading and trailing
307 whitespace and quotes removed. If there are no quotes, that is OK too.
308 So use get_value to preserve possible quotes, this one to remove them,
310 Note that we will NOT strip quotes from default!
312 val = get_value(lines, token, start, end, "")
315 return val.strip('"')
318 def get_bool_value(lines, token, start, end = 0, default = None):
319 """ get_value(lines, token, start[[, end], default]) -> string
321 Find the next line that looks like:
324 Returns True if bool_value is 1 or true and
325 False if bool_value is 0 or false
328 val = get_value(lines, token, start, end, "")
330 if val == "1" or val == "true":
332 if val == "0" or val == "false":
337 def get_option_value(line, option):
338 rx = option + '\s*=\s*"([^"]+)"'
346 def set_option_value(line, option, value):
347 rx = '(' + option + '\s*=\s*")[^"]+"'
352 return re.sub(rx, '\g<1>' + value + '"', line)
355 def del_token(lines, token, start, end = 0):
356 """ del_token(lines, token, start, end) -> int
358 Find the first line in lines where token is the first element
359 and delete that line. Returns True if we deleted a line, False
362 k = find_token_exact(lines, token, start, end)
369 def find_beginning_of(lines, i, start_token, end_token):
372 i = find_tokens_backwards(lines, [start_token, end_token], i-1)
375 if check_token(lines[i], end_token):
384 def find_end_of(lines, i, start_token, end_token):
388 i = find_tokens(lines, [end_token, start_token], i+1)
391 if check_token(lines[i], start_token):
400 def find_nonempty_line(lines, start, end = 0):
403 for i in range(start, end):
404 if is_nonempty_line(lines[i]):
409 def find_end_of_inset(lines, i):
410 " Find end of inset, where lines[i] is included."
411 return find_end_of(lines, i, "\\begin_inset", "\\end_inset")
414 def find_end_of_layout(lines, i):
415 " Find end of layout, where lines[i] is included."
416 return find_end_of(lines, i, "\\begin_layout", "\\end_layout")
419 def is_in_inset(lines, i, inset):
421 Checks if line i is in an inset of the given type.
422 If so, returns starting and ending lines.
423 Otherwise, returns False.
425 is_in_inset(document.body, i, "\\begin_inset Tabular")
426 returns False unless i is within a table. If it is, then
427 it returns the line on which the table begins and the one
428 on which it ends. Note that this pair will evaulate to
431 will do what you expect.
434 stins = find_token_backwards(lines, inset, i)
437 endins = find_end_of_inset(lines, stins)
438 # note that this includes the notfound case.
441 return (stins, endins)
444 def get_containing_inset(lines, i):
446 Finds out what kind of inset line i is within. Returns a
447 list containing (i) what follows \begin_inset on the line
448 on which the inset begins, plus the starting and ending line.
449 Returns False on any kind of error or if it isn't in an inset.
453 stins = find_token_backwards(lines, "\\begin_inset", j)
456 endins = find_end_of_inset(lines, stins)
464 inset = get_value(lines, "\\begin_inset", stins)
468 return (inset, stins, endins)
471 def get_containing_layout(lines, i):
473 Finds out what kind of layout line i is within. Returns a
474 list containing what follows \begin_layout on the line
475 on which the layout begins, plus the starting and ending line
476 and the start of the paragraph (after all params). I.e, returns:
477 (layoutname, layoutstart, layoutend, startofcontent)
478 Returns False on any kind of error.
482 stlay = find_token_backwards(lines, "\\begin_layout", j)
485 endlay = find_end_of_layout(lines, stlay)
493 lay = get_value(lines, "\\begin_layout", stlay)
497 par_params = ["\\noindent", "\\indent", "\\indent-toggle", "\\leftindent",
498 "\\start_of_appendix", "\\paragraph_spacing", "\\align",
499 "\\labelwidthstring"]
503 if lines[stpar].split(' ', 1)[0] not in par_params:
505 return (lay, stlay, endlay, stpar)
508 def count_pars_in_inset(lines, i):
510 Counts the paragraphs within this inset
512 ins = get_containing_inset(lines, i)
516 for j in range(ins[1], ins[2]):
517 m = re.match(r'\\begin_layout (.*)', lines[j])
518 if m and get_containing_inset(lines, j)[0] == ins[0]:
524 def find_end_of_sequence(lines, i):
526 Returns the end of a sequence of identical layouts.
528 lay = get_containing_layout(lines, i)
535 m = re.match(r'\\begin_layout (.*)', lines[i])
536 if m and m.group(1) != layout:
538 elif lines[i] == "\\begin_deeper":
539 j = find_end_of(lines, i, "\\begin_deeper", "\\end_deeper")
544 if m and m.group(1) == layout:
545 endlay = find_end_of_layout(lines, i)
548 if i == len(lines) - 1: