Applied Angus patch to compile on DEC C++ and to avoid name clashes

[lyx.git] / src / vspace.C

diff --git a/src/vspace.C b/src/vspace.C
index 25d5d5ef511809b04a76fb881587a58ebda30cb4..03e6128afffa51670428c758a51ccd544f38900d 100644 (file)
--- a/src/vspace.C
+++ b/src/vspace.C
@@ -24,51 +24,45 @@
 #include "support/lstrings.h"
 
 
+namespace {
+
 /*  length units
  */
 
-static const int num_units = LyXLength::UNIT_NONE;
+int const num_units = LyXLength::UNIT_NONE;
 
 // I am not sure if "mu" should be possible to select (Lgb)
-static char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
-                                            "mm", "pc", "cc", "cm",
-                                            "in", "ex", "em", "mu" }; 
-
+char const * unit_name[num_units] = { "sp", "pt", "bp", "dd",
+                                     "mm", "pc", "cc", "cm",
+                                     "in", "ex", "em", "mu" }; 
 
-LyXLength::UNIT unitFromString (string const & data)
-{
-       int i = 0;
-       while ((i < num_units) && (data != unit_name[i])) ++i;
-       return static_cast<LyXLength::UNIT>(i);
-}
 
 /*  The following static items form a simple scanner for
  *  length strings, used by isValid[Glue]Length.  See comments there.
  */
-static float           number[4] = { 0, 0, 0, 0 };
-static LyXLength::UNIT unit[4]   = { LyXLength::UNIT_NONE,
-                                    LyXLength::UNIT_NONE,
-                                    LyXLength::UNIT_NONE,
-                                    LyXLength::UNIT_NONE };
-//static int number_index, unit_index;
-int number_index, unit_index;
+float           number[4] = { 0, 0, 0, 0 };
+LyXLength::UNIT unit[4]   = { LyXLength::UNIT_NONE,
+                             LyXLength::UNIT_NONE,
+                             LyXLength::UNIT_NONE,
+                             LyXLength::UNIT_NONE };
+int number_index;
+int unit_index;
 
 
-static inline
+inline
 void lyx_advance(string & data, unsigned int n)
 {
        data.erase(0, n);
 }
 
 
-static inline
+inline
 bool isEndOfData(string const & data)
 {
        return frontStrip(data).empty();
 }
 
 
-static
 char nextToken(string & data)
 {
        data = frontStrip(data);
@@ -87,32 +81,57 @@ char nextToken(string & data)
                lyx_advance(data, 5);
                return '-';
        } else {
-               string::size_type i;
+               string::size_type i = data.find_first_not_of("0123456789.");
+
+               if (i != 0) {
+                       if (number_index > 3) return 'E';
+
+                       string buffer;
+               
+                       // we have found some number
+                       if (i == string::npos) {
+                               buffer = data;
+                               i = data.size() + 1;
+                       } else
+                               buffer = data.substr(0, i);
+
+                       lyx_advance(data, i);
 
-               // I really mean assignment ("=") below, not equality!
-               if ((i = data.find_last_of("0123456789.")) != string::npos) {
-                       if (number_index > 3) return 'E';  // Error
-                        string buffer = data.substr(0, i + 1);
                        if (isStrDbl(buffer)) {
                                number[number_index] = strToDbl(buffer);
-                               lyx_advance(data, i + 1);
                                ++number_index;
                                return 'n';
-                       } else 
-                               return 'E';  // Error
-               } else if ((i = data.find_last_of("abcdefghijklmnopqrstuvwxyz"))
-                          != string::npos) {
-                       if (unit_index > 3) return 'E';  // Error
-                       string buffer = data.substr(0, i + 1);
-                       unit[unit_index] = unitFromString(buffer);
+                       } else return 'E';
+               }
+               
+               i = data.find_first_not_of("abcdefghijklmnopqrstuvwxyz");
+               if (i != 0) {
+                       if (unit_index > 3) return 'E';
+
+                       string buffer;
+               
+                       // we have found some alphabetical string
+                       if (i == string::npos) {
+                               buffer = data;
+                               i = data.size() + 1;
+                       } else
+                               buffer = data.substr(0, i);
+
+                       // possibly we have "mmplus" string or similar
+                       if (buffer.size() > 5 && (buffer.substr(2,4) == string("plus") || buffer.substr(2,5) == string("minus"))) {
+                               lyx_advance(data, 2);
+                               unit[unit_index] = unitFromString(buffer.substr(0, 2));
+                       } else {
+                               lyx_advance(data, i);
+                               unit[unit_index] = unitFromString(buffer);
+                       }
+
                        if (unit[unit_index] != LyXLength::UNIT_NONE) {
-                               lyx_advance(data, i + 1);
                                ++unit_index;
                                return 'u';
-                       } else
-                               return 'E';  // Error
-               } else
-                       return 'E';  // Error
+                       } else return 'E';  // Error
+               }
+               return 'E';  // Error
        }
 }
 
@@ -124,7 +143,6 @@ struct LaTeXLength {
 };
 
 
-static
 LaTeXLength table[] = {
        { "nu",       0, 0, 0, 0 },
        { "nu+nu",    2, 0, 2, 0 },
@@ -142,6 +160,16 @@ LaTeXLength table[] = {
        { "",         0, 0, 0, 0 }   // sentinel, must be empty
 };
 
+} // namespace anon
+
+
+LyXLength::UNIT unitFromString (string const & data)
+{
+       int i = 0;
+       while ((i < num_units) && (data != unit_name[i])) ++i;
+       return static_cast<LyXLength::UNIT>(i);
+}
+
 
 bool isValidGlueLength (string const & data, LyXGlueLength * result)
 {
@@ -224,6 +252,8 @@ bool isValidLength(string const & data, LyXLength * result)
        /// The parser may seem overkill for lengths without 
        /// glue, but since we already have it, using it is
        /// easier than writing something from scratch.
+       if (data.empty())
+               return true;
 
         string   buffer(data);
        int       pattern_index = 0;
@@ -432,16 +462,16 @@ VSpace::VSpace (string const & data)
 
 bool VSpace::operator==(VSpace const & other) const
 {
-       if (this->kin == other.kin) 
-               if (this->kin == LENGTH)
-                       if (this->len == other.len)
-                               return this->kp == other.kp;
-                       else
-                               return false;
-               else
-                       return this->kp == other.kp;
-       else
+       if (this->kin != other.kin)
+               return false;
+ 
+       if (this->kin != LENGTH)
+               return this->kp == other.kp;
+ 
+       if (!(this->len == other.len))
                return false;
+ 
+       return this->kp == other.kp;
 }