Use HAVE_LONG_LONG_INT instead of LYX_USE_LONG_LONG

[lyx.git] / src / texstream.cpp

diff --git a/src/texstream.cpp b/src/texstream.cpp
index be1168a7e815e5536bdda3f5b083830060b6d660..1523ca9470ebf2447af87ec8f8dc7e446c58403e 100644 (file)
--- a/src/texstream.cpp
+++ b/src/texstream.cpp
@@ -59,11 +59,23 @@ void otexrowstream::put(char_type const & c)
 
 void otexstream::put(char_type const & c)
 {
+       bool isprotected = false;
        if (protectspace_) {
-               if (!canbreakline_ && c == ' ')
+               if (!canbreakline_ && c == ' ') {
                        os() << "{}";
+                       isprotected = true;
+               }
                protectspace_ = false;
        }
+       if (terminate_command_) {
+               if ((c == ' ' || c == '\0' || c == '\n') && !isprotected)
+                       // A space or line break follows. Terminate with brackets.
+                       os() << "{}";
+               else if (c != '\\' && c != '{' && c != '}')
+                       // Non-terminating character follows. Terminate with space.
+                       os() << " ";
+               terminate_command_ = false;
+       }
        otexrowstream::put(c);
        lastChar(c);
 }
@@ -78,24 +90,30 @@ size_t otexstringstream::length()
 
 TexString otexstringstream::release()
 {
-       TexString ts{ods_.str(), TexRow()};
-       swap(ts.texrow, texrow());
-       ods_ = odocstringstream();
+       TexString ts(ods_.str(), move(texrow()));
+       // reset this
+       texrow() = TexRow();
+       ods_.clear();
+       ods_.str(docstring());
        return ts;
 }
 
 
 BreakLine breakln;
 SafeBreakLine safebreakln;
+TerminateCommand termcmd;
 
 
 otexstream & operator<<(otexstream & ots, BreakLine)
 {
        if (ots.canBreakLine()) {
+               if (ots.terminateCommand())
+                       ots << "{}";
                ots.otexrowstream::put('\n');
                ots.lastChar('\n');
        }
        ots.protectSpace(false);
+       ots.terminateCommand(false);
        return ots;
 }
 
@@ -104,10 +122,20 @@ otexstream & operator<<(otexstream & ots, SafeBreakLine)
 {
        otexrowstream & otrs = ots;
        if (ots.canBreakLine()) {
+           if (ots.terminateCommand())
+                       otrs << "{}";
                otrs << "%\n";
                ots.lastChar('\n');
        }
        ots.protectSpace(false);
+       ots.terminateCommand(false);
+       return ots;
+}
+
+
+otexstream & operator<<(otexstream & ots, TerminateCommand)
+{
+       ots.terminateCommand(true);
        return ots;
 }
 
@@ -150,11 +178,24 @@ otexstream & operator<<(otexstream & ots, TexString ts)
                return ots;
 
        otexrowstream & otrs = ots;
+       bool isprotected = false;
+       char_type const c = ts.str[0];
        if (ots.protectSpace()) {
-               if (!ots.canBreakLine() && ts.str[0] == ' ')
+               if (!ots.canBreakLine() && c == ' ') {
                        otrs << "{}";
+                       isprotected = true;
+               }
                ots.protectSpace(false);
        }
+       if (ots.terminateCommand()) {
+               if ((c == ' ' || c == '\0' || c == '\n') && !isprotected)
+                       // A space or line break follows. Terminate with brackets.
+                       otrs << "{}";
+               else if (c != '\\' && c != '{' && c != '}')
+                       // Non-terminating character follows. Terminate with space.
+                       otrs << " ";
+               ots.terminateCommand(false);
+       }
 
        if (len > 1)
                ots.canBreakLine(ts.str[len - 2] != '\n');
@@ -181,11 +222,24 @@ otexstream & operator<<(otexstream & ots, docstring const & s)
        if (len == 0)
                return ots;
        otexrowstream & otrs = ots;
+       bool isprotected = false;
+       char_type const c = s[0];
        if (ots.protectSpace()) {
-               if (!ots.canBreakLine() && s[0] == ' ')
+               if (!ots.canBreakLine() && c == ' ') {
                        otrs << "{}";
+                       isprotected = true;
+               }
                ots.protectSpace(false);
        }
+       if (ots.terminateCommand()) {
+               if ((c == ' ' || c == '\0' || c == '\n') && !isprotected)
+                       // A space or line break follows. Terminate with brackets.
+                       otrs << "{}";
+               else if (c != '\\' && c != '{' && c != '}')
+                       // Non-terminating character follows. Terminate with space.
+                       otrs << " ";
+               ots.terminateCommand(false);
+       }
 
        if (contains(s, 0xF0000)) {
                // Some encoding changes for the underlying stream are embedded
@@ -276,7 +330,7 @@ template otexrowstream & operator<< <unsigned int>(otexrowstream &,
 template otexrowstream & operator<< <unsigned long>(otexrowstream &,
                                                                                                        unsigned long);
 
-#ifdef LYX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
 template otexrowstream & operator<< <unsigned long long>(otexrowstream &,
                                                          unsigned long long);
 #endif
@@ -288,6 +342,7 @@ otexstream & operator<<(otexstream & ots, Type value)
        ots.os() << value;
        ots.lastChar(0);
        ots.protectSpace(false);
+       ots.terminateCommand(false);
        return ots;
 }
 
@@ -296,8 +351,8 @@ template otexstream & operator<< <double>(otexstream &, double);
 template otexstream & operator<< <int>(otexstream &, int);
 template otexstream & operator<< <unsigned int>(otexstream &, unsigned int);
 template otexstream & operator<< <unsigned long>(otexstream &, unsigned long);
-#ifdef LYX_USE_LONG_LONG
+#ifdef HAVE_LONG_LONG_INT
 template otexstream & operator<< <unsigned long long>(otexstream &, unsigned long long);
 #endif
 
-}
+} // namespace lyx