lyx2lyx: correct placement of (new) local layout

[lyx.git] / lib / lyx2lyx / parser_tools.py

diff --git a/lib/lyx2lyx/parser_tools.py b/lib/lyx2lyx/parser_tools.py
index 44ac5d904594c5a89d2a460ff54d7355fb4f54f2..175db00ac3b21de3bc335204a435261f57aec90a 100644 (file)
--- a/lib/lyx2lyx/parser_tools.py
+++ b/lib/lyx2lyx/parser_tools.py
@@ -23,7 +23,7 @@ This module offers several free functions to help parse lines.
 More documentaton is below, but here is a quick guide to what
 they do. Optional arguments are marked by brackets.
 
 More documentaton is below, but here is a quick guide to what
 they do. Optional arguments are marked by brackets.
 

-find_token(lines, token, start[, end[, ignorews]]):
+find_token(lines, token[, start[, end[, ignorews]]]):

   Returns the first line i, start <= i < end, on which
   token is found at the beginning. Returns -1 if not
   found.
   Returns the first line i, start <= i < end, on which
   token is found at the beginning. Returns -1 if not
   found.


@@ -31,10 +31,10 @@ find_token(lines, token, start[, end[, ignorews]]):
   in whitespace do not count, except that there must be no
   extra whitespace following token itself.
 
   in whitespace do not count, except that there must be no
   extra whitespace following token itself.
 

-find_token_exact(lines, token, start[, end]):
+find_token_exact(lines, token[, start[, end]]]):

   As find_token, but with ignorews set to True.
 
   As find_token, but with ignorews set to True.
 

-find_tokens(lines, tokens, start[, end[, ignorews]]):
+find_tokens(lines, tokens[, start[, end[, ignorews]]]):

   Returns the first line i, start <= i < end, on which
   one of the tokens in tokens is found at the beginning.
   Returns -1 if not found.
   Returns the first line i, start <= i < end, on which
   one of the tokens in tokens is found at the beginning.
   Returns -1 if not found.


@@ -42,18 +42,21 @@ find_tokens(lines, tokens, start[, end[, ignorews]]):
   in whitespace do not count, except that there must be no
   extra whitespace following token itself.
 
   in whitespace do not count, except that there must be no
   extra whitespace following token itself.
 

-find_tokens_exact(lines, token, start[, end]):
+find_tokens_exact(lines, token[, start[, end]]):

   As find_tokens, but with ignorews True.
 
 find_token_backwards(lines, token, start):
 find_tokens_backwards(lines, tokens, start):
   As before, but look backwards.
 
   As find_tokens, but with ignorews True.
 
 find_token_backwards(lines, token, start):
 find_tokens_backwards(lines, tokens, start):
   As before, but look backwards.
 

+find_substring(lines, sub[, start[, end]]) -> int
+  As find_token, but sub may be anywhere in the line.
+

 find_re(lines, rexp, start[, end]):
   As find_token, but rexp is a regular expression object,
   so it has to be passed as e.g.: re.compile(r'...').
 
 find_re(lines, rexp, start[, end]):
   As find_token, but rexp is a regular expression object,
   so it has to be passed as e.g.: re.compile(r'...').
 

-get_value(lines, token, start[, end[, default]):
+get_value(lines, token[, start[, end[, default[, delete]]]]):

   Similar to find_token, but it returns what follows the
   token on the found line. Example:
     get_value(document.header, "\\use_xetex", 0)
   Similar to find_token, but it returns what follows the
   token on the found line. Example:
     get_value(document.header, "\\use_xetex", 0)


@@ -64,7 +67,7 @@ get_value(lines, token, start[, end[, default]):
   and is what is returned if we do not find anything. So you
   can use that to set a default.
 
   and is what is returned if we do not find anything. So you
   can use that to set a default.
 

-get_quoted_value(lines, token, start[, end[, default]]):
+get_quoted_value(lines, token[, start[, end[, default[, delete]]]]):

   Similar to get_value, but it will strip quotes off the
   value, if they are present. So use this one for cases
   where the value is normally quoted.
   Similar to get_value, but it will strip quotes off the
   value, if they are present. So use this one for cases
   where the value is normally quoted.


@@ -74,13 +77,20 @@ get_option_value(line, option):
       option="value"
   and returns value. Returns "" if not found.
 
       option="value"
   and returns value. Returns "" if not found.
 

-get_bool_value(lines, token, start[, end[, default]]):
+get_bool_value(lines, token[, start[, end[, default, delete]]]]):

   Like get_value, but returns a boolean.
 
   Like get_value, but returns a boolean.
 

-del_token(lines, token, start[, end]):
+set_bool_value(lines, token, value[, start[, end]]):
+  Find `token` in `lines[start:end]` and set to boolean value bool(`value`).
+  Return old value. Raise ValueError if token is not in lines.
+
+del_token(lines, token[, start[, end]]):

   Like find_token, but deletes the line if it finds one.
   Returns True if a line got deleted, otherwise False.
 
   Like find_token, but deletes the line if it finds one.
   Returns True if a line got deleted, otherwise False.
 

+  Use get_* with the optional argument "delete=True", if you want to
+  get and delete a token.
+

 find_beginning_of(lines, i, start_token, end_token):
   Here, start_token and end_token are meant to be a matching
   pair, like "\\begin_layout" and "\\end_layout". We look for
 find_beginning_of(lines, i, start_token, end_token):
   Here, start_token and end_token are meant to be a matching
   pair, like "\\begin_layout" and "\\end_layout". We look for


@@ -113,17 +123,17 @@ find_end_of_sequence(lines, i):
   the position of the last \end_deeper is returned, else
   the position of the last \end_layout.
 
   the position of the last \end_deeper is returned, else
   the position of the last \end_layout.
 

-is_in_inset(lines, i, inset):
-  Checks if line i is in an inset of the given type.
+is_in_inset(lines, i, inset, default=(-1,-1)):
+  Check if line i is in an inset of the given type.

   If so, returns starting and ending lines. Otherwise,
   If so, returns starting and ending lines. Otherwise,

-  returns False.
+  return default.

   Example:
     is_in_inset(document.body, i, "\\begin_inset Tabular")
   Example:
     is_in_inset(document.body, i, "\\begin_inset Tabular")

-  returns False unless i is within a table. If it is, then
+  returns (-1,-1) unless i is within a table. If it is, then

   it returns the line on which the table begins and the one
   on which it ends. Note that this pair will evaulate to
   boolean True, so
   it returns the line on which the table begins and the one
   on which it ends. Note that this pair will evaulate to
   boolean True, so

-    if is_in_inset(...):
+    if is_in_inset(..., default=False):

   will do what you expect.
 
 get_containing_inset(lines, i):
   will do what you expect.
 
 get_containing_inset(lines, i):


@@ -156,53 +166,6 @@ count_pars_in_inset(lines, i):
 
 import re
 
 
 import re
 

-# Fast search in lists
-def find_slice(l, sl, start = 0, stop = None):
-    """Return position of first occurence of sequence `sl` in list `l`
-    as a `slice` object.
-
-    >>> find_slice([1, 2, 3, 1, 1, 2], (1, 2))
-    slice(0, 2, None)
-
-    The return value can be used to delete or substitute the sub-list:
-
-    >>> l = [1, 0, 1, 1, 1, 2]
-    >>> s = find_slice(l, [0, 1, 1])
-    >>> del(l[s]); l
-    [1, 1, 2]
-    >>> s = find_slice(l, (1, 2))
-    >>> l[s] = [3]; l
-    [1, 3]
-
-    The start argument works similar to list.index()
-
-    >>> find_slice([1, 2, 3, 1, 1 ,2], (1, 2), start = 1)
-    slice(4, 6, None)
-
-    Use the `stop` attribute of the returned `slice` to test for success:
-
-    >>> s1 = find_slice([2, 3, 1], (3, 1))
-    >>> s2 = find_slice([2, 3, 1], (2, 1))
-    >>> if s1.stop and not s2.stop:
-    ...     print "wow"
-    wow
-    """
-    stop = stop or len(l)
-    N = len(sl) # lenght of sub-list
-    try:
-        while True:
-            for j, value in enumerate(sl):
-                i = l.index(value, start, stop)
-                if j and i != start:
-                    start = i-j
-                    break
-                start = i +1
-            else:
-                return slice(i+1-N, i+1)
-    except ValueError: # sub list `sl` not found
-        return slice(0, 0)
-
-

 # Utilities for one line
 def check_token(line, token):
     """ check_token(line, token) -> bool
 # Utilities for one line
 def check_token(line, token):
     """ check_token(line, token) -> bool


@@ -212,7 +175,6 @@ def check_token(line, token):
 
     Deprecated. Use line.startswith(token).
     """
 
     Deprecated. Use line.startswith(token).
     """

-

     return line.startswith(token)
 
 
     return line.startswith(token)
 
 


@@ -225,46 +187,49 @@ def is_nonempty_line(line):
 
 
 # Utilities for a list of lines
 
 
 # Utilities for a list of lines

-def find_token(lines, token, start, end = 0, ignorews = False):
+def find_token(lines, token, start=0, end=0, ignorews=False):

     """ find_token(lines, token, start[[, end], ignorews]) -> int
 
     Return the lowest line where token is found, and is the first
     element, in lines[start, end].
 
     If ignorews is True (default is False), then differences in
     """ find_token(lines, token, start[[, end], ignorews]) -> int
 
     Return the lowest line where token is found, and is the first
     element, in lines[start, end].
 
     If ignorews is True (default is False), then differences in

-    whitespace are ignored, except that there must be no extra
-    whitespace following token itself.
+    whitespace are ignored, but there must be whitespace following
+    token itself.
+
+    Use find_substring(lines, sub) to find a substring anywhere in `lines`.

 
     Return -1 on failure."""
 
     if end == 0 or end > len(lines):
         end = len(lines)
 
     Return -1 on failure."""
 
     if end == 0 or end > len(lines):
         end = len(lines)

-    m = len(token)
+    if ignorews:
+        y = token.split()

     for i in range(start, end):
         if ignorews:
             x = lines[i].split()
     for i in range(start, end):
         if ignorews:
             x = lines[i].split()

-            y = token.split()

             if len(x) < len(y):
                 continue
             if x[:len(y)] == y:
                 return i
         else:
             if len(x) < len(y):
                 continue
             if x[:len(y)] == y:
                 return i
         else:

-            if lines[i][:m] == token:
+            if lines[i].startswith(token):

                 return i
     return -1
 
 
                 return i
     return -1
 
 

-def find_token_exact(lines, token, start, end = 0):
+def find_token_exact(lines, token, start=0, end=0):

     return find_token(lines, token, start, end, True)
 
 
     return find_token(lines, token, start, end, True)
 
 

-def find_tokens(lines, tokens, start, end = 0, ignorews = False):
+def find_tokens(lines, tokens, start=0, end=0, ignorews=False):

     """ find_tokens(lines, tokens, start[[, end], ignorews]) -> int
 
     Return the lowest line where one token in tokens is found, and is
     the first element, in lines[start, end].
 
     Return -1 on failure."""
     """ find_tokens(lines, tokens, start[[, end], ignorews]) -> int
 
     Return the lowest line where one token in tokens is found, and is
     the first element, in lines[start, end].
 
     Return -1 on failure."""

+

     if end == 0 or end > len(lines):
         end = len(lines)
 
     if end == 0 or end > len(lines):
         end = len(lines)
 


@@ -278,23 +243,41 @@ def find_tokens(lines, tokens, start, end = 0, ignorews = False):
                 if x[:len(y)] == y:
                     return i
             else:
                 if x[:len(y)] == y:
                     return i
             else:

-                if lines[i][:len(token)] == token:
+                if lines[i].startswith(token):

                     return i
     return -1
 
 
                     return i
     return -1
 
 

-def find_tokens_exact(lines, tokens, start, end = 0):
+def find_tokens_exact(lines, tokens, start=0, end=0):

     return find_tokens(lines, tokens, start, end, True)
 
 
     return find_tokens(lines, tokens, start, end, True)
 
 

-def find_re(lines, rexp, start, end = 0):
-    """ find_token_re(lines, rexp, start[, end]) -> int
+def find_substring(lines, sub, start=0, end=0):
+    """ find_substring(lines, sub[, start[, end]]) -> int

 
 

-    Return the lowest line where rexp, a regular expression, is found
-    in lines[start, end].
+    Return the lowest line number `i` in [start, end] where
+    `sub` is a substring of line[i].

 
     Return -1 on failure."""
 
 
     Return -1 on failure."""
 

+    if end == 0 or end > len(lines):
+        end = len(lines)
+    for i in range(start, end):
+        if sub in lines[i]:
+                return i
+    return -1
+
+
+def find_re(lines, rexp, start=0, end=0):
+    """ find_re(lines, rexp[, start[, end]]) -> int
+
+    Return the lowest line number `i` in [start, end] where the regular
+    expression object `rexp` matches at the beginning of line[i].
+    Return -1 on failure.
+
+    Start your pattern with the wildcard ".*" to find a match anywhere in a
+    line. Use find_substring() to find a substring anywhere in the lines.
+    """

     if end == 0 or end > len(lines):
         end = len(lines)
     for i in range(start, end):
     if end == 0 or end > len(lines):
         end = len(lines)
     for i in range(start, end):


@@ -310,10 +293,8 @@ def find_token_backwards(lines, token, start):
     element, in lines[start, end].
 
     Return -1 on failure."""
     element, in lines[start, end].
 
     Return -1 on failure."""

-    m = len(token)

     for i in range(start, -1, -1):
     for i in range(start, -1, -1):

-        line = lines[i]
-        if line[:m] == token:
+        if lines[i].startswith(token):

             return i
     return -1
 
             return i
     return -1
 


@@ -328,30 +309,111 @@ def find_tokens_backwards(lines, tokens, start):
     for i in range(start, -1, -1):
         line = lines[i]
         for token in tokens:
     for i in range(start, -1, -1):
         line = lines[i]
         for token in tokens:

-            if line[:len(token)] == token:
+            if line.startswith(token):

                 return i
     return -1
 
 
                 return i
     return -1
 
 

-def get_value(lines, token, start, end = 0, default = ""):
-    """ get_value(lines, token, start[[, end], default]) -> string
+def find_complete_lines(lines, sublines, start=0, end=0):
+    """Find first occurence of sequence `sublines` in list `lines`.
+    Return index of first line or -1 on failure.
+
+    Efficient search for a sub-list in a large list. Works for any values.
+
+    >>> find_complete_lines([1, 2, 3, 1, 1, 2], [1, 2])
+    0
+
+    The `start` and `end` arguments work similar to list.index()
+
+    >>> find_complete_lines([1, 2, 3, 1, 1 ,2], [1, 2], start=1)
+    4
+    >>> find_complete_lines([1, 2, 3, 1, 1 ,2], [1, 2], start=1, end=4)
+    -1
+
+    The return value can be used to substitute the sub-list.
+    Take care to check before use:
+
+    >>> l = [1, 1, 2]
+    >>> s = find_complete_lines(l, [1, 2])
+    >>> if s != -1:
+    ...     l[s:s+2] = [3]; l
+    [1, 3]
+
+    See also del_complete_lines().
+    """
+    if not sublines:
+        return start
+    end = end or len(lines)
+    N = len(sublines)
+    try:
+        while True:
+            for j, value in enumerate(sublines):
+                i = lines.index(value, start, end)
+                if j and i != start:
+                    start = i-j
+                    break
+                start = i + 1
+            else:
+                return i +1 - N
+    except ValueError: # `sublines` not found
+        return -1
+
+
+def find_across_lines(lines, sub, start=0, end=0):
+    sublines = sub.splitlines()
+    if len(sublines) > 2:
+        # at least 3 lines: the middle one(s) are complete -> use index search
+        i = find_complete_lines(lines, sublines[1:-1], start+1, end-1)
+        if i < start+1:
+            return -1
+        try:
+            if (lines[i-1].endswith(sublines[0]) and
+                lines[i+len(sublines)].startswith(sublines[-1])):
+                return i-1
+        except IndexError:
+            pass
+    elif len(sublines) > 1:
+        # last subline must start a line
+        i = find_token(lines, sublines[-1], start, end)
+        if i < start + 1:
+            return -1
+        if lines[i-1].endswith(sublines[0]):
+            return i-1
+    else: # no line-break, may be in the middle of a line
+        if end == 0 or end > len(lines):
+            end = len(lines)
+        for i in range(start, end):
+            if sub in lines[i]:
+                return i
+    return -1
+
+
+def get_value(lines, token, start=0, end=0, default="", delete=False):
+    """Find `token` in `lines` and return part of line that follows it.

 
     Find the next line that looks like:
       token followed by other stuff
 
     Find the next line that looks like:
       token followed by other stuff

-    Returns "followed by other stuff" with leading and trailing
+
+    If `delete` is True, delete the line (if found).
+
+    Return "followed by other stuff" with leading and trailing

     whitespace removed.
     """
     whitespace removed.
     """

-

     i = find_token_exact(lines, token, start, end)
     if i == -1:
         return default
     i = find_token_exact(lines, token, start, end)
     if i == -1:
         return default

+    # TODO: establish desired behaviour, eventually change to
+    #  return lines.pop(i)[len(token):].strip() # or default
+    # see test_parser_tools.py

     l = lines[i].split(None, 1)
     l = lines[i].split(None, 1)

+    if delete:
+        del(lines[i])

     if len(l) > 1:
         return l[1].strip()
     return default
 
 
     if len(l) > 1:
         return l[1].strip()
     return default
 
 

-def get_quoted_value(lines, token, start, end = 0, default = ""):
+def get_quoted_value(lines, token, start=0, end=0, default="", delete=False):

     """ get_quoted_value(lines, token, start[[, end], default]) -> string
 
     Find the next line that looks like:
     """ get_quoted_value(lines, token, start[[, end], default]) -> string
 
     Find the next line that looks like:


@@ -362,29 +424,48 @@ def get_quoted_value(lines, token, start, end = 0, default = ""):
     if they are there.
     Note that we will NOT strip quotes from default!
     """
     if they are there.
     Note that we will NOT strip quotes from default!
     """

-    val = get_value(lines, token, start, end, "")
+    val = get_value(lines, token, start, end, "", delete)

     if not val:
       return default
     return val.strip('"')
 
 
     if not val:
       return default
     return val.strip('"')
 
 

-def get_bool_value(lines, token, start, end = 0, default = None):
-    """ get_value(lines, token, start[[, end], default]) -> string
+bool_values = {"true": True, "1": True,
+               "false": False, "0": False}
+
+def get_bool_value(lines, token, start=0, end=0, default=None, delete=False):
+    """ get_bool_value(lines, token, start[[, end], default]) -> string

 
     Find the next line that looks like:
 
     Find the next line that looks like:

-      token bool_value
+      `token` <bool_value>

 
 

-    Returns True if bool_value is 1 or true and
-    False if bool_value is 0 or false
+    Return True if <bool_value> is 1 or "true", False if <bool_value>
+    is 0 or "false", else `default`.

     """
     """

+    val = get_quoted_value(lines, token, start, end, default, delete)
+    return bool_values.get(val, default)

 
 

-    val = get_quoted_value(lines, token, start, end, "")

 
 

-    if val == "1" or val == "true":
-        return True
-    if val == "0" or val == "false":
-        return False
-    return default
+def set_bool_value(lines, token, value, start=0, end=0):
+    """Find `token` in `lines` and set to bool(`value`).
+
+    Return previous value. Raise `ValueError` if `token` is not in lines.
+
+    Cf. find_token(), get_bool_value().
+    """
+    i = find_token(lines, token, start, end)
+    if i == -1:
+        raise ValueError
+    oldvalue = get_bool_value(lines, token, i, i+1)
+    if oldvalue is value:
+        return oldvalue
+    # set to new value
+    if get_quoted_value(lines, token, i, i+1) in ('0', '1'):
+        lines[i] = "%s %d" % (token, value)
+    else:
+        lines[i] = "%s %s" % (token, str(value).lower())
+
+    return oldvalue

 
 
 def get_option_value(line, option):
 
 
 def get_option_value(line, option):


@@ -405,7 +486,7 @@ def set_option_value(line, option, value):
     return re.sub(rx, '\g<1>' + value + '"', line)
 
 
     return re.sub(rx, '\g<1>' + value + '"', line)
 
 

-def del_token(lines, token, start, end = 0):
+def del_token(lines, token, start=0, end=0):

     """ del_token(lines, token, start, end) -> int
 
     Find the first line in lines where token is the first element
     """ del_token(lines, token, start, end) -> int
 
     Find the first line in lines where token is the first element


@@ -418,6 +499,41 @@ def del_token(lines, token, start, end = 0):
     del lines[k]
     return True
 
     del lines[k]
     return True
 

+def del_complete_lines(lines, sublines, start=0, end=0):
+    """Delete first occurence of `sublines` in list `lines`.
+
+    Efficient deletion of a sub-list in a list. Works for any values.
+    The `start` and `end` arguments work similar to list.index()
+
+    Returns True if a deletion was done and False if not.
+
+    >>> l = [1, 0, 1, 1, 1, 2]
+    >>> del_complete_lines(l, [0, 1, 1])
+    True
+    >>> l
+    [1, 1, 2]
+    """
+    i = find_complete_lines(lines, sublines, start, end)
+    if i == -1:
+        return False
+    del(lines[i:i+len(sublines)])
+    return True
+
+
+def del_value(lines, token, start=0, end=0, default=None):
+    """
+    Find the next line that looks like:
+      token followed by other stuff
+    Delete that line and return "followed by other stuff"
+    with leading and trailing whitespace removed.
+
+    If token is not found, return `default`.
+    """
+    i = find_token_exact(lines, token, start, end)
+    if i == -1:
+        return default
+    return lines.pop(i)[len(token):].strip()
+

 
 def find_beginning_of(lines, i, start_token, end_token):
     count = 1
 
 def find_beginning_of(lines, i, start_token, end_token):
     count = 1


@@ -425,7 +541,7 @@ def find_beginning_of(lines, i, start_token, end_token):
         i = find_tokens_backwards(lines, [start_token, end_token], i-1)
         if i == -1:
             return -1
         i = find_tokens_backwards(lines, [start_token, end_token], i-1)
         if i == -1:
             return -1

-        if check_token(lines[i], end_token):
+        if lines[i].startswith(end_token):

             count = count+1
         else:
             count = count-1
             count = count+1
         else:
             count = count-1


@@ -441,7 +557,7 @@ def find_end_of(lines, i, start_token, end_token):
         i = find_tokens(lines, [end_token, start_token], i+1)
         if i == -1:
             return -1
         i = find_tokens(lines, [end_token, start_token], i+1)
         if i == -1:
             return -1

-        if check_token(lines[i], start_token):
+        if lines[i].startswith(start_token):

             count = count+1
         else:
             count = count-1
             count = count+1
         else:
             count = count-1


@@ -450,11 +566,11 @@ def find_end_of(lines, i, start_token, end_token):
     return -1
 
 
     return -1
 
 

-def find_nonempty_line(lines, start, end = 0):
+def find_nonempty_line(lines, start=0, end=0):

     if end == 0:
         end = len(lines)
     for i in range(start, end):
     if end == 0:
         end = len(lines)
     for i in range(start, end):

-        if is_nonempty_line(lines[i]):
+        if lines[i].strip():

             return i
     return -1
 
             return i
     return -1
 


@@ -469,29 +585,27 @@ def find_end_of_layout(lines, i):
     return find_end_of(lines, i, "\\begin_layout", "\\end_layout")
 
 
     return find_end_of(lines, i, "\\begin_layout", "\\end_layout")
 
 

-def is_in_inset(lines, i, inset):
-    '''
-    Checks if line i is in an inset of the given type.
-    If so, returns starting and ending lines.
-    Otherwise, returns False.
+def is_in_inset(lines, i, inset, default=(-1,-1)):
+    """
+    Check if line i is in an inset of the given type.
+    If so, return starting and ending lines, otherwise `default`.

     Example:
       is_in_inset(document.body, i, "\\begin_inset Tabular")
     Example:
       is_in_inset(document.body, i, "\\begin_inset Tabular")

-    returns False unless i is within a table. If it is, then
-    it returns the line on which the table begins and the one
-    on which it ends. Note that this pair will evaulate to
-    boolean True, so
-      if is_in_inset(...):
+    returns (-1,-1) if `i` is not within a "Tabular" inset (i.e. a table).
+    If it is, then it returns the line on which the table begins and the one
+    on which it ends.
+    Note that this pair will evaulate to boolean True, so (with the optional
+    default value set to False)
+      if is_in_inset(..., default=False):

     will do what you expect.
     will do what you expect.

-    '''
-    defval = (-1, -1)
-    stins = find_token_backwards(lines, inset, i)
-    if stins == -1:
-      return defval
-    endins = find_end_of_inset(lines, stins)
-    # note that this includes the notfound case.
-    if endins < i:
-      return defval
-    return (stins, endins)
+    """
+    start = find_token_backwards(lines, inset, i)
+    if start == -1:
+      return default
+    end = find_end_of_inset(lines, start)
+    if end < i: # this includes the notfound case.
+      return default
+    return (start, end)

 
 
 def get_containing_inset(lines, i):
 
 
 def get_containing_inset(lines, i):


@@ -523,12 +637,15 @@ def get_containing_inset(lines, i):
 
 def get_containing_layout(lines, i):
   '''
 
 def get_containing_layout(lines, i):
   '''

-  Finds out what kind of layout line i is within. Returns a
-  list containing what follows \begin_layout on the line
-  on which the layout begins, plus the starting and ending line
-  and the start of the paragraph (after all params). I.e, returns:
+  Find out what kind of layout line `i` is within.
+  Return a tuple

     (layoutname, layoutstart, layoutend, startofcontent)
     (layoutname, layoutstart, layoutend, startofcontent)

-  Returns False on any kind of error.
+  containing
+    * layout style/name,
+    * start line number,
+    * end line number, and
+    * number of first paragraph line (after all params).
+  Return `False` on any kind of error.

   '''
   j = i
   while True:
   '''
   j = i
   while True:


@@ -543,10 +660,13 @@ def get_containing_layout(lines, i):
   if endlay < i:
       return False
 
   if endlay < i:
       return False
 

-  lay = get_value(lines, "\\begin_layout", stlay)
-  if lay == "":
-      # shouldn't happen
-      return False
+  layoutname = get_value(lines, "\\begin_layout", stlay)
+  if layoutname == "": # layout style missing
+      # TODO: What shall we do in this case?
+      pass
+      # layoutname == "Standard" # use same fallback as the LyX parser:
+      # raise ValueError("Missing layout name on line %d"%stlay) # diagnosis
+      # return False # generic error response

   par_params = ["\\noindent", "\\indent", "\\indent-toggle", "\\leftindent",
                 "\\start_of_appendix", "\\paragraph_spacing", "\\align",
                 "\\labelwidthstring"]
   par_params = ["\\noindent", "\\indent", "\\indent-toggle", "\\leftindent",
                 "\\start_of_appendix", "\\paragraph_spacing", "\\align",
                 "\\labelwidthstring"]


@@ -555,7 +675,7 @@ def get_containing_layout(lines, i):
       stpar += 1
       if lines[stpar].split(' ', 1)[0] not in par_params:
           break
       stpar += 1
       if lines[stpar].split(' ', 1)[0] not in par_params:
           break

-  return (lay, stlay, endlay, stpar)
+  return (layoutname, stlay, endlay, stpar)

 
 
 def count_pars_in_inset(lines, i):
 
 
 def count_pars_in_inset(lines, i):