Extend the notermination flag to math as well.

Math commands need it as well as text commands. At the same time, this
further unifies the checking for termination and fixes cases of wrong
output (e.g. for 0x2005).

diff --git a/lib/unicodesymbols b/lib/unicodesymbols
index 94fead8fa048c7f966e980690d017dd5542506af..5b8e948d41e13e8b8d2bd91e6c4f6dee8af1aee8 100644 (file)
--- a/lib/unicodesymbols
+++ b/lib/unicodesymbols
@@ -34,10 +34,15 @@
 # - combining       This is a combining char that will get combined with a base char
 # - force           Always output replacement command
 # - mathalpha       This character is considered as a math variable in mathmode
-# - notermination   Do not terminate this command (by {} or space).
+# - notermination=text Do not terminate this textcommand (by {} or space).
+#                      This is set by default if textcommand ends with }.
+# - notermination=math Do not terminate this mathcommand (by {} or space).
+#                      This is set by default if mathcommand ends with }.
+# - notermination=both Do not terminate this textcommand and mathcommand (by {} or space).
+# - notermination=none Always terminate this textcommand and mathcommand (by {} or space).
 # - tipashortcut=<shortcut> Shortcut notation for TIPA
 
-0x00a0 "~"                        "" "notermination" "~" "" # NO-BREAK SPACE
+0x00a0 "~"                        "" "notermination=both" "~" "" # NO-BREAK SPACE
 0x00a1 "\\textexclamdown"         "" "" # INVERTED EXCLAMATION MARK
 0x00a2 "\\textcent"               "textcomp" "" #"\\mathcent" "txfonts|pxfonts" # CENT SIGN
 0x00a3 "\\pounds"                 "" "" "\\pounds" "" # £ POUND SIGN
@@ -50,7 +55,7 @@
 0x00aa "\\textordfeminine"        "textcomp" "" # FEMININE ORDINAL INDICATOR
 0x00ab "\\guillemotleft"          "" "" # LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
 0x00ac "\\textlnot"               "textcomp" "force" "\\neg" "" # ¬ NOT SIGN
-0x00ad "\\-"                      "" "notermination" # SOFT HYPHEN
+0x00ad "\\-"                      "" "notermination=text" "" "" # SOFT HYPHEN
 0x00ae "\\textregistered"         "textcomp" "force" "\\circledR" "amssymb" # REGISTERED SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005
 0x00af "\\textasciimacron"        "textcomp" "" # MACRON
 0x00b0 "\\textdegree"             "textcomp" "force" "{^\\circ}" "" # DEGREE SIGN # the force flag is only needed due to a bug in teTeX 3 / TeXLive 2005
@@ -61,7 +66,7 @@
 0x00b5 "\\textmu"                 "textcomp" "force" "\\mu" "" # µ MICRO SIGN
 0x00b6 "\\textparagraph"          "textcomp" "" # PILCROW SIGN # not equal to \textpilcrow
 0x00b7 "\\textperiodcentered"     "" "" "\cdot" # MIDDLE DOT
-0x00b8 "\\c\\ "                   "" "" # CEDILLA (command from latin1.def)
+0x00b8 "\\c\\ "                   "" "notermination=text" "" "" # CEDILLA (command from latin1.def)
 0x00b9 "\\textonesuperior"        "textcomp" "force" "{{}^1}" "" # ¹ SUPERSCRIPT ONE
 0x00ba "\\textordmasculine"       "textcomp" "" # MASCULINE ORDINAL INDICATOR
 0x00bb "\\guillemotright"         "" "" # RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
@@ -85,7 +90,7 @@
 0x00cd "\\'{I}"                   "" "mathalpha" "\\acute{I}" # LATIN CAPITAL LETTER I WITH ACUTE
 0x00ce "\\^{I}"                   "" "mathalpha" "\\hat{I}" # LATIN CAPITAL LETTER I WITH CIRCUMFLEX
 0x00cf "\\\"{I}"                  "" "mathalpha" "\\ddot{I}" # LATIN CAPITAL LETTER I WITH DIAERESIS
-0x00d0 "\\DH"                     "" "mathalpha" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER ETH
+0x00d0 "\\DH"                     "" "mathalpha,notermination=math" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER ETH
 0x00d1 "\\~{N}"                   "" "mathalpha" "\\tilde{N}" # LATIN CAPITAL LETTER N WITH TILDE
 0x00d2 "\\`{O}"                   "" "mathalpha" "\\grave{O}" # LATIN CAPITAL LETTER O WITH GRAVE
 0x00d3 "\\'{O}"                   "" "mathalpha" "\\acute{O}" # LATIN CAPITAL LETTER O WITH ACUTE
@@ -149,8 +154,8 @@
 0x010d "\\v{c}"                   "" "mathalpha" "\\check{c}" # LATIN SMALL LETTER C WITH CARON
 0x010e "\\v{D}"                   "" "mathalpha" "\\check{D}" # LATIN CAPITAL LETTER D WITH CARON
 0x010f "\\v{d}"                   "" "mathalpha" "\\check{d}" # LATIN SMALL LETTER D WITH CARON
-0x0110 "\\DJ"                     "" "mathalpha" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER D WITH STROKE
-0x0111 "\\dj"                     "" "mathalpha" "\\mkern3mu\\mathchar'26\\mkern-12mu d" # LATIN SMALL LETTER D WITH STROKE
+0x0110 "\\DJ"                     "" "mathalpha,notermination=math" "\\mkern2mu\\rule[0.75ex]{0.75ex}{0.06ex}\\mkern-8mu D" # LATIN CAPITAL LETTER D WITH STROKE
+0x0111 "\\dj"                     "" "mathalpha,notermination=math" "\\mkern3mu\\mathchar'26\\mkern-12mu d" # LATIN SMALL LETTER D WITH STROKE
 0x0112 "\\={E}"                   "" "mathalpha" "\\bar{E}" # LATIN CAPITAL LETTER E WITH MACRON
 0x0113 "\\={e}"                   "" "mathalpha" "\\bar{e}" # LATIN SMALL LETTER E WITH MACRON
 0x0114 "\\u{E}"                   "" "mathalpha" "\\breve{E}" # LATIN CAPITAL LETTER E WITH BREVE
@@ -168,7 +173,7 @@
 0x0120 "\\.{G}"                   "" "mathalpha" "\\dot{G}" # LATIN CAPITAL LETTER G WITH DOT ABOVE
 0x0121 "\\.{g}"                   "" "mathalpha" "\\dot{g}" # LATIN SMALL LETTER G WITH DOT ABOVE
 0x0122 "\\c{G}"                   "" "mathalpha" "\\cedilla{G}" "accents,cedilla" # LATIN CAPITAL LETTER G WITH CEDILLA
-0x0123 "\\accent96 g"             "" "mathalpha,notermination" "\\mathaccent96 g" # LATIN SMALL LETTER G WITH CEDILLA
+0x0123 "\\accent96 g"             "" "mathalpha,notermination=both" "\\mathaccent96 g" "" # LATIN SMALL LETTER G WITH CEDILLA
 0x0124 "\\^{H}"                   "" "mathalpha" "\\hat{H}" # LATIN CAPITAL LETTER H WITH CIRCUMFLEX
 0x0125 "\\^{h}"                   "" "mathalpha" "\\hat{h}" # LATIN SMALL LETTER H WITH CIRCUMFLEX
 #0x0126 ""                         "" "" "" "" # LATIN CAPITAL LETTER H WITH STROKE
@@ -183,8 +188,8 @@
 0x012f "\\k{i}"                   "" "mathalpha" "\\ogonek{i}" "accents,tipasymb,ogonek" # LATIN SMALL LETTER I WITH OGONEK
 0x0130 "\\.{I}"                   "" "mathalpha" "\\dot{I}" # LATIN CAPITAL LETTER I WITH DOT ABOVE
 0x0131 "\\i"                      "" "mathalpha" "\\imath" # LATIN SMALL LETTER DOTLESS I
-0x0132 "IJ"                       "" "mathalpha,notermination" "IJ" # LATIN CAPITAL LIGATURE IJ
-0x0133 "ij"                       "" "mathalpha,notermination" "ij" # LATIN SMALL LIGATURE IJ
+0x0132 "IJ"                       "" "mathalpha,notermination=both" "IJ" "" # LATIN CAPITAL LIGATURE IJ
+0x0133 "ij"                       "" "mathalpha,notermination=both" "ij" "" # LATIN SMALL LIGATURE IJ
 0x0134 "\\^{J}"                   "" "mathalpha" "\\hat{J}" # LATIN CAPITAL LETTER J WITH CIRCUMFLEX
 0x0135 "\\^{\\j}"                 "" "mathalpha" "\\hat{\\jmath}" # LATIN SMALL LETTER J WITH CIRCUMFLEX
 0x0136 "\\c{K}"                   "" "mathalpha" "\\cedilla{K}" "accents,cedilla" # LATIN CAPITAL LETTER K WITH CEDILLA
@@ -198,8 +203,8 @@
 0x013e "\\v{l}"                   "" "mathalpha" "l\\mkern-5mu\\mathchar19" # LATIN SMALL LETTER L WITH CARON
 #0x013f ""                         "" "" "" "" # LATIN CAPITAL LETTER L WITH MIDDLE DOT
 #0x0140 ""                         "" "" "" "" # LATIN SMALL LETTER L WITH MIDDLE DOT
-0x0141 "\\L"                      "" "mathalpha" "\\mkern2mu\\mathchar'40\\mkern-7mu L" # LATIN CAPITAL LETTER L WITH STROKE
-0x0142 "\\l"                      "" "mathalpha" "\\mathchar'40\\mkern-5mu l" # LATIN SMALL LETTER L WITH STROKE
+0x0141 "\\L"                      "" "mathalpha,notermination=math" "\\mkern2mu\\mathchar'40\\mkern-7mu L" # LATIN CAPITAL LETTER L WITH STROKE
+0x0142 "\\l"                      "" "mathalpha,notermination=math" "\\mathchar'40\\mkern-5mu l" # LATIN SMALL LETTER L WITH STROKE
 0x0143 "\\'{N}"                   "" "mathalpha" "\\acute{N}" # LATIN CAPITAL LETTER N WITH ACUTE
 0x0144 "\\'{n}"                   "" "mathalpha" "\\acute{n}" # LATIN SMALL LETTER N WITH ACUTE
 0x0145 "\\c{N}"                   "" "mathalpha" "\\cedilla{N}" "accents,cedilla" # LATIN CAPITAL LETTER N WITH CEDILLA
@@ -331,7 +336,7 @@
 0x01c0 "\\textpipe"               "tipa" "force,tipashortcut=|" # LATIN LETTER DENTAL CLICK
 0x01c1 "\\textdoublepipe"         "tipa" "force,tipashortcut=||" # LATIN LETTER LATERAL CLICK
 0x01c2 "\\textdoublebarpipe"      "tipa" "force" # LATIN LETTER ALVEOLAR CLICK
-0x01c3 "!"                        "" "notermination" # LATIN LETTER RETROFLEX CLICK
+0x01c3 "!"                        "" "notermination=text" "" "" # LATIN LETTER RETROFLEX CLICK
 #0x01c4 ""                         "" "" # LATIN CAPITAL LETTER DZ WITH CARON
 #0x01c5 ""                         "" "" # LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON
 #0x01c6 ""                         "" "" # LATIN SMALL LETTER DZ WITH CARON
@@ -611,8 +616,8 @@
 #0x02d3 ""                         "" "" # MODIFIER LETTER CENTRED LEFT HALF RING
 0x02d4 "\\textraising{ }"         "tipa" "force" # MODIFIER LETTER UP TACK
 0x02d5 "\\textlowering{ }"        "tipa" "force" # MODIFIER LETTER DOWN TACK
-0x02d6 ""                         "" "" "+" # MODIFIER LETTER PLUS SIGN
-0x02d7 ""                         "" "" "-" # MODIFIER LETTER MINUS SIGN
+0x02d6 ""                         "" "notermination=math" "+" # MODIFIER LETTER PLUS SIGN
+0x02d7 ""                         "" "notermination=math" "-" # MODIFIER LETTER MINUS SIGN
 0x02d8 "\\u{ }"                   "" "" # BREVE
 0x02d9 "\\.{ }"                   "" "" # DOT ABOVE
 0x02da "\\r{ }"                   "" "" # RING ABOVE
@@ -652,15 +657,15 @@
 #
 # Combining diacritical marks
 #
-0x0300 "\\`"                      "" "combining,force" # COMBINING GRAVE ACCENT
-0x0301 "\\'"                      "" "combining,force" # COMBINING ACUTE ACCENT
-0x0302 "\\^"                      "" "combining,force" # COMBINING CIRCUMFLEX ACCENT
-0x0303 "\\~"                      "" "combining,force" # COMBINING TILDE
-0x0304 "\\="                      "" "combining,force" # COMBINING MACRON
+0x0300 "\\`"                      "" "combining,force,notermination=text" "" "" # COMBINING GRAVE ACCENT
+0x0301 "\\'"                      "" "combining,force,notermination=text" "" "" # COMBINING ACUTE ACCENT
+0x0302 "\\^"                      "" "combining,force,notermination=text" "" "" # COMBINING CIRCUMFLEX ACCENT
+0x0303 "\\~"                      "" "combining,force,notermination=text" "" "" # COMBINING TILDE
+0x0304 "\\="                      "" "combining,force,notermination=text" "" "" # COMBINING MACRON
 #0x0305 ""                         "" "combining,force" # COMBINING OVERLINE
 0x0306 "\\u"                      "" "combining,force" # COMBINING BREVE
-0x0307 "\\."                      "" "combining,force" # COMBINING DOT ABOVE
-0x0308 "\\\""                     "" "combining,force" # COMBINING DIAERESIS
+0x0307 "\\."                      "" "combining,force,notermination=text" "" "" # COMBINING DOT ABOVE
+0x0308 "\\\""                     "" "combining,force,notermination=text" "" "" # COMBINING DIAERESIS
 #0x0309 ""                         "" "combining,force" # COMBINING HOOK ABOVE
 0x030a "\\r"                      "" "combining,force" # COMBINING RING ABOVE
 0x030b "\\H"                      "" "combining,force" # COMBINING DOUBLE ACUTE ACCENT
@@ -718,7 +723,7 @@
 #0x033f ""                         "" "combining,force" # COMBINING DOUBLE OVERLINE
 #0x0340 ""                         "" "combining,force" # COMBINING GRAVE TONE MARK
 #0x0341 ""                         "" "combining,force" # COMBINING ACUTE TONE MARK
-0x0342 "\\~"                      "textgreek" "combining,force" # COMBINING GREEK PERISPOMENI 
+0x0342 "\\~"                      "textgreek" "combining,force,notermination=text" "" "" # COMBINING GREEK PERISPOMENI 
 #0x0343 ""                         "" "combining,force" # COMBINING GREEK KORONIS
 #0x0344 ""                         "" "combining,force" # COMBINING GREEK DIALYTIKA TONOS
 #0x0345 ""                         "" "combining,force" # COMBINING GREEK YPOGEGRAMMENI
@@ -845,16 +850,16 @@
 #0x03d5 ""                         "" "" "" "" # GREEK PHI SYMBOL
 #0x03d6 ""                         "" "" "" "" # GREEK PI SYMBOL
 #0x03d7 ""                         "" "" "" "" # GREEK KAI SYMBOL
-0x03d8 "\\textgreek{\\char21}"     "textgreek" "" # GREEK LETTER ARCHAIC KOPPA
-0x03d9 "\\textgreek{\\char19}"     "textgreek" "" # GREEK SMALL LETTER ARCHAIC KOPPA
+0x03d8 "\\textgreek{\\char21}"    "textgreek" "" "" "" # GREEK LETTER ARCHAIC KOPPA
+0x03d9 "\\textgreek{\\char19}"    "textgreek" "" "" "" # GREEK SMALL LETTER ARCHAIC KOPPA
 #0x03da ""                         "" "" "" "" # GREEK LETTER STIGMA
-0x03db "\\textgreek{\\char6}"      "textgreek" "" # GREEK SMALL LETTER STIGMA
-0x03dc "\\textgreek{\\char195}"    "textgreek" "" # GREEK LETTER DIGAMMA
+0x03db "\\textgreek{\\char6}"     "textgreek" "" "" "" # GREEK SMALL LETTER STIGMA
+0x03dc "\\textgreek{\\char195}"   "textgreek" "" "" "" # GREEK LETTER DIGAMMA
 0x03dd "\\textgreek{\\char147}"   "textgreek" "" "\\digamma" "amssymb" # GREEK SMALL LETTER DIGAMMA
 #0x03de ""                         "" "" "" "" # GREEK LETTER KOPPA
-0x03df "\\textgreek{\\char18}"     "textgreek" "" # GREEK SMALL LETTER KOPPA
-0x03e0 "\\textgreek{\\char23}"     "textgreek" "" # GREEK LETTER SAMPI
-0x03e1 "\\textgreek{\\char27}"     "textgreek" "" # GREEK SMALL LETTER SAMPI
+0x03df "\\textgreek{\\char18}"    "textgreek" "" "" "" # GREEK SMALL LETTER KOPPA
+0x03e0 "\\textgreek{\\char23}"    "textgreek" "" "" "" # GREEK LETTER SAMPI
+0x03e1 "\\textgreek{\\char27}"    "textgreek" "" "" "" # GREEK SMALL LETTER SAMPI
 0x03f6 ""                         "" "" "\\backepsilon" "amssymb" # ϶ GREEK REVERSED LUNATE EPSILON SYMBOL
 #
 # Cyrillic
@@ -1580,9 +1585,9 @@
 0x2001 "\\quad"                   "" "" "\\quad" "" # EM QUAD
 0x2002 "\\enskip"                 "" "" "\\enskip" "" # EN SPACE
 0x2003 "\\quad"                   "" "" "\\quad" "" # EM SPACE
-0x2004 "\\;"                      "" "notermination" "\\;" "" # THREE-PER-EM SPACE
-0x2005 "\\:"                      "" "notermination" "\\:" "" # FOUR-PER-EM SPACE
-0x2006 "\\,"                      "" "notermination" "\\," "" # SIX-PER-EM SPACE
+0x2004 "\\;"                      "" "notermination=both" "\\;" "" # THREE-PER-EM SPACE
+0x2005 "\\:"                      "" "notermination=both" "\\:" "" # FOUR-PER-EM SPACE
+0x2006 "\\,"                      "" "notermination=both" "\\," "" # SIX-PER-EM SPACE
 0x2007 "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" "" "\\LyXFigureSpace" "\\newcommand*\\LyXFigureSpace{\\hphantom{0}}" # FIGURE SPACE
 0x2008 "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" "" "\\LyXPunctSpace" "\\newcommand*\\LyXPunctSpace{\\hphantom{,}}" # PUNCTUATION SPACE
 0x2009 "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" "" "\\LyXThinSpace" "\\newcommand*\\LyXThinSpace{\\,\\hspace{0pt}}" # THIN SPACE
@@ -1592,14 +1597,14 @@
 #0x200d ""                         "" "" "" "" # ZERO WIDTH JOINER
 #0x200e ""                         "" "" "" "" # LEFT-TO-RIGHT MARK
 #0x200f ""                         "" "" "" "" # RIGHT-TO-LEFT MARK
-0x2010 "-"                        "" "notermination" "" "" # HYPHEN # identic in LaTeX to FIGURE DASH
-0x2011 "\\nobreakdash-"           "amsmath" "notermination" "" "" # NON-BREAKING HYPHEN
-0x2012 "-"                        "" "notermination" # FIGURE DASH
+0x2010 "-"                        "" "notermination=text" "" "" # HYPHEN # identic in LaTeX to FIGURE DASH
+0x2011 "\\nobreakdash-"           "amsmath" "notermination=text" "" "" # NON-BREAKING HYPHEN
+0x2012 "-"                        "" "notermination=text" "" "" # FIGURE DASH
 0x2013 "\\textendash"             "" "" # EN DASH
 0x2014 "\\textemdash"             "" "" # EM DASH
 # use the following macro for the character HORIZONTAL BAR
 0x2015 "\\LyXbar" "\\newcommand*\\LyXbar{\\rule[0.585ex]{1.2em}{0.25pt}}" ""
-0x2016 "\\textbardbl"             "textcomp" "" "\\|" "" # DOUBLE VERTICAL LINE
+0x2016 "\\textbardbl"             "textcomp,notermination=math" "" "\\|" "" # DOUBLE VERTICAL LINE
 0x2017 "\\subdoublebar{ }"        "tipa" "" "" "" # DOUBLE LOW LINE
 0x2018 "\\textquoteleft"          "" "" # LEFT SINGLE QUOTATION MARK
 0x2019 "\\textquoteright"         "" "" # RIGHT SINGLE QUOTATION MARK
@@ -1613,10 +1618,10 @@
 0x2021 "\\ddag"                   "" "" "\\ddagger" "" # DOUBLE DAGGER
 0x2022 "\\textbullet"             "textcomp" "" # BULLET
 0x2023 "\\textifsymbol[ifgeo]{116}" "ifsym" "" # TRIANGULAR BULLET # ≈ 0x25b8
-0x2024 "."                        "" "notermination" # ONE DOT LEADER # ≈ FULL STOP
-0x2025 ".\\,."                    "" "notermination" # TWO DOT LEADER
+0x2024 "."                        "" "notermination=text" "" "" # ONE DOT LEADER # ≈ FULL STOP
+0x2025 ".\\,."                    "" "notermination=text" "" "" # TWO DOT LEADER
 0x2026 "\\ldots"                  "" "" "\\ldots" "" # HORIZONTAL ELLIPSIS
-0x2027 "\\-"                      "" "notermination" "" "" # HYPHENATION POINT
+0x2027 "\\-"                      "" "notermination=text" "" "" # HYPHENATION POINT
 #0x2028 ""                         "" "" "" "" # LINE SEPARATOR
 #0x2029 ""                         "" "" "" "" # PARAGRAPH SEPARATOR
 #0x202a ""                         "" "" "" "" # LEFT-TO-RIGHT EMBEDDING
@@ -1624,7 +1629,7 @@
 #0x202c ""                         "" "" "" "" # POP DIRECTIONAL FORMATTING
 #0x202d ""                         "" "" "" "" # LEFT-TO-RIGHT OVERRIDE
 #0x202e ""                         "" "" "" "" # RIGHT-TO-LEFT OVERRIDE
-0x202f "\\,"                      "" "notermination" "\\," "" # NARROW NO-BREAK SPACE
+0x202f "\\,"                      "" "notermination=both" "\\," "" # NARROW NO-BREAK SPACE
 0x2030 "\\textperthousand"        "textcomp" "" # PER MILLE SIGN
 0x2031 "\\textpertenthousand"     "textcomp" "" # PER TEN THOUSAND SIGN
 0x2032 "\\textasciiacute"         "textcomp" "" "\\prime" "" # PRIME
@@ -1633,24 +1638,24 @@
 0x2035 "\\textasciigrave"         "textcomp" "" "\\backprime" "amssymb" # REVERSED PRIME
 0x2036 "\\textgravedbl"           "textcomp" "" # REVERSED DOUBLE PRIME
 #0x2037 ""                         "" "" # REVERSED TRIPLE PRIME
-0x2038 "\\^{}"                    "" "notermination" # CARET
+0x2038 "\\^{}"                    "" "" "" "" # CARET
 0x2039 "\\guilsinglleft"          "" "" # SINGLE LEFT-POINTING ANGLE QUOTATION MARK
 0x203a "\\guilsinglright"         "" "" # SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
 0x203b "\\textreferencemark"      "textcomp" "" # REFERENCE MARK
-0x203c "!!"                       "" "notermination" # DOUBLE EXCLAMATION MARK # ≈ 2×EXCLAMATION MARK
+0x203c "!!"                       "" "notermination=text" "" "" # DOUBLE EXCLAMATION MARK # ≈ 2×EXCLAMATION MARK
 0x203d "\\textinterrobang"        "textcomp" "" # INTERROBANG
 # use the following macro for the character OVERLINE
 0x203e "\\LyXoverline" "\\newcommand*\\LyXoverline{\\raisebox{2.6ex}{\\_}}" ""
 0x2044 "\\textfractionsolidus"    "textcomp" "" # FRACTION SLASH
 0x2045 "\\textlquill"             "textcomp" "" # LEFT SQUARE BRACKET WITH QUILL
 0x2046 "\\textrquill"             "textcomp" "" # RIGHT SQUARE BRACKET WITH QUILL
-0x2047 "??"                       "" "notermination" # DOUBLE QUESTION MARK # ≈ 2×QUESTION MARK
-0x2048 "?!"                       "" "notermination" # QUESTION EXCLAMATION MARK
-0x2049 "!?"                       "" "notermination" # EXCLAMATION QUESTION MARK
+0x2047 "??"                       "" "notermination=text" "" "" # DOUBLE QUESTION MARK # ≈ 2×QUESTION MARK
+0x2048 "?!"                       "" "notermination=text" "" "" # QUESTION EXCLAMATION MARK
+0x2049 "!?"                       "" "notermination=text" "" "" # EXCLAMATION QUESTION MARK
 0x2052 "\\textdiscount"           "textcomp" "" # COMMERCIAL MINUS SIGN
 0x205d "\\vdots"                  "" "" # TRICOLON # ≈ VERTICAL ELLIPSIS
 #0x205e ""                         "" "" "" "" # VERTICAL FOUR DOTS
-0x205f ""                         "" "" "\\:" "" # MEDIUM MATHEMATICAL SPACE
+0x205f ""                         "" "notermination=math" "\\:" "" # MEDIUM MATHEMATICAL SPACE
 #0x2060 ""                         "" "" "" "" # WORD JOINER
 0x2070 "\\textsuperscript{0}"     "" "" "{{}^0}" "" # SUPERSCRIPT ZERO
 0x2071 "\\textsuperscript{i}"     "" "" "{{}^i}" "" # SUPERSCRIPT LATIN SMALL LETTER I
@@ -1716,13 +1721,13 @@
 0x2105 "\\LyXcareof" "\\newcommand*\\LyXcareof{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{o}}}" ""
 # use the following macro for the character CADA UNA
 0x2106 "\\LyXcadauna" "\\newcommand*\\LyXcadauna{\\mbox{\\raisebox{.8ex}{c}\\kern-.175em\\raisebox{.2ex}{/}\\kern-.18em\\raisebox{-.2ex}{u}}}" ""
-0x2109 "°{}F"                     "" "notermination" # DEGREE FARENHEIT
+0x2109 "°{}F"                     "" "notermination=text" "" "" # DEGREE FAHRENHEIT
 # mathrsfs has no small letters
 #0x210a ""                         "" "" "\\mathscr{g}" "mathrsfs" # SCRIPT SMALL G
 0x210b ""                         "" "" "\\mathscr{H}" "mathrsfs" # SCRIPT CAPITAL H
 0x210c ""                         "" "" "\\mathfrak{H}" "amssymb" # BLACK-LETTER CAPITAL H
 0x210d ""                         "" "" "\\mathbb{H}" "amssymb" # DOUBLE-STUCK CAPITAL H
-0x210e ""                         "" "" "h" # PLANCK CONSTANT
+0x210e ""                         "" "notermination=math" "h" # PLANCK CONSTANT
 0x210f ""                         "" "" "\\hbar" "amssymb" # PLANCK CONSTANT OVER TWO PI
 0x2110 ""                         "" "" "\\mathscr{I}" "mathrsfs" # SCRIPT CAPITAL I
 0x2111 ""                         "" "" "\\mathfrak{I}" "amssymb" # BLACK-LETTER CAPITAL I
@@ -1748,7 +1753,7 @@
 0x2127 "\\textmho"                "textcomp" "" "\\mho" "amssymb" # INVERTED OHM SIGN
 0x2128 ""                         "" "" "\\mathfrak{Z}" "amssymb" # BLACK-LETTER CAPITAL Z
 #0x2129 ""                         "" "" "" "" # TURNED GREEK SMALL LETTER IOTA
-0x212a "K"                        "" "notermination" # KELVIN SIGN
+0x212a "K"                        "" "notermination=text" "" "" # KELVIN SIGN
 0x212b "\\AA"                     "" "" # ANGSTROM SIGN
 0x212c ""                         "" "" "\\mathscr{B}" "mathrsfs" # SCRIPT CAPITAL B
 0x212d ""                         "" "" "\\mathfrak{C}" "amssymb" # BLACK-LETTER CAPITAL C
@@ -1843,15 +1848,15 @@
 0x2193 "\\textdownarrow"          "textcomp" "" "\\downarrow" # DOWNWARDS ARROW
 0x2194 ""                         "" "" "\\leftrightarrow" # LEFT RIGHT ARROW
 0x2195 ""                         "" "" "\\updownarrow" # UP DOWN ARROW
-0x2196 "Home"                     "" "notermination" "\\nwarrow" "amssymb" # Qt::Key_Home, NORTH WEST ARROW
-0x2198 "End"                      "" "notermination" "\\searrow" "" # Qt::Key_End, SOUTH EAST ARROW
+0x2196 "Home"                     "" "notermination=text" "\\nwarrow" "amssymb" # Qt::Key_Home, NORTH WEST ARROW
+0x2198 "End"                      "" "notermination=text" "\\searrow" "" # Qt::Key_End, SOUTH EAST ARROW
 0x21a8 "{\\ascii\\ETB}"           "ascii" "" # UP DOWN ARROW WITH BASE
 0x21b5 "{\\Pisymbol{psy}{191}}"   "pifont" "" # DOWNWARDS ARROW WITH CORNER LEFTWARDS, Return key
-0x21de "Option-Up Arrow"          "" "notermination" "" # Qt::Key_PageUp, UPWARDS ARROW WITH DOUBLE STROKE = page up
-0x21df "Option-Down Arrow"        "" "notermination" "" # Qt::Key_PageDown, DOWNWARDS ARROW WITH DOUBLE STROKE = page down
-0x21e4 "Shift-Tab"                "" "notermination" "" # Qt::Key_Backtab, LEFTWARDS ARROW TO BAR = leftward tab
-0x21e5 "Tab"                      "" "notermination" "" # Qt::Key_Tab, RIGHTWARDS ARROW TO BAR = rightward tab
-0x21ea "Caps Lock"                "" "notermination" "" # Qt::Key_CapsLock, UPWARDS WHITE ARROW FROM BAR = caps lock
+0x21de "Option-Up Arrow"          "" "notermination=text" "" "" # Qt::Key_PageUp, UPWARDS ARROW WITH DOUBLE STROKE = page up
+0x21df "Option-Down Arrow"        "" "notermination=text" "" "" # Qt::Key_PageDown, DOWNWARDS ARROW WITH DOUBLE STROKE = page down
+0x21e4 "Shift-Tab"                "" "notermination=text" "" "" # Qt::Key_Backtab, LEFTWARDS ARROW TO BAR = leftward tab
+0x21e5 "Tab"                      "" "notermination=text" "" "" # Qt::Key_Tab, RIGHTWARDS ARROW TO BAR = rightward tab
+0x21ea "Caps Lock"                "" "notermination=text" "" "" # Qt::Key_CapsLock, UPWARDS WHITE ARROW FROM BAR = caps lock
 #
 # mathematical operators
 #
@@ -1873,7 +1878,7 @@
 0x220f ""                         "" "" "\\prod" # N-ARY PRODUCT
 0x2210 ""                         "" "" "\\coprod" "" # N-ARY COPRODUCT
 0x2211 ""                         "" "" "\\sum" # N-ARY SUMMATION
-0x2212 "\\textminus"              "textcomp" "" "-" "" # MINUS SIGN
+0x2212 "\\textminus"              "textcomp" "notermination=math" "-" "" # MINUS SIGN
 0x2213 ""                         "" "" "\\mp" "" # MINUS-OR-PLUS SIGN
 0x2214 ""                         "" "" "\\dotplus" "amssymb" # DOT PLUS
 0x2215 ""                         "" "" "\\slash" # DIVISION SLASH
@@ -1967,10 +1972,10 @@
 0x231a "\\Clocklogo"              "marvosym" "" # WATCH
 #0x2320 ""                         "" "" # TOP HALF INTEGRAL
 #0x2321 ""                         "" "" # BOTTOM HALF INTEGRAL
-0x2326 "Delete"                   "" "notermination" "" # Qt::Key_Delete, ERASE TO THE RIGHT = delete to the right key
+0x2326 "Delete"                   "" "notermination=text" "" "" # Qt::Key_Delete, ERASE TO THE RIGHT = delete to the right key
 0x2328 "\\Keyboard"               "marvosym" "" # KEYBOARD
-0x232b "Backspace"                "" "notermination" "" # Qt::Key_Backspace, ERASE TO THE LEFT = delete to the left key
-0x238b "Escape"                   "" "notermination" "" # Qt::Key_Escape, BROKEN CIRCLE WITH NORTHWEST ARROW = escape
+0x232b "Backspace"                "" "notermination=text" "" "" # Qt::Key_Backspace, ERASE TO THE LEFT = delete to the left key
+0x238b "Escape"                   "" "notermination=text" "" "" # Qt::Key_Escape, BROKEN CIRCLE WITH NORTHWEST ARROW = escape
 #
 # control pictures
 #
@@ -2267,11 +2272,11 @@
 #
 # ligatures
 #
-0xfb00 "ff"                       "" "force,notermination" # LATIN SMALL LIGATURE FF
-0xfb01 "fi"                       "" "force,notermination" # LATIN SMALL LIGATURE FI
-0xfb02 "fl"                       "" "force,notermination" # LATIN SMALL LIGATURE FL
-0xfb03 "ffi"                      "" "force,notermination" # LATIN SMALL LIGATURE FFI
-0xfb04 "ffl"                      "" "force,notermination" # LATIN SMALL LIGATURE FFL
+0xfb00 "ff"                       "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FF
+0xfb01 "fi"                       "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FI
+0xfb02 "fl"                       "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FL
+0xfb03 "ffi"                      "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FFI
+0xfb04 "ffl"                      "" "force,notermination=text" "" "" # LATIN SMALL LIGATURE FFL
 #
 # mathematical alphanumeric symbols
 #
@@ -2327,57 +2332,57 @@
 0x1d431 ""                         "" "" "\\mathbf{x}" "" # 𝐱 MATHEMATICAL BOLD SMALL X
 0x1d432 ""                         "" "" "\\mathbf{y}" "" # 𝐲 MATHEMATICAL BOLD SMALL Y
 0x1d433 ""                         "" "" "\\mathbf{z}" "" # 𝐳 MATHEMATICAL BOLD SMALL Z
-0x1d434 ""                         "" "" "A" "" # 𝐴 MATHEMATICAL ITALIC CAPITAL A
-0x1d435 ""                         "" "" "B" "" # 𝐵 MATHEMATICAL ITALIC CAPITAL B
-0x1d436 ""                         "" "" "C" "" # 𝐶 MATHEMATICAL ITALIC CAPITAL C
-0x1d437 ""                         "" "" "D" "" # 𝐷 MATHEMATICAL ITALIC CAPITAL D
-0x1d438 ""                         "" "" "E" "" # 𝐸 MATHEMATICAL ITALIC CAPITAL E
-0x1d439 ""                         "" "" "F" "" # 𝐹 MATHEMATICAL ITALIC CAPITAL F
-0x1d43a ""                         "" "" "G" "" # 𝐺 MATHEMATICAL ITALIC CAPITAL G
-0x1d43b ""                         "" "" "H" "" # 𝐻 MATHEMATICAL ITALIC CAPITAL H
-0x1d43c ""                         "" "" "I" "" # 𝐼 MATHEMATICAL ITALIC CAPITAL I
-0x1d43d ""                         "" "" "J" "" # 𝐽 MATHEMATICAL ITALIC CAPITAL J
-0x1d43e ""                         "" "" "K" "" # 𝐾 MATHEMATICAL ITALIC CAPITAL K
-0x1d43f ""                         "" "" "L" "" # 𝐿 MATHEMATICAL ITALIC CAPITAL L
-0x1d440 ""                         "" "" "M" "" # 𝑀 MATHEMATICAL ITALIC CAPITAL M
-0x1d441 ""                         "" "" "N" "" # 𝑁 MATHEMATICAL ITALIC CAPITAL N
-0x1d442 ""                         "" "" "O" "" # 𝑂 MATHEMATICAL ITALIC CAPITAL O
-0x1d443 ""                         "" "" "P" "" # 𝑃 MATHEMATICAL ITALIC CAPITAL P
-0x1d444 ""                         "" "" "Q" "" # 𝑄 MATHEMATICAL ITALIC CAPITAL Q
-0x1d445 ""                         "" "" "R" "" # 𝑅 MATHEMATICAL ITALIC CAPITAL R
-0x1d446 ""                         "" "" "S" "" # 𝑆 MATHEMATICAL ITALIC CAPITAL S
-0x1d447 ""                         "" "" "T" "" # 𝑇 MATHEMATICAL ITALIC CAPITAL T
-0x1d448 ""                         "" "" "U" "" # 𝑈 MATHEMATICAL ITALIC CAPITAL U
-0x1d449 ""                         "" "" "V" "" # 𝑉 MATHEMATICAL ITALIC CAPITAL V
-0x1d44a ""                         "" "" "W" "" # 𝑊 MATHEMATICAL ITALIC CAPITAL W
-0x1d44b ""                         "" "" "X" "" # 𝑋 MATHEMATICAL ITALIC CAPITAL X
-0x1d44c ""                         "" "" "Y" "" # 𝑌 MATHEMATICAL ITALIC CAPITAL Y
-0x1d44d ""                         "" "" "Z" "" # 𝑍 MATHEMATICAL ITALIC CAPITAL Z
-0x1d44e ""                         "" "" "a" "" # 𝑎 MATHEMATICAL ITALIC SMALL A
-0x1d44f ""                         "" "" "b" "" # 𝑏 MATHEMATICAL ITALIC SMALL B
-0x1d450 ""                         "" "" "c" "" # 𝑐 MATHEMATICAL ITALIC SMALL C
-0x1d451 ""                         "" "" "d" "" # 𝑑 MATHEMATICAL ITALIC SMALL D
-0x1d452 ""                         "" "" "e" "" # 𝑒 MATHEMATICAL ITALIC SMALL E
-0x1d453 ""                         "" "" "f" "" # 𝑓 MATHEMATICAL ITALIC SMALL F
-0x1d454 ""                         "" "" "g" "" # 𝑔 MATHEMATICAL ITALIC SMALL G
-0x1d456 ""                         "" "" "i" "" # 𝑖 MATHEMATICAL ITALIC SMALL I
-0x1d457 ""                         "" "" "j" "" # 𝑗 MATHEMATICAL ITALIC SMALL J
-0x1d458 ""                         "" "" "k" "" # 𝑘 MATHEMATICAL ITALIC SMALL K
-0x1d459 ""                         "" "" "l" "" # 𝑙 MATHEMATICAL ITALIC SMALL L
-0x1d45a ""                         "" "" "m" "" # 𝑚 MATHEMATICAL ITALIC SMALL M
-0x1d45b ""                         "" "" "n" "" # 𝑛 MATHEMATICAL ITALIC SMALL N
-0x1d45c ""                         "" "" "o" "" # 𝑜 MATHEMATICAL ITALIC SMALL O
-0x1d45d ""                         "" "" "p" "" # 𝑝 MATHEMATICAL ITALIC SMALL P
-0x1d45e ""                         "" "" "q" "" # 𝑞 MATHEMATICAL ITALIC SMALL Q
-0x1d45f ""                         "" "" "r" "" # 𝑟 MATHEMATICAL ITALIC SMALL R
-0x1d460 ""                         "" "" "s" "" # 𝑠 MATHEMATICAL ITALIC SMALL S
-0x1d461 ""                         "" "" "t" "" # 𝑡 MATHEMATICAL ITALIC SMALL T
-0x1d462 ""                         "" "" "u" "" # 𝑢 MATHEMATICAL ITALIC SMALL U
-0x1d463 ""                         "" "" "v" "" # 𝑣 MATHEMATICAL ITALIC SMALL V
-0x1d464 ""                         "" "" "w" "" # 𝑤 MATHEMATICAL ITALIC SMALL W
-0x1d465 ""                         "" "" "x" "" # 𝑥 MATHEMATICAL ITALIC SMALL X
-0x1d466 ""                         "" "" "y" "" # 𝑦 MATHEMATICAL ITALIC SMALL Y
-0x1d467 ""                         "" "" "z" "" # 𝑧 MATHEMATICAL ITALIC SMALL Z
+0x1d434 ""                         "" "notermination=math" "A" "" # 𝐴 MATHEMATICAL ITALIC CAPITAL A
+0x1d435 ""                         "" "notermination=math" "B" "" # 𝐵 MATHEMATICAL ITALIC CAPITAL B
+0x1d436 ""                         "" "notermination=math" "C" "" # 𝐶 MATHEMATICAL ITALIC CAPITAL C
+0x1d437 ""                         "" "notermination=math" "D" "" # 𝐷 MATHEMATICAL ITALIC CAPITAL D
+0x1d438 ""                         "" "notermination=math" "E" "" # 𝐸 MATHEMATICAL ITALIC CAPITAL E
+0x1d439 ""                         "" "notermination=math" "F" "" # 𝐹 MATHEMATICAL ITALIC CAPITAL F
+0x1d43a ""                         "" "notermination=math" "G" "" # 𝐺 MATHEMATICAL ITALIC CAPITAL G
+0x1d43b ""                         "" "notermination=math" "H" "" # 𝐻 MATHEMATICAL ITALIC CAPITAL H
+0x1d43c ""                         "" "notermination=math" "I" "" # 𝐼 MATHEMATICAL ITALIC CAPITAL I
+0x1d43d ""                         "" "notermination=math" "J" "" # 𝐽 MATHEMATICAL ITALIC CAPITAL J
+0x1d43e ""                         "" "notermination=math" "K" "" # 𝐾 MATHEMATICAL ITALIC CAPITAL K
+0x1d43f ""                         "" "notermination=math" "L" "" # 𝐿 MATHEMATICAL ITALIC CAPITAL L
+0x1d440 ""                         "" "notermination=math" "M" "" # 𝑀 MATHEMATICAL ITALIC CAPITAL M
+0x1d441 ""                         "" "notermination=math" "N" "" # 𝑁 MATHEMATICAL ITALIC CAPITAL N
+0x1d442 ""                         "" "notermination=math" "O" "" # 𝑂 MATHEMATICAL ITALIC CAPITAL O
+0x1d443 ""                         "" "notermination=math" "P" "" # 𝑃 MATHEMATICAL ITALIC CAPITAL P
+0x1d444 ""                         "" "notermination=math" "Q" "" # 𝑄 MATHEMATICAL ITALIC CAPITAL Q
+0x1d445 ""                         "" "notermination=math" "R" "" # 𝑅 MATHEMATICAL ITALIC CAPITAL R
+0x1d446 ""                         "" "notermination=math" "S" "" # 𝑆 MATHEMATICAL ITALIC CAPITAL S
+0x1d447 ""                         "" "notermination=math" "T" "" # 𝑇 MATHEMATICAL ITALIC CAPITAL T
+0x1d448 ""                         "" "notermination=math" "U" "" # 𝑈 MATHEMATICAL ITALIC CAPITAL U
+0x1d449 ""                         "" "notermination=math" "V" "" # 𝑉 MATHEMATICAL ITALIC CAPITAL V
+0x1d44a ""                         "" "notermination=math" "W" "" # 𝑊 MATHEMATICAL ITALIC CAPITAL W
+0x1d44b ""                         "" "notermination=math" "X" "" # 𝑋 MATHEMATICAL ITALIC CAPITAL X
+0x1d44c ""                         "" "notermination=math" "Y" "" # 𝑌 MATHEMATICAL ITALIC CAPITAL Y
+0x1d44d ""                         "" "notermination=math" "Z" "" # 𝑍 MATHEMATICAL ITALIC CAPITAL Z
+0x1d44e ""                         "" "notermination=math" "a" "" # 𝑎 MATHEMATICAL ITALIC SMALL A
+0x1d44f ""                         "" "notermination=math" "b" "" # 𝑏 MATHEMATICAL ITALIC SMALL B
+0x1d450 ""                         "" "notermination=math" "c" "" # 𝑐 MATHEMATICAL ITALIC SMALL C
+0x1d451 ""                         "" "notermination=math" "d" "" # 𝑑 MATHEMATICAL ITALIC SMALL D
+0x1d452 ""                         "" "notermination=math" "e" "" # 𝑒 MATHEMATICAL ITALIC SMALL E
+0x1d453 ""                         "" "notermination=math" "f" "" # 𝑓 MATHEMATICAL ITALIC SMALL F
+0x1d454 ""                         "" "notermination=math" "g" "" # 𝑔 MATHEMATICAL ITALIC SMALL G
+0x1d456 ""                         "" "notermination=math" "i" "" # 𝑖 MATHEMATICAL ITALIC SMALL I
+0x1d457 ""                         "" "notermination=math" "j" "" # 𝑗 MATHEMATICAL ITALIC SMALL J
+0x1d458 ""                         "" "notermination=math" "k" "" # 𝑘 MATHEMATICAL ITALIC SMALL K
+0x1d459 ""                         "" "notermination=math" "l" "" # 𝑙 MATHEMATICAL ITALIC SMALL L
+0x1d45a ""                         "" "notermination=math" "m" "" # 𝑚 MATHEMATICAL ITALIC SMALL M
+0x1d45b ""                         "" "notermination=math" "n" "" # 𝑛 MATHEMATICAL ITALIC SMALL N
+0x1d45c ""                         "" "notermination=math" "o" "" # 𝑜 MATHEMATICAL ITALIC SMALL O
+0x1d45d ""                         "" "notermination=math" "p" "" # 𝑝 MATHEMATICAL ITALIC SMALL P
+0x1d45e ""                         "" "notermination=math" "q" "" # 𝑞 MATHEMATICAL ITALIC SMALL Q
+0x1d45f ""                         "" "notermination=math" "r" "" # 𝑟 MATHEMATICAL ITALIC SMALL R
+0x1d460 ""                         "" "notermination=math" "s" "" # 𝑠 MATHEMATICAL ITALIC SMALL S
+0x1d461 ""                         "" "notermination=math" "t" "" # 𝑡 MATHEMATICAL ITALIC SMALL T
+0x1d462 ""                         "" "notermination=math" "u" "" # 𝑢 MATHEMATICAL ITALIC SMALL U
+0x1d463 ""                         "" "notermination=math" "v" "" # 𝑣 MATHEMATICAL ITALIC SMALL V
+0x1d464 ""                         "" "notermination=math" "w" "" # 𝑤 MATHEMATICAL ITALIC SMALL W
+0x1d465 ""                         "" "notermination=math" "x" "" # 𝑥 MATHEMATICAL ITALIC SMALL X
+0x1d466 ""                         "" "notermination=math" "y" "" # 𝑦 MATHEMATICAL ITALIC SMALL Y
+0x1d467 ""                         "" "notermination=math" "z" "" # 𝑧 MATHEMATICAL ITALIC SMALL Z
 0x1d49c ""                         "" "" "\\mathcal{A}" "" # 𝒜 MATHEMATICAL SCRIPT CAPITAL A
 0x1d49e ""                         "" "" "\\mathcal{C}" "" # 𝒞 MATHEMATICAL SCRIPT CAPITAL C
 0x1d49f ""                         "" "" "\\mathcal{D}" "" # 𝒟 MATHEMATICAL SCRIPT CAPITAL D

diff --git a/src/BiblioInfo.cpp b/src/BiblioInfo.cpp
index 470c7ee4f84caf360a5e34a22534c23885fe4682..4efe50884c2b34302f0a89932b4ac7b0311ddc46 100644 (file)
--- a/src/BiblioInfo.cpp
+++ b/src/BiblioInfo.cpp
@@ -169,14 +169,17 @@ docstring convertLaTeXCommands(docstring const & str)
                // unicodesymbols has things in the form: \"{u},
                // whereas we may see things like: \"u. So we'll
                // look for that and change it, if necessary.
+               // FIXME: This is a sort of mini-tex2lyx.
+               //        Use the real tex2lyx instead!
                static lyx::regex const reg("^\\\\\\W\\w");
                if (lyx::regex_search(to_utf8(val), reg)) {
                        val.insert(3, from_ascii("}"));
                        val.insert(2, from_ascii("{"));
                }
+               bool termination;
                docstring rem;
                docstring const cnvtd = Encodings::fromLaTeXCommand(val,
-                               Encodings::TEXT_CMD, rem);
+                               Encodings::TEXT_CMD, termination, rem);
                if (!cnvtd.empty()) {
                        // it did, so we'll take that bit and proceed with what's left
                        ret += cnvtd;

diff --git a/src/Buffer.cpp b/src/Buffer.cpp
index 010843e9ec1ae55112c95a30d907f6a6f7450d61..5c4f1db9b65f2ede076f48f16b4b03f545d6e482 100644 (file)
--- a/src/Buffer.cpp
+++ b/src/Buffer.cpp
@@ -1508,9 +1508,8 @@ void Buffer::writeLaTeXSource(otexstream & os,
                        Encoding const * const enc = runparams.encoding;
                        if (enc) {
                                for (size_t n = 0; n < inputpath.size(); ++n) {
-                                       docstring const glyph =
-                                               docstring(1, inputpath[n]);
-                                       if (enc->latexChar(inputpath[n], true) != glyph) {
+                                       if (!enc->encodable(inputpath[n])) {
+                                               docstring const glyph(1, inputpath[n]);
                                                LYXERR0("Uncodable character '"
                                                        << glyph
                                                        << "' in input path!");

diff --git a/src/Changes.cpp b/src/Changes.cpp
index c237df62371bbefa1e19537af884c7706eaddfa0..c14bf9b41eabf2da281312e6e3662977757c3bc7 100644 (file)
--- a/src/Changes.cpp
+++ b/src/Changes.cpp
@@ -357,7 +357,7 @@ docstring getLaTeXMarkup(docstring const & macro, docstring const & author,
        docstring author_latexed;
        for (size_t n = 0; n < author.size(); ++n) {
                try {
-                       author_latexed += runparams.encoding->latexChar(author[n]);
+                       author_latexed += runparams.encoding->latexChar(author[n]).first;
                } catch (EncodingException & /* e */) {
                        if (runparams.dryrun) {
                                ods << "<" << _("LyX Warning: ")

diff --git a/src/Encoding.cpp b/src/Encoding.cpp
index b7c3f7dc555d31c1a78156e4c0ed7ca085ed1433..d9fe69110dec9063b871b1150af16f2ac02a370c 100644 (file)
--- a/src/Encoding.cpp
+++ b/src/Encoding.cpp
@@ -228,6 +228,21 @@ char_type const arabic_start = 0x0621;
 char_type const arabic_end = 0x06cc;
 
 
+enum CharInfoFlags {
+       ///
+       CharInfoCombining = 1,
+       ///
+       CharInfoTextFeature = 2,
+       ///
+       CharInfoMathFeature = 4,
+       ///
+       CharInfoForce = 8,
+       ///
+       CharInfoTextNoTermination = 16,
+       ///
+       CharInfoMathNoTermination = 32,
+};
+
 /// Information about a single UCS4 character
 struct CharInfo {
        /// LaTeX command (text mode) for this character
@@ -239,20 +254,24 @@ struct CharInfo {
        /// Needed LaTeX preamble (or feature) for math mode
        string mathpreamble;
        /// Is this a combining character?
-       bool combining;
+       bool combining() const { return flags & CharInfoCombining ? true : false; }
        /// Is \c textpreamble a feature known by LaTeXFeatures, or a raw LaTeX
        /// command?
-       bool textfeature;
+       bool textfeature() const { return flags & CharInfoTextFeature ? true : false; }
        /// Is \c mathpreamble a feature known by LaTeXFeatures, or a raw LaTeX
        /// command?
-       bool mathfeature;
+       bool mathfeature() const { return flags & CharInfoMathFeature ? true : false; }
        /// Always force the LaTeX command, even if the encoding contains
        /// this character?
-       bool force;
+       bool force() const { return flags & CharInfoForce ? true : false; }
        /// TIPA shortcut
        string tipashortcut;
-       /// This macro needs no termination (such as {} or space).
-       bool notermination;
+       /// \c textcommand needs no termination (such as {} or space).
+       bool textnotermination() const { return flags & CharInfoTextNoTermination ? true : false; }
+       /// \c mathcommand needs no termination (such as {} or space).
+       bool mathnotermination() const { return flags & CharInfoMathNoTermination ? true : false; }
+       ///
+       unsigned int flags;
 };
 
 
@@ -320,7 +339,7 @@ void Encoding::init() const
                                continue;
                        char_type const uc = ucs4[0];
                        CharInfoMap::const_iterator const it = unicodesymbols.find(uc);
-                       if (it == unicodesymbols.end() || !it->second.force)
+                       if (it == unicodesymbols.end() || !it->second.force())
                                encodable_.insert(uc);
                }
        } else {
@@ -332,7 +351,7 @@ void Encoding::init() const
                        vector<char> const eightbit = ucs4_to_eightbit(&c, 1, iconvName_);
                        if (!eightbit.empty()) {
                                CharInfoMap::const_iterator const it = unicodesymbols.find(c);
-                               if (it == unicodesymbols.end() || !it->second.force)
+                               if (it == unicodesymbols.end() || !it->second.force())
                                        encodable_.insert(c);
                        }
                }
@@ -348,19 +367,25 @@ void Encoding::init() const
 }
 
 
-docstring Encoding::latexChar(char_type c, bool no_commands) const
+bool Encoding::encodable(char_type c) const
 {
        // assure the used encoding is properly initialized
        init();
 
        if (iconvName_ == "UTF-8" && package_ == none)
-               return docstring(1, c);
+               return true;
        if (c < start_encodable_ && !encodings.isForced(c))
-               return docstring(1, c);
+               return true;
        if (encodable_.find(c) != encodable_.end())
-               return docstring(1, c);
-       if (no_commands)
-               return docstring();
+               return true;
+       return false;
+}
+
+
+pair<docstring, bool> Encoding::latexChar(char_type c) const
+{
+       if (encodable(c))
+               return make_pair(docstring(1, c), false);
 
        // c cannot (or should not) be encoded in this encoding
        CharInfoMap::const_iterator const it = unicodesymbols.find(c);
@@ -368,8 +393,9 @@ docstring Encoding::latexChar(char_type c, bool no_commands) const
                throw EncodingException(c);
        // at least one of mathcommand and textcommand is nonempty
        if (it->second.textcommand.empty())
-               return "\\ensuremath{" + it->second.mathcommand + '}';
-       return it->second.textcommand;
+               return make_pair(
+                       "\\ensuremath{" + it->second.mathcommand + '}', false);
+       return make_pair(it->second.textcommand, !it->second.textnotermination());
 }
 
 
@@ -393,10 +419,14 @@ vector<char_type> Encoding::symbolsList() const
 
 
 bool Encodings::latexMathChar(char_type c, bool mathmode,
-                       Encoding const * encoding, docstring & command)
+                       Encoding const * encoding, docstring & command,
+                       bool & needsTermination)
 {
+       command = empty_docstring();
        if (encoding)
-               command = encoding->latexChar(c, true);
+               if (encoding->encodable(c))
+                       command = docstring(1, c);
+       needsTermination = false;
 
        CharInfoMap::const_iterator const it = unicodesymbols.find(c);
        if (it == unicodesymbols.end()) {
@@ -411,10 +441,12 @@ bool Encodings::latexMathChar(char_type c, bool mathmode,
                        (!mathmode && it->second.textcommand.empty());
        if (use_math) {
                command = it->second.mathcommand;
+               needsTermination = !it->second.mathnotermination();
                addMathCmd(c);
        } else {
                if (!encoding || command.empty()) {
                        command = it->second.textcommand;
+                       needsTermination = !it->second.textnotermination();
                        addTextCmd(c);
                }
                if (mathmode)
@@ -425,35 +457,40 @@ bool Encodings::latexMathChar(char_type c, bool mathmode,
 
 
 char_type Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
-               bool & combining, set<string> * req)
+               bool & combining, bool & needsTermination, set<string> * req)
 {
        CharInfoMap::const_iterator const end = unicodesymbols.end();
        CharInfoMap::const_iterator it = unicodesymbols.begin();
        for (combining = false; it != end; ++it) {
                docstring const math = it->second.mathcommand;
                docstring const text = it->second.textcommand;
-               if ((cmdtype && MATH_CMD) && math == cmd) {
-                       combining = it->second.combining;
-                       if (req && it->second.mathfeature &&
+               if ((cmdtype & MATH_CMD) && math == cmd) {
+                       combining = it->second.combining();
+                       needsTermination = !it->second.mathnotermination();
+                       if (req && it->second.mathfeature() &&
                            !it->second.mathpreamble.empty())
                                req->insert(it->second.mathpreamble);
                        return it->first;
                }
                if ((cmdtype & TEXT_CMD) && text == cmd) {
-                       combining = it->second.combining;
-                       if (req && it->second.textfeature &&
+                       combining = it->second.combining();
+                       needsTermination = !it->second.textnotermination();
+                       if (req && it->second.textfeature() &&
                            !it->second.textpreamble.empty())
                                req->insert(it->second.textpreamble);
                        return it->first;
                }
        }
+       needsTermination = false;
        return 0;
 }
 
 
 docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
-               docstring & rem, set<string> * req)
+               bool & needsTermination, docstring & rem, set<string> * req)
 {
+       needsTermination = false;
+       rem = empty_docstring();
        bool const mathmode = cmdtype & MATH_CMD;
        bool const textmode = cmdtype & TEXT_CMD;
        docstring symbols;
@@ -536,11 +573,15 @@ docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
                                j = k - 1;
                                i = j + 1;
                                unicmd_size = cur_size;
+                               if (math == tmp)
+                                       needsTermination = !it->second.mathnotermination();
+                               else
+                                       needsTermination = !it->second.textnotermination();
                                if (req) {
-                                       if (math == tmp && it->second.mathfeature &&
+                                       if (math == tmp && it->second.mathfeature() &&
                                            !it->second.mathpreamble.empty())
                                                req->insert(it->second.mathpreamble);
-                                       if (text == tmp && it->second.textfeature &&
+                                       if (text == tmp && it->second.textfeature() &&
                                            !it->second.textpreamble.empty())
                                                req->insert(it->second.textpreamble);
                                }
@@ -548,9 +589,20 @@ docstring Encodings::fromLaTeXCommand(docstring const & cmd, int cmdtype,
                }
                if (unicmd_size)
                        symbols += c;
-               else if (j + 1 == cmdend)
+               else if (j + 1 == cmdend) {
                        // No luck. Return what remains
                        rem = cmd.substr(i);
+                       if (needsTermination && !rem.empty()) {
+                               if (rem.substr(0, 2) == "{}") {
+                                       rem = rem.substr(2);
+                                       needsTermination = false;
+                               } else if (rem[0] == ' ') {
+                                       needsTermination = false;
+                                       // LaTeX would swallow all spaces
+                                       rem = ltrim(rem);
+                               }
+                       }
+               }
        }
        return symbols;
 }
@@ -609,7 +661,7 @@ void Encodings::validate(char_type c, LaTeXFeatures & features, bool for_mathed)
                // with utf8-plain, we only load packages when in mathed (see #7766)
                if (math_mode || (use_math && !plain_utf8)) {
                        if (!it->second.mathpreamble.empty()) {
-                               if (it->second.mathfeature) {
+                               if (it->second.mathfeature()) {
                                        string feats = it->second.mathpreamble;
                                        while (!feats.empty()) {
                                                string feat;
@@ -623,7 +675,7 @@ void Encodings::validate(char_type c, LaTeXFeatures & features, bool for_mathed)
                // with utf8-plain, we do not load packages (see #7766)
                if (use_text && !plain_utf8) {
                        if (!it->second.textpreamble.empty()) {
-                               if (it->second.textfeature) {
+                               if (it->second.textfeature()) {
                                        string feats = it->second.textpreamble;
                                        while (!feats.empty()) {
                                                string feat;
@@ -684,7 +736,7 @@ bool Encodings::isCombiningChar(char_type c)
 {
        CharInfoMap::const_iterator const it = unicodesymbols.find(c);
        if (it != unicodesymbols.end())
-               return it->second.combining;
+               return it->second.combining();
        return false;
 }
 
@@ -728,15 +780,6 @@ bool Encodings::isMathAlpha(char_type c)
 }
 
 
-bool Encodings::needsTermination(char_type c)
-{
-       CharInfoMap::const_iterator const it = unicodesymbols.find(c);
-       if (it != unicodesymbols.end())
-               return !it->second.notermination;
-       return true;
-}
-
-
 Encoding const * Encodings::fromLyXName(string const & name) const
 {
        EncodingList::const_iterator const it = encodinglist.find(name);
@@ -806,22 +849,31 @@ void Encodings::read(FileName const & encfile, FileName const & symbolsfile)
                        break;
                flags = symbolslex.getString();
 
-               info.combining = false;
-               info.textfeature = false;
-               info.force = false;
-               info.notermination = false;
+               info.flags = 0;
+               if (suffixIs(info.textcommand, '}'))
+                       info.flags |= CharInfoTextNoTermination;
+               if (suffixIs(info.mathcommand, '}'))
+                       info.flags |= CharInfoMathNoTermination;
                while (!flags.empty()) {
                        string flag;
                        flags = split(flags, flag, ',');
                        if (flag == "combining") {
-                               info.combining = true;
+                               info.flags |= CharInfoCombining;
                        } else if (flag == "force") {
-                               info.force = true;
+                               info.flags |= CharInfoForce;
                                forced.insert(symbol);
                        } else if (flag == "mathalpha") {
                                mathalpha.insert(symbol);
-                       } else if (flag == "notermination") {
-                               info.notermination = true;
+                       } else if (flag == "notermination=text") {
+                               info.flags |= CharInfoTextNoTermination;
+                       } else if (flag == "notermination=math") {
+                               info.flags |= CharInfoMathNoTermination;
+                       } else if (flag == "notermination=both") {
+                               info.flags |= CharInfoTextNoTermination;
+                               info.flags |= CharInfoMathNoTermination;
+                       } else if (flag == "notermination=none") {
+                               info.flags &= ~CharInfoTextNoTermination;
+                               info.flags &= ~CharInfoMathNoTermination;
                        } else if (contains(flag, "tipashortcut=")) {
                                info.tipashortcut = split(flag, '=');
                        } else {
@@ -861,15 +913,18 @@ void Encodings::read(FileName const & encfile, FileName const & symbolsfile)
                        info.mathpreamble = "esint|amsmath";
 
                if (!info.textpreamble.empty())
-                       info.textfeature = info.textpreamble[0] != '\\';
+                       if (info.textpreamble[0] != '\\')
+                               info.flags |= CharInfoTextFeature;
                if (!info.mathpreamble.empty())
-                       info.mathfeature = info.mathpreamble[0] != '\\';
+                       if (info.mathpreamble[0] != '\\')
+                               info.flags |= CharInfoMathFeature;
 
                LYXERR(Debug::INFO, "Read unicode symbol " << symbol << " '"
                        << to_utf8(info.textcommand) << "' '" << info.textpreamble
-                       << "' " << info.combining << ' ' << info.textfeature
-                       << " '" << to_utf8(info.mathcommand) << "' '"
-                       << info.mathpreamble << "' " << info.mathfeature);
+                       << " '" << info.textfeature() << ' ' << info.textnotermination()
+                       << ' ' << to_utf8(info.mathcommand) << "' '" << info.mathpreamble
+                       << "' " << info.mathfeature() << ' ' << info.mathnotermination()
+                       << ' ' << info.combining() << ' ' << info.force());
 
                // we assume that at least one command is nonempty when using unicodesymbols
                if (!info.textcommand.empty() || !info.mathcommand.empty())

diff --git a/src/Encoding.h b/src/Encoding.h
index 7b0fa8ec19a30a0fb8134d8d12b28e38d78b3d80..7b7e483b8345334b1b47d600b261e85b0f666613 100644 (file)
--- a/src/Encoding.h
+++ b/src/Encoding.h
@@ -67,6 +67,8 @@ public:
        std::string const & iconvName() const { return iconvName_; }
        ///
        bool const & hasFixedWidth() const { return fixedwidth_; }
+       /// \p c is representable in this encoding without a LaTeX macro
+       bool encodable(char_type c) const;
        /**
         * Convert \p c to something that LaTeX can understand.
         * This is either the character itself (if it is representable
@@ -74,8 +76,10 @@ public:
         * If the character is not representable in this encoding, but no
         * LaTeX macro is known, a warning is given of lyxerr, and the
         * character is returned.
+        * \return the converted character and a flag indicating whether
+        * the command needs to be terminated by {} or a space.
         */
-       docstring latexChar(char_type c, bool no_commands = false) const;
+       std::pair<docstring, bool> latexChar(char_type c) const;
        /// Which LaTeX package handles this encoding?
        Package package() const { return package_; }
        /// A list of all characters usable in this encoding
@@ -195,11 +199,6 @@ public:
         * letters and accented characters that are output as math commands.
         */
        static bool isMathAlpha(char_type c);
-       /**
-        * Do we need to terminate this command (by {} or space)?
-        * This is true if the "notermination" flag is not set.
-        */
-       static bool needsTermination(char_type c);
        /**
         * Register \p c as a mathmode command.
         */
@@ -231,16 +230,22 @@ public:
        /**
         * If \p c cannot be encoded in the given \p encoding, convert
         * it to something that LaTeX can understand in mathmode.
+        * \p needsTermination indicates whether the command needs to be
+        * terminated by {} or a space.
         * \return whether \p command is a mathmode command
         */
        static bool latexMathChar(char_type c, bool mathmode,
-                       Encoding const * encoding, docstring & command);
+                       Encoding const * encoding, docstring & command,
+                       bool & needsTermination);
        /**
         * Convert the LaTeX command in \p cmd to the corresponding unicode
-        * point and set \p combining to true if it is a combining symbol
+        * point and set \p combining to true if it is a combining symbol.
+        * \p needsTermination indicates whether the command needs to be
+        * terminated by {} or a space.
         */
        static char_type fromLaTeXCommand(docstring const & cmd, int cmdtype,
-                       bool & combining, std::set<std::string> * req = 0);
+                       bool & combining, bool & needsTermination,
+                       std::set<std::string> * req = 0);
        ///
        enum LatexCmd {
                ///
@@ -255,9 +260,12 @@ public:
         * unconverted commands are returned in \p rem.
         * The \p cmdtype parameter can be used to limit recognized
         * commands to math or text mode commands only.
+        * \p needsTermination indicates whether the command needs to be
+        * terminated by {} or a space.
         */
        static docstring fromLaTeXCommand(docstring const & cmd, int cmdtype,
-                       docstring & rem, std::set<std::string> * req = 0);
+                       bool & needsTermination, docstring & rem,
+                       std::set<std::string> * req = 0);
        /**
         * Add the preamble snippet needed for the output of \p c to
         * \p features.

diff --git a/src/LaTeXFeatures.cpp b/src/LaTeXFeatures.cpp
index 58daaac6fc22b5450f664f046d77e0e668b05c27..f1d315cae84e3341ebea09efdff2715cce1b9aeb 100644 (file)
--- a/src/LaTeXFeatures.cpp
+++ b/src/LaTeXFeatures.cpp
@@ -1159,7 +1159,7 @@ docstring const getFloatI18nPreamble(docstring const & type,
        // Check whether name can be encoded in the buffer encoding
        bool encodable = true;
        for (size_t i = 0; i < name.size(); ++i) {
-               if (enc.latexChar(name[i], true)[0] != name[i]) {
+               if (!enc.encodable(name[i])) {
                        encodable = false;
                        break;
                }

diff --git a/src/Layout.cpp b/src/Layout.cpp
index a57a28e813a317f2aa0ca9a5d178124379ac7ab5..bd4c08bee42fa9884d9f08f0f6a472e22d5e59d7 100644 (file)
--- a/src/Layout.cpp
+++ b/src/Layout.cpp
@@ -893,7 +893,7 @@ docstring const i18npreamble(Language const * lang, Encoding const & enc,
                // Check whether name can be encoded in the buffer encoding
                bool encodable = true;
                for (size_t i = 0; i < name.size(); ++i) {
-                       if (enc.latexChar(name[i], true)[0] != name[i]) {
+                       if (!enc.encodable(name[i])) {
                                encodable = false;
                                break;
                        }

diff --git a/src/PDFOptions.cpp b/src/PDFOptions.cpp
index 62d0480e1f81bd11d4db2390d1103ac9cea5fa83..7de277c3212162655a60fcd7b565c43dae64e35f 100644 (file)
--- a/src/PDFOptions.cpp
+++ b/src/PDFOptions.cpp
@@ -150,7 +150,7 @@ void PDFOptions::writeLaTeX(OutputParams & runparams, otexstream & os,
        bool need_unicode = false;
        if (enc) {
                for (size_t n = 0; n < hs.size(); ++n) {
-                       if (enc->latexChar(hs[n], true) != docstring(1, hs[n]))
+                       if (!enc->encodable(hs[n]))
                                need_unicode = true;
                }
        }

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index 7a513aad64de8532564b28978a9599fae2a2cd60..8298576e27d881d70eb8694467716270f4f0fcc0 100644 (file)
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -858,8 +858,8 @@ int Paragraph::Private::latexSurrogatePair(otexstream & os, char_type c,
        // FIXME: change tracking
        // Is this correct WRT change tracking?
        Encoding const & encoding = *(runparams.encoding);
-       docstring const latex1 = encoding.latexChar(next);
-       docstring const latex2 = encoding.latexChar(c);
+       docstring const latex1 = encoding.latexChar(next).first;
+       docstring const latex2 = encoding.latexChar(c).first;
        if (docstring(1, next) == latex1) {
                // the encoding supports the combination
                os << latex2 << latex1;
@@ -975,7 +975,7 @@ int Paragraph::Private::writeScriptChars(otexstream & os,
                // Stop here if there is a font attribute or encoding change.
                if (found && cit != end && prev_font != cit->font())
                        break;
-               docstring const latex = encoding.latexChar(next);
+               docstring const latex = encoding.latexChar(next).first;
                docstring::size_type const b1 =
                                        latex.find_first_of(from_ascii("{"));
                docstring::size_type const b2 =
@@ -1168,7 +1168,7 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
        if (style.pass_thru || runparams.pass_thru) {
                if (c != '\0') {
                        Encoding const * const enc = runparams.encoding;
-                       if (enc && enc->latexChar(c, true).empty())
+                       if (enc && !enc->encodable(c))
                                throw EncodingException(c);
                        os.put(c);
                }
@@ -1273,41 +1273,41 @@ void Paragraph::Private::latexSpecialChar(otexstream & os,
                        }
                }
                string script;
-               docstring latex = encoding.latexChar(c);
+               pair<docstring, bool> latex = encoding.latexChar(c);
                docstring nextlatex;
                if (next != '\0' && next != META_INSET)
-                       nextlatex = encoding.latexChar(next);
+                       nextlatex = encoding.latexChar(next).first;
                bool tipas = false;
                if (runparams.inIPA) {
                        string const tipashortcut = Encodings::TIPAShortcut(c);
                        if (!tipashortcut.empty()) {
-                               latex = from_ascii(tipashortcut);
+                               latex.first = from_ascii(tipashortcut);
+                               latex.second = false;
                                tipas = true;
                        }
                }
                if (Encodings::isKnownScriptChar(c, script)
-                   && prefixIs(latex, from_ascii("\\" + script)))
-                       column += writeScriptChars(os, latex,
+                   && prefixIs(latex.first, from_ascii("\\" + script)))
+                       column += writeScriptChars(os, latex.first,
                                        running_change, encoding, i) - 1;
-               else if (Encodings::needsTermination(c)
-                        && !prefixIs(nextlatex, from_ascii("\\"))
-                        && !prefixIs(nextlatex, from_ascii("{"))
-                        && !prefixIs(nextlatex, from_ascii("}"))
-                        && latex.length() > 1 && latex[latex.length() - 1] != '}'
-                        && latex[latex.length() - 1] != '-' && !tipas) {
+               else if (latex.second
+                        && !prefixIs(nextlatex, '\\')
+                        && !prefixIs(nextlatex, '{')
+                        && !prefixIs(nextlatex, '}')
+                        && !tipas) {
                        // Prevent eating of a following
                        // space or command corruption by
                        // following characters
                        if (next == ' ' || next == '\0') {
-                               column += latex.length() + 1;
-                               os << latex << "{}";
+                               column += latex.first.length() + 1;
+                               os << latex.first << "{}";
                        } else {
-                               column += latex.length();
-                               os << latex << " ";
+                               column += latex.first.length();
+                               os << latex.first << " ";
                        }
                } else {
-                       column += latex.length() - 1;
-                       os << latex;
+                       column += latex.first.length() - 1;
+                       os << latex.first;
                }
                break;
        }

diff --git a/src/insets/InsetBibitem.cpp b/src/insets/InsetBibitem.cpp
index 3aaaceacbdd8d954fb53fcd1b692b4f3f75e8dd9..ac3c9149679b9073db7146afa1dfd2416e732c71 100644 (file)
--- a/src/insets/InsetBibitem.cpp
+++ b/src/insets/InsetBibitem.cpp
@@ -294,7 +294,7 @@ docstring bibitemWidest(Buffer const & buffer, OutputParams const & runparams)
                docstring latex_lbl;
                for (size_t n = 0; n < lbl.size(); ++n) {
                        try {
-                               latex_lbl += runparams.encoding->latexChar(lbl[n]);
+                               latex_lbl += runparams.encoding->latexChar(lbl[n]).first;
                        } catch (EncodingException & /* e */) {
                                if (runparams.dryrun) {
                                        latex_lbl += "<" + _("LyX Warning: ")

diff --git a/src/insets/InsetCommandParams.cpp b/src/insets/InsetCommandParams.cpp
index bb4882874af1b0220dba13776023ab8e34f1250e..cc75a0eb59f502b6b79e5571e7704962c724d3f8 100644 (file)
--- a/src/insets/InsetCommandParams.cpp
+++ b/src/insets/InsetCommandParams.cpp
@@ -376,7 +376,7 @@ docstring InsetCommandParams::prepareCommand(OutputParams const & runparams,
                for (size_t n = 0; n < command.size(); ++n) {
                        try {
                                char_type const c = command[n];
-                               docstring const latex = runparams.encoding->latexChar(c);
+                               docstring const latex = runparams.encoding->latexChar(c).first;
                                result += latex;
                                if (latex.length() > 1 && latex[latex.length() - 1] != '}') {
                                        // Prevent eating of a following

diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp
index e6335953c2ce50472d16034ef22eda0f5643c34a..02a370696174c5805793f45b27a7f9241d96440a 100644 (file)
--- a/src/insets/InsetIndex.cpp
+++ b/src/insets/InsetIndex.cpp
@@ -137,7 +137,7 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const
                        docstring spart2;
                        for (size_t n = 0; n < spart.size(); ++n) {
                                try {
-                                       spart2 += runparams.encoding->latexChar(spart[n]);
+                                       spart2 += runparams.encoding->latexChar(spart[n]).first;
                                } catch (EncodingException & /* e */) {
                                        LYXERR0("Uncodable character in index entry. Sorting might be wrong!");
                                }

diff --git a/src/insets/InsetListings.cpp b/src/insets/InsetListings.cpp
index a8b56d0773d27cdc2c121c4e9ffbfaedb5add992..0d61af671a02f8a45877b2011389674da79c13ee 100644 (file)
--- a/src/insets/InsetListings.cpp
+++ b/src/insets/InsetListings.cpp
@@ -176,7 +176,7 @@ void InsetListings::latex(otexstream & os, OutputParams const & runparams) const
                        // we can only output characters covered by the current
                        // encoding!
                        try {
-                               if (runparams.encoding->latexChar(c) == docstring(1, c))
+                               if (runparams.encoding->encodable(c))
                                        code += c;
                                else if (runparams.dryrun) {
                                        code += "<" + _("LyX Warning: ")

diff --git a/src/insets/InsetNomencl.cpp b/src/insets/InsetNomencl.cpp
index 7bdcfc7672cd903c963cd7b8d4737eadaf4c731b..a32191b78aa595ee79a6482d8c5723e6c92e04db 100644 (file)
--- a/src/insets/InsetNomencl.cpp
+++ b/src/insets/InsetNomencl.cpp
@@ -279,7 +279,7 @@ docstring nomenclWidest(Buffer const & buffer, OutputParams const & runparams)
        docstring latex_symb;
        for (size_t n = 0; n < symb.size(); ++n) {
                try {
-                       latex_symb += runparams.encoding->latexChar(symb[n]);
+                       latex_symb += runparams.encoding->latexChar(symb[n]).first;
                } catch (EncodingException & /* e */) {
                        if (runparams.dryrun) {
                                latex_symb += "<" + _("LyX Warning: ")

diff --git a/src/mathed/InsetMathString.cpp b/src/mathed/InsetMathString.cpp
index 98b641a72655d922a37acce871b696727d5e8aab..af9bc980fc0ecc8324de6f26e1c66a339abc67eb 100644 (file)
--- a/src/mathed/InsetMathString.cpp
+++ b/src/mathed/InsetMathString.cpp
@@ -119,7 +119,9 @@ void InsetMathString::write(WriteStream & os) const
                char_type const c = *cit;
                docstring command(1, c);
                try {
-                       if (c < 0x80 || Encodings::latexMathChar(c, mathmode, os.encoding(), command)) {
+                       bool termination = false;
+                       if (c < 0x80 ||
+                           Encodings::latexMathChar(c, mathmode, os.encoding(), command, termination)) {
                                if (os.textMode()) {
                                        if (in_forced_mode) {
                                                // we were inside \lyxmathsym
@@ -152,8 +154,7 @@ void InsetMathString::write(WriteStream & os) const
                        os << command;
                        // We may need a space if the command contains a macro
                        // and the last char is ASCII.
-                       if (lyx::support::contains(command, '\\')
-                           && isAlphaASCII(command[command.size() - 1]))
+                       if (termination)
                                os.pendingSpace(true);
                } catch (EncodingException & e) {
                        switch (os.output()) {

diff --git a/src/mathed/MathParser.cpp b/src/mathed/MathParser.cpp
index 30e5c004a30f459bb8c6cfa6a6c1ad62d3867783..b3f1bca76b64cabbfcb33b9f8d879503bc15aca3 100644 (file)
--- a/src/mathed/MathParser.cpp
+++ b/src/mathed/MathParser.cpp
@@ -1828,13 +1828,15 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                error("'}' expected in \\" + t.cs());
                                return success_;
                        }
+                       bool termination;
                        docstring rem;
                        do {
                                cmd = Encodings::fromLaTeXCommand(cmd,
-                                       Encodings::MATH_CMD | Encodings::TEXT_CMD, rem);
+                                       Encodings::MATH_CMD | Encodings::TEXT_CMD,
+                                       termination, rem);
                                for (size_t i = 0; i < cmd.size(); ++i)
                                        cell->push_back(MathAtom(new InsetMathChar(cmd[i])));
-                               if (rem.size()) {
+                               if (!rem.empty()) {
                                        char_type c = rem[0];
                                        cell->push_back(MathAtom(new InsetMathChar(c)));
                                        cmd = rem.substr(1);
@@ -1923,9 +1925,10 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                }
                                        }
                                        bool is_combining;
+                                       bool termination;
                                        char_type c = Encodings::fromLaTeXCommand(cmd,
                                                Encodings::MATH_CMD | Encodings::TEXT_CMD,
-                                               is_combining);
+                                               is_combining, termination);
                                        if (is_combining) {
                                                if (cat == catLetter)
                                                        cmd += '{';
@@ -1935,9 +1938,24 @@ bool Parser::parse1(InsetMathGrid & grid, unsigned flags,
                                                        cmd += '}';
                                                c = Encodings::fromLaTeXCommand(cmd,
                                                        Encodings::MATH_CMD | Encodings::TEXT_CMD,
-                                                       is_combining);
+                                                       is_combining, termination);
                                        }
                                        if (c) {
+                                               if (termination) {
+                                                       if (nextToken().cat() == catBegin) {
+                                                               getToken();
+                                                               if (nextToken().cat() == catEnd) {
+                                                                       getToken();
+                                                                       num_tokens += 2;
+                                                               } else
+                                                                       putback();
+                                                       } else {
+                                                               while (nextToken().cat() == catSpace) {
+                                                                       getToken();
+                                                                       ++num_tokens;
+                                                               }
+                                                       }
+                                               }
                                                is_unicode_symbol = true;
                                                cell->push_back(MathAtom(new InsetMathChar(c)));
                                        } else {

diff --git a/src/tex2lyx/text.cpp b/src/tex2lyx/text.cpp
index 0581eab8475121bccca5c46db12878428593d91f..2f59222ed7deeeaa7725ceb9d737fb31236f1a62 100644 (file)
--- a/src/tex2lyx/text.cpp
+++ b/src/tex2lyx/text.cpp
@@ -456,10 +456,11 @@ docstring convert_unicodesymbols(docstring s)
                        continue;
                }
                s = s.substr(i);
+               bool termination;
                docstring rem;
                set<string> req;
                docstring parsed = encodings.fromLaTeXCommand(s,
-                               Encodings::TEXT_CMD, rem, &req);
+                               Encodings::TEXT_CMD, termination, rem, &req);
                for (set<string>::const_iterator it = req.begin(); it != req.end(); it++)
                        preamble.registerAutomaticallyLoadedPackage(*it);
                os << parsed;
@@ -3500,13 +3501,15 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                         && contains("\"'.=^`bcdHkrtuv~", t.cs())) {
                        context.check_layout(os);
                        // try to see whether the string is in unicodesymbols
+                       bool termination;
                        docstring rem;
                        string command = t.asInput() + "{"
                                + trimSpaceAndEol(p.verbatim_item())
                                + "}";
                        set<string> req;
                        docstring s = encodings.fromLaTeXCommand(from_utf8(command),
-                               Encodings::TEXT_CMD | Encodings::MATH_CMD, rem, &req);
+                               Encodings::TEXT_CMD | Encodings::MATH_CMD,
+                               termination, rem, &req);
                        if (!s.empty()) {
                                if (!rem.empty())
                                        cerr << "When parsing " << command
@@ -4106,10 +4109,11 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                        // try to see whether the string is in unicodesymbols
                        // Only use text mode commands, since we are in text mode here,
                        // and math commands may be invalid (bug 6797)
+                       bool termination;
                        docstring rem;
                        set<string> req;
                        docstring s = encodings.fromLaTeXCommand(from_utf8(t.asInput()),
-                                                                Encodings::TEXT_CMD, rem, &req);
+                                       Encodings::TEXT_CMD, termination, rem, &req);
                        if (!s.empty()) {
                                if (!rem.empty())
                                        cerr << "When parsing " << t.cs()
@@ -4117,7 +4121,8 @@ void parse_text(Parser & p, ostream & os, unsigned flags, bool outer,
                                             << "+" << to_utf8(rem) << endl;
                                context.check_layout(os);
                                os << to_utf8(s);
-                               skip_spaces_braces(p);
+                               if (termination)
+                                       skip_spaces_braces(p);
                                for (set<string>::const_iterator it = req.begin(); it != req.end(); it++)
                                        preamble.registerAutomaticallyLoadedPackage(*it);
                        }