Fix bug #7663: Misparsing of description \item with spaces

[lyx.git] / src / tex2lyx / text.cpp

diff --git a/src/tex2lyx/text.cpp b/src/tex2lyx/text.cpp
index 611662af6d38cab9b3d32c9e5ffb3e0ff39af4eb..1886c08956895b135828f3336b06389c4a9b3258 100644 (file)
--- a/src/tex2lyx/text.cpp
+++ b/src/tex2lyx/text.cpp
@@ -798,6 +798,7 @@ void parse_box(Parser & p, ostream & os, unsigned outer_flags,
                latex_width = p.verbatim_item();
        // if e.g. only \ovalbox{content} was used, set the width to 1\columnwidth
        // as this is LyX's standard for such cases (except for makebox)
+       // \framebox is more special and handled below
        if (latex_width.empty() && inner_type != "makebox"
                && outer_type != "framebox")
                latex_width = "1\\columnwidth";
@@ -842,7 +843,7 @@ void parse_box(Parser & p, ostream & os, unsigned outer_flags,
                }
                p.popPosition();
        }
-       // if only \makebox{content} was used we can its width to 1\width
+       // if only \makebox{content} was used we can set its width to 1\width
        // because this identic and also identic to \mbox
        // this doesn't work for \framebox{content}, thus we have to use ERT for this
        if (latex_width.empty() && inner_type == "makebox") {
@@ -896,6 +897,13 @@ void parse_box(Parser & p, ostream & os, unsigned outer_flags,
                        // the inner env
                        if (!inner_type.empty() && (inner_flags & FLAG_END))
                                active_environments.pop_back();
+       
+                       // Ensure that the end of the outer box is parsed correctly:
+                       // The opening brace has been eaten by parse_outer_box()
+                       if (!outer_type.empty() && (outer_flags & FLAG_ITEM)) {
+                               outer_flags &= ~FLAG_ITEM;
+                               outer_flags |= FLAG_BRACE_LAST;
+                       }
                        parse_text(p, os, outer_flags, outer, parent_context);
                        if (outer_flags & FLAG_END)
                                handle_ert(os, "\\end{" + outer_type + '}',
@@ -1151,11 +1159,16 @@ void parse_environment(Parser & p, ostream & os, bool outer,
                end_inset(os);
        }
 
-       else if (name == "tabular" || name == "longtable") {
+       else if (unstarred_name == "tabular" || name == "longtable") {
                eat_whitespace(p, os, parent_context, false);
+               string width = "0pt";
+               if (name == "tabular*") {
+                       width = lyx::translate_len(p.getArg('{', '}'));
+                       eat_whitespace(p, os, parent_context, false);
+               }
                parent_context.check_layout(os);
                begin_inset(os, "Tabular ");
-               handle_tabular(p, os, name == "longtable", parent_context);
+               handle_tabular(p, os, name, width, parent_context);
                end_inset(os);
                p.skip_spaces();
        }
@@ -2166,16 +2179,15 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                }
 
                else if (t.cs() == "item") {
-                       p.skip_spaces();
                        string s;
-                       bool optarg = false;
-                       if (p.next_token().cat() != catEscape &&
-                           p.next_token().character() == '[') {
-                               p.get_token(); // eat '['
-                               s = parse_text_snippet(p, FLAG_BRACK_LAST,
-                                                      outer, context);
-                               optarg = true;
-                       }
+                       bool const optarg = p.hasOpt();
+                       if (optarg) {
+                               // FIXME: This swallows comments, but we cannot use
+                               //        eat_whitespace() since we must not output
+                               //        anything before the item.
+                               s = p.getArg('[', ']');
+                       } else
+                               p.skip_spaces(false);
                        context.set_item();
                        context.check_layout(os);
                        if (context.has_item) {
@@ -2191,13 +2203,30 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                                if (context.layout->labeltype != LABEL_MANUAL) {
                                        // LyX does not support \item[\mybullet]
                                        // in itemize environments
-                                       handle_ert(os, "[", context);
-                                       os << s;
-                                       handle_ert(os, "]", context);
+                                       Parser p2(s + ']');
+                                       os << parse_text_snippet(p2,
+                                               FLAG_BRACK_LAST, outer, context);
                                } else if (!s.empty()) {
+                                       // LyX adds braces around the argument,
+                                       // so we need to remove them here.
+                                       if (s.size() > 2 && s[0] == '{' &&
+                                           s[s.size()-1] == '}')
+                                               s = s.substr(1, s.size()-2);
+                                       // If the argument contains a space we
+                                       // must put it into ERT: Otherwise LyX
+                                       // would misinterpret the space as
+                                       // item delimiter (bug 7663)
+                                       if (contains(s, ' ')) {
+                                               handle_ert(os, s, context);
+                                       } else {
+                                               Parser p2(s + ']');
+                                               os << parse_text_snippet(p2,
+                                                       FLAG_BRACK_LAST,
+                                                       outer, context);
+                                       }
                                        // The space is needed to separate the
                                        // item from the rest of the sentence.
-                                       os << s << ' ';
+                                       os << ' ';
                                        eat_whitespace(p, os, context, false);
                                }
                        }
@@ -3552,14 +3581,18 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                }
 
                //\makebox() is part of the picture environment and different from \makebox{}
-               //\makebox{} will be parsed by parse_box when bug 2956 is fixed
+               //\makebox{} will be parsed by parse_box
                else if (t.cs() == "makebox") {
                        string arg = t.asInput();
                        if (p.next_token().character() == '(') {
                                //the syntax is: \makebox(x,y)[position]{content}
                                arg += p.getFullParentheseArg();
                                arg += p.getFullOpt();
-                               handle_ert(os, arg + p.get_token().asInput(), context);
+                               eat_whitespace(p, os, context, false);
+                               handle_ert(os, arg + '{', context);
+                               eat_whitespace(p, os, context, false);
+                               parse_text(p, os, FLAG_ITEM, outer, context);
+                               handle_ert(os, "}", context);
                        } else
                                //the syntax is: \makebox[width][position]{content}
                                parse_box(p, os, 0, FLAG_ITEM, outer, context,